13#ifndef LLVM_CLANG_AST_EXPR_H
14#define LLVM_CLANG_AST_EXPR_H
31#include "llvm/ADT/APFloat.h"
32#include "llvm/ADT/APSInt.h"
33#include "llvm/ADT/SmallVector.h"
34#include "llvm/ADT/StringRef.h"
35#include "llvm/ADT/iterator.h"
36#include "llvm/ADT/iterator_range.h"
37#include "llvm/Support/AtomicOrdering.h"
38#include "llvm/Support/Compiler.h"
39#include "llvm/Support/TrailingObjects.h"
47 class CXXBaseSpecifier;
48 class CXXMemberCallExpr;
49 class CXXOperatorCallExpr;
53 class MaterializeTemporaryExpr;
55 class ObjCPropertyRefExpr;
56 class OpaqueValueExpr;
61 class WarnUnusedResultAttr;
64typedef SmallVector<CXXBaseSpecifier*, 4>
CXXCastPath;
128 assert(
ExprBits.ObjectKind == OK &&
"truncated kind");
138 ExprBits.Dependent =
static_cast<unsigned>(Deps);
153 "Expressions can't have reference type");
178 return static_cast<bool>(
getDependence() & ExprDependence::Value);
195 return static_cast<bool>(
getDependence() & ExprDependence::Type);
224 return static_cast<bool>(
getDependence() & ExprDependence::Instantiation);
242 return static_cast<bool>(
getDependence() & ExprDependence::UnexpandedPack);
247 return static_cast<bool>(
getDependence() & ExprDependence::Error);
270 static
std::pair<const
NamedDecl *, const WarnUnusedResultAttr *>
373 unsigned short Modifiable;
376 :
Kind(k), Modifiable(m)
384 assert(Modifiable !=
CM_Untested &&
"Did not test for modifiability.");
413 return ClassifyImpl(Ctx,
nullptr);
425 return ClassifyImpl(Ctx, &
Loc);
436 return (isa<LValueReferenceType>(RT)
438 : (RT->getPointeeType()->isFunctionType()
531 return BT->getKind() == K;
554 bool IgnoreTemplateOrMacroSubstitution =
false)
const;
561 std::optional<llvm::APSInt>
600 const Expr **Culprit =
nullptr)
const;
661 bool InConstantContext =
false)
const;
668 bool InConstantContext =
false)
const;
681 bool InConstantContext =
false)
const;
688 bool InConstantContext =
false)
const;
694 bool InConstantContext =
false)
const;
709 bool IncludePossibleEffects =
true)
const;
731 bool InConstantContext =
false)
const;
740 bool IsConstantInitializer)
const;
780 unsigned Type)
const;
789 const Expr *SizeExpression,
791 EvalResult &Status)
const;
795 EvalResult &Status)
const;
1034 return T->getStmtClass() >= firstExprConstant &&
1035 T->getStmtClass() <= lastExprConstant;
1041 llvm::detail::ConstantLog2<
alignof(Expr)>::value,
1042 "PointerLikeTypeTraits<Expr*> assumes too much alignment.");
1072 return T->getStmtClass() >= firstFullExprConstant &&
1073 T->getStmtClass() <= lastFullExprConstant;
1084 private llvm::TrailingObjects<ConstantExpr, APValue, uint64_t> {
1085 static_assert(std::is_same<uint64_t, llvm::APInt::WordType>::value,
1086 "ConstantExpr assumes that llvm::APInt::WordType is uint64_t "
1087 "for tail-allocated storage");
1088 friend TrailingObjects;
1092 size_t numTrailingObjects(OverloadToken<APValue>)
const {
1095 size_t numTrailingObjects(OverloadToken<uint64_t>)
const {
1099 uint64_t &Int64Result() {
1101 "invalid accessor");
1102 return *getTrailingObjects<uint64_t>();
1104 const uint64_t &Int64Result()
const {
1105 return const_cast<ConstantExpr *
>(
this)->Int64Result();
1109 "invalid accessor");
1110 return *getTrailingObjects<APValue>();
1112 APValue &APValueResult()
const {
1113 return const_cast<ConstantExpr *
>(
this)->APValueResult();
1117 bool IsImmediateInvocation);
1121 static ConstantExpr *
Create(
const ASTContext &Context, Expr *
E,
1123 static ConstantExpr *
1124 Create(
const ASTContext &Context, Expr *
E,
1126 bool IsImmediateInvocation =
false);
1127 static ConstantExpr *
CreateEmpty(
const ASTContext &Context,
1132 const ASTContext &Context);
1142 return T->getStmtClass() == ConstantExprClass;
1187 :
Expr(OpaqueValueExprClass,
T,
VK, OK), SourceExpr(SourceExpr) {
1233 assert((!
V || SourceExpr) &&
1234 "unique OVEs are expected to have source expressions");
1241 return T->getStmtClass() == OpaqueValueExprClass;
1270 private llvm::TrailingObjects<DeclRefExpr, NestedNameSpecifierLoc,
1271 NamedDecl *, ASTTemplateKWAndArgsInfo,
1272 TemplateArgumentLoc> {
1275 friend TrailingObjects;
1284 size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>)
const {
1288 size_t numTrailingObjects(OverloadToken<NamedDecl *>)
const {
1289 return hasFoundDecl();
1292 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
1300 DeclRefExpr(
const ASTContext &Ctx, NestedNameSpecifierLoc QualifierLoc,
1301 SourceLocation TemplateKWLoc, ValueDecl *
D,
1302 bool RefersToEnclosingVariableOrCapture,
1303 const DeclarationNameInfo &NameInfo, NamedDecl *FoundD,
1304 const TemplateArgumentListInfo *TemplateArgs, QualType
T,
1308 explicit DeclRefExpr(EmptyShell
Empty) :
Expr(DeclRefExprClass,
Empty) {}
1311 DeclRefExpr(
const ASTContext &Ctx, ValueDecl *
D,
1312 bool RefersToEnclosingVariableOrCapture, QualType
T,
1314 const DeclarationNameLoc &LocInfo = DeclarationNameLoc(),
1317 static DeclRefExpr *
1318 Create(
const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
1319 SourceLocation TemplateKWLoc, ValueDecl *
D,
1320 bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc,
1322 const TemplateArgumentListInfo *TemplateArgs =
nullptr,
1325 static DeclRefExpr *
1326 Create(
const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
1327 SourceLocation TemplateKWLoc, ValueDecl *
D,
1328 bool RefersToEnclosingVariableOrCapture,
1330 NamedDecl *FoundD =
nullptr,
1331 const TemplateArgumentListInfo *TemplateArgs =
nullptr,
1335 static DeclRefExpr *
CreateEmpty(
const ASTContext &Context,
bool HasQualifier,
1337 bool HasTemplateKWAndArgsInfo,
1338 unsigned NumTemplateArgs);
1368 return *getTrailingObjects<NestedNameSpecifierLoc>();
1384 return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() :
D;
1390 return hasFoundDecl() ? *getTrailingObjects<NamedDecl *>() :
D;
1402 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
1410 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
1418 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
1433 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
1434 getTrailingObjects<TemplateArgumentLoc>(), List);
1442 return getTrailingObjects<TemplateArgumentLoc>();
1450 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
1489 return DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter;
1499 return T->getStmtClass() == DeclRefExprClass;
1543 return T->getStmtClass() == IntegerLiteralClass;
1561 :
Expr(FixedPointLiteralClass,
Empty) {}
1569 const llvm::APInt &
V,
1591 return T->getStmtClass() == FixedPointLiteralClass;
1640 return T->getStmtClass() == CharacterLiteralClass;
1672 assert(&
getSemantics() == &Val.getSemantics() &&
"Inconsistent semantics");
1679 return static_cast<llvm::APFloatBase::Semantics
>(
1691 return llvm::APFloatBase::EnumToSemantics(
1692 static_cast<llvm::APFloatBase::Semantics
>(
1716 return T->getStmtClass() == FloatingLiteralClass;
1743 :
Expr(ImaginaryLiteralClass,
Empty) { }
1755 return T->getStmtClass() == ImaginaryLiteralClass;
1800 private llvm::TrailingObjects<StringLiteral, unsigned, SourceLocation,
1803 friend TrailingObjects;
1819 unsigned numTrailingObjects(OverloadToken<unsigned>)
const {
return 1; }
1820 unsigned numTrailingObjects(OverloadToken<SourceLocation>)
const {
1824 unsigned numTrailingObjects(OverloadToken<char>)
const {
1828 char *getStrDataAsChar() {
return getTrailingObjects<char>(); }
1829 const char *getStrDataAsChar()
const {
return getTrailingObjects<char>(); }
1831 const uint16_t *getStrDataAsUInt16()
const {
1832 return reinterpret_cast<const uint16_t *
>(getTrailingObjects<char>());
1835 const uint32_t *getStrDataAsUInt32()
const {
1836 return reinterpret_cast<const uint32_t *
>(getTrailingObjects<char>());
1841 bool Pascal, QualType Ty, ArrayRef<SourceLocation> Locs);
1844 StringLiteral(EmptyShell
Empty,
unsigned NumConcatenated,
unsigned Length,
1845 unsigned CharByteWidth);
1848 static unsigned mapCharByteWidth(TargetInfo
const &
Target,
1852 void setStrTokenLoc(
unsigned TokNum, SourceLocation L) {
1854 getTrailingObjects<SourceLocation>()[TokNum] = L;
1860 static StringLiteral *
Create(
const ASTContext &Ctx, StringRef Str,
1862 ArrayRef<SourceLocation> Locs);
1865 static StringLiteral *
CreateEmpty(
const ASTContext &Ctx,
1866 unsigned NumConcatenated,
unsigned Length,
1867 unsigned CharByteWidth);
1871 "This function is used in places that assume strings use char");
1885 assert(i <
getLength() &&
"out of bounds access");
1888 return static_cast<unsigned char>(getStrDataAsChar()[i]);
1890 return getStrDataAsUInt16()[i];
1892 return getStrDataAsUInt32()[i];
1894 llvm_unreachable(
"Unsupported character width!");
1904 llvm::APInt AInt(Width, (uint64_t)
V);
1905 V = AInt.getSExtValue();
1911 unsigned getLength()
const {
return *getTrailingObjects<unsigned>(); }
1949 return getTrailingObjects<SourceLocation>()[TokNum];
1962 unsigned *StartToken =
nullptr,
1963 unsigned *StartTokenByteOffset =
nullptr)
const;
1968 return getTrailingObjects<SourceLocation>();
1979 return T->getStmtClass() == StringLiteralClass;
2007 private llvm::TrailingObjects<PredefinedExpr, Stmt *> {
2009 friend TrailingObjects;
2024 assert(hasFunctionName() &&
2025 "This PredefinedExpr has no storage for a function name!");
2026 *getTrailingObjects() = SL;
2034 static PredefinedExpr *
Create(
const ASTContext &Ctx, SourceLocation L,
2036 bool IsTransparent, StringLiteral *SL);
2039 static PredefinedExpr *
CreateEmpty(
const ASTContext &Ctx,
2040 bool HasFunctionName);
2052 return hasFunctionName()
2058 return hasFunctionName()
2069 const Decl *CurrentDecl,
2070 bool ForceElaboratedPrinting =
false);
2076 return T->getStmtClass() == PredefinedExprClass;
2081 return child_range(getTrailingObjects(hasFunctionName()));
2098 AsteriskLoc(AsteriskLoc) {}
2103 static OpenACCAsteriskSizeExpr *
Create(
const ASTContext &
C,
2104 SourceLocation
Loc);
2105 static OpenACCAsteriskSizeExpr *
CreateEmpty(
const ASTContext &
C);
2112 return T->getStmtClass() == OpenACCAsteriskSizeExprClass;
2141 void setLParenLocation(SourceLocation L) { LParen = L; }
2142 void setRParenLocation(SourceLocation L) { RParen = L; }
2162 return T->getStmtClass() == SYCLUniqueStableNameExprClass;
2192 L(l), R(r), Val(val) {
2217 return T->getStmtClass() == ParenExprClass;
2230 ParenExprBits.ProducedByFoldExpansion = ProducedByFoldExpansion;
2246 private llvm::TrailingObjects<UnaryOperator, FPOptionsOverride> {
2251 return *getTrailingObjects();
2256 return *getTrailingObjects();
2317 return Op == UO_PostInc || Op == UO_PostDec;
2322 return Op == UO_PreInc || Op == UO_PreDec;
2329 return Op == UO_PreInc || Op == UO_PostInc;
2336 return Op == UO_PreDec || Op == UO_PostDec;
2348 return Op >= UO_Plus && Op <= UO_LNot;
2373 return T->getStmtClass() == UnaryOperatorClass;
2387 return getTrailingFPFeatures();
2439 enum { MaskBits = 2, Mask = 0x03 };
2463 :
Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
2469 :
Range(DotLoc.isValid() ? DotLoc : NameLoc, NameLoc),
2529 private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {
2538 size_t numTrailingObjects(OverloadToken<OffsetOfNode>)
const {
2547 explicit OffsetOfExpr(
unsigned numComps,
unsigned numExprs)
2549 TSInfo(
nullptr), NumComps(numComps), NumExprs(numExprs) {}
2559 unsigned NumComps,
unsigned NumExprs);
2577 return getTrailingObjects<OffsetOfNode>(NumComps)[Idx];
2581 getTrailingObjects<OffsetOfNode>(NumComps)[Idx] = ON;
2589 return getTrailingObjects<Expr *>(NumExprs)[Idx];
2593 return getTrailingObjects<Expr *>(NumExprs)[Idx];
2597 getTrailingObjects<Expr *>(NumComps)[Idx] =
E;
2608 return T->getStmtClass() == OffsetOfExprClass;
2613 Stmt **begin =
reinterpret_cast<Stmt **
>(getTrailingObjects<Expr *>());
2617 Stmt *
const *begin =
2618 reinterpret_cast<Stmt *
const *
>(getTrailingObjects<Expr *>());
2640 OpLoc(op), RParenLoc(rp) {
2641 assert(ExprKind <=
UETT_Last &&
"invalid enum value!");
2643 assert(
static_cast<unsigned>(ExprKind) ==
2645 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
2647 Argument.Ty = TInfo;
2657 :
Expr(UnaryExprOrTypeTraitExprClass,
Empty) { }
2663 assert(K <=
UETT_Last &&
"invalid enum value!");
2666 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
2674 assert(
isArgumentType() &&
"calling getArgumentType() when arg is expr");
2678 assert(!
isArgumentType() &&
"calling getArgumentExpr() when arg is type");
2679 return static_cast<Expr*
>(Argument.Ex);
2690 Argument.Ty = TInfo;
2710 return T->getStmtClass() == UnaryExprOrTypeTraitExprClass;
2724 enum { LHS, RHS, END_EXPR };
2725 Stmt *SubExprs[END_EXPR];
2732 :
Expr(ArraySubscriptExprClass, t,
VK, OK) {
2733 SubExprs[LHS] = lhs;
2734 SubExprs[RHS] = rhs;
2741 :
Expr(ArraySubscriptExprClass, Shell) { }
2783 return T->getStmtClass() == ArraySubscriptExprClass;
2788 return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
2802 enum { BASE, ROW_IDX, COLUMN_IDX, END_EXPR };
2803 Stmt *SubExprs[END_EXPR];
2810 SubExprs[BASE] =
Base;
2811 SubExprs[ROW_IDX] = RowIdx;
2812 SubExprs[COLUMN_IDX] = ColumnIdx;
2819 :
Expr(MatrixSubscriptExprClass, Shell) {}
2823 assert((SubExprs[COLUMN_IDX] || IsIncomplete) &&
2824 "expressions without column index must be marked as incomplete");
2825 return IsIncomplete;
2838 "cannot get the column index of an incomplete expression");
2839 return cast<Expr>(SubExprs[COLUMN_IDX]);
2861 return T->getStmtClass() == MatrixSubscriptExprClass;
2866 return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR);
2880 enum { FN = 0, PREARGS_START = 1 };
2917 template <
typename T>
2918 static constexpr unsigned
2926 Stmt **getTrailingStmts() {
2927 return reinterpret_cast<Stmt **
>(
reinterpret_cast<char *
>(
this) +
2930 Stmt *
const *getTrailingStmts()
const {
2931 return const_cast<CallExpr *
>(
this)->getTrailingStmts();
2934 unsigned getSizeOfTrailingStmts()
const {
2938 size_t getOffsetOfTrailingFPFeatures()
const {
2963 bool HasFPFeatures) {
2964 return (1 + NumPreArgs + NumArgs) *
sizeof(
Stmt *) +
2969 assert(I <
getNumPreArgs() &&
"Prearg access out of range!");
2970 return getTrailingStmts()[PREARGS_START + I];
2973 assert(I <
getNumPreArgs() &&
"Prearg access out of range!");
2974 return getTrailingStmts()[PREARGS_START + I];
2977 assert(I <
getNumPreArgs() &&
"Prearg access out of range!");
2978 getTrailingStmts()[PREARGS_START + I] = PreArg;
2988 getSizeOfTrailingStmts());
2994 getSizeOfTrailingStmts());
3024 bool HasFPFeatures, EmptyShell
Empty);
3041 return CallExprBits.ExplicitObjectMemFunUsingMemberSyntax;
3049 updateTrailingSourceLoc();
3074 return reinterpret_cast<Expr **
>(getTrailingStmts() + PREARGS_START +
3078 return reinterpret_cast<const Expr *
const *
>(
3084 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
3088 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
3097 assert(Arg <
getNumArgs() &&
"Arg access out of range!");
3105 ArrayRef(
reinterpret_cast<Expr **
>(getTrailingStmts() + PREARGS_START),
3117 "shrinkNumArgs cannot increase the number of arguments!");
3118 NumArgs = NewNumArgs;
3137 return getTrailingStmts() + PREARGS_START +
getNumPreArgs();
3142 return getTrailingStmts() + PREARGS_START +
getNumPreArgs();
3200 std::pair<const NamedDecl *, const WarnUnusedResultAttr *>
3218 reinterpret_cast<const char *
>(
this + 1));
3236 bool hasTrailingSourceLoc()
const {
3240 void updateTrailingSourceLoc() {
3242 "Trailing source loc already set?");
3244 "Calling setTrailingSourceLocs on a subclass of CallExpr");
3249 reinterpret_cast<SourceLocation *
>(
reinterpret_cast<char *
>(
this + 1));
3271 std::optional<llvm::APInt>
3277 return T->getStmtClass() >= firstCallExprConstant &&
3278 T->getStmtClass() <= lastCallExprConstant;
3283 return child_range(getTrailingStmts(), getTrailingStmts() + PREARGS_START +
3289 getTrailingStmts() + PREARGS_START +
3298 private llvm::TrailingObjects<MemberExpr, NestedNameSpecifierLoc,
3299 DeclAccessPair, ASTTemplateKWAndArgsInfo,
3300 TemplateArgumentLoc> {
3304 friend TrailingObjects;
3321 size_t numTrailingObjects(OverloadToken<NestedNameSpecifierLoc>)
const {
3325 size_t numTrailingObjects(OverloadToken<DeclAccessPair>)
const {
3326 return hasFoundDecl();
3329 size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>)
const {
3330 return hasTemplateKWAndArgsInfo();
3333 bool hasFoundDecl()
const {
return MemberExprBits.HasFoundDecl; }
3335 bool hasTemplateKWAndArgsInfo()
const {
3339 MemberExpr(
Expr *
Base,
bool IsArrow, SourceLocation OperatorLoc,
3340 NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
3341 ValueDecl *MemberDecl, DeclAccessPair FoundDecl,
3342 const DeclarationNameInfo &NameInfo,
3343 const TemplateArgumentListInfo *TemplateArgs, QualType
T,
3345 MemberExpr(EmptyShell
Empty)
3349 static MemberExpr *
Create(
const ASTContext &
C,
Expr *
Base,
bool IsArrow,
3350 SourceLocation OperatorLoc,
3351 NestedNameSpecifierLoc QualifierLoc,
3352 SourceLocation TemplateKWLoc, ValueDecl *MemberDecl,
3353 DeclAccessPair FoundDecl,
3354 DeclarationNameInfo MemberNameInfo,
3355 const TemplateArgumentListInfo *TemplateArgs,
3373 bool HasTemplateKWAndArgsInfo,
3374 unsigned NumTemplateArgs);
3388 if (!hasFoundDecl())
3391 return *getTrailingObjects<DeclAccessPair>();
3405 return *getTrailingObjects<NestedNameSpecifierLoc>();
3418 if (!hasTemplateKWAndArgsInfo())
3420 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
3426 if (!hasTemplateKWAndArgsInfo())
3428 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
3434 if (!hasTemplateKWAndArgsInfo())
3436 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
3450 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
3451 getTrailingObjects<TemplateArgumentLoc>(), List);
3460 return getTrailingObjects<TemplateArgumentLoc>();
3469 return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
3479 MemberLoc, MemberDNLoc);
3529 return T->getStmtClass() == MemberExprClass;
3550 llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfoAndScope;
3554 mutable APValue *StaticValue =
nullptr;
3560 LParenLoc(lparenloc), TInfoAndScope(tinfo, fileScope), Init(init) {
3561 assert(Init &&
"Init is a nullptr");
3567 :
Expr(CompoundLiteralExprClass,
Empty) { }
3580 return TInfoAndScope.getPointer();
3583 TInfoAndScope.setPointer(tinfo);
3592 return Init->getBeginLoc();
3598 return T->getStmtClass() == CompoundLiteralExprClass;
3615 bool CastConsistency()
const;
3618 return const_cast<CastExpr*
>(
this)->path_buffer();
3626 Expr *op,
unsigned BasePathSize,
bool HasFPFeatures)
3632 "BasePathSize overflow!");
3633 assert(CastConsistency());
3645 "BasePathSize overflow!");
3699 llvm::iterator_range<path_iterator>
path() {
3702 llvm::iterator_range<path_const_iterator>
path()
const {
3757 return T->getStmtClass() >= firstCastExprConstant &&
3758 T->getStmtClass() <= lastCastExprConstant;
3788 private llvm::TrailingObjects<ImplicitCastExpr, CXXBaseSpecifier *,
3789 FPOptionsOverride> {
3794 :
CastExpr(ImplicitCastExprClass, ty,
VK, kind, op, BasePathLength,
3804 :
CastExpr(ImplicitCastExprClass, Shell, PathSize, HasFPFeatures) {}
3806 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)
const {
3814 :
CastExpr(ImplicitCastExprClass, ty,
VK, kind, op, 0,
3815 FPO.requiresTrailingStorage()) {
3831 unsigned PathSize,
bool HasFPFeatures);
3841 return T->getStmtClass() == ImplicitCastExprClass;
3873 :
CastExpr(SC, exprTy,
VK, kind, op, PathSize, HasFPFeatures),
3881 :
CastExpr(SC, Shell, PathSize, HasFPFeatures) {}
3894 return T->getStmtClass() >= firstExplicitCastExprConstant &&
3895 T->getStmtClass() <= lastExplicitCastExprConstant;
3904 private llvm::TrailingObjects<CStyleCastExpr, CXXBaseSpecifier *,
3905 FPOptionsOverride> {
3914 LPLoc(l), RPLoc(r) {
3924 unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>)
const {
3935 unsigned PathSize,
bool HasFPFeatures);
3949 return T->getStmtClass() == CStyleCastExprClass;
3975 enum { LHS, RHS, END_EXPR };
3976 Stmt *SubExprs[END_EXPR];
4052 return Opc == BO_PtrMemD || Opc == BO_PtrMemI;
4057 return Opc >= BO_Mul && Opc <= BO_Rem;
4083 llvm_unreachable(
"Not a comparison operator.");
4084 case BO_LT:
return BO_GE;
4085 case BO_GT:
return BO_LE;
4086 case BO_LE:
return BO_GT;
4087 case BO_GE:
return BO_LT;
4088 case BO_EQ:
return BO_NE;
4089 case BO_NE:
return BO_EQ;
4096 llvm_unreachable(
"Not a comparison operator.");
4097 case BO_LT:
return BO_GT;
4098 case BO_GT:
return BO_LT;
4099 case BO_LE:
return BO_GE;
4100 case BO_GE:
return BO_LE;
4111 return Opc >= BO_Assign && Opc <= BO_OrAssign;
4116 return Opc > BO_Assign && Opc <= BO_OrAssign;
4123 if (Opc >= BO_AndAssign)
4124 return Opcode(
unsigned(Opc) - BO_AndAssign + BO_And);
4126 return Opcode(
unsigned(Opc) - BO_MulAssign + BO_Mul);
4130 return Opc == BO_ShlAssign || Opc == BO_ShrAssign;
4144 return S->getStmtClass() >= firstBinaryOperatorConstant &&
4145 S->getStmtClass() <= lastBinaryOperatorConstant;
4150 return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
4252 ComputationLHSType(CompLHSType), ComputationResultType(CompResultType) {
4254 "Only should be used for compound assignments");
4259 bool hasFPFeatures);
4277 return S->getStmtClass() == CompoundAssignOperatorClass;
4297 :
Expr(SC,
T,
VK, OK), QuestionLoc(qloc), ColonLoc(cloc) {}
4320 return T->getStmtClass() == ConditionalOperatorClass ||
4321 T->getStmtClass() == BinaryConditionalOperatorClass;
4328 enum { COND, LHS, RHS, END_EXPR };
4329 Stmt* SubExprs[END_EXPR];
4338 SubExprs[COND] = cond;
4339 SubExprs[LHS] = lhs;
4340 SubExprs[RHS] = rhs;
4372 return T->getStmtClass() == ConditionalOperatorClass;
4377 return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
4390 enum { COMMON, COND, LHS, RHS, NUM_SUBEXPRS };
4397 Stmt *SubExprs[NUM_SUBEXPRS];
4408 OpaqueValue(opaqueValue) {
4409 SubExprs[COMMON] = common;
4410 SubExprs[COND] = cond;
4411 SubExprs[LHS] = lhs;
4412 SubExprs[RHS] = rhs;
4413 assert(OpaqueValue->
getSourceExpr() == common &&
"Wrong opaque value");
4437 return cast<Expr>(SubExprs[LHS]);
4444 return cast<Expr>(SubExprs[RHS]);
4455 return T->getStmtClass() == BinaryConditionalOperatorClass;
4460 return child_range(SubExprs, SubExprs + NUM_SUBEXPRS);
4469 return co->getCond();
4470 return cast<BinaryConditionalOperator>(
this)->getCond();
4475 return co->getTrueExpr();
4476 return cast<BinaryConditionalOperator>(
this)->getTrueExpr();
4481 return co->getFalseExpr();
4482 return cast<BinaryConditionalOperator>(
this)->getFalseExpr();
4493 LabelLoc(LLoc),
Label(L) {
4513 return T->getStmtClass() == AddrLabelExprClass;
4538 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4563 return T->getStmtClass() == StmtExprClass;
4594 :
Expr(ShuffleVectorExprClass,
Empty), SubExprs(nullptr) { }
4606 return T->getStmtClass() == ShuffleVectorExprClass;
4620 "Arg access out of range!");
4621 return cast<Expr>(SubExprs[Index]);
4625 "Arg access out of range!");
4626 return cast<Expr>(SubExprs[Index]);
4633 "Shuffle idx out of range!");
4634 assert(isa<ConstantExpr>(
getExpr(N + 2)) &&
4635 "Index expression must be a ConstantExpr");
4636 return cast<ConstantExpr>(
getExpr(N + 2))->getAPValueResult().getInt();
4655 private llvm::TrailingObjects<ConvertVectorExpr, FPOptionsOverride> {
4661 friend TrailingObjects;
4673 :
Expr(ConvertVectorExprClass, DstType,
VK, OK), SrcExpr(SrcExpr),
4674 TInfo(TI), BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {
4681 size_t numTrailingObjects(OverloadToken<FPOptionsOverride>)
const {
4685 FPOptionsOverride &getTrailingFPFeatures() {
4687 return *getTrailingObjects();
4690 const FPOptionsOverride &getTrailingFPFeatures()
const {
4692 return *getTrailingObjects();
4696 static ConvertVectorExpr *
CreateEmpty(
const ASTContext &
C,
4697 bool hasFPFeatures);
4699 static ConvertVectorExpr *
Create(
const ASTContext &
C,
Expr *SrcExpr,
4700 TypeSourceInfo *TI, QualType DstType,
4702 SourceLocation BuiltinLoc,
4703 SourceLocation RParenLoc,
4704 FPOptionsOverride FPFeatures);
4719 return getTrailingFPFeatures();
4765 return T->getStmtClass() == ConvertVectorExprClass;
4785 enum { COND, LHS, RHS, END_EXPR };
4786 Stmt* SubExprs[END_EXPR];
4793 :
Expr(ChooseExprClass, t,
VK, OK), BuiltinLoc(BLoc), RParenLoc(RP) {
4795 SubExprs[COND] = cond;
4796 SubExprs[LHS] = lhs;
4797 SubExprs[RHS] = rhs;
4809 "Dependent condition isn't true or false");
4841 return T->getStmtClass() == ChooseExprClass;
4846 return child_range(&SubExprs[0], &SubExprs[0]+END_EXPR);
4880 return T->getStmtClass() == GNUNullExprClass;
4895 llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
4901 TInfo(TInfo, IsMS), BuiltinLoc(BLoc), RParenLoc(RPLoc) {
4907 :
Expr(VAArgExprClass,
Empty), Val(nullptr), TInfo(nullptr,
false) {}
4930 return T->getStmtClass() == VAArgExprClass;
4968 const Expr *DefaultExpr)
const;
4989 llvm_unreachable(
"unknown source location expression kind");
5010 return T->getStmtClass() == SourceLocExprClass;
5068 unsigned NumOfElements;
5072 unsigned Begin,
unsigned NumOfElements);
5092 template <
bool Const>
5094 :
public llvm::iterator_facade_base<
5095 ChildElementIter<Const>, std::random_access_iterator_tag,
5096 std::conditional_t<Const, const IntegerLiteral *,
5097 IntegerLiteral *>> {
5101 unsigned long long CurOffset = ULLONG_MAX;
5102 using BaseTy =
typename ChildElementIter::iterator_facade_base;
5106 CurOffset =
E->getStartingElementPos();
5112 assert(EExpr && CurOffset != ULLONG_MAX &&
5113 "trying to dereference an invalid iterator");
5121 return const_cast<typename BaseTy::reference
>(EExpr->FakeChildNode);
5124 using BaseTy::operator++;
5126 assert(EExpr &&
"trying to increment an invalid iterator");
5127 assert(CurOffset != ULLONG_MAX &&
5128 "Already at the end of what we can iterate over");
5131 CurOffset = ULLONG_MAX;
5137 return (EExpr ==
Other.EExpr && CurOffset ==
Other.CurOffset);
5165 return T->getStmtClass() == EmbedExprClass;
5174 template <
typename Call,
typename... Targs>
5176 Targs &&...Fargs)
const {
5178 if (!std::invoke(std::forward<Call>(
C),
const_cast<IntegerLiteral *
>(It),
5179 StartingIndexInArray, std::forward<Targs>(Fargs)...))
5181 StartingIndexInArray++;
5246 llvm::PointerIntPair<InitListExpr *, 1, bool> AltForm;
5255 llvm::PointerUnion<Expr *, FieldDecl *> ArrayFillerOrUnionFieldInit;
5263 :
Expr(InitListExprClass,
Empty), AltForm(nullptr,
true) { }
5270 unsigned Sum = InitExprs.
size();
5271 for (
auto *IE : InitExprs)
5272 if (
auto *EE = dyn_cast<EmbedExpr>(IE))
5273 Sum += EE->getDataElementCount() - 1;
5282 return reinterpret_cast<Expr *
const *
>(InitExprs.
data());
5291 return cast_or_null<Expr>(InitExprs[
Init]);
5296 return cast_or_null<Expr>(InitExprs[
Init]);
5338 return dyn_cast_if_present<Expr *>(ArrayFillerOrUnionFieldInit);
5351 return llvm::any_of(
5352 *
this, [](
const Stmt *S) {
return isa<DesignatedInitExpr>(S); });
5362 return dyn_cast_if_present<FieldDecl *>(ArrayFillerOrUnionFieldInit);
5368 assert((FD ==
nullptr
5371 &&
"Only one field of a union may be initialized at a time!");
5372 ArrayFillerOrUnionFieldInit = FD;
5406 return !AltForm.getInt() || !AltForm.getPointer();
5413 AltForm.setPointer(
Init);
5414 AltForm.setInt(
true);
5415 Init->AltForm.setPointer(
this);
5416 Init->AltForm.setInt(
false);
5430 return T->getStmtClass() == InitListExprClass;
5442 if (InitExprs.
empty())
5487 private llvm::TrailingObjects<DesignatedInitExpr, Stmt *> {
5499 LLVM_PREFERRED_TYPE(
bool)
5500 unsigned GNUSyntax : 1;
5503 unsigned NumDesignators : 15;
5508 unsigned NumSubExprs : 16;
5521 NumDesignators(0), NumSubExprs(NumSubExprs), Designators(
nullptr) { }
5532 struct FieldDesignatorInfo {
5549 : NameOrField(
reinterpret_cast<uintptr_t>(II) | 0x1), DotLoc(DotLoc),
5550 FieldLoc(FieldLoc) {}
5554 struct ArrayOrRangeDesignatorInfo {
5569 ArrayOrRangeDesignatorInfo(
unsigned Index,
SourceLocation LBracketLoc,
5571 : Index(Index), LBracketLoc(LBracketLoc), RBracketLoc(RBracketLoc) {}
5573 ArrayOrRangeDesignatorInfo(
unsigned Index,
5577 : Index(Index), LBracketLoc(LBracketLoc), EllipsisLoc(EllipsisLoc),
5578 RBracketLoc(RBracketLoc) {}
5582 enum DesignatorKind {
5585 ArrayRangeDesignator
5588 DesignatorKind Kind;
5615 new (&
D.FieldInfo) FieldDesignatorInfo(FieldName, DotLoc, FieldLoc);
5651 new (&
D.ArrayOrRangeInfo) ArrayOrRangeDesignatorInfo(Index, LBracketLoc,
5662 new (&
D.ArrayOrRangeInfo) ArrayOrRangeDesignatorInfo(Index, LBracketLoc,
5670 "Only valid on an array or array-range designator");
5676 "Only valid on an array or array-range designator");
5682 "Only valid on an array-range designator");
5688 "Only valid on an array or array-range designator");
5714 unsigned NumIndexExprs);
5717 unsigned size()
const {
return NumDesignators; }
5721 return {Designators, NumDesignators};
5725 return {Designators, NumDesignators};
5734 unsigned NumDesigs);
5770 return cast<Expr>(getTrailingObjects(NumSubExprs)[Idx]);
5774 getTrailingObjects(NumSubExprs)[Idx] =
E;
5788 return T->getStmtClass() == DesignatedInitExprClass;
5793 Stmt **begin = getTrailingObjects();
5797 Stmt *
const *begin = getTrailingObjects();
5824 return T->getStmtClass() == NoInitExprClass;
5853 Stmt *BaseAndUpdaterExprs[2];
5860 :
Expr(DesignatedInitUpdateExprClass,
Empty) { }
5866 return T->getStmtClass() == DesignatedInitUpdateExprClass;
5873 return cast<InitListExpr>(BaseAndUpdaterExprs[1]);
5880 return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2);
5884 &BaseAndUpdaterExprs[0] + 2);
5908 :
Expr(ArrayInitLoopExprClass,
Empty), SubExprs{} {}
5913 SubExprs{CommonInit, ElementInit} {
5920 return cast<OpaqueValueExpr>(SubExprs[0]);
5927 return cast<ConstantArrayType>(
getType()->castAsArrayTypeUnsafe())
5932 return S->getStmtClass() == ArrayInitLoopExprClass;
5959 :
Expr(ArrayInitIndexExprClass,
Empty) {}
5968 return S->getStmtClass() == ArrayInitIndexExprClass;
6002 :
Expr(ImplicitValueInitExprClass,
Empty) { }
6005 return T->getStmtClass() == ImplicitValueInitExprClass;
6022 private llvm::TrailingObjects<ParenListExpr, Stmt *> {
6024 friend TrailingObjects;
6067 return T->getStmtClass() == ParenListExprClass;
6113 private llvm::TrailingObjects<GenericSelectionExpr, Stmt *,
6117 friend TrailingObjects;
6123 unsigned NumAssocs : 15;
6124 unsigned ResultIndex : 15;
6125 LLVM_PREFERRED_TYPE(
bool)
6126 unsigned IsExprPredicate : 1;
6128 ResultDependentIndex = 0x7FFF
6131 unsigned getIndexOfControllingExpression()
const {
6135 assert(
isExprPredicate() &&
"Asking for the controlling expression of a "
6136 "selection expr predicated by a type");
6140 unsigned getIndexOfControllingType()
const {
6144 "selection expr predicated by an expression");
6148 unsigned getIndexOfStartOfAssociatedExprs()
const {
6155 unsigned getIndexOfStartOfAssociatedTypes()
const {
6164 SourceLocation DefaultLoc, RParenLoc;
6175 unsigned numTrailingObjects(OverloadToken<Stmt *>)
const {
6181 unsigned numTrailingObjects(OverloadToken<TypeSourceInfo *>)
const {
6187 template <
bool Const>
class AssociationIteratorTy;
6191 template <
bool Const>
class AssociationTy {
6192 friend class GenericSelectionExpr;
6193 template <
bool OtherConst>
friend class AssociationIteratorTy;
6194 using ExprPtrTy = std::conditional_t<Const, const Expr *, Expr *>;
6196 std::conditional_t<Const, const TypeSourceInfo *, TypeSourceInfo *>;
6200 AssociationTy(ExprPtrTy
E, TSIPtrTy TSI,
bool Selected)
6201 :
E(
E), TSI(TSI), Selected(Selected) {}
6204 ExprPtrTy getAssociationExpr()
const {
return E; }
6205 TSIPtrTy getTypeSourceInfo()
const {
return TSI; }
6206 QualType getType()
const {
return TSI ? TSI->getType() : QualType(); }
6207 bool isSelected()
const {
return Selected; }
6208 AssociationTy *operator->() {
return this; }
6209 const AssociationTy *operator->()
const {
return this; }
6216 template <
bool Const>
6217 class AssociationIteratorTy
6218 :
public llvm::iterator_facade_base<
6219 AssociationIteratorTy<Const>, std::input_iterator_tag,
6220 AssociationTy<Const>, std::ptrdiff_t, AssociationTy<Const>,
6221 AssociationTy<Const>> {
6222 friend class GenericSelectionExpr;
6236 using BaseTy =
typename AssociationIteratorTy::iterator_facade_base;
6237 using StmtPtrPtrTy =
6238 std::conditional_t<Const, const Stmt *const *, Stmt **>;
6239 using TSIPtrPtrTy = std::conditional_t<
Const,
const TypeSourceInfo *
const *,
6241 StmtPtrPtrTy
E =
nullptr;
6243 unsigned Offset = 0, SelectedOffset = 0;
6244 AssociationIteratorTy(StmtPtrPtrTy
E, TSIPtrPtrTy TSI,
unsigned Offset,
6245 unsigned SelectedOffset)
6246 :
E(
E), TSI(TSI), Offset(Offset), SelectedOffset(SelectedOffset) {}
6249 AssociationIteratorTy() :
E(nullptr), TSI(nullptr) {}
6250 typename BaseTy::reference
operator*()
const {
6251 return AssociationTy<Const>(cast<Expr>(*
E), *TSI,
6252 Offset == SelectedOffset);
6254 typename BaseTy::pointer operator->()
const {
return **
this; }
6255 using BaseTy::operator++;
6256 AssociationIteratorTy &operator++() {
6267 GenericSelectionExpr(
const ASTContext &Context, SourceLocation GenericLoc,
6268 Expr *ControllingExpr,
6269 ArrayRef<TypeSourceInfo *> AssocTypes,
6270 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6271 SourceLocation RParenLoc,
6272 bool ContainsUnexpandedParameterPack,
6273 unsigned ResultIndex);
6277 GenericSelectionExpr(
const ASTContext &Context, SourceLocation GenericLoc,
6278 Expr *ControllingExpr,
6279 ArrayRef<TypeSourceInfo *> AssocTypes,
6280 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6281 SourceLocation RParenLoc,
6282 bool ContainsUnexpandedParameterPack);
6286 GenericSelectionExpr(
const ASTContext &Context, SourceLocation GenericLoc,
6287 TypeSourceInfo *ControllingType,
6288 ArrayRef<TypeSourceInfo *> AssocTypes,
6289 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6290 SourceLocation RParenLoc,
6291 bool ContainsUnexpandedParameterPack,
6292 unsigned ResultIndex);
6296 GenericSelectionExpr(
const ASTContext &Context, SourceLocation GenericLoc,
6297 TypeSourceInfo *ControllingType,
6298 ArrayRef<TypeSourceInfo *> AssocTypes,
6299 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6300 SourceLocation RParenLoc,
6301 bool ContainsUnexpandedParameterPack);
6304 explicit GenericSelectionExpr(EmptyShell
Empty,
unsigned NumAssocs);
6309 static GenericSelectionExpr *
6310 Create(
const ASTContext &Context, SourceLocation GenericLoc,
6311 Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
6312 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6313 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack,
6314 unsigned ResultIndex);
6318 static GenericSelectionExpr *
6319 Create(
const ASTContext &Context, SourceLocation GenericLoc,
6320 Expr *ControllingExpr, ArrayRef<TypeSourceInfo *> AssocTypes,
6321 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6322 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack);
6326 static GenericSelectionExpr *
6327 Create(
const ASTContext &Context, SourceLocation GenericLoc,
6328 TypeSourceInfo *ControllingType, ArrayRef<TypeSourceInfo *> AssocTypes,
6329 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6330 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack,
6331 unsigned ResultIndex);
6335 static GenericSelectionExpr *
6336 Create(
const ASTContext &Context, SourceLocation GenericLoc,
6337 TypeSourceInfo *ControllingType, ArrayRef<TypeSourceInfo *> AssocTypes,
6338 ArrayRef<Expr *> AssocExprs, SourceLocation DefaultLoc,
6339 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack);
6342 static GenericSelectionExpr *
CreateEmpty(
const ASTContext &Context,
6343 unsigned NumAssocs);
6351 llvm::iterator_range<ConstAssociationIterator>;
6361 "Generic selection is result-dependent but getResultIndex called!");
6379 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()]);
6383 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()]);
6390 return getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()];
6393 return getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()];
6400 getTrailingObjects<Stmt *>()[getIndexOfStartOfAssociatedExprs() +
6405 getTrailingObjects<Stmt *>()[getIndexOfStartOfAssociatedExprs() +
6410 return {
reinterpret_cast<Expr *
const *
>(getTrailingObjects<Stmt *>() +
6411 getIndexOfStartOfAssociatedExprs()),
6415 return {getTrailingObjects<TypeSourceInfo *>() +
6416 getIndexOfStartOfAssociatedTypes(),
6424 "Out-of-range index in GenericSelectionExpr::getAssociation!");
6427 getTrailingObjects<Stmt *>()[getIndexOfStartOfAssociatedExprs() +
6435 "Out-of-range index in GenericSelectionExpr::getAssociation!");
6438 getTrailingObjects<Stmt *>()[getIndexOfStartOfAssociatedExprs() +
6447 getIndexOfStartOfAssociatedExprs(),
6448 getTrailingObjects<TypeSourceInfo *>() +
6449 getIndexOfStartOfAssociatedTypes(),
6452 NumAssocs, ResultIndex);
6453 return llvm::make_range(
Begin, End);
6458 getIndexOfStartOfAssociatedExprs(),
6459 getTrailingObjects<TypeSourceInfo *>() +
6460 getIndexOfStartOfAssociatedTypes(),
6463 NumAssocs, ResultIndex);
6464 return llvm::make_range(
Begin, End);
6476 return T->getStmtClass() == GenericSelectionExprClass;
6481 numTrailingObjects(OverloadToken<Stmt *>())));
6485 numTrailingObjects(OverloadToken<Stmt *>())));
6507 :
Expr(ExtVectorElementExprClass, ty,
VK,
6509 Base(base), Accessor(&accessor), AccessorLoc(loc) {
6515 :
Expr(ExtVectorElementExprClass,
Empty) { }
6548 return T->getStmtClass() == ExtVectorElementExprClass;
6592 return T->getStmtClass() == BlockExprClass;
6634 :
Expr(AsTypeExprClass, DstType,
VK, OK), SrcExpr(SrcExpr),
6635 BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) {
6652 return T->getStmtClass() == AsTypeExprClass;
6692 private llvm::TrailingObjects<PseudoObjectExpr, Expr *> {
6706 unsigned resultIndex);
6710 unsigned getNumSubExprs()
const {
6721 unsigned resultIndex);
6724 unsigned numSemanticExprs);
6755 return getTrailingObjects() + 1;
6758 return getTrailingObjects() + getNumSubExprs();
6761 return getTrailingObjects() + getNumSubExprs();
6765 return getTrailingObjects(getNumSubExprs()).drop_front();
6768 return getTrailingObjects(getNumSubExprs()).drop_front();
6772 return getTrailingObjects(getNumSubExprs())[index + 1];
6796 Stmt *
const *cs =
const_cast<Stmt *
const *
>(
6797 reinterpret_cast<const Stmt *
const *
>(getTrailingObjects()));
6802 return T->getStmtClass() == PseudoObjectExprClass;
6819#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) AO ## ID,
6820#include "clang/Basic/Builtins.inc"
6829 enum { PTR, ORDER, VAL1, ORDER_FAIL, VAL2, WEAK, END_EXPR };
6830 Stmt *SubExprs[END_EXPR + 1];
6831 unsigned NumSubExprs;
6832 SourceLocation BuiltinLoc, RParenLoc;
6848 return cast<Expr>(SubExprs[
PTR]);
6851 return cast<Expr>(SubExprs[ORDER]);
6855 return cast<Expr>(SubExprs[NumSubExprs - 1]);
6858 if (Op == AO__c11_atomic_init || Op == AO__opencl_atomic_init)
6859 return cast<Expr>(SubExprs[ORDER]);
6860 assert(NumSubExprs > VAL1);
6861 return cast<Expr>(SubExprs[VAL1]);
6864 assert(NumSubExprs > ORDER_FAIL);
6865 return cast<Expr>(SubExprs[ORDER_FAIL]);
6868 if (Op == AO__atomic_exchange || Op == AO__scoped_atomic_exchange)
6869 return cast<Expr>(SubExprs[ORDER_FAIL]);
6870 assert(NumSubExprs > VAL2);
6871 return cast<Expr>(SubExprs[VAL2]);
6874 assert(NumSubExprs > WEAK);
6875 return cast<Expr>(SubExprs[WEAK]);
6882#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
6885#include "clang/Basic/Builtins.inc"
6887 llvm_unreachable(
"not an atomic operator?");
6893 return reinterpret_cast<Expr *
const *
>(SubExprs);
6901 return getOp() == AO__c11_atomic_compare_exchange_strong ||
6902 getOp() == AO__c11_atomic_compare_exchange_weak ||
6903 getOp() == AO__hip_atomic_compare_exchange_strong ||
6904 getOp() == AO__opencl_atomic_compare_exchange_strong ||
6905 getOp() == AO__opencl_atomic_compare_exchange_weak ||
6906 getOp() == AO__hip_atomic_compare_exchange_weak ||
6907 getOp() == AO__atomic_compare_exchange ||
6908 getOp() == AO__atomic_compare_exchange_n ||
6909 getOp() == AO__scoped_atomic_compare_exchange ||
6910 getOp() == AO__scoped_atomic_compare_exchange_n;
6914 return getOp() >= AO__opencl_atomic_compare_exchange_strong &&
6915 getOp() <= AO__opencl_atomic_store;
6919 return Op >= AO__hip_atomic_compare_exchange_strong &&
6920 Op <= AO__hip_atomic_store;
6936 return T->getStmtClass() == AtomicExprClass;
6941 return child_range(SubExprs, SubExprs+NumSubExprs);
6952 if (Op >= AO__opencl_atomic_compare_exchange_strong &&
6953 Op <= AO__opencl_atomic_store && Op != AO__opencl_atomic_init)
6955 if (Op >= AO__hip_atomic_compare_exchange_strong &&
6956 Op <= AO__hip_atomic_store)
6958 if (Op >= AO__scoped_atomic_add_fetch && Op <= AO__scoped_atomic_xor_fetch)
7106 OPENACC_END_EXPR = STRIDE
7110 Stmt *SubExprs[END_EXPR] = {
nullptr};
7111 SourceLocation ColonLocFirst;
7112 SourceLocation ColonLocSecond;
7113 SourceLocation RBracketLoc;
7122 ColonLocFirst(ColonLocFirst), ColonLocSecond(ColonLocSecond),
7123 RBracketLoc(RBracketLoc) {
7125 setLowerBound(LowerBound);
7136 ColonLocFirst(ColonLoc), RBracketLoc(RBracketLoc) {
7138 setLowerBound(LowerBound);
7145 :
Expr(ArraySectionExprClass, Shell) {}
7151 return T->getStmtClass() == ArraySectionExprClass;
7164 return cast_or_null<Expr>(SubExprs[LOWER_BOUND]);
7174 "Stride not valid in OpenACC subarrays");
7175 return cast_or_null<Expr>(SubExprs[STRIDE]);
7180 "Stride not valid in OpenACC subarrays");
7181 return cast_or_null<Expr>(SubExprs[STRIDE]);
7192 "second colon for stride not valid in OpenACC subarrays");
7193 return ColonLocSecond;
7215 void setBase(
Expr *
E) { SubExprs[BASE] =
E; }
7218 void setLowerBound(
Expr *
E) { SubExprs[LOWER_BOUND] =
E; }
7221 void setLength(
Expr *
E) { SubExprs[LENGTH] =
E; }
7224 void setStride(
Expr *
E) {
7226 "Stride not valid in OpenACC subarrays");
7227 SubExprs[STRIDE] =
E;
7230 void setColonLocFirst(SourceLocation L) { ColonLocFirst = L; }
7232 void setColonLocSecond(SourceLocation L) {
7234 "second colon for stride not valid in OpenACC subarrays");
7237 void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }
7268 Stmt *SubExprs[NumSubExprs];
7272 Expr *WB,
bool IsInOut)
7275 SubExprs[BaseLValue] = B;
7276 SubExprs[CastedTemporary] = OpV;
7277 SubExprs[WritebackCast] = WB;
7278 assert(!Ty->
isDependentType() &&
"HLSLOutArgExpr given a dependent type!");
7281 explicit HLSLOutArgExpr(EmptyShell Shell)
7282 :
Expr(HLSLOutArgExprClass, Shell) {}
7285 static HLSLOutArgExpr *
Create(
const ASTContext &
C, QualType Ty,
7286 OpaqueValueExpr *
Base, OpaqueValueExpr *OpV,
7287 Expr *WB,
bool IsInOut);
7288 static HLSLOutArgExpr *
CreateEmpty(
const ASTContext &Ctx);
7291 return cast<OpaqueValueExpr>(SubExprs[BaseLValue]);
7294 return cast<OpaqueValueExpr>(SubExprs[BaseLValue]);
7305 return cast<Expr>(SubExprs[WritebackCast]);
7310 return cast<OpaqueValueExpr>(SubExprs[CastedTemporary]);
7313 return cast<OpaqueValueExpr>(SubExprs[CastedTemporary]);
7324 return SubExprs[BaseLValue]->
getEndLoc();
7328 return T->getStmtClass() == HLSLOutArgExprClass;
7333 return child_range(&SubExprs[BaseLValue], &SubExprs[NumSubExprs]);
7364 private llvm::TrailingObjects<RecoveryExpr, Expr *> {
7378 Stmt **B =
reinterpret_cast<Stmt **
>(getTrailingObjects());
7386 return T->getStmtClass() == RecoveryExprClass;
7393 :
Expr(RecoveryExprClass,
Empty), NumExprs(NumSubExprs) {}
7395 size_t numTrailingObjects(OverloadToken<Stmt *>)
const {
return NumExprs; }
7397 SourceLocation BeginLoc, EndLoc;
7399 friend TrailingObjects;
static bool CanThrow(Expr *E, ASTContext &Ctx)
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
enum clang::sema::@1840::IndirectLocalPathEntry::EntryKind Kind
Defines the clang::LangOptions interface.
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::Target Target
Provides definitions for the atomic synchronization scopes.
C Language Family Type Representation.
Defines enumerations for the type traits support.
__device__ __2f16 float c
a trap message and trap category.
llvm::APFloat getValue(const llvm::fltSemantics &Semantics) const
void setValue(const ASTContext &C, const llvm::APFloat &Val)
unsigned getBitWidth() const
void setValue(const ASTContext &C, const llvm::APInt &Val)
llvm::APInt getValue() const
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
@ None
There is no such object (it's outside its lifetime).
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Imports selected nodes from one AST context into another context, merging AST nodes where appropriate...
Reads an AST files chain containing the contents of a translation unit.
std::reverse_iterator< iterator > reverse_iterator
reverse_iterator rbegin()
pointer data()
data - Return a pointer to the vector's buffer, even if empty().
std::reverse_iterator< const_iterator > const_reverse_iterator
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
AbstractConditionalOperator(StmtClass SC, EmptyShell Empty)
SourceLocation getColonLoc() const
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
static bool classof(const Stmt *T)
AbstractConditionalOperator(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK, SourceLocation qloc, SourceLocation cloc)
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
SourceLocation getQuestionLoc() const
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
AddrLabelExpr - The GNU address of label extension, representing &&label.
SourceLocation getAmpAmpLoc() const
static bool classof(const Stmt *T)
void setLabel(LabelDecl *L)
void setLabelLoc(SourceLocation L)
AddrLabelExpr(SourceLocation AALoc, SourceLocation LLoc, LabelDecl *L, QualType t)
void setAmpAmpLoc(SourceLocation L)
SourceLocation getEndLoc() const LLVM_READONLY
AddrLabelExpr(EmptyShell Empty)
Build an empty address of a label expression.
SourceLocation getLabelLoc() const
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
LabelDecl * getLabel() const
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
const_child_range children() const
ArrayInitIndexExpr(QualType T)
SourceLocation getBeginLoc() const LLVM_READONLY
static bool classof(const Stmt *S)
SourceLocation getEndLoc() const LLVM_READONLY
Represents a loop initializing the elements of an array.
ArrayInitLoopExpr(QualType T, Expr *CommonInit, Expr *ElementInit)
const_child_range children() const
llvm::APInt getArraySize() const
SourceLocation getEndLoc() const LLVM_READONLY
static bool classof(const Stmt *S)
SourceLocation getBeginLoc() const LLVM_READONLY
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Expr * getSubExpr() const
Get the initializer to use for each array element.
This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...
const Expr * getStride() const
SourceLocation getRBracketLoc() const
const_child_range children() const
Expr * getBase()
Get base of the array section.
static bool classof(const Stmt *T)
SourceLocation getEndLoc() const LLVM_READONLY
Expr * getLength()
Get length of array section.
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
SourceLocation getExprLoc() const LLVM_READONLY
const Expr * getLowerBound() const
bool isOMPArraySection() const
Expr * getStride()
Get stride of array section.
const Expr * getBase() const
ArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, QualType Type, ExprValueKind VK, ExprObjectKind OK, SourceLocation ColonLoc, SourceLocation RBracketLoc)
const Expr * getLength() const
ArraySectionExpr(EmptyShell Shell)
Create an empty array section expression.
ArraySectionExpr(Expr *Base, Expr *LowerBound, Expr *Length, Expr *Stride, QualType Type, ExprValueKind VK, ExprObjectKind OK, SourceLocation ColonLocFirst, SourceLocation ColonLocSecond, SourceLocation RBracketLoc)
SourceLocation getColonLocSecond() const
Expr * getLowerBound()
Get lower bound of array section.
SourceLocation getBeginLoc() const LLVM_READONLY
bool isOpenACCArraySection() const
SourceLocation getColonLocFirst() const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
ArraySubscriptExpr(Expr *lhs, Expr *rhs, QualType t, ExprValueKind VK, ExprObjectKind OK, SourceLocation rbracketloc)
SourceLocation getExprLoc() const LLVM_READONLY
const Expr * getLHS() const
const_child_range children() const
const Expr * getBase() const
SourceLocation getRBracketLoc() const
const Expr * getRHS() const
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getIdx() const
SourceLocation getEndLoc() const
void setRBracketLoc(SourceLocation L)
static bool classof(const Stmt *T)
ArraySubscriptExpr(EmptyShell Shell)
Create an empty array subscript expression.
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 getEndLoc() const LLVM_READONLY
AsTypeExpr(Expr *SrcExpr, QualType DstType, ExprValueKind VK, ExprObjectKind OK, SourceLocation BuiltinLoc, SourceLocation RParenLoc)
SourceLocation getBuiltinLoc() const
getBuiltinLoc - Return the location of the __builtin_astype token.
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
static bool classof(const Stmt *T)
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
static std::unique_ptr< AtomicScopeModel > getScopeModel(AtomicOp Op)
Get atomic scope model for the atomic op code.
SourceLocation getRParenLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
QualType getValueType() const
AtomicExpr(EmptyShell Empty)
Build an empty AtomicExpr.
StringRef getOpAsString() const
bool threadPrivateMemoryAtomicsAreUndefined() const
Return true if atomics operations targeting allocations in private memory are undefined.
const Expr *const * getSubExprs() const
std::unique_ptr< AtomicScopeModel > getScopeModel() const
Get atomic scope model.
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getBuiltinLoc() const
Expr * getOrderFail() const
unsigned getNumSubExprs() const
static bool classof(const Stmt *T)
static std::unique_ptr< AtomicScopeModel > create(AtomicScopeModelKind K)
Create an atomic scope model by AtomicScopeModelKind.
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
static bool classof(const Stmt *T)
BinaryConditionalOperator(Expr *common, OpaqueValueExpr *opaqueValue, Expr *cond, Expr *lhs, Expr *rhs, SourceLocation qloc, SourceLocation cloc, QualType t, ExprValueKind VK, ExprObjectKind OK)
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condition evaluates to false; ...
BinaryConditionalOperator(EmptyShell Empty)
Build an empty conditional operator.
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
SourceLocation getEndLoc() const LLVM_READONLY
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".
static bool isLogicalOp(Opcode Opc)
BinaryOperator(EmptyShell Empty)
Construct an empty binary operator.
static bool isRelationalOp(Opcode Opc)
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
const FPOptionsOverride * getTrailingFPFeatures() const
const_child_range children() const
static bool isComparisonOp(Opcode Opc)
void setHasStoredFPFeatures(bool B)
Set and fetch the bit that shows whether FPFeatures needs to be allocated in Trailing Storage.
void setOperatorLoc(SourceLocation L)
static bool isShiftOp(Opcode Opc)
bool isComparisonOp() const
FPOptionsOverride getStoredFPFeaturesOrDefault() const
Get the store FPOptionsOverride or default if not stored.
StringRef getOpcodeStr() const
static bool isCommaOp(Opcode Opc)
static Opcode getOpForCompoundAssignment(Opcode Opc)
SourceLocation getBeginLoc() const LLVM_READONLY
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
bool isRelationalOp() const
SourceLocation getOperatorLoc() const
bool isFEnvAccessOn(const LangOptions &LO) const
Get the FENV_ACCESS status of this operator.
bool hasStoredFPFeatures() const
bool isCompoundAssignmentOp() const
static Opcode negateComparisonOp(Opcode Opc)
bool isMultiplicativeOp() const
SourceLocation getExprLoc() const
static Opcode reverseComparisonOp(Opcode Opc)
static bool isShiftAssignOp(Opcode Opc)
bool isFPContractableWithinStatement(const LangOptions &LO) const
Get the FP contractibility status of this operator.
static unsigned sizeOfTrailingObjects(bool HasFPFeatures)
Return the size in bytes needed for the trailing objects.
bool isEqualityOp() const
BinaryOperator(StmtClass SC, EmptyShell Empty)
Construct an empty BinaryOperator, SC is CompoundAssignOperator.
void setExcludedOverflowPattern(bool B)
Set and get the bit that informs arithmetic overflow sanitizers whether or not they should exclude ce...
static BinaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
FPOptionsOverride getStoredFPFeatures() const
Get FPFeatures from trailing storage.
static bool classof(const Stmt *S)
bool isAdditiveOp() const
static bool isAdditiveOp(Opcode Opc)
static bool isPtrMemOp(Opcode Opc)
predicates to categorize the respective opcodes.
static bool isAssignmentOp(Opcode Opc)
static bool isCompoundAssignmentOp(Opcode Opc)
bool isShiftAssignOp() const
SourceLocation getEndLoc() const LLVM_READONLY
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
static bool isNullPointerArithmeticExtension(ASTContext &Ctx, Opcode Opc, const Expr *LHS, const Expr *RHS)
Return true if a binary operator using the specified opcode and operands would match the 'p = (i8*)nu...
void setStoredFPFeatures(FPOptionsOverride F)
Set FPFeatures in trailing storage, used only by Serialization.
FPOptionsOverride getFPFeatures() const
bool isAssignmentOp() const
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
size_t offsetOfTrailingStorage() const
static bool isEqualityOp(Opcode Opc)
bool hasExcludedOverflowPattern() const
void setOpcode(Opcode Opc)
static bool isBitwiseOp(Opcode Opc)
static bool isMultiplicativeOp(Opcode Opc)
BinaryOperatorKind Opcode
Represents a block literal declaration, which is like an unnamed FunctionDecl.
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
BlockExpr(EmptyShell Empty)
Build an empty block expression.
SourceLocation getCaretLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
BlockDecl * getBlockDecl()
const Stmt * getBody() const
BlockExpr(BlockDecl *BD, QualType ty, bool ContainsUnexpandedParameterPack)
const_child_range children() const
SourceLocation getEndLoc() const LLVM_READONLY
void setBlockDecl(BlockDecl *BD)
static bool classof(const Stmt *T)
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
const BlockDecl * getBlockDecl() const
This class is used for builtin types like 'int'.
static bool isPlaceholderTypeKind(Kind K)
Determines whether the given kind corresponds to a placeholder type.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
SourceLocation getRParenLoc() const
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
SourceLocation getBeginLoc() const LLVM_READONLY
void setRParenLoc(SourceLocation L)
static bool classof(const Stmt *T)
SourceLocation getLParenLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
void setLParenLoc(SourceLocation L)
Represents a base class of a C++ class.
Represents a C++ struct/union/class.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
bool hasStoredFPFeatures() const
const FPOptionsOverride * getTrailingFPFeatures() const
bool usesMemberSyntax() const
std::optional< llvm::APInt > evaluateBytesReturnedByAllocSizeCall(const ASTContext &Ctx) const
Evaluates the total size in bytes allocated by calling a function decorated with alloc_size.
static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs, bool HasFPFeatures)
Return the size in bytes needed for the trailing objects.
static constexpr ADLCallKind NotADL
const Stmt * getPreArg(unsigned I) const
SourceLocation getBeginLoc() const
void setRParenLoc(SourceLocation L)
const_arg_iterator arg_begin() const
static bool classof(const Stmt *T)
llvm::iterator_range< const_arg_iterator > const_arg_range
void setCoroElideSafe(bool V=true)
const Expr *const * getArgs() const
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
ConstExprIterator const_arg_iterator
ExprIterator arg_iterator
std::pair< const NamedDecl *, const WarnUnusedResultAttr * > getUnusedResultAttr(const ASTContext &Ctx) const
Returns the WarnUnusedResultAttr that is declared on the callee or its return type declaration,...
void setADLCallKind(ADLCallKind V=UsesADL)
const AllocSizeAttr * getCalleeAllocSizeAttr() const
Try to get the alloc_size attribute of the callee. May return null.
llvm::iterator_range< arg_iterator > arg_range
const_arg_range arguments() const
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
FPOptionsOverride getStoredFPFeaturesOrDefault() const
Get the store FPOptionsOverride or default if not stored.
FPOptionsOverride getStoredFPFeatures() const
Get FPOptionsOverride from trailing storage.
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
static CallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Create an empty call expression, for deserialization.
bool isCallToStdMove() const
void setUsesMemberSyntax(bool V=true)
void setPreArg(unsigned I, Stmt *PreArg)
ADLCallKind getADLCallKind() const
FPOptionsOverride getFPFeatures() const
static constexpr unsigned OffsetToTrailingObjects
void markDependentForPostponedNameLookup()
Used by Sema to implement MSVC-compatible delayed name lookup.
const Expr * getCallee() const
ArrayRef< Stmt * > getRawSubExprs()
This method provides fast access to all the subexpressions of a CallExpr without going through the sl...
const Decl * getCalleeDecl() const
void computeDependence()
Compute and set dependence bits.
void setStoredFPFeatures(FPOptionsOverride F)
Set FPOptionsOverride in trailing storage. Used only by Serialization.
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
bool isCoroElideSafe() const
Expr ** getArgs()
Retrieve the call arguments.
const_child_range children() const
static constexpr unsigned sizeToAllocateForCallExprSubclass(unsigned SizeOfTrailingObjects)
SourceLocation getEndLoc() const
SourceLocation getRParenLoc() const
static constexpr ADLCallKind UsesADL
bool isBuiltinAssumeFalse(const ASTContext &Ctx) const
Return true if this is a call to __assume() or __builtin_assume() with a non-value-dependent constant...
const_arg_iterator arg_end() const
const FunctionDecl * getDirectCallee() const
Stmt * getPreArg(unsigned I)
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
void setNumArgsUnsafe(unsigned NewNumArgs)
Bluntly set a new number of arguments without doing any checks whatsoever.
unsigned getNumPreArgs() const
bool hasUnusedResultAttr(const ASTContext &Ctx) const
Returns true if this call expression should warn on unused results.
void shrinkNumArgs(unsigned NewNumArgs)
Reduce the number of arguments in this call expression.
const Expr * getArg(unsigned Arg) const
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
path_iterator path_begin()
unsigned path_size() const
NamedDecl * getConversionFunction() const
If this cast applies a user-defined conversion, retrieve the conversion function that it invokes.
const Expr * getSubExprAsWritten() const
Expr * getSubExprAsWritten()
Retrieve the cast subexpression as it was written in the source code, looking through any implicit ca...
CastKind getCastKind() const
void setCastKind(CastKind K)
llvm::iterator_range< path_iterator > path()
Path through the class hierarchy taken by casts between base and derived classes (see implementation ...
const FieldDecl * getTargetUnionField() const
CastExpr(StmtClass SC, EmptyShell Empty, unsigned BasePathSize, bool HasFPFeatures)
Construct an empty cast.
static bool classof(const Stmt *T)
llvm::iterator_range< path_const_iterator > path() const
bool hasStoredFPFeatures() const
bool changesVolatileQualification() const
Return.
static const FieldDecl * getTargetFieldForToUnionCast(QualType unionType, QualType opType)
FPOptionsOverride getStoredFPFeatures() const
Get FPOptionsOverride from trailing storage.
CastExpr(StmtClass SC, QualType ty, ExprValueKind VK, const CastKind kind, Expr *op, unsigned BasePathSize, bool HasFPFeatures)
const Expr * getSubExpr() const
const_child_range children() const
const FPOptionsOverride * getTrailingFPFeatures() const
CXXBaseSpecifier ** path_iterator
path_const_iterator path_end() const
const char * getCastKindName() const
path_const_iterator path_begin() const
const CXXBaseSpecifier *const * path_const_iterator
FPOptionsOverride getFPFeatures() const
FPOptionsOverride getStoredFPFeaturesOrDefault() const
Get the store FPOptionsOverride or default if not stored.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operation.
void setValue(unsigned Val)
SourceLocation getLocation() const
SourceLocation getEndLoc() const LLVM_READONLY
void setLocation(SourceLocation Location)
static bool classof(const Stmt *T)
static void print(unsigned val, CharacterLiteralKind Kind, raw_ostream &OS)
unsigned getValue() const
void setKind(CharacterLiteralKind kind)
const_child_range children() const
CharacterLiteralKind getKind() const
CharacterLiteral(EmptyShell Empty)
Construct an empty character literal.
SourceLocation getBeginLoc() const LLVM_READONLY
CharacterLiteral(unsigned value, CharacterLiteralKind kind, QualType type, SourceLocation l)
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
void setRParenLoc(SourceLocation L)
void setIsConditionTrue(bool isTrue)
SourceLocation getBuiltinLoc() const
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
bool isConditionDependent() const
void setBuiltinLoc(SourceLocation L)
bool isConditionTrue() const
isConditionTrue - Return whether the condition is true (i.e.
ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t, ExprValueKind VK, ExprObjectKind OK, SourceLocation RP, bool condIsTrue)
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getRParenLoc() const
ChooseExpr(EmptyShell Empty)
Build an empty __builtin_choose_expr.
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
static bool classof(const Stmt *T)
CompoundAssignOperator - For compound assignments (e.g.
void setComputationResultType(QualType T)
static CompoundAssignOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
CompoundAssignOperator(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResType, ExprValueKind VK, ExprObjectKind OK, SourceLocation OpLoc, FPOptionsOverride FPFeatures, QualType CompLHSType, QualType CompResultType)
QualType getComputationLHSType() const
void setComputationLHSType(QualType T)
static bool classof(const Stmt *S)
QualType getComputationResultType() const
CompoundLiteralExpr - [C99 6.5.2.5].
void setFileScope(bool FS)
const_child_range children() const
void setTypeSourceInfo(TypeSourceInfo *tinfo)
bool hasStaticStorage() const
SourceLocation getLParenLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
APValue & getStaticValue() const
CompoundLiteralExpr(EmptyShell Empty)
Construct an empty compound literal.
void setLParenLoc(SourceLocation L)
SourceLocation getEndLoc() const LLVM_READONLY
APValue & getOrCreateStaticValue(ASTContext &Ctx) const
static bool classof(const Stmt *T)
const Expr * getInitializer() const
TypeSourceInfo * getTypeSourceInfo() const
void setInitializer(Expr *E)
CompoundLiteralExpr(SourceLocation lparenloc, TypeSourceInfo *tinfo, QualType T, ExprValueKind VK, Expr *init, bool fileScope)
CompoundStmt - This represents a group of statements like { stmt stmt }.
ConditionalOperator - The ?: ternary operator.
const_child_range children() const
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
static bool classof(const Stmt *T)
ConditionalOperator(Expr *cond, SourceLocation QLoc, Expr *lhs, SourceLocation CLoc, Expr *rhs, QualType t, ExprValueKind VK, ExprObjectKind OK)
SourceLocation getBeginLoc() const LLVM_READONLY
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
SourceLocation getEndLoc() const LLVM_READONLY
ConditionalOperator(EmptyShell Empty)
Build an empty conditional operator.
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
APValue getAPValueResult() const
static ConstantResultStorageKind getStorageKind(const APValue &Value)
void MoveIntoResult(APValue &Value, const ASTContext &Context)
llvm::APSInt getResultAsAPSInt() const
SourceLocation getBeginLoc() const LLVM_READONLY
ConstantResultStorageKind getResultStorageKind() const
void SetResult(APValue Value, const ASTContext &Context)
APValue::ValueKind getResultAPValueKind() const
static bool classof(const Stmt *T)
bool hasAPValueResult() const
const_child_range children() const
bool isImmediateInvocation() const
SourceLocation getEndLoc() const LLVM_READONLY
static ConstantExpr * CreateEmpty(const ASTContext &Context, ConstantResultStorageKind StorageKind)
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
FPOptionsOverride getStoredFPFeaturesOrDefault() const
Get the store FPOptionsOverride or default if not stored.
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
const_child_range children() const
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
bool isFPContractableWithinStatement(const LangOptions &LO) const
Get the FP contractibility status of this operator.
static ConvertVectorExpr * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
static bool classof(const Stmt *T)
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
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.
void setStoredFPFeatures(FPOptionsOverride F)
Set FPFeatures in trailing storage, used by Serialization & ASTImporter.
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
void setTypeSourceInfo(TypeSourceInfo *ti)
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
FPOptionsOverride getFPOptionsOverride() const
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
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 hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list.
NestedNameSpecifier getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
void setIsImmediateEscalating(bool Set)
const_child_range children() const
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
void setDecl(ValueDecl *NewD)
bool hasTemplateKWAndArgsInfo() const
const NamedDecl * getFoundDecl() const
Get the NamedDecl through which this reference occurred.
static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Construct an empty declaration reference expression.
void setLocation(SourceLocation L)
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments (if present) into the given structure.
DeclarationNameInfo getNameInfo() const
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a function that was resolved from an overload...
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding this name, if any.
bool isCapturedByCopyInLambdaWithExplicitObjectParameter() const
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
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,...
const ValueDecl * getDecl() const
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
ArrayRef< TemplateArgumentLoc > template_arguments() const
static bool classof(const Stmt *T)
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getEndLoc() const LLVM_READONLY
bool hadMultipleCandidates() const
Returns true if this expression refers to a function that was resolved from an overloaded set having ...
void setCapturedByCopyInLambdaWithExplicitObjectParameter(bool Set, const ASTContext &Context)
SourceLocation getBeginLoc() const
bool hasTemplateKeyword() const
Determines whether the name in this declaration reference was preceded by the template keyword.
SourceLocation getLocation() const
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
bool isImmediateEscalating() const
Decl - This represents one declaration (or definition), e.g.
AccessSpecifier getAccess() const
DeclarationNameLoc - Additional source/type location info for a declaration name.
Represents a single C99 designator.
unsigned getArrayIndex() const
SourceRange getSourceRange() const LLVM_READONLY
bool isFieldDesignator() const
SourceLocation getBeginLoc() const LLVM_READONLY
static Designator CreateArrayRangeDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation EllipsisLoc, SourceLocation RBracketLoc)
Creates a GNU array-range designator.
struct FieldDesignatorInfo FieldInfo
A field designator, e.g., ".x".
static Designator CreateFieldDesignator(const IdentifierInfo *FieldName, SourceLocation DotLoc, SourceLocation FieldLoc)
Creates a field designator.
struct ArrayOrRangeDesignatorInfo ArrayOrRangeInfo
An array or GNU array-range designator, e.g., "[9]" or "[10..15]".
bool isArrayRangeDesignator() const
void setFieldDecl(FieldDecl *FD)
static Designator CreateArrayDesignator(unsigned Index, SourceLocation LBracketLoc, SourceLocation RBracketLoc)
Creates an array designator.
FieldDecl * getFieldDecl() const
bool isArrayDesignator() const
SourceLocation getFieldLoc() const
SourceLocation getRBracketLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
const IdentifierInfo * getFieldName() const
SourceLocation getEllipsisLoc() const
SourceLocation getDotLoc() const
SourceLocation getLBracketLoc() const
Represents a C99 designated initializer expression.
bool isDirectInit() const
Whether this designated initializer should result in direct-initialization of the designated subobjec...
static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)
Expr * getArrayRangeEnd(const Designator &D) const
const_child_range children() const
const Designator * getDesignator(unsigned Idx) const
Expr * getSubExpr(unsigned Idx) const
SourceRange getDesignatorsSourceRange() const
void setSubExpr(unsigned Idx, Expr *E)
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Expr * getArrayRangeStart(const Designator &D) const
void ExpandDesignator(const ASTContext &C, unsigned Idx, const Designator *First, const Designator *Last)
Replaces the designator at index Idx with the series of designators in [First, Last).
MutableArrayRef< Designator > designators()
void setGNUSyntax(bool GNU)
void setEqualOrColonLoc(SourceLocation L)
Expr * getArrayIndex(const Designator &D) const
Designator * getDesignator(unsigned Idx)
ArrayRef< Designator > designators() const
Expr * getInit() const
Retrieve the initializer value.
unsigned size() const
Returns the number of designators in this initializer.
SourceLocation getBeginLoc() const LLVM_READONLY
void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)
SourceLocation getEndLoc() const LLVM_READONLY
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,...
static bool classof(const Stmt *T)
SourceLocation getBeginLoc() const LLVM_READONLY
DesignatedInitUpdateExpr(EmptyShell Empty)
static bool classof(const Stmt *T)
SourceLocation getEndLoc() const LLVM_READONLY
const_child_range children() const
void setUpdater(Expr *Updater)
InitListExpr * getUpdater() const
Designator - A designator in a C99 designated initializer.
BaseTy::pointer operator->() const
ChildElementIter & operator++()
BaseTy::reference operator*() const
bool operator==(ChildElementIter Other) const
Represents a reference to #emded data.
unsigned getStartingElementPos() const
ChildElementIter< false > begin()
bool doForEachDataElement(Call &&C, unsigned &StartingIndexInArray, Targs &&...Fargs) const
SourceLocation getEndLoc() const
ChildElementIter< true > begin() const
StringLiteral * getDataStringLiteral() const
const_fake_child_range underlying_data_elements() const
EmbedExpr(EmptyShell Empty)
EmbedDataStorage * getData() const
StringRef getFileName() const
llvm::iterator_range< ChildElementIter< true > > const_fake_child_range
llvm::iterator_range< ChildElementIter< false > > fake_child_range
fake_child_range underlying_data_elements()
SourceLocation getBeginLoc() const
SourceLocation getLocation() const
static bool classof(const Stmt *T)
const_child_range children() const
size_t getDataElementCount() const
An instance of this object exists for each enum constant that is defined.
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.
ExplicitCastExpr(StmtClass SC, QualType exprTy, ExprValueKind VK, CastKind kind, Expr *op, unsigned PathSize, bool HasFPFeatures, TypeSourceInfo *writtenTy)
void setTypeInfoAsWritten(TypeSourceInfo *writtenTy)
static bool classof(const Stmt *T)
ExplicitCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize, bool HasFPFeatures)
Construct an empty explicit cast.
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
The return type of classify().
ModifiableType
The results of modification testing.
ModifiableType getModifiable() const
Kinds
The various classification results. Most of these mean prvalue.
@ CL_SubObjCPropertySetting
@ CL_DuplicateVectorComponents
static Classification makeSimpleLValue()
Create a simple, modifiable lvalue.
bool isModifiable() const
This represents one expression.
@ LV_DuplicateVectorComponents
@ LV_InvalidMessageExpression
@ LV_SubObjCPropertySetting
Classification ClassifyModifiable(ASTContext &Ctx, SourceLocation &Loc) const
ClassifyModifiable - Classify this expression according to the C++11 expression taxonomy,...
Expr(StmtClass SC, QualType T, ExprValueKind VK, ExprObjectKind OK)
Expr(StmtClass SC, EmptyShell)
Construct an empty expression.
bool EvaluateAsInt(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsInt - Return true if this is a constant which we can fold and convert to an integer,...
EnumConstantDecl * getEnumConstantDecl()
If this expression refers to an enum constant, retrieve its declaration.
static bool isPotentialConstantExpr(const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExpr - Return true if this function's definition might be usable in a constant exp...
bool isReadIfDiscardedInCPlusPlus11() const
Determine whether an lvalue-to-rvalue conversion should implicitly be applied to this expression if i...
bool isIntegerConstantExpr(const ASTContext &Ctx) const
static bool isPotentialConstantExprUnevaluated(Expr *E, const FunctionDecl *FD, SmallVectorImpl< PartialDiagnosticAt > &Diags)
isPotentialConstantExprUnevaluated - Return true if this expression might be usable in a constant exp...
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...
@ SE_AllowSideEffects
Allow any unmodeled side effect.
@ SE_NoSideEffects
Strictly evaluate the expression.
@ SE_AllowUndefinedBehavior
Allow UB that we can give a value, but not arbitrary unmodeled side effects.
static bool classof(const Stmt *T)
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member.
Expr & operator=(const Expr &)=delete
bool isCXX11ConstantExpr(const ASTContext &Ctx, APValue *Result=nullptr) const
isCXX11ConstantExpr - Return true if this expression is a constant expression in C++11.
static std::pair< const NamedDecl *, const WarnUnusedResultAttr * > getUnusedResultAttrImpl(const Decl *Callee, QualType ReturnType)
Returns the WarnUnusedResultAttr that is declared on the callee or its return type declaration,...
bool EvaluateCharRangeAsString(std::string &Result, const Expr *SizeExpression, const Expr *PtrExpression, ASTContext &Ctx, EvalResult &Status) const
bool isImplicitCXXThis() const
Whether this expression is an implicit reference to 'this' in C++.
const Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) const
llvm::APSInt EvaluateKnownConstIntCheckOverflow(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
bool isUnusedResultAWarning(const Expr *&WarnExpr, SourceLocation &Loc, SourceRange &R1, SourceRange &R2, ASTContext &Ctx) const
isUnusedResultAWarning - Return true if this immediate expression should be warned about if the resul...
LValueClassification ClassifyLValue(ASTContext &Ctx) const
Reasons why an expression might not be an l-value.
bool isValueDependent() const
Determines whether the value of this expression depends on.
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
bool refersToVectorElement() const
Returns whether this expression refers to a vector element.
bool isTypeDependent() const
Determines whether the type of this expression depends on.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).
bool tryEvaluateStrLen(uint64_t &Result, ASTContext &Ctx) const
If the current Expr is a pointer, this will try to statically determine the strlen of the string poin...
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx, SmallVectorImpl< PartialDiagnosticAt > *Diag=nullptr) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Expr * IgnoreParenLValueCasts() LLVM_READONLY
Skip past any parentheses and lvalue casts which might surround this expression until reaching a fixe...
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Returns the set of floating point options that apply to this expression.
const CXXRecordDecl * getBestDynamicClassType() const
For an expression of class type or pointer to class type, return the most derived class decl the expr...
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Expr * IgnoreConversionOperatorSingleStep() LLVM_READONLY
Skip conversion operators.
bool containsErrors() const
Whether this expression contains subexpressions which had errors.
bool EvaluateAsFloat(llvm::APFloat &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFloat - Return true if this is a constant which we can fold and convert to a floating point...
bool isObjCSelfExpr() const
Check if this expression is the ObjC 'self' implicit parameter.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool isFlexibleArrayMemberLike(const ASTContext &Context, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution=false) const
Check whether this array fits the idiom of a flexible array member, depending on the value of -fstric...
bool hasPlaceholderType(BuiltinType::Kind K) const
Returns whether this expression has a specific placeholder type.
bool EvaluateAsLValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsLValue - Evaluate an expression to see if we can fold it to an lvalue with link time known ...
bool EvaluateAsFixedPoint(EvalResult &Result, const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects, bool InConstantContext=false) const
EvaluateAsFixedPoint - Return true if this is a constant which we can fold and convert to a fixed poi...
bool isEvaluatable(const ASTContext &Ctx, SideEffectsKind AllowSideEffects=SE_NoSideEffects) const
isEvaluatable - Call EvaluateAsRValue to see if this expression can be constant folded without side-e...
Expr * IgnoreParenBaseCasts() LLVM_READONLY
Skip past any parentheses and derived-to-base casts until reaching a fixed point.
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language.
static bool hasAnyTypeDependentArguments(ArrayRef< Expr * > Exprs)
hasAnyTypeDependentArguments - Determines if any of the expressions in Exprs is type-dependent.
FieldDecl * getSourceBitField()
If this expression refers to a bit-field, retrieve the declaration of that bit-field.
NullPointerConstantValueDependence
Enumeration used to describe how isNullPointerConstant() should cope with value-dependent expressions...
@ NPC_ValueDependentIsNull
Specifies that a value-dependent expression of integral or dependent type should be considered a null...
@ NPC_NeverValueDependent
Specifies that the expression should never be value-dependent.
@ NPC_ValueDependentIsNotNull
Specifies that a value-dependent expression should be considered to never be a null pointer constant.
Expr * IgnoreUnlessSpelledInSource()
Skip past any invisible AST nodes which might surround this statement, such as ExprWithCleanups or Im...
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Expr * IgnoreCasts() LLVM_READONLY
Skip past any casts which might surround this expression until reaching a fixed point.
Decl * getReferencedDeclOfCallee()
Expr * IgnoreImplicitAsWritten() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
const Expr * getBestDynamicClassTypeExpr() const
Get the inner expression that determines the best dynamic class.
const Expr * IgnoreUnlessSpelledInSource() const
std::optional< std::string > tryEvaluateString(ASTContext &Ctx) const
If the current Expr can be evaluated to a pointer to a null-terminated constant string,...
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point.
NullPointerConstantKind
Enumeration used to describe the kind of Null pointer constant returned from isNullPointerConstant().
@ NPCK_ZeroExpression
Expression is a Null pointer constant built from a zero integer expression that is not a simple,...
@ NPCK_ZeroLiteral
Expression is a Null pointer constant built from a literal zero.
@ NPCK_CXX11_nullptr
Expression is a C++11 nullptr.
@ NPCK_GNUNull
Expression is a GNU-style __null constant.
@ NPCK_NotNull
Expression is not a Null pointer constant.
bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsBooleanCondition - Return true if this is a constant which we can fold and convert to a boo...
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
NullPointerConstantKind isNullPointerConstant(ASTContext &Ctx, NullPointerConstantValueDependence NPC) const
isNullPointerConstant - C99 6.3.2.3p3 - Test if this reduces down to a Null pointer constant.
QualType getEnumCoercedType(const ASTContext &Ctx) const
If this expression is an enumeration constant, return the enumeration type under which said constant ...
bool isBoundMemberFunction(ASTContext &Ctx) const
Returns true if this expression is a bound member function.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant,...
@ ClassTemplateArgument
A class template argument. Such a value is used for code generation.
@ Normal
An integer constant expression (an array bound, enumerator, case value, bit-field width,...
@ ImmediateInvocation
An immediate invocation.
@ NonClassTemplateArgument
A non-class template argument.
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
const FieldDecl * getSourceBitField() const
static bool isSameComparisonOperand(const Expr *E1, const Expr *E2)
Checks that the two Expr's will refer to the same value as a comparison operand.
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
bool refersToMatrixElement() const
Returns whether this expression refers to a matrix element.
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
@ MLV_DuplicateVectorComponents
@ MLV_InvalidMessageExpression
@ MLV_ConstQualifiedField
@ MLV_SubObjCPropertySetting
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
const Decl * getReferencedDeclOfCallee() const
bool hasNonTrivialCall(const ASTContext &Ctx) const
Determine whether this expression involves a call to any function that is not trivial.
bool isOrdinaryOrBitFieldObject() const
bool hasPlaceholderType() const
Returns whether this expression has a placeholder type.
bool refersToGlobalRegisterVar() const
Returns whether this expression refers to a global register variable.
bool tryEvaluateObjectSize(uint64_t &Result, ASTContext &Ctx, unsigned Type) const
If the current Expr is a pointer, this will try to statically determine the number of bytes available...
bool isCXX98IntegralConstantExpr(const ASTContext &Ctx) const
isCXX98IntegralConstantExpr - Return true if this expression is an integral constant expression in C+...
const ValueDecl * getAsBuiltinConstantDeclRef(const ASTContext &Context) const
If this expression is an unambiguous reference to a single declaration, in the style of __builtin_fun...
bool isOBJCGCCandidate(ASTContext &Ctx) const
isOBJCGCCandidate - Return true if this expression may be used in a read/ write barrier.
static ExprValueKind getValueKindForType(QualType T)
getValueKindForType - Given a formal return or parameter type, give its value kind.
bool EvaluateWithSubstitution(APValue &Value, ASTContext &Ctx, const FunctionDecl *Callee, ArrayRef< const Expr * > Args, const Expr *This=nullptr) const
EvaluateWithSubstitution - Evaluate an expression as if from the context of a call to the given funct...
bool EvaluateAsInitializer(APValue &Result, const ASTContext &Ctx, const VarDecl *VD, SmallVectorImpl< PartialDiagnosticAt > &Notes, bool IsConstantInitializer) const
EvaluateAsInitializer - Evaluate an expression as if it were the initializer of the given declaration...
const Expr * skipRValueSubobjectAdjustments() const
bool isKnownToHaveBooleanValue(bool Semantic=true) const
isKnownToHaveBooleanValue - Return true if this is an integer expression that is known to return 0 or...
void setDependence(ExprDependence Deps)
Each concrete expr subclass is expected to compute its dependence and call this in the constructor.
Expr(const Expr &)=delete
void EvaluateForOverflow(const ASTContext &Ctx) const
ExprDependence getDependence() const
Expr & operator=(Expr &&)=delete
const EnumConstantDecl * getEnumConstantDecl() const
const ObjCPropertyRefExpr * getObjCProperty() const
If this expression is an l-value for an Objective C property, find the underlying property reference ...
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
ExtVectorElementExpr(EmptyShell Empty)
Build an empty vector element expression.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
bool containsDuplicateElements() const
containsDuplicateElements - Return true if any element access is repeated.
void setAccessor(IdentifierInfo *II)
bool isArrow() const
isArrow - Return true if the base expression is a pointer to vector, return false if the base express...
SourceLocation getAccessorLoc() const
void getEncodedElementAccess(SmallVectorImpl< uint32_t > &Elts) const
getEncodedElementAccess - Encode the elements accessed into an llvm aggregate Constant of ConstantInt...
const Expr * getBase() const
static bool classof(const Stmt *T)
void setAccessorLoc(SourceLocation L)
unsigned getNumElements() const
getNumElements - Get the number of components being selected.
ExtVectorElementExpr(QualType ty, ExprValueKind VK, Expr *base, IdentifierInfo &accessor, SourceLocation loc)
IdentifierInfo & getAccessor() const
const_child_range children() const
Represents difference between two FPOptions values.
FPOptions applyOverrides(FPOptions Base)
bool requiresTrailingStorage() const
static FPOptions defaultWithoutTrailingStorage(const LangOptions &LO)
Return the default value of FPOptions that's used when trailing storage isn't required.
bool allowFPContractWithinStatement() const
Represents a member of a struct/union/class.
SourceLocation getLocation() const
Retrieve the location of the literal.
std::string getValueAsString(unsigned Radix) const
unsigned getScale() const
SourceLocation getBeginLoc() const LLVM_READONLY
const_child_range children() const
void setLocation(SourceLocation Location)
llvm::APInt getValue() const
Returns an internal integer representation of the literal.
static bool classof(const Stmt *T)
void setScale(unsigned S)
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getLocation() const
llvm::APFloatBase::Semantics getRawSemantics() const
Get a raw enumeration value representing the floating-point semantics of this literal (32-bit IEEE,...
const llvm::fltSemantics & getSemantics() const
Return the APFloat semantics this literal uses.
void setValue(const ASTContext &C, const llvm::APFloat &Val)
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setRawSemantics(llvm::APFloatBase::Semantics Sem)
Set the raw enumeration value representing the floating-point semantics of this literal (32-bit IEEE,...
double getValueAsApproximateDouble() const
getValueAsApproximateDouble - This returns the value as an inaccurate double.
llvm::APFloat getValue() const
static bool classof(const Stmt *T)
void setLocation(SourceLocation L)
SourceLocation getEndLoc() const LLVM_READONLY
void setSemantics(const llvm::fltSemantics &Sem)
Set the APFloat semantics this literal uses.
FullExpr - Represents a "full-expression" node.
FullExpr(StmtClass SC, EmptyShell Empty)
void setSubExpr(Expr *E)
As with any mutator of the AST, be very careful when modifying an existing AST to preserve its invari...
static bool classof(const Stmt *T)
FullExpr(StmtClass SC, Expr *subexpr)
const Expr * getSubExpr() const
Represents a function declaration or definition.
Represents a prototype with parameter type info, e.g.
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.
static bool classof(const Stmt *T)
SourceLocation getBeginLoc() const LLVM_READONLY
const_child_range children() const
GNUNullExpr(QualType Ty, SourceLocation Loc)
SourceLocation getEndLoc() const LLVM_READONLY
GNUNullExpr(EmptyShell Empty)
Build an empty GNU __null expression.
void setTokenLocation(SourceLocation L)
Represents a C11 generic selection.
llvm::iterator_range< ConstAssociationIterator > const_association_range
SourceLocation getBeginLoc() const
AssociationTy< false > Association
TypeSourceInfo * getControllingType()
Return the controlling type of this generic selection expression.
static bool classof(const Stmt *T)
const Expr * getControllingExpr() const
unsigned getNumAssocs() const
The number of association expressions.
const_association_range associations() const
AssociationIteratorTy< true > ConstAssociationIterator
SourceLocation getEndLoc() const
ArrayRef< Expr * > getAssocExprs() const
bool isExprPredicate() const
Whether this generic selection uses an expression as its controlling argument.
ConstAssociation getAssociation(unsigned I) const
association_range associations()
AssociationTy< true > ConstAssociation
SourceLocation getGenericLoc() const
SourceLocation getRParenLoc() const
unsigned getResultIndex() const
The zero-based index of the result expression's generic association in the generic selection's associ...
Expr * getResultExpr()
Return the result expression of this controlling expression.
AssociationIteratorTy< false > AssociationIterator
SourceLocation getDefaultLoc() const
llvm::iterator_range< AssociationIterator > association_range
const Expr * getResultExpr() const
bool isResultDependent() const
Whether this generic selection is result-dependent.
const_child_range children() const
Association getAssociation(unsigned I)
Return the Ith association expression with its TypeSourceInfo, bundled together in GenericSelectionEx...
bool isTypePredicate() const
Whether this generic selection uses a type as its controlling argument.
const TypeSourceInfo * getControllingType() const
static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)
Create an empty generic selection expression for deserialization.
Expr * getControllingExpr()
Return the controlling expression of this generic selection expression.
ArrayRef< TypeSourceInfo * > getAssocTypeSourceInfos() const
This class represents temporary values used to represent inout and out arguments in HLSL.
SourceLocation getEndLoc() const LLVM_READONLY
const OpaqueValueExpr * getCastedTemporary() const
const OpaqueValueExpr * getOpaqueArgLValue() const
Expr * getWritebackCast()
bool isInOut() const
returns true if the parameter is inout and false if the parameter is out.
static HLSLOutArgExpr * CreateEmpty(const ASTContext &Ctx)
static bool classof(const Stmt *T)
OpaqueValueExpr * getCastedTemporary()
const Expr * getWritebackCast() const
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getArgLValue() const
Return the l-value expression that was written as the argument in source.
OpaqueValueExpr * getOpaqueArgLValue()
One of these records is kept for each identifier that is lexed.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
SourceLocation getEndLoc() const LLVM_READONLY
ImaginaryLiteral(Expr *val, QualType Ty)
const Expr * getSubExpr() const
SourceLocation getBeginLoc() const LLVM_READONLY
ImaginaryLiteral(EmptyShell Empty)
Build an empty imaginary literal.
static bool classof(const Stmt *T)
const_child_range children() const
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
ImplicitCastExpr(OnStack_t _, QualType ty, CastKind kind, Expr *op, ExprValueKind VK, FPOptionsOverride FPO)
bool isPartOfExplicitCast() const
static bool classof(const Stmt *T)
void setIsPartOfExplicitCast(bool PartOfExplicitCast)
Represents an implicitly-generated value initialization of an object of a given type.
SourceLocation getEndLoc() const LLVM_READONLY
static bool classof(const Stmt *T)
ImplicitValueInitExpr(EmptyShell Empty)
Construct an empty implicit value initialization.
const_child_range children() const
ImplicitValueInitExpr(QualType ty)
SourceLocation getBeginLoc() const LLVM_READONLY
Describes an C or C++ initializer list.
const_reverse_iterator rend() const
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
void setSyntacticForm(InitListExpr *Init)
InitExprsTy::reverse_iterator reverse_iterator
InitExprsTy::const_reverse_iterator const_reverse_iterator
void markError()
Mark the semantic form of the InitListExpr as error when the semantic analysis fails.
bool hasDesignatedInit() const
Determine whether this initializer list contains a designated initializer.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
void resizeInits(const ASTContext &Context, unsigned NumInits)
Specify the number of initializers.
bool isStringLiteralInit() const
Is this an initializer for an array of characters, initialized by a string literal or an @encode?
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
unsigned getNumInits() const
SourceLocation getBeginLoc() const LLVM_READONLY
bool isSemanticForm() const
void setInit(unsigned Init, Expr *expr)
const_iterator begin() const
reverse_iterator rbegin()
const_reverse_iterator rbegin() const
InitExprsTy::const_iterator const_iterator
Expr *const * getInits() const
Retrieve the set of initializers.
SourceLocation getLBraceLoc() const
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
void setArrayFiller(Expr *filler)
InitListExpr * getSyntacticForm() const
static bool classof(const Stmt *T)
bool hadArrayRangeDesignator() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
unsigned getNumInitsWithEmbedExpanded() const
getNumInits but if the list has an EmbedExpr inside includes full length of embedded data.
SourceLocation getRBraceLoc() const
InitListExpr * getSemanticForm() const
const FieldDecl * getInitializedFieldInUnion() const
const Expr * getInit(unsigned Init) const
InitListExpr(EmptyShell Empty)
Build an empty initializer list.
void setLBraceLoc(SourceLocation Loc)
const Expr * getArrayFiller() const
const_child_range children() const
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const
Is this the zero initializer {0} in a language which considers it idiomatic?
const_iterator end() const
SourceLocation getEndLoc() const LLVM_READONLY
void setInitializedFieldInUnion(FieldDecl *FD)
bool isSyntacticForm() const
ArrayRef< Expr * > inits()
void setRBraceLoc(SourceLocation Loc)
ArrayRef< Expr * > inits() const
InitExprsTy::iterator iterator
void sawArrayRangeDesignator(bool ARD=true)
Expr ** getInits()
Retrieve the set of initializers.
Expr * getInit(unsigned Init)
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
void setLocation(SourceLocation Location)
SourceLocation getEndLoc() const LLVM_READONLY
static bool classof(const Stmt *T)
SourceLocation getLocation() const
Retrieve the location of the literal.
const_child_range children() const
SourceLocation getBeginLoc() const LLVM_READONLY
Represents the declaration of a label.
StrictFlexArraysLevelKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
void setColumnIdx(Expr *E)
SourceLocation getEndLoc() const
const Expr * getBase() const
const_child_range children() const
SourceLocation getRBracketLoc() const
SourceLocation getExprLoc() const LLVM_READONLY
MatrixSubscriptExpr(Expr *Base, Expr *RowIdx, Expr *ColumnIdx, QualType T, SourceLocation RBracketLoc)
const Expr * getRowIdx() const
bool isIncomplete() const
MatrixSubscriptExpr(EmptyShell Shell)
Create an empty matrix subscript expression.
static bool classof(const Stmt *T)
const Expr * getColumnIdx() const
void setRBracketLoc(SourceLocation L)
SourceLocation getBeginLoc() const LLVM_READONLY
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
static MemberExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
ArrayRef< TemplateArgumentLoc > template_arguments() const
void setMemberDecl(ValueDecl *D)
SourceLocation getMemberLoc() const
getMemberLoc - Return the location of the "member", in X->F, it is the location of 'F'.
void setMemberLoc(SourceLocation L)
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a method that was resolved from an overloaded...
SourceLocation getOperatorLoc() const
NestedNameSpecifier getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
static bool classof(const Stmt *T)
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding the member name, if any.
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.
const_child_range children() const
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why? This is only meaningful if the named memb...
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments (if present) into the given structure.
bool isImplicitAccess() const
Determine whether the base of this explicit is implicit.
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
bool performsVirtualDispatch(const LangOptions &LO) const
Returns true if virtual dispatch is performed.
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
SourceLocation getEndLoc() const LLVM_READONLY
static MemberExpr * CreateImplicit(const ASTContext &C, Expr *Base, bool IsArrow, ValueDecl *MemberDecl, QualType T, ExprValueKind VK, ExprObjectKind OK)
Create an implicit MemberExpr, with no location, qualifier, template arguments, and so on.
bool hadMultipleCandidates() const
Returns true if this member expression refers to a method that was resolved from an overloaded set ha...
bool hasTemplateKeyword() const
Determines whether the member name was preceded by the template keyword.
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
SourceLocation getExprLoc() const LLVM_READONLY
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
A pointer to member type per C++ 8.3.3 - Pointers to members.
This represents a decl that may have a name.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
A C++ nested-name-specifier augmented with source location information.
NestedNameSpecifier getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
Represents a place-holder for an object not to be initialized by anything.
static bool classof(const Stmt *T)
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
NoInitExpr(EmptyShell Empty)
const_child_range children() const
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
const Expr * getIndexExpr(unsigned Idx) const
SourceLocation getBeginLoc() const LLVM_READONLY
void setOperatorLoc(SourceLocation L)
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
Expr * getIndexExpr(unsigned Idx)
SourceLocation getEndLoc() const LLVM_READONLY
static bool classof(const Stmt *T)
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
const OffsetOfNode & getComponent(unsigned Idx) const
void setIndexExpr(unsigned Idx, Expr *E)
TypeSourceInfo * getTypeSourceInfo() const
void setTypeSourceInfo(TypeSourceInfo *tsi)
const_child_range children() const
void setComponent(unsigned Idx, OffsetOfNode ON)
unsigned getNumExpressions() const
SourceLocation getRParenLoc() const
Return the location of the right parentheses.
void setRParenLoc(SourceLocation R)
unsigned getNumComponents() const
Helper class for OffsetOfExpr.
OffsetOfNode(SourceLocation DotLoc, IdentifierInfo *Name, SourceLocation NameLoc)
Create an offsetof node that refers to an identifier.
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.
OffsetOfNode(const CXXBaseSpecifier *Base)
Create an offsetof node that refers into a C++ base class.
OffsetOfNode(SourceLocation LBracketLoc, unsigned Index, SourceLocation RBracketLoc)
Create an offsetof node that refers to an array element.
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.
Kind
The kind of offsetof node we have.
@ Array
An index into an array.
@ Identifier
A field in a dependent type, known only by its name.
SourceLocation getBeginLoc() const LLVM_READONLY
Kind getKind() const
Determine what kind of offsetof node this is.
OffsetOfNode(SourceLocation DotLoc, FieldDecl *Field, SourceLocation NameLoc)
Create an offsetof node that refers to a field.
SourceLocation getEndLoc() const LLVM_READONLY
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.
static const OpaqueValueExpr * findInCopyConstruct(const Expr *expr)
Given an expression which invokes a copy constructor — i.e.
OpaqueValueExpr(EmptyShell Empty)
OpaqueValueExpr(SourceLocation Loc, QualType T, ExprValueKind VK, ExprObjectKind OK=OK_Ordinary, Expr *SourceExpr=nullptr)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
static bool classof(const Stmt *T)
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.
const_child_range children() const
SourceLocation getExprLoc() const LLVM_READONLY
This expression type represents an asterisk in an OpenACC Size-Expr, used in the 'tile' and 'gang' cl...
static OpenACCAsteriskSizeExpr * CreateEmpty(const ASTContext &C)
SourceLocation getEndLoc() const
SourceLocation getLocation() const
const_child_range children() const
SourceLocation getBeginLoc() const
static bool classof(const Stmt *T)
ParenExpr - This represents a parenthesized expression, e.g.
ParenExpr(SourceLocation l, SourceLocation r, Expr *val)
SourceLocation getLParen() const
Get the location of the left parentheses '('.
static bool classof(const Stmt *T)
ParenExpr(EmptyShell Empty)
Construct an empty parenthesized expression.
void setLParen(SourceLocation Loc)
void setIsProducedByFoldExpansion(bool ProducedByFoldExpansion=true)
const_child_range children() const
void setRParen(SourceLocation Loc)
SourceLocation getBeginLoc() const LLVM_READONLY
const Expr * getSubExpr() const
bool isProducedByFoldExpansion() const
SourceLocation getRParen() const
Get the location of the right parentheses ')'.
SourceLocation getEndLoc() const LLVM_READONLY
static ParenListExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumExprs)
Create an empty paren list.
ArrayRef< Expr * > exprs()
SourceLocation getBeginLoc() const
Expr * getExpr(unsigned Init)
const Expr * getExpr(unsigned Init) const
const_child_range children() const
SourceLocation getEndLoc() const
unsigned getNumExprs() const
Return the number of expressions in this paren list.
SourceLocation getLParenLoc() const
SourceLocation getRParenLoc() const
static bool classof(const Stmt *T)
[C99 6.4.2.2] - A predefined identifier such as func.
SourceLocation getBeginLoc() const
void setLocation(SourceLocation L)
static bool classof(const Stmt *T)
SourceLocation getEndLoc() const
const StringLiteral * getFunctionName() const
StringRef getIdentKindName() const
static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)
Create an empty PredefinedExpr.
bool isTransparent() const
static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl, bool ForceElaboratedPrinting=false)
const_child_range children() const
PredefinedIdentKind getIdentKind() const
SourceLocation getLocation() const
StringLiteral * getFunctionName()
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
const Expr * getResultExpr() const
const_semantics_iterator semantics_begin() const
semantics_iterator semantics_end()
SourceLocation getExprLoc() const LLVM_READONLY
unsigned getResultExprIndex() const
Return the index of the result-bearing expression into the semantics expressions, or PseudoObjectExpr...
semantics_iterator semantics_begin()
const Expr *const * const_semantics_iterator
SourceLocation getBeginLoc() const LLVM_READONLY
Expr *const * semantics_iterator
const_semantics_iterator semantics_end() const
const Expr * getSyntacticForm() const
static bool classof(const Stmt *T)
const Expr * getSemanticExpr(unsigned index) const
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
ArrayRef< Expr * > semantics()
ArrayRef< const Expr * > semantics() const
unsigned getNumSemanticExprs() const
Expr * getSemanticExpr(unsigned index)
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
SourceLocation getEndLoc() const LLVM_READONLY
const_child_range children() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Represents a struct/union/class.
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
ArrayRef< const Expr * > subExpressions() const
ArrayRef< Expr * > subExpressions()
SourceLocation getEndLoc() const
static bool classof(const Stmt *T)
SourceLocation getBeginLoc() const
static RecoveryExpr * CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs)
Base for LValueReferenceType and RValueReferenceType.
static bool classof(const Stmt *T)
const_child_range children() const
SourceLocation getLocation() const
const TypeSourceInfo * getTypeSourceInfo() const
SourceLocation getLParenLocation() const
TypeSourceInfo * getTypeSourceInfo()
std::string ComputeName(ASTContext &Context) const
SourceLocation getBeginLoc() const
SourceLocation getRParenLocation() const
SourceLocation getEndLoc() const
static SYCLUniqueStableNameExpr * CreateEmpty(const ASTContext &Ctx)
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
ShuffleVectorExpr(EmptyShell Empty)
Build an empty vector-shuffle expression.
llvm::APSInt getShuffleMaskIdx(unsigned N) const
void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)
Expr ** getSubExprs()
Retrieve the array of expressions.
const_child_range children() const
SourceLocation getBuiltinLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
void setRParenLoc(SourceLocation L)
const Expr * getExpr(unsigned Index) const
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
static bool classof(const Stmt *T)
SourceLocation getRParenLoc() const
SourceLocation getBeginLoc() const LLVM_READONLY
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
void setBuiltinLoc(SourceLocation L)
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...
SourceLocExpr(EmptyShell Empty)
Build an empty call expression.
SourceLocation getBeginLoc() const
APValue EvaluateInContext(const ASTContext &Ctx, const Expr *DefaultExpr) const
Return the result of evaluating this SourceLocExpr in the specified (and possibly null) default argum...
static bool classof(const Stmt *T)
SourceLocation getLocation() const
const DeclContext * getParentContext() const
If the SourceLocExpr has been resolved return the subexpression representing the resolved value.
SourceLocation getEndLoc() const
DeclContext * getParentContext()
StringRef getBuiltinStr() const
Return a string representing the name of the specific builtin function.
const_child_range children() const
static bool MayBeDependent(SourceLocIdentKind Kind)
SourceLocIdentKind getIdentKind() const
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
const CompoundStmt * getSubStmt() const
void setRParenLoc(SourceLocation L)
const_child_range children() const
CompoundStmt * getSubStmt()
static bool classof(const Stmt *T)
StmtExpr(CompoundStmt *SubStmt, QualType T, SourceLocation LParenLoc, SourceLocation RParenLoc, unsigned TemplateDepth)
StmtExpr(EmptyShell Empty)
Build an empty statement expression.
void setLParenLoc(SourceLocation L)
SourceLocation getEndLoc() const LLVM_READONLY
unsigned getTemplateDepth() const
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getRParenLoc() const
void setSubStmt(CompoundStmt *S)
SourceLocation getLParenLoc() const
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits
GenericSelectionExprBitfields GenericSelectionExprBits
InitListExprBitfields InitListExprBits
ParenListExprBitfields ParenListExprBits
ArrayOrMatrixSubscriptExprBitfields ArrayOrMatrixSubscriptExprBits
ParenExprBitfields ParenExprBits
StmtIterator child_iterator
Child Iterators: All subclasses must implement 'children' to permit easy iteration over the substatem...
CallExprBitfields CallExprBits
ShuffleVectorExprBitfields ShuffleVectorExprBits
FloatingLiteralBitfields FloatingLiteralBits
child_iterator child_begin()
StmtClass getStmtClass() const
CharacterLiteralBitfields CharacterLiteralBits
UnaryOperatorBitfields UnaryOperatorBits
SourceLocExprBitfields SourceLocExprBits
ChooseExprBitfields ChooseExprBits
ConstantExprBitfields ConstantExprBits
llvm::iterator_range< child_iterator > child_range
StmtExprBitfields StmtExprBits
StringLiteralBitfields StringLiteralBits
OpaqueValueExprBitfields OpaqueValueExprBits
CastExprBitfields CastExprBits
MemberExprBitfields MemberExprBits
DeclRefExprBitfields DeclRefExprBits
ConstStmtIterator const_child_iterator
PredefinedExprBitfields PredefinedExprBits
ConvertVectorExprBitfields ConvertVectorExprBits
SourceLocation getBeginLoc() const LLVM_READONLY
BinaryOperatorBitfields BinaryOperatorBits
PseudoObjectExprBitfields PseudoObjectExprBits
llvm::iterator_range< const_child_iterator > const_child_range
The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.
void AddTaggedVal(uint64_t V, DiagnosticsEngine::ArgumentKind Kind) const
StringLiteral - This represents a string literal expression, e.g.
const_child_range children() const
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
SourceLocation getBeginLoc() const LLVM_READONLY
bool containsNonAscii() const
bool containsNonAsciiOrNull() const
unsigned getLength() const
static bool classof(const Stmt *T)
tokloc_iterator tokloc_begin() const
tokloc_iterator tokloc_end() const
StringLiteralKind getKind() const
SourceLocation getLocationOfByte(unsigned ByteNo, const SourceManager &SM, const LangOptions &Features, const TargetInfo &Target, unsigned *StartToken=nullptr, unsigned *StartTokenByteOffset=nullptr) const
getLocationOfByte - Return a source location that points to the specified byte of this string literal...
StringRef getBytes() const
Allow access to clients that need the byte representation, such as ASTWriterStmt::VisitStringLiteral(...
uint32_t getCodeUnit(size_t i) const
bool isUnevaluated() const
void outputString(raw_ostream &OS) const
int64_t getCodeUnitS(size_t I, uint64_t BitWidth) const
unsigned getByteLength() const
StringRef getString() const
static StringLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumConcatenated, unsigned Length, unsigned CharByteWidth)
Construct an empty string literal.
SourceLocation getEndLoc() const LLVM_READONLY
const SourceLocation * tokloc_iterator
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
unsigned getCharByteWidth() const
Exposes information about the current target.
A convenient class for passing around template argument information.
Location wrapper for a TemplateArgument.
A container of type source information.
QualType getType() const
Return the type wrapped by this type source info.
The base class of the type hierarchy.
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
bool isReferenceType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
const T * getAs() const
Member-template getAs<specific type>'.
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
SourceLocation getRParenLoc() const
SourceLocation getEndLoc() const LLVM_READONLY
void setKind(UnaryExprOrTypeTrait K)
QualType getArgumentType() const
void setOperatorLoc(SourceLocation L)
SourceLocation getOperatorLoc() const
const Expr * getArgumentExpr() const
SourceLocation getBeginLoc() const LLVM_READONLY
void setRParenLoc(SourceLocation L)
static bool classof(const Stmt *T)
QualType getTypeOfArgument() const
Gets the argument type, or the type of the argument expression, whichever is appropriate.
bool isArgumentType() const
void setArgument(Expr *E)
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo, QualType resultType, SourceLocation op, SourceLocation rp)
TypeSourceInfo * getArgumentTypeInfo() const
UnaryExprOrTypeTraitExpr(EmptyShell Empty)
Construct an empty sizeof/alignof expression.
UnaryExprOrTypeTrait getKind() const
void setArgument(TypeSourceInfo *TInfo)
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
static bool classof(const Stmt *T)
static bool isPostfix(Opcode Op)
isPostfix - Return true if this is a postfix operation, like x++.
bool isDecrementOp() const
SourceLocation getExprLoc() const
bool isFEnvAccessOn(const LangOptions &LO) const
Get the FENV_ACCESS status of this operator.
void setOperatorLoc(SourceLocation L)
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
SourceLocation getEndLoc() const LLVM_READONLY
bool isArithmeticOp() const
void setCanOverflow(bool C)
UnaryOperator(bool HasFPFeatures, EmptyShell Empty)
Build an empty unary operator.
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
void setOpcode(Opcode Opc)
static bool isIncrementOp(Opcode Op)
static bool isIncrementDecrementOp(Opcode Op)
SourceLocation getBeginLoc() const LLVM_READONLY
static bool isDecrementOp(Opcode Op)
FPOptionsOverride getStoredFPFeaturesOrDefault() const
Get the store FPOptionsOverride or default if not stored.
FPOptionsOverride getStoredFPFeatures() const
Get FPFeatures from trailing storage.
bool isFPContractableWithinStatement(const LangOptions &LO) const
Get the FP contractibility status of this operator.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix)
Retrieve the unary opcode that corresponds to the given overloaded operator.
FPOptions getFPFeaturesInEffect(const LangOptions &LO) const
Get the FP features status of this operator.
void setStoredFPFeatures(FPOptionsOverride F)
Set FPFeatures in trailing storage, used by Serialization & ASTImporter.
FPOptionsOverride getFPOptionsOverride() const
static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
static bool isPrefix(Opcode Op)
isPrefix - Return true if this is a prefix operation, like –x.
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
static bool isArithmeticOp(Opcode Op)
bool isIncrementDecrementOp() const
bool isIncrementOp() const
const_child_range children() const
bool canOverflow() const
Returns true if the unary operator can cause an overflow.
Represents a call to the builtin function __builtin_va_arg.
VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo, SourceLocation RPLoc, QualType t, bool IsMS)
void setRParenLoc(SourceLocation L)
TypeSourceInfo * getWrittenTypeInfo() const
SourceLocation getBuiltinLoc() const
SourceLocation getRParenLoc() const
VAArgExpr(EmptyShell Empty)
Create an empty __builtin_va_arg expression.
bool isMicrosoftABI() const
Returns whether this is really a Win64 ABI va_arg expression.
void setIsMicrosoftABI(bool IsMS)
static bool classof(const Stmt *T)
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const LLVM_READONLY
void setBuiltinLoc(SourceLocation L)
void setWrittenTypeInfo(TypeSourceInfo *TI)
const_child_range children() const
const Expr * getSubExpr() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a statement that could possibly have a value and type.
Stmt(StmtClass SC, EmptyShell)
Construct an empty statement.
Represents a variable declaration or definition.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
bool Const(InterpState &S, CodePtr OpPC, const T &Arg)
std::variant< struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl, struct ModuleDecl, struct ExcludeDecl, struct ExportDecl, struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl, struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl > Decl
All declarations that can appear in a module declaration.
The JSON file list parser is used to communicate input to InstallAPI.
LLVM_READNONE bool isASCII(char c)
Returns true if a byte is an ASCII character.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
ConstantResultStorageKind
Describes the kind of result that can be tail-allocated.
StmtIterator cast_away_const(const ConstStmtIterator &RHS)
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
@ OK_VectorComponent
A vector component is an element or range of elements on a vector.
@ OK_Ordinary
An ordinary object is located at an address in memory.
@ OK_BitField
A bitfield object is a bitfield on a C or C++ record.
@ OK_MatrixComponent
A matrix component is a single element of a matrix.
ExprDependence computeDependence(FullExpr *E)
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
bool operator==(const CallGraphNode::CallRecord &LHS, const CallGraphNode::CallRecord &RHS)
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
@ Result
The result type of a method or function.
CastKind
CastKind - The kind of operation required for a conversion.
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
@ VK_PRValue
A pr-value expression (in the C++11 taxonomy) produces a temporary value.
@ VK_XValue
An x-value expression is a reference to an object with independent storage but which can be "moved",...
@ VK_LValue
An l-value expression is a reference to an object with independent storage.
const FunctionProtoType * T
SmallVector< CXXBaseSpecifier *, 4 > CXXCastPath
A simple array of base specifiers.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs.
@ None
The alignment was not explicit in code.
@ Other
Other implicit parameter.
@ PrettyFunctionNoVirtual
The same as PrettyFunction, except that the 'virtual' keyword is omitted for virtual member functions...
NonOdrUseReason
The reason why a DeclRefExpr does not constitute an odr-use.
@ NOUR_None
This is an odr-use.
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Copy initialization expr of a __block variable and a boolean flag that indicates whether the expressi...
BlockVarCopyInit(Expr *CopyExpr, bool CanThrow)
Expr * getCopyExpr() const
BlockVarCopyInit()=default
llvm::PointerIntPair< Expr *, 1, bool > ExprAndFlag
void setExprAndFlag(Expr *CopyExpr, bool CanThrow)
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
Stores data related to a single #embed directive.
StringLiteral * BinaryData
size_t getDataElementCount() const
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool isGlobalLValue() const
EvalStatus is a struct with detailed info about an evaluation in progress.
bool hasSideEffects() const
SmallVectorImpl< PartialDiagnosticAt > * Diag
Diag - If this is non-null, it will be filled in with a stack of notes indicating why evaluation fail...
bool HasUndefinedBehavior
Whether the evaluation hit undefined behavior.
bool HasSideEffects
Whether the evaluated expression has side effects.
Iterator for iterating over Stmt * arrays that contain only T *.
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....
const CastExpr * BasePath
const CXXRecordDecl * DerivedClass
const MemberPointerType * MPT
An adjustment to be made to the temporary created when emitting a reference binding,...
@ DerivedToBaseAdjustment
@ MemberPointerAdjustment
SubobjectAdjustment(const MemberPointerType *MPT, Expr *RHS)
SubobjectAdjustment(const FieldDecl *Field)
SubobjectAdjustment(const CastExpr *BasePath, const CXXRecordDecl *DerivedClass)
enum clang::SubobjectAdjustment::@52 Kind