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 CastExpr *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 MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
105 if (!ME->isArrow()) {
106 assert(ME->getBase()->getType()->isRecordType());
107 if (
FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
108 if (!Field->isBitField() && !Field->getType()->isReferenceType()) {
115 }
else if (
const BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
116 if (BO->getOpcode() == BO_PtrMemD) {
117 assert(BO->getRHS()->isPRValue());
124 if (BO->getOpcode() == BO_Comma) {
125 CommaLHSs.push_back(BO->getLHS());
146 switch (UO->getOpcode()) {
148 return UO->getSubExpr()->isKnownToHaveBooleanValue(Semantic);
160 return CE->getSubExpr()->isKnownToHaveBooleanValue(Semantic);
163 switch (BO->getOpcode()) {
164 default:
return false;
179 return BO->getLHS()->isKnownToHaveBooleanValue(Semantic) &&
180 BO->getRHS()->isKnownToHaveBooleanValue(Semantic);
184 return BO->getRHS()->isKnownToHaveBooleanValue(Semantic);
189 return CO->getTrueExpr()->isKnownToHaveBooleanValue(Semantic) &&
190 CO->getFalseExpr()->isKnownToHaveBooleanValue(Semantic);
192 if (isa<ObjCBoolLiteralExpr>(E))
195 if (
const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
196 return OVE->getSourceExpr()->isKnownToHaveBooleanValue(Semantic);
199 if (!Semantic && FD->getType()->isUnsignedIntegerType() &&
200 !FD->getBitWidth()->isValueDependent() &&
201 FD->getBitWidthValue(FD->getASTContext()) == 1)
210 bool IgnoreTemplateOrMacroSubstitution)
const {
216 llvm::APInt Size = CAT->getSize();
220 if (StrictFlexArraysLevel == FAMKind::IncompleteOnly)
227 if (StrictFlexArraysLevel == FAMKind::ZeroOrIncomplete && Size.uge(1))
230 if (StrictFlexArraysLevel == FAMKind::OneZeroOrIncomplete && Size.uge(2))
238 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
240 else if (
const auto *ME = dyn_cast<MemberExpr>(E))
241 ND = ME->getMemberDecl();
242 else if (
const auto *IRE = dyn_cast<ObjCIvarRefExpr>(E))
243 return IRE->getDecl()->getNextIvar() ==
nullptr;
251 if (
const auto *FD = dyn_cast<FieldDecl>(ND)) {
255 llvm::APInt Size = CAT->getSize();
256 if (FD->getParent()->isUnion() && (Size.isZero() || Size.isOne()))
262 if (IgnoreTemplateOrMacroSubstitution) {
273 const Expr *SizeExpr = dyn_cast<IntegerLiteral>(CTL.getSizeExpr());
283 return ++FI == FD->getParent()->field_end();
296 if (
Value.isMemberPointer())
297 return Value.getMemberPointerDecl();
299 if (
Value.isLValue() &&
Value.getLValueOffset().isZero())
313 template <
class E,
class T>
316 return static_cast<const E*
>(
expr)->getExprLoc();
326 return static_cast<const E *
>(
expr)->getBeginLoc();
333#define ABSTRACT_STMT(type)
334#define STMT(type, base) \
335 case Stmt::type##Class: break;
336#define EXPR(type, base) \
337 case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc);
338#include "clang/AST/StmtNodes.inc"
340 llvm_unreachable(
"unknown expression kind");
350 "Invalid StorageKind Value");
361 if (!
Value.getInt().needsCleanup())
376ConstantExpr::ConstantExpr(
Expr *SubExpr, ResultStorageKind StorageKind,
377 bool IsImmediateInvocation)
378 :
FullExpr(ConstantExprClass, SubExpr) {
387 ::new (getTrailingObjects<APValue>())
APValue();
392 bool IsImmediateInvocation) {
393 assert(!isa<ConstantExpr>(E));
396 unsigned Size = totalSizeToAlloc<APValue, uint64_t>(
400 return new (Mem)
ConstantExpr(E, StorageKind, IsImmediateInvocation);
412 :
FullExpr(ConstantExprClass, Empty) {
416 ::new (getTrailingObjects<APValue>())
APValue();
423 unsigned Size = totalSizeToAlloc<APValue, uint64_t>(
432 "Invalid storage for this value kind");
438 Int64Result() = *
Value.getInt().getRawData();
447 APValueResult() = std::move(
Value);
450 llvm_unreachable(
"Invalid ResultKind Bits");
456 return APValueResult().
getInt();
461 llvm_unreachable(
"invalid Accessor");
469 return APValueResult();
479 llvm_unreachable(
"invalid ResultKind");
483 bool RefersToEnclosingVariableOrCapture,
QualType T,
493 RefersToEnclosingVariableOrCapture;
500DeclRefExpr::DeclRefExpr(
const ASTContext &Ctx,
503 bool RefersToEnclosingVariableOrCapture,
512 new (getTrailingObjects<NestedNameSpecifierLoc>())
516 *getTrailingObjects<NamedDecl *>() = FoundD;
518 = (TemplateArgs || TemplateKWLoc.
isValid()) ? 1 : 0;
520 RefersToEnclosingVariableOrCapture;
523 auto Deps = TemplateArgumentDependence::None;
524 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
525 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
527 assert(!(Deps & TemplateArgumentDependence::Dependent) &&
528 "built a DeclRefExpr with dependent template args");
529 }
else if (TemplateKWLoc.
isValid()) {
530 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
541 bool RefersToEnclosingVariableOrCapture,
546 return Create(Context, QualifierLoc, TemplateKWLoc, D,
547 RefersToEnclosingVariableOrCapture,
549 T, VK, FoundD, TemplateArgs, NOUR);
555 bool RefersToEnclosingVariableOrCapture,
565 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
569 QualifierLoc ? 1 : 0, FoundD ? 1 : 0,
570 HasTemplateKWAndArgsInfo ? 1 : 0,
571 TemplateArgs ? TemplateArgs->
size() : 0);
574 return new (Mem)
DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
575 RefersToEnclosingVariableOrCapture, NameInfo,
576 FoundD, TemplateArgs, T, VK, NOUR);
582 bool HasTemplateKWAndArgsInfo,
583 unsigned NumTemplateArgs) {
584 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
588 HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo,
596 if (
getType()->isUndeducedType())
612SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(
SourceLocation OpLoc,
618 OpLoc(OpLoc), LParen(LParen), RParen(RParen) {
619 setTypeSourceInfo(TSI);
623SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell Empty,
650 const NamedDecl *ND) -> std::optional<unsigned> {
651 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
652 return RD->getDeviceLambdaManglingNumber();
661 llvm::raw_string_ostream Out(Buffer);
662 Ctx->mangleTypeName(Ty, Out);
671 assert((getIdentKind() == IK) &&
672 "IdentKind do not fit in PredefinedExprBitfields!");
673 bool HasFunctionName = SL !=
nullptr;
682PredefinedExpr::PredefinedExpr(EmptyShell Empty,
bool HasFunctionName)
683 :
Expr(PredefinedExprClass, Empty) {
690 bool HasFunctionName = SL !=
nullptr;
691 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
697 bool HasFunctionName) {
698 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
708 return "__FUNCTION__";
710 return "__FUNCDNAME__";
712 return "L__FUNCTION__";
714 return "__PRETTY_FUNCTION__";
716 return "__FUNCSIG__";
718 return "L__FUNCSIG__";
722 llvm_unreachable(
"Unknown ident kind for PredefinedExpr");
731 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
732 std::unique_ptr<MangleContext> MC;
735 if (MC->shouldMangleDeclName(ND)) {
737 llvm::raw_svector_ostream Out(Buffer);
743 else if (ND->hasAttr<CUDAGlobalAttr>())
747 MC->mangleName(GD, Out);
749 if (!Buffer.empty() && Buffer.front() ==
'\01')
750 return std::string(Buffer.substr(1));
751 return std::string(Buffer.str());
753 return std::string(ND->getIdentifier()->getName());
757 if (isa<BlockDecl>(CurrentDecl)) {
762 if (DC->isFileContext())
766 llvm::raw_svector_ostream Out(Buffer);
767 if (
auto *DCBlock = dyn_cast<BlockDecl>(DC))
770 else if (
auto *DCDecl = dyn_cast<Decl>(DC))
772 return std::string(Out.str());
774 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
777 return FD->getNameAsString();
780 llvm::raw_svector_ostream Out(Name);
792 std::string remapPath(StringRef Path)
const override {
795 return std::string(p);
805 llvm::raw_string_ostream POut(Proto);
812 if (FD->hasWrittenPrototype())
813 FT = dyn_cast<FunctionProtoType>(AFT);
817 case CC_C: POut <<
"__cdecl ";
break;
828 FD->printQualifiedName(POut, Policy);
832 for (
unsigned i = 0, e =
Decl->getNumParams(); i != e; ++i) {
834 POut <<
Decl->getParamDecl(i)->getType().stream(Policy);
837 if (FT->isVariadic()) {
838 if (FD->getNumParams()) POut <<
", ";
842 !
Decl->getNumParams()) {
849 assert(FT &&
"We must have a written prototype in this case.");
852 if (FT->isVolatile())
864 while (Ctx && isa<NamedDecl>(Ctx)) {
866 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
868 Specs.push_back(Spec);
872 std::string TemplateParams;
873 llvm::raw_string_ostream TOut(TemplateParams);
876 D->getSpecializedTemplate()->getTemplateParameters();
878 assert(Params->
size() == Args.
size());
879 for (
unsigned i = 0, numParams = Params->
size(); i != numParams; ++i) {
881 if (Param.empty())
continue;
882 TOut << Param <<
" = ";
891 = FD->getTemplateSpecializationInfo();
896 assert(Params->
size() == Args->
size());
897 for (
unsigned i = 0, e = Params->
size(); i != e; ++i) {
899 if (Param.empty())
continue;
900 TOut << Param <<
" = ";
901 Args->
get(i).
print(Policy, TOut,
true);
907 if (!TemplateParams.empty()) {
909 TemplateParams.resize(TemplateParams.size() - 2);
910 POut <<
" [" << TemplateParams <<
"]";
919 if (isa<CXXMethodDecl>(FD) &&
920 cast<CXXMethodDecl>(FD)->getParent()->isLambda())
921 Proto =
"auto " + Proto;
922 else if (FT && FT->getReturnType()->getAs<
DecltypeType>())
927 else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
932 return std::string(Name);
934 if (
const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
938 if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {
942 llvm_unreachable(
"CapturedDecl not inside a function or method");
944 if (
const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
946 llvm::raw_svector_ostream Out(Name);
947 Out << (MD->isInstanceMethod() ?
'-' :
'+');
956 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
957 Out <<
'(' << *CID <<
')';
960 MD->getSelector().print(Out);
963 return std::string(Name);
965 if (isa<TranslationUnitDecl>(CurrentDecl) && IK ==
PrettyFunction) {
973 const llvm::APInt &Val) {
977 BitWidth = Val.getBitWidth();
978 unsigned NumWords = Val.getNumWords();
979 const uint64_t* Words = Val.getRawData();
981 pVal =
new (
C) uint64_t[NumWords];
982 std::copy(Words, Words + NumWords,
pVal);
983 }
else if (NumWords == 1)
989IntegerLiteral::IntegerLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
992 assert(
type->isIntegerType() &&
"Illegal type in IntegerLiteral");
993 assert(
V.getBitWidth() ==
C.getIntWidth(
type) &&
994 "Integer type is not the correct size for constant.");
1010FixedPointLiteral::FixedPointLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
1015 assert(
type->isFixedPointType() &&
"Illegal type in FixedPointLiteral");
1016 assert(
V.getBitWidth() ==
C.getTypeInfo(
type).Width &&
1017 "Fixed point type is not the correct size for constant.");
1023 const llvm::APInt &
V,
1041 S, llvm::APSInt::getUnsigned(
getValue().getZExtValue()), Scale);
1042 return std::string(S.str());
1064 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Val);
1065 if (!Escaped.empty()) {
1066 OS <<
"'" << Escaped <<
"'";
1075 OS <<
"'" << (char)Val <<
"'";
1077 OS <<
"'\\x" << llvm::format(
"%02x", Val) <<
"'";
1078 else if (Val <= 0xFFFF)
1079 OS <<
"'\\u" << llvm::format(
"%04x", Val) <<
"'";
1081 OS <<
"'\\U" << llvm::format(
"%08x", Val) <<
"'";
1085FloatingLiteral::FloatingLiteral(
const ASTContext &
C,
const llvm::APFloat &
V,
1088 setSemantics(
V.getSemantics());
1094FloatingLiteral::FloatingLiteral(
const ASTContext &
C, EmptyShell Empty)
1095 :
Expr(FloatingLiteralClass, Empty) {
1096 setRawSemantics(llvm::APFloatBase::S_IEEEhalf);
1117 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
1119 return V.convertToDouble();
1124 unsigned CharByteWidth = 0;
1128 CharByteWidth =
Target.getCharWidth();
1131 CharByteWidth =
Target.getWCharWidth();
1134 CharByteWidth =
Target.getChar16Width();
1137 CharByteWidth =
Target.getChar32Width();
1140 return sizeof(char);
1142 assert((CharByteWidth & 7) == 0 &&
"Assumes character size is byte multiple");
1144 assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&
1145 "The only supported character byte widths are 1,2 and 4!");
1146 return CharByteWidth;
1149StringLiteral::StringLiteral(
const ASTContext &Ctx, StringRef Str,
1150 StringKind Kind,
bool Pascal,
QualType Ty,
1152 unsigned NumConcatenated)
1155 unsigned Length = Str.size();
1160 if (Kind != StringKind::Unevaluated) {
1162 "StringLiteral must be of constant array type!");
1163 unsigned CharByteWidth = mapCharByteWidth(Ctx.
getTargetInfo(), Kind);
1164 unsigned ByteLength = Str.size();
1165 assert((ByteLength % CharByteWidth == 0) &&
1166 "The size of the data must be a multiple of CharByteWidth!");
1171 switch (CharByteWidth) {
1173 Length = ByteLength;
1176 Length = ByteLength / 2;
1179 Length = ByteLength / 4;
1182 llvm_unreachable(
"Unsupported character width!");
1188 assert(!Pascal &&
"Can't make an unevaluated Pascal string");
1193 *getTrailingObjects<unsigned>() = Length;
1197 std::memcpy(getTrailingObjects<SourceLocation>(), Loc,
1201 std::memcpy(getTrailingObjects<char>(), Str.data(), Str.size());
1206StringLiteral::StringLiteral(EmptyShell Empty,
unsigned NumConcatenated,
1207 unsigned Length,
unsigned CharByteWidth)
1208 :
Expr(StringLiteralClass, Empty) {
1211 *getTrailingObjects<unsigned>() = Length;
1217 unsigned NumConcatenated) {
1218 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1219 1, NumConcatenated, Str.size()),
1222 StringLiteral(Ctx, Str, Kind, Pascal, Ty, Loc, NumConcatenated);
1226 unsigned NumConcatenated,
1228 unsigned CharByteWidth) {
1229 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1230 1, NumConcatenated, Length * CharByteWidth),
1241 case Wide: OS <<
'L';
break;
1242 case UTF8: OS <<
"u8";
break;
1243 case UTF16: OS <<
'u';
break;
1244 case UTF32: OS <<
'U';
break;
1247 static const char Hex[] =
"0123456789ABCDEF";
1250 for (
unsigned I = 0, N =
getLength(); I != N; ++I) {
1252 StringRef Escaped = escapeCStyle<EscapeChar::Double>(Char);
1253 if (Escaped.empty()) {
1258 if (
getKind() ==
UTF16 && I != N - 1 && Char >= 0xd800 &&
1261 if (Trail >= 0xdc00 && Trail <= 0xdfff) {
1262 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
1272 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
1276 while ((Char >> Shift) == 0)
1278 for (; Shift >= 0; Shift -= 4)
1279 OS << Hex[(Char >> Shift) & 15];
1286 << Hex[(Char >> 20) & 15]
1287 << Hex[(Char >> 16) & 15];
1290 OS << Hex[(Char >> 12) & 15]
1291 << Hex[(Char >> 8) & 15]
1292 << Hex[(Char >> 4) & 15]
1293 << Hex[(Char >> 0) & 15];
1299 if (LastSlashX + 1 == I) {
1301 case '0':
case '1':
case '2':
case '3':
case '4':
1302 case '5':
case '6':
case '7':
case '8':
case '9':
1303 case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
1304 case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
1309 assert(Char <= 0xff &&
1310 "Characters above 0xff should already have been handled.");
1316 << (char)(
'0' + ((Char >> 6) & 7))
1317 << (char)(
'0' + ((Char >> 3) & 7))
1318 << (char)(
'0' + ((Char >> 0) & 7));
1347 unsigned *StartTokenByteOffset)
const {
1351 "Only narrow string literals are currently supported");
1356 unsigned StringOffset = 0;
1358 TokNo = *StartToken;
1359 if (StartTokenByteOffset) {
1360 StringOffset = *StartTokenByteOffset;
1361 ByteNo -= StringOffset;
1373 std::pair<FileID, unsigned> LocInfo =
1374 SM.getDecomposedLoc(StrTokSpellingLoc);
1376 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
1378 if (StartTokenByteOffset !=
nullptr)
1379 *StartTokenByteOffset = StringOffset;
1380 if (StartToken !=
nullptr)
1381 *StartToken = TokNo;
1382 return StrTokSpellingLoc;
1385 const char *StrData = Buffer.data()+LocInfo.second;
1388 Lexer TheLexer(
SM.getLocForStartOfFile(LocInfo.first), Features,
1389 Buffer.begin(), StrData, Buffer.end());
1398 if (ByteNo < TokNumBytes ||
1404 if (StartTokenByteOffset !=
nullptr)
1405 *StartTokenByteOffset = StringOffset;
1406 if (StartToken !=
nullptr)
1407 *StartToken = TokNo;
1412 StringOffset += TokNumBytes;
1414 ByteNo -= TokNumBytes;
1422#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;
1423#include "clang/AST/OperationKinds.def"
1425 llvm_unreachable(
"Unknown unary operator");
1431 default: llvm_unreachable(
"No unary operator for overloaded function");
1432 case OO_PlusPlus:
return Postfix ? UO_PostInc : UO_PreInc;
1433 case OO_MinusMinus:
return Postfix ? UO_PostDec : UO_PreDec;
1434 case OO_Amp:
return UO_AddrOf;
1435 case OO_Star:
return UO_Deref;
1436 case OO_Plus:
return UO_Plus;
1437 case OO_Minus:
return UO_Minus;
1438 case OO_Tilde:
return UO_Not;
1439 case OO_Exclaim:
return UO_LNot;
1440 case OO_Coawait:
return UO_Coawait;
1446 case UO_PostInc:
case UO_PreInc:
return OO_PlusPlus;
1447 case UO_PostDec:
case UO_PreDec:
return OO_MinusMinus;
1448 case UO_AddrOf:
return OO_Amp;
1449 case UO_Deref:
return OO_Star;
1450 case UO_Plus:
return OO_Plus;
1451 case UO_Minus:
return OO_Minus;
1452 case UO_Not:
return OO_Tilde;
1453 case UO_LNot:
return OO_Exclaim;
1454 case UO_Coawait:
return OO_Coawait;
1469 NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1470 unsigned NumPreArgs = PreArgs.size();
1472 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1474 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1475 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1476 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1477 "OffsetToTrailingObjects overflow!");
1482 for (
unsigned I = 0; I != NumPreArgs; ++I)
1484 for (
unsigned I = 0; I != Args.size(); ++I)
1486 for (
unsigned I = Args.size(); I != NumArgs; ++I)
1498 :
Expr(SC, Empty), NumArgs(NumArgs) {
1500 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1502 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1503 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1504 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1505 "OffsetToTrailingObjects overflow!");
1514 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1519 return new (Mem)
CallExpr(CallExprClass, Fn, {}, Args, Ty, VK,
1520 RParenLoc, FPFeatures, MinNumArgs,
UsesADL);
1527 "Misaligned memory in CallExpr::CreateTemporary!");
1528 return new (Mem)
CallExpr(CallExprClass, Fn, {}, {}, Ty,
1535 unsigned SizeOfTrailingObjects =
1540 CallExpr(CallExprClass, 0, NumArgs, HasFPFeatures, Empty);
1543unsigned CallExpr::offsetToTrailingObjects(StmtClass SC) {
1547 case CXXOperatorCallExprClass:
1549 case CXXMemberCallExprClass:
1551 case UserDefinedLiteralClass:
1553 case CUDAKernelCallExprClass:
1556 llvm_unreachable(
"unexpected class deriving from CallExpr!");
1563 while (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE))
1568 if (
auto *BO = dyn_cast<BinaryOperator>(CEE)) {
1569 if (BO->isPtrMemOp()) {
1573 }
else if (
auto *UO = dyn_cast<UnaryOperator>(CEE)) {
1574 if (UO->getOpcode() == UO_Deref || UO->getOpcode() == UO_AddrOf ||
1575 UO->getOpcode() == UO_Plus) {
1583 if (
auto *DRE = dyn_cast<DeclRefExpr>(CEE))
1584 return DRE->getDecl();
1585 if (
auto *ME = dyn_cast<MemberExpr>(CEE))
1586 return ME->getMemberDecl();
1587 if (
auto *BE = dyn_cast<BlockExpr>(CEE))
1588 return BE->getBlockDecl();
1596 return FDecl ? FDecl->getBuiltinID() : 0;
1607 QualType CalleeType = Callee->getType();
1613 if (isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))
1616 if (isa<UnresolvedMemberExpr>(Callee->IgnoreParens()))
1621 assert(!CalleeType.
isNull());
1635 if (
const auto *A = TD->getAttr<WarnUnusedResultAttr>())
1639 TD = TD->desugar()->getAs<TypedefType>())
1640 if (
const auto *A = TD->getDecl()->getAttr<WarnUnusedResultAttr>())
1646 return D ? D->
getAttr<WarnUnusedResultAttr>() :
nullptr;
1650 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
this))
1651 return OCE->getBeginLoc();
1659 if (
const auto *OCE = dyn_cast<CXXOperatorCallExpr>(
this))
1660 return OCE->getEndLoc();
1674 void *Mem =
C.Allocate(
1675 totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
1682 unsigned numComps,
unsigned numExprs) {
1684 C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
1693 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1694 NumComps(comps.size()), NumExprs(exprs.size()) {
1695 for (
unsigned i = 0; i != comps.size(); ++i)
1697 for (
unsigned i = 0; i != exprs.size(); ++i)
1715 OpLoc(op), RParenLoc(rp) {
1716 assert(ExprKind <=
UETT_Last &&
"invalid enum value!");
1719 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
1730 :
Expr(MemberExprClass, T, VK, OK),
Base(
Base), MemberDecl(MemberDecl),
1731 MemberDNLoc(NameInfo.
getInfo()), MemberLoc(NameInfo.getLoc()) {
1749 bool HasQualOrFound = QualifierLoc || FoundDecl.getDecl() != MemberDecl ||
1751 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1755 HasQualOrFound ? 1 : 0, HasTemplateKWAndArgsInfo ? 1 : 0,
1756 TemplateArgs ? TemplateArgs->
size() : 0);
1758 void *Mem =
C.Allocate(Size,
alignof(
MemberExpr));
1760 NameInfo, T, VK, OK, NOUR);
1762 if (HasQualOrFound) {
1772 TemplateArgs || TemplateKWLoc.
isValid();
1777 auto TemplateArgDeps = TemplateArgumentDependence::None;
1779 TemplateKWLoc, *TemplateArgs,
1784 }
else if (TemplateKWLoc.
isValid()) {
1794 bool HasQualifier,
bool HasFoundDecl,
1795 bool HasTemplateKWAndArgsInfo,
1796 unsigned NumTemplateArgs) {
1797 assert((!NumTemplateArgs || HasTemplateKWAndArgsInfo) &&
1798 "template args but no template arg info?");
1799 bool HasQualOrFound = HasQualifier || HasFoundDecl;
1803 HasTemplateKWAndArgsInfo ? 1 : 0,
1811 if (
getType()->isUndeducedType())
1827 return BaseStartLoc;
1839bool CastExpr::CastConsistency()
const {
1841 case CK_DerivedToBase:
1842 case CK_UncheckedDerivedToBase:
1843 case CK_DerivedToBaseMemberPointer:
1844 case CK_BaseToDerived:
1845 case CK_BaseToDerivedMemberPointer:
1846 assert(!
path_empty() &&
"Cast kind should have a base path!");
1849 case CK_CPointerToObjCPointerCast:
1850 assert(
getType()->isObjCObjectPointerType());
1852 goto CheckNoBasePath;
1854 case CK_BlockPointerToObjCPointerCast:
1855 assert(
getType()->isObjCObjectPointerType());
1857 goto CheckNoBasePath;
1859 case CK_ReinterpretMemberPointer:
1860 assert(
getType()->isMemberPointerType());
1862 goto CheckNoBasePath;
1868 if (!
getType()->isPointerType()) {
1869 assert(
getType()->isObjCObjectPointerType() ==
1871 assert(
getType()->isBlockPointerType() ==
1874 goto CheckNoBasePath;
1876 case CK_AnyPointerToBlockPointerCast:
1877 assert(
getType()->isBlockPointerType());
1880 goto CheckNoBasePath;
1882 case CK_CopyAndAutoreleaseBlockObject:
1883 assert(
getType()->isBlockPointerType());
1885 goto CheckNoBasePath;
1887 case CK_FunctionToPointerDecay:
1888 assert(
getType()->isPointerType());
1890 goto CheckNoBasePath;
1892 case CK_AddressSpaceConversion: {
1901 (!Ty.
isNull() && !SETy.isNull() &&
1903 goto CheckNoBasePath;
1908 case CK_ArrayToPointerDecay:
1909 case CK_NullToMemberPointer:
1910 case CK_NullToPointer:
1911 case CK_ConstructorConversion:
1912 case CK_IntegralToPointer:
1913 case CK_PointerToIntegral:
1915 case CK_VectorSplat:
1916 case CK_IntegralCast:
1917 case CK_BooleanToSignedIntegral:
1918 case CK_IntegralToFloating:
1919 case CK_FloatingToIntegral:
1920 case CK_FloatingCast:
1921 case CK_ObjCObjectLValueCast:
1922 case CK_FloatingRealToComplex:
1923 case CK_FloatingComplexToReal:
1924 case CK_FloatingComplexCast:
1925 case CK_FloatingComplexToIntegralComplex:
1926 case CK_IntegralRealToComplex:
1927 case CK_IntegralComplexToReal:
1928 case CK_IntegralComplexCast:
1929 case CK_IntegralComplexToFloatingComplex:
1930 case CK_ARCProduceObject:
1931 case CK_ARCConsumeObject:
1932 case CK_ARCReclaimReturnedObject:
1933 case CK_ARCExtendBlockObject:
1934 case CK_ZeroToOCLOpaqueType:
1935 case CK_IntToOCLSampler:
1936 case CK_FloatingToFixedPoint:
1937 case CK_FixedPointToFloating:
1938 case CK_FixedPointCast:
1939 case CK_FixedPointToIntegral:
1940 case CK_IntegralToFixedPoint:
1943 goto CheckNoBasePath;
1946 case CK_LValueToRValue:
1948 case CK_AtomicToNonAtomic:
1949 case CK_NonAtomicToAtomic:
1950 case CK_PointerToBoolean:
1951 case CK_IntegralToBoolean:
1952 case CK_FloatingToBoolean:
1953 case CK_MemberPointerToBoolean:
1954 case CK_FloatingComplexToBoolean:
1955 case CK_IntegralComplexToBoolean:
1956 case CK_LValueBitCast:
1957 case CK_LValueToRValueBitCast:
1958 case CK_UserDefinedConversion:
1959 case CK_BuiltinFnToFnPtr:
1960 case CK_FixedPointToBoolean:
1962 assert(
path_empty() &&
"Cast kind should not have a base path!");
1970#define CAST_OPERATION(Name) case CK_##Name: return #Name;
1971#include "clang/AST/OperationKinds.def"
1973 llvm_unreachable(
"Unhandled cast kind!");
1979static Expr *ignoreImplicitSemaNodes(
Expr *E) {
1980 if (
auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E))
1981 return Materialize->getSubExpr();
1983 if (
auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
1984 return Binder->getSubExpr();
1986 if (
auto *Full = dyn_cast<FullExpr>(E))
1987 return Full->getSubExpr();
1989 if (
auto *CPLIE = dyn_cast<CXXParenListInitExpr>(E);
1990 CPLIE && CPLIE->getInitExprs().size() == 1)
1991 return CPLIE->getInitExprs()[0];
1998 const Expr *SubExpr =
nullptr;
2000 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
2005 if (E->getCastKind() == CK_ConstructorConversion) {
2007 ignoreImplicitSemaNodes);
2008 }
else if (E->getCastKind() == CK_UserDefinedConversion) {
2009 assert((isa<CXXMemberCallExpr>(SubExpr) || isa<BlockExpr>(SubExpr)) &&
2010 "Unexpected SubExpr for CK_UserDefinedConversion.");
2011 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
2012 SubExpr = MCE->getImplicitObjectArgument();
2016 return const_cast<Expr *
>(SubExpr);
2020 const Expr *SubExpr =
nullptr;
2022 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
2025 if (E->getCastKind() == CK_ConstructorConversion)
2026 return cast<CXXConstructExpr>(SubExpr)->getConstructor();
2028 if (E->getCastKind() == CK_UserDefinedConversion) {
2029 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
2030 return MCE->getMethodDecl();
2039#define ABSTRACT_STMT(x)
2040#define CASTEXPR(Type, Base) \
2041 case Stmt::Type##Class: \
2042 return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>();
2043#define STMT(Type, Base)
2044#include "clang/AST/StmtNodes.inc"
2046 llvm_unreachable(
"non-cast expressions not possible here");
2061 Field != FieldEnd; ++Field) {
2063 !Field->isUnnamedBitfield()) {
2073 case ImplicitCastExprClass:
2075 ->getTrailingObjects<FPOptionsOverride>();
2076 case CStyleCastExprClass:
2078 ->getTrailingObjects<FPOptionsOverride>();
2079 case CXXFunctionalCastExprClass:
2081 ->getTrailingObjects<FPOptionsOverride>();
2082 case CXXStaticCastExprClass:
2084 ->getTrailingObjects<FPOptionsOverride>();
2086 llvm_unreachable(
"Cast does not have FPFeatures");
2095 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2097 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2101 assert((Kind != CK_LValueToRValue ||
2103 "invalid type for lvalue-to-rvalue conversion");
2107 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2114 bool HasFPFeatures) {
2116 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2117 PathSize, HasFPFeatures));
2127 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2129 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2132 new (Buffer)
CStyleCastExpr(T, VK, K, Op, PathSize, FPO, WrittenTy, L, R);
2134 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2141 bool HasFPFeatures) {
2143 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2144 PathSize, HasFPFeatures));
2152#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;
2153#include "clang/AST/OperationKinds.def"
2155 llvm_unreachable(
"Invalid OpCode!");
2161 default: llvm_unreachable(
"Not an overloadable binary operator");
2162 case OO_Plus:
return BO_Add;
2163 case OO_Minus:
return BO_Sub;
2164 case OO_Star:
return BO_Mul;
2165 case OO_Slash:
return BO_Div;
2166 case OO_Percent:
return BO_Rem;
2167 case OO_Caret:
return BO_Xor;
2168 case OO_Amp:
return BO_And;
2169 case OO_Pipe:
return BO_Or;
2170 case OO_Equal:
return BO_Assign;
2171 case OO_Spaceship:
return BO_Cmp;
2172 case OO_Less:
return BO_LT;
2173 case OO_Greater:
return BO_GT;
2174 case OO_PlusEqual:
return BO_AddAssign;
2175 case OO_MinusEqual:
return BO_SubAssign;
2176 case OO_StarEqual:
return BO_MulAssign;
2177 case OO_SlashEqual:
return BO_DivAssign;
2178 case OO_PercentEqual:
return BO_RemAssign;
2179 case OO_CaretEqual:
return BO_XorAssign;
2180 case OO_AmpEqual:
return BO_AndAssign;
2181 case OO_PipeEqual:
return BO_OrAssign;
2182 case OO_LessLess:
return BO_Shl;
2183 case OO_GreaterGreater:
return BO_Shr;
2184 case OO_LessLessEqual:
return BO_ShlAssign;
2185 case OO_GreaterGreaterEqual:
return BO_ShrAssign;
2186 case OO_EqualEqual:
return BO_EQ;
2187 case OO_ExclaimEqual:
return BO_NE;
2188 case OO_LessEqual:
return BO_LE;
2189 case OO_GreaterEqual:
return BO_GE;
2190 case OO_AmpAmp:
return BO_LAnd;
2191 case OO_PipePipe:
return BO_LOr;
2192 case OO_Comma:
return BO_Comma;
2193 case OO_ArrowStar:
return BO_PtrMemI;
2200 OO_Star, OO_Slash, OO_Percent,
2202 OO_LessLess, OO_GreaterGreater,
2204 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
2205 OO_EqualEqual, OO_ExclaimEqual,
2211 OO_Equal, OO_StarEqual,
2212 OO_SlashEqual, OO_PercentEqual,
2213 OO_PlusEqual, OO_MinusEqual,
2214 OO_LessLessEqual, OO_GreaterGreaterEqual,
2215 OO_AmpEqual, OO_CaretEqual,
2219 return OverOps[Opc];
2261 BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {
2269 return "__builtin_FILE";
2271 return "__builtin_FILE_NAME";
2273 return "__builtin_FUNCTION";
2275 return "__builtin_FUNCSIG";
2277 return "__builtin_LINE";
2279 return "__builtin_COLUMN";
2281 return "__builtin_source_location";
2283 llvm_unreachable(
"unexpected IdentKind!");
2287 const Expr *DefaultExpr)
const {
2291 if (
const auto *DIE = dyn_cast_if_present<CXXDefaultInitExpr>(DefaultExpr)) {
2292 Loc = DIE->getUsedLocation();
2293 Context = DIE->getUsedContext();
2294 }
else if (
const auto *DAE =
2295 dyn_cast_if_present<CXXDefaultArgExpr>(DefaultExpr)) {
2296 Loc = DAE->getUsedLocation();
2297 Context = DAE->getUsedContext();
2306 auto MakeStringLiteral = [&](StringRef Tmp) {
2310 LValuePathEntry Path[1] = {LValuePathEntry::ArrayIndex(0)};
2321 return MakeStringLiteral(
FileName);
2327 return MakeStringLiteral(Path);
2331 const auto *CurDecl = dyn_cast<Decl>(Context);
2335 return MakeStringLiteral(
2355 StringRef Name = F->getName();
2356 if (Name ==
"_M_file_name") {
2360 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(Path);
2361 }
else if (Name ==
"_M_function_name") {
2364 const auto *CurDecl = dyn_cast<Decl>(Context);
2365 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(
2366 CurDecl && !isa<TranslationUnitDecl>(CurDecl)
2370 }
else if (Name ==
"_M_line") {
2372 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2373 }
else if (Name ==
"_M_column") {
2375 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2386 llvm_unreachable(
"unhandled case");
2392 InitExprs(
C, initExprs.size()), LBraceLoc(lbraceloc),
2393 RBraceLoc(rbraceloc), AltForm(nullptr,
true) {
2395 InitExprs.
insert(
C, InitExprs.
end(), initExprs.begin(), initExprs.end());
2401 if (NumInits > InitExprs.
size())
2406 InitExprs.
resize(
C, NumInits,
nullptr);
2410 if (Init >= InitExprs.
size()) {
2411 InitExprs.
insert(
C, InitExprs.
end(), Init - InitExprs.
size() + 1,
nullptr);
2416 Expr *
Result = cast_or_null<Expr>(InitExprs[Init]);
2423 ArrayFillerOrUnionFieldInit = filler;
2426 for (
unsigned i = 0, e =
getNumInits(); i != e; ++i)
2427 if (
inits[i] ==
nullptr)
2441 Init = Init->IgnoreParenImpCasts();
2442 return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init);
2446 assert(
isSemanticForm() &&
"syntactic form never semantically transparent");
2450 assert(
getNumInits() == 1 &&
"multiple inits in glvalue init list");
2469 assert(
isSyntacticForm() &&
"only test syntactic form as zero initializer");
2476 return Lit && Lit->
getValue() == 0;
2481 return SyntacticForm->getBeginLoc();
2486 E = InitExprs.
end();
2489 Beg = S->getBeginLoc();
2499 return SyntacticForm->getEndLoc();
2501 if (End.isInvalid()) {
2503 for (
Stmt *S : llvm::reverse(InitExprs)) {
2505 End = S->getEndLoc();
2517 return cast<BlockPointerType>(
getType())
2548 if (isa<DeclRefExpr>(E))
2552 if (isa<ArraySubscriptExpr>(E))
2556 if (isa<MemberExpr>(E))
2560 if (
auto *UO = dyn_cast<UnaryOperator>(E))
2561 if (UO->getOpcode() == UO_Deref)
2564 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
2566 if (BO->isPtrMemOp())
2570 if (BO->getOpcode() == BO_Comma)
2571 return BO->getRHS()->isReadIfDiscardedInCPlusPlus11();
2576 if (
auto *CO = dyn_cast<ConditionalOperator>(E))
2577 return CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&
2578 CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2581 dyn_cast<BinaryConditionalOperator>(E)) {
2582 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
2583 return OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&
2584 BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2588 if (isa<ObjCIvarRefExpr>(E))
2590 if (
const auto *POE = dyn_cast<PseudoObjectExpr>(E)) {
2591 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(POE->getSyntacticForm()))
2618 case ParenExprClass:
2619 return cast<ParenExpr>(
this)->getSubExpr()->
2621 case GenericSelectionExprClass:
2622 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
2624 case CoawaitExprClass:
2625 case CoyieldExprClass:
2626 return cast<CoroutineSuspendExpr>(
this)->getResumeExpr()->
2628 case ChooseExprClass:
2629 return cast<ChooseExpr>(
this)->getChosenSubExpr()->
2631 case UnaryOperatorClass: {
2665 case BinaryOperatorClass: {
2677 if (IE->getValue() == 0)
2696 case CompoundAssignOperatorClass:
2697 case VAArgExprClass:
2698 case AtomicExprClass:
2701 case ConditionalOperatorClass: {
2705 const auto *Exp = cast<ConditionalOperator>(
this);
2706 return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) &&
2707 Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2709 case BinaryConditionalOperatorClass: {
2710 const auto *Exp = cast<BinaryConditionalOperator>(
this);
2711 return Exp->getFalseExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2714 case MemberExprClass:
2716 Loc = cast<MemberExpr>(
this)->getMemberLoc();
2718 R2 = cast<MemberExpr>(
this)->getBase()->getSourceRange();
2721 case ArraySubscriptExprClass:
2723 Loc = cast<ArraySubscriptExpr>(
this)->getRBracketLoc();
2724 R1 = cast<ArraySubscriptExpr>(
this)->getLHS()->getSourceRange();
2725 R2 = cast<ArraySubscriptExpr>(
this)->getRHS()->getSourceRange();
2728 case CXXOperatorCallExprClass: {
2740 case OO_ExclaimEqual:
2743 case OO_GreaterEqual:
2758 case CXXMemberCallExprClass:
2759 case UserDefinedLiteralClass: {
2761 const CallExpr *CE = cast<CallExpr>(
this);
2769 FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {
2784 case UnresolvedLookupExprClass:
2785 case CXXUnresolvedConstructExprClass:
2786 case RecoveryExprClass:
2789 case CXXTemporaryObjectExprClass:
2790 case CXXConstructExprClass: {
2792 const auto *WarnURAttr =
Type->getAttr<WarnUnusedResultAttr>();
2794 (WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {
2802 const auto *CE = cast<CXXConstructExpr>(
this);
2804 const auto *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
2805 if (WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {
2810 if (
unsigned NumArgs = CE->getNumArgs())
2812 CE->getArg(NumArgs - 1)->getEndLoc());
2820 case ObjCMessageExprClass: {
2833 if (MD->hasAttr<WarnUnusedResultAttr>()) {
2842 case ObjCPropertyRefExprClass:
2843 case ObjCSubscriptRefExprClass:
2849 case PseudoObjectExprClass: {
2850 const auto *POE = cast<PseudoObjectExpr>(
this);
2853 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(
2854 POE->getSyntacticForm())) {
2862 if (
auto *BO = dyn_cast<BinaryOperator>(POE->getSyntacticForm()))
2863 if (BO->isAssignmentOp())
2865 if (
auto *UO = dyn_cast<UnaryOperator>(POE->getSyntacticForm()))
2866 if (UO->isIncrementDecrementOp())
2871 return Result &&
Result->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2874 case StmtExprClass: {
2880 const CompoundStmt *CS = cast<StmtExpr>(
this)->getSubStmt();
2885 if (
const Expr *E = dyn_cast<Expr>(
Label->getSubStmt()))
2892 Loc = cast<StmtExpr>(
this)->getLParenLoc();
2896 case CXXFunctionalCastExprClass:
2897 case CStyleCastExprClass: {
2904 const CastExpr *CE = cast<CastExpr>(
this);
2911 if (
auto *DRE = dyn_cast<DeclRefExpr>(SubE))
2912 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
2913 if (!VD->isExternallyVisible())
2929 if (CE->
getCastKind() == CK_ConstructorConversion)
2936 dyn_cast<CXXFunctionalCastExpr>(
this)) {
2937 Loc = CXXCE->getBeginLoc();
2938 R1 = CXXCE->getSubExpr()->getSourceRange();
2946 case ImplicitCastExprClass: {
2947 const CastExpr *ICE = cast<ImplicitCastExpr>(
this);
2956 case CXXDefaultArgExprClass:
2957 return (cast<CXXDefaultArgExpr>(
this)
2959 case CXXDefaultInitExprClass:
2960 return (cast<CXXDefaultInitExpr>(
this)
2963 case CXXNewExprClass:
2966 case CXXDeleteExprClass:
2968 case MaterializeTemporaryExprClass:
2969 return cast<MaterializeTemporaryExpr>(
this)
2971 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2972 case CXXBindTemporaryExprClass:
2973 return cast<CXXBindTemporaryExpr>(
this)->getSubExpr()
2974 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2975 case ExprWithCleanupsClass:
2976 return cast<ExprWithCleanups>(
this)->getSubExpr()
2977 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2988 case ObjCIvarRefExprClass:
2990 case Expr::UnaryOperatorClass:
2991 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2992 case ImplicitCastExprClass:
2993 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2994 case MaterializeTemporaryExprClass:
2995 return cast<MaterializeTemporaryExpr>(E)->getSubExpr()->isOBJCGCCandidate(
2997 case CStyleCastExprClass:
2998 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2999 case DeclRefExprClass: {
3000 const Decl *D = cast<DeclRefExpr>(E)->getDecl();
3002 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
3003 if (VD->hasGlobalStorage())
3013 case MemberExprClass: {
3017 case ArraySubscriptExprClass:
3018 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
3029 assert(
expr->hasPlaceholderType(BuiltinType::BoundMember));
3037 assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
3038 return mem->getMemberDecl()->getType();
3044 assert(
type->isFunctionType());
3048 assert(isa<UnresolvedMemberExpr>(
expr) || isa<CXXPseudoDestructorExpr>(
expr));
3082 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
this)) {
3083 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
3084 return MCE->getImplicitObjectArgument();
3100 auto IgnoreNoopCastsSingleStep = [&Ctx](
Expr *E) {
3101 if (
auto *CE = dyn_cast<CastExpr>(E)) {
3104 Expr *SubExpr = CE->getSubExpr();
3105 bool IsIdentityCast =
3114 if (IsIdentityCast || IsSameWidthCast)
3116 }
else if (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
3117 return NTTP->getReplacement();
3122 IgnoreNoopCastsSingleStep);
3127 if (
auto *Cast = dyn_cast<CXXFunctionalCastExpr>(E)) {
3128 auto *SE = Cast->getSubExpr();
3133 if (
auto *
C = dyn_cast<CXXConstructExpr>(E)) {
3134 auto NumArgs =
C->getNumArgs();
3136 (NumArgs > 1 && isa<CXXDefaultArgExpr>(
C->getArg(1)))) {
3137 Expr *A =
C->getArg(0);
3144 auto IgnoreImplicitMemberCallSingleStep = [](
Expr *E) {
3145 if (
auto *
C = dyn_cast<CXXMemberCallExpr>(E)) {
3146 Expr *ExprNode =
C->getImplicitObjectArgument();
3150 if (
auto *PE = dyn_cast<ParenExpr>(ExprNode)) {
3151 if (PE->getSourceRange() ==
C->getSourceRange()) {
3152 return cast<Expr>(PE);
3164 IgnoreImplicitMemberCallSingleStep);
3168 const Expr *E =
this;
3170 E = M->getSubExpr();
3173 E = ICE->getSubExprAsWritten();
3175 return isa<CXXDefaultArgExpr>(E);
3182 E = M->getSubExpr();
3185 if (ICE->getCastKind() == CK_NoOp)
3186 E = ICE->getSubExpr();
3192 E = BE->getSubExpr();
3195 if (ICE->getCastKind() == CK_NoOp)
3196 E = ICE->getSubExpr();
3207 if (!
C.hasSameUnqualifiedType(
getType(),
C.getTypeDeclType(TempTy)))
3215 if (!isa<ObjCPropertyRefExpr>(E))
3223 if (isa<ImplicitCastExpr>(E)) {
3224 switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
3225 case CK_DerivedToBase:
3226 case CK_UncheckedDerivedToBase:
3234 if (isa<MemberExpr>(E))
3238 if (BO->isPtrMemOp())
3242 if (isa<OpaqueValueExpr>(E))
3249 const Expr *E =
this;
3254 E =
Paren->getSubExpr();
3259 if (ICE->getCastKind() == CK_NoOp ||
3260 ICE->getCastKind() == CK_LValueToRValue ||
3261 ICE->getCastKind() == CK_DerivedToBase ||
3262 ICE->getCastKind() == CK_UncheckedDerivedToBase) {
3263 E = ICE->getSubExpr();
3268 if (
const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
3269 if (UnOp->getOpcode() == UO_Extension) {
3270 E = UnOp->getSubExpr();
3276 = dyn_cast<MaterializeTemporaryExpr>(E)) {
3277 E = M->getSubExpr();
3284 if (
const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
3285 return This->isImplicit();
3293 for (
unsigned I = 0; I < Exprs.size(); ++I)
3301 const Expr **Culprit)
const {
3303 "Expression evaluator can't be called on a dependent expression.");
3315 if (
auto *EWC = dyn_cast<ExprWithCleanups>(
this))
3316 return EWC->getSubExpr()->isConstantInitializer(Ctx,
true, Culprit);
3317 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(
this))
3318 return MTE->getSubExpr()->isConstantInitializer(Ctx,
false, Culprit);
3329 case Stmt::ExprWithCleanupsClass:
3331 Ctx, IsForRef, Culprit);
3332 case StringLiteralClass:
3333 case ObjCEncodeExprClass:
3335 case CXXTemporaryObjectExprClass:
3336 case CXXConstructExprClass: {
3345 assert(CE->
getNumArgs() == 1 &&
"trivial ctor with > 1 argument");
3351 case ConstantExprClass: {
3354 const Expr *Exp = cast<ConstantExpr>(
this)->getSubExpr();
3357 case CompoundLiteralExprClass: {
3361 const Expr *Exp = cast<CompoundLiteralExpr>(
this)->getInitializer();
3364 case DesignatedInitUpdateExprClass: {
3369 case InitListExprClass: {
3371 assert(ILE->
isSemanticForm() &&
"InitListExpr must be in semantic form");
3374 for (
unsigned i = 0; i < numInits; i++) {
3382 unsigned ElementNo = 0;
3384 for (
const auto *Field : RD->
fields()) {
3390 if (Field->isUnnamedBitfield())
3393 if (ElementNo < ILE->getNumInits()) {
3395 if (Field->isBitField()) {
3404 bool RefType = Field->getType()->isReferenceType();
3415 case ImplicitValueInitExprClass:
3416 case NoInitExprClass:
3418 case ParenExprClass:
3419 return cast<ParenExpr>(
this)->getSubExpr()
3420 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3421 case GenericSelectionExprClass:
3422 return cast<GenericSelectionExpr>(
this)->getResultExpr()
3423 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3424 case ChooseExprClass:
3425 if (cast<ChooseExpr>(
this)->isConditionDependent()) {
3430 return cast<ChooseExpr>(
this)->getChosenSubExpr()
3432 case UnaryOperatorClass: {
3438 case CXXFunctionalCastExprClass:
3439 case CXXStaticCastExprClass:
3440 case ImplicitCastExprClass:
3441 case CStyleCastExprClass:
3442 case ObjCBridgedCastExprClass:
3443 case CXXDynamicCastExprClass:
3444 case CXXReinterpretCastExprClass:
3445 case CXXAddrspaceCastExprClass:
3446 case CXXConstCastExprClass: {
3447 const CastExpr *CE = cast<CastExpr>(
this);
3462 case MaterializeTemporaryExprClass:
3463 return cast<MaterializeTemporaryExpr>(
this)
3465 ->isConstantInitializer(Ctx,
false, Culprit);
3467 case SubstNonTypeTemplateParmExprClass:
3468 return cast<SubstNonTypeTemplateParmExpr>(
this)->getReplacement()
3469 ->isConstantInitializer(Ctx,
false, Culprit);
3470 case CXXDefaultArgExprClass:
3471 return cast<CXXDefaultArgExpr>(
this)->getExpr()
3472 ->isConstantInitializer(Ctx,
false, Culprit);
3473 case CXXDefaultInitExprClass:
3474 return cast<CXXDefaultInitExpr>(
this)->getExpr()
3475 ->isConstantInitializer(Ctx,
false, Culprit);
3489 if (BuiltinID != Builtin::BI__assume &&
3490 BuiltinID != Builtin::BI__builtin_assume)
3507 const bool IncludePossibleEffects;
3508 bool HasSideEffects;
3511 explicit SideEffectFinder(
const ASTContext &Context,
bool IncludePossible)
3512 : Inherited(Context),
3513 IncludePossibleEffects(IncludePossible), HasSideEffects(
false) { }
3515 bool hasSideEffects()
const {
return HasSideEffects; }
3517 void VisitDecl(
const Decl *D) {
3523 if (
auto *VD = dyn_cast<VarDecl>(D)) {
3525 if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&
3526 VD->needsDestruction(Context))
3527 HasSideEffects =
true;
3531 void VisitDeclStmt(
const DeclStmt *DS) {
3532 for (
auto *D : DS->
decls())
3534 Inherited::VisitDeclStmt(DS);
3537 void VisitExpr(
const Expr *E) {
3538 if (!HasSideEffects &&
3540 HasSideEffects =
true;
3546 bool IncludePossibleEffects)
const {
3550 if (!IncludePossibleEffects &&
getExprLoc().isMacroID())
3555 #define ABSTRACT_STMT(Type)
3556 #define STMT(Type, Base) case Type##Class:
3557 #define EXPR(Type, Base)
3558 #include "clang/AST/StmtNodes.inc"
3559 llvm_unreachable(
"unexpected Expr kind");
3561 case DependentScopeDeclRefExprClass:
3562 case CXXUnresolvedConstructExprClass:
3563 case CXXDependentScopeMemberExprClass:
3564 case UnresolvedLookupExprClass:
3565 case UnresolvedMemberExprClass:
3566 case PackExpansionExprClass:
3567 case SubstNonTypeTemplateParmPackExprClass:
3568 case FunctionParmPackExprClass:
3570 case RecoveryExprClass:
3571 case CXXFoldExprClass:
3573 return IncludePossibleEffects;
3575 case DeclRefExprClass:
3576 case ObjCIvarRefExprClass:
3577 case PredefinedExprClass:
3578 case IntegerLiteralClass:
3579 case FixedPointLiteralClass:
3580 case FloatingLiteralClass:
3581 case ImaginaryLiteralClass:
3582 case StringLiteralClass:
3583 case CharacterLiteralClass:
3584 case OffsetOfExprClass:
3585 case ImplicitValueInitExprClass:
3586 case UnaryExprOrTypeTraitExprClass:
3587 case AddrLabelExprClass:
3588 case GNUNullExprClass:
3589 case ArrayInitIndexExprClass:
3590 case NoInitExprClass:
3591 case CXXBoolLiteralExprClass:
3592 case CXXNullPtrLiteralExprClass:
3593 case CXXThisExprClass:
3594 case CXXScalarValueInitExprClass:
3595 case TypeTraitExprClass:
3596 case ArrayTypeTraitExprClass:
3597 case ExpressionTraitExprClass:
3598 case CXXNoexceptExprClass:
3599 case SizeOfPackExprClass:
3600 case ObjCStringLiteralClass:
3601 case ObjCEncodeExprClass:
3602 case ObjCBoolLiteralExprClass:
3603 case ObjCAvailabilityCheckExprClass:
3604 case CXXUuidofExprClass:
3605 case OpaqueValueExprClass:
3606 case SourceLocExprClass:
3607 case ConceptSpecializationExprClass:
3608 case RequiresExprClass:
3609 case SYCLUniqueStableNameExprClass:
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();
4117 if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)
4126 if (isa<ExtVectorElementExpr>(E))
4129 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4130 if (
auto *BD = dyn_cast<BindingDecl>(DRE->getDecl()))
4131 if (
auto *E = BD->getBinding())
4140 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
4141 if (
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
4143 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
4159 case CXXThisExprClass:
4161 case DeclRefExprClass: {
4164 const auto *DRE1 = cast<DeclRefExpr>(E1);
4165 const auto *DRE2 = cast<DeclRefExpr>(E2);
4166 return DRE1->isPRValue() && DRE2->isPRValue() &&
4167 DRE1->getDecl() == DRE2->getDecl();
4169 case ImplicitCastExprClass: {
4172 const auto *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
4173 const auto *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
4176 if (ICE1->getCastKind() != ICE2->getCastKind())
4181 if (ICE1->getCastKind() == CK_LValueToRValue ||
4182 ICE1->getCastKind() == CK_ArrayToPointerDecay ||
4183 ICE1->getCastKind() == CK_FunctionToPointerDecay) {
4188 const auto *DRE1 = dyn_cast<DeclRefExpr>(E1);
4189 const auto *DRE2 = dyn_cast<DeclRefExpr>(E2);
4193 const auto *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
4194 const auto *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
4195 if (Ivar1 && Ivar2) {
4196 return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
4200 const auto *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
4201 const auto *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
4202 if (Array1 && Array2) {
4206 auto Idx1 = Array1->getIdx();
4207 auto Idx2 = Array2->getIdx();
4208 const auto Integer1 = dyn_cast<IntegerLiteral>(Idx1);
4209 const auto Integer2 = dyn_cast<IntegerLiteral>(Idx2);
4210 if (Integer1 && Integer2) {
4211 if (!llvm::APInt::isSameValue(Integer1->getValue(),
4212 Integer2->getValue()))
4223 while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
4224 const auto *ME1 = cast<MemberExpr>(E1);
4225 const auto *ME2 = cast<MemberExpr>(E2);
4228 if (
const auto *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
4229 if (D->isStaticDataMember())
4235 if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
4241 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
4242 return DRE->getDecl();
4243 if (
const auto *ME = dyn_cast<MemberExpr>(E))
4244 return ME->getMemberDecl();
4263 return VT->getNumElements();
4271 StringRef Comp = Accessor->
getName();
4274 if (Comp ==
"hi" || Comp ==
"lo" || Comp ==
"even" || Comp ==
"odd")
4278 if (Comp[0] ==
's' || Comp[0] ==
'S')
4279 Comp = Comp.substr(1);
4281 for (
unsigned i = 0, e = Comp.size(); i != e; ++i)
4282 if (Comp.substr(i + 1).contains(Comp[i]))
4291 StringRef Comp = Accessor->
getName();
4292 bool isNumericAccessor =
false;
4293 if (Comp[0] ==
's' || Comp[0] ==
'S') {
4294 Comp = Comp.substr(1);
4295 isNumericAccessor =
true;
4298 bool isHi = Comp ==
"hi";
4299 bool isLo = Comp ==
"lo";
4300 bool isEven = Comp ==
"even";
4301 bool isOdd = Comp ==
"odd";
4317 Elts.push_back(Index);
4325 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
4326 SubExprs =
new (
C)
Stmt*[args.size()];
4327 for (
unsigned i = 0; i != args.size(); i++)
4328 SubExprs[i] = args[i];
4334 if (SubExprs)
C.Deallocate(SubExprs);
4336 this->NumExprs = Exprs.size();
4337 SubExprs =
new (
C)
Stmt*[NumExprs];
4338 memcpy(SubExprs, Exprs.data(),
sizeof(
Expr *) * Exprs.size());
4341GenericSelectionExpr::GenericSelectionExpr(
4345 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex)
4346 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4347 AssocExprs[ResultIndex]->getValueKind(),
4348 AssocExprs[ResultIndex]->getObjectKind()),
4349 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4350 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4351 assert(AssocTypes.size() == AssocExprs.size() &&
4352 "Must have the same number of association expressions"
4353 " and TypeSourceInfo!");
4354 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4357 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4359 std::copy(AssocExprs.begin(), AssocExprs.end(),
4360 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4361 std::copy(AssocTypes.begin(), AssocTypes.end(),
4362 getTrailingObjects<TypeSourceInfo *>() +
4363 getIndexOfStartOfAssociatedTypes());
4368GenericSelectionExpr::GenericSelectionExpr(
4373 unsigned ResultIndex)
4374 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4375 AssocExprs[ResultIndex]->getValueKind(),
4376 AssocExprs[ResultIndex]->getObjectKind()),
4377 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4378 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4379 assert(AssocTypes.size() == AssocExprs.size() &&
4380 "Must have the same number of association expressions"
4381 " and TypeSourceInfo!");
4382 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4385 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4387 std::copy(AssocExprs.begin(), AssocExprs.end(),
4388 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4389 std::copy(AssocTypes.begin(), AssocTypes.end(),
4390 getTrailingObjects<TypeSourceInfo *>() +
4391 getIndexOfStartOfAssociatedTypes());
4396GenericSelectionExpr::GenericSelectionExpr(
4400 bool ContainsUnexpandedParameterPack)
4401 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4403 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4404 IsExprPredicate(
true), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4405 assert(AssocTypes.size() == AssocExprs.size() &&
4406 "Must have the same number of association expressions"
4407 " and TypeSourceInfo!");
4410 getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =
4412 std::copy(AssocExprs.begin(), AssocExprs.end(),
4413 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4414 std::copy(AssocTypes.begin(), AssocTypes.end(),
4415 getTrailingObjects<TypeSourceInfo *>() +
4416 getIndexOfStartOfAssociatedTypes());
4421GenericSelectionExpr::GenericSelectionExpr(
4426 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4428 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4429 IsExprPredicate(
false), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4430 assert(AssocTypes.size() == AssocExprs.size() &&
4431 "Must have the same number of association expressions"
4432 " and TypeSourceInfo!");
4435 getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =
4437 std::copy(AssocExprs.begin(), AssocExprs.end(),
4438 getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());
4439 std::copy(AssocTypes.begin(), AssocTypes.end(),
4440 getTrailingObjects<TypeSourceInfo *>() +
4441 getIndexOfStartOfAssociatedTypes());
4446GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty,
unsigned NumAssocs)
4447 :
Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
4453 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex) {
4454 unsigned NumAssocs = AssocExprs.size();
4456 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4459 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4460 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4467 bool ContainsUnexpandedParameterPack) {
4468 unsigned NumAssocs = AssocExprs.size();
4470 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4473 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4474 RParenLoc, ContainsUnexpandedParameterPack);
4482 unsigned ResultIndex) {
4483 unsigned NumAssocs = AssocExprs.size();
4485 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4488 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4489 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4496 SourceLocation RParenLoc,
bool ContainsUnexpandedParameterPack) {
4497 unsigned NumAssocs = AssocExprs.size();
4499 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4502 Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,
4503 RParenLoc, ContainsUnexpandedParameterPack);
4508 unsigned NumAssocs) {
4510 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4533 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
4534 NumDesignators(Designators.
size()), NumSubExprs(IndexExprs.
size() + 1) {
4535 this->Designators =
new (
C)
Designator[NumDesignators];
4543 unsigned IndexIdx = 0;
4544 for (
unsigned I = 0; I != NumDesignators; ++I) {
4545 this->Designators[I] = Designators[I];
4548 *Child++ = IndexExprs[IndexIdx++];
4551 *Child++ = IndexExprs[IndexIdx++];
4552 *Child++ = IndexExprs[IndexIdx++];
4556 assert(IndexIdx == IndexExprs.size() &&
"Wrong number of index expressions");
4565 bool UsesColonSyntax,
Expr *Init) {
4566 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
4569 ColonOrEqualLoc, UsesColonSyntax,
4574 unsigned NumIndexExprs) {
4575 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
4582 unsigned NumDesigs) {
4584 NumDesignators = NumDesigs;
4585 for (
unsigned I = 0; I != NumDesigs; ++I)
4586 Designators[I] = Desigs[I];
4600 if (
First.isFieldDesignator())
4601 return GNUSyntax ?
First.getFieldLoc() :
First.getDotLoc();
4602 return First.getLBracketLoc();
4629 unsigned NumNewDesignators =
Last -
First;
4630 if (NumNewDesignators == 0) {
4631 std::copy_backward(Designators + Idx + 1,
4632 Designators + NumDesignators,
4634 --NumNewDesignators;
4637 if (NumNewDesignators == 1) {
4638 Designators[Idx] = *
First;
4643 =
new (
C)
Designator[NumDesignators - 1 + NumNewDesignators];
4644 std::copy(Designators, Designators + Idx, NewDesignators);
4645 std::copy(
First,
Last, NewDesignators + Idx);
4646 std::copy(Designators + Idx + 1, Designators + NumDesignators,
4647 NewDesignators + Idx + NumNewDesignators);
4648 Designators = NewDesignators;
4649 NumDesignators = NumDesignators - 1 + NumNewDesignators;
4658 BaseAndUpdaterExprs[0] = baseExpr;
4663 BaseAndUpdaterExprs[1] = ILE;
4680 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4683 for (
unsigned I = 0, N = Exprs.size(); I != N; ++I)
4684 getTrailingObjects<Stmt *>()[I] = Exprs[I];
4688ParenListExpr::ParenListExpr(EmptyShell Empty,
unsigned NumExprs)
4689 :
Expr(ParenListExprClass, Empty) {
4697 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
4699 return new (Mem)
ParenListExpr(LParenLoc, Exprs, RParenLoc);
4703 unsigned NumExprs) {
4713 :
Expr(BinaryOperatorClass, ResTy, VK, OK) {
4716 "Use CompoundAssignOperator for compound assignments");
4718 SubExprs[LHS] = lhs;
4719 SubExprs[RHS] = rhs;
4730 :
Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
4733 "Use CompoundAssignOperator for compound assignments");
4735 SubExprs[LHS] = lhs;
4736 SubExprs[RHS] = rhs;
4744 bool HasFPFeatures) {
4784 CompLHSType, CompResultType);
4788 bool hasFPFeatures) {
4789 void *Mem =
C.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),
4798 :
Expr(UnaryOperatorClass,
type, VK, OK), Val(input) {
4814 unsigned Size = totalSizeToAlloc<FPOptionsOverride>(HasFPFeatures);
4822 e = ewc->getSubExpr();
4824 e = m->getSubExpr();
4825 e = cast<CXXConstructExpr>(e)->getArg(0);
4827 e = ice->getSubExpr();
4828 return cast<OpaqueValueExpr>(e);
4833 unsigned numSemanticExprs) {
4835 Context.
Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
4840PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell,
unsigned numSemanticExprs)
4841 :
Expr(PseudoObjectExprClass, shell) {
4847 unsigned resultIndex) {
4848 assert(syntax &&
"no syntactic expression!");
4849 assert(
semantics.size() &&
"no semantic expressions!");
4859 VK =
semantics[resultIndex]->getValueKind();
4863 void *buffer =
C.Allocate(totalSizeToAlloc<Expr *>(
semantics.size() + 1),
4871 unsigned resultIndex)
4876 for (
unsigned i = 0, e =
semantics.size() + 1; i != e; ++i) {
4878 getSubExprsBuffer()[i] = E;
4880 if (isa<OpaqueValueExpr>(E))
4881 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() !=
nullptr &&
4882 "opaque-value semantic expressions for pseudo-object "
4883 "operations must have sources");
4916 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
4917 assert(args.size() ==
getNumSubExprs(op) &&
"wrong number of subexpressions");
4918 for (
unsigned i = 0; i != args.size(); i++)
4919 SubExprs[i] = args[i];
4925 case AO__c11_atomic_init:
4926 case AO__opencl_atomic_init:
4927 case AO__c11_atomic_load:
4928 case AO__atomic_load_n:
4931 case AO__opencl_atomic_load:
4932 case AO__hip_atomic_load:
4933 case AO__c11_atomic_store:
4934 case AO__c11_atomic_exchange:
4935 case AO__atomic_load:
4936 case AO__atomic_store:
4937 case AO__atomic_store_n:
4938 case AO__atomic_exchange_n:
4939 case AO__c11_atomic_fetch_add:
4940 case AO__c11_atomic_fetch_sub:
4941 case AO__c11_atomic_fetch_and:
4942 case AO__c11_atomic_fetch_or:
4943 case AO__c11_atomic_fetch_xor:
4944 case AO__c11_atomic_fetch_nand:
4945 case AO__c11_atomic_fetch_max:
4946 case AO__c11_atomic_fetch_min:
4947 case AO__atomic_fetch_add:
4948 case AO__atomic_fetch_sub:
4949 case AO__atomic_fetch_and:
4950 case AO__atomic_fetch_or:
4951 case AO__atomic_fetch_xor:
4952 case AO__atomic_fetch_nand:
4953 case AO__atomic_add_fetch:
4954 case AO__atomic_sub_fetch:
4955 case AO__atomic_and_fetch:
4956 case AO__atomic_or_fetch:
4957 case AO__atomic_xor_fetch:
4958 case AO__atomic_nand_fetch:
4959 case AO__atomic_min_fetch:
4960 case AO__atomic_max_fetch:
4961 case AO__atomic_fetch_min:
4962 case AO__atomic_fetch_max:
4965 case AO__hip_atomic_exchange:
4966 case AO__hip_atomic_fetch_add:
4967 case AO__hip_atomic_fetch_sub:
4968 case AO__hip_atomic_fetch_and:
4969 case AO__hip_atomic_fetch_or:
4970 case AO__hip_atomic_fetch_xor:
4971 case AO__hip_atomic_fetch_min:
4972 case AO__hip_atomic_fetch_max:
4973 case AO__opencl_atomic_store:
4974 case AO__hip_atomic_store:
4975 case AO__opencl_atomic_exchange:
4976 case AO__opencl_atomic_fetch_add:
4977 case AO__opencl_atomic_fetch_sub:
4978 case AO__opencl_atomic_fetch_and:
4979 case AO__opencl_atomic_fetch_or:
4980 case AO__opencl_atomic_fetch_xor:
4981 case AO__opencl_atomic_fetch_min:
4982 case AO__opencl_atomic_fetch_max:
4983 case AO__atomic_exchange:
4986 case AO__c11_atomic_compare_exchange_strong:
4987 case AO__c11_atomic_compare_exchange_weak:
4989 case AO__hip_atomic_compare_exchange_strong:
4990 case AO__opencl_atomic_compare_exchange_strong:
4991 case AO__opencl_atomic_compare_exchange_weak:
4992 case AO__hip_atomic_compare_exchange_weak:
4993 case AO__atomic_compare_exchange:
4994 case AO__atomic_compare_exchange_n:
4997 llvm_unreachable(
"unknown atomic op");
5003 return AT->getValueType();
5008 unsigned ArraySectionCount = 0;
5009 while (
auto *OASE = dyn_cast<OMPArraySectionExpr>(
Base->IgnoreParens())) {
5010 Base = OASE->getBase();
5011 ++ArraySectionCount;
5014 dyn_cast<ArraySubscriptExpr>(
Base->IgnoreParenImpCasts())) {
5015 Base = ASE->getBase();
5016 ++ArraySectionCount;
5018 Base =
Base->IgnoreParenImpCasts();
5019 auto OriginalTy =
Base->getType();
5020 if (
auto *DRE = dyn_cast<DeclRefExpr>(
Base))
5021 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
5022 OriginalTy = PVD->getOriginalType().getNonReferenceType();
5024 for (
unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
5025 if (OriginalTy->isAnyPointerType())
5026 OriginalTy = OriginalTy->getPointeeType();
5028 assert (OriginalTy->isArrayType());
5029 OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
5037 :
Expr(RecoveryExprClass, T.getNonReferenceType(),
5038 T->isDependentType() ?
VK_LValue : getValueKindForType(T),
5040 BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
5042 assert(!llvm::is_contained(SubExprs,
nullptr));
5044 llvm::copy(SubExprs, getTrailingObjects<Expr *>());
5052 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(SubExprs.size()),
5054 return new (Mem)
RecoveryExpr(Ctx, T, BeginLoc, EndLoc, SubExprs);
5058 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(NumSubExprs),
5065 NumDims == Dims.size() &&
5066 "Preallocated number of dimensions is different from the provided one.");
5067 llvm::copy(Dims, getTrailingObjects<Expr *>());
5072 NumDims == BR.size() &&
5073 "Preallocated number of dimensions is different from the provided one.");
5074 llvm::copy(BR, getTrailingObjects<SourceRange>());
5077OMPArrayShapingExpr::OMPArrayShapingExpr(
QualType ExprTy,
Expr *Op,