23#include "llvm/Bitstream/BitstreamWriter.h"
54 class PakedBitsWriter {
57 ~PakedBitsWriter() { assert(!CurrentIndex); }
59 void addBit(
bool Value) {
60 assert(CurrentIndex &&
"Writing Bits without recording first!");
63 void addBits(uint32_t
Value, uint32_t BitsWidth) {
64 assert(CurrentIndex &&
"Writing Bits without recording first!");
72 RecordRef[*CurrentIndex] = (uint32_t)PackingBits;
73 CurrentIndex = std::nullopt;
80 CurrentIndex = RecordRef.
size();
87 std::optional<unsigned> CurrentIndex;
90 PakedBitsWriter CurrentPackingBits;
95 : Writer(Writer), Record(Context, Writer, Record),
97 CurrentPackingBits(this->Record) {}
103 CurrentPackingBits.writeBits();
105 "unhandled sub-statement writing AST file");
106 return Record.EmitStmt(Code, AbbrevToUse);
113#define STMT(Type, Base) \
114 void Visit##Type(Type *);
115#include "clang/AST/StmtNodes.inc"
122 Record.AddSourceLocation(ArgInfo.
LAngleLoc);
123 Record.AddSourceLocation(ArgInfo.
RAngleLoc);
125 Record.AddTemplateArgumentLoc(Args[i]);
131void ASTStmtWriter::VisitNullStmt(
NullStmt *S) {
144 for (
auto *CS : S->
body())
157void ASTStmtWriter::VisitSwitchCase(
SwitchCase *S) {
159 Record.push_back(Writer.getSwitchCaseID(S));
164void ASTStmtWriter::VisitCaseStmt(
CaseStmt *S) {
167 Record.AddStmt(S->
getLHS());
170 Record.AddStmt(S->
getRHS());
176void ASTStmtWriter::VisitDefaultStmt(
DefaultStmt *S) {
182void ASTStmtWriter::VisitLabelStmt(
LabelStmt *S) {
185 Record.AddDeclRef(S->
getDecl());
193 Record.push_back(S->
getAttrs().size());
194 Record.AddAttributes(S->
getAttrs());
200void ASTStmtWriter::VisitIfStmt(
IfStmt *S) {
203 bool HasElse = S->
getElse() !=
nullptr;
205 bool HasInit = S->
getInit() !=
nullptr;
207 CurrentPackingBits.updateBits();
209 CurrentPackingBits.addBit(HasElse);
210 CurrentPackingBits.addBit(HasVar);
211 CurrentPackingBits.addBit(HasInit);
222 Record.AddSourceLocation(S->
getIfLoc());
231void ASTStmtWriter::VisitSwitchStmt(
SwitchStmt *S) {
234 bool HasInit = S->
getInit() !=
nullptr;
236 Record.push_back(HasInit);
237 Record.push_back(HasVar);
253 Record.push_back(Writer.RecordSwitchCaseID(SC));
257void ASTStmtWriter::VisitWhileStmt(
WhileStmt *S) {
261 Record.push_back(HasVar);
274void ASTStmtWriter::VisitDoStmt(
DoStmt *S) {
278 Record.AddSourceLocation(S->
getDoLoc());
284void ASTStmtWriter::VisitForStmt(
ForStmt *S) {
289 Record.AddStmt(S->
getInc());
291 Record.AddSourceLocation(S->
getForLoc());
297void ASTStmtWriter::VisitGotoStmt(
GotoStmt *S) {
315 Record.AddSourceLocation(S->
getKwLoc());
324 VisitLoopControlStmt(S);
328void ASTStmtWriter::VisitBreakStmt(
BreakStmt *S) {
329 VisitLoopControlStmt(S);
333void ASTStmtWriter::VisitReturnStmt(
ReturnStmt *S) {
337 Record.push_back(HasNRVOCandidate);
340 if (HasNRVOCandidate)
347void ASTStmtWriter::VisitDeclStmt(
DeclStmt *S) {
350 Record.AddSourceLocation(S->
getEndLoc());
353 Record.AddDeclRef(*D);
357void ASTStmtWriter::VisitAsmStmt(
AsmStmt *S) {
362 Record.AddSourceLocation(S->
getAsmLoc());
367void ASTStmtWriter::VisitGCCAsmStmt(
GCCAsmStmt *S) {
381 for (
unsigned I = 0, N = S->
getNumInputs(); I != N; ++I) {
392 for (
unsigned I = 0, N = S->
getNumLabels(); I != N; ++I) {
400void ASTStmtWriter::VisitMSAsmStmt(
MSAsmStmt *S) {
403 Record.AddSourceLocation(S->
getEndLoc());
410 Writer.AddToken(S->
getAsmToks()[I], Record.getRecordData());
425 for (
unsigned I = 0, N = S->
getNumInputs(); I != N; ++I) {
436 for (Stmt *S : CoroStmt->
children())
458void ASTStmtWriter::VisitCoawaitExpr(
CoawaitExpr *E) {
459 VisitCoroutineSuspendExpr(E);
464void ASTStmtWriter::VisitCoyieldExpr(
CoyieldExpr *E) {
465 VisitCoroutineSuspendExpr(E);
484 for (
const auto &DetailRecord : Satisfaction) {
485 if (
auto *
Diag = dyn_cast<const ConstraintSubstitutionDiagnostic *>(
492 if (
auto *E = dyn_cast<const Expr *>(DetailRecord)) {
498 Record.AddConceptReference(CR);
513void ASTStmtWriter::VisitConceptSpecializationExpr(
518 Record.push_back(CR !=
nullptr);
520 Record.AddConceptReference(CR);
533 Record.AddDeclRef(E->
getBody());
535 Record.AddDeclRef(
P);
537 if (
auto *TypeReq = dyn_cast<concepts::TypeRequirement>(R)) {
539 Record.push_back(TypeReq->Status);
543 Record.AddTypeSourceInfo(TypeReq->getType());
544 }
else if (
auto *ExprReq = dyn_cast<concepts::ExprRequirement>(R)) {
545 Record.push_back(ExprReq->getKind());
546 Record.push_back(ExprReq->Status);
547 if (ExprReq->isExprSubstitutionFailure()) {
554 Record.AddSourceLocation(ExprReq->NoexceptLoc);
555 const auto &RetReq = ExprReq->getReturnTypeRequirement();
556 if (RetReq.isSubstitutionFailure()) {
559 }
else if (RetReq.isTypeConstraint()) {
561 Record.AddTemplateParameterList(
562 RetReq.getTypeConstraintTemplateParameterList());
563 if (ExprReq->Status >=
566 ExprReq->getReturnTypeRequirementSubstitutedConstraintExpr());
568 assert(RetReq.isEmpty());
575 Record.push_back(NestedReq->hasInvalidConstraint());
576 if (NestedReq->hasInvalidConstraint()) {
577 Record.AddString(NestedReq->getInvalidConstraintEntity());
580 Record.AddStmt(NestedReq->getConstraintExpr());
581 if (!NestedReq->isDependent())
588 Record.AddSourceLocation(E->
getEndLoc());
613 for (
const auto &I : S->
captures()) {
614 if (I.capturesThis() || I.capturesVariableArrayType())
615 Record.AddDeclRef(
nullptr);
617 Record.AddDeclRef(I.getCapturedVar());
618 Record.push_back(I.getCaptureKind());
619 Record.AddSourceLocation(I.getLocation());
633void ASTStmtWriter::VisitExpr(
Expr *E) {
636 CurrentPackingBits.updateBits();
641 Record.AddTypeRef(E->
getType());
658 Record.push_back(E->Int64Result());
661 Record.AddAPValue(E->APValueResult());
690 Record.push_back(HasFunctionName);
700void ASTStmtWriter::VisitDeclRefExpr(
DeclRefExpr *E) {
703 CurrentPackingBits.updateBits();
715 Record.push_back(NumTemplateArgs);
723 AbbrevToUse = Writer.getDeclRefExprAbbrev();
734 E->getTrailingObjects<TemplateArgumentLoc>());
736 Record.AddDeclRef(E->
getDecl());
748 AbbrevToUse = Writer.getIntegerLiteralAbbrev();
765 Record.push_back(E->
isExact());
784 Record.push_back(llvm::to_underlying(E->
getKind()));
794 Record.push_back(StrData[I]);
803 Record.push_back(llvm::to_underlying(E->
getKind()));
805 AbbrevToUse = Writer.getCharacterLiteralAbbrev();
810void ASTStmtWriter::VisitParenExpr(
ParenExpr *E) {
813 Record.AddSourceLocation(E->
getLParen());
814 Record.AddSourceLocation(E->
getRParen());
822 for (
auto *SubStmt : E->
exprs())
823 Record.AddStmt(SubStmt);
834 CurrentPackingBits.addBit(HasFPFeatures);
836 CurrentPackingBits.addBits(E->
getOpcode(),
855 Record.push_back(ON.
getKind());
872 Record.AddCXXBaseSpecifier(*ON.
getBase());
883 Record.push_back(E->
getKind());
897 Record.AddStmt(E->
getLHS());
898 Record.AddStmt(E->
getRHS());
914 Record.writeEnum(E->ASType);
936 Record.AddSourceRange(SR);
952 Record.AddStmt(
Range.Begin);
953 Record.AddStmt(
Range.End);
954 Record.AddStmt(
Range.Step);
959 OMPIteratorHelperData &HD = E->
getHelper(I);
961 Record.AddStmt(HD.
Upper);
962 Record.AddStmt(HD.
Update);
968void ASTStmtWriter::VisitCallExpr(
CallExpr *E) {
972 CurrentPackingBits.updateBits();
973 CurrentPackingBits.addBit(
static_cast<bool>(E->
getADLCallKind()));
981 Arg != ArgEnd; ++Arg)
982 Record.AddStmt(*Arg);
990 AbbrevToUse = Writer.getCallExprAbbrev();
997 Record.push_back(std::distance(E->
children().begin(), E->
children().end()));
999 Record.AddSourceLocation(E->
getEndLoc());
1001 Record.AddStmt(Child);
1005void ASTStmtWriter::VisitMemberExpr(
MemberExpr *E) {
1009 bool HasFoundDecl = E->hasFoundDecl();
1010 bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();
1015 CurrentPackingBits.updateBits();
1016 CurrentPackingBits.addBit(HasQualifier);
1017 CurrentPackingBits.addBit(HasFoundDecl);
1018 CurrentPackingBits.addBit(HasTemplateInfo);
1019 Record.push_back(NumTemplateArgs);
1023 Record.AddDeclarationNameLoc(E->MemberDNLoc,
1026 CurrentPackingBits.addBit(E->
isArrow());
1036 Record.AddDeclRef(FoundDecl.
getDecl());
1037 CurrentPackingBits.addBits(FoundDecl.
getAccess(), 2);
1040 if (HasTemplateInfo)
1042 E->getTrailingObjects<TemplateArgumentLoc>());
1047void ASTStmtWriter::VisitObjCIsaExpr(
ObjCIsaExpr *E) {
1051 Record.AddSourceLocation(E->
getOpLoc());
1052 Record.push_back(E->
isArrow());
1065 VisitExplicitCastExpr(E);
1072void ASTStmtWriter::VisitCastExpr(
CastExpr *E) {
1076 CurrentPackingBits.updateBits();
1084 Record.AddCXXBaseSpecifier(**PI);
1095 CurrentPackingBits.updateBits();
1096 CurrentPackingBits.addBits(E->
getOpcode(), 6);
1098 CurrentPackingBits.addBit(HasFPFeatures);
1100 Record.AddStmt(E->
getLHS());
1101 Record.AddStmt(E->
getRHS());
1108 AbbrevToUse = Writer.getBinaryOperatorAbbrev();
1114 VisitBinaryOperator(E);
1120 AbbrevToUse = Writer.getCompoundAssignOperatorAbbrev();
1128 Record.AddStmt(E->
getLHS());
1129 Record.AddStmt(E->
getRHS());
1153 AbbrevToUse = Writer.getExprImplicitCastAbbrev();
1164 VisitExplicitCastExpr(E);
1187void ASTStmtWriter::VisitInitListExpr(
InitListExpr *E) {
1194 bool isArrayFiller =
isa<Expr *>(E->ArrayFillerOrUnionFieldInit);
1195 Record.push_back(isArrayFiller);
1202 if (isArrayFiller) {
1206 for (
unsigned I = 0, N = E->
getNumInits(); I != N; ++I)
1207 Record.AddStmt(E->
getInit(I) != filler ? E->
getInit(I) :
nullptr);
1209 for (
unsigned I = 0, N = E->
getNumInits(); I != N; ++I)
1210 Record.AddStmt(E->
getInit(I));
1222 for (
const DesignatedInitExpr::Designator &D : E->
designators()) {
1223 if (D.isFieldDesignator()) {
1224 if (FieldDecl *Field = D.getFieldDecl()) {
1226 Record.AddDeclRef(Field);
1229 Record.AddIdentifierRef(D.getFieldName());
1231 Record.AddSourceLocation(D.getDotLoc());
1232 Record.AddSourceLocation(D.getFieldLoc());
1233 }
else if (D.isArrayDesignator()) {
1235 Record.push_back(D.getArrayIndex());
1236 Record.AddSourceLocation(D.getLBracketLoc());
1237 Record.AddSourceLocation(D.getRBracketLoc());
1239 assert(D.isArrayRangeDesignator() &&
"Unknown designator");
1241 Record.push_back(D.getArrayIndex());
1242 Record.AddSourceLocation(D.getLBracketLoc());
1243 Record.AddSourceLocation(D.getEllipsisLoc());
1244 Record.AddSourceLocation(D.getRBracketLoc());
1257void ASTStmtWriter::VisitNoInitExpr(
NoInitExpr *E) {
1264 Record.AddStmt(E->SubExprs[0]);
1265 Record.AddStmt(E->SubExprs[1]);
1279void ASTStmtWriter::VisitVAArgExpr(
VAArgExpr *E) {
1293 Record.AddSourceLocation(E->
getEndLoc());
1294 Record.push_back(llvm::to_underlying(E->
getIdentKind()));
1298void ASTStmtWriter::VisitEmbedExpr(
EmbedExpr *E) {
1301 Record.AddSourceLocation(E->
getEndLoc());
1316void ASTStmtWriter::VisitStmtExpr(
StmtExpr *E) {
1325void ASTStmtWriter::VisitChooseExpr(
ChooseExpr *E) {
1328 Record.AddStmt(E->
getLHS());
1329 Record.AddStmt(E->
getRHS());
1336void ASTStmtWriter::VisitGNUNullExpr(
GNUNullExpr *E) {
1346 Record.AddStmt(E->
getExpr(I));
1355 CurrentPackingBits.addBit(HasFPFeatures);
1365void ASTStmtWriter::VisitBlockExpr(
BlockExpr *E) {
1376 Record.push_back(E->ResultIndex);
1381 Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1385 for (
unsigned I = 0, N = E->
getNumAssocs() + 1; I < N; ++I)
1386 Record.AddStmt(Stmts[I]);
1388 TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1389 for (
unsigned I = 0, N = E->
getNumAssocs(); I < N; ++I)
1390 Record.AddTypeSourceInfo(TSIs[I]);
1403 Record.push_back(result);
1413void ASTStmtWriter::VisitAtomicExpr(
AtomicExpr *E) {
1415 Record.push_back(E->
getOp());
1430 Record.AddSourceLocation(E->
getAtLoc());
1455 Record.push_back(E->HasPackExpansions);
1458 Record.AddStmt(Element.
Key);
1459 Record.AddStmt(Element.
Value);
1460 if (E->HasPackExpansions) {
1462 unsigned NumExpansions = 0;
1465 Record.push_back(NumExpansions);
1477 Record.AddSourceLocation(E->
getAtLoc());
1485 Record.AddSourceLocation(E->
getAtLoc());
1493 Record.AddSourceLocation(E->
getAtLoc());
1494 Record.AddSourceLocation(E->ProtoLoc);
1501 Record.AddDeclRef(E->
getDecl());
1503 Record.AddSourceLocation(E->
getOpLoc());
1505 Record.push_back(E->
isArrow());
1512 Record.push_back(E->SetterAndMethodRefFlags.getInt());
1523 Record.push_back(0);
1526 Record.push_back(1);
1529 Record.push_back(2);
1550 Record.push_back(E->getNumStoredSelLocs());
1551 Record.push_back(E->SelLocsKind);
1553 Record.push_back(E->IsImplicit);
1572 Record.push_back(1);
1575 Record.push_back(0);
1583 Arg != ArgEnd; ++Arg)
1584 Record.AddStmt(*Arg);
1586 SourceLocation *Locs = E->getStoredSelLocs();
1587 for (
unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1588 Record.AddSourceLocation(Locs[i]);
1598 Record.AddSourceLocation(S->
getForLoc());
1622 Record.AddSourceLocation(S->
getAtLoc());
1672void ASTStmtWriter::VisitCXXCatchStmt(
CXXCatchStmt *S) {
1680void ASTStmtWriter::VisitCXXTryStmt(
CXXTryStmt *S) {
1683 Record.AddSourceLocation(S->
getTryLoc());
1692 Record.AddSourceLocation(S->
getForLoc());
1701 Record.AddStmt(S->
getInc());
1720 Record.AddSourceLocation(E->BeginLoc);
1724 AbbrevToUse = Writer.getCXXOperatorCallExprAbbrev();
1734 AbbrevToUse = Writer.getCXXMemberCallExprAbbrev();
1739void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(
1763 for (
unsigned I = 0, N = E->
getNumArgs(); I != N; ++I)
1764 Record.AddStmt(E->
getArg(I));
1779 VisitCXXConstructExpr(E);
1784void ASTStmtWriter::VisitLambdaExpr(
LambdaExpr *E) {
1787 Record.AddSourceRange(E->IntroducerRange);
1789 Record.AddSourceLocation(E->CaptureDefaultLoc);
1792 Record.AddSourceLocation(E->ClosingBrace);
1814 VisitExplicitCastExpr(E);
1822 VisitCXXNamedCastExpr(E);
1827 VisitCXXNamedCastExpr(E);
1832 VisitCXXNamedCastExpr(E);
1837 VisitCXXNamedCastExpr(E);
1842 VisitCXXNamedCastExpr(E);
1847 VisitExplicitCastExpr(E);
1854 VisitExplicitCastExpr(E);
1856 Record.AddSourceLocation(E->
getEndLoc());
1862 Record.AddSourceLocation(E->UDSuffixLoc);
1891void ASTStmtWriter::VisitCXXThisExpr(
CXXThisExpr *E) {
1900void ASTStmtWriter::VisitCXXThrowExpr(
CXXThrowExpr *E) {
1944void ASTStmtWriter::VisitCXXNewExpr(
CXXNewExpr *E) {
1947 Record.push_back(E->
isArray());
1992 Record.push_back(E->
isArrow());
2013 if (
auto *BD = Obj.dyn_cast<BlockDecl *>()) {
2015 Record.AddDeclRef(BD);
2016 }
else if (
auto *CLE = Obj.dyn_cast<CompoundLiteralExpr *>()) {
2018 Record.AddStmt(CLE);
2027void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(
2034 CurrentPackingBits.updateBits();
2035 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());
2036 CurrentPackingBits.addBit(E->hasFirstQualifierFoundInScope());
2038 if (E->hasTemplateKWAndArgsInfo()) {
2039 const ASTTemplateKWAndArgsInfo &ArgInfo =
2040 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2042 E->getTrailingObjects<TemplateArgumentLoc>());
2045 CurrentPackingBits.addBit(E->
isArrow());
2055 if (E->hasFirstQualifierFoundInScope())
2058 Record.AddDeclarationNameInfo(E->MemberNameInfo);
2068 CurrentPackingBits.addBit(
2072 const ASTTemplateKWAndArgsInfo &ArgInfo =
2073 *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>();
2077 E->getTrailingObjects<TemplateArgumentLoc>());
2081 Record.AddDeclarationNameInfo(E->NameInfo);
2091 Record.AddStmt(*ArgI);
2099void ASTStmtWriter::VisitOverloadExpr(
OverloadExpr *E) {
2104 CurrentPackingBits.updateBits();
2107 const ASTTemplateKWAndArgsInfo &ArgInfo =
2115 OvI != OvE; ++OvI) {
2116 Record.AddDeclRef(OvI.getDecl());
2117 Record.push_back(OvI.getAccess());
2125 VisitOverloadExpr(E);
2126 CurrentPackingBits.addBit(E->
isArrow());
2139 VisitOverloadExpr(E);
2144 if (Writer.isWritingStdCXXNamedModules() && Writer.getChain()) {
2147 DeclarationName Name = E->
getName();
2149 Record.getASTContext().getTranslationUnitDecl()->lookup(Name))
2150 if (
Found->isFromASTFile())
2151 Writer.GetDeclRef(
Found);
2153 llvm::SmallVector<NamespaceDecl *> ExternalNSs;
2154 Writer.getChain()->ReadKnownNamespaces(ExternalNSs);
2155 for (
auto *NS : ExternalNSs)
2156 for (
auto *
Found : NS->lookup(Name))
2157 Writer.GetDeclRef(
Found);
2173 for (
unsigned I = 0, N = E->
getNumArgs(); I != N; ++I)
2174 Record.AddTypeSourceInfo(E->
getArg(I));
2208 Record.push_back(E->NumExpansions);
2217 Record.AddSourceLocation(E->OperatorLoc);
2218 Record.AddSourceLocation(E->PackLoc);
2219 Record.AddSourceLocation(E->RParenLoc);
2220 Record.AddDeclRef(E->Pack);
2223 Record.AddTemplateArgument(TA);
2239 Record.AddStmt(Sub);
2243void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
2248 CurrentPackingBits.addBits(E->
getIndex(), 12);
2250 CurrentPackingBits.addBit(E->
getFinal());
2257void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
2261 CurrentPackingBits.addBit(E->
getFinal());
2275 Record.AddDeclRef(*I);
2289void ASTStmtWriter::VisitCXXFoldExpr(
CXXFoldExpr *E) {
2291 Record.AddSourceLocation(E->LParenLoc);
2292 Record.AddSourceLocation(E->EllipsisLoc);
2293 Record.AddSourceLocation(E->RParenLoc);
2295 Record.AddStmt(E->SubExprs[0]);
2296 Record.AddStmt(E->SubExprs[1]);
2297 Record.AddStmt(E->SubExprs[2]);
2305 Record.push_back(InitExprs.size());
2309 Record.AddSourceLocation(E->
getEndLoc());
2311 Record.AddStmt(InitExpr);
2314 bool HasArrayFillerOrUnionDecl = ArrayFiller || UnionField;
2315 Record.push_back(HasArrayFillerOrUnionDecl);
2316 if (HasArrayFillerOrUnionDecl) {
2317 Record.push_back(
static_cast<bool>(ArrayFiller));
2319 Record.AddStmt(ArrayFiller);
2321 Record.AddDeclRef(UnionField);
2347void ASTStmtWriter::VisitAsTypeExpr(
AsTypeExpr *E) {
2360 Record.push_back(E->
isArrow());
2371 Record.AddStmt(E->
getIdx());
2404void ASTStmtWriter::VisitSEHTryStmt(
SEHTryStmt *S) {
2407 Record.AddSourceLocation(S->
getTryLoc());
2413void ASTStmtWriter::VisitSEHLeaveStmt(
SEHLeaveStmt *S) {
2423void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2425 for (Stmt *SubStmt : S->SubStmts)
2426 Record.AddStmt(SubStmt);
2430void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2431 Record.writeOMPChildren(E->Data);
2432 Record.AddSourceLocation(E->getBeginLoc());
2433 Record.AddSourceLocation(E->getEndLoc());
2436void ASTStmtWriter::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2438 Record.writeUInt32(D->getLoopsNumber());
2439 VisitOMPExecutableDirective(D);
2442void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
2443 VisitOMPLoopBasedDirective(D);
2446void ASTStmtWriter::VisitOMPMetaDirective(OMPMetaDirective *D) {
2448 Record.push_back(D->getNumClauses());
2449 VisitOMPExecutableDirective(D);
2453void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
2455 VisitOMPExecutableDirective(D);
2456 Record.writeBool(D->hasCancel());
2460void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
2461 VisitOMPLoopDirective(D);
2465void ASTStmtWriter::VisitOMPCanonicalLoopNestTransformationDirective(
2466 OMPCanonicalLoopNestTransformationDirective *D) {
2467 VisitOMPLoopBasedDirective(D);
2468 Record.writeUInt32(D->getNumGeneratedTopLevelLoops());
2471void ASTStmtWriter::VisitOMPTileDirective(OMPTileDirective *D) {
2472 VisitOMPCanonicalLoopNestTransformationDirective(D);
2476void ASTStmtWriter::VisitOMPStripeDirective(OMPStripeDirective *D) {
2477 VisitOMPCanonicalLoopNestTransformationDirective(D);
2481void ASTStmtWriter::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2482 VisitOMPCanonicalLoopNestTransformationDirective(D);
2486void ASTStmtWriter::VisitOMPReverseDirective(OMPReverseDirective *D) {
2487 VisitOMPCanonicalLoopNestTransformationDirective(D);
2491void ASTStmtWriter::VisitOMPInterchangeDirective(OMPInterchangeDirective *D) {
2492 VisitOMPCanonicalLoopNestTransformationDirective(D);
2496void ASTStmtWriter::VisitOMPCanonicalLoopSequenceTransformationDirective(
2497 OMPCanonicalLoopSequenceTransformationDirective *D) {
2499 VisitOMPExecutableDirective(D);
2500 Record.writeUInt32(D->getNumGeneratedTopLevelLoops());
2503void ASTStmtWriter::VisitOMPFuseDirective(OMPFuseDirective *D) {
2504 VisitOMPCanonicalLoopSequenceTransformationDirective(D);
2508void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
2509 VisitOMPLoopDirective(D);
2510 Record.writeBool(D->hasCancel());
2514void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2515 VisitOMPLoopDirective(D);
2519void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2521 VisitOMPExecutableDirective(D);
2522 Record.writeBool(D->hasCancel());
2526void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
2528 VisitOMPExecutableDirective(D);
2529 Record.writeBool(D->hasCancel());
2533void ASTStmtWriter::VisitOMPScopeDirective(OMPScopeDirective *D) {
2535 VisitOMPExecutableDirective(D);
2539void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2541 VisitOMPExecutableDirective(D);
2545void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2547 VisitOMPExecutableDirective(D);
2551void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2553 VisitOMPExecutableDirective(D);
2554 Record.AddDeclarationNameInfo(D->getDirectiveName());
2558void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2559 VisitOMPLoopDirective(D);
2560 Record.writeBool(D->hasCancel());
2564void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2565 OMPParallelForSimdDirective *D) {
2566 VisitOMPLoopDirective(D);
2570void ASTStmtWriter::VisitOMPParallelMasterDirective(
2571 OMPParallelMasterDirective *D) {
2573 VisitOMPExecutableDirective(D);
2577void ASTStmtWriter::VisitOMPParallelMaskedDirective(
2578 OMPParallelMaskedDirective *D) {
2580 VisitOMPExecutableDirective(D);
2584void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2585 OMPParallelSectionsDirective *D) {
2587 VisitOMPExecutableDirective(D);
2588 Record.writeBool(D->hasCancel());
2592void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2594 VisitOMPExecutableDirective(D);
2595 Record.writeBool(D->hasCancel());
2599void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2601 VisitOMPExecutableDirective(D);
2602 Record.writeBool(D->isXLHSInRHSPart());
2603 Record.writeBool(D->isPostfixUpdate());
2604 Record.writeBool(D->isFailOnly());
2608void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2610 VisitOMPExecutableDirective(D);
2614void ASTStmtWriter::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2616 VisitOMPExecutableDirective(D);
2620void ASTStmtWriter::VisitOMPTargetEnterDataDirective(
2621 OMPTargetEnterDataDirective *D) {
2623 VisitOMPExecutableDirective(D);
2627void ASTStmtWriter::VisitOMPTargetExitDataDirective(
2628 OMPTargetExitDataDirective *D) {
2630 VisitOMPExecutableDirective(D);
2634void ASTStmtWriter::VisitOMPTargetParallelDirective(
2635 OMPTargetParallelDirective *D) {
2637 VisitOMPExecutableDirective(D);
2642void ASTStmtWriter::VisitOMPTargetParallelForDirective(
2643 OMPTargetParallelForDirective *D) {
2644 VisitOMPLoopDirective(D);
2649void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2651 VisitOMPExecutableDirective(D);
2655void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2657 VisitOMPExecutableDirective(D);
2661void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2663 Record.push_back(D->getNumClauses());
2664 VisitOMPExecutableDirective(D);
2668void ASTStmtWriter::VisitOMPAssumeDirective(OMPAssumeDirective *D) {
2670 VisitOMPExecutableDirective(D);
2674void ASTStmtWriter::VisitOMPErrorDirective(OMPErrorDirective *D) {
2676 Record.push_back(D->getNumClauses());
2677 VisitOMPExecutableDirective(D);
2681void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2683 VisitOMPExecutableDirective(D);
2687void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2689 VisitOMPExecutableDirective(D);
2693void ASTStmtWriter::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2695 VisitOMPExecutableDirective(D);
2699void ASTStmtWriter::VisitOMPScanDirective(OMPScanDirective *D) {
2701 VisitOMPExecutableDirective(D);
2705void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2707 VisitOMPExecutableDirective(D);
2711void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2713 VisitOMPExecutableDirective(D);
2717void ASTStmtWriter::VisitOMPCancellationPointDirective(
2718 OMPCancellationPointDirective *D) {
2720 VisitOMPExecutableDirective(D);
2725void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2727 VisitOMPExecutableDirective(D);
2732void ASTStmtWriter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2733 VisitOMPLoopDirective(D);
2738void ASTStmtWriter::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2739 VisitOMPLoopDirective(D);
2743void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(
2744 OMPMasterTaskLoopDirective *D) {
2745 VisitOMPLoopDirective(D);
2750void ASTStmtWriter::VisitOMPMaskedTaskLoopDirective(
2751 OMPMaskedTaskLoopDirective *D) {
2752 VisitOMPLoopDirective(D);
2757void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
2758 OMPMasterTaskLoopSimdDirective *D) {
2759 VisitOMPLoopDirective(D);
2763void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective(
2764 OMPMaskedTaskLoopSimdDirective *D) {
2765 VisitOMPLoopDirective(D);
2769void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
2770 OMPParallelMasterTaskLoopDirective *D) {
2771 VisitOMPLoopDirective(D);
2776void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopDirective(
2777 OMPParallelMaskedTaskLoopDirective *D) {
2778 VisitOMPLoopDirective(D);
2783void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(
2784 OMPParallelMasterTaskLoopSimdDirective *D) {
2785 VisitOMPLoopDirective(D);
2789void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopSimdDirective(
2790 OMPParallelMaskedTaskLoopSimdDirective *D) {
2791 VisitOMPLoopDirective(D);
2795void ASTStmtWriter::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2796 VisitOMPLoopDirective(D);
2800void ASTStmtWriter::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2802 VisitOMPExecutableDirective(D);
2806void ASTStmtWriter::VisitOMPDistributeParallelForDirective(
2807 OMPDistributeParallelForDirective *D) {
2808 VisitOMPLoopDirective(D);
2813void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(
2814 OMPDistributeParallelForSimdDirective *D) {
2815 VisitOMPLoopDirective(D);
2819void ASTStmtWriter::VisitOMPDistributeSimdDirective(
2820 OMPDistributeSimdDirective *D) {
2821 VisitOMPLoopDirective(D);
2825void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(
2826 OMPTargetParallelForSimdDirective *D) {
2827 VisitOMPLoopDirective(D);
2831void ASTStmtWriter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2832 VisitOMPLoopDirective(D);
2836void ASTStmtWriter::VisitOMPTeamsDistributeDirective(
2837 OMPTeamsDistributeDirective *D) {
2838 VisitOMPLoopDirective(D);
2842void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(
2843 OMPTeamsDistributeSimdDirective *D) {
2844 VisitOMPLoopDirective(D);
2848void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(
2849 OMPTeamsDistributeParallelForSimdDirective *D) {
2850 VisitOMPLoopDirective(D);
2854void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(
2855 OMPTeamsDistributeParallelForDirective *D) {
2856 VisitOMPLoopDirective(D);
2861void ASTStmtWriter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2863 VisitOMPExecutableDirective(D);
2867void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(
2868 OMPTargetTeamsDistributeDirective *D) {
2869 VisitOMPLoopDirective(D);
2873void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(
2874 OMPTargetTeamsDistributeParallelForDirective *D) {
2875 VisitOMPLoopDirective(D);
2880void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2881 OMPTargetTeamsDistributeParallelForSimdDirective *D) {
2882 VisitOMPLoopDirective(D);
2883 Code = serialization::
2884 STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE;
2887void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(
2888 OMPTargetTeamsDistributeSimdDirective *D) {
2889 VisitOMPLoopDirective(D);
2893void ASTStmtWriter::VisitOMPInteropDirective(OMPInteropDirective *D) {
2895 VisitOMPExecutableDirective(D);
2899void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2901 VisitOMPExecutableDirective(D);
2906void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2908 VisitOMPExecutableDirective(D);
2912void ASTStmtWriter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2913 VisitOMPLoopDirective(D);
2917void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective(
2918 OMPTeamsGenericLoopDirective *D) {
2919 VisitOMPLoopDirective(D);
2923void ASTStmtWriter::VisitOMPTargetTeamsGenericLoopDirective(
2924 OMPTargetTeamsGenericLoopDirective *D) {
2925 VisitOMPLoopDirective(D);
2930void ASTStmtWriter::VisitOMPParallelGenericLoopDirective(
2931 OMPParallelGenericLoopDirective *D) {
2932 VisitOMPLoopDirective(D);
2936void ASTStmtWriter::VisitOMPTargetParallelGenericLoopDirective(
2937 OMPTargetParallelGenericLoopDirective *D) {
2938 VisitOMPLoopDirective(D);
2946 Record.push_back(S->
clauses().size());
2947 Record.writeEnum(S->Kind);
2948 Record.AddSourceRange(S->Range);
2949 Record.AddSourceLocation(S->DirectiveLoc);
2950 Record.writeOpenACCClauseList(S->
clauses());
2953void ASTStmtWriter::VisitOpenACCAssociatedStmtConstruct(
2955 VisitOpenACCConstructStmt(S);
2961 VisitOpenACCAssociatedStmtConstruct(S);
2965void ASTStmtWriter::VisitOpenACCLoopConstruct(OpenACCLoopConstruct *S) {
2967 VisitOpenACCAssociatedStmtConstruct(S);
2972void ASTStmtWriter::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) {
2974 VisitOpenACCAssociatedStmtConstruct(S);
2978void ASTStmtWriter::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) {
2980 VisitOpenACCAssociatedStmtConstruct(S);
2984void ASTStmtWriter::VisitOpenACCEnterDataConstruct(
2985 OpenACCEnterDataConstruct *S) {
2987 VisitOpenACCConstructStmt(S);
2991void ASTStmtWriter::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) {
2993 VisitOpenACCConstructStmt(S);
2997void ASTStmtWriter::VisitOpenACCInitConstruct(OpenACCInitConstruct *S) {
2999 VisitOpenACCConstructStmt(S);
3003void ASTStmtWriter::VisitOpenACCShutdownConstruct(OpenACCShutdownConstruct *S) {
3005 VisitOpenACCConstructStmt(S);
3009void ASTStmtWriter::VisitOpenACCSetConstruct(OpenACCSetConstruct *S) {
3011 VisitOpenACCConstructStmt(S);
3015void ASTStmtWriter::VisitOpenACCUpdateConstruct(OpenACCUpdateConstruct *S) {
3017 VisitOpenACCConstructStmt(S);
3021void ASTStmtWriter::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) {
3023 VisitOpenACCAssociatedStmtConstruct(S);
3027void ASTStmtWriter::VisitOpenACCWaitConstruct(OpenACCWaitConstruct *S) {
3029 Record.push_back(S->getExprs().size());
3030 VisitOpenACCConstructStmt(S);
3031 Record.AddSourceLocation(S->LParenLoc);
3032 Record.AddSourceLocation(S->RParenLoc);
3033 Record.AddSourceLocation(S->QueuesLoc);
3035 for(Expr *E : S->getExprs())
3041void ASTStmtWriter::VisitOpenACCAtomicConstruct(OpenACCAtomicConstruct *S) {
3043 VisitOpenACCConstructStmt(S);
3050void ASTStmtWriter::VisitOpenACCCacheConstruct(OpenACCCacheConstruct *S) {
3053 VisitOpenACCConstructStmt(S);
3054 Record.AddSourceRange(S->ParensLoc);
3055 Record.AddSourceLocation(S->ReadOnlyLoc);
3071 Record.writeBool(S->
isInOut());
3080 assert(!SwitchCaseIDs.contains(S) &&
"SwitchCase recorded twice");
3081 unsigned NextID = SwitchCaseIDs.size();
3082 SwitchCaseIDs[S] = NextID;
3087 assert(SwitchCaseIDs.contains(S) &&
"SwitchCase hasn't been seen yet");
3088 return SwitchCaseIDs[S];
3092 SwitchCaseIDs.clear();
3107 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
3108 if (I != SubStmtEntries.end()) {
3109 Record.push_back(I->second);
3115 assert(!ParentStmts.count(S) &&
"There is a Stmt cycle!");
3117 struct ParentStmtInserterRAII {
3119 llvm::DenseSet<Stmt *> &ParentStmts;
3121 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
3122 : S(S), ParentStmts(ParentStmts) {
3123 ParentStmts.insert(S);
3125 ~ParentStmtInserterRAII() {
3126 ParentStmts.erase(S);
3130 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
3136 SubStmtEntries[S] = Offset;
3141void ASTRecordWriter::FlushStmts() {
3144 assert(Writer->SubStmtEntries.empty() &&
"unexpected entries in sub-stmt map");
3145 assert(Writer->ParentStmts.empty() &&
"unexpected entries in parent stmt map");
3147 for (
unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
3148 Writer->WriteSubStmt(getASTContext(), StmtsToEmit[I]);
3150 assert(N == StmtsToEmit.size() &&
"record modified while being written!");
3157 Writer->SubStmtEntries.clear();
3158 Writer->ParentStmts.clear();
3161 StmtsToEmit.clear();
3164void ASTRecordWriter::FlushSubStmts() {
3168 for (
unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
3169 Writer->WriteSubStmt(getASTContext(), StmtsToEmit[N - I - 1]);
3170 assert(N == StmtsToEmit.size() &&
"record modified while being written!");
3173 StmtsToEmit.clear();
This file provides AST data structures related to concepts.
Defines the clang::ASTContext interface.
static void addConstraintSatisfaction(ASTRecordWriter &Record, const ASTConstraintSatisfaction &Satisfaction)
static void addSubstitutionDiagnostic(ASTRecordWriter &Record, const concepts::Requirement::SubstitutionDiagnostic *D)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
llvm::MachO::Record Record
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
SourceLocation getTargetCallLoc() const
Return location of target-call.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool canBeParallelFor() const
Return true if current loop directive's associated loop can be a parallel for.
bool hasCancel() const
Return true if current directive has inner cancel directive.
bool hasCancel() const
Return true if current directive has inner cancel directive.
const Stmt * getAssociatedStmt() const
OpenACCAtomicKind getAtomicKind() const
ArrayRef< Expr * > getVarList() const
OpenACCDirectiveKind getParentComputeConstructKind() const
unsigned getBitWidth() const
llvm::APInt getValue() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
An object for streaming information to a record.
void push_back(uint64_t N)
Minimal vector-like interface.
void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args)
ASTStmtWriter(const ASTStmtWriter &)=delete
ASTStmtWriter & operator=(const ASTStmtWriter &)=delete
ASTStmtWriter(ASTContext &Context, ASTWriter &Writer, ASTWriter::RecordData &Record)
Writes an AST file containing the contents of a translation unit.
unsigned getSwitchCaseID(SwitchCase *S)
Retrieve the ID for the given switch-case statement.
void ClearSwitchCaseIDs()
unsigned RecordSwitchCaseID(SwitchCase *S)
Record an ID for the given switch-case statement.
unsigned getCompoundStmtAbbrev() const
SmallVector< uint64_t, 64 > RecordData
SourceLocation getColonLoc() const
SourceLocation getQuestionLoc() const
AddrLabelExpr - The GNU address of label extension, representing &&label.
SourceLocation getAmpAmpLoc() const
SourceLocation getLabelLoc() const
LabelDecl * getLabel() const
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...
SourceLocation getRBracketLoc() const
Expr * getBase()
Get base of the array section.
Expr * getLength()
Get length of array section.
bool isOMPArraySection() const
Expr * getStride()
Get stride of array section.
SourceLocation getColonLocSecond() const
Expr * getLowerBound()
Get lower bound of array section.
SourceLocation getColonLocFirst() const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getRBracketLoc() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
uint64_t getValue() const
ArrayTypeTrait getTrait() const
Expr * getDimensionExpression() const
TypeSourceInfo * getQueriedTypeSourceInfo() const
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
SourceLocation getBuiltinLoc() const
getBuiltinLoc - Return the location of the __builtin_astype token.
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
SourceLocation getAsmLoc() const
unsigned getNumClobbers() const
unsigned getNumOutputs() const
unsigned getNumInputs() const
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
SourceLocation getRParenLoc() const
static unsigned getNumSubExprs(AtomicOp Op)
Determine the number of arguments the specified atomic builtin should have.
SourceLocation getBuiltinLoc() const
Represents an attribute applied to a statement.
SourceLocation getAttrLoc() const
ArrayRef< const Attr * > getAttrs() const
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condition evaluates to false; ...
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression which will be evaluated if the condition evaluates to true; th...
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
A builtin binary operation expression such as "x + y" or "x <= y".
SourceLocation getOperatorLoc() const
bool hasStoredFPFeatures() const
FPOptionsOverride getStoredFPFeatures() const
Get FPFeatures from trailing storage.
bool hasExcludedOverflowPattern() const
A simple helper class to pack several bits in order into (a) 32 bit integer(s).
void addBits(uint32_t Value, uint32_t BitsWidth)
void reset(uint32_t Value)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
const BlockDecl * getBlockDecl() const
BreakStmt - This represents a break.
Represents a C++2a __builtin_bit_cast(T, v) expression.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
SourceLocation getRParenLoc() const
SourceLocation getLParenLoc() const
Represents a call to a CUDA kernel function.
const CallExpr * getConfig() const
A C++ addrspace_cast expression (currently only enabled for OpenCL).
Represents binding an expression to a temporary.
CXXTemporary * getTemporary()
const Expr * getSubExpr() const
A boolean literal, per ([C++ lex.bool] Boolean literals).
SourceLocation getLocation() const
CXXCatchStmt - This represents a C++ catch block.
SourceLocation getCatchLoc() const
Stmt * getHandlerBlock() const
VarDecl * getExceptionDecl() const
A C++ const_cast expression (C++ [expr.const.cast]).
Represents a call to a C++ constructor.
SourceRange getParenOrBraceRange() const
bool isElidable() const
Whether this construction is elidable.
bool hadMultipleCandidates() const
Whether the referred constructor was resolved from an overloaded set having size greater than 1.
Expr * getArg(unsigned Arg)
Return the specified argument.
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
bool isImmediateEscalating() const
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called.
SourceLocation getLocation() const
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
CXXConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
A default argument (C++ [dcl.fct.default]).
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
const ParmVarDecl * getParam() const
Expr * getRewrittenExpr()
const DeclContext * getUsedContext() const
bool hasRewrittenInit() const
A use of a default initializer in a constructor or in aggregate initialization.
const DeclContext * getUsedContext() const
const Expr * getRewrittenExpr() const
Retrieve the initializing expression with evaluated immediate calls, if any.
bool hasRewrittenInit() const
FieldDecl * getField()
Get the field whose initializer will be used.
Represents a delete expression for memory deallocation and destructor calls, e.g.
FunctionDecl * getOperatorDelete() const
SourceLocation getBeginLoc() const
bool isGlobalDelete() const
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
bool isArrayFormAsWritten() const
Represents a C++ member access expression where the actual member referenced could not be resolved be...
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
SourceLocation getOperatorLoc() const
Retrieve the location of the '->' or '.' operator.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
QualType getBaseType() const
NamedDecl * getFirstQualifierFoundInScope() const
Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the member name, with source location information.
bool isImplicitAccess() const
True if this is an implicit access, i.e.
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...
DeclStmt * getBeginStmt()
DeclStmt * getLoopVarStmt()
SourceLocation getForLoc() const
DeclStmt * getRangeStmt()
SourceLocation getRParenLoc() const
SourceLocation getColonLoc() const
SourceLocation getCoawaitLoc() const
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
Represents a call to an inherited base class constructor from an inheriting constructor.
bool constructsVBase() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
SourceLocation getLocation() const LLVM_READONLY
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
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.
SourceLocation getOperatorLoc() const
Retrieve the location of the cast operator keyword, e.g., static_cast.
SourceRange getAngleBrackets() const LLVM_READONLY
SourceLocation getRParenLoc() const
Retrieve the location of the closing parenthesis.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
SourceRange getDirectInitRange() const
ExprIterator arg_iterator
ImplicitAllocationParameters implicitAllocationParameters() const
Provides the full set of information about expected implicit parameters in this call.
bool hasInitializer() const
Whether this new-expression has any initializer at all.
FunctionDecl * getOperatorDelete() const
unsigned getNumPlacementArgs() const
TypeSourceInfo * getAllocatedTypeSourceInfo() const
SourceRange getSourceRange() const
SourceRange getTypeIdParens() const
bool isParenTypeId() const
raw_arg_iterator raw_arg_end()
bool doesUsualArrayDeleteWantSize() const
Answers whether the usual array deallocation function for the allocated type expects the size of the ...
raw_arg_iterator raw_arg_begin()
FunctionDecl * getOperatorNew() const
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Expr * getOperand() const
SourceRange getSourceRange() const
The null pointer literal (C++11 [lex.nullptr])
SourceLocation getLocation() const
A call to an overloaded operator written using operator syntax.
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Represents a list-initialization with parenthesis.
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getInitLoc() const LLVM_READONLY
MutableArrayRef< Expr * > getInitExprs()
ArrayRef< Expr * > getUserSpecifiedInitExprs()
SourceLocation getBeginLoc() const LLVM_READONLY
FieldDecl * getInitializedFieldInUnion()
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
TypeSourceInfo * getDestroyedTypeInfo() const
Retrieve the source location information for the type being destroyed.
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise,...
TypeSourceInfo * getScopeTypeInfo() const
Retrieve the scope type in a qualified pseudo-destructor expression.
SourceLocation getTildeLoc() const
Retrieve the location of the '~'.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieves the nested-name-specifier that qualifies the type name, with source-location information.
SourceLocation getDestroyedTypeLoc() const
Retrieve the starting location of the type being destroyed.
SourceLocation getColonColonLoc() const
Retrieve the location of the '::' in a qualified pseudo-destructor expression.
SourceLocation getOperatorLoc() const
Retrieve the location of the '.' or '->' operator.
const IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
A rewritten comparison expression that was originally written using operator syntax.
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
bool isReversed() const
Determine whether this expression was rewritten in reverse form.
An expression "T()" which creates an rvalue of a non-class type T.
TypeSourceInfo * getTypeSourceInfo() const
SourceLocation getRParenLoc() const
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.
TypeSourceInfo * getTypeSourceInfo() const
Represents the this expression in C++.
bool isCapturedByCopyInLambdaWithExplicitObjectParameter() const
SourceLocation getLocation() const
A C++ throw-expression (C++ [except.throw]).
const Expr * getSubExpr() const
SourceLocation getThrowLoc() const
bool isThrownVariableInScope() const
Determines whether the variable thrown by this expression (if any!) is within the innermost try block...
CXXTryStmt - A C++ try block, including all handlers.
SourceLocation getTryLoc() const
CXXCatchStmt * getHandler(unsigned i)
unsigned getNumHandlers() const
CompoundStmt * getTryBlock()
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
bool isTypeOperand() const
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Expr * getExprOperand() const
SourceRange getSourceRange() const LLVM_READONLY
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
SourceLocation getLParenLoc() const
Retrieve the location of the left parentheses ('(') that precedes the argument list.
bool isListInitialization() const
Determine whether this expression models list-initialization.
TypeSourceInfo * getTypeSourceInfo() const
Retrieve the type source information for the type being constructed.
SourceLocation getRParenLoc() const
Retrieve the location of the right parentheses (')') that follows the argument list.
unsigned getNumArgs() const
Retrieve the number of arguments.
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Expr * getExprOperand() const
MSGuidDecl * getGuidDecl() const
bool isTypeOperand() const
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
SourceRange getSourceRange() const LLVM_READONLY
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
bool hasStoredFPFeatures() const
bool usesMemberSyntax() const
ExprIterator arg_iterator
ADLCallKind getADLCallKind() const
FPOptionsOverride getFPFeatures() const
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
bool isCoroElideSafe() const
SourceLocation getRParenLoc() const
This captures a statement into a function.
capture_init_range capture_inits()
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of captures.
const RecordDecl * getCapturedRecordDecl() const
Retrieve the record declaration for captured variables.
Stmt * getCapturedStmt()
Retrieve the statement being captured.
capture_iterator capture_begin()
Retrieve an iterator pointing to the first capture.
CapturedRegionKind getCapturedRegionKind() const
Retrieve the captured region kind.
CaseStmt - Represent a case statement.
bool caseStmtIsGNURange() const
True if this case statement is of the form case LHS ... RHS, which is a GNU extension.
SourceLocation getEllipsisLoc() const
Get the location of the ... in a case statement of the form LHS ... RHS.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
path_iterator path_begin()
unsigned path_size() const
CastKind getCastKind() const
bool hasStoredFPFeatures() const
CXXBaseSpecifier ** path_iterator
FPOptionsOverride getFPFeatures() const
SourceLocation getLocation() const
unsigned getValue() const
CharacterLiteralKind getKind() const
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
SourceLocation getBuiltinLoc() const
bool isConditionDependent() const
bool isConditionTrue() const
isConditionTrue - Return whether the condition is true (i.e.
SourceLocation getRParenLoc() const
Represents a 'co_await' expression.
CompoundAssignOperator - For compound assignments (e.g.
QualType getComputationLHSType() const
QualType getComputationResultType() const
CompoundLiteralExpr - [C99 6.5.2.5].
SourceLocation getLParenLoc() const
const Expr * getInitializer() const
TypeSourceInfo * getTypeSourceInfo() const
CompoundStmt - This represents a group of statements like { stmt stmt }.
FPOptionsOverride getStoredFPFeatures() const
Get FPOptionsOverride from trailing storage.
SourceLocation getLBracLoc() const
bool hasStoredFPFeatures() const
SourceLocation getRBracLoc() const
Represents the specialization of a concept - evaluates to a prvalue of type bool.
ConceptReference * getConceptReference() const
const ImplicitConceptSpecializationDecl * getSpecializationDecl() const
const ASTConstraintSatisfaction & getSatisfaction() const
Get elaborated satisfaction info about the template arguments' satisfaction of the named concept.
ConditionalOperator - The ?
Expr * getCond() const
getCond - Return the expression representing the condition for the ?
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
ConstantResultStorageKind getResultStorageKind() const
ContinueStmt - This represents a continue.
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
SourceLocation getBuiltinLoc() const
getBuiltinLoc - Return the location of the __builtin_convertvector token.
FPOptionsOverride getStoredFPFeatures() const
Get FPFeatures from trailing storage.
TypeSourceInfo * getTypeSourceInfo() const
getTypeSourceInfo - Return the destination type.
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Represents a 'co_return' statement in the C++ Coroutines TS.
Expr * getOperand() const
Retrieve the operand of the 'co_return' statement.
Expr * getPromiseCall() const
Retrieve the promise call that results from this 'co_return' statement.
SourceLocation getKeywordLoc() const
Represents the body of a coroutine.
ArrayRef< Stmt const * > getParamMoves() const
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
SourceLocation getKeywordLoc() const
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Represents a 'co_yield' expression.
NamedDecl * getDecl() const
AccessSpecifier getAccess() const
A reference to a declared variable, function, enum, etc.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
bool hasTemplateKWAndArgsInfo() const
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name,...
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
bool hadMultipleCandidates() const
Returns true if this expression refers to a function that was resolved from an overloaded set having ...
SourceLocation getLocation() const
bool isImmediateEscalating() const
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
SourceLocation getEndLoc() const
const DeclGroupRef getDeclGroup() const
SourceLocation getBeginLoc() const LLVM_READONLY
NameKind
The kind of the name stored in this DeclarationName.
Represents a 'co_await' expression while the type of the promise is dependent.
SourceLocation getKeywordLoc() const
A qualified reference to a name whose declaration cannot yet be resolved.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source location information.
Represents a C99 designated initializer expression.
Expr * getSubExpr(unsigned Idx) const
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
MutableArrayRef< Designator > designators()
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression,...
InitListExpr * getUpdater() const
DoStmt - This represents a 'do/while' stmt.
SourceLocation getWhileLoc() const
SourceLocation getDoLoc() const
SourceLocation getRParenLoc() const
Represents a reference to emded data.
unsigned getStartingElementPos() const
SourceLocation getEndLoc() const
StringLiteral * getDataStringLiteral() const
SourceLocation getBeginLoc() const
size_t getDataElementCount() const
ExplicitCastExpr - An explicit cast written in the source code.
TypeSourceInfo * getTypeInfoAsWritten() const
getTypeInfoAsWritten - Returns the type source info for the type that this expression is casting to.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
bool cleanupsHaveSideEffects() const
ArrayRef< CleanupObject > getObjects() const
unsigned getNumObjects() const
This represents one expression.
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
ExprDependence getDependence() const
An expression trait intrinsic.
Expr * getQueriedExpression() const
ExpressionTrait getTrait() const
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
SourceLocation getAccessorLoc() const
const Expr * getBase() const
IdentifierInfo & getAccessor() const
storage_type getAsOpaqueInt() const
SourceLocation getLocation() const
Retrieve the location of the literal.
unsigned getScale() const
llvm::APInt getValue() const
Returns an internal integer representation of the literal.
SourceLocation getLocation() const
llvm::APFloatBase::Semantics getRawSemantics() const
Get a raw enumeration value representing the floating-point semantics of this literal (32-bit IEEE,...
llvm::APFloat getValue() const
ForStmt - This represents a 'for (init;cond;inc)' stmt.
SourceLocation getRParenLoc() const
SourceLocation getForLoc() const
SourceLocation getLParenLoc() const
DeclStmt * getConditionVariableDeclStmt()
If this ForStmt has a condition variable, return the faux DeclStmt associated with the creation of th...
const Expr * getSubExpr() const
Represents a reference to a function parameter pack, init-capture pack, or binding pack that has been...
ValueDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
ValueDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
This represents a GCC inline-assembly statement extension.
unsigned getNumLabels() const
SourceLocation getRParenLoc() const
IdentifierInfo * getInputIdentifier(unsigned i) const
const Expr * getOutputConstraintExpr(unsigned i) const
IdentifierInfo * getLabelIdentifier(unsigned i) const
const Expr * getInputConstraintExpr(unsigned i) const
IdentifierInfo * getOutputIdentifier(unsigned i) const
const Expr * getAsmStringExpr() const
Expr * getOutputExpr(unsigned i)
Expr * getClobberExpr(unsigned i)
Expr * getInputExpr(unsigned i)
AddrLabelExpr * getLabelExpr(unsigned i) const
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
SourceLocation getTokenLocation() const
getTokenLocation - The location of the __null token.
Represents a C11 generic selection.
unsigned getNumAssocs() const
The number of association expressions.
bool isExprPredicate() const
Whether this generic selection uses an expression as its controlling argument.
SourceLocation getGenericLoc() const
SourceLocation getRParenLoc() const
SourceLocation getDefaultLoc() const
GotoStmt - This represents a direct goto.
SourceLocation getLabelLoc() const
SourceLocation getGotoLoc() const
LabelDecl * getLabel() const
This class represents temporary values used to represent inout and out arguments in HLSL.
const OpaqueValueExpr * getCastedTemporary() const
const OpaqueValueExpr * getOpaqueArgLValue() const
bool isInOut() const
returns true if the parameter is inout and false if the parameter is out.
const Expr * getWritebackCast() const
IfStmt - This represents an if/then/else.
SourceLocation getIfLoc() const
IfStatementKind getStatementKind() const
SourceLocation getElseLoc() const
SourceLocation getLParenLoc() const
DeclStmt * getConditionVariableDeclStmt()
If this IfStmt has a condition variable, return the faux DeclStmt associated with the creation of tha...
SourceLocation getRParenLoc() const
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
const Expr * getSubExpr() const
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
bool isPartOfExplicitCast() const
Represents an implicitly-generated value initialization of an object of a given type.
IndirectGotoStmt - This represents an indirect goto.
SourceLocation getGotoLoc() const
SourceLocation getStarLoc() const
Describes an C or C++ initializer list.
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
unsigned getNumInits() const
SourceLocation getLBraceLoc() const
InitListExpr * getSyntacticForm() const
bool hadArrayRangeDesignator() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
SourceLocation getRBraceLoc() const
const Expr * getInit(unsigned Init) const
SourceLocation getLocation() const
Retrieve the location of the literal.
LabelStmt - Represents a label, which has a substatement.
LabelDecl * getDecl() const
SourceLocation getIdentLoc() const
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Expr ** capture_init_iterator
Iterator that walks over the capture initialization arguments.
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression.
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Base class for BreakStmt and ContinueStmt.
SourceLocation getLabelLoc() const
LabelDecl * getLabelDecl()
SourceLocation getKwLoc() const
bool hasLabelTarget() const
This represents a Microsoft inline-assembly statement extension.
Expr * getOutputExpr(unsigned i)
StringRef getAsmString() const
SourceLocation getLBraceLoc() const
SourceLocation getEndLoc() const
StringRef getInputConstraint(unsigned i) const
StringRef getOutputConstraint(unsigned i) const
StringRef getClobber(unsigned i) const
Expr * getInputExpr(unsigned i)
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.
bool isIfExists() const
Determine whether this is an __if_exists statement.
DeclarationNameInfo getNameInfo() const
Retrieve the name of the entity we're testing for, along with location information.
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies this name, if any.
CompoundStmt * getSubStmt() const
Retrieve the compound statement that will be included in the program only if the existence of the sym...
SourceLocation getKeywordLoc() const
Retrieve the location of the __if_exists or __if_not_exists keyword.
A member reference to an MSPropertyDecl.
NestedNameSpecifierLoc getQualifierLoc() const
MSPropertyDecl * getPropertyDecl() const
Expr * getBaseExpr() const
SourceLocation getMemberLoc() const
MS property subscript expression.
SourceLocation getRBracketLoc() const
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
LifetimeExtendedTemporaryDecl * getLifetimeExtendedTemporaryDecl()
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
SourceLocation getRBracketLoc() const
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
SourceLocation getOperatorLoc() const
NestedNameSpecifierLoc getQualifierLoc() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name,...
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
bool hadMultipleCandidates() const
Returns true if this member expression refers to a method that was resolved from an overloaded set ha...
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Represents a place-holder for an object not to be initialized by anything.
NullStmt - This is the null statement ";": C99 6.8.3p3.
SourceLocation getSemiLoc() const
An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......
Expr * getBase()
Fetches base expression of array shaping expression.
SourceLocation getLParenLoc() const
ArrayRef< Expr * > getDimensions() const
Fetches the dimensions for array shaping expression.
SourceLocation getRParenLoc() const
ArrayRef< SourceRange > getBracketsRanges() const
Fetches source ranges for the brackets os the array shaping expression.
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
SourceLocation getLParenLoc() const
SourceLocation getSecondColonLoc(unsigned I) const
Gets the location of the second ':' (if any) in the range for the given iteratori definition.
SourceLocation getColonLoc(unsigned I) const
Gets the location of the first ':' in the range for the given iterator definition.
SourceLocation getRParenLoc() const
IteratorRange getIteratorRange(unsigned I)
Gets the iterator range for the given iterator.
OMPIteratorHelperData & getHelper(unsigned I)
Fetches helper data for the specified iteration space.
SourceLocation getAssignLoc(unsigned I) const
Gets the location of '=' for the given iterator definition.
SourceLocation getIteratorKwLoc() const
unsigned numOfIterators() const
Returns number of iterator definitions.
Decl * getIteratorDecl(unsigned I)
Gets the iterator declaration for the given iterator.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Expr * getElement(unsigned Index)
getElement - Return the Element at the specified index.
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
SourceRange getSourceRange() const LLVM_READONLY
ObjCMethodDecl * getArrayWithObjectsMethod() const
Represents Objective-C's @catch statement.
const VarDecl * getCatchParamDecl() const
const Stmt * getCatchBody() const
SourceLocation getAtCatchLoc() const
SourceLocation getRParenLoc() const
Represents Objective-C's @finally statement.
const Stmt * getFinallyBody() const
SourceLocation getAtFinallyLoc() const
Represents Objective-C's @synchronized statement.
const Expr * getSynchExpr() const
const CompoundStmt * getSynchBody() const
SourceLocation getAtSynchronizedLoc() const
Represents Objective-C's @throw statement.
const Expr * getThrowExpr() const
SourceLocation getThrowLoc() const LLVM_READONLY
Represents Objective-C's @try ... @catch ... @finally statement.
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
const Stmt * getTryBody() const
Retrieve the @try body.
SourceLocation getAtTryLoc() const
Retrieve the location of the @ in the @try.
catch_range catch_stmts()
Represents Objective-C's @autoreleasepool Statement.
SourceLocation getAtLoc() const
const Stmt * getSubStmt() const
A runtime availability query.
SourceRange getSourceRange() const
VersionTuple getVersion() const
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
SourceLocation getLocation() const
ObjCBoxedExpr - used for generalized expression boxing.
SourceRange getSourceRange() const LLVM_READONLY
ObjCMethodDecl * getBoxingMethod() const
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...
SourceLocation getLParenLoc() const
SourceLocation getBridgeKeywordLoc() const
The location of the bridge keyword.
ObjCBridgeCastKind getBridgeKind() const
Determine which kind of bridge is being performed via this cast.
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
ObjCMethodDecl * getDictWithObjectsMethod() const
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
SourceRange getSourceRange() const LLVM_READONLY
ObjCEncodeExpr, used for @encode in Objective-C.
TypeSourceInfo * getEncodedTypeSourceInfo() const
SourceLocation getRParenLoc() const
SourceLocation getAtLoc() const
Represents Objective-C's collection statement.
SourceLocation getForLoc() const
SourceLocation getRParenLoc() const
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
bool shouldCopy() const
shouldCopy - True if we should do the 'copy' part of the copy-restore.
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
SourceLocation getIsaMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
SourceLocation getOpLoc() const
ObjCIvarRefExpr - A reference to an ObjC instance variable.
SourceLocation getLocation() const
SourceLocation getOpLoc() const
const Expr * getBase() const
An expression that sends a message to the given Objective-C object or class.
bool isDelegateInitCall() const
isDelegateInitCall - Answers whether this message send has been tagged as a "delegate init call",...
SourceLocation getLeftLoc() const
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
SourceLocation getSuperLoc() const
Retrieve the location of the 'super' keyword for a class or instance message to 'super',...
Selector getSelector() const
@ SuperInstance
The receiver is the instance of the superclass object.
@ Instance
The receiver is an object instance.
@ SuperClass
The receiver is a superclass.
@ Class
The receiver is a class.
TypeSourceInfo * getClassReceiverTypeInfo() const
Returns a type-source information of a class message send, or nullptr if the message is not a class m...
QualType getSuperType() const
Retrieve the type referred to by 'super'.
const ObjCMethodDecl * getMethodDecl() const
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
SourceLocation getRightLoc() const
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver.
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
ObjCPropertyDecl * getExplicitProperty() const
ObjCMethodDecl * getImplicitPropertyGetter() const
SourceLocation getReceiverLocation() const
const Expr * getBase() const
bool isObjectReceiver() const
QualType getSuperReceiverType() const
bool isImplicitProperty() const
ObjCMethodDecl * getImplicitPropertySetter() const
ObjCInterfaceDecl * getClassReceiver() const
SourceLocation getLocation() const
bool isSuperReceiver() const
ObjCProtocolExpr used for protocol expression in Objective-C.
ObjCProtocolDecl * getProtocol() const
SourceLocation getRParenLoc() const
SourceLocation getAtLoc() const
ObjCSelectorExpr used for @selector in Objective-C.
SourceLocation getRParenLoc() const
Selector getSelector() const
SourceLocation getAtLoc() const
ObjCStringLiteral, used for Objective-C string literals i.e.
SourceLocation getAtLoc() const
StringLiteral * getString()
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Expr * getKeyExpr() const
Expr * getBaseExpr() const
ObjCMethodDecl * getAtIndexMethodDecl() const
SourceLocation getRBracket() const
ObjCMethodDecl * setAtIndexMethodDecl() const
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Expr * getIndexExpr(unsigned Idx)
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
const OffsetOfNode & getComponent(unsigned Idx) const
TypeSourceInfo * getTypeSourceInfo() const
unsigned getNumExpressions() const
SourceLocation getRParenLoc() const
Return the location of the right parentheses.
unsigned getNumComponents() const
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
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.
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range that covers this offsetof node.
@ 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.
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
SourceLocation getLocation() const
Retrieve the location of this expression.
This is a base class for any OpenACC statement-level constructs that have an associated statement.
Stmt * getAssociatedStmt()
This expression type represents an asterisk in an OpenACC Size-Expr, used in the 'tile' and 'gang' cl...
SourceLocation getLocation() const
This is the base class for an OpenACC statement-level construct, other construct types are expected t...
ArrayRef< const OpenACCClause * > clauses() const
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
UnresolvedSetImpl::iterator decls_iterator
decls_iterator decls_begin() const
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
TemplateArgumentLoc * getTrailingTemplateArgumentLoc()
Return the optional template arguments.
bool hasTemplateKWAndArgsInfo() const
decls_iterator decls_end() const
DeclarationName getName() const
Gets the name looked up.
Represents a C++11 pack expansion that produces a sequence of expressions.
Expr * getPattern()
Retrieve the pattern of the pack expansion.
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that describes this pack expansion.
SourceLocation getEllipsisLoc() const
Determine the location of the 'sizeof' keyword.
Expr * getIndexExpr() const
ArrayRef< Expr * > getExpressions() const
Return the trailing expressions, regardless of the expansion.
SourceLocation getRSquareLoc() const
Determine the location of the right parenthesis.
Expr * getPackIdExpression() const
ParenExpr - This represents a parenthesized expression, e.g.
SourceLocation getLParen() const
Get the location of the left parentheses '('.
const Expr * getSubExpr() const
bool isProducedByFoldExpansion() const
SourceLocation getRParen() const
Get the location of the right parentheses ')'.
ArrayRef< Expr * > exprs()
unsigned getNumExprs() const
Return the number of expressions in this paren list.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
[C99 6.4.2.2] - A predefined identifier such as func.
bool isTransparent() const
PredefinedIdentKind getIdentKind() const
SourceLocation getLocation() const
StringLiteral * getFunctionName()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
semantics_iterator semantics_end()
unsigned getResultExprIndex() const
Return the index of the result-bearing expression into the semantics expressions, or PseudoObjectExpr...
semantics_iterator semantics_begin()
Expr *const * semantics_iterator
unsigned getNumSemanticExprs() const
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
SourceLocation getEndLoc() const
SourceLocation getBeginLoc() const
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
RequiresExprBodyDecl * getBody() const
ArrayRef< concepts::Requirement * > getRequirements() const
ArrayRef< ParmVarDecl * > getLocalParameters() const
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
SourceLocation getReturnLoc() const
const VarDecl * getNRVOCandidate() const
Retrieve the variable that might be used for the named return value optimization.
CompoundStmt * getBlock() const
SourceLocation getExceptLoc() const
Expr * getFilterExpr() const
SourceLocation getFinallyLoc() const
CompoundStmt * getBlock() const
Represents a __leave statement.
SourceLocation getLeaveLoc() const
CompoundStmt * getTryBlock() const
SourceLocation getTryLoc() const
Stmt * getHandler() const
SYCLKernelCallStmt represents the transformation that is applied to the body of a function declared w...
CompoundStmt * getOriginalStmt()
Retrieve the model statement.
OutlinedFunctionDecl * getOutlinedFunctionDecl()
Retrieve the outlined function declaration.
SourceLocation getLocation() const
SourceLocation getLParenLocation() const
TypeSourceInfo * getTypeSourceInfo()
SourceLocation getRParenLocation() const
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
SourceLocation getBuiltinLoc() const
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
SourceLocation getRParenLoc() const
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
Represents an expression that computes the length of a parameter pack.
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof... expression, such as is produced f...
ArrayRef< TemplateArgument > getPartialArguments() const
Get.
unsigned getPackLength() const
Retrieve the length of the parameter pack.
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
SourceLocation getBeginLoc() const
const DeclContext * getParentContext() const
If the SourceLocExpr has been resolved return the subexpression representing the resolved value.
SourceLocation getEndLoc() const
SourceLocIdentKind getIdentKind() const
SourceLocation getEnd() const
SourceLocation getBegin() const
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
CompoundStmt * getSubStmt()
unsigned getTemplateDepth() const
SourceLocation getRParenLoc() const
SourceLocation getLParenLoc() const
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Stmt - This represents one statement.
LambdaExprBitfields LambdaExprBits
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
TypeTraitExprBitfields TypeTraitExprBits
CXXNewExprBitfields CXXNewExprBits
ConstantExprBitfields ConstantExprBits
RequiresExprBitfields RequiresExprBits
CXXFoldExprBitfields CXXFoldExprBits
PackIndexingExprBitfields PackIndexingExprBits
NullStmtBitfields NullStmtBits
DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
unsigned getLength() const
StringLiteralKind getKind() const
StringRef getBytes() const
Allow access to clients that need the byte representation, such as ASTWriterStmt::VisitStringLiteral(...
unsigned getByteLength() const
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
unsigned getCharByteWidth() const
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
UnsignedOrNone getPackIndex() const
bool isReferenceParameter() const
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
SourceLocation getNameLoc() const
Expr * getReplacement() const
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
Decl * getAssociatedDecl() const
A template-like entity which owns the whole pattern being substituted.
unsigned getIndex() const
Returns the index of the replaced parameter in the associated declaration.
SourceLocation getKeywordLoc() const
SourceLocation getColonLoc() const
const SwitchCase * getNextSwitchCase() const
SwitchStmt - This represents a 'switch' stmt.
SourceLocation getSwitchLoc() const
SourceLocation getLParenLoc() const
bool isAllEnumCasesCovered() const
Returns true if the SwitchStmt is a switch of an enum value and all cases have been explicitly covere...
SourceLocation getRParenLoc() const
SwitchCase * getSwitchCaseList()
DeclStmt * getConditionVariableDeclStmt()
If this SwitchStmt has a condition variable, return the faux DeclStmt associated with the creation of...
Location wrapper for a TemplateArgument.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
TypeSourceInfo * getArg(unsigned I) const
Retrieve the Ith argument.
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
const APValue & getAPValue() const
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
SourceLocation getRParenLoc() const
SourceLocation getOperatorLoc() const
bool isArgumentType() const
TypeSourceInfo * getArgumentTypeInfo() const
UnaryExprOrTypeTrait getKind() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
FPOptionsOverride getStoredFPFeatures() const
Get FPFeatures from trailing storage.
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
CXXRecordDecl * getNamingClass()
Gets the 'naming class' (in the sense of C++0x [class.access.base]p5) of the lookup.
bool requiresADL() const
True if this declaration should be extended by argument-dependent lookup.
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
QualType getBaseType() const
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '.
SourceLocation getOperatorLoc() const
Retrieve the location of the '->' or '.' operator.
bool hasUnresolvedUsing() const
Determine whether the lookup results contain an unresolved using declaration.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
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.
TypeSourceInfo * getWrittenTypeInfo() const
SourceLocation getBuiltinLoc() const
SourceLocation getRParenLoc() const
bool isMicrosoftABI() const
Returns whether this is really a Win64 ABI va_arg expression.
const Expr * getSubExpr() const
WhileStmt - This represents a 'while' stmt.
SourceLocation getWhileLoc() const
SourceLocation getRParenLoc() const
DeclStmt * getConditionVariableDeclStmt()
If this WhileStmt has a condition variable, return the faux DeclStmt associated with the creation of ...
SourceLocation getLParenLoc() const
@ SS_ConstraintsNotSatisfied
StmtCode
Record codes for each kind of statement or expression.
@ STMT_OMP_SECTION_DIRECTIVE
@ STMT_OPENACC_COMBINED_CONSTRUCT
@ EXPR_DESIGNATED_INIT
A DesignatedInitExpr record.
@ EXPR_COMPOUND_LITERAL
A CompoundLiteralExpr record.
@ STMT_OMP_ASSUME_DIRECTIVE
@ STMT_OPENACC_HOST_DATA_CONSTRUCT
@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ EXPR_OBJC_IVAR_REF_EXPR
An ObjCIvarRefExpr record.
@ STMT_OMP_SCOPE_DIRECTIVE
@ STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
@ EXPR_MEMBER
A MemberExpr record.
@ STMT_OMP_TARGET_TEAMS_DIRECTIVE
@ EXPR_CXX_TEMPORARY_OBJECT
A CXXTemporaryObjectExpr record.
@ EXPR_CXX_UNRESOLVED_LOOKUP
@ EXPR_COMPOUND_ASSIGN_OPERATOR
A CompoundAssignOperator record.
@ EXPR_EXPR_WITH_CLEANUPS
@ EXPR_CXX_STATIC_CAST
A CXXStaticCastExpr record.
@ STMT_OMP_META_DIRECTIVE
@ EXPR_OBJC_STRING_LITERAL
An ObjCStringLiteral record.
@ EXPR_CXX_PROPERTY_REF_EXPR
@ EXPR_SYCL_UNIQUE_STABLE_NAME
@ STMT_OMP_TARGET_DATA_DIRECTIVE
@ STMT_OMP_BARRIER_DIRECTIVE
@ EXPR_VA_ARG
A VAArgExpr record.
@ STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OPENACC_SHUTDOWN_CONSTRUCT
@ EXPR_OBJC_ISA
An ObjCIsa Expr record.
@ STMT_OMP_SINGLE_DIRECTIVE
@ STMT_OPENACC_EXIT_DATA_CONSTRUCT
@ EXPR_CXX_OPERATOR_CALL
A CXXOperatorCallExpr record.
@ STMT_OBJC_AT_TRY
An ObjCAtTryStmt record.
@ STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
@ EXPR_CXX_UNRESOLVED_CONSTRUCT
@ EXPR_FIXEDPOINT_LITERAL
@ STMT_DO
A DoStmt record.
@ STMT_OBJC_CATCH
An ObjCAtCatchStmt record.
@ STMT_OMP_TARGET_DIRECTIVE
@ STMT_IF
An IfStmt record.
@ EXPR_CXX_EXPRESSION_TRAIT
@ EXPR_STRING_LITERAL
A StringLiteral record.
@ EXPR_OBJC_AVAILABILITY_CHECK
An ObjCAvailabilityCheckExpr record.
@ STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE
@ EXPR_PSEUDO_OBJECT
A PseudoObjectExpr record.
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
@ STMT_OMP_FLUSH_DIRECTIVE
@ STMT_CAPTURED
A CapturedStmt record.
@ STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_TILE_DIRECTIVE
@ STMT_OMP_CANCELLATION_POINT_DIRECTIVE
@ STMT_GCCASM
A GCC-style AsmStmt record.
@ EXPR_IMAGINARY_LITERAL
An ImaginaryLiteral record.
@ STMT_OMP_INTERCHANGE_DIRECTIVE
@ STMT_WHILE
A WhileStmt record.
@ EXPR_CONVERT_VECTOR
A ConvertVectorExpr record.
@ EXPR_OBJC_SUBSCRIPT_REF_EXPR
An ObjCSubscriptRefExpr record.
@ STMT_OPENACC_COMPUTE_CONSTRUCT
@ STMT_OMP_TASKWAIT_DIRECTIVE
@ STMT_OMP_TASKYIELD_DIRECTIVE
@ EXPR_STMT
A StmtExpr record.
@ STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE
@ EXPR_CXX_REINTERPRET_CAST
A CXXReinterpretCastExpr record.
@ EXPR_DESIGNATED_INIT_UPDATE
A DesignatedInitUpdateExpr record.
@ STMT_OBJC_AT_SYNCHRONIZED
An ObjCAtSynchronizedStmt record.
@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TASKLOOP_SIMD_DIRECTIVE
@ STMT_MS_DEPENDENT_EXISTS
@ EXPR_BUILTIN_BIT_CAST
A BuiltinBitCastExpr record.
@ EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
@ EXPR_CXX_PSEUDO_DESTRUCTOR
@ STMT_OMP_MASKED_DIRECTIVE
@ STMT_SYCLKERNELCALL
A SYCLKernelCallStmt record.
@ STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
@ EXPR_OBJC_ENCODE
An ObjCEncodeExpr record.
@ STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
@ STMT_OMP_PARALLEL_FOR_DIRECTIVE
@ EXPR_CSTYLE_CAST
A CStyleCastExpr record.
@ STMT_OMP_PARALLEL_DIRECTIVE
@ EXPR_OBJC_BOXED_EXPRESSION
@ EXPR_OBJC_BOOL_LITERAL
An ObjCBoolLiteralExpr record.
@ EXPR_CXX_BIND_TEMPORARY
@ STMT_OMP_ATOMIC_DIRECTIVE
@ STMT_OPENACC_ATOMIC_CONSTRUCT
@ STMT_OMP_ORDERED_DIRECTIVE
@ EXPR_EXT_VECTOR_ELEMENT
An ExtVectorElementExpr record.
@ STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_CRITICAL_DIRECTIVE
@ EXPR_ATOMIC
An AtomicExpr record.
@ STMT_OPENACC_ENTER_DATA_CONSTRUCT
@ STMT_OMP_CANCEL_DIRECTIVE
@ EXPR_OFFSETOF
An OffsetOfExpr record.
@ STMT_RETURN
A ReturnStmt record.
@ STMT_OBJC_FOR_COLLECTION
An ObjCForCollectionStmt record.
@ STMT_OPENACC_CACHE_CONSTRUCT
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
@ EXPR_ARRAY_INIT_LOOP
An ArrayInitLoopExpr record.
@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE
@ STMT_CONTINUE
A ContinueStmt record.
@ EXPR_PREDEFINED
A PredefinedExpr record.
@ EXPR_OPENACC_ASTERISK_SIZE
@ STMT_OMP_DEPOBJ_DIRECTIVE
@ EXPR_CXX_BOOL_LITERAL
A CXXBoolLiteralExpr record.
@ EXPR_PAREN_LIST
A ParenListExpr record.
@ EXPR_CXX_PAREN_LIST_INIT
A CXXParenListInitExpr record.
@ STMT_OMP_DISPATCH_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OPENACC_DATA_CONSTRUCT
@ STMT_OMP_TASKLOOP_DIRECTIVE
@ STMT_COMPOUND
A CompoundStmt record.
@ STMT_OMP_CANONICAL_LOOP
@ STMT_FOR
A ForStmt record.
@ STMT_ATTRIBUTED
An AttributedStmt record.
@ STMT_OMP_PARALLEL_MASTER_DIRECTIVE
@ STMT_OPENACC_WAIT_CONSTRUCT
@ STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TEAMS_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_DIRECTIVE
@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR
A CXXRewrittenBinaryOperator record.
@ STMT_GOTO
A GotoStmt record.
@ EXPR_NO_INIT
An NoInitExpr record.
@ EXPR_OBJC_ARRAY_LITERAL
@ STMT_OMP_ERROR_DIRECTIVE
@ EXPR_OBJC_PROTOCOL_EXPR
An ObjCProtocolExpr record.
@ STMT_OMP_GENERIC_LOOP_DIRECTIVE
@ EXPR_ARRAY_INIT_INDEX
An ArrayInitIndexExpr record.
@ STMT_OMP_TASK_DIRECTIVE
@ STMT_OPENACC_INIT_CONSTRUCT
@ EXPR_CXX_CONSTRUCT
A CXXConstructExpr record.
@ STMT_OMP_PARALLEL_MASKED_DIRECTIVE
@ STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ STMT_OPENACC_UPDATE_CONSTRUCT
@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE
@ EXPR_OBJC_DICTIONARY_LITERAL
@ STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ EXPR_CXX_DYNAMIC_CAST
A CXXDynamicCastExpr record.
@ STMT_CXX_TRY
A CXXTryStmt record.
@ EXPR_GENERIC_SELECTION
A GenericSelectionExpr record.
@ STMT_OMP_TARGET_SIMD_DIRECTIVE
@ EXPR_OBJC_INDIRECT_COPY_RESTORE
An ObjCIndirectCopyRestoreExpr record.
@ EXPR_CXX_INHERITED_CTOR_INIT
A CXXInheritedCtorInitExpr record.
@ EXPR_CALL
A CallExpr record.
@ EXPR_GNU_NULL
A GNUNullExpr record.
@ EXPR_BINARY_CONDITIONAL_OPERATOR
@ EXPR_OBJC_PROPERTY_REF_EXPR
An ObjCPropertyRefExpr record.
@ STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_FOR_SIMD_DIRECTIVE
@ STMT_OMP_MASKED_TASKLOOP_DIRECTIVE
@ EXPR_CXX_CONST_CAST
A CXXConstCastExpr record.
@ STMT_OMP_SCAN_DIRECTIVE
@ STMT_REF_PTR
A reference to a previously [de]serialized Stmt record.
@ EXPR_OBJC_MESSAGE_EXPR
An ObjCMessageExpr record.
@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
@ STMT_OMP_FUSE_DIRECTIVE
@ STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE
@ STMT_CASE
A CaseStmt record.
@ EXPR_CONSTANT
A constant expression context.
@ EXPR_FUNCTION_PARM_PACK
@ STMT_STOP
A marker record that indicates that we are at the end of an expression.
@ EXPR_CXX_NULL_PTR_LITERAL
@ STMT_OMP_TARGET_UPDATE_DIRECTIVE
@ STMT_MSASM
A MS-style AsmStmt record.
@ STMT_OMP_DISTRIBUTE_DIRECTIVE
@ EXPR_CONDITIONAL_OPERATOR
A ConditionOperator record.
@ EXPR_BINARY_OPERATOR
A BinaryOperator record.
@ EXPR_CXX_STD_INITIALIZER_LIST
A CXXStdInitializerListExpr record.
@ STMT_OMP_TASKGROUP_DIRECTIVE
@ STMT_OMP_REVERSE_DIRECTIVE
@ EXPR_SHUFFLE_VECTOR
A ShuffleVectorExpr record.
@ STMT_OBJC_FINALLY
An ObjCAtFinallyStmt record.
@ EXPR_OBJC_SELECTOR_EXPR
An ObjCSelectorExpr record.
@ EXPR_FLOATING_LITERAL
A FloatingLiteral record.
@ STMT_OMP_MASTER_DIRECTIVE
@ EXPR_CXX_DEPENDENT_SCOPE_MEMBER
@ STMT_NULL_PTR
A NULL expression.
@ STMP_OMP_STRIPE_DIRECTIVE
@ STMT_DEFAULT
A DefaultStmt record.
@ EXPR_CHOOSE
A ChooseExpr record.
@ STMT_OMP_UNROLL_DIRECTIVE
@ STMT_NULL
A NullStmt record.
@ STMT_OMP_SIMD_DIRECTIVE
@ EXPR_DECL_REF
A DeclRefExpr record.
@ STMT_OPENACC_LOOP_CONSTRUCT
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
@ EXPR_INIT_LIST
An InitListExpr record.
@ EXPR_IMPLICIT_VALUE_INIT
An ImplicitValueInitExpr record.
@ STMT_OBJC_AUTORELEASE_POOL
An ObjCAutoreleasePoolStmt record.
@ STMT_OPENACC_SET_CONSTRUCT
@ EXPR_RECOVERY
A RecoveryExpr record.
@ EXPR_PAREN
A ParenExpr record.
@ STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE
@ STMT_LABEL
A LabelStmt record.
@ EXPR_CXX_FUNCTIONAL_CAST
A CXXFunctionalCastExpr record.
@ EXPR_USER_DEFINED_LITERAL
A UserDefinedLiteral record.
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
@ EXPR_SOURCE_LOC
A SourceLocExpr record.
@ EXPR_MATERIALIZE_TEMPORARY
@ EXPR_CXX_MEMBER_CALL
A CXXMemberCallExpr record.
@ STMT_OMP_INTEROP_DIRECTIVE
@ STMT_SWITCH
A SwitchStmt record.
@ STMT_DECL
A DeclStmt record.
@ EXPR_CXX_UNRESOLVED_MEMBER
@ STMT_OMP_SECTIONS_DIRECTIVE
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
@ EXPR_CXX_SCALAR_VALUE_INIT
@ STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
@ EXPR_SIZEOF_ALIGN_OF
A SizefAlignOfExpr record.
@ STMT_BREAK
A BreakStmt record.
@ STMT_OBJC_AT_THROW
An ObjCAtThrowStmt record.
@ EXPR_ADDR_LABEL
An AddrLabelExpr record.
@ STMT_CXX_FOR_RANGE
A CXXForRangeStmt record.
@ EXPR_CXX_ADDRSPACE_CAST
A CXXAddrspaceCastExpr record.
@ EXPR_ARRAY_SUBSCRIPT
An ArraySubscriptExpr record.
@ EXPR_CONCEPT_SPECIALIZATION
@ EXPR_UNARY_OPERATOR
A UnaryOperator record.
@ STMT_CXX_CATCH
A CXXCatchStmt record.
@ EXPR_BUILTIN_PP_EMBED
A EmbedExpr record.
@ STMT_INDIRECT_GOTO
An IndirectGotoStmt record.
@ DESIG_ARRAY_RANGE
GNU array range designator.
@ DESIG_FIELD_NAME
Field designator where only the field name is known.
@ DESIG_FIELD_DECL
Field designator where the field has been resolved to a declaration.
@ DESIG_ARRAY
Array designator.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
@ OK_Ordinary
An ordinary object is located at an address in memory.
OpenACCComputeConstruct(OpenACCDirectiveKind K, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)
bool isAlignedAllocation(AlignedAllocationMode Mode)
bool isTypeAwareAllocation(TypeAwareAllocationMode Mode)
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
U cast(CodeGen::Address addr)
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
SourceLocation TemplateKWLoc
The source location of the template keyword; this is used as part of the representation of qualified ...
AlignedAllocationMode PassAlignment
TypeAwareAllocationMode PassTypeIdentity
Expr * CounterUpdate
Updater for the internal counter: ++CounterVD;.
Expr * Upper
Normalized upper bound.
Expr * Update
Update expression for the originally specified iteration variable, calculated as VD = Begin + Counter...
VarDecl * CounterVD
Internal normalized counter.
Expr * Value
The value of the dictionary element.
SourceLocation EllipsisLoc
The location of the ellipsis, if this is a pack expansion.
UnsignedOrNone NumExpansions
The number of elements this pack expansion will expand to, if this is a pack expansion and is known.
Expr * Key
The key for the dictionary element.
constexpr unsigned toInternalRepresentation() const
StringRef SubstitutedEntity