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) {
683 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
684 std::unique_ptr<MangleContext> MC;
687 if (MC->shouldMangleDeclName(ND)) {
689 llvm::raw_svector_ostream Out(Buffer);
695 else if (ND->hasAttr<CUDAGlobalAttr>())
699 MC->mangleName(GD, Out);
701 if (!Buffer.empty() && Buffer.front() ==
'\01')
702 return std::string(Buffer.substr(1));
703 return std::string(Buffer);
705 return std::string(ND->getIdentifier()->getName());
709 if (isa<BlockDecl>(CurrentDecl)) {
714 if (DC->isFileContext())
718 llvm::raw_svector_ostream Out(Buffer);
719 if (
auto *DCBlock = dyn_cast<BlockDecl>(DC))
722 else if (
auto *DCDecl = dyn_cast<Decl>(DC))
724 return std::string(Out.str());
726 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
731 return FD->getNameAsString();
734 llvm::raw_svector_ostream Out(Name);
746 std::string remapPath(StringRef Path)
const override {
749 return std::string(p);
759 llvm::raw_string_ostream POut(Proto);
766 if (FD->hasWrittenPrototype())
767 FT = dyn_cast<FunctionProtoType>(AFT);
772 case CC_C: POut <<
"__cdecl ";
break;
783 FD->printQualifiedName(POut, Policy);
787 for (
unsigned i = 0, e =
Decl->getNumParams(); i != e; ++i) {
789 POut <<
Decl->getParamDecl(i)->getType().stream(Policy);
792 if (FT->isVariadic()) {
793 if (FD->getNumParams()) POut <<
", ";
798 !
Decl->getNumParams()) {
805 assert(FT &&
"We must have a written prototype in this case.");
808 if (FT->isVolatile())
820 while (Ctx && isa<NamedDecl>(Ctx)) {
822 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
824 Specs.push_back(Spec);
828 std::string TemplateParams;
829 llvm::raw_string_ostream TOut(TemplateParams);
832 D->getSpecializedTemplate()->getTemplateParameters();
834 assert(Params->
size() == Args.
size());
835 for (
unsigned i = 0, numParams = Params->
size(); i != numParams; ++i) {
837 if (Param.empty())
continue;
838 TOut << Param <<
" = ";
847 = FD->getTemplateSpecializationInfo();
852 assert(Params->
size() == Args->
size());
853 for (
unsigned i = 0, e = Params->
size(); i != e; ++i) {
855 if (Param.empty())
continue;
856 TOut << Param <<
" = ";
857 Args->
get(i).
print(Policy, TOut,
true);
863 if (!TemplateParams.empty()) {
865 TemplateParams.resize(TemplateParams.size() - 2);
866 POut <<
" [" << TemplateParams <<
"]";
875 if (isa<CXXMethodDecl>(FD) &&
876 cast<CXXMethodDecl>(FD)->getParent()->isLambda())
877 Proto =
"auto " + Proto;
878 else if (FT && FT->getReturnType()->getAs<
DecltypeType>())
883 else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
888 return std::string(Name);
890 if (
const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
894 if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {
898 llvm_unreachable(
"CapturedDecl not inside a function or method");
900 if (
const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
902 llvm::raw_svector_ostream Out(Name);
903 Out << (MD->isInstanceMethod() ?
'-' :
'+');
912 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
913 Out <<
'(' << *CID <<
')';
916 MD->getSelector().print(Out);
919 return std::string(Name);
921 if (isa<TranslationUnitDecl>(CurrentDecl) &&
930 const llvm::APInt &Val) {
934 BitWidth = Val.getBitWidth();
935 unsigned NumWords = Val.getNumWords();
936 const uint64_t* Words = Val.getRawData();
938 pVal =
new (
C) uint64_t[NumWords];
939 std::copy(Words, Words + NumWords,
pVal);
940 }
else if (NumWords == 1)
946IntegerLiteral::IntegerLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
949 assert(
type->isIntegerType() &&
"Illegal type in IntegerLiteral");
950 assert(
V.getBitWidth() ==
C.getIntWidth(
type) &&
951 "Integer type is not the correct size for constant.");
967FixedPointLiteral::FixedPointLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
972 assert(
type->isFixedPointType() &&
"Illegal type in FixedPointLiteral");
973 assert(
V.getBitWidth() ==
C.getTypeInfo(
type).Width &&
974 "Fixed point type is not the correct size for constant.");
980 const llvm::APInt &
V,
998 S, llvm::APSInt::getUnsigned(
getValue().getZExtValue()), Scale);
999 return std::string(S);
1021 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Val);
1022 if (!Escaped.empty()) {
1023 OS <<
"'" << Escaped <<
"'";
1032 OS <<
"'" << (char)Val <<
"'";
1034 OS <<
"'\\x" << llvm::format(
"%02x", Val) <<
"'";
1035 else if (Val <= 0xFFFF)
1036 OS <<
"'\\u" << llvm::format(
"%04x", Val) <<
"'";
1038 OS <<
"'\\U" << llvm::format(
"%08x", Val) <<
"'";
1042FloatingLiteral::FloatingLiteral(
const ASTContext &
C,
const llvm::APFloat &
V,
1045 setSemantics(
V.getSemantics());
1051FloatingLiteral::FloatingLiteral(
const ASTContext &
C, EmptyShell Empty)
1052 :
Expr(FloatingLiteralClass, Empty) {
1053 setRawSemantics(llvm::APFloatBase::S_IEEEhalf);
1074 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
1076 return V.convertToDouble();
1081 unsigned CharByteWidth = 0;
1085 CharByteWidth =
Target.getCharWidth();
1088 CharByteWidth =
Target.getWCharWidth();
1091 CharByteWidth =
Target.getChar16Width();
1094 CharByteWidth =
Target.getChar32Width();
1097 return sizeof(char);
1099 assert((CharByteWidth & 7) == 0 &&
"Assumes character size is byte multiple");
1101 assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&
1102 "The only supported character byte widths are 1,2 and 4!");
1103 return CharByteWidth;
1106StringLiteral::StringLiteral(
const ASTContext &Ctx, StringRef Str,
1109 unsigned NumConcatenated)
1112 unsigned Length = Str.size();
1119 "StringLiteral must be of constant array type!");
1120 unsigned CharByteWidth = mapCharByteWidth(Ctx.
getTargetInfo(), Kind);
1121 unsigned ByteLength = Str.size();
1122 assert((ByteLength % CharByteWidth == 0) &&
1123 "The size of the data must be a multiple of CharByteWidth!");
1128 switch (CharByteWidth) {
1130 Length = ByteLength;
1133 Length = ByteLength / 2;
1136 Length = ByteLength / 4;
1139 llvm_unreachable(
"Unsupported character width!");
1145 assert(!Pascal &&
"Can't make an unevaluated Pascal string");
1150 *getTrailingObjects<unsigned>() = Length;
1154 std::memcpy(getTrailingObjects<SourceLocation>(), Loc,
1158 std::memcpy(getTrailingObjects<char>(), Str.data(), Str.size());
1163StringLiteral::StringLiteral(EmptyShell Empty,
unsigned NumConcatenated,
1164 unsigned Length,
unsigned CharByteWidth)
1165 :
Expr(StringLiteralClass, Empty) {
1168 *getTrailingObjects<unsigned>() = Length;
1174 unsigned NumConcatenated) {
1175 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1176 1, NumConcatenated, Str.size()),
1179 StringLiteral(Ctx, Str, Kind, Pascal, Ty, Loc, NumConcatenated);
1183 unsigned NumConcatenated,
1185 unsigned CharByteWidth) {
1186 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1187 1, NumConcatenated, Length * CharByteWidth),
1212 static const char Hex[] =
"0123456789ABCDEF";
1215 for (
unsigned I = 0, N =
getLength(); I != N; ++I) {
1217 StringRef Escaped = escapeCStyle<EscapeChar::Double>(Char);
1218 if (Escaped.empty()) {
1224 Char >= 0xd800 && Char <= 0xdbff) {
1226 if (Trail >= 0xdc00 && Trail <= 0xdfff) {
1227 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
1237 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
1241 while ((Char >> Shift) == 0)
1243 for (; Shift >= 0; Shift -= 4)
1244 OS << Hex[(Char >> Shift) & 15];
1251 << Hex[(Char >> 20) & 15]
1252 << Hex[(Char >> 16) & 15];
1255 OS << Hex[(Char >> 12) & 15]
1256 << Hex[(Char >> 8) & 15]
1257 << Hex[(Char >> 4) & 15]
1258 << Hex[(Char >> 0) & 15];
1264 if (LastSlashX + 1 == I) {
1266 case '0':
case '1':
case '2':
case '3':
case '4':
1267 case '5':
case '6':
case '7':
case '8':
case '9':
1268 case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
1269 case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
1274 assert(Char <= 0xff &&
1275 "Characters above 0xff should already have been handled.");
1281 << (char)(
'0' + ((Char >> 6) & 7))
1282 << (char)(
'0' + ((Char >> 3) & 7))
1283 << (char)(
'0' + ((Char >> 0) & 7));
1312 unsigned *StartTokenByteOffset)
const {
1316 "Only narrow string literals are currently supported");
1321 unsigned StringOffset = 0;
1323 TokNo = *StartToken;
1324 if (StartTokenByteOffset) {
1325 StringOffset = *StartTokenByteOffset;
1326 ByteNo -= StringOffset;
1338 std::pair<FileID, unsigned> LocInfo =
1339 SM.getDecomposedLoc(StrTokSpellingLoc);
1341 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
1343 if (StartTokenByteOffset !=
nullptr)
1344 *StartTokenByteOffset = StringOffset;
1345 if (StartToken !=
nullptr)
1346 *StartToken = TokNo;
1347 return StrTokSpellingLoc;
1350 const char *StrData = Buffer.data()+LocInfo.second;
1353 Lexer TheLexer(
SM.getLocForStartOfFile(LocInfo.first), Features,
1354 Buffer.begin(), StrData, Buffer.end());
1363 if (ByteNo < TokNumBytes ||
1369 if (StartTokenByteOffset !=
nullptr)
1370 *StartTokenByteOffset = StringOffset;
1371 if (StartToken !=
nullptr)
1372 *StartToken = TokNo;
1377 StringOffset += TokNumBytes;
1379 ByteNo -= TokNumBytes;
1387#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;
1388#include "clang/AST/OperationKinds.def"
1390 llvm_unreachable(
"Unknown unary operator");
1396 default: llvm_unreachable(
"No unary operator for overloaded function");
1397 case OO_PlusPlus:
return Postfix ? UO_PostInc : UO_PreInc;
1398 case OO_MinusMinus:
return Postfix ? UO_PostDec : UO_PreDec;
1399 case OO_Amp:
return UO_AddrOf;
1400 case OO_Star:
return UO_Deref;
1401 case OO_Plus:
return UO_Plus;
1402 case OO_Minus:
return UO_Minus;
1403 case OO_Tilde:
return UO_Not;
1404 case OO_Exclaim:
return UO_LNot;
1405 case OO_Coawait:
return UO_Coawait;
1411 case UO_PostInc:
case UO_PreInc:
return OO_PlusPlus;
1412 case UO_PostDec:
case UO_PreDec:
return OO_MinusMinus;
1413 case UO_AddrOf:
return OO_Amp;
1414 case UO_Deref:
return OO_Star;
1415 case UO_Plus:
return OO_Plus;
1416 case UO_Minus:
return OO_Minus;
1417 case UO_Not:
return OO_Tilde;
1418 case UO_LNot:
return OO_Exclaim;
1419 case UO_Coawait:
return OO_Coawait;
1434 NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1435 unsigned NumPreArgs = PreArgs.size();
1437 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1439 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1440 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1441 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1442 "OffsetToTrailingObjects overflow!");
1447 for (
unsigned I = 0; I != NumPreArgs; ++I)
1449 for (
unsigned I = 0; I != Args.size(); ++I)
1451 for (
unsigned I = Args.size(); I != NumArgs; ++I)
1463 :
Expr(SC, Empty), NumArgs(NumArgs) {
1465 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1467 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1468 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1469 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1470 "OffsetToTrailingObjects overflow!");
1479 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1484 return new (Mem)
CallExpr(CallExprClass, Fn, {}, Args, Ty, VK,
1485 RParenLoc, FPFeatures, MinNumArgs,
UsesADL);
1492 "Misaligned memory in CallExpr::CreateTemporary!");
1493 return new (Mem)
CallExpr(CallExprClass, Fn, {}, {}, Ty,
1500 unsigned SizeOfTrailingObjects =
1505 CallExpr(CallExprClass, 0, NumArgs, HasFPFeatures, Empty);
1508unsigned CallExpr::offsetToTrailingObjects(StmtClass SC) {
1512 case CXXOperatorCallExprClass:
1514 case CXXMemberCallExprClass:
1516 case UserDefinedLiteralClass:
1518 case CUDAKernelCallExprClass:
1521 llvm_unreachable(
"unexpected class deriving from CallExpr!");
1528 while (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE))
1533 if (
auto *BO = dyn_cast<BinaryOperator>(CEE)) {
1534 if (BO->isPtrMemOp()) {
1538 }
else if (
auto *UO = dyn_cast<UnaryOperator>(CEE)) {
1539 if (UO->getOpcode() == UO_Deref || UO->getOpcode() == UO_AddrOf ||
1540 UO->getOpcode() == UO_Plus) {
1548 if (
auto *DRE = dyn_cast<DeclRefExpr>(CEE))
1549 return DRE->getDecl();
1550 if (
auto *ME = dyn_cast<MemberExpr>(CEE))
1551 return ME->getMemberDecl();
1552 if (
auto *BE = dyn_cast<BlockExpr>(CEE))
1553 return BE->getBlockDecl();
1561 return FDecl ? FDecl->getBuiltinID() : 0;
1572 QualType CalleeType = Callee->getType();
1578 if (isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))
1581 if (isa<UnresolvedMemberExpr>(Callee->IgnoreParens()))
1586 assert(!CalleeType.
isNull());
1604 if (
const auto *A = TD->getAttr<WarnUnusedResultAttr>())
1608 TD = TD->desugar()->getAs<TypedefType>())
1609 if (
const auto *A = TD->getDecl()->getAttr<WarnUnusedResultAttr>())
1615 return D ? D->
getAttr<WarnUnusedResultAttr>() :
nullptr;
1619 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
this))
1620 return OCE->getBeginLoc();
1628 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
this))
1629 return OCE->getEndLoc();
1643 void *Mem =
C.Allocate(
1644 totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
1651 unsigned numComps,
unsigned numExprs) {
1653 C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
1662 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1663 NumComps(comps.size()), NumExprs(exprs.size()) {
1664 for (
unsigned i = 0; i != comps.size(); ++i)
1666 for (
unsigned i = 0; i != exprs.size(); ++i)
1684 OpLoc(op), RParenLoc(rp) {
1685 assert(ExprKind <=
UETT_Last &&
"invalid enum value!");
1688 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
1699 :
Expr(MemberExprClass, T, VK, OK),
Base(
Base), MemberDecl(MemberDecl),
1700 MemberDNLoc(NameInfo.
getInfo()), MemberLoc(NameInfo.getLoc()) {
1718 bool HasQualOrFound = QualifierLoc || FoundDecl.getDecl() != MemberDecl ||
1720 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1724 HasQualOrFound ? 1 : 0, HasTemplateKWAndArgsInfo ? 1 : 0,
1725 TemplateArgs ? TemplateArgs->
size() : 0);
1727 void *Mem =
C.Allocate(Size,
alignof(
MemberExpr));
1729 NameInfo, T, VK, OK, NOUR);
1731 if (HasQualOrFound) {
1741 TemplateArgs || TemplateKWLoc.
isValid();
1746 auto TemplateArgDeps = TemplateArgumentDependence::None;
1748 TemplateKWLoc, *TemplateArgs,
1753 }
else if (TemplateKWLoc.
isValid()) {
1763 bool HasQualifier,
bool HasFoundDecl,
1764 bool HasTemplateKWAndArgsInfo,
1765 unsigned NumTemplateArgs) {
1766 assert((!NumTemplateArgs || HasTemplateKWAndArgsInfo) &&
1767 "template args but no template arg info?");
1768 bool HasQualOrFound = HasQualifier || HasFoundDecl;
1772 HasTemplateKWAndArgsInfo ? 1 : 0,
1780 if (
getType()->isUndeducedType())
1796 return BaseStartLoc;
1808bool CastExpr::CastConsistency()
const {
1810 case CK_DerivedToBase:
1811 case CK_UncheckedDerivedToBase:
1812 case CK_DerivedToBaseMemberPointer:
1813 case CK_BaseToDerived:
1814 case CK_BaseToDerivedMemberPointer:
1815 assert(!
path_empty() &&
"Cast kind should have a base path!");
1818 case CK_CPointerToObjCPointerCast:
1819 assert(
getType()->isObjCObjectPointerType());
1821 goto CheckNoBasePath;
1823 case CK_BlockPointerToObjCPointerCast:
1824 assert(
getType()->isObjCObjectPointerType());
1826 goto CheckNoBasePath;
1828 case CK_ReinterpretMemberPointer:
1829 assert(
getType()->isMemberPointerType());
1831 goto CheckNoBasePath;
1837 if (!
getType()->isPointerType()) {
1838 assert(
getType()->isObjCObjectPointerType() ==
1840 assert(
getType()->isBlockPointerType() ==
1843 goto CheckNoBasePath;
1845 case CK_AnyPointerToBlockPointerCast:
1846 assert(
getType()->isBlockPointerType());
1849 goto CheckNoBasePath;
1851 case CK_CopyAndAutoreleaseBlockObject:
1852 assert(
getType()->isBlockPointerType());
1854 goto CheckNoBasePath;
1856 case CK_FunctionToPointerDecay:
1857 assert(
getType()->isPointerType());
1859 goto CheckNoBasePath;
1861 case CK_AddressSpaceConversion: {
1870 (!Ty.
isNull() && !SETy.isNull() &&
1872 goto CheckNoBasePath;
1877 case CK_ArrayToPointerDecay:
1878 case CK_NullToMemberPointer:
1879 case CK_NullToPointer:
1880 case CK_ConstructorConversion:
1881 case CK_IntegralToPointer:
1882 case CK_PointerToIntegral:
1884 case CK_VectorSplat:
1885 case CK_IntegralCast:
1886 case CK_BooleanToSignedIntegral:
1887 case CK_IntegralToFloating:
1888 case CK_FloatingToIntegral:
1889 case CK_FloatingCast:
1890 case CK_ObjCObjectLValueCast:
1891 case CK_FloatingRealToComplex:
1892 case CK_FloatingComplexToReal:
1893 case CK_FloatingComplexCast:
1894 case CK_FloatingComplexToIntegralComplex:
1895 case CK_IntegralRealToComplex:
1896 case CK_IntegralComplexToReal:
1897 case CK_IntegralComplexCast:
1898 case CK_IntegralComplexToFloatingComplex:
1899 case CK_ARCProduceObject:
1900 case CK_ARCConsumeObject:
1901 case CK_ARCReclaimReturnedObject:
1902 case CK_ARCExtendBlockObject:
1903 case CK_ZeroToOCLOpaqueType:
1904 case CK_IntToOCLSampler:
1905 case CK_FloatingToFixedPoint:
1906 case CK_FixedPointToFloating:
1907 case CK_FixedPointCast:
1908 case CK_FixedPointToIntegral:
1909 case CK_IntegralToFixedPoint:
1911 case CK_HLSLVectorTruncation:
1913 goto CheckNoBasePath;
1916 case CK_LValueToRValue:
1918 case CK_AtomicToNonAtomic:
1919 case CK_NonAtomicToAtomic:
1920 case CK_PointerToBoolean:
1921 case CK_IntegralToBoolean:
1922 case CK_FloatingToBoolean:
1923 case CK_MemberPointerToBoolean:
1924 case CK_FloatingComplexToBoolean:
1925 case CK_IntegralComplexToBoolean:
1926 case CK_LValueBitCast:
1927 case CK_LValueToRValueBitCast:
1928 case CK_UserDefinedConversion:
1929 case CK_BuiltinFnToFnPtr:
1930 case CK_FixedPointToBoolean:
1932 assert(
path_empty() &&
"Cast kind should not have a base path!");
1940#define CAST_OPERATION(Name) case CK_##Name: return #Name;
1941#include "clang/AST/OperationKinds.def"
1943 llvm_unreachable(
"Unhandled cast kind!");
1949static Expr *ignoreImplicitSemaNodes(
Expr *E) {
1950 if (
auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E))
1951 return Materialize->getSubExpr();
1953 if (
auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
1954 return Binder->getSubExpr();
1956 if (
auto *Full = dyn_cast<FullExpr>(E))
1957 return Full->getSubExpr();
1959 if (
auto *CPLIE = dyn_cast<CXXParenListInitExpr>(E);
1960 CPLIE && CPLIE->getInitExprs().size() == 1)
1961 return CPLIE->getInitExprs()[0];
1968 const Expr *SubExpr =
nullptr;
1970 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
1975 if (E->getCastKind() == CK_ConstructorConversion) {
1977 ignoreImplicitSemaNodes);
1978 }
else if (E->getCastKind() == CK_UserDefinedConversion) {
1979 assert((isa<CXXMemberCallExpr>(SubExpr) || isa<BlockExpr>(SubExpr)) &&
1980 "Unexpected SubExpr for CK_UserDefinedConversion.");
1981 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
1982 SubExpr = MCE->getImplicitObjectArgument();
1986 return const_cast<Expr *
>(SubExpr);
1990 const Expr *SubExpr =
nullptr;
1992 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
1995 if (E->getCastKind() == CK_ConstructorConversion)
1996 return cast<CXXConstructExpr>(SubExpr)->getConstructor();
1998 if (E->getCastKind() == CK_UserDefinedConversion) {
1999 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
2000 return MCE->getMethodDecl();
2009#define ABSTRACT_STMT(x)
2010#define CASTEXPR(Type, Base) \
2011 case Stmt::Type##Class: \
2012 return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>();
2013#define STMT(Type, Base)
2014#include "clang/AST/StmtNodes.inc"
2016 llvm_unreachable(
"non-cast expressions not possible here");
2031 Field != FieldEnd; ++Field) {
2033 !Field->isUnnamedBitfield()) {
2043 case ImplicitCastExprClass:
2045 ->getTrailingObjects<FPOptionsOverride>();
2046 case CStyleCastExprClass:
2048 ->getTrailingObjects<FPOptionsOverride>();
2049 case CXXFunctionalCastExprClass:
2051 ->getTrailingObjects<FPOptionsOverride>();
2052 case CXXStaticCastExprClass:
2054 ->getTrailingObjects<FPOptionsOverride>();
2056 llvm_unreachable(
"Cast does not have FPFeatures");
2065 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2067 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2071 assert((Kind != CK_LValueToRValue ||
2073 "invalid type for lvalue-to-rvalue conversion");
2077 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2084 bool HasFPFeatures) {
2086 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2087 PathSize, HasFPFeatures));
2097 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2099 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2102 new (Buffer)
CStyleCastExpr(T, VK, K, Op, PathSize, FPO, WrittenTy, L, R);
2104 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2111 bool HasFPFeatures) {
2113 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2114 PathSize, HasFPFeatures));
2122#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;
2123#include "clang/AST/OperationKinds.def"
2125 llvm_unreachable(
"Invalid OpCode!");
2131 default: llvm_unreachable(
"Not an overloadable binary operator");
2132 case OO_Plus:
return BO_Add;
2133 case OO_Minus:
return BO_Sub;
2134 case OO_Star:
return BO_Mul;
2135 case OO_Slash:
return BO_Div;
2136 case OO_Percent:
return BO_Rem;
2137 case OO_Caret:
return BO_Xor;
2138 case OO_Amp:
return BO_And;
2139 case OO_Pipe:
return BO_Or;
2140 case OO_Equal:
return BO_Assign;
2141 case OO_Spaceship:
return BO_Cmp;
2142 case OO_Less:
return BO_LT;
2143 case OO_Greater:
return BO_GT;
2144 case OO_PlusEqual:
return BO_AddAssign;
2145 case OO_MinusEqual:
return BO_SubAssign;
2146 case OO_StarEqual:
return BO_MulAssign;
2147 case OO_SlashEqual:
return BO_DivAssign;
2148 case OO_PercentEqual:
return BO_RemAssign;
2149 case OO_CaretEqual:
return BO_XorAssign;
2150 case OO_AmpEqual:
return BO_AndAssign;
2151 case OO_PipeEqual:
return BO_OrAssign;
2152 case OO_LessLess:
return BO_Shl;
2153 case OO_GreaterGreater:
return BO_Shr;
2154 case OO_LessLessEqual:
return BO_ShlAssign;
2155 case OO_GreaterGreaterEqual:
return BO_ShrAssign;
2156 case OO_EqualEqual:
return BO_EQ;
2157 case OO_ExclaimEqual:
return BO_NE;
2158 case OO_LessEqual:
return BO_LE;
2159 case OO_GreaterEqual:
return BO_GE;
2160 case OO_AmpAmp:
return BO_LAnd;
2161 case OO_PipePipe:
return BO_LOr;
2162 case OO_Comma:
return BO_Comma;
2163 case OO_ArrowStar:
return BO_PtrMemI;
2170 OO_Star, OO_Slash, OO_Percent,
2172 OO_LessLess, OO_GreaterGreater,
2174 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
2175 OO_EqualEqual, OO_ExclaimEqual,
2181 OO_Equal, OO_StarEqual,
2182 OO_SlashEqual, OO_PercentEqual,
2183 OO_PlusEqual, OO_MinusEqual,
2184 OO_LessLessEqual, OO_GreaterGreaterEqual,
2185 OO_AmpEqual, OO_CaretEqual,
2189 return OverOps[Opc];
2231 BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {
2235 ? ExprDependence::Value
2236 : ExprDependence::None);
2242 return "__builtin_FILE";
2244 return "__builtin_FILE_NAME";
2246 return "__builtin_FUNCTION";
2248 return "__builtin_FUNCSIG";
2250 return "__builtin_LINE";
2252 return "__builtin_COLUMN";
2254 return "__builtin_source_location";
2256 llvm_unreachable(
"unexpected IdentKind!");
2260 const Expr *DefaultExpr)
const {
2264 if (
const auto *DIE = dyn_cast_if_present<CXXDefaultInitExpr>(DefaultExpr)) {
2265 Loc = DIE->getUsedLocation();
2266 Context = DIE->getUsedContext();
2267 }
else if (
const auto *DAE =
2268 dyn_cast_if_present<CXXDefaultArgExpr>(DefaultExpr)) {
2269 Loc = DAE->getUsedLocation();
2270 Context = DAE->getUsedContext();
2279 auto MakeStringLiteral = [&](StringRef Tmp) {
2283 LValuePathEntry Path[1] = {LValuePathEntry::ArrayIndex(0)};
2294 return MakeStringLiteral(
FileName);
2300 return MakeStringLiteral(Path);
2304 const auto *CurDecl = dyn_cast<Decl>(Context);
2308 return MakeStringLiteral(
2328 StringRef Name = F->getName();
2329 if (Name ==
"_M_file_name") {
2333 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(Path);
2334 }
else if (Name ==
"_M_function_name") {
2337 const auto *CurDecl = dyn_cast<Decl>(Context);
2338 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(
2339 CurDecl && !isa<TranslationUnitDecl>(CurDecl)
2343 }
else if (Name ==
"_M_line") {
2345 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2346 }
else if (Name ==
"_M_column") {
2348 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2359 llvm_unreachable(
"unhandled case");
2365 InitExprs(
C, initExprs.size()), LBraceLoc(lbraceloc),
2366 RBraceLoc(rbraceloc), AltForm(nullptr,
true) {
2368 InitExprs.
insert(
C, InitExprs.
end(), initExprs.begin(), initExprs.end());
2374 if (NumInits > InitExprs.
size())
2379 InitExprs.
resize(
C, NumInits,
nullptr);
2396 ArrayFillerOrUnionFieldInit = filler;
2399 for (
unsigned i = 0, e =
getNumInits(); i != e; ++i)
2400 if (
inits[i] ==
nullptr)
2414 Init =
Init->IgnoreParenImpCasts();
2415 return isa<StringLiteral>(
Init) || isa<ObjCEncodeExpr>(
Init);
2419 assert(
isSemanticForm() &&
"syntactic form never semantically transparent");
2423 assert(
getNumInits() == 1 &&
"multiple inits in glvalue init list");
2442 assert(
isSyntacticForm() &&
"only test syntactic form as zero initializer");
2449 return Lit && Lit->
getValue() == 0;
2454 return SyntacticForm->getBeginLoc();
2459 E = InitExprs.
end();
2462 Beg = S->getBeginLoc();
2472 return SyntacticForm->getEndLoc();
2474 if (End.isInvalid()) {
2476 for (
Stmt *S : llvm::reverse(InitExprs)) {
2478 End = S->getEndLoc();
2490 return cast<BlockPointerType>(
getType())
2521 if (isa<DeclRefExpr>(E))
2525 if (isa<ArraySubscriptExpr>(E))
2529 if (isa<MemberExpr>(E))
2533 if (
auto *UO = dyn_cast<UnaryOperator>(E))
2534 if (UO->getOpcode() == UO_Deref)
2537 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
2539 if (BO->isPtrMemOp())
2543 if (BO->getOpcode() == BO_Comma)
2544 return BO->getRHS()->isReadIfDiscardedInCPlusPlus11();
2549 if (
auto *CO = dyn_cast<ConditionalOperator>(E))
2550 return CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&
2551 CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2554 dyn_cast<BinaryConditionalOperator>(E)) {
2555 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
2556 return OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&
2557 BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2561 if (isa<ObjCIvarRefExpr>(E))
2563 if (
const auto *POE = dyn_cast<PseudoObjectExpr>(E)) {
2564 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(POE->getSyntacticForm()))
2591 case ParenExprClass:
2592 return cast<ParenExpr>(
this)->getSubExpr()->
2594 case GenericSelectionExprClass:
2595 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
2597 case CoawaitExprClass:
2598 case CoyieldExprClass:
2599 return cast<CoroutineSuspendExpr>(
this)->getResumeExpr()->
2601 case ChooseExprClass:
2602 return cast<ChooseExpr>(
this)->getChosenSubExpr()->
2604 case UnaryOperatorClass: {
2638 case BinaryOperatorClass: {
2650 if (IE->getValue() == 0)
2669 case CompoundAssignOperatorClass:
2670 case VAArgExprClass:
2671 case AtomicExprClass:
2674 case ConditionalOperatorClass: {
2678 const auto *Exp = cast<ConditionalOperator>(
this);
2679 return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) &&
2680 Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2682 case BinaryConditionalOperatorClass: {
2683 const auto *Exp = cast<BinaryConditionalOperator>(
this);
2684 return Exp->getFalseExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2687 case MemberExprClass:
2689 Loc = cast<MemberExpr>(
this)->getMemberLoc();
2691 R2 = cast<MemberExpr>(
this)->getBase()->getSourceRange();
2694 case ArraySubscriptExprClass:
2696 Loc = cast<ArraySubscriptExpr>(
this)->getRBracketLoc();
2697 R1 = cast<ArraySubscriptExpr>(
this)->getLHS()->getSourceRange();
2698 R2 = cast<ArraySubscriptExpr>(
this)->getRHS()->getSourceRange();
2701 case CXXOperatorCallExprClass: {
2713 case OO_ExclaimEqual:
2716 case OO_GreaterEqual:
2731 case CXXMemberCallExprClass:
2732 case UserDefinedLiteralClass: {
2734 const CallExpr *CE = cast<CallExpr>(
this);
2742 FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {
2757 case UnresolvedLookupExprClass:
2758 case CXXUnresolvedConstructExprClass:
2759 case RecoveryExprClass:
2762 case CXXTemporaryObjectExprClass:
2763 case CXXConstructExprClass: {
2765 const auto *WarnURAttr =
Type->getAttr<WarnUnusedResultAttr>();
2767 (WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {
2775 const auto *CE = cast<CXXConstructExpr>(
this);
2777 const auto *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
2778 if (WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {
2783 if (
unsigned NumArgs = CE->getNumArgs())
2785 CE->getArg(NumArgs - 1)->getEndLoc());
2793 case ObjCMessageExprClass: {
2806 if (MD->hasAttr<WarnUnusedResultAttr>()) {
2815 case ObjCPropertyRefExprClass:
2816 case ObjCSubscriptRefExprClass:
2822 case PseudoObjectExprClass: {
2823 const auto *POE = cast<PseudoObjectExpr>(
this);
2826 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(
2827 POE->getSyntacticForm())) {
2835 if (
auto *BO = dyn_cast<BinaryOperator>(POE->getSyntacticForm()))
2836 if (BO->isAssignmentOp())
2838 if (
auto *UO = dyn_cast<UnaryOperator>(POE->getSyntacticForm()))
2839 if (UO->isIncrementDecrementOp())
2844 return Result &&
Result->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2847 case StmtExprClass: {
2853 const CompoundStmt *CS = cast<StmtExpr>(
this)->getSubStmt();
2858 if (
const Expr *E = dyn_cast<Expr>(
Label->getSubStmt()))
2865 Loc = cast<StmtExpr>(
this)->getLParenLoc();
2869 case CXXFunctionalCastExprClass:
2870 case CStyleCastExprClass: {
2877 const CastExpr *CE = cast<CastExpr>(
this);
2884 if (
auto *DRE = dyn_cast<DeclRefExpr>(SubE))
2885 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
2886 if (!VD->isExternallyVisible())
2902 if (CE->
getCastKind() == CK_ConstructorConversion)
2909 dyn_cast<CXXFunctionalCastExpr>(
this)) {
2910 Loc = CXXCE->getBeginLoc();
2911 R1 = CXXCE->getSubExpr()->getSourceRange();
2919 case ImplicitCastExprClass: {
2920 const CastExpr *ICE = cast<ImplicitCastExpr>(
this);
2929 case CXXDefaultArgExprClass:
2930 return (cast<CXXDefaultArgExpr>(
this)
2932 case CXXDefaultInitExprClass:
2933 return (cast<CXXDefaultInitExpr>(
this)
2936 case CXXNewExprClass:
2939 case CXXDeleteExprClass:
2941 case MaterializeTemporaryExprClass:
2942 return cast<MaterializeTemporaryExpr>(
this)
2944 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2945 case CXXBindTemporaryExprClass:
2946 return cast<CXXBindTemporaryExpr>(
this)->getSubExpr()
2947 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2948 case ExprWithCleanupsClass:
2949 return cast<ExprWithCleanups>(
this)->getSubExpr()
2950 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2961 case ObjCIvarRefExprClass:
2963 case Expr::UnaryOperatorClass:
2964 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2965 case ImplicitCastExprClass:
2966 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2967 case MaterializeTemporaryExprClass:
2968 return cast<MaterializeTemporaryExpr>(E)->getSubExpr()->isOBJCGCCandidate(
2970 case CStyleCastExprClass:
2971 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2972 case DeclRefExprClass: {
2973 const Decl *D = cast<DeclRefExpr>(E)->getDecl();
2975 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2976 if (VD->hasGlobalStorage())
2986 case MemberExprClass: {
2990 case ArraySubscriptExprClass:
2991 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
3002 assert(
expr->hasPlaceholderType(BuiltinType::BoundMember));
3010 assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
3011 return mem->getMemberDecl()->getType();
3017 assert(
type->isFunctionType());
3021 assert(isa<UnresolvedMemberExpr>(
expr) || isa<CXXPseudoDestructorExpr>(
expr));
3055 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
this)) {
3056 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
3057 return MCE->getImplicitObjectArgument();
3073 auto IgnoreNoopCastsSingleStep = [&Ctx](
Expr *E) {
3074 if (
auto *CE = dyn_cast<CastExpr>(E)) {
3077 Expr *SubExpr = CE->getSubExpr();
3078 bool IsIdentityCast =
3087 if (IsIdentityCast || IsSameWidthCast)
3089 }
else if (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
3090 return NTTP->getReplacement();
3095 IgnoreNoopCastsSingleStep);
3100 if (
auto *Cast = dyn_cast<CXXFunctionalCastExpr>(E)) {
3101 auto *SE = Cast->getSubExpr();
3106 if (
auto *
C = dyn_cast<CXXConstructExpr>(E)) {
3107 auto NumArgs =
C->getNumArgs();
3109 (NumArgs > 1 && isa<CXXDefaultArgExpr>(
C->getArg(1)))) {
3110 Expr *A =
C->getArg(0);
3117 auto IgnoreImplicitMemberCallSingleStep = [](
Expr *E) {
3118 if (
auto *
C = dyn_cast<CXXMemberCallExpr>(E)) {
3119 Expr *ExprNode =
C->getImplicitObjectArgument();
3123 if (
auto *PE = dyn_cast<ParenExpr>(ExprNode)) {
3124 if (PE->getSourceRange() ==
C->getSourceRange()) {
3125 return cast<Expr>(PE);
3137 IgnoreImplicitMemberCallSingleStep);
3141 const Expr *E =
this;
3143 E = M->getSubExpr();
3146 E = ICE->getSubExprAsWritten();
3148 return isa<CXXDefaultArgExpr>(E);
3155 E = M->getSubExpr();
3158 if (ICE->getCastKind() == CK_NoOp)
3159 E = ICE->getSubExpr();
3165 E = BE->getSubExpr();
3168 if (ICE->getCastKind() == CK_NoOp)
3169 E = ICE->getSubExpr();
3180 if (!
C.hasSameUnqualifiedType(
getType(),
C.getTypeDeclType(TempTy)))
3188 if (!isa<ObjCPropertyRefExpr>(E))
3196 if (isa<ImplicitCastExpr>(E)) {
3197 switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
3198 case CK_DerivedToBase:
3199 case CK_UncheckedDerivedToBase:
3207 if (isa<MemberExpr>(E))
3211 if (BO->isPtrMemOp())
3215 if (isa<OpaqueValueExpr>(E))
3222 const Expr *E =
this;
3227 E =
Paren->getSubExpr();
3232 if (ICE->getCastKind() == CK_NoOp ||
3233 ICE->getCastKind() == CK_LValueToRValue ||
3234 ICE->getCastKind() == CK_DerivedToBase ||
3235 ICE->getCastKind() == CK_UncheckedDerivedToBase) {
3236 E = ICE->getSubExpr();
3241 if (
const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
3242 if (UnOp->getOpcode() == UO_Extension) {
3243 E = UnOp->getSubExpr();
3249 = dyn_cast<MaterializeTemporaryExpr>(E)) {
3250 E = M->getSubExpr();
3257 if (
const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
3258 return This->isImplicit();
3266 for (
unsigned I = 0; I < Exprs.size(); ++I)
3274 const Expr **Culprit)
const {
3276 "Expression evaluator can't be called on a dependent expression.");
3288 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
this))
3289 return EWC->getSubExpr()->isConstantInitializer(Ctx,
true, Culprit);
3290 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
this))
3291 return MTE->getSubExpr()->isConstantInitializer(Ctx,
false, Culprit);
3302 case Stmt::ExprWithCleanupsClass:
3304 Ctx, IsForRef, Culprit);
3305 case StringLiteralClass:
3306 case ObjCEncodeExprClass:
3308 case CXXTemporaryObjectExprClass:
3309 case CXXConstructExprClass: {
3318 assert(CE->
getNumArgs() == 1 &&
"trivial ctor with > 1 argument");
3324 case ConstantExprClass: {
3327 const Expr *Exp = cast<ConstantExpr>(
this)->getSubExpr();
3330 case CompoundLiteralExprClass: {
3334 const Expr *Exp = cast<CompoundLiteralExpr>(
this)->getInitializer();
3337 case DesignatedInitUpdateExprClass: {
3342 case InitListExprClass: {
3350 assert(ILE->
isSemanticForm() &&
"InitListExpr must be in semantic form");
3353 for (
unsigned i = 0; i < numInits; i++) {
3361 unsigned ElementNo = 0;
3366 if (
const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD)) {
3367 for (
unsigned i = 0, e = CXXRD->getNumBases(); i < e; i++) {
3368 if (ElementNo < ILE->getNumInits()) {
3376 for (
const auto *Field : RD->
fields()) {
3382 if (Field->isUnnamedBitfield())
3385 if (ElementNo < ILE->getNumInits()) {
3387 if (Field->isBitField()) {
3396 bool RefType = Field->getType()->isReferenceType();
3407 case ImplicitValueInitExprClass:
3408 case NoInitExprClass:
3410 case ParenExprClass:
3411 return cast<ParenExpr>(
this)->getSubExpr()
3412 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3413 case GenericSelectionExprClass:
3414 return cast<GenericSelectionExpr>(
this)->getResultExpr()
3415 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3416 case ChooseExprClass:
3417 if (cast<ChooseExpr>(
this)->isConditionDependent()) {
3422 return cast<ChooseExpr>(
this)->getChosenSubExpr()
3424 case UnaryOperatorClass: {
3430 case PackIndexingExprClass: {
3431 return cast<PackIndexingExpr>(
this)
3433 ->isConstantInitializer(Ctx,
false, Culprit);
3435 case CXXFunctionalCastExprClass:
3436 case CXXStaticCastExprClass:
3437 case ImplicitCastExprClass:
3438 case CStyleCastExprClass:
3439 case ObjCBridgedCastExprClass:
3440 case CXXDynamicCastExprClass:
3441 case CXXReinterpretCastExprClass:
3442 case CXXAddrspaceCastExprClass:
3443 case CXXConstCastExprClass: {
3444 const CastExpr *CE = cast<CastExpr>(
this);
3459 case MaterializeTemporaryExprClass:
3460 return cast<MaterializeTemporaryExpr>(
this)
3462 ->isConstantInitializer(Ctx,
false, Culprit);
3464 case SubstNonTypeTemplateParmExprClass:
3465 return cast<SubstNonTypeTemplateParmExpr>(
this)->getReplacement()
3466 ->isConstantInitializer(Ctx,
false, Culprit);
3467 case CXXDefaultArgExprClass:
3468 return cast<CXXDefaultArgExpr>(
this)->getExpr()
3469 ->isConstantInitializer(Ctx,
false, Culprit);
3470 case CXXDefaultInitExprClass:
3471 return cast<CXXDefaultInitExpr>(
this)->getExpr()
3472 ->isConstantInitializer(Ctx,
false, Culprit);
3486 if (BuiltinID != Builtin::BI__assume &&
3487 BuiltinID != Builtin::BI__builtin_assume)
3504 const bool IncludePossibleEffects;
3505 bool HasSideEffects;
3508 explicit SideEffectFinder(
const ASTContext &Context,
bool IncludePossible)
3509 : Inherited(Context),
3510 IncludePossibleEffects(IncludePossible), HasSideEffects(
false) { }
3512 bool hasSideEffects()
const {
return HasSideEffects; }
3514 void VisitDecl(
const Decl *D) {
3520 if (
auto *VD = dyn_cast<VarDecl>(D)) {
3522 if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&
3523 VD->needsDestruction(Context))
3524 HasSideEffects =
true;
3528 void VisitDeclStmt(
const DeclStmt *DS) {
3529 for (
auto *D : DS->
decls())
3531 Inherited::VisitDeclStmt(DS);
3534 void VisitExpr(
const Expr *E) {
3535 if (!HasSideEffects &&
3537 HasSideEffects =
true;
3543 bool IncludePossibleEffects)
const {
3547 if (!IncludePossibleEffects &&
getExprLoc().isMacroID())
3552 #define ABSTRACT_STMT(Type)
3553 #define STMT(Type, Base) case Type##Class:
3554 #define EXPR(Type, Base)
3555 #include "clang/AST/StmtNodes.inc"
3556 llvm_unreachable(
"unexpected Expr kind");
3558 case DependentScopeDeclRefExprClass:
3559 case CXXUnresolvedConstructExprClass:
3560 case CXXDependentScopeMemberExprClass:
3561 case UnresolvedLookupExprClass:
3562 case UnresolvedMemberExprClass:
3563 case PackExpansionExprClass:
3564 case SubstNonTypeTemplateParmPackExprClass:
3565 case FunctionParmPackExprClass:
3567 case RecoveryExprClass:
3568 case CXXFoldExprClass:
3570 return IncludePossibleEffects;
3572 case DeclRefExprClass:
3573 case ObjCIvarRefExprClass:
3574 case PredefinedExprClass:
3575 case IntegerLiteralClass:
3576 case FixedPointLiteralClass:
3577 case FloatingLiteralClass:
3578 case ImaginaryLiteralClass:
3579 case StringLiteralClass:
3580 case CharacterLiteralClass:
3581 case OffsetOfExprClass:
3582 case ImplicitValueInitExprClass:
3583 case UnaryExprOrTypeTraitExprClass:
3584 case AddrLabelExprClass:
3585 case GNUNullExprClass:
3586 case ArrayInitIndexExprClass:
3587 case NoInitExprClass:
3588 case CXXBoolLiteralExprClass:
3589 case CXXNullPtrLiteralExprClass:
3590 case CXXThisExprClass:
3591 case CXXScalarValueInitExprClass:
3592 case TypeTraitExprClass:
3593 case ArrayTypeTraitExprClass:
3594 case ExpressionTraitExprClass:
3595 case CXXNoexceptExprClass:
3596 case SizeOfPackExprClass:
3597 case ObjCStringLiteralClass:
3598 case ObjCEncodeExprClass:
3599 case ObjCBoolLiteralExprClass:
3600 case ObjCAvailabilityCheckExprClass:
3601 case CXXUuidofExprClass:
3602 case OpaqueValueExprClass:
3603 case SourceLocExprClass:
3604 case ConceptSpecializationExprClass:
3605 case RequiresExprClass:
3606 case SYCLUniqueStableNameExprClass:
3610 case PackIndexingExprClass:
3611 return cast<PackIndexingExpr>(
this)->getSelectedExpr()->HasSideEffects(
3612 Ctx, IncludePossibleEffects);
3613 case ConstantExprClass:
3615 return cast<ConstantExpr>(
this)->getSubExpr()->HasSideEffects(
3616 Ctx, IncludePossibleEffects);
3619 case CXXOperatorCallExprClass:
3620 case CXXMemberCallExprClass:
3621 case CUDAKernelCallExprClass:
3622 case UserDefinedLiteralClass: {
3626 const Decl *FD = cast<CallExpr>(
this)->getCalleeDecl();
3627 bool IsPure = FD && (FD->
hasAttr<ConstAttr>() || FD->
hasAttr<PureAttr>());
3628 if (IsPure || !IncludePossibleEffects)
3633 case BlockExprClass:
3634 case CXXBindTemporaryExprClass:
3635 if (!IncludePossibleEffects)
3639 case MSPropertyRefExprClass:
3640 case MSPropertySubscriptExprClass:
3641 case CompoundAssignOperatorClass:
3642 case VAArgExprClass:
3643 case AtomicExprClass:
3644 case CXXThrowExprClass:
3645 case CXXNewExprClass:
3646 case CXXDeleteExprClass:
3647 case CoawaitExprClass:
3648 case DependentCoawaitExprClass:
3649 case CoyieldExprClass:
3653 case StmtExprClass: {
3655 SideEffectFinder Finder(Ctx, IncludePossibleEffects);
3656 Finder.Visit(cast<StmtExpr>(
this)->getSubStmt());
3657 return Finder.hasSideEffects();
3660 case ExprWithCleanupsClass:
3661 if (IncludePossibleEffects)
3662 if (cast<ExprWithCleanups>(
this)->cleanupsHaveSideEffects())
3666 case ParenExprClass:
3667 case ArraySubscriptExprClass:
3668 case MatrixSubscriptExprClass:
3669 case OMPArraySectionExprClass:
3670 case OMPArrayShapingExprClass:
3671 case OMPIteratorExprClass:
3672 case MemberExprClass:
3673 case ConditionalOperatorClass:
3674 case BinaryConditionalOperatorClass:
3675 case CompoundLiteralExprClass:
3676 case ExtVectorElementExprClass:
3677 case DesignatedInitExprClass:
3678 case DesignatedInitUpdateExprClass:
3679 case ArrayInitLoopExprClass:
3680 case ParenListExprClass:
3681 case CXXPseudoDestructorExprClass:
3682 case CXXRewrittenBinaryOperatorClass:
3683 case CXXStdInitializerListExprClass:
3684 case SubstNonTypeTemplateParmExprClass:
3685 case MaterializeTemporaryExprClass:
3686 case ShuffleVectorExprClass:
3687 case ConvertVectorExprClass:
3688 case AsTypeExprClass:
3689 case CXXParenListInitExprClass:
3693 case UnaryOperatorClass:
3694 if (cast<UnaryOperator>(
this)->isIncrementDecrementOp())
3698 case BinaryOperatorClass:
3699 if (cast<BinaryOperator>(
this)->isAssignmentOp())
3703 case InitListExprClass:
3705 if (
const Expr *E = cast<InitListExpr>(
this)->getArrayFiller())
3710 case GenericSelectionExprClass:
3711 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
3714 case ChooseExprClass:
3715 return cast<ChooseExpr>(
this)->getChosenSubExpr()->HasSideEffects(
3716 Ctx, IncludePossibleEffects);
3718 case CXXDefaultArgExprClass:
3719 return cast<CXXDefaultArgExpr>(
this)->getExpr()->HasSideEffects(
3720 Ctx, IncludePossibleEffects);
3722 case CXXDefaultInitExprClass: {
3723 const FieldDecl *FD = cast<CXXDefaultInitExpr>(
this)->getField();
3730 case CXXDynamicCastExprClass: {
3738 case ImplicitCastExprClass:
3739 case CStyleCastExprClass:
3740 case CXXStaticCastExprClass:
3741 case CXXReinterpretCastExprClass:
3742 case CXXConstCastExprClass:
3743 case CXXAddrspaceCastExprClass:
3744 case CXXFunctionalCastExprClass:
3745 case BuiltinBitCastExprClass: {
3750 if (!IncludePossibleEffects)
3753 const CastExpr *CE = cast<CastExpr>(
this);
3760 case CXXTypeidExprClass:
3763 return cast<CXXTypeidExpr>(
this)->isPotentiallyEvaluated();
3765 case CXXConstructExprClass:
3766 case CXXTemporaryObjectExprClass: {
3775 case CXXInheritedCtorInitExprClass: {
3776 const auto *ICIE = cast<CXXInheritedCtorInitExpr>(
this);
3777 if (!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)
3782 case LambdaExprClass: {
3783 const LambdaExpr *LE = cast<LambdaExpr>(
this);
3784 for (
Expr *E : LE->capture_inits())
3790 case PseudoObjectExprClass: {
3797 const Expr *Subexpr = *I;
3799 Subexpr = OVE->getSourceExpr();
3806 case ObjCBoxedExprClass:
3807 case ObjCArrayLiteralClass:
3808 case ObjCDictionaryLiteralClass:
3809 case ObjCSelectorExprClass:
3810 case ObjCProtocolExprClass:
3811 case ObjCIsaExprClass:
3812 case ObjCIndirectCopyRestoreExprClass:
3813 case ObjCSubscriptRefExprClass:
3814 case ObjCBridgedCastExprClass:
3815 case ObjCMessageExprClass:
3816 case ObjCPropertyRefExprClass:
3818 if (IncludePossibleEffects)
3826 cast<Expr>(SubStmt)->
HasSideEffects(Ctx, IncludePossibleEffects))
3833 if (
auto Call = dyn_cast<CallExpr>(
this))
3834 return Call->getFPFeaturesInEffect(LO);
3835 if (
auto UO = dyn_cast<UnaryOperator>(
this))
3836 return UO->getFPFeaturesInEffect(LO);
3837 if (
auto BO = dyn_cast<BinaryOperator>(
this))
3838 return BO->getFPFeaturesInEffect(LO);
3839 if (
auto Cast = dyn_cast<CastExpr>(
this))
3840 return Cast->getFPFeaturesInEffect(LO);
3853 explicit NonTrivialCallFinder(
const ASTContext &Context)
3854 : Inherited(Context), NonTrivial(
false) { }
3856 bool hasNonTrivialCall()
const {
return NonTrivial; }
3858 void VisitCallExpr(
const CallExpr *E) {
3860 = dyn_cast_or_null<const CXXMethodDecl>(E->
getCalleeDecl())) {
3861 if (Method->isTrivial()) {
3863 Inherited::VisitStmt(E);
3874 Inherited::VisitStmt(E);
3883 Inherited::VisitStmt(E);
3893 NonTrivialCallFinder Finder(Ctx);
3895 return Finder.hasNonTrivialCall();
3913 llvm_unreachable(
"Unexpected value dependent expression!");
3941 CE->getSubExpr()->getType()->isIntegerType())
3942 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3945 }
else if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(
this)) {
3947 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3948 }
else if (
const ParenExpr *PE = dyn_cast<ParenExpr>(
this)) {
3951 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3953 dyn_cast<GenericSelectionExpr>(
this)) {
3954 if (GE->isResultDependent())
3956 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
3957 }
else if (
const ChooseExpr *CE = dyn_cast<ChooseExpr>(
this)) {
3958 if (CE->isConditionDependent())
3960 return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);
3962 = dyn_cast<CXXDefaultArgExpr>(
this)) {
3964 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
3966 = dyn_cast<CXXDefaultInitExpr>(
this)) {
3968 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
3969 }
else if (isa<GNUNullExpr>(
this)) {
3973 = dyn_cast<MaterializeTemporaryExpr>(
this)) {
3974 return M->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3975 }
else if (
const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(
this)) {
3976 if (
const Expr *Source = OVE->getSourceExpr())
3977 return Source->isNullPointerConstant(Ctx, NPC);
3986 if (
getType()->isNullPtrType())
3991 UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
3993 const Expr *InitExpr = CLE->getInitializer();
3994 if (
const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
3998 if (!
getType()->isIntegerType() ||
4021 if (isa<IntegerLiteral>(
this))
4029 const Expr *E =
this;
4032 "expression is not a property reference");
4035 if (BO->getOpcode() == BO_Comma) {
4044 return cast<ObjCPropertyRefExpr>(E);
4050 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
4069 if (ICE->getCastKind() == CK_LValueToRValue ||
4070 (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp))
4076 if (
MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
4077 if (
FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
4078 if (Field->isBitField())
4087 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) {
4088 if (
FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
4089 if (Field->isBitField())
4092 if (
BindingDecl *BD = dyn_cast<BindingDecl>(DeclRef->getDecl()))
4093 if (
Expr *E = BD->getBinding())
4098 if (BinOp->isAssignmentOp() && BinOp->getLHS())
4099 return BinOp->getLHS()->getSourceBitField();
4101 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
4102 return BinOp->getRHS()->getSourceBitField();
4106 if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())
4107 return UnOp->getSubExpr()->getSourceBitField();
4114 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4115 return dyn_cast<EnumConstantDecl>(DRE->getDecl());
4124 if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)
4133 if (isa<ExtVectorElementExpr>(E))
4136 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4137 if (
auto *BD = dyn_cast<BindingDecl>(DRE->getDecl()))
4138 if (
auto *E = BD->getBinding())
4147 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
4148 if (
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
4150 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
4166 case CXXThisExprClass:
4168 case DeclRefExprClass: {
4171 const auto *DRE1 = cast<DeclRefExpr>(E1);
4172 const auto *DRE2 = cast<DeclRefExpr>(E2);
4173 return DRE1->isPRValue() && DRE2->isPRValue() &&
4174 DRE1->getDecl() == DRE2->getDecl();
4176 case ImplicitCastExprClass: {
4179 const auto *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
4180 const auto *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
4183 if (ICE1->getCastKind() != ICE2->getCastKind())
4188 if (ICE1->getCastKind() == CK_LValueToRValue ||
4189 ICE1->getCastKind() == CK_ArrayToPointerDecay ||
4190 ICE1->getCastKind() == CK_FunctionToPointerDecay) {
4195 const auto *DRE1 = dyn_cast<DeclRefExpr>(E1);
4196 const auto *DRE2 = dyn_cast<DeclRefExpr>(E2);
4200 const auto *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
4201 const auto *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
4202 if (Ivar1 && Ivar2) {
4203 return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
4207 const auto *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
4208 const auto *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
4209 if (Array1 && Array2) {
4213 auto Idx1 = Array1->getIdx();
4214 auto Idx2 = Array2->getIdx();
4215 const auto Integer1 = dyn_cast<IntegerLiteral>(Idx1);
4216 const auto Integer2 = dyn_cast<IntegerLiteral>(Idx2);
4217 if (Integer1 && Integer2) {
4218 if (!llvm::APInt::isSameValue(Integer1->getValue(),
4219 Integer2->getValue()))
4230 while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
4231 const auto *ME1 = cast<MemberExpr>(E1);
4232 const auto *ME2 = cast<MemberExpr>(E2);
4235 if (
const auto *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
4236 if (D->isStaticDataMember())
4242 if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
4248 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
4249 return DRE->getDecl();
4250 if (
const auto *ME = dyn_cast<MemberExpr>(E))
4251 return ME->getMemberDecl();
4270 return VT->getNumElements();
4278 StringRef Comp = Accessor->
getName();
4281 if (Comp ==
"hi" || Comp ==
"lo" || Comp ==
"even" || Comp ==
"odd")
4285 if (Comp[0] ==
's' || Comp[0] ==
'S')
4286 Comp = Comp.substr(1);
4288 for (
unsigned i = 0, e = Comp.size(); i != e; ++i)
4289 if (Comp.substr(i + 1).contains(Comp[i]))
4298 StringRef Comp = Accessor->
getName();
4299 bool isNumericAccessor =
false;
4300 if (Comp[0] ==
's' || Comp[0] ==
'S') {
4301 Comp = Comp.substr(1);
4302 isNumericAccessor =
true;
4305 bool isHi = Comp ==
"hi";
4306 bool isLo = Comp ==
"lo";
4307 bool isEven = Comp ==
"even";
4308 bool isOdd = Comp ==
"odd";
4324 Elts.push_back(Index);
4332 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
4333 SubExprs =
new (
C)
Stmt*[args.size()];
4334 for (
unsigned i = 0; i != args.size(); i++)
4335 SubExprs[i] = args[i];
4341 if (SubExprs)
C.Deallocate(SubExprs);
4343 this->NumExprs = Exprs.size();
4344 SubExprs =
new (
C)
Stmt*[NumExprs];
4345 memcpy(SubExprs, Exprs.data(),
sizeof(
Expr *) * Exprs.size());
4348GenericSelectionExpr::GenericSelectionExpr(
4352 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex)
4353 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4354 AssocExprs[ResultIndex]->getValueKind(),
4355 AssocExprs[ResultIndex]->getObjectKind()),
4356 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4357 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4358 assert(AssocTypes.size() == AssocExprs.size() &&
4359 "Must have the same number of association expressions"
4360 " and TypeSourceInfo!");
4361 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4364 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4366 std::copy(AssocExprs.begin(), AssocExprs.end(),
4367 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4368 std::copy(AssocTypes.begin(), AssocTypes.end(),
4369 getTrailingObjects<TypeSourceInfo *>() +
4370 getIndexOfStartOfAssociatedTypes());
4375GenericSelectionExpr::GenericSelectionExpr(
4380 unsigned ResultIndex)
4381 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4382 AssocExprs[ResultIndex]->getValueKind(),
4383 AssocExprs[ResultIndex]->getObjectKind()),
4384 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4385 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4386 assert(AssocTypes.size() == AssocExprs.size() &&
4387 "Must have the same number of association expressions"
4388 " and TypeSourceInfo!");
4389 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4392 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4394 std::copy(AssocExprs.begin(), AssocExprs.end(),
4395 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4396 std::copy(AssocTypes.begin(), AssocTypes.end(),
4397 getTrailingObjects<TypeSourceInfo *>() +
4398 getIndexOfStartOfAssociatedTypes());
4403GenericSelectionExpr::GenericSelectionExpr(
4407 bool ContainsUnexpandedParameterPack)
4408 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4410 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4411 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4412 assert(AssocTypes.size() == AssocExprs.size() &&
4413 "Must have the same number of association expressions"
4414 " and TypeSourceInfo!");
4417 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4419 std::copy(AssocExprs.begin(), AssocExprs.end(),
4420 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4421 std::copy(AssocTypes.begin(), AssocTypes.end(),
4422 getTrailingObjects<TypeSourceInfo *>() +
4423 getIndexOfStartOfAssociatedTypes());
4428GenericSelectionExpr::GenericSelectionExpr(
4433 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4435 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4436 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4437 assert(AssocTypes.size() == AssocExprs.size() &&
4438 "Must have the same number of association expressions"
4439 " and TypeSourceInfo!");
4442 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4444 std::copy(AssocExprs.begin(), AssocExprs.end(),
4445 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4446 std::copy(AssocTypes.begin(), AssocTypes.end(),
4447 getTrailingObjects<TypeSourceInfo *>() +
4448 getIndexOfStartOfAssociatedTypes());
4453GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty,
unsigned NumAssocs)
4454 :
Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
4460 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex) {
4461 unsigned NumAssocs = AssocExprs.size();
4463 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4466 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4467 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4474 bool ContainsUnexpandedParameterPack) {
4475 unsigned NumAssocs = AssocExprs.size();
4477 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4480 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4481 RParenLoc, ContainsUnexpandedParameterPack);
4489 unsigned ResultIndex) {
4490 unsigned NumAssocs = AssocExprs.size();
4492 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4495 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4496 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4503 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack) {
4504 unsigned NumAssocs = AssocExprs.size();
4506 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4509 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4510 RParenLoc, ContainsUnexpandedParameterPack);
4515 unsigned NumAssocs) {
4517 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4540 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
4541 NumDesignators(Designators.
size()), NumSubExprs(IndexExprs.
size() + 1) {
4542 this->Designators =
new (
C)
Designator[NumDesignators];
4550 unsigned IndexIdx = 0;
4551 for (
unsigned I = 0; I != NumDesignators; ++I) {
4552 this->Designators[I] = Designators[I];
4555 *Child++ = IndexExprs[IndexIdx++];
4558 *Child++ = IndexExprs[IndexIdx++];
4559 *Child++ = IndexExprs[IndexIdx++];
4563 assert(IndexIdx == IndexExprs.size() &&
"Wrong number of index expressions");
4572 bool UsesColonSyntax,
Expr *
Init) {
4573 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
4576 ColonOrEqualLoc, UsesColonSyntax,
4581 unsigned NumIndexExprs) {
4582 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
4589 unsigned NumDesigs) {
4591 NumDesignators = NumDesigs;
4592 for (
unsigned I = 0; I != NumDesigs; ++I)
4593 Designators[I] = Desigs[I];
4607 if (
First.isFieldDesignator()) {
4610 for (
unsigned int i = 0; i < DIE->size(); i++) {
4618 return First.getLBracketLoc();
4645 unsigned NumNewDesignators =
Last -
First;
4646 if (NumNewDesignators == 0) {
4647 std::copy_backward(Designators + Idx + 1,
4648 Designators + NumDesignators,
4650 --NumNewDesignators;
4653 if (NumNewDesignators == 1) {
4654 Designators[Idx] = *
First;
4659 =
new (
C)
Designator[NumDesignators - 1 + NumNewDesignators];
4660 std::copy(Designators, Designators + Idx, NewDesignators);
4661 std::copy(
First,
Last, NewDesignators + Idx);
4662 std::copy(Designators + Idx + 1, Designators + NumDesignators,
4663 NewDesignators + Idx + NumNewDesignators);
4664 Designators = NewDesignators;
4665 NumDesignators = NumDesignators - 1 + NumNewDesignators;
4674 BaseAndUpdaterExprs[0] = baseExpr;
4679 BaseAndUpdaterExprs[1] = ILE;
4696 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4699 for (
unsigned I = 0, N = Exprs.size(); I != N; ++I)
4700 getTrailingObjects<Stmt *>()[I] = Exprs[I];
4704ParenListExpr::ParenListExpr(EmptyShell Empty,
unsigned NumExprs)
4705 :
Expr(ParenListExprClass, Empty) {
4713 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
4715 return new (Mem)
ParenListExpr(LParenLoc, Exprs, RParenLoc);
4719 unsigned NumExprs) {
4729 :
Expr(BinaryOperatorClass, ResTy, VK, OK) {
4732 "Use CompoundAssignOperator for compound assignments");
4734 SubExprs[LHS] = lhs;
4735 SubExprs[RHS] = rhs;
4746 :
Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
4749 "Use CompoundAssignOperator for compound assignments");
4751 SubExprs[LHS] = lhs;
4752 SubExprs[RHS] = rhs;
4760 bool HasFPFeatures) {
4800 CompLHSType, CompResultType);
4804 bool hasFPFeatures) {
4805 void *Mem =
C.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),
4814 :
Expr(UnaryOperatorClass,
type, VK, OK), Val(input) {
4830 unsigned Size = totalSizeToAlloc<FPOptionsOverride>(HasFPFeatures);
4838 e = ewc->getSubExpr();
4840 e = m->getSubExpr();
4841 e = cast<CXXConstructExpr>(e)->getArg(0);
4843 e = ice->getSubExpr();
4844 return cast<OpaqueValueExpr>(e);
4849 unsigned numSemanticExprs) {
4851 Context.
Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
4856PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell,
unsigned numSemanticExprs)
4857 :
Expr(PseudoObjectExprClass, shell) {
4863 unsigned resultIndex) {
4864 assert(syntax &&
"no syntactic expression!");
4865 assert(
semantics.size() &&
"no semantic expressions!");
4875 VK =
semantics[resultIndex]->getValueKind();
4879 void *buffer =
C.Allocate(totalSizeToAlloc<Expr *>(
semantics.size() + 1),
4887 unsigned resultIndex)
4892 for (
unsigned i = 0, e =
semantics.size() + 1; i != e; ++i) {
4894 getSubExprsBuffer()[i] = E;
4896 if (isa<OpaqueValueExpr>(E))
4897 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() !=
nullptr &&
4898 "opaque-value semantic expressions for pseudo-object "
4899 "operations must have sources");
4932 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
4933 assert(args.size() ==
getNumSubExprs(op) &&
"wrong number of subexpressions");
4934 for (
unsigned i = 0; i != args.size(); i++)
4935 SubExprs[i] = args[i];
4941 case AO__c11_atomic_init:
4942 case AO__opencl_atomic_init:
4943 case AO__c11_atomic_load:
4944 case AO__atomic_load_n:
4947 case AO__scoped_atomic_load_n:
4948 case AO__opencl_atomic_load:
4949 case AO__hip_atomic_load:
4950 case AO__c11_atomic_store:
4951 case AO__c11_atomic_exchange:
4952 case AO__atomic_load:
4953 case AO__atomic_store:
4954 case AO__atomic_store_n:
4955 case AO__atomic_exchange_n:
4956 case AO__c11_atomic_fetch_add:
4957 case AO__c11_atomic_fetch_sub:
4958 case AO__c11_atomic_fetch_and:
4959 case AO__c11_atomic_fetch_or:
4960 case AO__c11_atomic_fetch_xor:
4961 case AO__c11_atomic_fetch_nand:
4962 case AO__c11_atomic_fetch_max:
4963 case AO__c11_atomic_fetch_min:
4964 case AO__atomic_fetch_add:
4965 case AO__atomic_fetch_sub:
4966 case AO__atomic_fetch_and:
4967 case AO__atomic_fetch_or:
4968 case AO__atomic_fetch_xor:
4969 case AO__atomic_fetch_nand:
4970 case AO__atomic_add_fetch:
4971 case AO__atomic_sub_fetch:
4972 case AO__atomic_and_fetch:
4973 case AO__atomic_or_fetch:
4974 case AO__atomic_xor_fetch:
4975 case AO__atomic_nand_fetch:
4976 case AO__atomic_min_fetch:
4977 case AO__atomic_max_fetch:
4978 case AO__atomic_fetch_min:
4979 case AO__atomic_fetch_max:
4982 case AO__scoped_atomic_load:
4983 case AO__scoped_atomic_store:
4984 case AO__scoped_atomic_store_n:
4985 case AO__scoped_atomic_fetch_add:
4986 case AO__scoped_atomic_fetch_sub:
4987 case AO__scoped_atomic_fetch_and:
4988 case AO__scoped_atomic_fetch_or:
4989 case AO__scoped_atomic_fetch_xor:
4990 case AO__scoped_atomic_fetch_nand:
4991 case AO__scoped_atomic_add_fetch:
4992 case AO__scoped_atomic_sub_fetch:
4993 case AO__scoped_atomic_and_fetch:
4994 case AO__scoped_atomic_or_fetch:
4995 case AO__scoped_atomic_xor_fetch:
4996 case AO__scoped_atomic_nand_fetch:
4997 case AO__scoped_atomic_min_fetch:
4998 case AO__scoped_atomic_max_fetch:
4999 case AO__scoped_atomic_fetch_min:
5000 case AO__scoped_atomic_fetch_max:
5001 case AO__scoped_atomic_exchange_n:
5002 case AO__hip_atomic_exchange:
5003 case AO__hip_atomic_fetch_add:
5004 case AO__hip_atomic_fetch_sub:
5005 case AO__hip_atomic_fetch_and:
5006 case AO__hip_atomic_fetch_or:
5007 case AO__hip_atomic_fetch_xor:
5008 case AO__hip_atomic_fetch_min:
5009 case AO__hip_atomic_fetch_max:
5010 case AO__opencl_atomic_store:
5011 case AO__hip_atomic_store:
5012 case AO__opencl_atomic_exchange:
5013 case AO__opencl_atomic_fetch_add:
5014 case AO__opencl_atomic_fetch_sub:
5015 case AO__opencl_atomic_fetch_and:
5016 case AO__opencl_atomic_fetch_or:
5017 case AO__opencl_atomic_fetch_xor:
5018 case AO__opencl_atomic_fetch_min:
5019 case AO__opencl_atomic_fetch_max:
5020 case AO__atomic_exchange:
5023 case AO__scoped_atomic_exchange:
5024 case AO__c11_atomic_compare_exchange_strong:
5025 case AO__c11_atomic_compare_exchange_weak:
5027 case AO__hip_atomic_compare_exchange_strong:
5028 case AO__opencl_atomic_compare_exchange_strong:
5029 case AO__opencl_atomic_compare_exchange_weak:
5030 case AO__hip_atomic_compare_exchange_weak:
5031 case AO__atomic_compare_exchange:
5032 case AO__atomic_compare_exchange_n:
5035 case AO__scoped_atomic_compare_exchange:
5036 case AO__scoped_atomic_compare_exchange_n:
5039 llvm_unreachable(
"unknown atomic op");
5045 return AT->getValueType();
5050 unsigned ArraySectionCount = 0;
5051 while (
auto *OASE = dyn_cast<OMPArraySectionExpr>(
Base->IgnoreParens())) {
5052 Base = OASE->getBase();
5053 ++ArraySectionCount;
5056 dyn_cast<ArraySubscriptExpr>(
Base->IgnoreParenImpCasts())) {
5057 Base = ASE->getBase();
5058 ++ArraySectionCount;
5060 Base =
Base->IgnoreParenImpCasts();
5061 auto OriginalTy =
Base->getType();
5062 if (
auto *DRE = dyn_cast<DeclRefExpr>(
Base))
5063 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
5064 OriginalTy = PVD->getOriginalType().getNonReferenceType();
5066 for (
unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
5067 if (OriginalTy->isAnyPointerType())
5068 OriginalTy = OriginalTy->getPointeeType();
5069 else if (OriginalTy->isArrayType())
5070 OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
5079 :
Expr(RecoveryExprClass, T.getNonReferenceType(),
5080 T->isDependentType() ?
VK_LValue : getValueKindForType(T),
5082 BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
5084 assert(!llvm::is_contained(SubExprs,
nullptr));
5086 llvm::copy(SubExprs, getTrailingObjects<Expr *>());
5094 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(SubExprs.size()),
5096 return new (Mem)
RecoveryExpr(Ctx, T, BeginLoc, EndLoc, SubExprs);
5100 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(NumSubExprs),
5107 NumDims == Dims.size() &&
5108 "Preallocated number of dimensions is different from the provided one.");
5109 llvm::copy(Dims, getTrailingObjects<Expr *>());
5114 NumDims == BR.size() &&
5115 "Preallocated number of dimensions is different from the provided one.");
5116 llvm::copy(BR, getTrailingObjects<SourceRange>());
5119OMPArrayShapingExpr::OMPArrayShapingExpr(
QualType ExprTy,
Expr *Op,
5123 RPLoc(R), NumDims(Dims.size()) {
5125 setDimensions(Dims);
5134 assert(Dims.size() == BracketRanges.size() &&
5135 "Different number of dimensions and brackets ranges.");
5137 totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),
5140 E->setBracketsRanges(BracketRanges);
5147 totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),
5152void OMPIteratorExpr::setIteratorDeclaration(
unsigned I,
Decl *D) {
5153 assert(I < NumIterators &&
5154 "Idx is greater or equal the number of iterators definitions.");
5155 getTrailingObjects<Decl *>()[I] = D;
5158void OMPIteratorExpr::setAssignmentLoc(
unsigned I,
SourceLocation Loc) {
5159 assert(I < NumIterators &&
5160 "Idx is greater or equal the number of iterators definitions.");
5163 static_cast<int>(RangeLocOffset::AssignLoc)] = Loc;
5166void OMPIteratorExpr::setIteratorRange(
unsigned I,
Expr *
Begin,
5170 assert(I < NumIterators &&
5171 "Idx is greater or equal the number of iterators definitions.");
5172 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5173 static_cast<int>(RangeExprOffset::Begin)] =
5175 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5176 static_cast<int>(RangeExprOffset::End)] = End;
5177 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5178 static_cast<int>(RangeExprOffset::Step)] = Step;
5181 static_cast<int>(RangeLocOffset::FirstColonLoc)] =
5185 static_cast<int>(RangeLocOffset::SecondColonLoc)] =
5190 return getTrailingObjects<Decl *>()[I];
5196 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5197 RangeExprOffset::Total) +
5198 static_cast<int>(RangeExprOffset::Begin)];
5200 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5201 RangeExprOffset::Total) +
5202 static_cast<int>(RangeExprOffset::End)];
5204 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5205 RangeExprOffset::Total) +
5206 static_cast<int>(RangeExprOffset::Step)];
5211 return getTrailingObjects<
5213 static_cast<int>(RangeLocOffset::AssignLoc)];
5217 return getTrailingObjects<
5219 static_cast<int>(RangeLocOffset::FirstColonLoc)];
5223 return getTrailingObjects<
5225 static_cast<int>(RangeLocOffset::SecondColonLoc)];
5229 getTrailingObjects<OMPIteratorHelperData>()[I] = D;
5233 return getTrailingObjects<OMPIteratorHelperData>()[I];
5237 return getTrailingObjects<OMPIteratorHelperData>()[I];
5240OMPIteratorExpr::OMPIteratorExpr(
5245 IteratorKwLoc(IteratorKwLoc), LPLoc(L), RPLoc(R),
5246 NumIterators(
Data.size()) {
5247 for (
unsigned I = 0, E =
Data.size(); I < E; ++I) {
5248 const IteratorDefinition &D =
Data[I];
5249 setIteratorDeclaration(I, D.IteratorDecl);
5250 setAssignmentLoc(I, D.AssignmentLoc);
5251 setIteratorRange(I, D.Range.Begin, D.ColonLoc, D.Range.End,
5252 D.SecondColonLoc, D.Range.Step);
5253 setHelper(I, Helpers[I]);
5264 assert(
Data.size() == Helpers.size() &&
5265 "Data and helpers must have the same size.");
5267 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
5268 Data.size(),
Data.size() *
static_cast<int>(RangeExprOffset::Total),
5269 Data.size() *
static_cast<int>(RangeLocOffset::Total),
5276 unsigned NumIterators) {
5278 totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(
5279 NumIterators, NumIterators *
static_cast<int>(RangeExprOffset::Total),
5280 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)
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.
ExprDependence getDependence() const
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.
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
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 std::string ComputeName(PredefinedIdentKind IK, const Decl *CurrentDecl)
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 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.
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
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.
ExprDependence toExprDependence(TemplateArgumentDependence TA)
Computes dependencies of a reference with the name having template arguments with TA dependencies.
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)
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.
Extra data stored in some MemberExpr objects.
DeclAccessPair FoundDecl
The DeclAccessPair through which the MemberDecl was found due to name qualifiers.
NestedNameSpecifierLoc QualifierLoc
The nested-name-specifier that qualifies the name, including source-location information.
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.
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,...