RetroSearch Browse

.isMemberPointer())

232 return Value

.getMemberPointerDecl();

234 if

(

.isLValue() &&

.getLValueOffset().isZero())

248 template

class

251 return static_cast<const E

>

(

)->getExprLoc();

261 return static_cast<const E

>

(

)->getBeginLoc();

266 if

(isa<EnumType>(

()))

269 const auto

*ED = cast<EnumDecl>(ECD->getDeclContext());

270 if

(ED->isCompleteDefinition())

279#define ABSTRACT_STMT(type) 280#define STMT(type, base) \ 281 case Stmt::type##Class: break; 282#define EXPR(type, base) \ 283 case Stmt::type##Class: return getExprLocImpl<type>(this, &type::getExprLoc); 284#include "clang/AST/StmtNodes.inc" 286

llvm_unreachable(

"unknown expression kind"

);

297 "Invalid StorageKind Value"

);

307 if

.getInt().needsCleanup())

323 bool

IsImmediateInvocation)

324

FullExpr

(ConstantExprClass, SubExpr) {

333

::new (getTrailingObjects<APValue>())

();

338 bool

IsImmediateInvocation) {

339

assert(!isa<ConstantExpr>(

));

342 unsigned

Size = totalSizeToAlloc<APValue, uint64_t>(

346 return new

(Mem)

ConstantExpr

(

, StorageKind, IsImmediateInvocation);

357

ConstantExpr::ConstantExpr(EmptyShell

363

::new (getTrailingObjects<APValue>())

();

370 unsigned

Size = totalSizeToAlloc<APValue, uint64_t>(

379 "Invalid storage for this value kind"

);

385

Int64Result() = *

.getInt().getRawData();

394

APValueResult() = std::move(

);

397

llvm_unreachable(

"Invalid ResultKind Bits"

);

403 return

APValueResult().

getInt

();

405 return

llvm::APSInt(llvm::APInt(

ConstantExprBits

.BitWidth, Int64Result()),

408

llvm_unreachable(

"invalid Accessor"

);

416 return

APValueResult();

426

llvm_unreachable(

"invalid ResultKind"

);

430 bool

RefersToEnclosingVariableOrCapture,

QualType T

440

RefersToEnclosingVariableOrCapture;

441 DeclRefExprBits

.CapturedByCopyInLambdaWithExplicitObjectParameter =

false

;

448

DeclRefExpr::DeclRefExpr(

const ASTContext

&Ctx,

451 bool

RefersToEnclosingVariableOrCapture,

460 new

(getTrailingObjects<NestedNameSpecifierLoc>())

464

*getTrailingObjects<NamedDecl *>() = FoundD;

466

= (TemplateArgs || TemplateKWLoc.

()) ? 1 : 0;

468

RefersToEnclosingVariableOrCapture;

469 DeclRefExprBits

.CapturedByCopyInLambdaWithExplicitObjectParameter =

false

;

472 auto

Deps = TemplateArgumentDependence::None;

473

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

474

TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),

476

assert(!(Deps & TemplateArgumentDependence::Dependent) &&

477 "built a DeclRefExpr with dependent template args"

);

478

}

else if

(TemplateKWLoc.

()) {

479

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

490 bool

RefersToEnclosingVariableOrCapture,

495 return Create

(Context, QualifierLoc, TemplateKWLoc,

496

RefersToEnclosingVariableOrCapture,

498 T

, VK, FoundD, TemplateArgs, NOUR);

504 bool

RefersToEnclosingVariableOrCapture,

514 bool

HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.

();

518

QualifierLoc ? 1 : 0, FoundD ? 1 : 0,

519

HasTemplateKWAndArgsInfo ? 1 : 0,

520

TemplateArgs ? TemplateArgs->

() : 0);

523 return new

(Mem)

DeclRefExpr

(Context, QualifierLoc, TemplateKWLoc,

524

RefersToEnclosingVariableOrCapture, NameInfo,

525

FoundD, TemplateArgs,

, VK, NOUR);

531 bool

HasTemplateKWAndArgsInfo,

532 unsigned

NumTemplateArgs) {

533

assert(NumTemplateArgs == 0 || HasTemplateKWAndArgsInfo);

537

HasQualifier ? 1 : 0, HasFoundDecl ? 1 : 0, HasTemplateKWAndArgsInfo,

545 if

(

()->isUndeducedType())

561

SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(

SourceLocation

OpLoc,

567

OpLoc(OpLoc), LParen(LParen), RParen(RParen) {

568

setTypeSourceInfo(TSI);

572

SYCLUniqueStableNameExpr::SYCLUniqueStableNameExpr(EmptyShell

599 const NamedDecl

*ND) -> std::optional<unsigned> {

600 if

(

const auto

*RD = dyn_cast<CXXRecordDecl>(ND))

601 return

RD->getDeviceLambdaManglingNumber();

610

llvm::raw_string_ostream Out(Buffer);

611

Ctx->mangleCanonicalTypeName(Ty, Out);

621

assert((getIdentKind() == IK) &&

622 "IdentKind do not fit in PredefinedExprBitfields!"

);

623 bool

HasFunctionName = SL !=

nullptr

;

632

PredefinedExpr::PredefinedExpr(EmptyShell

bool

HasFunctionName)

640 bool

HasFunctionName = SL !=

nullptr

;

641 void

*Mem = Ctx.

(totalSizeToAlloc<Stmt *>(HasFunctionName),

647 bool

HasFunctionName) {

648 void

*Mem = Ctx.

(totalSizeToAlloc<Stmt *>(HasFunctionName),

658 return "__FUNCTION__"

;

660 return "__FUNCDNAME__"

;

662 return "L__FUNCTION__"

;

664 return "__PRETTY_FUNCTION__"

;

666 return "__FUNCSIG__"

;

668 return "L__FUNCSIG__"

;

672

llvm_unreachable(

"Unknown ident kind for PredefinedExpr"

);

678 const Decl

*CurrentDecl,

679 bool

ForceElaboratedPrinting) {

683 if

(

const NamedDecl

*ND = dyn_cast<NamedDecl>(CurrentDecl)) {

684

std::unique_ptr<MangleContext> MC;

687 if

(MC->shouldMangleDeclName(ND)) {

689

llvm::raw_svector_ostream Out(Buffer);

695 else if

(ND->hasAttr<CUDAGlobalAttr>())

699

MC->mangleName(GD, Out);

701 if

(!Buffer.empty() && Buffer.front() ==

'\01'

)

702 return

std::string(Buffer.substr(1));

703 return

std::string(Buffer);

705 return

std::string(ND->getIdentifier()->getName());

709 if

(isa<BlockDecl>(CurrentDecl)) {

714 if

(DC->isFileContext())

718

llvm::raw_svector_ostream Out(Buffer);

719 if

(

auto

*DCBlock = dyn_cast<BlockDecl>(DC))

722 else if

(

auto

*DCDecl = dyn_cast<Decl>(DC))

723

Out <<

ComputeName

(IK, DCDecl) <<

"_block_invoke"

;

724 return

std::string(Out.str());

726 if

(

const FunctionDecl

*FD = dyn_cast<FunctionDecl>(CurrentDecl)) {

728 bool

IsFuncOrFunctionInNonMSVCCompatEnv =

730

IK == PredefinedIdentKind ::Function) &&

732 bool

IsLFunctionInMSVCCommpatEnv =

734 bool

IsFuncOrFunctionOrLFunctionOrFuncDName =

739 if

((ForceElaboratedPrinting &&

740

(IsFuncOrFunctionInNonMSVCCompatEnv || IsLFunctionInMSVCCommpatEnv)) ||

741

(!ForceElaboratedPrinting && IsFuncOrFunctionOrLFunctionOrFuncDName))

742 return

FD->getNameAsString();

745

llvm::raw_svector_ostream Out(Name);

747 if

(

const CXXMethodDecl

*MD = dyn_cast<CXXMethodDecl>(FD)) {

756

PrettyCallbacks(

const LangOptions

&LO) : LO(LO) {}

757

std::string remapPath(StringRef

)

const override

{

760 return

std::string(p);

772

llvm::raw_string_ostream POut(Proto);

781 const Type

*Ty =

->getType().getTypePtrOrNull();

787 if

(FD->hasWrittenPrototype())

788

FT = dyn_cast<FunctionProtoType>(AFT);

793 case CC_C

: POut <<

"__cdecl "

;

break

;

804

FD->printQualifiedName(POut, Policy);

808 return

std::string(Name);

813 for

(

unsigned

i = 0, e =

->getNumParams(); i != e; ++i) {

814 if

(i) POut <<

", "

;

815

POut <<

->getParamDecl(i)->getType().stream(Policy);

818 if

(FT->isVariadic()) {

819 if

(FD->getNumParams()) POut <<

", "

;

824

->getNumParams()) {

830 if

(

const CXXMethodDecl

*MD = dyn_cast<CXXMethodDecl>(FD)) {

831

assert(FT &&

"We must have a written prototype in this case."

);

834 if

(FT->isVolatile())

835

POut <<

" volatile"

;

846 while

(isa_and_nonnull<NamedDecl>(Ctx)) {

848

= dyn_cast<ClassTemplateSpecializationDecl>(Ctx);

850

Specs.push_back(Spec);

851

Ctx = Ctx->getParent();

854

std::string TemplateParams;

855

llvm::raw_string_ostream TOut(TemplateParams);

858 D

->getSpecializedTemplate()->getTemplateParameters();

860

assert(Params->

() == Args.

());

861 for

(

unsigned

i = 0, numParams = Params->

(); i != numParams; ++i) {

863 if

(Param.empty())

continue

;

864

TOut << Param <<

" = "

;

873

= FD->getTemplateSpecializationInfo();

878

assert(Params->

() == Args->

());

879 for

(

unsigned

i = 0, e = Params->

(); i != e; ++i) {

881 if

(Param.empty())

continue

;

882

TOut << Param <<

" = "

;

883

Args->

get

(i).

(Policy, TOut,

true

);

888 if

(!TemplateParams.empty()) {

890

TemplateParams.resize(TemplateParams.size() - 2);

891

POut <<

" ["

<< TemplateParams <<

"]"

;

899

Proto =

"auto "

+ Proto;

900 else if

(FT && FT->getReturnType()->getAs<

DecltypeType

>())

905 else if

(!isa<CXXConstructorDecl>(FD) && !isa<CXXDestructorDecl>(FD))

910 return

std::string(Name);

912 if

(

const CapturedDecl

*CD = dyn_cast<CapturedDecl>(CurrentDecl)) {

916 if

(DC->isFunctionOrMethod() && (DC->getDeclKind() != Decl::Captured)) {

920

llvm_unreachable(

"CapturedDecl not inside a function or method"

);

922 if

(

const ObjCMethodDecl

*MD = dyn_cast<ObjCMethodDecl>(CurrentDecl)) {

924

llvm::raw_svector_ostream Out(Name);

925

Out << (MD->isInstanceMethod() ?

'-'

'+'

);

934

dyn_cast<ObjCCategoryImplDecl>(MD->getDeclContext()))

935

Out <<

'('

<< *CID <<

')'

;

938

MD->getSelector().print(Out);

941 return

std::string(Name);

943 if

(isa<TranslationUnitDecl>(CurrentDecl) &&

952 const

llvm::APInt &Val) {

954 C

.Deallocate(

pVal

);

956

BitWidth = Val.getBitWidth();

957 unsigned

NumWords = Val.getNumWords();

958 const

uint64_t* Words = Val.getRawData();

960 pVal

new

(

) uint64_t[NumWords];

961

std::copy(Words, Words + NumWords,

pVal

);

962

}

else if

(NumWords == 1)

968

IntegerLiteral::IntegerLiteral(

const ASTContext

const

llvm::APInt &

971

assert(

->isIntegerType() &&

"Illegal type in IntegerLiteral"

);

972

assert(

.getBitWidth() ==

.getIntWidth(

) &&

973 "Integer type is not the correct size for constant."

);

989

FixedPointLiteral::FixedPointLiteral(

const ASTContext

const

llvm::APInt &

994

assert(

->isFixedPointType() &&

"Illegal type in FixedPointLiteral"

);

995

assert(

.getBitWidth() ==

.getTypeInfo(

).Width &&

996 "Fixed point type is not the correct size for constant."

);

1002 const

llvm::APInt &

1020

S, llvm::APSInt::getUnsigned(

getValue

().getZExtValue()), Scale);

1021 return

std::string(S);

1043

StringRef Escaped = escapeCStyle<EscapeChar::Single>(Val);

1044 if

(!Escaped.empty()) {

1045

OS <<

"'"

<< Escaped <<

"'"

;

1053 if

(Val < 256 &&

isPrintable

((

unsigned char

)Val))

1054

OS <<

"'"

<< (char)Val <<

"'"

;

1056

OS <<

"'\\x"

<< llvm::format(

"%02x"

, Val) <<

"'"

;

1057 else if

(Val <= 0xFFFF)

1058

OS <<

"'\\u"

<< llvm::format(

"%04x"

, Val) <<

"'"

;

1060

OS <<

"'\\U"

<< llvm::format(

"%08x"

, Val) <<

"'"

;

1064

FloatingLiteral::FloatingLiteral(

const ASTContext

const

llvm::APFloat &

1067

setSemantics(

.getSemantics());

1073

FloatingLiteral::FloatingLiteral(

const ASTContext

, EmptyShell

)

1075

setRawSemantics(llvm::APFloatBase::S_IEEEhalf);

1096 V

.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,

1098 return V

.convertToDouble();

1103 unsigned

CharByteWidth = 0;

1107

CharByteWidth =

.getCharWidth();

1110

CharByteWidth =

.getWCharWidth();

1113

CharByteWidth =

.getChar16Width();

1116

CharByteWidth =

.getChar32Width();

1119 return sizeof

(char);

1121

assert((CharByteWidth & 7) == 0 &&

"Assumes character size is byte multiple"

);

1123

assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth == 4) &&

1124 "The only supported character byte widths are 1,2 and 4!"

);

1125 return

CharByteWidth;

1128

StringLiteral::StringLiteral(

const ASTContext

&Ctx, StringRef Str,

1131 unsigned

NumConcatenated)

1134 unsigned

Length = Str.size();

1141 "StringLiteral must be of constant array type!"

);

1142 unsigned

CharByteWidth = mapCharByteWidth(Ctx.

getTargetInfo

(), Kind);

1143 unsigned

ByteLength = Str.size();

1144

assert((ByteLength % CharByteWidth == 0) &&

1145 "The size of the data must be a multiple of CharByteWidth!"

);

1150 switch

(CharByteWidth) {

1152

Length = ByteLength;

1155

Length = ByteLength / 2;

1158

Length = ByteLength / 4;

1161

llvm_unreachable(

"Unsupported character width!"

);

1167

assert(!Pascal &&

"Can't make an unevaluated Pascal string"

);

1172

*getTrailingObjects<unsigned>() = Length;

1176

std::memcpy(getTrailingObjects<SourceLocation>(), Loc,

1180

std::memcpy(getTrailingObjects<char>(), Str.data(), Str.size());

1185

StringLiteral::StringLiteral(EmptyShell

unsigned

NumConcatenated,

1186 unsigned

Length,

unsigned

CharByteWidth)

1190

*getTrailingObjects<unsigned>() = Length;

1196 unsigned

NumConcatenated) {

1197 void

*Mem = Ctx.

(totalSizeToAlloc<unsigned, SourceLocation, char>(

1198

1, NumConcatenated, Str.size()),

1205 unsigned

NumConcatenated,

1207 unsigned

CharByteWidth) {

1208 void

*Mem = Ctx.

(totalSizeToAlloc<unsigned, SourceLocation, char>(

1209

1, NumConcatenated, Length * CharByteWidth),

1234 static const char

Hex[] =

"0123456789ABCDEF"

;

1237 for

(

unsigned

I = 0, N =

getLength

(); I != N; ++I) {

1239

StringRef Escaped = escapeCStyle<EscapeChar::Double>(Char);

1240 if

(Escaped.empty()) {

1246

Char >= 0xd800 && Char <= 0xdbff) {

1248 if

(Trail >= 0xdc00 && Trail <= 0xdfff) {

1249

Char = 0x10000 + ((Char - 0xd800) << 10) + (Trail - 0xdc00);

1259

(Char >= 0xd800 && Char <= 0xdfff) || Char >= 0x110000) {

1263 while

((Char >> Shift) == 0)

1265 for

(

; Shift >= 0; Shift -= 4)

1266

OS << Hex[(Char >> Shift) & 15];

1273

<< Hex[(Char >> 20) & 15]

1274

<< Hex[(Char >> 16) & 15];

1277

OS << Hex[(Char >> 12) & 15]

1278

<< Hex[(Char >> 8) & 15]

1279

<< Hex[(Char >> 4) & 15]

1280

<< Hex[(Char >> 0) & 15];

1286 if

(LastSlashX + 1 == I) {

1288 case '0'

case '1'

case '2'

case '3'

case '4'

1289 case '5'

case '6'

case '7'

case '8'

case '9'

1290 case 'a'

case 'b'

case 'c'

case 'd'

case 'e'

case 'f'

1291 case 'A'

case 'B'

case 'C'

case 'D'

case 'E'

case 'F'

1296

assert(Char <= 0xff &&

1297 "Characters above 0xff should already have been handled."

);

1303

<< (char)(

'0'

+ ((Char >> 6) & 7))

1304

<< (char)(

'0'

+ ((Char >> 3) & 7))

1305

<< (char)(

'0'

+ ((Char >> 0) & 7));

1334 unsigned

*StartTokenByteOffset)

const

{

1338 "Only narrow string literals are currently supported"

);

1343 unsigned

StringOffset = 0;

1345

TokNo = *StartToken;

1346 if

(StartTokenByteOffset) {

1347

StringOffset = *StartTokenByteOffset;

1348

ByteNo -= StringOffset;

1360

std::pair<FileID, unsigned> LocInfo =

1361 SM

.getDecomposedLoc(StrTokSpellingLoc);

1363

StringRef Buffer =

.getBufferData(LocInfo.first, &

Invalid

);

1365 if

(StartTokenByteOffset !=

nullptr

)

1366

*StartTokenByteOffset = StringOffset;

1367 if

(StartToken !=

nullptr

)

1368

*StartToken = TokNo;

1369 return

StrTokSpellingLoc;

1372 const char

*StrData = Buffer.data()+LocInfo.second;

1375 Lexer

TheLexer(

.getLocForStartOfFile(LocInfo.first), Features,

1376

Buffer.begin(), StrData, Buffer.end());

1385 if

(ByteNo < TokNumBytes ||

1391 if

(StartTokenByteOffset !=

nullptr

)

1392

*StartTokenByteOffset = StringOffset;

1393 if

(StartToken !=

nullptr

)

1394

*StartToken = TokNo;

1399

StringOffset += TokNumBytes;

1401

ByteNo -= TokNumBytes;

1409#define UNARY_OPERATION(Name, Spelling) case UO_##Name: return Spelling; 1410#include "clang/AST/OperationKinds.def" 1412

llvm_unreachable(

"Unknown unary operator"

);

1418 default

: llvm_unreachable(

"No unary operator for overloaded function"

);

1419 case

OO_PlusPlus:

return

Postfix ? UO_PostInc : UO_PreInc;

1420 case

OO_MinusMinus:

return

Postfix ? UO_PostDec : UO_PreDec;

1421 case

OO_Amp:

return

UO_AddrOf;

1422 case

OO_Star:

return

UO_Deref;

1423 case

OO_Plus:

return

UO_Plus;

1424 case

OO_Minus:

return

UO_Minus;

1425 case

OO_Tilde:

return

UO_Not;

1426 case

OO_Exclaim:

return

UO_LNot;

1427 case

OO_Coawait:

return

UO_Coawait;

1433 case

UO_PostInc:

case

UO_PreInc:

return

OO_PlusPlus;

1434 case

UO_PostDec:

case

UO_PreDec:

return

OO_MinusMinus;

1435 case

UO_AddrOf:

return

OO_Amp;

1436 case

UO_Deref:

return

OO_Star;

1437 case

UO_Plus:

return

OO_Plus;

1438 case

UO_Minus:

return

OO_Minus;

1439 case

UO_Not:

return

OO_Tilde;

1440 case

UO_LNot:

return

OO_Exclaim;

1441 case

UO_Coawait:

return

OO_Coawait;

1456

NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

1457 unsigned

NumPreArgs = PreArgs.size();

1459

assert((NumPreArgs ==

getNumPreArgs

()) &&

"NumPreArgs overflow!"

);

1461 unsigned

OffsetToTrailingObjects = offsetToTrailingObjects(SC);

1462 CallExprBits

.OffsetToTrailingObjects = OffsetToTrailingObjects;

1463

assert((

CallExprBits

.OffsetToTrailingObjects == OffsetToTrailingObjects) &&

1464 "OffsetToTrailingObjects overflow!"

);

1469 for

(

unsigned

I = 0; I != NumPreArgs; ++I)

1471 for

(

unsigned

I = 0; I != Args.size(); ++I)

1473 for

(

unsigned

I = Args.size(); I != NumArgs; ++I)

1488

assert((NumPreArgs ==

getNumPreArgs

()) &&

"NumPreArgs overflow!"

);

1490 unsigned

OffsetToTrailingObjects = offsetToTrailingObjects(SC);

1491 CallExprBits

.OffsetToTrailingObjects = OffsetToTrailingObjects;

1492

assert((

CallExprBits

.OffsetToTrailingObjects == OffsetToTrailingObjects) &&

1493 "OffsetToTrailingObjects overflow!"

);

1503 unsigned

NumArgs = std::max<unsigned>(Args.size(), MinNumArgs);

1508 return new

(Mem)

CallExpr

(CallExprClass, Fn,

{}, Args, Ty, VK,

1509

RParenLoc, FPFeatures, MinNumArgs,

UsesADL

);

1516 "Misaligned memory in CallExpr::CreateTemporary!"

);

1517 return new

(Mem)

CallExpr

(CallExprClass, Fn,

{},

{}, Ty,

1524 unsigned

SizeOfTrailingObjects =

1529 CallExpr

(CallExprClass,

0, NumArgs, HasFPFeatures,

);

1532unsigned

CallExpr::offsetToTrailingObjects(StmtClass SC) {

1536 case

CXXOperatorCallExprClass:

1538 case

CXXMemberCallExprClass:

1540 case

UserDefinedLiteralClass:

1542 case

CUDAKernelCallExprClass:

1545

llvm_unreachable(

"unexpected class deriving from CallExpr!"

);

1552 while

(

auto

*NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(CEE))

1557 if

(

auto

*BO = dyn_cast<BinaryOperator>(CEE)) {

1558 if

(BO->isPtrMemOp()) {

1562

}

else if

(

auto

*UO = dyn_cast<UnaryOperator>(CEE)) {

1563 if

(UO->getOpcode() == UO_Deref || UO->getOpcode() == UO_AddrOf ||

1564

UO->getOpcode() == UO_Plus) {

1572 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(CEE))

1573 return

DRE->getDecl();

1574 if

(

auto

*ME = dyn_cast<MemberExpr>(CEE))

1575 return

ME->getMemberDecl();

1576 if

(

auto

*BE = dyn_cast<BlockExpr>(CEE))

1577 return

BE->getBlockDecl();

1585 return

FDecl ? FDecl->getBuiltinID() : 0;

1596 QualType

CalleeType = Callee->getType();

1602 if

(isa<CXXPseudoDestructorExpr>(Callee->IgnoreParens()))

1605 if

(isa<UnresolvedMemberExpr>(Callee->IgnoreParens()))

1610

assert(!CalleeType.

isNull

());

1624

std::pair<const NamedDecl *, const Attr *>

1628 if

(

const auto

*A =

getAttr

<WarnUnusedResultAttr>())

1629 return

{

nullptr

, A};

1634 if

(

const auto

*A = TD->getAttr<WarnUnusedResultAttr>())

1638

TD = TD->desugar()->getAs<TypedefType>())

1639 if

(

const auto

*A = TD->getDecl()->getAttr<WarnUnusedResultAttr>())

1640 return

{TD->getDecl(), A};

1641 return

{

nullptr

};

1645 if

(

const auto

*OCE = dyn_cast<CXXOperatorCallExpr>(

this

))

1646 return

OCE->getBeginLoc();

1648 if

(

const auto

*Method =

1649

dyn_cast_if_present<const CXXMethodDecl>(

getCalleeDecl

());

1650

Method && Method->isExplicitObjectMemberFunction()) {

1662 if

(

const auto

*OCE = dyn_cast<CXXOperatorCallExpr>(

this

))

1663 return

OCE->getEndLoc();

1677 void

*Mem =

.Allocate(

1678

totalSizeToAlloc<OffsetOfNode, Expr *>(comps.size(), exprs.size()));

1685 unsigned

numComps,

unsigned

numExprs) {

1687 C

.Allocate(totalSizeToAlloc<OffsetOfNode, Expr *>(numComps, numExprs));

1696

OperatorLoc(OperatorLoc), RParenLoc(RParenLoc), TSInfo(tsi),

1697

NumComps(comps.size()), NumExprs(exprs.size()) {

1698 for

(

unsigned

i = 0; i != comps.size(); ++i)

1700 for

(

unsigned

i = 0; i != exprs.size(); ++i)

1718

OpLoc(op), RParenLoc(rp) {

1719

assert(ExprKind <=

UETT_Last

"invalid enum value!"

);

1722 "UnaryExprOrTypeTraitExprBits.Kind overflow!"

);

1736

(MemberExprClass,

, VK, OK),

(

), MemberDecl(MemberDecl),

1737

MemberDNLoc(NameInfo.

getInfo

()), MemberLoc(NameInfo.getLoc()) {

1738

assert(!NameInfo.

getName

() ||

1743

FoundDecl.getDecl() != MemberDecl ||

1746

TemplateArgs || TemplateKWLoc.

();

1752 new

(getTrailingObjects<NestedNameSpecifierLoc>())

1755

*getTrailingObjects<DeclAccessPair>() = FoundDecl;

1757 auto

Deps = TemplateArgumentDependence::None;

1758

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

1759

TemplateKWLoc, *TemplateArgs, getTrailingObjects<TemplateArgumentLoc>(),

1761

}

else if

(TemplateKWLoc.

()) {

1762

getTrailingObjects<ASTTemplateKWAndArgsInfo>()->initializeFrom(

1775 bool

HasFoundDecl = FoundDecl.getDecl() != MemberDecl ||

1777 bool

HasTemplateKWAndArgsInfo = TemplateArgs || TemplateKWLoc.

();

1781

HasQualifier, HasFoundDecl, HasTemplateKWAndArgsInfo,

1782

TemplateArgs ? TemplateArgs->

() : 0);

1784 void

*Mem =

.Allocate(Size,

alignof

(

MemberExpr

));

1785 return new

(Mem)

MemberExpr

(

, IsArrow, OperatorLoc, QualifierLoc,

1786

TemplateKWLoc, MemberDecl, FoundDecl, NameInfo,

1787

TemplateArgs,

, VK, OK, NOUR);

1791 bool

HasQualifier,

bool

HasFoundDecl,

1792 bool

HasTemplateKWAndArgsInfo,

1793 unsigned

NumTemplateArgs) {

1794

assert((!NumTemplateArgs || HasTemplateKWAndArgsInfo) &&

1795 "template args but no template arg info?"

);

1799

HasQualifier, HasFoundDecl, HasTemplateKWAndArgsInfo,

1807 if

(

()->isUndeducedType())

1823 return

BaseStartLoc;

1835bool

CastExpr::CastConsistency()

const

{

1837 case

CK_DerivedToBase:

1838 case

CK_UncheckedDerivedToBase:

1839 case

CK_DerivedToBaseMemberPointer:

1840 case

CK_BaseToDerived:

1841 case

CK_BaseToDerivedMemberPointer:

1842

assert(!

path_empty

() &&

"Cast kind should have a base path!"

);

1845 case

CK_CPointerToObjCPointerCast:

1846

assert(

()->isObjCObjectPointerType());

1848 goto

CheckNoBasePath;

1850 case

CK_BlockPointerToObjCPointerCast:

1851

assert(

()->isObjCObjectPointerType());

1853 goto

CheckNoBasePath;

1855 case

CK_ReinterpretMemberPointer:

1856

assert(

()->isMemberPointerType());

1858 goto

CheckNoBasePath;

1864 if

()->isPointerType()) {

1865

assert(

()->isObjCObjectPointerType() ==

1867

assert(

()->isBlockPointerType() ==

1870 goto

CheckNoBasePath;

1872 case

CK_AnyPointerToBlockPointerCast:

1873

assert(

()->isBlockPointerType());

1876 goto

CheckNoBasePath;

1878 case

CK_CopyAndAutoreleaseBlockObject:

1879

assert(

()->isBlockPointerType());

1881 goto

CheckNoBasePath;

1883 case

CK_FunctionToPointerDecay:

1884

assert(

()->isPointerType());

1886 goto

CheckNoBasePath;

1888 case

CK_AddressSpaceConversion: {

1897

(!Ty.

isNull

() && !SETy.isNull() &&

1899 goto

CheckNoBasePath;

1904 case

CK_ArrayToPointerDecay:

1905 case

CK_NullToMemberPointer:

1906 case

CK_NullToPointer:

1907 case

CK_ConstructorConversion:

1908 case

CK_IntegralToPointer:

1909 case

CK_PointerToIntegral:

1911 case

CK_VectorSplat:

1912 case

CK_IntegralCast:

1913 case

CK_BooleanToSignedIntegral:

1914 case

CK_IntegralToFloating:

1915 case

CK_FloatingToIntegral:

1916 case

CK_FloatingCast:

1917 case

CK_ObjCObjectLValueCast:

1918 case

CK_FloatingRealToComplex:

1919 case

CK_FloatingComplexToReal:

1920 case

CK_FloatingComplexCast:

1921 case

CK_FloatingComplexToIntegralComplex:

1922 case

CK_IntegralRealToComplex:

1923 case

CK_IntegralComplexToReal:

1924 case

CK_IntegralComplexCast:

1925 case

CK_IntegralComplexToFloatingComplex:

1926 case

CK_ARCProduceObject:

1927 case

CK_ARCConsumeObject:

1928 case

CK_ARCReclaimReturnedObject:

1929 case

CK_ARCExtendBlockObject:

1930 case

CK_ZeroToOCLOpaqueType:

1931 case

CK_IntToOCLSampler:

1932 case

CK_FloatingToFixedPoint:

1933 case

CK_FixedPointToFloating:

1934 case

CK_FixedPointCast:

1935 case

CK_FixedPointToIntegral:

1936 case

CK_IntegralToFixedPoint:

1939 goto

CheckNoBasePath;

1942 case

CK_LValueToRValue:

1944 case

CK_AtomicToNonAtomic:

1945 case

CK_NonAtomicToAtomic:

1946 case

CK_PointerToBoolean:

1947 case

CK_IntegralToBoolean:

1948 case

CK_FloatingToBoolean:

1949 case

CK_MemberPointerToBoolean:

1950 case

CK_FloatingComplexToBoolean:

1951 case

CK_IntegralComplexToBoolean:

1952 case

CK_LValueBitCast:

1953 case

CK_LValueToRValueBitCast:

1954 case

CK_UserDefinedConversion:

1955 case

CK_BuiltinFnToFnPtr:

1956 case

CK_FixedPointToBoolean:

1957 case

CK_HLSLArrayRValue:

1958 case

CK_HLSLVectorTruncation:

1960

assert(

path_empty

() &&

"Cast kind should not have a base path!"

);

1968#define CAST_OPERATION(Name) case CK_##Name: return #Name; 1969#include "clang/AST/OperationKinds.def" 1971

llvm_unreachable(

"Unhandled cast kind!"

);

1977static Expr

*ignoreImplicitSemaNodes(

) {

1978 if

(

auto

*Materialize = dyn_cast<MaterializeTemporaryExpr>(

))

1979 return

Materialize->getSubExpr();

1981 if

(

auto

*Binder = dyn_cast<CXXBindTemporaryExpr>(

))

1982 return

Binder->getSubExpr();

1984 if

(

auto

*Full = dyn_cast<FullExpr>(

))

1985 return

Full->getSubExpr();

1987 if

(

auto

*CPLIE = dyn_cast<CXXParenListInitExpr>(

);

1988

CPLIE && CPLIE->getInitExprs().size() == 1)

1989 return

CPLIE->getInitExprs()[0];

1996 const Expr

*SubExpr =

nullptr

;

1998 for

(

const CastExpr

this

;

= dyn_cast<ImplicitCastExpr>(SubExpr)) {

2003 if

(

->getCastKind() == CK_ConstructorConversion) {

2004

SubExpr =

IgnoreExprNodes

(cast<CXXConstructExpr>(SubExpr)->getArg(0),

2005

ignoreImplicitSemaNodes);

2006

}

else if

(

->getCastKind() == CK_UserDefinedConversion) {

2007

assert((isa<CallExpr, BlockExpr>(SubExpr)) &&

2008 "Unexpected SubExpr for CK_UserDefinedConversion."

);

2009 if

(

auto

*MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))

2010

SubExpr = MCE->getImplicitObjectArgument();

2014 return const_cast<Expr

>

(SubExpr);

2018 const Expr

*SubExpr =

nullptr

;

2020 for

(

const CastExpr

this

;

= dyn_cast<ImplicitCastExpr>(SubExpr)) {

2023 if

(

->getCastKind() == CK_ConstructorConversion)

2024 return

cast<CXXConstructExpr>(SubExpr)->getConstructor();

2026 if

(

->getCastKind() == CK_UserDefinedConversion) {

2027 if

(

auto

*MCE = dyn_cast<CXXMemberCallExpr>(SubExpr))

2028 return

MCE->getMethodDecl();

2037#define ABSTRACT_STMT(x) 2038#define CASTEXPR(Type, Base) \ 2039 case Stmt::Type##Class: \ 2040 return static_cast<Type *>(this)->getTrailingObjects<CXXBaseSpecifier *>(); 2041#define STMT(Type, Base) 2042#include "clang/AST/StmtNodes.inc" 2044

llvm_unreachable(

"non-cast expressions not possible here"

);

2059

Field != FieldEnd; ++Field) {

2061

!Field->isUnnamedBitField()) {

2071 case

ImplicitCastExprClass:

2073

->getTrailingObjects<FPOptionsOverride>();

2074 case

CStyleCastExprClass:

2076

->getTrailingObjects<FPOptionsOverride>();

2077 case

CXXFunctionalCastExprClass:

2079

->getTrailingObjects<FPOptionsOverride>();

2080 case

CXXStaticCastExprClass:

2082

->getTrailingObjects<FPOptionsOverride>();

2084

llvm_unreachable(

"Cast does not have FPFeatures"

);

2093 unsigned

PathSize = (BasePath ? BasePath->size() : 0);

2095 C

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2099

assert((Kind != CK_LValueToRValue ||

2101 "invalid type for lvalue-to-rvalue conversion"

);

2105

std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

2112 bool

HasFPFeatures) {

2114 C

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2115

PathSize, HasFPFeatures));

2125 unsigned

PathSize = (BasePath ? BasePath->size() : 0);

2127 C

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2130 new

(Buffer)

CStyleCastExpr

(

, VK, K, Op, PathSize, FPO, WrittenTy, L, R);

2132

std::uninitialized_copy_n(BasePath->data(), BasePath->size(),

2139 bool

HasFPFeatures) {

2141 C

.Allocate(totalSizeToAlloc<CXXBaseSpecifier *, FPOptionsOverride>(

2142

PathSize, HasFPFeatures));

2150#define BINARY_OPERATION(Name, Spelling) case BO_##Name: return Spelling; 2151#include "clang/AST/OperationKinds.def" 2153

llvm_unreachable(

"Invalid OpCode!"

);

2159 default

: llvm_unreachable(

"Not an overloadable binary operator"

);

2160 case

OO_Plus:

return

BO_Add;

2161 case

OO_Minus:

return

BO_Sub;

2162 case

OO_Star:

return

BO_Mul;

2163 case

OO_Slash:

return

BO_Div;

2164 case

OO_Percent:

return

BO_Rem;

2165 case

OO_Caret:

return

BO_Xor;

2166 case

OO_Amp:

return

BO_And;

2167 case

OO_Pipe:

return

BO_Or;

2168 case

OO_Equal:

return

BO_Assign;

2169 case

OO_Spaceship:

return

BO_Cmp;

2170 case

OO_Less:

return

BO_LT;

2171 case

OO_Greater:

return

BO_GT;

2172 case

OO_PlusEqual:

return

BO_AddAssign;

2173 case

OO_MinusEqual:

return

BO_SubAssign;

2174 case

OO_StarEqual:

return

BO_MulAssign;

2175 case

OO_SlashEqual:

return

BO_DivAssign;

2176 case

OO_PercentEqual:

return

BO_RemAssign;

2177 case

OO_CaretEqual:

return

BO_XorAssign;

2178 case

OO_AmpEqual:

return

BO_AndAssign;

2179 case

OO_PipeEqual:

return

BO_OrAssign;

2180 case

OO_LessLess:

return

BO_Shl;

2181 case

OO_GreaterGreater:

return

BO_Shr;

2182 case

OO_LessLessEqual:

return

BO_ShlAssign;

2183 case

OO_GreaterGreaterEqual:

return

BO_ShrAssign;

2184 case

OO_EqualEqual:

return

BO_EQ;

2185 case

OO_ExclaimEqual:

return

BO_NE;

2186 case

OO_LessEqual:

return

BO_LE;

2187 case

OO_GreaterEqual:

return

BO_GE;

2188 case

OO_AmpAmp:

return

BO_LAnd;

2189 case

OO_PipePipe:

return

BO_LOr;

2190 case

OO_Comma:

return

BO_Comma;

2191 case

OO_ArrowStar:

return

BO_PtrMemI;

2198

OO_Star, OO_Slash, OO_Percent,

2200

OO_LessLess, OO_GreaterGreater,

2202

OO_Less, OO_Greater, OO_LessEqual, OO_GreaterEqual,

2203

OO_EqualEqual, OO_ExclaimEqual,

2209

OO_Equal, OO_StarEqual,

2210

OO_SlashEqual, OO_PercentEqual,

2211

OO_PlusEqual, OO_MinusEqual,

2212

OO_LessLessEqual, OO_GreaterGreaterEqual,

2213

OO_AmpEqual, OO_CaretEqual,

2217 return

OverOps[Opc];

2259

BuiltinLoc(BLoc), RParenLoc(RParenLoc), ParentContext(ParentContext) {

2263

? ExprDependence::Value

2264

: ExprDependence::None);

2270 return "__builtin_FILE"

;

2272 return "__builtin_FILE_NAME"

;

2274 return "__builtin_FUNCTION"

;

2276 return "__builtin_FUNCSIG"

;

2278 return "__builtin_LINE"

;

2280 return "__builtin_COLUMN"

;

2282 return "__builtin_source_location"

;

2284

llvm_unreachable(

"unexpected IdentKind!"

);

2288 const Expr

*DefaultExpr)

const

{

2292 if

(

const auto

*DIE = dyn_cast_if_present<CXXDefaultInitExpr>(DefaultExpr)) {

2293 Loc

= DIE->getUsedLocation();

2294

Context = DIE->getUsedContext();

2295

}

else if

(

const auto

*DAE =

2296

dyn_cast_if_present<CXXDefaultArgExpr>(DefaultExpr)) {

2297 Loc

= DAE->getUsedLocation();

2298

Context = DAE->getUsedContext();

2309 if

(

const auto

= dyn_cast<CXXMethodDecl>(Context);

2311

Context =

->getParent()->getParent();

2316 auto

MakeStringLiteral = [&](StringRef Tmp) {

2320

LValuePathEntry

[1] = {LValuePathEntry::ArrayIndex(0)};

2331 return

MakeStringLiteral(

FileName

);

2337 return

MakeStringLiteral(

);

2341 const auto

*CurDecl = dyn_cast<Decl>(Context);

2345 return

MakeStringLiteral(

2365

StringRef Name = F->getName();

2366 if

(Name ==

"_M_file_name"

) {

2370 Value

.getStructField(F->getFieldIndex()) = MakeStringLiteral(

);

2371

}

else if

(Name ==

"_M_function_name"

) {

2374 const auto

*CurDecl = dyn_cast<Decl>(Context);

2375 Value

.getStructField(F->getFieldIndex()) = MakeStringLiteral(

2376

CurDecl && !isa<TranslationUnitDecl>(CurDecl)

2380

}

else if

(Name ==

"_M_line"

) {

2382 Value

.getStructField(F->getFieldIndex()) =

(IntVal);

2383

}

else if

(Name ==

"_M_column"

) {

2385 Value

.getStructField(F->getFieldIndex()) =

(IntVal);

2396

llvm_unreachable(

"unhandled case"

);

2401 unsigned

NumOfElements)

2404

NumOfElements(NumOfElements) {

2413

InitExprs(

, initExprs.size()), LBraceLoc(lbraceloc),

2414

RBraceLoc(rbraceloc), AltForm(nullptr,

true

) {

2416

InitExprs.

insert

(

, InitExprs.

end

(), initExprs.begin(), initExprs.end());

2422 if

(NumInits > InitExprs.

())

2423

InitExprs.

reserve

(

, NumInits);

2427

InitExprs.

resize

(

, NumInits,

nullptr

);

2444

ArrayFillerOrUnionFieldInit = filler;

2447 for

(

unsigned

i = 0, e =

getNumInits

(); i != e; ++i)

2448 if

(

inits

[i] ==

nullptr

)

2462 Init

->IgnoreParenImpCasts();

2463 return

isa<StringLiteral>(

) || isa<ObjCEncodeExpr>(

);

2467

assert(

isSemanticForm

() &&

"syntactic form never semantically transparent"

);

2471

assert(

getNumInits

() == 1 &&

"multiple inits in glvalue init list"

);

2490

assert(

isSyntacticForm

() &&

"only test syntactic form as zero initializer"

);

2497 return

Lit && Lit->

getValue

() == 0;

2502 return

SyntacticForm->getBeginLoc();

2507 E

= InitExprs.

end

();

2509 if

(

*S = *I) {

2510

Beg = S->getBeginLoc();

2520 return

SyntacticForm->getEndLoc();

2522 if

(End.isInvalid()) {

2524 for

(

*S : llvm::reverse(InitExprs)) {

2526

End = S->getEndLoc();

2538 return

cast<BlockPointerType>(

())

2569 if

(isa<DeclRefExpr>(

))

2573 if

(isa<ArraySubscriptExpr>(

))

2577 if

(isa<MemberExpr>(

))

2581 if

(

auto

*UO = dyn_cast<UnaryOperator>(

))

2582 if

(UO->getOpcode() == UO_Deref)

2585 if

(

auto

*BO = dyn_cast<BinaryOperator>(

)) {

2587 if

(BO->isPtrMemOp())

2591 if

(BO->getOpcode() == BO_Comma)

2592 return

BO->getRHS()->isReadIfDiscardedInCPlusPlus11();

2597 if

(

auto

*CO = dyn_cast<ConditionalOperator>(

))

2598 return

CO->getTrueExpr()->isReadIfDiscardedInCPlusPlus11() &&

2599

CO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();

2602

dyn_cast<BinaryConditionalOperator>(

)) {

2603 if

(

auto

*OVE = dyn_cast<OpaqueValueExpr>(BCO->getTrueExpr()))

2604 return

OVE->getSourceExpr()->isReadIfDiscardedInCPlusPlus11() &&

2605

BCO->getFalseExpr()->isReadIfDiscardedInCPlusPlus11();

2609 if

(isa<ObjCIvarRefExpr>(

))

2611 if

(

const auto

*POE = dyn_cast<PseudoObjectExpr>(

)) {

2612 if

(isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(POE->getSyntacticForm()))

2633 if

(

()->isVoidType())

2639 case

ParenExprClass:

2640 return

cast<ParenExpr>(

this

)->getSubExpr()->

2642 case

GenericSelectionExprClass:

2643 return

cast<GenericSelectionExpr>(

this

)->getResultExpr()->

2645 case

CoawaitExprClass:

2646 case

CoyieldExprClass:

2647 return

cast<CoroutineSuspendExpr>(

this

)->getResumeExpr()->

2649 case

ChooseExprClass:

2650 return

cast<ChooseExpr>(

this

)->getChosenSubExpr()->

2652 case

UnaryOperatorClass: {

2686 case

BinaryOperatorClass: {

2698 if

(IE->getValue() == 0)

2717 case

CompoundAssignOperatorClass:

2718 case

VAArgExprClass:

2719 case

AtomicExprClass:

2722 case

ConditionalOperatorClass: {

2726 const auto

*Exp = cast<ConditionalOperator>(

this

);

2727 return

Exp->getLHS()->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx) &&

2728

Exp->getRHS()->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx);

2730 case

BinaryConditionalOperatorClass: {

2731 const auto

*Exp = cast<BinaryConditionalOperator>(

this

);

2732 return

Exp->getFalseExpr()->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx);

2735 case

MemberExprClass:

2737 Loc

= cast<MemberExpr>(

this

)->getMemberLoc();

2739

R2 = cast<MemberExpr>(

this

)->getBase()->getSourceRange();

2742 case

ArraySubscriptExprClass:

2744 Loc

= cast<ArraySubscriptExpr>(

this

)->getRBracketLoc();

2745

R1 = cast<ArraySubscriptExpr>(

this

)->getLHS()->getSourceRange();

2746

R2 = cast<ArraySubscriptExpr>(

this

)->getRHS()->getSourceRange();

2749 case

CXXOperatorCallExprClass: {

2761 case

OO_ExclaimEqual:

2764 case

OO_GreaterEqual:

2779 case

CXXMemberCallExprClass:

2780 case

UserDefinedLiteralClass: {

2782 const CallExpr

*CE = cast<CallExpr>(

this

);

2790

FD->hasAttr<PureAttr>() || FD->hasAttr<ConstAttr>()) {

2805 case

UnresolvedLookupExprClass:

2806 case

CXXUnresolvedConstructExprClass:

2807 case

RecoveryExprClass:

2810 case

CXXTemporaryObjectExprClass:

2811 case

CXXConstructExprClass: {

2813 const auto

*WarnURAttr =

Type

->getAttr<WarnUnusedResultAttr>();

2815

(WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {

2823 const auto

*CE = cast<CXXConstructExpr>(

this

);

2825 const auto

*WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();

2826 if

(WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {

2831 if

(

unsigned

NumArgs = CE->getNumArgs())

2833

CE->getArg(NumArgs - 1)->getEndLoc());

2841 case

ObjCMessageExprClass: {

2854 if

(MD->hasAttr<WarnUnusedResultAttr>()) {

2863 case

ObjCPropertyRefExprClass:

2864 case

ObjCSubscriptRefExprClass:

2870 case

PseudoObjectExprClass: {

2871 const auto

*POE = cast<PseudoObjectExpr>(

this

);

2874 if

(isa<ObjCPropertyRefExpr, ObjCSubscriptRefExpr>(

2875

POE->getSyntacticForm())) {

2883 if

(

auto

*BO = dyn_cast<BinaryOperator>(POE->getSyntacticForm()))

2884 if

(BO->isAssignmentOp())

2886 if

(

auto

*UO = dyn_cast<UnaryOperator>(POE->getSyntacticForm()))

2887 if

(UO->isIncrementDecrementOp())

2892 return Result

Result

->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx);

2895 case

StmtExprClass: {

2901 const CompoundStmt

*CS = cast<StmtExpr>(

this

)->getSubStmt();

2906 if

(

const Expr

= dyn_cast<Expr>(

Label

->getSubStmt()))

2910 if

(

()->isVoidType())

2913 Loc

= cast<StmtExpr>(

this

)->getLParenLoc();

2917 case

CXXFunctionalCastExprClass:

2918 case

CStyleCastExprClass: {

2925 const CastExpr

*CE = cast<CastExpr>(

this

);

2932 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(SubE))

2933 if

(

auto

*VD = dyn_cast<VarDecl>(DRE->getDecl()))

2934 if

(!VD->isExternallyVisible())

2950 if

(CE->

getCastKind

() == CK_ConstructorConversion)

2957

dyn_cast<CXXFunctionalCastExpr>(

this

)) {

2958 Loc

= CXXCE->getBeginLoc();

2959

R1 = CXXCE->getSubExpr()->getSourceRange();

2967 case

ImplicitCastExprClass: {

2968 const CastExpr

*ICE = cast<ImplicitCastExpr>(

this

);

2977 case

CXXDefaultArgExprClass:

2978 return

(cast<CXXDefaultArgExpr>(

this

)

2980 case

CXXDefaultInitExprClass:

2981 return

(cast<CXXDefaultInitExpr>(

this

)

2984 case

CXXNewExprClass:

2987 case

CXXDeleteExprClass:

2989 case

MaterializeTemporaryExprClass:

2990 return

cast<MaterializeTemporaryExpr>(

this

)

2992

->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx);

2993 case

CXXBindTemporaryExprClass:

2994 return

cast<CXXBindTemporaryExpr>(

this

)->getSubExpr()

2995

->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx);

2996 case

ExprWithCleanupsClass:

2997 return

cast<ExprWithCleanups>(

this

)->getSubExpr()

2998

->isUnusedResultAWarning(WarnE,

, R1, R2, Ctx);

2999 case

OpaqueValueExprClass:

3000 return

cast<OpaqueValueExpr>(

this

)->getSourceExpr()->isUnusedResultAWarning(

3001

WarnE,

, R1, R2, Ctx);

3012 case

ObjCIvarRefExprClass:

3014 case

Expr::UnaryOperatorClass:

3015 return

cast<UnaryOperator>(

)->getSubExpr()->isOBJCGCCandidate(Ctx);

3016 case

ImplicitCastExprClass:

3017 return

cast<ImplicitCastExpr>(

)->getSubExpr()->isOBJCGCCandidate(Ctx);

3018 case

MaterializeTemporaryExprClass:

3019 return

cast<MaterializeTemporaryExpr>(

)->getSubExpr()->isOBJCGCCandidate(

3021 case

CStyleCastExprClass:

3022 return

cast<CStyleCastExpr>(

)->getSubExpr()->isOBJCGCCandidate(Ctx);

3023 case

DeclRefExprClass: {

3024 const Decl

= cast<DeclRefExpr>(

)->getDecl();

3026 if

(

const VarDecl

*VD = dyn_cast<VarDecl>(

)) {

3027 if

(VD->hasGlobalStorage())

3037 case

MemberExprClass: {

3041 case

ArraySubscriptExprClass:

3042 return

cast<ArraySubscriptExpr>(

)->getBase()->isOBJCGCCandidate(Ctx);

3053

assert(

->hasPlaceholderType(BuiltinType::BoundMember));

3061

assert(isa<CXXMethodDecl>(mem->getMemberDecl()));

3062 return

mem->getMemberDecl()->getType();

3068

assert(

->isFunctionType());

3072

assert(isa<UnresolvedMemberExpr>(

) || isa<CXXPseudoDestructorExpr>(

));

3106 if

(

auto

*MCE = dyn_cast<CXXMemberCallExpr>(

this

)) {

3107 if

(isa_and_nonnull<CXXConversionDecl>(MCE->getMethodDecl()))

3108 return

MCE->getImplicitObjectArgument();

3124 auto

IgnoreNoopCastsSingleStep = [&Ctx](

) {

3125 if

(

auto

*CE = dyn_cast<CastExpr>(

)) {

3128 Expr

*SubExpr = CE->getSubExpr();

3129 bool

IsIdentityCast =

3138 if

(IsIdentityCast || IsSameWidthCast)

3140

}

else if

(

auto

*NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(

))

3141 return

NTTP->getReplacement();

3146

IgnoreNoopCastsSingleStep);

3151 if

(

auto

*Cast = dyn_cast<CXXFunctionalCastExpr>(

)) {

3152 auto

*SE = Cast->getSubExpr();

3157 if

(

auto

= dyn_cast<CXXConstructExpr>(

)) {

3158 auto

NumArgs =

->getNumArgs();

3160

(NumArgs > 1 && isa<CXXDefaultArgExpr>(

->getArg(1)))) {

3161 Expr

*A =

->getArg(0);

3168 auto

IgnoreImplicitMemberCallSingleStep = [](

) {

3169 if

(

auto

= dyn_cast<CXXMemberCallExpr>(

)) {

3170 Expr

*ExprNode =

->getImplicitObjectArgument();

3174 if

(

auto

*PE = dyn_cast<ParenExpr>(ExprNode)) {

3175 if

(PE->getSourceRange() ==

->getSourceRange()) {

3176 return

cast<Expr>(PE);

3188

IgnoreImplicitMemberCallSingleStep);

3192 const Expr

this

;

3194 E

= M->getSubExpr();

3197 E

= ICE->getSubExprAsWritten();

3199 return

isa<CXXDefaultArgExpr>(

);

3206 E

= M->getSubExpr();

3209 if

(ICE->getCastKind() == CK_NoOp)

3210 E

= ICE->getSubExpr();

3216 E

= BE->getSubExpr();

3219 if

(ICE->getCastKind() == CK_NoOp)

3220 E

= ICE->getSubExpr();

3231 if

.hasSameUnqualifiedType(

(),

.getTypeDeclType(TempTy)))

3239 if

(!isa<ObjCPropertyRefExpr>(

))

3247 if

(isa<ImplicitCastExpr>(

)) {

3248 switch

(cast<ImplicitCastExpr>(

)->getCastKind()) {

3249 case

CK_DerivedToBase:

3250 case

CK_UncheckedDerivedToBase:

3258 if

(isa<MemberExpr>(

))

3262 if

(BO->isPtrMemOp())

3266 if

(isa<OpaqueValueExpr>(

))

3273 const Expr

this

;

3278 E

Paren

->getSubExpr();

3283 if

(ICE->getCastKind() == CK_NoOp ||

3284

ICE->getCastKind() == CK_LValueToRValue ||

3285

ICE->getCastKind() == CK_DerivedToBase ||

3286

ICE->getCastKind() == CK_UncheckedDerivedToBase) {

3287 E

= ICE->getSubExpr();

3292 if

(

const UnaryOperator

* UnOp = dyn_cast<UnaryOperator>(

)) {

3293 if

(UnOp->getOpcode() == UO_Extension) {

3294 E

= UnOp->getSubExpr();

3300

= dyn_cast<MaterializeTemporaryExpr>(

)) {

3301 E

= M->getSubExpr();

3308 if

(

const CXXThisExpr

*This = dyn_cast<CXXThisExpr>(

))

3309 return

This->isImplicit();

3317 for

(

unsigned

I = 0; I < Exprs.size(); ++I)

3325 const Expr

**Culprit)

const

{

3327 "Expression evaluator can't be called on a dependent expression."

);

3339 if

(

auto

*EWC = dyn_cast<ExprWithCleanups>(

this

))

3340 return

EWC->getSubExpr()->isConstantInitializer(Ctx,

true

, Culprit);

3341 if

(

auto

*MTE = dyn_cast<MaterializeTemporaryExpr>(

this

))

3342 return

MTE->getSubExpr()->isConstantInitializer(Ctx,

false

, Culprit);

3353 case

Stmt::ExprWithCleanupsClass:

3355

Ctx, IsForRef, Culprit);

3356 case

StringLiteralClass:

3357 case

ObjCEncodeExprClass:

3359 case

CXXTemporaryObjectExprClass:

3360 case

CXXConstructExprClass: {

3369

assert(CE->

getNumArgs

() == 1 &&

"trivial ctor with > 1 argument"

);

3375 case

ConstantExprClass: {

3378 const Expr

*Exp = cast<ConstantExpr>(

this

)->getSubExpr();

3381 case

CompoundLiteralExprClass: {

3385 const Expr

*Exp = cast<CompoundLiteralExpr>(

this

)->getInitializer();

3388 case

DesignatedInitUpdateExprClass: {

3393 case

InitListExprClass: {

3401

assert(ILE->

isSemanticForm

() &&

"InitListExpr must be in semantic form"

);

3404 for

(

unsigned

i = 0; i < numInits; i++) {

3412 unsigned

ElementNo = 0;

3417 if

(

const auto

*CXXRD = dyn_cast<CXXRecordDecl>(RD)) {

3418 for

(

unsigned

i = 0, e = CXXRD->getNumBases(); i < e; i++) {

3419 if

(ElementNo < ILE->getNumInits()) {

3427 for

(

const auto

*Field : RD->

fields

()) {

3433 if

(Field->isUnnamedBitField())

3436 if

(ElementNo < ILE->getNumInits()) {

3438 if

(Field->isBitField()) {

3447 bool

RefType = Field->getType()->isReferenceType();

3458 case

ImplicitValueInitExprClass:

3459 case

NoInitExprClass:

3461 case

ParenExprClass:

3462 return

cast<ParenExpr>(

this

)->getSubExpr()

3463

->isConstantInitializer(Ctx, IsForRef, Culprit);

3464 case

GenericSelectionExprClass:

3465 return

cast<GenericSelectionExpr>(

this

)->getResultExpr()

3466

->isConstantInitializer(Ctx, IsForRef, Culprit);

3467 case

ChooseExprClass:

3468 if

(cast<ChooseExpr>(

this

)->isConditionDependent()) {

3473 return

cast<ChooseExpr>(

this

)->getChosenSubExpr()

3475 case

UnaryOperatorClass: {

3481 case

PackIndexingExprClass: {

3482 return

cast<PackIndexingExpr>(

this

)

3484

->isConstantInitializer(Ctx,

false

, Culprit);

3486 case

CXXFunctionalCastExprClass:

3487 case

CXXStaticCastExprClass:

3488 case

ImplicitCastExprClass:

3489 case

CStyleCastExprClass:

3490 case

ObjCBridgedCastExprClass:

3491 case

CXXDynamicCastExprClass:

3492 case

CXXReinterpretCastExprClass:

3493 case

CXXAddrspaceCastExprClass:

3494 case

CXXConstCastExprClass: {

3495 const CastExpr

*CE = cast<CastExpr>(

this

);

3501

CE->

getCastKind

() == CK_ConstructorConversion ||

3510 case

MaterializeTemporaryExprClass:

3511 return

cast<MaterializeTemporaryExpr>(

this

)

3513

->isConstantInitializer(Ctx,

false

, Culprit);

3515 case

SubstNonTypeTemplateParmExprClass:

3516 return

cast<SubstNonTypeTemplateParmExpr>(

this

)->getReplacement()

3517

->isConstantInitializer(Ctx,

false

, Culprit);

3518 case

CXXDefaultArgExprClass:

3519 return

cast<CXXDefaultArgExpr>(

this

)->getExpr()

3520

->isConstantInitializer(Ctx,

false

, Culprit);

3521 case

CXXDefaultInitExprClass:

3522 return

cast<CXXDefaultInitExpr>(

this

)->getExpr()

3523

->isConstantInitializer(Ctx,

false

, Culprit);

3537 if

(BuiltinID != Builtin::BI__assume &&

3538

BuiltinID != Builtin::BI__builtin_assume)

3555 const bool

IncludePossibleEffects;

3556 bool

HasSideEffects;

3559 explicit

SideEffectFinder(

const ASTContext

&Context,

bool

IncludePossible)

3560

: Inherited(Context),

3561

IncludePossibleEffects(IncludePossible), HasSideEffects(

) { }

3563 bool

hasSideEffects()

const

{

return

HasSideEffects; }

3565 void

VisitDecl(

const Decl

) {

3571 if

(

auto

*VD = dyn_cast<VarDecl>(

)) {

3573 if

(IncludePossibleEffects && VD->isThisDeclarationADefinition() &&

3574

VD->needsDestruction(Context))

3575

HasSideEffects =

true

;

3579 void

VisitDeclStmt(

const DeclStmt

*DS) {

3580 for

(

auto

: DS->

decls

())

3582

Inherited::VisitDeclStmt(DS);

3585 void

VisitExpr(

const Expr

) {

3586 if

(!HasSideEffects &&

3588

HasSideEffects =

true

;

3594 bool

IncludePossibleEffects)

const

{

3598 if

(!IncludePossibleEffects &&

getExprLoc

().isMacroID())

3603 #define ABSTRACT_STMT(Type) 3604 #define STMT(Type, Base) case Type##Class: 3605 #define EXPR(Type, Base) 3606 #include "clang/AST/StmtNodes.inc" 3607

llvm_unreachable(

"unexpected Expr kind"

);

3609 case

DependentScopeDeclRefExprClass:

3610 case

CXXUnresolvedConstructExprClass:

3611 case

CXXDependentScopeMemberExprClass:

3612 case

UnresolvedLookupExprClass:

3613 case

UnresolvedMemberExprClass:

3614 case

PackExpansionExprClass:

3615 case

SubstNonTypeTemplateParmPackExprClass:

3616 case

FunctionParmPackExprClass:

3618 case

RecoveryExprClass:

3619 case

CXXFoldExprClass:

3621 return

IncludePossibleEffects;

3623 case

DeclRefExprClass:

3624 case

ObjCIvarRefExprClass:

3625 case

PredefinedExprClass:

3626 case

IntegerLiteralClass:

3627 case

FixedPointLiteralClass:

3628 case

FloatingLiteralClass:

3629 case

ImaginaryLiteralClass:

3630 case

StringLiteralClass:

3631 case

CharacterLiteralClass:

3632 case

OffsetOfExprClass:

3633 case

ImplicitValueInitExprClass:

3634 case

UnaryExprOrTypeTraitExprClass:

3635 case

AddrLabelExprClass:

3636 case

GNUNullExprClass:

3637 case

ArrayInitIndexExprClass:

3638 case

NoInitExprClass:

3639 case

CXXBoolLiteralExprClass:

3640 case

CXXNullPtrLiteralExprClass:

3641 case

CXXThisExprClass:

3642 case

CXXScalarValueInitExprClass:

3643 case

TypeTraitExprClass:

3644 case

ArrayTypeTraitExprClass:

3645 case

ExpressionTraitExprClass:

3646 case

CXXNoexceptExprClass:

3647 case

SizeOfPackExprClass:

3648 case

ObjCStringLiteralClass:

3649 case

ObjCEncodeExprClass:

3650 case

ObjCBoolLiteralExprClass:

3651 case

ObjCAvailabilityCheckExprClass:

3652 case

CXXUuidofExprClass:

3653 case

OpaqueValueExprClass:

3654 case

SourceLocExprClass:

3655 case

EmbedExprClass:

3656 case

ConceptSpecializationExprClass:

3657 case

RequiresExprClass:

3658 case

SYCLUniqueStableNameExprClass:

3659 case

PackIndexingExprClass:

3660 case

HLSLOutArgExprClass:

3661 case

OpenACCAsteriskSizeExprClass:

3662 case

ResolvedUnexpandedPackExprClass:

3666 case

ConstantExprClass:

3668 return

cast<ConstantExpr>(

this

)->getSubExpr()->HasSideEffects(

3669

Ctx, IncludePossibleEffects);

3672 case

CXXOperatorCallExprClass:

3673 case

CXXMemberCallExprClass:

3674 case

CUDAKernelCallExprClass:

3675 case

UserDefinedLiteralClass: {

3679 const Decl

*FD = cast<CallExpr>(

this

)->getCalleeDecl();

3680 bool

IsPure = FD && (FD->

hasAttr

hasAttr

<PureAttr>());

3681 if

(IsPure || !IncludePossibleEffects)

3686 case

BlockExprClass:

3687 case

CXXBindTemporaryExprClass:

3688 if

(!IncludePossibleEffects)

3692 case

MSPropertyRefExprClass:

3693 case

MSPropertySubscriptExprClass:

3694 case

CompoundAssignOperatorClass:

3695 case

VAArgExprClass:

3696 case

AtomicExprClass:

3697 case

CXXThrowExprClass:

3698 case

CXXNewExprClass:

3699 case

CXXDeleteExprClass:

3700 case

CoawaitExprClass:

3701 case

DependentCoawaitExprClass:

3702 case

CoyieldExprClass:

3706 case

StmtExprClass: {

3708

SideEffectFinder Finder(Ctx, IncludePossibleEffects);

3709

Finder.Visit(cast<StmtExpr>(

this

)->getSubStmt());

3710 return

Finder.hasSideEffects();

3713 case

ExprWithCleanupsClass:

3714 if

(IncludePossibleEffects)

3715 if

(cast<ExprWithCleanups>(

this

)->cleanupsHaveSideEffects())

3719 case

ParenExprClass:

3720 case

ArraySubscriptExprClass:

3721 case

MatrixSubscriptExprClass:

3722 case

ArraySectionExprClass:

3723 case

OMPArrayShapingExprClass:

3724 case

OMPIteratorExprClass:

3725 case

MemberExprClass:

3726 case

ConditionalOperatorClass:

3727 case

BinaryConditionalOperatorClass:

3728 case

CompoundLiteralExprClass:

3729 case

ExtVectorElementExprClass:

3730 case

DesignatedInitExprClass:

3731 case

DesignatedInitUpdateExprClass:

3732 case

ArrayInitLoopExprClass:

3733 case

ParenListExprClass:

3734 case

CXXPseudoDestructorExprClass:

3735 case

CXXRewrittenBinaryOperatorClass:

3736 case

CXXStdInitializerListExprClass:

3737 case

SubstNonTypeTemplateParmExprClass:

3738 case

MaterializeTemporaryExprClass:

3739 case

ShuffleVectorExprClass:

3740 case

ConvertVectorExprClass:

3741 case

AsTypeExprClass:

3742 case

CXXParenListInitExprClass:

3746 case

UnaryOperatorClass:

3747 if

(cast<UnaryOperator>(

this

)->isIncrementDecrementOp())

3751 case

BinaryOperatorClass:

3752 if

(cast<BinaryOperator>(

this

)->isAssignmentOp())

3756 case

InitListExprClass:

3758 if

(

const Expr

= cast<InitListExpr>(

this

)->getArrayFiller())

3763 case

GenericSelectionExprClass:

3764 return

cast<GenericSelectionExpr>(

this

)->getResultExpr()->

3767 case

ChooseExprClass:

3768 return

cast<ChooseExpr>(

this

)->getChosenSubExpr()->HasSideEffects(

3769

Ctx, IncludePossibleEffects);

3771 case

CXXDefaultArgExprClass:

3772 return

cast<CXXDefaultArgExpr>(

this

)->getExpr()->HasSideEffects(

3773

Ctx, IncludePossibleEffects);

3775 case

CXXDefaultInitExprClass: {

3776 const FieldDecl

*FD = cast<CXXDefaultInitExpr>(

this

)->getField();

3783 case

CXXDynamicCastExprClass: {

3791 case

ImplicitCastExprClass:

3792 case

CStyleCastExprClass:

3793 case

CXXStaticCastExprClass:

3794 case

CXXReinterpretCastExprClass:

3795 case

CXXConstCastExprClass:

3796 case

CXXAddrspaceCastExprClass:

3797 case

CXXFunctionalCastExprClass:

3798 case

BuiltinBitCastExprClass: {

3803 if

(!IncludePossibleEffects)

3806 const CastExpr

*CE = cast<CastExpr>(

this

);

3813 case

CXXTypeidExprClass: {

3814 const auto

*TE = cast<CXXTypeidExpr>(

this

);

3815 if

(!TE->isPotentiallyEvaluated())

3820 if

(IncludePossibleEffects && TE->hasNullCheck())

3826 case

CXXConstructExprClass:

3827 case

CXXTemporaryObjectExprClass: {

3836 case

CXXInheritedCtorInitExprClass: {

3837 const auto

*ICIE = cast<CXXInheritedCtorInitExpr>(

this

);

3838 if

(!ICIE->getConstructor()->isTrivial() && IncludePossibleEffects)

3843 case

LambdaExprClass: {

3844 const LambdaExpr

*LE = cast<LambdaExpr>(

this

);

3845 for

(

: LE->capture_inits())

3851 case

PseudoObjectExprClass: {

3858 const Expr

*Subexpr = *I;

3860

Subexpr = OVE->getSourceExpr();

3867 case

ObjCBoxedExprClass:

3868 case

ObjCArrayLiteralClass:

3869 case

ObjCDictionaryLiteralClass:

3870 case

ObjCSelectorExprClass:

3871 case

ObjCProtocolExprClass:

3872 case

ObjCIsaExprClass:

3873 case

ObjCIndirectCopyRestoreExprClass:

3874 case

ObjCSubscriptRefExprClass:

3875 case

ObjCBridgedCastExprClass:

3876 case

ObjCMessageExprClass:

3877 case

ObjCPropertyRefExprClass:

3879 if

(IncludePossibleEffects)

3887

cast<Expr>(SubStmt)->

HasSideEffects

(Ctx, IncludePossibleEffects))

3894 if

(

auto Call

= dyn_cast<CallExpr>(

this

))

3895 return Call

->getFPFeaturesInEffect(LO);

3896 if

(

auto

UO = dyn_cast<UnaryOperator>(

this

))

3897 return

UO->getFPFeaturesInEffect(LO);

3898 if

(

auto

BO = dyn_cast<BinaryOperator>(

this

))

3899 return

BO->getFPFeaturesInEffect(LO);

3900 if

(

auto

Cast = dyn_cast<CastExpr>(

this

))

3901 return

Cast->getFPFeaturesInEffect(LO);

3914 explicit

NonTrivialCallFinder(

const ASTContext

&Context)

3915

: Inherited(Context), NonTrivial(

) { }

3917 bool

hasNonTrivialCall()

const

{

return

NonTrivial; }

3919 void

VisitCallExpr(

const CallExpr

) {

3921

= dyn_cast_or_null<const CXXMethodDecl>(

->getCalleeDecl())) {

3922 if

(Method->isTrivial()) {

3924

Inherited::VisitStmt(

);

3933 if

(

->getConstructor()->isTrivial()) {

3935

Inherited::VisitStmt(

);

3946 E

->getTemporary()->getDestructor()) {

3947 if

(DtorDecl->isTrivial()) {

3948

Inherited::VisitStmt(

);

3959

NonTrivialCallFinder Finder(Ctx);

3960

Finder.Visit(

this

);

3961 return

Finder.hasNonTrivialCall();

3979

llvm_unreachable(

"Unexpected value dependent expression!"

);

4007

CE->getSubExpr()->getType()->isIntegerType())

4008 return

CE->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4011

}

else if

(

const ImplicitCastExpr

*ICE = dyn_cast<ImplicitCastExpr>(

this

)) {

4013 return

ICE->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4014

}

else if

(

const ParenExpr

*PE = dyn_cast<ParenExpr>(

this

)) {

4017 return

PE->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4019

dyn_cast<GenericSelectionExpr>(

this

)) {

4020 if

(GE->isResultDependent())

4022 return

GE->getResultExpr()->isNullPointerConstant(Ctx, NPC);

4023

}

else if

(

const ChooseExpr

*CE = dyn_cast<ChooseExpr>(

this

)) {

4024 if

(CE->isConditionDependent())

4026 return

CE->getChosenSubExpr()->isNullPointerConstant(Ctx, NPC);

4028

= dyn_cast<CXXDefaultArgExpr>(

this

)) {

4030 return

DefaultArg->getExpr()->isNullPointerConstant(Ctx, NPC);

4032

= dyn_cast<CXXDefaultInitExpr>(

this

)) {

4034 return

DefaultInit->getExpr()->isNullPointerConstant(Ctx, NPC);

4035

}

else if

(isa<GNUNullExpr>(

this

)) {

4039

= dyn_cast<MaterializeTemporaryExpr>(

this

)) {

4040 return

M->getSubExpr()->isNullPointerConstant(Ctx, NPC);

4041

}

else if

(

const OpaqueValueExpr

*OVE = dyn_cast<OpaqueValueExpr>(

this

)) {

4042 if

(

const Expr

*Source = OVE->getSourceExpr())

4043 return

Source->isNullPointerConstant(Ctx, NPC);

4052 if

(

()->isNullPtrType())

4057

UT && UT->getDecl()->hasAttr<TransparentUnionAttr>())

4059 const Expr

*InitExpr = CLE->getInitializer();

4060 if

(

const InitListExpr

*ILE = dyn_cast<InitListExpr>(InitExpr))

4064 if

()->isIntegerType() ||

4087 if

(isa<IntegerLiteral>(

this

))

4095 const Expr

this

;

4098 "expression is not a property reference"

);

4101 if

(BO->getOpcode() == BO_Comma) {

4110 return

cast<ObjCPropertyRefExpr>(

);

4135 if

(ICE->getCastKind() == CK_LValueToRValue ||

4136

(ICE->isGLValue() && ICE->getCastKind() == CK_NoOp))

4142 if

(

MemberExpr

*MemRef = dyn_cast<MemberExpr>(

))

4143 if

(

FieldDecl

*Field = dyn_cast<FieldDecl>(MemRef->getMemberDecl()))

4144 if

(Field->isBitField())

4153 if

(

DeclRefExpr

*DeclRef = dyn_cast<DeclRefExpr>(

)) {

4154 if

(

FieldDecl

*Field = dyn_cast<FieldDecl>(DeclRef->getDecl()))

4155 if

(Field->isBitField())

4158 if

(

BindingDecl

*BD = dyn_cast<BindingDecl>(DeclRef->getDecl()))

4159 if

(

= BD->getBinding())

4164 if

(BinOp->isAssignmentOp() && BinOp->getLHS())

4165 return

BinOp->getLHS()->getSourceBitField();

4167 if

(BinOp->getOpcode() == BO_Comma && BinOp->getRHS())

4168 return

BinOp->getRHS()->getSourceBitField();

4172 if

(UnOp->isPrefix() && UnOp->isIncrementDecrementOp())

4173 return

UnOp->getSubExpr()->getSourceBitField();

4180 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(

))

4181 return

dyn_cast<EnumConstantDecl>(DRE->getDecl());

4190 if

(ICE->isGLValue() && ICE->getCastKind() == CK_NoOp)

4199 if

(isa<ExtVectorElementExpr>(

))

4202 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(

))

4203 if

(

auto

*BD = dyn_cast<BindingDecl>(DRE->getDecl()))

4204 if

(

auto

= BD->getBinding())

4213 if

(

const DeclRefExpr

*DRE = dyn_cast<DeclRefExpr>(

))

4214 if

(

const auto

*VD = dyn_cast<VarDecl>(DRE->getDecl()))

4216

VD->hasAttr<AsmLabelAttr>() && !VD->isLocalVarDecl())

4232 case

CXXThisExprClass:

4234 case

DeclRefExprClass: {

4237 const auto

*DRE1 = cast<DeclRefExpr>(E1);

4238 const auto

*DRE2 = cast<DeclRefExpr>(E2);

4239 return

DRE1->isPRValue() && DRE2->isPRValue() &&

4240

DRE1->getDecl() == DRE2->getDecl();

4242 case

ImplicitCastExprClass: {

4245 const auto

*ICE1 = dyn_cast<ImplicitCastExpr>(E1);

4246 const auto

*ICE2 = dyn_cast<ImplicitCastExpr>(E2);

4249 if

(ICE1->getCastKind() != ICE2->getCastKind())

4254 if

(ICE1->getCastKind() == CK_LValueToRValue ||

4255

ICE1->getCastKind() == CK_ArrayToPointerDecay ||

4256

ICE1->getCastKind() == CK_FunctionToPointerDecay) {

4261 const auto

*DRE1 = dyn_cast<DeclRefExpr>(E1);

4262 const auto

*DRE2 = dyn_cast<DeclRefExpr>(E2);

4266 const auto

*Ivar1 = dyn_cast<ObjCIvarRefExpr>(E1);

4267 const auto

*Ivar2 = dyn_cast<ObjCIvarRefExpr>(E2);

4268 if

(Ivar1 && Ivar2) {

4269 return

Ivar1->isFreeIvar() && Ivar2->isFreeIvar() &&

4273 const auto

*Array1 = dyn_cast<ArraySubscriptExpr>(E1);

4274 const auto

*Array2 = dyn_cast<ArraySubscriptExpr>(E2);

4275 if

(Array1 && Array2) {

4279 auto

Idx1 = Array1->getIdx();

4280 auto

Idx2 = Array2->getIdx();

4281 const auto

Integer1 = dyn_cast<IntegerLiteral>(Idx1);

4282 const auto

Integer2 = dyn_cast<IntegerLiteral>(Idx2);

4283 if

(Integer1 && Integer2) {

4284 if

(!llvm::APInt::isSameValue(Integer1->getValue(),

4285

Integer2->getValue()))

4296 while

(isa<MemberExpr>(E1) && isa<MemberExpr>(E2)) {

4297 const auto

*ME1 = cast<MemberExpr>(E1);

4298 const auto

*ME2 = cast<MemberExpr>(E2);

4301 if

(

const auto

= dyn_cast<VarDecl>(ME1->getMemberDecl()))

4302 if

(

->isStaticDataMember())

4308 if

(isa<CXXThisExpr>(E1) && isa<CXXThisExpr>(E2))

4314 if

(

const auto

*DRE = dyn_cast<DeclRefExpr>(

))

4315 return

DRE->getDecl();

4316 if

(

const auto

*ME = dyn_cast<MemberExpr>(

))

4317 return

ME->getMemberDecl();

4336 return

VT->getNumElements();

4344

StringRef Comp = Accessor->

getName

();

4347 if

(Comp ==

"hi"

|| Comp ==

"lo"

|| Comp ==

"even"

|| Comp ==

"odd"

)

4351 if

(Comp[0] ==

's'

|| Comp[0] ==

'S'

)

4352

Comp = Comp.substr(1);

4354 for

(

unsigned

i = 0, e = Comp.size(); i != e; ++i)

4355 if

(Comp.substr(i + 1).contains(Comp[i]))

4364

StringRef Comp = Accessor->

getName

();

4365 bool

isNumericAccessor =

false

;

4366 if

(Comp[0] ==

's'

|| Comp[0] ==

'S'

) {

4367

Comp = Comp.substr(1);

4368

isNumericAccessor =

true

;

4371 bool

isHi = Comp ==

"hi"

;

4372 bool

isLo = Comp ==

"lo"

;

4373 bool

isEven = Comp ==

"even"

;

4374 bool

isOdd = Comp ==

"odd"

;

4390

Elts.push_back(Index);

4398

BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {

4399

SubExprs =

new

(

)

*[args.size()];

4400 for

(

unsigned

i = 0; i != args.size(); i++)

4401

SubExprs[i] = args[i];

4407 if

(SubExprs)

.Deallocate(SubExprs);

4409

this->NumExprs = Exprs.size();

4410

SubExprs =

new

(

)

*[NumExprs];

4411 memcpy

(SubExprs, Exprs.data(),

sizeof

(

*) * Exprs.size());

4414

GenericSelectionExpr::GenericSelectionExpr(

4418 bool

ContainsUnexpandedParameterPack,

unsigned

ResultIndex)

4419

(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),

4420

AssocExprs[ResultIndex]->getValueKind(),

4421

AssocExprs[ResultIndex]->getObjectKind()),

4422

NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),

4423

IsExprPredicate(

true

), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4424

assert(AssocTypes.size() == AssocExprs.size() &&

4425 "Must have the same number of association expressions" 4426 " and TypeSourceInfo!"

);

4427

assert(ResultIndex < NumAssocs &&

"ResultIndex is out-of-bounds!"

);

4430

getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =

4432

std::copy(AssocExprs.begin(), AssocExprs.end(),

4433

getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4434

std::copy(AssocTypes.begin(), AssocTypes.end(),

4435

getTrailingObjects<TypeSourceInfo *>() +

4436

getIndexOfStartOfAssociatedTypes());

4441

GenericSelectionExpr::GenericSelectionExpr(

4446 unsigned

ResultIndex)

4447

(GenericSelectionExprClass, AssocExprs[ResultIndex]->getType(),

4448

AssocExprs[ResultIndex]->getValueKind(),

4449

AssocExprs[ResultIndex]->getObjectKind()),

4450

NumAssocs(AssocExprs.size()), ResultIndex(ResultIndex),

4451

IsExprPredicate(

), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4452

assert(AssocTypes.size() == AssocExprs.size() &&

4453 "Must have the same number of association expressions" 4454 " and TypeSourceInfo!"

);

4455

assert(ResultIndex < NumAssocs &&

"ResultIndex is out-of-bounds!"

);

4458

getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =

4460

std::copy(AssocExprs.begin(), AssocExprs.end(),

4461

getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4462

std::copy(AssocTypes.begin(), AssocTypes.end(),

4463

getTrailingObjects<TypeSourceInfo *>() +

4464

getIndexOfStartOfAssociatedTypes());

4469

GenericSelectionExpr::GenericSelectionExpr(

4473 bool

ContainsUnexpandedParameterPack)

4474

(GenericSelectionExprClass, Context.DependentTy,

VK_PRValue

4476

NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),

4477

IsExprPredicate(

true

), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4478

assert(AssocTypes.size() == AssocExprs.size() &&

4479 "Must have the same number of association expressions" 4480 " and TypeSourceInfo!"

);

4483

getTrailingObjects<Stmt *>()[getIndexOfControllingExpression()] =

4485

std::copy(AssocExprs.begin(), AssocExprs.end(),

4486

getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4487

std::copy(AssocTypes.begin(), AssocTypes.end(),

4488

getTrailingObjects<TypeSourceInfo *>() +

4489

getIndexOfStartOfAssociatedTypes());

4494

GenericSelectionExpr::GenericSelectionExpr(

4499

(GenericSelectionExprClass, Context.DependentTy,

VK_PRValue

4501

NumAssocs(AssocExprs.size()), ResultIndex(ResultDependentIndex),

4502

IsExprPredicate(

), DefaultLoc(DefaultLoc), RParenLoc(RParenLoc) {

4503

assert(AssocTypes.size() == AssocExprs.size() &&

4504 "Must have the same number of association expressions" 4505 " and TypeSourceInfo!"

);

4508

getTrailingObjects<TypeSourceInfo *>()[getIndexOfControllingType()] =

4510

std::copy(AssocExprs.begin(), AssocExprs.end(),

4511

getTrailingObjects<Stmt *>() + getIndexOfStartOfAssociatedExprs());

4512

std::copy(AssocTypes.begin(), AssocTypes.end(),

4513

getTrailingObjects<TypeSourceInfo *>() +

4514

getIndexOfStartOfAssociatedTypes());

4519

GenericSelectionExpr::GenericSelectionExpr(EmptyShell

unsigned

NumAssocs)

4520

(GenericSelectionExprClass,

), NumAssocs(NumAssocs) {}

4526 bool

ContainsUnexpandedParameterPack,

unsigned

ResultIndex) {

4527 unsigned

NumAssocs = AssocExprs.size();

4529

totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4532

Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,

4533

RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);

4540 bool

ContainsUnexpandedParameterPack) {

4541 unsigned

NumAssocs = AssocExprs.size();

4543

totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4546

Context, GenericLoc, ControllingExpr, AssocTypes, AssocExprs, DefaultLoc,

4547

RParenLoc, ContainsUnexpandedParameterPack);

4555 unsigned

ResultIndex) {

4556 unsigned

NumAssocs = AssocExprs.size();

4558

totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4561

Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,

4562

RParenLoc, ContainsUnexpandedParameterPack, ResultIndex);

4569 SourceLocation

RParenLoc,

bool

ContainsUnexpandedParameterPack) {

4570 unsigned

NumAssocs = AssocExprs.size();

4572

totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4575

Context, GenericLoc, ControllingType, AssocTypes, AssocExprs, DefaultLoc,

4576

RParenLoc, ContainsUnexpandedParameterPack);

4581 unsigned

NumAssocs) {

4583

totalSizeToAlloc<Stmt *, TypeSourceInfo *>(1 + NumAssocs, NumAssocs),

4606

EqualOrColonLoc(EqualOrColonLoc), GNUSyntax(GNUSyntax),

4607

NumDesignators(Designators.

()), NumSubExprs(IndexExprs.

() + 1) {

4608

this->Designators =

new

(

)

Designator

[NumDesignators];

4616 unsigned

IndexIdx = 0;

4617 for

(

unsigned

I = 0; I != NumDesignators; ++I) {

4618

this->Designators[I] = Designators[I];

4621

*Child++ = IndexExprs[IndexIdx++];

4624

*Child++ = IndexExprs[IndexIdx++];

4625

*Child++ = IndexExprs[IndexIdx++];

4629

assert(IndexIdx == IndexExprs.size() &&

"Wrong number of index expressions"

);

4638 bool

UsesColonSyntax,

) {

4639 void

*Mem =

.Allocate(totalSizeToAlloc<Stmt *>(IndexExprs.size() + 1),

4642

ColonOrEqualLoc, UsesColonSyntax,

4647 unsigned

NumIndexExprs) {

4648 void

*Mem =

.Allocate(totalSizeToAlloc<Stmt *>(NumIndexExprs + 1),

4655 unsigned

NumDesigs) {

4657

NumDesignators = NumDesigs;

4658 for

(

unsigned

I = 0; I != NumDesigs; ++I)

4659

Designators[I] = Desigs[I];

4673 if

(

.isFieldDesignator()) {

4676 for

(

unsigned int

i = 0; i < DIE->size(); i++) {

4684 return First

.getLBracketLoc();

4692

assert(

.isArrayDesignator() &&

"Requires array designator"

);

4697

assert(

.isArrayRangeDesignator() &&

"Requires array range designator"

);

4702

assert(

.isArrayRangeDesignator() &&

"Requires array range designator"

);

4711 unsigned

NumNewDesignators =

Last

;

4712 if

(NumNewDesignators == 0) {

4713

std::copy_backward(Designators + Idx + 1,

4714

Designators + NumDesignators,

4716

--NumNewDesignators;

4719 if

(NumNewDesignators == 1) {

4720

Designators[Idx] = *

;

4725

new

(

)

Designator

[NumDesignators - 1 + NumNewDesignators];

4726

std::copy(Designators, Designators + Idx, NewDesignators);

4727

std::copy(

Last

, NewDesignators + Idx);

4728

std::copy(Designators + Idx + 1, Designators + NumDesignators,

4729

NewDesignators + Idx + NumNewDesignators);

4730

Designators = NewDesignators;

4731

NumDesignators = NumDesignators - 1 + NumNewDesignators;

4740

BaseAndUpdaterExprs[0] = baseExpr;

4744

BaseAndUpdaterExprs[1] = ILE;

4761

LParenLoc(LParenLoc), RParenLoc(RParenLoc) {

4764 for

(

unsigned

I = 0, N = Exprs.size(); I != N; ++I)

4765

getTrailingObjects<Stmt *>()[I] = Exprs[I];

4769

ParenListExpr::ParenListExpr(EmptyShell

unsigned

NumExprs)

4778 void

*Mem = Ctx.

(totalSizeToAlloc<Stmt *>(Exprs.size()),

4780 return new

(Mem)

ParenListExpr

(LParenLoc, Exprs, RParenLoc);

4784 unsigned

NumExprs) {

4794static

std::optional<BinaryOperator *>

4797 if

(

->getOpcode() == BO_LT) {

4799

ComparedTo =

->getRHS();

4800

}

else if

(

->getOpcode() == BO_GT) {

4802

ComparedTo =

->getLHS();

4807 const Expr

*AddLHS =

nullptr

, *AddRHS =

nullptr

;

4810 if

(BO && BO->

getOpcode

() == clang::BO_Add) {

4816 if

(!AddLHS || !AddRHS)

4819 const Decl

*LHSDecl, *RHSDecl, *OtherDecl;

4822

RHSDecl = AddRHS->IgnoreParenImpCasts()->getReferencedDeclOfCallee();

4828 if

(!LHSDecl && !RHSDecl)

4831 if

((LHSDecl && LHSDecl == OtherDecl && LHSDecl != RHSDecl) ||

4832

(RHSDecl && RHSDecl == OtherDecl && RHSDecl != LHSDecl))

4844 if

Result

.has_value())

4854 Result

.value()->setExcludedOverflowPattern(

true

);

4861

(BinaryOperatorClass, ResTy, VK, OK) {

4864 "Use CompoundAssignOperator for compound assignments"

);

4867

SubExprs[LHS] = lhs;

4868

SubExprs[RHS] = rhs;

4880

(CompoundAssignOperatorClass, ResTy, VK, OK) {

4884 "Use CompoundAssignOperator for compound assignments"

);

4886

SubExprs[LHS] = lhs;

4887

SubExprs[RHS] = rhs;

4895 bool

HasFPFeatures) {

4912 BinaryOperator

(

, lhs, rhs, opc, ResTy, VK, OK, opLoc, FPFeatures);

4935

CompLHSType, CompResultType);

4939 bool

hasFPFeatures) {

4940 void

*Mem =

.Allocate(totalSizeToAlloc<FPOptionsOverride>(hasFPFeatures),

4949

(UnaryOperatorClass,

, VK, OK), Val(input) {

4965 unsigned

Size = totalSizeToAlloc<FPOptionsOverride>(HasFPFeatures);

4973

e = ewc->getSubExpr();

4975

e = m->getSubExpr();

4976

e = cast<CXXConstructExpr>(e)->getArg(0);

4978

e = ice->getSubExpr();

4979 return

cast<OpaqueValueExpr>(e);

4984 unsigned

numSemanticExprs) {

4986

Context.

(totalSizeToAlloc<Expr *>(1 + numSemanticExprs),

4991

PseudoObjectExpr::PseudoObjectExpr(EmptyShell shell,

unsigned

numSemanticExprs)

4992

(PseudoObjectExprClass, shell) {

4998 unsigned

resultIndex) {

4999

assert(syntax &&

"no syntactic expression!"

);

5000

assert(

.size() &&

"no semantic expressions!"

);

5008

assert(resultIndex <

.size());

5010

VK =

[resultIndex]->getValueKind();

5014 void

*buffer =

.Allocate(totalSizeToAlloc<Expr *>(

.size() + 1),

5022 unsigned

resultIndex)

5027 for

(

unsigned

i = 0, e =

.size() + 1; i != e; ++i) {

5029

getSubExprsBuffer()[i] =

;

5031 if

(isa<OpaqueValueExpr>(

))

5032

assert(cast<OpaqueValueExpr>(

)->getSourceExpr() !=

nullptr

5033 "opaque-value semantic expressions for pseudo-object " 5034 "operations must have sources"

);

5067

NumSubExprs(args.size()), BuiltinLoc(BLoc), RParenLoc(RP), Op(op) {

5068

assert(args.size() ==

getNumSubExprs

(op) &&

"wrong number of subexpressions"

);

5069 for

(

unsigned

i = 0; i != args.size(); i++)

5070

SubExprs[i] = args[i];

5076 case

AO__c11_atomic_init:

5077 case

AO__opencl_atomic_init:

5078 case

AO__c11_atomic_load:

5079 case

AO__atomic_load_n:

5080 case

AO__atomic_test_and_set:

5081 case

AO__atomic_clear:

5084 case

AO__scoped_atomic_load_n:

5085 case

AO__opencl_atomic_load:

5086 case

AO__hip_atomic_load:

5087 case

AO__c11_atomic_store:

5088 case

AO__c11_atomic_exchange:

5089 case

AO__atomic_load:

5090 case

AO__atomic_store:

5091 case

AO__atomic_store_n:

5092 case

AO__atomic_exchange_n:

5093 case

AO__c11_atomic_fetch_add:

5094 case

AO__c11_atomic_fetch_sub:

5095 case

AO__c11_atomic_fetch_and:

5096 case

AO__c11_atomic_fetch_or:

5097 case

AO__c11_atomic_fetch_xor:

5098 case

AO__c11_atomic_fetch_nand:

5099 case

AO__c11_atomic_fetch_max:

5100 case

AO__c11_atomic_fetch_min:

5101 case

AO__atomic_fetch_add:

5102 case

AO__atomic_fetch_sub:

5103 case

AO__atomic_fetch_and:

5104 case

AO__atomic_fetch_or:

5105 case

AO__atomic_fetch_xor:

5106 case

AO__atomic_fetch_nand:

5107 case

AO__atomic_add_fetch:

5108 case

AO__atomic_sub_fetch:

5109 case

AO__atomic_and_fetch:

5110 case

AO__atomic_or_fetch:

5111 case

AO__atomic_xor_fetch:

5112 case

AO__atomic_nand_fetch:

5113 case

AO__atomic_min_fetch:

5114 case

AO__atomic_max_fetch:

5115 case

AO__atomic_fetch_min:

5116 case

AO__atomic_fetch_max:

5119 case

AO__scoped_atomic_load:

5120 case

AO__scoped_atomic_store:

5121 case

AO__scoped_atomic_store_n:

5122 case

AO__scoped_atomic_fetch_add:

5123 case

AO__scoped_atomic_fetch_sub:

5124 case

AO__scoped_atomic_fetch_and:

5125 case

AO__scoped_atomic_fetch_or:

5126 case

AO__scoped_atomic_fetch_xor:

5127 case

AO__scoped_atomic_fetch_nand:

5128 case

AO__scoped_atomic_add_fetch:

5129 case

AO__scoped_atomic_sub_fetch:

5130 case

AO__scoped_atomic_and_fetch:

5131 case

AO__scoped_atomic_or_fetch:

5132 case

AO__scoped_atomic_xor_fetch:

5133 case

AO__scoped_atomic_nand_fetch:

5134 case

AO__scoped_atomic_min_fetch:

5135 case

AO__scoped_atomic_max_fetch:

5136 case

AO__scoped_atomic_fetch_min:

5137 case

AO__scoped_atomic_fetch_max:

5138 case

AO__scoped_atomic_exchange_n:

5139 case

AO__hip_atomic_exchange:

5140 case

AO__hip_atomic_fetch_add:

5141 case

AO__hip_atomic_fetch_sub:

5142 case

AO__hip_atomic_fetch_and:

5143 case

AO__hip_atomic_fetch_or:

5144 case

AO__hip_atomic_fetch_xor:

5145 case

AO__hip_atomic_fetch_min:

5146 case

AO__hip_atomic_fetch_max:

5147 case

AO__opencl_atomic_store:

5148 case

AO__hip_atomic_store:

5149 case

AO__opencl_atomic_exchange:

5150 case

AO__opencl_atomic_fetch_add:

5151 case

AO__opencl_atomic_fetch_sub:

5152 case

AO__opencl_atomic_fetch_and:

5153 case

AO__opencl_atomic_fetch_or:

5154 case

AO__opencl_atomic_fetch_xor:

5155 case

AO__opencl_atomic_fetch_min:

5156 case

AO__opencl_atomic_fetch_max:

5157 case

AO__atomic_exchange:

5160 case

AO__scoped_atomic_exchange:

5161 case

AO__c11_atomic_compare_exchange_strong:

5162 case

AO__c11_atomic_compare_exchange_weak:

5164 case

AO__hip_atomic_compare_exchange_strong:

5165 case

AO__opencl_atomic_compare_exchange_strong:

5166 case

AO__opencl_atomic_compare_exchange_weak:

5167 case

AO__hip_atomic_compare_exchange_weak:

5168 case

AO__atomic_compare_exchange:

5169 case

AO__atomic_compare_exchange_n:

5172 case

AO__scoped_atomic_compare_exchange:

5173 case

AO__scoped_atomic_compare_exchange_n:

5176

llvm_unreachable(

"unknown atomic op"

);

5182 return

AT->getValueType();

5187 unsigned

ArraySectionCount = 0;

5188 while

(

auto

*OASE = dyn_cast<ArraySectionExpr>(

->IgnoreParens())) {

5189 Base

= OASE->getBase();

5190

++ArraySectionCount;

5193

dyn_cast<ArraySubscriptExpr>(

->IgnoreParenImpCasts())) {

5194 Base

= ASE->getBase();

5195

++ArraySectionCount;

5197 Base

->IgnoreParenImpCasts();

5198 auto

OriginalTy =

->getType();

5199 if

(

auto

*DRE = dyn_cast<DeclRefExpr>(

))

5200 if

(

auto

*PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))

5201

OriginalTy = PVD->getOriginalType().getNonReferenceType();

5203 for

(

unsigned

Cnt = 0; Cnt < ArraySectionCount; ++Cnt) {

5204 if

(OriginalTy->isAnyPointerType())

5205

OriginalTy = OriginalTy->getPointeeType();

5206 else if

(OriginalTy->isArrayType())

5207

OriginalTy = OriginalTy->castAsArrayTypeUnsafe()->getElementType();

5216

(RecoveryExprClass,

.getNonReferenceType(),

5217 T

->isDependentType() ?

VK_LValue

: getValueKindForType(

5219

BeginLoc(BeginLoc), EndLoc(EndLoc), NumExprs(SubExprs.size()) {

5220

assert(!

.isNull());

5221

assert(!llvm::is_contained(SubExprs,

nullptr

));

5223

llvm::copy(SubExprs, getTrailingObjects<Expr *>());

5231 void

*Mem = Ctx.

(totalSizeToAlloc<Expr *>(SubExprs.size()),

5233 return new

(Mem)

RecoveryExpr

(Ctx,

, BeginLoc, EndLoc, SubExprs);

5237 void

*Mem = Ctx.

(totalSizeToAlloc<Expr *>(NumSubExprs),

5244

NumDims == Dims.size() &&

5245 "Preallocated number of dimensions is different from the provided one."

);

5246

llvm::copy(Dims, getTrailingObjects<Expr *>());

5251

NumDims == BR.size() &&

5252 "Preallocated number of dimensions is different from the provided one."

);

5253

llvm::copy(BR, getTrailingObjects<SourceRange>());

5256

OMPArrayShapingExpr::OMPArrayShapingExpr(

QualType

ExprTy,

*Op,

5260

RPLoc(R), NumDims(Dims.size()) {

5262

setDimensions(Dims);

5271

assert(Dims.size() == BracketRanges.size() &&

5272 "Different number of dimensions and brackets ranges."

);

5274

totalSizeToAlloc<Expr *, SourceRange>(Dims.size() + 1, Dims.size()),

5277 E

->setBracketsRanges(BracketRanges);

5284

totalSizeToAlloc<Expr *, SourceRange>(NumDims + 1, NumDims),

5289void

OMPIteratorExpr::setIteratorDeclaration(

unsigned

) {

5290

assert(I < NumIterators &&

5291 "Idx is greater or equal the number of iterators definitions."

);

5292

getTrailingObjects<Decl *>()[I] =

;

5296

assert(I < NumIterators &&

5297 "Idx is greater or equal the number of iterators definitions."

);

5299 SourceLocation

>()[I *

static_cast<int>

(RangeLocOffset::Total) +

5300 static_cast<int>

(RangeLocOffset::AssignLoc)] =

;

5303void

OMPIteratorExpr::setIteratorRange(

unsigned

Begin

5307

assert(I < NumIterators &&

5308 "Idx is greater or equal the number of iterators definitions."

);

5309

getTrailingObjects<Expr *>()[I *

static_cast<int>

(RangeExprOffset::Total) +

5310 static_cast<int>

(RangeExprOffset::Begin)] =

5312

getTrailingObjects<Expr *>()[I *

static_cast<int>

(RangeExprOffset::Total) +

5313 static_cast<int>

(RangeExprOffset::End)] = End;

5314

getTrailingObjects<Expr *>()[I *

static_cast<int>

(RangeExprOffset::Total) +

5315 static_cast<int>

(RangeExprOffset::Step)] = Step;

5317 SourceLocation

>()[I *

static_cast<int>

(RangeLocOffset::Total) +

5318 static_cast<int>

(RangeLocOffset::FirstColonLoc)] =

5321 SourceLocation

>()[I *

static_cast<int>

(RangeLocOffset::Total) +

5322 static_cast<int>

(RangeLocOffset::SecondColonLoc)] =

5327 return

getTrailingObjects<Decl *>()[I];

5333

getTrailingObjects<Expr *>()[I *

static_cast<int>

(

5334

RangeExprOffset::Total) +

5335 static_cast<int>

(RangeExprOffset::Begin)];

5337

getTrailingObjects<Expr *>()[I *

static_cast<int>

(

5338

RangeExprOffset::Total) +

5339 static_cast<int>

(RangeExprOffset::End)];

5341

getTrailingObjects<Expr *>()[I *

static_cast<int>

(

5342

RangeExprOffset::Total) +

5343 static_cast<int>

(RangeExprOffset::Step)];

5348 return

getTrailingObjects<

5349 SourceLocation

>()[I *

static_cast<int>

(RangeLocOffset::Total) +

5350 static_cast<int>

(RangeLocOffset::AssignLoc)];

5354 return

getTrailingObjects<

5355 SourceLocation

>()[I *

static_cast<int>

(RangeLocOffset::Total) +

5356 static_cast<int>

(RangeLocOffset::FirstColonLoc)];

5360 return

getTrailingObjects<

5361 SourceLocation

>()[I *

static_cast<int>

(RangeLocOffset::Total) +

5362 static_cast<int>

(RangeLocOffset::SecondColonLoc)];

5366

getTrailingObjects<OMPIteratorHelperData>()[I] =

;

5370 return

getTrailingObjects<OMPIteratorHelperData>()[I];

5374 return

getTrailingObjects<OMPIteratorHelperData>()[I];

5377

OMPIteratorExpr::OMPIteratorExpr(

5382

IteratorKwLoc(IteratorKwLoc), LPLoc(L), RPLoc(R),

5383

NumIterators(

.size()) {

5384 for

(

unsigned

I = 0,

.size(); I <

; ++I) {

5385 const

IteratorDefinition &

[I];

5386

setIteratorDeclaration(I,

.IteratorDecl);

5387

setAssignmentLoc(I,

.AssignmentLoc);

5388

setIteratorRange(I,

.Range.Begin,

.ColonLoc,

.Range.End,

5389 D

.SecondColonLoc,

.Range.Step);

5390

setHelper(I, Helpers[I]);

5401

assert(

.size() == Helpers.size() &&

5402 "Data and helpers must have the same size."

);

5404

totalSizeToAlloc<Decl *, Expr *, SourceLocation, OMPIteratorHelperData>(

5405 Data

.size(),