35#include "llvm/Support/ErrorHandling.h"
36#include "llvm/Support/Format.h"
37#include "llvm/Support/raw_ostream.h"
49 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
50 if (BO->getOpcode() == BO_Comma) {
57 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E)) {
58 E = MTE->getSubExpr();
79 return cast<CXXRecordDecl>(D);
89 if (
const auto *CE = dyn_cast<CastExpr>(E)) {
90 if ((CE->getCastKind() == CK_DerivedToBase ||
91 CE->getCastKind() == CK_UncheckedDerivedToBase) &&
100 if (CE->getCastKind() == CK_NoOp) {
101 E = CE->getSubExpr();
104 }
else if (
const auto *ME = dyn_cast<MemberExpr>(E)) {
105 if (!ME->isArrow()) {
106 assert(ME->getBase()->getType()->getAsRecordDecl());
107 if (
const auto *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
108 if (!Field->isBitField() && !Field->getType()->isReferenceType()) {
115 }
else if (
const auto *BO = dyn_cast<BinaryOperator>(E)) {
116 if (BO->getOpcode() == BO_PtrMemD) {
117 assert(BO->getRHS()->isPRValue());
123 if (BO->getOpcode() == BO_Comma) {
124 CommaLHSs.push_back(BO->getLHS());
145 switch (UO->getOpcode()) {
147 return UO->getSubExpr()->isKnownToHaveBooleanValue(Semantic);
159 return CE->getSubExpr()->isKnownToHaveBooleanValue(Semantic);
162 switch (BO->getOpcode()) {
163 default:
return false;
178 return BO->getLHS()->isKnownToHaveBooleanValue(Semantic) &&
179 BO->getRHS()->isKnownToHaveBooleanValue(Semantic);
183 return BO->getRHS()->isKnownToHaveBooleanValue(Semantic);
188 return CO->getTrueExpr()->isKnownToHaveBooleanValue(Semantic) &&
189 CO->getFalseExpr()->isKnownToHaveBooleanValue(Semantic);
191 if (isa<ObjCBoolLiteralExpr>(E))
194 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
195 return OVE->getSourceExpr()->isKnownToHaveBooleanValue(Semantic);
198 if (!Semantic && FD->getType()->isUnsignedIntegerType() &&
199 !FD->getBitWidth()->isValueDependent() &&
200 FD->getBitWidthValue(FD->getASTContext()) == 1)
209 bool IgnoreTemplateOrMacroSubstitution)
const {
211 const Decl *D =
nullptr;
213 if (
const auto *ME = dyn_cast<MemberExpr>(E))
214 D = ME->getMemberDecl();
215 else if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
217 else if (
const auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
221 StrictFlexArraysLevel,
222 IgnoreTemplateOrMacroSubstitution);
232 if (
Value.isMemberPointer())
233 return Value.getMemberPointerDecl();
235 if (
Value.isLValue() &&
Value.getLValueOffset().isZero())
249 template <
class E,
class T>
252 return static_cast<const E*
>(
expr)->getExprLoc();
262 return static_cast<const E *
>(
expr)->getBeginLoc();
270 const auto *ED = cast<EnumDecl>(ECD->getDeclContext());
271 if (ED->isCompleteDefinition())
280#define ABSTRACT_STMT(type)
281#define STMT(type, base) \
282 case Stmt::type##Class: break;
283#define EXPR(type, base) \
284 case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
285#include "clang/AST/StmtNodes.inc"
287 llvm_unreachable(
"unknown expression kind");
298 "Invalid StorageKind Value");
308 if (!
Value.getInt().needsCleanup())
324 bool IsImmediateInvocation)
325 :
FullExpr(ConstantExprClass, SubExpr) {
334 ::new (getTrailingObjects<APValue>())
APValue();
339 bool IsImmediateInvocation) {
340 assert(!isa<ConstantExpr>(E));
343 unsigned Size = totalSizeToAlloc<APValue, uint64_t>(
347 return new (Mem)
ConstantExpr(E, StorageKind, IsImmediateInvocation);
358ConstantExpr::ConstantExpr(EmptyShell Empty,
360 :
FullExpr(ConstantExprClass, Empty) {
364 ::new (getTrailingObjects<APValue>())
APValue();
371 unsigned Size = totalSizeToAlloc<APValue, uint64_t>(
380 "Invalid storage for this value kind");
386 Int64Result() = *
Value.getInt().getRawData();
395 APValueResult() = std::move(
Value);
398 llvm_unreachable(
"Invalid ResultKind Bits");
404 return APValueResult().
getInt();
409 llvm_unreachable(
"invalid Accessor");
417 return APValueResult();
427 llvm_unreachable(
"invalid ResultKind");
431 bool RefersToEnclosingVariableOrCapture,
QualType T,
441 RefersToEnclosingVariableOrCapture;
442 DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter =
false;
449DeclRefExpr::DeclRefExpr(
const ASTContext &Ctx,
452 bool RefersToEnclosingVariableOrCapture,
461 new (getTrailingObjects<NestedNameSpecifierLoc>())
465 *getTrailingObjects<NamedDecl *>() = FoundD;
467 = (TemplateArgs || TemplateKWLoc.
isValid()) ? 1 : 0;
469 RefersToEnclosingVariableOrCapture;
470 DeclRefExprBits.CapturedByCopyInLambdaWithExplicitObjectParameter =
false;
473 auto Deps = TemplateArgumentDependence::None;
474 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
475 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
477 assert(!(Deps & TemplateArgumentDependence::Dependent) &&
478 "built a DeclRefExpr with dependent template args");
479 }
else if (TemplateKWLoc.
isValid()) {
480 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
491 bool RefersToEnclosingVariableOrCapture,
496 return Create(Context, QualifierLoc, TemplateKWLoc, D,
497 RefersToEnclosingVariableOrCapture,
499 T, VK, FoundD, TemplateArgs, NOUR);
505 bool RefersToEnclosingVariableOrCapture,
515 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
519 QualifierLoc ? 1 : 0, FoundD ? 1 : 0,
520 HasTemplateKWAndArgsInfo ? 1 : 0,
521 TemplateArgs ? TemplateArgs->
size() : 0);
524 return new (Mem)
DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
525 RefersToEnclosingVariableOrCapture, NameInfo,
526 FoundD, TemplateArgs,
T, VK, NOUR);
532 bool HasTemplateKWAndArgsInfo,
533 unsigned NumTemplateArgs) {
534 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
538 HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo,
546 if (
getType()->isUndeducedType())
562SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(
SourceLocation OpLoc,
568 OpLoc(OpLoc), LParen(LParen), RParen(RParen) {
569 setTypeSourceInfo(TSI);
573SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell Empty,
600 const NamedDecl *ND) -> std::optional<unsigned> {
601 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
602 return RD->getDeviceLambdaManglingNumber();
611 llvm::raw_string_ostream Out(Buffer);
612 Ctx->mangleCanonicalTypeName(Ty, Out);
622 assert((getIdentKind() == IK) &&
623 "IdentKind do not fit in PredefinedExprBitfields!");
624 bool HasFunctionName = SL !=
nullptr;
633PredefinedExpr::PredefinedExpr(EmptyShell Empty,
bool HasFunctionName)
634 :
Expr(PredefinedExprClass, Empty) {
641 bool HasFunctionName = SL !=
nullptr;
642 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
648 bool HasFunctionName) {
649 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
659 return "__FUNCTION__";
661 return "__FUNCDNAME__";
663 return "L__FUNCTION__";
665 return "__PRETTY_FUNCTION__";
667 return "__FUNCSIG__";
669 return "L__FUNCSIG__";
673 llvm_unreachable(
"Unknown ident kind for PredefinedExpr");
679 const Decl *CurrentDecl,
680 bool ForceElaboratedPrinting) {
684 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
685 std::unique_ptr<MangleContext> MC;
688 if (MC->shouldMangleDeclName(ND)) {
690 llvm::raw_svector_ostream Out(Buffer);
696 else if (ND->hasAttr<CUDAGlobalAttr>())
700 MC->mangleName(GD, Out);
702 if (!Buffer.empty() && Buffer.front() ==
'\01')
703 return std::string(Buffer.substr(1));
704 return std::string(Buffer);
706 return std::string(ND->getIdentifier()->getName());
710 if (isa<BlockDecl>(CurrentDecl)) {
715 if (DC->isFileContext())
719 llvm::raw_svector_ostream Out(Buffer);
720 if (
auto *DCBlock = dyn_cast<BlockDecl>(DC))
723 else if (
auto *DCDecl = dyn_cast<Decl>(DC))
725 return std::string(Out.str());
727 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
729 bool IsFuncOrFunctionInNonMSVCCompatEnv =
731 IK == PredefinedIdentKind ::Function) &&
733 bool IsLFunctionInMSVCCommpatEnv =
735 bool IsFuncOrFunctionOrLFunctionOrFuncDName =
740 if ((ForceElaboratedPrinting &&
741 (IsFuncOrFunctionInNonMSVCCompatEnv || IsLFunctionInMSVCCommpatEnv)) ||
742 (!ForceElaboratedPrinting && IsFuncOrFunctionOrLFunctionOrFuncDName))
743 return FD->getNameAsString();
746 llvm::raw_svector_ostream Out(Name);
758 std::string remapPath(StringRef Path)
const override {
761 return std::string(p);
773 llvm::raw_string_ostream POut(Proto);
780 if (FD->hasWrittenPrototype())
781 FT = dyn_cast<FunctionProtoType>(AFT);
786 case CC_C: POut <<
"__cdecl ";
break;
797 FD->printQualifiedName(POut, Policy);
802 return std::string(Name);
807 for (
unsigned i = 0, e =
Decl->getNumParams(); i != e; ++i) {
809 POut <<
Decl->getParamDecl(i)->getType().stream(Policy);
812 if (FT->isVariadic()) {
813 if (FD->getNumParams()) POut <<
", ";
818 !
Decl->getNumParams()) {
825 assert(FT &&
"We must have a written prototype in this case.");
828 if (FT->isVolatile())
840 while (Ctx && isa<NamedDecl>(Ctx)) {
842 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
844 Specs.push_back(Spec);
848 std::string TemplateParams;
849 llvm::raw_string_ostream TOut(TemplateParams);
852 D->getSpecializedTemplate()->getTemplateParameters();
854 assert(Params->
size() == Args.
size());
855 for (
unsigned i = 0, numParams = Params->
size(); i != numParams; ++i) {
857 if (Param.empty())
continue;
858 TOut << Param <<
" = ";
867 = FD->getTemplateSpecializationInfo();
872 assert(Params->
size() == Args->
size());
873 for (
unsigned i = 0, e = Params->
size(); i != e; ++i) {
875 if (Param.empty())
continue;
876 TOut << Param <<
" = ";
877 Args->
get(i).
print(Policy, TOut,
true);
883 if (!TemplateParams.empty()) {
885 TemplateParams.resize(TemplateParams.size() - 2);
886 POut <<
" [" << TemplateParams <<
"]";
895 if (isa<CXXMethodDecl>(FD) &&
896 cast<CXXMethodDecl>(FD)->getParent()->isLambda())
897 Proto =
"auto " + Proto;
898 else if (FT && FT->getReturnType()->getAs<
DecltypeType>())
903 else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
908 return std::string(Name);
910 if (
const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
914 if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {
918 llvm_unreachable(
"CapturedDecl not inside a function or method");
920 if (
const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
922 llvm::raw_svector_ostream Out(Name);
923 Out << (MD->isInstanceMethod() ?
'-' :
'+');
932 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
933 Out <<
'(' << *CID <<
')';
936 MD->getSelector().print(Out);
939 return std::string(Name);
941 if (isa<TranslationUnitDecl>(CurrentDecl) &&
950 const llvm::APInt &Val) {
954 BitWidth = Val.getBitWidth();
955 unsigned NumWords = Val.getNumWords();
956 const uint64_t* Words = Val.getRawData();
958 pVal =
new (
C) uint64_t[NumWords];
959 std::copy(Words, Words + NumWords,
pVal);
960 }
else if (NumWords == 1)
966IntegerLiteral::IntegerLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
969 assert(
type->isIntegerType() &&
"Illegal type in IntegerLiteral");
970 assert(
V.getBitWidth() ==
C.getIntWidth(
type) &&
971 "Integer type is not the correct size for constant.");
987FixedPointLiteral::FixedPointLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
992 assert(
type->isFixedPointType() &&
"Illegal type in FixedPointLiteral");
993 assert(
V.getBitWidth() ==
C.getTypeInfo(
type).Width &&
994 "Fixed point type is not the correct size for constant.");
1000 const llvm::APInt &
V,
1018 S, llvm::APSInt::getUnsigned(
getValue().getZExtValue()), Scale);
1019 return std::string(S);
1041 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Val);
1042 if (!Escaped.empty()) {
1043 OS <<
"'" << Escaped <<
"'";
1052 OS <<
"'" << (char)Val <<
"'";
1054 OS <<
"'\\x" << llvm::format(
"%02x", Val) <<
"'";
1055 else if (Val <= 0xFFFF)
1056 OS <<
"'\\u" << llvm::format(
"%04x", Val) <<
"'";
1058 OS <<
"'\\U" << llvm::format(
"%08x", Val) <<
"'";
1062FloatingLiteral::FloatingLiteral(
const ASTContext &
C,
const llvm::APFloat &
V,
1065 setSemantics(
V.getSemantics());
1071FloatingLiteral::FloatingLiteral(
const ASTContext &
C, EmptyShell Empty)
1072 :
Expr(FloatingLiteralClass, Empty) {
1073 setRawSemantics(llvm::APFloatBase::S_IEEEhalf);
1094 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
1096 return V.convertToDouble();
1101 unsigned CharByteWidth = 0;
1105 CharByteWidth =
Target.getCharWidth();
1108 CharByteWidth =
Target.getWCharWidth();
1111 CharByteWidth =
Target.getChar16Width();
1114 CharByteWidth =
Target.getChar32Width();
1117 return sizeof(char);
1119 assert((CharByteWidth & 7) == 0 &&
"Assumes character size is byte multiple");
1121 assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&
1122 "The only supported character byte widths are 1,2 and 4!");
1123 return CharByteWidth;
1126StringLiteral::StringLiteral(
const ASTContext &Ctx, StringRef Str,
1129 unsigned NumConcatenated)
1132 unsigned Length = Str.size();
1139 "StringLiteral must be of constant array type!");
1140 unsigned CharByteWidth = mapCharByteWidth(Ctx.
getTargetInfo(), Kind);
1141 unsigned ByteLength = Str.size();
1142 assert((ByteLength % CharByteWidth == 0) &&
1143 "The size of the data must be a multiple of CharByteWidth!");
1148 switch (CharByteWidth) {
1150 Length = ByteLength;
1153 Length = ByteLength / 2;
1156 Length = ByteLength / 4;
1159 llvm_unreachable(
"Unsupported character width!");
1165 assert(!Pascal &&
"Can't make an unevaluated Pascal string");
1170 *getTrailingObjects<unsigned>() = Length;
1174 std::memcpy(getTrailingObjects<SourceLocation>(), Loc,
1178 std::memcpy(getTrailingObjects<char>(), Str.data(), Str.size());
1183StringLiteral::StringLiteral(EmptyShell Empty,
unsigned NumConcatenated,
1184 unsigned Length,
unsigned CharByteWidth)
1185 :
Expr(StringLiteralClass, Empty) {
1188 *getTrailingObjects<unsigned>() = Length;
1194 unsigned NumConcatenated) {
1195 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1196 1, NumConcatenated, Str.size()),
1203 unsigned NumConcatenated,
1205 unsigned CharByteWidth) {
1206 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1207 1, NumConcatenated, Length * CharByteWidth),
1232 static const char Hex[] =
"0123456789ABCDEF";
1235 for (
unsigned I = 0, N =
getLength(); I != N; ++I) {
1237 StringRef Escaped = escapeCStyle<EscapeChar::Double>(Char);
1238 if (Escaped.empty()) {
1244 Char >= 0xd800 && Char <= 0xdbff) {
1246 if (Trail >= 0xdc00 && Trail <= 0xdfff) {
1247 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
1257 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
1261 while ((Char >> Shift) == 0)
1263 for (; Shift >= 0; Shift -= 4)
1264 OS << Hex[(Char >> Shift) & 15];
1271 << Hex[(Char >> 20) & 15]
1272 << Hex[(Char >> 16) & 15];
1275 OS << Hex[(Char >> 12) & 15]
1276 << Hex[(Char >> 8) & 15]
1277 << Hex[(Char >> 4) & 15]
1278 << Hex[(Char >> 0) & 15];
1284 if (LastSlashX + 1 == I) {
1286 case '0':
case '1':
case '2':
case '3':
case '4':
1287 case '5':
case '6':
case '7':
case '8':
case '9':
1288 case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
1289 case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
1294 assert(Char <= 0xff &&
1295 "Characters above 0xff should already have been handled.");
1301 << (char)(
'0' + ((Char >> 6) & 7))
1302 << (char)(
'0' + ((Char >> 3) & 7))
1303 << (char)(
'0' + ((Char >> 0) & 7));
1332 unsigned *StartTokenByteOffset)
const {
1336 "Only narrow string literals are currently supported");
1341 unsigned StringOffset = 0;
1343 TokNo = *StartToken;
1344 if (StartTokenByteOffset) {
1345 StringOffset = *StartTokenByteOffset;
1346 ByteNo -= StringOffset;
1358 std::pair<FileID, unsigned> LocInfo =
1359 SM.getDecomposedLoc(StrTokSpellingLoc);
1361 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
1363 if (StartTokenByteOffset !=
nullptr)
1364 *StartTokenByteOffset = StringOffset;
1365 if (StartToken !=
nullptr)
1366 *StartToken = TokNo;
1367 return StrTokSpellingLoc;
1370 const char *StrData = Buffer.data()+LocInfo.second;
1373 Lexer TheLexer(
SM.getLocForStartOfFile(LocInfo.first), Features,
1374 Buffer.begin(), StrData, Buffer.end());
1383 if (ByteNo < TokNumBytes ||
1389 if (StartTokenByteOffset !=
nullptr)
1390 *StartTokenByteOffset = StringOffset;
1391 if (StartToken !=
nullptr)
1392 *StartToken = TokNo;
1397 StringOffset += TokNumBytes;
1399 ByteNo -= TokNumBytes;
1407#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;
1408#include "clang/AST/OperationKinds.def"
1410 llvm_unreachable(
"Unknown unary operator");
1416 default: llvm_unreachable(
"No unary operator for overloaded function");
1417 case OO_PlusPlus:
return Postfix ? UO_PostInc : UO_PreInc;
1418 case OO_MinusMinus:
return Postfix ? UO_PostDec : UO_PreDec;
1419 case OO_Amp:
return UO_AddrOf;
1420 case OO_Star:
return UO_Deref;
1421 case OO_Plus:
return UO_Plus;
1422 case OO_Minus:
return UO_Minus;
1423 case OO_Tilde:
return UO_Not;
1424 case OO_Exclaim:
return UO_LNot;
1425 case OO_Coawait:
return UO_Coawait;
1431 case UO_PostInc:
case UO_PreInc:
return OO_PlusPlus;
1432 case UO_PostDec:
case UO_PreDec:
return OO_MinusMinus;
1433 case UO_AddrOf:
return OO_Amp;
1434 case UO_Deref:
return OO_Star;
1435 case UO_Plus:
return OO_Plus;
1436 case UO_Minus:
return OO_Minus;
1437 case UO_Not:
return OO_Tilde;
1438 case UO_LNot:
return OO_Exclaim;
1439 case UO_Coawait:
return OO_Coawait;
1454 NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1455 unsigned NumPreArgs = PreArgs.size();
1457 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1459 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1460 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1461 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1462 "OffsetToTrailingObjects overflow!");
1467 for (
unsigned I = 0; I != NumPreArgs; ++I)
1469 for (
unsigned I = 0; I != Args.size(); ++I)
1471 for (
unsigned I = Args.size(); I != NumArgs; ++I)
1483 :
Expr(SC, Empty), NumArgs(NumArgs) {
1485 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1487 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1488 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1489 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1490 "OffsetToTrailingObjects overflow!");
1499 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1504 return new (Mem)
CallExpr(CallExprClass, Fn, {}, Args, Ty, VK,
1505 RParenLoc, FPFeatures, MinNumArgs,
UsesADL);
1512 "Misaligned memory in CallExpr::CreateTemporary!");
1513 return new (Mem)
CallExpr(CallExprClass, Fn, {}, {}, Ty,
1520 unsigned SizeOfTrailingObjects =
1525 CallExpr(CallExprClass, 0, NumArgs, HasFPFeatures, Empty);
1528unsigned CallExpr::offsetToTrailingObjects(StmtClass SC) {
1532 case CXXOperatorCallExprClass:
1534 case CXXMemberCallExprClass:
1536 case UserDefinedLiteralClass:
1538 case CUDAKernelCallExprClass:
1541 llvm_unreachable(
"unexpected class deriving from CallExpr!");
1548 while (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE))
1553 if (
auto *BO = dyn_cast<BinaryOperator>(CEE)) {
1554 if (BO->isPtrMemOp()) {
1558 }
else if (
auto *UO = dyn_cast<UnaryOperator>(CEE)) {
1559 if (UO->getOpcode() == UO_Deref || UO->getOpcode() == UO_AddrOf ||
1560 UO->getOpcode() == UO_Plus) {
1568 if (
auto *DRE = dyn_cast<DeclRefExpr>(CEE))
1569 return DRE->getDecl();
1570 if (
auto *ME = dyn_cast<MemberExpr>(CEE))
1571 return ME->getMemberDecl();
1572 if (
auto *BE = dyn_cast<BlockExpr>(CEE))
1573 return BE->getBlockDecl();
1581 return FDecl ? FDecl->getBuiltinID() : 0;
1592 QualType CalleeType = Callee->getType();
1598 if (isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))
1601 if (isa<UnresolvedMemberExpr>(Callee->IgnoreParens()))
1606 assert(!CalleeType.
isNull());
1624 if (
const auto *A = TD->getAttr<WarnUnusedResultAttr>())
1628 TD = TD->desugar()->getAs<TypedefType>())
1629 if (
const auto *A = TD->getDecl()->getAttr<WarnUnusedResultAttr>())
1635 return D ? D->
getAttr<WarnUnusedResultAttr>() :
nullptr;
1639 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
this))
1640 return OCE->getBeginLoc();
1648 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
this))
1649 return OCE->getEndLoc();
1663 void *Mem =
C.Allocate(
1664 totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
1671 unsigned numComps,
unsigned numExprs) {
1673 C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
1682 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1683 NumComps(comps.size()), NumExprs(exprs.size()) {
1684 for (
unsigned i = 0; i != comps.size(); ++i)
1686 for (
unsigned i = 0; i != exprs.size(); ++i)
1704 OpLoc(op), RParenLoc(rp) {
1705 assert(ExprKind <=
UETT_Last &&
"invalid enum value!");
1708 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
1722 :
Expr(MemberExprClass,
T, VK, OK),
Base(
Base), MemberDecl(MemberDecl),
1723 MemberDNLoc(NameInfo.
getInfo()), MemberLoc(NameInfo.getLoc()) {
1729 FoundDecl.getDecl() != MemberDecl ||
1732 TemplateArgs || TemplateKWLoc.
isValid();
1738 new (getTrailingObjects<NestedNameSpecifierLoc>())
1741 *getTrailingObjects<DeclAccessPair>() = FoundDecl;
1743 auto Deps = TemplateArgumentDependence::None;
1744 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1745 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
1747 }
else if (TemplateKWLoc.
isValid()) {
1748 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
1761 bool HasFoundDecl = FoundDecl.getDecl() != MemberDecl ||
1763 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1767 HasQualifier, HasFoundDecl, HasTemplateKWAndArgsInfo,
1768 TemplateArgs ? TemplateArgs->
size() : 0);
1770 void *Mem =
C.Allocate(Size,
alignof(
MemberExpr));
1771 return new (Mem)
MemberExpr(
Base, IsArrow, OperatorLoc, QualifierLoc,
1772 TemplateKWLoc, MemberDecl, FoundDecl, NameInfo,
1773 TemplateArgs,
T, VK, OK, NOUR);
1777 bool HasQualifier,
bool HasFoundDecl,
1778 bool HasTemplateKWAndArgsInfo,
1779 unsigned NumTemplateArgs) {
1780 assert((!NumTemplateArgs || HasTemplateKWAndArgsInfo) &&
1781 "template args but no template arg info?");
1785 HasQualifier, HasFoundDecl, HasTemplateKWAndArgsInfo,
1793 if (
getType()->isUndeducedType())
1809 return BaseStartLoc;
1821bool CastExpr::CastConsistency()
const {
1823 case CK_DerivedToBase:
1824 case CK_UncheckedDerivedToBase:
1825 case CK_DerivedToBaseMemberPointer:
1826 case CK_BaseToDerived:
1827 case CK_BaseToDerivedMemberPointer:
1828 assert(!
path_empty() &&
"Cast kind should have a base path!");
1831 case CK_CPointerToObjCPointerCast:
1832 assert(
getType()->isObjCObjectPointerType());
1834 goto CheckNoBasePath;
1836 case CK_BlockPointerToObjCPointerCast:
1837 assert(
getType()->isObjCObjectPointerType());
1839 goto CheckNoBasePath;
1841 case CK_ReinterpretMemberPointer:
1842 assert(
getType()->isMemberPointerType());
1844 goto CheckNoBasePath;
1850 if (!
getType()->isPointerType()) {
1851 assert(
getType()->isObjCObjectPointerType() ==
1853 assert(
getType()->isBlockPointerType() ==
1856 goto CheckNoBasePath;
1858 case CK_AnyPointerToBlockPointerCast:
1859 assert(
getType()->isBlockPointerType());
1862 goto CheckNoBasePath;
1864 case CK_CopyAndAutoreleaseBlockObject:
1865 assert(
getType()->isBlockPointerType());
1867 goto CheckNoBasePath;
1869 case CK_FunctionToPointerDecay:
1870 assert(
getType()->isPointerType());
1872 goto CheckNoBasePath;
1874 case CK_AddressSpaceConversion: {
1883 (!Ty.
isNull() && !SETy.isNull() &&
1885 goto CheckNoBasePath;
1890 case CK_ArrayToPointerDecay:
1891 case CK_NullToMemberPointer:
1892 case CK_NullToPointer:
1893 case CK_ConstructorConversion:
1894 case CK_IntegralToPointer:
1895 case CK_PointerToIntegral:
1897 case CK_VectorSplat:
1898 case CK_IntegralCast:
1899 case CK_BooleanToSignedIntegral:
1900 case CK_IntegralToFloating:
1901 case CK_FloatingToIntegral:
1902 case CK_FloatingCast:
1903 case CK_ObjCObjectLValueCast:
1904 case CK_FloatingRealToComplex:
1905 case CK_FloatingComplexToReal:
1906 case CK_FloatingComplexCast:
1907 case CK_FloatingComplexToIntegralComplex:
1908 case CK_IntegralRealToComplex:
1909 case CK_IntegralComplexToReal:
1910 case CK_IntegralComplexCast:
1911 case CK_IntegralComplexToFloatingComplex:
1912 case CK_ARCProduceObject:
1913 case CK_ARCConsumeObject:
1914 case CK_ARCReclaimReturnedObject:
1915 case CK_ARCExtendBlockObject:
1916 case CK_ZeroToOCLOpaqueType:
1917 case CK_IntToOCLSampler:
1918 case CK_FloatingToFixedPoint:
1919 case CK_FixedPointToFloating:
1920 case CK_FixedPointCast:
1921 case CK_FixedPointToIntegral:
1922 case CK_IntegralToFixedPoint:
1924 case CK_HLSLVectorTruncation:
1926 goto CheckNoBasePath;
1929 case CK_LValueToRValue:
1931 case CK_AtomicToNonAtomic:
1932 case CK_NonAtomicToAtomic:
1933 case CK_PointerToBoolean:
1934 case CK_IntegralToBoolean:
1935 case CK_FloatingToBoolean:
1936 case CK_MemberPointerToBoolean:
1937 case CK_FloatingComplexToBoolean:
1938 case CK_IntegralComplexToBoolean:
1939 case CK_LValueBitCast:
1940 case CK_LValueToRValueBitCast:
1941 case CK_UserDefinedConversion:
1942 case CK_BuiltinFnToFnPtr:
1943 case CK_FixedPointToBoolean:
1944 case CK_HLSLArrayRValue:
1946 assert(
path_empty() &&
"Cast kind should not have a base path!");
1954#define CAST_OPERATION(Name) case CK_##Name: return #Name;
1955#include "clang/AST/OperationKinds.def"
1957 llvm_unreachable(
"Unhandled cast kind!");
1963static Expr *ignoreImplicitSemaNodes(
Expr *E) {
1964 if (
auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E))
1965 return Materialize->getSubExpr();
1967 if (
auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
1968 return Binder->getSubExpr();
1970 if (
auto *Full = dyn_cast<FullExpr>(E))
1971 return Full->getSubExpr();
1973 if (
auto *CPLIE = dyn_cast<CXXParenListInitExpr>(E);
1974 CPLIE && CPLIE->getInitExprs().size() == 1)
1975 return CPLIE->getInitExprs()[0];
1982 const Expr *SubExpr =
nullptr;
1984 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
1989 if (E->getCastKind() == CK_ConstructorConversion) {
1991 ignoreImplicitSemaNodes);
1992 }
else if (E->getCastKind() == CK_UserDefinedConversion) {
1993 assert((isa<CXXMemberCallExpr>(SubExpr) || isa<BlockExpr>(SubExpr)) &&
1994 "Unexpected SubExpr for CK_UserDefinedConversion.");
1995 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
1996 SubExpr = MCE->getImplicitObjectArgument();
2000 return const_cast<Expr *
>(SubExpr);
2004 const Expr *SubExpr =
nullptr;
2006 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
2009 if (E->getCastKind() == CK_ConstructorConversion)
2010 return cast<CXXConstructExpr>(SubExpr)->getConstructor();
2012 if (E->getCastKind() == CK_UserDefinedConversion) {
2013 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
2014 return MCE->getMethodDecl();
2023#define ABSTRACT_STMT(x)
2024#define CASTEXPR(Type, Base) \
2025 case Stmt::Type##Class: \
2026 return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>();
2027#define STMT(Type, Base)
2028#include "clang/AST/StmtNodes.inc"
2030 llvm_unreachable(
"non-cast expressions not possible here");
2045 Field != FieldEnd; ++Field) {
2047 !Field->isUnnamedBitField()) {
2057 case ImplicitCastExprClass:
2059 ->getTrailingObjects<FPOptionsOverride>();
2060 case CStyleCastExprClass:
2062 ->getTrailingObjects<FPOptionsOverride>();
2063 case CXXFunctionalCastExprClass:
2065 ->getTrailingObjects<FPOptionsOverride>();
2066 case CXXStaticCastExprClass:
2068 ->getTrailingObjects<FPOptionsOverride>();
2070 llvm_unreachable(
"Cast does not have FPFeatures");
2079 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2081 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2085 assert((Kind != CK_LValueToRValue ||
2087 "invalid type for lvalue-to-rvalue conversion");
2091 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2098 bool HasFPFeatures) {
2100 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2101 PathSize, HasFPFeatures));
2111 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2113 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2116 new (Buffer)
CStyleCastExpr(
T, VK, K, Op, PathSize, FPO, WrittenTy, L, R);
2118 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2125 bool HasFPFeatures) {
2127 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2128 PathSize, HasFPFeatures));
2136#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;
2137#include "clang/AST/OperationKinds.def"
2139 llvm_unreachable(
"Invalid OpCode!");
2145 default: llvm_unreachable(
"Not an overloadable binary operator");
2146 case OO_Plus:
return BO_Add;
2147 case OO_Minus:
return BO_Sub;
2148 case OO_Star:
return BO_Mul;
2149 case OO_Slash:
return BO_Div;
2150 case OO_Percent:
return BO_Rem;
2151 case OO_Caret:
return BO_Xor;
2152 case OO_Amp:
return BO_And;
2153 case OO_Pipe:
return BO_Or;
2154 case OO_Equal:
return BO_Assign;
2155 case OO_Spaceship:
return BO_Cmp;
2156 case OO_Less:
return BO_LT;
2157 case OO_Greater:
return BO_GT;
2158 case OO_PlusEqual:
return BO_AddAssign;
2159 case OO_MinusEqual:
return BO_SubAssign;
2160 case OO_StarEqual:
return BO_MulAssign;
2161 case OO_SlashEqual:
return BO_DivAssign;
2162 case OO_PercentEqual:
return BO_RemAssign;
2163 case OO_CaretEqual:
return BO_XorAssign;
2164 case OO_AmpEqual:
return BO_AndAssign;
2165 case OO_PipeEqual:
return BO_OrAssign;
2166 case OO_LessLess:
return BO_Shl;
2167 case OO_GreaterGreater:
return BO_Shr;
2168 case OO_LessLessEqual:
return BO_ShlAssign;
2169 case OO_GreaterGreaterEqual:
return BO_ShrAssign;
2170 case OO_EqualEqual:
return BO_EQ;
2171 case OO_ExclaimEqual:
return BO_NE;
2172 case OO_LessEqual:
return BO_LE;
2173 case OO_GreaterEqual:
return BO_GE;
2174 case OO_AmpAmp:
return BO_LAnd;
2175 case OO_PipePipe:
return BO_LOr;
2176 case OO_Comma:
return BO_Comma;
2177 case OO_ArrowStar:
return BO_PtrMemI;
2184 OO_Star, OO_Slash, OO_Percent,
2186 OO_LessLess, OO_GreaterGreater,
2188 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
2189 OO_EqualEqual, OO_ExclaimEqual,
2195 OO_Equal, OO_StarEqual,
2196 OO_SlashEqual, OO_PercentEqual,
2197 OO_PlusEqual, OO_MinusEqual,
2198 OO_LessLessEqual, OO_GreaterGreaterEqual,
2199 OO_AmpEqual, OO_CaretEqual,
2203 return OverOps[Opc];
2245 BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {
2249 ? ExprDependence::Value
2250 : ExprDependence::None);
2256 return "__builtin_FILE";
2258 return "__builtin_FILE_NAME";
2260 return "__builtin_FUNCTION";
2262 return "__builtin_FUNCSIG";
2264 return "__builtin_LINE";
2266 return "__builtin_COLUMN";
2268 return "__builtin_source_location";
2270 llvm_unreachable(
"unexpected IdentKind!");
2274 const Expr *DefaultExpr)
const {
2278 if (
const auto *DIE = dyn_cast_if_present<CXXDefaultInitExpr>(DefaultExpr)) {
2279 Loc = DIE->getUsedLocation();
2280 Context = DIE->getUsedContext();
2281 }
else if (
const auto *DAE =
2282 dyn_cast_if_present<CXXDefaultArgExpr>(DefaultExpr)) {
2283 Loc = DAE->getUsedLocation();
2284 Context = DAE->getUsedContext();
2293 auto MakeStringLiteral = [&](StringRef Tmp) {
2297 LValuePathEntry Path[1] = {LValuePathEntry::ArrayIndex(0)};
2308 return MakeStringLiteral(
FileName);
2314 return MakeStringLiteral(Path);
2318 const auto *CurDecl = dyn_cast<Decl>(Context);
2322 return MakeStringLiteral(
2342 StringRef Name = F->getName();
2343 if (Name ==
"_M_file_name") {
2347 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(Path);
2348 }
else if (Name ==
"_M_function_name") {
2351 const auto *CurDecl = dyn_cast<Decl>(Context);
2352 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(
2353 CurDecl && !isa<TranslationUnitDecl>(CurDecl)
2357 }
else if (Name ==
"_M_line") {
2359 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2360 }
else if (Name ==
"_M_column") {
2362 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2373 llvm_unreachable(
"unhandled case");
2379 InitExprs(
C, initExprs.size()), LBraceLoc(lbraceloc),
2380 RBraceLoc(rbraceloc), AltForm(nullptr,
true) {
2382 InitExprs.
insert(
C, InitExprs.
end(), initExprs.begin(), initExprs.end());
2388 if (NumInits > InitExprs.
size())
2393 InitExprs.
resize(
C, NumInits,
nullptr);
2410 ArrayFillerOrUnionFieldInit = filler;
2413 for (
unsigned i = 0, e =
getNumInits(); i != e; ++i)
2414 if (
inits[i] ==
nullptr)
2428 Init =
Init->IgnoreParenImpCasts();
2429 return isa<StringLiteral>(
Init) || isa<ObjCEncodeExpr>(
Init);
2433 assert(
isSemanticForm() &&
"syntactic form never semantically transparent");
2437 assert(
getNumInits() == 1 &&
"multiple inits in glvalue init list");
2456 assert(
isSyntacticForm() &&
"only test syntactic form as zero initializer");
2463 return Lit && Lit->
getValue() == 0;
2468 return SyntacticForm->getBeginLoc();
2473 E = InitExprs.
end();
2476 Beg = S->getBeginLoc();
2486 return SyntacticForm->getEndLoc();
2488 if (End.isInvalid()) {
2490 for (
Stmt *S : llvm::reverse(InitExprs)) {
2492 End = S->getEndLoc();
2504 return cast<BlockPointerType>(
getType())
2535 if (isa<DeclRefExpr>(E))
2539 if (isa<ArraySubscriptExpr>(E))
2543 if (isa<MemberExpr>(E))
2547 if (
auto *UO = dyn_cast<UnaryOperator>(E))
2548 if (UO->getOpcode() == UO_Deref)
2551 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
2553 if (BO->isPtrMemOp())
2557 if (BO->getOpcode() == BO_Comma)
2558 return BO->getRHS()->isReadIfDiscardedInCPlusPlus11();
2563 if (
auto *CO = dyn_cast<ConditionalOperator>(E))
2564 return CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&
2565 CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2568 dyn_cast<BinaryConditionalOperator>(E)) {
2569 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
2570 return OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&
2571 BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2575 if (isa<ObjCIvarRefExpr>(E))
2577 if (
const auto *POE = dyn_cast<PseudoObjectExpr>(E)) {
2578 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(POE->getSyntacticForm()))
2605 case ParenExprClass:
2606 return cast<ParenExpr>(
this)->getSubExpr()->
2608 case GenericSelectionExprClass:
2609 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
2611 case CoawaitExprClass:
2612 case CoyieldExprClass:
2613 return cast<CoroutineSuspendExpr>(
this)->getResumeExpr()->
2615 case ChooseExprClass:
2616 return cast<ChooseExpr>(
this)->getChosenSubExpr()->
2618 case UnaryOperatorClass: {
2652 case BinaryOperatorClass: {
2664 if (IE->getValue() == 0)
2683 case CompoundAssignOperatorClass:
2684 case VAArgExprClass:
2685 case AtomicExprClass:
2688 case ConditionalOperatorClass: {
2692 const auto *Exp = cast<ConditionalOperator>(
this);
2693 return Exp->getLHS()->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx) &&
2694 Exp->getRHS()->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx);
2696 case BinaryConditionalOperatorClass: {
2697 const auto *Exp = cast<BinaryConditionalOperator>(
this);
2698 return Exp->getFalseExpr()->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx);
2701 case MemberExprClass:
2703 Loc = cast<MemberExpr>(
this)->getMemberLoc();
2705 R2 = cast<MemberExpr>(
this)->getBase()->getSourceRange();
2708 case ArraySubscriptExprClass:
2710 Loc = cast<ArraySubscriptExpr>(
this)->getRBracketLoc();
2711 R1 = cast<ArraySubscriptExpr>(
this)->getLHS()->getSourceRange();
2712 R2 = cast<ArraySubscriptExpr>(
this)->getRHS()->getSourceRange();
2715 case CXXOperatorCallExprClass: {
2727 case OO_ExclaimEqual:
2730 case OO_GreaterEqual:
2745 case CXXMemberCallExprClass:
2746 case UserDefinedLiteralClass: {
2748 const CallExpr *CE = cast<CallExpr>(
this);
2756 FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {
2771 case UnresolvedLookupExprClass:
2772 case CXXUnresolvedConstructExprClass:
2773 case RecoveryExprClass:
2776 case CXXTemporaryObjectExprClass:
2777 case CXXConstructExprClass: {
2779 const auto *WarnURAttr =
Type->getAttr<WarnUnusedResultAttr>();
2781 (WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {
2789 const auto *CE = cast<CXXConstructExpr>(
this);
2791 const auto *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
2792 if (WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {
2797 if (
unsigned NumArgs = CE->getNumArgs())
2799 CE->getArg(NumArgs - 1)->getEndLoc());
2807 case ObjCMessageExprClass: {
2820 if (MD->hasAttr<WarnUnusedResultAttr>()) {
2829 case ObjCPropertyRefExprClass:
2830 case ObjCSubscriptRefExprClass:
2836 case PseudoObjectExprClass: {
2837 const auto *POE = cast<PseudoObjectExpr>(
this);
2840 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(
2841 POE->getSyntacticForm())) {
2849 if (
auto *BO = dyn_cast<BinaryOperator>(POE->getSyntacticForm()))
2850 if (BO->isAssignmentOp())
2852 if (
auto *UO = dyn_cast<UnaryOperator>(POE->getSyntacticForm()))
2853 if (UO->isIncrementDecrementOp())
2858 return Result &&
Result->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx);
2861 case StmtExprClass: {
2867 const CompoundStmt *CS = cast<StmtExpr>(
this)->getSubStmt();
2872 if (
const Expr *E = dyn_cast<Expr>(
Label->getSubStmt()))
2879 Loc = cast<StmtExpr>(
this)->getLParenLoc();
2883 case CXXFunctionalCastExprClass:
2884 case CStyleCastExprClass: {
2891 const CastExpr *CE = cast<CastExpr>(
this);
2898 if (
auto *DRE = dyn_cast<DeclRefExpr>(SubE))
2899 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
2900 if (!VD->isExternallyVisible())
2916 if (CE->
getCastKind() == CK_ConstructorConversion)
2923 dyn_cast<CXXFunctionalCastExpr>(
this)) {
2924 Loc = CXXCE->getBeginLoc();
2925 R1 = CXXCE->getSubExpr()->getSourceRange();
2933 case ImplicitCastExprClass: {
2934 const CastExpr *ICE = cast<ImplicitCastExpr>(
this);
2943 case CXXDefaultArgExprClass:
2944 return (cast<CXXDefaultArgExpr>(
this)
2946 case CXXDefaultInitExprClass:
2947 return (cast<CXXDefaultInitExpr>(
this)
2950 case CXXNewExprClass:
2953 case CXXDeleteExprClass:
2955 case MaterializeTemporaryExprClass:
2956 return cast<MaterializeTemporaryExpr>(
this)
2958 ->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx);
2959 case CXXBindTemporaryExprClass:
2960 return cast<CXXBindTemporaryExpr>(
this)->getSubExpr()
2961 ->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx);
2962 case ExprWithCleanupsClass:
2963 return cast<ExprWithCleanups>(
this)->getSubExpr()
2964 ->isUnusedResultAWarning(WarnE,
Loc, R1, R2, Ctx);
2975 case ObjCIvarRefExprClass:
2977 case Expr::UnaryOperatorClass:
2978 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2979 case ImplicitCastExprClass:
2980 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2981 case MaterializeTemporaryExprClass:
2982 return cast<MaterializeTemporaryExpr>(E)->getSubExpr()->isOBJCGCCandidate(
2984 case CStyleCastExprClass:
2985 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2986 case DeclRefExprClass: {
2987 const Decl *D = cast<DeclRefExpr>(E)->getDecl();
2989 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2990 if (VD->hasGlobalStorage())
3000 case MemberExprClass: {
3004 case ArraySubscriptExprClass:
3005 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
3016 assert(
expr->hasPlaceholderType(BuiltinType::BoundMember));
3024 assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
3025 return mem->getMemberDecl()->getType();
3031 assert(
type->isFunctionType());
3035 assert(isa<UnresolvedMemberExpr>(
expr) || isa<CXXPseudoDestructorExpr>(
expr));
3069 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
this)) {
3070 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
3071 return MCE->getImplicitObjectArgument();
3087 auto IgnoreNoopCastsSingleStep = [&Ctx](
Expr *E) {
3088 if (
auto *CE = dyn_cast<CastExpr>(E)) {
3091 Expr *SubExpr = CE->getSubExpr();
3092 bool IsIdentityCast =
3101 if (IsIdentityCast || IsSameWidthCast)
3103 }
else if (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
3104 return NTTP->getReplacement();
3109 IgnoreNoopCastsSingleStep);
3114 if (
auto *Cast = dyn_cast<CXXFunctionalCastExpr>(E)) {
3115 auto *SE = Cast->getSubExpr();
3120 if (
auto *
C = dyn_cast<CXXConstructExpr>(E)) {
3121 auto NumArgs =
C->getNumArgs();
3123 (NumArgs > 1 && isa<CXXDefaultArgExpr>(
C->getArg(1)))) {
3124 Expr *A =
C->getArg(0);
3131 auto IgnoreImplicitMemberCallSingleStep = [](
Expr *E) {
3132 if (
auto *
C = dyn_cast<CXXMemberCallExpr>(E)) {
3133 Expr *ExprNode =
C->getImplicitObjectArgument();
3137 if (
auto *PE = dyn_cast<ParenExpr>(ExprNode)) {
3138 if (PE->getSourceRange() ==
C->getSourceRange()) {
3139 return cast<Expr>(PE);
3151 IgnoreImplicitMemberCallSingleStep);
3155 const Expr *E =
this;
3157 E = M->getSubExpr();
3160 E = ICE->getSubExprAsWritten();
3162 return isa<CXXDefaultArgExpr>(E);
3169 E = M->getSubExpr();
3172 if (ICE->getCastKind() == CK_NoOp)
3173 E = ICE->getSubExpr();
3179 E = BE->getSubExpr();
3182 if (ICE->getCastKind() == CK_NoOp)
3183 E = ICE->getSubExpr();
3194 if (!
C.hasSameUnqualifiedType(
getType(),
C.getTypeDeclType(TempTy)))
3202 if (!isa<ObjCPropertyRefExpr>(E))
3210 if (isa<ImplicitCastExpr>(E)) {
3211 switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
3212 case CK_DerivedToBase:
3213 case CK_UncheckedDerivedToBase:
3221 if (isa<MemberExpr>(E))
3225 if (BO->isPtrMemOp())
3229 if (isa<OpaqueValueExpr>(E))
3236 const Expr *E =
this;
3241 E =
Paren->getSubExpr();
3246 if (ICE->getCastKind() == CK_NoOp ||
3247 ICE->getCastKind() == CK_LValueToRValue ||
3248 ICE->getCastKind() == CK_DerivedToBase ||
3249 ICE->getCastKind() == CK_UncheckedDerivedToBase) {
3250 E = ICE->getSubExpr();
3255 if (
const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
3256 if (UnOp->getOpcode() == UO_Extension) {
3257 E = UnOp->getSubExpr();
3263 = dyn_cast<MaterializeTemporaryExpr>(E)) {
3264 E = M->getSubExpr();
3271 if (
const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
3272 return This->isImplicit();
3280 for (
unsigned I = 0; I < Exprs.size(); ++I)
3288 const Expr **Culprit)
const {
3290 "Expression evaluator can't be called on a dependent expression.");
3302 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
this))
3303 return EWC->getSubExpr()->isConstantInitializer(Ctx,
true, Culprit);
3304 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
this))
3305 return MTE->getSubExpr()->isConstantInitializer(Ctx,
false, Culprit);
3316 case Stmt::ExprWithCleanupsClass:
3318 Ctx, IsForRef, Culprit);
3319 case StringLiteralClass:
3320 case ObjCEncodeExprClass:
3322 case CXXTemporaryObjectExprClass:
3323 case CXXConstructExprClass: {
3332 assert(CE->
getNumArgs() == 1 &&
"trivial ctor with > 1 argument");
3338 case ConstantExprClass: {
3341 const Expr *Exp = cast<ConstantExpr>(
this)->getSubExpr();
3344 case CompoundLiteralExprClass: {
3348 const Expr *Exp = cast<CompoundLiteralExpr>(
this)->getInitializer();
3351 case DesignatedInitUpdateExprClass: {
3356 case InitListExprClass: {
3364 assert(ILE->
isSemanticForm() &&
"InitListExpr must be in semantic form");
3367 for (
unsigned i = 0; i < numInits; i++) {
3375 unsigned ElementNo = 0;
3380 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3381 for (
unsigned i = 0, e = CXXRD->getNumBases(); i < e; i++) {
3382 if (ElementNo < ILE->getNumInits()) {
3390 for (
const auto *Field : RD->
fields()) {
3396 if (Field->isUnnamedBitField())
3399 if (ElementNo < ILE->getNumInits()) {
3401 if (Field->isBitField()) {
3410 bool RefType = Field->getType()->isReferenceType();
3421 case ImplicitValueInitExprClass:
3422 case NoInitExprClass:
3424 case ParenExprClass:
3425 return cast<ParenExpr>(
this)->getSubExpr()
3426 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3427 case GenericSelectionExprClass:
3428 return cast<GenericSelectionExpr>(
this)->getResultExpr()
3429 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3430 case ChooseExprClass:
3431 if (cast<ChooseExpr>(
this)->isConditionDependent()) {
3436 return cast<ChooseExpr>(
this)->getChosenSubExpr()
3438 case UnaryOperatorClass: {
3444 case PackIndexingExprClass: {
3445 return cast<PackIndexingExpr>(
this)
3447 ->isConstantInitializer(Ctx,
false, Culprit);
3449 case CXXFunctionalCastExprClass:
3450 case CXXStaticCastExprClass:
3451 case ImplicitCastExprClass:
3452 case CStyleCastExprClass:
3453 case ObjCBridgedCastExprClass:
3454 case CXXDynamicCastExprClass:
3455 case CXXReinterpretCastExprClass:
3456 case CXXAddrspaceCastExprClass:
3457 case CXXConstCastExprClass: {
3458 const CastExpr *CE = cast<CastExpr>(
this);
3473 case MaterializeTemporaryExprClass:
3474 return cast<MaterializeTemporaryExpr>(
this)
3476 ->isConstantInitializer(Ctx,
false, Culprit);
3478 case SubstNonTypeTemplateParmExprClass:
3479 return cast<SubstNonTypeTemplateParmExpr>(
this)->getReplacement()
3480 ->isConstantInitializer(Ctx,
false, Culprit);
3481 case CXXDefaultArgExprClass:
3482 return cast<CXXDefaultArgExpr>(
this)->getExpr()
3483 ->isConstantInitializer(Ctx,
false, Culprit);
3484 case CXXDefaultInitExprClass:
3485 return cast<CXXDefaultInitExpr>(
this)->getExpr()
3486 ->isConstantInitializer(Ctx,
false, Culprit);
3500 if (BuiltinID != Builtin::BI__assume &&
3501 BuiltinID != Builtin::BI__builtin_assume)
3518 const bool IncludePossibleEffects;
3519 bool HasSideEffects;
3522 explicit SideEffectFinder(
const ASTContext &Context,
bool IncludePossible)
3523 : Inherited(Context),
3524 IncludePossibleEffects(IncludePossible), HasSideEffects(
false) { }
3526 bool hasSideEffects()
const {
return HasSideEffects; }
3528 void VisitDecl(
const Decl *D) {
3534 if (
auto *VD = dyn_cast<VarDecl>(D)) {
3536 if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&
3537 VD->needsDestruction(Context))
3538 HasSideEffects =
true;
3542 void VisitDeclStmt(
const DeclStmt *DS) {
3543 for (
auto *D : DS->
decls())
3545 Inherited::VisitDeclStmt(DS);
3548 void VisitExpr(
const Expr *E) {
3549 if (!HasSideEffects &&
3551 HasSideEffects =
true;
3557 bool IncludePossibleEffects)
const {
3561 if (!IncludePossibleEffects &&
getExprLoc().isMacroID())
3566 #define ABSTRACT_STMT(Type)
3567 #define STMT(Type, Base) case Type##Class:
3568 #define EXPR(Type, Base)
3569 #include "clang/AST/StmtNodes.inc"
3570 llvm_unreachable(
"unexpected Expr kind");
3572 case DependentScopeDeclRefExprClass:
3573 case CXXUnresolvedConstructExprClass:
3574 case CXXDependentScopeMemberExprClass:
3575 case UnresolvedLookupExprClass:
3576 case UnresolvedMemberExprClass:
3577 case PackExpansionExprClass:
3578 case SubstNonTypeTemplateParmPackExprClass:
3579 case FunctionParmPackExprClass:
3581 case RecoveryExprClass:
3582 case CXXFoldExprClass:
3584 return IncludePossibleEffects;
3586 case DeclRefExprClass:
3587 case ObjCIvarRefExprClass:
3588 case PredefinedExprClass:
3589 case IntegerLiteralClass:
3590 case FixedPointLiteralClass:
3591 case FloatingLiteralClass:
3592 case ImaginaryLiteralClass:
3593 case StringLiteralClass:
3594 case CharacterLiteralClass:
3595 case OffsetOfExprClass:
3596 case ImplicitValueInitExprClass:
3597 case UnaryExprOrTypeTraitExprClass:
3598 case AddrLabelExprClass:
3599 case GNUNullExprClass:
3600 case ArrayInitIndexExprClass:
3601 case NoInitExprClass:
3602 case CXXBoolLiteralExprClass:
3603 case CXXNullPtrLiteralExprClass:
3604 case CXXThisExprClass:
3605 case CXXScalarValueInitExprClass:
3606 case TypeTraitExprClass:
3607 case ArrayTypeTraitExprClass:
3608 case ExpressionTraitExprClass:
3609 case CXXNoexceptExprClass:
3610 case SizeOfPackExprClass:
3611 case ObjCStringLiteralClass:
3612 case ObjCEncodeExprClass:
3613 case ObjCBoolLiteralExprClass:
3614 case ObjCAvailabilityCheckExprClass:
3615 case CXXUuidofExprClass:
3616 case OpaqueValueExprClass:
3617 case SourceLocExprClass:
3618 case ConceptSpecializationExprClass:
3619 case RequiresExprClass:
3620 case SYCLUniqueStableNameExprClass:
3624 case PackIndexingExprClass:
3625 return cast<PackIndexingExpr>(
this)->getSelectedExpr()->HasSideEffects(
3626 Ctx, IncludePossibleEffects);
3627 case ConstantExprClass:
3629 return cast<ConstantExpr>(
this)->getSubExpr()->HasSideEffects(
3630 Ctx, IncludePossibleEffects);
3633 case CXXOperatorCallExprClass:
3634 case CXXMemberCallExprClass:
3635 case CUDAKernelCallExprClass:
3636 case UserDefinedLiteralClass: {
3640 const Decl *FD = cast<CallExpr>(
this)->getCalleeDecl();
3641 bool IsPure = FD && (FD->
hasAttr<ConstAttr>() || FD->
hasAttr<PureAttr>());
3642 if (IsPure || !IncludePossibleEffects)
3647 case BlockExprClass:
3648 case CXXBindTemporaryExprClass:
3649 if (!IncludePossibleEffects)
3653 case MSPropertyRefExprClass:
3654 case MSPropertySubscriptExprClass:
3655 case CompoundAssignOperatorClass:
3656 case VAArgExprClass:
3657 case AtomicExprClass:
3658 case CXXThrowExprClass:
3659 case CXXNewExprClass:
3660 case CXXDeleteExprClass:
3661 case CoawaitExprClass:
3662 case DependentCoawaitExprClass:
3663 case CoyieldExprClass:
3667 case StmtExprClass: {
3669 SideEffectFinder Finder(Ctx, IncludePossibleEffects);
3670 Finder.Visit(cast<StmtExpr>(
this)->getSubStmt());
3671 return Finder.hasSideEffects();
3674 case ExprWithCleanupsClass:
3675 if (IncludePossibleEffects)
3676 if (cast<ExprWithCleanups>(
this)->cleanupsHaveSideEffects())
3680 case ParenExprClass:
3681 case ArraySubscriptExprClass:
3682 case MatrixSubscriptExprClass:
3683 case ArraySectionExprClass:
3684 case OMPArrayShapingExprClass:
3685 case OMPIteratorExprClass:
3686 case MemberExprClass:
3687 case ConditionalOperatorClass:
3688 case BinaryConditionalOperatorClass:
3689 case CompoundLiteralExprClass:
3690 case ExtVectorElementExprClass:
3691 case DesignatedInitExprClass:
3692 case DesignatedInitUpdateExprClass:
3693 case ArrayInitLoopExprClass:
3694 case ParenListExprClass:
3695 case CXXPseudoDestructorExprClass:
3696 case CXXRewrittenBinaryOperatorClass:
3697 case CXXStdInitializerListExprClass:
3698 case SubstNonTypeTemplateParmExprClass:
3699 case MaterializeTemporaryExprClass:
3700 case ShuffleVectorExprClass:
3701 case ConvertVectorExprClass:
3702 case AsTypeExprClass:
3703 case CXXParenListInitExprClass:
3707 case UnaryOperatorClass:
3708 if (cast<UnaryOperator>(
this)->isIncrementDecrementOp())
3712 case BinaryOperatorClass:
3713 if (cast<BinaryOperator>(
this)->isAssignmentOp())
3717 case InitListExprClass:
3719 if (
const Expr *E = cast<InitListExpr>(
this)->getArrayFiller())
3724 case GenericSelectionExprClass:
3725 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
3728 case ChooseExprClass:
3729 return cast<ChooseExpr>(
this)->getChosenSubExpr()->HasSideEffects(
3730 Ctx, IncludePossibleEffects);
3732 case CXXDefaultArgExprClass:
3733 return cast<CXXDefaultArgExpr>(
this)->getExpr()->HasSideEffects(
3734 Ctx, IncludePossibleEffects);
3736 case CXXDefaultInitExprClass: {
3737 const FieldDecl *FD = cast<CXXDefaultInitExpr>(
this)->getField();
3744 case CXXDynamicCastExprClass: {
3752 case ImplicitCastExprClass:
3753 case CStyleCastExprClass:
3754 case CXXStaticCastExprClass:
3755 case CXXReinterpretCastExprClass:
3756 case CXXConstCastExprClass:
3757 case CXXAddrspaceCastExprClass:
3758 case CXXFunctionalCastExprClass:
3759 case BuiltinBitCastExprClass: {
3764 if (!IncludePossibleEffects)
3767 const CastExpr *CE = cast<CastExpr>(
this);
3774 case CXXTypeidExprClass:
3777 return cast<CXXTypeidExpr>(
this)->isPotentiallyEvaluated();
3779 case CXXConstructExprClass:
3780 case CXXTemporaryObjectExprClass: {
3789 case CXXInheritedCtorInitExprClass: {
3790 const auto *ICIE = cast<CXXInheritedCtorInitExpr>(
this);
3791 if (!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)
3796 case LambdaExprClass: {
3797 const LambdaExpr *LE = cast<LambdaExpr>(
this);
3798 for (
Expr *E : LE->capture_inits())
3804 case PseudoObjectExprClass: {
3811 const Expr *Subexpr = *I;
3813 Subexpr = OVE->getSourceExpr();
3820 case ObjCBoxedExprClass:
3821 case ObjCArrayLiteralClass:
3822 case ObjCDictionaryLiteralClass:
3823 case ObjCSelectorExprClass:
3824 case ObjCProtocolExprClass:
3825 case ObjCIsaExprClass:
3826 case ObjCIndirectCopyRestoreExprClass:
3827 case ObjCSubscriptRefExprClass:
3828 case ObjCBridgedCastExprClass:
3829 case ObjCMessageExprClass:
3830 case ObjCPropertyRefExprClass:
3832 if (IncludePossibleEffects)
3840 cast<Expr>(SubStmt)->
HasSideEffects(Ctx, IncludePossibleEffects))
3847 if (
auto Call = dyn_cast<CallExpr>(
this))
3848 return Call->getFPFeaturesInEffect(LO);
3849 if (
auto UO = dyn_cast<UnaryOperator>(
this))
3850 return UO->getFPFeaturesInEffect(LO);
3851 if (
auto BO = dyn_cast<BinaryOperator>(
this))
3852 return BO->getFPFeaturesInEffect(LO);
3853 if (
auto Cast = dyn_cast<CastExpr>(
this))
3854 return Cast->getFPFeaturesInEffect(LO);
3867 explicit NonTrivialCallFinder(
const ASTContext &Context)
3868 : Inherited(Context), NonTrivial(
false) { }
3870 bool hasNonTrivialCall()
const {
return NonTrivial; }
3872 void VisitCallExpr(
const CallExpr *E) {
3874 = dyn_cast_or_null<const CXXMethodDecl>(E->
getCalleeDecl())) {
3875 if (Method->isTrivial()) {
3877 Inherited::VisitStmt(E);
3888 Inherited::VisitStmt(E);
3900 if (DtorDecl->isTrivial()) {
3901 Inherited::VisitStmt(E);
3912 NonTrivialCallFinder Finder(Ctx);
3914 return Finder.hasNonTrivialCall();
3932 llvm_unreachable(
"Unexpected value dependent expression!");
3960 CE->getSubExpr()->getType()->isIntegerType())
3961 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3964 }
else if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(
this)) {
3966 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3967 }
else if (
const ParenExpr *PE = dyn_cast<ParenExpr>(
this)) {
3970 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3972 dyn_cast<GenericSelectionExpr>(
this)) {
3973 if (GE->isResultDependent())
3975 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
3976 }
else if (
const ChooseExpr *CE = dyn_cast<ChooseExpr>(
this)) {
3977 if (CE->isConditionDependent())
3979 return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);
3981 = dyn_cast<CXXDefaultArgExpr>(
this)) {
3983 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
3985 = dyn_cast<CXXDefaultInitExpr>(
this)) {
3987 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
3988 }
else if (isa<GNUNullExpr>(
this)) {
3992 = dyn_cast<MaterializeTemporaryExpr>(
this)) {
3993 return M->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3994 }
else if (
const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(
this)) {
3995 if (
const Expr *Source = OVE->getSourceExpr())
3996 return Source->isNullPointerConstant(Ctx, NPC);
4005 if (
getType()->isNullPtrType())
4010 UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
4012 const Expr *InitExpr = CLE->getInitializer();
4013 if (
const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
4017 if (!
getType()->isIntegerType() ||
4040 if (isa<IntegerLiteral>(
this))
4048 const Expr *E =
this;
4051 "expression is not a property reference");
4054 if (BO->getOpcode() == BO_Comma) {
4063 return cast<ObjCPropertyRefExpr>(E);
4069 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
4088 if (ICE->getCastKind() == CK_LValueToRValue ||
4089 (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp))
4095 if (
MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
4096 if (
FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
4097 if (Field->isBitField())
4106 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) {
4107 if (
FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
4108 if (Field->isBitField())
4111 if (
BindingDecl *BD = dyn_cast<BindingDecl>(DeclRef->getDecl()))
4112 if (
Expr *E = BD->getBinding())
4117 if (BinOp->isAssignmentOp() && BinOp->getLHS())
4118 return BinOp->getLHS()->getSourceBitField();
4120 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
4121 return BinOp->getRHS()->getSourceBitField();
4125 if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())
4126 return UnOp->getSubExpr()->getSourceBitField();
4133 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4134 return dyn_cast<EnumConstantDecl>(DRE->getDecl());
4143 if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)
4152 if (isa<ExtVectorElementExpr>(E))
4155 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4156 if (
auto *BD = dyn_cast<BindingDecl>(DRE->getDecl()))
4157 if (
auto *E = BD->getBinding())
4166 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
4167 if (
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
4169 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
4185 case CXXThisExprClass:
4187 case DeclRefExprClass: {
4190 const auto *DRE1 = cast<DeclRefExpr>(E1);
4191 const auto *DRE2 = cast<DeclRefExpr>(E2);
4192 return DRE1->isPRValue() && DRE2->isPRValue() &&
4193 DRE1->getDecl() == DRE2->getDecl();
4195 case ImplicitCastExprClass: {
4198 const auto *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
4199 const auto *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
4202 if (ICE1->getCastKind() != ICE2->getCastKind())
4207 if (ICE1->getCastKind() == CK_LValueToRValue ||
4208 ICE1->getCastKind() == CK_ArrayToPointerDecay ||
4209 ICE1->getCastKind() == CK_FunctionToPointerDecay) {
4214 const auto *DRE1 = dyn_cast<DeclRefExpr>(E1);
4215 const auto *DRE2 = dyn_cast<DeclRefExpr>(E2);
4219 const auto *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
4220 const auto *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
4221 if (Ivar1 && Ivar2) {
4222 return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
4226 const auto *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
4227 const auto *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
4228 if (Array1 && Array2) {
4232 auto Idx1 = Array1->getIdx();
4233 auto Idx2 = Array2->getIdx();
4234 const auto Integer1 = dyn_cast<IntegerLiteral>(Idx1);
4235 const auto Integer2 = dyn_cast<IntegerLiteral>(Idx2);
4236 if (Integer1 && Integer2) {
4237 if (!llvm::APInt::isSameValue(Integer1->getValue(),
4238 Integer2->getValue()))
4249 while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
4250 const auto *ME1 = cast<MemberExpr>(E1);
4251 const auto *ME2 = cast<MemberExpr>(E2);
4254 if (
const auto *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
4255 if (D->isStaticDataMember())
4261 if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
4267 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
4268 return DRE->getDecl();
4269 if (
const auto *ME = dyn_cast<MemberExpr>(E))
4270 return ME->getMemberDecl();
4289 return VT->getNumElements();
4297 StringRef Comp = Accessor->
getName();
4300 if (Comp ==
"hi" || Comp ==
"lo" || Comp ==
"even" || Comp ==
"odd")
4304 if (Comp[0] ==
's' || Comp[0] ==
'S')
4305 Comp = Comp.substr(1);
4307 for (
unsigned i = 0, e = Comp.size(); i != e; ++i)
4308 if (Comp.substr(i + 1).contains(Comp[i]))
4317 StringRef Comp = Accessor->
getName();
4318 bool isNumericAccessor =
false;
4319 if (Comp[0] ==
's' || Comp[0] ==
'S') {
4320 Comp = Comp.substr(1);
4321 isNumericAccessor =
true;
4324 bool isHi = Comp ==
"hi";
4325 bool isLo = Comp ==
"lo";
4326 bool isEven = Comp ==
"even";
4327 bool isOdd = Comp ==
"odd";
4343 Elts.push_back(Index);
4351 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
4352 SubExprs =
new (
C)
Stmt*[args.size()];
4353 for (
unsigned i = 0; i != args.size(); i++)
4354 SubExprs[i] = args[i];
4360 if (SubExprs)
C.Deallocate(SubExprs);
4362 this->NumExprs = Exprs.size();
4363 SubExprs =
new (
C)
Stmt*[NumExprs];
4364 memcpy(SubExprs, Exprs.data(),
sizeof(
Expr *) * Exprs.size());
4367GenericSelectionExpr::GenericSelectionExpr(
4371 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex)
4372 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4373 AssocExprs[ResultIndex]->getValueKind(),
4374 AssocExprs[ResultIndex]->getObjectKind()),
4375 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4376 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4377 assert(AssocTypes.size() == AssocExprs.size() &&
4378 "Must have the same number of association expressions"
4379 " and TypeSourceInfo!");
4380 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4383 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4385 std::copy(AssocExprs.begin(), AssocExprs.end(),
4386 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4387 std::copy(AssocTypes.begin(), AssocTypes.end(),
4388 getTrailingObjects<TypeSourceInfo *>() +
4389 getIndexOfStartOfAssociatedTypes());
4394GenericSelectionExpr::GenericSelectionExpr(
4399 unsigned ResultIndex)
4400 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4401 AssocExprs[ResultIndex]->getValueKind(),
4402 AssocExprs[ResultIndex]->getObjectKind()),
4403 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4404 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4405 assert(AssocTypes.size() == AssocExprs.size() &&
4406 "Must have the same number of association expressions"
4407 " and TypeSourceInfo!");
4408 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4411 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4413 std::copy(AssocExprs.begin(), AssocExprs.end(),
4414 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4415 std::copy(AssocTypes.begin(), AssocTypes.end(),
4416 getTrailingObjects<TypeSourceInfo *>() +
4417 getIndexOfStartOfAssociatedTypes());
4422GenericSelectionExpr::GenericSelectionExpr(
4426 bool ContainsUnexpandedParameterPack)
4427 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4429 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4430 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4431 assert(AssocTypes.size() == AssocExprs.size() &&
4432 "Must have the same number of association expressions"
4433 " and TypeSourceInfo!");
4436 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4438 std::copy(AssocExprs.begin(), AssocExprs.end(),
4439 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4440 std::copy(AssocTypes.begin(), AssocTypes.end(),
4441 getTrailingObjects<TypeSourceInfo *>() +
4442 getIndexOfStartOfAssociatedTypes());
4447GenericSelectionExpr::GenericSelectionExpr(
4452 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4454 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4455 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4456 assert(AssocTypes.size() == AssocExprs.size() &&
4457 "Must have the same number of association expressions"
4458 " and TypeSourceInfo!");
4461 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4463 std::copy(AssocExprs.begin(), AssocExprs.end(),
4464 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4465 std::copy(AssocTypes.begin(), AssocTypes.end(),
4466 getTrailingObjects<TypeSourceInfo *>() +
4467 getIndexOfStartOfAssociatedTypes());
4472GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty,
unsigned NumAssocs)
4473 :
Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
4479 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex) {
4480 unsigned NumAssocs = AssocExprs.size();
4482 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4485 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4486 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4493 bool ContainsUnexpandedParameterPack) {
4494 unsigned NumAssocs = AssocExprs.size();
4496 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4499 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4500 RParenLoc, ContainsUnexpandedParameterPack);
4508 unsigned ResultIndex) {
4509 unsigned NumAssocs = AssocExprs.size();
4511 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4514 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4515 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4522 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack) {
4523 unsigned NumAssocs = AssocExprs.size();
4525 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4528 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4529 RParenLoc, ContainsUnexpandedParameterPack);
4534 unsigned NumAssocs) {
4536 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4559 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
4560 NumDesignators(Designators.
size()), NumSubExprs(IndexExprs.
size() + 1) {
4561 this->Designators =
new (
C)
Designator[NumDesignators];
4569 unsigned IndexIdx = 0;
4570 for (
unsigned I = 0; I != NumDesignators; ++I) {
4571 this->Designators[I] = Designators[I];
4574 *Child++ = IndexExprs[IndexIdx++];
4577 *Child++ = IndexExprs[IndexIdx++];
4578 *Child++ = IndexExprs[IndexIdx++];
4582 assert(IndexIdx == IndexExprs.size() &&
"Wrong number of index expressions");
4591 bool UsesColonSyntax,
Expr *
Init) {
4592 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
4595 ColonOrEqualLoc, UsesColonSyntax,
4600 unsigned NumIndexExprs) {
4601 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
4608 unsigned NumDesigs) {
4610 NumDesignators = NumDesigs;
4611 for (
unsigned I = 0; I != NumDesigs; ++I)
4612 Designators[I] = Desigs[I];
4626 if (
First.isFieldDesignator()) {
4629 for (
unsigned int i = 0; i < DIE->size(); i++) {
4637 return First.getLBracketLoc();
4664 unsigned NumNewDesignators =
Last -
First;
4665 if (NumNewDesignators == 0) {
4666 std::copy_backward(Designators + Idx + 1,
4667 Designators + NumDesignators,
4669 --NumNewDesignators;
4672 if (NumNewDesignators == 1) {
4673 Designators[Idx] = *
First;
4678 =
new (
C)
Designator[NumDesignators - 1 + NumNewDesignators];
4679 std::copy(Designators, Designators + Idx, NewDesignators);
4680 std::copy(
First,
Last, NewDesignators + Idx);
4681 std::copy(Designators + Idx + 1, Designators + NumDesignators,
4682 NewDesignators + Idx + NumNewDesignators);
4683 Designators = NewDesignators;
4684 NumDesignators = NumDesignators - 1 + NumNewDesignators;
4693 BaseAndUpdaterExprs[0] = baseExpr;
4698 BaseAndUpdaterExprs[1] = ILE;
4715 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4718 for (
unsigned I = 0, N = Exprs.size(); I != N; ++I)
4719 getTrailingObjects<Stmt *>()[I] = Exprs[I];
4723ParenListExpr::ParenListExpr(EmptyShell Empty,
unsigned NumExprs)
4724 :
Expr(ParenListExprClass, Empty) {
4732 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
4734 return new (Mem)
ParenListExpr(LParenLoc, Exprs, RParenLoc);
4738 unsigned NumExprs) {
4748 :
Expr(BinaryOperatorClass, ResTy, VK, OK) {
4751 "Use CompoundAssignOperator for compound assignments");
4753 SubExprs[LHS] = lhs;
4754 SubExprs[RHS] = rhs;
4765 :
Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
4768 "Use CompoundAssignOperator for compound assignments");
4770 SubExprs[LHS] = lhs;
4771 SubExprs[RHS] = rhs;
4779 bool HasFPFeatures) {
4819 CompLHSType, CompResultType);
4823 bool hasFPFeatures) {
4824 void *Mem =
C.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),
4833 :
Expr(UnaryOperatorClass,
type, VK, OK), Val(input) {
4849 unsigned Size = totalSizeToAlloc<FPOptionsOverride>(HasFPFeatures);
4857 e = ewc->getSubExpr();
4859 e = m->getSubExpr();
4860 e = cast<CXXConstructExpr>(e)->getArg(0);
4862 e = ice->getSubExpr();
4863 return cast<OpaqueValueExpr>(e);
4868 unsigned numSemanticExprs) {
4870 Context.
Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
4875PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell,
unsigned numSemanticExprs)
4876 :
Expr(PseudoObjectExprClass, shell) {
4882 unsigned resultIndex) {
4883 assert(syntax &&
"no syntactic expression!");
4884 assert(
semantics.size() &&
"no semantic expressions!");
4894 VK =
semantics[resultIndex]->getValueKind();
4898 void *buffer =
C.Allocate(totalSizeToAlloc<Expr *>(
semantics.size() + 1),
4906 unsigned resultIndex)
4911 for (
unsigned i = 0, e =
semantics.size() + 1; i != e; ++i) {
4913 getSubExprsBuffer()[i] = E;
4915 if (isa<OpaqueValueExpr>(E))
4916 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() !=
nullptr &&
4917 "opaque-value semantic expressions for pseudo-object "
4918 "operations must have sources");
4951 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
4952 assert(args.size() ==
getNumSubExprs(op) &&
"wrong number of subexpressions");
4953 for (
unsigned i = 0; i != args.size(); i++)
4954 SubExprs[i] = args[i];
4960 case AO__c11_atomic_init:
4961 case AO__opencl_atomic_init:
4962 case AO__c11_atomic_load:
4963 case AO__atomic_load_n:
4966 case AO__scoped_atomic_load_n:
4967 case AO__opencl_atomic_load:
4968 case AO__hip_atomic_load:
4969 case AO__c11_atomic_store:
4970 case AO__c11_atomic_exchange:
4971 case AO__atomic_load:
4972 case AO__atomic_store:
4973 case AO__atomic_store_n:
4974 case AO__atomic_exchange_n:
4975 case AO__c11_atomic_fetch_add:
4976 case AO__c11_atomic_fetch_sub:
4977 case AO__c11_atomic_fetch_and:
4978 case AO__c11_atomic_fetch_or:
4979 case AO__c11_atomic_fetch_xor:
4980 case AO__c11_atomic_fetch_nand:
4981 case AO__c11_atomic_fetch_max:
4982 case AO__c11_atomic_fetch_min:
4983 case AO__atomic_fetch_add:
4984 case AO__atomic_fetch_sub:
4985 case AO__atomic_fetch_and:
4986 case AO__atomic_fetch_or:
4987 case AO__atomic_fetch_xor:
4988 case AO__atomic_fetch_nand:
4989 case AO__atomic_add_fetch:
4990 case AO__atomic_sub_fetch:
4991 case AO__atomic_and_fetch:
4992 case AO__atomic_or_fetch:
4993 case AO__atomic_xor_fetch:
4994 case AO__atomic_nand_fetch:
4995 case AO__atomic_min_fetch:
4996 case AO__atomic_max_fetch:
4997 case AO__atomic_fetch_min:
4998 case AO__atomic_fetch_max:
5001 case AO__scoped_atomic_load:
5002 case AO__scoped_atomic_store:
5003 case AO__scoped_atomic_store_n:
5004 case AO__scoped_atomic_fetch_add:
5005 case AO__scoped_atomic_fetch_sub:
5006 case AO__scoped_atomic_fetch_and:
5007 case AO__scoped_atomic_fetch_or:
5008 case AO__scoped_atomic_fetch_xor:
5009 case AO__scoped_atomic_fetch_nand:
5010 case AO__scoped_atomic_add_fetch:
5011 case AO__scoped_atomic_sub_fetch:
5012 case AO__scoped_atomic_and_fetch:
5013 case AO__scoped_atomic_or_fetch:
5014 case AO__scoped_atomic_xor_fetch:
5015 case AO__scoped_atomic_nand_fetch:
5016 case AO__scoped_atomic_min_fetch:
5017 case AO__scoped_atomic_max_fetch:
5018 case AO__scoped_atomic_fetch_min:
5019 case AO__scoped_atomic_fetch_max:
5020 case AO__scoped_atomic_exchange_n:
5021 case AO__hip_atomic_exchange:
5022 case AO__hip_atomic_fetch_add:
5023 case AO__hip_atomic_fetch_sub:
5024 case AO__hip_atomic_fetch_and:
5025 case AO__hip_atomic_fetch_or:
5026 case AO__hip_atomic_fetch_xor:
5027 case AO__hip_atomic_fetch_min:
5028 case AO__hip_atomic_fetch_max:
5029 case AO__opencl_atomic_store:
5030 case AO__hip_atomic_store:
5031 case AO__opencl_atomic_exchange:
5032 case AO__opencl_atomic_fetch_add:
5033 case AO__opencl_atomic_fetch_sub:
5034 case AO__opencl_atomic_fetch_and:
5035 case AO__opencl_atomic_fetch_or:
5036 case AO__opencl_atomic_fetch_xor:
5037 case AO__opencl_atomic_fetch_min:
5038 case AO__opencl_atomic_fetch_max:
5039 case AO__atomic_exchange:
5042 case AO__scoped_atomic_exchange:
5043 case AO__c11_atomic_compare_exchange_strong:
5044 case AO__c11_atomic_compare_exchange_weak:
5046 case AO__hip_atomic_compare_exchange_strong:
5047 case AO__opencl_atomic_compare_exchange_strong:
5048 case AO__opencl_atomic_compare_exchange_weak:
5049 case AO__hip_atomic_compare_exchange_weak:
5050 case AO__atomic_compare_exchange:
5051 case AO__atomic_compare_exchange_n:
5054 case AO__scoped_atomic_compare_exchange:
5055 case AO__scoped_atomic_compare_exchange_n:
5058 llvm_unreachable(
"unknown atomic op");
5064 return AT->getValueType();
5069 unsigned ArraySectionCount = 0;
5070 while (
auto *OASE = dyn_cast<ArraySectionExpr>(
Base->IgnoreParens())) {
5071 Base = OASE->getBase();
5072 ++ArraySectionCount;
5075 dyn_cast<ArraySubscriptExpr>(
Base->IgnoreParenImpCasts())) {
5076 Base = ASE->getBase();
5077 ++ArraySectionCount;
5079 Base =
Base->IgnoreParenImpCasts();
5080 auto OriginalTy =
Base->getType();
5081 if (
auto *DRE = dyn_cast<DeclRefExpr>(
Base))
5082 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
5083 OriginalTy = PVD->getOriginalType().getNonReferenceType();
5085 for (
unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
5086 if (OriginalTy->isAnyPointerType())
5087 OriginalTy = OriginalTy->getPointeeType();
5088 else if (OriginalTy->isArrayType())
5089 OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
5098 :
Expr(RecoveryExprClass,
T.getNonReferenceType(),
5099 T->isDependentType() ?
VK_LValue : getValueKindForType(
T),
5101 BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
5102 assert(!
T.isNull());
5103 assert(!llvm::is_contained(SubExprs,
nullptr));
5105 llvm::copy(SubExprs, getTrailingObjects<Expr *>());
5113 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(SubExprs.size()),
5115 return new (Mem)
RecoveryExpr(Ctx,
T, BeginLoc, EndLoc, SubExprs);
5119 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(NumSubExprs),
5126 NumDims == Dims.size() &&
5127 "Preallocated number of dimensions is different from the provided one.");
5128 llvm::copy(Dims, getTrailingObjects<Expr *>());
5133 NumDims == BR.size() &&
5134 "Preallocated number of dimensions is different from the provided one.");
5135 llvm::copy(BR, getTrailingObjects<SourceRange>());
5138OMPArrayShapingExpr::OMPArrayShapingExpr(
QualType ExprTy,
Expr *Op,
5142 RPLoc(R), NumDims(Dims.size()) {
5144 setDimensions(Dims);
5153 assert(Dims.size() == BracketRanges.size() &&
5154 "Different number of dimensions and brackets ranges.");
5156 totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),
5159 E->setBracketsRanges(BracketRanges);
5166 totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),
5171void OMPIteratorExpr::setIteratorDeclaration(
unsigned I,
Decl *D) {
5172 assert(I < NumIterators &&
5173 "Idx is greater or equal the number of iterators definitions.");
5174 getTrailingObjects<Decl *>()[I] = D;
5178 assert(I < NumIterators &&
5179 "Idx is greater or equal the number of iterators definitions.");
5182 static_cast<int>(RangeLocOffset::AssignLoc)] =
Loc;
5185void OMPIteratorExpr::setIteratorRange(
unsigned I,
Expr *
Begin,
5189 assert(I < NumIterators &&
5190 "Idx is greater or equal the number of iterators definitions.");
5191 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5192 static_cast<int>(RangeExprOffset::Begin)] =
5194 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5195 static_cast<int>(RangeExprOffset::End)] = End;
5196 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5197 static_cast<int>(RangeExprOffset::Step)] = Step;
5200 static_cast<int>(RangeLocOffset::FirstColonLoc)] =
5204 static_cast<int>(RangeLocOffset::SecondColonLoc)] =
5209 return getTrailingObjects<Decl *>()[I];
5215 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5216 RangeExprOffset::Total) +
5217 static_cast<int>(RangeExprOffset::Begin)];
5219 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5220 RangeExprOffset::Total) +
5221 static_cast<int>(RangeExprOffset::End)];
5223 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5224 RangeExprOffset::Total) +
5225 static_cast<int>(RangeExprOffset::Step)];
5230 return getTrailingObjects<
5232 static_cast<int>(RangeLocOffset::AssignLoc)];
5236 return getTrailingObjects<
5238 static_cast<int>(RangeLocOffset::FirstColonLoc)];
5242 return getTrailingObjects<
5244 static_cast<int>(RangeLocOffset::SecondColonLoc)];
5248 getTrailingObjects<OMPIteratorHelperData>()[I] = D;
5252 return getTrailingObjects<OMPIteratorHelperData>()[I];
5256 return getTrailingObjects<OMPIteratorHelperData>()[I];
5259OMPIteratorExpr::OMPIteratorExpr(
5264 IteratorKwLoc(IteratorKwLoc), LPLoc(L), RPLoc(R),
5265 NumIterators(
Data.size()) {
5266 for (
unsigned I = 0, E =
Data.size(); I < E; ++I) {
5267 const IteratorDefinition &D =
Data[I];
5268 setIteratorDeclaration(I, D.IteratorDecl);
5269 setAssignmentLoc(I, D.AssignmentLoc);
5270 setIteratorRange(I, D.Range.Begin, D.ColonLoc, D.Range.End,
5271 D.SecondColonLoc, D.Range.Step);
5272 setHelper(I, Helpers[I]);
5283 assert(
Data.size() == Helpers.size() &&
5284 "Data and helpers must have the same size.");
5286 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
5287 Data.size(),
Data.size() *
static_cast<int>(RangeExprOffset::Total),
5288 Data.size() *
static_cast<int>(RangeLocOffset::Total),
5295 unsigned NumIterators) {
5297 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
5298 NumIterators, NumIterators *
static_cast<int>(RangeExprOffset::Total),
5299 NumIterators *
static_cast<int>(RangeLocOffset::Total), NumIterators),
Defines the clang::ASTContext interface.
static bool isBooleanType(QualType Ty)
static Expr * IgnoreImplicitConstructorSingleStep(Expr *E)
Defines enum values for all the target-independent builtin functions.
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
Defines the clang::Expr interface and subclasses for C++ expressions.
static const Expr * skipTemporaryBindingsNoOpCastsAndParens(const Expr *E)
Skip over any no-op casts and any temporary-binding expressions.
static void AssertResultStorageKind(ConstantResultStorageKind Kind)
llvm::MachO::Target Target
Defines the clang::Preprocessor interface.
static QualType getUnderlyingType(const SubRegion *R)
static bool isRecordType(QualType T)
Defines the SourceManager interface.
static const TypeInfo & getInfo(unsigned id)
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
void setValue(const ASTContext &C, const llvm::APInt &Val)
llvm::APInt getValue() const
uint64_t * pVal
Used to store the >64 bits integer value.
uint64_t VAL
Used to store the <= 64 bits integer value.
void setIntValue(const ASTContext &C, const llvm::APInt &Val)
A non-discriminated union of a base, field, or array index.
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
static APValue IndeterminateValue()
@ Indeterminate
This object has an indeterminate value (C++ [basic.indet]).
@ 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 ...
SourceManager & getSourceManager()
const ConstantArrayType * getAsConstantArrayType(QualType T) const
MangleContext * createMangleContext(const TargetInfo *T=nullptr)
If T is null pointer, assume the target in ASTContext.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Builtin::Context & BuiltinInfo
const LangOptions & getLangOpts() const
Qualifiers::GC getObjCGCAttrKind(QualType Ty) const
Return one of the GCNone, Weak or Strong Objective-C garbage collection attributes.
TypeInfo getTypeInfo(const Type *T) const
Get the size and alignment of the specified complete type in bits.
LangAS getDefaultOpenCLPointeeAddrSpace()
Returns default address space based on OpenCL version and enabled features.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
void * Allocate(size_t Size, unsigned Align=8) const
CanQualType UnsignedIntTy
llvm::APSInt MakeIntValue(uint64_t Value, QualType Type) const
Make an APSInt of the appropriate width and signedness for the given Value and integer Type.
StringLiteral * getPredefinedStringLiteralFromCache(StringRef Key) const
Return a string representing the human readable name for the specified function declaration or file n...
DiagnosticsEngine & getDiagnostics() const
UnnamedGlobalConstantDecl * getUnnamedGlobalConstantDecl(QualType Ty, const APValue &Value) const
Return a declaration for a uniquified anonymous global constant corresponding to a given APValue.
const TargetInfo & getTargetInfo() const
void addDestruction(T *Ptr) const
If T isn't trivially destructible, calls AddDeallocation to register it for destruction.
void resize(const ASTContext &C, unsigned N, const T &NV)
iterator insert(const ASTContext &C, iterator I, const T &Elt)
void reserve(const ASTContext &C, unsigned N)
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
QualType getValueType() const
AtomicExpr(SourceLocation BLoc, ArrayRef< Expr * > args, QualType t, AtomicOp op, SourceLocation RP)
unsigned getNumSubExprs() const
Attr - This represents one attribute.
A builtin binary operation expression such as "x + y" or "x <= y".
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given binary opcode.
StringRef getOpcodeStr() const
SourceLocation getOperatorLoc() const
bool hasStoredFPFeatures() const
bool isCompoundAssignmentOp() const
static unsigned sizeOfTrailingObjects(bool HasFPFeatures)
Return the size in bytes needed for the trailing objects.
static BinaryOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
static BinaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
static bool isAssignmentOp(Opcode Opc)
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.
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO)
Retrieve the binary opcode that corresponds to the given overloaded operator.
BinaryOperator(const ASTContext &Ctx, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures)
Build a binary operator, assuming that appropriate storage has been allocated for the trailing object...
A binding in a decomposition declaration.
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
SourceLocation getCaretLocation() const
SourceLocation getCaretLocation() const
const Stmt * getBody() const
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
bool isUnevaluated(unsigned ID) const
Returns true if this builtin does not perform the side-effects of its arguments.
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, FPOptionsOverride FPO, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
SourceLocation getLParenLoc() const
Represents a call to a CUDA kernel function.
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
CXXTemporary * getTemporary()
Represents a call to a C++ constructor.
Expr * getArg(unsigned Arg)
Return the specified argument.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Represents a C++ constructor within a class.
A default argument (C++ [dcl.fct.default]).
A use of a default initializer in a constructor or in aggregate initialization.
Represents a C++ destructor within a class.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
A call to an overloaded operator written using operator syntax.
SourceLocation getOperatorLoc() const
Returns the location of the operator symbol in the expression.
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
SourceRange getSourceRange() const
Represents a C++ struct/union/class.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
A C++ static_cast expression (C++ [expr.static.cast]).
const CXXDestructorDecl * getDestructor() const
Represents the this expression in C++.
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
static unsigned sizeOfTrailingObjects(unsigned NumPreArgs, unsigned NumArgs, bool HasFPFeatures)
Return the size in bytes needed for the trailing objects.
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
SourceLocation getBeginLoc() const LLVM_READONLY
unsigned getBuiltinCallee() const
getBuiltinCallee - If this is a call to a builtin, return the builtin ID of the callee.
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
SourceLocation getEndLoc() const LLVM_READONLY
void setPreArg(unsigned I, Stmt *PreArg)
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.
CallExpr(StmtClass SC, Expr *Fn, ArrayRef< Expr * > PreArgs, ArrayRef< Expr * > Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, FPOptionsOverride FPFeatures, unsigned MinNumArgs, ADLCallKind UsesADL)
Build a call expression, assuming that appropriate storage has been allocated for the trailing object...
SourceLocation getRParenLoc() const
static constexpr ADLCallKind UsesADL
static CallExpr * CreateTemporary(void *Mem, Expr *Fn, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, ADLCallKind UsesADL=NotADL)
Create a temporary call expression with no arguments in the memory pointed to by Mem.
bool isBuiltinAssumeFalse(const ASTContext &Ctx) const
Return true if this is a call to __assume() or __builtin_assume() with a non-value-dependent constant...
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
const Attr * getUnusedResultAttr(const ASTContext &Ctx) const
Returns the WarnUnusedResultAttr that is either declared on the called function, or its return type d...
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...
unsigned getNumPreArgs() const
bool hasUnusedResultAttr(const ASTContext &Ctx) const
Returns true if this call expression should warn on unused results.
QualType withConst() const
Retrieves a version of this type with const applied.
bool isVolatileQualified() const
Represents the body of a CapturedStmt, and serves as its DeclContext.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
NamedDecl * getConversionFunction() const
If this cast applies a user-defined conversion, retrieve the conversion function that it invokes.
Expr * getSubExprAsWritten()
Retrieve the cast subexpression as it was written in the source code, looking through any implicit ca...
CastKind getCastKind() const
bool hasStoredFPFeatures() const
static const FieldDecl * getTargetFieldForToUnionCast(QualType unionType, QualType opType)
const char * getCastKindName() const
SourceLocation getEnd() const
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
void setValue(unsigned Val)
static void print(unsigned val, CharacterLiteralKind Kind, raw_ostream &OS)
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Represents a class template specialization, which refers to a class template with a given set of temp...
bool isExplicitSpecialization() const
CompoundAssignOperator - For compound assignments (e.g.
static CompoundAssignOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
static CompoundAssignOperator * Create(const ASTContext &C, Expr *lhs, Expr *rhs, Opcode opc, QualType ResTy, ExprValueKind VK, ExprObjectKind OK, SourceLocation opLoc, FPOptionsOverride FPFeatures, QualType CompLHSType=QualType(), QualType CompResultType=QualType())
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
ConditionalOperator - The ?: ternary operator.
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
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
ConstantResultStorageKind getResultStorageKind() const
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
static ConstantExpr * CreateEmpty(const ASTContext &Context, ConstantResultStorageKind StorageKind)
A POD class for pairing a NamedDecl* with an access specifier.
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
A reference to a declared variable, function, enum, etc.
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list.
void setDecl(ValueDecl *NewD)
static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Construct an empty declaration reference expression.
SourceLocation getBeginLoc() const LLVM_READONLY
DeclarationNameInfo getNameInfo() const
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
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,...
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Decl - This represents one declaration (or definition), e.g.
ASTContext & getASTContext() const LLVM_READONLY
static Decl * castFromDeclContext(const DeclContext *)
DeclContext * getDeclContext()
AccessSpecifier getAccess() const
static bool isFlexibleArrayMemberLike(ASTContext &Context, const Decl *D, QualType Ty, LangOptions::StrictFlexArraysLevelKind StrictFlexArraysLevel, bool IgnoreTemplateOrMacroSubstitution)
Whether it resembles a flexible array member.
DeclarationNameLoc - Additional source/type location info for a declaration name.
Represents the type decltype(expr) (C++11).
Represents a single C99 designator.
unsigned getArrayIndex() const
SourceRange getSourceRange() const LLVM_READONLY
bool isFieldDesignator() const
SourceLocation getBeginLoc() const LLVM_READONLY
struct FieldDesignatorInfo FieldInfo
A field designator, e.g., ".x".
bool isArrayRangeDesignator() const
FieldDecl * getFieldDecl() const
bool isArrayDesignator() const
SourceLocation getFieldLoc() const
const IdentifierInfo * getFieldName() const
SourceLocation getDotLoc() const
Represents a C99 designated initializer expression.
static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)
Expr * getArrayRangeEnd(const Designator &D) const
Expr * getSubExpr(unsigned Idx) const
SourceRange getDesignatorsSourceRange() const
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).
static DesignatedInitExpr * Create(const ASTContext &C, llvm::ArrayRef< Designator > Designators, ArrayRef< Expr * > IndexExprs, SourceLocation EqualOrColonLoc, bool GNUSyntax, Expr *Init)
Expr * getArrayIndex(const Designator &D) const
Designator * getDesignator(unsigned Idx)
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 getBeginLoc() const LLVM_READONLY
DesignatedInitUpdateExpr(const ASTContext &C, SourceLocation lBraceLoc, Expr *baseExprs, SourceLocation rBraceLoc)
SourceLocation getEndLoc() const LLVM_READONLY
InitListExpr * getUpdater() const
An instance of this object exists for each enum constant that is defined.
ExplicitCastExpr - An explicit cast written in the source code.
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
This represents one expression.
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.
bool isReadIfDiscardedInCPlusPlus11() const
Determine whether an lvalue-to-rvalue conversion should implicitly be applied to this expression if i...
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...
@ SE_AllowUndefinedBehavior
Allow UB that we can give a value, but not arbitrary unmodeled side effects.
static QualType findBoundMemberType(const Expr *expr)
Given an expression of bound-member type, find the type of the member.
bool isImplicitCXXThis() const
Whether this expression is an implicit reference to 'this' in C++.
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.
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, e.g.
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 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 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.
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.
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.
const Expr * getBestDynamicClassTypeExpr() const
Get the inner expression that determines the best dynamic class.
bool isIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
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,...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
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.
bool isDefaultArgument() const
Determine whether this expression is a default function argument.
bool isFlexibleArrayMemberLike(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...
Classification Classify(ASTContext &Ctx) const
Classify - Classify this expression according to the C++11 expression taxonomy.
bool hasNonTrivialCall(const ASTContext &Ctx) const
Determine whether this expression involves a call to any function that is not trivial.
bool refersToGlobalRegisterVar() const
Returns whether this expression refers to a global register variable.
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.
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.
const ObjCPropertyRefExpr * getObjCProperty() const
If this expression is an l-value for an Objective C property, find the underlying property reference ...
bool containsDuplicateElements() const
containsDuplicateElements - Return true if any element access is repeated.
bool isArrow() const
isArrow - Return true if the base expression is a pointer to vector, return false if the base express...
void getEncodedElementAccess(SmallVectorImpl< uint32_t > &Elts) const
getEncodedElementAccess - Encode the elements accessed into an llvm aggregate Constant of ConstantInt...
const Expr * getBase() const
unsigned getNumElements() const
getNumElements - Get the number of components being selected.
static int getAccessorIdx(char c, bool isNumericAccessor)
Represents difference between two FPOptions values.
bool requiresTrailingStorage() const
static FPOptions defaultWithoutTrailingStorage(const LangOptions &LO)
Return the default value of FPOptions that's used when trailing storage isn't required.
Represents a member of a struct/union/class.
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
bool isBitField() const
Determines whether this field is a bitfield.
static FixedPointLiteral * Create(const ASTContext &C, EmptyShell Empty)
Returns an empty fixed-point literal.
std::string getValueAsString(unsigned Radix) const
static FixedPointLiteral * CreateFromRawInt(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l, unsigned Scale)
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
double getValueAsApproximateDouble() const
getValueAsApproximateDouble - This returns the value as an inaccurate double.
llvm::APFloat getValue() const
FullExpr - Represents a "full-expression" node.
Represents a function declaration or definition.
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Represents a prototype with parameter type info, e.g.
Provides information about a function template specialization, which is a FunctionDecl that has been ...
bool isExplicitSpecialization() const
TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
QualType getReturnType() const
Represents a C11 generic selection.
static GenericSelectionExpr * Create(const ASTContext &Context, SourceLocation GenericLoc, Expr *ControllingExpr, ArrayRef< TypeSourceInfo * > AssocTypes, ArrayRef< Expr * > AssocExprs, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool ContainsUnexpandedParameterPack, unsigned ResultIndex)
Create a non-result-dependent generic selection expression accepting an expression predicate.
static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)
Create an empty generic selection expression for deserialization.
GlobalDecl - represents a global declaration.
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat, FPOptionsOverride FPO)
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Describes an C or C++ initializer list.
bool hasArrayFiller() const
Return true if this is an array initializer and its array "filler" has been set.
InitListExpr(const ASTContext &C, SourceLocation lbraceloc, ArrayRef< Expr * > initExprs, SourceLocation rbraceloc)
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)
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
const Expr * getInit(unsigned Init) const
bool isIdiomaticZeroInitializer(const LangOptions &LangOpts) const
Is this the zero initializer {0} in a language which considers it idiomatic?
SourceLocation getEndLoc() const LLVM_READONLY
bool isSyntacticForm() const
ArrayRef< Expr * > inits()
void sawArrayRangeDesignator(bool ARD=true)
Expr ** getInits()
Retrieve the set of initializers.
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
static ItaniumMangleContext * create(ASTContext &Context, DiagnosticsEngine &Diags, bool IsAux=false)
LabelStmt - Represents a label, which has a substatement.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
StrictFlexArraysLevelKind
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
void remapPathPrefix(SmallVectorImpl< char > &Path) const
Remap path prefix according to -fmacro-prefix-path option.
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.
bool LexFromRawLexer(Token &Result)
LexFromRawLexer - Lex a token from a designated raw lexer (one with no associated preprocessor object...
static SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Characters, const SourceManager &SM, const LangOptions &LangOpts)
AdvanceToTokenCharacter - If the current SourceLocation specifies a location at the start of a token,...
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
static MemberExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
void setMemberDecl(ValueDecl *D)
NestedNameSpecifierLoc getQualifierLoc() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name,...
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
bool isImplicitAccess() const
Determine whether the base of this explicit is implicit.
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
SourceLocation getEndLoc() const LLVM_READONLY
SourceLocation getBeginLoc() const LLVM_READONLY
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
A pointer to member type per C++ 8.3.3 - Pointers to members.
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
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.
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
bool hasQualifier() const
Evaluates true when this nested-name-specifier location is non-empty.
An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......
static OMPArrayShapingExpr * CreateEmpty(const ASTContext &Context, unsigned NumDims)
static OMPArrayShapingExpr * Create(const ASTContext &Context, QualType T, Expr *Op, SourceLocation L, SourceLocation R, ArrayRef< Expr * > Dims, ArrayRef< SourceRange > BracketRanges)
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
static OMPIteratorExpr * Create(const ASTContext &Context, QualType T, SourceLocation IteratorKwLoc, SourceLocation L, SourceLocation R, ArrayRef< IteratorDefinition > Data, ArrayRef< OMPIteratorHelperData > Helpers)
static OMPIteratorExpr * CreateEmpty(const ASTContext &Context, unsigned NumIterators)
SourceLocation getSecondColonLoc(unsigned I) const
Gets the location of the second ':' (if any) in the range for the given iteratori definition.
SourceLocation getColonLoc(unsigned I) const
Gets the location of the first ':' in the range for the given iterator definition.
IteratorRange getIteratorRange(unsigned I)
Gets the iterator range for the given iterator.
OMPIteratorHelperData & getHelper(unsigned I)
Fetches helper data for the specified iteration space.
SourceLocation getAssignLoc(unsigned I) const
Gets the location of '=' for the given iterator definition.
Decl * getIteratorDecl(unsigned I)
Gets the iterator declaration for the given iterator.
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.
Represents an ObjC class declaration.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
An expression that sends a message to the given Objective-C object or class.
ObjCMethodFamily getMethodFamily() const
bool isInstanceMessage() const
Determine whether this is an instance message to either a computed object or to super.
const ObjCMethodDecl * getMethodDecl() const
ObjCMethodDecl - Represents an instance or class method declaration.
ImplicitParamDecl * getSelfDecl() 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,...
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
static OffsetOfExpr * Create(const ASTContext &C, QualType type, SourceLocation OperatorLoc, TypeSourceInfo *tsi, ArrayRef< OffsetOfNode > comps, ArrayRef< Expr * > exprs, SourceLocation RParenLoc)
void setIndexExpr(unsigned Idx, Expr *E)
void setComponent(unsigned Idx, OffsetOfNode ON)
FieldDecl * getField() const
For a field offsetof node, returns the field.
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
@ Identifier
A field in a dependent type, known only by its name.
Kind getKind() const
Determine what kind of offsetof node this is.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
static const OpaqueValueExpr * findInCopyConstruct(const Expr *expr)
Given an expression which invokes a copy constructor — i.e.
ParenExpr - This represents a parethesized expression, e.g.
static ParenListExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumExprs)
Create an empty paren list.
static ParenListExpr * Create(const ASTContext &Ctx, SourceLocation LParenLoc, ArrayRef< Expr * > Exprs, SourceLocation RParenLoc)
Create a paren list.
PointerType - C99 6.7.5.1 - Pointer Declarators.
QualType getPointeeType() const
[C99 6.4.2.2] - A predefined identifier such as func.
static PredefinedExpr * Create(const ASTContext &Ctx, SourceLocation L, QualType FNTy, PredefinedIdentKind IK, bool IsTransparent, StringLiteral *SL)
Create a PredefinedExpr.
StringRef getIdentKindName() const
static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)
Create an empty PredefinedExpr.
static std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl, bool ForceElaboratedPrinting=false)
static void processPathToFileName(SmallVectorImpl< char > &FileName, const PresumedLoc &PLoc, const LangOptions &LangOpts, const TargetInfo &TI)
static void processPathForFileMacro(SmallVectorImpl< char > &Path, const LangOptions &LangOpts, const TargetInfo &TI)
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
Callbacks to use to customize the behavior of the pretty-printer.
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
semantics_iterator semantics_end()
semantics_iterator semantics_begin()
const Expr *const * const_semantics_iterator
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
ArrayRef< Expr * > semantics()
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.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
QualType getCanonicalType() const
The collection of all-type qualifiers we support.
void removeAddressSpace()
Represents a struct/union/class.
field_iterator field_end() const
field_range fields() const
field_iterator field_begin() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
RecordDecl * getDecl() const
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
static RecoveryExpr * Create(ASTContext &Ctx, QualType T, SourceLocation BeginLoc, SourceLocation EndLoc, ArrayRef< Expr * > SubExprs)
static RecoveryExpr * CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs)
TypeSourceInfo * getTypeSourceInfo()
static SYCLUniqueStableNameExpr * Create(const ASTContext &Ctx, SourceLocation OpLoc, SourceLocation LParen, SourceLocation RParen, TypeSourceInfo *TSI)
std::string ComputeName(ASTContext &Context) const
static SYCLUniqueStableNameExpr * CreateEmpty(const ASTContext &Ctx)
void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)
ShuffleVectorExpr(const ASTContext &C, ArrayRef< Expr * > args, QualType Type, SourceLocation BLoc, SourceLocation RP)
APValue EvaluateInContext(const ASTContext &Ctx, const Expr *DefaultExpr) const
Return the result of evaluating this SourceLocExpr in the specified (and possibly null) default argum...
SourceLocExpr(const ASTContext &Ctx, SourceLocIdentKind Type, QualType ResultTy, SourceLocation BLoc, SourceLocation RParenLoc, DeclContext *Context)
SourceLocation getLocation() const
const DeclContext * getParentContext() const
If the SourceLocExpr has been resolved return the subexpression representing the resolved value.
StringRef getBuiltinStr() const
Return a string representing the name of the specific builtin function.
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.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
CharSourceRange getExpansionRange(SourceLocation Loc) const
Given a SourceLocation object, return the range of tokens covered by the expansion in the ultimate fi...
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
SourceLocation getEndLoc() const LLVM_READONLY
UnaryExprOrTypeTraitExprBitfields UnaryExprOrTypeTraitExprBits
GenericSelectionExprBitfields GenericSelectionExprBits
ParenListExprBitfields ParenListExprBits
CallExprBitfields CallExprBits
FloatingLiteralBitfields FloatingLiteralBits
child_iterator child_begin()
StmtClass getStmtClass() const
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
UnaryOperatorBitfields UnaryOperatorBits
SourceLocExprBitfields SourceLocExprBits
ConstantExprBitfields ConstantExprBits
llvm::iterator_range< child_iterator > child_range
StringLiteralBitfields StringLiteralBits
MemberExprBitfields MemberExprBits
DeclRefExprBitfields DeclRefExprBits
ConstStmtIterator const_child_iterator
PredefinedExprBitfields PredefinedExprBits
SourceLocation getBeginLoc() const LLVM_READONLY
BinaryOperatorBitfields BinaryOperatorBits
PseudoObjectExprBitfields PseudoObjectExprBits
llvm::iterator_range< const_child_iterator > const_child_range
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
unsigned getOffsetOfStringByte(const Token &TheTok, unsigned ByteNo) const
getOffsetOfStringByte - This function returns the offset of the specified byte of the string data rep...
unsigned GetStringLength() const
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
unsigned getLength() const
StringLiteralKind getKind() const
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...
uint32_t getCodeUnit(size_t i) const
void outputString(raw_ostream &OS) const
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringLiteralKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
static StringLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumConcatenated, unsigned Length, unsigned CharByteWidth)
Construct an empty string literal.
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Represents the declaration of a struct/union/class/enum.
Exposes information about the current target.
A convenient class for passing around template argument information.
A template argument list.
unsigned size() const
Retrieve the number of template arguments in this template argument list.
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Location wrapper for a TemplateArgument.
void print(const PrintingPolicy &Policy, raw_ostream &Out, bool IncludeType) const
Print this template argument to the given output stream.
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Stores a list of template parameters for a TemplateDecl and its derived classes.
NamedDecl * getParam(unsigned Idx)
static bool shouldIncludeTypeForArgument(const PrintingPolicy &Policy, const TemplateParameterList *TPL, unsigned Idx)
Token - This structure provides full information about a lexed token.
A container of type source information.
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isBooleanType() const
bool hasAttr(attr::Kind AK) const
Determine whether this type had the specified attribute applied to it (looking through top-level type...
bool isPointerType() const
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
const T * castAs() const
Member-template castAs<specific type>.
bool isSpecificPlaceholderType(unsigned K) const
Test for a specific placeholder type.
bool isReferenceType() const
const CXXRecordDecl * getPointeeCXXRecordDecl() const
If this is a pointer or reference to a RecordType, return the CXXRecordDecl that the type refers to.
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
const ArrayType * getAsArrayTypeUnsafe() const
A variant of getAs<> for array types which silently discards qualifiers from the outermost type.
bool isVectorType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
QualType getArgumentType() const
bool isArgumentType() const
UnaryExprOrTypeTraitExpr(UnaryExprOrTypeTrait ExprKind, TypeSourceInfo *TInfo, QualType resultType, SourceLocation op, SourceLocation rp)
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Expr * getSubExpr() const
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
static OverloadedOperatorKind getOverloadedOperator(Opcode Opc)
Retrieve the overloaded operator kind that corresponds to the given unary opcode.
static UnaryOperator * Create(const ASTContext &C, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
static Opcode getOverloadedOpcode(OverloadedOperatorKind OO, bool Postfix)
Retrieve the unary opcode that corresponds to the given overloaded operator.
void setStoredFPFeatures(FPOptionsOverride F)
Set FPFeatures in trailing storage, used by Serialization & ASTImporter.
UnaryOperator(const ASTContext &Ctx, Expr *input, Opcode opc, QualType type, ExprValueKind VK, ExprObjectKind OK, SourceLocation l, bool CanOverflow, FPOptionsOverride FPFeatures)
static UnaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to,...
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
Defines the clang::TargetInfo interface.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
The JSON file list parser is used to communicate input to InstallAPI.
@ Create
'create' clause, allowed on Compute and Combined constructs, plus 'data', 'enter data',...
@ Self
'self' clause, allowed on Compute and Combined Constructs, plus 'update'.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
@ OO_None
Not an overloaded operator.
ConstantResultStorageKind
Describes the kind of result that can be tail-allocated.
@ Ctor_Base
Base object ctor.
LLVM_READONLY bool isPrintable(unsigned char c)
Return true if this character is an ASCII printable character; that is, a character that should take ...
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
RefQualifierKind
The kind of C++11 ref-qualifier associated with a function type.
@ RQ_LValue
An lvalue ref-qualifier was provided (&).
@ RQ_RValue
An rvalue ref-qualifier was provided (&&).
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_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
@ OK_Ordinary
An ordinary object is located at an address in memory.
ExprDependence computeDependence(FullExpr *E)
UnaryExprOrTypeTrait
Names for the "expression or type" traits.
Expr * IgnoreImplicitCastsExtraSingleStep(Expr *E)
@ Result
The result type of a method or function.
Expr * IgnoreImplicitCastsSingleStep(Expr *E)
@ Dtor_Base
Base object dtor.
CastKind
CastKind - The kind of operation required for a conversion.
void FixedPointValueToString(SmallVectorImpl< char > &Str, llvm::APSInt Val, unsigned Scale)
Expr * IgnoreImplicitSingleStep(Expr *E)
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_LValue
An l-value expression is a reference to an object with independent storage.
Expr * IgnoreParensSingleStep(Expr *E)
const FunctionProtoType * T
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
Expr * IgnoreCastsSingleStep(Expr *E)
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Expr * IgnoreLValueCastsSingleStep(Expr *E)
Expr * IgnoreParensOnlySingleStep(Expr *E)
@ PrettyFunctionNoVirtual
The same as PrettyFunction, except that the 'virtual' keyword is omitted for virtual member functions...
Expr * IgnoreBaseCastsSingleStep(Expr *E)
NonOdrUseReason
The reason why a DeclRefExpr does not constitute 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...
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
DeclarationName getName() const
getName - Returns the embedded declaration name.
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
SourceLocation getEndLoc() const LLVM_READONLY
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
Iterator range representation begin:end[:step].
Helper expressions and declaration for OMPIteratorExpr class for each iteration space.
Describes how types, statements, expressions, and declarations should be printed.
unsigned SuppressTagKeyword
Whether type printing should skip printing the tag keyword.
const PrintingCallbacks * Callbacks
Callbacks to use to allow the behavior of printing to be customized.
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....
An adjustment to be made to the temporary created when emitting a reference binding,...