| /src/external/apache2/llvm/dist/clang/include/clang/AST/ |
| TypeLocVisitor.h | 22 Visit##CLASSNAME(TyLoc.castAs<CLASSNAME>())
27 RetTy Visit(TypeLoc TyLoc) {
37 RetTy Visit(UnqualTypeLoc TyLoc) {
48 RetTy Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc) { \
|
| TypeVisitor.h | 22 Visit##CLASS(static_cast<const CLASS*>(T))
31 /// from Type. The operation is performed by calling method Visit. It then
45 /// sometype result = avisitor.Visit(atype);
68 RetTy Visit(const Type *T) {
78 // If the implementation chooses not to implement a certain visit method, fall
80 #define TYPE(CLASS, PARENT) RetTy Visit##CLASS##Type(const CLASS##Type *T) { \
|
| ASTNodeTraverser.h | 44 void Visit(const comments::Comment *C, const comments::FullComment *FC);
45 void Visit(const Attr *A);
46 void Visit(const TemplateArgument &TA, SourceRange R = {},
48 void Visit(const Stmt *Node);
49 void Visit(const Type *T);
50 void Visit(QualType T);
51 void Visit(const Decl *D);
52 void Visit(const CXXCtorInitializer *Init);
53 void Visit(const OMPClause *C);
54 void Visit(const BlockDecl::Capture &C)
[all...] |
| /src/external/apache2/llvm/dist/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ |
| SValVisitor.h | 31 return static_cast<ImplClass *>(this)->Visit ## NAME(V.castAs<CLASS>())
33 RetTy Visit(SVal V) {
58 RetTy Visit ## Id(Id V) { DISPATCH(Parent, Id); }
79 return static_cast<ImplClass *>(this)->Visit ## CLASS(cast<CLASS>(S))
81 RetTy Visit(SymbolRef S) {
91 // If the implementation chooses not to implement a certain visit method, fall
93 #define SYMBOL(Id, Parent) RetTy Visit ## Id(const Id *S) { DISPATCH(Parent); }
109 return static_cast<ImplClass *>(this)->Visit ## CLASS(cast<CLASS>(R))
111 RetTy Visit(const MemRegion *R) {
120 // If the implementation chooses not to implement a certain visit method, fal
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/ |
| CanonicalizeFreezeInLoops.cpp | 155 auto Visit = [&](User *U) {
162 for_each(PHI.users(), Visit);
163 for_each(Info.StepInst->users(), Visit);
|
| /src/external/apache2/llvm/dist/clang/lib/Analysis/ |
| LiveVariables.cpp | 171 void Visit(Stmt *S);
211 void TransferFunctions::Visit(Stmt *S) {
215 StmtVisitor<TransferFunctions>::Visit(S);
279 // No need to unconditionally visit subexpressions.
463 // Visit the terminator (if any).
465 TF.Visit(const_cast<Stmt*>(term));
482 TF.Visit(const_cast<Stmt*>(S));
|
| CFG.cpp | 611 CFGBlock *Visit(Stmt *S, AddStmtChoice asc = AddStmtChoice::NotAlwaysAdd,
738 // there's no need to do this manually in every Visit... function.
746 return Visit(S, AddStmtChoice::AlwaysAdd);
1381 // FIXME: This, like the main visit, doesn't support CUDAKernelCallExpr.
1497 // Visit the statements and create the CFG.
1658 return Visit(cast<ExprWithCleanups>(Init)->getSubExpr());
1668 if (CFGBlock *R = Visit(Child))
1673 return Visit(Init);
2116 /// Visit - Walk the subtree of a statement and add extra
2119 CFGBlock *CFGBuilder::Visit(Stmt * S, AddStmtChoice asc
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Sema/ |
| SemaStmtAttr.cpp | 183 CallExprFinder(Sema &S, const Stmt *St) : Inherited(S.Context) { Visit(St); }
190 void Visit(const Stmt *St) {
193 ConstEvaluatedExprVisitor<CallExprFinder>::Visit(St);
|
| SemaExprObjC.cpp | 3557 using super::Visit;
3558 ACCResult Visit(Expr *e) {
3559 return super::Visit(e->IgnoreParens());
3594 return Visit(e->getSubExpr());
3603 return Visit(e->getSubExpr());
3608 return Visit(e->getRHS());
3613 ACCResult left = Visit(e->getTrueExpr());
3615 return merge(left, Visit(e->getFalseExpr()));
3621 return Visit(e->getResultExpr());
3626 return Visit(e->getSubStmt()->body_back())
[all...] |
| SemaTemplate.cpp | 5939 bool Visit(QualType T) {
5940 return T.isNull() ? false : inherited::Visit(T.getTypePtr());
5944 bool Visit##Class##Type(const Class##Type *);
5946 bool Visit##Class##Type(const Class##Type *) { return false; }
5948 bool Visit##Class##Type(const Class##Type *) { return false; }
5961 return Visit(T->getElementType());
5965 return Visit(T->getPointeeType());
5970 return Visit(T->getPointeeType());
5975 return Visit(T->getPointeeType());
5980 return Visit(T->getPointeeType())
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/StaticAnalyzer/Checkers/ |
| LLVMConventionsChecker.cpp | 127 Visit(Child);
139 walker.Visit(D->getBody());
225 void Visit(FieldDecl *D);
237 walker.Visit(I);
241 void ASTFieldVisitor::Visit(FieldDecl *D) {
252 Visit(I);
|
| /src/external/apache2/llvm/dist/clang/lib/AST/ |
| ODRHash.cpp | 237 // Process a Decl pointer. Add* methods call back into ODRHash while Visit*
277 void Visit(const Decl *D) {
279 Inherited::Visit(D);
469 ODRDeclVisitor(ID, *this).Visit(D);
655 // Process a Type pointer. Add* methods call back into ODRHash while Visit*
753 void Visit(const Type *T) {
756 Inherited::Visit(T);
1121 ODRTypeVisitor(ID, *this).Visit(T);
|
| JSONNodeDumper.cpp | 22 void JSONNodeDumper::Visit(const Attr *A) {
44 InnerAttrVisitor::Visit(A);
47 void JSONNodeDumper::Visit(const Stmt *S) {
66 InnerStmtVisitor::Visit(S);
69 void JSONNodeDumper::Visit(const Type *T) {
85 InnerTypeVisitor::Visit(T);
88 void JSONNodeDumper::Visit(QualType T) {
95 void JSONNodeDumper::Visit(const Decl *D) {
127 InnerDeclVisitor::Visit(D);
130 void JSONNodeDumper::Visit(const comments::Comment *C
[all...] |
| TextNodeDumper.cpp | 69 void TextNodeDumper::Visit(const comments::Comment *C,
85 const comments::FullComment *>::visit(C, FC);
88 void TextNodeDumper::Visit(const Attr *A) {
108 ConstAttrVisitor<TextNodeDumper>::Visit(A);
111 void TextNodeDumper::Visit(const TemplateArgument &TA, SourceRange R,
120 ConstTemplateArgumentVisitor<TextNodeDumper>::Visit(TA);
123 void TextNodeDumper::Visit(const Stmt *Node) {
182 ConstStmtVisitor<TextNodeDumper>::Visit(Node);
185 void TextNodeDumper::Visit(const Type *T) {
230 TypeVisitor<TextNodeDumper>::Visit(T)
[all...] |
| StmtPrinter.cpp | 88 Visit(S);
91 Visit(S);
133 Visit(E);
144 void Visit(Stmt* S) {
147 else StmtVisitor<StmtPrinter>::Visit(S);
162 void Visit##CLASS(CLASS *Node);
436 Visit(Node->getOutputExpr(i));
457 Visit(Node->getInputExpr(i));
649 Printer.Visit(Clause);
1529 Visit(Node->getSyntacticForm())
[all...] |
| Type.cpp | 845 // Visit the type itself.
846 QualType result = static_cast<Derived *>(this)->Visit(splitType.Ty);
862 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
866 QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
868 QualType Visit##Class##Type(const Class##Type *T) { \
1790 using TypeVisitor<GetContainedDeducedTypeVisitor, Type*>::Visit;
1792 Type *Visit(QualType T) {
1795 return Visit(T.getTypePtr());
1806 return Visit(T->getNamedType());
1810 return Visit(T->getPointeeType())
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/Serialization/ |
| ASTWriterDecl.cpp | 55 void Visit(Decl *D);
269 void ASTDeclWriter::Visit(Decl *D) {
270 DeclVisitor<ASTDeclWriter>::Visit(D);
544 // FunctionDecl's body is handled last at ASTWriterDecl::Visit,
2410 W.Visit(D);
|
| /src/external/apache2/llvm/dist/clang/lib/CodeGen/ |
| CGException.cpp | 1763 void Visit(const Stmt *S) {
1765 ConstStmtVisitor<CaptureFinder>::Visit(S);
1768 Visit(Child);
1850 Finder.Visit(OutlinedStmt);
|
| CGExprAgg.cpp | 105 void Visit(Expr *E) {
107 StmtVisitor<AggExprEmitter>::Visit(E);
113 void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
115 Visit(GE->getResultExpr());
123 void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->getSubExpr()); }
124 void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
126 return Visit(E->getReplacement());
135 return Visit(E->getSubExpr());
161 Visit(E->getSemanticForm());
179 Visit(DAE->getExpr())
[all...] |
| CGExprComplex.cpp | 95 ComplexPairTy Visit(Expr *E) {
97 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
109 return Visit(E->getSubExpr());
111 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
113 return Visit(GE->getResultExpr());
118 return Visit(PE->getReplacement());
127 return Visit(E->getSubExpr());
212 return Visit(E->getSubExpr());
218 return Visit(E->getSubExpr());
222 return Visit(DAE->getExpr())
[all...] |
| CGExprScalar.cpp | 410 Value *Visit(Expr *E) {
412 return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E);
428 return Visit(E->getSubExpr());
431 return Visit(PE->getSubExpr());
434 return Visit(E->getReplacement());
437 return Visit(GE->getResultExpr());
446 return Visit(E->getSubExpr());
616 return Visit(E->getSubExpr()); // the actual value should be unused
622 return Visit(E->getSubExpr());
630 return Visit(E->getSubExpr())
[all...] |
| /src/external/apache2/llvm/dist/clang/utils/TableGen/ |
| ClangDiagnosticsEmitter.cpp | 719 void Visit(Piece *P) {
723 return getDerived().Visit##T(static_cast<T##Piece *>(P))
737 Visit(Guard.Substitution);
819 return Visit(P->Pieces[0]);
833 Visitor.Visit(NodePair.first);
900 Visit(O);
943 Visit(Child);
957 Visit(D);
972 Visit(P->OptionPrefixes[I]);
973 Visit(P->Options[I])
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/ObjCARC/ |
| ObjCARCOpts.cpp | 541 bool Visit(Function &F, DenseMap<const BasicBlock *, BBState> &BBStates,
797 /// Visit each call, one at a time, and make simplifications without doing any
849 // Visit all objc_* calls in F.
1463 // Visit all the instructions, bottom-up.
1483 // If there's a predecessor with an invoke, visit the invoke as if it were
1607 // Visit all the instructions, top-down.
1707 // Visit the function both top-down and bottom-up.
1708 bool ObjCARCOpt::Visit(Function &F,
2007 // Visit each retain.
2232 bool NestingDetected = Visit(F, BBStates, Retains, Releases)
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/StaticAnalyzer/Core/ |
| ExprEngine.cpp | 786 // Visit the statement.
790 // Visit the statement.
791 Visit(currStmt, I, DstI);
1202 void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
2347 // FIXME: add checker visit.
2662 // FIXME: Prechecks eventually go in ::Visit().
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| LowerMatrixIntrinsics.cpp | 657 bool Visit() {
2053 if (LMT.Visit()) {
2082 bool C = LMT.Visit();
2131 bool C = LMT.Visit();
|
