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;
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());
156 if (Canonical && !
T.isNull())
159 ID.AddPointer(
T.getAsOpaquePtr());
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);
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) {
913 Profiler->VisitStmt(
D.Allocator);
914 if (
D.AllocatorTraits)
915 Profiler->VisitStmt(
D.AllocatorTraits);
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 VisitOMPLoopTransformationDirective(S);
992void StmtProfiler::VisitOMPInterchangeDirective(
994 VisitOMPLoopTransformationDirective(S);
998 VisitOMPLoopDirective(S);
1002 VisitOMPLoopDirective(S);
1006 VisitOMPExecutableDirective(S);
1010 VisitOMPExecutableDirective(S);
1014 VisitOMPExecutableDirective(S);
1018 VisitOMPExecutableDirective(S);
1022 VisitOMPExecutableDirective(S);
1026 VisitOMPExecutableDirective(S);
1027 VisitName(S->getDirectiveName().getName());
1032 VisitOMPLoopDirective(S);
1035void StmtProfiler::VisitOMPParallelForSimdDirective(
1037 VisitOMPLoopDirective(S);
1040void StmtProfiler::VisitOMPParallelMasterDirective(
1042 VisitOMPExecutableDirective(S);
1045void StmtProfiler::VisitOMPParallelMaskedDirective(
1047 VisitOMPExecutableDirective(S);
1050void StmtProfiler::VisitOMPParallelSectionsDirective(
1052 VisitOMPExecutableDirective(S);
1056 VisitOMPExecutableDirective(S);
1060 VisitOMPExecutableDirective(S);
1064 VisitOMPExecutableDirective(S);
1068 VisitOMPExecutableDirective(S);
1072 VisitOMPExecutableDirective(S);
1075 VisitOMPExecutableDirective(S);
1076 if (
const Expr *
E = S->getReductionRef())
1081 VisitOMPExecutableDirective(S);
1085 VisitOMPExecutableDirective(S);
1089 VisitOMPExecutableDirective(S);
1093 VisitOMPExecutableDirective(S);
1097 VisitOMPExecutableDirective(S);
1101 VisitOMPExecutableDirective(S);
1105 VisitOMPExecutableDirective(S);
1108void StmtProfiler::VisitOMPTargetEnterDataDirective(
1110 VisitOMPExecutableDirective(S);
1113void StmtProfiler::VisitOMPTargetExitDataDirective(
1115 VisitOMPExecutableDirective(S);
1118void StmtProfiler::VisitOMPTargetParallelDirective(
1120 VisitOMPExecutableDirective(S);
1123void StmtProfiler::VisitOMPTargetParallelForDirective(
1125 VisitOMPExecutableDirective(S);
1129 VisitOMPExecutableDirective(S);
1132void StmtProfiler::VisitOMPCancellationPointDirective(
1134 VisitOMPExecutableDirective(S);
1138 VisitOMPExecutableDirective(S);
1142 VisitOMPLoopDirective(S);
1145void StmtProfiler::VisitOMPTaskLoopSimdDirective(
1147 VisitOMPLoopDirective(S);
1150void StmtProfiler::VisitOMPMasterTaskLoopDirective(
1152 VisitOMPLoopDirective(S);
1155void StmtProfiler::VisitOMPMaskedTaskLoopDirective(
1157 VisitOMPLoopDirective(S);
1160void StmtProfiler::VisitOMPMasterTaskLoopSimdDirective(
1162 VisitOMPLoopDirective(S);
1165void StmtProfiler::VisitOMPMaskedTaskLoopSimdDirective(
1167 VisitOMPLoopDirective(S);
1170void StmtProfiler::VisitOMPParallelMasterTaskLoopDirective(
1172 VisitOMPLoopDirective(S);
1175void StmtProfiler::VisitOMPParallelMaskedTaskLoopDirective(
1177 VisitOMPLoopDirective(S);
1180void StmtProfiler::VisitOMPParallelMasterTaskLoopSimdDirective(
1182 VisitOMPLoopDirective(S);
1185void StmtProfiler::VisitOMPParallelMaskedTaskLoopSimdDirective(
1187 VisitOMPLoopDirective(S);
1190void StmtProfiler::VisitOMPDistributeDirective(
1192 VisitOMPLoopDirective(S);
1195void OMPClauseProfiler::VisitOMPDistScheduleClause(
1197 VistOMPClauseWithPreInit(
C);
1198 if (
auto *S =
C->getChunkSize())
1199 Profiler->VisitStmt(S);
1204void StmtProfiler::VisitOMPTargetUpdateDirective(
1206 VisitOMPExecutableDirective(S);
1209void StmtProfiler::VisitOMPDistributeParallelForDirective(
1211 VisitOMPLoopDirective(S);
1214void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
1216 VisitOMPLoopDirective(S);
1219void StmtProfiler::VisitOMPDistributeSimdDirective(
1221 VisitOMPLoopDirective(S);
1224void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
1226 VisitOMPLoopDirective(S);
1229void StmtProfiler::VisitOMPTargetSimdDirective(
1231 VisitOMPLoopDirective(S);
1234void StmtProfiler::VisitOMPTeamsDistributeDirective(
1236 VisitOMPLoopDirective(S);
1239void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
1241 VisitOMPLoopDirective(S);
1244void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
1246 VisitOMPLoopDirective(S);
1249void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
1251 VisitOMPLoopDirective(S);
1254void StmtProfiler::VisitOMPTargetTeamsDirective(
1256 VisitOMPExecutableDirective(S);
1259void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
1261 VisitOMPLoopDirective(S);
1264void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
1266 VisitOMPLoopDirective(S);
1269void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
1271 VisitOMPLoopDirective(S);
1274void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
1276 VisitOMPLoopDirective(S);
1280 VisitOMPExecutableDirective(S);
1284 VisitOMPExecutableDirective(S);
1288 VisitOMPExecutableDirective(S);
1291void StmtProfiler::VisitOMPGenericLoopDirective(
1293 VisitOMPLoopDirective(S);
1296void StmtProfiler::VisitOMPTeamsGenericLoopDirective(
1298 VisitOMPLoopDirective(S);
1301void StmtProfiler::VisitOMPTargetTeamsGenericLoopDirective(
1303 VisitOMPLoopDirective(S);
1306void StmtProfiler::VisitOMPParallelGenericLoopDirective(
1308 VisitOMPLoopDirective(S);
1311void StmtProfiler::VisitOMPTargetParallelGenericLoopDirective(
1313 VisitOMPLoopDirective(S);
1316void StmtProfiler::VisitExpr(
const Expr *S) {
1320void StmtProfiler::VisitConstantExpr(
const ConstantExpr *S) {
1324void StmtProfiler::VisitDeclRefExpr(
const DeclRefExpr *S) {
1327 VisitNestedNameSpecifier(S->getQualifier());
1328 VisitDecl(S->getDecl());
1330 ID.AddBoolean(S->hasExplicitTemplateArgs());
1331 if (S->hasExplicitTemplateArgs())
1332 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1336void StmtProfiler::VisitSYCLUniqueStableNameExpr(
1339 VisitType(S->getTypeSourceInfo()->getType());
1344 ID.AddInteger(llvm::to_underlying(S->getIdentKind()));
1349 S->getValue().Profile(ID);
1353 T =
T.getCanonicalType();
1356 BitIntT->Profile(ID);
1363 S->getValue().Profile(ID);
1369 ID.AddInteger(llvm::to_underlying(S->getKind()));
1370 ID.AddInteger(S->getValue());
1375 S->getValue().Profile(ID);
1376 ID.AddBoolean(S->isExact());
1384void StmtProfiler::VisitStringLiteral(
const StringLiteral *S) {
1386 ID.AddString(S->getBytes());
1387 ID.AddInteger(llvm::to_underlying(S->getKind()));
1390void StmtProfiler::VisitParenExpr(
const ParenExpr *S) {
1394void StmtProfiler::VisitParenListExpr(
const ParenListExpr *S) {
1398void StmtProfiler::VisitUnaryOperator(
const UnaryOperator *S) {
1400 ID.AddInteger(S->getOpcode());
1403void StmtProfiler::VisitOffsetOfExpr(
const OffsetOfExpr *S) {
1404 VisitType(S->getTypeSourceInfo()->getType());
1405 unsigned n = S->getNumComponents();
1406 for (
unsigned i = 0; i < n; ++i) {
1434 ID.AddInteger(S->getKind());
1435 if (S->isArgumentType())
1436 VisitType(S->getArgumentType());
1457 for (
unsigned I = 0,
E = S->numOfIterators(); I <
E; ++I)
1458 VisitDecl(S->getIteratorDecl(I));
1461void StmtProfiler::VisitCallExpr(
const CallExpr *S) {
1465void StmtProfiler::VisitMemberExpr(
const MemberExpr *S) {
1467 VisitDecl(S->getMemberDecl());
1469 VisitNestedNameSpecifier(S->getQualifier());
1470 ID.AddBoolean(S->isArrow());
1475 ID.AddBoolean(S->isFileScope());
1478void StmtProfiler::VisitCastExpr(
const CastExpr *S) {
1484 ID.AddInteger(S->getValueKind());
1489 VisitType(S->getTypeAsWritten());
1493 VisitExplicitCastExpr(S);
1498 ID.AddInteger(S->getOpcode());
1503 VisitBinaryOperator(S);
1510void StmtProfiler::VisitBinaryConditionalOperator(
1515void StmtProfiler::VisitAddrLabelExpr(
const AddrLabelExpr *S) {
1517 VisitDecl(S->getLabel());
1520void StmtProfiler::VisitStmtExpr(
const StmtExpr *S) {
1532void StmtProfiler::VisitChooseExpr(
const ChooseExpr *S) {
1536void StmtProfiler::VisitGNUNullExpr(
const GNUNullExpr *S) {
1540void StmtProfiler::VisitVAArgExpr(
const VAArgExpr *S) {
1544void StmtProfiler::VisitInitListExpr(
const InitListExpr *S) {
1545 if (S->getSyntacticForm()) {
1546 VisitInitListExpr(S->getSyntacticForm());
1555 ID.AddBoolean(S->usesGNUSyntax());
1557 if (
D.isFieldDesignator()) {
1559 VisitName(
D.getFieldName());
1563 if (
D.isArrayDesignator()) {
1566 assert(
D.isArrayRangeDesignator());
1569 ID.AddInteger(
D.getArrayIndex());
1575void StmtProfiler::VisitDesignatedInitUpdateExpr(
1577 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
1589void StmtProfiler::VisitNoInitExpr(
const NoInitExpr *S) {
1590 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
1599 VisitName(&S->getAccessor());
1602void StmtProfiler::VisitBlockExpr(
const BlockExpr *S) {
1604 VisitDecl(S->getBlockDecl());
1610 S->associations()) {
1613 ID.AddPointer(
nullptr);
1616 VisitExpr(Assoc.getAssociationExpr());
1623 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1626 Visit(OVE->getSourceExpr());
1629void StmtProfiler::VisitAtomicExpr(
const AtomicExpr *S) {
1631 ID.AddInteger(S->getOp());
1634void StmtProfiler::VisitConceptSpecializationExpr(
1637 VisitDecl(S->getNamedConcept());
1639 VisitTemplateArgument(Arg);
1642void StmtProfiler::VisitRequiresExpr(
const RequiresExpr *S) {
1644 ID.AddInteger(S->getLocalParameters().size());
1645 for (
ParmVarDecl *LocalParam : S->getLocalParameters())
1646 VisitDecl(LocalParam);
1647 ID.AddInteger(S->getRequirements().size());
1649 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) {
1651 ID.AddBoolean(TypeReq->isSubstitutionFailure());
1652 if (!TypeReq->isSubstitutionFailure())
1653 VisitType(TypeReq->getType()->getType());
1654 }
else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) {
1656 ID.AddBoolean(ExprReq->isExprSubstitutionFailure());
1657 if (!ExprReq->isExprSubstitutionFailure())
1658 Visit(ExprReq->getExpr());
1663 ID.AddBoolean(ExprReq->getNoexceptLoc().isValid());
1665 ExprReq->getReturnTypeRequirement();
1677 auto *NestedReq = cast<concepts::NestedRequirement>(Req);
1678 ID.AddBoolean(NestedReq->hasInvalidConstraint());
1679 if (!NestedReq->hasInvalidConstraint())
1680 Visit(NestedReq->getConstraintExpr());
1688 unsigned &NumArgs) {
1689 switch (S->getOperator()) {
1694 case OO_Array_Delete:
1696 case OO_Conditional:
1698 llvm_unreachable(
"Invalid operator call kind");
1703 return Stmt::UnaryOperatorClass;
1707 return Stmt::BinaryOperatorClass;
1712 return Stmt::UnaryOperatorClass;
1716 return Stmt::BinaryOperatorClass;
1721 return Stmt::UnaryOperatorClass;
1725 return Stmt::BinaryOperatorClass;
1729 return Stmt::BinaryOperatorClass;
1733 return Stmt::BinaryOperatorClass;
1737 return Stmt::BinaryOperatorClass;
1741 UnaryOp = UO_AddrOf;
1742 return Stmt::UnaryOperatorClass;
1746 return Stmt::BinaryOperatorClass;
1750 return Stmt::BinaryOperatorClass;
1754 return Stmt::UnaryOperatorClass;
1758 return Stmt::UnaryOperatorClass;
1761 BinaryOp = BO_Assign;
1762 return Stmt::BinaryOperatorClass;
1766 return Stmt::BinaryOperatorClass;
1770 return Stmt::BinaryOperatorClass;
1773 BinaryOp = BO_AddAssign;
1774 return Stmt::CompoundAssignOperatorClass;
1777 BinaryOp = BO_SubAssign;
1778 return Stmt::CompoundAssignOperatorClass;
1781 BinaryOp = BO_MulAssign;
1782 return Stmt::CompoundAssignOperatorClass;
1785 BinaryOp = BO_DivAssign;
1786 return Stmt::CompoundAssignOperatorClass;
1788 case OO_PercentEqual:
1789 BinaryOp = BO_RemAssign;
1790 return Stmt::CompoundAssignOperatorClass;
1793 BinaryOp = BO_XorAssign;
1794 return Stmt::CompoundAssignOperatorClass;
1797 BinaryOp = BO_AndAssign;
1798 return Stmt::CompoundAssignOperatorClass;
1801 BinaryOp = BO_OrAssign;
1802 return Stmt::CompoundAssignOperatorClass;
1806 return Stmt::BinaryOperatorClass;
1808 case OO_GreaterGreater:
1810 return Stmt::BinaryOperatorClass;
1812 case OO_LessLessEqual:
1813 BinaryOp = BO_ShlAssign;
1814 return Stmt::CompoundAssignOperatorClass;
1816 case OO_GreaterGreaterEqual:
1817 BinaryOp = BO_ShrAssign;
1818 return Stmt::CompoundAssignOperatorClass;
1822 return Stmt::BinaryOperatorClass;
1824 case OO_ExclaimEqual:
1826 return Stmt::BinaryOperatorClass;
1830 return Stmt::BinaryOperatorClass;
1832 case OO_GreaterEqual:
1834 return Stmt::BinaryOperatorClass;
1838 return Stmt::BinaryOperatorClass;
1842 return Stmt::BinaryOperatorClass;
1846 return Stmt::BinaryOperatorClass;
1849 UnaryOp = NumArgs == 1 ? UO_PreInc : UO_PostInc;
1851 return Stmt::UnaryOperatorClass;
1854 UnaryOp = NumArgs == 1 ? UO_PreDec : UO_PostDec;
1856 return Stmt::UnaryOperatorClass;
1859 BinaryOp = BO_Comma;
1860 return Stmt::BinaryOperatorClass;
1863 BinaryOp = BO_PtrMemI;
1864 return Stmt::BinaryOperatorClass;
1867 return Stmt::ArraySubscriptExprClass;
1870 return Stmt::CallExprClass;
1873 UnaryOp = UO_Coawait;
1874 return Stmt::UnaryOperatorClass;
1877 llvm_unreachable(
"Invalid overloaded operator expression");
1880#if defined(_MSC_VER) && !defined(__clang__)
1885#pragma optimize("", off)
1890 if (S->isTypeDependent()) {
1896 if (S->getOperator() == OO_Arrow)
1897 return Visit(S->getArg(0));
1901 unsigned NumArgs = S->getNumArgs();
1905 for (
unsigned I = 0; I != NumArgs; ++I)
1906 Visit(S->getArg(I));
1907 if (SC == Stmt::UnaryOperatorClass)
1908 ID.AddInteger(UnaryOp);
1909 else if (SC == Stmt::BinaryOperatorClass ||
1910 SC == Stmt::CompoundAssignOperatorClass)
1911 ID.AddInteger(BinaryOp);
1913 assert(SC == Stmt::ArraySubscriptExprClass || SC == Stmt::CallExprClass);
1919 ID.AddInteger(S->getOperator());
1922void StmtProfiler::VisitCXXRewrittenBinaryOperator(
1926 assert(!S->isTypeDependent() &&
1927 "resolved rewritten operator should never be type-dependent");
1928 ID.AddBoolean(S->isReversed());
1929 VisitExpr(S->getSemanticForm());
1932#if defined(_MSC_VER) && !defined(__clang__)
1934#pragma optimize("", on)
1946void StmtProfiler::VisitAsTypeExpr(
const AsTypeExpr *S) {
1951 VisitExplicitCastExpr(S);
1955 VisitCXXNamedCastExpr(S);
1959 VisitCXXNamedCastExpr(S);
1964 VisitCXXNamedCastExpr(S);
1968 VisitCXXNamedCastExpr(S);
1973 VisitType(S->getTypeInfoAsWritten()->getType());
1977 VisitCXXNamedCastExpr(S);
1986 ID.AddBoolean(S->getValue());
1993void StmtProfiler::VisitCXXStdInitializerListExpr(
1998void StmtProfiler::VisitCXXTypeidExpr(
const CXXTypeidExpr *S) {
2000 if (S->isTypeOperand())
2001 VisitType(S->getTypeOperandSourceInfo()->getType());
2004void StmtProfiler::VisitCXXUuidofExpr(
const CXXUuidofExpr *S) {
2006 if (S->isTypeOperand())
2007 VisitType(S->getTypeOperandSourceInfo()->getType());
2012 VisitDecl(S->getPropertyDecl());
2015void StmtProfiler::VisitMSPropertySubscriptExpr(
2020void StmtProfiler::VisitCXXThisExpr(
const CXXThisExpr *S) {
2022 ID.AddBoolean(S->isImplicit());
2023 ID.AddBoolean(S->isCapturedByCopyInLambdaWithExplicitObjectParameter());
2026void StmtProfiler::VisitCXXThrowExpr(
const CXXThrowExpr *S) {
2032 VisitDecl(S->getParam());
2037 VisitDecl(S->getField());
2048 VisitDecl(S->getConstructor());
2049 ID.AddBoolean(S->isElidable());
2052void StmtProfiler::VisitCXXInheritedCtorInitExpr(
2055 VisitDecl(S->getConstructor());
2059 VisitExplicitCastExpr(S);
2064 VisitCXXConstructExpr(S);
2068StmtProfiler::VisitLambdaExpr(
const LambdaExpr *S) {
2069 if (!ProfileLambdaExpr) {
2073 VisitStmtNoChildren(S);
2077 VisitDecl(S->getLambdaClass());
2084 ID.AddInteger(
Capture.getCaptureKind());
2085 if (
Capture.capturesVariable())
2086 VisitDecl(
Capture.getCapturedVar());
2095 for (
auto *SubDecl : Lambda->
decls()) {
2097 if (
auto *FTD = dyn_cast<FunctionTemplateDecl>(SubDecl))
2098 Call = FTD->getTemplatedDecl();
2099 else if (
auto *FD = dyn_cast<FunctionDecl>(SubDecl))
2115void StmtProfiler::VisitCXXDeleteExpr(
const CXXDeleteExpr *S) {
2117 ID.AddBoolean(S->isGlobalDelete());
2118 ID.AddBoolean(S->isArrayForm());
2119 VisitDecl(S->getOperatorDelete());
2122void StmtProfiler::VisitCXXNewExpr(
const CXXNewExpr *S) {
2124 VisitType(S->getAllocatedType());
2125 VisitDecl(S->getOperatorNew());
2126 VisitDecl(S->getOperatorDelete());
2127 ID.AddBoolean(S->isArray());
2128 ID.AddInteger(S->getNumPlacementArgs());
2129 ID.AddBoolean(S->isGlobalNew());
2130 ID.AddBoolean(S->isParenTypeId());
2131 ID.AddInteger(llvm::to_underlying(S->getInitializationStyle()));
2137 ID.AddBoolean(S->isArrow());
2138 VisitNestedNameSpecifier(S->getQualifier());
2139 ID.AddBoolean(S->getScopeTypeInfo() !=
nullptr);
2140 if (S->getScopeTypeInfo())
2141 VisitType(S->getScopeTypeInfo()->getType());
2142 ID.AddBoolean(S->getDestroyedTypeInfo() !=
nullptr);
2143 if (S->getDestroyedTypeInfo())
2144 VisitType(S->getDestroyedType());
2146 VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
2149void StmtProfiler::VisitOverloadExpr(
const OverloadExpr *S) {
2151 VisitNestedNameSpecifier(S->getQualifier());
2152 VisitName(S->getName(),
true);
2153 ID.AddBoolean(S->hasExplicitTemplateArgs());
2154 if (S->hasExplicitTemplateArgs())
2155 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2160 VisitOverloadExpr(S);
2163void StmtProfiler::VisitTypeTraitExpr(
const TypeTraitExpr *S) {
2165 ID.AddInteger(S->getTrait());
2166 ID.AddInteger(S->getNumArgs());
2167 for (
unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2168 VisitType(S->getArg(I)->getType());
2173 ID.AddInteger(S->getTrait());
2174 VisitType(S->getQueriedType());
2179 ID.AddInteger(S->getTrait());
2180 VisitExpr(S->getQueriedExpression());
2183void StmtProfiler::VisitDependentScopeDeclRefExpr(
2186 VisitName(S->getDeclName());
2187 VisitNestedNameSpecifier(S->getQualifier());
2188 ID.AddBoolean(S->hasExplicitTemplateArgs());
2189 if (S->hasExplicitTemplateArgs())
2190 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2197void StmtProfiler::VisitCXXUnresolvedConstructExpr(
2200 VisitType(S->getTypeAsWritten());
2201 ID.AddInteger(S->isListInitialization());
2204void StmtProfiler::VisitCXXDependentScopeMemberExpr(
2206 ID.AddBoolean(S->isImplicitAccess());
2207 if (!S->isImplicitAccess()) {
2209 ID.AddBoolean(S->isArrow());
2211 VisitNestedNameSpecifier(S->getQualifier());
2212 VisitName(S->getMember());
2213 ID.AddBoolean(S->hasExplicitTemplateArgs());
2214 if (S->hasExplicitTemplateArgs())
2215 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2219 ID.AddBoolean(S->isImplicitAccess());
2220 if (!S->isImplicitAccess()) {
2222 ID.AddBoolean(S->isArrow());
2224 VisitNestedNameSpecifier(S->getQualifier());
2225 VisitName(S->getMemberName());
2226 ID.AddBoolean(S->hasExplicitTemplateArgs());
2227 if (S->hasExplicitTemplateArgs())
2228 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2241 VisitDecl(S->getPack());
2242 if (S->isPartiallySubstituted()) {
2243 auto Args = S->getPartialArguments();
2244 ID.AddInteger(Args.size());
2245 for (
const auto &TA : Args)
2246 VisitTemplateArgument(TA);
2254 VisitExpr(
E->getPackIdExpression());
2255 VisitExpr(
E->getIndexExpr());
2258void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
2261 VisitDecl(S->getParameterPack());
2262 VisitTemplateArgument(S->getArgumentPack());
2265void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
2268 Visit(
E->getReplacement());
2273 VisitDecl(S->getParameterPack());
2274 ID.AddInteger(S->getNumExpansions());
2279void StmtProfiler::VisitMaterializeTemporaryExpr(
2284void StmtProfiler::VisitCXXFoldExpr(
const CXXFoldExpr *S) {
2286 ID.AddInteger(S->getOperator());
2297void StmtProfiler::VisitCoreturnStmt(
const CoreturnStmt *S) {
2301void StmtProfiler::VisitCoawaitExpr(
const CoawaitExpr *S) {
2309void StmtProfiler::VisitCoyieldExpr(
const CoyieldExpr *S) {
2317void StmtProfiler::VisitTypoExpr(
const TypoExpr *
E) {
2325void StmtProfiler::VisitEmbedExpr(
const EmbedExpr *
E) { VisitExpr(
E); }
2327void StmtProfiler::VisitRecoveryExpr(
const RecoveryExpr *
E) { VisitExpr(
E); }
2347 VisitType(S->getEncodedType());
2352 VisitName(S->getSelector());
2357 VisitDecl(S->getProtocol());
2362 VisitDecl(S->getDecl());
2363 ID.AddBoolean(S->isArrow());
2364 ID.AddBoolean(S->isFreeIvar());
2369 if (S->isImplicitProperty()) {
2370 VisitDecl(S->getImplicitPropertyGetter());
2371 VisitDecl(S->getImplicitPropertySetter());
2373 VisitDecl(S->getExplicitProperty());
2375 if (S->isSuperReceiver()) {
2376 ID.AddBoolean(S->isSuperReceiver());
2377 VisitType(S->getSuperReceiverType());
2383 VisitDecl(S->getAtIndexMethodDecl());
2384 VisitDecl(S->setAtIndexMethodDecl());
2389 VisitName(S->getSelector());
2390 VisitDecl(S->getMethodDecl());
2393void StmtProfiler::VisitObjCIsaExpr(
const ObjCIsaExpr *S) {
2395 ID.AddBoolean(S->isArrow());
2400 ID.AddBoolean(S->getValue());
2403void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
2406 ID.AddBoolean(S->shouldCopy());
2410 VisitExplicitCastExpr(S);
2411 ID.AddBoolean(S->getBridgeKind());
2414void StmtProfiler::VisitObjCAvailabilityCheckExpr(
2421 ID.AddInteger(NumArgs);
2422 for (
unsigned I = 0; I != NumArgs; ++I)
2469 VisitTemplateArgument(
P);
2475class OpenACCClauseProfiler
2477 StmtProfiler &Profiler;
2480 OpenACCClauseProfiler(StmtProfiler &
P) : Profiler(
P) {}
2490#define VISIT_CLAUSE(CLAUSE_NAME) \
2491 void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause);
2493#include "clang/Basic/OpenACCClauses.def"
2497void OpenACCClauseProfiler::VisitDefaultClause(
2500void OpenACCClauseProfiler::VisitIfClause(
const OpenACCIfClause &Clause) {
2502 "if clause requires a valid condition expr");
2508 Profiler.VisitStmt(
E);
2510void OpenACCClauseProfiler::VisitCopyInClause(
2513 Profiler.VisitStmt(
E);
2516void OpenACCClauseProfiler::VisitCopyOutClause(
2519 Profiler.VisitStmt(
E);
2522void OpenACCClauseProfiler::VisitCreateClause(
2525 Profiler.VisitStmt(
E);
2533void OpenACCClauseProfiler::VisitNumGangsClause(
2536 Profiler.VisitStmt(
E);
2539void OpenACCClauseProfiler::VisitNumWorkersClause(
2541 assert(Clause.
hasIntExpr() &&
"num_workers clause requires a valid int expr");
2545void OpenACCClauseProfiler::VisitPrivateClause(
2548 Profiler.VisitStmt(
E);
2551void OpenACCClauseProfiler::VisitFirstPrivateClause(
2554 Profiler.VisitStmt(
E);
2557void OpenACCClauseProfiler::VisitAttachClause(
2560 Profiler.VisitStmt(
E);
2563void OpenACCClauseProfiler::VisitDevicePtrClause(
2566 Profiler.VisitStmt(
E);
2569void OpenACCClauseProfiler::VisitNoCreateClause(
2572 Profiler.VisitStmt(
E);
2575void OpenACCClauseProfiler::VisitPresentClause(
2578 Profiler.VisitStmt(
E);
2581void OpenACCClauseProfiler::VisitVectorLengthClause(
2584 "vector_length clause requires a valid int expr");
2597 Profiler.VisitStmt(
E);
2600void OpenACCClauseProfiler::VisitDeviceTypeClause(
2605void OpenACCClauseProfiler::VisitIndependentClause(
2608void OpenACCClauseProfiler::VisitSeqClause(
const OpenACCSeqClause &Clause) {}
2610void OpenACCClauseProfiler::VisitReductionClause(
2613 Profiler.VisitStmt(
E);
2617void StmtProfiler::VisitOpenACCComputeConstruct(
2622 OpenACCClauseProfiler
P{*
this};
2623 P.VisitOpenACCClauseList(S->clauses());
2630 OpenACCClauseProfiler
P{*
this};
2631 P.VisitOpenACCClauseList(S->clauses());
2635 bool Canonical,
bool ProfileLambdaExpr)
const {
2636 StmtProfilerWithPointers Profiler(ID, Context, Canonical, ProfileLambdaExpr);
2637 Profiler.Visit(
this);
2642 StmtProfilerWithoutPointers Profiler(ID, Hash);
2643 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.
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
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
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.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
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.
Represents a reference to #emded data.
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 function declaration or definition.
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 AddFunctionDecl(const FunctionDecl *Function, bool SkipBody=false)
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.
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.
Represents the '#pragma omp interchange' loop transformation directive.
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.
Represents the '#pragma omp reverse' loop transformation directive.
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.
void Visit(const OpenACCClause *C)
bool hasConditionExpr() const
const Expr * getConditionExpr() const
const Expr * getIntExpr() const
ArrayRef< Expr * > getVarList()
This is the base type for all OpenACC Clauses.
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
A 'default' clause, has the optional 'none' or 'present' argument.
A 'device_type' or 'dtype' clause, takes a list of either an 'asterisk' or an identifier.
An 'if' clause, which has a required condition expression.
This class represents a 'loop' construct.
llvm::ArrayRef< Expr * > getIntExprs()
A 'self' clause, which has an optional condition expression.
Expr * getDevNumExpr() const
llvm::ArrayRef< Expr * > getQueueIdExprs()
bool hasDevNumExpr() const
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.
ParenExpr - This represents a parenthesized 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.
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...
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
const FunctionProtoType * T
Data for list of allocators.