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()->isRecordType());
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()),
1199 StringLiteral(Ctx, Str, Kind, Pascal, Ty, Loc, NumConcatenated);
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);
3897 Inherited::VisitStmt(E);
3907 NonTrivialCallFinder Finder(Ctx);
3909 return Finder.hasNonTrivialCall();
3927 llvm_unreachable(
"Unexpected value dependent expression!");
3955 CE->getSubExpr()->getType()->isIntegerType())
3956 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3959 }
else if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(
this)) {
3961 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3962 }
else if (
const ParenExpr *PE = dyn_cast<ParenExpr>(
this)) {
3965 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3967 dyn_cast<GenericSelectionExpr>(
this)) {
3968 if (GE->isResultDependent())
3970 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
3971 }
else if (
const ChooseExpr *CE = dyn_cast<ChooseExpr>(
this)) {
3972 if (CE->isConditionDependent())
3974 return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);
3976 = dyn_cast<CXXDefaultArgExpr>(
this)) {
3978 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
3980 = dyn_cast<CXXDefaultInitExpr>(
this)) {
3982 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
3983 }
else if (isa<GNUNullExpr>(
this)) {
3987 = dyn_cast<MaterializeTemporaryExpr>(
this)) {
3988 return M->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3989 }
else if (
const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(
this)) {
3990 if (
const Expr *Source = OVE->getSourceExpr())
3991 return Source->isNullPointerConstant(Ctx, NPC);
4000 if (
getType()->isNullPtrType())
4005 UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
4007 const Expr *InitExpr = CLE->getInitializer();
4008 if (
const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
4012 if (!
getType()->isIntegerType() ||
4035 if (isa<IntegerLiteral>(
this))
4043 const Expr *E =
this;
4046 "expression is not a property reference");
4049 if (BO->getOpcode() == BO_Comma) {
4058 return cast<ObjCPropertyRefExpr>(E);
4064 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
4083 if (ICE->getCastKind() == CK_LValueToRValue ||
4084 (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp))
4090 if (
MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
4091 if (
FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
4092 if (Field->isBitField())
4101 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) {
4102 if (
FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
4103 if (Field->isBitField())
4106 if (
BindingDecl *BD = dyn_cast<BindingDecl>(DeclRef->getDecl()))
4107 if (
Expr *E = BD->getBinding())
4112 if (BinOp->isAssignmentOp() && BinOp->getLHS())
4113 return BinOp->getLHS()->getSourceBitField();
4115 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
4116 return BinOp->getRHS()->getSourceBitField();
4120 if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())
4121 return UnOp->getSubExpr()->getSourceBitField();
4128 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4129 return dyn_cast<EnumConstantDecl>(DRE->getDecl());
4138 if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)
4147 if (isa<ExtVectorElementExpr>(E))
4150 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4151 if (
auto *BD = dyn_cast<BindingDecl>(DRE->getDecl()))
4152 if (
auto *E = BD->getBinding())
4161 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
4162 if (
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
4164 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
4180 case CXXThisExprClass:
4182 case DeclRefExprClass: {
4185 const auto *DRE1 = cast<DeclRefExpr>(E1);
4186 const auto *DRE2 = cast<DeclRefExpr>(E2);
4187 return DRE1->isPRValue() && DRE2->isPRValue() &&
4188 DRE1->getDecl() == DRE2->getDecl();
4190 case ImplicitCastExprClass: {
4193 const auto *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
4194 const auto *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
4197 if (ICE1->getCastKind() != ICE2->getCastKind())
4202 if (ICE1->getCastKind() == CK_LValueToRValue ||
4203 ICE1->getCastKind() == CK_ArrayToPointerDecay ||
4204 ICE1->getCastKind() == CK_FunctionToPointerDecay) {
4209 const auto *DRE1 = dyn_cast<DeclRefExpr>(E1);
4210 const auto *DRE2 = dyn_cast<DeclRefExpr>(E2);
4214 const auto *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
4215 const auto *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
4216 if (Ivar1 && Ivar2) {
4217 return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
4221 const auto *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
4222 const auto *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
4223 if (Array1 && Array2) {
4227 auto Idx1 = Array1->getIdx();
4228 auto Idx2 = Array2->getIdx();
4229 const auto Integer1 = dyn_cast<IntegerLiteral>(Idx1);
4230 const auto Integer2 = dyn_cast<IntegerLiteral>(Idx2);
4231 if (Integer1 && Integer2) {
4232 if (!llvm::APInt::isSameValue(Integer1->getValue(),
4233 Integer2->getValue()))
4244 while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
4245 const auto *ME1 = cast<MemberExpr>(E1);
4246 const auto *ME2 = cast<MemberExpr>(E2);
4249 if (
const auto *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
4250 if (D->isStaticDataMember())
4256 if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
4262 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
4263 return DRE->getDecl();
4264 if (
const auto *ME = dyn_cast<MemberExpr>(E))
4265 return ME->getMemberDecl();
4284 return VT->getNumElements();
4292 StringRef Comp = Accessor->
getName();
4295 if (Comp ==
"hi" || Comp ==
"lo" || Comp ==
"even" || Comp ==
"odd")
4299 if (Comp[0] ==
's' || Comp[0] ==
'S')
4300 Comp = Comp.substr(1);
4302 for (
unsigned i = 0, e = Comp.size(); i != e; ++i)
4303 if (Comp.substr(i + 1).contains(Comp[i]))
4312 StringRef Comp = Accessor->
getName();
4313 bool isNumericAccessor =
false;
4314 if (Comp[0] ==
's' || Comp[0] ==
'S') {
4315 Comp = Comp.substr(1);
4316 isNumericAccessor =
true;
4319 bool isHi = Comp ==
"hi";
4320 bool isLo = Comp ==
"lo";
4321 bool isEven = Comp ==
"even";
4322 bool isOdd = Comp ==
"odd";
4338 Elts.push_back(Index);
4346 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
4347 SubExprs =
new (
C)
Stmt*[args.size()];
4348 for (
unsigned i = 0; i != args.size(); i++)
4349 SubExprs[i] = args[i];
4355 if (SubExprs)
C.Deallocate(SubExprs);
4357 this->NumExprs = Exprs.size();
4358 SubExprs =
new (
C)
Stmt*[NumExprs];
4359 memcpy(SubExprs, Exprs.data(),
sizeof(
Expr *) * Exprs.size());
4362GenericSelectionExpr::GenericSelectionExpr(
4366 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex)
4367 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4368 AssocExprs[ResultIndex]->getValueKind(),
4369 AssocExprs[ResultIndex]->getObjectKind()),
4370 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4371 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4372 assert(AssocTypes.size() == AssocExprs.size() &&
4373 "Must have the same number of association expressions"
4374 " and TypeSourceInfo!");
4375 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4378 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4380 std::copy(AssocExprs.begin(), AssocExprs.end(),
4381 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4382 std::copy(AssocTypes.begin(), AssocTypes.end(),
4383 getTrailingObjects<TypeSourceInfo *>() +
4384 getIndexOfStartOfAssociatedTypes());
4389GenericSelectionExpr::GenericSelectionExpr(
4394 unsigned ResultIndex)
4395 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4396 AssocExprs[ResultIndex]->getValueKind(),
4397 AssocExprs[ResultIndex]->getObjectKind()),
4398 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4399 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4400 assert(AssocTypes.size() == AssocExprs.size() &&
4401 "Must have the same number of association expressions"
4402 " and TypeSourceInfo!");
4403 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4406 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4408 std::copy(AssocExprs.begin(), AssocExprs.end(),
4409 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4410 std::copy(AssocTypes.begin(), AssocTypes.end(),
4411 getTrailingObjects<TypeSourceInfo *>() +
4412 getIndexOfStartOfAssociatedTypes());
4417GenericSelectionExpr::GenericSelectionExpr(
4421 bool ContainsUnexpandedParameterPack)
4422 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4424 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4425 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4426 assert(AssocTypes.size() == AssocExprs.size() &&
4427 "Must have the same number of association expressions"
4428 " and TypeSourceInfo!");
4431 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4433 std::copy(AssocExprs.begin(), AssocExprs.end(),
4434 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4435 std::copy(AssocTypes.begin(), AssocTypes.end(),
4436 getTrailingObjects<TypeSourceInfo *>() +
4437 getIndexOfStartOfAssociatedTypes());
4442GenericSelectionExpr::GenericSelectionExpr(
4447 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4449 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4450 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4451 assert(AssocTypes.size() == AssocExprs.size() &&
4452 "Must have the same number of association expressions"
4453 " and TypeSourceInfo!");
4456 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4458 std::copy(AssocExprs.begin(), AssocExprs.end(),
4459 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4460 std::copy(AssocTypes.begin(), AssocTypes.end(),
4461 getTrailingObjects<TypeSourceInfo *>() +
4462 getIndexOfStartOfAssociatedTypes());
4467GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty,
unsigned NumAssocs)
4468 :
Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
4474 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex) {
4475 unsigned NumAssocs = AssocExprs.size();
4477 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4480 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4481 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4488 bool ContainsUnexpandedParameterPack) {
4489 unsigned NumAssocs = AssocExprs.size();
4491 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4494 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4495 RParenLoc, ContainsUnexpandedParameterPack);
4503 unsigned ResultIndex) {
4504 unsigned NumAssocs = AssocExprs.size();
4506 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4509 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4510 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4517 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack) {
4518 unsigned NumAssocs = AssocExprs.size();
4520 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4523 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4524 RParenLoc, ContainsUnexpandedParameterPack);
4529 unsigned NumAssocs) {
4531 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4554 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
4555 NumDesignators(Designators.
size()), NumSubExprs(IndexExprs.
size() + 1) {
4556 this->Designators =
new (
C)
Designator[NumDesignators];
4564 unsigned IndexIdx = 0;
4565 for (
unsigned I = 0; I != NumDesignators; ++I) {
4566 this->Designators[I] = Designators[I];
4569 *Child++ = IndexExprs[IndexIdx++];
4572 *Child++ = IndexExprs[IndexIdx++];
4573 *Child++ = IndexExprs[IndexIdx++];
4577 assert(IndexIdx == IndexExprs.size() &&
"Wrong number of index expressions");
4586 bool UsesColonSyntax,
Expr *
Init) {
4587 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
4590 ColonOrEqualLoc, UsesColonSyntax,
4595 unsigned NumIndexExprs) {
4596 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
4603 unsigned NumDesigs) {
4605 NumDesignators = NumDesigs;
4606 for (
unsigned I = 0; I != NumDesigs; ++I)
4607 Designators[I] = Desigs[I];
4621 if (
First.isFieldDesignator()) {
4624 for (
unsigned int i = 0; i < DIE->size(); i++) {
4632 return First.getLBracketLoc();
4659 unsigned NumNewDesignators =
Last -
First;
4660 if (NumNewDesignators == 0) {
4661 std::copy_backward(Designators + Idx + 1,
4662 Designators + NumDesignators,
4664 --NumNewDesignators;
4667 if (NumNewDesignators == 1) {
4668 Designators[Idx] = *
First;
4673 =
new (
C)
Designator[NumDesignators - 1 + NumNewDesignators];
4674 std::copy(Designators, Designators + Idx, NewDesignators);
4675 std::copy(
First,
Last, NewDesignators + Idx);
4676 std::copy(Designators + Idx + 1, Designators + NumDesignators,
4677 NewDesignators + Idx + NumNewDesignators);
4678 Designators = NewDesignators;
4679 NumDesignators = NumDesignators - 1 + NumNewDesignators;
4688 BaseAndUpdaterExprs[0] = baseExpr;
4693 BaseAndUpdaterExprs[1] = ILE;
4710 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4713 for (
unsigned I = 0, N = Exprs.size(); I != N; ++I)
4714 getTrailingObjects<Stmt *>()[I] = Exprs[I];
4718ParenListExpr::ParenListExpr(EmptyShell Empty,
unsigned NumExprs)
4719 :
Expr(ParenListExprClass, Empty) {
4727 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
4729 return new (Mem)
ParenListExpr(LParenLoc, Exprs, RParenLoc);
4733 unsigned NumExprs) {
4743 :
Expr(BinaryOperatorClass, ResTy, VK, OK) {
4746 "Use CompoundAssignOperator for compound assignments");
4748 SubExprs[LHS] = lhs;
4749 SubExprs[RHS] = rhs;
4760 :
Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
4763 "Use CompoundAssignOperator for compound assignments");
4765 SubExprs[LHS] = lhs;
4766 SubExprs[RHS] = rhs;
4774 bool HasFPFeatures) {
4814 CompLHSType, CompResultType);
4818 bool hasFPFeatures) {
4819 void *Mem =
C.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),
4828 :
Expr(UnaryOperatorClass,
type, VK, OK), Val(input) {
4844 unsigned Size = totalSizeToAlloc<FPOptionsOverride>(HasFPFeatures);
4852 e = ewc->getSubExpr();
4854 e = m->getSubExpr();
4855 e = cast<CXXConstructExpr>(e)->getArg(0);
4857 e = ice->getSubExpr();
4858 return cast<OpaqueValueExpr>(e);
4863 unsigned numSemanticExprs) {
4865 Context.
Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
4870PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell,
unsigned numSemanticExprs)
4871 :
Expr(PseudoObjectExprClass, shell) {
4877 unsigned resultIndex) {
4878 assert(syntax &&
"no syntactic expression!");
4879 assert(
semantics.size() &&
"no semantic expressions!");
4889 VK =
semantics[resultIndex]->getValueKind();
4893 void *buffer =
C.Allocate(totalSizeToAlloc<Expr *>(
semantics.size() + 1),
4901 unsigned resultIndex)
4906 for (
unsigned i = 0, e =
semantics.size() + 1; i != e; ++i) {
4908 getSubExprsBuffer()[i] = E;
4910 if (isa<OpaqueValueExpr>(E))
4911 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() !=
nullptr &&
4912 "opaque-value semantic expressions for pseudo-object "
4913 "operations must have sources");
4946 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
4947 assert(args.size() ==
getNumSubExprs(op) &&
"wrong number of subexpressions");
4948 for (
unsigned i = 0; i != args.size(); i++)
4949 SubExprs[i] = args[i];
4955 case AO__c11_atomic_init:
4956 case AO__opencl_atomic_init:
4957 case AO__c11_atomic_load:
4958 case AO__atomic_load_n:
4961 case AO__scoped_atomic_load_n:
4962 case AO__opencl_atomic_load:
4963 case AO__hip_atomic_load:
4964 case AO__c11_atomic_store:
4965 case AO__c11_atomic_exchange:
4966 case AO__atomic_load:
4967 case AO__atomic_store:
4968 case AO__atomic_store_n:
4969 case AO__atomic_exchange_n:
4970 case AO__c11_atomic_fetch_add:
4971 case AO__c11_atomic_fetch_sub:
4972 case AO__c11_atomic_fetch_and:
4973 case AO__c11_atomic_fetch_or:
4974 case AO__c11_atomic_fetch_xor:
4975 case AO__c11_atomic_fetch_nand:
4976 case AO__c11_atomic_fetch_max:
4977 case AO__c11_atomic_fetch_min:
4978 case AO__atomic_fetch_add:
4979 case AO__atomic_fetch_sub:
4980 case AO__atomic_fetch_and:
4981 case AO__atomic_fetch_or:
4982 case AO__atomic_fetch_xor:
4983 case AO__atomic_fetch_nand:
4984 case AO__atomic_add_fetch:
4985 case AO__atomic_sub_fetch:
4986 case AO__atomic_and_fetch:
4987 case AO__atomic_or_fetch:
4988 case AO__atomic_xor_fetch:
4989 case AO__atomic_nand_fetch:
4990 case AO__atomic_min_fetch:
4991 case AO__atomic_max_fetch:
4992 case AO__atomic_fetch_min:
4993 case AO__atomic_fetch_max:
4996 case AO__scoped_atomic_load:
4997 case AO__scoped_atomic_store:
4998 case AO__scoped_atomic_store_n:
4999 case AO__scoped_atomic_fetch_add:
5000 case AO__scoped_atomic_fetch_sub:
5001 case AO__scoped_atomic_fetch_and:
5002 case AO__scoped_atomic_fetch_or:
5003 case AO__scoped_atomic_fetch_xor:
5004 case AO__scoped_atomic_fetch_nand:
5005 case AO__scoped_atomic_add_fetch:
5006 case AO__scoped_atomic_sub_fetch:
5007 case AO__scoped_atomic_and_fetch:
5008 case AO__scoped_atomic_or_fetch:
5009 case AO__scoped_atomic_xor_fetch:
5010 case AO__scoped_atomic_nand_fetch:
5011 case AO__scoped_atomic_min_fetch:
5012 case AO__scoped_atomic_max_fetch:
5013 case AO__scoped_atomic_fetch_min:
5014 case AO__scoped_atomic_fetch_max:
5015 case AO__scoped_atomic_exchange_n:
5016 case AO__hip_atomic_exchange:
5017 case AO__hip_atomic_fetch_add:
5018 case AO__hip_atomic_fetch_sub:
5019 case AO__hip_atomic_fetch_and:
5020 case AO__hip_atomic_fetch_or:
5021 case AO__hip_atomic_fetch_xor:
5022 case AO__hip_atomic_fetch_min:
5023 case AO__hip_atomic_fetch_max:
5024 case AO__opencl_atomic_store:
5025 case AO__hip_atomic_store:
5026 case AO__opencl_atomic_exchange:
5027 case AO__opencl_atomic_fetch_add:
5028 case AO__opencl_atomic_fetch_sub:
5029 case AO__opencl_atomic_fetch_and:
5030 case AO__opencl_atomic_fetch_or:
5031 case AO__opencl_atomic_fetch_xor:
5032 case AO__opencl_atomic_fetch_min:
5033 case AO__opencl_atomic_fetch_max:
5034 case AO__atomic_exchange:
5037 case AO__scoped_atomic_exchange:
5038 case AO__c11_atomic_compare_exchange_strong:
5039 case AO__c11_atomic_compare_exchange_weak:
5041 case AO__hip_atomic_compare_exchange_strong:
5042 case AO__opencl_atomic_compare_exchange_strong:
5043 case AO__opencl_atomic_compare_exchange_weak:
5044 case AO__hip_atomic_compare_exchange_weak:
5045 case AO__atomic_compare_exchange:
5046 case AO__atomic_compare_exchange_n:
5049 case AO__scoped_atomic_compare_exchange:
5050 case AO__scoped_atomic_compare_exchange_n:
5053 llvm_unreachable(
"unknown atomic op");
5059 return AT->getValueType();
5064 unsigned ArraySectionCount = 0;
5065 while (
auto *OASE = dyn_cast<ArraySectionExpr>(
Base->IgnoreParens())) {
5066 Base = OASE->getBase();
5067 ++ArraySectionCount;
5070 dyn_cast<ArraySubscriptExpr>(
Base->IgnoreParenImpCasts())) {
5071 Base = ASE->getBase();
5072 ++ArraySectionCount;
5074 Base =
Base->IgnoreParenImpCasts();
5075 auto OriginalTy =
Base->getType();
5076 if (
auto *DRE = dyn_cast<DeclRefExpr>(
Base))
5077 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
5078 OriginalTy = PVD->getOriginalType().getNonReferenceType();
5080 for (
unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
5081 if (OriginalTy->isAnyPointerType())
5082 OriginalTy = OriginalTy->getPointeeType();
5083 else if (OriginalTy->isArrayType())
5084 OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
5093 :
Expr(RecoveryExprClass,
T.getNonReferenceType(),
5094 T->isDependentType() ?
VK_LValue : getValueKindForType(
T),
5096 BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
5097 assert(!
T.isNull());
5098 assert(!llvm::is_contained(SubExprs,
nullptr));
5100 llvm::copy(SubExprs, getTrailingObjects<Expr *>());
5108 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(SubExprs.size()),
5110 return new (Mem)
RecoveryExpr(Ctx,
T, BeginLoc, EndLoc, SubExprs);
5114 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(NumSubExprs),
5121 NumDims == Dims.size() &&
5122 "Preallocated number of dimensions is different from the provided one.");
5123 llvm::copy(Dims, getTrailingObjects<Expr *>());
5128 NumDims == BR.size() &&
5129 "Preallocated number of dimensions is different from the provided one.");
5130 llvm::copy(BR, getTrailingObjects<SourceRange>());
5133OMPArrayShapingExpr::OMPArrayShapingExpr(
QualType ExprTy,
Expr *Op,
5137 RPLoc(R), NumDims(Dims.size()) {
5139 setDimensions(Dims);
5148 assert(Dims.size() == BracketRanges.size() &&
5149 "Different number of dimensions and brackets ranges.");
5151 totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),
5154 E->setBracketsRanges(BracketRanges);
5161 totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),
5166void OMPIteratorExpr::setIteratorDeclaration(
unsigned I,
Decl *D) {
5167 assert(I < NumIterators &&
5168 "Idx is greater or equal the number of iterators definitions.");
5169 getTrailingObjects<Decl *>()[I] = D;
5172void OMPIteratorExpr::setAssignmentLoc(
unsigned I,
SourceLocation Loc) {
5173 assert(I < NumIterators &&
5174 "Idx is greater or equal the number of iterators definitions.");
5177 static_cast<int>(RangeLocOffset::AssignLoc)] = Loc;
5180void OMPIteratorExpr::setIteratorRange(
unsigned I,
Expr *
Begin,
5184 assert(I < NumIterators &&
5185 "Idx is greater or equal the number of iterators definitions.");
5186 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5187 static_cast<int>(RangeExprOffset::Begin)] =
5189 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5190 static_cast<int>(RangeExprOffset::End)] = End;
5191 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5192 static_cast<int>(RangeExprOffset::Step)] = Step;
5195 static_cast<int>(RangeLocOffset::FirstColonLoc)] =
5199 static_cast<int>(RangeLocOffset::SecondColonLoc)] =
5204 return getTrailingObjects<Decl *>()[I];
5210 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5211 RangeExprOffset::Total) +
5212 static_cast<int>(RangeExprOffset::Begin)];
5214 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5215 RangeExprOffset::Total) +
5216 static_cast<int>(RangeExprOffset::End)];
5218 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5219 RangeExprOffset::Total) +
5220 static_cast<int>(RangeExprOffset::Step)];
5225 return getTrailingObjects<
5227 static_cast<int>(RangeLocOffset::AssignLoc)];
5231 return getTrailingObjects<
5233 static_cast<int>(RangeLocOffset::FirstColonLoc)];
5237 return getTrailingObjects<
5239 static_cast<int>(RangeLocOffset::SecondColonLoc)];
5243 getTrailingObjects<OMPIteratorHelperData>()[I] = D;
5247 return getTrailingObjects<OMPIteratorHelperData>()[I];
5251 return getTrailingObjects<OMPIteratorHelperData>()[I];
5254OMPIteratorExpr::OMPIteratorExpr(
5259 IteratorKwLoc(IteratorKwLoc), LPLoc(L), RPLoc(R),
5260 NumIterators(
Data.size()) {
5261 for (
unsigned I = 0, E =
Data.size(); I < E; ++I) {
5262 const IteratorDefinition &D =
Data[I];
5263 setIteratorDeclaration(I, D.IteratorDecl);
5264 setAssignmentLoc(I, D.AssignmentLoc);
5265 setIteratorRange(I, D.Range.Begin, D.ColonLoc, D.Range.End,
5266 D.SecondColonLoc, D.Range.Step);
5267 setHelper(I, Helpers[I]);
5278 assert(
Data.size() == Helpers.size() &&
5279 "Data and helpers must have the same size.");
5281 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
5282 Data.size(),
Data.size() *
static_cast<int>(RangeExprOffset::Total),
5283 Data.size() *
static_cast<int>(RangeLocOffset::Total),
5290 unsigned NumIterators) {
5292 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
5293 NumIterators, NumIterators *
static_cast<int>(RangeExprOffset::Total),
5294 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 ...
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
bool isExplicitSpecialization() const
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 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
'copyin' 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,...