24 #include "llvm/ADT/FoldingSet.h"
25 using namespace clang;
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 void VisitStmtNoChildren(
const Stmt *S) {
42 HandleStmtClass(S->getStmtClass());
47 #define STMT(Node, Base) void Visit##Node(const Node *S);
48 #include "clang/AST/StmtNodes.inc"
52 virtual void VisitDecl(
const Decl *D) = 0;
56 virtual void VisitType(
QualType T) = 0;
59 virtual void VisitName(
DeclarationName Name,
bool TreatAsDecl =
false) = 0;
81 class StmtProfilerWithPointers :
public StmtProfiler {
85 StmtProfilerWithPointers(llvm::FoldingSetNodeID &
ID,
87 : StmtProfiler(
ID, Canonical), Context(Context) {}
93 void VisitDecl(
const Decl *D)
override {
98 dyn_cast<NonTypeTemplateParmDecl>(D)) {
99 ID.AddInteger(NTTP->getDepth());
100 ID.AddInteger(NTTP->getIndex());
101 ID.AddBoolean(NTTP->isParameterPack());
102 VisitType(NTTP->getType());
106 if (
const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
114 VisitType(Parm->getType());
115 ID.AddInteger(Parm->getFunctionScopeDepth());
116 ID.AddInteger(Parm->getFunctionScopeIndex());
121 dyn_cast<TemplateTypeParmDecl>(D)) {
122 ID.AddInteger(TTP->getDepth());
123 ID.AddInteger(TTP->getIndex());
124 ID.AddBoolean(TTP->isParameterPack());
129 dyn_cast<TemplateTemplateParmDecl>(D)) {
130 ID.AddInteger(TTP->getDepth());
131 ID.AddInteger(TTP->getIndex());
132 ID.AddBoolean(TTP->isParameterPack());
140 void VisitType(
QualType T)
override {
141 if (Canonical && !T.
isNull())
148 ID.AddPointer(Name.getAsOpaquePtr());
169 class StmtProfilerWithoutPointers :
public StmtProfiler {
172 StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &
ID,
ODRHash &Hash)
173 : StmtProfiler(
ID,
false), Hash(Hash) {}
177 if (SC == Stmt::UnresolvedLookupExprClass) {
180 ID.AddInteger(Stmt::DeclRefExprClass);
186 void VisitType(
QualType T)
override {
204 void VisitDecl(
const Decl *D)
override {
222 void StmtProfiler::VisitStmt(
const Stmt *S) {
223 assert(S &&
"Requires non-null Stmt pointer");
225 VisitStmtNoChildren(S);
227 for (
const Stmt *SubStmt : S->children()) {
235 void StmtProfiler::VisitDeclStmt(
const DeclStmt *S) {
237 for (
const auto *D : S->decls())
241 void StmtProfiler::VisitNullStmt(
const NullStmt *S) {
245 void StmtProfiler::VisitCompoundStmt(
const CompoundStmt *S) {
249 void StmtProfiler::VisitCaseStmt(
const CaseStmt *S) {
253 void StmtProfiler::VisitDefaultStmt(
const DefaultStmt *S) {
257 void StmtProfiler::VisitLabelStmt(
const LabelStmt *S) {
259 VisitDecl(S->getDecl());
267 void StmtProfiler::VisitIfStmt(
const IfStmt *S) {
269 VisitDecl(S->getConditionVariable());
272 void StmtProfiler::VisitSwitchStmt(
const SwitchStmt *S) {
274 VisitDecl(S->getConditionVariable());
277 void StmtProfiler::VisitWhileStmt(
const WhileStmt *S) {
279 VisitDecl(S->getConditionVariable());
282 void StmtProfiler::VisitDoStmt(
const DoStmt *S) {
286 void StmtProfiler::VisitForStmt(
const ForStmt *S) {
290 void StmtProfiler::VisitGotoStmt(
const GotoStmt *S) {
292 VisitDecl(S->getLabel());
299 void StmtProfiler::VisitContinueStmt(
const ContinueStmt *S) {
303 void StmtProfiler::VisitBreakStmt(
const BreakStmt *S) {
307 void StmtProfiler::VisitReturnStmt(
const ReturnStmt *S) {
311 void StmtProfiler::VisitGCCAsmStmt(
const GCCAsmStmt *S) {
313 ID.AddBoolean(S->isVolatile());
314 ID.AddBoolean(S->isSimple());
315 VisitStringLiteral(S->getAsmString());
316 ID.AddInteger(S->getNumOutputs());
317 for (
unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
318 ID.AddString(S->getOutputName(I));
319 VisitStringLiteral(S->getOutputConstraintLiteral(I));
321 ID.AddInteger(S->getNumInputs());
322 for (
unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
323 ID.AddString(S->getInputName(I));
324 VisitStringLiteral(S->getInputConstraintLiteral(I));
326 ID.AddInteger(S->getNumClobbers());
327 for (
unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
328 VisitStringLiteral(S->getClobberStringLiteral(I));
329 ID.AddInteger(S->getNumLabels());
330 for (
auto *L : S->labels())
331 VisitDecl(L->getLabel());
334 void StmtProfiler::VisitMSAsmStmt(
const MSAsmStmt *S) {
339 void StmtProfiler::VisitCXXCatchStmt(
const CXXCatchStmt *S) {
341 VisitType(S->getCaughtType());
344 void StmtProfiler::VisitCXXTryStmt(
const CXXTryStmt *S) {
354 ID.AddBoolean(S->isIfExists());
355 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier());
356 VisitName(S->getNameInfo().getName());
359 void StmtProfiler::VisitSEHTryStmt(
const SEHTryStmt *S) {
367 void StmtProfiler::VisitSEHExceptStmt(
const SEHExceptStmt *S) {
371 void StmtProfiler::VisitSEHLeaveStmt(
const SEHLeaveStmt *S) {
375 void StmtProfiler::VisitCapturedStmt(
const CapturedStmt *S) {
385 ID.AddBoolean(S->hasEllipsis());
386 if (S->getCatchParamDecl())
387 VisitType(S->getCatchParamDecl()->getType());
394 void StmtProfiler::VisitObjCAtTryStmt(
const ObjCAtTryStmt *S) {
414 StmtProfiler *Profiler;
416 template <
typename T>
417 void VisitOMPClauseList(T *
Node);
420 OMPClauseProfiler(StmtProfiler *
P) : Profiler(
P) { }
421 #define GEN_CLANG_CLAUSE_CLASS
422 #define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
423 #include "llvm/Frontend/OpenMP/OMP.inc"
428 void OMPClauseProfiler::VistOMPClauseWithPreInit(
430 if (
auto *S =
C->getPreInitStmt())
431 Profiler->VisitStmt(S);
434 void OMPClauseProfiler::VistOMPClauseWithPostUpdate(
436 VistOMPClauseWithPreInit(C);
437 if (
auto *E =
C->getPostUpdateExpr())
438 Profiler->VisitStmt(E);
441 void OMPClauseProfiler::VisitOMPIfClause(
const OMPIfClause *C) {
442 VistOMPClauseWithPreInit(C);
443 if (
C->getCondition())
444 Profiler->VisitStmt(
C->getCondition());
447 void OMPClauseProfiler::VisitOMPFinalClause(
const OMPFinalClause *C) {
448 VistOMPClauseWithPreInit(C);
449 if (
C->getCondition())
450 Profiler->VisitStmt(
C->getCondition());
454 VistOMPClauseWithPreInit(C);
455 if (
C->getNumThreads())
456 Profiler->VisitStmt(
C->getNumThreads());
459 void OMPClauseProfiler::VisitOMPAlignClause(
const OMPAlignClause *C) {
460 if (
C->getAlignment())
461 Profiler->VisitStmt(
C->getAlignment());
466 Profiler->VisitStmt(
C->getSafelen());
471 Profiler->VisitStmt(
C->getSimdlen());
474 void OMPClauseProfiler::VisitOMPSizesClause(
const OMPSizesClause *C) {
475 for (
auto E :
C->getSizesRefs())
477 Profiler->VisitExpr(E);
480 void OMPClauseProfiler::VisitOMPFullClause(
const OMPFullClause *C) {}
483 if (
const Expr *Factor =
C->getFactor())
484 Profiler->VisitExpr(Factor);
488 if (
C->getAllocator())
489 Profiler->VisitStmt(
C->getAllocator());
493 if (
C->getNumForLoops())
494 Profiler->VisitStmt(
C->getNumForLoops());
497 void OMPClauseProfiler::VisitOMPDetachClause(
const OMPDetachClause *C) {
498 if (
Expr *Evt =
C->getEventHandler())
499 Profiler->VisitStmt(Evt);
503 VistOMPClauseWithPreInit(C);
504 if (
C->getCondition())
505 Profiler->VisitStmt(
C->getCondition());
509 VistOMPClauseWithPreInit(C);
510 if (
C->getCondition())
511 Profiler->VisitStmt(
C->getCondition());
514 void OMPClauseProfiler::VisitOMPDefaultClause(
const OMPDefaultClause *C) { }
518 void OMPClauseProfiler::VisitOMPUnifiedAddressClause(
521 void OMPClauseProfiler::VisitOMPUnifiedSharedMemoryClause(
524 void OMPClauseProfiler::VisitOMPReverseOffloadClause(
527 void OMPClauseProfiler::VisitOMPDynamicAllocatorsClause(
530 void OMPClauseProfiler::VisitOMPAtomicDefaultMemOrderClause(
534 VistOMPClauseWithPreInit(C);
535 if (
auto *S =
C->getChunkSize())
536 Profiler->VisitStmt(S);
540 if (
auto *Num =
C->getNumForLoops())
541 Profiler->VisitStmt(Num);
544 void OMPClauseProfiler::VisitOMPNowaitClause(
const OMPNowaitClause *) {}
546 void OMPClauseProfiler::VisitOMPUntiedClause(
const OMPUntiedClause *) {}
550 void OMPClauseProfiler::VisitOMPReadClause(
const OMPReadClause *) {}
552 void OMPClauseProfiler::VisitOMPWriteClause(
const OMPWriteClause *) {}
554 void OMPClauseProfiler::VisitOMPUpdateClause(
const OMPUpdateClause *) {}
560 void OMPClauseProfiler::VisitOMPSeqCstClause(
const OMPSeqCstClause *) {}
562 void OMPClauseProfiler::VisitOMPAcqRelClause(
const OMPAcqRelClause *) {}
572 void OMPClauseProfiler::VisitOMPSIMDClause(
const OMPSIMDClause *) {}
576 void OMPClauseProfiler::VisitOMPInitClause(
const OMPInitClause *C) {
577 VisitOMPClauseList(C);
580 void OMPClauseProfiler::VisitOMPUseClause(
const OMPUseClause *C) {
581 if (
C->getInteropVar())
582 Profiler->VisitStmt(
C->getInteropVar());
586 if (
C->getInteropVar())
587 Profiler->VisitStmt(
C->getInteropVar());
590 void OMPClauseProfiler::VisitOMPFilterClause(
const OMPFilterClause *C) {
591 VistOMPClauseWithPreInit(C);
592 if (
C->getThreadID())
593 Profiler->VisitStmt(
C->getThreadID());
597 void OMPClauseProfiler::VisitOMPClauseList(T *
Node) {
598 for (
auto *E :
Node->varlists()) {
600 Profiler->VisitStmt(E);
605 VisitOMPClauseList(C);
606 for (
auto *E :
C->private_copies()) {
608 Profiler->VisitStmt(E);
613 VisitOMPClauseList(C);
614 VistOMPClauseWithPreInit(C);
615 for (
auto *E :
C->private_copies()) {
617 Profiler->VisitStmt(E);
619 for (
auto *E :
C->inits()) {
621 Profiler->VisitStmt(E);
626 VisitOMPClauseList(C);
627 VistOMPClauseWithPostUpdate(C);
628 for (
auto *E :
C->source_exprs()) {
630 Profiler->VisitStmt(E);
632 for (
auto *E :
C->destination_exprs()) {
634 Profiler->VisitStmt(E);
636 for (
auto *E :
C->assignment_ops()) {
638 Profiler->VisitStmt(E);
641 void OMPClauseProfiler::VisitOMPSharedClause(
const OMPSharedClause *C) {
642 VisitOMPClauseList(C);
644 void OMPClauseProfiler::VisitOMPReductionClause(
646 Profiler->VisitNestedNameSpecifier(
647 C->getQualifierLoc().getNestedNameSpecifier());
648 Profiler->VisitName(
C->getNameInfo().getName());
649 VisitOMPClauseList(C);
650 VistOMPClauseWithPostUpdate(C);
651 for (
auto *E :
C->privates()) {
653 Profiler->VisitStmt(E);
655 for (
auto *E :
C->lhs_exprs()) {
657 Profiler->VisitStmt(E);
659 for (
auto *E :
C->rhs_exprs()) {
661 Profiler->VisitStmt(E);
663 for (
auto *E :
C->reduction_ops()) {
665 Profiler->VisitStmt(E);
667 if (
C->getModifier() == clang::OMPC_REDUCTION_inscan) {
668 for (
auto *E :
C->copy_ops()) {
670 Profiler->VisitStmt(E);
672 for (
auto *E :
C->copy_array_temps()) {
674 Profiler->VisitStmt(E);
676 for (
auto *E :
C->copy_array_elems()) {
678 Profiler->VisitStmt(E);
682 void OMPClauseProfiler::VisitOMPTaskReductionClause(
684 Profiler->VisitNestedNameSpecifier(
685 C->getQualifierLoc().getNestedNameSpecifier());
686 Profiler->VisitName(
C->getNameInfo().getName());
687 VisitOMPClauseList(C);
688 VistOMPClauseWithPostUpdate(C);
689 for (
auto *E :
C->privates()) {
691 Profiler->VisitStmt(E);
693 for (
auto *E :
C->lhs_exprs()) {
695 Profiler->VisitStmt(E);
697 for (
auto *E :
C->rhs_exprs()) {
699 Profiler->VisitStmt(E);
701 for (
auto *E :
C->reduction_ops()) {
703 Profiler->VisitStmt(E);
706 void OMPClauseProfiler::VisitOMPInReductionClause(
708 Profiler->VisitNestedNameSpecifier(
709 C->getQualifierLoc().getNestedNameSpecifier());
710 Profiler->VisitName(
C->getNameInfo().getName());
711 VisitOMPClauseList(C);
712 VistOMPClauseWithPostUpdate(C);
713 for (
auto *E :
C->privates()) {
715 Profiler->VisitStmt(E);
717 for (
auto *E :
C->lhs_exprs()) {
719 Profiler->VisitStmt(E);
721 for (
auto *E :
C->rhs_exprs()) {
723 Profiler->VisitStmt(E);
725 for (
auto *E :
C->reduction_ops()) {
727 Profiler->VisitStmt(E);
729 for (
auto *E :
C->taskgroup_descriptors()) {
731 Profiler->VisitStmt(E);
734 void OMPClauseProfiler::VisitOMPLinearClause(
const OMPLinearClause *C) {
735 VisitOMPClauseList(C);
736 VistOMPClauseWithPostUpdate(C);
737 for (
auto *E :
C->privates()) {
739 Profiler->VisitStmt(E);
741 for (
auto *E :
C->inits()) {
743 Profiler->VisitStmt(E);
745 for (
auto *E :
C->updates()) {
747 Profiler->VisitStmt(E);
749 for (
auto *E :
C->finals()) {
751 Profiler->VisitStmt(E);
754 Profiler->VisitStmt(
C->getStep());
755 if (
C->getCalcStep())
756 Profiler->VisitStmt(
C->getCalcStep());
759 VisitOMPClauseList(C);
760 if (
C->getAlignment())
761 Profiler->VisitStmt(
C->getAlignment());
763 void OMPClauseProfiler::VisitOMPCopyinClause(
const OMPCopyinClause *C) {
764 VisitOMPClauseList(C);
765 for (
auto *E :
C->source_exprs()) {
767 Profiler->VisitStmt(E);
769 for (
auto *E :
C->destination_exprs()) {
771 Profiler->VisitStmt(E);
773 for (
auto *E :
C->assignment_ops()) {
775 Profiler->VisitStmt(E);
780 VisitOMPClauseList(C);
781 for (
auto *E :
C->source_exprs()) {
783 Profiler->VisitStmt(E);
785 for (
auto *E :
C->destination_exprs()) {
787 Profiler->VisitStmt(E);
789 for (
auto *E :
C->assignment_ops()) {
791 Profiler->VisitStmt(E);
794 void OMPClauseProfiler::VisitOMPFlushClause(
const OMPFlushClause *C) {
795 VisitOMPClauseList(C);
797 void OMPClauseProfiler::VisitOMPDepobjClause(
const OMPDepobjClause *C) {
798 if (
const Expr *Depobj =
C->getDepobj())
799 Profiler->VisitStmt(Depobj);
801 void OMPClauseProfiler::VisitOMPDependClause(
const OMPDependClause *C) {
802 VisitOMPClauseList(C);
804 void OMPClauseProfiler::VisitOMPDeviceClause(
const OMPDeviceClause *C) {
806 Profiler->VisitStmt(
C->getDevice());
808 void OMPClauseProfiler::VisitOMPMapClause(
const OMPMapClause *C) {
809 VisitOMPClauseList(C);
812 if (
Expr *Allocator =
C->getAllocator())
813 Profiler->VisitStmt(Allocator);
814 VisitOMPClauseList(C);
817 VistOMPClauseWithPreInit(C);
818 if (
C->getNumTeams())
819 Profiler->VisitStmt(
C->getNumTeams());
821 void OMPClauseProfiler::VisitOMPThreadLimitClause(
823 VistOMPClauseWithPreInit(C);
824 if (
C->getThreadLimit())
825 Profiler->VisitStmt(
C->getThreadLimit());
828 VistOMPClauseWithPreInit(C);
829 if (
C->getPriority())
830 Profiler->VisitStmt(
C->getPriority());
833 VistOMPClauseWithPreInit(C);
834 if (
C->getGrainsize())
835 Profiler->VisitStmt(
C->getGrainsize());
838 VistOMPClauseWithPreInit(C);
839 if (
C->getNumTasks())
840 Profiler->VisitStmt(
C->getNumTasks());
842 void OMPClauseProfiler::VisitOMPHintClause(
const OMPHintClause *C) {
844 Profiler->VisitStmt(
C->getHint());
846 void OMPClauseProfiler::VisitOMPToClause(
const OMPToClause *C) {
847 VisitOMPClauseList(C);
849 void OMPClauseProfiler::VisitOMPFromClause(
const OMPFromClause *C) {
850 VisitOMPClauseList(C);
852 void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
854 VisitOMPClauseList(C);
856 void OMPClauseProfiler::VisitOMPUseDeviceAddrClause(
858 VisitOMPClauseList(C);
860 void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
862 VisitOMPClauseList(C);
864 void OMPClauseProfiler::VisitOMPHasDeviceAddrClause(
866 VisitOMPClauseList(C);
868 void OMPClauseProfiler::VisitOMPNontemporalClause(
870 VisitOMPClauseList(C);
871 for (
auto *E :
C->private_refs())
872 Profiler->VisitStmt(E);
875 VisitOMPClauseList(C);
878 VisitOMPClauseList(C);
880 void OMPClauseProfiler::VisitOMPUsesAllocatorsClause(
882 for (
unsigned I = 0, E =
C->getNumberOfAllocators(); I < E; ++I) {
890 if (
const Expr *Modifier =
C->getModifier())
891 Profiler->VisitStmt(Modifier);
892 for (
const Expr *E :
C->varlists())
893 Profiler->VisitStmt(E);
895 void OMPClauseProfiler::VisitOMPOrderClause(
const OMPOrderClause *C) {}
896 void OMPClauseProfiler::VisitOMPBindClause(
const OMPBindClause *C) {}
902 OMPClauseProfiler
P(
this);
915 VisitOMPExecutableDirective(S);
919 VisitOMPLoopBasedDirective(S);
923 VisitOMPExecutableDirective(S);
927 VisitOMPExecutableDirective(S);
931 VisitOMPLoopDirective(S);
934 void StmtProfiler::VisitOMPLoopTransformationDirective(
936 VisitOMPLoopBasedDirective(S);
940 VisitOMPLoopTransformationDirective(S);
944 VisitOMPLoopTransformationDirective(S);
948 VisitOMPLoopDirective(S);
952 VisitOMPLoopDirective(S);
956 VisitOMPExecutableDirective(S);
960 VisitOMPExecutableDirective(S);
964 VisitOMPExecutableDirective(S);
968 VisitOMPExecutableDirective(S);
972 VisitOMPExecutableDirective(S);
973 VisitName(S->getDirectiveName().getName());
978 VisitOMPLoopDirective(S);
981 void StmtProfiler::VisitOMPParallelForSimdDirective(
983 VisitOMPLoopDirective(S);
986 void StmtProfiler::VisitOMPParallelMasterDirective(
988 VisitOMPExecutableDirective(S);
991 void StmtProfiler::VisitOMPParallelSectionsDirective(
993 VisitOMPExecutableDirective(S);
997 VisitOMPExecutableDirective(S);
1001 VisitOMPExecutableDirective(S);
1005 VisitOMPExecutableDirective(S);
1009 VisitOMPExecutableDirective(S);
1013 VisitOMPExecutableDirective(S);
1014 if (
const Expr *E = S->getReductionRef())
1019 VisitOMPExecutableDirective(S);
1023 VisitOMPExecutableDirective(S);
1027 VisitOMPExecutableDirective(S);
1031 VisitOMPExecutableDirective(S);
1035 VisitOMPExecutableDirective(S);
1039 VisitOMPExecutableDirective(S);
1043 VisitOMPExecutableDirective(S);
1046 void StmtProfiler::VisitOMPTargetEnterDataDirective(
1048 VisitOMPExecutableDirective(S);
1051 void StmtProfiler::VisitOMPTargetExitDataDirective(
1053 VisitOMPExecutableDirective(S);
1056 void StmtProfiler::VisitOMPTargetParallelDirective(
1058 VisitOMPExecutableDirective(S);
1061 void StmtProfiler::VisitOMPTargetParallelForDirective(
1063 VisitOMPExecutableDirective(S);
1067 VisitOMPExecutableDirective(S);
1070 void StmtProfiler::VisitOMPCancellationPointDirective(
1072 VisitOMPExecutableDirective(S);
1076 VisitOMPExecutableDirective(S);
1080 VisitOMPLoopDirective(S);
1083 void StmtProfiler::VisitOMPTaskLoopSimdDirective(
1085 VisitOMPLoopDirective(S);
1088 void StmtProfiler::VisitOMPMasterTaskLoopDirective(
1090 VisitOMPLoopDirective(S);
1093 void StmtProfiler::VisitOMPMasterTaskLoopSimdDirective(
1095 VisitOMPLoopDirective(S);
1098 void StmtProfiler::VisitOMPParallelMasterTaskLoopDirective(
1100 VisitOMPLoopDirective(S);
1103 void StmtProfiler::VisitOMPParallelMasterTaskLoopSimdDirective(
1105 VisitOMPLoopDirective(S);
1108 void StmtProfiler::VisitOMPDistributeDirective(
1110 VisitOMPLoopDirective(S);
1113 void OMPClauseProfiler::VisitOMPDistScheduleClause(
1115 VistOMPClauseWithPreInit(C);
1116 if (
auto *S =
C->getChunkSize())
1117 Profiler->VisitStmt(S);
1122 void StmtProfiler::VisitOMPTargetUpdateDirective(
1124 VisitOMPExecutableDirective(S);
1127 void StmtProfiler::VisitOMPDistributeParallelForDirective(
1129 VisitOMPLoopDirective(S);
1132 void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
1134 VisitOMPLoopDirective(S);
1137 void StmtProfiler::VisitOMPDistributeSimdDirective(
1139 VisitOMPLoopDirective(S);
1142 void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
1144 VisitOMPLoopDirective(S);
1147 void StmtProfiler::VisitOMPTargetSimdDirective(
1149 VisitOMPLoopDirective(S);
1152 void StmtProfiler::VisitOMPTeamsDistributeDirective(
1154 VisitOMPLoopDirective(S);
1157 void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
1159 VisitOMPLoopDirective(S);
1162 void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
1164 VisitOMPLoopDirective(S);
1167 void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
1169 VisitOMPLoopDirective(S);
1172 void StmtProfiler::VisitOMPTargetTeamsDirective(
1174 VisitOMPExecutableDirective(S);
1177 void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
1179 VisitOMPLoopDirective(S);
1182 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
1184 VisitOMPLoopDirective(S);
1187 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
1189 VisitOMPLoopDirective(S);
1192 void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
1194 VisitOMPLoopDirective(S);
1198 VisitOMPExecutableDirective(S);
1202 VisitOMPExecutableDirective(S);
1206 VisitOMPExecutableDirective(S);
1209 void StmtProfiler::VisitOMPGenericLoopDirective(
1211 VisitOMPLoopDirective(S);
1214 void StmtProfiler::VisitOMPTeamsGenericLoopDirective(
1216 VisitOMPLoopDirective(S);
1219 void StmtProfiler::VisitOMPTargetTeamsGenericLoopDirective(
1221 VisitOMPLoopDirective(S);
1224 void StmtProfiler::VisitOMPParallelGenericLoopDirective(
1226 VisitOMPLoopDirective(S);
1229 void StmtProfiler::VisitOMPTargetParallelGenericLoopDirective(
1231 VisitOMPLoopDirective(S);
1234 void StmtProfiler::VisitExpr(
const Expr *S) {
1238 void StmtProfiler::VisitConstantExpr(
const ConstantExpr *S) {
1242 void StmtProfiler::VisitDeclRefExpr(
const DeclRefExpr *S) {
1245 VisitNestedNameSpecifier(S->getQualifier());
1246 VisitDecl(S->getDecl());
1248 ID.AddBoolean(S->hasExplicitTemplateArgs());
1249 if (S->hasExplicitTemplateArgs())
1250 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1254 void StmtProfiler::VisitSYCLUniqueStableNameExpr(
1257 VisitType(S->getTypeSourceInfo()->getType());
1260 void StmtProfiler::VisitPredefinedExpr(
const PredefinedExpr *S) {
1262 ID.AddInteger(S->getIdentKind());
1265 void StmtProfiler::VisitIntegerLiteral(
const IntegerLiteral *S) {
1267 S->getValue().Profile(
ID);
1273 S->getValue().Profile(
ID);
1279 ID.AddInteger(S->getKind());
1280 ID.AddInteger(S->getValue());
1285 S->getValue().Profile(
ID);
1286 ID.AddBoolean(S->isExact());
1294 void StmtProfiler::VisitStringLiteral(
const StringLiteral *S) {
1296 ID.AddString(S->getBytes());
1297 ID.AddInteger(S->getKind());
1300 void StmtProfiler::VisitParenExpr(
const ParenExpr *S) {
1304 void StmtProfiler::VisitParenListExpr(
const ParenListExpr *S) {
1308 void StmtProfiler::VisitUnaryOperator(
const UnaryOperator *S) {
1310 ID.AddInteger(S->getOpcode());
1313 void StmtProfiler::VisitOffsetOfExpr(
const OffsetOfExpr *S) {
1314 VisitType(S->getTypeSourceInfo()->getType());
1315 unsigned n = S->getNumComponents();
1316 for (
unsigned i = 0; i < n; ++i) {
1344 ID.AddInteger(S->getKind());
1345 if (S->isArgumentType())
1346 VisitType(S->getArgumentType());
1367 for (
unsigned I = 0, E = S->numOfIterators(); I < E; ++I)
1368 VisitDecl(S->getIteratorDecl(I));
1371 void StmtProfiler::VisitCallExpr(
const CallExpr *S) {
1375 void StmtProfiler::VisitMemberExpr(
const MemberExpr *S) {
1377 VisitDecl(S->getMemberDecl());
1379 VisitNestedNameSpecifier(S->getQualifier());
1380 ID.AddBoolean(S->isArrow());
1385 ID.AddBoolean(S->isFileScope());
1388 void StmtProfiler::VisitCastExpr(
const CastExpr *S) {
1394 ID.AddInteger(S->getValueKind());
1399 VisitType(S->getTypeAsWritten());
1402 void StmtProfiler::VisitCStyleCastExpr(
const CStyleCastExpr *S) {
1403 VisitExplicitCastExpr(S);
1406 void StmtProfiler::VisitBinaryOperator(
const BinaryOperator *S) {
1408 ID.AddInteger(S->getOpcode());
1413 VisitBinaryOperator(S);
1420 void StmtProfiler::VisitBinaryConditionalOperator(
1425 void StmtProfiler::VisitAddrLabelExpr(
const AddrLabelExpr *S) {
1427 VisitDecl(S->getLabel());
1430 void StmtProfiler::VisitStmtExpr(
const StmtExpr *S) {
1442 void StmtProfiler::VisitChooseExpr(
const ChooseExpr *S) {
1446 void StmtProfiler::VisitGNUNullExpr(
const GNUNullExpr *S) {
1450 void StmtProfiler::VisitVAArgExpr(
const VAArgExpr *S) {
1454 void StmtProfiler::VisitInitListExpr(
const InitListExpr *S) {
1455 if (S->getSyntacticForm()) {
1456 VisitInitListExpr(S->getSyntacticForm());
1465 ID.AddBoolean(S->usesGNUSyntax());
1467 if (D.isFieldDesignator()) {
1469 VisitName(D.getFieldName());
1473 if (D.isArrayDesignator()) {
1476 assert(D.isArrayRangeDesignator());
1479 ID.AddInteger(D.getFirstExprIndex());
1485 void StmtProfiler::VisitDesignatedInitUpdateExpr(
1487 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
1499 void StmtProfiler::VisitNoInitExpr(
const NoInitExpr *S) {
1500 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
1509 VisitName(&S->getAccessor());
1512 void StmtProfiler::VisitBlockExpr(
const BlockExpr *S) {
1514 VisitDecl(S->getBlockDecl());
1520 S->associations()) {
1523 ID.AddPointer(
nullptr);
1526 VisitExpr(Assoc.getAssociationExpr());
1533 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1536 Visit(OVE->getSourceExpr());
1539 void StmtProfiler::VisitAtomicExpr(
const AtomicExpr *S) {
1541 ID.AddInteger(S->getOp());
1544 void StmtProfiler::VisitConceptSpecializationExpr(
1547 VisitDecl(S->getNamedConcept());
1549 VisitTemplateArgument(Arg);
1552 void StmtProfiler::VisitRequiresExpr(
const RequiresExpr *S) {
1554 ID.AddInteger(S->getLocalParameters().size());
1555 for (
ParmVarDecl *LocalParam : S->getLocalParameters())
1556 VisitDecl(LocalParam);
1557 ID.AddInteger(S->getRequirements().size());
1559 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) {
1561 ID.AddBoolean(TypeReq->isSubstitutionFailure());
1562 if (!TypeReq->isSubstitutionFailure())
1563 VisitType(TypeReq->getType()->getType());
1564 }
else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) {
1566 ID.AddBoolean(ExprReq->isExprSubstitutionFailure());
1567 if (!ExprReq->isExprSubstitutionFailure())
1568 Visit(ExprReq->getExpr());
1573 ID.AddBoolean(ExprReq->getNoexceptLoc().isValid());
1575 ExprReq->getReturnTypeRequirement();
1587 auto *NestedReq = cast<concepts::NestedRequirement>(Req);
1588 ID.AddBoolean(NestedReq->isSubstitutionFailure());
1589 if (!NestedReq->isSubstitutionFailure())
1590 Visit(NestedReq->getConstraintExpr());
1598 switch (S->getOperator()) {
1603 case OO_Array_Delete:
1605 case OO_Conditional:
1607 llvm_unreachable(
"Invalid operator call kind");
1610 if (S->getNumArgs() == 1) {
1612 return Stmt::UnaryOperatorClass;
1616 return Stmt::BinaryOperatorClass;
1619 if (S->getNumArgs() == 1) {
1621 return Stmt::UnaryOperatorClass;
1625 return Stmt::BinaryOperatorClass;
1628 if (S->getNumArgs() == 1) {
1630 return Stmt::UnaryOperatorClass;
1634 return Stmt::BinaryOperatorClass;
1638 return Stmt::BinaryOperatorClass;
1642 return Stmt::BinaryOperatorClass;
1646 return Stmt::BinaryOperatorClass;
1649 if (S->getNumArgs() == 1) {
1650 UnaryOp = UO_AddrOf;
1651 return Stmt::UnaryOperatorClass;
1655 return Stmt::BinaryOperatorClass;
1659 return Stmt::BinaryOperatorClass;
1663 return Stmt::UnaryOperatorClass;
1667 return Stmt::UnaryOperatorClass;
1670 BinaryOp = BO_Assign;
1671 return Stmt::BinaryOperatorClass;
1675 return Stmt::BinaryOperatorClass;
1679 return Stmt::BinaryOperatorClass;
1682 BinaryOp = BO_AddAssign;
1683 return Stmt::CompoundAssignOperatorClass;
1686 BinaryOp = BO_SubAssign;
1687 return Stmt::CompoundAssignOperatorClass;
1690 BinaryOp = BO_MulAssign;
1691 return Stmt::CompoundAssignOperatorClass;
1694 BinaryOp = BO_DivAssign;
1695 return Stmt::CompoundAssignOperatorClass;
1697 case OO_PercentEqual:
1698 BinaryOp = BO_RemAssign;
1699 return Stmt::CompoundAssignOperatorClass;
1702 BinaryOp = BO_XorAssign;
1703 return Stmt::CompoundAssignOperatorClass;
1706 BinaryOp = BO_AndAssign;
1707 return Stmt::CompoundAssignOperatorClass;
1710 BinaryOp = BO_OrAssign;
1711 return Stmt::CompoundAssignOperatorClass;
1715 return Stmt::BinaryOperatorClass;
1717 case OO_GreaterGreater:
1719 return Stmt::BinaryOperatorClass;
1721 case OO_LessLessEqual:
1722 BinaryOp = BO_ShlAssign;
1723 return Stmt::CompoundAssignOperatorClass;
1725 case OO_GreaterGreaterEqual:
1726 BinaryOp = BO_ShrAssign;
1727 return Stmt::CompoundAssignOperatorClass;
1731 return Stmt::BinaryOperatorClass;
1733 case OO_ExclaimEqual:
1735 return Stmt::BinaryOperatorClass;
1739 return Stmt::BinaryOperatorClass;
1741 case OO_GreaterEqual:
1743 return Stmt::BinaryOperatorClass;
1747 return Stmt::BinaryOperatorClass;
1751 return Stmt::BinaryOperatorClass;
1755 return Stmt::BinaryOperatorClass;
1758 UnaryOp = S->getNumArgs() == 1? UO_PreInc
1760 return Stmt::UnaryOperatorClass;
1763 UnaryOp = S->getNumArgs() == 1? UO_PreDec
1765 return Stmt::UnaryOperatorClass;
1768 BinaryOp = BO_Comma;
1769 return Stmt::BinaryOperatorClass;
1772 BinaryOp = BO_PtrMemI;
1773 return Stmt::BinaryOperatorClass;
1776 return Stmt::ArraySubscriptExprClass;
1779 return Stmt::CallExprClass;
1782 UnaryOp = UO_Coawait;
1783 return Stmt::UnaryOperatorClass;
1786 llvm_unreachable(
"Invalid overloaded operator expression");
1789 #if defined(_MSC_VER) && !defined(__clang__)
1790 #if _MSC_VER == 1911
1794 #pragma optimize("", off)
1799 if (S->isTypeDependent()) {
1805 if (S->getOperator() == OO_Arrow)
1806 return Visit(S->getArg(0));
1813 for (
unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
1814 Visit(S->getArg(I));
1815 if (SC == Stmt::UnaryOperatorClass)
1816 ID.AddInteger(UnaryOp);
1817 else if (SC == Stmt::BinaryOperatorClass ||
1818 SC == Stmt::CompoundAssignOperatorClass)
1819 ID.AddInteger(BinaryOp);
1821 assert(SC == Stmt::ArraySubscriptExprClass || SC == Stmt::CallExprClass);
1827 ID.AddInteger(S->getOperator());
1830 void StmtProfiler::VisitCXXRewrittenBinaryOperator(
1834 assert(!S->isTypeDependent() &&
1835 "resolved rewritten operator should never be type-dependent");
1836 ID.AddBoolean(S->isReversed());
1837 VisitExpr(S->getSemanticForm());
1840 #if defined(_MSC_VER) && !defined(__clang__)
1841 #if _MSC_VER == 1911
1842 #pragma optimize("", on)
1854 void StmtProfiler::VisitAsTypeExpr(
const AsTypeExpr *S) {
1859 VisitExplicitCastExpr(S);
1863 VisitCXXNamedCastExpr(S);
1867 VisitCXXNamedCastExpr(S);
1872 VisitCXXNamedCastExpr(S);
1876 VisitCXXNamedCastExpr(S);
1881 VisitType(S->getTypeInfoAsWritten()->getType());
1885 VisitCXXNamedCastExpr(S);
1894 ID.AddBoolean(S->getValue());
1901 void StmtProfiler::VisitCXXStdInitializerListExpr(
1906 void StmtProfiler::VisitCXXTypeidExpr(
const CXXTypeidExpr *S) {
1908 if (S->isTypeOperand())
1909 VisitType(S->getTypeOperandSourceInfo()->getType());
1912 void StmtProfiler::VisitCXXUuidofExpr(
const CXXUuidofExpr *S) {
1914 if (S->isTypeOperand())
1915 VisitType(S->getTypeOperandSourceInfo()->getType());
1920 VisitDecl(S->getPropertyDecl());
1923 void StmtProfiler::VisitMSPropertySubscriptExpr(
1928 void StmtProfiler::VisitCXXThisExpr(
const CXXThisExpr *S) {
1930 ID.AddBoolean(S->isImplicit());
1933 void StmtProfiler::VisitCXXThrowExpr(
const CXXThrowExpr *S) {
1939 VisitDecl(S->getParam());
1944 VisitDecl(S->getField());
1955 VisitDecl(S->getConstructor());
1956 ID.AddBoolean(S->isElidable());
1959 void StmtProfiler::VisitCXXInheritedCtorInitExpr(
1962 VisitDecl(S->getConstructor());
1966 VisitExplicitCastExpr(S);
1971 VisitCXXConstructExpr(S);
1975 StmtProfiler::VisitLambdaExpr(
const LambdaExpr *S) {
1979 VisitStmtNoChildren(S);
1983 VisitDecl(S->getLambdaClass());
1991 void StmtProfiler::VisitCXXDeleteExpr(
const CXXDeleteExpr *S) {
1993 ID.AddBoolean(S->isGlobalDelete());
1994 ID.AddBoolean(S->isArrayForm());
1995 VisitDecl(S->getOperatorDelete());
1998 void StmtProfiler::VisitCXXNewExpr(
const CXXNewExpr *S) {
2000 VisitType(S->getAllocatedType());
2001 VisitDecl(S->getOperatorNew());
2002 VisitDecl(S->getOperatorDelete());
2003 ID.AddBoolean(S->isArray());
2004 ID.AddInteger(S->getNumPlacementArgs());
2005 ID.AddBoolean(S->isGlobalNew());
2006 ID.AddBoolean(S->isParenTypeId());
2007 ID.AddInteger(S->getInitializationStyle());
2013 ID.AddBoolean(S->isArrow());
2014 VisitNestedNameSpecifier(S->getQualifier());
2015 ID.AddBoolean(S->getScopeTypeInfo() !=
nullptr);
2016 if (S->getScopeTypeInfo())
2017 VisitType(S->getScopeTypeInfo()->getType());
2018 ID.AddBoolean(S->getDestroyedTypeInfo() !=
nullptr);
2019 if (S->getDestroyedTypeInfo())
2020 VisitType(S->getDestroyedType());
2022 VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
2025 void StmtProfiler::VisitOverloadExpr(
const OverloadExpr *S) {
2027 VisitNestedNameSpecifier(S->getQualifier());
2028 VisitName(S->getName(),
true);
2029 ID.AddBoolean(S->hasExplicitTemplateArgs());
2030 if (S->hasExplicitTemplateArgs())
2031 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2036 VisitOverloadExpr(S);
2039 void StmtProfiler::VisitTypeTraitExpr(
const TypeTraitExpr *S) {
2041 ID.AddInteger(S->getTrait());
2042 ID.AddInteger(S->getNumArgs());
2043 for (
unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2044 VisitType(S->getArg(I)->getType());
2049 ID.AddInteger(S->getTrait());
2050 VisitType(S->getQueriedType());
2055 ID.AddInteger(S->getTrait());
2056 VisitExpr(S->getQueriedExpression());
2059 void StmtProfiler::VisitDependentScopeDeclRefExpr(
2062 VisitName(S->getDeclName());
2063 VisitNestedNameSpecifier(S->getQualifier());
2064 ID.AddBoolean(S->hasExplicitTemplateArgs());
2065 if (S->hasExplicitTemplateArgs())
2066 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2073 void StmtProfiler::VisitCXXUnresolvedConstructExpr(
2076 VisitType(S->getTypeAsWritten());
2077 ID.AddInteger(S->isListInitialization());
2080 void StmtProfiler::VisitCXXDependentScopeMemberExpr(
2082 ID.AddBoolean(S->isImplicitAccess());
2083 if (!S->isImplicitAccess()) {
2085 ID.AddBoolean(S->isArrow());
2087 VisitNestedNameSpecifier(S->getQualifier());
2088 VisitName(S->getMember());
2089 ID.AddBoolean(S->hasExplicitTemplateArgs());
2090 if (S->hasExplicitTemplateArgs())
2091 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2095 ID.AddBoolean(S->isImplicitAccess());
2096 if (!S->isImplicitAccess()) {
2098 ID.AddBoolean(S->isArrow());
2100 VisitNestedNameSpecifier(S->getQualifier());
2101 VisitName(S->getMemberName());
2102 ID.AddBoolean(S->hasExplicitTemplateArgs());
2103 if (S->hasExplicitTemplateArgs())
2104 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2115 void StmtProfiler::VisitSizeOfPackExpr(
const SizeOfPackExpr *S) {
2117 VisitDecl(S->getPack());
2118 if (S->isPartiallySubstituted()) {
2119 auto Args = S->getPartialArguments();
2120 ID.AddInteger(Args.size());
2121 for (
const auto &TA : Args)
2122 VisitTemplateArgument(TA);
2128 void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
2131 VisitDecl(S->getParameterPack());
2132 VisitTemplateArgument(S->getArgumentPack());
2135 void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
2143 VisitDecl(S->getParameterPack());
2144 ID.AddInteger(S->getNumExpansions());
2149 void StmtProfiler::VisitMaterializeTemporaryExpr(
2154 void StmtProfiler::VisitCXXFoldExpr(
const CXXFoldExpr *S) {
2156 ID.AddInteger(S->getOperator());
2163 void StmtProfiler::VisitCoreturnStmt(
const CoreturnStmt *S) {
2167 void StmtProfiler::VisitCoawaitExpr(
const CoawaitExpr *S) {
2175 void StmtProfiler::VisitCoyieldExpr(
const CoyieldExpr *S) {
2183 void StmtProfiler::VisitTypoExpr(
const TypoExpr *E) {
2187 void StmtProfiler::VisitSourceLocExpr(
const SourceLocExpr *E) {
2191 void StmtProfiler::VisitRecoveryExpr(
const RecoveryExpr *E) { VisitExpr(E); }
2197 void StmtProfiler::VisitObjCBoxedExpr(
const ObjCBoxedExpr *E) {
2209 void StmtProfiler::VisitObjCEncodeExpr(
const ObjCEncodeExpr *S) {
2211 VisitType(S->getEncodedType());
2216 VisitName(S->getSelector());
2221 VisitDecl(S->getProtocol());
2226 VisitDecl(S->getDecl());
2227 ID.AddBoolean(S->isArrow());
2228 ID.AddBoolean(S->isFreeIvar());
2233 if (S->isImplicitProperty()) {
2234 VisitDecl(S->getImplicitPropertyGetter());
2235 VisitDecl(S->getImplicitPropertySetter());
2237 VisitDecl(S->getExplicitProperty());
2239 if (S->isSuperReceiver()) {
2240 ID.AddBoolean(S->isSuperReceiver());
2241 VisitType(S->getSuperReceiverType());
2247 VisitDecl(S->getAtIndexMethodDecl());
2248 VisitDecl(S->setAtIndexMethodDecl());
2253 VisitName(S->getSelector());
2254 VisitDecl(S->getMethodDecl());
2257 void StmtProfiler::VisitObjCIsaExpr(
const ObjCIsaExpr *S) {
2259 ID.AddBoolean(S->isArrow());
2264 ID.AddBoolean(S->getValue());
2267 void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
2270 ID.AddBoolean(S->shouldCopy());
2274 VisitExplicitCastExpr(S);
2275 ID.AddBoolean(S->getBridgeKind());
2278 void StmtProfiler::VisitObjCAvailabilityCheckExpr(
2285 ID.AddInteger(NumArgs);
2286 for (
unsigned I = 0; I != NumArgs; ++I)
2327 VisitTemplateArgument(
P);
2333 bool Canonical)
const {
2334 StmtProfilerWithPointers Profiler(
ID, Context, Canonical);
2335 Profiler.Visit(
this);
2340 StmtProfilerWithoutPointers Profiler(
ID, Hash);
2341 Profiler.Visit(
this);