24#include "llvm/ADT/FoldingSet.h"
30 llvm::FoldingSetNodeID &
ID;
32 bool ProfileLambdaExpr;
35 StmtProfiler(llvm::FoldingSetNodeID &ID,
bool Canonical,
36 bool ProfileLambdaExpr)
37 :
ID(
ID), Canonical(Canonical), ProfileLambdaExpr(ProfileLambdaExpr) {}
39 virtual ~StmtProfiler() {}
41 void VisitStmt(
const Stmt *S);
43 void VisitStmtNoChildren(
const Stmt *S) {
44 HandleStmtClass(S->getStmtClass());
49#define STMT(Node, Base) void Visit##Node(const Node *S);
50#include "clang/AST/StmtNodes.inc"
54 virtual void VisitDecl(
const Decl *D) = 0;
58 virtual void VisitType(
QualType T) = 0;
61 virtual void VisitName(
DeclarationName Name,
bool TreatAsDecl =
false) = 0;
83 class StmtProfilerWithPointers :
public StmtProfiler {
87 StmtProfilerWithPointers(llvm::FoldingSetNodeID &ID,
89 bool ProfileLambdaExpr)
90 : StmtProfiler(
ID, Canonical, ProfileLambdaExpr), Context(Context) {}
97 void VisitDecl(
const Decl *D)
override {
100 if (Canonical && D) {
102 dyn_cast<NonTypeTemplateParmDecl>(D)) {
103 ID.AddInteger(NTTP->getDepth());
104 ID.AddInteger(NTTP->getIndex());
105 ID.AddBoolean(NTTP->isParameterPack());
118 if (
const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
129 VisitType(Parm->getType());
130 ID.AddInteger(Parm->getFunctionScopeDepth());
131 ID.AddInteger(Parm->getFunctionScopeIndex());
136 dyn_cast<TemplateTypeParmDecl>(D)) {
137 ID.AddInteger(TTP->getDepth());
138 ID.AddInteger(TTP->getIndex());
139 ID.AddBoolean(TTP->isParameterPack());
144 dyn_cast<TemplateTemplateParmDecl>(D)) {
145 ID.AddInteger(TTP->getDepth());
146 ID.AddInteger(TTP->getIndex());
147 ID.AddBoolean(TTP->isParameterPack());
155 void VisitType(
QualType T)
override {
156 if (Canonical && !T.
isNull())
163 ID.AddPointer(Name.getAsOpaquePtr());
184 class StmtProfilerWithoutPointers :
public StmtProfiler {
187 StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &ID,
ODRHash &Hash)
193 if (SC == Stmt::UnresolvedLookupExprClass) {
196 ID.AddInteger(Stmt::DeclRefExprClass);
202 void VisitType(
QualType T)
override {
220 void VisitDecl(
const Decl *D)
override {
238void StmtProfiler::VisitStmt(
const Stmt *S) {
239 assert(S &&
"Requires non-null Stmt pointer");
241 VisitStmtNoChildren(S);
243 for (
const Stmt *SubStmt : S->children()) {
251void StmtProfiler::VisitDeclStmt(
const DeclStmt *S) {
253 for (
const auto *D : S->decls())
257void StmtProfiler::VisitNullStmt(
const NullStmt *S) {
261void StmtProfiler::VisitCompoundStmt(
const CompoundStmt *S) {
265void StmtProfiler::VisitCaseStmt(
const CaseStmt *S) {
269void StmtProfiler::VisitDefaultStmt(
const DefaultStmt *S) {
273void StmtProfiler::VisitLabelStmt(
const LabelStmt *S) {
275 VisitDecl(S->getDecl());
283void StmtProfiler::VisitIfStmt(
const IfStmt *S) {
285 VisitDecl(S->getConditionVariable());
288void StmtProfiler::VisitSwitchStmt(
const SwitchStmt *S) {
290 VisitDecl(S->getConditionVariable());
293void StmtProfiler::VisitWhileStmt(
const WhileStmt *S) {
295 VisitDecl(S->getConditionVariable());
298void StmtProfiler::VisitDoStmt(
const DoStmt *S) {
302void StmtProfiler::VisitForStmt(
const ForStmt *S) {
306void StmtProfiler::VisitGotoStmt(
const GotoStmt *S) {
308 VisitDecl(S->getLabel());
315void StmtProfiler::VisitContinueStmt(
const ContinueStmt *S) {
319void StmtProfiler::VisitBreakStmt(
const BreakStmt *S) {
323void StmtProfiler::VisitReturnStmt(
const ReturnStmt *S) {
327void StmtProfiler::VisitGCCAsmStmt(
const GCCAsmStmt *S) {
329 ID.AddBoolean(S->isVolatile());
330 ID.AddBoolean(S->isSimple());
331 VisitStringLiteral(S->getAsmString());
332 ID.AddInteger(S->getNumOutputs());
333 for (
unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
334 ID.AddString(S->getOutputName(I));
335 VisitStringLiteral(S->getOutputConstraintLiteral(I));
337 ID.AddInteger(S->getNumInputs());
338 for (
unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
339 ID.AddString(S->getInputName(I));
340 VisitStringLiteral(S->getInputConstraintLiteral(I));
342 ID.AddInteger(S->getNumClobbers());
343 for (
unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
344 VisitStringLiteral(S->getClobberStringLiteral(I));
345 ID.AddInteger(S->getNumLabels());
346 for (
auto *L : S->labels())
347 VisitDecl(L->getLabel());
350void StmtProfiler::VisitMSAsmStmt(
const MSAsmStmt *S) {
355void StmtProfiler::VisitCXXCatchStmt(
const CXXCatchStmt *S) {
357 VisitType(S->getCaughtType());
360void StmtProfiler::VisitCXXTryStmt(
const CXXTryStmt *S) {
370 ID.AddBoolean(S->isIfExists());
371 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier());
372 VisitName(S->getNameInfo().getName());
375void StmtProfiler::VisitSEHTryStmt(
const SEHTryStmt *S) {
383void StmtProfiler::VisitSEHExceptStmt(
const SEHExceptStmt *S) {
387void StmtProfiler::VisitSEHLeaveStmt(
const SEHLeaveStmt *S) {
391void StmtProfiler::VisitCapturedStmt(
const CapturedStmt *S) {
401 ID.AddBoolean(S->hasEllipsis());
402 if (S->getCatchParamDecl())
403 VisitType(S->getCatchParamDecl()->getType());
410void StmtProfiler::VisitObjCAtTryStmt(
const ObjCAtTryStmt *S) {
430 StmtProfiler *Profiler;
432 template <
typename T>
433 void VisitOMPClauseList(T *
Node);
436 OMPClauseProfiler(StmtProfiler *
P) : Profiler(
P) { }
437#define GEN_CLANG_CLAUSE_CLASS
438#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
439#include "llvm/Frontend/OpenMP/OMP.inc"
444void OMPClauseProfiler::VistOMPClauseWithPreInit(
446 if (
auto *S =
C->getPreInitStmt())
447 Profiler->VisitStmt(S);
450void OMPClauseProfiler::VistOMPClauseWithPostUpdate(
452 VistOMPClauseWithPreInit(
C);
453 if (
auto *E =
C->getPostUpdateExpr())
454 Profiler->VisitStmt(E);
457void OMPClauseProfiler::VisitOMPIfClause(
const OMPIfClause *
C) {
458 VistOMPClauseWithPreInit(
C);
459 if (
C->getCondition())
460 Profiler->VisitStmt(
C->getCondition());
464 VistOMPClauseWithPreInit(
C);
465 if (
C->getCondition())
466 Profiler->VisitStmt(
C->getCondition());
470 VistOMPClauseWithPreInit(
C);
471 if (
C->getNumThreads())
472 Profiler->VisitStmt(
C->getNumThreads());
476 if (
C->getAlignment())
477 Profiler->VisitStmt(
C->getAlignment());
482 Profiler->VisitStmt(
C->getSafelen());
487 Profiler->VisitStmt(
C->getSimdlen());
491 for (
auto *E :
C->getSizesRefs())
493 Profiler->VisitExpr(E);
496void OMPClauseProfiler::VisitOMPFullClause(
const OMPFullClause *
C) {}
499 if (
const Expr *Factor =
C->getFactor())
500 Profiler->VisitExpr(Factor);
504 if (
C->getAllocator())
505 Profiler->VisitStmt(
C->getAllocator());
509 if (
C->getNumForLoops())
510 Profiler->VisitStmt(
C->getNumForLoops());
514 if (
Expr *Evt =
C->getEventHandler())
515 Profiler->VisitStmt(Evt);
519 VistOMPClauseWithPreInit(
C);
520 if (
C->getCondition())
521 Profiler->VisitStmt(
C->getCondition());
525 VistOMPClauseWithPreInit(
C);
526 if (
C->getCondition())
527 Profiler->VisitStmt(
C->getCondition());
534void OMPClauseProfiler::VisitOMPUnifiedAddressClause(
537void OMPClauseProfiler::VisitOMPUnifiedSharedMemoryClause(
540void OMPClauseProfiler::VisitOMPReverseOffloadClause(
543void OMPClauseProfiler::VisitOMPDynamicAllocatorsClause(
546void OMPClauseProfiler::VisitOMPAtomicDefaultMemOrderClause(
549void OMPClauseProfiler::VisitOMPAtClause(
const OMPAtClause *
C) {}
554 if (
C->getMessageString())
555 Profiler->VisitStmt(
C->getMessageString());
559 VistOMPClauseWithPreInit(
C);
560 if (
auto *S =
C->getChunkSize())
561 Profiler->VisitStmt(S);
565 if (
auto *Num =
C->getNumForLoops())
566 Profiler->VisitStmt(Num);
569void OMPClauseProfiler::VisitOMPNowaitClause(
const OMPNowaitClause *) {}
571void OMPClauseProfiler::VisitOMPUntiedClause(
const OMPUntiedClause *) {}
575void OMPClauseProfiler::VisitOMPReadClause(
const OMPReadClause *) {}
577void OMPClauseProfiler::VisitOMPWriteClause(
const OMPWriteClause *) {}
579void OMPClauseProfiler::VisitOMPUpdateClause(
const OMPUpdateClause *) {}
585void OMPClauseProfiler::VisitOMPFailClause(
const OMPFailClause *) {}
587void OMPClauseProfiler::VisitOMPSeqCstClause(
const OMPSeqCstClause *) {}
589void OMPClauseProfiler::VisitOMPAcqRelClause(
const OMPAcqRelClause *) {}
597void OMPClauseProfiler::VisitOMPWeakClause(
const OMPWeakClause *) {}
601void OMPClauseProfiler::VisitOMPSIMDClause(
const OMPSIMDClause *) {}
605void OMPClauseProfiler::VisitOMPInitClause(
const OMPInitClause *
C) {
606 VisitOMPClauseList(
C);
609void OMPClauseProfiler::VisitOMPUseClause(
const OMPUseClause *
C) {
610 if (
C->getInteropVar())
611 Profiler->VisitStmt(
C->getInteropVar());
615 if (
C->getInteropVar())
616 Profiler->VisitStmt(
C->getInteropVar());
620 VistOMPClauseWithPreInit(
C);
621 if (
C->getThreadID())
622 Profiler->VisitStmt(
C->getThreadID());
626void OMPClauseProfiler::VisitOMPClauseList(T *
Node) {
627 for (
auto *E :
Node->varlists()) {
629 Profiler->VisitStmt(E);
634 VisitOMPClauseList(
C);
635 for (
auto *E :
C->private_copies()) {
637 Profiler->VisitStmt(E);
642 VisitOMPClauseList(
C);
643 VistOMPClauseWithPreInit(
C);
644 for (
auto *E :
C->private_copies()) {
646 Profiler->VisitStmt(E);
648 for (
auto *E :
C->inits()) {
650 Profiler->VisitStmt(E);
655 VisitOMPClauseList(
C);
656 VistOMPClauseWithPostUpdate(
C);
657 for (
auto *E :
C->source_exprs()) {
659 Profiler->VisitStmt(E);
661 for (
auto *E :
C->destination_exprs()) {
663 Profiler->VisitStmt(E);
665 for (
auto *E :
C->assignment_ops()) {
667 Profiler->VisitStmt(E);
671 VisitOMPClauseList(
C);
673void OMPClauseProfiler::VisitOMPReductionClause(
675 Profiler->VisitNestedNameSpecifier(
676 C->getQualifierLoc().getNestedNameSpecifier());
677 Profiler->VisitName(
C->getNameInfo().getName());
678 VisitOMPClauseList(
C);
679 VistOMPClauseWithPostUpdate(
C);
680 for (
auto *E :
C->privates()) {
682 Profiler->VisitStmt(E);
684 for (
auto *E :
C->lhs_exprs()) {
686 Profiler->VisitStmt(E);
688 for (
auto *E :
C->rhs_exprs()) {
690 Profiler->VisitStmt(E);
692 for (
auto *E :
C->reduction_ops()) {
694 Profiler->VisitStmt(E);
696 if (
C->getModifier() == clang::OMPC_REDUCTION_inscan) {
697 for (
auto *E :
C->copy_ops()) {
699 Profiler->VisitStmt(E);
701 for (
auto *E :
C->copy_array_temps()) {
703 Profiler->VisitStmt(E);
705 for (
auto *E :
C->copy_array_elems()) {
707 Profiler->VisitStmt(E);
711void OMPClauseProfiler::VisitOMPTaskReductionClause(
713 Profiler->VisitNestedNameSpecifier(
714 C->getQualifierLoc().getNestedNameSpecifier());
715 Profiler->VisitName(
C->getNameInfo().getName());
716 VisitOMPClauseList(
C);
717 VistOMPClauseWithPostUpdate(
C);
718 for (
auto *E :
C->privates()) {
720 Profiler->VisitStmt(E);
722 for (
auto *E :
C->lhs_exprs()) {
724 Profiler->VisitStmt(E);
726 for (
auto *E :
C->rhs_exprs()) {
728 Profiler->VisitStmt(E);
730 for (
auto *E :
C->reduction_ops()) {
732 Profiler->VisitStmt(E);
735void OMPClauseProfiler::VisitOMPInReductionClause(
737 Profiler->VisitNestedNameSpecifier(
738 C->getQualifierLoc().getNestedNameSpecifier());
739 Profiler->VisitName(
C->getNameInfo().getName());
740 VisitOMPClauseList(
C);
741 VistOMPClauseWithPostUpdate(
C);
742 for (
auto *E :
C->privates()) {
744 Profiler->VisitStmt(E);
746 for (
auto *E :
C->lhs_exprs()) {
748 Profiler->VisitStmt(E);
750 for (
auto *E :
C->rhs_exprs()) {
752 Profiler->VisitStmt(E);
754 for (
auto *E :
C->reduction_ops()) {
756 Profiler->VisitStmt(E);
758 for (
auto *E :
C->taskgroup_descriptors()) {
760 Profiler->VisitStmt(E);
764 VisitOMPClauseList(
C);
765 VistOMPClauseWithPostUpdate(
C);
766 for (
auto *E :
C->privates()) {
768 Profiler->VisitStmt(E);
770 for (
auto *E :
C->inits()) {
772 Profiler->VisitStmt(E);
774 for (
auto *E :
C->updates()) {
776 Profiler->VisitStmt(E);
778 for (
auto *E :
C->finals()) {
780 Profiler->VisitStmt(E);
783 Profiler->VisitStmt(
C->getStep());
784 if (
C->getCalcStep())
785 Profiler->VisitStmt(
C->getCalcStep());
788 VisitOMPClauseList(
C);
789 if (
C->getAlignment())
790 Profiler->VisitStmt(
C->getAlignment());
793 VisitOMPClauseList(
C);
794 for (
auto *E :
C->source_exprs()) {
796 Profiler->VisitStmt(E);
798 for (
auto *E :
C->destination_exprs()) {
800 Profiler->VisitStmt(E);
802 for (
auto *E :
C->assignment_ops()) {
804 Profiler->VisitStmt(E);
809 VisitOMPClauseList(
C);
810 for (
auto *E :
C->source_exprs()) {
812 Profiler->VisitStmt(E);
814 for (
auto *E :
C->destination_exprs()) {
816 Profiler->VisitStmt(E);
818 for (
auto *E :
C->assignment_ops()) {
820 Profiler->VisitStmt(E);
824 VisitOMPClauseList(
C);
827 if (
const Expr *Depobj =
C->getDepobj())
828 Profiler->VisitStmt(Depobj);
831 VisitOMPClauseList(
C);
835 Profiler->VisitStmt(
C->getDevice());
837void OMPClauseProfiler::VisitOMPMapClause(
const OMPMapClause *
C) {
838 VisitOMPClauseList(
C);
841 if (
Expr *Allocator =
C->getAllocator())
842 Profiler->VisitStmt(Allocator);
843 VisitOMPClauseList(
C);
846 VistOMPClauseWithPreInit(
C);
847 if (
C->getNumTeams())
848 Profiler->VisitStmt(
C->getNumTeams());
850void OMPClauseProfiler::VisitOMPThreadLimitClause(
852 VistOMPClauseWithPreInit(
C);
853 if (
C->getThreadLimit())
854 Profiler->VisitStmt(
C->getThreadLimit());
857 VistOMPClauseWithPreInit(
C);
858 if (
C->getPriority())
859 Profiler->VisitStmt(
C->getPriority());
862 VistOMPClauseWithPreInit(
C);
863 if (
C->getGrainsize())
864 Profiler->VisitStmt(
C->getGrainsize());
867 VistOMPClauseWithPreInit(
C);
868 if (
C->getNumTasks())
869 Profiler->VisitStmt(
C->getNumTasks());
871void OMPClauseProfiler::VisitOMPHintClause(
const OMPHintClause *
C) {
873 Profiler->VisitStmt(
C->getHint());
875void OMPClauseProfiler::VisitOMPToClause(
const OMPToClause *
C) {
876 VisitOMPClauseList(
C);
878void OMPClauseProfiler::VisitOMPFromClause(
const OMPFromClause *
C) {
879 VisitOMPClauseList(
C);
881void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
883 VisitOMPClauseList(
C);
885void OMPClauseProfiler::VisitOMPUseDeviceAddrClause(
887 VisitOMPClauseList(
C);
889void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
891 VisitOMPClauseList(
C);
893void OMPClauseProfiler::VisitOMPHasDeviceAddrClause(
895 VisitOMPClauseList(
C);
897void OMPClauseProfiler::VisitOMPNontemporalClause(
899 VisitOMPClauseList(
C);
900 for (
auto *E :
C->private_refs())
901 Profiler->VisitStmt(E);
904 VisitOMPClauseList(
C);
907 VisitOMPClauseList(
C);
909void OMPClauseProfiler::VisitOMPUsesAllocatorsClause(
911 for (
unsigned I = 0, E =
C->getNumberOfAllocators(); I < E; ++I) {
919 if (
const Expr *Modifier =
C->getModifier())
920 Profiler->VisitStmt(Modifier);
921 for (
const Expr *E :
C->varlists())
922 Profiler->VisitStmt(E);
925void OMPClauseProfiler::VisitOMPBindClause(
const OMPBindClause *
C) {}
926void OMPClauseProfiler::VisitOMPXDynCGroupMemClause(
928 VistOMPClauseWithPreInit(
C);
929 if (
Expr *Size =
C->getSize())
930 Profiler->VisitStmt(Size);
933 VisitOMPClauseList(
C);
943 OMPClauseProfiler
P(
this);
956 VisitOMPExecutableDirective(S);
960 VisitOMPLoopBasedDirective(S);
964 VisitOMPExecutableDirective(S);
968 VisitOMPExecutableDirective(S);
972 VisitOMPLoopDirective(S);
975void StmtProfiler::VisitOMPLoopTransformationDirective(
977 VisitOMPLoopBasedDirective(S);
981 VisitOMPLoopTransformationDirective(S);
985 VisitOMPLoopTransformationDirective(S);
989 VisitOMPLoopDirective(S);
993 VisitOMPLoopDirective(S);
997 VisitOMPExecutableDirective(S);
1001 VisitOMPExecutableDirective(S);
1005 VisitOMPExecutableDirective(S);
1009 VisitOMPExecutableDirective(S);
1013 VisitOMPExecutableDirective(S);
1017 VisitOMPExecutableDirective(S);
1018 VisitName(S->getDirectiveName().getName());
1023 VisitOMPLoopDirective(S);
1026void StmtProfiler::VisitOMPParallelForSimdDirective(
1028 VisitOMPLoopDirective(S);
1031void StmtProfiler::VisitOMPParallelMasterDirective(
1033 VisitOMPExecutableDirective(S);
1036void StmtProfiler::VisitOMPParallelMaskedDirective(
1038 VisitOMPExecutableDirective(S);
1041void StmtProfiler::VisitOMPParallelSectionsDirective(
1043 VisitOMPExecutableDirective(S);
1047 VisitOMPExecutableDirective(S);
1051 VisitOMPExecutableDirective(S);
1055 VisitOMPExecutableDirective(S);
1059 VisitOMPExecutableDirective(S);
1063 VisitOMPExecutableDirective(S);
1066 VisitOMPExecutableDirective(S);
1067 if (
const Expr *E = S->getReductionRef())
1072 VisitOMPExecutableDirective(S);
1076 VisitOMPExecutableDirective(S);
1080 VisitOMPExecutableDirective(S);
1084 VisitOMPExecutableDirective(S);
1088 VisitOMPExecutableDirective(S);
1092 VisitOMPExecutableDirective(S);
1096 VisitOMPExecutableDirective(S);
1099void StmtProfiler::VisitOMPTargetEnterDataDirective(
1101 VisitOMPExecutableDirective(S);
1104void StmtProfiler::VisitOMPTargetExitDataDirective(
1106 VisitOMPExecutableDirective(S);
1109void StmtProfiler::VisitOMPTargetParallelDirective(
1111 VisitOMPExecutableDirective(S);
1114void StmtProfiler::VisitOMPTargetParallelForDirective(
1116 VisitOMPExecutableDirective(S);
1120 VisitOMPExecutableDirective(S);
1123void StmtProfiler::VisitOMPCancellationPointDirective(
1125 VisitOMPExecutableDirective(S);
1129 VisitOMPExecutableDirective(S);
1133 VisitOMPLoopDirective(S);
1136void StmtProfiler::VisitOMPTaskLoopSimdDirective(
1138 VisitOMPLoopDirective(S);
1141void StmtProfiler::VisitOMPMasterTaskLoopDirective(
1143 VisitOMPLoopDirective(S);
1146void StmtProfiler::VisitOMPMaskedTaskLoopDirective(
1148 VisitOMPLoopDirective(S);
1151void StmtProfiler::VisitOMPMasterTaskLoopSimdDirective(
1153 VisitOMPLoopDirective(S);
1156void StmtProfiler::VisitOMPMaskedTaskLoopSimdDirective(
1158 VisitOMPLoopDirective(S);
1161void StmtProfiler::VisitOMPParallelMasterTaskLoopDirective(
1163 VisitOMPLoopDirective(S);
1166void StmtProfiler::VisitOMPParallelMaskedTaskLoopDirective(
1168 VisitOMPLoopDirective(S);
1171void StmtProfiler::VisitOMPParallelMasterTaskLoopSimdDirective(
1173 VisitOMPLoopDirective(S);
1176void StmtProfiler::VisitOMPParallelMaskedTaskLoopSimdDirective(
1178 VisitOMPLoopDirective(S);
1181void StmtProfiler::VisitOMPDistributeDirective(
1183 VisitOMPLoopDirective(S);
1186void OMPClauseProfiler::VisitOMPDistScheduleClause(
1188 VistOMPClauseWithPreInit(
C);
1189 if (
auto *S =
C->getChunkSize())
1190 Profiler->VisitStmt(S);
1195void StmtProfiler::VisitOMPTargetUpdateDirective(
1197 VisitOMPExecutableDirective(S);
1200void StmtProfiler::VisitOMPDistributeParallelForDirective(
1202 VisitOMPLoopDirective(S);
1205void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
1207 VisitOMPLoopDirective(S);
1210void StmtProfiler::VisitOMPDistributeSimdDirective(
1212 VisitOMPLoopDirective(S);
1215void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
1217 VisitOMPLoopDirective(S);
1220void StmtProfiler::VisitOMPTargetSimdDirective(
1222 VisitOMPLoopDirective(S);
1225void StmtProfiler::VisitOMPTeamsDistributeDirective(
1227 VisitOMPLoopDirective(S);
1230void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
1232 VisitOMPLoopDirective(S);
1235void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
1237 VisitOMPLoopDirective(S);
1240void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
1242 VisitOMPLoopDirective(S);
1245void StmtProfiler::VisitOMPTargetTeamsDirective(
1247 VisitOMPExecutableDirective(S);
1250void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
1252 VisitOMPLoopDirective(S);
1255void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
1257 VisitOMPLoopDirective(S);
1260void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
1262 VisitOMPLoopDirective(S);
1265void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
1267 VisitOMPLoopDirective(S);
1271 VisitOMPExecutableDirective(S);
1275 VisitOMPExecutableDirective(S);
1279 VisitOMPExecutableDirective(S);
1282void StmtProfiler::VisitOMPGenericLoopDirective(
1284 VisitOMPLoopDirective(S);
1287void StmtProfiler::VisitOMPTeamsGenericLoopDirective(
1289 VisitOMPLoopDirective(S);
1292void StmtProfiler::VisitOMPTargetTeamsGenericLoopDirective(
1294 VisitOMPLoopDirective(S);
1297void StmtProfiler::VisitOMPParallelGenericLoopDirective(
1299 VisitOMPLoopDirective(S);
1302void StmtProfiler::VisitOMPTargetParallelGenericLoopDirective(
1304 VisitOMPLoopDirective(S);
1307void StmtProfiler::VisitExpr(
const Expr *S) {
1311void StmtProfiler::VisitConstantExpr(
const ConstantExpr *S) {
1315void StmtProfiler::VisitDeclRefExpr(
const DeclRefExpr *S) {
1318 VisitNestedNameSpecifier(S->getQualifier());
1319 VisitDecl(S->getDecl());
1321 ID.AddBoolean(S->hasExplicitTemplateArgs());
1322 if (S->hasExplicitTemplateArgs())
1323 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1327void StmtProfiler::VisitSYCLUniqueStableNameExpr(
1330 VisitType(S->getTypeSourceInfo()->getType());
1335 ID.AddInteger(llvm::to_underlying(S->getIdentKind()));
1340 S->getValue().Profile(ID);
1347 BitIntT->Profile(ID);
1354 S->getValue().Profile(ID);
1360 ID.AddInteger(llvm::to_underlying(S->getKind()));
1361 ID.AddInteger(S->getValue());
1366 S->getValue().Profile(ID);
1367 ID.AddBoolean(S->isExact());
1375void StmtProfiler::VisitStringLiteral(
const StringLiteral *S) {
1377 ID.AddString(S->getBytes());
1378 ID.AddInteger(llvm::to_underlying(S->getKind()));
1381void StmtProfiler::VisitParenExpr(
const ParenExpr *S) {
1385void StmtProfiler::VisitParenListExpr(
const ParenListExpr *S) {
1389void StmtProfiler::VisitUnaryOperator(
const UnaryOperator *S) {
1391 ID.AddInteger(S->getOpcode());
1394void StmtProfiler::VisitOffsetOfExpr(
const OffsetOfExpr *S) {
1395 VisitType(S->getTypeSourceInfo()->getType());
1396 unsigned n = S->getNumComponents();
1397 for (
unsigned i = 0; i < n; ++i) {
1425 ID.AddInteger(S->getKind());
1426 if (S->isArgumentType())
1427 VisitType(S->getArgumentType());
1448 for (
unsigned I = 0, E = S->numOfIterators(); I < E; ++I)
1449 VisitDecl(S->getIteratorDecl(I));
1452void StmtProfiler::VisitCallExpr(
const CallExpr *S) {
1456void StmtProfiler::VisitMemberExpr(
const MemberExpr *S) {
1458 VisitDecl(S->getMemberDecl());
1460 VisitNestedNameSpecifier(S->getQualifier());
1461 ID.AddBoolean(S->isArrow());
1466 ID.AddBoolean(S->isFileScope());
1469void StmtProfiler::VisitCastExpr(
const CastExpr *S) {
1475 ID.AddInteger(S->getValueKind());
1480 VisitType(S->getTypeAsWritten());
1484 VisitExplicitCastExpr(S);
1489 ID.AddInteger(S->getOpcode());
1494 VisitBinaryOperator(S);
1501void StmtProfiler::VisitBinaryConditionalOperator(
1506void StmtProfiler::VisitAddrLabelExpr(
const AddrLabelExpr *S) {
1508 VisitDecl(S->getLabel());
1511void StmtProfiler::VisitStmtExpr(
const StmtExpr *S) {
1523void StmtProfiler::VisitChooseExpr(
const ChooseExpr *S) {
1527void StmtProfiler::VisitGNUNullExpr(
const GNUNullExpr *S) {
1531void StmtProfiler::VisitVAArgExpr(
const VAArgExpr *S) {
1535void StmtProfiler::VisitInitListExpr(
const InitListExpr *S) {
1536 if (S->getSyntacticForm()) {
1537 VisitInitListExpr(S->getSyntacticForm());
1546 ID.AddBoolean(S->usesGNUSyntax());
1548 if (D.isFieldDesignator()) {
1550 VisitName(D.getFieldName());
1554 if (D.isArrayDesignator()) {
1557 assert(D.isArrayRangeDesignator());
1560 ID.AddInteger(D.getArrayIndex());
1566void StmtProfiler::VisitDesignatedInitUpdateExpr(
1568 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
1580void StmtProfiler::VisitNoInitExpr(
const NoInitExpr *S) {
1581 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
1590 VisitName(&S->getAccessor());
1593void StmtProfiler::VisitBlockExpr(
const BlockExpr *S) {
1595 VisitDecl(S->getBlockDecl());
1601 S->associations()) {
1604 ID.AddPointer(
nullptr);
1607 VisitExpr(Assoc.getAssociationExpr());
1614 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1617 Visit(OVE->getSourceExpr());
1620void StmtProfiler::VisitAtomicExpr(
const AtomicExpr *S) {
1622 ID.AddInteger(S->getOp());
1625void StmtProfiler::VisitConceptSpecializationExpr(
1628 VisitDecl(S->getNamedConcept());
1630 VisitTemplateArgument(Arg);
1633void StmtProfiler::VisitRequiresExpr(
const RequiresExpr *S) {
1635 ID.AddInteger(S->getLocalParameters().size());
1636 for (
ParmVarDecl *LocalParam : S->getLocalParameters())
1637 VisitDecl(LocalParam);
1638 ID.AddInteger(S->getRequirements().size());
1640 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) {
1642 ID.AddBoolean(TypeReq->isSubstitutionFailure());
1643 if (!TypeReq->isSubstitutionFailure())
1644 VisitType(TypeReq->getType()->getType());
1645 }
else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) {
1647 ID.AddBoolean(ExprReq->isExprSubstitutionFailure());
1648 if (!ExprReq->isExprSubstitutionFailure())
1649 Visit(ExprReq->getExpr());
1654 ID.AddBoolean(ExprReq->getNoexceptLoc().isValid());
1656 ExprReq->getReturnTypeRequirement();
1668 auto *NestedReq = cast<concepts::NestedRequirement>(Req);
1669 ID.AddBoolean(NestedReq->hasInvalidConstraint());
1670 if (!NestedReq->hasInvalidConstraint())
1671 Visit(NestedReq->getConstraintExpr());
1679 unsigned &NumArgs) {
1680 switch (S->getOperator()) {
1685 case OO_Array_Delete:
1687 case OO_Conditional:
1689 llvm_unreachable(
"Invalid operator call kind");
1694 return Stmt::UnaryOperatorClass;
1698 return Stmt::BinaryOperatorClass;
1703 return Stmt::UnaryOperatorClass;
1707 return Stmt::BinaryOperatorClass;
1712 return Stmt::UnaryOperatorClass;
1716 return Stmt::BinaryOperatorClass;
1720 return Stmt::BinaryOperatorClass;
1724 return Stmt::BinaryOperatorClass;
1728 return Stmt::BinaryOperatorClass;
1732 UnaryOp = UO_AddrOf;
1733 return Stmt::UnaryOperatorClass;
1737 return Stmt::BinaryOperatorClass;
1741 return Stmt::BinaryOperatorClass;
1745 return Stmt::UnaryOperatorClass;
1749 return Stmt::UnaryOperatorClass;
1752 BinaryOp = BO_Assign;
1753 return Stmt::BinaryOperatorClass;
1757 return Stmt::BinaryOperatorClass;
1761 return Stmt::BinaryOperatorClass;
1764 BinaryOp = BO_AddAssign;
1765 return Stmt::CompoundAssignOperatorClass;
1768 BinaryOp = BO_SubAssign;
1769 return Stmt::CompoundAssignOperatorClass;
1772 BinaryOp = BO_MulAssign;
1773 return Stmt::CompoundAssignOperatorClass;
1776 BinaryOp = BO_DivAssign;
1777 return Stmt::CompoundAssignOperatorClass;
1779 case OO_PercentEqual:
1780 BinaryOp = BO_RemAssign;
1781 return Stmt::CompoundAssignOperatorClass;
1784 BinaryOp = BO_XorAssign;
1785 return Stmt::CompoundAssignOperatorClass;
1788 BinaryOp = BO_AndAssign;
1789 return Stmt::CompoundAssignOperatorClass;
1792 BinaryOp = BO_OrAssign;
1793 return Stmt::CompoundAssignOperatorClass;
1797 return Stmt::BinaryOperatorClass;
1799 case OO_GreaterGreater:
1801 return Stmt::BinaryOperatorClass;
1803 case OO_LessLessEqual:
1804 BinaryOp = BO_ShlAssign;
1805 return Stmt::CompoundAssignOperatorClass;
1807 case OO_GreaterGreaterEqual:
1808 BinaryOp = BO_ShrAssign;
1809 return Stmt::CompoundAssignOperatorClass;
1813 return Stmt::BinaryOperatorClass;
1815 case OO_ExclaimEqual:
1817 return Stmt::BinaryOperatorClass;
1821 return Stmt::BinaryOperatorClass;
1823 case OO_GreaterEqual:
1825 return Stmt::BinaryOperatorClass;
1829 return Stmt::BinaryOperatorClass;
1833 return Stmt::BinaryOperatorClass;
1837 return Stmt::BinaryOperatorClass;
1840 UnaryOp = NumArgs == 1 ? UO_PreInc : UO_PostInc;
1842 return Stmt::UnaryOperatorClass;
1845 UnaryOp = NumArgs == 1 ? UO_PreDec : UO_PostDec;
1847 return Stmt::UnaryOperatorClass;
1850 BinaryOp = BO_Comma;
1851 return Stmt::BinaryOperatorClass;
1854 BinaryOp = BO_PtrMemI;
1855 return Stmt::BinaryOperatorClass;
1858 return Stmt::ArraySubscriptExprClass;
1861 return Stmt::CallExprClass;
1864 UnaryOp = UO_Coawait;
1865 return Stmt::UnaryOperatorClass;
1868 llvm_unreachable(
"Invalid overloaded operator expression");
1871#if defined(_MSC_VER) && !defined(__clang__)
1876#pragma optimize("", off)
1881 if (S->isTypeDependent()) {
1887 if (S->getOperator() == OO_Arrow)
1888 return Visit(S->getArg(0));
1892 unsigned NumArgs = S->getNumArgs();
1896 for (
unsigned I = 0; I != NumArgs; ++I)
1897 Visit(S->getArg(I));
1898 if (SC == Stmt::UnaryOperatorClass)
1899 ID.AddInteger(UnaryOp);
1900 else if (SC == Stmt::BinaryOperatorClass ||
1901 SC == Stmt::CompoundAssignOperatorClass)
1902 ID.AddInteger(BinaryOp);
1904 assert(SC == Stmt::ArraySubscriptExprClass || SC == Stmt::CallExprClass);
1910 ID.AddInteger(S->getOperator());
1913void StmtProfiler::VisitCXXRewrittenBinaryOperator(
1917 assert(!S->isTypeDependent() &&
1918 "resolved rewritten operator should never be type-dependent");
1919 ID.AddBoolean(S->isReversed());
1920 VisitExpr(S->getSemanticForm());
1923#if defined(_MSC_VER) && !defined(__clang__)
1925#pragma optimize("", on)
1937void StmtProfiler::VisitAsTypeExpr(
const AsTypeExpr *S) {
1942 VisitExplicitCastExpr(S);
1946 VisitCXXNamedCastExpr(S);
1950 VisitCXXNamedCastExpr(S);
1955 VisitCXXNamedCastExpr(S);
1959 VisitCXXNamedCastExpr(S);
1964 VisitType(S->getTypeInfoAsWritten()->getType());
1968 VisitCXXNamedCastExpr(S);
1977 ID.AddBoolean(S->getValue());
1984void StmtProfiler::VisitCXXStdInitializerListExpr(
1989void StmtProfiler::VisitCXXTypeidExpr(
const CXXTypeidExpr *S) {
1991 if (S->isTypeOperand())
1992 VisitType(S->getTypeOperandSourceInfo()->getType());
1995void StmtProfiler::VisitCXXUuidofExpr(
const CXXUuidofExpr *S) {
1997 if (S->isTypeOperand())
1998 VisitType(S->getTypeOperandSourceInfo()->getType());
2003 VisitDecl(S->getPropertyDecl());
2006void StmtProfiler::VisitMSPropertySubscriptExpr(
2011void StmtProfiler::VisitCXXThisExpr(
const CXXThisExpr *S) {
2013 ID.AddBoolean(S->isImplicit());
2016void StmtProfiler::VisitCXXThrowExpr(
const CXXThrowExpr *S) {
2022 VisitDecl(S->getParam());
2027 VisitDecl(S->getField());
2038 VisitDecl(S->getConstructor());
2039 ID.AddBoolean(S->isElidable());
2042void StmtProfiler::VisitCXXInheritedCtorInitExpr(
2045 VisitDecl(S->getConstructor());
2049 VisitExplicitCastExpr(S);
2054 VisitCXXConstructExpr(S);
2058StmtProfiler::VisitLambdaExpr(
const LambdaExpr *S) {
2059 if (!ProfileLambdaExpr) {
2063 VisitStmtNoChildren(S);
2067 VisitDecl(S->getLambdaClass());
2076 ID.AddInteger(
Capture.getCaptureKind());
2077 if (
Capture.capturesVariable())
2078 VisitDecl(
Capture.getCapturedVar());
2087void StmtProfiler::VisitCXXDeleteExpr(
const CXXDeleteExpr *S) {
2089 ID.AddBoolean(S->isGlobalDelete());
2090 ID.AddBoolean(S->isArrayForm());
2091 VisitDecl(S->getOperatorDelete());
2094void StmtProfiler::VisitCXXNewExpr(
const CXXNewExpr *S) {
2096 VisitType(S->getAllocatedType());
2097 VisitDecl(S->getOperatorNew());
2098 VisitDecl(S->getOperatorDelete());
2099 ID.AddBoolean(S->isArray());
2100 ID.AddInteger(S->getNumPlacementArgs());
2101 ID.AddBoolean(S->isGlobalNew());
2102 ID.AddBoolean(S->isParenTypeId());
2103 ID.AddInteger(llvm::to_underlying(S->getInitializationStyle()));
2109 ID.AddBoolean(S->isArrow());
2110 VisitNestedNameSpecifier(S->getQualifier());
2111 ID.AddBoolean(S->getScopeTypeInfo() !=
nullptr);
2112 if (S->getScopeTypeInfo())
2113 VisitType(S->getScopeTypeInfo()->getType());
2114 ID.AddBoolean(S->getDestroyedTypeInfo() !=
nullptr);
2115 if (S->getDestroyedTypeInfo())
2116 VisitType(S->getDestroyedType());
2118 VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
2121void StmtProfiler::VisitOverloadExpr(
const OverloadExpr *S) {
2123 VisitNestedNameSpecifier(S->getQualifier());
2124 VisitName(S->getName(),
true);
2125 ID.AddBoolean(S->hasExplicitTemplateArgs());
2126 if (S->hasExplicitTemplateArgs())
2127 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2132 VisitOverloadExpr(S);
2135void StmtProfiler::VisitTypeTraitExpr(
const TypeTraitExpr *S) {
2137 ID.AddInteger(S->getTrait());
2138 ID.AddInteger(S->getNumArgs());
2139 for (
unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2140 VisitType(S->getArg(I)->getType());
2145 ID.AddInteger(S->getTrait());
2146 VisitType(S->getQueriedType());
2151 ID.AddInteger(S->getTrait());
2152 VisitExpr(S->getQueriedExpression());
2155void StmtProfiler::VisitDependentScopeDeclRefExpr(
2158 VisitName(S->getDeclName());
2159 VisitNestedNameSpecifier(S->getQualifier());
2160 ID.AddBoolean(S->hasExplicitTemplateArgs());
2161 if (S->hasExplicitTemplateArgs())
2162 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2169void StmtProfiler::VisitCXXUnresolvedConstructExpr(
2172 VisitType(S->getTypeAsWritten());
2173 ID.AddInteger(S->isListInitialization());
2176void StmtProfiler::VisitCXXDependentScopeMemberExpr(
2178 ID.AddBoolean(S->isImplicitAccess());
2179 if (!S->isImplicitAccess()) {
2181 ID.AddBoolean(S->isArrow());
2183 VisitNestedNameSpecifier(S->getQualifier());
2184 VisitName(S->getMember());
2185 ID.AddBoolean(S->hasExplicitTemplateArgs());
2186 if (S->hasExplicitTemplateArgs())
2187 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2191 ID.AddBoolean(S->isImplicitAccess());
2192 if (!S->isImplicitAccess()) {
2194 ID.AddBoolean(S->isArrow());
2196 VisitNestedNameSpecifier(S->getQualifier());
2197 VisitName(S->getMemberName());
2198 ID.AddBoolean(S->hasExplicitTemplateArgs());
2199 if (S->hasExplicitTemplateArgs())
2200 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2213 VisitDecl(S->getPack());
2214 if (S->isPartiallySubstituted()) {
2215 auto Args = S->getPartialArguments();
2216 ID.AddInteger(Args.size());
2217 for (
const auto &TA : Args)
2218 VisitTemplateArgument(TA);
2230void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
2233 VisitDecl(S->getParameterPack());
2234 VisitTemplateArgument(S->getArgumentPack());
2237void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
2245 VisitDecl(S->getParameterPack());
2246 ID.AddInteger(S->getNumExpansions());
2251void StmtProfiler::VisitMaterializeTemporaryExpr(
2256void StmtProfiler::VisitCXXFoldExpr(
const CXXFoldExpr *S) {
2258 ID.AddInteger(S->getOperator());
2269void StmtProfiler::VisitCoreturnStmt(
const CoreturnStmt *S) {
2273void StmtProfiler::VisitCoawaitExpr(
const CoawaitExpr *S) {
2281void StmtProfiler::VisitCoyieldExpr(
const CoyieldExpr *S) {
2289void StmtProfiler::VisitTypoExpr(
const TypoExpr *E) {
2293void StmtProfiler::VisitSourceLocExpr(
const SourceLocExpr *E) {
2297void StmtProfiler::VisitRecoveryExpr(
const RecoveryExpr *E) { VisitExpr(E); }
2303void StmtProfiler::VisitObjCBoxedExpr(
const ObjCBoxedExpr *E) {
2317 VisitType(S->getEncodedType());
2322 VisitName(S->getSelector());
2327 VisitDecl(S->getProtocol());
2332 VisitDecl(S->getDecl());
2333 ID.AddBoolean(S->isArrow());
2334 ID.AddBoolean(S->isFreeIvar());
2339 if (S->isImplicitProperty()) {
2340 VisitDecl(S->getImplicitPropertyGetter());
2341 VisitDecl(S->getImplicitPropertySetter());
2343 VisitDecl(S->getExplicitProperty());
2345 if (S->isSuperReceiver()) {
2346 ID.AddBoolean(S->isSuperReceiver());
2347 VisitType(S->getSuperReceiverType());
2353 VisitDecl(S->getAtIndexMethodDecl());
2354 VisitDecl(S->setAtIndexMethodDecl());
2359 VisitName(S->getSelector());
2360 VisitDecl(S->getMethodDecl());
2363void StmtProfiler::VisitObjCIsaExpr(
const ObjCIsaExpr *S) {
2365 ID.AddBoolean(S->isArrow());
2370 ID.AddBoolean(S->getValue());
2373void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
2376 ID.AddBoolean(S->shouldCopy());
2380 VisitExplicitCastExpr(S);
2381 ID.AddBoolean(S->getBridgeKind());
2384void StmtProfiler::VisitObjCAvailabilityCheckExpr(
2391 ID.AddInteger(NumArgs);
2392 for (
unsigned I = 0; I != NumArgs; ++I)
2439 VisitTemplateArgument(
P);
2444void StmtProfiler::VisitOpenACCComputeConstruct(
2452 bool Canonical,
bool ProfileLambdaExpr)
const {
2453 StmtProfilerWithPointers Profiler(ID, Context, Canonical, ProfileLambdaExpr);
2454 Profiler.Visit(
this);
2459 StmtProfilerWithoutPointers Profiler(ID, Hash);
2460 Profiler.Visit(
this);
Defines the clang::ASTContext interface.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes,...
This file defines OpenMP AST classes for clauses.
static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, UnaryOperatorKind &UnaryOp, BinaryOperatorKind &BinaryOp, unsigned &NumArgs)
static const TemplateArgument & getArgument(const TemplateArgument &A)
void Profile(llvm::FoldingSetNodeID &ID) const
profile this value.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
TemplateName getCanonicalTemplateName(const TemplateName &Name) const
Retrieves the "canonical" template name that refers to a given template.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getUnconstrainedType(QualType T) const
Remove any type constraints from a template parameter type, for equivalence comparison of template pa...
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
AddrLabelExpr - The GNU address of label extension, representing &&label.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Represents a loop initializing the elements of an array.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Represents an attribute applied to a statement.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
A builtin binary operation expression such as "x + y" or "x <= y".
A fixed int type of a specified bitwidth.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
BreakStmt - This represents a break.
Represents a C++2a __builtin_bit_cast(T, v) expression.
This class is used for builtin types like 'int'.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Represents a call to a CUDA kernel function.
A C++ addrspace_cast expression (currently only enabled for OpenCL).
Represents binding an expression to a temporary.
A boolean literal, per ([C++ lex.bool] Boolean literals).
CXXCatchStmt - This represents a C++ catch block.
A C++ const_cast expression (C++ [expr.const.cast]).
Represents a call to a C++ constructor.
A default argument (C++ [dcl.fct.default]).
A use of a default initializer in a constructor or in aggregate initialization.
Represents a delete expression for memory deallocation and destructor calls, e.g.
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Represents a C++ destructor within a class.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Represents a folding of a pack over an operator.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Represents a call to an inherited base class constructor from an inheriting constructor.
Represents a call to a member function that may be written either with member call syntax (e....
Abstract class common to all of the C++ "named"/"keyword" casts.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
The null pointer literal (C++11 [lex.nullptr])
A call to an overloaded operator written using operator syntax.
Represents a list-initialization with parenthesis.
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
capture_const_range captures() const
unsigned getODRHash() const
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
A rewritten comparison expression that was originally written using operator syntax.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
A C++ static_cast expression (C++ [expr.static.cast]).
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Represents a C++ functional cast expression that builds a temporary object.
Represents the this expression in C++.
A C++ throw-expression (C++ [except.throw]).
CXXTryStmt - A C++ try block, including all handlers.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
This captures a statement into a function.
CaseStmt - Represent a case statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Represents a 'co_await' expression.
CompoundAssignOperator - For compound assignments (e.g.
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
Represents the specialization of a concept - evaluates to a prvalue of type bool.
ConditionalOperator - The ?: ternary operator.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
ContinueStmt - This represents a continue.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Represents a 'co_return' statement in the C++ Coroutines TS.
Represents the body of a coroutine.
Represents a 'co_yield' expression.
A reference to a declared variable, function, enum, etc.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Decl - This represents one declaration (or definition), e.g.
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
The name of a declaration.
Represents a 'co_await' expression while the type of the promise is dependent.
A qualified reference to a name whose declaration cannot yet be resolved.
Represents a single C99 designator.
Represents a C99 designated initializer expression.
DoStmt - This represents a 'do/while' stmt.
ExplicitCastExpr - An explicit cast written in the source code.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
This represents one expression.
An expression trait intrinsic.
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
VarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
This represents a GCC inline-assembly statement extension.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Represents a C11 generic selection.
AssociationTy< true > ConstAssociation
GotoStmt - This represents a direct goto.
One of these records is kept for each identifier that is lexed.
IfStmt - This represents an if/then/else.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Represents an implicitly-generated value initialization of an object of a given type.
IndirectGotoStmt - This represents an indirect goto.
Describes an C or C++ initializer list.
LabelStmt - Represents a label, which has a substatement.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
This represents a Microsoft inline-assembly statement extension.
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.
A member reference to an MSPropertyDecl.
MS property subscript expression.
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Represents a place-holder for an object not to be initialized by anything.
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
NullStmt - This is the null statement ";": C99 6.8.3p3.
void AddDecl(const Decl *D)
void AddIdentifierInfo(const IdentifierInfo *II)
void AddDeclarationName(DeclarationName Name, bool TreatAsDecl=false)
void AddNestedNameSpecifier(const NestedNameSpecifier *NNS)
void AddTemplateName(TemplateName Name)
void AddQualType(QualType T)
This represents 'acq_rel' clause in the '#pragma omp atomic|flush' directives.
This represents 'acquire' clause in the '#pragma omp atomic|flush' directives.
This represents clause 'affinity' in the '#pragma omp task'-based directives.
This represents the 'align' clause in the '#pragma omp allocate' directive.
This represents clause 'aligned' in the '#pragma omp ...' directives.
This represents clause 'allocate' in the '#pragma omp ...' directives.
This represents 'allocator' clause in the '#pragma omp ...' directive.
OpenMP 5.0 [2.1.5, Array Sections].
An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......
This represents 'at' clause in the '#pragma omp error' directive.
This represents 'atomic_default_mem_order' clause in the '#pragma omp requires' directive.
This represents '#pragma omp atomic' directive.
This represents '#pragma omp barrier' directive.
This represents 'bind' clause in the '#pragma omp ...' directives.
This represents '#pragma omp cancel' directive.
This represents '#pragma omp cancellation point' directive.
Representation of an OpenMP canonical loop.
This represents 'capture' clause in the '#pragma omp atomic' directive.
Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc.
Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc.
This represents 'collapse' clause in the '#pragma omp ...' directive.
This represents 'compare' clause in the '#pragma omp atomic' directive.
This represents clause 'copyin' in the '#pragma omp ...' directives.
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
This represents '#pragma omp critical' directive.
This represents 'default' clause in the '#pragma omp ...' directive.
This represents 'defaultmap' clause in the '#pragma omp ...' directive.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
This represents implicit clause 'depobj' for the '#pragma omp depobj' directive.
This represents '#pragma omp depobj' directive.
This represents 'destroy' clause in the '#pragma omp depobj' directive or the '#pragma omp interop' d...
This represents 'detach' clause in the '#pragma omp task' directive.
This represents 'device' clause in the '#pragma omp ...' directive.
This represents '#pragma omp dispatch' directive.
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
This represents '#pragma omp distribute' directive.
This represents '#pragma omp distribute parallel for' composite directive.
This represents '#pragma omp distribute parallel for simd' composite directive.
This represents '#pragma omp distribute simd' composite directive.
This represents the 'doacross' clause for the '#pragma omp ordered' directive.
This represents 'dynamic_allocators' clause in the '#pragma omp requires' directive.
This represents '#pragma omp error' directive.
This represents clause 'exclusive' in the '#pragma omp scan' directive.
This is a basic class for representing single OpenMP executable directive.
This represents 'fail' clause in the '#pragma omp atomic' directive.
This represents 'filter' clause in the '#pragma omp ...' directive.
This represents 'final' clause in the '#pragma omp ...' directive.
This represents clause 'firstprivate' in the '#pragma omp ...' directives.
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
This represents '#pragma omp flush' directive.
This represents '#pragma omp for' directive.
This represents '#pragma omp for simd' directive.
This represents clause 'from' in the '#pragma omp ...' directives.
Representation of the 'full' clause of the '#pragma omp unroll' directive.
This represents '#pragma omp loop' directive.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
This represents clause 'has_device_ptr' in the '#pragma omp ...' directives.
This represents 'hint' clause in the '#pragma omp ...' directive.
This represents 'if' clause in the '#pragma omp ...' directive.
This represents clause 'in_reduction' in the '#pragma omp task' directives.
This represents clause 'inclusive' in the '#pragma omp scan' directive.
This represents the 'init' clause in '#pragma omp ...' directives.
This represents '#pragma omp interop' directive.
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
This represents clause 'lastprivate' in the '#pragma omp ...' directives.
This represents clause 'linear' in the '#pragma omp ...' directives.
The base class for all loop-based directives, including loop transformation directives.
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
This represents clause 'map' in the '#pragma omp ...' directives.
This represents '#pragma omp masked' directive.
This represents '#pragma omp masked taskloop' directive.
This represents '#pragma omp masked taskloop simd' directive.
This represents '#pragma omp master' directive.
This represents '#pragma omp master taskloop' directive.
This represents '#pragma omp master taskloop simd' directive.
This represents 'mergeable' clause in the '#pragma omp ...' directive.
This represents 'message' clause in the '#pragma omp error' directive.
This represents 'nocontext' clause in the '#pragma omp ...' directive.
This represents 'nogroup' clause in the '#pragma omp ...' directive.
This represents clause 'nontemporal' in the '#pragma omp ...' directives.
This represents 'novariants' clause in the '#pragma omp ...' directive.
This represents 'nowait' clause in the '#pragma omp ...' directive.
This represents 'num_tasks' clause in the '#pragma omp ...' directive.
This represents 'num_teams' clause in the '#pragma omp ...' directive.
This represents 'num_threads' clause in the '#pragma omp ...' directive.
This represents 'order' clause in the '#pragma omp ...' directive.
This represents 'ordered' clause in the '#pragma omp ...' directive.
This represents '#pragma omp ordered' directive.
This represents '#pragma omp parallel' directive.
This represents '#pragma omp parallel for' directive.
This represents '#pragma omp parallel for simd' directive.
This represents '#pragma omp parallel loop' directive.
This represents '#pragma omp parallel masked' directive.
This represents '#pragma omp parallel masked taskloop' directive.
This represents '#pragma omp parallel masked taskloop simd' directive.
This represents '#pragma omp parallel master' directive.
This represents '#pragma omp parallel master taskloop' directive.
This represents '#pragma omp parallel master taskloop simd' directive.
This represents '#pragma omp parallel sections' directive.
Representation of the 'partial' clause of the '#pragma omp unroll' directive.
This represents 'priority' clause in the '#pragma omp ...' directive.
This represents clause 'private' in the '#pragma omp ...' directives.
This represents 'proc_bind' clause in the '#pragma omp ...' directive.
This represents 'read' clause in the '#pragma omp atomic' directive.
This represents clause 'reduction' in the '#pragma omp ...' directives.
This represents 'relaxed' clause in the '#pragma omp atomic' directives.
This represents 'release' clause in the '#pragma omp atomic|flush' directives.
This represents 'reverse_offload' clause in the '#pragma omp requires' directive.
This represents 'simd' clause in the '#pragma omp ...' directive.
This represents 'safelen' clause in the '#pragma omp ...' directive.
This represents '#pragma omp scan' directive.
This represents 'schedule' clause in the '#pragma omp ...' directive.
This represents '#pragma omp scope' directive.
This represents '#pragma omp section' directive.
This represents '#pragma omp sections' directive.
This represents 'seq_cst' clause in the '#pragma omp atomic' directive.
This represents 'severity' clause in the '#pragma omp error' directive.
This represents clause 'shared' in the '#pragma omp ...' directives.
This represents '#pragma omp simd' directive.
This represents 'simdlen' clause in the '#pragma omp ...' directive.
This represents '#pragma omp single' directive.
This represents the 'sizes' clause in the '#pragma omp tile' directive.
This represents '#pragma omp target data' directive.
This represents '#pragma omp target' directive.
This represents '#pragma omp target enter data' directive.
This represents '#pragma omp target exit data' directive.
This represents '#pragma omp target parallel' directive.
This represents '#pragma omp target parallel for' directive.
This represents '#pragma omp target parallel for simd' directive.
This represents '#pragma omp target parallel loop' directive.
This represents '#pragma omp target simd' directive.
This represents '#pragma omp target teams' directive.
This represents '#pragma omp target teams distribute' combined directive.
This represents '#pragma omp target teams distribute parallel for' combined directive.
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
This represents '#pragma omp target teams distribute simd' combined directive.
This represents '#pragma omp target teams loop' directive.
This represents '#pragma omp target update' directive.
This represents '#pragma omp task' directive.
This represents '#pragma omp taskloop' directive.
This represents '#pragma omp taskloop simd' directive.
This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives.
This represents '#pragma omp taskgroup' directive.
This represents '#pragma omp taskwait' directive.
This represents '#pragma omp taskyield' directive.
This represents '#pragma omp teams' directive.
This represents '#pragma omp teams distribute' directive.
This represents '#pragma omp teams distribute parallel for' composite directive.
This represents '#pragma omp teams distribute parallel for simd' composite directive.
This represents '#pragma omp teams distribute simd' combined directive.
This represents '#pragma omp teams loop' directive.
This represents 'thread_limit' clause in the '#pragma omp ...' directive.
This represents 'threads' clause in the '#pragma omp ...' directive.
This represents the '#pragma omp tile' loop transformation directive.
This represents clause 'to' in the '#pragma omp ...' directives.
This represents 'unified_address' clause in the '#pragma omp requires' directive.
This represents 'unified_shared_memory' clause in the '#pragma omp requires' directive.
This represents the '#pragma omp unroll' loop transformation directive.
This represents 'untied' clause in the '#pragma omp ...' directive.
This represents 'update' clause in the '#pragma omp atomic' directive.
This represents the 'use' clause in '#pragma omp ...' directives.
This represents clause 'use_device_addr' in the '#pragma omp ...' directives.
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
This represents clause 'uses_allocators' in the '#pragma omp target'-based directives.
This represents 'weak' clause in the '#pragma omp atomic' directives.
This represents 'write' clause in the '#pragma omp atomic' directive.
This represents 'ompx_attribute' clause in a directive that might generate an outlined function.
This represents 'ompx_bare' clause in the '#pragma omp target teams ...' directive.
This represents 'ompx_dyn_cgroup_mem' clause in the '#pragma omp target ...' directive.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Represents Objective-C's @catch statement.
Represents Objective-C's @finally statement.
Represents Objective-C's @synchronized statement.
Represents Objective-C's @throw statement.
Represents Objective-C's @try ... @catch ... @finally statement.
Represents Objective-C's @autoreleasepool Statement.
A runtime availability query.
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
ObjCBoxedExpr - used for generalized expression boxing.
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
ObjCEncodeExpr, used for @encode in Objective-C.
Represents Objective-C's collection statement.
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
An expression that sends a message to the given Objective-C object or class.
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
ObjCProtocolExpr used for protocol expression in Objective-C.
ObjCSelectorExpr used for @selector in Objective-C.
ObjCStringLiteral, used for Objective-C string literals i.e.
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Helper class for OffsetOfExpr.
FieldDecl * getField() const
For a field offsetof node, returns the field.
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
@ Array
An index into an array.
@ Identifier
A field in a dependent type, known only by its name.
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
Kind getKind() const
Determine what kind of offsetof node this is.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Represents a C++11 pack expansion that produces a sequence of expressions.
Expr * getIndexExpr() const
Expr * getPackIdExpression() const
ParenExpr - This represents a parethesized expression, e.g.
Represents a parameter to a function.
[C99 6.4.2.2] - A predefined identifier such as func.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
const Expr *const * const_semantics_iterator
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
QualType getCanonicalType() const
void * getAsOpaquePtr() const
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Represents a __leave statement.
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Represents an expression that computes the length of a parameter pack.
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Stmt - This represents one statement.
void ProcessODRHash(llvm::FoldingSetNodeID &ID, ODRHash &Hash) const
Calculate a unique representation for a statement that is stable across compiler invocations.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical, bool ProfileLambdaExpr=false) const
Produce a unique representation of the given statement.
StringLiteral - This represents a string literal expression, e.g.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Expr * getReplacement() const
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
SwitchStmt - This represents a 'switch' stmt.
Location wrapper for a TemplateArgument.
Represents a template argument.
QualType getStructuralValueType() const
Get the type of a StructuralValue.
QualType getParamTypeForDecl() const
Expr * getAsExpr() const
Retrieve the template argument as an expression.
QualType getAsType() const
Retrieve the type for a type template argument.
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
QualType getIntegralType() const
Retrieve the type of the integral value.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
@ Declaration
The template argument is a declaration that was provided for a pointer, reference,...
@ Template
The template argument is a template name that was provided for a template template parameter.
@ StructuralValue
The template argument is a non-type template argument that can't be represented by the special-case D...
@ Pack
The template argument is actually a parameter pack.
@ TemplateExpansion
The template argument is a pack expansion of a template name that was provided for a template templat...
@ NullPtr
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
@ Type
The template argument is a type.
@ Null
Represents an empty template argument, e.g., one that has not been deduced.
@ Integral
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
@ Expression
The template argument is an expression, and we've not resolved it to one of the other forms yet,...
ArgKind getKind() const
Return the kind of stored template argument.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion,...
const APValue & getAsStructuralValue() const
Get the value of a StructuralValue.
Represents a C++ template name within the type system.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Declaration of a template type parameter.
Expr * getImmediatelyDeclaredConstraint() const
Get the immediately-declared constraint expression introduced by this type-constraint,...
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
const T * castAs() const
Member-template castAs<specific type>.
TypeClass getTypeClass() const
const T * getAs() const
Member-template getAs<specific type>'.
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Represents a call to the builtin function __builtin_va_arg.
WhileStmt - This represents a 'while' stmt.
bool isTypeConstraint() const
const TypeConstraint * getTypeConstraint() const
bool isSubstitutionFailure() const
A static requirement that can be used in a requires-expression to check properties of types and expre...
The JSON file list parser is used to communicate input to InstallAPI.
@ OO_None
Not an overloaded operator.
@ NUM_OVERLOADED_OPERATORS
Data for list of allocators.
Expr * AllocatorTraits
Allocator traits.
Expr * Allocator
Allocator.