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())
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");
356 switch (
Value.getKind()) {
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;
499DeclRefExpr::DeclRefExpr(
const ASTContext &Ctx,
502 bool RefersToEnclosingVariableOrCapture,
511 new (getTrailingObjects<NestedNameSpecifierLoc>())
515 *getTrailingObjects<NamedDecl *>() = FoundD;
517 = (TemplateArgs || TemplateKWLoc.
isValid()) ? 1 : 0;
519 RefersToEnclosingVariableOrCapture;
522 auto Deps = TemplateArgumentDependence::None;
523 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
524 TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),
526 assert(!(Deps & TemplateArgumentDependence::Dependent) &&
527 "built a DeclRefExpr with dependent template args");
528 }
else if (TemplateKWLoc.
isValid()) {
529 getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(
539 bool RefersToEnclosingVariableOrCapture,
544 return Create(Context, QualifierLoc, TemplateKWLoc, D,
545 RefersToEnclosingVariableOrCapture,
547 T, VK, FoundD, TemplateArgs, NOUR);
553 bool RefersToEnclosingVariableOrCapture,
563 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
567 QualifierLoc ? 1 : 0, FoundD ? 1 : 0,
568 HasTemplateKWAndArgsInfo ? 1 : 0,
569 TemplateArgs ? TemplateArgs->
size() : 0);
572 return new (Mem)
DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
573 RefersToEnclosingVariableOrCapture, NameInfo,
574 FoundD, TemplateArgs, T, VK, NOUR);
580 bool HasTemplateKWAndArgsInfo,
581 unsigned NumTemplateArgs) {
582 assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);
586 HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo,
594 if (
getType()->isUndeducedType())
610SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(
SourceLocation OpLoc,
616 OpLoc(OpLoc), LParen(LParen), RParen(RParen) {
617 setTypeSourceInfo(TSI);
621SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell Empty,
648 const NamedDecl *ND) -> std::optional<unsigned> {
649 if (
const auto *RD = dyn_cast<CXXRecordDecl>(ND))
650 return RD->getDeviceLambdaManglingNumber();
659 llvm::raw_string_ostream Out(Buffer);
660 Ctx->mangleTypeName(Ty, Out);
669 assert((getIdentKind() == IK) &&
670 "IdentKind do not fit in PredefinedExprBitfields!");
671 bool HasFunctionName = SL !=
nullptr;
679PredefinedExpr::PredefinedExpr(EmptyShell Empty,
bool HasFunctionName)
680 :
Expr(PredefinedExprClass, Empty) {
687 bool HasFunctionName = SL !=
nullptr;
688 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
694 bool HasFunctionName) {
695 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(HasFunctionName),
705 return "__FUNCTION__";
707 return "__FUNCDNAME__";
709 return "L__FUNCTION__";
711 return "__PRETTY_FUNCTION__";
713 return "__FUNCSIG__";
715 return "L__FUNCSIG__";
719 llvm_unreachable(
"Unknown ident kind for PredefinedExpr");
728 if (
const NamedDecl *ND = dyn_cast<NamedDecl>(CurrentDecl)) {
729 std::unique_ptr<MangleContext> MC;
732 if (MC->shouldMangleDeclName(ND)) {
734 llvm::raw_svector_ostream Out(Buffer);
740 else if (ND->hasAttr<CUDAGlobalAttr>())
744 MC->mangleName(GD, Out);
746 if (!Buffer.empty() && Buffer.front() ==
'\01')
747 return std::string(Buffer.substr(1));
748 return std::string(Buffer.str());
750 return std::string(ND->getIdentifier()->getName());
754 if (isa<BlockDecl>(CurrentDecl)) {
759 if (DC->isFileContext())
763 llvm::raw_svector_ostream Out(Buffer);
764 if (
auto *DCBlock = dyn_cast<BlockDecl>(DC))
767 else if (
auto *DCDecl = dyn_cast<Decl>(DC))
769 return std::string(Out.str());
771 if (
const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurrentDecl)) {
774 return FD->getNameAsString();
777 llvm::raw_svector_ostream Out(Name);
788 llvm::raw_string_ostream POut(Proto);
795 if (FD->hasWrittenPrototype())
796 FT = dyn_cast<FunctionProtoType>(AFT);
800 case CC_C: POut <<
"__cdecl ";
break;
811 FD->printQualifiedName(POut, Policy);
815 for (
unsigned i = 0, e =
Decl->getNumParams(); i != e; ++i) {
817 POut <<
Decl->getParamDecl(i)->getType().stream(Policy);
820 if (FT->isVariadic()) {
821 if (FD->getNumParams()) POut <<
", ";
825 !
Decl->getNumParams()) {
832 assert(FT &&
"We must have a written prototype in this case.");
835 if (FT->isVolatile())
847 while (Ctx && isa<NamedDecl>(Ctx)) {
849 = dyn_cast<ClassTemplateSpecializationDecl>(Ctx);
851 Specs.push_back(Spec);
855 std::string TemplateParams;
856 llvm::raw_string_ostream TOut(TemplateParams);
859 D->getSpecializedTemplate()->getTemplateParameters();
861 assert(Params->
size() == Args.
size());
862 for (
unsigned i = 0, numParams = Params->
size(); i != numParams; ++i) {
864 if (Param.empty())
continue;
865 TOut << Param <<
" = ";
874 = FD->getTemplateSpecializationInfo();
879 assert(Params->
size() == Args->
size());
880 for (
unsigned i = 0, e = Params->
size(); i != e; ++i) {
882 if (Param.empty())
continue;
883 TOut << Param <<
" = ";
884 Args->
get(i).
print(Policy, TOut,
true);
890 if (!TemplateParams.empty()) {
892 TemplateParams.resize(TemplateParams.size() - 2);
893 POut <<
" [" << TemplateParams <<
"]";
902 if (isa<CXXMethodDecl>(FD) &&
903 cast<CXXMethodDecl>(FD)->getParent()->isLambda())
904 Proto =
"auto " + Proto;
905 else if (FT && FT->getReturnType()->getAs<
DecltypeType>())
910 else if (!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))
915 return std::string(Name);
917 if (
const CapturedDecl *CD = dyn_cast<CapturedDecl>(CurrentDecl)) {
921 if (DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {
925 llvm_unreachable(
"CapturedDecl not inside a function or method");
927 if (
const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {
929 llvm::raw_svector_ostream Out(Name);
930 Out << (MD->isInstanceMethod() ?
'-' :
'+');
939 dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))
940 Out <<
'(' << *CID <<
')';
943 MD->getSelector().print(Out);
946 return std::string(Name);
948 if (isa<TranslationUnitDecl>(CurrentDecl) && IK ==
PrettyFunction) {
956 const llvm::APInt &Val) {
960 BitWidth = Val.getBitWidth();
961 unsigned NumWords = Val.getNumWords();
962 const uint64_t* Words = Val.getRawData();
964 pVal =
new (
C) uint64_t[NumWords];
965 std::copy(Words, Words + NumWords,
pVal);
966 }
else if (NumWords == 1)
972IntegerLiteral::IntegerLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
975 assert(
type->isIntegerType() &&
"Illegal type in IntegerLiteral");
976 assert(
V.getBitWidth() ==
C.getIntWidth(
type) &&
977 "Integer type is not the correct size for constant.");
993FixedPointLiteral::FixedPointLiteral(
const ASTContext &
C,
const llvm::APInt &
V,
998 assert(
type->isFixedPointType() &&
"Illegal type in FixedPointLiteral");
999 assert(
V.getBitWidth() ==
C.getTypeInfo(
type).Width &&
1000 "Fixed point type is not the correct size for constant.");
1006 const llvm::APInt &
V,
1024 S, llvm::APSInt::getUnsigned(
getValue().getZExtValue()), Scale);
1025 return std::string(S.str());
1047 StringRef Escaped = escapeCStyle<EscapeChar::Single>(Val);
1048 if (!Escaped.empty()) {
1049 OS <<
"'" << Escaped <<
"'";
1058 OS <<
"'" << (char)Val <<
"'";
1060 OS <<
"'\\x" << llvm::format(
"%02x", Val) <<
"'";
1061 else if (Val <= 0xFFFF)
1062 OS <<
"'\\u" << llvm::format(
"%04x", Val) <<
"'";
1064 OS <<
"'\\U" << llvm::format(
"%08x", Val) <<
"'";
1068FloatingLiteral::FloatingLiteral(
const ASTContext &
C,
const llvm::APFloat &
V,
1071 setSemantics(
V.getSemantics());
1077FloatingLiteral::FloatingLiteral(
const ASTContext &
C, EmptyShell Empty)
1078 :
Expr(FloatingLiteralClass, Empty) {
1079 setRawSemantics(llvm::APFloatBase::S_IEEEhalf);
1100 V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
1102 return V.convertToDouble();
1107 unsigned CharByteWidth = 0;
1111 CharByteWidth =
Target.getCharWidth();
1114 CharByteWidth =
Target.getWCharWidth();
1117 CharByteWidth =
Target.getChar16Width();
1120 CharByteWidth =
Target.getChar32Width();
1123 assert((CharByteWidth & 7) == 0 &&
"Assumes character size is byte multiple");
1125 assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&
1126 "The only supported character byte widths are 1,2 and 4!");
1127 return CharByteWidth;
1130StringLiteral::StringLiteral(
const ASTContext &Ctx, StringRef Str,
1131 StringKind Kind,
bool Pascal,
QualType Ty,
1133 unsigned NumConcatenated)
1136 "StringLiteral must be of constant array type!");
1137 unsigned CharByteWidth = mapCharByteWidth(Ctx.
getTargetInfo(), Kind);
1138 unsigned ByteLength = Str.size();
1139 assert((ByteLength % CharByteWidth == 0) &&
1140 "The size of the data must be a multiple of CharByteWidth!");
1146 switch (CharByteWidth) {
1148 Length = ByteLength;
1151 Length = ByteLength / 2;
1154 Length = ByteLength / 4;
1157 llvm_unreachable(
"Unsupported character width!");
1164 *getTrailingObjects<unsigned>() = Length;
1168 std::memcpy(getTrailingObjects<SourceLocation>(), Loc,
1172 std::memcpy(getTrailingObjects<char>(), Str.data(), ByteLength);
1177StringLiteral::StringLiteral(EmptyShell Empty,
unsigned NumConcatenated,
1178 unsigned Length,
unsigned CharByteWidth)
1179 :
Expr(StringLiteralClass, Empty) {
1182 *getTrailingObjects<unsigned>() = Length;
1188 unsigned NumConcatenated) {
1189 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1190 1, NumConcatenated, Str.size()),
1193 StringLiteral(Ctx, Str, Kind, Pascal, Ty, Loc, NumConcatenated);
1197 unsigned NumConcatenated,
1199 unsigned CharByteWidth) {
1200 void *Mem = Ctx.
Allocate(totalSizeToAlloc<unsigned, SourceLocation, char>(
1201 1, NumConcatenated, Length * CharByteWidth),
1211 case Wide:
OS <<
'L';
break;
1212 case UTF8:
OS <<
"u8";
break;
1217 static const char Hex[] =
"0123456789ABCDEF";
1220 for (
unsigned I = 0, N =
getLength(); I != N; ++I) {
1222 StringRef Escaped = escapeCStyle<EscapeChar::Double>(Char);
1223 if (Escaped.empty()) {
1228 if (
getKind() ==
UTF16 && I != N - 1 && Char >= 0xd800 &&
1231 if (Trail >= 0xdc00 && Trail <= 0xdfff) {
1232 Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);
1242 (Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {
1246 while ((Char >> Shift) == 0)
1248 for (; Shift >= 0; Shift -= 4)
1249 OS << Hex[(Char >> Shift) & 15];
1256 << Hex[(Char >> 20) & 15]
1257 << Hex[(Char >> 16) & 15];
1260 OS << Hex[(Char >> 12) & 15]
1261 << Hex[(Char >> 8) & 15]
1262 << Hex[(Char >> 4) & 15]
1263 << Hex[(Char >> 0) & 15];
1269 if (LastSlashX + 1 == I) {
1271 case '0':
case '1':
case '2':
case '3':
case '4':
1272 case '5':
case '6':
case '7':
case '8':
case '9':
1273 case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
1274 case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
1279 assert(Char <= 0xff &&
1280 "Characters above 0xff should already have been handled.");
1286 << (char)(
'0' + ((Char >> 6) & 7))
1287 << (char)(
'0' + ((Char >> 3) & 7))
1288 << (char)(
'0' + ((Char >> 0) & 7));
1317 unsigned *StartTokenByteOffset)
const {
1320 "Only narrow string literals are currently supported");
1325 unsigned StringOffset = 0;
1327 TokNo = *StartToken;
1328 if (StartTokenByteOffset) {
1329 StringOffset = *StartTokenByteOffset;
1330 ByteNo -= StringOffset;
1342 std::pair<FileID, unsigned> LocInfo =
1343 SM.getDecomposedLoc(StrTokSpellingLoc);
1345 StringRef Buffer =
SM.getBufferData(LocInfo.first, &
Invalid);
1347 if (StartTokenByteOffset !=
nullptr)
1348 *StartTokenByteOffset = StringOffset;
1349 if (StartToken !=
nullptr)
1350 *StartToken = TokNo;
1351 return StrTokSpellingLoc;
1354 const char *StrData = Buffer.data()+LocInfo.second;
1357 Lexer TheLexer(
SM.getLocForStartOfFile(LocInfo.first), Features,
1358 Buffer.begin(), StrData, Buffer.end());
1367 if (ByteNo < TokNumBytes ||
1373 if (StartTokenByteOffset !=
nullptr)
1374 *StartTokenByteOffset = StringOffset;
1375 if (StartToken !=
nullptr)
1376 *StartToken = TokNo;
1381 StringOffset += TokNumBytes;
1383 ByteNo -= TokNumBytes;
1391#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling;
1392#include "clang/AST/OperationKinds.def"
1394 llvm_unreachable(
"Unknown unary operator");
1400 default: llvm_unreachable(
"No unary operator for overloaded function");
1401 case OO_PlusPlus:
return Postfix ? UO_PostInc : UO_PreInc;
1402 case OO_MinusMinus:
return Postfix ? UO_PostDec : UO_PreDec;
1403 case OO_Amp:
return UO_AddrOf;
1404 case OO_Star:
return UO_Deref;
1405 case OO_Plus:
return UO_Plus;
1406 case OO_Minus:
return UO_Minus;
1407 case OO_Tilde:
return UO_Not;
1408 case OO_Exclaim:
return UO_LNot;
1409 case OO_Coawait:
return UO_Coawait;
1415 case UO_PostInc:
case UO_PreInc:
return OO_PlusPlus;
1416 case UO_PostDec:
case UO_PreDec:
return OO_MinusMinus;
1417 case UO_AddrOf:
return OO_Amp;
1418 case UO_Deref:
return OO_Star;
1419 case UO_Plus:
return OO_Plus;
1420 case UO_Minus:
return OO_Minus;
1421 case UO_Not:
return OO_Tilde;
1422 case UO_LNot:
return OO_Exclaim;
1423 case UO_Coawait:
return OO_Coawait;
1438 NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1439 unsigned NumPreArgs = PreArgs.size();
1441 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1443 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1444 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1445 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1446 "OffsetToTrailingObjects overflow!");
1451 for (
unsigned I = 0; I != NumPreArgs; ++I)
1453 for (
unsigned I = 0; I != Args.size(); ++I)
1455 for (
unsigned I = Args.size(); I != NumArgs; ++I)
1467 :
Expr(SC, Empty), NumArgs(NumArgs) {
1469 assert((NumPreArgs ==
getNumPreArgs()) &&
"NumPreArgs overflow!");
1471 unsigned OffsetToTrailingObjects = offsetToTrailingObjects(SC);
1472 CallExprBits.OffsetToTrailingObjects = OffsetToTrailingObjects;
1473 assert((
CallExprBits.OffsetToTrailingObjects == OffsetToTrailingObjects) &&
1474 "OffsetToTrailingObjects overflow!");
1483 unsigned NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);
1488 return new (Mem)
CallExpr(CallExprClass, Fn, {}, Args, Ty, VK,
1489 RParenLoc, FPFeatures, MinNumArgs,
UsesADL);
1496 "Misaligned memory in CallExpr::CreateTemporary!");
1497 return new (Mem)
CallExpr(CallExprClass, Fn, {}, {}, Ty,
1504 unsigned SizeOfTrailingObjects =
1509 CallExpr(CallExprClass, 0, NumArgs, HasFPFeatures, Empty);
1512unsigned CallExpr::offsetToTrailingObjects(StmtClass SC) {
1516 case CXXOperatorCallExprClass:
1518 case CXXMemberCallExprClass:
1520 case UserDefinedLiteralClass:
1522 case CUDAKernelCallExprClass:
1525 llvm_unreachable(
"unexpected class deriving from CallExpr!");
1533 dyn_cast<SubstNonTypeTemplateParmExpr>(CEE)) {
1540 if (BO->isPtrMemOp()) {
1544 }
else if (
UnaryOperator *UO = dyn_cast<UnaryOperator>(CEE)) {
1545 if (UO->getOpcode() == UO_Deref || UO->getOpcode() == UO_AddrOf ||
1546 UO->getOpcode() == UO_Plus) {
1554 if (
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE))
1555 return DRE->getDecl();
1556 if (
MemberExpr *ME = dyn_cast<MemberExpr>(CEE))
1557 return ME->getMemberDecl();
1558 if (
auto *BE = dyn_cast<BlockExpr>(CEE))
1559 return BE->getBlockDecl();
1567 return FDecl ? FDecl->getBuiltinID() : 0;
1578 QualType CalleeType = Callee->getType();
1584 if (isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))
1587 if (isa<UnresolvedMemberExpr>(Callee->IgnoreParens()))
1592 assert(!CalleeType.
isNull());
1606 if (
const auto *A = TD->getAttr<WarnUnusedResultAttr>())
1610 TD = TD->desugar()->getAs<TypedefType>())
1611 if (
const auto *A = TD->getDecl()->getAttr<WarnUnusedResultAttr>())
1617 return D ? D->
getAttr<WarnUnusedResultAttr>() :
nullptr;
1621 if (isa<CXXOperatorCallExpr>(
this))
1622 return cast<CXXOperatorCallExpr>(
this)->getBeginLoc();
1630 if (isa<CXXOperatorCallExpr>(
this))
1631 return cast<CXXOperatorCallExpr>(
this)->getEndLoc();
1645 void *Mem =
C.Allocate(
1646 totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));
1653 unsigned numComps,
unsigned numExprs) {
1655 C.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));
1664 OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),
1665 NumComps(comps.size()), NumExprs(exprs.size()) {
1666 for (
unsigned i = 0; i != comps.size(); ++i)
1668 for (
unsigned i = 0; i != exprs.size(); ++i)
1686 OpLoc(op), RParenLoc(rp) {
1687 assert(ExprKind <=
UETT_Last &&
"invalid enum value!");
1690 "UnaryExprOrTypeTraitExprBits.Kind overflow!");
1701 :
Expr(MemberExprClass, T, VK, OK),
Base(
Base), MemberDecl(MemberDecl),
1702 MemberDNLoc(NameInfo.
getInfo()), MemberLoc(NameInfo.getLoc()) {
1720 bool HasQualOrFound = QualifierLoc || FoundDecl.getDecl() != MemberDecl ||
1722 bool HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.
isValid();
1726 HasQualOrFound ? 1 : 0, HasTemplateKWAndArgsInfo ? 1 : 0,
1727 TemplateArgs ? TemplateArgs->
size() : 0);
1729 void *Mem =
C.Allocate(Size,
alignof(
MemberExpr));
1731 NameInfo, T, VK, OK, NOUR);
1735 if (HasQualOrFound) {
1738 Deps |= ExprDependence::TypeValueInstantiation;
1739 else if (QualifierLoc &&
1741 Deps |= ExprDependence::Instantiation;
1752 TemplateArgs || TemplateKWLoc.
isValid();
1755 auto TemplateArgDeps = TemplateArgumentDependence::None;
1757 TemplateKWLoc, *TemplateArgs,
1759 if (TemplateArgDeps & TemplateArgumentDependence::Instantiation)
1760 Deps |= ExprDependence::Instantiation;
1761 }
else if (TemplateKWLoc.
isValid()) {
1771 bool HasQualifier,
bool HasFoundDecl,
1772 bool HasTemplateKWAndArgsInfo,
1773 unsigned NumTemplateArgs) {
1774 assert((!NumTemplateArgs || HasTemplateKWAndArgsInfo) &&
1775 "template args but no template arg info?");
1776 bool HasQualOrFound = HasQualifier || HasFoundDecl;
1780 HasTemplateKWAndArgsInfo ? 1 : 0,
1788 if (
getType()->isUndeducedType())
1804 return BaseStartLoc;
1816bool CastExpr::CastConsistency()
const {
1818 case CK_DerivedToBase:
1819 case CK_UncheckedDerivedToBase:
1820 case CK_DerivedToBaseMemberPointer:
1821 case CK_BaseToDerived:
1822 case CK_BaseToDerivedMemberPointer:
1823 assert(!
path_empty() &&
"Cast kind should have a base path!");
1826 case CK_CPointerToObjCPointerCast:
1827 assert(
getType()->isObjCObjectPointerType());
1829 goto CheckNoBasePath;
1831 case CK_BlockPointerToObjCPointerCast:
1832 assert(
getType()->isObjCObjectPointerType());
1834 goto CheckNoBasePath;
1836 case CK_ReinterpretMemberPointer:
1837 assert(
getType()->isMemberPointerType());
1839 goto CheckNoBasePath;
1845 if (!
getType()->isPointerType()) {
1846 assert(
getType()->isObjCObjectPointerType() ==
1848 assert(
getType()->isBlockPointerType() ==
1851 goto CheckNoBasePath;
1853 case CK_AnyPointerToBlockPointerCast:
1854 assert(
getType()->isBlockPointerType());
1857 goto CheckNoBasePath;
1859 case CK_CopyAndAutoreleaseBlockObject:
1860 assert(
getType()->isBlockPointerType());
1862 goto CheckNoBasePath;
1864 case CK_FunctionToPointerDecay:
1865 assert(
getType()->isPointerType());
1867 goto CheckNoBasePath;
1869 case CK_AddressSpaceConversion: {
1878 (!Ty.
isNull() && !SETy.isNull() &&
1880 goto CheckNoBasePath;
1885 case CK_ArrayToPointerDecay:
1886 case CK_NullToMemberPointer:
1887 case CK_NullToPointer:
1888 case CK_ConstructorConversion:
1889 case CK_IntegralToPointer:
1890 case CK_PointerToIntegral:
1892 case CK_VectorSplat:
1893 case CK_IntegralCast:
1894 case CK_BooleanToSignedIntegral:
1895 case CK_IntegralToFloating:
1896 case CK_FloatingToIntegral:
1897 case CK_FloatingCast:
1898 case CK_ObjCObjectLValueCast:
1899 case CK_FloatingRealToComplex:
1900 case CK_FloatingComplexToReal:
1901 case CK_FloatingComplexCast:
1902 case CK_FloatingComplexToIntegralComplex:
1903 case CK_IntegralRealToComplex:
1904 case CK_IntegralComplexToReal:
1905 case CK_IntegralComplexCast:
1906 case CK_IntegralComplexToFloatingComplex:
1907 case CK_ARCProduceObject:
1908 case CK_ARCConsumeObject:
1909 case CK_ARCReclaimReturnedObject:
1910 case CK_ARCExtendBlockObject:
1911 case CK_ZeroToOCLOpaqueType:
1912 case CK_IntToOCLSampler:
1913 case CK_FloatingToFixedPoint:
1914 case CK_FixedPointToFloating:
1915 case CK_FixedPointCast:
1916 case CK_FixedPointToIntegral:
1917 case CK_IntegralToFixedPoint:
1920 goto CheckNoBasePath;
1923 case CK_LValueToRValue:
1925 case CK_AtomicToNonAtomic:
1926 case CK_NonAtomicToAtomic:
1927 case CK_PointerToBoolean:
1928 case CK_IntegralToBoolean:
1929 case CK_FloatingToBoolean:
1930 case CK_MemberPointerToBoolean:
1931 case CK_FloatingComplexToBoolean:
1932 case CK_IntegralComplexToBoolean:
1933 case CK_LValueBitCast:
1934 case CK_LValueToRValueBitCast:
1935 case CK_UserDefinedConversion:
1936 case CK_BuiltinFnToFnPtr:
1937 case CK_FixedPointToBoolean:
1939 assert(
path_empty() &&
"Cast kind should not have a base path!");
1947#define CAST_OPERATION(Name) case CK_##Name: return #Name;
1948#include "clang/AST/OperationKinds.def"
1950 llvm_unreachable(
"Unhandled cast kind!");
1956Expr *ignoreImplicitSemaNodes(
Expr *E) {
1957 if (
auto *Materialize = dyn_cast<MaterializeTemporaryExpr>(E))
1958 return Materialize->getSubExpr();
1960 if (
auto *Binder = dyn_cast<CXXBindTemporaryExpr>(E))
1961 return Binder->getSubExpr();
1963 if (
auto *Full = dyn_cast<FullExpr>(E))
1964 return Full->getSubExpr();
1971 const Expr *SubExpr =
nullptr;
1973 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
1978 if (E->getCastKind() == CK_ConstructorConversion) {
1980 ignoreImplicitSemaNodes);
1981 }
else if (E->getCastKind() == CK_UserDefinedConversion) {
1982 assert((isa<CXXMemberCallExpr>(SubExpr) || isa<BlockExpr>(SubExpr)) &&
1983 "Unexpected SubExpr for CK_UserDefinedConversion.");
1984 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
1985 SubExpr = MCE->getImplicitObjectArgument();
1989 return const_cast<Expr *
>(SubExpr);
1993 const Expr *SubExpr =
nullptr;
1995 for (
const CastExpr *E =
this; E; E = dyn_cast<ImplicitCastExpr>(SubExpr)) {
1998 if (E->getCastKind() == CK_ConstructorConversion)
1999 return cast<CXXConstructExpr>(SubExpr)->getConstructor();
2001 if (E->getCastKind() == CK_UserDefinedConversion) {
2002 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))
2003 return MCE->getMethodDecl();
2012#define ABSTRACT_STMT(x)
2013#define CASTEXPR(Type, Base) \
2014 case Stmt::Type##Class: \
2015 return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>();
2016#define STMT(Type, Base)
2017#include "clang/AST/StmtNodes.inc"
2019 llvm_unreachable(
"non-cast expressions not possible here");
2034 Field != FieldEnd; ++Field) {
2036 !Field->isUnnamedBitfield()) {
2046 case ImplicitCastExprClass:
2048 ->getTrailingObjects<FPOptionsOverride>();
2049 case CStyleCastExprClass:
2051 ->getTrailingObjects<FPOptionsOverride>();
2052 case CXXFunctionalCastExprClass:
2054 ->getTrailingObjects<FPOptionsOverride>();
2055 case CXXStaticCastExprClass:
2057 ->getTrailingObjects<FPOptionsOverride>();
2059 llvm_unreachable(
"Cast does not have FPFeatures");
2068 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2070 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2074 assert((Kind != CK_LValueToRValue ||
2076 "invalid type for lvalue-to-rvalue conversion");
2080 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2087 bool HasFPFeatures) {
2089 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2090 PathSize, HasFPFeatures));
2100 unsigned PathSize = (BasePath ? BasePath->size() : 0);
2102 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2105 new (Buffer)
CStyleCastExpr(T, VK, K, Op, PathSize, FPO, WrittenTy, L, R);
2107 std::uninitialized_copy_n(BasePath->data(), BasePath->size(),
2114 bool HasFPFeatures) {
2116 C.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(
2117 PathSize, HasFPFeatures));
2125#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling;
2126#include "clang/AST/OperationKinds.def"
2128 llvm_unreachable(
"Invalid OpCode!");
2134 default: llvm_unreachable(
"Not an overloadable binary operator");
2135 case OO_Plus:
return BO_Add;
2136 case OO_Minus:
return BO_Sub;
2137 case OO_Star:
return BO_Mul;
2138 case OO_Slash:
return BO_Div;
2139 case OO_Percent:
return BO_Rem;
2140 case OO_Caret:
return BO_Xor;
2141 case OO_Amp:
return BO_And;
2142 case OO_Pipe:
return BO_Or;
2143 case OO_Equal:
return BO_Assign;
2144 case OO_Spaceship:
return BO_Cmp;
2145 case OO_Less:
return BO_LT;
2146 case OO_Greater:
return BO_GT;
2147 case OO_PlusEqual:
return BO_AddAssign;
2148 case OO_MinusEqual:
return BO_SubAssign;
2149 case OO_StarEqual:
return BO_MulAssign;
2150 case OO_SlashEqual:
return BO_DivAssign;
2151 case OO_PercentEqual:
return BO_RemAssign;
2152 case OO_CaretEqual:
return BO_XorAssign;
2153 case OO_AmpEqual:
return BO_AndAssign;
2154 case OO_PipeEqual:
return BO_OrAssign;
2155 case OO_LessLess:
return BO_Shl;
2156 case OO_GreaterGreater:
return BO_Shr;
2157 case OO_LessLessEqual:
return BO_ShlAssign;
2158 case OO_GreaterGreaterEqual:
return BO_ShrAssign;
2159 case OO_EqualEqual:
return BO_EQ;
2160 case OO_ExclaimEqual:
return BO_NE;
2161 case OO_LessEqual:
return BO_LE;
2162 case OO_GreaterEqual:
return BO_GE;
2163 case OO_AmpAmp:
return BO_LAnd;
2164 case OO_PipePipe:
return BO_LOr;
2165 case OO_Comma:
return BO_Comma;
2166 case OO_ArrowStar:
return BO_PtrMemI;
2173 OO_Star, OO_Slash, OO_Percent,
2175 OO_LessLess, OO_GreaterGreater,
2177 OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,
2178 OO_EqualEqual, OO_ExclaimEqual,
2184 OO_Equal, OO_StarEqual,
2185 OO_SlashEqual, OO_PercentEqual,
2186 OO_PlusEqual, OO_MinusEqual,
2187 OO_LessLessEqual, OO_GreaterGreaterEqual,
2188 OO_AmpEqual, OO_CaretEqual,
2192 return OverOps[Opc];
2233 BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {
2241 return "__builtin_FILE";
2243 return "__builtin_FILE_NAME";
2245 return "__builtin_FUNCTION";
2247 return "__builtin_LINE";
2249 return "__builtin_COLUMN";
2251 return "__builtin_source_location";
2253 llvm_unreachable(
"unexpected IdentKind!");
2257 const Expr *DefaultExpr)
const {
2262 Context) = [&]() -> std::pair<SourceLocation, const DeclContext *> {
2263 if (
auto *DIE = dyn_cast_or_null<CXXDefaultInitExpr>(DefaultExpr))
2264 return {DIE->getUsedLocation(), DIE->getUsedContext()};
2265 if (
auto *DAE = dyn_cast_or_null<CXXDefaultArgExpr>(DefaultExpr))
2266 return {DAE->getUsedLocation(), DAE->getUsedContext()};
2273 auto MakeStringLiteral = [&](StringRef Tmp) {
2277 LValuePathEntry Path[1] = {LValuePathEntry::ArrayIndex(0)};
2288 return MakeStringLiteral(
FileName);
2294 return MakeStringLiteral(Path);
2297 const auto *CurDecl = dyn_cast<Decl>(Context);
2298 return MakeStringLiteral(
2323 StringRef Name = F->getName();
2324 if (Name ==
"_M_file_name") {
2328 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(Path);
2329 }
else if (Name ==
"_M_function_name") {
2332 const auto *CurDecl = dyn_cast<Decl>(Context);
2333 Value.getStructField(F->getFieldIndex()) = MakeStringLiteral(
2334 CurDecl && !isa<TranslationUnitDecl>(CurDecl)
2338 }
else if (Name ==
"_M_line") {
2343 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2344 }
else if (Name ==
"_M_column") {
2349 Value.getStructField(F->getFieldIndex()) =
APValue(IntVal);
2360 llvm_unreachable(
"unhandled case");
2366 InitExprs(
C, initExprs.size()), LBraceLoc(lbraceloc),
2367 RBraceLoc(rbraceloc), AltForm(nullptr,
true) {
2369 InitExprs.
insert(
C, InitExprs.
end(), initExprs.begin(), initExprs.end());
2375 if (NumInits > InitExprs.
size())
2380 InitExprs.
resize(
C, NumInits,
nullptr);
2384 if (Init >= InitExprs.
size()) {
2385 InitExprs.
insert(
C, InitExprs.
end(), Init - InitExprs.
size() + 1,
nullptr);
2390 Expr *
Result = cast_or_null<Expr>(InitExprs[Init]);
2397 ArrayFillerOrUnionFieldInit = filler;
2400 for (
unsigned i = 0, e =
getNumInits(); i != e; ++i)
2401 if (
inits[i] ==
nullptr)
2415 Init = Init->IgnoreParenImpCasts();
2416 return isa<StringLiteral>(Init) || isa<ObjCEncodeExpr>(Init);
2420 assert(
isSemanticForm() &&
"syntactic form never semantically transparent");
2424 assert(
getNumInits() == 1 &&
"multiple inits in glvalue init list");
2443 assert(
isSyntacticForm() &&
"only test syntactic form as zero initializer");
2450 return Lit && Lit->
getValue() == 0;
2455 return SyntacticForm->getBeginLoc();
2460 E = InitExprs.
end();
2463 Beg = S->getBeginLoc();
2473 return SyntacticForm->getEndLoc();
2475 if (End.isInvalid()) {
2477 for (
Stmt *S : llvm::reverse(InitExprs)) {
2479 End = S->getEndLoc();
2491 return cast<BlockPointerType>(
getType())
2522 if (isa<DeclRefExpr>(E))
2526 if (isa<ArraySubscriptExpr>(E))
2530 if (isa<MemberExpr>(E))
2534 if (
auto *UO = dyn_cast<UnaryOperator>(E))
2535 if (UO->getOpcode() == UO_Deref)
2538 if (
auto *BO = dyn_cast<BinaryOperator>(E)) {
2540 if (BO->isPtrMemOp())
2544 if (BO->getOpcode() == BO_Comma)
2545 return BO->getRHS()->isReadIfDiscardedInCPlusPlus11();
2550 if (
auto *CO = dyn_cast<ConditionalOperator>(E))
2551 return CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&
2552 CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2555 dyn_cast<BinaryConditionalOperator>(E)) {
2556 if (
auto *OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))
2557 return OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&
2558 BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();
2562 if (isa<ObjCIvarRefExpr>(E))
2564 if (
const auto *POE = dyn_cast<PseudoObjectExpr>(E)) {
2565 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(POE->getSyntacticForm()))
2592 case ParenExprClass:
2593 return cast<ParenExpr>(
this)->getSubExpr()->
2595 case GenericSelectionExprClass:
2596 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
2598 case CoawaitExprClass:
2599 case CoyieldExprClass:
2600 return cast<CoroutineSuspendExpr>(
this)->getResumeExpr()->
2602 case ChooseExprClass:
2603 return cast<ChooseExpr>(
this)->getChosenSubExpr()->
2605 case UnaryOperatorClass: {
2639 case BinaryOperatorClass: {
2651 if (IE->getValue() == 0)
2670 case CompoundAssignOperatorClass:
2671 case VAArgExprClass:
2672 case AtomicExprClass:
2675 case ConditionalOperatorClass: {
2679 const auto *Exp = cast<ConditionalOperator>(
this);
2680 return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) &&
2681 Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2683 case BinaryConditionalOperatorClass: {
2684 const auto *Exp = cast<BinaryConditionalOperator>(
this);
2685 return Exp->getFalseExpr()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2688 case MemberExprClass:
2690 Loc = cast<MemberExpr>(
this)->getMemberLoc();
2692 R2 = cast<MemberExpr>(
this)->getBase()->getSourceRange();
2695 case ArraySubscriptExprClass:
2697 Loc = cast<ArraySubscriptExpr>(
this)->getRBracketLoc();
2698 R1 = cast<ArraySubscriptExpr>(
this)->getLHS()->getSourceRange();
2699 R2 = cast<ArraySubscriptExpr>(
this)->getRHS()->getSourceRange();
2702 case CXXOperatorCallExprClass: {
2714 case OO_ExclaimEqual:
2717 case OO_GreaterEqual:
2732 case CXXMemberCallExprClass:
2733 case UserDefinedLiteralClass: {
2735 const CallExpr *CE = cast<CallExpr>(
this);
2743 FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {
2758 case UnresolvedLookupExprClass:
2759 case CXXUnresolvedConstructExprClass:
2760 case RecoveryExprClass:
2763 case CXXTemporaryObjectExprClass:
2764 case CXXConstructExprClass: {
2766 const auto *WarnURAttr =
Type->getAttr<WarnUnusedResultAttr>();
2768 (WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {
2776 const auto *CE = cast<CXXConstructExpr>(
this);
2778 const auto *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
2779 if (WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {
2784 if (
unsigned NumArgs = CE->getNumArgs())
2786 CE->getArg(NumArgs - 1)->getEndLoc());
2794 case ObjCMessageExprClass: {
2807 if (MD->hasAttr<WarnUnusedResultAttr>()) {
2816 case ObjCPropertyRefExprClass:
2817 case ObjCSubscriptRefExprClass:
2823 case PseudoObjectExprClass: {
2824 const auto *POE = cast<PseudoObjectExpr>(
this);
2827 if (isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(
2828 POE->getSyntacticForm())) {
2836 if (
auto *BO = dyn_cast<BinaryOperator>(POE->getSyntacticForm()))
2837 if (BO->isAssignmentOp())
2839 if (
auto *UO = dyn_cast<UnaryOperator>(POE->getSyntacticForm()))
2840 if (UO->isIncrementDecrementOp())
2845 return Result &&
Result->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2848 case StmtExprClass: {
2854 const CompoundStmt *CS = cast<StmtExpr>(
this)->getSubStmt();
2859 if (
const Expr *E = dyn_cast<Expr>(
Label->getSubStmt()))
2866 Loc = cast<StmtExpr>(
this)->getLParenLoc();
2870 case CXXFunctionalCastExprClass:
2871 case CStyleCastExprClass: {
2878 const CastExpr *CE = cast<CastExpr>(
this);
2885 if (
auto *DRE = dyn_cast<DeclRefExpr>(SubE))
2886 if (
auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
2887 if (!VD->isExternallyVisible())
2903 if (CE->
getCastKind() == CK_ConstructorConversion)
2910 dyn_cast<CXXFunctionalCastExpr>(
this)) {
2911 Loc = CXXCE->getBeginLoc();
2912 R1 = CXXCE->getSubExpr()->getSourceRange();
2920 case ImplicitCastExprClass: {
2921 const CastExpr *ICE = cast<ImplicitCastExpr>(
this);
2930 case CXXDefaultArgExprClass:
2931 return (cast<CXXDefaultArgExpr>(
this)
2933 case CXXDefaultInitExprClass:
2934 return (cast<CXXDefaultInitExpr>(
this)
2937 case CXXNewExprClass:
2940 case CXXDeleteExprClass:
2942 case MaterializeTemporaryExprClass:
2943 return cast<MaterializeTemporaryExpr>(
this)
2945 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2946 case CXXBindTemporaryExprClass:
2947 return cast<CXXBindTemporaryExpr>(
this)->getSubExpr()
2948 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2949 case ExprWithCleanupsClass:
2950 return cast<ExprWithCleanups>(
this)->getSubExpr()
2951 ->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
2962 case ObjCIvarRefExprClass:
2964 case Expr::UnaryOperatorClass:
2965 return cast<UnaryOperator>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2966 case ImplicitCastExprClass:
2967 return cast<ImplicitCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2968 case MaterializeTemporaryExprClass:
2969 return cast<MaterializeTemporaryExpr>(E)->getSubExpr()->isOBJCGCCandidate(
2971 case CStyleCastExprClass:
2972 return cast<CStyleCastExpr>(E)->getSubExpr()->isOBJCGCCandidate(Ctx);
2973 case DeclRefExprClass: {
2974 const Decl *D = cast<DeclRefExpr>(E)->getDecl();
2976 if (
const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2977 if (VD->hasGlobalStorage())
2987 case MemberExprClass: {
2991 case ArraySubscriptExprClass:
2992 return cast<ArraySubscriptExpr>(E)->getBase()->isOBJCGCCandidate(Ctx);
3003 assert(
expr->hasPlaceholderType(BuiltinType::BoundMember));
3011 assert(isa<CXXMethodDecl>(mem->getMemberDecl()));
3012 return mem->getMemberDecl()->getType();
3018 assert(
type->isFunctionType());
3022 assert(isa<UnresolvedMemberExpr>(
expr) || isa<CXXPseudoDestructorExpr>(
expr));
3056 if (
auto *MCE = dyn_cast<CXXMemberCallExpr>(
this)) {
3057 if (MCE->getMethodDecl() && isa<CXXConversionDecl>(MCE->getMethodDecl()))
3058 return MCE->getImplicitObjectArgument();
3074 auto IgnoreNoopCastsSingleStep = [&Ctx](
Expr *E) {
3075 if (
auto *CE = dyn_cast<CastExpr>(E)) {
3078 Expr *SubExpr = CE->getSubExpr();
3079 bool IsIdentityCast =
3088 if (IsIdentityCast || IsSameWidthCast)
3090 }
else if (
auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
3091 return NTTP->getReplacement();
3096 IgnoreNoopCastsSingleStep);
3101 if (
auto *Cast = dyn_cast<CXXFunctionalCastExpr>(E)) {
3102 auto *SE = Cast->getSubExpr();
3107 if (
auto *
C = dyn_cast<CXXConstructExpr>(E)) {
3108 auto NumArgs =
C->getNumArgs();
3110 (NumArgs > 1 && isa<CXXDefaultArgExpr>(
C->getArg(1)))) {
3111 Expr *A =
C->getArg(0);
3118 auto IgnoreImplicitMemberCallSingleStep = [](
Expr *E) {
3119 if (
auto *
C = dyn_cast<CXXMemberCallExpr>(E)) {
3120 Expr *ExprNode =
C->getImplicitObjectArgument();
3124 if (
auto *PE = dyn_cast<ParenExpr>(ExprNode)) {
3125 if (PE->getSourceRange() ==
C->getSourceRange()) {
3126 return cast<Expr>(PE);
3138 IgnoreImplicitMemberCallSingleStep);
3142 const Expr *E =
this;
3144 E = M->getSubExpr();
3147 E = ICE->getSubExprAsWritten();
3149 return isa<CXXDefaultArgExpr>(E);
3156 E = M->getSubExpr();
3159 if (ICE->getCastKind() == CK_NoOp)
3160 E = ICE->getSubExpr();
3166 E = BE->getSubExpr();
3169 if (ICE->getCastKind() == CK_NoOp)
3170 E = ICE->getSubExpr();
3181 if (!
C.hasSameUnqualifiedType(
getType(),
C.getTypeDeclType(TempTy)))
3189 if (!isa<ObjCPropertyRefExpr>(E))
3197 if (isa<ImplicitCastExpr>(E)) {
3198 switch (cast<ImplicitCastExpr>(E)->getCastKind()) {
3199 case CK_DerivedToBase:
3200 case CK_UncheckedDerivedToBase:
3208 if (isa<MemberExpr>(E))
3212 if (BO->isPtrMemOp())
3216 if (isa<OpaqueValueExpr>(E))
3223 const Expr *E =
this;
3228 E =
Paren->getSubExpr();
3233 if (ICE->getCastKind() == CK_NoOp ||
3234 ICE->getCastKind() == CK_LValueToRValue ||
3235 ICE->getCastKind() == CK_DerivedToBase ||
3236 ICE->getCastKind() == CK_UncheckedDerivedToBase) {
3237 E = ICE->getSubExpr();
3242 if (
const UnaryOperator* UnOp = dyn_cast<UnaryOperator>(E)) {
3243 if (UnOp->getOpcode() == UO_Extension) {
3244 E = UnOp->getSubExpr();
3250 = dyn_cast<MaterializeTemporaryExpr>(E)) {
3251 E = M->getSubExpr();
3258 if (
const CXXThisExpr *This = dyn_cast<CXXThisExpr>(E))
3259 return This->isImplicit();
3267 for (
unsigned I = 0; I < Exprs.size(); ++I)
3275 const Expr **Culprit)
const {
3277 "Expression evaluator can't be called on a dependent expression.");
3299 case Stmt::ExprWithCleanupsClass:
3301 Ctx, IsForRef, Culprit);
3302 case StringLiteralClass:
3303 case ObjCEncodeExprClass:
3305 case CXXTemporaryObjectExprClass:
3306 case CXXConstructExprClass: {
3315 assert(CE->
getNumArgs() == 1 &&
"trivial ctor with > 1 argument");
3321 case ConstantExprClass: {
3324 const Expr *Exp = cast<ConstantExpr>(
this)->getSubExpr();
3327 case CompoundLiteralExprClass: {
3331 const Expr *Exp = cast<CompoundLiteralExpr>(
this)->getInitializer();
3334 case DesignatedInitUpdateExprClass: {
3339 case InitListExprClass: {
3341 assert(ILE->
isSemanticForm() &&
"InitListExpr must be in semantic form");
3344 for (
unsigned i = 0; i < numInits; i++) {
3352 unsigned ElementNo = 0;
3354 for (
const auto *Field : RD->
fields()) {
3360 if (Field->isUnnamedBitfield())
3363 if (ElementNo < ILE->getNumInits()) {
3365 if (Field->isBitField()) {
3374 bool RefType = Field->getType()->isReferenceType();
3385 case ImplicitValueInitExprClass:
3386 case NoInitExprClass:
3388 case ParenExprClass:
3389 return cast<ParenExpr>(
this)->getSubExpr()
3390 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3391 case GenericSelectionExprClass:
3392 return cast<GenericSelectionExpr>(
this)->getResultExpr()
3393 ->isConstantInitializer(Ctx, IsForRef, Culprit);
3394 case ChooseExprClass:
3395 if (cast<ChooseExpr>(
this)->isConditionDependent()) {
3400 return cast<ChooseExpr>(
this)->getChosenSubExpr()
3402 case UnaryOperatorClass: {
3408 case CXXFunctionalCastExprClass:
3409 case CXXStaticCastExprClass:
3410 case ImplicitCastExprClass:
3411 case CStyleCastExprClass:
3412 case ObjCBridgedCastExprClass:
3413 case CXXDynamicCastExprClass:
3414 case CXXReinterpretCastExprClass:
3415 case CXXAddrspaceCastExprClass:
3416 case CXXConstCastExprClass: {
3417 const CastExpr *CE = cast<CastExpr>(
this);
3431 case MaterializeTemporaryExprClass:
3432 return cast<MaterializeTemporaryExpr>(
this)
3434 ->isConstantInitializer(Ctx,
false, Culprit);
3436 case SubstNonTypeTemplateParmExprClass:
3437 return cast<SubstNonTypeTemplateParmExpr>(
this)->getReplacement()
3438 ->isConstantInitializer(Ctx,
false, Culprit);
3439 case CXXDefaultArgExprClass:
3440 return cast<CXXDefaultArgExpr>(
this)->getExpr()
3441 ->isConstantInitializer(Ctx,
false, Culprit);
3442 case CXXDefaultInitExprClass:
3443 return cast<CXXDefaultInitExpr>(
this)->getExpr()
3444 ->isConstantInitializer(Ctx,
false, Culprit);
3458 if (BuiltinID != Builtin::BI__assume &&
3459 BuiltinID != Builtin::BI__builtin_assume)
3476 const bool IncludePossibleEffects;
3477 bool HasSideEffects;
3480 explicit SideEffectFinder(
const ASTContext &Context,
bool IncludePossible)
3481 : Inherited(Context),
3482 IncludePossibleEffects(IncludePossible), HasSideEffects(
false) { }
3484 bool hasSideEffects()
const {
return HasSideEffects; }
3486 void VisitDecl(
const Decl *D) {
3492 if (
auto *VD = dyn_cast<VarDecl>(D)) {
3494 if (IncludePossibleEffects && VD->isThisDeclarationADefinition() &&
3495 VD->needsDestruction(Context))
3496 HasSideEffects =
true;
3500 void VisitDeclStmt(
const DeclStmt *DS) {
3501 for (
auto *D : DS->
decls())
3503 Inherited::VisitDeclStmt(DS);
3506 void VisitExpr(
const Expr *E) {
3507 if (!HasSideEffects &&
3509 HasSideEffects =
true;
3515 bool IncludePossibleEffects)
const {
3519 if (!IncludePossibleEffects &&
getExprLoc().isMacroID())
3524 #define ABSTRACT_STMT(Type)
3525 #define STMT(Type, Base) case Type##Class:
3526 #define EXPR(Type, Base)
3527 #include "clang/AST/StmtNodes.inc"
3528 llvm_unreachable(
"unexpected Expr kind");
3530 case DependentScopeDeclRefExprClass:
3531 case CXXUnresolvedConstructExprClass:
3532 case CXXDependentScopeMemberExprClass:
3533 case UnresolvedLookupExprClass:
3534 case UnresolvedMemberExprClass:
3535 case PackExpansionExprClass:
3536 case SubstNonTypeTemplateParmPackExprClass:
3537 case FunctionParmPackExprClass:
3539 case RecoveryExprClass:
3540 case CXXFoldExprClass:
3542 return IncludePossibleEffects;
3544 case DeclRefExprClass:
3545 case ObjCIvarRefExprClass:
3546 case PredefinedExprClass:
3547 case IntegerLiteralClass:
3548 case FixedPointLiteralClass:
3549 case FloatingLiteralClass:
3550 case ImaginaryLiteralClass:
3551 case StringLiteralClass:
3552 case CharacterLiteralClass:
3553 case OffsetOfExprClass:
3554 case ImplicitValueInitExprClass:
3555 case UnaryExprOrTypeTraitExprClass:
3556 case AddrLabelExprClass:
3557 case GNUNullExprClass:
3558 case ArrayInitIndexExprClass:
3559 case NoInitExprClass:
3560 case CXXBoolLiteralExprClass:
3561 case CXXNullPtrLiteralExprClass:
3562 case CXXThisExprClass:
3563 case CXXScalarValueInitExprClass:
3564 case TypeTraitExprClass:
3565 case ArrayTypeTraitExprClass:
3566 case ExpressionTraitExprClass:
3567 case CXXNoexceptExprClass:
3568 case SizeOfPackExprClass:
3569 case ObjCStringLiteralClass:
3570 case ObjCEncodeExprClass:
3571 case ObjCBoolLiteralExprClass:
3572 case ObjCAvailabilityCheckExprClass:
3573 case CXXUuidofExprClass:
3574 case OpaqueValueExprClass:
3575 case SourceLocExprClass:
3576 case ConceptSpecializationExprClass:
3577 case RequiresExprClass:
3578 case SYCLUniqueStableNameExprClass:
3582 case ConstantExprClass:
3584 return cast<ConstantExpr>(
this)->getSubExpr()->HasSideEffects(
3585 Ctx, IncludePossibleEffects);
3588 case CXXOperatorCallExprClass:
3589 case CXXMemberCallExprClass:
3590 case CUDAKernelCallExprClass:
3591 case UserDefinedLiteralClass: {
3595 const Decl *FD = cast<CallExpr>(
this)->getCalleeDecl();
3596 bool IsPure = FD && (FD->
hasAttr<ConstAttr>() || FD->
hasAttr<PureAttr>());
3597 if (IsPure || !IncludePossibleEffects)
3602 case BlockExprClass:
3603 case CXXBindTemporaryExprClass:
3604 if (!IncludePossibleEffects)
3608 case MSPropertyRefExprClass:
3609 case MSPropertySubscriptExprClass:
3610 case CompoundAssignOperatorClass:
3611 case VAArgExprClass:
3612 case AtomicExprClass:
3613 case CXXThrowExprClass:
3614 case CXXNewExprClass:
3615 case CXXDeleteExprClass:
3616 case CoawaitExprClass:
3617 case DependentCoawaitExprClass:
3618 case CoyieldExprClass:
3622 case StmtExprClass: {
3624 SideEffectFinder Finder(Ctx, IncludePossibleEffects);
3625 Finder.Visit(cast<StmtExpr>(
this)->getSubStmt());
3626 return Finder.hasSideEffects();
3629 case ExprWithCleanupsClass:
3630 if (IncludePossibleEffects)
3631 if (cast<ExprWithCleanups>(
this)->cleanupsHaveSideEffects())
3635 case ParenExprClass:
3636 case ArraySubscriptExprClass:
3637 case MatrixSubscriptExprClass:
3638 case OMPArraySectionExprClass:
3639 case OMPArrayShapingExprClass:
3640 case OMPIteratorExprClass:
3641 case MemberExprClass:
3642 case ConditionalOperatorClass:
3643 case BinaryConditionalOperatorClass:
3644 case CompoundLiteralExprClass:
3645 case ExtVectorElementExprClass:
3646 case DesignatedInitExprClass:
3647 case DesignatedInitUpdateExprClass:
3648 case ArrayInitLoopExprClass:
3649 case ParenListExprClass:
3650 case CXXPseudoDestructorExprClass:
3651 case CXXRewrittenBinaryOperatorClass:
3652 case CXXStdInitializerListExprClass:
3653 case SubstNonTypeTemplateParmExprClass:
3654 case MaterializeTemporaryExprClass:
3655 case ShuffleVectorExprClass:
3656 case ConvertVectorExprClass:
3657 case AsTypeExprClass:
3658 case CXXParenListInitExprClass:
3662 case UnaryOperatorClass:
3663 if (cast<UnaryOperator>(
this)->isIncrementDecrementOp())
3667 case BinaryOperatorClass:
3668 if (cast<BinaryOperator>(
this)->isAssignmentOp())
3672 case InitListExprClass:
3674 if (
const Expr *E = cast<InitListExpr>(
this)->getArrayFiller())
3679 case GenericSelectionExprClass:
3680 return cast<GenericSelectionExpr>(
this)->getResultExpr()->
3683 case ChooseExprClass:
3684 return cast<ChooseExpr>(
this)->getChosenSubExpr()->HasSideEffects(
3685 Ctx, IncludePossibleEffects);
3687 case CXXDefaultArgExprClass:
3688 return cast<CXXDefaultArgExpr>(
this)->getExpr()->HasSideEffects(
3689 Ctx, IncludePossibleEffects);
3691 case CXXDefaultInitExprClass: {
3692 const FieldDecl *FD = cast<CXXDefaultInitExpr>(
this)->getField();
3699 case CXXDynamicCastExprClass: {
3707 case ImplicitCastExprClass:
3708 case CStyleCastExprClass:
3709 case CXXStaticCastExprClass:
3710 case CXXReinterpretCastExprClass:
3711 case CXXConstCastExprClass:
3712 case CXXAddrspaceCastExprClass:
3713 case CXXFunctionalCastExprClass:
3714 case BuiltinBitCastExprClass: {
3719 if (!IncludePossibleEffects)
3722 const CastExpr *CE = cast<CastExpr>(
this);
3729 case CXXTypeidExprClass:
3732 return cast<CXXTypeidExpr>(
this)->isPotentiallyEvaluated();
3734 case CXXConstructExprClass:
3735 case CXXTemporaryObjectExprClass: {
3744 case CXXInheritedCtorInitExprClass: {
3745 const auto *ICIE = cast<CXXInheritedCtorInitExpr>(
this);
3746 if (!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)
3751 case LambdaExprClass: {
3752 const LambdaExpr *LE = cast<LambdaExpr>(
this);
3753 for (
Expr *E : LE->capture_inits())
3759 case PseudoObjectExprClass: {
3766 const Expr *Subexpr = *I;
3768 Subexpr = OVE->getSourceExpr();
3775 case ObjCBoxedExprClass:
3776 case ObjCArrayLiteralClass:
3777 case ObjCDictionaryLiteralClass:
3778 case ObjCSelectorExprClass:
3779 case ObjCProtocolExprClass:
3780 case ObjCIsaExprClass:
3781 case ObjCIndirectCopyRestoreExprClass:
3782 case ObjCSubscriptRefExprClass:
3783 case ObjCBridgedCastExprClass:
3784 case ObjCMessageExprClass:
3785 case ObjCPropertyRefExprClass:
3787 if (IncludePossibleEffects)
3795 cast<Expr>(SubStmt)->
HasSideEffects(Ctx, IncludePossibleEffects))
3802 if (
auto Call = dyn_cast<CallExpr>(
this))
3803 return Call->getFPFeaturesInEffect(LO);
3804 if (
auto UO = dyn_cast<UnaryOperator>(
this))
3805 return UO->getFPFeaturesInEffect(LO);
3806 if (
auto BO = dyn_cast<BinaryOperator>(
this))
3807 return BO->getFPFeaturesInEffect(LO);
3808 if (
auto Cast = dyn_cast<CastExpr>(
this))
3809 return Cast->getFPFeaturesInEffect(LO);
3822 explicit NonTrivialCallFinder(
const ASTContext &Context)
3823 : Inherited(Context), NonTrivial(
false) { }
3825 bool hasNonTrivialCall()
const {
return NonTrivial; }
3827 void VisitCallExpr(
const CallExpr *E) {
3829 = dyn_cast_or_null<const CXXMethodDecl>(E->
getCalleeDecl())) {
3830 if (Method->isTrivial()) {
3832 Inherited::VisitStmt(E);
3843 Inherited::VisitStmt(E);
3852 Inherited::VisitStmt(E);
3862 NonTrivialCallFinder Finder(Ctx);
3864 return Finder.hasNonTrivialCall();
3882 llvm_unreachable(
"Unexpected value dependent expression!");
3910 CE->getSubExpr()->getType()->isIntegerType())
3911 return CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3914 }
else if (
const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(
this)) {
3916 return ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3917 }
else if (
const ParenExpr *PE = dyn_cast<ParenExpr>(
this)) {
3920 return PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3922 dyn_cast<GenericSelectionExpr>(
this)) {
3923 if (GE->isResultDependent())
3925 return GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);
3926 }
else if (
const ChooseExpr *CE = dyn_cast<ChooseExpr>(
this)) {
3927 if (CE->isConditionDependent())
3929 return CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);
3931 = dyn_cast<CXXDefaultArgExpr>(
this)) {
3933 return DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);
3935 = dyn_cast<CXXDefaultInitExpr>(
this)) {
3937 return DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);
3938 }
else if (isa<GNUNullExpr>(
this)) {
3942 = dyn_cast<MaterializeTemporaryExpr>(
this)) {
3943 return M->getSubExpr()->isNullPointerConstant(Ctx, NPC);
3944 }
else if (
const OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(
this)) {
3945 if (
const Expr *Source = OVE->getSourceExpr())
3946 return Source->isNullPointerConstant(Ctx, NPC);
3955 if (
getType()->isNullPtrType())
3960 UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())
3962 const Expr *InitExpr = CLE->getInitializer();
3963 if (
const InitListExpr *ILE = dyn_cast<InitListExpr>(InitExpr))
3967 if (!
getType()->isIntegerType() ||
3990 if (isa<IntegerLiteral>(
this))
3998 const Expr *E =
this;
4001 "expression is not a property reference");
4004 if (BO->getOpcode() == BO_Comma) {
4013 return cast<ObjCPropertyRefExpr>(E);
4019 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
4038 if (ICE->getCastKind() == CK_LValueToRValue ||
4039 (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp))
4045 if (
MemberExpr *MemRef = dyn_cast<MemberExpr>(E))
4046 if (
FieldDecl *Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))
4047 if (Field->isBitField())
4056 if (
DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E)) {
4057 if (
FieldDecl *Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))
4058 if (Field->isBitField())
4061 if (
BindingDecl *BD = dyn_cast<BindingDecl>(DeclRef->getDecl()))
4062 if (
Expr *E = BD->getBinding())
4067 if (BinOp->isAssignmentOp() && BinOp->getLHS())
4068 return BinOp->getLHS()->getSourceBitField();
4070 if (BinOp->getOpcode() == BO_Comma && BinOp->getRHS())
4071 return BinOp->getRHS()->getSourceBitField();
4075 if (UnOp->isPrefix() && UnOp->isIncrementDecrementOp())
4076 return UnOp->getSubExpr()->getSourceBitField();
4086 if (ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)
4095 if (isa<ExtVectorElementExpr>(E))
4098 if (
auto *DRE = dyn_cast<DeclRefExpr>(E))
4099 if (
auto *BD = dyn_cast<BindingDecl>(DRE->getDecl()))
4100 if (
auto *E = BD->getBinding())
4109 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
4110 if (
const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
4112 VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())
4128 case CXXThisExprClass:
4130 case DeclRefExprClass: {
4133 const auto *DRE1 = cast<DeclRefExpr>(E1);
4134 const auto *DRE2 = cast<DeclRefExpr>(E2);
4135 return DRE1->isPRValue() && DRE2->isPRValue() &&
4136 DRE1->getDecl() == DRE2->getDecl();
4138 case ImplicitCastExprClass: {
4141 const auto *ICE1 = dyn_cast<ImplicitCastExpr>(E1);
4142 const auto *ICE2 = dyn_cast<ImplicitCastExpr>(E2);
4145 if (ICE1->getCastKind() != ICE2->getCastKind())
4150 if (ICE1->getCastKind() == CK_LValueToRValue ||
4151 ICE1->getCastKind() == CK_ArrayToPointerDecay ||
4152 ICE1->getCastKind() == CK_FunctionToPointerDecay) {
4157 const auto *DRE1 = dyn_cast<DeclRefExpr>(E1);
4158 const auto *DRE2 = dyn_cast<DeclRefExpr>(E2);
4162 const auto *Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);
4163 const auto *Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);
4164 if (Ivar1 && Ivar2) {
4165 return Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&
4169 const auto *Array1 = dyn_cast<ArraySubscriptExpr>(E1);
4170 const auto *Array2 = dyn_cast<ArraySubscriptExpr>(E2);
4171 if (Array1 && Array2) {
4175 auto Idx1 = Array1->getIdx();
4176 auto Idx2 = Array2->getIdx();
4177 const auto Integer1 = dyn_cast<IntegerLiteral>(Idx1);
4178 const auto Integer2 = dyn_cast<IntegerLiteral>(Idx2);
4179 if (Integer1 && Integer2) {
4180 if (!llvm::APInt::isSameValue(Integer1->getValue(),
4181 Integer2->getValue()))
4192 while (isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {
4193 const auto *ME1 = cast<MemberExpr>(E1);
4194 const auto *ME2 = cast<MemberExpr>(E2);
4197 if (
const auto *D = dyn_cast<VarDecl>(ME1->getMemberDecl()))
4198 if (D->isStaticDataMember())
4204 if (isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))
4210 if (
const auto *DRE = dyn_cast<DeclRefExpr>(E))
4211 return DRE->getDecl();
4212 if (
const auto *ME = dyn_cast<MemberExpr>(E))
4213 return ME->getMemberDecl();
4232 return VT->getNumElements();
4240 StringRef Comp = Accessor->
getName();
4243 if (Comp ==
"hi" || Comp ==
"lo" || Comp ==
"even" || Comp ==
"odd")
4247 if (Comp[0] ==
's' || Comp[0] ==
'S')
4248 Comp = Comp.substr(1);
4250 for (
unsigned i = 0, e = Comp.size(); i != e; ++i)
4251 if (Comp.substr(i + 1).contains(Comp[i]))
4260 StringRef Comp = Accessor->
getName();
4261 bool isNumericAccessor =
false;
4262 if (Comp[0] ==
's' || Comp[0] ==
'S') {
4263 Comp = Comp.substr(1);
4264 isNumericAccessor =
true;
4267 bool isHi = Comp ==
"hi";
4268 bool isLo = Comp ==
"lo";
4269 bool isEven = Comp ==
"even";
4270 bool isOdd = Comp ==
"odd";
4286 Elts.push_back(Index);
4294 BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
4295 SubExprs =
new (
C)
Stmt*[args.size()];
4296 for (
unsigned i = 0; i != args.size(); i++)
4297 SubExprs[i] = args[i];
4303 if (SubExprs)
C.Deallocate(SubExprs);
4305 this->NumExprs = Exprs.size();
4306 SubExprs =
new (
C)
Stmt*[NumExprs];
4307 memcpy(SubExprs, Exprs.data(),
sizeof(
Expr *) * Exprs.size());
4310GenericSelectionExpr::GenericSelectionExpr(
4314 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex)
4315 :
Expr(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),
4316 AssocExprs[ResultIndex]->getValueKind(),
4317 AssocExprs[ResultIndex]->getObjectKind()),
4318 NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),
4319 DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4320 assert(AssocTypes.size() == AssocExprs.size() &&
4321 "Must have the same number of association expressions"
4322 " and TypeSourceInfo!");
4323 assert(ResultIndex < NumAssocs &&
"ResultIndex is out-of-bounds!");
4326 getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
4327 std::copy(AssocExprs.begin(), AssocExprs.end(),
4328 getTrailingObjects<Stmt *>() + AssocExprStartIndex);
4329 std::copy(AssocTypes.begin(), AssocTypes.end(),
4330 getTrailingObjects<TypeSourceInfo *>());
4335GenericSelectionExpr::GenericSelectionExpr(
4339 bool ContainsUnexpandedParameterPack)
4340 :
Expr(GenericSelectionExprClass, Context.DependentTy,
VK_PRValue,
4342 NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),
4343 DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {
4344 assert(AssocTypes.size() == AssocExprs.size() &&
4345 "Must have the same number of association expressions"
4346 " and TypeSourceInfo!");
4349 getTrailingObjects<Stmt *>()[ControllingIndex] = ControllingExpr;
4350 std::copy(AssocExprs.begin(), AssocExprs.end(),
4351 getTrailingObjects<Stmt *>() + AssocExprStartIndex);
4352 std::copy(AssocTypes.begin(), AssocTypes.end(),
4353 getTrailingObjects<TypeSourceInfo *>());
4358GenericSelectionExpr::GenericSelectionExpr(EmptyShell Empty,
unsigned NumAssocs)
4359 :
Expr(GenericSelectionExprClass, Empty), NumAssocs(NumAssocs) {}
4365 bool ContainsUnexpandedParameterPack,
unsigned ResultIndex) {
4366 unsigned NumAssocs = AssocExprs.size();
4368 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4371 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4372 RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);
4379 bool ContainsUnexpandedParameterPack) {
4380 unsigned NumAssocs = AssocExprs.size();
4382 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4385 Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,
4386 RParenLoc, ContainsUnexpandedParameterPack);
4391 unsigned NumAssocs) {
4393 totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),
4403 assert(Kind ==
FieldDesignator &&
"Only valid on a field designator");
4416 EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),
4417 NumDesignators(Designators.
size()), NumSubExprs(IndexExprs.
size() + 1) {
4418 this->Designators =
new (
C)
Designator[NumDesignators];
4426 unsigned IndexIdx = 0;
4427 for (
unsigned I = 0; I != NumDesignators; ++I) {
4428 this->Designators[I] = Designators[I];
4431 *Child++ = IndexExprs[IndexIdx++];
4434 *Child++ = IndexExprs[IndexIdx++];
4435 *Child++ = IndexExprs[IndexIdx++];
4439 assert(IndexIdx == IndexExprs.size() &&
"Wrong number of index expressions");
4448 bool UsesColonSyntax,
Expr *Init) {
4449 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),
4452 ColonOrEqualLoc, UsesColonSyntax,
4457 unsigned NumIndexExprs) {
4458 void *Mem =
C.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),
4465 unsigned NumDesigs) {
4467 NumDesignators = NumDesigs;
4468 for (
unsigned I = 0; I != NumDesigs; ++I)
4469 Designators[I] = Desigs[I];
4484 if (
First.isFieldDesignator())
4485 StartLoc = GNUSyntax ?
First.Field.FieldLoc :
First.Field.DotLoc;
4487 StartLoc =
First.ArrayOrRange.LBracketLoc;
4496 assert(D.Kind == Designator::ArrayDesignator &&
"Requires array designator");
4501 assert(D.Kind == Designator::ArrayRangeDesignator &&
4502 "Requires array range designator");
4507 assert(D.Kind == Designator::ArrayRangeDesignator &&
4508 "Requires array range designator");
4517 unsigned NumNewDesignators =
Last -
First;
4518 if (NumNewDesignators == 0) {
4519 std::copy_backward(Designators + Idx + 1,
4520 Designators + NumDesignators,
4522 --NumNewDesignators;
4525 if (NumNewDesignators == 1) {
4526 Designators[Idx] = *
First;
4531 =
new (
C)
Designator[NumDesignators - 1 + NumNewDesignators];
4532 std::copy(Designators, Designators + Idx, NewDesignators);
4533 std::copy(
First,
Last, NewDesignators + Idx);
4534 std::copy(Designators + Idx + 1, Designators + NumDesignators,
4535 NewDesignators + Idx + NumNewDesignators);
4536 Designators = NewDesignators;
4537 NumDesignators = NumDesignators - 1 + NumNewDesignators;
4546 BaseAndUpdaterExprs[0] = baseExpr;
4551 BaseAndUpdaterExprs[1] = ILE;
4568 LParenLoc(LParenLoc), RParenLoc(RParenLoc) {
4571 for (
unsigned I = 0, N = Exprs.size(); I != N; ++I)
4572 getTrailingObjects<Stmt *>()[I] = Exprs[I];
4576ParenListExpr::ParenListExpr(EmptyShell Empty,
unsigned NumExprs)
4577 :
Expr(ParenListExprClass, Empty) {
4585 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Stmt *>(Exprs.size()),
4587 return new (Mem)
ParenListExpr(LParenLoc, Exprs, RParenLoc);
4591 unsigned NumExprs) {
4601 :
Expr(BinaryOperatorClass, ResTy, VK, OK) {
4604 "Use CompoundAssignOperator for compound assignments");
4606 SubExprs[LHS] = lhs;
4607 SubExprs[RHS] = rhs;
4618 :
Expr(CompoundAssignOperatorClass, ResTy, VK, OK) {
4621 "Use CompoundAssignOperator for compound assignments");
4623 SubExprs[LHS] = lhs;
4624 SubExprs[RHS] = rhs;
4632 bool HasFPFeatures) {
4672 CompLHSType, CompResultType);
4676 bool hasFPFeatures) {
4677 void *Mem =
C.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),
4686 :
Expr(UnaryOperatorClass,
type, VK, OK), Val(input) {
4702 unsigned Size = totalSizeToAlloc<FPOptionsOverride>(HasFPFeatures);
4710 e = ewc->getSubExpr();
4712 e = m->getSubExpr();
4713 e = cast<CXXConstructExpr>(e)->getArg(0);
4715 e = ice->getSubExpr();
4716 return cast<OpaqueValueExpr>(e);
4721 unsigned numSemanticExprs) {
4723 Context.
Allocate(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),
4728PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell,
unsigned numSemanticExprs)
4729 :
Expr(PseudoObjectExprClass, shell) {
4735 unsigned resultIndex) {
4736 assert(syntax &&
"no syntactic expression!");
4737 assert(
semantics.size() &&
"no semantic expressions!");
4747 VK =
semantics[resultIndex]->getValueKind();
4751 void *buffer =
C.Allocate(totalSizeToAlloc<Expr *>(
semantics.size() + 1),
4759 unsigned resultIndex)
4764 for (
unsigned i = 0, e =
semantics.size() + 1; i != e; ++i) {
4766 getSubExprsBuffer()[i] = E;
4768 if (isa<OpaqueValueExpr>(E))
4769 assert(cast<OpaqueValueExpr>(E)->getSourceExpr() !=
nullptr &&
4770 "opaque-value semantic expressions for pseudo-object "
4771 "operations must have sources");
4804 NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {
4805 assert(args.size() ==
getNumSubExprs(op) &&
"wrong number of subexpressions");
4806 for (
unsigned i = 0; i != args.size(); i++)
4807 SubExprs[i] = args[i];
4813 case AO__c11_atomic_init:
4814 case AO__opencl_atomic_init:
4815 case AO__c11_atomic_load:
4816 case AO__atomic_load_n:
4819 case AO__opencl_atomic_load:
4820 case AO__hip_atomic_load:
4821 case AO__c11_atomic_store:
4822 case AO__c11_atomic_exchange:
4823 case AO__atomic_load:
4824 case AO__atomic_store:
4825 case AO__atomic_store_n:
4826 case AO__atomic_exchange_n:
4827 case AO__c11_atomic_fetch_add:
4828 case AO__c11_atomic_fetch_sub:
4829 case AO__c11_atomic_fetch_and:
4830 case AO__c11_atomic_fetch_or:
4831 case AO__c11_atomic_fetch_xor:
4832 case AO__c11_atomic_fetch_nand:
4833 case AO__c11_atomic_fetch_max:
4834 case AO__c11_atomic_fetch_min:
4835 case AO__atomic_fetch_add:
4836 case AO__atomic_fetch_sub:
4837 case AO__atomic_fetch_and:
4838 case AO__atomic_fetch_or:
4839 case AO__atomic_fetch_xor:
4840 case AO__atomic_fetch_nand:
4841 case AO__atomic_add_fetch:
4842 case AO__atomic_sub_fetch:
4843 case AO__atomic_and_fetch:
4844 case AO__atomic_or_fetch:
4845 case AO__atomic_xor_fetch:
4846 case AO__atomic_nand_fetch:
4847 case AO__atomic_min_fetch:
4848 case AO__atomic_max_fetch:
4849 case AO__atomic_fetch_min:
4850 case AO__atomic_fetch_max:
4853 case AO__hip_atomic_exchange:
4854 case AO__hip_atomic_fetch_add:
4855 case AO__hip_atomic_fetch_and:
4856 case AO__hip_atomic_fetch_or:
4857 case AO__hip_atomic_fetch_xor:
4858 case AO__hip_atomic_fetch_min:
4859 case AO__hip_atomic_fetch_max:
4860 case AO__opencl_atomic_store:
4861 case AO__hip_atomic_store:
4862 case AO__opencl_atomic_exchange:
4863 case AO__opencl_atomic_fetch_add:
4864 case AO__opencl_atomic_fetch_sub:
4865 case AO__opencl_atomic_fetch_and:
4866 case AO__opencl_atomic_fetch_or:
4867 case AO__opencl_atomic_fetch_xor:
4868 case AO__opencl_atomic_fetch_min:
4869 case AO__opencl_atomic_fetch_max:
4870 case AO__atomic_exchange:
4873 case AO__c11_atomic_compare_exchange_strong:
4874 case AO__c11_atomic_compare_exchange_weak:
4876 case AO__hip_atomic_compare_exchange_strong:
4877 case AO__opencl_atomic_compare_exchange_strong:
4878 case AO__opencl_atomic_compare_exchange_weak:
4879 case AO__hip_atomic_compare_exchange_weak:
4880 case AO__atomic_compare_exchange:
4881 case AO__atomic_compare_exchange_n:
4884 llvm_unreachable(
"unknown atomic op");
4890 return AT->getValueType();
4895 unsigned ArraySectionCount = 0;
4896 while (
auto *OASE = dyn_cast<OMPArraySectionExpr>(
Base->IgnoreParens())) {
4897 Base = OASE->getBase();
4898 ++ArraySectionCount;
4901 dyn_cast<ArraySubscriptExpr>(
Base->IgnoreParenImpCasts())) {
4902 Base = ASE->getBase();
4903 ++ArraySectionCount;
4905 Base =
Base->IgnoreParenImpCasts();
4906 auto OriginalTy =
Base->getType();
4907 if (
auto *DRE = dyn_cast<DeclRefExpr>(
Base))
4908 if (
auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
4909 OriginalTy = PVD->getOriginalType().getNonReferenceType();
4911 for (
unsigned Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {
4912 if (OriginalTy->isAnyPointerType())
4913 OriginalTy = OriginalTy->getPointeeType();
4915 assert (OriginalTy->isArrayType());
4916 OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();
4924 :
Expr(RecoveryExprClass, T.getNonReferenceType(),
4925 T->isDependentType() ?
VK_LValue : getValueKindForType(T),
4927 BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {
4929 assert(!llvm::is_contained(SubExprs,
nullptr));
4931 llvm::copy(SubExprs, getTrailingObjects<Expr *>());
4939 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(SubExprs.size()),
4941 return new (Mem)
RecoveryExpr(Ctx, T, BeginLoc, EndLoc, SubExprs);
4945 void *Mem = Ctx.
Allocate(totalSizeToAlloc<Expr *>(NumSubExprs),
4952 NumDims == Dims.size() &&
4953 "Preallocated number of dimensions is different from the provided one.");
4954 llvm::copy(Dims, getTrailingObjects<Expr *>());
4959 NumDims == BR.size() &&
4960 "Preallocated number of dimensions is different from the provided one.");
4961 llvm::copy(BR, getTrailingObjects<SourceRange>());
4964OMPArrayShapingExpr::OMPArrayShapingExpr(
QualType ExprTy,
Expr *Op,
4968 RPLoc(R), NumDims(Dims.size()) {
4970 setDimensions(Dims);
4979 assert(Dims.size() == BracketRanges.size() &&
4980 "Different number of dimensions and brackets ranges.");
4982 totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),
4985 E->setBracketsRanges(BracketRanges);
4992 totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),
4997void OMPIteratorExpr::setIteratorDeclaration(
unsigned I,
Decl *D) {
4998 assert(I < NumIterators &&
4999 "Idx is greater or equal the number of iterators definitions.");
5000 getTrailingObjects<Decl *>()[I] = D;
5003void OMPIteratorExpr::setAssignmentLoc(
unsigned I,
SourceLocation Loc) {
5004 assert(I < NumIterators &&
5005 "Idx is greater or equal the number of iterators definitions.");
5008 static_cast<int>(RangeLocOffset::AssignLoc)] = Loc;
5011void OMPIteratorExpr::setIteratorRange(
unsigned I,
Expr *
Begin,
5015 assert(I < NumIterators &&
5016 "Idx is greater or equal the number of iterators definitions.");
5017 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5018 static_cast<int>(RangeExprOffset::Begin)] =
5020 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5021 static_cast<int>(RangeExprOffset::End)] = End;
5022 getTrailingObjects<Expr *>()[I *
static_cast<int>(RangeExprOffset::Total) +
5023 static_cast<int>(RangeExprOffset::Step)] = Step;
5026 static_cast<int>(RangeLocOffset::FirstColonLoc)] =
5030 static_cast<int>(RangeLocOffset::SecondColonLoc)] =
5035 return getTrailingObjects<Decl *>()[I];
5041 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5042 RangeExprOffset::Total) +
5043 static_cast<int>(RangeExprOffset::Begin)];
5045 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5046 RangeExprOffset::Total) +
5047 static_cast<int>(RangeExprOffset::End)];
5049 getTrailingObjects<Expr *>()[I *
static_cast<int>(
5050 RangeExprOffset::Total) +
5051 static_cast<int>(RangeExprOffset::Step)];
5056 return getTrailingObjects<
5058 static_cast<int>(Range