|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
tools/clang/include/clang/AST/Stmt.h 1213 class DeclStmt : public Stmt {
1285 class NullStmt : public Stmt {
1320 class CompoundStmt final : public Stmt,
1443 class SwitchCase : public Stmt {
1701 class ValueStmt : public Stmt {
1822 class IfStmt final
2027 class SwitchStmt final : public Stmt,
2210 class WhileStmt final : public Stmt,
2338 class DoStmt : public Stmt {
2394 class ForStmt : public Stmt {
2465 class GotoStmt : public Stmt {
2504 class IndirectGotoStmt : public Stmt {
2553 class ContinueStmt : public Stmt {
2583 class BreakStmt : public Stmt {
2620 class ReturnStmt final
2703 class AsmStmt : public Stmt {
3189 class SEHExceptStmt : public Stmt {
3233 class SEHFinallyStmt : public Stmt {
3268 class SEHTryStmt : public Stmt {
3321 class SEHLeaveStmt : public Stmt {
3360 class CapturedStmt : public Stmt {
tools/clang/include/clang/AST/StmtCXX.h 28 class CXXCatchStmt : public Stmt {
68 class CXXTryStmt final : public Stmt,
134 class CXXForRangeStmt : public Stmt {
252 class MSDependentExistsStmt : public Stmt {
317 class CoroutineBodyStmt final
456 class CoreturnStmt : public Stmt {
tools/clang/include/clang/AST/StmtObjC.h 23 class ObjCForCollectionStmt : public Stmt {
77 class ObjCAtCatchStmt : public Stmt {
127 class ObjCAtFinallyStmt : public Stmt {
165 class ObjCAtTryStmt : public Stmt {
277 class ObjCAtSynchronizedStmt : public Stmt {
332 class ObjCAtThrowStmt : public Stmt {
368 class ObjCAutoreleasePoolStmt : public Stmt {
tools/clang/include/clang/AST/StmtOpenMP.h 33 class OMPExecutableDirective : public Stmt {
Declarations
tools/clang/include/clang/AST/ASTContext.h 117 class Stmt;
tools/clang/include/clang/AST/ASTFwd.h 22 class Stmt;
tools/clang/include/clang/AST/ASTImporter.h 45 class Stmt;
tools/clang/include/clang/AST/Decl.h 69 class Stmt;
tools/clang/include/clang/AST/DeclBase.h 66 class Stmt;
tools/clang/include/clang/AST/DeclObjC.h 57 class Stmt;
tools/clang/include/clang/AST/ExternalASTSource.h 52 class Stmt;
tools/clang/include/clang/AST/ODRHash.h 31 class Stmt;
tools/clang/include/clang/AST/ParentMap.h 17 class Stmt;
tools/clang/include/clang/AST/PrettyPrinter.h 23 class Stmt;
tools/clang/include/clang/AST/StmtIterator.h 24 class Stmt;
tools/clang/include/clang/AST/Type.h 116 class Stmt;
tools/clang/include/clang/Analysis/Analyses/Consumed.h 36 class Stmt;
tools/clang/include/clang/Analysis/Analyses/LiveVariables.h 24 class Stmt;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 55 class Stmt;
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 70 class Stmt;
tools/clang/include/clang/Analysis/Analyses/UninitializedValues.h 26 class Stmt;
tools/clang/include/clang/Analysis/AnalysisDeclContext.h 43 class Stmt;
tools/clang/include/clang/Analysis/BodyFarm.h 28 class Stmt;
tools/clang/include/clang/Analysis/CFGStmtMap.h 22 class Stmt;
tools/clang/include/clang/Analysis/CallGraph.h 34 class Stmt;
tools/clang/include/clang/Analysis/CloneDetection.h 23 class Stmt;
tools/clang/include/clang/Analysis/CodeInjector.h 21 class Stmt;
tools/clang/include/clang/Sema/Ownership.h 37 class Stmt;
tools/clang/include/clang/Sema/ScopeInfo.h 57 class Stmt;
tools/clang/include/clang/Sema/Sema.h 173 class Stmt;
tools/clang/include/clang/Serialization/ASTReader.h 111 class Stmt;
tools/clang/include/clang/Serialization/ASTWriter.h 90 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 52 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 32 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h 33 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h 24 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 50 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h 65 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h 44 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h 24 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h 33 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h 18 class Stmt;
tools/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h 23 class Stmt;
tools/clang/include/clang/Tooling/Refactoring/Extract/SourceExtraction.h 19 class Stmt;
tools/clang/lib/ARCMigrate/Internals.h 20 class Stmt;
tools/clang/lib/ARCMigrate/Transforms.h 19 class Stmt;
tools/clang/lib/AST/Interp/Context.h 27 class Stmt;
tools/clang/lib/AST/Interp/Program.h 32 class Stmt;
tools/clang/lib/CodeGen/CodeGenModule.h 65 class Stmt;
tools/clang/lib/CodeGen/CoverageMappingGen.h 30 class Stmt;
tools/clang/lib/CodeGen/VarBypassDetector.h 25 class Stmt;
tools/clang/lib/Index/IndexingContext.h 30 class Stmt;
tools/clang/tools/libclang/CXCursor.h 39 class Stmt;
tools/lldb/include/lldb/Core/ClangForward.h 103 class Stmt;
References
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h 75 typename std::add_pointer<typename std::add_const<T>::type>::type;
include/llvm/Support/Allocator.h 342 return Out / alignof(T);
include/llvm/Support/Casting.h 34 using SimpleType = From; // The real type this represents...
37 static SimpleType &getSimplifiedValue(From &Val) { return Val; }
41 using NonConstSimpleType = typename simplify_type<From>::SimpleType;
47 static RetType getSimplifiedValue(const From& Val) {
57 static inline bool doit(const From &Val) {
66 static inline bool doit(const From &) { return true; }
76 static inline bool doit(const From &Val) {
77 return isa_impl<To, From>::doit(Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
141 template <class X, class Y> LLVM_NODISCARD inline bool isa(const Y &Val) {
142 return isa_impl_wrap<X, const Y,
142 return isa_impl_wrap<X, const Y,
143 typename simplify_type<const Y>::SimpleType>::doit(Val);
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
236 std::is_same<X, typename simplify_type<X>::SimpleType>::value;
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
309 return cast<X>(Val);
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
367 dyn_cast_or_null(Y *Val) {
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Support/type_traits.h 55 struct add_const_past_pointer { using type = const T; };
tools/clang/include/clang/AST/ASTContext.h 664 template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node) {
tools/clang/include/clang/AST/ASTImporter.h 268 llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
268 llvm::DenseMap<Stmt *, Stmt *> ImportedStmts;
420 llvm::Expected<Stmt *> Import(Stmt *FromS);
420 llvm::Expected<Stmt *> Import(Stmt *FromS);
tools/clang/include/clang/AST/ASTNodeTraverser.h 100 void Visit(const Stmt *S, StringRef Label = {}) {
115 for (const Stmt *SubStmt : S->children())
178 for (const auto *S : C->children())
212 else if (const auto *S = N.get<Stmt>())
212 else if (const auto *S = N.get<Stmt>())
tools/clang/include/clang/AST/ASTTypeTraits.h 65 return ASTNodeKind(KindToKindId<T>::Id);
71 static ASTNodeKind getFromNode(const Stmt &S);
234 static DynTypedNode create(const T &Node) {
235 return BaseConverter<T>::create(Node);
251 const T *get() const {
252 return BaseConverter<T>::get(NodeKind, Storage.buffer);
259 const T &getUnchecked() const {
260 return BaseConverter<T>::getUnchecked(NodeKind, Storage.buffer);
394 static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
395 if (ASTNodeKind::getFromNodeKind<T>().isBaseOf(NodeKind))
399 static const T &getUnchecked(ASTNodeKind NodeKind, const char Storage[]) {
401 return *cast<T>(static_cast<const BaseT *>(
404 static DynTypedNode create(const BaseT &Node) {
474 : public DynCastPtrConverter<T, Stmt> {};
474 : public DynCastPtrConverter<T, Stmt> {};
tools/clang/include/clang/AST/Decl.h 819 Stmt *Value;
867 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
1241 Stmt **getInitAddress();
2022 Stmt *getBody(const FunctionDecl *&Definition) const;
2024 Stmt *getBody() const override {
2044 void setBody(Stmt *B);
2863 Stmt *Init; // an integer constant expression
4015 Stmt *Body = nullptr;
4037 Stmt *getBody() const override { return (Stmt*) Body; }
4164 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
4186 Stmt *getBody() const override;
4187 void setBody(Stmt *B);
tools/clang/include/clang/AST/DeclBase.h 986 virtual Stmt* getBody() const { return nullptr; }
tools/clang/include/clang/AST/DeclCXX.h 2154 Stmt *Init;
2229 return Init->getStmtClass() == Stmt::CXXDefaultInitExprClass;
tools/clang/include/clang/AST/DeclObjC.h 506 Stmt *getBody() const override;
511 void setBody(Stmt *B) { Body = B; }
tools/clang/include/clang/AST/EvaluatedExprVisitor.h 101 for (auto *SubStmt : S->children())
tools/clang/include/clang/AST/Expr.h 914 static bool classof(const Stmt *T) {
927 Stmt *SubExpr;
945 static bool classof(const Stmt *T) {
1016 static bool classof(const Stmt *T) {
1118 static bool classof(const Stmt *T) {
1356 static bool classof(const Stmt *T) {
1451 static bool classof(const Stmt *T) {
1490 static bool classof(const Stmt *T) {
1545 static bool classof(const Stmt *T) {
1619 static bool classof(const Stmt *T) {
1638 Stmt *Val;
1658 static bool classof(const Stmt *T) {
1864 static bool classof(const Stmt *T) {
1880 private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
1914 *getTrailingObjects<Stmt *>() = SL;
1935 ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
1941 ? static_cast<StringLiteral *>(*getTrailingObjects<Stmt *>())
1951 static bool classof(const Stmt *T) {
1957 return child_range(getTrailingObjects<Stmt *>(),
1958 getTrailingObjects<Stmt *>() + hasFunctionName());
1962 return const_child_range(getTrailingObjects<Stmt *>(),
1963 getTrailingObjects<Stmt *>() + hasFunctionName());
1971 Stmt *Val;
2000 static bool classof(const Stmt *T) {
2022 Stmt *Val;
2124 static bool classof(const Stmt *T) {
2327 static bool classof(const Stmt *T) {
2333 Stmt **begin = reinterpret_cast<Stmt **>(getTrailingObjects<Expr *>());
2337 Stmt *const *begin =
2350 Stmt *Ex;
2423 static bool classof(const Stmt *T) {
2439 Stmt *SubExprs[END_EXPR];
2502 static bool classof(const Stmt *T) {
2555 Stmt **getTrailingStmts() {
2559 Stmt *const *getTrailingStmts() const {
2586 return (1 + NumPreArgs + NumArgs) * sizeof(Stmt *);
2589 Stmt *getPreArg(unsigned I) {
2593 const Stmt *getPreArg(unsigned I) const {
2597 void setPreArg(unsigned I, Stmt *PreArg) {
2733 ArrayRef<Stmt *> getRawSubExprs() {
2780 static bool classof(const Stmt *T) {
2823 Stmt *Base;
3039 static bool classof(const Stmt *T) {
3062 Stmt *Init;
3110 static bool classof(const Stmt *T) {
3126 Stmt *Op;
3219 static bool classof(const Stmt *T) {
3288 static bool classof(const Stmt *T) {
3337 static bool classof(const Stmt *T) {
3383 static bool classof(const Stmt *T) {
3411 Stmt *SubExprs[END_EXPR];
3567 static bool classof(const Stmt *S) {
3658 static bool classof(const Stmt *S) {
3699 static bool classof(const Stmt *T) {
3709 Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
3762 static bool classof(const Stmt *T) {
3788 Stmt *SubExprs[NUM_SUBEXPRS];
3850 static bool classof(const Stmt *T) {
3907 static bool classof(const Stmt *T) {
3927 Stmt *SubStmt;
3954 static bool classof(const Stmt *T) {
3978 Stmt **SubExprs;
3998 static bool classof(const Stmt *T) {
4041 Stmt *SrcExpr;
4082 static bool classof(const Stmt *T) {
4104 Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
4163 static bool classof(const Stmt *T) {
4202 static bool classof(const Stmt *T) {
4217 Stmt *Val;
4254 static bool classof(const Stmt *T) {
4322 static bool classof(const Stmt *T) {
4377 typedef ASTVector<Stmt *> InitExprsTy;
4555 static bool classof(const Stmt *T) {
4613 private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
4865 return cast<Expr>(getTrailingObjects<Stmt *>()[Idx]);
4870 getTrailingObjects<Stmt *>()[Idx] = E;
4883 static bool classof(const Stmt *T) {
4889 Stmt **begin = getTrailingObjects<Stmt *>();
4889 Stmt **begin = getTrailingObjects<Stmt *>();
4893 Stmt * const *begin = getTrailingObjects<Stmt *>();
4893 Stmt * const *begin = getTrailingObjects<Stmt *>();
4918 static bool classof(const Stmt *T) {
4948 Stmt *BaseAndUpdaterExprs[2];
4960 static bool classof(const Stmt *T) {
5000 Stmt *SubExprs[2];
5028 static bool classof(const Stmt *S) {
5063 static bool classof(const Stmt *S) {
5099 static bool classof(const Stmt *T) {
5117 private llvm::TrailingObjects<ParenListExpr, Stmt *> {
5153 return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>());
5165 static bool classof(const Stmt *T) {
5171 return child_range(getTrailingObjects<Stmt *>(),
5172 getTrailingObjects<Stmt *>() + getNumExprs());
5175 return const_child_range(getTrailingObjects<Stmt *>(),
5176 getTrailingObjects<Stmt *>() + getNumExprs());
5208 private llvm::TrailingObjects<GenericSelectionExpr, Stmt *,
5235 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
5297 typename std::conditional<Const, const Stmt *const *, Stmt **>::type;
5297 typename std::conditional<Const, const Stmt *const *, Stmt **>::type;
5390 return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
5393 return cast<Expr>(getTrailingObjects<Stmt *>()[ControllingIndex]);
5400 getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
5404 getTrailingObjects<Stmt *>()[AssocExprStartIndex + getResultIndex()]);
5408 return {reinterpret_cast<Expr *const *>(getTrailingObjects<Stmt *>() +
5422 cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
5430 cast<Expr>(getTrailingObjects<Stmt *>()[AssocExprStartIndex + I]),
5436 AssociationIterator Begin(getTrailingObjects<Stmt *>() +
5446 ConstAssociationIterator Begin(getTrailingObjects<Stmt *>() +
5463 static bool classof(const Stmt *T) {
5468 return child_range(getTrailingObjects<Stmt *>(),
5469 getTrailingObjects<Stmt *>() +
5473 return const_child_range(getTrailingObjects<Stmt *>(),
5474 getTrailingObjects<Stmt *>() +
5491 Stmt *Base;
5538 static bool classof(const Stmt *T) {
5571 const Stmt *getBody() const;
5572 Stmt *getBody();
5584 static bool classof(const Stmt *T) {
5602 Stmt *SrcExpr;
5634 static bool classof(const Stmt *T) {
5787 Stmt *const *cs = const_cast<Stmt *const *>(
5792 static bool classof(const Stmt *T) {
5822 Stmt *SubExprs[END_EXPR + 1];
5903 static bool classof(const Stmt *T) {
5957 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/ExprCXX.h 143 static bool classof(const Stmt *T) {
218 static bool classof(const Stmt *T) {
252 static bool classof(const Stmt *T) {
277 Stmt *SemanticForm;
342 static bool classof(const Stmt *T) {
392 static bool classof(const Stmt *T) {
435 static bool classof(const Stmt *T) {
474 static bool classof(const Stmt *T) {
515 static bool classof(const Stmt *T) {
550 static bool classof(const Stmt *T) {
639 static bool classof(const Stmt *S) {
666 static bool classof(const Stmt *T) {
700 static bool classof(const Stmt *T) {
716 Stmt *SubExpr = nullptr;
748 static bool classof(const Stmt *S) {
766 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
823 return static_cast<Expr*>(Operand.get<Stmt *>());
836 static bool classof(const Stmt *T) {
844 auto **begin = reinterpret_cast<Stmt **>(&Operand);
852 auto **begin =
915 static bool classof(const Stmt *T) {
942 Stmt *SubExprs[NUM_SUBEXPRS];
982 static bool classof(const Stmt *T) {
1002 llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
1048 return static_cast<Expr*>(Operand.get<Stmt *>());
1064 static bool classof(const Stmt *T) {
1072 auto **begin = reinterpret_cast<Stmt **>(&Operand);
1079 auto **begin =
1121 static bool classof(const Stmt *T) {
1144 Stmt *Operand;
1183 static bool classof(const Stmt *T) {
1257 static bool classof(const Stmt *T) {
1326 static bool classof(const Stmt *T) {
1375 Stmt *SubExpr = nullptr;
1409 static bool classof(const Stmt *T) {
1458 inline Stmt **getTrailingArgs();
1459 const Stmt *const *getTrailingArgs() const {
1478 return NumArgs * sizeof(Stmt *);
1593 static bool classof(const Stmt *T) {
1668 static bool classof(const Stmt *T) {
1730 static bool classof(const Stmt *T) {
1784 static bool classof(const Stmt *T) {
1789 Stmt **CXXConstructExpr::getTrailingArgs() {
1819 private llvm::TrailingObjects<LambdaExpr, Stmt *> {
1866 Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
1866 Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
1868 Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
1868 Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
2030 static bool classof(const Stmt *T) {
2084 static bool classof(const Stmt *T) {
2102 private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
2143 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
2228 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2233 return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
2241 return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>() +
2277 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2282 ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
2314 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2320 return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
2326 using raw_arg_iterator = Stmt **;
2328 raw_arg_iterator raw_arg_begin() { return getTrailingObjects<Stmt *>(); }
2333 return getTrailingObjects<Stmt *>();
2345 static bool classof(const Stmt *T) {
2366 Stmt *Argument = nullptr;
2415 static bool classof(const Stmt *T) {
2483 Stmt *Base = nullptr;
2607 static bool classof(const Stmt *T) {
2693 static bool classof(const Stmt *T) {
2764 static bool classof(const Stmt *T) {
2828 static bool classof(const Stmt *T) {
3020 static bool classof(const Stmt *T) {
3136 static bool classof(const Stmt *T) {
3283 static bool classof(const Stmt *T) {
3357 static bool classof(const Stmt *T) {
3487 static bool classof(const Stmt *T) {
3493 auto **begin = reinterpret_cast<Stmt **>(arg_begin());
3498 auto **begin = reinterpret_cast<Stmt **>(
3522 Stmt *Base;
3738 static bool classof(const Stmt *T) {
3784 Stmt *Base;
3907 static bool classof(const Stmt *T) {
3961 Stmt *Operand;
3986 static bool classof(const Stmt *T) {
4028 Stmt *Pattern;
4068 static bool classof(const Stmt *T) {
4193 static bool classof(const Stmt *T) {
4217 Stmt *Replacement;
4245 static bool classof(const Stmt *s) {
4309 static bool classof(const Stmt *T) {
4386 static bool classof(const Stmt *T) {
4427 Stmt *Temporary;
4435 llvm::PointerUnion<Stmt *, ExtraState *> State;
4450 Stmt *getTemporary() const {
4451 return State.is<Stmt *>() ? State.get<Stmt *>()
4451 return State.is<Stmt *>() ? State.get<Stmt *>()
4480 return State.is<Stmt *>() ? nullptr
4487 return State.is<Stmt *>() ? 0 : State.get<ExtraState *>()->ManglingNumber;
4504 static bool classof(const Stmt *T) {
4510 if (State.is<Stmt *>())
4518 if (State.is<Stmt *>())
4545 Stmt *SubExprs[2];
4593 static bool classof(const Stmt *T) {
4625 Stmt *SubExprs[SubExpr::Count];
4698 static bool classof(const Stmt *T) {
4734 static bool classof(const Stmt *T) {
4745 Stmt *SubExprs[2];
4786 static bool classof(const Stmt *T) {
4810 static bool classof(const Stmt *T) {
4839 static bool classof(const Stmt *T) {
4945 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/ExprObjC.h 51 Stmt *String;
79 static bool classof(const Stmt *T) {
115 static bool classof(const Stmt *T) {
125 Stmt *SubExpr;
181 static bool classof(const Stmt *T) {
254 static bool classof(const Stmt *T) {
386 static_assert(sizeof(KeyValuePair) == sizeof(Stmt *) * 2,
399 static bool classof(const Stmt *T) {
448 static bool classof(const Stmt *T) {
490 static bool classof(const Stmt *T) {
540 static bool classof(const Stmt *T) {
548 Stmt *Base;
607 static bool classof(const Stmt *T) {
645 llvm::PointerUnion3<Stmt *, const Type *, ObjCInterfaceDecl *> Receiver;
757 return cast<Expr>(Receiver.get<Stmt*>());
760 return cast<Expr>(Receiver.get<Stmt*>());
775 bool isObjectReceiver() const { return Receiver.is<Stmt*>(); }
791 if (Receiver.is<Stmt*>()) {
792 Stmt **begin = reinterpret_cast<Stmt**>(&Receiver); // hack!
803 static bool classof(const Stmt *T) {
853 Stmt* SubExprs[END_EXPR];
891 void setBaseExpr(Stmt *S) { SubExprs[BASE] = S; }
894 void setKeyExpr(Stmt *S) { SubExprs[KEY] = S; }
916 static bool classof(const Stmt *T) {
1485 static bool classof(const Stmt *T) {
1494 Stmt *Base;
1550 static bool classof(const Stmt *T) {
1581 Stmt *Operand;
1627 static bool classof(const Stmt *s) {
1681 static bool classof(const Stmt *T) {
1731 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/ExprOpenMP.h 46 Stmt *SubExprs[END_EXPR];
118 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/ExternalASTSource.h 129 virtual Stmt *GetExternalDeclStmt(uint64_t Offset);
359 explicit LazyOffsetPtr(T *Ptr) : Ptr(reinterpret_cast<uint64_t>(Ptr)) {}
400 T* get(ExternalASTSource *Source) const {
597 LazyOffsetPtr<Stmt, uint64_t, &ExternalASTSource::GetExternalDeclStmt>;
tools/clang/include/clang/AST/JSONNodeDumper.h 189 void Visit(const Stmt *Node);
tools/clang/include/clang/AST/LexicallyOrderedRecursiveASTVisitor.h 113 Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
113 Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
115 SmallVector<Stmt *, 8> getStmtChildren(CXXOperatorCallExpr *CE) {
116 SmallVector<Stmt *, 8> Children(CE->children());
tools/clang/include/clang/AST/ODRHash.h 81 void AddStmt(const Stmt *S);
tools/clang/include/clang/AST/OpenMPClause.h 111 Stmt *PreInit = nullptr;
122 void setPreInitStmt(Stmt *S, OpenMPDirectiveKind ThisRegion = OMPD_unknown) {
129 const Stmt *getPreInitStmt() const { return PreInit; }
132 Stmt *getPreInitStmt() { return PreInit; }
270 Stmt *Allocator = nullptr;
429 Stmt *Condition = nullptr;
465 OMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Cond, Stmt *HelperCond,
529 Stmt *Condition = nullptr;
544 OMPFinalClause(Expr *Cond, Stmt *HelperCond,
598 Stmt *NumThreads = nullptr;
613 OMPNumThreadsClause(Expr *NumThreads, Stmt *HelperNumThreads,
674 Stmt *Safelen = nullptr;
739 Stmt *Simdlen = nullptr;
804 Stmt *NumForLoops = nullptr;
1383 Expr *ChunkSize, Stmt *HelperChunkSize,
1481 Stmt *NumForLoops = nullptr;
2062 ArrayRef<Expr *> InitVL, Stmt *PreInit);
2253 Stmt *PreInit, Expr *PostUpdate);
2559 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
2793 ArrayRef<Expr *> ReductionOps, Stmt *PreInit, Expr *PostUpdate);
3038 Stmt *PreInit, Expr *PostUpdate);
3266 Stmt *PreInit, Expr *PostUpdate);
4065 Stmt *Device = nullptr;
4081 OMPDeviceClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion,
5065 Stmt *NumTeams = nullptr;
5082 OMPNumTeamsClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion,
5140 Stmt *ThreadLimit = nullptr;
5157 OMPThreadLimitClause(Expr *E, Stmt *HelperE,
5216 Stmt *Priority = nullptr;
5233 OMPPriorityClause(Expr *Priority, Stmt *HelperPriority,
5290 Stmt *Grainsize = nullptr;
5304 OMPGrainsizeClause(Expr *Size, Stmt *HelperSize,
5397 Stmt *NumTasks = nullptr;
5411 OMPNumTasksClause(Expr *Size, Stmt *HelperSize,
5464 Stmt *Hint = nullptr;
5578 Stmt *HelperChunkSize)
tools/clang/include/clang/AST/ParentMap.h 23 ParentMap(Stmt* ASTRoot);
29 void addStmt(Stmt* S);
34 void setParent(const Stmt *S, const Stmt *Parent);
34 void setParent(const Stmt *S, const Stmt *Parent);
36 Stmt *getParent(Stmt*) const;
36 Stmt *getParent(Stmt*) const;
37 Stmt *getParentIgnoreParens(Stmt *) const;
37 Stmt *getParentIgnoreParens(Stmt *) const;
38 Stmt *getParentIgnoreParenCasts(Stmt *) const;
38 Stmt *getParentIgnoreParenCasts(Stmt *) const;
39 Stmt *getParentIgnoreParenImpCasts(Stmt *) const;
39 Stmt *getParentIgnoreParenImpCasts(Stmt *) const;
40 Stmt *getOuterParenParent(Stmt *) const;
40 Stmt *getOuterParenParent(Stmt *) const;
42 const Stmt *getParent(const Stmt* S) const {
42 const Stmt *getParent(const Stmt* S) const {
46 const Stmt *getParentIgnoreParens(const Stmt *S) const {
46 const Stmt *getParentIgnoreParens(const Stmt *S) const {
50 const Stmt *getParentIgnoreParenCasts(const Stmt *S) const {
50 const Stmt *getParentIgnoreParenCasts(const Stmt *S) const {
54 bool hasParent(Stmt* S) const {
tools/clang/include/clang/AST/PrettyPrinter.h 29 virtual bool handledStmt(Stmt* E, raw_ostream& OS) = 0;
tools/clang/include/clang/AST/RecursiveASTVisitor.h 157 typedef SmallVectorImpl<llvm::PointerIntPair<Stmt *, 1, bool>>
193 bool TraverseStmt(Stmt *S, DataRecursionQueue *Queue = nullptr);
198 bool dataTraverseStmtPre(Stmt *S) { return true; }
205 bool dataTraverseStmtPost(Stmt *S) { return true; }
319 Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
319 Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
363 bool WalkUpFromStmt(Stmt *S) { return getDerived().VisitStmt(S); }
364 bool VisitStmt(Stmt *S) { return true; }
539 bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
540 bool PostVisitStmt(Stmt *S);
544 bool RecursiveASTVisitor<Derived>::dataTraverseNode(Stmt *S,
584 case Stmt::NoStmtClass:
599 bool RecursiveASTVisitor<Derived>::PostVisitStmt(Stmt *S) {
601 case Stmt::NoStmtClass:
626 bool RecursiveASTVisitor<Derived>::TraverseStmt(Stmt *S,
636 SmallVector<llvm::PointerIntPair<Stmt *, 1, bool>, 8> LocalQueue;
641 Stmt *CurrS = CurrSAndVisited.getPointer();
2315 for (Stmt *SubStmt : S->children()) {
tools/clang/include/clang/AST/Stmt.h 1067 using ConstCastIterator = CastIterator<T, const T *const, const Stmt *const>;
1082 Stmt(const Stmt &) = delete;
1083 Stmt(Stmt &&) = delete;
1084 Stmt &operator=(const Stmt &) = delete;
1084 Stmt &operator=(const Stmt &) = delete;
1085 Stmt &operator=(Stmt &&) = delete;
1085 Stmt &operator=(Stmt &&) = delete;
1094 if (StatisticsEnabled) Stmt::addStmtClass(SC);
1151 Stmt *IgnoreContainers(bool IgnoreCaptured = false);
1152 const Stmt *IgnoreContainers(bool IgnoreCaptured = false) const {
1156 const Stmt *stripLabelLikeStatements() const;
1157 Stmt *stripLabelLikeStatements() {
1213 class DeclStmt : public Stmt {
1241 static bool classof(const Stmt *T) {
1285 class NullStmt : public Stmt {
1306 static bool classof(const Stmt *T) {
1320 class CompoundStmt final : public Stmt,
1321 private llvm::TrailingObjects<CompoundStmt, Stmt *> {
1328 CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB, SourceLocation RB);
1331 void setStmts(ArrayRef<Stmt *> Stmts);
1334 static CompoundStmt *Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
1350 using body_iterator = Stmt **;
1354 body_iterator body_begin() { return getTrailingObjects<Stmt *>(); }
1356 Stmt *body_front() { return !body_empty() ? body_begin()[0] : nullptr; }
1358 Stmt *body_back() {
1362 using const_body_iterator = Stmt *const *;
1370 return getTrailingObjects<Stmt *>();
1375 const Stmt *body_front() const {
1379 const Stmt *body_back() const {
1412 Stmt *getStmtExprResult() {
1413 for (auto *B : llvm::reverse(body())) {
1420 const Stmt *getStmtExprResult() const {
1430 static bool classof(const Stmt *T) {
1443 class SwitchCase : public Stmt {
1472 inline Stmt *getSubStmt();
1473 const Stmt *getSubStmt() const {
1480 static bool classof(const Stmt *T) {
1490 private llvm::TrailingObjects<CaseStmt, Stmt *, SourceLocation> {
1511 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
1578 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[lhsOffset()]);
1582 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[lhsOffset()]);
1586 getTrailingObjects<Stmt *>()[lhsOffset()] = reinterpret_cast<Stmt *>(Val);
1591 getTrailingObjects<Stmt *>()[rhsOffset()])
1597 getTrailingObjects<Stmt *>()[rhsOffset()])
1604 getTrailingObjects<Stmt *>()[rhsOffset()] = reinterpret_cast<Stmt *>(Val);
1607 Stmt *getSubStmt() { return getTrailingObjects<Stmt *>()[subStmtOffset()]; }
1607 Stmt *getSubStmt() { return getTrailingObjects<Stmt *>()[subStmtOffset()]; }
1608 const Stmt *getSubStmt() const {
1609 return getTrailingObjects<Stmt *>()[subStmtOffset()];
1612 void setSubStmt(Stmt *S) {
1613 getTrailingObjects<Stmt *>()[subStmtOffset()] = S;
1626 static bool classof(const Stmt *T) {
1632 return child_range(getTrailingObjects<Stmt *>(),
1633 getTrailingObjects<Stmt *>() +
1638 return const_child_range(getTrailingObjects<Stmt *>(),
1639 getTrailingObjects<Stmt *>() +
1645 Stmt *SubStmt;
1648 DefaultStmt(SourceLocation DL, SourceLocation CL, Stmt *substmt)
1655 Stmt *getSubStmt() { return SubStmt; }
1656 const Stmt *getSubStmt() const { return SubStmt; }
1657 void setSubStmt(Stmt *S) { SubStmt = S; }
1667 static bool classof(const Stmt *T) {
1687 Stmt *SwitchCase::getSubStmt() {
1701 class ValueStmt : public Stmt {
1712 static bool classof(const Stmt *T) {
1722 Stmt *SubStmt;
1726 LabelStmt(SourceLocation IL, LabelDecl *D, Stmt *substmt)
1741 Stmt *getSubStmt() { return SubStmt; }
1743 const Stmt *getSubStmt() const { return SubStmt; }
1744 void setSubStmt(Stmt *SS) { SubStmt = SS; }
1755 static bool classof(const Stmt *T) {
1770 Stmt *SubStmt;
1773 Stmt *SubStmt)
1794 ArrayRef<const Attr *> Attrs, Stmt *SubStmt);
1804 Stmt *getSubStmt() { return SubStmt; }
1805 const Stmt *getSubStmt() const { return SubStmt; }
1816 static bool classof(const Stmt *T) {
1823 : public Stmt,
1824 private llvm::TrailingObjects<IfStmt, Stmt *, SourceLocation> {
1852 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
1870 IfStmt(const ASTContext &Ctx, SourceLocation IL, bool IsConstexpr, Stmt *Init,
1871 VarDecl *Var, Expr *Cond, Stmt *Then, SourceLocation EL, Stmt *Else);
1871 VarDecl *Var, Expr *Cond, Stmt *Then, SourceLocation EL, Stmt *Else);
1879 bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
1880 Stmt *Then, SourceLocation EL = SourceLocation(),
1881 Stmt *Else = nullptr);
1898 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
1902 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
1906 getTrailingObjects<Stmt *>()[condOffset()] = reinterpret_cast<Stmt *>(Cond);
1909 Stmt *getThen() { return getTrailingObjects<Stmt *>()[thenOffset()]; }
1909 Stmt *getThen() { return getTrailingObjects<Stmt *>()[thenOffset()]; }
1910 const Stmt *getThen() const {
1911 return getTrailingObjects<Stmt *>()[thenOffset()];
1914 void setThen(Stmt *Then) {
1915 getTrailingObjects<Stmt *>()[thenOffset()] = Then;
1918 Stmt *getElse() {
1919 return hasElseStorage() ? getTrailingObjects<Stmt *>()[elseOffset()]
1923 const Stmt *getElse() const {
1924 return hasElseStorage() ? getTrailingObjects<Stmt *>()[elseOffset()]
1928 void setElse(Stmt *Else) {
1931 getTrailingObjects<Stmt *>()[elseOffset()] = Else;
1955 getTrailingObjects<Stmt *>()[varOffset()])
1961 getTrailingObjects<Stmt *>()[varOffset()])
1965 Stmt *getInit() {
1966 return hasInitStorage() ? getTrailingObjects<Stmt *>()[initOffset()]
1970 const Stmt *getInit() const {
1971 return hasInitStorage() ? getTrailingObjects<Stmt *>()[initOffset()]
1975 void setInit(Stmt *Init) {
1978 getTrailingObjects<Stmt *>()[initOffset()] = Init;
2010 return child_range(getTrailingObjects<Stmt *>(),
2011 getTrailingObjects<Stmt *>() +
2016 return const_child_range(getTrailingObjects<Stmt *>(),
2017 getTrailingObjects<Stmt *>() +
2021 static bool classof(const Stmt *T) {
2027 class SwitchStmt final : public Stmt,
2028 private llvm::TrailingObjects<SwitchStmt, Stmt *> {
2054 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
2066 SwitchStmt(const ASTContext &Ctx, Stmt *Init, VarDecl *Var, Expr *Cond);
2073 static SwitchStmt *Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
2088 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
2092 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
2096 getTrailingObjects<Stmt *>()[condOffset()] = reinterpret_cast<Stmt *>(Cond);
2099 Stmt *getBody() { return getTrailingObjects<Stmt *>()[bodyOffset()]; }
2099 Stmt *getBody() { return getTrailingObjects<Stmt *>()[bodyOffset()]; }
2100 const Stmt *getBody() const {
2101 return getTrailingObjects<Stmt *>()[bodyOffset()];
2104 void setBody(Stmt *Body) {
2105 getTrailingObjects<Stmt *>()[bodyOffset()] = Body;
2108 Stmt *getInit() {
2109 return hasInitStorage() ? getTrailingObjects<Stmt *>()[initOffset()]
2113 const Stmt *getInit() const {
2114 return hasInitStorage() ? getTrailingObjects<Stmt *>()[initOffset()]
2118 void setInit(Stmt *Init) {
2121 getTrailingObjects<Stmt *>()[initOffset()] = Init;
2146 getTrailingObjects<Stmt *>()[varOffset()])
2152 getTrailingObjects<Stmt *>()[varOffset()])
2163 void setBody(Stmt *S, SourceLocation SL) {
2193 return child_range(getTrailingObjects<Stmt *>(),
2194 getTrailingObjects<Stmt *>() +
2199 return const_child_range(getTrailingObjects<Stmt *>(),
2200 getTrailingObjects<Stmt *>() +
2204 static bool classof(const Stmt *T) {
2210 class WhileStmt final : public Stmt,
2211 private llvm::TrailingObjects<WhileStmt, Stmt *> {
2236 unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
2241 WhileStmt(const ASTContext &Ctx, VarDecl *Var, Expr *Cond, Stmt *Body,
2250 Stmt *Body, SourceLocation WL);
2260 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
2264 return reinterpret_cast<Expr *>(getTrailingObjects<Stmt *>()[condOffset()]);
2268 getTrailingObjects<Stmt *>()[condOffset()] = reinterpret_cast<Stmt *>(Cond);
2271 Stmt *getBody() { return getTrailingObjects<Stmt *>()[bodyOffset()]; }
2271 Stmt *getBody() { return getTrailingObjects<Stmt *>()[bodyOffset()]; }
2272 const Stmt *getBody() const {
2273 return getTrailingObjects<Stmt *>()[bodyOffset()];
2276 void setBody(Stmt *Body) {
2277 getTrailingObjects<Stmt *>()[bodyOffset()] = Body;
2301 getTrailingObjects<Stmt *>()[varOffset()])
2307 getTrailingObjects<Stmt *>()[varOffset()])
2319 static bool classof(const Stmt *T) {
2325 return child_range(getTrailingObjects<Stmt *>(),
2326 getTrailingObjects<Stmt *>() +
2331 return const_child_range(getTrailingObjects<Stmt *>(),
2332 getTrailingObjects<Stmt *>() +
2338 class DoStmt : public Stmt {
2340 Stmt *SubExprs[END_EXPR];
2345 DoStmt(Stmt *Body, Expr *Cond, SourceLocation DL, SourceLocation WL,
2363 Stmt *getBody() { return SubExprs[BODY]; }
2364 const Stmt *getBody() const { return SubExprs[BODY]; }
2365 void setBody(Stmt *Body) { SubExprs[BODY] = Body; }
2377 static bool classof(const Stmt *T) {
2394 class ForStmt : public Stmt {
2396 Stmt* SubExprs[END_EXPR]; // SubExprs[INIT] is an expression or declstmt.
2400 ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
2401 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
2407 Stmt *getInit() { return SubExprs[INIT]; }
2428 Stmt *getBody() { return SubExprs[BODY]; }
2430 const Stmt *getInit() const { return SubExprs[INIT]; }
2433 const Stmt *getBody() const { return SubExprs[BODY]; }
2435 void setInit(Stmt *S) { SubExprs[INIT] = S; }
2438 void setBody(Stmt *S) { SubExprs[BODY] = S; }
2450 static bool classof(const Stmt *T) {
2465 class GotoStmt : public Stmt {
2489 static bool classof(const Stmt *T) {
2504 class IndirectGotoStmt : public Stmt {
2506 Stmt *Target;
2540 static bool classof(const Stmt *T) {
2553 class ContinueStmt : public Stmt {
2568 static bool classof(const Stmt *T) {
2583 class BreakStmt : public Stmt {
2598 static bool classof(const Stmt *T) {
2621 : public Stmt,
2626 Stmt *RetExpr;
2684 static bool classof(const Stmt *T) {
2703 class AsmStmt : public Stmt {
2721 Stmt **Exprs = nullptr;
2787 static bool classof(const Stmt *T) {
3054 Stmt **Exprs,
3079 static bool classof(const Stmt *T) {
3176 static bool classof(const Stmt *T) {
3189 class SEHExceptStmt : public Stmt {
3194 Stmt *Children[2];
3198 SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block);
3205 Stmt *Block);
3228 static bool classof(const Stmt *T) {
3233 class SEHFinallyStmt : public Stmt {
3238 Stmt *Block;
3240 SEHFinallyStmt(SourceLocation Loc, Stmt *Block);
3246 Stmt *Block);
3263 static bool classof(const Stmt *T) {
3268 class SEHTryStmt : public Stmt {
3274 Stmt *Children[2];
3280 Stmt *TryBlock,
3281 Stmt *Handler);
3287 SourceLocation TryLoc, Stmt *TryBlock,
3288 Stmt *Handler);
3301 Stmt *getHandler() const { return Children[HANDLER]; }
3315 static bool classof(const Stmt *T) {
3321 class SEHLeaveStmt : public Stmt {
3337 static bool classof(const Stmt *T) {
3360 class CapturedStmt : public Stmt {
3432 CapturedStmt(Stmt *S, CapturedRegionKind Kind, ArrayRef<Capture> Captures,
3438 Stmt **getStoredStmts() { return reinterpret_cast<Stmt **>(this + 1); }
3440 Stmt *const *getStoredStmts() const {
3446 void setCapturedStmt(Stmt *S) { getStoredStmts()[NumCaptures] = S; }
3451 static CapturedStmt *Create(const ASTContext &Context, Stmt *S,
3461 Stmt *getCapturedStmt() { return getStoredStmts()[NumCaptures]; }
3462 const Stmt *getCapturedStmt() const { return getStoredStmts()[NumCaptures]; }
3564 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/StmtCXX.h 28 class CXXCatchStmt : public Stmt {
33 Stmt *HandlerBlock;
36 CXXCatchStmt(SourceLocation catchLoc, VarDecl *exDecl, Stmt *handlerBlock)
51 Stmt *getHandlerBlock() const { return HandlerBlock; }
53 static bool classof(const Stmt *T) {
68 class CXXTryStmt final : public Stmt,
69 private llvm::TrailingObjects<CXXTryStmt, Stmt *> {
76 size_t numTrailingObjects(OverloadToken<Stmt *>) const { return NumHandlers; }
78 CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, ArrayRef<Stmt*> handlers);
78 CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock, ArrayRef<Stmt*> handlers);
82 Stmt *const *getStmts() const { return getTrailingObjects<Stmt *>(); }
82 Stmt *const *getStmts() const { return getTrailingObjects<Stmt *>(); }
83 Stmt **getStmts() { return getTrailingObjects<Stmt *>(); }
83 Stmt **getStmts() { return getTrailingObjects<Stmt *>(); }
87 Stmt *tryBlock, ArrayRef<Stmt*> handlers);
87 Stmt *tryBlock, ArrayRef<Stmt*> handlers);
114 static bool classof(const Stmt *T) {
134 class CXXForRangeStmt : public Stmt {
139 Stmt *SubExprs[END];
146 CXXForRangeStmt(Stmt *InitStmt, DeclStmt *Range, DeclStmt *Begin,
148 Stmt *Body, SourceLocation FL, SourceLocation CAL,
152 Stmt *getInit() { return SubExprs[INIT]; }
156 const Stmt *getInit() const { return SubExprs[INIT]; }
169 Stmt *getBody() { return SubExprs[BODY]; }
189 const Stmt *getBody() const { return SubExprs[BODY]; }
191 void setInit(Stmt *S) { SubExprs[INIT] = S; }
193 void setRangeStmt(Stmt *S) { SubExprs[RANGE] = S; }
194 void setBeginStmt(Stmt *S) { SubExprs[BEGINSTMT] = S; }
195 void setEndStmt(Stmt *S) { SubExprs[ENDSTMT] = S; }
198 void setLoopVarStmt(Stmt *S) { SubExprs[LOOPVAR] = S; }
199 void setBody(Stmt *S) { SubExprs[BODY] = S; }
211 static bool classof(const Stmt *T) {
252 class MSDependentExistsStmt : public Stmt {
257 Stmt *SubStmt;
309 static bool classof(const Stmt *T) {
318 : public Stmt,
319 private llvm::TrailingObjects<CoroutineBodyStmt, Stmt *> {
341 Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
341 Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
343 Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
343 Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }
348 Stmt *Body = nullptr;
349 Stmt *Promise = nullptr;
352 Stmt *OnException = nullptr;
353 Stmt *OnFallthrough = nullptr;
357 Stmt *ResultDecl = nullptr;
358 Stmt *ReturnStmt = nullptr;
359 Stmt *ReturnStmtOnAllocFailure = nullptr;
360 ArrayRef<Stmt *> ParamMoves;
378 Stmt *getBody() const {
382 Stmt *getPromiseDeclStmt() const {
389 Stmt *getInitSuspendStmt() const {
392 Stmt *getFinalSuspendStmt() const {
396 Stmt *getExceptionHandler() const {
399 Stmt *getFallthroughHandler() const {
412 Stmt *getResultDecl() const { return getStoredStmts()[SubStmt::ResultDecl]; }
413 Stmt *getReturnStmt() const { return getStoredStmts()[SubStmt::ReturnStmt]; }
414 Stmt *getReturnStmtOnAllocFailure() const {
417 ArrayRef<Stmt const *> getParamMoves() const {
440 static bool classof(const Stmt *T) {
456 class CoreturnStmt : public Stmt {
460 Stmt *SubStmts[SubStmt::Count];
466 CoreturnStmt(SourceLocation CoreturnLoc, Stmt *Operand, Stmt *PromiseCall,
466 CoreturnStmt(SourceLocation CoreturnLoc, Stmt *Operand, Stmt *PromiseCall,
511 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/StmtGraphTraits.h 24 using NodeRef = clang::Stmt *;
25 using ChildIteratorType = clang::Stmt::child_iterator;
26 using nodes_iterator = llvm::df_iterator<clang::Stmt *>;
28 static NodeRef getEntryNode(clang::Stmt *S) { return S; }
40 static nodes_iterator nodes_begin(clang::Stmt* S) {
44 static nodes_iterator nodes_end(clang::Stmt* S) {
50 using NodeRef = const clang::Stmt *;
51 using ChildIteratorType = clang::Stmt::const_child_iterator;
52 using nodes_iterator = llvm::df_iterator<const clang::Stmt *>;
54 static NodeRef getEntryNode(const clang::Stmt *S) { return S; }
tools/clang/include/clang/AST/StmtIterator.h 37 Stmt **stmt;
43 StmtIteratorBase(Stmt **s) : stmt(s) {}
73 Stmt*& GetDeclExpr() const;
86 StmtIteratorImpl(Stmt **s) : StmtIteratorBase(s) {}
124 struct StmtIterator : public StmtIteratorImpl<StmtIterator, Stmt*&> {
126 StmtIterator(Stmt** S) : StmtIteratorImpl<StmtIterator, Stmt*&>(S) {}
141 const Stmt*> {
146 ConstStmtIterator(Stmt * const *S)
tools/clang/include/clang/AST/StmtObjC.h 23 class ObjCForCollectionStmt : public Stmt {
25 Stmt* SubExprs[END_EXPR]; // SubExprs[ELEM] is an expression or declstmt.
29 ObjCForCollectionStmt(Stmt *Elem, Expr *Collect, Stmt *Body,
29 ObjCForCollectionStmt(Stmt *Elem, Expr *Collect, Stmt *Body,
34 Stmt *getElement() { return SubExprs[ELEM]; }
38 Stmt *getBody() { return SubExprs[BODY]; }
40 const Stmt *getElement() const { return SubExprs[ELEM]; }
44 const Stmt *getBody() const { return SubExprs[BODY]; }
46 void setElement(Stmt *S) { SubExprs[ELEM] = S; }
50 void setBody(Stmt *S) { SubExprs[BODY] = S; }
62 static bool classof(const Stmt *T) {
77 class ObjCAtCatchStmt : public Stmt {
80 Stmt *Body;
86 Stmt *atCatchStmt)
93 const Stmt *getCatchBody() const { return Body; }
94 Stmt *getCatchBody() { return Body; }
95 void setCatchBody(Stmt *S) { Body = S; }
115 static bool classof(const Stmt *T) {
127 class ObjCAtFinallyStmt : public Stmt {
129 Stmt *AtFinallyStmt;
132 ObjCAtFinallyStmt(SourceLocation atFinallyLoc, Stmt *atFinallyStmt)
139 const Stmt *getFinallyBody() const { return AtFinallyStmt; }
140 Stmt *getFinallyBody() { return AtFinallyStmt; }
141 void setFinallyBody(Stmt *S) { AtFinallyStmt = S; }
151 static bool classof(const Stmt *T) {
165 class ObjCAtTryStmt : public Stmt {
181 Stmt **getStmts() { return reinterpret_cast<Stmt **> (this + 1); }
182 const Stmt* const *getStmts() const {
186 ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
187 Stmt **CatchStmts, unsigned NumCatchStmts,
188 Stmt *atFinallyStmt);
197 SourceLocation atTryLoc, Stmt *atTryStmt,
198 Stmt **CatchStmts, unsigned NumCatchStmts,
199 Stmt *atFinallyStmt);
208 const Stmt *getTryBody() const { return getStmts()[0]; }
209 Stmt *getTryBody() { return getStmts()[0]; }
210 void setTryBody(Stmt *S) { getStmts()[0] = S; }
247 void setFinallyStmt(Stmt *S) {
255 static bool classof(const Stmt *T) {
277 class ObjCAtSynchronizedStmt : public Stmt {
281 Stmt* SubStmts[END_EXPR];
284 ObjCAtSynchronizedStmt(SourceLocation atSynchronizedLoc, Stmt *synchExpr,
285 Stmt *synchBody)
303 void setSynchBody(Stmt *S) { SubStmts[SYNC_BODY] = S; }
311 void setSynchExpr(Stmt *S) { SubStmts[SYNC_EXPR] = S; }
318 static bool classof(const Stmt *T) {
332 class ObjCAtThrowStmt : public Stmt {
334 Stmt *Throw;
337 ObjCAtThrowStmt(SourceLocation atThrowLoc, Stmt *throwExpr)
346 void setThrowExpr(Stmt *S) { Throw = S; }
356 static bool classof(const Stmt *T) {
368 class ObjCAutoreleasePoolStmt : public Stmt {
370 Stmt *SubStmt;
373 ObjCAutoreleasePoolStmt(SourceLocation atLoc, Stmt *subStmt)
379 const Stmt *getSubStmt() const { return SubStmt; }
380 Stmt *getSubStmt() { return SubStmt; }
381 void setSubStmt(Stmt *S) { SubStmt = S; }
391 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/StmtOpenMP.h 33 class OMPExecutableDirective : public Stmt {
85 void setAssociatedStmt(Stmt *S) {
95 std::forward_iterator_tag, Stmt *, ptrdiff_t, Stmt *, Stmt *> {
95 std::forward_iterator_tag, Stmt *, ptrdiff_t, Stmt *, Stmt *> {
95 std::forward_iterator_tag, Stmt *, ptrdiff_t, Stmt *, Stmt *> {
123 Stmt *operator*() const { return *ChildI; }
124 Stmt *operator->() const { return **this; }
253 const Stmt *getAssociatedStmt() const {
257 Stmt *getAssociatedStmt() {
303 static bool classof(const Stmt *S) {
311 Stmt **ChildStorage = reinterpret_cast<Stmt **>(getClauses().end());
320 Stmt **ChildStorage = reinterpret_cast<Stmt **>(
340 const Stmt *getStructuredBlock() const;
342 Stmt *getStructuredBlock() {
398 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel);
411 static bool classof(const Stmt *T) {
604 void setPreInits(Stmt *PreInits) {
842 Stmt *PreInits;
941 const Stmt *getPreInits() const {
944 Stmt *getPreInits() { return *std::next(child_begin(), PreInitsOffset); }
1087 const Stmt *getBody() const {
1089 const Stmt *Body =
1159 static bool classof(const Stmt *T) {
1238 Stmt *AssociatedStmt,
1251 static bool classof(const Stmt *T) {
1312 Stmt *AssociatedStmt, const HelperExprs &Exprs,
1328 static bool classof(const Stmt *T) {
1380 Stmt *AssociatedStmt, const HelperExprs &Exprs);
1393 static bool classof(const Stmt *T) {
1450 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel);
1464 static bool classof(const Stmt *T) {
1510 Stmt *AssociatedStmt, bool HasCancel);
1524 static bool classof(const Stmt *T) {
1570 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1581 static bool classof(const Stmt *T) {
1620 Stmt *AssociatedStmt);
1628 static bool classof(const Stmt *T) {
1685 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
1699 static bool classof(const Stmt *T) {
1761 Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
1778 static bool classof(const Stmt *T) {
1833 Stmt *AssociatedStmt, const HelperExprs &Exprs);
1847 static bool classof(const Stmt *T) {
1905 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel);
1919 static bool classof(const Stmt *T) {
1975 Stmt *AssociatedStmt, bool HasCancel);
1989 static bool classof(const Stmt *T) {
2033 static bool classof(const Stmt *T) {
2077 static bool classof(const Stmt *T) {
2121 static bool classof(const Stmt *T) {
2170 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2190 static bool classof(const Stmt *T) {
2249 static bool classof(const Stmt *T) {
2293 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2303 static bool classof(const Stmt *T) {
2392 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
2436 static bool classof(const Stmt *T) {
2482 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2493 static bool classof(const Stmt *T) {
2541 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2551 static bool classof(const Stmt *T) {
2600 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2610 static bool classof(const Stmt *T) {
2659 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2669 static bool classof(const Stmt *T) {
2717 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
2728 static bool classof(const Stmt *T) {
2792 Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
2809 static bool classof(const Stmt *T) {
2856 Stmt *AssociatedStmt);
2867 static bool classof(const Stmt *T) {
2925 static bool classof(const Stmt *T) {
2988 static bool classof(const Stmt *T) {
3040 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3053 static bool classof(const Stmt *T) {
3106 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3120 static bool classof(const Stmt *T) {
3174 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3188 static bool classof(const Stmt *T) {
3242 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3255 static bool classof(const Stmt *T) {
3311 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3325 static bool classof(const Stmt *T) {
3379 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3392 static bool classof(const Stmt *T) {
3440 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
3451 static bool classof(const Stmt *T) {
3514 Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
3531 static bool classof(const Stmt *T) {
3589 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3601 static bool classof(const Stmt *T) {
3655 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3668 static bool classof(const Stmt *T) {
3723 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3736 static bool classof(const Stmt *T) {
3790 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3803 static bool classof(const Stmt *T) {
3857 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3870 static bool classof(const Stmt *T) {
3926 Stmt *AssociatedStmt, const HelperExprs &Exprs);
3940 static bool classof(const Stmt *T) {
3999 Stmt *AssociatedStmt, const HelperExprs &Exprs);
4011 static bool classof(const Stmt *T) {
4075 Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
4090 static bool classof(const Stmt *T) {
4139 Stmt *AssociatedStmt);
4149 static bool classof(const Stmt *T) {
4204 Stmt *AssociatedStmt, const HelperExprs &Exprs);
4216 static bool classof(const Stmt *T) {
4284 Stmt *AssociatedStmt, const HelperExprs &Exprs, bool HasCancel);
4299 static bool classof(const Stmt *T) {
4360 Stmt *AssociatedStmt, const HelperExprs &Exprs);
4372 static bool classof(const Stmt *T) {
4430 Stmt *AssociatedStmt, const HelperExprs &Exprs);
4442 static bool classof(const Stmt *T) {
tools/clang/include/clang/AST/TextNodeDumper.h 163 void Visit(const Stmt *Node);
tools/clang/include/clang/AST/Type.h 3015 Stmt *SizeExpr;
3074 Stmt *SizeExpr;
tools/clang/include/clang/ASTMatchers/ASTMatchFinder.h 184 template <typename T> void match(const T &Node, ASTContext &Context) {
266 const NodeT *
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
269 if (const NodeT *Node = N.getNodeAs<NodeT>(BoundTo))
tools/clang/include/clang/ASTMatchers/ASTMatchers.h 110 const T *getNodeAs(StringRef ID) const {
111 return MyBoundNodes.getNodeAs<T>(ID);
138 using StatementMatcher = internal::Matcher<Stmt>;
1055 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
1211 extern const internal::VariadicAllOfMatcher<Stmt> stmt;
1221 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
1234 extern const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
1248 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
1260 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
1272 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
1302 extern const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
1311 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
1323 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
1433 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
1443 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt>
1453 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
1463 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
1473 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
1486 extern const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr>
1509 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
1521 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
1539 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr>
1552 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
1593 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
1639 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr>
1649 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
1661 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
1672 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
1686 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr>
1697 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
1718 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
1730 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
1740 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr>
1751 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
1763 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
1780 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
1789 extern const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
1798 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr>
1812 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr>
1821 extern const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
1829 extern const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
1838 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
1850 const Stmt *const Increment = Node.getInc();
1865 const Stmt *const Init = Node.getInit();
1876 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
1915 extern const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
1925 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
1935 extern const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
1945 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt>
1956 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
1967 extern const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
1978 extern const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
1990 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr>
2001 extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
2011 extern const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
2021 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
2031 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt>
2040 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt>
2050 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt>
2060 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
2069 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr>
2079 extern const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
2089 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
2097 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
2107 extern const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral>
2120 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
2127 extern const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
2137 extern const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral>
2142 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral>
2148 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
2158 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
2162 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
2166 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr>
2170 extern const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr>
2178 extern const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
2186 extern const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
2194 extern const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
2203 extern const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator>
2212 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
2221 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
2233 extern const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
2262 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
2278 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
2293 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
2304 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
2313 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
2337 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
2344 extern const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
2360 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
2370 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
2379 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
2388 extern const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
2397 extern const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
2470 extern const internal::VariadicDynCastAllOfMatcher<Stmt,
2506 inline internal::Matcher<Stmt> alignOfExpr(
2515 inline internal::Matcher<Stmt> sizeOfExpr(
2886 internal::Matcher<T> findAll(const internal::Matcher<T> &Matcher) {
2886 internal::Matcher<T> findAll(const internal::Matcher<T> &Matcher) {
4300 const Stmt *const Then = Node.getThen();
4312 const Stmt *const Else = Node.getElse();
4419 const Stmt *const Statement = internal::GetBodyMatcher<NodeType>::get(Node);
6430 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
6648 extern const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
tools/clang/include/clang/ASTMatchers/ASTMatchersInternal.h 160 const T *getNodeAs(StringRef ID) const {
165 return It->second.get<T>();
302 virtual bool matches(const T &Node,
309 return matches(DynNode.getUnchecked<T>(), Finder, Builder);
345 DynTypedMatcher(MatcherInterface<T> *Implementation)
346 : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
436 return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
445 template <typename T> Matcher<T> convertTo() const {
447 return unconditionalConvertTo<T>();
479 class WrapperMatcherInterface : public MatcherInterface<T> {
499 explicit Matcher(MatcherInterface<T> *Implementation)
506 Matcher(const Matcher<From> &Other,
507 typename std::enable_if<std::is_base_of<From, T>::value &&
508 !std::is_same<From, T>::value>::type * = nullptr)
520 std::is_same<T, QualType>::value &&
528 Matcher<To> dynCastTo() const {
529 static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
534 bool matches(const T &Node,
581 return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
596 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
922 std::is_same<T, Decl>::value ||
923 std::is_same<T, Stmt>::value ||
923 std::is_same<T, Stmt>::value ||
924 std::is_same<T, QualType>::value ||
925 std::is_same<T, Type>::value ||
926 std::is_same<T, TypeLoc>::value ||
927 std::is_same<T, NestedNameSpecifier>::value ||
928 std::is_same<T, NestedNameSpecifierLoc>::value ||
929 std::is_same<T, CXXCtorInitializer>::value;
994 bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
997 static_assert(std::is_base_of<Decl, T>::value ||
998 std::is_base_of<Stmt, T>::value ||
998 std::is_base_of<Stmt, T>::value ||
999 std::is_base_of<NestedNameSpecifier, T>::value ||
1000 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1001 std::is_base_of<TypeLoc, T>::value ||
1002 std::is_base_of<QualType, T>::value,
1009 bool matchesDescendantOf(const T &Node,
1013 static_assert(std::is_base_of<Decl, T>::value ||
1014 std::is_base_of<Stmt, T>::value ||
1014 std::is_base_of<Stmt, T>::value ||
1015 std::is_base_of<NestedNameSpecifier, T>::value ||
1016 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1017 std::is_base_of<TypeLoc, T>::value ||
1018 std::is_base_of<QualType, T>::value,
1026 bool matchesAncestorOf(const T &Node,
1030 static_assert(std::is_base_of<Decl, T>::value ||
1031 std::is_base_of<NestedNameSpecifierLoc, T>::value ||
1032 std::is_base_of<Stmt, T>::value ||
1032 std::is_base_of<Stmt, T>::value ||
1033 std::is_base_of<TypeLoc, T>::value,
1067 using head = T1;
1073 using tail = TypeList<Ts...>;
1084 std::is_base_of<typename AnyTypeList::head, T>::value ||
1085 TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
1096 TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, QualType,
1111 TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc, TypeLoc,
1141 explicit Adaptor(const Matcher<T> &InnerMatcher)
1146 template <typename To> operator Matcher<To>() const {
1151 const Matcher<T> InnerMatcher;
1155 static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
1155 static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
1160 Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
1160 Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
1184 operator Matcher<T>() const {
1185 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1202 operator Matcher<T>() const {
1203 static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
1243 operator Matcher<T>() const {
1245 ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
1246 .template unconditionalConvertTo<T>();
1255 class BindableMatcher : public Matcher<T> {
1257 explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
1258 explicit BindableMatcher(MatcherInterface<T> *Implementation)
1265 Matcher<T> bind(StringRef ID) const {
1268 ->template unconditionalConvertTo<T>();
1285 class HasMatcher : public WrapperMatcherInterface<T> {
1287 explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
1290 bool matches(const T &Node, ASTMatchFinder *Finder,
1304 class ForEachMatcher : public WrapperMatcherInterface<T> {
1305 static_assert(IsBaseType<ChildT>::value,
1309 explicit ForEachMatcher(const Matcher<ChildT> &ChildMatcher)
1312 bool matches(const T& Node, ASTMatchFinder* Finder,
1335 template <typename T> operator Matcher<T>() const {
1337 Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1338 getMatchers<T>(std::index_sequence_for<Ps...>()))
1339 .template unconditionalConvertTo<T>();
1370 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
1376 BindableMatcher<T> makeAllOfComposite(
1377 ArrayRef<const Matcher<T> *> InnerMatchers) {
1388 using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
1395 ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
1397 .template unconditionalConvertTo<T>());
1407 BindableMatcher<T> makeDynCastAllOfComposite(
1410 makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
1418 class HasDescendantMatcher : public WrapperMatcherInterface<T> {
1419 static_assert(IsBaseType<DescendantT>::value,
1423 explicit HasDescendantMatcher(const Matcher<DescendantT> &DescendantMatcher)
1426 bool matches(const T &Node, ASTMatchFinder *Finder,
1438 class HasParentMatcher : public WrapperMatcherInterface<T> {
1439 static_assert(IsBaseType<ParentT>::value,
1443 explicit HasParentMatcher(const Matcher<ParentT> &ParentMatcher)
1446 bool matches(const T &Node, ASTMatchFinder *Finder,
1458 class HasAncestorMatcher : public WrapperMatcherInterface<T> {
1459 static_assert(IsBaseType<AncestorT>::value,
1463 explicit HasAncestorMatcher(const Matcher<AncestorT> &AncestorMatcher)
1466 bool matches(const T &Node, ASTMatchFinder *Finder,
1480 class ForEachDescendantMatcher : public WrapperMatcherInterface<T> {
1481 static_assert(IsBaseType<DescendantT>::value,
1486 const Matcher<DescendantT> &DescendantMatcher)
1489 bool matches(const T &Node, ASTMatchFinder *Finder,
1557 : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
1558 makeDynCastAllOfComposite<SourceT, TargetT>> {
1575 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1575 : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
1576 makeAllOfComposite<T>> {
1767 static const Stmt *get(const Ty &Node) {
1773 inline const Stmt *GetBodyMatcher<FunctionDecl>::get(const FunctionDecl &Node) {
tools/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h 199 ast_matchers::internal::Matcher<T> getTypedMatcher() const {
202 ->template convertTo<T>();
227 : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
228 typedef ast_matchers::internal::Matcher<T> MatcherT;
232 return DynTypedMatcher(Matcher.convertTo<T>());
tools/clang/include/clang/Analysis/Analyses/Consumed.h 149 const Stmt *From = nullptr;
189 void setSource(const Stmt *Source) { this->From = Source; }
tools/clang/include/clang/Analysis/Analyses/ExprMutationAnalyzer.h 25 ExprMutationAnalyzer(const Stmt &Stm, ASTContext &Context)
30 const Stmt *findMutation(const Expr *Exp);
31 const Stmt *findMutation(const Decl *Dec);
39 const Stmt *findPointeeMutation(const Expr *Exp);
40 const Stmt *findPointeeMutation(const Decl *Dec);
44 using ResultMap = llvm::DenseMap<const Expr *, const Stmt *>;
46 const Stmt *findMutationMemoized(const Expr *Exp,
49 const Stmt *tryEachDeclRef(const Decl *Dec, MutationFinder Finder);
53 const Stmt *findExprMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
54 const Stmt *findDeclMutation(ArrayRef<ast_matchers::BoundNodes> Matches);
55 const Stmt *
57 const Stmt *
60 const Stmt *findDirectMutation(const Expr *Exp);
61 const Stmt *findMemberMutation(const Expr *Exp);
62 const Stmt *findArrayElementMutation(const Expr *Exp);
63 const Stmt *findCastMutation(const Expr *Exp);
64 const Stmt *findRangeLoopMutation(const Expr *Exp);
65 const Stmt *findReferenceMutation(const Expr *Exp);
66 const Stmt *findFunctionArgMutation(const Expr *Exp);
68 const Stmt &Stm;
86 const Stmt *findMutation(const ParmVarDecl *Parm);
90 llvm::DenseMap<const ParmVarDecl *, const Stmt *> Results;
tools/clang/include/clang/Analysis/Analyses/LiveVariables.h 33 llvm::ImmutableSet<const Stmt *> liveStmts;
42 LivenessValues(llvm::ImmutableSet<const Stmt *> LiveStmts,
48 bool isLive(const Stmt *S) const;
61 virtual void observeStmt(const Stmt *S,
84 bool isLive(const Stmt *S, const VarDecl *D);
88 bool isLive(const Stmt *Loc, const Stmt *StmtVal);
88 bool isLive(const Stmt *Loc, const Stmt *StmtVal);
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyCommon.h 120 void handleStatement(const Stmt *S) {}
379 til::SExpr *translate(const Stmt *S, CallingContext *Ctx);
382 til::SExpr *lookupStmt(const Stmt *S);
426 using StatementMap = llvm::DenseMap<const Stmt *, til::SExpr *>;
456 void handleStatement(const Stmt *S);
465 void insertStmt(const Stmt *S, til::SExpr *E) {
471 til::SExpr *addStatement(til::SExpr *E, const Stmt *S,
tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h 489 Undefined(const Stmt *S = nullptr) : SExpr(COP_Undefined), Cstmt(S) {}
505 const Stmt *Cstmt;
tools/clang/include/clang/Analysis/Analyses/UninitializedValues.h 33 const Stmt *Terminator;
tools/clang/include/clang/Analysis/AnalysisDeclContext.h 132 void registerForcedBlockExpression(const Stmt *stmt);
133 const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt);
136 Stmt *getBody() const;
141 Stmt *getBody(bool &IsAutosynthesized) const;
186 const Stmt *S, const CFGBlock *Blk,
300 const Stmt *CallSite;
314 const Stmt *s, const CFGBlock *blk, unsigned blockCount,
322 const Stmt *getCallSite() const { return CallSite; }
334 const LocationContext *parent, const Stmt *s,
350 const Stmt *Enter;
353 const Stmt *s, int64_t ID)
362 const LocationContext *parent, const Stmt *s) {
417 const Stmt *s, const CFGBlock *blk,
422 const Stmt *s);
491 const Stmt *S, const CFGBlock *Blk,
505 const Stmt *S, const CFGBlock *Blk,
tools/clang/include/clang/Analysis/BodyFarm.h 36 Stmt *getBody(const FunctionDecl *D);
39 Stmt *getBody(const ObjCMethodDecl *D);
45 typedef llvm::DenseMap<const Decl *, Optional<Stmt *>> BodyMap;
tools/clang/include/clang/Analysis/CFG.h 134 explicit CFGStmt(Stmt *S, Kind K = Statement) : CFGElement(K, S) {
138 const Stmt *getStmt() const {
273 explicit CFGLoopExit(const Stmt *stmt) : CFGElement(LoopExit, stmt) {}
275 const Stmt *getLoopStmt() const {
292 explicit CFGLifetimeEnds(const VarDecl *var, const Stmt *stmt)
299 const Stmt *getTriggerStmt() const {
318 CFGScopeBegin(const VarDecl *VD, const Stmt *S)
322 const Stmt *getTriggerStmt() const {
344 CFGScopeEnd(const VarDecl *VD, const Stmt *S) : CFGElement(ScopeEnd, VD, S) {}
350 const Stmt *getTriggerStmt() const {
391 CFGAutomaticObjDtor(const VarDecl *var, const Stmt *stmt)
399 const Stmt *getTriggerStmt() const {
528 llvm::PointerIntPair<Stmt *, KindBits> Data;
532 CFGTerminator(Stmt *S, Kind K = StmtBranch) : Data(S, K) {}
535 Stmt *getStmt() { return Data.getPointer(); }
536 const Stmt *getStmt() const { return Data.getPointer(); }
772 Stmt *Label = nullptr;
781 const Stmt *LoopTarget = nullptr;
1041 void setLabel(Stmt *Statement) { Label = Statement; }
1042 void setLoopTarget(const Stmt *loopTarget) { LoopTarget = loopTarget; }
1051 Stmt *getTerminatorStmt() { return Terminator.getStmt(); }
1052 const Stmt *getTerminatorStmt() const { return Terminator.getStmt(); }
1062 Stmt *getTerminatorCondition(bool StripParens = true);
1064 const Stmt *getTerminatorCondition(bool StripParens = true) const {
1068 const Stmt *getLoopTarget() const { return LoopTarget; }
1070 Stmt *getLabel() { return Label; }
1071 const Stmt *getLabel() const { return Label; }
1096 void appendStmt(Stmt *statement, BumpVectorContext &C) {
1121 void appendScopeBegin(const VarDecl *VD, const Stmt *S,
1126 void prependScopeBegin(const VarDecl *VD, const Stmt *S,
1131 void appendScopeEnd(const VarDecl *VD, const Stmt *S, BumpVectorContext &C) {
1135 void prependScopeEnd(const VarDecl *VD, const Stmt *S, BumpVectorContext &C) {
1151 void appendAutomaticObjDtor(VarDecl *VD, Stmt *S, BumpVectorContext &C) {
1155 void appendLifetimeEnds(VarDecl *VD, Stmt *S, BumpVectorContext &C) {
1159 void appendLoopExit(const Stmt *LoopStmt, BumpVectorContext &C) {
1175 iterator insertAutomaticObjDtor(iterator I, VarDecl *VD, Stmt *S) {
1188 iterator insertLifetimeEnds(iterator I, VarDecl *VD, Stmt *S) {
1200 iterator insertScopeEnd(iterator I, VarDecl *VD, Stmt *S) {
1233 std::bitset<Stmt::lastStmtConstant> alwaysAddMask;
1236 using ForcedBlkExprs = llvm::DenseMap<const Stmt *, const CFGBlock *>;
1257 bool alwaysAdd(const Stmt *stmt) const {
1261 BuildOptions &setAlwaysAdd(Stmt::StmtClass stmtClass, bool val = true) {
1273 static std::unique_ptr<CFG> buildCFG(const Decl *D, Stmt *AST, ASTContext *C,
1461 using SimpleType = ::clang::Stmt *;
tools/clang/include/clang/Analysis/CFGStmtMap.h 41 CFGBlock *getBlock(Stmt * S);
43 const CFGBlock *getBlock(const Stmt * S) const {
tools/clang/include/clang/Analysis/CallGraph.h 130 bool TraverseStmt(Stmt *S) { return true; }
tools/clang/include/clang/Analysis/CloneDetection.h 37 const Stmt *S;
68 StmtSequence(const Stmt *Stmt, const Decl *D);
73 typedef const Stmt *const *iterator;
84 const Stmt *front() const {
92 const Stmt *back() const {
358 const Stmt *Mention;
360 VariableOccurence(size_t KindID, const Stmt *Mention)
373 void addVariableOccurence(const VarDecl *VarDecl, const Stmt *Mention);
376 void addVariables(const Stmt *S);
382 for (const Stmt *S : Sequence)
395 const Stmt *Mention;
400 SuspiciousCloneInfo(const VarDecl *Variable, const Stmt *Mention,
tools/clang/include/clang/Analysis/CodeInjector.h 40 virtual Stmt *getBody(const FunctionDecl *D) = 0;
41 virtual Stmt *getBody(const ObjCMethodDecl *D) = 0;
tools/clang/include/clang/Analysis/ConstructionContext.h 136 const Stmt *getStmt() const {
141 const Stmt *getStmtOrNull() const {
tools/clang/include/clang/Analysis/PathDiagnostic.h 161 const Stmt *S = nullptr;
182 PathDiagnosticLocation(const Stmt *s, const SourceManager &sm,
229 static PathDiagnosticLocation createBegin(const Stmt *S,
237 static PathDiagnosticLocation createEnd(const Stmt *S,
286 getValidSourceLocation(const Stmt *S, LocationOrAnalysisDeclContext LAC,
309 const Stmt *asStmt() const { assert(isValid()); return S; }
310 const Stmt *getStmtOrNull() const {
tools/clang/include/clang/Analysis/ProgramPoint.h 220 static ProgramPoint getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
259 const Stmt *getTerminator() const {
273 StmtPoint(const Stmt *S, const void *p2, Kind k, const LocationContext *L,
279 const Stmt *getStmt() const { return (const Stmt*) getData1(); }
297 PreStmt(const Stmt *S, const LocationContext *L, const ProgramPointTag *tag,
298 const Stmt *SubStmt = nullptr)
301 const Stmt *getSubStmt() const { return (const Stmt*) getData2(); }
314 PostStmt(const Stmt *S, const void *data, Kind k, const LocationContext *L,
319 explicit PostStmt(const Stmt *S, Kind k, const LocationContext *L,
323 explicit PostStmt(const Stmt *S, const LocationContext *L,
361 PostCondition(const Stmt *S, const LocationContext *L,
376 LocationCheck(const Stmt *S, const LocationContext *L,
390 PreLoad(const Stmt *S, const LocationContext *L,
404 PreStore(const Stmt *S, const LocationContext *L,
418 PostLoad(const Stmt *S, const LocationContext *L,
436 PostStore(const Stmt *S, const LocationContext *L, const void *Loc,
459 PostLValue(const Stmt *S, const LocationContext *L,
475 PreStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
491 PostStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
616 PostAllocatorCall(const Stmt *S, const LocationContext *L,
632 CallEnter(const Stmt *stmt, const StackFrameContext *calleeCtx,
636 const Stmt *getCallExpr() const {
715 LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
718 const Stmt *getLoopStmt() const {
tools/clang/include/clang/Parse/Parser.h 1930 typedef SmallVector<Stmt*, 32> StmtVector;
tools/clang/include/clang/Sema/MultiplexExternalSemaSource.h 82 Stmt *GetExternalDeclStmt(uint64_t Offset) override;
tools/clang/include/clang/Sema/Ownership.h 217 template <typename T> T *getAs() { return static_cast<T*>(get()); }
264 using StmtResult = ActionResult<Stmt *>;
274 using MultiStmtArg = MutableArrayRef<Stmt *>;
293 inline Stmt *AssertSuccess(StmtResult R) {
tools/clang/include/clang/Sema/ScopeInfo.h 88 llvm::TinyPtrVector<const Stmt*> Stmts;
91 ArrayRef<const Stmt *> Stmts)
197 llvm::SmallMapVector<ParmVarDecl *, Stmt *, 4> CoroutineParameterMoves;
200 std::pair<Stmt *, Stmt *> CoroutineSuspends;
200 std::pair<Stmt *, Stmt *> CoroutineSuspends;
480 void setCoroutineSuspends(Stmt *Initial, Stmt *Final) {
480 void setCoroutineSuspends(Stmt *Initial, Stmt *Final) {
tools/clang/include/clang/Sema/Sema.h 2318 void computeNRVO(Stmt *Body, sema::FunctionScopeInfo *Scope);
2319 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body);
2320 Decl *ActOnFinishFunctionBody(Decl *Decl, Stmt *Body, bool IsInstantiation);
2339 void DiagnoseInvalidJumps(Stmt *Body);
3760 StmtResult ProcessStmtAttributes(Stmt *Stmt,
4051 ArrayRef<Stmt *> Elts, bool isStmtExpr);
4089 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
4089 void ActOnCaseStmtBody(Stmt *CaseStmt, Stmt *SubStmt);
4093 Stmt *SubStmt, Scope *CurScope);
4095 SourceLocation ColonLoc, Stmt *SubStmt);
4099 Stmt *SubStmt);
4103 Stmt *InitStmt,
4104 ConditionResult Cond, Stmt *ThenVal,
4105 SourceLocation ElseLoc, Stmt *ElseVal);
4107 Stmt *InitStmt,
4108 ConditionResult Cond, Stmt *ThenVal,
4109 SourceLocation ElseLoc, Stmt *ElseVal);
4111 Stmt *InitStmt,
4114 Stmt *Switch, Stmt *Body);
4114 Stmt *Switch, Stmt *Body);
4116 Stmt *Body);
4117 StmtResult ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
4123 Stmt *First,
4127 Stmt *Body);
4131 Stmt *First, Expr *collection,
4133 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
4133 StmtResult FinishObjCForCollectionStmt(Stmt *ForCollection, Stmt *Body);
4148 Stmt *InitStmt,
4149 Stmt *LoopVar,
4155 Stmt *InitStmt,
4157 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
4157 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
4157 Stmt *RangeDecl, Stmt *Begin, Stmt *End,
4159 Stmt *LoopVarDecl,
4162 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
4162 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body);
4180 StmtResult ActOnCapturedRegionEnd(Stmt *S);
4245 Decl *Parm, Stmt *Body);
4247 StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body);
4249 StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
4250 MultiStmtArg Catch, Stmt *Finally);
4259 Stmt *SynchBody);
4261 StmtResult ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body);
4271 Decl *ExDecl, Stmt *HandlerBlock);
4272 StmtResult ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
4273 ArrayRef<Stmt *> Handlers);
4276 SourceLocation TryLoc, Stmt *TryBlock,
4277 Stmt *Handler);
4280 Stmt *Block);
4283 StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
4296 void DiagnoseUnusedExprResult(const Stmt *S);
4307 const Stmt *Body,
4312 void DiagnoseEmptyLoopBody(const Stmt *S,
4313 const Stmt *PossibleBody);
4497 bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
4501 bool DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
4864 ExprResult ActOnStmtExpr(SourceLocation LPLoc, Stmt *SubStmt,
4948 Stmt *Nested);
4952 Stmt *Nested);
4971 ExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc, Stmt *Body,
5763 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
5763 Stmt *MaybeCreateStmtWithCleanups(Stmt *SubStmt);
5776 StmtResult ActOnFinishFullStmt(Stmt *Stmt);
6076 ExprResult ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
8359 StmtResult SubstStmt(Stmt *S,
9170 void CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body);
9389 void EndOpenMPDSABlock(Stmt *CurDirective);
9395 void ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init);
9505 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
9509 Stmt *AStmt,
9517 ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
9523 ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
9529 ActOnOpenMPForSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
9535 Stmt *AStmt, SourceLocation StartLoc,
9539 StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
9544 Stmt *AStmt, SourceLocation StartLoc,
9548 StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,
9554 Stmt *AStmt, SourceLocation StartLoc,
9559 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9564 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9569 Stmt *AStmt,
9575 Stmt *AStmt, SourceLocation StartLoc,
9588 Stmt *AStmt, SourceLocation StartLoc,
9597 Stmt *AStmt, SourceLocation StartLoc,
9602 Stmt *AStmt, SourceLocation StartLoc,
9607 Stmt *AStmt, SourceLocation StartLoc,
9612 Stmt *AStmt, SourceLocation StartLoc,
9619 Stmt *AStmt);
9625 Stmt *AStmt);
9629 Stmt *AStmt,
9635 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9640 Stmt *AStmt, SourceLocation StartLoc,
9655 ActOnOpenMPTaskLoopDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
9661 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9666 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9671 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9676 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9681 ActOnOpenMPDistributeDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
9688 Stmt *AStmt);
9692 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9697 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9702 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9707 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9712 ActOnOpenMPTargetSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
9718 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9723 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9728 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9733 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9738 Stmt *AStmt,
9744 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9749 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9754 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9759 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
tools/clang/include/clang/Serialization/ASTReader.h 1149 SmallVector<Stmt *, 16> StmtStack;
1205 Stmt *ReadStmtFromStream(ModuleFile &F);
1903 Stmt *GetExternalDeclStmt(uint64_t Offset) override;
2268 Stmt *ReadStmt(ModuleFile &F);
2274 Stmt *ReadSubStmt() {
2465 Stmt *readStmt() { return Reader->ReadStmt(*F); }
2471 Stmt *readSubStmt() { return Reader->ReadSubStmt(); }
tools/clang/include/clang/Serialization/ASTWriter.h 295 llvm::DenseSet<Stmt *> ParentStmts;
299 llvm::DenseMap<Stmt *, uint64_t> SubStmtEntries;
457 void WriteSubStmt(Stmt *S);
754 SmallVector<Stmt *, 16> StmtsToEmit;
839 void AddStmt(Stmt *S) {
tools/clang/include/clang/StaticAnalyzer/Checkers/SValExplainer.h 29 std::string printStmt(const Stmt *S) {
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporter.h 358 const Stmt *getStmt() const;
tools/clang/include/clang/StaticAnalyzer/Core/BugReporter/BugReporterVisitors.h 119 const Expr *getDerefExpr(const Stmt *S);
209 static const Expr *getNilReceiver(const Stmt *S, const ExplodedNode *N);
239 VisitTerminator(const Stmt *Term, const ExplodedNode *N,
tools/clang/include/clang/StaticAnalyzer/Core/Checker.h 84 static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
85 ((const CHECKER *)checker)->checkPreStmt(cast<STMT>(S), C);
88 static bool _handlesStmt(const Stmt *S) {
89 return isa<STMT>(S);
103 static void _checkStmt(void *checker, const Stmt *S, CheckerContext &C) {
107 static bool _handlesStmt(const Stmt *S) {
197 const SVal &location, bool isLoad, const Stmt *S,
213 const SVal &location, const SVal &val, const Stmt *S,
272 static void _checkBranchCondition(void *checker, const Stmt *Condition,
tools/clang/include/clang/StaticAnalyzer/Core/CheckerManager.h 207 const Stmt *S,
220 const Stmt *S,
229 const Stmt *S, ExprEngine &Eng,
291 const Stmt *NodeEx,
292 const Stmt *BoundEx,
299 const Stmt *S, ExprEngine &Eng,
320 void runCheckersForBranchCondition(const Stmt *condition,
346 SymbolReaper &SymReaper, const Stmt *S,
442 using CheckStmtFunc = CheckerFn<void (const Stmt *, CheckerContext &)>;
451 CheckerFn<void (const SVal &location, bool isLoad, const Stmt *S,
455 CheckerFn<void (const SVal &location, const SVal &val, const Stmt *S,
467 CheckerFn<void (const Stmt *, CheckerContext &)>;
501 using HandlesStmtFunc = bool (*)(const Stmt *D);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h 182 SVal getSVal(const Stmt *S) const {
369 static bool isCallStmt(const Stmt *S);
781 CXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger,
1209 getCall(const Stmt *S, ProgramStateRef State,
1229 getCXXDestructorCall(const CXXDestructorDecl *DD, const Stmt *Trigger,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h 144 SVal getSVal(const Stmt *S) const {
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h 28 bool containsMacro(const Stmt *S);
29 bool containsEnum(const Stmt *S);
30 bool containsStaticLocal(const Stmt *S);
31 bool containsBuiltinOffsetOf(const Stmt *S);
32 template <class T> bool containsStmt(const Stmt *S) {
36 for (const Stmt *Child : S->children())
44 parseAssignment(const Stmt *S);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h 115 void HandleBranch(const Stmt *Cond, const Stmt *Term, const CFGBlock *B,
115 void HandleBranch(const Stmt *Cond, const Stmt *Term, const CFGBlock *B,
407 ExplodedNode *generateNode(const Stmt *S,
417 ExplodedNode *generateSink(const Stmt *S,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/Environment.h 35 class EnvironmentEntry : public std::pair<const Stmt *,
38 EnvironmentEntry(const Stmt *s, const LocationContext *L);
40 const Stmt *getStmt() const { return first; }
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h 177 SVal getSVal(const Stmt *S) const {
276 const Stmt *getStmtForDiagnostics() const;
282 const Stmt *getNextStmtForDiagnostics() const;
288 const Stmt *getPreviousStmtForDiagnostics() const;
294 const Stmt *getCurrentOrPreviousStmtForDiagnostics() const;
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h 208 const Stmt *getStmt() const;
266 const Stmt *ReferenceStmt, const LocationContext *LC,
267 const Stmt *DiagnosticStmt = nullptr,
275 void ProcessStmt(const Stmt *S, ExplodedNode *Pred);
277 void ProcessLoopExit(const Stmt* S, ExplodedNode *Pred);
303 void processBranch(const Stmt *Condition,
413 void Visit(const Stmt *S, ExplodedNode *Pred, ExplodedNodeSet &Dst);
531 const Stmt *S, bool IsBaseDtor,
611 void evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE, ExplodedNode *Pred,
695 const Stmt *NodeEx, /* This will eventually be a CFGStmt */
696 const Stmt *BoundEx,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopUnrolling.h 39 ProgramStateRef updateLoopStack(const Stmt *LoopStmt, ASTContext &ASTCtx,
44 ProgramStateRef processLoopEnd(const Stmt *LoopStmt, ProgramStateRef State);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/LoopWidening.h 30 unsigned BlockCount, const Stmt *LoopStmt);
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ProgramState.h 237 LLVM_NODISCARD ProgramStateRef BindExpr(const Stmt *S,
327 SVal getSVal(const Stmt *S, const LocationContext *LCtx) const;
329 SVal getSValAsScalarOrLoc(const Stmt *Ex, const LocationContext *LCtx) const;
757 inline SVal ProgramState::getSVal(const Stmt *Ex,
764 ProgramState::getSValAsScalarOrLoc(const Stmt *S,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h 179 const SymbolConjured* conjureSymbol(const Stmt *stmt,
215 DefinedOrUnknownSVal conjureSymbolVal(const Stmt *stmt,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SubEngine.h 74 virtual void processBranch(const Stmt *Condition,
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h 76 const Stmt *S;
83 SymbolConjured(SymbolID sym, const Stmt *s, const LocationContext *lctx,
96 const Stmt *getStmt() const { return S; }
104 static void Profile(llvm::FoldingSetNodeID& profile, const Stmt *S,
203 const Stmt *S;
210 SymbolMetadata(SymbolID sym, const MemRegion* r, const Stmt *s, QualType t,
222 const Stmt *getStmt() const { return S; }
232 const Stmt *S, QualType T, const LocationContext *LCtx,
486 const SymbolConjured* conjureSymbol(const Stmt *E,
508 const SymbolMetadata *getMetadataSymbol(const MemRegion *R, const Stmt *S,
564 const Stmt *Loc;
577 SymbolReaper(const StackFrameContext *Ctx, const Stmt *s,
585 bool isLive(const Stmt *ExprVal, const LocationContext *LCtx) const;
tools/clang/include/clang/StaticAnalyzer/Frontend/FrontendActions.h 43 ParseModelFileAction(llvm::StringMap<Stmt *> &Bodies);
51 llvm::StringMap<Stmt *> &Bodies;
tools/clang/include/clang/StaticAnalyzer/Frontend/ModelConsumer.h 33 ModelConsumer(llvm::StringMap<Stmt *> &Bodies);
38 llvm::StringMap<Stmt *> &Bodies;
tools/clang/include/clang/Tooling/FixIt.h 43 template <typename T> CharSourceRange getSourceRange(const T &Node) {
50 StringRef getText(const T &Node, const ASTContext &Context) {
62 FixItHint createReplacement(const D &Destination, const S &Source,
62 FixItHint createReplacement(const D &Destination, const S &Source,
tools/clang/include/clang/Tooling/Refactoring/ASTSelection.h 109 const Stmt *operator[](size_t I) const {
112 return SelectedNode.get().Node.get<Stmt>();
114 return SelectedNode.get().Children[I].Node.get<Stmt>();
tools/clang/include/clang/Tooling/Refactoring/Extract/SourceExtraction.h 34 static ExtractionSemicolonPolicy compute(const Stmt *S,
tools/clang/lib/ARCMigrate/Internals.h 64 void removeStmt(Stmt *S);
67 void replaceStmt(Stmt *S, StringRef text);
tools/clang/lib/ARCMigrate/ObjCMT.cpp 359 for (Stmt *SubStmt : E->children())
377 bool TraverseStmt(Stmt *S) {
tools/clang/lib/ARCMigrate/TransAutoreleasePool.cpp 78 void transformBody(Stmt *body, Decl *ParentD) {
128 Stmt::child_iterator retI = scope.End;
166 for (Stmt::child_iterator
168 Stmt *child = getEssential(*I);
217 void clearUnavailableDiags(Stmt *S) {
227 Stmt::child_iterator Begin;
228 Stmt::child_iterator End;
236 Stmt::child_iterator rangeS = Begin;
240 Stmt::child_iterator rangeE = Begin;
241 for (Stmt::child_iterator I = rangeS; I != End; ++I)
301 Stmt::child_iterator SI = scope.End, SE = compoundS->body_end();
340 Stmt::child_iterator I = scope.Begin;
372 bool isPoolDrain(VarDecl *poolVar, Stmt *S) {
404 static Stmt *getEssential(Stmt *S) {
404 static Stmt *getEssential(Stmt *S) {
412 Stmt *Body;
tools/clang/lib/ARCMigrate/TransEmptyStatementsAndDealloc.cpp 90 for (auto *I : S->body())
165 for (auto *I : S->body())
173 void check(Stmt *S) {
186 for (auto *I : body->body())
tools/clang/lib/ARCMigrate/TransProtectedScope.cpp 66 Stmt *Parent = getCaseParent(Curr);
87 Stmt *getCaseParent(SwitchCase *S) {
88 Stmt *Parent = PMap.getParent(S);
tools/clang/lib/ARCMigrate/TransRetainReleaseDealloc.cpp 36 Stmt *Body;
53 void transformBody(Stmt *body, Decl *ParentD) {
191 Stmt *nextStmt = getNextStmt(E);
212 Stmt *prevStmt, *nextStmt;
219 bool isPlusOneAssignToVar(Stmt *S, Decl *RefD) {
240 Stmt *getNextStmt(Expr *E) {
244 std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) {
244 std::pair<Stmt *, Stmt *> getPreviousAndNextStmt(Expr *E) {
245 Stmt *prevStmt = nullptr, *nextStmt = nullptr;
249 Stmt *OuterS = E, *InnerS;
261 Stmt::child_iterator currChildS = OuterS->child_begin();
262 Stmt::child_iterator childE = OuterS->child_end();
263 Stmt::child_iterator prevChildS = childE;
343 Stmt *S = Msg;
355 Stmt::child_range StmtExprChild = StmtE->children();
362 Stmt::child_range CompStmtChild = CompS->children();
412 Stmt *S = E;
432 Stmt *parent = StmtMap->getParent(E);
tools/clang/lib/ARCMigrate/TransUnbridgedCasts.cpp 64 Stmt *Body;
73 void transformBody(Stmt *body, Decl *ParentD) {
371 Stmt *parent = E;
tools/clang/lib/ARCMigrate/TransUnusedInitDelegate.cpp 34 Stmt *Body;
43 void transformBody(Stmt *body, Decl *ParentD) {
tools/clang/lib/ARCMigrate/TransformActions.cpp 48 Stmt *S;
113 llvm::DenseSet<Stmt *> StmtRemovals;
136 void removeStmt(Stmt *S);
139 void replaceStmt(Stmt *S, StringRef text);
159 void commitRemoveStmt(Stmt *S);
312 void TransformActionsImpl::removeStmt(Stmt *S) {
351 void TransformActionsImpl::replaceStmt(Stmt *S, StringRef text) {
450 void TransformActionsImpl::commitRemoveStmt(Stmt *S) {
642 void TransformActions::removeStmt(Stmt *S) {
655 void TransformActions::replaceStmt(Stmt *S, StringRef text) {
tools/clang/lib/ARCMigrate/Transforms.cpp 257 for (auto *I : S->body())
286 void mark(Stmt *S) {
300 void trans::clearRefsIn(Stmt *S, ExprSet &refs) {
304 void trans::collectRefs(ValueDecl *D, Stmt *S, ExprSet &refs) {
308 void trans::collectRemovables(Stmt *S, ExprSet &exprs) {
337 bool TraverseStmt(Stmt *rootS) {
tools/clang/lib/ARCMigrate/Transforms.h 48 Stmt *TopStmt;
51 BodyContext(MigrationContext &MigrateCtx, Stmt *S)
56 Stmt *getTopStmt() { return TopStmt; }
193 bool TraverseStmt(Stmt *rootS) {
207 void clearRefsIn(Stmt *S, ExprSet &refs);
214 void collectRefs(ValueDecl *D, Stmt *S, ExprSet &refs);
216 void collectRemovables(Stmt *S, ExprSet &exprs);
tools/clang/lib/AST/ASTContext.cpp 898 llvm::PointerUnion4<const Decl *, const Stmt *,
905 llvm::PointerUnion4<const Decl *, const Stmt *,
916 if (const auto *S = U.dyn_cast<const Stmt *>())
916 if (const auto *S = U.dyn_cast<const Stmt *>())
10445 else if (const auto *S = ParentStack.back().get<Stmt>())
10445 else if (const auto *S = ParentStack.back().get<Stmt>())
10482 bool TraverseStmt(Stmt *StmtNode) {
tools/clang/lib/AST/ASTImporter.cpp 79 using ExpectedStmt = llvm::Expected<Stmt *>;
162 Expected<T *> import(T *From) {
162 Expected<T *> import(T *From) {
166 return cast_or_null<T>(*ToOrErr);
170 Expected<T *> import(const T *From) {
170 Expected<T *> import(const T *From) {
506 ExpectedStmt VisitStmt(Stmt *S);
2985 if (Stmt *FromBody = FromFD->getBody()) {
5639 ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {
5749 SmallVector<Stmt *, 8> ToStmts(S->size());
5775 Stmt *ToSubStmt;
5793 Stmt *ToSubStmt;
5807 Stmt *ToSubStmt;
5838 Stmt *ToInit, *ToThen, *ToElse;
5857 Stmt *ToInit, *ToBody;
5893 Stmt *ToBody;
5908 Stmt *ToBody;
5924 Stmt *ToInit;
5927 Stmt *ToBody;
6002 Stmt *ToHandlerBlock;
6018 SmallVector<Stmt *, 1> ToHandlers(S->getNumHandlers());
6044 Stmt *ToInit, *ToBody;
6064 Stmt *ToElement, *ToBody;
6085 Stmt *ToCatchBody;
6110 Stmt *ToTryBody, *ToFinallyStmt;
6113 SmallVector<Stmt *, 1> ToCatchStmts(S->getNumCatchStmts());
6137 Stmt *ToSynchBody;
6759 case Stmt::CStyleCastExprClass: {
6773 case Stmt::CXXFunctionalCastExprClass: {
6787 case Stmt::ObjCBridgedCastExprClass: {
8119 if (ExpectedStmt ToSOrErr = Import(cast_or_null<Stmt>(FromE)))
8125 Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
8125 Expected<Stmt *> ASTImporter::Import(Stmt *FromS) {
8130 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
8130 llvm::DenseMap<Stmt *, Stmt *>::iterator Pos = ImportedStmts.find(FromS);
tools/clang/lib/AST/ASTTypeTraits.cpp 91 ASTNodeKind ASTNodeKind::getFromNode(const Stmt &S) {
93 case Stmt::NoStmtClass: return NKI_None;
146 else if (const Stmt *S = get<Stmt>())
146 else if (const Stmt *S = get<Stmt>())
157 else if (const Stmt *S = get<Stmt>())
157 else if (const Stmt *S = get<Stmt>())
174 if (const Stmt *S = get<Stmt>())
174 if (const Stmt *S = get<Stmt>())
tools/clang/lib/AST/Decl.cpp 2223 if (auto *S = Init.dyn_cast<Stmt *>())
2223 if (auto *S = Init.dyn_cast<Stmt *>())
2229 Stmt **VarDecl::getInitAddress() {
2335 Eval->Value = Init.get<Stmt *>();
2740 return cast_or_null<Expr>(Init.get<Stmt *>());
2826 Stmt *S = getBody();
2849 Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
2859 void FunctionDecl::setBody(Stmt *B) {
4667 Stmt *CapturedDecl::getBody() const { return BodyAndNothrow.getPointer(); }
4668 void CapturedDecl::setBody(Stmt *B) { BodyAndNothrow.setPointer(B); }
tools/clang/lib/AST/DeclBase.cpp 906 if (Stmt *Body = getBody())
tools/clang/lib/AST/DeclObjC.cpp 851 Stmt *ObjCMethodDecl::getBody() const {
980 if (Stmt *Body = getBody())
tools/clang/lib/AST/Expr.cpp 223 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
634 void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
641 void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
2329 if (Stmt *S = *I) {
2347 if (Stmt *S = *I) {
2367 const Stmt *BlockExpr::getBody() const {
2370 Stmt *BlockExpr::getBody() {
3616 for (const Stmt *SubStmt : children())
4107 SubExprs = new (C) Stmt*[args.size()];
4126 SubExprs = new (C) Stmt*[NumExprs];
4150 getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
4152 getTrailingObjects<Stmt *>() + AssocExprStartIndex);
4174 getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
4176 getTrailingObjects<Stmt *>() + AssocExprStartIndex);
4191 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4205 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4216 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4304 void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
4313 void *Mem = C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
4434 getTrailingObjects<Stmt *>()[I] = Exprs[I];
4447 void *Mem = Ctx.Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
4455 Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumExprs), alignof(ParenListExpr));
4541 Stmt::child_range UnaryExprOrTypeTraitExpr::children() {
4547 Stmt::const_child_range UnaryExprOrTypeTraitExpr::children() const {
tools/clang/lib/AST/ExprCXX.cpp 205 getTrailingObjects<Stmt *>()[arraySizeOffset()] = *ArraySize;
216 getTrailingObjects<Stmt *>()[initExprOffset()] = Initializer;
227 getTrailingObjects<Stmt *>()[placementNewArgsOffset() + I] =
270 Ctx.Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
284 Ctx.Allocate(totalSizeToAlloc<Stmt *, SourceRange>(
1113 Stmt **TrailingArgs = getTrailingArgs();
1206 Stmt **Stored = getStoredStmts();
1224 unsigned Size = totalSizeToAlloc<Stmt *>(Captures.size() + 1);
1234 unsigned Size = totalSizeToAlloc<Stmt *>(NumCaptures + 1);
1666 ES->Temporary = State.get<Stmt *>();
tools/clang/lib/AST/ExprClassification.cpp 107 case Stmt::NoStmtClass:
tools/clang/lib/AST/ExprConstant.cpp 978 bool nextStep(const Stmt *S) {
4363 const Stmt *S,
4368 const Stmt *Body,
4398 if (const Stmt *Init = SS->getInit()) {
4465 const Stmt *S, const SwitchCase *Case) {
4473 case Stmt::CompoundStmtClass:
4477 case Stmt::LabelStmtClass:
4478 case Stmt::AttributedStmtClass:
4479 case Stmt::DoStmtClass:
4482 case Stmt::CaseStmtClass:
4483 case Stmt::DefaultStmtClass:
4488 case Stmt::IfStmtClass: {
4499 if (const Stmt *Init = IS->getInit()) {
4528 case Stmt::WhileStmtClass: {
4536 case Stmt::ForStmtClass: {
4542 if (const Stmt *Init = FS->getInit()) {
4562 case Stmt::DeclStmtClass: {
4600 case Stmt::NullStmtClass:
4603 case Stmt::DeclStmtClass: {
4616 case Stmt::ReturnStmtClass: {
4627 case Stmt::CompoundStmtClass: {
4631 for (const auto *BI : CS->body()) {
4646 case Stmt::IfStmtClass: {
4651 if (const Stmt *Init = IS->getInit()) {
4663 if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
4674 case Stmt::WhileStmtClass: {
4697 case Stmt::DoStmtClass: {
4714 case Stmt::ForStmtClass: {
4753 case Stmt::CXXForRangeStmtClass: {
4828 case Stmt::SwitchStmtClass:
4831 case Stmt::ContinueStmtClass:
4834 case Stmt::BreakStmtClass:
4837 case Stmt::LabelStmtClass:
4840 case Stmt::AttributedStmtClass:
4846 case Stmt::CaseStmtClass:
4847 case Stmt::DefaultStmtClass:
4849 case Stmt::CXXTryStmtClass:
4887 const Stmt *Body) {
5474 ArrayRef<const Expr*> Args, const Stmt *Body,
5833 const Stmt *Body = DD->getBody(Definition);
6694 bool VisitStmt(const Stmt *) {
6989 Stmt *Body = FD->getBody(Definition);
tools/clang/lib/AST/ExprObjC.cpp 370 Stmt::child_range ObjCMessageExpr::children() {
371 Stmt **begin;
380 Stmt::const_child_range ObjCMessageExpr::children() const {
tools/clang/lib/AST/ExternalASTSource.cpp 94 Stmt *ExternalASTSource::GetExternalDeclStmt(uint64_t Offset) {
tools/clang/lib/AST/Interp/ByteCodeEmitter.h 58 bool bail(const Stmt *S) { return bail(S->getBeginLoc()); }
tools/clang/lib/AST/Interp/ByteCodeGenError.h 24 ByteCodeGenError(const Stmt *S) : ByteCodeGenError(S->getBeginLoc()) {}
tools/clang/lib/AST/Interp/ByteCodeStmtGen.cpp 103 if (auto *Body = F->getBody())
115 bool ByteCodeStmtGen<Emitter>::visitStmt(const Stmt *S) {
117 case Stmt::CompoundStmtClass:
119 case Stmt::DeclStmtClass:
121 case Stmt::ReturnStmtClass:
123 case Stmt::IfStmtClass:
125 case Stmt::NullStmtClass:
139 for (auto *InnerStmt : CompoundStmt->body())
204 if (const Stmt *Else = IS->getElse()) {
tools/clang/lib/AST/Interp/ByteCodeStmtGen.h 60 bool visitStmt(const Stmt *S);
tools/clang/lib/AST/Interp/EvalEmitter.h 60 bool bail(const Stmt *S) { return bail(S->getBeginLoc()); }
tools/clang/lib/AST/Interp/Source.cpp 18 if (const Stmt *S = asStmt())
26 if (auto *S = Source.dyn_cast<const Stmt *>())
tools/clang/lib/AST/Interp/Source.h 84 SourceInfo(const Stmt *E) : Source(E) {}
89 const Stmt *asStmt() const { return Source.dyn_cast<const Stmt *>(); }
89 const Stmt *asStmt() const { return Source.dyn_cast<const Stmt *>(); }
96 llvm::PointerUnion<const Decl *, const Stmt *> Source;
tools/clang/lib/AST/JSONNodeDumper.cpp 45 void JSONNodeDumper::Visit(const Stmt *S) {
tools/clang/lib/AST/ODRHash.cpp 24 void ODRHash::AddStmt(const Stmt *S) {
248 void AddStmt(const Stmt *S) {
577 auto *Body = Function->getBody();
661 void AddStmt(Stmt *S) {
tools/clang/lib/AST/OpenMPClause.cpp 224 static Stmt **getAddrOfExprAsWritten(Stmt *S) {
224 static Stmt **getAddrOfExprAsWritten(Stmt *S) {
236 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
242 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
248 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
254 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
260 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt()))
357 ArrayRef<Expr *> InitVL, Stmt *PreInit) {
405 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, Stmt *PreInit,
478 Stmt *PreInit, Expr *PostUpdate) {
651 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
704 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit,
767 ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) {
tools/clang/lib/AST/ParentMap.cpp 22 typedef llvm::DenseMap<Stmt*, Stmt*> MapTy;
22 typedef llvm::DenseMap<Stmt*, Stmt*> MapTy;
29 static void BuildParentMap(MapTy& M, Stmt* S,
35 case Stmt::PseudoObjectExprClass: {
41 for (Stmt *SubStmt : S->children())
55 case Stmt::BinaryConditionalOperatorClass: {
73 case Stmt::OpaqueValueExprClass: {
86 case Stmt::CapturedStmtClass:
87 for (Stmt *SubStmt : S->children()) {
93 if (Stmt *SubStmt = cast<CapturedStmt>(S)->getCapturedStmt()) {
99 for (Stmt *SubStmt : S->children()) {
109 ParentMap::ParentMap(Stmt *S) : Impl(nullptr) {
121 void ParentMap::addStmt(Stmt* S) {
127 void ParentMap::setParent(const Stmt *S, const Stmt *Parent) {
127 void ParentMap::setParent(const Stmt *S, const Stmt *Parent) {
134 Stmt* ParentMap::getParent(Stmt* S) const {
134 Stmt* ParentMap::getParent(Stmt* S) const {
140 Stmt *ParentMap::getParentIgnoreParens(Stmt *S) const {
140 Stmt *ParentMap::getParentIgnoreParens(Stmt *S) const {
145 Stmt *ParentMap::getParentIgnoreParenCasts(Stmt *S) const {
145 Stmt *ParentMap::getParentIgnoreParenCasts(Stmt *S) const {
154 Stmt *ParentMap::getParentIgnoreParenImpCasts(Stmt *S) const {
154 Stmt *ParentMap::getParentIgnoreParenImpCasts(Stmt *S) const {
162 Stmt *ParentMap::getOuterParenParent(Stmt *S) const {
162 Stmt *ParentMap::getOuterParenParent(Stmt *S) const {
163 Stmt *Paren = nullptr;
172 Stmt *P = getParent(E);
173 Stmt *DirectChild = E;
188 case Stmt::DeclStmtClass:
190 case Stmt::BinaryOperatorClass: {
196 case Stmt::ForStmtClass:
198 case Stmt::WhileStmtClass:
200 case Stmt::DoStmtClass:
202 case Stmt::IfStmtClass:
204 case Stmt::IndirectGotoStmtClass:
206 case Stmt::SwitchStmtClass:
208 case Stmt::ObjCForCollectionStmtClass:
210 case Stmt::ReturnStmtClass:
tools/clang/lib/AST/Stmt.cpp 52 } StmtClassInfo[Stmt::lastStmtConstant+1];
54 static StmtClassNameTable &getStmtInfoTableEntry(Stmt::StmtClass E) {
99 getStmtInfoTableEntry(Stmt::NullStmtClass);
103 for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
109 for (int i = 0; i != Stmt::lastStmtConstant+1; i++) {
133 Stmt *Stmt::IgnoreContainers(bool IgnoreCaptured) {
134 Stmt *S = this;
155 const Stmt *Stmt::stripLabelLikeStatements() const {
156 const Stmt *S = this;
179 typedef Stmt::child_range children_t();
223 Stmt::child_range Stmt::children() {
225 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
244 SourceRange getSourceRangeImpl(const Stmt *stmt,
254 SourceRange getSourceRangeImpl(const Stmt *stmt,
264 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
277 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
289 case Stmt::NoStmtClass: llvm_unreachable("statement without class");
300 return Context.getAllocator().identifyKnownAlignedObject<Stmt>(this);
303 CompoundStmt::CompoundStmt(ArrayRef<Stmt *> Stmts, SourceLocation LB,
311 void CompoundStmt::setStmts(ArrayRef<Stmt *> Stmts) {
318 CompoundStmt *CompoundStmt::Create(const ASTContext &C, ArrayRef<Stmt *> Stmts,
321 C.Allocate(totalSizeToAlloc<Stmt *>(Stmts.size()), alignof(CompoundStmt));
328 C.Allocate(totalSizeToAlloc<Stmt *>(NumStmts), alignof(CompoundStmt));
335 const Stmt *S = this;
357 Stmt *SubStmt) {
475 Stmt **Exprs,
494 this->Exprs = new (C) Stmt*[NumExprs];
768 Exprs = new (C) Stmt*[NumExprs];
809 Exprs = new (C) Stmt*[exprs.size()];
830 Stmt *Init, VarDecl *Var, Expr *Cond, Stmt *Then,
830 Stmt *Init, VarDecl *Var, Expr *Cond, Stmt *Then,
831 SourceLocation EL, Stmt *Else)
864 bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
865 Stmt *Then, SourceLocation EL, Stmt *Else) {
865 Stmt *Then, SourceLocation EL, Stmt *Else) {
870 totalSizeToAlloc<Stmt *, SourceLocation>(
880 totalSizeToAlloc<Stmt *, SourceLocation>(
898 getTrailingObjects<Stmt *>()[varOffset()] = nullptr;
903 getTrailingObjects<Stmt *>()[varOffset()] = new (Ctx)
911 ForStmt::ForStmt(const ASTContext &C, Stmt *Init, Expr *Cond, VarDecl *condVar,
912 Expr *Inc, Stmt *Body, SourceLocation FL, SourceLocation LP,
943 SwitchStmt::SwitchStmt(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
969 SwitchStmt *SwitchStmt::Create(const ASTContext &Ctx, Stmt *Init, VarDecl *Var,
974 totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),
982 totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasInit + HasVar),
999 getTrailingObjects<Stmt *>()[varOffset()] = nullptr;
1004 getTrailingObjects<Stmt *>()[varOffset()] = new (Ctx)
1009 Stmt *Body, SourceLocation WL)
1028 Stmt *Body, SourceLocation WL) {
1031 Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),
1038 Ctx.Allocate(totalSizeToAlloc<Stmt *>(NumMandatoryStmtPtr + HasVar),
1055 getTrailingObjects<Stmt *>()[varOffset()] = nullptr;
1060 getTrailingObjects<Stmt *>()[varOffset()] = new (Ctx)
1107 totalSizeToAlloc<Stmt *, SourceLocation>(
1116 totalSizeToAlloc<Stmt *, SourceLocation>(
1122 SEHTryStmt::SEHTryStmt(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock,
1123 Stmt *Handler)
1130 SourceLocation TryLoc, Stmt *TryBlock,
1131 Stmt *Handler) {
1143 SEHExceptStmt::SEHExceptStmt(SourceLocation Loc, Expr *FilterExpr, Stmt *Block)
1150 Expr *FilterExpr, Stmt *Block) {
1154 SEHFinallyStmt::SEHFinallyStmt(SourceLocation Loc, Stmt *Block)
1158 Stmt *Block) {
1201 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1211 CapturedStmt::CapturedStmt(Stmt *S, CapturedRegionKind Kind,
1223 Stmt **Stored = getStoredStmts();
1241 CapturedStmt *CapturedStmt::Create(const ASTContext &Context, Stmt *S,
1258 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (Captures.size() + 1);
1271 unsigned Size = sizeof(CapturedStmt) + sizeof(Stmt *) * (NumCaptures + 1);
1282 Stmt::child_range CapturedStmt::children() {
1287 Stmt::const_child_range CapturedStmt::children() const {
tools/clang/lib/AST/StmtCXX.cpp 26 Stmt *tryBlock, ArrayRef<Stmt *> handlers) {
26 Stmt *tryBlock, ArrayRef<Stmt *> handlers) {
27 const size_t Size = totalSizeToAlloc<Stmt *>(handlers.size() + 1);
34 const size_t Size = totalSizeToAlloc<Stmt *>(numHandlers + 1);
39 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
40 ArrayRef<Stmt *> handlers)
42 Stmt **Stmts = getStmts();
47 CXXForRangeStmt::CXXForRangeStmt(Stmt *Init, DeclStmt *Range,
50 Stmt *Body, SourceLocation FL,
88 std::size_t Size = totalSizeToAlloc<Stmt *>(
97 std::size_t Size = totalSizeToAlloc<Stmt *>(
111 Stmt **SubStmts = getStoredStmts();
tools/clang/lib/AST/StmtObjC.cpp 20 ObjCForCollectionStmt::ObjCForCollectionStmt(Stmt *Elem, Expr *Collect,
21 Stmt *Body, SourceLocation FCL,
31 ObjCAtTryStmt::ObjCAtTryStmt(SourceLocation atTryLoc, Stmt *atTryStmt,
32 Stmt **CatchStmts, unsigned NumCatchStmts,
33 Stmt *atFinallyStmt)
36 Stmt **Stmts = getStmts();
46 SourceLocation atTryLoc, Stmt *atTryStmt,
47 Stmt **CatchStmts, unsigned NumCatchStmts,
48 Stmt *atFinallyStmt) {
51 (1 + NumCatchStmts + (atFinallyStmt != nullptr)) * sizeof(Stmt *);
61 sizeof(ObjCAtTryStmt) + (1 + NumCatchStmts + HasFinally) * sizeof(Stmt *);
tools/clang/lib/AST/StmtOpenMP.cpp 36 const Stmt *OMPExecutableDirective::getStructuredBlock() const {
96 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
100 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
115 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
122 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
127 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
158 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
165 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
170 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
210 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
217 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
223 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
263 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
269 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
273 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
288 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
295 Stmt *AssociatedStmt,
297 unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
298 void *Mem = C.Allocate(Size + sizeof(Stmt *));
307 unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
308 void *Mem = C.Allocate(Size + sizeof(Stmt *));
316 Stmt *AssociatedStmt) {
320 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
334 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
341 Stmt *AssociatedStmt) {
342 unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
343 void *Mem = C.Allocate(Size + sizeof(Stmt *));
351 unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
352 void *Mem = C.Allocate(Size + sizeof(Stmt *));
359 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
363 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
377 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
383 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
388 sizeof(Stmt *) *
428 sizeof(Stmt *) *
435 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
441 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
481 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
487 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
491 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
506 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
513 Stmt *AssociatedStmt, bool HasCancel) {
516 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
530 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
579 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) {
582 alignof(Stmt *));
583 void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
597 alignof(Stmt *));
598 void *Mem = C.Allocate(Size + sizeof(Stmt *) + sizeof(Expr *));
606 llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
617 llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
628 alignof(Stmt *));
642 alignof(Stmt *));
673 Stmt *AssociatedStmt) {
677 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
691 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
697 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
702 5 * sizeof(Stmt *));
722 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
730 Stmt *AssociatedStmt) {
734 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
748 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
754 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
758 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
772 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
778 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
784 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
825 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_target_parallel_for));
831 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
834 sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
847 sizeof(OMPClause *) * N + sizeof(Stmt *));
853 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
856 sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
869 sizeof(OMPClause *) * N + sizeof(Stmt *));
875 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
878 sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
891 sizeof(OMPClause *) * N + sizeof(Stmt *));
899 Stmt *AssociatedStmt) {
903 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
917 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
923 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
929 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
969 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
975 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
980 sizeof(Stmt *) *
1019 sizeof(Stmt *) *
1026 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1032 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop));
1072 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_master_taskloop));
1078 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1084 sizeof(Stmt *) *
1125 sizeof(Stmt *) *
1132 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1138 sizeof(Stmt *) *
1180 sizeof(Stmt *) *
1187 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1192 sizeof(Stmt *) *
1231 sizeof(Stmt *) *
1238 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1242 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1256 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1262 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1268 sizeof(Stmt *) *
1325 sizeof(Stmt *) *
1333 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1339 sizeof(Stmt *) *
1395 sizeof(Stmt *) *
1403 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1409 sizeof(Stmt *) *
1450 sizeof(Stmt *) *
1457 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1463 sizeof(Stmt *) *
1506 sizeof(Stmt *) *
1515 Stmt *AssociatedStmt, const HelperExprs &Exprs) {
1519 sizeof(Stmt *) *
1550 sizeof(Stmt *) *
1557 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1563 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
1603 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_teams_distribute));
1609 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1615 sizeof(Stmt *) *
1656 sizeof(Stmt *) *
1664 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1670 sizeof(Stmt *) *
1727 sizeof(Stmt *) *
1737 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1743 sizeof(Stmt *) *
1800 sizeof(Stmt *) *
1808 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
1812 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
1826 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
1832 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1838 sizeof(Stmt *) *
1881 sizeof(Stmt *) *
1889 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1896 sizeof(Stmt *) *
1955 sizeof(Stmt *) *
1965 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
1972 sizeof(Stmt *) *
2029 sizeof(Stmt *) *
2039 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
2045 sizeof(Stmt *) *
2088 sizeof(Stmt *) *
tools/clang/lib/AST/StmtPrinter.cpp 83 void PrintStmt(Stmt *S) {
87 void PrintStmt(Stmt *S, int SubIndent) {
102 void PrintInitStmt(Stmt *S, unsigned PrefixWidth) {
113 void PrintControlledStmt(Stmt *S) {
148 void Visit(Stmt* S) {
154 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
180 for (auto *I : Node->body())
261 if (Stmt *Else = If->getElse()) {
tools/clang/lib/AST/StmtProfile.cpp 38 void VisitStmt(const Stmt *S);
40 virtual void HandleStmtClass(Stmt::StmtClass SC) = 0;
84 void HandleStmtClass(Stmt::StmtClass SC) override {
171 void HandleStmtClass(Stmt::StmtClass SC) override {
172 if (SC == Stmt::UnresolvedLookupExprClass) {
175 ID.AddInteger(Stmt::DeclRefExprClass);
217 void StmtProfiler::VisitStmt(const Stmt *S) {
222 for (const Stmt *SubStmt : S->children()) {
1327 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
1345 return Stmt::UnaryOperatorClass;
1349 return Stmt::BinaryOperatorClass;
1354 return Stmt::UnaryOperatorClass;
1358 return Stmt::BinaryOperatorClass;
1363 return Stmt::UnaryOperatorClass;
1367 return Stmt::BinaryOperatorClass;
1371 return Stmt::BinaryOperatorClass;
1375 return Stmt::BinaryOperatorClass;
1379 return Stmt::BinaryOperatorClass;
1384 return Stmt::UnaryOperatorClass;
1388 return Stmt::BinaryOperatorClass;
1392 return Stmt::BinaryOperatorClass;
1396 return Stmt::UnaryOperatorClass;
1400 return Stmt::UnaryOperatorClass;
1404 return Stmt::BinaryOperatorClass;
1408 return Stmt::BinaryOperatorClass;
1412 return Stmt::BinaryOperatorClass;
1416 return Stmt::CompoundAssignOperatorClass;
1420 return Stmt::CompoundAssignOperatorClass;
1424 return Stmt::CompoundAssignOperatorClass;
1428 return Stmt::CompoundAssignOperatorClass;
1432 return Stmt::CompoundAssignOperatorClass;
1436 return Stmt::CompoundAssignOperatorClass;
1440 return Stmt::CompoundAssignOperatorClass;
1444 return Stmt::CompoundAssignOperatorClass;
1448 return Stmt::BinaryOperatorClass;
1452 return Stmt::BinaryOperatorClass;
1456 return Stmt::CompoundAssignOperatorClass;
1460 return Stmt::CompoundAssignOperatorClass;
1464 return Stmt::BinaryOperatorClass;
1468 return Stmt::BinaryOperatorClass;
1472 return Stmt::BinaryOperatorClass;
1476 return Stmt::BinaryOperatorClass;
1484 return Stmt::BinaryOperatorClass;
1488 return Stmt::BinaryOperatorClass;
1493 return Stmt::UnaryOperatorClass;
1498 return Stmt::UnaryOperatorClass;
1502 return Stmt::BinaryOperatorClass;
1506 return Stmt::BinaryOperatorClass;
1509 return Stmt::ArraySubscriptExprClass;
1513 return Stmt::UnaryOperatorClass;
1540 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp);
1545 if (SC == Stmt::UnaryOperatorClass)
1547 else if (SC == Stmt::BinaryOperatorClass ||
1548 SC == Stmt::CompoundAssignOperatorClass)
tools/clang/lib/AST/StmtViz.cpp 34 static std::string getNodeLabel(const Stmt* Node, const Stmt* Graph) {
34 static std::string getNodeLabel(const Stmt* Node, const Stmt* Graph) {
tools/clang/lib/AST/TextNodeDumper.cpp 111 void TextNodeDumper::Visit(const Stmt *Node) {
tools/clang/lib/ASTMatchers/ASTMatchFinder.cpp 108 else if (const Stmt *S = DynNode.get<Stmt>())
108 else if (const Stmt *S = DynNode.get<Stmt>())
139 bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr) {
145 Stmt *StmtToTraverse = StmtNode;
227 bool baseTraverse(const Stmt &StmtNode) {
254 bool match(const T &Node) {
281 bool traverse(const T &Node) {
282 static_assert(IsBaseType<T>::value,
384 bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr);
488 } else if (auto *N = Node.get<Stmt>()) {
505 template <typename T> void match(const T &Node) {
604 void matchDispatch(const Stmt *Node) {
922 bool MatchASTVisitor::TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue) {
1061 } else if (NodeMatch.canConvertTo<Stmt>()) {
1062 addMatcher(NodeMatch.convertTo<Stmt>(), Action);
tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp 550 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAutoreleasePoolStmt>
593 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryExprOrTypeTraitExpr>
614 const internal::VariadicAllOfMatcher<Stmt> stmt;
615 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclStmt> declStmt;
616 const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
617 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedMemberExpr>
619 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDependentScopeMemberExpr>
621 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
622 const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
623 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXMemberCallExpr>
625 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCMessageExpr>
644 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtThrowStmt>
646 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtTryStmt> objcTryStmt;
647 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtCatchStmt>
649 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCAtFinallyStmt>
651 const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
653 const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
654 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStdInitializerListExpr>
656 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitValueInitExpr>
658 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenListExpr> parenListExpr;
659 const internal::VariadicDynCastAllOfMatcher<Stmt, SubstNonTypeTemplateParmExpr>
664 const internal::VariadicDynCastAllOfMatcher<Stmt, UnresolvedLookupExpr>
670 const internal::VariadicDynCastAllOfMatcher<Stmt, ConstantExpr> constantExpr;
671 const internal::VariadicDynCastAllOfMatcher<Stmt, ParenExpr> parenExpr;
672 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstructExpr>
674 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXUnresolvedConstructExpr>
676 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> cxxThisExpr;
677 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBindTemporaryExpr>
679 const internal::VariadicDynCastAllOfMatcher<Stmt, MaterializeTemporaryExpr>
681 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> cxxNewExpr;
682 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> cxxDeleteExpr;
683 const internal::VariadicDynCastAllOfMatcher<Stmt, ArraySubscriptExpr>
685 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDefaultArgExpr>
687 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXOperatorCallExpr>
689 const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
690 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr;
691 const internal::VariadicDynCastAllOfMatcher<Stmt, ObjCIvarRefExpr> objcIvarRefExpr;
692 const internal::VariadicDynCastAllOfMatcher<Stmt, BlockExpr> blockExpr;
693 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
694 const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
695 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt>
697 const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
698 const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
699 const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
700 const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt;
701 const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
702 const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
703 const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
704 const internal::VariadicDynCastAllOfMatcher<Stmt, AddrLabelExpr> addrLabelExpr;
705 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
706 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
707 const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
708 const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt;
709 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt;
710 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> cxxCatchStmt;
711 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> cxxTryStmt;
712 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> cxxThrowExpr;
713 const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
714 const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
715 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXBoolLiteralExpr>
717 const internal::VariadicDynCastAllOfMatcher<Stmt, StringLiteral> stringLiteral;
718 const internal::VariadicDynCastAllOfMatcher<Stmt, CharacterLiteral>
720 const internal::VariadicDynCastAllOfMatcher<Stmt, IntegerLiteral>
722 const internal::VariadicDynCastAllOfMatcher<Stmt, FloatingLiteral> floatLiteral;
723 const internal::VariadicDynCastAllOfMatcher<Stmt, ImaginaryLiteral> imaginaryLiteral;
724 const internal::VariadicDynCastAllOfMatcher<Stmt, UserDefinedLiteral>
726 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundLiteralExpr>
728 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNullPtrLiteralExpr>
730 const internal::VariadicDynCastAllOfMatcher<Stmt, ChooseExpr> chooseExpr;
731 const internal::VariadicDynCastAllOfMatcher<Stmt, GNUNullExpr> gnuNullExpr;
732 const internal::VariadicDynCastAllOfMatcher<Stmt, AtomicExpr> atomicExpr;
733 const internal::VariadicDynCastAllOfMatcher<Stmt, StmtExpr> stmtExpr;
734 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryOperator>
736 const internal::VariadicDynCastAllOfMatcher<Stmt, UnaryOperator> unaryOperator;
737 const internal::VariadicDynCastAllOfMatcher<Stmt, ConditionalOperator>
739 const internal::VariadicDynCastAllOfMatcher<Stmt, BinaryConditionalOperator>
741 const internal::VariadicDynCastAllOfMatcher<Stmt, OpaqueValueExpr>
745 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXReinterpretCastExpr>
747 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXStaticCastExpr>
749 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDynamicCastExpr>
751 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXConstCastExpr>
753 const internal::VariadicDynCastAllOfMatcher<Stmt, CStyleCastExpr>
755 const internal::VariadicDynCastAllOfMatcher<Stmt, ExplicitCastExpr>
757 const internal::VariadicDynCastAllOfMatcher<Stmt, ImplicitCastExpr>
759 const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
760 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
762 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
764 const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
766 const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
805 const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
848 const internal::VariadicDynCastAllOfMatcher<Stmt, OMPExecutableDirective>
tools/clang/lib/ASTMatchers/Dynamic/Marshallers.h 75 return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
78 static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
79 return Value.getMatcher().getTypedMatcher<T>();
83 return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
361 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
368 RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
466 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
778 ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT>
tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp 562 ASTNodeKind::getFromNodeKind<Stmt>(),
tools/clang/lib/Analysis/AnalysisDeclContext.cpp 93 Stmt *AnalysisDeclContext::getBody(bool &IsAutosynthesized) const {
96 Stmt *Body = FD->getBody();
100 Stmt *SynthesizedBody = Manager->getBodyFarm().getBody(FD);
109 Stmt *Body = MD->getBody();
111 Stmt *SynthesizedBody = Manager->getBodyFarm().getBody(MD);
126 Stmt *AnalysisDeclContext::getBody() const {
139 Stmt *Body = getBody(Tmp);
180 void AnalysisDeclContext::registerForcedBlockExpression(const Stmt *stmt) {
190 AnalysisDeclContext::getBlockForRegisteredExpression(const Stmt *stmt) {
312 AnalysisDeclContext::getStackFrame(LocationContext const *Parent, const Stmt *S,
384 const DATA *d) {
399 AnalysisDeclContext *ctx, const LocationContext *parent, const Stmt *s,
416 const Stmt *s) {
417 return getLocationContext<ScopeContext, Stmt>(ctx, parent, s);
496 if (const Stmt *S = cast<StackFrameContext>(LCtx)->getCallSite()) {
543 if (const Stmt *S = cast<StackFrameContext>(LCtx)->getCallSite()) {
592 void VisitStmt(Stmt *S) {
593 for (auto *Child : S->children())
tools/clang/lib/Analysis/BodyFarm.cpp 61 CompoundStmt *makeCompound(ArrayRef<Stmt*>);
134 CompoundStmt *ASTMaker::makeCompound(ArrayRef<Stmt *> Stmts) {
247 typedef Stmt *(*FunctionFarmer)(ASTContext &C, const FunctionDecl *D);
317 static Stmt *create_call_once(ASTContext &C, const FunctionDecl *D) {
477 static Stmt *create_dispatch_once(ASTContext &C, const FunctionDecl *D) {
535 Stmt *Stmts[] = { B, CE };
560 static Stmt *create_dispatch_sync(ASTContext &C, const FunctionDecl *D) {
586 static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
636 Stmt *Stmts[2];
655 Stmt *Else = M.makeReturn(RetVal);
667 Stmt *BodyFarm::getBody(const FunctionDecl *D) {
668 Optional<Stmt *> &Val = Bodies[D];
739 static Stmt *createObjCPropertyGetter(ASTContext &Ctx,
800 Stmt *BodyFarm::getBody(const ObjCMethodDecl *D) {
812 Optional<Stmt *> &Val = Bodies[D];
tools/clang/lib/Analysis/CFG.cpp 191 const Stmt *stmt) const;
414 llvm::SmallVector<Stmt *, 12> childrenBuf;
415 ArrayRef<Stmt *> children;
418 reverse_children(Stmt *S);
420 using iterator = ArrayRef<Stmt *>::reverse_iterator;
428 reverse_children::reverse_children(Stmt *S) {
435 case Stmt::InitListExprClass: {
446 for (Stmt *SubStmt : S->children())
524 const Stmt *lastLookup = nullptr;
539 std::unique_ptr<CFG> buildCFG(const Decl *D, Stmt *Statement);
541 bool alwaysAdd(const Stmt *stmt);
586 Stmt *Term,
600 CFGBlock *VisitReturnStmt(Stmt *S);
612 CFGBlock *Visit(Stmt *S, AddStmtChoice asc = AddStmtChoice::NotAlwaysAdd,
614 CFGBlock *VisitStmt(Stmt *S, AddStmtChoice asc);
615 CFGBlock *VisitChildren(Stmt *S);
621 const Stmt *S) {
684 CFGBlock *VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
686 CFGBlock *VisitChildrenForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
716 Stmt *Child);
746 CFGBlock *addStmt(Stmt *S) {
751 void addLoopExit(const Stmt *LoopStmt);
753 LocalScope::const_iterator E, Stmt *S);
755 LocalScope::const_iterator E, Stmt *S);
757 LocalScope::const_iterator E, Stmt *S);
760 Stmt *S);
763 LocalScope::const_iterator E, Stmt *S);
768 void addLocalScopeForStmt(Stmt *S);
773 void addLocalScopeAndDtors(Stmt *S);
790 void appendStmt(CFGBlock *B, const Stmt *S) {
858 void appendAutomaticObjDtor(CFGBlock *B, VarDecl *VD, Stmt *S) {
862 void appendLifetimeEnds(CFGBlock *B, VarDecl *VD, Stmt *S) {
866 void appendLoopExit(CFGBlock *B, const Stmt *LoopStmt) {
898 void appendScopeBegin(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
903 void prependScopeBegin(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
908 void appendScopeEnd(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
913 void prependScopeEnd(CFGBlock *B, const VarDecl *VD, const Stmt *S) {
1288 const Stmt *stmt) const {
1292 bool CFGBuilder::alwaysAdd(const Stmt *stmt) {
1358 const ConstructionContextLayer *Layer, Stmt *Child) {
1371 case Stmt::CXXConstructExprClass:
1372 case Stmt::CXXTemporaryObjectExprClass: {
1385 case Stmt::CallExprClass:
1386 case Stmt::CXXMemberCallExprClass:
1387 case Stmt::CXXOperatorCallExprClass:
1388 case Stmt::UserDefinedLiteralClass:
1389 case Stmt::ObjCMessageExprClass: {
1395 case Stmt::ExprWithCleanupsClass: {
1400 case Stmt::CXXFunctionalCastExprClass: {
1405 case Stmt::ImplicitCastExprClass: {
1418 case Stmt::CXXBindTemporaryExprClass: {
1423 case Stmt::MaterializeTemporaryExprClass: {
1435 case Stmt::ConditionalOperatorClass: {
1451 case Stmt::InitListExprClass: {
1479 std::unique_ptr<CFG> CFGBuilder::buildCFG(const Decl *D, Stmt *Statement) {
1668 if (Stmt *Child = Default->getExpr())
1721 void CFGBuilder::addLoopExit(const Stmt *LoopStmt){
1729 LocalScope::const_iterator E, Stmt *S) {
1752 Stmt *S) {
1764 LocalScope::const_iterator E, Stmt *S) {
1809 LocalScope::const_iterator E, Stmt *S) {
1828 LocalScope::const_iterator E, Stmt *S) {
1937 void CFGBuilder::addLocalScopeForStmt(Stmt *S) {
1946 for (auto *BI : CS->body()) {
1947 Stmt *SI = BI->stripLabelLikeStatements();
2054 void CFGBuilder::addLocalScopeAndDtors(Stmt *S) {
2120 CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc,
2138 case Stmt::AddrLabelExprClass:
2141 case Stmt::BinaryConditionalOperatorClass:
2144 case Stmt::BinaryOperatorClass:
2147 case Stmt::BlockExprClass:
2150 case Stmt::BreakStmtClass:
2153 case Stmt::CallExprClass:
2154 case Stmt::CXXOperatorCallExprClass:
2155 case Stmt::CXXMemberCallExprClass:
2156 case Stmt::UserDefinedLiteralClass:
2159 case Stmt::CaseStmtClass:
2162 case Stmt::ChooseExprClass:
2165 case Stmt::CompoundStmtClass:
2168 case Stmt::ConditionalOperatorClass:
2171 case Stmt::ContinueStmtClass:
2174 case Stmt::CXXCatchStmtClass:
2177 case Stmt::ExprWithCleanupsClass:
2181 case Stmt::CXXDefaultArgExprClass:
2182 case Stmt::CXXDefaultInitExprClass:
2194 case Stmt::CXXBindTemporaryExprClass:
2197 case Stmt::CXXConstructExprClass:
2200 case Stmt::CXXNewExprClass:
2203 case Stmt::CXXDeleteExprClass:
2206 case Stmt::CXXFunctionalCastExprClass:
2209 case Stmt::CXXTemporaryObjectExprClass:
2212 case Stmt::CXXThrowExprClass:
2215 case Stmt::CXXTryStmtClass:
2218 case Stmt::CXXForRangeStmtClass:
2221 case Stmt::DeclStmtClass:
2224 case Stmt::DefaultStmtClass:
2227 case Stmt::DoStmtClass:
2230 case Stmt::ForStmtClass:
2233 case Stmt::GotoStmtClass:
2236 case Stmt::GCCAsmStmtClass:
2239 case Stmt::IfStmtClass:
2242 case Stmt::ImplicitCastExprClass:
2245 case Stmt::ConstantExprClass:
2248 case Stmt::IndirectGotoStmtClass:
2251 case Stmt::LabelStmtClass:
2254 case Stmt::LambdaExprClass:
2257 case Stmt::MaterializeTemporaryExprClass:
2261 case Stmt::MemberExprClass:
2264 case Stmt::NullStmtClass:
2267 case Stmt::ObjCAtCatchStmtClass:
2270 case Stmt::ObjCAutoreleasePoolStmtClass:
2273 case Stmt::ObjCAtSynchronizedStmtClass:
2276 case Stmt::ObjCAtThrowStmtClass:
2279 case Stmt::ObjCAtTryStmtClass:
2282 case Stmt::ObjCForCollectionStmtClass:
2285 case Stmt::ObjCMessageExprClass:
2288 case Stmt::OpaqueValueExprClass:
2291 case Stmt::PseudoObjectExprClass:
2294 case Stmt::ReturnStmtClass:
2295 case Stmt::CoreturnStmtClass:
2298 case Stmt::SEHExceptStmtClass:
2301 case Stmt::SEHFinallyStmtClass:
2304 case Stmt::SEHLeaveStmtClass:
2307 case Stmt::SEHTryStmtClass:
2310 case Stmt::UnaryExprOrTypeTraitExprClass:
2314 case Stmt::StmtExprClass:
2317 case Stmt::SwitchStmtClass:
2320 case Stmt::UnaryOperatorClass:
2323 case Stmt::WhileStmtClass:
2328 CFGBlock *CFGBuilder::VisitStmt(Stmt *S, AddStmtChoice asc) {
2338 CFGBlock *CFGBuilder::VisitChildren(Stmt *S) {
2346 if (Stmt *Child = *I)
2391 Stmt *Term,
2915 if (Stmt *Init = I->getInit())
2936 if (Stmt *Else = I->getElse()) {
2961 Stmt *Then = I->getThen();
3028 if (Stmt *Init = I->getInit()) {
3036 CFGBlock *CFGBuilder::VisitReturnStmt(Stmt *S) {
3292 if (Stmt *Init = F->getInit())
3334 if (Stmt *I = F->getInc()) {
3446 if (Stmt *I = F->getInit()) {
3861 if (Stmt *C = D->getCond()) {
3999 if (Stmt *Init = Terminator->getInit())
4092 if (Stmt *Init = Terminator->getInit()) {
4141 if (Stmt *Sub = CS->getSubStmt()) {
4344 if (Stmt *Range = S->getRangeStmt())
4346 if (Stmt *Begin = S->getBeginStmt())
4348 if (Stmt *End = S->getEndStmt())
4596 CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
4609 case Stmt::InitListExprClass:
4612 case Stmt::BinaryOperatorClass:
4617 case Stmt::CXXBindTemporaryExprClass:
4621 case Stmt::BinaryConditionalOperatorClass:
4622 case Stmt::ConditionalOperatorClass:
4626 case Stmt::ImplicitCastExprClass:
4631 case Stmt::CXXFunctionalCastExprClass:
4636 case Stmt::ConstantExprClass:
4640 case Stmt::ParenExprClass:
4644 case Stmt::MaterializeTemporaryExprClass: {
4662 case Stmt::BlockExprClass:
4667 case Stmt::LambdaExprClass: {
4682 case Stmt::StmtExprClass:
4687 case Stmt::CXXDefaultArgExprClass:
4691 case Stmt::CXXDefaultInitExprClass:
4697 CFGBlock *CFGBuilder::VisitChildrenForTemporaryDtors(Stmt *E,
4710 for (Stmt *Child : E->children())
4857 SmallVector<Stmt *, 8> Used(
4859 for (Stmt *S : llvm::reverse(Used)) {
4867 Stmt *S = CS->getCapturedStmt();
4897 std::unique_ptr<CFG> CFG::buildCFG(const Decl *D, Stmt *Statement,
5046 const Stmt *L = To->getLabel();
5063 using StmtMapTy = llvm::DenseMap<const Stmt *, std::pair<unsigned, unsigned>>;
5082 const Stmt *stmt= SE->getStmt();
5087 case Stmt::DeclStmtClass:
5090 case Stmt::IfStmtClass: {
5096 case Stmt::ForStmtClass: {
5102 case Stmt::WhileStmtClass: {
5109 case Stmt::SwitchStmtClass: {
5116 case Stmt::CXXCatchStmtClass: {
5137 bool handledStmt(Stmt *S, raw_ostream &OS) override {
5183 if (Stmt *C = I->getCond())
5188 void VisitStmt(Stmt *Terminator) {
5202 if (Stmt *C = F->getCond())
5212 if (Stmt *C = W->getCond())
5218 if (Stmt *C = D->getCond())
5236 if (Stmt *Cond = C->getCond())
5243 if (Stmt *Cond = C->getCond())
5250 if (Stmt *T = I->getTarget())
5322 SmallVector<const Stmt *, 3> Stmts;
5381 if (const Stmt *BTE = ACC->getCXXBindTemporaryExpr()) {
5413 const Stmt *S = CS.getStmt();
5526 Helper.handledStmt(cast<Stmt>(DelExpr->getArgument()), OS);
5585 if (Stmt *Label = const_cast<Stmt*>(B.getLabel())) {
5886 const Stmt *Cond = StmtElem->getStmt();
5895 Stmt *CFGBlock::getTerminatorCondition(bool StripParens) {
5896 Stmt *Terminator = getTerminatorStmt();
5906 case Stmt::CXXForRangeStmtClass:
5910 case Stmt::ForStmtClass:
5914 case Stmt::WhileStmtClass:
5918 case Stmt::DoStmtClass:
5922 case Stmt::IfStmtClass:
5926 case Stmt::ChooseExprClass:
5930 case Stmt::IndirectGotoStmtClass:
5934 case Stmt::SwitchStmtClass:
5938 case Stmt::BinaryConditionalOperatorClass:
5942 case Stmt::ConditionalOperatorClass:
5946 case Stmt::BinaryOperatorClass: // '&&' and '||'
5950 case Stmt::ObjCForCollectionStmtClass:
tools/clang/lib/Analysis/CFGStmtMap.cpp 21 typedef llvm::DenseMap<const Stmt*, CFGBlock*> SMap;
26 CFGBlock *CFGStmtMap::getBlock(Stmt *S) {
28 Stmt *X = S;
67 if (Stmt *Label = B->getLabel())
73 if (Stmt *Term = B->getTerminatorStmt())
tools/clang/lib/Analysis/CallGraph.cpp 53 void VisitStmt(Stmt *S) { VisitChildren(S); }
131 void VisitChildren(Stmt *S) {
132 for (Stmt *SubStmt : S->children())
182 if (Stmt *Body = D->getBody())
tools/clang/lib/Analysis/CloneDetection.cpp 30 StmtSequence::StmtSequence(const Stmt *Stmt, const Decl *D)
191 CloneTypeIIStmtDataCollector(const Stmt *S, ASTContext &Context,
249 saveHash(const Stmt *S, const Decl *D,
259 for (const Stmt *Child : S->children()) {
319 for (const Stmt *S : Sequence) {
323 for (const Stmt *Child : S->children()) {
447 for (const Stmt *S : Seq) {
454 for (const Stmt *S : Seq.front()->children()) {
526 const Stmt *Mention) {
542 void VariablePattern::addVariables(const Stmt *S) {
556 for (const Stmt *Child : S->children()) {
tools/clang/lib/Analysis/Consumed.cpp 79 if (const Stmt *StmtNode = Block->getTerminatorStmt()) {
460 using MapType = llvm::DenseMap<const Stmt *, PropagationInfo>;
461 using PairType= std::pair<const Stmt *, PropagationInfo>;
tools/clang/lib/Analysis/ExprMutationAnalyzer.cpp 39 const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr>
46 const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt, CXXNoexceptExpr>
49 const ast_matchers::internal::VariadicDynCastAllOfMatcher<Stmt,
85 const Stmt *tryEachMatch(ArrayRef<ast_matchers::BoundNodes> Matches,
89 if (const Stmt *S = (Analyzer->*Finder)(Nodes.getNodeAs<T>(ID)))
97 const Stmt *ExprMutationAnalyzer::findMutation(const Expr *Exp) {
109 const Stmt *ExprMutationAnalyzer::findMutation(const Decl *Dec) {
113 const Stmt *ExprMutationAnalyzer::findPointeeMutation(const Expr *Exp) {
117 const Stmt *ExprMutationAnalyzer::findPointeeMutation(const Decl *Dec) {
121 const Stmt *ExprMutationAnalyzer::findMutationMemoized(
132 if (const Stmt *S = (this->*Finder)(Exp))
139 const Stmt *ExprMutationAnalyzer::tryEachDeclRef(const Decl *Dec,
183 const Stmt *
188 const Stmt *
193 const Stmt *ExprMutationAnalyzer::findExprPointeeMutation(
199 const Stmt *ExprMutationAnalyzer::findDeclPointeeMutation(
205 const Stmt *ExprMutationAnalyzer::findDirectMutation(const Expr *Exp) {
293 return selectFirst<Stmt>("stmt", Matches);
296 const Stmt *ExprMutationAnalyzer::findMemberMutation(const Expr *Exp) {
307 const Stmt *ExprMutationAnalyzer::findArrayElementMutation(const Expr *Exp) {
316 const Stmt *ExprMutationAnalyzer::findCastMutation(const Expr *Exp) {
326 if (const Stmt *S = findExprMutation(Casts))
338 const Stmt *ExprMutationAnalyzer::findRangeLoopMutation(const Expr *Exp) {
350 const Stmt *ExprMutationAnalyzer::findReferenceMutation(const Expr *Exp) {
362 if (const Stmt *S = findExprMutation(Ref))
384 const Stmt *ExprMutationAnalyzer::findFunctionArgMutation(const Expr *Exp) {
445 if (const Stmt *S = InitAnalyzer.findMutation(Parm))
452 const Stmt *
458 if (const Stmt *S = BodyAnalyzer.findMutation(Parm))
tools/clang/lib/Analysis/LiveVariables.cpp 77 llvm::ImmutableSet<const Stmt *>::Factory SSetFact;
82 llvm::DenseMap<const Stmt *, LiveVariables::LivenessValues> stmtsToLiveness;
114 bool LiveVariables::LivenessValues::isLive(const Stmt *S) const {
147 llvm::ImmutableSetRef<const Stmt *>
187 bool LiveVariables::isLive(const Stmt *S, const VarDecl *D) {
191 bool LiveVariables::isLive(const Stmt *Loc, const Stmt *S) {
191 bool LiveVariables::isLive(const Stmt *Loc, const Stmt *S) {
219 void Visit(Stmt *S);
236 static const Stmt *LookThroughStmt(const Stmt *S) {
236 static const Stmt *LookThroughStmt(const Stmt *S) {
253 static void AddLiveStmt(llvm::ImmutableSet<const Stmt *> &Set,
254 llvm::ImmutableSet<const Stmt *>::Factory &F,
255 const Stmt *S) {
259 void TransferFunctions::Visit(Stmt *S) {
274 case Stmt::StmtExprClass: {
279 case Stmt::CXXMemberCallExprClass: {
287 case Stmt::ObjCMessageExprClass: {
295 case Stmt::DeclStmtClass: {
305 case Stmt::PseudoObjectExprClass: {
318 case Stmt::ExprWithCleanupsClass: {
322 case Stmt::CXXBindTemporaryExprClass: {
326 case Stmt::UnaryExprOrTypeTraitExprClass: {
330 case Stmt::IfStmtClass: {
337 case Stmt::WhileStmtClass: {
344 case Stmt::DoStmtClass: {
351 case Stmt::ForStmtClass: {
361 for (Stmt *Child : S->children()) {
439 Stmt *element = OS->getElement();
504 if (const Stmt *term = block->getTerminatorStmt())
521 const Stmt *S = elem.castAs<CFGStmt>().getStmt();
574 const Stmt* stmt = cs->getStmt();
tools/clang/lib/Analysis/PathDiagnostic.cpp 463 const Stmt *S, LocationOrAnalysisDeclContext LAC, bool UseEndOfStatement) {
480 const Stmt *Parent = S;
489 const Stmt *Body = ADC->getBody();
536 if (const Stmt *CallerBody = CallerInfo->getBody())
570 PathDiagnosticLocation::createBegin(const Stmt *S,
578 PathDiagnosticLocation::createEnd(const Stmt *S,
651 const Stmt* S = nullptr;
763 const Stmt *S = asStmt();
767 case Stmt::DeclStmtClass: {
778 case Stmt::IfStmtClass:
779 case Stmt::WhileStmtClass:
780 case Stmt::DoStmtClass:
781 case Stmt::ForStmtClass:
782 case Stmt::ChooseExprClass:
783 case Stmt::IndirectGotoStmtClass:
784 case Stmt::SwitchStmtClass:
785 case Stmt::BinaryConditionalOperatorClass:
786 case Stmt::ConditionalOperatorClass:
787 case Stmt::ObjCForCollectionStmtClass: {
801 if (Stmt *Body = FD->getBody())
1145 if (const Stmt *SLoc = getLocation().getStmtOrNull())
tools/clang/lib/Analysis/ProgramPoint.cpp 21 ProgramPoint ProgramPoint::getProgramPoint(const Stmt *S, ProgramPoint::Kind K,
135 const Stmt *T = E.getSrc()->getTerminatorStmt();
152 if (const Stmt *Label = E.getDst()->getLabel()) {
155 if (const Stmt *LHS = C->getLHS()) {
162 if (const Stmt *RHS = C->getRHS()) {
186 const Stmt *S = castAs<StmtPoint>().getStmt();
tools/clang/lib/Analysis/ReachableCode.cpp 48 static bool isTrivialDoWhile(const CFGBlock *B, const Stmt *S) {
51 if (const Stmt *Term = B->getTerminatorStmt()) {
60 static bool isBuiltinUnreachable(const Stmt *S) {
68 static bool isBuiltinAssumeFalse(const CFGBlock *B, const Stmt *S,
83 static bool isDeadReturn(const CFGBlock *B, const Stmt *S) {
148 static bool isExpandedFromConfigurationMacro(const Stmt *S,
187 static bool isConfigurationValue(const Stmt *S,
213 case Stmt::CallExprClass: {
218 case Stmt::DeclRefExprClass:
220 case Stmt::ObjCBoolLiteralExprClass:
223 case Stmt::CXXBoolLiteralExprClass:
224 case Stmt::IntegerLiteralClass: {
233 case Stmt::MemberExprClass:
235 case Stmt::UnaryExprOrTypeTraitExprClass:
237 case Stmt::BinaryOperatorClass: {
248 case Stmt::UnaryOperatorClass: {
295 if (const Stmt *Term = B->getTerminatorStmt()) {
304 const Stmt *Cond = B->getTerminatorCondition(/* stripParens */ false);
392 typedef SmallVector<std::pair<const CFGBlock *, const Stmt *>, 12>
409 const Stmt *findDeadCode(const CFGBlock *Block);
412 const Stmt *S,
448 static bool isValidDeadStmt(const Stmt *S) {
456 const Stmt *DeadCodeScan::findDeadCode(const clang::CFGBlock *Block) {
459 const Stmt *S = CS->getStmt();
466 const Stmt *S = T.getStmt();
474 static int SrcCmp(const std::pair<const CFGBlock *, const Stmt *> *p1,
475 const std::pair<const CFGBlock *, const Stmt *> *p2) {
498 const Stmt *S = findDeadCode(Block);
545 static SourceLocation GetUnreachableLoc(const Stmt *S,
596 case Stmt::CXXTryStmtClass: {
611 const Stmt *S,
632 if (const Stmt *LoopTarget = B->getLoopTarget()) {
653 const Stmt *TermCond =
tools/clang/lib/Analysis/ThreadSafety.cpp 419 std::vector<std::pair<const Stmt *, Context>> SavedContexts;
460 Context getNextContext(unsigned &CtxIndex, const Stmt *S, Context C) {
522 void saveContext(const Stmt *S, Context C) {
818 if (const Stmt *S = CurrBlock->getTerminatorStmt()) {
1046 const CallExpr* getTrylockCallExpr(const Stmt *Cond, LocalVarContext C,
1424 const CallExpr* ThreadSafetyAnalyzer::getTrylockCallExpr(const Stmt *Cond,
1500 const Stmt *Cond = PredBlock->getTerminatorCondition();
2405 if (const Stmt *Terminator = (*PI)->getTerminatorStmt()) {
2444 const Stmt *Terminator = PrevBlock->getTerminatorStmt();
tools/clang/lib/Analysis/ThreadSafetyCommon.cpp 42 case Stmt::IntegerLiteralClass:
44 case Stmt::StringLiteralClass: {
50 case Stmt::CharacterLiteralClass:
51 case Stmt::CXXNullPtrLiteralExprClass:
52 case Stmt::GNUNullExprClass:
53 case Stmt::CXXBoolLiteralExprClass:
54 case Stmt::FloatingLiteralClass:
55 case Stmt::ImaginaryLiteralClass:
56 case Stmt::ObjCStringLiteralClass:
71 til::SExpr *SExprBuilder::lookupStmt(const Stmt *S) {
198 til::SExpr *SExprBuilder::translate(const Stmt *S, CallingContext *Ctx) {
208 case Stmt::DeclRefExprClass:
210 case Stmt::CXXThisExprClass:
212 case Stmt::MemberExprClass:
214 case Stmt::ObjCIvarRefExprClass:
216 case Stmt::CallExprClass:
218 case Stmt::CXXMemberCallExprClass:
220 case Stmt::CXXOperatorCallExprClass:
222 case Stmt::UnaryOperatorClass:
224 case Stmt::BinaryOperatorClass:
225 case Stmt::CompoundAssignOperatorClass:
228 case Stmt::ArraySubscriptExprClass:
230 case Stmt::ConditionalOperatorClass:
233 case Stmt::BinaryConditionalOperatorClass:
238 case Stmt::ConstantExprClass:
240 case Stmt::ParenExprClass:
242 case Stmt::ExprWithCleanupsClass:
244 case Stmt::CXXBindTemporaryExprClass:
246 case Stmt::MaterializeTemporaryExprClass:
251 case Stmt::CharacterLiteralClass:
252 case Stmt::CXXNullPtrLiteralExprClass:
253 case Stmt::GNUNullExprClass:
254 case Stmt::CXXBoolLiteralExprClass:
255 case Stmt::FloatingLiteralClass:
256 case Stmt::ImaginaryLiteralClass:
257 case Stmt::IntegerLiteralClass:
258 case Stmt::StringLiteralClass:
259 case Stmt::ObjCStringLiteralClass:
262 case Stmt::DeclStmtClass:
636 til::SExpr *SExprBuilder::addStatement(til::SExpr* E, const Stmt *S,
884 void SExprBuilder::handleStatement(const Stmt *S) {
tools/clang/lib/Analysis/UninitializedValues.cpp 355 void operator()(Stmt *S) { Visit(S); }
460 for (Stmt *S : OMPExecutableDirective::used_clauses_children(ED->clauses()))
661 const Stmt *Term = Block->getTerminatorStmt();
677 const Stmt *Label = Succ->getLabel();
719 for (Stmt *S : OMPExecutableDirective::used_clauses_children(ED->clauses())) {
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGClass.cpp 839 Stmt *Body = Ctor->getBody(Definition);
1139 FieldDecl *getMemcpyableField(Stmt *S) {
1152 Stmt *RHS = BO->getRHS();
1208 SmallVector<Stmt*, 16> AggregatedStmts;
1218 void emitAssignment(Stmt *S) {
1438 Stmt *Body = Dtor->getBody();
1535 const Stmt *RootS = AssignOp->getBody();
1544 for (auto *I : RootCS->body())
tools/clang/lib/CodeGen/CGCoroutine.cpp 47 Stmt *ExceptionHandler = nullptr;
330 void VisitStmt(Stmt *S) {
331 for (auto *C : S->children()) {
420 Stmt *Deallocate;
464 explicit CallCoroDelete(Stmt *DeallocStmt) : Deallocate(DeallocStmt) {}
535 const CoroutineBodyStmt &S, Stmt *Body) {
539 if (Stmt *OnFallthrough = S.getFallthroughHandler())
572 if (auto *RetOnAllocFailure = S.getReturnStmtOnAllocFailure()) {
691 if (Stmt *Ret = S.getReturnStmt())
tools/clang/lib/CodeGen/CGDebugInfo.cpp 4649 const Stmt *FuncBody = (*FD).getBody();
tools/clang/lib/CodeGen/CGDecl.cpp 631 static bool isAccessedBy(const VarDecl &var, const Stmt *s) {
648 for (const Stmt *SubStmt : s->children())
1587 static bool isCapturedBy(const VarDecl &Var, const Stmt *S) {
1590 for (const Stmt *SubStmt : S->children())
1616 for (const auto *BI : CS->body())
1638 for (const Stmt *SubStmt : E->children())
tools/clang/lib/CodeGen/CGException.cpp 428 const Stmt *ThrowStmt = E->getSubExpr();
1291 const Stmt *Body;
1297 PerformFinally(const Stmt *Body, llvm::Value *ForEHVar,
1363 void CodeGenFunction::FinallyInfo::enter(CodeGenFunction &CGF, const Stmt *body,
1667 void Visit(const Stmt *S) {
1670 for (const Stmt *Child : S->children())
1752 const Stmt *OutlinedStmt,
1835 const Stmt *OutlinedStmt) {
1914 const Stmt *FinallyBlock = Finally.getBlock();
tools/clang/lib/CodeGen/CGExprAgg.cpp 108 void VisitStmt(Stmt *S) {
tools/clang/lib/CodeGen/CGExprComplex.cpp 98 ComplexPairTy VisitStmt(Stmt *S) {
tools/clang/lib/CodeGen/CGExprConstant.cpp 997 llvm::Constant *VisitStmt(Stmt *S, QualType T) {
1759 ConstantLValue VisitStmt(const Stmt *S) { return nullptr; }
tools/clang/lib/CodeGen/CGExprScalar.cpp 426 Value *VisitStmt(Stmt *S) {
tools/clang/lib/CodeGen/CGObjC.cpp 3440 const Stmt *subStmt = ARPS.getSubStmt();
3457 for (const auto *I : S.body())
tools/clang/lib/CodeGen/CGObjCMac.cpp 1367 void EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const Stmt &S);
4121 const Stmt &S;
4126 PerformFragileFinally(const Stmt *S,
4442 const Stmt &S) {
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 120 const Stmt *Body;
199 const Stmt *FinallyBlock = Finally->getFinallyBody();
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 70 void EmitBody(CodeGenFunction &CGF, const Stmt *S) override;
372 void EmitBody(CodeGenFunction &CGF, const Stmt *S) override {
1210 void CGOpenMPRegionInfo::EmitBody(CodeGenFunction &CGF, const Stmt * /*S*/) {
6548 const Stmt *CGOpenMPRuntime::getSingleCompoundChild(ASTContext &Ctx,
6549 const Stmt *Body) {
6550 const Stmt *Child = Body->IgnoreContainers();
6553 for (const Stmt *S : C->body()) {
6614 const auto *Body =
6616 const Stmt *ChildStmt =
6720 const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
6835 const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
6865 const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
6892 const Stmt *Child = CGOpenMPRuntime::getSingleCompoundChild(
8707 const auto *Body =
8709 const Stmt *ChildStmt =
9437 void CGOpenMPRuntime::scanForTargetRegionsFunctions(const Stmt *S,
9575 for (const Stmt *II : S->children())
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 692 void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName);
825 static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body);
825 static const Stmt *getSingleCompoundChild(ASTContext &Ctx, const Stmt *Body);
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 570 for (const Stmt *Child : E->children())
575 void VisitStmt(const Stmt *S) {
578 for (const Stmt *Child : S->children())
726 const auto *Body =
728 const Stmt *ChildStmt = CGOpenMPRuntime::getSingleCompoundChild(Ctx, Body);
910 const auto *Body =
912 const Stmt *ChildStmt = CGOpenMPRuntime::getSingleCompoundChild(Ctx, Body);
2004 if (const Stmt *S = CGOpenMPRuntime::getSingleCompoundChild(
4666 const Stmt *Body = nullptr;
tools/clang/lib/CodeGen/CGStmt.cpp 34 void CodeGenFunction::EmitStopPoint(const Stmt *S) {
44 void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs) {
83 case Stmt::NoStmtClass:
84 case Stmt::CXXCatchStmtClass:
85 case Stmt::SEHExceptStmtClass:
86 case Stmt::SEHFinallyStmtClass:
87 case Stmt::MSDependentExistsStmtClass:
89 case Stmt::NullStmtClass:
90 case Stmt::CompoundStmtClass:
91 case Stmt::DeclStmtClass:
92 case Stmt::LabelStmtClass:
93 case Stmt::AttributedStmtClass:
94 case Stmt::GotoStmtClass:
95 case Stmt::BreakStmtClass:
96 case Stmt::ContinueStmtClass:
97 case Stmt::DefaultStmtClass:
98 case Stmt::CaseStmtClass:
99 case Stmt::SEHLeaveStmtClass:
136 case Stmt::IndirectGotoStmtClass:
139 case Stmt::IfStmtClass: EmitIfStmt(cast<IfStmt>(*S)); break;
140 case Stmt::WhileStmtClass: EmitWhileStmt(cast<WhileStmt>(*S), Attrs); break;
141 case Stmt::DoStmtClass: EmitDoStmt(cast<DoStmt>(*S), Attrs); break;
142 case Stmt::ForStmtClass: EmitForStmt(cast<ForStmt>(*S), Attrs); break;
144 case Stmt::ReturnStmtClass: EmitReturnStmt(cast<ReturnStmt>(*S)); break;
146 case Stmt::SwitchStmtClass: EmitSwitchStmt(cast<SwitchStmt>(*S)); break;
147 case Stmt::GCCAsmStmtClass: // Intentional fall-through.
148 case Stmt::MSAsmStmtClass: EmitAsmStmt(cast<AsmStmt>(*S)); break;
149 case Stmt::CoroutineBodyStmtClass:
152 case Stmt::CoreturnStmtClass:
155 case Stmt::CapturedStmtClass: {
160 case Stmt::ObjCAtTryStmtClass:
163 case Stmt::ObjCAtCatchStmtClass:
166 case Stmt::ObjCAtFinallyStmtClass:
169 case Stmt::ObjCAtThrowStmtClass:
172 case Stmt::ObjCAtSynchronizedStmtClass:
175 case Stmt::ObjCForCollectionStmtClass:
178 case Stmt::ObjCAutoreleasePoolStmtClass:
182 case Stmt::CXXTryStmtClass:
185 case Stmt::CXXForRangeStmtClass:
188 case Stmt::SEHTryStmtClass:
191 case Stmt::OMPParallelDirectiveClass:
194 case Stmt::OMPSimdDirectiveClass:
197 case Stmt::OMPForDirectiveClass:
200 case Stmt::OMPForSimdDirectiveClass:
203 case Stmt::OMPSectionsDirectiveClass:
206 case Stmt::OMPSectionDirectiveClass:
209 case Stmt::OMPSingleDirectiveClass:
212 case Stmt::OMPMasterDirectiveClass:
215 case Stmt::OMPCriticalDirectiveClass:
218 case Stmt::OMPParallelForDirectiveClass:
221 case Stmt::OMPParallelForSimdDirectiveClass:
224 case Stmt::OMPParallelSectionsDirectiveClass:
227 case Stmt::OMPTaskDirectiveClass:
230 case Stmt::OMPTaskyieldDirectiveClass:
233 case Stmt::OMPBarrierDirectiveClass:
236 case Stmt::OMPTaskwaitDirectiveClass:
239 case Stmt::OMPTaskgroupDirectiveClass:
242 case Stmt::OMPFlushDirectiveClass:
245 case Stmt::OMPOrderedDirectiveClass:
248 case Stmt::OMPAtomicDirectiveClass:
251 case Stmt::OMPTargetDirectiveClass:
254 case Stmt::OMPTeamsDirectiveClass:
257 case Stmt::OMPCancellationPointDirectiveClass:
260 case Stmt::OMPCancelDirectiveClass:
263 case Stmt::OMPTargetDataDirectiveClass:
266 case Stmt::OMPTargetEnterDataDirectiveClass:
269 case Stmt::OMPTargetExitDataDirectiveClass:
272 case Stmt::OMPTargetParallelDirectiveClass:
275 case Stmt::OMPTargetParallelForDirectiveClass:
278 case Stmt::OMPTaskLoopDirectiveClass:
281 case Stmt::OMPTaskLoopSimdDirectiveClass:
284 case Stmt::OMPMasterTaskLoopDirectiveClass:
287 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
291 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
295 case Stmt::OMPDistributeDirectiveClass:
298 case Stmt::OMPTargetUpdateDirectiveClass:
301 case Stmt::OMPDistributeParallelForDirectiveClass:
305 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
309 case Stmt::OMPDistributeSimdDirectiveClass:
312 case Stmt::OMPTargetParallelForSimdDirectiveClass:
316 case Stmt::OMPTargetSimdDirectiveClass:
319 case Stmt::OMPTeamsDistributeDirectiveClass:
322 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
326 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
330 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
334 case Stmt::OMPTargetTeamsDirectiveClass:
337 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
341 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
345 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
349 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
356 bool CodeGenFunction::EmitSimpleStmt(const Stmt *S) {
359 case Stmt::NullStmtClass: break;
360 case Stmt::CompoundStmtClass: EmitCompoundStmt(cast<CompoundStmt>(*S)); break;
361 case Stmt::DeclStmtClass: EmitDeclStmt(cast<DeclStmt>(*S)); break;
362 case Stmt::LabelStmtClass: EmitLabelStmt(cast<LabelStmt>(*S)); break;
363 case Stmt::AttributedStmtClass:
365 case Stmt::GotoStmtClass: EmitGotoStmt(cast<GotoStmt>(*S)); break;
366 case Stmt::BreakStmtClass: EmitBreakStmt(cast<BreakStmt>(*S)); break;
367 case Stmt::ContinueStmtClass: EmitContinueStmt(cast<ContinueStmt>(*S)); break;
368 case Stmt::DefaultStmtClass: EmitDefaultStmt(cast<DefaultStmt>(*S)); break;
369 case Stmt::CaseStmtClass: EmitCaseStmt(cast<CaseStmt>(*S)); break;
370 case Stmt::SEHLeaveStmtClass: EmitSEHLeaveStmt(cast<SEHLeaveStmt>(*S)); break;
395 const Stmt *ExprResult = S.getStmtExprResult();
401 for (auto *CurStmt : S.body()) {
649 const Stmt *Executed = S.getThen();
650 const Stmt *Skipped = S.getElse();
688 if (const Stmt *Else = S.getElse()) {
1377 static CSFC_Result CollectStatementsForCase(const Stmt *S,
1380 SmallVectorImpl<const Stmt*> &ResultStmts) {
1534 SmallVectorImpl<const Stmt*> &ResultStmts,
1595 SmallVector<const Stmt*, 4> CaseStmts;
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 146 const Stmt *Body =
156 if (const Stmt *Init = CXXFor->getInit())
1372 const Stmt *Body =
1394 const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,
2608 const Stmt *CapturedStmt = S.getInnermostCapturedStmt()->getCapturedStmt();
2658 for (const Stmt *SubStmt : CS->children()) {
4092 const Stmt *CS = S.getInnermostCapturedStmt()->IgnoreContainers();
4097 for (const Stmt *C : Compound->body()) {
tools/clang/lib/CodeGen/CodeGenFunction.cpp 588 const Stmt *Body = nullptr;
738 FD->getBody()->getStmtClass() == Stmt::CoroutineBodyStmtClass)
1039 void CodeGenFunction::EmitFunctionBody(const Stmt *Body) {
1052 const Stmt *S) {
1156 if (Stmt *Body = FD->getBody())
1175 Stmt *Body = FD->getBody();
1250 bool CodeGenFunction::ContainsLabel(const Stmt *S, bool IgnoreCaseStmts) {
1272 for (const Stmt *SubStmt : S->children())
1282 bool CodeGenFunction::containsBreak(const Stmt *S) {
1296 for (const Stmt *SubStmt : S->children())
1303 bool CodeGenFunction::mightAddDeclToScope(const Stmt *S) {
1319 for (const Stmt *SubStmt : S->children())
1563 void CodeGenFunction::ErrorUnsupported(const Stmt *S, const char *Type) {
tools/clang/lib/CodeGen/CodeGenFunction.h 389 virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) {
589 void enter(CodeGenFunction &CGF, const Stmt *Finally,
1336 llvm::MDNode *createProfileWeightsForLoop(const Stmt *Cond,
1342 void incrementProfileCounter(const Stmt *S, llvm::Value *StepV = nullptr) {
1349 uint64_t getProfileCount(const Stmt *S) {
1852 void EmitFunctionBody(const Stmt *Body);
1853 void EmitBlockWithFallThrough(llvm::BasicBlock *BB, const Stmt *S);
2117 void ErrorUnsupported(const Stmt *S, const char *Type);
2841 void EmitStopPoint(const Stmt *S);
2849 void EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs = None);
2857 bool EmitSimpleStmt(const Stmt *S);
2921 const Stmt *OutlinedStmt);
2942 void EmitCapturedLocals(CodeGenFunction &ParentCGF, const Stmt *OutlinedStmt,
3240 const Stmt &S, bool RequiresCleanup, const Expr *LoopCond,
4034 static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts = false);
4039 static bool containsBreak(const Stmt *S);
4043 static bool mightAddDeclToScope(const Stmt *S);
tools/clang/lib/CodeGen/CodeGenModule.cpp 735 void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
2600 bool VisitStmt(const Stmt *S) {
2601 for (const Stmt *Child : S->children())
2689 const Stmt *Body = FD->getBody();
tools/clang/lib/CodeGen/CodeGenModule.h 1087 void ErrorUnsupported(const Stmt *S, const char *Type);
tools/clang/lib/CodeGen/CodeGenPGO.cpp 158 llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
161 llvm::DenseMap<const Stmt *, unsigned> &CounterMap)
195 PGOHash::HashType updateCounterMappings(Stmt *S) {
203 bool VisitStmt(Stmt *S) {
219 for (Stmt *CS : If->children()) {
252 PGOHash::HashType getHashType(PGOHashVersion HashVersion, const Stmt *S) {
256 case Stmt::LabelStmtClass:
258 case Stmt::WhileStmtClass:
260 case Stmt::DoStmtClass:
262 case Stmt::ForStmtClass:
264 case Stmt::CXXForRangeStmtClass:
266 case Stmt::ObjCForCollectionStmtClass:
268 case Stmt::SwitchStmtClass:
270 case Stmt::CaseStmtClass:
272 case Stmt::DefaultStmtClass:
274 case Stmt::IfStmtClass:
276 case Stmt::CXXTryStmtClass:
278 case Stmt::CXXCatchStmtClass:
280 case Stmt::ConditionalOperatorClass:
282 case Stmt::BinaryConditionalOperatorClass:
284 case Stmt::BinaryOperatorClass: {
316 case Stmt::GotoStmtClass:
318 case Stmt::IndirectGotoStmtClass:
320 case Stmt::BreakStmtClass:
322 case Stmt::ContinueStmtClass:
324 case Stmt::ReturnStmtClass:
326 case Stmt::CXXThrowExprClass:
328 case Stmt::UnaryOperatorClass: {
355 llvm::DenseMap<const Stmt *, uint64_t> &CountMap;
365 ComputeRegionCounts(llvm::DenseMap<const Stmt *, uint64_t> &CountMap,
369 void RecordStmtCount(const Stmt *S) {
382 void VisitStmt(const Stmt *S) {
384 for (const Stmt *Child : S->children())
803 RegionCounterMap.reset(new llvm::DenseMap<const Stmt *, unsigned>);
870 StmtCountMap.reset(new llvm::DenseMap<const Stmt *, uint64_t>);
892 void CodeGenPGO::emitCounterIncrement(CGBuilderTy &Builder, const Stmt *S,
1048 llvm::MDNode *CodeGenFunction::createProfileWeightsForLoop(const Stmt *Cond,
tools/clang/lib/CodeGen/CodeGenPGO.h 36 std::unique_ptr<llvm::DenseMap<const Stmt *, unsigned>> RegionCounterMap;
37 std::unique_ptr<llvm::DenseMap<const Stmt *, uint64_t>> StmtCountMap;
62 Optional<uint64_t> getStmtCount(const Stmt *S) {
73 void setCurrentStmt(const Stmt *S) {
103 void emitCounterIncrement(CGBuilderTy &Builder, const Stmt *S,
107 uint64_t getRegionCount(const Stmt *S) {
tools/clang/lib/CodeGen/CoverageMappingGen.cpp 205 SourceLocation getStart(const Stmt *S) {
213 SourceLocation getEnd(const Stmt *S) {
436 llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
473 Counter getRegionCounter(const Stmt *S) {
660 Counter propagateCounts(Counter TopCount, const Stmt *S,
774 void extendRegion(const Stmt *S) {
786 void terminateRegion(const Stmt *S) {
811 Optional<SourceRange> findGapAreaBetween(const Stmt *AfterStmt,
812 const Stmt *BeforeStmt) {
839 llvm::DenseMap<const Stmt *, unsigned> &CounterMap, SourceManager &SM,
861 void VisitStmt(const Stmt *S) {
864 for (const Stmt *Child : S->children())
873 Stmt *Body = D->getBody();
1021 if (const Stmt *Inc = S->getInc()) {
1110 const Stmt *Body = S->getBody();
1119 for (const auto *Child : CS->children())
1194 if (const Stmt *Else = S->getElse()) {
tools/clang/lib/CodeGen/CoverageMappingGen.h 88 llvm::DenseMap<const Stmt *, unsigned> *CounterMap;
97 llvm::DenseMap<const Stmt *, unsigned> *CounterMap)
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 3965 SmallVector<const Stmt *, 4> ArgVec;
tools/clang/lib/CodeGen/VarBypassDetector.cpp 20 void VarBypassDetector::Init(const Stmt *Body) {
53 bool VarBypassDetector::BuildScopeInformation(const Stmt *S,
66 case Stmt::IndirectGotoStmtClass:
69 case Stmt::SwitchStmtClass:
70 if (const Stmt *Init = cast<SwitchStmt>(S)->getInit()) {
82 case Stmt::GotoStmtClass:
86 case Stmt::DeclStmtClass: {
94 case Stmt::CaseStmtClass:
95 case Stmt::DefaultStmtClass:
96 case Stmt::LabelStmtClass:
104 for (const Stmt *SubStmt : S->children()) {
116 const Stmt *Next;
138 const Stmt *St = S.first;
tools/clang/lib/CodeGen/VarBypassDetector.h 44 llvm::SmallVector<std::pair<const Stmt *, unsigned>, 16> FromScopes;
46 llvm::DenseMap<const Stmt *, unsigned> ToScopes;
53 void Init(const Stmt *Body);
63 bool BuildScopeInformation(const Stmt *S, unsigned &origParentScope);
tools/clang/lib/Frontend/ASTConsumers.cpp 187 if (Stmt *Body = D->getBody()) {
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 72 Stmt *CurrentBody;
124 SmallVector<Stmt *, 32> Stmts;
162 llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
162 llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
250 void ReplaceStmt(Stmt *Old, Stmt *New) {
250 void ReplaceStmt(Stmt *Old, Stmt *New) {
254 void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
254 void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
257 Stmt *ReplacingStmt = ReplacedNodes[Old];
347 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
347 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
348 Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
349 Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo);
350 Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo);
351 Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
352 Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
353 Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
354 Stmt *RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp);
355 Stmt *RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp);
356 Stmt *RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp);
357 Stmt *RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp);
358 Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
359 Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
360 Stmt *RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S);
361 Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
362 Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
363 Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
365 Stmt *RewriteBreakStmt(BreakStmt *S);
366 Stmt *RewriteContinueStmt(ContinueStmt *S);
390 Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD);
391 Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE);
423 Stmt *SynthMessageExpr(ObjCMessageExpr *Exp,
462 Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV);
476 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
480 Stmt *SynthBlockInitExpr(BlockExpr *Exp,
485 void WarnAboutReturnGotoStmts(Stmt *S);
492 void GetBlockDeclRefExprs(Stmt *S);
493 void GetInnerBlockDeclRefExprs(Stmt *S,
1408 Stmt *RewriteModernObjC::RewritePropertyOrImplicitSetter(PseudoObjectExpr *PseudoOp) {
1491 Stmt *Replacement = SynthMessageExpr(NewMsg);
1496 Stmt *RewriteModernObjC::RewritePropertyOrImplicitGetter(PseudoObjectExpr *PseudoOp) {
1574 Stmt *Replacement = SynthMessageExpr(NewMsg);
1602 Stmt *RewriteModernObjC::RewriteBreakStmt(BreakStmt *S) {
1632 Stmt *RewriteModernObjC::RewriteContinueStmt(ContinueStmt *S) {
1678 Stmt *RewriteModernObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
1858 Stmt *RewriteModernObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1907 void RewriteModernObjC::WarnAboutReturnGotoStmts(Stmt *S)
1910 for (Stmt *SubStmt : S->children())
1920 Stmt *RewriteModernObjC::RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1929 Stmt *RewriteModernObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
2015 Stmt *body = finalStmt->getFinallyBody();
2033 Stmt *RewriteModernObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
2062 Stmt *RewriteModernObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
2074 Stmt *RewriteModernObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
2551 Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
2596 Stmt *RewriteModernObjC::RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp) {
2611 Stmt *RewriteModernObjC::RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp) {
2694 Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) {
2815 Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) {
3187 Stmt *RewriteModernObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
3535 Stmt *ReplacingStmt = CE;
3552 Stmt *RewriteModernObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
3553 Stmt *ReplacingStmt =
3580 Stmt *RewriteModernObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
4458 void RewriteModernObjC::GetBlockDeclRefExprs(Stmt *S) {
4459 for (Stmt *SubStmt : S->children())
4474 void RewriteModernObjC::GetInnerBlockDeclRefExprs(Stmt *S,
4477 for (Stmt *SubStmt : S->children())
4550 Stmt *RewriteModernObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
4567 Stmt *LHSStmt = SynthesizeBlockCall(Exp, LHSExp);
4569 Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp);
4662 Stmt *RewriteModernObjC::RewriteBlockDeclRefExpr(DeclRefExpr *DeclRefExp) {
4698 Stmt *RewriteModernObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) {
5195 Stmt *RewriteModernObjC::SynthBlockInitExpr(BlockExpr *Exp,
5425 Stmt *RewriteModernObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
5425 Stmt *RewriteModernObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
5451 for (Stmt *&childStmt : S->children())
5453 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt);
5467 Stmt *SaveCurrentBody = CurrentBody;
5486 Stmt *blockTranscribed = SynthBlockInitExpr(BE, InnerBlockDeclRefs);
5633 Stmt *BlockCall = SynthesizeBlockCall(CE, CE->getCallee());
7437 Stmt *RewriteModernObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) {
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 71 Stmt *CurrentBody;
115 SmallVector<Stmt *, 32> Stmts;
143 llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
143 llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
201 void ReplaceStmt(Stmt *Old, Stmt *New) {
201 void ReplaceStmt(Stmt *Old, Stmt *New) {
205 void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
205 void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
208 Stmt *ReplacingStmt = ReplacedNodes[Old];
293 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
293 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
294 Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
295 Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo);
296 Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo);
297 Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
298 Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
299 Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
300 Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
301 void RewriteTryReturnStmts(Stmt *S);
302 void RewriteSyncReturnStmts(Stmt *S, std::string buf);
303 Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
304 Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
305 Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
306 Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
308 Stmt *RewriteBreakStmt(BreakStmt *S);
309 Stmt *RewriteContinueStmt(ContinueStmt *S);
318 Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD);
319 Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE);
343 virtual Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) = 0;
359 Stmt *SynthMessageExpr(ObjCMessageExpr *Exp,
386 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
390 Stmt *SynthBlockInitExpr(BlockExpr *Exp,
395 void WarnAboutReturnGotoStmts(Stmt *S);
396 void HasReturnStmts(Stmt *S, bool &hasReturns);
403 void GetBlockDeclRefExprs(Stmt *S);
404 void GetInnerBlockDeclRefExprs(Stmt *S,
540 Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) override;
1227 Stmt *RewriteObjC::RewritePropertyOrImplicitSetter(PseudoObjectExpr *PseudoOp) {
1305 Stmt *Replacement = SynthMessageExpr(NewMsg);
1310 Stmt *RewriteObjC::RewritePropertyOrImplicitGetter(PseudoObjectExpr *PseudoOp) {
1381 Stmt *Replacement = SynthMessageExpr(NewMsg);
1409 Stmt *RewriteObjC::RewriteBreakStmt(BreakStmt *S) {
1426 Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) {
1472 Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
1642 Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1714 void RewriteObjC::WarnAboutReturnGotoStmts(Stmt *S)
1717 for (Stmt *SubStmt : S->children())
1727 void RewriteObjC::HasReturnStmts(Stmt *S, bool &hasReturns)
1730 for (Stmt *SubStmt : S->children())
1738 void RewriteObjC::RewriteTryReturnStmts(Stmt *S) {
1740 for (Stmt *SubStmt : S->children())
1759 void RewriteObjC::RewriteSyncReturnStmts(Stmt *S, std::string syncExitBuf) {
1761 for (Stmt *SubStmt : S->children())
1783 Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
1823 Stmt *lastCatchBody = nullptr;
1909 Stmt *body = finalStmt->getFinallyBody();
1951 Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
1977 Stmt *RewriteObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
1989 Stmt *RewriteObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
2476 Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
2614 Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
2964 Stmt *ReplacingStmt = CE;
3009 Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
3010 Stmt *ReplacingStmt =
3037 Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
3645 void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) {
3646 for (Stmt *SubStmt : S->children())
3661 void RewriteObjC::GetInnerBlockDeclRefExprs(Stmt *S,
3664 for (Stmt *SubStmt : S->children())
3718 Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
3735 Stmt *LHSStmt = SynthesizeBlockCall(Exp, LHSExp);
3737 Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp);
3830 Stmt *RewriteObjC::RewriteBlockDeclRefExpr(DeclRefExpr *DeclRefExp) {
3867 Stmt *RewriteObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) {
4349 Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp,
4549 Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
4549 Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
4573 for (Stmt *&childStmt : S->children())
4575 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt);
4589 Stmt *SaveCurrentBody = CurrentBody;
4608 Stmt *blockTranscribed = SynthBlockInitExpr(BE, InnerBlockDeclRefs);
4735 Stmt *BlockCall = SynthesizeBlockCall(CE, CE->getCallee());
5790 Stmt *RewriteObjCFragileABI::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) {
tools/clang/lib/Index/IndexBody.cpp 22 SmallVector<Stmt*, 16> StmtStack;
26 Stmt *getParentStmt() const {
36 bool dataTraverseStmtPre(Stmt *S) {
41 bool dataTraverseStmtPost(Stmt *S) {
73 const Stmt *Parent = *It;
232 Stmt *Containing = getParentStmt();
408 for (Stmt *SubStmt : Form->children()) {
471 void IndexingContext::indexBody(const Stmt *S, const NamedDecl *Parent,
tools/clang/lib/Index/IndexDecl.cpp 176 const Stmt *Body = D->getBody();
283 const Stmt *Body = D->getBody();
tools/clang/lib/Index/IndexTypeSourceInfo.cpp 201 bool TraverseStmt(Stmt *S) {
tools/clang/lib/Index/IndexingContext.h 118 void indexBody(const Stmt *S, const NamedDecl *Parent,
tools/clang/lib/Parse/ParseAST.cpp 118 Stmt::EnableStatistics();
186 Stmt::PrintStats();
tools/clang/lib/Parse/ParseStmt.cpp 695 Stmt *DeepestParsedCaseStmt = nullptr;
770 Stmt *NextDeepest = Case.get();
tools/clang/lib/Parse/Parser.cpp 1292 Stmt *GeneratedBody = Res ? Res->getBody() : nullptr;
tools/clang/lib/Sema/AnalysisBasedWarnings.cpp 136 for (const Stmt *SubStmt : E->children())
254 const Stmt *Body, AnalysisDeclContext &AC) {
415 const Stmt *Term = B->getTerminatorStmt();
464 const Stmt *Term = B.getTerminatorStmt();
475 const Stmt *S = CS.getStmt();
636 static void CheckFallThroughForBody(Sema &S, const Decl *D, const Stmt *Body,
786 static void CreateIfFixit(Sema &S, const Stmt *If, const Stmt *Then,
786 static void CreateIfFixit(Sema &S, const Stmt *If, const Stmt *Then,
787 const Stmt *Else, bool CondVal,
845 const Stmt *Term = I->Terminator;
861 switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) {
868 case Stmt::IfStmtClass: {
878 case Stmt::ConditionalOperatorClass: {
888 case Stmt::BinaryOperatorClass: {
908 case Stmt::WhileStmtClass:
915 case Stmt::ForStmtClass:
925 case Stmt::CXXForRangeStmtClass:
938 case Stmt::DoStmtClass:
947 case Stmt::CaseStmtClass:
952 case Stmt::DefaultStmtClass:
1065 const Stmt *L = B->getLabel();
1095 const Stmt *Term = P->getTerminatorStmt();
1137 const Stmt *LastStmt = getLastStmt(*P);
1184 static const AttributedStmt *asFallThroughAttr(const Stmt *S) {
1192 static const Stmt *getLastStmt(const CFGBlock &B) {
1193 if (const Stmt *Term = B.getTerminatorStmt())
1271 const Stmt *Label = B->getLabel();
1294 const Stmt *Term = B->getTerminatorStmt();
1319 const Stmt *S) {
1324 case Stmt::ForStmtClass:
1325 case Stmt::WhileStmtClass:
1326 case Stmt::CXXForRangeStmtClass:
1327 case Stmt::ObjCForCollectionStmtClass:
1329 case Stmt::DoStmtClass: {
1350 typedef std::pair<const Stmt *, WeakObjectUseMap::const_iterator>
1440 const Stmt *FirstRead = P.first;
2048 const Stmt *Body = D->getBody();
2077 .setAlwaysAdd(Stmt::BinaryOperatorClass)
2078 .setAlwaysAdd(Stmt::CompoundAssignOperatorClass)
2079 .setAlwaysAdd(Stmt::BlockExprClass)
2080 .setAlwaysAdd(Stmt::CStyleCastExprClass)
2081 .setAlwaysAdd(Stmt::DeclRefExprClass)
2082 .setAlwaysAdd(Stmt::ImplicitCastExprClass)
2083 .setAlwaysAdd(Stmt::UnaryOperatorClass)
2084 .setAlwaysAdd(Stmt::AttributedStmtClass);
2100 for (const Stmt *S : D.Stmts)
2108 for (const Stmt *S : D.Stmts) {
tools/clang/lib/Sema/CoroutineStmtBuilder.h 30 SmallVector<Stmt *, 4> ParamMovesVector;
38 Stmt *Body);
tools/clang/lib/Sema/JumpDiagnostics.cpp 65 llvm::DenseMap<Stmt*, unsigned> LabelAndGotoScopes;
66 SmallVector<Stmt*, 16> Jumps;
68 SmallVector<Stmt*, 4> IndirectJumps;
69 SmallVector<Stmt*, 4> AsmJumps;
73 JumpScopeChecker(Stmt *Body, Sema &S);
78 void BuildScopeInformation(Stmt *S, unsigned &origParentScope);
83 void DiagnoseIndirectOrAsmJump(Stmt *IG, unsigned IGScope, LabelDecl *Target,
85 void CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
85 void CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
96 JumpScopeChecker::JumpScopeChecker(Stmt *Body, Sema &s)
283 void JumpScopeChecker::BuildScopeInformation(Stmt *S,
296 case Stmt::AddrLabelExprClass:
300 case Stmt::ObjCForCollectionStmtClass: {
309 case Stmt::IndirectGotoStmtClass:
325 case Stmt::SwitchStmtClass:
328 if (Stmt *Init = cast<SwitchStmt>(S)->getInit()) {
338 case Stmt::GotoStmtClass:
345 case Stmt::GCCAsmStmtClass:
357 case Stmt::IfStmtClass: {
377 if (Stmt *Else = IS->getElse()) {
385 case Stmt::CXXTryStmtClass: {
393 if (Stmt *TryBlock = TS->getTryBlock())
410 case Stmt::SEHTryStmtClass: {
418 if (Stmt *TryBlock = TS->getTryBlock())
442 case Stmt::DeclStmtClass: {
453 case Stmt::ObjCAtTryStmtClass: {
464 if (Stmt *TryPart = AT->getTryBody())
493 case Stmt::ObjCAtSynchronizedStmtClass: {
512 case Stmt::ObjCAutoreleasePoolStmtClass: {
526 case Stmt::ExprWithCleanupsClass: {
541 case Stmt::MaterializeTemporaryExprClass: {
561 case Stmt::CaseStmtClass:
562 case Stmt::DefaultStmtClass:
563 case Stmt::LabelStmtClass:
571 for (Stmt *SubStmt : S->children()) {
583 Stmt *Next;
604 Stmt *Jump = Jumps.pop_back_val();
666 SmallVector<Stmt*, 4> GotoJumps = IsAsmGoto ? AsmJumps : IndirectJumps;
682 typedef std::pair<unsigned, Stmt*> JumpScope;
685 llvm::DenseMap<unsigned, Stmt*> JumpScopesMap;
686 for (SmallVectorImpl<Stmt *>::iterator I = GotoJumps.begin(),
689 Stmt *IG = *I;
693 Stmt *&Entry = JumpScopesMap[IGScope];
697 for (llvm::DenseMap<unsigned, Stmt *>::iterator I = JumpScopesMap.begin(),
806 static void DiagnoseIndirectOrAsmJumpStmt(Sema &S, Stmt *Jump,
828 void JumpScopeChecker::DiagnoseIndirectOrAsmJump(Stmt *Jump, unsigned JumpScope,
869 void JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
869 void JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc,
942 void Sema::DiagnoseInvalidJumps(Stmt *Body) {
tools/clang/lib/Sema/MultiplexExternalSemaSource.cpp 71 Stmt *MultiplexExternalSemaSource::GetExternalDeclStmt(uint64_t Offset) {
73 if (Stmt *Result = Sources[i]->GetExternalDeclStmt(Offset))
tools/clang/lib/Sema/ScopeInfo.cpp 75 case Stmt::DeclRefExprClass:
79 case Stmt::MemberExprClass: {
85 case Stmt::ObjCIvarRefExprClass: {
91 case Stmt::PseudoObjectExprClass: {
tools/clang/lib/Sema/SemaChecking.cpp 258 if (Call->getStmtClass() != Stmt::CallExprClass) {
6820 case Stmt::BinaryConditionalOperatorClass:
6821 case Stmt::ConditionalOperatorClass: {
6867 case Stmt::ImplicitCastExprClass:
6871 case Stmt::OpaqueValueExprClass:
6878 case Stmt::PredefinedExprClass:
6884 case Stmt::DeclRefExprClass: {
6956 case Stmt::CallExprClass:
6957 case Stmt::CXXMemberCallExprClass: {
6993 case Stmt::ObjCMessageExprClass: {
7022 case Stmt::ObjCStringLiteralClass:
7023 case Stmt::StringLiteralClass: {
7047 case Stmt::BinaryOperatorClass: {
7078 case Stmt::UnaryOperatorClass: {
8183 case Stmt::ArraySubscriptExprClass:
8184 case Stmt::CallExprClass:
8185 case Stmt::CharacterLiteralClass:
8186 case Stmt::CXXBoolLiteralExprClass:
8187 case Stmt::DeclRefExprClass:
8188 case Stmt::FloatingLiteralClass:
8189 case Stmt::IntegerLiteralClass:
8190 case Stmt::MemberExprClass:
8191 case Stmt::ObjCArrayLiteralClass:
8192 case Stmt::ObjCBoolLiteralExprClass:
8193 case Stmt::ObjCBoxedExprClass:
8194 case Stmt::ObjCDictionaryLiteralClass:
8195 case Stmt::ObjCEncodeExprClass:
8196 case Stmt::ObjCIvarRefExprClass:
8197 case Stmt::ObjCMessageExprClass:
8198 case Stmt::ObjCPropertyRefExprClass:
8199 case Stmt::ObjCStringLiteralClass:
8200 case Stmt::ObjCSubscriptRefExprClass:
8201 case Stmt::ParenExprClass:
8202 case Stmt::StringLiteralClass:
8203 case Stmt::UnaryOperatorClass:
12119 for (Stmt *SubStmt : E->children()) {
12738 void VisitStmt(Stmt *S) {
13374 case Stmt::ArraySubscriptExprClass: {
13381 case Stmt::MemberExprClass: {
13385 case Stmt::OMPArraySectionExprClass: {
13392 case Stmt::UnaryOperatorClass: {
13408 case Stmt::ConditionalOperatorClass: {
13416 case Stmt::CXXOperatorCallExprClass: {
14040 const Stmt *Body,
14060 void Sema::DiagnoseEmptyLoopBody(const Stmt *S,
14061 const Stmt *PossibleBody) {
14065 const Stmt *Body;
14389 case Stmt::UnaryOperatorClass: {
14398 case Stmt::DeclRefExprClass: {
14404 case Stmt::IntegerLiteralClass: {
14414 case Stmt::BinaryConditionalOperatorClass:
14415 case Stmt::ConditionalOperatorClass: {
14430 case Stmt::BinaryOperatorClass: {
tools/clang/lib/Sema/SemaCoroutine.cpp 633 return cast<Stmt>(Suspend.get());
896 Stmt *Res = new (Context) CoreturnStmt(Loc, E, PCE, IsImplicit);
957 void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {
994 Stmt *Body)
tools/clang/lib/Sema/SemaDecl.cpp13646 void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
13709 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
13757 Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
14030 for (const Stmt *S : Body->children()) {
tools/clang/lib/Sema/SemaDeclAttr.cpp 8130 bool isBodyLikeChildStmt(const Stmt *S, const Stmt *Parent) {
8130 bool isBodyLikeChildStmt(const Stmt *S, const Stmt *Parent) {
8132 case Stmt::IfStmtClass:
8135 case Stmt::WhileStmtClass:
8137 case Stmt::DoStmtClass:
8139 case Stmt::ForStmtClass:
8141 case Stmt::CXXForRangeStmtClass:
8143 case Stmt::ObjCForCollectionStmtClass:
8145 case Stmt::CaseStmtClass:
8146 case Stmt::DefaultStmtClass:
8154 const Stmt *Target;
8157 bool VisitStmt(Stmt *S) { return S != Target; }
8160 static bool isContained(const Stmt *Target, const Decl *D) {
8179 static const Stmt *findLastStmtThatUsesDecl(const Decl *D,
8184 const Stmt *S = *I;
8207 SmallVector<const Stmt *, 16> StmtStack;
8226 bool TraverseStmt(Stmt *S) {
8235 void IssueDiagnostics(Stmt *S) { TraverseStmt(S); }
8343 const Stmt *StmtOfUse = StmtStack.back();
8345 for (const Stmt *S : llvm::reverse(StmtStack)) {
8358 const Stmt *LastStmtOfUse = nullptr;
8453 Stmt *Body = nullptr;
tools/clang/lib/Sema/SemaDeclCXX.cpp 78 for (Stmt *SubStmt : Node->children())
1667 Stmt *Body,
1755 Stmt *Body = NewFD->getBody();
1963 CheckConstexprFunctionStmt(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *S,
1969 case Stmt::NullStmtClass:
1973 case Stmt::DeclStmtClass:
1983 case Stmt::ReturnStmtClass:
1995 case Stmt::CompoundStmtClass: {
2001 for (auto *BodyIt : CompStmt->body()) {
2009 case Stmt::AttributedStmtClass:
2014 case Stmt::IfStmtClass: {
2030 case Stmt::WhileStmtClass:
2031 case Stmt::DoStmtClass:
2032 case Stmt::ForStmtClass:
2033 case Stmt::CXXForRangeStmtClass:
2034 case Stmt::ContinueStmtClass:
2041 for (Stmt *SubStmt : S->children())
2048 case Stmt::SwitchStmtClass:
2049 case Stmt::CaseStmtClass:
2050 case Stmt::DefaultStmtClass:
2051 case Stmt::BreakStmtClass:
2056 for (Stmt *SubStmt : S->children())
2063 case Stmt::GCCAsmStmtClass:
2064 case Stmt::MSAsmStmtClass:
2066 case Stmt::CXXTryStmtClass:
2069 for (Stmt *SubStmt : S->children()) {
2077 case Stmt::CXXCatchStmtClass:
2109 Stmt *Body,
2148 for (Stmt *SubStmt : Body->children()) {
12078 return Call.getAs<Stmt>();
12255 Stmt *InitStmt = new (S.Context) DeclStmt(DeclGroupRef(IterationVar),Loc,Loc);
12486 SmallVector<Stmt*, 8> Statements;
12613 Statements.push_back(Copy.getAs<Stmt>());
12624 Statements.push_back(Return.getAs<Stmt>());
12639 CopyAssignOperator->setBody(Body.getAs<Stmt>());
12848 SmallVector<Stmt*, 8> Statements;
12984 Statements.push_back(Move.getAs<Stmt>());
12996 Statements.push_back(Return.getAs<Stmt>());
13011 MoveAssignOperator->setBody(Body.getAs<Stmt>());
13148 ActOnCompoundStmt(Loc, Loc, None, /*isStmtExpr=*/false).getAs<Stmt>());
13273 Loc, Loc, None, /*isStmtExpr=*/ false).getAs<Stmt>());
13330 Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
13385 Stmt *ReturnS = Return.get();
15288 static void SearchForReturnInStmt(Sema &Self, Stmt *S) {
15289 for (Stmt *SubStmt : S->children()) {
tools/clang/lib/Sema/SemaExceptionSpec.cpp 975 for (const Stmt *SubStmt : E->children()) {
tools/clang/lib/Sema/SemaExpr.cpp10105 case Stmt::ObjCArrayLiteralClass:
10106 case Stmt::ObjCDictionaryLiteralClass:
10107 case Stmt::ObjCStringLiteralClass:
10108 case Stmt::ObjCBoxedExprClass:
10167 case Stmt::ObjCStringLiteralClass:
10170 case Stmt::ObjCArrayLiteralClass:
10173 case Stmt::ObjCDictionaryLiteralClass:
10176 case Stmt::BlockExprClass:
10178 case Stmt::ObjCBoxedExprClass: {
10181 case Stmt::IntegerLiteralClass:
10182 case Stmt::FloatingLiteralClass:
10183 case Stmt::CharacterLiteralClass:
10184 case Stmt::ObjCBoolLiteralExprClass:
10185 case Stmt::CXXBoolLiteralExprClass:
10188 case Stmt::ImplicitCastExprClass: {
12218 case Stmt::DeclRefExprClass:
12220 case Stmt::MemberExprClass:
12228 case Stmt::ArraySubscriptExprClass: {
12238 case Stmt::UnaryOperatorClass: {
12250 case Stmt::ParenExprClass:
12252 case Stmt::ImplicitCastExprClass:
15053 StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body) {
17091 bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
17134 bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
tools/clang/lib/Sema/SemaExprCXX.cpp 6548 Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
6548 Stmt *Sema::MaybeCreateStmtWithCleanups(Stmt *SubStmt) {
8039 StmtResult Sema::ActOnFinishFullStmt(Stmt *FullStmt) {
tools/clang/lib/Sema/SemaExprObjC.cpp 3357 ACCResult VisitStmt(Stmt *s) {
tools/clang/lib/Sema/SemaInit.cpp 930 for (const Stmt *Init : *IL)
6960 case Stmt::DeclRefExprClass: {
6983 case Stmt::UnaryOperatorClass: {
6994 case Stmt::OMPArraySectionExprClass: {
7001 case Stmt::ConditionalOperatorClass:
7002 case Stmt::BinaryConditionalOperatorClass: {
7207 case Stmt::UnaryOperatorClass: {
7226 case Stmt::BinaryOperatorClass: {
7242 case Stmt::ConditionalOperatorClass:
7243 case Stmt::BinaryConditionalOperatorClass: {
7256 case Stmt::BlockExprClass:
7263 case Stmt::AddrLabelExprClass:
tools/clang/lib/Sema/SemaLambda.cpp 1531 ExprResult Sema::ActOnLambdaExpr(SourceLocation StartLoc, Stmt *Body,
tools/clang/lib/Sema/SemaOpenMP.cpp 2149 void Sema::EndOpenMPDSABlock(Stmt *CurDirective) {
2411 bool VisitStmt(const Stmt *S) {
2412 for (const Stmt *Child : S->children()) {
3033 for (Stmt *CC : C->children()) {
3042 void VisitStmt(Stmt *S) {
3043 for (Stmt *C : S->children()) {
3668 for (Stmt *VarRef : Clause->children()) {
4237 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
4255 Stmt *S = AStmt;
4666 for (Stmt *CC : C->children()) {
5217 Stmt *AStmt,
5334 Optional<unsigned> doesDependOnLoopCounter(const Stmt *S, bool IsInitializer);
5346 bool checkAndSetInit(Stmt *S, bool EmitDiags = true);
5605 bool VisitStmt(const Stmt *S) {
5607 for (const Stmt *Child : S->children())
5628 OpenMPIterationSpaceChecker::doesDependOnLoopCounter(const Stmt *S,
5640 bool OpenMPIterationSpaceChecker::checkAndSetInit(Stmt *S, bool EmitDiags) {
6465 void Sema::ActOnOpenMPLoopInitialization(SourceLocation ForLoc, Stmt *Init) {
6550 OpenMPDirectiveKind DKind, Stmt *S, Sema &SemaRef, DSAStackTy &DSA,
6592 Stmt *Init = For ? For->getInit() : CXXFor->getBeginStmt();
6850 static Stmt *buildPreInits(ASTContext &Context,
6861 static Stmt *
6898 Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef,
6941 Stmt *CurStmt = AStmt->IgnoreContainers(/* IgnoreCaptured */ true);
7645 Sema::ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
7684 Sema::ActOnOpenMPForDirective(ArrayRef<OMPClause *> Clauses, Stmt *AStmt,
7720 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7759 Stmt *AStmt,
7775 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
7796 StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
7812 Stmt *AStmt,
7842 StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
7857 Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
7915 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
7959 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
8003 Stmt *AStmt, SourceLocation StartLoc,
8018 for (Stmt *SectionStmt : llvm::make_range(std::next(S.begin()), S.end())) {
8041 Stmt *AStmt, SourceLocation StartLoc,
8076 Stmt *AStmt,
8099 Stmt *AStmt,
8234 bool checkStatement(Stmt *S, unsigned DiagId = 0, unsigned NoteId = 0);
8325 bool OpenMPAtomicUpdateChecker::checkStatement(Stmt *S, unsigned DiagId,
8418 Stmt *AStmt,
8448 Stmt *Body = CS->getCapturedStmt();
8698 Stmt *First = CS->body_front();
8699 Stmt *Second = CS->body_back();
8851 Stmt *AStmt,
8880 const Stmt *S = CS->IgnoreContainers(/*IgnoreCaptured=*/true);
8917 Stmt *AStmt, SourceLocation StartLoc,
8947 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9014 Stmt *AStmt,
9040 SourceLocation EndLoc, Stmt *AStmt) {
9077 SourceLocation EndLoc, Stmt *AStmt) {
9114 Stmt *AStmt) {
9145 Stmt *AStmt, SourceLocation StartLoc,
9250 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9286 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9335 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9371 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9420 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9475 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9500 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9544 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9601 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9657 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9712 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9768 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9813 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9875 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9937 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
9986 Stmt *AStmt,
10017 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10060 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10115 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10174 ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
10979 Stmt *HelperValStmt = nullptr;
11011 Stmt *HelperValStmt = nullptr;
11085 Stmt **HelperValStmt = nullptr) {
11125 Stmt *HelperValStmt = nullptr;
11642 Stmt *HelperValStmt = nullptr;
12680 bool VisitStmt(Stmt *S) {
12681 for (Stmt *Child : S->children()) {
14493 Stmt *HelperValStmt = nullptr;
15945 Stmt *HelperValStmt = nullptr;
15972 Stmt *HelperValStmt = nullptr;
15999 Stmt *HelperValStmt = nullptr;
16019 Stmt *HelperValStmt = nullptr;
16040 Stmt *HelperValStmt = nullptr;
16083 Stmt *HelperValStmt = nullptr;
tools/clang/lib/Sema/SemaOverload.cpp 7157 alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
tools/clang/lib/Sema/SemaStmt.cpp 58 return StmtResult(FE.getAs<Stmt>());
218 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
389 ArrayRef<Stmt *> Elts, bool isStmtExpr) {
499 void Sema::ActOnCaseStmtBody(Stmt *S, Stmt *SubStmt) {
499 void Sema::ActOnCaseStmtBody(Stmt *S, Stmt *SubStmt) {
505 Stmt *SubStmt, Scope *CurScope) {
518 SourceLocation ColonLoc, Stmt *SubStmt) {
542 Stmt *SubStmt) {
563 Sema::ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr, Stmt *InitStmt,
565 Stmt *thenStmt, SourceLocation ElseLoc,
566 Stmt *elseStmt) {
590 Stmt *InitStmt, ConditionResult Cond,
591 Stmt *thenStmt, SourceLocation ElseLoc,
592 Stmt *elseStmt) {
727 Stmt *InitStmt, ConditionResult Cond) {
847 Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch,
848 Stmt *BodyStmt) {
1317 Stmt *Body) {
1336 Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body,
1391 void VisitStmt(Stmt *S) {
1458 DeclMatcher(Sema &S, DeclSetVector &Decls, Stmt *Statement) :
1531 Expr *Third, Stmt *Body) {
1578 bool ProcessIterationStmt(Sema &S, Stmt* Statement, bool &Increment,
1627 BreakContinueFinder(Sema &S, const Stmt* Body) :
1644 if (const Stmt *Init = S->getInit())
1646 if (const Stmt *CondVar = S->getConditionVariableDeclStmt())
1648 if (const Stmt *Cond = S->getCond())
1653 if (const Stmt *Body = S->getBody())
1661 if (const Stmt *Init = S->getInit())
1678 if (const Stmt *Init = S->getInit())
1680 if (const Stmt *Range = S->getRangeStmt())
1682 if (const Stmt *Begin = S->getBeginStmt())
1684 if (const Stmt *End = S->getEndStmt())
1691 if (const Stmt *Element = S->getElement())
1693 if (const Stmt *Collection = S->getCollection())
1709 void CheckForRedundantIteration(Sema &S, Expr *Third, Stmt *Body) {
1720 Stmt *LastStmt = CS->body_back();
1764 Stmt *First, ConditionResult Second,
1766 Stmt *Body) {
1903 Stmt *First, Expr *collection,
2094 SourceLocation CoawaitLoc, Stmt *InitStmt,
2095 Stmt *First, SourceLocation ColonLoc,
2306 Stmt *InitStmt,
2307 Stmt *LoopVarDecl,
2357 SourceLocation CoawaitLoc, Stmt *InitStmt,
2358 SourceLocation ColonLoc, Stmt *RangeDecl,
2359 Stmt *Begin, Stmt *End, Expr *Cond,
2359 Stmt *Begin, Stmt *End, Expr *Cond,
2360 Expr *Inc, Stmt *LoopVarDecl,
2691 StmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) {
2691 StmtResult Sema::FinishObjCForCollectionStmt(Stmt *S, Stmt *B) {
2858 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
2858 StmtResult Sema::FinishCXXForRangeStmt(Stmt *S, Stmt *B) {
3822 Stmt *Body) {
3831 Sema::ActOnObjCAtFinallyStmt(SourceLocation AtLoc, Stmt *Body) {
3836 Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try,
3837 MultiStmtArg CatchStmts, Stmt *Finally) {
3930 Stmt *SyncBody) {
3940 Stmt *HandlerBlock) {
3947 Sema::ActOnObjCAutoreleasePoolStmt(SourceLocation AtLoc, Stmt *Body) {
4056 StmtResult Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock,
4057 ArrayRef<Stmt *> Handlers) {
4153 Stmt *TryBlock, Stmt *Handler) {
4153 Stmt *TryBlock, Stmt *Handler) {
4190 Stmt *Block) {
4210 StmtResult Sema::ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block) {
4232 Stmt *Nested)
4244 Stmt *Nested) {
4421 StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
tools/clang/lib/Sema/SemaStmtAsm.cpp 150 for (Stmt *Child : E->children()) {
tools/clang/lib/Sema/SemaStmtAttr.cpp 24 static Attr *handleFallThroughAttr(Sema &S, Stmt *St, const ParsedAttr &A,
53 static Attr *handleSuppressAttr(Sema &S, Stmt *St, const ParsedAttr &A,
76 static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A,
89 if (St->getStmtClass() != Stmt::DoStmtClass &&
90 St->getStmtClass() != Stmt::ForStmtClass &&
91 St->getStmtClass() != Stmt::CXXForRangeStmtClass &&
92 St->getStmtClass() != Stmt::WhileStmtClass) {
280 static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const ParsedAttr &A,
321 static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
347 StmtResult Sema::ProcessStmtAttributes(Stmt *S,
tools/clang/lib/Sema/SemaTemplate.cpp 2490 bool TraverseStmt(Stmt *S, DataRecursionQueue *Q = nullptr) {
3128 bool handledStmt(Stmt *E, raw_ostream &OS) override {
tools/clang/lib/Sema/SemaTemplateInstantiate.cpp 2893 Sema::SubstStmt(Stmt *S, const MultiLevelTemplateArgumentList &TemplateArgs) {
tools/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp 4206 Stmt *Pattern = nullptr;
tools/clang/lib/Sema/SemaTemplateVariadic.cpp 133 bool TraverseStmt(Stmt *S) {
tools/clang/lib/Sema/TreeTransform.h 134 static inline StmtResult Owned(Stmt *S) { return S; }
342 StmtResult TransformStmt(Stmt *S, StmtDiscardKind SDK = SDK_Discarded);
621 StmtResult TransformSEHHandler(Stmt *Handler);
663 StmtResult TransformLambdaBody(LambdaExpr *E, Stmt *Body);
666 StmtResult SkipLambdaBody(LambdaExpr *E, Stmt *Body);
1246 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1246 StmtResult RebuildCaseStmtBody(Stmt *S, Stmt *Body) {
1257 Stmt *SubStmt) {
1267 SourceLocation ColonLoc, Stmt *SubStmt) {
1277 Stmt *SubStmt) {
1286 Sema::ConditionResult Cond, Stmt *Init, Stmt *Then,
1286 Sema::ConditionResult Cond, Stmt *Init, Stmt *Then,
1287 SourceLocation ElseLoc, Stmt *Else) {
1296 StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc, Stmt *Init,
1306 Stmt *Switch, Stmt *Body) {
1306 Stmt *Switch, Stmt *Body) {
1315 Sema::ConditionResult Cond, Stmt *Body) {
1323 StmtResult RebuildDoStmt(SourceLocation DoLoc, Stmt *Body,
1335 Stmt *Init, Sema::ConditionResult Cond,
1337 Stmt *Body) {
1457 Stmt *TryBody,
1459 Stmt *Finally) {
1483 Stmt *Body) {
1493 Stmt *Body) {
1514 Stmt *AStmt, SourceLocation StartLoc,
2001 Expr *Object, Stmt *Body) {
2010 Stmt *Body) {
2019 Stmt *Element,
2022 Stmt *Body) {
2055 Stmt *Handler) {
2064 StmtResult RebuildCXXTryStmt(SourceLocation TryLoc, Stmt *TryBlock,
2065 ArrayRef<Stmt *> Handlers) {
2074 SourceLocation CoawaitLoc, Stmt *Init,
2075 SourceLocation ColonLoc, Stmt *Range,
2076 Stmt *Begin, Stmt *End, Expr *Cond,
2076 Stmt *Begin, Stmt *End, Expr *Cond,
2077 Expr *Inc, Stmt *LoopVar,
2117 Stmt *Nested) {
2126 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
2126 StmtResult FinishCXXForRangeStmt(Stmt *ForRange, Stmt *Body) {
2131 Stmt *TryBlock, Stmt *Handler) {
2131 Stmt *TryBlock, Stmt *Handler) {
2136 Stmt *Block) {
2140 StmtResult RebuildSEHFinallyStmt(SourceLocation Loc, Stmt *Block) {
2558 case Stmt::CXXStaticCastExprClass:
2563 case Stmt::CXXDynamicCastExprClass:
2568 case Stmt::CXXReinterpretCastExprClass:
2574 case Stmt::CXXConstCastExprClass:
3373 StmtResult TreeTransform<Derived>::TransformStmt(Stmt *S, StmtDiscardKind SDK) {
3378 case Stmt::NoStmtClass: break;
3432 case Stmt::NoStmtClass: break;
6658 const Stmt *ExprResult = S->getStmtExprResult();
6661 SmallVector<Stmt*, 8> Statements;
6662 for (auto *B : S->body()) {
6678 Statements.push_back(Result.getAs<Stmt>());
7249 if (auto *OnFallthrough = S->getFallthroughHandler()) {
7256 if (auto *OnException = S->getExceptionHandler()) {
7263 if (auto *OnAllocFailure = S->getReturnStmtOnAllocFailure()) {
7289 if (auto *ReturnStmt = S->getReturnStmt()) {
7374 SmallVector<Stmt*, 8> CatchStmts;
7597 SmallVector<Stmt *, 8> Handlers;
7604 Handlers.push_back(Handler.getAs<Stmt>());
7854 StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
7897 Stmt *CS = D->getInnermostCapturedStmt()->getCapturedStmt();
11700 TreeTransform<Derived>::TransformLambdaBody(LambdaExpr *E, Stmt *S) {
11706 TreeTransform<Derived>::SkipLambdaBody(LambdaExpr *E, Stmt *S) {
tools/clang/lib/Serialization/ASTReader.cpp 7916 Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
tools/clang/lib/Serialization/ASTReaderStmt.cpp 129 void VisitStmt(Stmt *S);
149 void ASTStmtReader::VisitStmt(Stmt *S) {
162 SmallVector<Stmt *, 16> Stmts;
385 SmallVector<Stmt*, 16> Exprs;
669 E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
1120 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1120 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
2407 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
2436 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2442 llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2450 Stmt::EmptyShell Empty;
2474 Stmt *S = nullptr;
tools/clang/lib/Serialization/ASTWriterStmt.cpp 53 void VisitStmt(Stmt *S);
69 void ASTStmtWriter::VisitStmt(Stmt *S) {
83 for (auto *CS : S->body())
350 for (Stmt *S : CoroStmt->children())
367 for (Stmt *S : E->children())
386 for (Stmt *S : E->children())
1029 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1029 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
2024 for (Stmt *S : D->dependent_counters())
2026 for (Stmt *S : D->dependent_inits())
2028 for (Stmt *S : D->finals_conditions())
2394 void ASTWriter::WriteSubStmt(Stmt *S) {
2404 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2415 Stmt *S;
2416 llvm::DenseSet<Stmt *> &ParentStmts;
2418 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2418 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
tools/clang/lib/StaticAnalyzer/Checkers/AnalysisOrderChecker.cpp 148 void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &C) const {
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundChecker.cpp 30 void checkLocation(SVal l, bool isLoad, const Stmt* S,
35 void ArrayBoundChecker::checkLocation(SVal l, bool isLoad, const Stmt* LoadS,
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 41 void checkLocation(SVal l, bool isLoad, const Stmt*S,
116 const Stmt* LoadS,
tools/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp 891 const Stmt *Element = FCS->getElement();
tools/clang/lib/StaticAnalyzer/Checkers/BoolAssignmentChecker.cpp 28 void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const;
55 void BoolAssignmentChecker::checkBind(SVal loc, SVal val, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp 234 const Stmt *First,
235 const Stmt *Second) const;
237 void emitNullArgBug(CheckerContext &C, ProgramStateRef State, const Stmt *S,
240 const Stmt *S, StringRef WarningMsg) const;
242 const Stmt *S, StringRef WarningMsg) const;
563 const Stmt *First, const Stmt *Second) const {
563 const Stmt *First, const Stmt *Second) const {
582 const Stmt *S, StringRef WarningMsg) const {
599 ProgramStateRef State, const Stmt *S,
621 const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp 108 void VisitChildren(Stmt *S);
109 void VisitStmt(Stmt *S) {
272 void WalkAST::VisitChildren(Stmt *S) {
273 for (Stmt *Child : S->children())
tools/clang/lib/StaticAnalyzer/Checkers/CheckSecuritySyntaxOnly.cpp 88 void VisitStmt(Stmt *S) { VisitChildren(S); }
90 void VisitChildren(Stmt *S);
121 void WalkAST::VisitChildren(Stmt *S) {
122 for (Stmt *Child : S->children())
186 for (Stmt *Child : S->children())
tools/clang/lib/StaticAnalyzer/Checkers/CheckSizeofPointer.cpp 33 void VisitStmt(Stmt *S) { VisitChildren(S); }
34 void VisitChildren(Stmt *S);
38 void WalkAST::VisitChildren(Stmt *S) {
39 for (Stmt *Child : S->children())
tools/clang/lib/StaticAnalyzer/Checkers/CheckerDocumentation.cpp 127 void checkBranchCondition(const Stmt *Condition, CheckerContext &Ctx) const {}
154 void checkLocation(SVal Loc, bool IsLoad, const Stmt *S,
164 void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &) const {}
tools/clang/lib/StaticAnalyzer/Checkers/ConversionChecker.cpp 69 const Stmt *Parent = PM.getParent(Cast);
tools/clang/lib/StaticAnalyzer/Checkers/DeadStoresChecker.cpp 317 void observeStmt(const Stmt *S, const CFGBlock *block,
365 const Stmt *parent = Parents.getParentIgnoreParenCasts(U);
460 void operator()(const Stmt *S) {
tools/clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp 327 class ReportStmts : public Checker<check::PreStmt<Stmt>> {
331 void checkPreStmt(const Stmt *S, CheckerContext &C) const {
tools/clang/lib/StaticAnalyzer/Checkers/DeleteWithNonVirtualDtorChecker.cpp 111 const Stmt *S = N->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/DereferenceChecker.cpp 36 void reportBug(ProgramStateRef State, const Stmt *S, CheckerContext &C) const;
39 void checkLocation(SVal location, bool isLoad, const Stmt* S,
41 void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const;
62 case Stmt::DeclRefExprClass: {
71 case Stmt::MemberExprClass: {
79 case Stmt::ObjCIvarRefExprClass: {
90 static const Expr *getDereferenceExpr(const Stmt *S, bool IsBind=false){
119 void DereferenceChecker::reportBug(ProgramStateRef State, const Stmt *S,
137 case Stmt::ArraySubscriptExprClass: {
145 case Stmt::OMPArraySectionExprClass: {
153 case Stmt::UnaryOperatorClass: {
160 case Stmt::MemberExprClass: {
170 case Stmt::ObjCIvarRefExprClass: {
194 void DereferenceChecker::checkLocation(SVal l, bool isLoad, const Stmt* S,
246 void DereferenceChecker::checkBind(SVal L, SVal V, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/DirectIvarAssignment.cpp 74 void VisitStmt(const Stmt *S) { VisitChildren(S); }
78 void VisitChildren(const Stmt *S) {
79 for (const Stmt *Child : S->children())
146 const Stmt *Body = M->getBody();
tools/clang/lib/StaticAnalyzer/Checkers/DivZeroChecker.cpp 37 const Stmt *S = N->getLocationAs<PreStmt>()->getStmt();
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypeChecker.cpp 60 const MemRegion *Reg, const Stmt *ReportedNode,
71 const Stmt *ReportedNode,
106 const Stmt *S = N->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp 98 const Stmt *ReportedNode = nullptr) const;
902 const Stmt *ReportedNode) const {
940 const Stmt *S = N->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/IdenticalExprChecker.cpp 28 static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
29 const Stmt *Stmt2, bool IgnoreSideEffects = false);
107 const Stmt *Stmt1 = I->getThen();
108 const Stmt *Stmt2 = I->getElse();
137 const Stmt *Else = Stmt2;
306 static bool isIdenticalStmt(const ASTContext &Ctx, const Stmt *Stmt1,
307 const Stmt *Stmt2, bool IgnoreSideEffects) {
351 case Stmt::CallExprClass:
352 case Stmt::ArraySubscriptExprClass:
353 case Stmt::OMPArraySectionExprClass:
354 case Stmt::ImplicitCastExprClass:
355 case Stmt::ParenExprClass:
356 case Stmt::BreakStmtClass:
357 case Stmt::ContinueStmtClass:
358 case Stmt::NullStmtClass:
360 case Stmt::CStyleCastExprClass: {
366 case Stmt::ReturnStmtClass: {
373 case Stmt::ForStmtClass: {
391 case Stmt::DoStmtClass: {
403 case Stmt::WhileStmtClass: {
415 case Stmt::IfStmtClass: {
430 case Stmt::CompoundStmtClass: {
448 case Stmt::CompoundAssignOperatorClass:
449 case Stmt::BinaryOperatorClass: {
454 case Stmt::CharacterLiteralClass: {
459 case Stmt::DeclRefExprClass: {
464 case Stmt::IntegerLiteralClass: {
474 case Stmt::FloatingLiteralClass: {
479 case Stmt::StringLiteralClass: {
484 case Stmt::MemberExprClass: {
489 case Stmt::UnaryOperatorClass: {
tools/clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp 287 const Stmt *S = N->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/IteratorChecker.cpp 255 void checkBind(SVal Loc, SVal Val, const Stmt *S, CheckerContext &C) const;
749 void IteratorChecker::checkBind(SVal Loc, SVal Val, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp 159 void VisitStmt(const Stmt *S) { VisitChildren(S); }
165 void VisitChildren(const Stmt *S) {
166 for (const auto *Child : S->children()) {
tools/clang/lib/StaticAnalyzer/Checkers/LLVMConventionsChecker.cpp 124 void VisitChildren(Stmt *S) {
125 for (Stmt *Child : S->children())
129 void VisitStmt(Stmt *S) { VisitChildren(S); }
tools/clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp 1052 void VisitStmt(const Stmt *S) { VisitChildren(S); }
1058 void VisitChildren(const Stmt *S) {
1059 for (const Stmt *Child : S->children()) {
1079 const Stmt *Body = M->getBody();
1205 llvm::SmallVector<const clang::Stmt *, 8> MatchingStatements;
1224 void reportPluralMisuseError(const Stmt *S) const;
1382 const Stmt *S) const {
tools/clang/lib/StaticAnalyzer/Checkers/MacOSKeychainAPIChecker.cpp 487 const Stmt *AllocStmt = AllocNode->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 97 const Stmt *S);
138 const Stmt *S;
143 RefState(Kind k, const Stmt *s, AllocationFamily family)
155 const Stmt *getStmt() const { return S; }
161 static RefState getAllocated(AllocationFamily family, const Stmt *s) {
168 static RefState getReleased(AllocationFamily family, const Stmt *s) {
171 static RefState getRelinquished(AllocationFamily family, const Stmt *s) {
372 void checkLocation(SVal l, bool isLoad, const Stmt *S,
585 bool checkUseAfterFree(SymbolRef Sym, CheckerContext &C, const Stmt *S) const;
590 const Stmt *S) const;
626 const Stmt *AllocDeallocStmt,
708 const Stmt *Stmt) {
719 const Stmt *Stmt) {
730 const RefState *RSPrev, const Stmt *Stmt) {
744 const Stmt *Stmt) {
1631 const Stmt *S) {
1941 const Stmt *AllocDeallocStmt,
2594 const Stmt *AllocationStmt = AllocNode->getStmtForDiagnostics();
2814 if (const Stmt *Body = FD->getBody())
2837 const Stmt *S) const {
2848 const Stmt *S) const {
2870 void MallocChecker::checkLocation(SVal l, bool isLoad, const Stmt *S,
3179 const Stmt *S = N->getStmtForDiagnostics();
3246 const Stmt *S = RSCurr->getStmt();
tools/clang/lib/StaticAnalyzer/Checkers/MallocSizeofChecker.cpp 31 typedef llvm::PointerUnion<const Stmt *, const VarDecl *> ExprParent;
59 void VisitChild(ExprParent Parent, const Stmt *S) {
66 void VisitChildren(const Stmt *S) {
67 for (const Stmt *Child : S->children())
85 TypeCallPair VisitStmt(const Stmt *S) {
tools/clang/lib/StaticAnalyzer/Checkers/MoveChecker.cpp 292 const Stmt *S = N->getStmtForDiagnostics();
404 if (const Stmt *MoveStmt = MoveNode->getStmtForDiagnostics())
tools/clang/lib/StaticAnalyzer/Checkers/NSErrorChecker.cpp 162 void checkLocation(SVal loc, bool isLoad, const Stmt *S,
202 const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp 43 void checkLocation(SVal l, bool isLoad, const Stmt *S,
68 const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp 96 void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const;
157 const Stmt *ValueExpr = nullptr,
162 const Stmt *ValueExpr = nullptr) const {
199 NullabilityState(Nullability Nullab, const Stmt *Source = nullptr)
202 const Stmt *getNullabilitySource() const { return Source; }
221 const Stmt *Source;
310 const Stmt *S = TrackedNullab->getNullabilitySource();
435 CheckerContext &C, const Stmt *ValueExpr, bool SuppressPath) const {
895 const Stmt *NullabilitySource =
918 const Stmt *NullabilitySource = ComputedNullab == RetNullability
987 static const Expr * matchValueExprForBind(const Stmt *S) {
1011 static bool isARCNilInitializedLocal(CheckerContext &C, const Stmt *S) {
1053 void NullabilityChecker::checkBind(SVal L, SVal V, const Stmt *S,
1102 const Stmt *ValueStmt = S;
1155 const Stmt *NullabilitySource = BinOp ? BinOp->getRHS() : S;
1163 const Stmt *NullabilitySource = BinOp ? BinOp->getLHS() : S;
tools/clang/lib/StaticAnalyzer/Checkers/NumberObjectConversionChecker.cpp 66 (Result.Nodes.getNodeAs<Stmt>("pedantic") != nullptr);
102 const Stmt *Conv = Result.Nodes.getNodeAs<Stmt>("conv");
102 const Stmt *Conv = Result.Nodes.getNodeAs<Stmt>("conv");
116 (Result.Nodes.getNodeAs<Stmt>("comparison") != nullptr);
tools/clang/lib/StaticAnalyzer/Checkers/ObjCContainersASTChecker.cpp 78 void VisitChildren(Stmt *S);
79 void VisitStmt(Stmt *S) { VisitChildren(S); }
153 void WalkAST::VisitChildren(Stmt *S) {
154 for (Stmt *Child : S->children())
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSelfInitChecker.cpp 74 void checkLocation(SVal location, bool isLoad, const Stmt *S,
76 void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const;
301 const Stmt *S,
316 void ObjCSelfInitChecker::checkBind(SVal loc, SVal val, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/ObjCSuperDeallocChecker.cpp 46 void checkLocation(SVal l, bool isLoad, const Stmt *S,
53 void reportUseAfterDealloc(SymbolRef Sym, StringRef Desc, const Stmt *S,
129 void ObjCSuperDeallocChecker::checkLocation(SVal L, bool IsLoad, const Stmt *S,
176 const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/ObjCUnusedIVarsChecker.cpp 32 static void Scan(IvarUsageMap& M, const Stmt *S) {
59 for (const Stmt *SubStmt : S->children())
tools/clang/lib/StaticAnalyzer/Checkers/PointerIterationChecker.cpp 40 const auto *MarkedStmt = Match.getNodeAs<Stmt>(WarnAtNode);
40 const auto *MarkedStmt = Match.getNodeAs<Stmt>(WarnAtNode);
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp 233 for (const Stmt *Child : Ex->children()) {
1137 void RetainCountChecker::checkBind(SVal loc, SVal val, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h 294 void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const;
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp 203 static std::string findAllocatedObjectName(const Stmt *S, QualType QT) {
213 const Stmt *S,
503 const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
555 const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
589 const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
596 for (const Stmt *Child : S->children())
678 const Stmt *CE = CEP->getCallExpr();
680 const Stmt *RecExpr = ME->getInstanceReceiver();
tools/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h 79 const Stmt *AllocStmt;
tools/clang/lib/StaticAnalyzer/Checkers/RunLoopAutoreleaseLeakChecker.cpp 65 static bool seenBefore(const Stmt *Parent, const Stmt *A, const Stmt *B) {
65 static bool seenBefore(const Stmt *Parent, const Stmt *A, const Stmt *B) {
65 static bool seenBefore(const Stmt *Parent, const Stmt *A, const Stmt *B) {
66 for (const Stmt *C : Parent->children()) {
87 const Stmt *DeclBody = D->getBody();
101 const auto *RLR = Match.getNodeAs<Stmt>(RunLoopRunBind);
101 const auto *RLR = Match.getNodeAs<Stmt>(RunLoopRunBind);
tools/clang/lib/StaticAnalyzer/Checkers/StreamChecker.cpp 30 const Stmt *S;
32 StreamState(Kind k, const Stmt *s) : K(k), S(s) {}
43 static StreamState getOpened(const Stmt *s) { return StreamState(Opened, s); }
44 static StreamState getClosed(const Stmt *s) { return StreamState(Closed, s); }
45 static StreamState getOpenFailed(const Stmt *s) {
48 static StreamState getEscaped(const Stmt *s) {
tools/clang/lib/StaticAnalyzer/Checkers/Taint.cpp 44 ProgramStateRef taint::addTaint(ProgramStateRef State, const Stmt *S,
120 bool taint::isTainted(ProgramStateRef State, const Stmt *S,
216 const Stmt *S = N->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/Taint.h 31 addTaint(ProgramStateRef State, const Stmt *S, const LocationContext *LCtx,
60 bool isTainted(ProgramStateRef State, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Checkers/TestAfterDivZeroChecker.cpp 85 void checkBranchCondition(const Stmt *Condition, CheckerContext &C) const;
212 void TestAfterDivZeroChecker::checkBranchCondition(const Stmt *Condition,
tools/clang/lib/StaticAnalyzer/Checkers/TraversalChecker.cpp 30 void checkBranchCondition(const Stmt *Condition, CheckerContext &C) const;
36 void TraversalDumper::checkBranchCondition(const Stmt *Condition,
40 const Stmt *Parent = dyn_cast<ObjCForCollectionStmt>(Condition);
tools/clang/lib/StaticAnalyzer/Checkers/UndefBranchChecker.cpp 40 for (const Stmt *SubStmt : Ex->children())
54 void checkBranchCondition(const Stmt *Condition, CheckerContext &Ctx) const;
59 void UndefBranchChecker::checkBranchCondition(const Stmt *Condition,
tools/clang/lib/StaticAnalyzer/Checkers/UndefCapturedBlockVarChecker.cpp 36 static const DeclRefExpr *FindBlockDeclRefExpr(const Stmt *S,
42 for (const Stmt *Child : S->children())
tools/clang/lib/StaticAnalyzer/Checkers/UndefinedAssignmentChecker.cpp 29 void checkBind(SVal location, SVal val, const Stmt *S,
35 const Stmt *StoreE,
tools/clang/lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp 180 const Stmt *CallSite = Context.getStackFrame()->getCallSite();
515 static const Stmt *getMethodBody(const CXXMethodDecl *M) {
561 const Stmt *MethodBody = getMethodBody(M);
574 const auto *FirstGuard = Guards[0].getNodeAs<Stmt>("guard");
574 const auto *FirstGuard = Guards[0].getNodeAs<Stmt>("guard");
tools/clang/lib/StaticAnalyzer/Checkers/UnreachableCodeChecker.cpp 39 static inline const Stmt *getUnreachableStmt(const CFGBlock *CB);
121 if (const Stmt *label = CB->getLabel())
122 if (label->getStmtClass() == Stmt::DefaultStmtClass)
149 if (const Stmt *S = getUnreachableStmt(CB)) {
155 if (const Stmt *Parent = PM->getParent(S))
200 const Stmt *UnreachableCodeChecker::getUnreachableStmt(const CFGBlock *CB) {
207 if (const Stmt *S = CB->getTerminatorStmt())
235 const Stmt *cond = pred->getTerminatorCondition();
tools/clang/lib/StaticAnalyzer/Checkers/ValistChecker.cpp 287 if (const Stmt *StartCallStmt = StartNode->getStmtForDiagnostics())
383 const Stmt *S = N->getStmtForDiagnostics();
tools/clang/lib/StaticAnalyzer/Checkers/VforkChecker.cpp 63 void checkBind(SVal L, SVal V, const Stmt *S, CheckerContext &C) const;
162 const Stmt *P = PM.getParentIgnoreParenCasts(Call.getOriginExpr());
191 void VforkChecker::checkBind(SVal L, SVal V, const Stmt *S,
tools/clang/lib/StaticAnalyzer/Core/BugReporter.cpp 167 const Stmt *getParent(const Stmt *S) const {
167 const Stmt *getParent(const Stmt *S) const {
251 generateDiagForGotoOP(const PathDiagnosticConstruct &C, const Stmt *S,
259 generateDiagForBinaryOP(const PathDiagnosticConstruct &C, const Stmt *T,
288 const Stmt *CallSite = CExit.getCalleeContext()->getCallSite();
532 const Stmt *Start = CF->getStartLocation().asStmt();
533 const Stmt *End = CF->getEndLocation().asStmt();
576 if (const Stmt *S = C.getCurrentNode()->getNextStmtForDiagnostics())
613 static const Stmt *getEnclosingParent(const Stmt *S, const ParentMap &PM) {
613 static const Stmt *getEnclosingParent(const Stmt *S, const ParentMap &PM) {
617 const Stmt *Parent = PM.getParentIgnoreParens(S);
622 case Stmt::ForStmtClass:
623 case Stmt::DoStmtClass:
624 case Stmt::WhileStmtClass:
625 case Stmt::ObjCForCollectionStmtClass:
626 case Stmt::CXXForRangeStmtClass:
636 getEnclosingStmtLocation(const Stmt *S, const LocationContext *LC,
643 while (const Stmt *Parent = getEnclosingParent(S, LC->getParentMap())) {
645 case Stmt::BinaryOperatorClass: {
651 case Stmt::CompoundStmtClass:
652 case Stmt::StmtExprClass:
654 case Stmt::ChooseExprClass:
661 case Stmt::BinaryConditionalOperatorClass:
662 case Stmt::ConditionalOperatorClass:
670 case Stmt::CXXForRangeStmtClass:
674 case Stmt::DoStmtClass:
676 case Stmt::ForStmtClass:
680 case Stmt::IfStmtClass:
684 case Stmt::ObjCForCollectionStmtClass:
688 case Stmt::WhileStmtClass:
747 if (const Stmt *S = Dst->getLabel()) {
756 case Stmt::DefaultStmtClass:
761 case Stmt::CaseStmtClass: {
796 const PathDiagnosticConstruct &C, const Stmt *S,
807 const PathDiagnosticConstruct &C, const Stmt *T, const CFGBlock *Src,
860 const Stmt *T = Src->getTerminatorStmt();
869 case Stmt::GotoStmtClass:
870 case Stmt::IndirectGotoStmtClass: {
871 if (const Stmt *S = C.getCurrentNode()->getNextStmtForDiagnostics())
876 case Stmt::SwitchStmtClass: {
881 case Stmt::BreakStmtClass:
882 case Stmt::ContinueStmtClass: {
892 case Stmt::BinaryConditionalOperatorClass:
893 case Stmt::ConditionalOperatorClass: {
905 if (const Stmt *S = End.asStmt())
914 case Stmt::BinaryOperatorClass: {
922 case Stmt::DoStmtClass:
930 if (const Stmt *S = End.asStmt())
939 if (const Stmt *S = End.asStmt())
948 case Stmt::WhileStmtClass:
949 case Stmt::ForStmtClass:
956 if (const Stmt *S = End.asStmt())
964 if (const Stmt *S = End.asStmt())
974 case Stmt::IfStmtClass: {
977 if (const Stmt *S = End.asStmt())
998 static bool isLoop(const Stmt *Term) {
1000 case Stmt::ForStmtClass:
1001 case Stmt::WhileStmtClass:
1002 case Stmt::ObjCForCollectionStmtClass:
1003 case Stmt::CXXForRangeStmtClass:
1017 static bool isContainedByStmt(const ParentMap &PM, const Stmt *S,
1018 const Stmt *SubS) {
1027 static const Stmt *getStmtBeforeCond(const ParentMap &PM, const Stmt *Term,
1027 static const Stmt *getStmtBeforeCond(const ParentMap &PM, const Stmt *Term,
1032 const Stmt *S = SP->getStmt();
1041 static bool isInLoopBody(const ParentMap &PM, const Stmt *S, const Stmt *Term) {
1041 static bool isInLoopBody(const ParentMap &PM, const Stmt *S, const Stmt *Term) {
1042 const Stmt *LoopBody = nullptr;
1044 case Stmt::CXXForRangeStmtClass: {
1053 case Stmt::ForStmtClass: {
1060 case Stmt::ObjCForCollectionStmtClass: {
1065 case Stmt::WhileStmtClass:
1102 static const Stmt *getTerminatorCondition(const CFGBlock *B) {
1103 const Stmt *S = B->getTerminatorCondition();
1238 if (const Stmt *Loop = BE->getSrc()->getLoopTarget()) {
1240 const Stmt *Body = nullptr;
1270 if (const Stmt *Term = BSrc->getTerminatorStmt()) {
1274 const Stmt *TermCond = getTerminatorCondition(BSrc);
1332 static const Stmt *getStmtParent(const Stmt *S, const ParentMap &PM) {
1332 static const Stmt *getStmtParent(const Stmt *S, const ParentMap &PM) {
1353 static bool isConditionForTerminator(const Stmt *S, const Stmt *Cond) {
1353 static bool isConditionForTerminator(const Stmt *S, const Stmt *Cond) {
1355 case Stmt::BinaryOperatorClass: {
1361 case Stmt::IfStmtClass:
1363 case Stmt::ForStmtClass:
1365 case Stmt::WhileStmtClass:
1367 case Stmt::DoStmtClass:
1369 case Stmt::ChooseExprClass:
1371 case Stmt::IndirectGotoStmtClass:
1373 case Stmt::SwitchStmtClass:
1375 case Stmt::BinaryConditionalOperatorClass:
1377 case Stmt::ConditionalOperatorClass: {
1383 case Stmt::ObjCForCollectionStmtClass:
1385 case Stmt::CXXForRangeStmtClass: {
1394 static bool isIncrementOrInitInForLoop(const Stmt *S, const Stmt *FL) {
1394 static bool isIncrementOrInitInForLoop(const Stmt *S, const Stmt *FL) {
1424 const Stmt *InnerStmt = nullptr;
1436 const Stmt *Dst = Piece->getEndLocation().getStmtOrNull();
1458 if (const Stmt *PrevSrc =
1460 const Stmt *PrevSrcParent = getStmtParent(PrevSrc, PM);
1498 const Stmt *s1Start = PieceI->getStartLocation().getStmtOrNull();
1499 const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
1532 const Stmt *s2Start = PieceNextI->getStartLocation().getStmtOrNull();
1533 const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
1592 const Stmt *S) {
1622 const Stmt *s1Start = PieceI->getStartLocation().getStmtOrNull();
1623 const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
1646 const Stmt *s2Start = PieceNextI->getStartLocation().getStmtOrNull();
1647 const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
1667 static bool lexicalContains(const ParentMap &PM, const Stmt *X, const Stmt *Y) {
1667 static bool lexicalContains(const ParentMap &PM, const Stmt *X, const Stmt *Y) {
1690 const Stmt *start = PieceI->getStartLocation().getStmtOrNull();
1691 const Stmt *end = PieceI->getEndLocation().getStmtOrNull();
1696 const Stmt *endParent = PM.getParent(end);
1783 const Stmt *s1Start = PieceI->getStartLocation().getStmtOrNull();
1784 const Stmt *s1End = PieceI->getEndLocation().getStmtOrNull();
1785 const Stmt *level1 = getStmtParent(s1Start, PM);
1786 const Stmt *level2 = getStmtParent(s1End, PM);
1799 const Stmt *s2Start = PieceNextI->getStartLocation().getStmtOrNull();
1800 const Stmt *s2End = PieceNextI->getEndLocation().getStmtOrNull();
1801 const Stmt *level3 = getStmtParent(s2Start, PM);
1802 const Stmt *level4 = getStmtParent(s2End, PM);
2309 const Stmt *PathSensitiveBugReport::getStmt() const {
2314 const Stmt *S = nullptr;
2340 const Stmt *S = ErrorNode->getStmtForDiagnostics();
3047 const Stmt* Body = Signature->getBody();
3069 const Stmt *S, const SourceManager &SM,
3095 } else if (const Stmt *S = N->getStmtForDiagnostics()) {
3099 const Stmt *P = N->getParentMap().getParent(S);
tools/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp 97 const Expr *bugreporter::getDerefExpr(const Stmt *S) {
853 const Stmt *S = N->getStmtForDiagnostics();
924 static void addVisitorIfNecessary(const ExplodedNode *Node, const Stmt *S,
1468 const Stmt *S = PS->getStmt();
1665 const Stmt *CurTerminatorStmt = nullptr;
1669 const Stmt *CurStmt = SP->getStmt();
1777 if (const Stmt *ElseCond = Else->getTerminatorCondition())
1883 if (const Stmt *term = srcBlk->getTerminatorStmt()) {
2080 const Expr *NilReceiverBRVisitor::getNilReceiver(const Stmt *S,
2101 const Stmt *S = P->getStmt();
2163 if (const Stmt *Term = SrcBlock->getTerminatorStmt()) {
2191 const Stmt *Term, const ExplodedNode *N, const CFGBlock *srcBlk,
2214 case Stmt::IfStmtClass:
2217 case Stmt::ConditionalOperatorClass:
2220 case Stmt::BinaryOperatorClass:
2274 case Stmt::BinaryOperatorClass:
2279 case Stmt::DeclRefExprClass:
2284 case Stmt::MemberExprClass:
2289 case Stmt::UnaryOperatorClass: {
tools/clang/lib/StaticAnalyzer/Core/CallEvent.cpp 456 bool CallEvent::isCallStmt(const Stmt *S) {
556 Stmt* Body = AD->getBody(IsAutosynthesized);
1041 const Stmt *S = PM.getParentIgnoreParenCasts(getOriginExpr());
1049 case Stmt::ObjCPropertyRefExprClass:
1052 case Stmt::ObjCSubscriptRefExprClass:
1386 const Stmt *CallSite = CalleeCtx->getCallSite();
1417 const Stmt *Trigger;
1430 CallEventRef<> CallEventManager::getCall(const Stmt *S, ProgramStateRef State,
tools/clang/lib/StaticAnalyzer/Core/CheckerHelpers.cpp 22 bool containsMacro(const Stmt *S) {
29 for (const Stmt *Child : S->children())
37 bool containsEnum(const Stmt *S) {
43 for (const Stmt *Child : S->children())
51 bool containsStaticLocal(const Stmt *S) {
59 for (const Stmt *Child : S->children())
67 bool containsBuiltinOffsetOf(const Stmt *S) {
71 for (const Stmt *Child : S->children())
80 parseAssignment(const Stmt *S) {
tools/clang/lib/StaticAnalyzer/Core/CheckerManager.cpp 157 const Stmt *S;
162 const Stmt *s, ExprEngine &eng, bool wasInlined = false)
187 const Stmt *S,
319 const Stmt *NodeEx; /* Will become a CFGStmt */
320 const Stmt *BoundEx;
324 SVal loc, bool isLoad, const Stmt *NodeEx,
325 const Stmt *BoundEx,
353 const Stmt *NodeEx,
354 const Stmt *BoundEx,
369 const Stmt *S;
374 SVal loc, SVal val, const Stmt *s, ExprEngine &eng,
396 const Stmt *S, ExprEngine &Eng,
472 const Stmt *Condition;
476 const Stmt *Cond, ExprEngine &eng)
494 void CheckerManager::runCheckersForBranchCondition(const Stmt *Condition,
556 const Stmt *S;
561 const Stmt *s, ExprEngine &eng,
587 const Stmt *S,
tools/clang/lib/StaticAnalyzer/Core/CoreEngine.cpp 297 if (const Stmt *Term = B->getTerminatorStmt()) {
302 case Stmt::CXXBindTemporaryExprClass:
308 case Stmt::DeclStmtClass:
312 case Stmt::BinaryOperatorClass: // '&&' and '||'
316 case Stmt::BinaryConditionalOperatorClass:
317 case Stmt::ConditionalOperatorClass:
325 case Stmt::ChooseExprClass:
329 case Stmt::CXXTryStmtClass:
341 case Stmt::DoStmtClass:
345 case Stmt::CXXForRangeStmtClass:
349 case Stmt::ForStmtClass:
353 case Stmt::ContinueStmtClass:
354 case Stmt::BreakStmtClass:
355 case Stmt::GotoStmtClass:
358 case Stmt::IfStmtClass:
362 case Stmt::IndirectGotoStmtClass: {
374 case Stmt::ObjCForCollectionStmtClass:
388 case Stmt::SwitchStmtClass: {
396 case Stmt::WhileStmtClass:
400 case Stmt::GCCAsmStmtClass:
424 void CoreEngine::HandleBranch(const Stmt *Cond, const Stmt *Term,
424 void CoreEngine::HandleBranch(const Stmt *Cond, const Stmt *Term,
tools/clang/lib/StaticAnalyzer/Core/Environment.cpp 41 case Stmt::OpaqueValueExprClass:
44 case Stmt::ExprWithCleanupsClass:
47 case Stmt::ConstantExprClass:
50 case Stmt::CXXBindTemporaryExprClass:
53 case Stmt::SubstNonTypeTemplateParmExprClass:
64 static const Stmt *ignoreTransparentExprs(const Stmt *S) {
64 static const Stmt *ignoreTransparentExprs(const Stmt *S) {
70 EnvironmentEntry::EnvironmentEntry(const Stmt *S, const LocationContext *L)
87 const Stmt *S = Entry.getStmt();
91 case Stmt::CXXBindTemporaryExprClass:
92 case Stmt::ExprWithCleanupsClass:
93 case Stmt::GenericSelectionExprClass:
94 case Stmt::OpaqueValueExprClass:
95 case Stmt::ConstantExprClass:
96 case Stmt::ParenExprClass:
97 case Stmt::SubstNonTypeTemplateParmExprClass:
100 case Stmt::AddrLabelExprClass:
101 case Stmt::CharacterLiteralClass:
102 case Stmt::CXXBoolLiteralExprClass:
103 case Stmt::CXXScalarValueInitExprClass:
104 case Stmt::ImplicitValueInitExprClass:
105 case Stmt::IntegerLiteralClass:
106 case Stmt::ObjCBoolLiteralExprClass:
107 case Stmt::CXXNullPtrLiteralExprClass:
108 case Stmt::ObjCStringLiteralClass:
109 case Stmt::StringLiteralClass:
110 case Stmt::TypeTraitExprClass:
111 case Stmt::SizeOfPackExprClass:
115 case Stmt::ReturnStmtClass: {
252 const Stmt *S = I->first.getStmt();
264 const Stmt *S = I->first.getStmt();
tools/clang/lib/StaticAnalyzer/Core/ExplodedGraph.cpp 300 if (const Stmt *S = getStmtForDiagnostics())
322 const Stmt *ExplodedNode::getStmtForDiagnostics() const {
353 const Stmt *ExplodedNode::getNextStmtForDiagnostics() const {
355 if (const Stmt *S = N->getStmtForDiagnostics()) {
359 case Stmt::ChooseExprClass:
360 case Stmt::BinaryConditionalOperatorClass:
361 case Stmt::ConditionalOperatorClass:
363 case Stmt::BinaryOperatorClass: {
380 const Stmt *ExplodedNode::getPreviousStmtForDiagnostics() const {
382 if (const Stmt *S = N->getStmtForDiagnostics())
388 const Stmt *ExplodedNode::getCurrentOrPreviousStmtForDiagnostics() const {
389 if (const Stmt *S = getStmtForDiagnostics())
tools/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp 127 if (const Stmt *S = getItem().getStmtOrNull())
147 const Stmt *S = getItem().getStmtOrNull();
664 const Stmt *S,
690 const Stmt *ReferenceStmt,
692 const Stmt *DiagnosticStmt,
768 void ExprEngine::ProcessStmt(const Stmt *currStmt, ExplodedNode *Pred) {
798 void ExprEngine::ProcessLoopExit(const Stmt* S, ExplodedNode *Pred) {
990 const Stmt *Arg = DE->getArgument();
1196 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
1208 case Stmt::CXXDependentScopeMemberExprClass:
1209 case Stmt::CXXInheritedCtorInitExprClass:
1210 case Stmt::CXXTryStmtClass:
1211 case Stmt::CXXTypeidExprClass:
1212 case Stmt::CXXUuidofExprClass:
1213 case Stmt::CXXFoldExprClass:
1214 case Stmt::MSPropertyRefExprClass:
1215 case Stmt::MSPropertySubscriptExprClass:
1216 case Stmt::CXXUnresolvedConstructExprClass:
1217 case Stmt::DependentScopeDeclRefExprClass:
1218 case Stmt::ArrayTypeTraitExprClass:
1219 case Stmt::ExpressionTraitExprClass:
1220 case Stmt::UnresolvedLookupExprClass:
1221 case Stmt::UnresolvedMemberExprClass:
1222 case Stmt::TypoExprClass:
1223 case Stmt::CXXNoexceptExprClass:
1224 case Stmt::PackExpansionExprClass:
1225 case Stmt::SubstNonTypeTemplateParmPackExprClass:
1226 case Stmt::FunctionParmPackExprClass:
1227 case Stmt::CoroutineBodyStmtClass:
1228 case Stmt::CoawaitExprClass:
1229 case Stmt::DependentCoawaitExprClass:
1230 case Stmt::CoreturnStmtClass:
1231 case Stmt::CoyieldExprClass:
1232 case Stmt::SEHTryStmtClass:
1233 case Stmt::SEHExceptStmtClass:
1234 case Stmt::SEHLeaveStmtClass:
1235 case Stmt::SEHFinallyStmtClass:
1236 case Stmt::OMPParallelDirectiveClass:
1237 case Stmt::OMPSimdDirectiveClass:
1238 case Stmt::OMPForDirectiveClass:
1239 case Stmt::OMPForSimdDirectiveClass:
1240 case Stmt::OMPSectionsDirectiveClass:
1241 case Stmt::OMPSectionDirectiveClass:
1242 case Stmt::OMPSingleDirectiveClass:
1243 case Stmt::OMPMasterDirectiveClass:
1244 case Stmt::OMPCriticalDirectiveClass:
1245 case Stmt::OMPParallelForDirectiveClass:
1246 case Stmt::OMPParallelForSimdDirectiveClass:
1247 case Stmt::OMPParallelSectionsDirectiveClass:
1248 case Stmt::OMPTaskDirectiveClass:
1249 case Stmt::OMPTaskyieldDirectiveClass:
1250 case Stmt::OMPBarrierDirectiveClass:
1251 case Stmt::OMPTaskwaitDirectiveClass:
1252 case Stmt::OMPTaskgroupDirectiveClass:
1253 case Stmt::OMPFlushDirectiveClass:
1254 case Stmt::OMPOrderedDirectiveClass:
1255 case Stmt::OMPAtomicDirectiveClass:
1256 case Stmt::OMPTargetDirectiveClass:
1257 case Stmt::OMPTargetDataDirectiveClass:
1258 case Stmt::OMPTargetEnterDataDirectiveClass:
1259 case Stmt::OMPTargetExitDataDirectiveClass:
1260 case Stmt::OMPTargetParallelDirectiveClass:
1261 case Stmt::OMPTargetParallelForDirectiveClass:
1262 case Stmt::OMPTargetUpdateDirectiveClass:
1263 case Stmt::OMPTeamsDirectiveClass:
1264 case Stmt::OMPCancellationPointDirectiveClass:
1265 case Stmt::OMPCancelDirectiveClass:
1266 case Stmt::OMPTaskLoopDirectiveClass:
1267 case Stmt::OMPTaskLoopSimdDirectiveClass:
1268 case Stmt::OMPMasterTaskLoopDirectiveClass:
1269 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
1270 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
1271 case Stmt::OMPDistributeDirectiveClass:
1272 case Stmt::OMPDistributeParallelForDirectiveClass:
1273 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
1274 case Stmt::OMPDistributeSimdDirectiveClass:
1275 case Stmt::OMPTargetParallelForSimdDirectiveClass:
1276 case Stmt::OMPTargetSimdDirectiveClass:
1277 case Stmt::OMPTeamsDistributeDirectiveClass:
1278 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
1279 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
1280 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
1281 case Stmt::OMPTargetTeamsDirectiveClass:
1282 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
1283 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
1284 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
1285 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
1286 case Stmt::CapturedStmtClass: {
1292 case Stmt::ParenExprClass:
1294 case Stmt::GenericSelectionExprClass:
1298 case Stmt::BreakStmtClass:
1299 case Stmt::CaseStmtClass:
1300 case Stmt::CompoundStmtClass:
1301 case Stmt::ContinueStmtClass:
1302 case Stmt::CXXForRangeStmtClass:
1303 case Stmt::DefaultStmtClass:
1304 case Stmt::DoStmtClass:
1305 case Stmt::ForStmtClass:
1306 case Stmt::GotoStmtClass:
1307 case Stmt::IfStmtClass:
1308 case Stmt::IndirectGotoStmtClass:
1309 case Stmt::LabelStmtClass:
1310 case Stmt::NoStmtClass:
1311 case Stmt::NullStmtClass:
1312 case Stmt::SwitchStmtClass:
1313 case Stmt::WhileStmtClass:
1317 case Stmt::ObjCSubscriptRefExprClass:
1318 case Stmt::ObjCPropertyRefExprClass:
1321 case Stmt::GNUNullExprClass: {
1330 case Stmt::ObjCAtSynchronizedStmtClass:
1337 case Stmt::ExprWithCleanupsClass:
1341 case Stmt::CXXBindTemporaryExprClass: {
1353 case Stmt::DesignatedInitExprClass:
1354 case Stmt::DesignatedInitUpdateExprClass:
1355 case Stmt::ArrayInitLoopExprClass:
1356 case Stmt::ArrayInitIndexExprClass:
1357 case Stmt::ExtVectorElementExprClass:
1358 case Stmt::ImaginaryLiteralClass:
1359 case Stmt::ObjCAtCatchStmtClass:
1360 case Stmt::ObjCAtFinallyStmtClass:
1361 case Stmt::ObjCAtTryStmtClass:
1362 case Stmt::ObjCAutoreleasePoolStmtClass:
1363 case Stmt::ObjCEncodeExprClass:
1364 case Stmt::ObjCIsaExprClass:
1365 case Stmt::ObjCProtocolExprClass:
1366 case Stmt::ObjCSelectorExprClass:
1367 case Stmt::ParenListExprClass:
1368 case Stmt::ShuffleVectorExprClass:
1369 case Stmt::ConvertVectorExprClass:
1370 case Stmt::VAArgExprClass:
1371 case Stmt::CUDAKernelCallExprClass:
1372 case Stmt::OpaqueValueExprClass:
1373 case Stmt::AsTypeExprClass:
1374 case Stmt::ConceptSpecializationExprClass:
1375 case Stmt::CXXRewrittenBinaryOperatorClass:
1380 case Stmt::PredefinedExprClass:
1381 case Stmt::AddrLabelExprClass:
1382 case Stmt::AttributedStmtClass:
1383 case Stmt::IntegerLiteralClass:
1384 case Stmt::FixedPointLiteralClass:
1385 case Stmt::CharacterLiteralClass:
1386 case Stmt::ImplicitValueInitExprClass:
1387 case Stmt::CXXScalarValueInitExprClass:
1388 case Stmt::CXXBoolLiteralExprClass:
1389 case Stmt::ObjCBoolLiteralExprClass:
1390 case Stmt::ObjCAvailabilityCheckExprClass:
1391 case Stmt::FloatingLiteralClass:
1392 case Stmt::NoInitExprClass:
1393 case Stmt::SizeOfPackExprClass:
1394 case Stmt::StringLiteralClass:
1395 case Stmt::SourceLocExprClass:
1396 case Stmt::ObjCStringLiteralClass:
1397 case Stmt::CXXPseudoDestructorExprClass:
1398 case Stmt::SubstNonTypeTemplateParmExprClass:
1399 case Stmt::CXXNullPtrLiteralExprClass:
1400 case Stmt::OMPArraySectionExprClass:
1401 case Stmt::TypeTraitExprClass: {
1410 case Stmt::CXXDefaultArgExprClass:
1411 case Stmt::CXXDefaultInitExprClass: {
1454 case Stmt::CXXStdInitializerListExprClass:
1495 case Stmt::ArraySubscriptExprClass:
1501 case Stmt::GCCAsmStmtClass:
1507 case Stmt::MSAsmStmtClass:
1513 case Stmt::BlockExprClass:
1519 case Stmt::LambdaExprClass:
1530 case Stmt::BinaryOperatorClass: {
1562 case Stmt::CXXOperatorCallExprClass: {
1587 case Stmt::CallExprClass:
1588 case Stmt::CXXMemberCallExprClass:
1589 case Stmt::UserDefinedLiteralClass:
1595 case Stmt::CXXCatchStmtClass:
1601 case Stmt::CXXTemporaryObjectExprClass:
1602 case Stmt::CXXConstructExprClass:
1608 case Stmt::CXXNewExprClass: {
1623 case Stmt::CXXDeleteExprClass: {
1638 case Stmt::ChooseExprClass: { // __builtin_choose_expr
1646 case Stmt::CompoundAssignOperatorClass:
1652 case Stmt::CompoundLiteralExprClass:
1658 case Stmt::BinaryConditionalOperatorClass:
1659 case Stmt::ConditionalOperatorClass: { // '?' operator
1667 case Stmt::CXXThisExprClass:
1673 case Stmt::DeclRefExprClass: {
1681 case Stmt::DeclStmtClass:
1687 case Stmt::ImplicitCastExprClass:
1688 case Stmt::CStyleCastExprClass:
1689 case Stmt::CXXStaticCastExprClass:
1690 case Stmt::CXXDynamicCastExprClass:
1691 case Stmt::CXXReinterpretCastExprClass:
1692 case Stmt::CXXConstCastExprClass:
1693 case Stmt::CXXFunctionalCastExprClass:
1694 case Stmt::BuiltinBitCastExprClass:
1695 case Stmt::ObjCBridgedCastExprClass: {
1720 case Stmt::InitListExprClass:
1726 case Stmt::MemberExprClass:
1732 case Stmt::AtomicExprClass:
1738 case Stmt::ObjCIvarRefExprClass:
1744 case Stmt::ObjCForCollectionStmtClass:
1750 case Stmt::ObjCMessageExprClass:
1756 case Stmt::ObjCAtThrowStmtClass:
1757 case Stmt::CXXThrowExprClass:
1763 case Stmt::ReturnStmtClass:
1769 case Stmt::OffsetOfExprClass: {
1783 case Stmt::UnaryExprOrTypeTraitExprClass:
1790 case Stmt::StmtExprClass: {
1811 case Stmt::UnaryOperatorClass: {
1825 case Stmt::PseudoObjectExprClass: {
1851 const Stmt *CE = CalleeSF->getCallSite();
1917 const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminatorStmt();
1938 const Stmt *Term = nodeBuilder.getContext().getBlock()->getTerminatorStmt();
1991 const Stmt *Condition,
2028 static const Stmt *getRightmostLeaf(const Stmt *Condition) {
2028 static const Stmt *getRightmostLeaf(const Stmt *Condition) {
2054 static const Stmt *ResolveCondition(const Stmt *Condition,
2054 static const Stmt *ResolveCondition(const Stmt *Condition,
2080 const Stmt *LastStmt = CS->getStmt();
2087 void ExprEngine::processBranch(const Stmt *Condition,
2759 void ExprEngine::evalBind(ExplodedNodeSet &Dst, const Stmt *StoreE,
2878 const Stmt *NodeEx,
2879 const Stmt *BoundEx,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp 603 const Stmt *S,
tools/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp 72 static std::pair<const Stmt*,
74 const Stmt *S = nullptr;
164 const Stmt *LastSt = nullptr;
212 const Stmt *CE = calleeCtx->getCallSite();
215 const Stmt *LastSt = nullptr;
485 const Stmt *CallE) {
tools/clang/lib/StaticAnalyzer/Core/ExprEngineObjC.cpp 48 const ObjCForCollectionStmt *S, const Stmt *elem, SVal elementV,
114 const Stmt *elem = S->getElement();
115 const Stmt *collection = S->getCollection();
tools/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp 200 if (const Stmt *Body = DeclWithIssue->getBody()) {
tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp 30 const Stmt *LoopStmt;
33 LoopState(Kind InK, const Stmt *S, const LocationContext *L, unsigned N)
37 static LoopState getNormal(const Stmt *S, const LocationContext *L,
41 static LoopState getUnrolled(const Stmt *S, const LocationContext *L,
47 const Stmt *getLoopStmt() const { return LoopStmt; }
71 static bool isLoopStmt(const Stmt *S) {
75 ProgramStateRef processLoopEnd(const Stmt *LoopStmt, ProgramStateRef State) {
82 static internal::Matcher<Stmt> simpleCondition(StringRef BindName) {
93 static internal::Matcher<Stmt>
104 static internal::Matcher<Stmt>
111 static internal::Matcher<Stmt>
120 static internal::Matcher<Stmt>
127 static internal::Matcher<Stmt> hasSuspiciousStmt(StringRef NodeName) {
139 static internal::Matcher<Stmt> forLoopMatcher() {
170 const Stmt *S = N->getStmtForDiagnostics();
199 bool shouldCompletelyUnroll(const Stmt *LoopStmt, ASTContext &ASTCtx,
231 bool madeNewBranch(ExplodedNode *N, const Stmt *LoopStmt) {
232 const Stmt *S = nullptr;
251 ProgramStateRef updateLoopStack(const Stmt *LoopStmt, ASTContext &ASTCtx,
tools/clang/lib/StaticAnalyzer/Core/LoopWidening.cpp 28 static const Expr *getLoopCondition(const Stmt *LoopStmt) {
32 case Stmt::ForStmtClass:
34 case Stmt::WhileStmtClass:
36 case Stmt::DoStmtClass:
46 unsigned BlockCount, const Stmt *LoopStmt) {
tools/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp 728 if (const Stmt *Body = DeclWithIssue->getBody()) {
tools/clang/lib/StaticAnalyzer/Core/ProgramState.cpp 302 ProgramStateRef ProgramState::BindExpr(const Stmt *S,
tools/clang/lib/StaticAnalyzer/Core/SValBuilder.cpp 172 DefinedOrUnknownSVal SValBuilder::conjureSymbolVal(const Stmt *stmt,
291 case Stmt::AddrLabelExprClass:
294 case Stmt::CXXScalarValueInitExprClass:
295 case Stmt::ImplicitValueInitExprClass:
298 case Stmt::ObjCStringLiteralClass: {
303 case Stmt::StringLiteralClass: {
310 case Stmt::CharacterLiteralClass: {
315 case Stmt::CXXBoolLiteralExprClass:
318 case Stmt::TypeTraitExprClass: {
323 case Stmt::IntegerLiteralClass:
326 case Stmt::ObjCBoolLiteralExprClass:
329 case Stmt::CXXNullPtrLiteralExprClass:
332 case Stmt::CStyleCastExprClass:
333 case Stmt::CXXFunctionalCastExprClass:
334 case Stmt::CXXConstCastExprClass:
335 case Stmt::CXXReinterpretCastExprClass:
336 case Stmt::CXXStaticCastExprClass:
337 case Stmt::ImplicitCastExprClass: {
tools/clang/lib/StaticAnalyzer/Core/SymbolManager.cpp 183 const SymbolConjured* SymbolManager::conjureSymbol(const Stmt *E,
236 SymbolManager::getMetadataSymbol(const MemRegion* R, const Stmt *S, QualType T,
511 SymbolReaper::isLive(const Stmt *ExprVal, const LocationContext *ELCtx) const {
tools/clang/lib/StaticAnalyzer/Frontend/AnalysisConsumer.cpp 752 const Stmt *Body = D->getBody();
tools/clang/lib/StaticAnalyzer/Frontend/FrontendActions.cpp 20 ParseModelFileAction::ParseModelFileAction(llvm::StringMap<Stmt *> &Bodies)
tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp 30 Stmt *ModelInjector::getBody(const FunctionDecl *D) {
35 Stmt *ModelInjector::getBody(const ObjCMethodDecl *D) {
tools/clang/lib/StaticAnalyzer/Frontend/ModelInjector.h 41 Stmt *getBody(const FunctionDecl *D) override;
42 Stmt *getBody(const ObjCMethodDecl *D) override;
64 llvm::StringMap<Stmt *> Bodies;
tools/clang/lib/Tooling/ASTDiff/ASTDiff.cpp 116 Impl(SyntaxTree *Parent, Stmt *N, ASTContext &AST);
158 std::string getStmtValue(const Stmt *S) const;
166 static bool isSpecializedNodeExcluded(const Stmt *S) { return false; }
172 static bool isNodeExcluded(const SourceManager &SrcMgr, T *N) {
196 template <class T> std::tuple<NodeId, NodeId> PreTraverse(T *ASTNode) {
239 bool TraverseStmt(Stmt *S) {
273 SyntaxTree::Impl::Impl(SyntaxTree *Parent, Stmt *N, ASTContext &AST)
384 const Stmt *S) {
392 S = P.get<Stmt>();
414 if (auto *S = DTN.get<Stmt>())
446 std::string SyntaxTree::Impl::getStmtValue(const Stmt *S) const {
tools/clang/lib/Tooling/Refactoring/ASTSelection.cpp 112 bool TraverseStmt(Stmt *S) {
223 } else if (const Stmt *S = Node.Node.get<Stmt>()) {
223 } else if (const Stmt *S = Node.Node.get<Stmt>()) {
265 getSelectionCanonizalizationAction(const Stmt *S, const Stmt *Parent) {
265 getSelectionCanonizalizationAction(const Stmt *S, const Stmt *Parent) {
291 const Stmt *S = Node.get().Node.get<Stmt>();
291 const Stmt *S = Node.get().Node.get<Stmt>();
293 const Stmt *Parent = Parents[Parents.size() - 1].get().Node.get<Stmt>();
293 const Stmt *Parent = Parents[Parents.size() - 1].get().Node.get<Stmt>();
301 const Stmt *NewParent =
302 Parents[Parents.size() - ParentIndex - 1].get().Node.get<Stmt>();
393 if (!Selected.Node.get().Node.get<Stmt>())
395 const Stmt *CodeRangeStmt = Selected.Node.get().Node.get<Stmt>();
395 const Stmt *CodeRangeStmt = Selected.Node.get().Node.get<Stmt>();
tools/clang/lib/Tooling/Refactoring/Extract/Extract.cpp 34 case Stmt::DeclRefExprClass:
35 case Stmt::PredefinedExprClass:
36 case Stmt::IntegerLiteralClass:
37 case Stmt::FloatingLiteralClass:
38 case Stmt::ImaginaryLiteralClass:
39 case Stmt::CharacterLiteralClass:
40 case Stmt::StringLiteralClass:
tools/clang/lib/Tooling/Refactoring/Extract/SourceExtraction.cpp 29 bool isSemicolonRequiredAfter(const Stmt *S) {
48 case Stmt::DeclStmtClass:
49 case Stmt::CXXTryStmtClass:
50 case Stmt::ObjCAtSynchronizedStmtClass:
51 case Stmt::ObjCAutoreleasePoolStmtClass:
52 case Stmt::ObjCAtTryStmtClass:
72 ExtractionSemicolonPolicy::compute(const Stmt *S, SourceRange &ExtractedRange,
tools/clang/lib/Tooling/RefactoringCallbacks.cpp 72 static Replacement replaceStmtWithText(SourceManager &Sources, const Stmt &From,
77 static Replacement replaceStmtWithStmt(SourceManager &Sources, const Stmt &From,
78 const Stmt &To) {
90 if (const Stmt *FromMatch = Result.Nodes.getNodeAs<Stmt>(FromId)) {
90 if (const Stmt *FromMatch = Result.Nodes.getNodeAs<Stmt>(FromId)) {
108 const Stmt *FromMatch = Result.Nodes.getNodeAs<Stmt>(FromId);
108 const Stmt *FromMatch = Result.Nodes.getNodeAs<Stmt>(FromId);
109 const Stmt *ToMatch = Result.Nodes.getNodeAs<Stmt>(ToId);
109 const Stmt *ToMatch = Result.Nodes.getNodeAs<Stmt>(ToId);
129 const Stmt *Body = PickTrueBranch ? Node->getThen() : Node->getElse();
tools/clang/lib/Tooling/Syntax/BuildTree.cpp 86 llvm::ArrayRef<syntax::Token> getRange(const Stmt *S) const {
tools/clang/lib/Tooling/Transformer/RangeSelector.cpp 134 return Node->get<Stmt>() != nullptr && Node->get<Expr>() == nullptr
tools/clang/tools/clang-extdef-mapping/ClangExtDefMapGen.cpp 64 if (const Stmt *Body = FD->getBody())
tools/clang/tools/extra/clang-tidy/abseil/StrCatAppendCheck.cpp 24 const Stmt *E = &Node;
tools/clang/tools/extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.cpp 142 internal::Matcher<Stmt> IsInsideTemplate =
tools/clang/tools/extra/clang-tidy/bugprone/AssertSideEffectCheck.cpp 104 SourceLocation Loc = Result.Nodes.getNodeAs<Stmt>("condStmt")->getBeginLoc();
tools/clang/tools/extra/clang-tidy/bugprone/BranchCloneCheck.cpp 20 static bool areStatementsIdentical(const Stmt *LHS, const Stmt *RHS,
20 static bool areStatementsIdentical(const Stmt *LHS, const Stmt *RHS,
31 using SwitchBranch = llvm::SmallVector<const Stmt *, 2>;
74 const Stmt *Then = IS->getThen();
77 const Stmt *Else = Result.Nodes.getNodeAs<Stmt>("else");
77 const Stmt *Else = Result.Nodes.getNodeAs<Stmt>("else");
92 llvm::SmallVector<const Stmt *, 4> Branches;
176 for (const Stmt *S : Body->body()) {
tools/clang/tools/extra/clang-tidy/bugprone/DanglingHandleCheck.cpp 24 ast_matchers::internal::BindableMatcher<Stmt>
35 ast_matchers::internal::Matcher<Stmt> handleFromTemporaryValue(
62 ast_matchers::internal::BindableMatcher<Stmt> makeContainerMatcher(
179 diag(Result.Nodes.getNodeAs<Stmt>("bad_stmt")->getBeginLoc(),
tools/clang/tools/extra/clang-tidy/bugprone/InfiniteLoopCheck.cpp 20 static internal::Matcher<Stmt>
21 loopEndingStmt(internal::Matcher<Stmt> Internal) {
28 static bool isAccessForVar(const Stmt *S, const VarDecl *Var) {
36 static bool isPtrOrReferenceForVar(const Stmt *S, const VarDecl *Var) {
54 static bool hasPtrOrReferenceInStmt(const Stmt *S, const VarDecl *Var) {
58 for (const Stmt *Child : S->children()) {
76 static bool isChanged(const Stmt *LoopStmt, const VarDecl *Var,
93 const Stmt *LoopStmt, const Stmt *Cond,
93 const Stmt *LoopStmt, const Stmt *Cond,
120 const Stmt *LoopStmt, const Stmt *Cond,
120 const Stmt *LoopStmt, const Stmt *Cond,
125 for (const Stmt *Child : Cond->children()) {
136 static std::string getCondVarNames(const Stmt *Cond) {
143 for (const Stmt *Child : Cond->children()) {
170 const auto *LoopStmt = Result.Nodes.getNodeAs<Stmt>("loop-stmt");
170 const auto *LoopStmt = Result.Nodes.getNodeAs<Stmt>("loop-stmt");
tools/clang/tools/extra/clang-tidy/bugprone/MultipleStatementMacroCheck.cpp 24 const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
24 const Stmt *nextStmt(const MatchFinder::MatchResult &Result, const Stmt *S) {
28 const auto *Parent = Parents[0].get<Stmt>();
28 const auto *Parent = Parents[0].get<Stmt>();
31 const Stmt *Prev = nullptr;
32 for (const Stmt *Child : Parent->children()) {
70 const auto *Outer = Result.Nodes.getNodeAs<Stmt>("outer");
70 const auto *Outer = Result.Nodes.getNodeAs<Stmt>("outer");
71 const auto *Next = nextStmt(Result, Outer);
76 if (Result.Nodes.getNodeAs<Stmt>("else"))
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousSemicolonCheck.cpp 47 const auto *Statement = Result.Nodes.getNodeAs<Stmt>("stmt");
47 const auto *Statement = Result.Nodes.getNodeAs<Stmt>("stmt");
tools/clang/tools/extra/clang-tidy/bugprone/SuspiciousStringCompareCheck.cpp 174 if (Result.Nodes.getNodeAs<Stmt>("missing-comparison")) {
198 if (Result.Nodes.getNodeAs<Stmt>("invalid-comparison")) {
210 if (Result.Nodes.getNodeAs<Stmt>("invalid-conversion")) {
tools/clang/tools/extra/clang-tidy/bugprone/UndelegatedConstructorCheck.cpp 22 const Stmt *E = &Node;
tools/clang/tools/extra/clang-tidy/bugprone/UseAfterMoveCheck.cpp 45 bool find(Stmt *FunctionBody, const Expr *MovingCall,
54 llvm::SmallPtrSetImpl<const Stmt *> *Reinits);
58 llvm::SmallPtrSetImpl<const Stmt *> *Stmts,
86 bool UseAfterMoveFinder::find(Stmt *FunctionBody, const Expr *MovingCall,
130 llvm::SmallPtrSet<const Stmt *, 1> Reinits;
135 llvm::SmallVector<const Stmt *, 1> ReinitsToDelete;
136 for (const Stmt *Reinit : Reinits) {
140 for (const Stmt *Reinit : ReinitsToDelete) {
151 for (const Stmt *Reinit : Reinits) {
187 llvm::SmallPtrSetImpl<const Stmt *> *Reinits) {
269 llvm::SmallPtrSetImpl<const Stmt *> *Stmts,
340 const auto *TheStmt = Match.getNodeAs<Stmt>("reinit");
340 const auto *TheStmt = Match.getNodeAs<Stmt>("reinit");
417 Stmt *FunctionBody = nullptr;
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeMemberInitCheck.cpp 48 const Stmt &Stmt, ASTContext &Context,
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/ProTypeVarargCheck.cpp 19 const internal::VariadicDynCastAllOfMatcher<Stmt, VAArgExpr> vAArgExpr;
tools/clang/tools/extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp 234 static bool isInTemplate(const NodeType &Node,
236 internal::Matcher<NodeType> IsInsideTemplate =
277 IsInTemplate = isInTemplate<Stmt>(*Call, Result);
282 IsInTemplate = isInTemplate<Stmt>(*Ref, Result);
tools/clang/tools/extra/clang-tidy/misc/RedundantExpressionCheck.cpp 87 case Stmt::CharacterLiteralClass:
90 case Stmt::IntegerLiteralClass: {
96 case Stmt::FloatingLiteralClass:
99 case Stmt::StringLiteralClass:
102 case Stmt::CXXOperatorCallExprClass:
105 case Stmt::DependentScopeDeclRefExprClass:
112 case Stmt::DeclRefExprClass:
115 case Stmt::MemberExprClass:
118 case Stmt::CXXFunctionalCastExprClass:
119 case Stmt::CStyleCastExprClass:
122 case Stmt::CallExprClass:
123 case Stmt::ImplicitCastExprClass:
124 case Stmt::ArraySubscriptExprClass:
126 case Stmt::UnaryOperatorClass:
131 case Stmt::BinaryOperatorClass:
tools/clang/tools/extra/clang-tidy/misc/StaticAssertCheck.cpp 83 const auto *CondStmt = Result.Nodes.getNodeAs<Stmt>("condStmt");
83 const auto *CondStmt = Result.Nodes.getNodeAs<Stmt>("condStmt");
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.cpp 39 bool StmtAncestorASTVisitor::TraverseStmt(Stmt *Statement) {
82 const Stmt *Curr = DeclParents->lookup(V);
380 case Stmt::ArraySubscriptExprClass: {
387 case Stmt::UnaryOperatorClass:
390 case Stmt::CXXOperatorCallExprClass: {
401 case Stmt::CXXMemberCallExprClass: {
465 bool ForLoopIndexUseVisitor::findAndVerifyUsages(const Stmt *Body) {
820 bool ForLoopIndexUseVisitor::TraverseStmt(Stmt *S) {
835 const Stmt *OldNextParent = NextStmtParent;
889 for (const Stmt *S = SourceStmt; S != nullptr; S = ReverseAST->lookup(S)) {
tools/clang/tools/extra/clang-tidy/modernize/LoopConvertUtils.h 32 typedef llvm::DenseMap<const clang::Stmt *, const clang::Stmt *> StmtParentMap;
32 typedef llvm::DenseMap<const clang::Stmt *, const clang::Stmt *> StmtParentMap;
45 typedef llvm::DenseMap<const clang::Stmt *, std::string>
77 llvm::SmallVector<const clang::Stmt *, 16> StmtStack;
79 bool TraverseStmt(clang::Stmt *Statement);
115 const clang::Stmt *ContainingStmt)
149 bool dependsOnInsideVariable(const clang::Stmt *Body) {
160 const clang::Stmt *ContainingStmt;
182 bool findUsages(const clang::Stmt *Body) {
302 bool findAndVerifyUsages(const Stmt *Body);
352 bool TraverseStmt(Stmt *S);
388 const Stmt *NextStmtParent;
392 const Stmt *CurrStmtParent;
433 const StmtParentMap *ReverseAST, const clang::Stmt *SourceStmt,
451 const clang::Stmt *SourceStmt;
tools/clang/tools/extra/clang-tidy/modernize/RedundantVoidArgCheck.cpp 106 if (const Stmt *Body = Function->getBody()) {
tools/clang/tools/extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp 110 case Stmt::CXXNullPtrLiteralExprClass:
111 case Stmt::ImplicitValueInitExprClass:
113 case Stmt::InitListExprClass:
115 case Stmt::CharacterLiteralClass:
117 case Stmt::CXXBoolLiteralExprClass:
119 case Stmt::IntegerLiteralClass:
121 case Stmt::FloatingLiteralClass: {
155 case Stmt::UnaryOperatorClass:
158 case Stmt::CharacterLiteralClass:
161 case Stmt::CXXBoolLiteralExprClass:
164 case Stmt::IntegerLiteralClass:
167 case Stmt::FloatingLiteralClass:
170 case Stmt::StringLiteralClass:
173 case Stmt::DeclRefExprClass:
tools/clang/tools/extra/clang-tidy/modernize/UseNullptrCheck.cpp 101 bool TraverseStmt(Stmt *S) {
126 bool VisitStmt(Stmt *S) {
179 bool TraverseStmt(Stmt *S) {
190 bool VisitStmt(Stmt *S) {
280 ast_type_traits::DynTypedNode::create<Stmt>(*CE), MacroLoc,
292 else if (const auto *S = ContainingAncestor.get<Stmt>())
292 else if (const auto *S = ContainingAncestor.get<Stmt>())
437 else if (const auto *S = Parent.get<Stmt>())
437 else if (const auto *S = Parent.get<Stmt>())
tools/clang/tools/extra/clang-tidy/openmp/ExceptionEscapeCheck.cpp 65 const auto *StructuredBlock =
66 Result.Nodes.getNodeAs<Stmt>("structured-block");
tools/clang/tools/extra/clang-tidy/performance/ImplicitConversionInLoopCheck.cpp 27 static bool IsNonTrivialImplicitCast(const Stmt *ST) {
tools/clang/tools/extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp 200 const Stmt *LoopStmt = ForLoop;
tools/clang/tools/extra/clang-tidy/performance/UnnecessaryCopyInitialization.cpp 92 const auto *BlockStmt = Result.Nodes.getNodeAs<Stmt>("blockStmt");
92 const auto *BlockStmt = Result.Nodes.getNodeAs<Stmt>("blockStmt");
118 const VarDecl &Var, const Stmt &BlockStmt, bool IssueFix,
141 const VarDecl &NewVar, const VarDecl &OldVar, const Stmt &BlockStmt,
tools/clang/tools/extra/clang-tidy/performance/UnnecessaryCopyInitialization.h 34 void handleCopyFromMethodReturn(const VarDecl &Var, const Stmt &BlockStmt,
38 const Stmt &BlockStmt, bool IssueFix,
tools/clang/tools/extra/clang-tidy/readability/BracesAroundStatementsCheck.cpp 157 const Stmt *Else = S->getElse();
204 const MatchFinder::MatchResult &Result, const Stmt *S,
tools/clang/tools/extra/clang-tidy/readability/BracesAroundStatementsCheck.h 53 const Stmt *S, SourceLocation StartLoc,
60 std::set<const Stmt *> ForceBracesStmts;
tools/clang/tools/extra/clang-tidy/readability/ElseAfterReturnCheck.cpp 47 if (Result.Nodes.getNodeAs<Stmt>(BindingName))
tools/clang/tools/extra/clang-tidy/readability/FunctionSizeCheck.cpp 39 bool TraverseStmt(Stmt *Node) {
47 case Stmt::IfStmtClass:
48 case Stmt::WhileStmtClass:
49 case Stmt::DoStmtClass:
50 case Stmt::CXXForRangeStmtClass:
51 case Stmt::ForStmtClass:
52 case Stmt::SwitchStmtClass:
55 case Stmt::CompoundStmtClass:
167 if (const Stmt *Body = Func->getBody()) {
tools/clang/tools/extra/clang-tidy/readability/ImplicitBoolConversionCheck.cpp 30 bool isNULLMacroExpansion(const Stmt *Statement, ASTContext &Context) {
61 bool isUnaryLogicalNotOperator(const Stmt *Statement) {
83 bool areParensNeededForStatement(const Stmt *Statement) {
92 const ImplicitCastExpr *Cast, const Stmt *Parent,
105 Parent = Context.getParents(*Parent)[0].get<Stmt>();
222 std::queue<const Stmt *> Q;
226 const Stmt *S = N.get<Stmt>();
226 const Stmt *S = N.get<Stmt>();
336 const auto *Parent = Result.Nodes.getNodeAs<Stmt>("parentStmt");
336 const auto *Parent = Result.Nodes.getNodeAs<Stmt>("parentStmt");
349 const Stmt *Parent,
tools/clang/tools/extra/clang-tidy/readability/ImplicitBoolConversionCheck.h 32 const Stmt *ParentStatement, ASTContext &Context);
tools/clang/tools/extra/clang-tidy/readability/MisleadingIndentationCheck.cpp 60 const Stmt *CurrentStmt = CStmt->body_begin()[i];
61 const Stmt *Inner = nullptr;
92 const Stmt *NextStmt = CStmt->body_begin()[i + 1];
tools/clang/tools/extra/clang-tidy/readability/NonConstParameterCheck.cpp 57 } else if (const auto *S = Result.Nodes.getNodeAs<Stmt>("Mark")) {
57 } else if (const auto *S = Result.Nodes.getNodeAs<Stmt>("Mark")) {
tools/clang/tools/extra/clang-tidy/readability/RedundantControlFlowCheck.cpp 83 dyn_cast<Stmt>(*Previous)->getEndLoc(), tok::semi, SM, getLangOpts(),
tools/clang/tools/extra/clang-tidy/readability/SimplifyBooleanExprCheck.cpp 67 internal::Matcher<Stmt> returnsBool(bool Value, StringRef Id = "ignored") {
585 const Stmt *ElseStatement = IfStatement->getElse();
tools/clang/tools/extra/clang-tidy/readability/StringCompareCheck.cpp 52 if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) {
52 if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match1")) {
57 if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match2")) {
57 if (const auto *Matched = Result.Nodes.getNodeAs<Stmt>("match2")) {
60 if (const auto *Zero = Result.Nodes.getNodeAs<Stmt>("zero")) {
60 if (const auto *Zero = Result.Nodes.getNodeAs<Stmt>("zero")) {
62 const auto *Str2 = Result.Nodes.getNodeAs<Stmt>("str2");
62 const auto *Str2 = Result.Nodes.getNodeAs<Stmt>("str2");
63 const auto *Compare = Result.Nodes.getNodeAs<Stmt>("compare");
63 const auto *Compare = Result.Nodes.getNodeAs<Stmt>("compare");
tools/clang/tools/extra/clang-tidy/utils/ASTUtils.cpp 21 const Stmt &Statement) {
tools/clang/tools/extra/clang-tidy/utils/ASTUtils.h 19 const Stmt &Statement);
tools/clang/tools/extra/clang-tidy/utils/DeclRefExprUtils.cpp 107 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
tools/clang/tools/extra/clang-tidy/utils/DeclRefExprUtils.h 27 bool isOnlyUsedAsConst(const VarDecl &Var, const Stmt &Stmt,
32 allDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt, ASTContext &Context);
41 constReferenceDeclRefExprs(const VarDecl &VarDecl, const Stmt &Stmt,
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.cpp 118 if (const Stmt *Body = Func->getBody()) {
137 const Stmt *St, const ExceptionInfo::Throwables &Caught,
199 for (const Stmt *Child : St->children()) {
228 ExceptionAnalyzer::analyzeImpl(const Stmt *Stmt) {
235 ExceptionAnalyzer::analyzeDispatch(const T *Node) {
255 ExceptionAnalyzer::analyze(const Stmt *Stmt) {
tools/clang/tools/extra/clang-tidy/utils/ExceptionAnalyzer.h 132 ExceptionInfo analyze(const Stmt *Stmt);
139 throwsException(const Stmt *St, const ExceptionInfo::Throwables &Caught,
143 ExceptionInfo analyzeImpl(const Stmt *Stmt);
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.cpp 27 static SmallVector<const Stmt *, 1> getParentStmts(const Stmt *S,
29 SmallVector<const Stmt *, 1> Result;
40 if (const auto *S = Node.get<Stmt>()) {
40 if (const auto *S = Node.get<Stmt>()) {
52 bool isDescendantOrEqual(const Stmt *Descendant, const Stmt *Ancestor,
52 bool isDescendantOrEqual(const Stmt *Descendant, const Stmt *Ancestor,
56 for (const Stmt *Parent : getParentStmts(Descendant, Context)) {
65 ExprSequence::ExprSequence(const CFG *TheCFG, const Stmt *Root,
73 bool ExprSequence::inSequence(const Stmt *Before, const Stmt *After) const {
73 bool ExprSequence::inSequence(const Stmt *Before, const Stmt *After) const {
79 for (const Stmt *Successor = getSequenceSuccessor(Before); Successor;
87 for (const Stmt *Parent : getParentStmts(Before, Context)) {
95 bool ExprSequence::potentiallyAfter(const Stmt *After,
96 const Stmt *Before) const {
100 const Stmt *ExprSequence::getSequenceSuccessor(const Stmt *S) const {
100 const Stmt *ExprSequence::getSequenceSuccessor(const Stmt *S) const {
101 for (const Stmt *Parent : getParentStmts(S, Context)) {
121 const Stmt *Previous = nullptr;
122 for (const auto *Child : Compound->body()) {
180 const Stmt *ExprSequence::resolveSyntheticStmt(const Stmt *S) const {
180 const Stmt *ExprSequence::resolveSyntheticStmt(const Stmt *S) const {
196 const CFGBlock *StmtToBlockMap::blockContainingStmt(const Stmt *S) const {
198 SmallVector<const Stmt *, 1> Parents = getParentStmts(S, Context);
tools/clang/tools/extra/clang-tidy/utils/ExprSequence.h 72 ExprSequence(const CFG *TheCFG, const Stmt *Root, ASTContext *TheContext);
75 bool inSequence(const Stmt *Before, const Stmt *After) const;
75 bool inSequence(const Stmt *Before, const Stmt *After) const;
80 bool potentiallyAfter(const Stmt *After, const Stmt *Before) const;
80 bool potentiallyAfter(const Stmt *After, const Stmt *Before) const;
91 const Stmt *getSequenceSuccessor(const Stmt *S) const;
91 const Stmt *getSequenceSuccessor(const Stmt *S) const;
93 const Stmt *resolveSyntheticStmt(const Stmt *S) const;
93 const Stmt *resolveSyntheticStmt(const Stmt *S) const;
96 const Stmt *Root;
98 llvm::DenseMap<const Stmt *, const Stmt *> SyntheticStmtSourceMap;
98 llvm::DenseMap<const Stmt *, const Stmt *> SyntheticStmtSourceMap;
112 const CFGBlock *blockContainingStmt(const Stmt *S) const;
117 llvm::DenseMap<const Stmt *, const CFGBlock *> Map;
tools/clang/tools/extra/clang-tidy/utils/NamespaceAliaser.cpp 30 NamespaceAliaser::createAlias(ASTContext &Context, const Stmt &Statement,
82 const Stmt &Statement,
tools/clang/tools/extra/clang-tidy/utils/NamespaceAliaser.h 32 createAlias(ASTContext &Context, const Stmt &Statement,
38 std::string getNamespaceName(ASTContext &Context, const Stmt &Statement,
tools/clang/tools/extra/clang-tidy/utils/UsingInserter.cpp 33 ASTContext &Context, const Stmt &Statement, StringRef QualifiedName) {
78 const Stmt &Statement,
tools/clang/tools/extra/clang-tidy/utils/UsingInserter.h 32 createUsingDeclaration(ASTContext &Context, const Stmt &Statement,
37 llvm::StringRef getShortName(ASTContext &Context, const Stmt &Statement,
tools/clang/tools/extra/clangd/FindTarget.cpp 169 void add(const Stmt *S, RelSet Flags) {
349 else if (const Stmt *S = N.get<Stmt>())
349 else if (const Stmt *S = N.get<Stmt>())
721 void findExplicitReferences(const Stmt *S,
tools/clang/tools/extra/clangd/FindTarget.h 106 void findExplicitReferences(const Stmt *S,
tools/clang/tools/extra/clangd/Selection.cpp 212 bool dataTraverseStmtPre(Stmt *X) {
226 bool dataTraverseStmtPost(Stmt *X) {
tools/clang/tools/extra/clangd/refactor/tweaks/DumpAST.cpp 53 return N.get<Decl>() || N.get<Stmt>() || N.get<Type>();
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractFunction.cpp 94 if (!N->ASTNode.get<Stmt>())
158 bool isRootStmt(const Stmt *S) const;
165 llvm::DenseSet<const Stmt *> RootStmts;
168 bool ExtractionZone::isRootStmt(const Stmt *S) const {
175 RootStmts.insert(Child->ASTNode.get<Stmt>());
239 if (Child->ASTNode.get<Stmt>() == EnclosingFunc->getBody())
416 bool isLoop(const Stmt *S) {
433 bool TraverseStmt(Stmt *S) {
454 void addToLoopSwitchCounters(Stmt *S, int Increment) {
465 void decrementLoopSwitchCounters(Stmt *S) {
576 ExtZone.getLastRootStmt()->ASTNode.get<Stmt>(), FuncBodyRange, SM,
tools/clang/tools/extra/clangd/refactor/tweaks/ExtractVariable.cpp 57 const clang::Stmt *InsertionPoint = nullptr;
63 bool exprIsValidOutside(const clang::Stmt *Scope) const;
65 const clang::Stmt *computeInsertionPoint() const;
82 Visitor.TraverseStmt(const_cast<Stmt *>(dyn_cast<Stmt>(Expr)));
99 bool ExtractionContext::exprIsValidOutside(const clang::Stmt *Scope) const {
119 const clang::Stmt *ExtractionContext::computeInsertionPoint() const {
123 if (const clang::Stmt *Stmt = InsertionPoint->ASTNode.get<clang::Stmt>()) {
123 if (const clang::Stmt *Stmt = InsertionPoint->ASTNode.get<clang::Stmt>()) {
145 const clang::Stmt *CurInsertionPoint = CurNode->ASTNode.get<Stmt>();
145 const clang::Stmt *CurInsertionPoint = CurNode->ASTNode.get<Stmt>();
149 if (const clang::Stmt *CurParent = CurNode->Parent->ASTNode.get<Stmt>()) {
149 if (const clang::Stmt *CurParent = CurNode->Parent->ASTNode.get<Stmt>()) {
339 bool childExprIsStmt(const Stmt *Outer, const Expr *Inner) {
391 childExprIsStmt(OuterImplicit.Parent->ASTNode.get<Stmt>(),
tools/clang/tools/extra/clangd/refactor/tweaks/RawStringLiteral.cpp 84 Str = dyn_cast_or_null<StringLiteral>(N->ASTNode.get<Stmt>());
tools/clang/tools/extra/clangd/refactor/tweaks/SwapIfBranches.cpp 54 if (dyn_cast_or_null<CompoundStmt>(N->ASTNode.get<Stmt>()))
56 If = dyn_cast_or_null<IfStmt>(N->ASTNode.get<Stmt>());
tools/clang/tools/extra/modularize/Modularize.cpp 551 bool TraverseStmt(Stmt *S) { return true; }
742 bool TraverseStmt(Stmt *S) { return true; }
tools/clang/tools/libclang/CIndex.cpp 507 if (const Stmt *S = getCursorStmt(Cursor))
591 if (Stmt *Body = B->getBody())
1927 DeclarationNameInfoVisit(const Stmt *S, CXCursor parent)
1933 const Stmt *S = static_cast<const Stmt *>(data[0]);
1937 case clang::Stmt::MSDependentExistsStmtClass:
1939 case Stmt::CXXDependentScopeMemberExprClass:
1941 case Stmt::DependentScopeDeclRefExprClass:
1943 case Stmt::OMPCriticalDirectiveClass:
2003 void VisitStmt(const Stmt *S);
2082 void AddDeclarationNameInfo(const Stmt *S);
2087 void AddStmt(const Stmt *S);
2090 void EnqueueChildren(const Stmt *S);
2095 void EnqueueVisitor::AddDeclarationNameInfo(const Stmt *S) {
2107 void EnqueueVisitor::AddStmt(const Stmt *S) {
2127 void EnqueueVisitor::EnqueueChildren(const Stmt *S) {
2129 for (const Stmt *SubStmt : S->children()) {
2692 void EnqueueVisitor::VisitStmt(const Stmt *S) {
2989 void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
3068 const Stmt *S = cast<StmtVisit>(&LI)->get();
3207 bool CursorVisitor::Visit(const Stmt *S) {
3708 if (arg->getStmtClass() == Stmt::ImplicitCastExprClass) {
3712 if(subExpr->getStmtClass() != Stmt::StringLiteralClass){
3717 } else if (arg->getStmtClass() == Stmt::StringLiteralClass) {
3841 if (expr->getStmtClass() == Stmt::ImplicitCastExprClass) {
3844 if (subExpr->getStmtClass() == Stmt::StringLiteralClass ||
3845 subExpr->getStmtClass() == Stmt::ObjCStringLiteralClass) {
3865 } else if (expr->getStmtClass() == Stmt::ObjCStringLiteralClass ||
3866 expr->getStmtClass() == Stmt::StringLiteralClass) {
3886 if (expr->getStmtClass() == Stmt::CStyleCastExprClass) {
3891 CC->getSubExpr()->getStmtClass() == Stmt::CallExprClass) {
3907 } else if (expr->getStmtClass() == Stmt::CallExprClass) {
3931 } else if (expr->getStmtClass() == Stmt::DeclRefExprClass) {
3959 for (auto *bodyIterator : CS->body()) {
4332 static const Decl *getDeclFromExpr(const Stmt *E) {
4597 const Stmt *S = getCursorStmt(C);
4657 const Stmt *S = getCursorStmt(C);
6159 const Stmt *S = getCursorStmt(C);
tools/clang/tools/libclang/CXCursor.cpp 126 CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
133 case Stmt::NoStmtClass:
136 case Stmt::CaseStmtClass:
140 case Stmt::DefaultStmtClass:
144 case Stmt::IfStmtClass:
148 case Stmt::SwitchStmtClass:
152 case Stmt::WhileStmtClass:
156 case Stmt::DoStmtClass:
160 case Stmt::ForStmtClass:
164 case Stmt::GotoStmtClass:
168 case Stmt::IndirectGotoStmtClass:
172 case Stmt::ContinueStmtClass:
176 case Stmt::BreakStmtClass:
180 case Stmt::ReturnStmtClass:
184 case Stmt::GCCAsmStmtClass:
188 case Stmt::MSAsmStmtClass:
192 case Stmt::ObjCAtTryStmtClass:
196 case Stmt::ObjCAtCatchStmtClass:
200 case Stmt::ObjCAtFinallyStmtClass:
204 case Stmt::ObjCAtThrowStmtClass:
208 case Stmt::ObjCAtSynchronizedStmtClass:
212 case Stmt::ObjCAutoreleasePoolStmtClass:
216 case Stmt::ObjCForCollectionStmtClass:
220 case Stmt::CXXCatchStmtClass:
224 case Stmt::CXXTryStmtClass:
228 case Stmt::CXXForRangeStmtClass:
232 case Stmt::SEHTryStmtClass:
236 case Stmt::SEHExceptStmtClass:
240 case Stmt::SEHFinallyStmtClass:
244 case Stmt::SEHLeaveStmtClass:
248 case Stmt::CoroutineBodyStmtClass:
249 case Stmt::CoreturnStmtClass:
253 case Stmt::ArrayTypeTraitExprClass:
254 case Stmt::AsTypeExprClass:
255 case Stmt::AtomicExprClass:
256 case Stmt::BinaryConditionalOperatorClass:
257 case Stmt::TypeTraitExprClass:
258 case Stmt::CoawaitExprClass:
259 case Stmt::ConceptSpecializationExprClass:
260 case Stmt::DependentCoawaitExprClass:
261 case Stmt::CoyieldExprClass:
262 case Stmt::CXXBindTemporaryExprClass:
263 case Stmt::CXXDefaultArgExprClass:
264 case Stmt::CXXDefaultInitExprClass:
265 case Stmt::CXXFoldExprClass:
266 case Stmt::CXXRewrittenBinaryOperatorClass:
267 case Stmt::CXXStdInitializerListExprClass:
268 case Stmt::CXXScalarValueInitExprClass:
269 case Stmt::CXXUuidofExprClass:
270 case Stmt::ChooseExprClass:
271 case Stmt::DesignatedInitExprClass:
272 case Stmt::DesignatedInitUpdateExprClass:
273 case Stmt::ArrayInitLoopExprClass:
274 case Stmt::ArrayInitIndexExprClass:
275 case Stmt::ExprWithCleanupsClass:
276 case Stmt::ExpressionTraitExprClass:
277 case Stmt::ExtVectorElementExprClass:
278 case Stmt::ImplicitCastExprClass:
279 case Stmt::ImplicitValueInitExprClass:
280 case Stmt::NoInitExprClass:
281 case Stmt::MaterializeTemporaryExprClass:
282 case Stmt::ObjCIndirectCopyRestoreExprClass:
283 case Stmt::OffsetOfExprClass:
284 case Stmt::ParenListExprClass:
285 case Stmt::PredefinedExprClass:
286 case Stmt::ShuffleVectorExprClass:
287 case Stmt::SourceLocExprClass:
288 case Stmt::ConvertVectorExprClass:
289 case Stmt::VAArgExprClass:
290 case Stmt::ObjCArrayLiteralClass:
291 case Stmt::ObjCDictionaryLiteralClass:
292 case Stmt::ObjCBoxedExprClass:
293 case Stmt::ObjCSubscriptRefExprClass:
297 case Stmt::OpaqueValueExprClass:
303 case Stmt::PseudoObjectExprClass:
307 case Stmt::CompoundStmtClass:
311 case Stmt::NullStmtClass:
315 case Stmt::LabelStmtClass:
319 case Stmt::AttributedStmtClass:
323 case Stmt::DeclStmtClass:
327 case Stmt::CapturedStmtClass:
331 case Stmt::IntegerLiteralClass:
335 case Stmt::FixedPointLiteralClass:
339 case Stmt::FloatingLiteralClass:
343 case Stmt::ImaginaryLiteralClass:
347 case Stmt::StringLiteralClass:
351 case Stmt::CharacterLiteralClass:
355 case Stmt::ConstantExprClass:
359 case Stmt::ParenExprClass:
363 case Stmt::UnaryOperatorClass:
367 case Stmt::UnaryExprOrTypeTraitExprClass:
368 case Stmt::CXXNoexceptExprClass:
372 case Stmt::MSPropertySubscriptExprClass:
373 case Stmt::ArraySubscriptExprClass:
377 case Stmt::OMPArraySectionExprClass:
381 case Stmt::BinaryOperatorClass:
385 case Stmt::CompoundAssignOperatorClass:
389 case Stmt::ConditionalOperatorClass:
393 case Stmt::CStyleCastExprClass:
397 case Stmt::CompoundLiteralExprClass:
401 case Stmt::InitListExprClass:
405 case Stmt::AddrLabelExprClass:
409 case Stmt::StmtExprClass:
413 case Stmt::GenericSelectionExprClass:
417 case Stmt::GNUNullExprClass:
421 case Stmt::CXXStaticCastExprClass:
425 case Stmt::CXXDynamicCastExprClass:
429 case Stmt::CXXReinterpretCastExprClass:
433 case Stmt::CXXConstCastExprClass:
437 case Stmt::CXXFunctionalCastExprClass:
441 case Stmt::CXXTypeidExprClass:
445 case Stmt::CXXBoolLiteralExprClass:
449 case Stmt::CXXNullPtrLiteralExprClass:
453 case Stmt::CXXThisExprClass:
457 case Stmt::CXXThrowExprClass:
461 case Stmt::CXXNewExprClass:
465 case Stmt::CXXDeleteExprClass:
469 case Stmt::ObjCStringLiteralClass:
473 case Stmt::ObjCEncodeExprClass:
477 case Stmt::ObjCSelectorExprClass:
481 case Stmt::ObjCProtocolExprClass:
485 case Stmt::ObjCBoolLiteralExprClass:
489 case Stmt::ObjCAvailabilityCheckExprClass:
493 case Stmt::ObjCBridgedCastExprClass:
497 case Stmt::BlockExprClass:
501 case Stmt::PackExpansionExprClass:
505 case Stmt::SizeOfPackExprClass:
509 case Stmt::DeclRefExprClass:
524 case Stmt::DependentScopeDeclRefExprClass:
525 case Stmt::SubstNonTypeTemplateParmExprClass:
526 case Stmt::SubstNonTypeTemplateParmPackExprClass:
527 case Stmt::FunctionParmPackExprClass:
528 case Stmt::UnresolvedLookupExprClass:
529 case Stmt::TypoExprClass: // A typo could actually be a DeclRef or a MemberRef
533 case Stmt::CXXDependentScopeMemberExprClass:
534 case Stmt::CXXPseudoDestructorExprClass:
535 case Stmt::MemberExprClass:
536 case Stmt::MSPropertyRefExprClass:
537 case Stmt::ObjCIsaExprClass:
538 case Stmt::ObjCIvarRefExprClass:
539 case Stmt::ObjCPropertyRefExprClass:
540 case Stmt::UnresolvedMemberExprClass:
544 case Stmt::CallExprClass:
545 case Stmt::CXXOperatorCallExprClass:
546 case Stmt::CXXMemberCallExprClass:
547 case Stmt::CUDAKernelCallExprClass:
548 case Stmt::CXXConstructExprClass:
549 case Stmt::CXXInheritedCtorInitExprClass:
550 case Stmt::CXXTemporaryObjectExprClass:
551 case Stmt::CXXUnresolvedConstructExprClass:
552 case Stmt::UserDefinedLiteralClass:
556 case Stmt::LambdaExprClass:
560 case Stmt::ObjCMessageExprClass: {
577 case Stmt::MSDependentExistsStmtClass:
580 case Stmt::OMPParallelDirectiveClass:
583 case Stmt::OMPSimdDirectiveClass:
586 case Stmt::OMPForDirectiveClass:
589 case Stmt::OMPForSimdDirectiveClass:
592 case Stmt::OMPSectionsDirectiveClass:
595 case Stmt::OMPSectionDirectiveClass:
598 case Stmt::OMPSingleDirectiveClass:
601 case Stmt::OMPMasterDirectiveClass:
604 case Stmt::OMPCriticalDirectiveClass:
607 case Stmt::OMPParallelForDirectiveClass:
610 case Stmt::OMPParallelForSimdDirectiveClass:
613 case Stmt::OMPParallelSectionsDirectiveClass:
616 case Stmt::OMPTaskDirectiveClass:
619 case Stmt::OMPTaskyieldDirectiveClass:
622 case Stmt::OMPBarrierDirectiveClass:
625 case Stmt::OMPTaskwaitDirectiveClass:
628 case Stmt::OMPTaskgroupDirectiveClass:
631 case Stmt::OMPFlushDirectiveClass:
634 case Stmt::OMPOrderedDirectiveClass:
637 case Stmt::OMPAtomicDirectiveClass:
640 case Stmt::OMPTargetDirectiveClass:
643 case Stmt::OMPTargetDataDirectiveClass:
646 case Stmt::OMPTargetEnterDataDirectiveClass:
649 case Stmt::OMPTargetExitDataDirectiveClass:
652 case Stmt::OMPTargetParallelDirectiveClass:
655 case Stmt::OMPTargetParallelForDirectiveClass:
658 case Stmt::OMPTargetUpdateDirectiveClass:
661 case Stmt::OMPTeamsDirectiveClass:
664 case Stmt::OMPCancellationPointDirectiveClass:
667 case Stmt::OMPCancelDirectiveClass:
670 case Stmt::OMPTaskLoopDirectiveClass:
673 case Stmt::OMPTaskLoopSimdDirectiveClass:
676 case Stmt::OMPMasterTaskLoopDirectiveClass:
679 case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
682 case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
685 case Stmt::OMPDistributeDirectiveClass:
688 case Stmt::OMPDistributeParallelForDirectiveClass:
691 case Stmt::OMPDistributeParallelForSimdDirectiveClass:
694 case Stmt::OMPDistributeSimdDirectiveClass:
697 case Stmt::OMPTargetParallelForSimdDirectiveClass:
700 case Stmt::OMPTargetSimdDirectiveClass:
703 case Stmt::OMPTeamsDistributeDirectiveClass:
706 case Stmt::OMPTeamsDistributeSimdDirectiveClass:
709 case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
712 case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
715 case Stmt::OMPTargetTeamsDirectiveClass:
718 case Stmt::OMPTargetTeamsDistributeDirectiveClass:
721 case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
724 case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
727 case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
730 case Stmt::BuiltinBitCastExprClass:
1022 const Stmt *cxcursor::getCursorStmt(CXCursor Cursor) {
tools/clang/tools/libclang/CXCursor.h 55 CXCursor MakeCXCursor(const clang::Stmt *S, const clang::Decl *Parent,
242 const Stmt *getCursorStmt(CXCursor Cursor);
tools/clang/tools/libclang/CursorVisitor.h 266 void EnqueueWorkList(VisitorWorkList &WL, const Stmt *S);
267 LLVM_ATTRIBUTE_NOINLINE bool Visit(const Stmt *S);
tools/clang/unittests/AST/ASTContextParentMapTest.cpp 34 MatchVerifier<Stmt> Verifier;
74 MatchVerifier<Stmt> TemplateVerifier;
tools/clang/unittests/AST/ASTImporterTest.cpp 867 const internal::VariadicDynCastAllOfMatcher<Stmt, SizeOfPackExpr>
900 const internal::VariadicDynCastAllOfMatcher<Stmt, TypeTraitExpr> typeTraitExpr;
912 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr> cxxTypeidExpr;
tools/clang/unittests/AST/ASTPrint.h 26 const Stmt *S, PolicyAdjusterType PolicyAdjuster) {
44 const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
44 const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
tools/clang/unittests/AST/ASTTraverserTest.cpp 32 void Visit(const Stmt *S) { OS << S->getStmtClassName(); }
104 static void withDynNode(T *Node, const std::string &DumpString) {
157 Stmt *Body = Func->getBody();
tools/clang/unittests/AST/ASTTypeTraitsTest.cpp 25 return ASTNodeKind::getFromNodeKind<T>();
tools/clang/unittests/AST/DataCollectionTest.cpp 37 StmtDataCollector(const Stmt *S, ASTContext &Context, llvm::MD5 &DataConsumer)
59 const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
59 const Stmt *S = Result.Nodes.getNodeAs<Stmt>("id");
tools/clang/unittests/AST/MatchVerifier.h 62 const NodeType &Node) {}
150 const NodeType *Node = Result.Nodes.getNodeAs<NodeType>("");
150 const NodeType *Node = Result.Nodes.getNodeAs<NodeType>("");
tools/clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp 1546 bool verify(const BoundNodes &Nodes, ASTContext &Context, const Stmt *Node) {
tools/clang/unittests/ASTMatchers/ASTMatchersTest.h 421 if (Nodes->getNodeAs<T>(Id)) {
tools/clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp 2290 const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
2290 const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
2465 VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
2473 const T *Node = Nodes->getNodeAs<T>(Id);
2473 const T *Node = Nodes->getNodeAs<T>(Id);
2474 return selectFirst<T>(InnerId, match(InnerMatcher, *Node, *Context)) !=
2479 internal::Matcher<T> InnerMatcher;
tools/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp 30 ast_matchers::internal::Matcher<Stmt> M = stmt(stmt(), stmt());
72 typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
259 auto M = OM->unconditionalConvertTo<Stmt>();
tools/clang/unittests/ASTMatchers/Dynamic/RegistryTest.cpp 128 Matcher<Stmt> IsArrowValue = constructMatcher(
129 "memberExpr", constructMatcher("isArrow")).getTypedMatcher<Stmt>();
130 Matcher<Stmt> BoolValue =
131 constructMatcher("cxxBoolLiteral").getTypedMatcher<Stmt>();
187 Matcher<Stmt> CallExpr0 = constructMatcher(
191 .getTypedMatcher<Stmt>();
193 Matcher<Stmt> CallExpr1 = constructMatcher(
199 .getTypedMatcher<Stmt>();
256 Matcher<Stmt> ConstructExpr = constructMatcher(
264 .getTypedMatcher<Stmt>();
325 Matcher<Stmt> S = constructMatcher(
331 .getTypedMatcher<Stmt>();
339 .getTypedMatcher<Stmt>();
509 Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>();
509 Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>();
515 Matcher<Stmt> BooleanStmt = constructMatcher(
517 .getTypedMatcher<Stmt>();
524 .getTypedMatcher<Stmt>();
529 Matcher<Stmt> DoubleStmt = constructMatcher(
531 .getTypedMatcher<Stmt>();
541 Matcher<Stmt> IntegerStmt = constructMatcher(
543 .getTypedMatcher<Stmt>();
547 Matcher<Stmt> CharStmt = constructMatcher(
549 .getTypedMatcher<Stmt>();
tools/clang/unittests/Analysis/CFGBuildResult.h 42 Stmt *Body = Func->getBody();
tools/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp 30 using StmtMatcher = internal::Matcher<Stmt>;
55 const auto *const S = selectFirst<Stmt>("stmt", Results);
55 const auto *const S = selectFirst<Stmt>("stmt", Results);
62 const auto *const S = selectFirst<Stmt>("stmt", Results);
62 const auto *const S = selectFirst<Stmt>("stmt", Results);
66 const Stmt *By = Analyzer.findMutation(E);
tools/clang/unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp 89 void checkLocation(SVal Loc, bool IsLoad, const Stmt *S,
tools/clang/unittests/Tooling/ASTSelectionTest.cpp 107 typename std::enable_if<std::is_base_of<Stmt, T>::value, T>::type
109 checkNodeImpl(isa<T>(StmtNode.Node.get<Stmt>()), StmtNode, SelectionKind,
tools/clang/unittests/Tooling/LexicallyOrderedRecursiveASTVisitorTest.cpp 35 bool TraverseStmt(Stmt *S);
62 template <class T> void match(StringRef Path, const T *D) {
67 bool LexicallyOrderedDeclVisitor::TraverseStmt(Stmt *S) {
tools/clang/unittests/Tooling/RecursiveASTVisitorTests/LambdaExpr.cpp 26 bool VisitStmt(Stmt *S) {
44 std::stack<Stmt *> PendingBodies;
tools/clang/unittests/Tooling/StencilTest.cpp 345 return std::string(R.Nodes.getNodeAs<Stmt>(Id) != nullptr ? "Bound"
tools/lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h 61 clang::Stmt *GetExternalDeclStmt(uint64_t Offset) override {
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp 136 Stmt *function_body = function_decl->getBody();
176 Stmt *method_body = MethodDecl->getBody();
211 Stmt **last_stmt_ptr = Body->body_end() - 1;
212 Stmt *last_stmt = *last_stmt_ptr;
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTStructExtractor.cpp 54 Stmt *body_stmt = F->getBody();
67 Stmt *curr_stmt = *bi;
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTUtils.h 43 clang::Stmt *GetExternalDeclStmt(uint64_t Offset) override {
296 clang::Stmt *GetExternalDeclStmt(uint64_t Offset) override {
298 if (clang::Stmt *Result = Sources[i]->GetExternalDeclStmt(Offset))
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h 49 clang::Stmt *GetExternalDeclStmt(uint64_t) override { return nullptr; }
tools/lldb/tools/lldb-instr/Instrument.cpp 175 Stmt *Body = Decl->getBody();
280 Stmt *Body = Decl->getBody();
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1580 { typedef _Tp const type; };
1629 { typedef _Tp type; };
1983 { typedef _Up type; };
1999 { typedef typename remove_reference<_Tp>::type* type; };
2003 : public __add_pointer_helper<_Tp>