1 //===---- StmtProfile.cpp - Profile implementation for Stmt ASTs ----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Stmt::Profile method, which builds a unique bit
11 // representation that identifies a statement/expression.
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/Expr.h"
19 #include "clang/AST/ExprCXX.h"
20 #include "clang/AST/ExprObjC.h"
21 #include "clang/AST/ExprOpenMP.h"
22 #include "clang/AST/ODRHash.h"
23 #include "clang/AST/StmtVisitor.h"
24 #include "llvm/ADT/FoldingSet.h"
25 using namespace clang;
28 class StmtProfiler : public ConstStmtVisitor<StmtProfiler> {
30 llvm::FoldingSetNodeID &ID;
34 StmtProfiler(llvm::FoldingSetNodeID &ID, bool Canonical)
35 : ID(ID), Canonical(Canonical) {}
37 virtual ~StmtProfiler() {}
39 void VisitStmt(const Stmt *S);
41 #define STMT(Node, Base) void Visit##Node(const Node *S);
42 #include "clang/AST/StmtNodes.inc"
44 /// \brief Visit a declaration that is referenced within an expression
46 virtual void VisitDecl(const Decl *D) = 0;
48 /// \brief Visit a type that is referenced within an expression or
50 virtual void VisitType(QualType T) = 0;
52 /// \brief Visit a name that occurs within an expression or statement.
53 virtual void VisitName(DeclarationName Name) = 0;
55 /// \brief Visit identifiers that are not in Decl's or Type's.
56 virtual void VisitIdentifierInfo(IdentifierInfo *II) = 0;
58 /// \brief Visit a nested-name-specifier that occurs within an expression
60 virtual void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) = 0;
62 /// \brief Visit a template name that occurs within an expression or
64 virtual void VisitTemplateName(TemplateName Name) = 0;
66 /// \brief Visit template arguments that occur within an expression or
68 void VisitTemplateArguments(const TemplateArgumentLoc *Args,
71 /// \brief Visit a single template argument.
72 void VisitTemplateArgument(const TemplateArgument &Arg);
75 class StmtProfilerWithPointers : public StmtProfiler {
76 const ASTContext &Context;
79 StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID,
80 const ASTContext &Context, bool Canonical)
81 : StmtProfiler(ID, Canonical), Context(Context) {}
83 void VisitDecl(const Decl *D) override {
84 ID.AddInteger(D ? D->getKind() : 0);
87 if (const NonTypeTemplateParmDecl *NTTP =
88 dyn_cast<NonTypeTemplateParmDecl>(D)) {
89 ID.AddInteger(NTTP->getDepth());
90 ID.AddInteger(NTTP->getIndex());
91 ID.AddBoolean(NTTP->isParameterPack());
92 VisitType(NTTP->getType());
96 if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
97 // The Itanium C++ ABI uses the type, scope depth, and scope
98 // index of a parameter when mangling expressions that involve
99 // function parameters, so we will use the parameter's type for
100 // establishing function parameter identity. That way, our
101 // definition of "equivalent" (per C++ [temp.over.link]) is at
102 // least as strong as the definition of "equivalent" used for
104 VisitType(Parm->getType());
105 ID.AddInteger(Parm->getFunctionScopeDepth());
106 ID.AddInteger(Parm->getFunctionScopeIndex());
110 if (const TemplateTypeParmDecl *TTP =
111 dyn_cast<TemplateTypeParmDecl>(D)) {
112 ID.AddInteger(TTP->getDepth());
113 ID.AddInteger(TTP->getIndex());
114 ID.AddBoolean(TTP->isParameterPack());
118 if (const TemplateTemplateParmDecl *TTP =
119 dyn_cast<TemplateTemplateParmDecl>(D)) {
120 ID.AddInteger(TTP->getDepth());
121 ID.AddInteger(TTP->getIndex());
122 ID.AddBoolean(TTP->isParameterPack());
127 ID.AddPointer(D ? D->getCanonicalDecl() : nullptr);
130 void VisitType(QualType T) override {
131 if (Canonical && !T.isNull())
132 T = Context.getCanonicalType(T);
134 ID.AddPointer(T.getAsOpaquePtr());
137 void VisitName(DeclarationName Name) override {
138 ID.AddPointer(Name.getAsOpaquePtr());
141 void VisitIdentifierInfo(IdentifierInfo *II) override {
145 void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
147 NNS = Context.getCanonicalNestedNameSpecifier(NNS);
151 void VisitTemplateName(TemplateName Name) override {
153 Name = Context.getCanonicalTemplateName(Name);
159 class StmtProfilerWithoutPointers : public StmtProfiler {
162 StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID, ODRHash &Hash)
163 : StmtProfiler(ID, false), Hash(Hash) {}
166 void VisitType(QualType T) override {
170 void VisitName(DeclarationName Name) override {
171 Hash.AddDeclarationName(Name);
173 void VisitIdentifierInfo(IdentifierInfo *II) override {
176 Hash.AddIdentifierInfo(II);
179 void VisitDecl(const Decl *D) override {
185 void VisitTemplateName(TemplateName Name) override {
186 Hash.AddTemplateName(Name);
188 void VisitNestedNameSpecifier(NestedNameSpecifier *NNS) override {
189 Hash.AddNestedNameSpecifier(NNS);
194 void StmtProfiler::VisitStmt(const Stmt *S) {
195 assert(S && "Requires non-null Stmt pointer");
196 ID.AddInteger(S->getStmtClass());
197 for (const Stmt *SubStmt : S->children()) {
205 void StmtProfiler::VisitDeclStmt(const DeclStmt *S) {
207 for (const auto *D : S->decls())
211 void StmtProfiler::VisitNullStmt(const NullStmt *S) {
215 void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) {
219 void StmtProfiler::VisitCaseStmt(const CaseStmt *S) {
223 void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) {
227 void StmtProfiler::VisitLabelStmt(const LabelStmt *S) {
229 VisitDecl(S->getDecl());
232 void StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) {
234 // TODO: maybe visit attributes?
237 void StmtProfiler::VisitIfStmt(const IfStmt *S) {
239 VisitDecl(S->getConditionVariable());
242 void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) {
244 VisitDecl(S->getConditionVariable());
247 void StmtProfiler::VisitWhileStmt(const WhileStmt *S) {
249 VisitDecl(S->getConditionVariable());
252 void StmtProfiler::VisitDoStmt(const DoStmt *S) {
256 void StmtProfiler::VisitForStmt(const ForStmt *S) {
260 void StmtProfiler::VisitGotoStmt(const GotoStmt *S) {
262 VisitDecl(S->getLabel());
265 void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) {
269 void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) {
273 void StmtProfiler::VisitBreakStmt(const BreakStmt *S) {
277 void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) {
281 void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) {
283 ID.AddBoolean(S->isVolatile());
284 ID.AddBoolean(S->isSimple());
285 VisitStringLiteral(S->getAsmString());
286 ID.AddInteger(S->getNumOutputs());
287 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
288 ID.AddString(S->getOutputName(I));
289 VisitStringLiteral(S->getOutputConstraintLiteral(I));
291 ID.AddInteger(S->getNumInputs());
292 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
293 ID.AddString(S->getInputName(I));
294 VisitStringLiteral(S->getInputConstraintLiteral(I));
296 ID.AddInteger(S->getNumClobbers());
297 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
298 VisitStringLiteral(S->getClobberStringLiteral(I));
301 void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) {
302 // FIXME: Implement MS style inline asm statement profiler.
306 void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) {
308 VisitType(S->getCaughtType());
311 void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) {
315 void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
319 void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
321 ID.AddBoolean(S->isIfExists());
322 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier());
323 VisitName(S->getNameInfo().getName());
326 void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) {
330 void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) {
334 void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) {
338 void StmtProfiler::VisitSEHLeaveStmt(const SEHLeaveStmt *S) {
342 void StmtProfiler::VisitCapturedStmt(const CapturedStmt *S) {
346 void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
350 void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) {
352 ID.AddBoolean(S->hasEllipsis());
353 if (S->getCatchParamDecl())
354 VisitType(S->getCatchParamDecl()->getType());
357 void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) {
361 void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) {
366 StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) {
370 void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) {
375 StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) {
380 class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
381 StmtProfiler *Profiler;
382 /// \brief Process clauses with list of variables.
383 template <typename T>
384 void VisitOMPClauseList(T *Node);
387 OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { }
388 #define OPENMP_CLAUSE(Name, Class) \
389 void Visit##Class(const Class *C);
390 #include "clang/Basic/OpenMPKinds.def"
391 void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
392 void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
395 void OMPClauseProfiler::VistOMPClauseWithPreInit(
396 const OMPClauseWithPreInit *C) {
397 if (auto *S = C->getPreInitStmt())
398 Profiler->VisitStmt(S);
401 void OMPClauseProfiler::VistOMPClauseWithPostUpdate(
402 const OMPClauseWithPostUpdate *C) {
403 VistOMPClauseWithPreInit(C);
404 if (auto *E = C->getPostUpdateExpr())
405 Profiler->VisitStmt(E);
408 void OMPClauseProfiler::VisitOMPIfClause(const OMPIfClause *C) {
409 VistOMPClauseWithPreInit(C);
410 if (C->getCondition())
411 Profiler->VisitStmt(C->getCondition());
414 void OMPClauseProfiler::VisitOMPFinalClause(const OMPFinalClause *C) {
415 if (C->getCondition())
416 Profiler->VisitStmt(C->getCondition());
419 void OMPClauseProfiler::VisitOMPNumThreadsClause(const OMPNumThreadsClause *C) {
420 VistOMPClauseWithPreInit(C);
421 if (C->getNumThreads())
422 Profiler->VisitStmt(C->getNumThreads());
425 void OMPClauseProfiler::VisitOMPSafelenClause(const OMPSafelenClause *C) {
427 Profiler->VisitStmt(C->getSafelen());
430 void OMPClauseProfiler::VisitOMPSimdlenClause(const OMPSimdlenClause *C) {
432 Profiler->VisitStmt(C->getSimdlen());
435 void OMPClauseProfiler::VisitOMPCollapseClause(const OMPCollapseClause *C) {
436 if (C->getNumForLoops())
437 Profiler->VisitStmt(C->getNumForLoops());
440 void OMPClauseProfiler::VisitOMPDefaultClause(const OMPDefaultClause *C) { }
442 void OMPClauseProfiler::VisitOMPProcBindClause(const OMPProcBindClause *C) { }
444 void OMPClauseProfiler::VisitOMPScheduleClause(const OMPScheduleClause *C) {
445 VistOMPClauseWithPreInit(C);
446 if (auto *S = C->getChunkSize())
447 Profiler->VisitStmt(S);
450 void OMPClauseProfiler::VisitOMPOrderedClause(const OMPOrderedClause *C) {
451 if (auto *Num = C->getNumForLoops())
452 Profiler->VisitStmt(Num);
455 void OMPClauseProfiler::VisitOMPNowaitClause(const OMPNowaitClause *) {}
457 void OMPClauseProfiler::VisitOMPUntiedClause(const OMPUntiedClause *) {}
459 void OMPClauseProfiler::VisitOMPMergeableClause(const OMPMergeableClause *) {}
461 void OMPClauseProfiler::VisitOMPReadClause(const OMPReadClause *) {}
463 void OMPClauseProfiler::VisitOMPWriteClause(const OMPWriteClause *) {}
465 void OMPClauseProfiler::VisitOMPUpdateClause(const OMPUpdateClause *) {}
467 void OMPClauseProfiler::VisitOMPCaptureClause(const OMPCaptureClause *) {}
469 void OMPClauseProfiler::VisitOMPSeqCstClause(const OMPSeqCstClause *) {}
471 void OMPClauseProfiler::VisitOMPThreadsClause(const OMPThreadsClause *) {}
473 void OMPClauseProfiler::VisitOMPSIMDClause(const OMPSIMDClause *) {}
475 void OMPClauseProfiler::VisitOMPNogroupClause(const OMPNogroupClause *) {}
478 void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
479 for (auto *E : Node->varlists()) {
481 Profiler->VisitStmt(E);
485 void OMPClauseProfiler::VisitOMPPrivateClause(const OMPPrivateClause *C) {
486 VisitOMPClauseList(C);
487 for (auto *E : C->private_copies()) {
489 Profiler->VisitStmt(E);
493 OMPClauseProfiler::VisitOMPFirstprivateClause(const OMPFirstprivateClause *C) {
494 VisitOMPClauseList(C);
495 VistOMPClauseWithPreInit(C);
496 for (auto *E : C->private_copies()) {
498 Profiler->VisitStmt(E);
500 for (auto *E : C->inits()) {
502 Profiler->VisitStmt(E);
506 OMPClauseProfiler::VisitOMPLastprivateClause(const OMPLastprivateClause *C) {
507 VisitOMPClauseList(C);
508 VistOMPClauseWithPostUpdate(C);
509 for (auto *E : C->source_exprs()) {
511 Profiler->VisitStmt(E);
513 for (auto *E : C->destination_exprs()) {
515 Profiler->VisitStmt(E);
517 for (auto *E : C->assignment_ops()) {
519 Profiler->VisitStmt(E);
522 void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) {
523 VisitOMPClauseList(C);
525 void OMPClauseProfiler::VisitOMPReductionClause(
526 const OMPReductionClause *C) {
527 Profiler->VisitNestedNameSpecifier(
528 C->getQualifierLoc().getNestedNameSpecifier());
529 Profiler->VisitName(C->getNameInfo().getName());
530 VisitOMPClauseList(C);
531 VistOMPClauseWithPostUpdate(C);
532 for (auto *E : C->privates()) {
534 Profiler->VisitStmt(E);
536 for (auto *E : C->lhs_exprs()) {
538 Profiler->VisitStmt(E);
540 for (auto *E : C->rhs_exprs()) {
542 Profiler->VisitStmt(E);
544 for (auto *E : C->reduction_ops()) {
546 Profiler->VisitStmt(E);
549 void OMPClauseProfiler::VisitOMPLinearClause(const OMPLinearClause *C) {
550 VisitOMPClauseList(C);
551 VistOMPClauseWithPostUpdate(C);
552 for (auto *E : C->privates()) {
554 Profiler->VisitStmt(E);
556 for (auto *E : C->inits()) {
558 Profiler->VisitStmt(E);
560 for (auto *E : C->updates()) {
562 Profiler->VisitStmt(E);
564 for (auto *E : C->finals()) {
566 Profiler->VisitStmt(E);
569 Profiler->VisitStmt(C->getStep());
570 if (C->getCalcStep())
571 Profiler->VisitStmt(C->getCalcStep());
573 void OMPClauseProfiler::VisitOMPAlignedClause(const OMPAlignedClause *C) {
574 VisitOMPClauseList(C);
575 if (C->getAlignment())
576 Profiler->VisitStmt(C->getAlignment());
578 void OMPClauseProfiler::VisitOMPCopyinClause(const OMPCopyinClause *C) {
579 VisitOMPClauseList(C);
580 for (auto *E : C->source_exprs()) {
582 Profiler->VisitStmt(E);
584 for (auto *E : C->destination_exprs()) {
586 Profiler->VisitStmt(E);
588 for (auto *E : C->assignment_ops()) {
590 Profiler->VisitStmt(E);
594 OMPClauseProfiler::VisitOMPCopyprivateClause(const OMPCopyprivateClause *C) {
595 VisitOMPClauseList(C);
596 for (auto *E : C->source_exprs()) {
598 Profiler->VisitStmt(E);
600 for (auto *E : C->destination_exprs()) {
602 Profiler->VisitStmt(E);
604 for (auto *E : C->assignment_ops()) {
606 Profiler->VisitStmt(E);
609 void OMPClauseProfiler::VisitOMPFlushClause(const OMPFlushClause *C) {
610 VisitOMPClauseList(C);
612 void OMPClauseProfiler::VisitOMPDependClause(const OMPDependClause *C) {
613 VisitOMPClauseList(C);
615 void OMPClauseProfiler::VisitOMPDeviceClause(const OMPDeviceClause *C) {
617 Profiler->VisitStmt(C->getDevice());
619 void OMPClauseProfiler::VisitOMPMapClause(const OMPMapClause *C) {
620 VisitOMPClauseList(C);
622 void OMPClauseProfiler::VisitOMPNumTeamsClause(const OMPNumTeamsClause *C) {
623 VistOMPClauseWithPreInit(C);
624 if (C->getNumTeams())
625 Profiler->VisitStmt(C->getNumTeams());
627 void OMPClauseProfiler::VisitOMPThreadLimitClause(
628 const OMPThreadLimitClause *C) {
629 VistOMPClauseWithPreInit(C);
630 if (C->getThreadLimit())
631 Profiler->VisitStmt(C->getThreadLimit());
633 void OMPClauseProfiler::VisitOMPPriorityClause(const OMPPriorityClause *C) {
634 if (C->getPriority())
635 Profiler->VisitStmt(C->getPriority());
637 void OMPClauseProfiler::VisitOMPGrainsizeClause(const OMPGrainsizeClause *C) {
638 if (C->getGrainsize())
639 Profiler->VisitStmt(C->getGrainsize());
641 void OMPClauseProfiler::VisitOMPNumTasksClause(const OMPNumTasksClause *C) {
642 if (C->getNumTasks())
643 Profiler->VisitStmt(C->getNumTasks());
645 void OMPClauseProfiler::VisitOMPHintClause(const OMPHintClause *C) {
647 Profiler->VisitStmt(C->getHint());
649 void OMPClauseProfiler::VisitOMPToClause(const OMPToClause *C) {
650 VisitOMPClauseList(C);
652 void OMPClauseProfiler::VisitOMPFromClause(const OMPFromClause *C) {
653 VisitOMPClauseList(C);
655 void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
656 const OMPUseDevicePtrClause *C) {
657 VisitOMPClauseList(C);
659 void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
660 const OMPIsDevicePtrClause *C) {
661 VisitOMPClauseList(C);
666 StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
668 OMPClauseProfiler P(this);
669 ArrayRef<OMPClause *> Clauses = S->clauses();
670 for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
676 void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) {
677 VisitOMPExecutableDirective(S);
680 void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
681 VisitOMPExecutableDirective(S);
684 void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) {
685 VisitOMPLoopDirective(S);
688 void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) {
689 VisitOMPLoopDirective(S);
692 void StmtProfiler::VisitOMPForSimdDirective(const OMPForSimdDirective *S) {
693 VisitOMPLoopDirective(S);
696 void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) {
697 VisitOMPExecutableDirective(S);
700 void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
701 VisitOMPExecutableDirective(S);
704 void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) {
705 VisitOMPExecutableDirective(S);
708 void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) {
709 VisitOMPExecutableDirective(S);
712 void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) {
713 VisitOMPExecutableDirective(S);
714 VisitName(S->getDirectiveName().getName());
718 StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) {
719 VisitOMPLoopDirective(S);
722 void StmtProfiler::VisitOMPParallelForSimdDirective(
723 const OMPParallelForSimdDirective *S) {
724 VisitOMPLoopDirective(S);
727 void StmtProfiler::VisitOMPParallelSectionsDirective(
728 const OMPParallelSectionsDirective *S) {
729 VisitOMPExecutableDirective(S);
732 void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) {
733 VisitOMPExecutableDirective(S);
736 void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) {
737 VisitOMPExecutableDirective(S);
740 void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) {
741 VisitOMPExecutableDirective(S);
744 void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) {
745 VisitOMPExecutableDirective(S);
748 void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) {
749 VisitOMPExecutableDirective(S);
752 void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) {
753 VisitOMPExecutableDirective(S);
756 void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) {
757 VisitOMPExecutableDirective(S);
760 void StmtProfiler::VisitOMPAtomicDirective(const OMPAtomicDirective *S) {
761 VisitOMPExecutableDirective(S);
764 void StmtProfiler::VisitOMPTargetDirective(const OMPTargetDirective *S) {
765 VisitOMPExecutableDirective(S);
768 void StmtProfiler::VisitOMPTargetDataDirective(const OMPTargetDataDirective *S) {
769 VisitOMPExecutableDirective(S);
772 void StmtProfiler::VisitOMPTargetEnterDataDirective(
773 const OMPTargetEnterDataDirective *S) {
774 VisitOMPExecutableDirective(S);
777 void StmtProfiler::VisitOMPTargetExitDataDirective(
778 const OMPTargetExitDataDirective *S) {
779 VisitOMPExecutableDirective(S);
782 void StmtProfiler::VisitOMPTargetParallelDirective(
783 const OMPTargetParallelDirective *S) {
784 VisitOMPExecutableDirective(S);
787 void StmtProfiler::VisitOMPTargetParallelForDirective(
788 const OMPTargetParallelForDirective *S) {
789 VisitOMPExecutableDirective(S);
792 void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) {
793 VisitOMPExecutableDirective(S);
796 void StmtProfiler::VisitOMPCancellationPointDirective(
797 const OMPCancellationPointDirective *S) {
798 VisitOMPExecutableDirective(S);
801 void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) {
802 VisitOMPExecutableDirective(S);
805 void StmtProfiler::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *S) {
806 VisitOMPLoopDirective(S);
809 void StmtProfiler::VisitOMPTaskLoopSimdDirective(
810 const OMPTaskLoopSimdDirective *S) {
811 VisitOMPLoopDirective(S);
814 void StmtProfiler::VisitOMPDistributeDirective(
815 const OMPDistributeDirective *S) {
816 VisitOMPLoopDirective(S);
819 void OMPClauseProfiler::VisitOMPDistScheduleClause(
820 const OMPDistScheduleClause *C) {
821 VistOMPClauseWithPreInit(C);
822 if (auto *S = C->getChunkSize())
823 Profiler->VisitStmt(S);
826 void OMPClauseProfiler::VisitOMPDefaultmapClause(const OMPDefaultmapClause *) {}
828 void StmtProfiler::VisitOMPTargetUpdateDirective(
829 const OMPTargetUpdateDirective *S) {
830 VisitOMPExecutableDirective(S);
833 void StmtProfiler::VisitOMPDistributeParallelForDirective(
834 const OMPDistributeParallelForDirective *S) {
835 VisitOMPLoopDirective(S);
838 void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
839 const OMPDistributeParallelForSimdDirective *S) {
840 VisitOMPLoopDirective(S);
843 void StmtProfiler::VisitOMPDistributeSimdDirective(
844 const OMPDistributeSimdDirective *S) {
845 VisitOMPLoopDirective(S);
848 void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
849 const OMPTargetParallelForSimdDirective *S) {
850 VisitOMPLoopDirective(S);
853 void StmtProfiler::VisitOMPTargetSimdDirective(
854 const OMPTargetSimdDirective *S) {
855 VisitOMPLoopDirective(S);
858 void StmtProfiler::VisitOMPTeamsDistributeDirective(
859 const OMPTeamsDistributeDirective *S) {
860 VisitOMPLoopDirective(S);
863 void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
864 const OMPTeamsDistributeSimdDirective *S) {
865 VisitOMPLoopDirective(S);
868 void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
869 const OMPTeamsDistributeParallelForSimdDirective *S) {
870 VisitOMPLoopDirective(S);
873 void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
874 const OMPTeamsDistributeParallelForDirective *S) {
875 VisitOMPLoopDirective(S);
878 void StmtProfiler::VisitOMPTargetTeamsDirective(
879 const OMPTargetTeamsDirective *S) {
880 VisitOMPExecutableDirective(S);
883 void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
884 const OMPTargetTeamsDistributeDirective *S) {
885 VisitOMPLoopDirective(S);
888 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
889 const OMPTargetTeamsDistributeParallelForDirective *S) {
890 VisitOMPLoopDirective(S);
893 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
894 const OMPTargetTeamsDistributeParallelForSimdDirective *S) {
895 VisitOMPLoopDirective(S);
898 void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
899 const OMPTargetTeamsDistributeSimdDirective *S) {
900 VisitOMPLoopDirective(S);
903 void StmtProfiler::VisitExpr(const Expr *S) {
907 void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) {
910 VisitNestedNameSpecifier(S->getQualifier());
911 VisitDecl(S->getDecl());
913 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
916 void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) {
918 ID.AddInteger(S->getIdentType());
921 void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) {
923 S->getValue().Profile(ID);
924 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
927 void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) {
929 ID.AddInteger(S->getKind());
930 ID.AddInteger(S->getValue());
933 void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) {
935 S->getValue().Profile(ID);
936 ID.AddBoolean(S->isExact());
937 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
940 void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) {
944 void StmtProfiler::VisitStringLiteral(const StringLiteral *S) {
946 ID.AddString(S->getBytes());
947 ID.AddInteger(S->getKind());
950 void StmtProfiler::VisitParenExpr(const ParenExpr *S) {
954 void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) {
958 void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) {
960 ID.AddInteger(S->getOpcode());
963 void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
964 VisitType(S->getTypeSourceInfo()->getType());
965 unsigned n = S->getNumComponents();
966 for (unsigned i = 0; i < n; ++i) {
967 const OffsetOfNode &ON = S->getComponent(i);
968 ID.AddInteger(ON.getKind());
969 switch (ON.getKind()) {
970 case OffsetOfNode::Array:
971 // Expressions handled below.
974 case OffsetOfNode::Field:
975 VisitDecl(ON.getField());
978 case OffsetOfNode::Identifier:
979 VisitIdentifierInfo(ON.getFieldName());
982 case OffsetOfNode::Base:
983 // These nodes are implicit, and therefore don't need profiling.
992 StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) {
994 ID.AddInteger(S->getKind());
995 if (S->isArgumentType())
996 VisitType(S->getArgumentType());
999 void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) {
1003 void StmtProfiler::VisitOMPArraySectionExpr(const OMPArraySectionExpr *S) {
1007 void StmtProfiler::VisitCallExpr(const CallExpr *S) {
1011 void StmtProfiler::VisitMemberExpr(const MemberExpr *S) {
1013 VisitDecl(S->getMemberDecl());
1015 VisitNestedNameSpecifier(S->getQualifier());
1016 ID.AddBoolean(S->isArrow());
1019 void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) {
1021 ID.AddBoolean(S->isFileScope());
1024 void StmtProfiler::VisitCastExpr(const CastExpr *S) {
1028 void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) {
1030 ID.AddInteger(S->getValueKind());
1033 void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) {
1035 VisitType(S->getTypeAsWritten());
1038 void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) {
1039 VisitExplicitCastExpr(S);
1042 void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) {
1044 ID.AddInteger(S->getOpcode());
1048 StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) {
1049 VisitBinaryOperator(S);
1052 void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) {
1056 void StmtProfiler::VisitBinaryConditionalOperator(
1057 const BinaryConditionalOperator *S) {
1061 void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) {
1063 VisitDecl(S->getLabel());
1066 void StmtProfiler::VisitStmtExpr(const StmtExpr *S) {
1070 void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) {
1074 void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) {
1078 void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) {
1082 void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
1086 void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
1090 void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
1091 if (S->getSyntacticForm()) {
1092 VisitInitListExpr(S->getSyntacticForm());
1099 void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
1101 ID.AddBoolean(S->usesGNUSyntax());
1102 for (const DesignatedInitExpr::Designator &D : S->designators()) {
1103 if (D.isFieldDesignator()) {
1105 VisitName(D.getFieldName());
1109 if (D.isArrayDesignator()) {
1112 assert(D.isArrayRangeDesignator());
1115 ID.AddInteger(D.getFirstExprIndex());
1119 // Seems that if VisitInitListExpr() only works on the syntactic form of an
1120 // InitListExpr, then a DesignatedInitUpdateExpr is not encountered.
1121 void StmtProfiler::VisitDesignatedInitUpdateExpr(
1122 const DesignatedInitUpdateExpr *S) {
1123 llvm_unreachable("Unexpected DesignatedInitUpdateExpr in syntactic form of "
1127 void StmtProfiler::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *S) {
1131 void StmtProfiler::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *S) {
1135 void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) {
1136 llvm_unreachable("Unexpected NoInitExpr in syntactic form of initializer");
1139 void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) {
1143 void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) {
1145 VisitName(&S->getAccessor());
1148 void StmtProfiler::VisitBlockExpr(const BlockExpr *S) {
1150 VisitDecl(S->getBlockDecl());
1153 void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) {
1155 for (unsigned i = 0; i != S->getNumAssocs(); ++i) {
1156 QualType T = S->getAssocType(i);
1158 ID.AddPointer(nullptr);
1161 VisitExpr(S->getAssocExpr(i));
1165 void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) {
1167 for (PseudoObjectExpr::const_semantics_iterator
1168 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1169 // Normally, we would not profile the source expressions of OVEs.
1170 if (const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(*i))
1171 Visit(OVE->getSourceExpr());
1174 void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) {
1176 ID.AddInteger(S->getOp());
1179 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
1180 UnaryOperatorKind &UnaryOp,
1181 BinaryOperatorKind &BinaryOp) {
1182 switch (S->getOperator()) {
1187 case OO_Array_Delete:
1190 case OO_Conditional:
1192 case NUM_OVERLOADED_OPERATORS:
1193 llvm_unreachable("Invalid operator call kind");
1196 if (S->getNumArgs() == 1) {
1198 return Stmt::UnaryOperatorClass;
1202 return Stmt::BinaryOperatorClass;
1205 if (S->getNumArgs() == 1) {
1207 return Stmt::UnaryOperatorClass;
1211 return Stmt::BinaryOperatorClass;
1214 if (S->getNumArgs() == 1) {
1216 return Stmt::UnaryOperatorClass;
1220 return Stmt::BinaryOperatorClass;
1224 return Stmt::BinaryOperatorClass;
1228 return Stmt::BinaryOperatorClass;
1232 return Stmt::BinaryOperatorClass;
1235 if (S->getNumArgs() == 1) {
1236 UnaryOp = UO_AddrOf;
1237 return Stmt::UnaryOperatorClass;
1241 return Stmt::BinaryOperatorClass;
1245 return Stmt::BinaryOperatorClass;
1249 return Stmt::UnaryOperatorClass;
1253 return Stmt::UnaryOperatorClass;
1256 BinaryOp = BO_Assign;
1257 return Stmt::BinaryOperatorClass;
1261 return Stmt::BinaryOperatorClass;
1265 return Stmt::BinaryOperatorClass;
1268 BinaryOp = BO_AddAssign;
1269 return Stmt::CompoundAssignOperatorClass;
1272 BinaryOp = BO_SubAssign;
1273 return Stmt::CompoundAssignOperatorClass;
1276 BinaryOp = BO_MulAssign;
1277 return Stmt::CompoundAssignOperatorClass;
1280 BinaryOp = BO_DivAssign;
1281 return Stmt::CompoundAssignOperatorClass;
1283 case OO_PercentEqual:
1284 BinaryOp = BO_RemAssign;
1285 return Stmt::CompoundAssignOperatorClass;
1288 BinaryOp = BO_XorAssign;
1289 return Stmt::CompoundAssignOperatorClass;
1292 BinaryOp = BO_AndAssign;
1293 return Stmt::CompoundAssignOperatorClass;
1296 BinaryOp = BO_OrAssign;
1297 return Stmt::CompoundAssignOperatorClass;
1301 return Stmt::BinaryOperatorClass;
1303 case OO_GreaterGreater:
1305 return Stmt::BinaryOperatorClass;
1307 case OO_LessLessEqual:
1308 BinaryOp = BO_ShlAssign;
1309 return Stmt::CompoundAssignOperatorClass;
1311 case OO_GreaterGreaterEqual:
1312 BinaryOp = BO_ShrAssign;
1313 return Stmt::CompoundAssignOperatorClass;
1317 return Stmt::BinaryOperatorClass;
1319 case OO_ExclaimEqual:
1321 return Stmt::BinaryOperatorClass;
1325 return Stmt::BinaryOperatorClass;
1327 case OO_GreaterEqual:
1329 return Stmt::BinaryOperatorClass;
1333 return Stmt::BinaryOperatorClass;
1337 return Stmt::BinaryOperatorClass;
1340 UnaryOp = S->getNumArgs() == 1? UO_PreInc
1342 return Stmt::UnaryOperatorClass;
1345 UnaryOp = S->getNumArgs() == 1? UO_PreDec
1347 return Stmt::UnaryOperatorClass;
1350 BinaryOp = BO_Comma;
1351 return Stmt::BinaryOperatorClass;
1354 BinaryOp = BO_PtrMemI;
1355 return Stmt::BinaryOperatorClass;
1358 return Stmt::ArraySubscriptExprClass;
1361 llvm_unreachable("Invalid overloaded operator expression");
1364 void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
1365 if (S->isTypeDependent()) {
1366 // Type-dependent operator calls are profiled like their underlying
1367 // syntactic operator.
1369 // An operator call to operator-> is always implicit, so just skip it. The
1370 // enclosing MemberExpr will profile the actual member access.
1371 if (S->getOperator() == OO_Arrow)
1372 return Visit(S->getArg(0));
1374 UnaryOperatorKind UnaryOp = UO_Extension;
1375 BinaryOperatorKind BinaryOp = BO_Comma;
1376 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp);
1379 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
1380 Visit(S->getArg(I));
1381 if (SC == Stmt::UnaryOperatorClass)
1382 ID.AddInteger(UnaryOp);
1383 else if (SC == Stmt::BinaryOperatorClass ||
1384 SC == Stmt::CompoundAssignOperatorClass)
1385 ID.AddInteger(BinaryOp);
1387 assert(SC == Stmt::ArraySubscriptExprClass);
1393 ID.AddInteger(S->getOperator());
1396 void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) {
1400 void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) {
1404 void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) {
1408 void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) {
1409 VisitExplicitCastExpr(S);
1412 void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) {
1413 VisitCXXNamedCastExpr(S);
1416 void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) {
1417 VisitCXXNamedCastExpr(S);
1421 StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) {
1422 VisitCXXNamedCastExpr(S);
1425 void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) {
1426 VisitCXXNamedCastExpr(S);
1429 void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) {
1433 void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
1435 ID.AddBoolean(S->getValue());
1438 void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) {
1442 void StmtProfiler::VisitCXXStdInitializerListExpr(
1443 const CXXStdInitializerListExpr *S) {
1447 void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) {
1449 if (S->isTypeOperand())
1450 VisitType(S->getTypeOperandSourceInfo()->getType());
1453 void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) {
1455 if (S->isTypeOperand())
1456 VisitType(S->getTypeOperandSourceInfo()->getType());
1459 void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) {
1461 VisitDecl(S->getPropertyDecl());
1464 void StmtProfiler::VisitMSPropertySubscriptExpr(
1465 const MSPropertySubscriptExpr *S) {
1469 void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) {
1471 ID.AddBoolean(S->isImplicit());
1474 void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) {
1478 void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) {
1480 VisitDecl(S->getParam());
1483 void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) {
1485 VisitDecl(S->getField());
1488 void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) {
1491 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor()));
1494 void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) {
1496 VisitDecl(S->getConstructor());
1497 ID.AddBoolean(S->isElidable());
1500 void StmtProfiler::VisitCXXInheritedCtorInitExpr(
1501 const CXXInheritedCtorInitExpr *S) {
1503 VisitDecl(S->getConstructor());
1506 void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) {
1507 VisitExplicitCastExpr(S);
1511 StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) {
1512 VisitCXXConstructExpr(S);
1516 StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
1518 for (LambdaExpr::capture_iterator C = S->explicit_capture_begin(),
1519 CEnd = S->explicit_capture_end();
1521 ID.AddInteger(C->getCaptureKind());
1522 switch (C->getCaptureKind()) {
1528 VisitDecl(C->getCapturedVar());
1529 ID.AddBoolean(C->isPackExpansion());
1532 llvm_unreachable("VLA type in explicit captures.");
1535 // Note: If we actually needed to be able to match lambda
1536 // expressions, we would have to consider parameters and return type
1537 // here, among other things.
1538 VisitStmt(S->getBody());
1542 StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) {
1546 void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
1548 ID.AddBoolean(S->isGlobalDelete());
1549 ID.AddBoolean(S->isArrayForm());
1550 VisitDecl(S->getOperatorDelete());
1553 void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) {
1555 VisitType(S->getAllocatedType());
1556 VisitDecl(S->getOperatorNew());
1557 VisitDecl(S->getOperatorDelete());
1558 ID.AddBoolean(S->isArray());
1559 ID.AddInteger(S->getNumPlacementArgs());
1560 ID.AddBoolean(S->isGlobalNew());
1561 ID.AddBoolean(S->isParenTypeId());
1562 ID.AddInteger(S->getInitializationStyle());
1566 StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
1568 ID.AddBoolean(S->isArrow());
1569 VisitNestedNameSpecifier(S->getQualifier());
1570 ID.AddBoolean(S->getScopeTypeInfo() != nullptr);
1571 if (S->getScopeTypeInfo())
1572 VisitType(S->getScopeTypeInfo()->getType());
1573 ID.AddBoolean(S->getDestroyedTypeInfo() != nullptr);
1574 if (S->getDestroyedTypeInfo())
1575 VisitType(S->getDestroyedType());
1577 VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
1580 void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) {
1582 VisitNestedNameSpecifier(S->getQualifier());
1583 VisitName(S->getName());
1584 ID.AddBoolean(S->hasExplicitTemplateArgs());
1585 if (S->hasExplicitTemplateArgs())
1586 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1590 StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) {
1591 VisitOverloadExpr(S);
1594 void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) {
1596 ID.AddInteger(S->getTrait());
1597 ID.AddInteger(S->getNumArgs());
1598 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
1599 VisitType(S->getArg(I)->getType());
1602 void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) {
1604 ID.AddInteger(S->getTrait());
1605 VisitType(S->getQueriedType());
1608 void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) {
1610 ID.AddInteger(S->getTrait());
1611 VisitExpr(S->getQueriedExpression());
1614 void StmtProfiler::VisitDependentScopeDeclRefExpr(
1615 const DependentScopeDeclRefExpr *S) {
1617 VisitName(S->getDeclName());
1618 VisitNestedNameSpecifier(S->getQualifier());
1619 ID.AddBoolean(S->hasExplicitTemplateArgs());
1620 if (S->hasExplicitTemplateArgs())
1621 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1624 void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) {
1628 void StmtProfiler::VisitCXXUnresolvedConstructExpr(
1629 const CXXUnresolvedConstructExpr *S) {
1631 VisitType(S->getTypeAsWritten());
1634 void StmtProfiler::VisitCXXDependentScopeMemberExpr(
1635 const CXXDependentScopeMemberExpr *S) {
1636 ID.AddBoolean(S->isImplicitAccess());
1637 if (!S->isImplicitAccess()) {
1639 ID.AddBoolean(S->isArrow());
1641 VisitNestedNameSpecifier(S->getQualifier());
1642 VisitName(S->getMember());
1643 ID.AddBoolean(S->hasExplicitTemplateArgs());
1644 if (S->hasExplicitTemplateArgs())
1645 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1648 void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) {
1649 ID.AddBoolean(S->isImplicitAccess());
1650 if (!S->isImplicitAccess()) {
1652 ID.AddBoolean(S->isArrow());
1654 VisitNestedNameSpecifier(S->getQualifier());
1655 VisitName(S->getMemberName());
1656 ID.AddBoolean(S->hasExplicitTemplateArgs());
1657 if (S->hasExplicitTemplateArgs())
1658 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1661 void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) {
1665 void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) {
1669 void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) {
1671 VisitDecl(S->getPack());
1672 if (S->isPartiallySubstituted()) {
1673 auto Args = S->getPartialArguments();
1674 ID.AddInteger(Args.size());
1675 for (const auto &TA : Args)
1676 VisitTemplateArgument(TA);
1682 void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
1683 const SubstNonTypeTemplateParmPackExpr *S) {
1685 VisitDecl(S->getParameterPack());
1686 VisitTemplateArgument(S->getArgumentPack());
1689 void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
1690 const SubstNonTypeTemplateParmExpr *E) {
1691 // Profile exactly as the replacement expression.
1692 Visit(E->getReplacement());
1695 void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) {
1697 VisitDecl(S->getParameterPack());
1698 ID.AddInteger(S->getNumExpansions());
1699 for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I)
1703 void StmtProfiler::VisitMaterializeTemporaryExpr(
1704 const MaterializeTemporaryExpr *S) {
1708 void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) {
1710 ID.AddInteger(S->getOperator());
1713 void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) {
1717 void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
1721 void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) {
1725 void StmtProfiler::VisitDependentCoawaitExpr(const DependentCoawaitExpr *S) {
1729 void StmtProfiler::VisitCoyieldExpr(const CoyieldExpr *S) {
1733 void StmtProfiler::VisitOpaqueValueExpr(const OpaqueValueExpr *E) {
1737 void StmtProfiler::VisitTypoExpr(const TypoExpr *E) {
1741 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
1745 void StmtProfiler::VisitObjCBoxedExpr(const ObjCBoxedExpr *E) {
1749 void StmtProfiler::VisitObjCArrayLiteral(const ObjCArrayLiteral *E) {
1753 void StmtProfiler::VisitObjCDictionaryLiteral(const ObjCDictionaryLiteral *E) {
1757 void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) {
1759 VisitType(S->getEncodedType());
1762 void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) {
1764 VisitName(S->getSelector());
1767 void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) {
1769 VisitDecl(S->getProtocol());
1772 void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) {
1774 VisitDecl(S->getDecl());
1775 ID.AddBoolean(S->isArrow());
1776 ID.AddBoolean(S->isFreeIvar());
1779 void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) {
1781 if (S->isImplicitProperty()) {
1782 VisitDecl(S->getImplicitPropertyGetter());
1783 VisitDecl(S->getImplicitPropertySetter());
1785 VisitDecl(S->getExplicitProperty());
1787 if (S->isSuperReceiver()) {
1788 ID.AddBoolean(S->isSuperReceiver());
1789 VisitType(S->getSuperReceiverType());
1793 void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) {
1795 VisitDecl(S->getAtIndexMethodDecl());
1796 VisitDecl(S->setAtIndexMethodDecl());
1799 void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) {
1801 VisitName(S->getSelector());
1802 VisitDecl(S->getMethodDecl());
1805 void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) {
1807 ID.AddBoolean(S->isArrow());
1810 void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) {
1812 ID.AddBoolean(S->getValue());
1815 void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
1816 const ObjCIndirectCopyRestoreExpr *S) {
1818 ID.AddBoolean(S->shouldCopy());
1821 void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) {
1822 VisitExplicitCastExpr(S);
1823 ID.AddBoolean(S->getBridgeKind());
1826 void StmtProfiler::VisitObjCAvailabilityCheckExpr(
1827 const ObjCAvailabilityCheckExpr *S) {
1831 void StmtProfiler::VisitTemplateArguments(const TemplateArgumentLoc *Args,
1833 ID.AddInteger(NumArgs);
1834 for (unsigned I = 0; I != NumArgs; ++I)
1835 VisitTemplateArgument(Args[I].getArgument());
1838 void StmtProfiler::VisitTemplateArgument(const TemplateArgument &Arg) {
1839 // Mostly repetitive with TemplateArgument::Profile!
1840 ID.AddInteger(Arg.getKind());
1841 switch (Arg.getKind()) {
1842 case TemplateArgument::Null:
1845 case TemplateArgument::Type:
1846 VisitType(Arg.getAsType());
1849 case TemplateArgument::Template:
1850 case TemplateArgument::TemplateExpansion:
1851 VisitTemplateName(Arg.getAsTemplateOrTemplatePattern());
1854 case TemplateArgument::Declaration:
1855 VisitDecl(Arg.getAsDecl());
1858 case TemplateArgument::NullPtr:
1859 VisitType(Arg.getNullPtrType());
1862 case TemplateArgument::Integral:
1863 Arg.getAsIntegral().Profile(ID);
1864 VisitType(Arg.getIntegralType());
1867 case TemplateArgument::Expression:
1868 Visit(Arg.getAsExpr());
1871 case TemplateArgument::Pack:
1872 for (const auto &P : Arg.pack_elements())
1873 VisitTemplateArgument(P);
1878 void Stmt::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
1879 bool Canonical) const {
1880 StmtProfilerWithPointers Profiler(ID, Context, Canonical);
1881 Profiler.Visit(this);
1884 void Stmt::ProcessODRHash(llvm::FoldingSetNodeID &ID,
1885 class ODRHash &Hash) const {
1886 StmtProfilerWithoutPointers Profiler(ID, Hash);
1887 Profiler.Visit(this);