24 #include "llvm/ADT/FoldingSet.h"
25 using namespace clang;
30 llvm::FoldingSetNodeID &
ID;
34 StmtProfiler(llvm::FoldingSetNodeID &
ID,
bool Canonical)
35 : ID(ID), Canonical(Canonical) {}
37 virtual ~StmtProfiler() {}
39 void VisitStmt(
const Stmt *
S);
41 #define STMT(Node, Base) void Visit##Node(const Node *S);
42 #include "clang/AST/StmtNodes.inc"
46 virtual void VisitDecl(
const Decl *D) = 0;
50 virtual void VisitType(
QualType T) = 0;
75 class StmtProfilerWithPointers :
public StmtProfiler {
79 StmtProfilerWithPointers(llvm::FoldingSetNodeID &
ID,
81 : StmtProfiler(ID, Canonical), Context(Context) {}
83 void VisitDecl(
const Decl *D)
override {
88 dyn_cast<NonTypeTemplateParmDecl>(D)) {
89 ID.AddInteger(NTTP->getDepth());
90 ID.AddInteger(NTTP->getIndex());
91 ID.AddBoolean(NTTP->isParameterPack());
92 VisitType(NTTP->getType());
96 if (
const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(D)) {
104 VisitType(Parm->getType());
105 ID.AddInteger(Parm->getFunctionScopeDepth());
106 ID.AddInteger(Parm->getFunctionScopeIndex());
111 dyn_cast<TemplateTypeParmDecl>(D)) {
112 ID.AddInteger(TTP->getDepth());
113 ID.AddInteger(TTP->getIndex());
114 ID.AddBoolean(TTP->isParameterPack());
119 dyn_cast<TemplateTemplateParmDecl>(D)) {
120 ID.AddInteger(TTP->getDepth());
121 ID.AddInteger(TTP->getIndex());
122 ID.AddBoolean(TTP->isParameterPack());
130 void VisitType(
QualType T)
override {
131 if (Canonical && !T.
isNull())
159 class StmtProfilerWithoutPointers :
public StmtProfiler {
162 StmtProfilerWithoutPointers(llvm::FoldingSetNodeID &
ID,
ODRHash &Hash)
163 : StmtProfiler(ID,
false), Hash(Hash) {}
166 void VisitType(
QualType T)
override {
171 Hash.AddDeclarationName(Name);
176 Hash.AddIdentifierInfo(II);
179 void VisitDecl(
const Decl *D)
override {
186 Hash.AddTemplateName(Name);
191 Hash.AddNestedNameSpecifier(NNS);
197 void StmtProfiler::VisitStmt(
const Stmt *
S) {
198 assert(S &&
"Requires non-null Stmt pointer");
208 void StmtProfiler::VisitDeclStmt(
const DeclStmt *S) {
210 for (
const auto *D : S->
decls())
214 void StmtProfiler::VisitNullStmt(
const NullStmt *S) {
218 void StmtProfiler::VisitCompoundStmt(
const CompoundStmt *S) {
222 void StmtProfiler::VisitCaseStmt(
const CaseStmt *S) {
226 void StmtProfiler::VisitDefaultStmt(
const DefaultStmt *S) {
230 void StmtProfiler::VisitLabelStmt(
const LabelStmt *S) {
240 void StmtProfiler::VisitIfStmt(
const IfStmt *S) {
245 void StmtProfiler::VisitSwitchStmt(
const SwitchStmt *S) {
250 void StmtProfiler::VisitWhileStmt(
const WhileStmt *S) {
255 void StmtProfiler::VisitDoStmt(
const DoStmt *S) {
259 void StmtProfiler::VisitForStmt(
const ForStmt *S) {
263 void StmtProfiler::VisitGotoStmt(
const GotoStmt *S) {
272 void StmtProfiler::VisitContinueStmt(
const ContinueStmt *S) {
276 void StmtProfiler::VisitBreakStmt(
const BreakStmt *S) {
280 void StmtProfiler::VisitReturnStmt(
const ReturnStmt *S) {
284 void StmtProfiler::VisitGCCAsmStmt(
const GCCAsmStmt *S) {
304 void StmtProfiler::VisitMSAsmStmt(
const MSAsmStmt *S) {
309 void StmtProfiler::VisitCXXCatchStmt(
const CXXCatchStmt *S) {
314 void StmtProfiler::VisitCXXTryStmt(
const CXXTryStmt *S) {
329 void StmtProfiler::VisitSEHTryStmt(
const SEHTryStmt *S) {
337 void StmtProfiler::VisitSEHExceptStmt(
const SEHExceptStmt *S) {
341 void StmtProfiler::VisitSEHLeaveStmt(
const SEHLeaveStmt *S) {
345 void StmtProfiler::VisitCapturedStmt(
const CapturedStmt *S) {
364 void StmtProfiler::VisitObjCAtTryStmt(
const ObjCAtTryStmt *S) {
384 StmtProfiler *Profiler;
386 template <
typename T>
387 void VisitOMPClauseList(T *
Node);
390 OMPClauseProfiler(StmtProfiler *
P) : Profiler(P) { }
391 #define OPENMP_CLAUSE(Name, Class) \
392 void Visit##Class(const Class *C);
393 #include "clang/Basic/OpenMPKinds.def"
398 void OMPClauseProfiler::VistOMPClauseWithPreInit(
401 Profiler->VisitStmt(S);
404 void OMPClauseProfiler::VistOMPClauseWithPostUpdate(
406 VistOMPClauseWithPreInit(C);
408 Profiler->VisitStmt(
E);
411 void OMPClauseProfiler::VisitOMPIfClause(
const OMPIfClause *C) {
412 VistOMPClauseWithPreInit(C);
417 void OMPClauseProfiler::VisitOMPFinalClause(
const OMPFinalClause *C) {
423 VistOMPClauseWithPreInit(C);
443 void OMPClauseProfiler::VisitOMPDefaultClause(
const OMPDefaultClause *C) { }
448 VistOMPClauseWithPreInit(C);
450 Profiler->VisitStmt(S);
455 Profiler->VisitStmt(Num);
458 void OMPClauseProfiler::VisitOMPNowaitClause(
const OMPNowaitClause *) {}
460 void OMPClauseProfiler::VisitOMPUntiedClause(
const OMPUntiedClause *) {}
464 void OMPClauseProfiler::VisitOMPReadClause(
const OMPReadClause *) {}
466 void OMPClauseProfiler::VisitOMPWriteClause(
const OMPWriteClause *) {}
468 void OMPClauseProfiler::VisitOMPUpdateClause(
const OMPUpdateClause *) {}
472 void OMPClauseProfiler::VisitOMPSeqCstClause(
const OMPSeqCstClause *) {}
476 void OMPClauseProfiler::VisitOMPSIMDClause(
const OMPSIMDClause *) {}
481 void OMPClauseProfiler::VisitOMPClauseList(T *
Node) {
482 for (
auto *
E : Node->varlists()) {
484 Profiler->VisitStmt(
E);
489 VisitOMPClauseList(C);
492 Profiler->VisitStmt(
E);
497 VisitOMPClauseList(C);
498 VistOMPClauseWithPreInit(C);
501 Profiler->VisitStmt(
E);
503 for (
auto *
E : C->
inits()) {
505 Profiler->VisitStmt(
E);
510 VisitOMPClauseList(C);
511 VistOMPClauseWithPostUpdate(C);
514 Profiler->VisitStmt(
E);
518 Profiler->VisitStmt(
E);
522 Profiler->VisitStmt(
E);
525 void OMPClauseProfiler::VisitOMPSharedClause(
const OMPSharedClause *C) {
526 VisitOMPClauseList(C);
528 void OMPClauseProfiler::VisitOMPReductionClause(
530 Profiler->VisitNestedNameSpecifier(
533 VisitOMPClauseList(C);
534 VistOMPClauseWithPostUpdate(C);
537 Profiler->VisitStmt(
E);
541 Profiler->VisitStmt(
E);
545 Profiler->VisitStmt(
E);
549 Profiler->VisitStmt(
E);
552 void OMPClauseProfiler::VisitOMPTaskReductionClause(
554 Profiler->VisitNestedNameSpecifier(
557 VisitOMPClauseList(C);
558 VistOMPClauseWithPostUpdate(C);
561 Profiler->VisitStmt(
E);
565 Profiler->VisitStmt(
E);
569 Profiler->VisitStmt(
E);
573 Profiler->VisitStmt(
E);
576 void OMPClauseProfiler::VisitOMPLinearClause(
const OMPLinearClause *C) {
577 VisitOMPClauseList(C);
578 VistOMPClauseWithPostUpdate(C);
579 for (
auto *
E : C->privates()) {
581 Profiler->VisitStmt(
E);
583 for (
auto *
E : C->inits()) {
585 Profiler->VisitStmt(
E);
587 for (
auto *
E : C->updates()) {
589 Profiler->VisitStmt(
E);
591 for (
auto *
E : C->finals()) {
593 Profiler->VisitStmt(
E);
596 Profiler->VisitStmt(C->getStep());
597 if (C->getCalcStep())
598 Profiler->VisitStmt(C->getCalcStep());
601 VisitOMPClauseList(C);
605 void OMPClauseProfiler::VisitOMPCopyinClause(
const OMPCopyinClause *C) {
606 VisitOMPClauseList(C);
609 Profiler->VisitStmt(
E);
613 Profiler->VisitStmt(
E);
617 Profiler->VisitStmt(
E);
622 VisitOMPClauseList(C);
625 Profiler->VisitStmt(
E);
629 Profiler->VisitStmt(
E);
633 Profiler->VisitStmt(
E);
636 void OMPClauseProfiler::VisitOMPFlushClause(
const OMPFlushClause *C) {
637 VisitOMPClauseList(C);
639 void OMPClauseProfiler::VisitOMPDependClause(
const OMPDependClause *C) {
640 VisitOMPClauseList(C);
642 void OMPClauseProfiler::VisitOMPDeviceClause(
const OMPDeviceClause *C) {
646 void OMPClauseProfiler::VisitOMPMapClause(
const OMPMapClause *C) {
647 VisitOMPClauseList(C);
650 VistOMPClauseWithPreInit(C);
654 void OMPClauseProfiler::VisitOMPThreadLimitClause(
656 VistOMPClauseWithPreInit(C);
672 void OMPClauseProfiler::VisitOMPHintClause(
const OMPHintClause *C) {
674 Profiler->VisitStmt(C->
getHint());
676 void OMPClauseProfiler::VisitOMPToClause(
const OMPToClause *C) {
677 VisitOMPClauseList(C);
679 void OMPClauseProfiler::VisitOMPFromClause(
const OMPFromClause *C) {
680 VisitOMPClauseList(C);
682 void OMPClauseProfiler::VisitOMPUseDevicePtrClause(
684 VisitOMPClauseList(C);
686 void OMPClauseProfiler::VisitOMPIsDevicePtrClause(
688 VisitOMPClauseList(C);
695 OMPClauseProfiler
P(
this);
704 VisitOMPExecutableDirective(S);
708 VisitOMPExecutableDirective(S);
712 VisitOMPLoopDirective(S);
716 VisitOMPLoopDirective(S);
720 VisitOMPLoopDirective(S);
724 VisitOMPExecutableDirective(S);
728 VisitOMPExecutableDirective(S);
732 VisitOMPExecutableDirective(S);
736 VisitOMPExecutableDirective(S);
740 VisitOMPExecutableDirective(S);
746 VisitOMPLoopDirective(S);
749 void StmtProfiler::VisitOMPParallelForSimdDirective(
751 VisitOMPLoopDirective(S);
754 void StmtProfiler::VisitOMPParallelSectionsDirective(
756 VisitOMPExecutableDirective(S);
760 VisitOMPExecutableDirective(S);
764 VisitOMPExecutableDirective(S);
768 VisitOMPExecutableDirective(S);
772 VisitOMPExecutableDirective(S);
776 VisitOMPExecutableDirective(S);
780 VisitOMPExecutableDirective(S);
784 VisitOMPExecutableDirective(S);
788 VisitOMPExecutableDirective(S);
792 VisitOMPExecutableDirective(S);
796 VisitOMPExecutableDirective(S);
799 void StmtProfiler::VisitOMPTargetEnterDataDirective(
801 VisitOMPExecutableDirective(S);
804 void StmtProfiler::VisitOMPTargetExitDataDirective(
806 VisitOMPExecutableDirective(S);
809 void StmtProfiler::VisitOMPTargetParallelDirective(
811 VisitOMPExecutableDirective(S);
814 void StmtProfiler::VisitOMPTargetParallelForDirective(
816 VisitOMPExecutableDirective(S);
820 VisitOMPExecutableDirective(S);
823 void StmtProfiler::VisitOMPCancellationPointDirective(
825 VisitOMPExecutableDirective(S);
829 VisitOMPExecutableDirective(S);
833 VisitOMPLoopDirective(S);
836 void StmtProfiler::VisitOMPTaskLoopSimdDirective(
838 VisitOMPLoopDirective(S);
841 void StmtProfiler::VisitOMPDistributeDirective(
843 VisitOMPLoopDirective(S);
846 void OMPClauseProfiler::VisitOMPDistScheduleClause(
848 VistOMPClauseWithPreInit(C);
850 Profiler->VisitStmt(S);
855 void StmtProfiler::VisitOMPTargetUpdateDirective(
857 VisitOMPExecutableDirective(S);
860 void StmtProfiler::VisitOMPDistributeParallelForDirective(
862 VisitOMPLoopDirective(S);
865 void StmtProfiler::VisitOMPDistributeParallelForSimdDirective(
867 VisitOMPLoopDirective(S);
870 void StmtProfiler::VisitOMPDistributeSimdDirective(
872 VisitOMPLoopDirective(S);
875 void StmtProfiler::VisitOMPTargetParallelForSimdDirective(
877 VisitOMPLoopDirective(S);
880 void StmtProfiler::VisitOMPTargetSimdDirective(
882 VisitOMPLoopDirective(S);
885 void StmtProfiler::VisitOMPTeamsDistributeDirective(
887 VisitOMPLoopDirective(S);
890 void StmtProfiler::VisitOMPTeamsDistributeSimdDirective(
892 VisitOMPLoopDirective(S);
895 void StmtProfiler::VisitOMPTeamsDistributeParallelForSimdDirective(
897 VisitOMPLoopDirective(S);
900 void StmtProfiler::VisitOMPTeamsDistributeParallelForDirective(
902 VisitOMPLoopDirective(S);
905 void StmtProfiler::VisitOMPTargetTeamsDirective(
907 VisitOMPExecutableDirective(S);
910 void StmtProfiler::VisitOMPTargetTeamsDistributeDirective(
912 VisitOMPLoopDirective(S);
915 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForDirective(
917 VisitOMPLoopDirective(S);
920 void StmtProfiler::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
922 VisitOMPLoopDirective(S);
925 void StmtProfiler::VisitOMPTargetTeamsDistributeSimdDirective(
927 VisitOMPLoopDirective(S);
930 void StmtProfiler::VisitExpr(
const Expr *S) {
934 void StmtProfiler::VisitDeclRefExpr(
const DeclRefExpr *S) {
971 void StmtProfiler::VisitStringLiteral(
const StringLiteral *S) {
977 void StmtProfiler::VisitParenExpr(
const ParenExpr *S) {
981 void StmtProfiler::VisitParenListExpr(
const ParenListExpr *S) {
985 void StmtProfiler::VisitUnaryOperator(
const UnaryOperator *S) {
990 void StmtProfiler::VisitOffsetOfExpr(
const OffsetOfExpr *S) {
993 for (
unsigned i = 0; i < n; ++i) {
1034 void StmtProfiler::VisitCallExpr(
const CallExpr *S) {
1038 void StmtProfiler::VisitMemberExpr(
const MemberExpr *S) {
1051 void StmtProfiler::VisitCastExpr(
const CastExpr *S) {
1065 void StmtProfiler::VisitCStyleCastExpr(
const CStyleCastExpr *S) {
1066 VisitExplicitCastExpr(S);
1069 void StmtProfiler::VisitBinaryOperator(
const BinaryOperator *S) {
1076 VisitBinaryOperator(S);
1083 void StmtProfiler::VisitBinaryConditionalOperator(
1088 void StmtProfiler::VisitAddrLabelExpr(
const AddrLabelExpr *S) {
1093 void StmtProfiler::VisitStmtExpr(
const StmtExpr *S) {
1105 void StmtProfiler::VisitChooseExpr(
const ChooseExpr *S) {
1109 void StmtProfiler::VisitGNUNullExpr(
const GNUNullExpr *S) {
1113 void StmtProfiler::VisitVAArgExpr(
const VAArgExpr *S) {
1117 void StmtProfiler::VisitInitListExpr(
const InitListExpr *S) {
1130 if (D.isFieldDesignator()) {
1132 VisitName(D.getFieldName());
1136 if (D.isArrayDesignator()) {
1139 assert(D.isArrayRangeDesignator());
1142 ID.AddInteger(D.getFirstExprIndex());
1148 void StmtProfiler::VisitDesignatedInitUpdateExpr(
1150 llvm_unreachable(
"Unexpected DesignatedInitUpdateExpr in syntactic form of "
1162 void StmtProfiler::VisitNoInitExpr(
const NoInitExpr *S) {
1163 llvm_unreachable(
"Unexpected NoInitExpr in syntactic form of initializer");
1175 void StmtProfiler::VisitBlockExpr(
const BlockExpr *S) {
1185 ID.AddPointer(
nullptr);
1198 Visit(OVE->getSourceExpr());
1201 void StmtProfiler::VisitAtomicExpr(
const AtomicExpr *S) {
1214 case OO_Array_Delete:
1217 case OO_Conditional:
1220 llvm_unreachable(
"Invalid operator call kind");
1225 return Stmt::UnaryOperatorClass;
1229 return Stmt::BinaryOperatorClass;
1234 return Stmt::UnaryOperatorClass;
1238 return Stmt::BinaryOperatorClass;
1243 return Stmt::UnaryOperatorClass;
1247 return Stmt::BinaryOperatorClass;
1251 return Stmt::BinaryOperatorClass;
1255 return Stmt::BinaryOperatorClass;
1259 return Stmt::BinaryOperatorClass;
1263 UnaryOp = UO_AddrOf;
1264 return Stmt::UnaryOperatorClass;
1268 return Stmt::BinaryOperatorClass;
1272 return Stmt::BinaryOperatorClass;
1276 return Stmt::UnaryOperatorClass;
1280 return Stmt::UnaryOperatorClass;
1283 BinaryOp = BO_Assign;
1284 return Stmt::BinaryOperatorClass;
1288 return Stmt::BinaryOperatorClass;
1292 return Stmt::BinaryOperatorClass;
1295 BinaryOp = BO_AddAssign;
1296 return Stmt::CompoundAssignOperatorClass;
1299 BinaryOp = BO_SubAssign;
1300 return Stmt::CompoundAssignOperatorClass;
1303 BinaryOp = BO_MulAssign;
1304 return Stmt::CompoundAssignOperatorClass;
1307 BinaryOp = BO_DivAssign;
1308 return Stmt::CompoundAssignOperatorClass;
1310 case OO_PercentEqual:
1311 BinaryOp = BO_RemAssign;
1312 return Stmt::CompoundAssignOperatorClass;
1315 BinaryOp = BO_XorAssign;
1316 return Stmt::CompoundAssignOperatorClass;
1319 BinaryOp = BO_AndAssign;
1320 return Stmt::CompoundAssignOperatorClass;
1323 BinaryOp = BO_OrAssign;
1324 return Stmt::CompoundAssignOperatorClass;
1328 return Stmt::BinaryOperatorClass;
1330 case OO_GreaterGreater:
1332 return Stmt::BinaryOperatorClass;
1334 case OO_LessLessEqual:
1335 BinaryOp = BO_ShlAssign;
1336 return Stmt::CompoundAssignOperatorClass;
1338 case OO_GreaterGreaterEqual:
1339 BinaryOp = BO_ShrAssign;
1340 return Stmt::CompoundAssignOperatorClass;
1344 return Stmt::BinaryOperatorClass;
1346 case OO_ExclaimEqual:
1348 return Stmt::BinaryOperatorClass;
1352 return Stmt::BinaryOperatorClass;
1354 case OO_GreaterEqual:
1356 return Stmt::BinaryOperatorClass;
1360 return Stmt::BinaryOperatorClass;
1364 return Stmt::BinaryOperatorClass;
1369 return Stmt::UnaryOperatorClass;
1374 return Stmt::UnaryOperatorClass;
1377 BinaryOp = BO_Comma;
1378 return Stmt::BinaryOperatorClass;
1381 BinaryOp = BO_PtrMemI;
1382 return Stmt::BinaryOperatorClass;
1385 return Stmt::ArraySubscriptExprClass;
1388 llvm_unreachable(
"Invalid overloaded operator expression");
1391 #if defined(_MSC_VER)
1392 #if _MSC_VER == 1911
1396 #pragma optimize("", off)
1408 return Visit(S->
getArg(0));
1417 if (SC == Stmt::UnaryOperatorClass)
1418 ID.AddInteger(UnaryOp);
1419 else if (SC == Stmt::BinaryOperatorClass ||
1420 SC == Stmt::CompoundAssignOperatorClass)
1421 ID.AddInteger(BinaryOp);
1423 assert(SC == Stmt::ArraySubscriptExprClass);
1432 #if defined(_MSC_VER)
1433 #if _MSC_VER == 1911
1434 #pragma optimize("", on)
1446 void StmtProfiler::VisitAsTypeExpr(
const AsTypeExpr *S) {
1451 VisitExplicitCastExpr(S);
1455 VisitCXXNamedCastExpr(S);
1459 VisitCXXNamedCastExpr(S);
1464 VisitCXXNamedCastExpr(S);
1468 VisitCXXNamedCastExpr(S);
1484 void StmtProfiler::VisitCXXStdInitializerListExpr(
1489 void StmtProfiler::VisitCXXTypeidExpr(
const CXXTypeidExpr *S) {
1495 void StmtProfiler::VisitCXXUuidofExpr(
const CXXUuidofExpr *S) {
1506 void StmtProfiler::VisitMSPropertySubscriptExpr(
1511 void StmtProfiler::VisitCXXThisExpr(
const CXXThisExpr *S) {
1516 void StmtProfiler::VisitCXXThrowExpr(
const CXXThrowExpr *S) {
1542 void StmtProfiler::VisitCXXInheritedCtorInitExpr(
1549 VisitExplicitCastExpr(S);
1554 VisitCXXConstructExpr(S);
1558 StmtProfiler::VisitLambdaExpr(
const LambdaExpr *S) {
1563 ID.AddInteger(C->getCaptureKind());
1564 switch (C->getCaptureKind()) {
1570 VisitDecl(C->getCapturedVar());
1571 ID.AddBoolean(C->isPackExpansion());
1574 llvm_unreachable(
"VLA type in explicit captures.");
1588 void StmtProfiler::VisitCXXDeleteExpr(
const CXXDeleteExpr *S) {
1595 void StmtProfiler::VisitCXXNewExpr(
const CXXNewExpr *S) {
1622 void StmtProfiler::VisitOverloadExpr(
const OverloadExpr *S) {
1633 VisitOverloadExpr(S);
1636 void StmtProfiler::VisitTypeTraitExpr(
const TypeTraitExpr *S) {
1656 void StmtProfiler::VisitDependentScopeDeclRefExpr(
1670 void StmtProfiler::VisitCXXUnresolvedConstructExpr(
1676 void StmtProfiler::VisitCXXDependentScopeMemberExpr(
1711 void StmtProfiler::VisitSizeOfPackExpr(
const SizeOfPackExpr *S) {
1716 ID.AddInteger(Args.size());
1717 for (
const auto &TA : Args)
1718 VisitTemplateArgument(TA);
1724 void StmtProfiler::VisitSubstNonTypeTemplateParmPackExpr(
1731 void StmtProfiler::VisitSubstNonTypeTemplateParmExpr(
1745 void StmtProfiler::VisitMaterializeTemporaryExpr(
1750 void StmtProfiler::VisitCXXFoldExpr(
const CXXFoldExpr *S) {
1759 void StmtProfiler::VisitCoreturnStmt(
const CoreturnStmt *S) {
1763 void StmtProfiler::VisitCoawaitExpr(
const CoawaitExpr *S) {
1771 void StmtProfiler::VisitCoyieldExpr(
const CoyieldExpr *S) {
1779 void StmtProfiler::VisitTypoExpr(
const TypoExpr *E) {
1787 void StmtProfiler::VisitObjCBoxedExpr(
const ObjCBoxedExpr *E) {
1799 void StmtProfiler::VisitObjCEncodeExpr(
const ObjCEncodeExpr *S) {
1847 void StmtProfiler::VisitObjCIsaExpr(
const ObjCIsaExpr *S) {
1857 void StmtProfiler::VisitObjCIndirectCopyRestoreExpr(
1864 VisitExplicitCastExpr(S);
1868 void StmtProfiler::VisitObjCAvailabilityCheckExpr(
1875 ID.AddInteger(NumArgs);
1876 for (
unsigned I = 0;
I != NumArgs; ++
I)
1877 VisitTemplateArgument(Args[
I].getArgument());
1915 VisitTemplateArgument(
P);
1921 bool Canonical)
const {
1922 StmtProfilerWithPointers Profiler(ID, Context, Canonical);
1923 Profiler.Visit(
this);
1928 StmtProfilerWithoutPointers Profiler(ID, Hash);
1929 Profiler.Visit(
this);
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
A call to an overloaded operator written using operator syntax.
Represents a single C99 designator.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Defines the clang::ASTContext interface.
This represents '#pragma omp distribute simd' composite directive.
This represents '#pragma omp master' directive.
DeclarationName getMember() const
Retrieve the name of the member that this expression refers to.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
ParmVarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
StmtClass getStmtClass() const
The null pointer literal (C++11 [lex.nullptr])
This represents '#pragma omp task' directive.
This represents a GCC inline-assembly statement extension.
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
Represents a 'co_await' expression while the type of the promise is dependent.
TypeSourceInfo * getDestroyedTypeInfo() const
Retrieve the source location information for the type being destroyed.
unsigned getNumOutputs() const
This represents 'thread_limit' clause in the '#pragma omp ...' directive.
This represents clause 'copyin' in the '#pragma omp ...' directives.
A (possibly-)qualified type.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
helper_expr_const_range source_exprs() const
ArrayRef< OMPClause * > clauses()
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
NestedNameSpecifier * getCanonicalNestedNameSpecifier(NestedNameSpecifier *NNS) const
Retrieves the "canonical" nested name specifier for a given nested name specifier.
bool isElidable() const
Whether this construction is elidable.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
This file contains the declaration of the ODRHash class, which calculates a hash based on AST nodes...
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Expr * getSimdlen() const
Return safe iteration space distance.
private_copies_range private_copies()
CharacterKind getKind() const
Represents a 'co_return' statement in the C++ Coroutines TS.
Stmt - This represents one statement.
TypeSourceInfo * getScopeTypeInfo() const
Retrieve the scope type in a qualified pseudo-destructor expression.
void AddQualType(QualType T)
bool isArgumentType() const
IfStmt - This represents an if/then/else.
Class that handles pre-initialization statement for some clauses, like 'shedule', 'firstprivate' etc...
bool isGlobalDelete() const
This represents '#pragma omp for simd' directive.
The template argument is an expression, and we've not resolved it to one of the other forms yet...
TypeSourceInfo * getTypeSourceInfo() const
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Decl - This represents one declaration (or definition), e.g.
This represents 'grainsize' clause in the '#pragma omp ...' directive.
ObjCMethodDecl * getAtIndexMethodDecl() const
This represents '#pragma omp teams distribute parallel for' composite directive.
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
helper_expr_const_range lhs_exprs() const
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
This represents 'if' clause in the '#pragma omp ...' directive.
Defines the C++ template declaration subclasses.
Represents an attribute applied to a statement.
TypeSourceInfo * getArg(unsigned I) const
Retrieve the Ith argument.
ParenExpr - This represents a parethesized expression, e.g.
This represents 'priority' clause in the '#pragma omp ...' directive.
This represents '#pragma omp target teams distribute' combined directive.
Represents Objective-C's @throw statement.
InitListExpr * getSyntacticForm() const
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Represents a call to a C++ constructor.
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
This represents 'update' clause in the '#pragma omp atomic' directive.
This represents '#pragma omp parallel for' directive.
MS property subscript expression.
Expr * getAsExpr() const
Retrieve the template argument as an expression.
This represents '#pragma omp target teams distribute parallel for' combined directive.
Describes the capture of a variable or of this, or of a C++1y init-capture.
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
unsigned getNumTemplateArgs() const
Expr * getAlignment()
Returns alignment.
IdentType getIdentType() const
void * getAsOpaquePtr() const
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
This represents '#pragma omp target exit data' directive.
This represents 'read' clause in the '#pragma omp atomic' directive.
ArrayRef< TemplateArgument > getPartialArguments() const
Get.
This represents clause 'private' in the '#pragma omp ...' directives.
const Expr * getPostUpdateExpr() const
Get post-update expression for the clause.
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
CompoundLiteralExpr - [C99 6.5.2.5].
This represents 'num_threads' clause in the '#pragma omp ...' directive.
Represents an empty template argument, e.g., one that has not been deduced.
This represents 'defaultmap' clause in the '#pragma omp ...' directive.
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
UnaryExprOrTypeTrait getKind() const
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
const ParmVarDecl * getParam() const
unsigned getValue() const
A C++ throw-expression (C++ [except.throw]).
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Expr * getNumForLoops() const
Return the number of associated for-loops.
ParmVarDecl - Represents a parameter to a function.
Defines the clang::Expr interface and subclasses for C++ expressions.
ArrayTypeTrait getTrait() const
This represents 'nogroup' clause in the '#pragma omp ...' directive.
This represents 'safelen' clause in the '#pragma omp ...' directive.
A C++ static_cast expression (C++ [expr.static.cast]).
LabelStmt - Represents a label, which has a substatement.
Represents a C99 designated initializer expression.
Expr * getNumThreads() const
Returns number of threads.
DeclarationName getMemberName() const
Retrieve the name of the member that this expression refers to.
DeclarationName getName() const
getName - Returns the embedded declaration name.
One of these records is kept for each identifier that is lexed.
ObjCProtocolDecl * getProtocol() const
This represents '#pragma omp parallel' directive.
unsigned getNumInputs() const
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
This represents 'simd' clause in the '#pragma omp ...' directive.
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
unsigned getNumAssocs() const
This represents clause 'lastprivate' in the '#pragma omp ...' directives.
Represents a place-holder for an object not to be initialized by anything.
Expr * getChunkSize()
Get chunk size.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
This represents clause 'map' in the '#pragma omp ...' directives.
This represents clause 'to' in the '#pragma omp ...' directives.
This represents '#pragma omp target simd' directive.
DeclarationNameInfo getNameInfo() const
Retrieve the name of the entity we're testing for, along with location information.
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
IdentifierInfo & getAccessor() const
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
QualType getQueriedType() const
This represents '#pragma omp barrier' directive.
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc...
Expr * getNumTeams()
Return NumTeams number.
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
This represents '#pragma omp critical' directive.
bool shouldCopy() const
shouldCopy - True if we should do the 'copy' part of the copy-restore.
const Expr *const * const_semantics_iterator
const VarDecl * getCatchParamDecl() const
Represents Objective-C's @catch statement.
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
IndirectGotoStmt - This represents an indirect goto.
Describes an C or C++ initializer list.
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
This represents '#pragma omp distribute parallel for' composite directive.
This represents '#pragma omp teams distribute parallel for simd' composite directive.
ForStmt - This represents a 'for (init;cond;inc)' stmt.
ObjCBridgeCastKind getBridgeKind() const
Determine which kind of bridge is being performed via this cast.
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
< Capturing the *this object by copy
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
bool isSuperReceiver() const
helper_expr_const_range source_exprs() const
semantics_iterator semantics_end()
static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S, UnaryOperatorKind &UnaryOp, BinaryOperatorKind &BinaryOp)
A builtin binary operation expression such as "x + y" or "x <= y".
Selector getSelector() const
InitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Class that handles post-update expression for some clauses, like 'lastprivate', 'reduction' etc...
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies this declaration.
This represents '#pragma omp cancellation point' directive.
This represents 'default' clause in the '#pragma omp ...' directive.
ObjCStringLiteral, used for Objective-C string literals i.e.
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
This represents 'final' clause in the '#pragma omp ...' directive.
This represents 'mergeable' clause in the '#pragma omp ...' directive.
This represents '#pragma omp teams' directive.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
This represents clause 'reduction' in the '#pragma omp ...' directives.
FieldDecl * getField()
Get the field whose initializer will be used.
Helper class for OffsetOfExpr.
This represents '#pragma omp teams distribute simd' combined directive.
Represents binding an expression to a temporary.
StringLiteral * getClobberStringLiteral(unsigned i)
CompoundStmt * getBody() const
Retrieve the body of the lambda.
CXXTemporary * getTemporary()
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Represents a C++ member access expression where the actual member referenced could not be resolved be...
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise, it used a '.
Expr * getHint() const
Returns number of threads.
ObjCMethodDecl * setAtIndexMethodDecl() const
detail::InMemoryDirectory::const_iterator I
A default argument (C++ [dcl.fct.default]).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
ExpressionTrait getTrait() const
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
This represents clause 'from' in the '#pragma omp ...' directives.
Represents the this expression in C++.
MSPropertyDecl * getPropertyDecl() const
QualType getTypeAsWritten() const
Retrieve the type that is being constructed, as specified in the source code.
This represents '#pragma omp target parallel for simd' directive.
OpenMP 4.0 [2.4, Array Sections].
FunctionDecl * getOperatorDelete() const
ConditionalOperator - The ?: ternary operator.
llvm::APInt getValue() const
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
CompoundStmt - This represents a group of statements like { stmt stmt }.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the member name.
This represents 'threads' clause in the '#pragma omp ...' directive.
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
This represents '#pragma omp taskgroup' directive.
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
This represents clause 'aligned' in the '#pragma omp ...' directives.
Expr * getQueriedExpression() const
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
This represents clause 'task_reduction' in the '#pragma omp taskgroup' directives.
Represents a call to the builtin function __builtin_va_arg.
FunctionDecl * getOperatorDelete() const
This represents '#pragma omp distribute' directive.
This represents implicit clause 'depend' for the '#pragma omp task' directive.
const ObjCMethodDecl * getMethodDecl() const
LabelDecl * getDecl() const
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
llvm::MutableArrayRef< Designator > designators()
This represents 'proc_bind' clause in the '#pragma omp ...' directive.
This represents 'capture' clause in the '#pragma omp atomic' directive.
Expr - This represents one expression.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
helper_expr_const_range assignment_ops() const
This represents 'simdlen' clause in the '#pragma omp ...' directive.
Declaration of a template type parameter.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
Expr * getCondition() const
Returns condition.
Represents a C++ functional cast expression that builds a temporary object.
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
A C++ const_cast expression (C++ [expr.const.cast]).
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
helper_expr_const_range reduction_ops() const
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
bool hasExplicitTemplateArgs() const
Determines whether this member expression actually had a C++ template argument list explicitly specif...
ObjCMethodDecl * getImplicitPropertyGetter() const
ArgKind getKind() const
Return the kind of stored template argument.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Represents Objective-C's @synchronized statement.
ObjCSelectorExpr used for @selector in Objective-C.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Represents an expression that computes the length of a parameter pack.
CXXTryStmt - A C++ try block, including all handlers.
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
Represents a C++ template name within the type system.
This represents '#pragma omp target teams distribute simd' combined directive.
This represents 'ordered' clause in the '#pragma omp ...' directive.
Selector getSelector() const
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
QualType getAllocatedType() const
StringRef getInputName(unsigned i) const
This represents '#pragma omp for' directive.
helper_expr_const_range rhs_exprs() const
Represents a folding of a pack over an operator.
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
This represents '#pragma omp target teams' directive.
An expression that sends a message to the given Objective-C object or class.
unsigned getNumComponents() const
This represents a Microsoft inline-assembly statement extension.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
A member reference to an MSPropertyDecl.
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Expr * getDevice()
Return device number.
This represents '#pragma omp cancel' directive.
This represents 'collapse' clause in the '#pragma omp ...' directive.
This represents clause 'firstprivate' in the '#pragma omp ...' directives.
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
helper_expr_const_range privates() const
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
This represents '#pragma omp flush' directive.
helper_expr_const_range destination_exprs() const
This represents '#pragma omp parallel for simd' directive.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
DoStmt - This represents a 'do/while' stmt.
This represents 'seq_cst' clause in the '#pragma omp atomic' directive.
This represents 'untied' clause in the '#pragma omp ...' directive.
LabelDecl * getLabel() const
unsigned getNumTemplateArgs() const
helper_expr_const_range privates() const
This represents '#pragma omp target enter data' directive.
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
This represents 'num_teams' clause in the '#pragma omp ...' directive.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
const StringLiteral * getAsmString() const
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
A field in a dependent type, known only by its name.
This captures a statement into a function.
Represents a call to an inherited base class constructor from an inheriting constructor.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Expr * getNumForLoops() const
Return the number of associated for-loops.
This represents '#pragma omp single' directive.
This represents 'hint' clause in the '#pragma omp ...' directive.
TemplateArgumentLoc const * getTemplateArgs() const
helper_expr_const_range reduction_ops() const
This is a basic class for representing single OpenMP executable directive.
private_copies_range private_copies()
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies this name, if any.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Expr * getCondition() const
Returns condition.
helper_expr_const_range lhs_exprs() const
This represents 'schedule' clause in the '#pragma omp ...' directive.
Represents a call to a member function that may be written either with member call syntax (e...
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
This represents clause 'shared' in the '#pragma omp ...' directives.
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
Expr * getPriority()
Return Priority number.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
This represents '#pragma omp taskwait' directive.
bool isImplicitAccess() const
True if this is an implicit access, i.e.
NamedDecl * getPack() const
Retrieve the parameter pack.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>.
void Profile(llvm::FoldingSetNodeID &ID)
ObjCProtocolExpr used for protocol expression in Objective-C.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
capture_iterator explicit_capture_end() const
Retrieve an iterator pointing past the end of the sequence of explicit lambda captures.
QualType getAssocType(unsigned i) const
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
This represents '#pragma omp target' directive.
TypeTrait getTrait() const
Determine which type trait this expression uses.
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
const T * castAs() const
Member-template castAs<specific type>.
StringRef getOutputName(unsigned i) const
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
An expression trait intrinsic.
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
This represents '#pragma omp ordered' directive.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
This represents '#pragma omp target update' directive.
ObjCBoxedExpr - used for generalized expression boxing.
Expr * getGrainsize() const
Return safe iteration space distance.
const BlockDecl * getBlockDecl() const
bool isParenTypeId() const
QualType getType() const
Return the type wrapped by this type source info.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name...
const OffsetOfNode & getComponent(unsigned Idx) const
A qualified reference to a name whose declaration cannot yet be resolved.
CompoundAssignOperator - For compound assignments (e.g.
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Represents a C11 generic selection.
DeclarationName getDeclName() const
Retrieve the name that this expression refers to.
AddrLabelExpr - The GNU address of label extension, representing &&label.
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
ast_type_traits::DynTypedNode Node
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Represents a template argument.
Expr * getReplacement() const
QualType getAsType() const
Retrieve the type for a type template argument.
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
NullStmt - This is the null statement ";": C99 6.8.3p3.
bool isImplicitProperty() const
This represents 'device' clause in the '#pragma omp ...' directive.
const Expr * getAssocExpr(unsigned i) const
helper_expr_const_range rhs_exprs() const
[C99 6.4.2.2] - A predefined identifier such as func.
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
TemplateArgumentLoc const * getTemplateArgs() const
The template argument is a pack expansion of a template name that was provided for a template templat...
TemplateName getCanonicalTemplateName(TemplateName Name) const
Retrieves the "canonical" template name that refers to a given template.
This represents '#pragma omp section' directive.
This represents '#pragma omp teams distribute' directive.
A runtime availability query.
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
This represents '#pragma omp simd' directive.
Represents a 'co_yield' expression.
DeclarationName - The name of a declaration.
Expr * getNumTasks() const
Return safe iteration space distance.
const StringLiteral * getOutputConstraintLiteral(unsigned i) const
Represents a C++11 pack expansion that produces a sequence of expressions.
QualType getCaughtType() const
unsigned getNumPlacementArgs() const
StringRef getBytes() const
Allow access to clients that need the byte representation, such as ASTWriterStmt::VisitStringLiteral(...
This represents clause 'linear' in the '#pragma omp ...' directives.
DeclarationNameInfo getDirectiveName() const
Return name of the directive.
StringKind getKind() const
bool isTypeOperand() const
detail::InMemoryDirectory::const_iterator E
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
semantics_iterator semantics_begin()
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
ExplicitCastExpr - An explicit cast written in the source code.
This represents '#pragma omp atomic' directive.
llvm::APFloat getValue() const
Represents a __leave statement.
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
SwitchStmt - This represents a 'switch' stmt.
Capturing variable-length array type.
Not an overloaded operator.
void * getAsOpaquePtr() const
getAsOpaquePtr - Get the representation of this declaration name as an opaque pointer.
Expr * getSafelen() const
Return safe iteration space distance.
Represents the body of a coroutine.
Location wrapper for a TemplateArgument.
FunctionDecl * getOperatorNew() const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
capture_iterator explicit_capture_begin() const
Retrieve an iterator pointing to the first explicit lambda capture.
Represents Objective-C's collection statement.
ObjCEncodeExpr, used for @encode in Objective-C.
An implicit indirection through a C++ base class, when the field found is in a base class...
QualType getIntegralType() const
Retrieve the type of the integral value.
Represents a call to a CUDA kernel function.
Represents a 'co_await' expression.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Represents Objective-C's @finally statement.
The template argument is a type.
QualType getSuperReceiverType() const
The template argument is actually a parameter pack.
LabelDecl * getLabel() const
Capturing the *this object by reference.
This represents 'write' clause in the '#pragma omp atomic' directive.
ObjCPropertyDecl * getExplicitProperty() const
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
GotoStmt - This represents a direct goto.
A use of a default initializer in a constructor or in aggregate initialization.
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
helper_expr_const_range destination_exprs() const
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
const StringLiteral * getInputConstraintLiteral(unsigned i) const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
This represents '#pragma omp target parallel' directive.
This represents 'nowait' clause in the '#pragma omp ...' directive.
ContinueStmt - This represents a continue.
Represents a loop initializing the elements of an array.
This represents 'num_tasks' clause in the '#pragma omp ...' directive.
The template argument is a template name that was provided for a template template parameter...
QualType getEncodedType() const
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
CXXCatchStmt - This represents a C++ catch block.
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
WhileStmt - This represents a 'while' stmt.
FieldDecl * getField() const
For a field offsetof node, returns the field.
helper_expr_const_range assignment_ops() const
Expr * getThreadLimit()
Return ThreadLimit number.
This class is used for builtin types like 'int'.
Represents Objective-C's @try ... @catch ... @finally statement.
This represents '#pragma omp taskloop simd' directive.
StringLiteral - This represents a string literal expression, e.g.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
DeclarationName getName() const
Gets the name looked up.
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
bool isIfExists() const
Determine whether this is an __if_exists statement.
static Decl::Kind getKind(const Decl *D)
Abstract class common to all of the C++ "named"/"keyword" casts.
This represents '#pragma omp sections' directive.
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
This represents '#pragma omp target data' directive.
A reference to a declared variable, function, enum, etc.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
BreakStmt - This represents a break.
Expr * getChunkSize()
Get chunk size.
const Stmt * getPreInitStmt() const
Get pre-initialization statement for the clause.
BinaryOperatorKind getOperator() const
unsigned getNumClobbers() const
helper_expr_const_range destination_exprs() const
This represents '#pragma omp taskyield' directive.
This represents '#pragma omp distribute parallel for simd' composite directive.
A boolean literal, per ([C++ lex.bool] Boolean literals).
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
QualType getDestroyedType() const
Retrieve the type being destroyed.
This represents '#pragma omp parallel sections' directive.
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
bool isNull() const
Return true if this QualType doesn't point to a type yet.
bool isTypeOperand() const
Represents Objective-C's @autoreleasepool Statement.
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
const CXXDestructorDecl * getDestructor() const
Represents an implicitly-generated value initialization of an object of a given type.
ObjCMethodDecl * getImplicitPropertySetter() const
This represents '#pragma omp target parallel for' directive.
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
Kind getKind() const
Determine what kind of offsetof node this is.
helper_expr_const_range assignment_ops() const
void ProcessODRHash(llvm::FoldingSetNodeID &ID, ODRHash &Hash) const
Calculate a unique representation for a statement that is stable across compiler invocations.
helper_expr_const_range source_exprs() const
QualType getArgumentType() const
This represents '#pragma omp taskloop' directive.