/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGExprCXX.cpp

Bug Summary

File:	src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGExprCXX.cpp
Warning:	line 1178, column 34 Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGExprCXX.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGExprCXX.cpp

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGExprCXX.cpp

→

1//===--- CGExprCXX.cpp - Emit LLVM Code for C++ expressions ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This contains code dealing with code generation of C++ expressions
10//
11//===----------------------------------------------------------------------===//

13#include "CGCUDARuntime.h"
14#include "CGCXXABI.h"
15#include "CGDebugInfo.h"
16#include "CGObjCRuntime.h"
17#include "CodeGenFunction.h"
18#include "ConstantEmitter.h"
19#include "TargetInfo.h"
20#include "clang/Basic/CodeGenOptions.h"
21#include "clang/CodeGen/CGFunctionInfo.h"
22#include "llvm/IR/Intrinsics.h"

24using namespace clang;
25using namespace CodeGen;

27namespace {
28struct MemberCallInfo {
RequiredArgs ReqArgs;
// Number of prefix arguments for the call. Ignores the `this` pointer.
unsigned PrefixSize;
32};
33}

35static MemberCallInfo
36commonEmitCXXMemberOrOperatorCall(CodeGenFunction &CGF, const CXXMethodDecl *MD,
                                llvm::Value *This, llvm::Value *ImplicitParam,
                                QualType ImplicitParamTy, const CallExpr *CE,
                                CallArgList &Args, CallArgList *RtlArgs) {
assert(CE == nullptr || isa<CXXMemberCallExpr>(CE) ||((void)0)
       isa<CXXOperatorCallExpr>(CE))((void)0);
assert(MD->isInstance() &&((void)0)
       "Trying to emit a member or operator call expr on a static method!")((void)0);

// Push the this ptr.
const CXXRecordDecl *RD =
    CGF.CGM.getCXXABI().getThisArgumentTypeForMethod(MD);
Args.add(RValue::get(This), CGF.getTypes().DeriveThisType(RD, MD));

// If there is an implicit parameter (e.g. VTT), emit it.
if (ImplicitParam) {
  Args.add(RValue::get(ImplicitParam), ImplicitParamTy);
}

const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, Args.size());
unsigned PrefixSize = Args.size() - 1;

// And the rest of the call args.
if (RtlArgs) {
  // Special case: if the caller emitted the arguments right-to-left already
  // (prior to emitting the *this argument), we're done. This happens for
  // assignment operators.
  Args.addFrom(*RtlArgs);
} else if (CE) {
  // Special case: skip first argument of CXXOperatorCall (it is "this").
  unsigned ArgsToSkip = isa<CXXOperatorCallExpr>(CE) ? 1 : 0;
  CGF.EmitCallArgs(Args, FPT, drop_begin(CE->arguments(), ArgsToSkip),
                   CE->getDirectCallee());
} else {
  assert(((void)0)
      FPT->getNumParams() == 0 &&((void)0)
      "No CallExpr specified for function with non-zero number of arguments")((void)0);
}
return {required, PrefixSize};
76}

78RValue CodeGenFunction::EmitCXXMemberOrOperatorCall(
  const CXXMethodDecl *MD, const CGCallee &Callee,
  ReturnValueSlot ReturnValue,
  llvm::Value *This, llvm::Value *ImplicitParam, QualType ImplicitParamTy,
  const CallExpr *CE, CallArgList *RtlArgs) {
const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
CallArgList Args;
MemberCallInfo CallInfo = commonEmitCXXMemberOrOperatorCall(
    *this, MD, This, ImplicitParam, ImplicitParamTy, CE, Args, RtlArgs);
auto &FnInfo = CGM.getTypes().arrangeCXXMethodCall(
    Args, FPT, CallInfo.ReqArgs, CallInfo.PrefixSize);
return EmitCall(FnInfo, Callee, ReturnValue, Args, nullptr,
                CE && CE == MustTailCall,
                CE ? CE->getExprLoc() : SourceLocation());
92}

94RValue CodeGenFunction::EmitCXXDestructorCall(
  GlobalDecl Dtor, const CGCallee &Callee, llvm::Value *This, QualType ThisTy,
  llvm::Value *ImplicitParam, QualType ImplicitParamTy, const CallExpr *CE) {
const CXXMethodDecl *DtorDecl = cast<CXXMethodDecl>(Dtor.getDecl());

assert(!ThisTy.isNull())((void)0);
assert(ThisTy->getAsCXXRecordDecl() == DtorDecl->getParent() &&((void)0)
       "Pointer/Object mixup")((void)0);

LangAS SrcAS = ThisTy.getAddressSpace();
LangAS DstAS = DtorDecl->getMethodQualifiers().getAddressSpace();
if (SrcAS != DstAS) {
  QualType DstTy = DtorDecl->getThisType();
  llvm::Type *NewType = CGM.getTypes().ConvertType(DstTy);
  This = getTargetHooks().performAddrSpaceCast(*this, This, SrcAS, DstAS,
                                               NewType);
}

CallArgList Args;
commonEmitCXXMemberOrOperatorCall(*this, DtorDecl, This, ImplicitParam,
                                  ImplicitParamTy, CE, Args, nullptr);
return EmitCall(CGM.getTypes().arrangeCXXStructorDeclaration(Dtor), Callee,
                ReturnValueSlot(), Args, nullptr, CE && CE == MustTailCall,
                CE ? CE->getExprLoc() : SourceLocation{});
118}

120RValue CodeGenFunction::EmitCXXPseudoDestructorExpr(
                                          const CXXPseudoDestructorExpr *E) {
QualType DestroyedType = E->getDestroyedType();
if (DestroyedType.hasStrongOrWeakObjCLifetime()) {
  // Automatic Reference Counting:
  //   If the pseudo-expression names a retainable object with weak or
  //   strong lifetime, the object shall be released.
  Expr *BaseExpr = E->getBase();
  Address BaseValue = Address::invalid();
  Qualifiers BaseQuals;

  // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
  if (E->isArrow()) {
    BaseValue = EmitPointerWithAlignment(BaseExpr);
    const auto *PTy = BaseExpr->getType()->castAs<PointerType>();
    BaseQuals = PTy->getPointeeType().getQualifiers();
  } else {
    LValue BaseLV = EmitLValue(BaseExpr);
    BaseValue = BaseLV.getAddress(*this);
    QualType BaseTy = BaseExpr->getType();
    BaseQuals = BaseTy.getQualifiers();
  }

  switch (DestroyedType.getObjCLifetime()) {
  case Qualifiers::OCL_None:
  case Qualifiers::OCL_ExplicitNone:
  case Qualifiers::OCL_Autoreleasing:
    break;

  case Qualifiers::OCL_Strong:
    EmitARCRelease(Builder.CreateLoad(BaseValue,
                      DestroyedType.isVolatileQualified()),
                   ARCPreciseLifetime);
    break;

  case Qualifiers::OCL_Weak:
    EmitARCDestroyWeak(BaseValue);
    break;
  }
} else {
  // C++ [expr.pseudo]p1:
  //   The result shall only be used as the operand for the function call
  //   operator (), and the result of such a call has type void. The only
  //   effect is the evaluation of the postfix-expression before the dot or
  //   arrow.
  EmitIgnoredExpr(E->getBase());
}

return RValue::get(nullptr);
169}

171static CXXRecordDecl *getCXXRecord(const Expr *E) {
QualType T = E->getType();
if (const PointerType *PTy = T->getAs<PointerType>())
  T = PTy->getPointeeType();
const RecordType *Ty = T->castAs<RecordType>();
return cast<CXXRecordDecl>(Ty->getDecl());
177}

179// Note: This function also emit constructor calls to support a MSVC
180// extensions allowing explicit constructor function call.
181RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
                                            ReturnValueSlot ReturnValue) {
const Expr *callee = CE->getCallee()->IgnoreParens();

if (isa<BinaryOperator>(callee))
  return EmitCXXMemberPointerCallExpr(CE, ReturnValue);

const MemberExpr *ME = cast<MemberExpr>(callee);
const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());

if (MD->isStatic()) {
  // The method is static, emit it as we would a regular call.
  CGCallee callee =
      CGCallee::forDirect(CGM.GetAddrOfFunction(MD), GlobalDecl(MD));
  return EmitCall(getContext().getPointerType(MD->getType()), callee, CE,
                  ReturnValue);
}

bool HasQualifier = ME->hasQualifier();
NestedNameSpecifier *Qualifier = HasQualifier ? ME->getQualifier() : nullptr;
bool IsArrow = ME->isArrow();
const Expr *Base = ME->getBase();

return EmitCXXMemberOrOperatorMemberCallExpr(
    CE, MD, ReturnValue, HasQualifier, Qualifier, IsArrow, Base);
206}

208RValue CodeGenFunction::EmitCXXMemberOrOperatorMemberCallExpr(
  const CallExpr *CE, const CXXMethodDecl *MD, ReturnValueSlot ReturnValue,
  bool HasQualifier, NestedNameSpecifier *Qualifier, bool IsArrow,
  const Expr *Base) {
assert(isa<CXXMemberCallExpr>(CE) || isa<CXXOperatorCallExpr>(CE))((void)0);

// Compute the object pointer.
bool CanUseVirtualCall = MD->isVirtual() && !HasQualifier;

const CXXMethodDecl *DevirtualizedMethod = nullptr;
if (CanUseVirtualCall &&
    MD->getDevirtualizedMethod(Base, getLangOpts().AppleKext)) {
  const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
  DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);
  assert(DevirtualizedMethod)((void)0);
  const CXXRecordDecl *DevirtualizedClass = DevirtualizedMethod->getParent();
  const Expr *Inner = Base->IgnoreParenBaseCasts();
  if (DevirtualizedMethod->getReturnType().getCanonicalType() !=
      MD->getReturnType().getCanonicalType())
    // If the return types are not the same, this might be a case where more
    // code needs to run to compensate for it. For example, the derived
    // method might return a type that inherits form from the return
    // type of MD and has a prefix.
    // For now we just avoid devirtualizing these covariant cases.
    DevirtualizedMethod = nullptr;
  else if (getCXXRecord(Inner) == DevirtualizedClass)
    // If the class of the Inner expression is where the dynamic method
    // is defined, build the this pointer from it.
    Base = Inner;
  else if (getCXXRecord(Base) != DevirtualizedClass) {
    // If the method is defined in a class that is not the best dynamic
    // one or the one of the full expression, we would have to build
    // a derived-to-base cast to compute the correct this pointer, but
    // we don't have support for that yet, so do a virtual call.
    DevirtualizedMethod = nullptr;
  }
}

bool TrivialForCodegen =
    MD->isTrivial() || (MD->isDefaulted() && MD->getParent()->isUnion());
bool TrivialAssignment =
    TrivialForCodegen &&
    (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) &&
    !MD->getParent()->mayInsertExtraPadding();

// C++17 demands that we evaluate the RHS of a (possibly-compound) assignment
// operator before the LHS.
CallArgList RtlArgStorage;
CallArgList *RtlArgs = nullptr;
LValue TrivialAssignmentRHS;
if (auto *OCE = dyn_cast<CXXOperatorCallExpr>(CE)) {
  if (OCE->isAssignmentOp()) {
    if (TrivialAssignment) {
      TrivialAssignmentRHS = EmitLValue(CE->getArg(1));
    } else {
      RtlArgs = &RtlArgStorage;
      EmitCallArgs(*RtlArgs, MD->getType()->castAs<FunctionProtoType>(),
                   drop_begin(CE->arguments(), 1), CE->getDirectCallee(),
                   /*ParamsToSkip*/0, EvaluationOrder::ForceRightToLeft);
    }
  }
}

LValue This;
if (IsArrow) {
  LValueBaseInfo BaseInfo;
  TBAAAccessInfo TBAAInfo;
  Address ThisValue = EmitPointerWithAlignment(Base, &BaseInfo, &TBAAInfo);
  This = MakeAddrLValue(ThisValue, Base->getType(), BaseInfo, TBAAInfo);
} else {
  This = EmitLValue(Base);
}

if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
  // This is the MSVC p->Ctor::Ctor(...) extension. We assume that's
  // constructing a new complete object of type Ctor.
  assert(!RtlArgs)((void)0);
  assert(ReturnValue.isNull() && "Constructor shouldn't have return value")((void)0);
  CallArgList Args;
  commonEmitCXXMemberOrOperatorCall(
      *this, Ctor, This.getPointer(*this), /*ImplicitParam=*/nullptr,
      /*ImplicitParamTy=*/QualType(), CE, Args, nullptr);

  EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false,
                         /*Delegating=*/false, This.getAddress(*this), Args,
                         AggValueSlot::DoesNotOverlap, CE->getExprLoc(),
                         /*NewPointerIsChecked=*/false);
  return RValue::get(nullptr);
}

if (TrivialForCodegen) {
  if (isa<CXXDestructorDecl>(MD))
    return RValue::get(nullptr);

  if (TrivialAssignment) {
    // We don't like to generate the trivial copy/move assignment operator
    // when it isn't necessary; just produce the proper effect here.
    // It's important that we use the result of EmitLValue here rather than
    // emitting call arguments, in order to preserve TBAA information from
    // the RHS.
    LValue RHS = isa<CXXOperatorCallExpr>(CE)
                     ? TrivialAssignmentRHS
                     : EmitLValue(*CE->arg_begin());
    EmitAggregateAssign(This, RHS, CE->getType());
    return RValue::get(This.getPointer(*this));
  }

  assert(MD->getParent()->mayInsertExtraPadding() &&((void)0)
         "unknown trivial member function")((void)0);
}

// Compute the function type we're calling.
const CXXMethodDecl *CalleeDecl =
    DevirtualizedMethod ? DevirtualizedMethod : MD;
const CGFunctionInfo *FInfo = nullptr;
if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))
  FInfo = &CGM.getTypes().arrangeCXXStructorDeclaration(
      GlobalDecl(Dtor, Dtor_Complete));
else
  FInfo = &CGM.getTypes().arrangeCXXMethodDeclaration(CalleeDecl);

llvm::FunctionType *Ty = CGM.getTypes().GetFunctionType(*FInfo);

// C++11 [class.mfct.non-static]p2:
//   If a non-static member function of a class X is called for an object that
//   is not of type X, or of a type derived from X, the behavior is undefined.
SourceLocation CallLoc;
ASTContext &C = getContext();
if (CE)
  CallLoc = CE->getExprLoc();

SanitizerSet SkippedChecks;
if (const auto *CMCE = dyn_cast<CXXMemberCallExpr>(CE)) {
  auto *IOA = CMCE->getImplicitObjectArgument();
  bool IsImplicitObjectCXXThis = IsWrappedCXXThis(IOA);
  if (IsImplicitObjectCXXThis)
    SkippedChecks.set(SanitizerKind::Alignment, true);
  if (IsImplicitObjectCXXThis || isa<DeclRefExpr>(IOA))
    SkippedChecks.set(SanitizerKind::Null, true);
}
EmitTypeCheck(CodeGenFunction::TCK_MemberCall, CallLoc,
              This.getPointer(*this),
              C.getRecordType(CalleeDecl->getParent()),
              /*Alignment=*/CharUnits::Zero(), SkippedChecks);

// C++ [class.virtual]p12:
//   Explicit qualification with the scope operator (5.1) suppresses the
//   virtual call mechanism.
//
// We also don't emit a virtual call if the base expression has a record type
// because then we know what the type is.
bool UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;

if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl)) {
  assert(CE->arg_begin() == CE->arg_end() &&((void)0)
         "Destructor shouldn't have explicit parameters")((void)0);
  assert(ReturnValue.isNull() && "Destructor shouldn't have return value")((void)0);
  if (UseVirtualCall) {
    CGM.getCXXABI().EmitVirtualDestructorCall(*this, Dtor, Dtor_Complete,
                                              This.getAddress(*this),
                                              cast<CXXMemberCallExpr>(CE));
  } else {
    GlobalDecl GD(Dtor, Dtor_Complete);
    CGCallee Callee;
    if (getLangOpts().AppleKext && Dtor->isVirtual() && HasQualifier)
      Callee = BuildAppleKextVirtualCall(Dtor, Qualifier, Ty);
    else if (!DevirtualizedMethod)
      Callee =
          CGCallee::forDirect(CGM.getAddrOfCXXStructor(GD, FInfo, Ty), GD);
    else {
      Callee = CGCallee::forDirect(CGM.GetAddrOfFunction(GD, Ty), GD);
    }

    QualType ThisTy =
        IsArrow ? Base->getType()->getPointeeType() : Base->getType();
    EmitCXXDestructorCall(GD, Callee, This.getPointer(*this), ThisTy,
                          /*ImplicitParam=*/nullptr,
                          /*ImplicitParamTy=*/QualType(), CE);
  }
  return RValue::get(nullptr);
}

// FIXME: Uses of 'MD' past this point need to be audited. We may need to use
// 'CalleeDecl' instead.

CGCallee Callee;
if (UseVirtualCall) {
  Callee = CGCallee::forVirtual(CE, MD, This.getAddress(*this), Ty);
} else {
  if (SanOpts.has(SanitizerKind::CFINVCall) &&
      MD->getParent()->isDynamicClass()) {
    llvm::Value *VTable;
    const CXXRecordDecl *RD;
    std::tie(VTable, RD) = CGM.getCXXABI().LoadVTablePtr(
        *this, This.getAddress(*this), CalleeDecl->getParent());
    EmitVTablePtrCheckForCall(RD, VTable, CFITCK_NVCall, CE->getBeginLoc());
  }

  if (getLangOpts().AppleKext && MD->isVirtual() && HasQualifier)
    Callee = BuildAppleKextVirtualCall(MD, Qualifier, Ty);
  else if (!DevirtualizedMethod)
    Callee =
        CGCallee::forDirect(CGM.GetAddrOfFunction(MD, Ty), GlobalDecl(MD));
  else {
    Callee =
        CGCallee::forDirect(CGM.GetAddrOfFunction(DevirtualizedMethod, Ty),
                            GlobalDecl(DevirtualizedMethod));
  }
}

if (MD->isVirtual()) {
  Address NewThisAddr =
      CGM.getCXXABI().adjustThisArgumentForVirtualFunctionCall(
          *this, CalleeDecl, This.getAddress(*this), UseVirtualCall);
  This.setAddress(NewThisAddr);
}

return EmitCXXMemberOrOperatorCall(
    CalleeDecl, Callee, ReturnValue, This.getPointer(*this),
    /*ImplicitParam=*/nullptr, QualType(), CE, RtlArgs);
428}

430RValue
431CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
                                            ReturnValueSlot ReturnValue) {
const BinaryOperator *BO =
    cast<BinaryOperator>(E->getCallee()->IgnoreParens());
const Expr *BaseExpr = BO->getLHS();
const Expr *MemFnExpr = BO->getRHS();

const auto *MPT = MemFnExpr->getType()->castAs<MemberPointerType>();
const auto *FPT = MPT->getPointeeType()->castAs<FunctionProtoType>();
const auto *RD =
    cast<CXXRecordDecl>(MPT->getClass()->castAs<RecordType>()->getDecl());

// Emit the 'this' pointer.
Address This = Address::invalid();
if (BO->getOpcode() == BO_PtrMemI)
  This = EmitPointerWithAlignment(BaseExpr);
else
  This = EmitLValue(BaseExpr).getAddress(*this);

EmitTypeCheck(TCK_MemberCall, E->getExprLoc(), This.getPointer(),
              QualType(MPT->getClass(), 0));

// Get the member function pointer.
llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);

// Ask the ABI to load the callee.  Note that This is modified.
llvm::Value *ThisPtrForCall = nullptr;
CGCallee Callee =
  CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(*this, BO, This,
                                           ThisPtrForCall, MemFnPtr, MPT);

CallArgList Args;

QualType ThisType =
  getContext().getPointerType(getContext().getTagDeclType(RD));

// Push the this ptr.
Args.add(RValue::get(ThisPtrForCall), ThisType);

RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, 1);

// And the rest of the call args
EmitCallArgs(Args, FPT, E->arguments());
return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required,
                                                    /*PrefixSize=*/0),
                Callee, ReturnValue, Args, nullptr, E == MustTailCall,
                E->getExprLoc());
478}

480RValue
481CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
                                             const CXXMethodDecl *MD,
                                             ReturnValueSlot ReturnValue) {
assert(MD->isInstance() &&((void)0)
       "Trying to emit a member call expr on a static method!")((void)0);
return EmitCXXMemberOrOperatorMemberCallExpr(
    E, MD, ReturnValue, /*HasQualifier=*/false, /*Qualifier=*/nullptr,
    /*IsArrow=*/false, E->getArg(0));
489}

491RValue CodeGenFunction::EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
                                             ReturnValueSlot ReturnValue) {
return CGM.getCUDARuntime().EmitCUDAKernelCallExpr(*this, E, ReturnValue);
494}

496static void EmitNullBaseClassInitialization(CodeGenFunction &CGF,
                                          Address DestPtr,
                                          const CXXRecordDecl *Base) {
if (Base->isEmpty())
  return;

DestPtr = CGF.Builder.CreateElementBitCast(DestPtr, CGF.Int8Ty);

const ASTRecordLayout &Layout = CGF.getContext().getASTRecordLayout(Base);
CharUnits NVSize = Layout.getNonVirtualSize();

// We cannot simply zero-initialize the entire base sub-object if vbptrs are
// present, they are initialized by the most derived class before calling the
// constructor.
SmallVector<std::pair<CharUnits, CharUnits>, 1> Stores;
Stores.emplace_back(CharUnits::Zero(), NVSize);

// Each store is split by the existence of a vbptr.
CharUnits VBPtrWidth = CGF.getPointerSize();
std::vector<CharUnits> VBPtrOffsets =
    CGF.CGM.getCXXABI().getVBPtrOffsets(Base);
for (CharUnits VBPtrOffset : VBPtrOffsets) {
  // Stop before we hit any virtual base pointers located in virtual bases.
  if (VBPtrOffset >= NVSize)
    break;
  std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();
  CharUnits LastStoreOffset = LastStore.first;
  CharUnits LastStoreSize = LastStore.second;

  CharUnits SplitBeforeOffset = LastStoreOffset;
  CharUnits SplitBeforeSize = VBPtrOffset - SplitBeforeOffset;
  assert(!SplitBeforeSize.isNegative() && "negative store size!")((void)0);
  if (!SplitBeforeSize.isZero())
    Stores.emplace_back(SplitBeforeOffset, SplitBeforeSize);

  CharUnits SplitAfterOffset = VBPtrOffset + VBPtrWidth;
  CharUnits SplitAfterSize = LastStoreSize - SplitAfterOffset;
  assert(!SplitAfterSize.isNegative() && "negative store size!")((void)0);
  if (!SplitAfterSize.isZero())
    Stores.emplace_back(SplitAfterOffset, SplitAfterSize);
}

// If the type contains a pointer to data member we can't memset it to zero.
// Instead, create a null constant and copy it to the destination.
// TODO: there are other patterns besides zero that we can usefully memset,
// like -1, which happens to be the pattern used by member-pointers.
// TODO: isZeroInitializable can be over-conservative in the case where a
// virtual base contains a member pointer.
llvm::Constant *NullConstantForBase = CGF.CGM.EmitNullConstantForBase(Base);
if (!NullConstantForBase->isNullValue()) {
  llvm::GlobalVariable *NullVariable = new llvm::GlobalVariable(
      CGF.CGM.getModule(), NullConstantForBase->getType(),
      /*isConstant=*/true, llvm::GlobalVariable::PrivateLinkage,
      NullConstantForBase, Twine());

  CharUnits Align = std::max(Layout.getNonVirtualAlignment(),
                             DestPtr.getAlignment());
  NullVariable->setAlignment(Align.getAsAlign());

  Address SrcPtr = Address(CGF.EmitCastToVoidPtr(NullVariable), Align);

  // Get and call the appropriate llvm.memcpy overload.
  for (std::pair<CharUnits, CharUnits> Store : Stores) {
    CharUnits StoreOffset = Store.first;
    CharUnits StoreSize = Store.second;
    llvm::Value *StoreSizeVal = CGF.CGM.getSize(StoreSize);
    CGF.Builder.CreateMemCpy(
        CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
        CGF.Builder.CreateConstInBoundsByteGEP(SrcPtr, StoreOffset),
        StoreSizeVal);
  }

// Otherwise, just memset the whole thing to zero.  This is legal
// because in LLVM, all default initializers (other than the ones we just
// handled above) are guaranteed to have a bit pattern of all zeros.
} else {
  for (std::pair<CharUnits, CharUnits> Store : Stores) {
    CharUnits StoreOffset = Store.first;
    CharUnits StoreSize = Store.second;
    llvm::Value *StoreSizeVal = CGF.CGM.getSize(StoreSize);
    CGF.Builder.CreateMemSet(
        CGF.Builder.CreateConstInBoundsByteGEP(DestPtr, StoreOffset),
        CGF.Builder.getInt8(0), StoreSizeVal);
  }
}
581}

583void
584CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,
                                    AggValueSlot Dest) {
assert(!Dest.isIgnored() && "Must have a destination!")((void)0);
const CXXConstructorDecl *CD = E->getConstructor();

// If we require zero initialization before (or instead of) calling the
// constructor, as can be the case with a non-user-provided default
// constructor, emit the zero initialization now, unless destination is
// already zeroed.
if (E->requiresZeroInitialization() && !Dest.isZeroed()) {
  switch (E->getConstructionKind()) {
  case CXXConstructExpr::CK_Delegating:
  case CXXConstructExpr::CK_Complete:
    EmitNullInitialization(Dest.getAddress(), E->getType());
    break;
  case CXXConstructExpr::CK_VirtualBase:
  case CXXConstructExpr::CK_NonVirtualBase:
    EmitNullBaseClassInitialization(*this, Dest.getAddress(),
                                    CD->getParent());
    break;
  }
}

// If this is a call to a trivial default constructor, do nothing.
if (CD->isTrivial() && CD->isDefaultConstructor())
  return;

// Elide the constructor if we're constructing from a temporary.
if (getLangOpts().ElideConstructors && E->isElidable()) {
  // FIXME: This only handles the simplest case, where the source object
  //        is passed directly as the first argument to the constructor.
  //        This should also handle stepping though implicit casts and
  //        conversion sequences which involve two steps, with a
  //        conversion operator followed by a converting constructor.
  const Expr *SrcObj = E->getArg(0);
  assert(SrcObj->isTemporaryObject(getContext(), CD->getParent()))((void)0);
  assert(((void)0)
      getContext().hasSameUnqualifiedType(E->getType(), SrcObj->getType()))((void)0);
  EmitAggExpr(SrcObj, Dest);
  return;
}

if (const ArrayType *arrayType
      = getContext().getAsArrayType(E->getType())) {
  EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddress(), E,
                             Dest.isSanitizerChecked());
} else {
  CXXCtorType Type = Ctor_Complete;
  bool ForVirtualBase = false;
  bool Delegating = false;

  switch (E->getConstructionKind()) {
   case CXXConstructExpr::CK_Delegating:
    // We should be emitting a constructor; GlobalDecl will assert this
    Type = CurGD.getCtorType();
    Delegating = true;
    break;

   case CXXConstructExpr::CK_Complete:
    Type = Ctor_Complete;
    break;

   case CXXConstructExpr::CK_VirtualBase:
    ForVirtualBase = true;
    LLVM_FALLTHROUGH[[gnu::fallthrough]];

   case CXXConstructExpr::CK_NonVirtualBase:
    Type = Ctor_Base;
   }

   // Call the constructor.
   EmitCXXConstructorCall(CD, Type, ForVirtualBase, Delegating, Dest, E);
}
657}

659void CodeGenFunction::EmitSynthesizedCXXCopyCtor(Address Dest, Address Src,
                                               const Expr *Exp) {
if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
  Exp = E->getSubExpr();
assert(isa<CXXConstructExpr>(Exp) &&((void)0)
       "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr")((void)0);
const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
const CXXConstructorDecl *CD = E->getConstructor();
RunCleanupsScope Scope(*this);

// If we require zero initialization before (or instead of) calling the
// constructor, as can be the case with a non-user-provided default
// constructor, emit the zero initialization now.
// FIXME. Do I still need this for a copy ctor synthesis?
if (E->requiresZeroInitialization())
  EmitNullInitialization(Dest, E->getType());

assert(!getContext().getAsConstantArrayType(E->getType())((void)0)
       && "EmitSynthesizedCXXCopyCtor - Copied-in Array")((void)0);
EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src, E);
679}

681static CharUnits CalculateCookiePadding(CodeGenFunction &CGF,
                                      const CXXNewExpr *E) {
if (!E->isArray())
  return CharUnits::Zero();

// No cookie is required if the operator new[] being used is the
// reserved placement operator new[].
if (E->getOperatorNew()->isReservedGlobalPlacementOperator())
  return CharUnits::Zero();

return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
692}

694static llvm::Value *EmitCXXNewAllocSize(CodeGenFunction &CGF,
                                      const CXXNewExpr *e,
                                      unsigned minElements,
                                      llvm::Value *&numElements,
                                      llvm::Value *&sizeWithoutCookie) {
QualType type = e->getAllocatedType();

if (!e->isArray()) {
4
←
Taking true branch→
  CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
  sizeWithoutCookie
    = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
  return sizeWithoutCookie;
5
←
Returning without writing to 'numElements'→
}

// The width of size_t.
unsigned sizeWidth = CGF.SizeTy->getBitWidth();

// Figure out the cookie size.
llvm::APInt cookieSize(sizeWidth,
                       CalculateCookiePadding(CGF, e).getQuantity());

// Emit the array size expression.
// We multiply the size of all dimensions for NumElements.
// e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
numElements =
  ConstantEmitter(CGF).tryEmitAbstract(*e->getArraySize(), e->getType());
if (!numElements)
  numElements = CGF.EmitScalarExpr(*e->getArraySize());
assert(isa<llvm::IntegerType>(numElements->getType()))((void)0);

// The number of elements can be have an arbitrary integer type;
// essentially, we need to multiply it by a constant factor, add a
// cookie size, and verify that the result is representable as a
// size_t.  That's just a gloss, though, and it's wrong in one
// important way: if the count is negative, it's an error even if
// the cookie size would bring the total size >= 0.
bool isSigned
  = (*e->getArraySize())->getType()->isSignedIntegerOrEnumerationType();
llvm::IntegerType *numElementsType
  = cast<llvm::IntegerType>(numElements->getType());
unsigned numElementsWidth = numElementsType->getBitWidth();

// Compute the constant factor.
llvm::APInt arraySizeMultiplier(sizeWidth, 1);
while (const ConstantArrayType *CAT
           = CGF.getContext().getAsConstantArrayType(type)) {
  type = CAT->getElementType();
  arraySizeMultiplier *= CAT->getSize();
}

CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity());
typeSizeMultiplier *= arraySizeMultiplier;

// This will be a size_t.
llvm::Value *size;

// If someone is doing 'new int[42]' there is no need to do a dynamic check.
// Don't bloat the -O0 code.
if (llvm::ConstantInt *numElementsC =
      dyn_cast<llvm::ConstantInt>(numElements)) {
  const llvm::APInt &count = numElementsC->getValue();

  bool hasAnyOverflow = false;

  // If 'count' was a negative number, it's an overflow.
  if (isSigned && count.isNegative())
    hasAnyOverflow = true;

  // We want to do all this arithmetic in size_t.  If numElements is
  // wider than that, check whether it's already too big, and if so,
  // overflow.
  else if (numElementsWidth > sizeWidth &&
           numElementsWidth - sizeWidth > count.countLeadingZeros())
    hasAnyOverflow = true;

  // Okay, compute a count at the right width.
  llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);

  // If there is a brace-initializer, we cannot allocate fewer elements than
  // there are initializers. If we do, that's treated like an overflow.
  if (adjustedCount.ult(minElements))
    hasAnyOverflow = true;

  // Scale numElements by that.  This might overflow, but we don't
  // care because it only overflows if allocationSize does, too, and
  // if that overflows then we shouldn't use this.
  numElements = llvm::ConstantInt::get(CGF.SizeTy,
                                       adjustedCount * arraySizeMultiplier);

  // Compute the size before cookie, and track whether it overflowed.
  bool overflow;
  llvm::APInt allocationSize
    = adjustedCount.umul_ov(typeSizeMultiplier, overflow);
  hasAnyOverflow |= overflow;

  // Add in the cookie, and check whether it's overflowed.
  if (cookieSize != 0) {
    // Save the current size without a cookie.  This shouldn't be
    // used if there was overflow.
    sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);

    allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
    hasAnyOverflow |= overflow;
  }

  // On overflow, produce a -1 so operator new will fail.
  if (hasAnyOverflow) {
    size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
  } else {
    size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
  }

// Otherwise, we might need to use the overflow intrinsics.
} else {
  // There are up to five conditions we need to test for:
  // 1) if isSigned, we need to check whether numElements is negative;
  // 2) if numElementsWidth > sizeWidth, we need to check whether
  //   numElements is larger than something representable in size_t;
  // 3) if minElements > 0, we need to check whether numElements is smaller
  //    than that.
  // 4) we need to compute
  //      sizeWithoutCookie := numElements * typeSizeMultiplier
  //    and check whether it overflows; and
  // 5) if we need a cookie, we need to compute
  //      size := sizeWithoutCookie + cookieSize
  //    and check whether it overflows.

  llvm::Value *hasOverflow = nullptr;

  // If numElementsWidth > sizeWidth, then one way or another, we're
  // going to have to do a comparison for (2), and this happens to
  // take care of (1), too.
  if (numElementsWidth > sizeWidth) {
    llvm::APInt threshold(numElementsWidth, 1);
    threshold <<= sizeWidth;

    llvm::Value *thresholdV
      = llvm::ConstantInt::get(numElementsType, threshold);

    hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
    numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);

  // Otherwise, if we're signed, we want to sext up to size_t.
  } else if (isSigned) {
    if (numElementsWidth < sizeWidth)
      numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);

    // If there's a non-1 type size multiplier, then we can do the
    // signedness check at the same time as we do the multiply
    // because a negative number times anything will cause an
    // unsigned overflow.  Otherwise, we have to do it here. But at least
    // in this case, we can subsume the >= minElements check.
    if (typeSizeMultiplier == 1)
      hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
                            llvm::ConstantInt::get(CGF.SizeTy, minElements));

  // Otherwise, zext up to size_t if necessary.
  } else if (numElementsWidth < sizeWidth) {
    numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
  }

  assert(numElements->getType() == CGF.SizeTy)((void)0);

  if (minElements) {
    // Don't allow allocation of fewer elements than we have initializers.
    if (!hasOverflow) {
      hasOverflow = CGF.Builder.CreateICmpULT(numElements,
                            llvm::ConstantInt::get(CGF.SizeTy, minElements));
    } else if (numElementsWidth > sizeWidth) {
      // The other existing overflow subsumes this check.
      // We do an unsigned comparison, since any signed value < -1 is
      // taken care of either above or below.
      hasOverflow = CGF.Builder.CreateOr(hasOverflow,
                        CGF.Builder.CreateICmpULT(numElements,
                            llvm::ConstantInt::get(CGF.SizeTy, minElements)));
    }
  }

  size = numElements;

  // Multiply by the type size if necessary.  This multiplier
  // includes all the factors for nested arrays.
  //
  // This step also causes numElements to be scaled up by the
  // nested-array factor if necessary.  Overflow on this computation
  // can be ignored because the result shouldn't be used if
  // allocation fails.
  if (typeSizeMultiplier != 1) {
    llvm::Function *umul_with_overflow
      = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy);

    llvm::Value *tsmV =
      llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
    llvm::Value *result =
        CGF.Builder.CreateCall(umul_with_overflow, {size, tsmV});

    llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
    if (hasOverflow)
      hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
    else
      hasOverflow = overflowed;

    size = CGF.Builder.CreateExtractValue(result, 0);

    // Also scale up numElements by the array size multiplier.
    if (arraySizeMultiplier != 1) {
      // If the base element type size is 1, then we can re-use the
      // multiply we just did.
      if (typeSize.isOne()) {
        assert(arraySizeMultiplier == typeSizeMultiplier)((void)0);
        numElements = size;

      // Otherwise we need a separate multiply.
      } else {
        llvm::Value *asmV =
          llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
        numElements = CGF.Builder.CreateMul(numElements, asmV);
      }
    }
  } else {
    // numElements doesn't need to be scaled.
    assert(arraySizeMultiplier == 1)((void)0);
  }

  // Add in the cookie size if necessary.
  if (cookieSize != 0) {
    sizeWithoutCookie = size;

    llvm::Function *uadd_with_overflow
      = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy);

    llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
    llvm::Value *result =
        CGF.Builder.CreateCall(uadd_with_overflow, {size, cookieSizeV});

    llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
    if (hasOverflow)
      hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
    else
      hasOverflow = overflowed;

    size = CGF.Builder.CreateExtractValue(result, 0);
  }

  // If we had any possibility of dynamic overflow, make a select to
  // overwrite 'size' with an all-ones value, which should cause
  // operator new to throw.
  if (hasOverflow)
    size = CGF.Builder.CreateSelect(hasOverflow,
                               llvm::Constant::getAllOnesValue(CGF.SizeTy),
                                    size);
}

if (cookieSize == 0)
  sizeWithoutCookie = size;
else
  assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?")((void)0);

return size;
954}

956static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init,
                                  QualType AllocType, Address NewPtr,
                                  AggValueSlot::Overlap_t MayOverlap) {
// FIXME: Refactor with EmitExprAsInit.
switch (CGF.getEvaluationKind(AllocType)) {
case TEK_Scalar:
  CGF.EmitScalarInit(Init, nullptr,
                     CGF.MakeAddrLValue(NewPtr, AllocType), false);
  return;
case TEK_Complex:
  CGF.EmitComplexExprIntoLValue(Init, CGF.MakeAddrLValue(NewPtr, AllocType),
                                /*isInit*/ true);
  return;
case TEK_Aggregate: {
  AggValueSlot Slot
    = AggValueSlot::forAddr(NewPtr, AllocType.getQualifiers(),
                            AggValueSlot::IsDestructed,
                            AggValueSlot::DoesNotNeedGCBarriers,
                            AggValueSlot::IsNotAliased,
                            MayOverlap, AggValueSlot::IsNotZeroed,
                            AggValueSlot::IsSanitizerChecked);
  CGF.EmitAggExpr(Init, Slot);
  return;
}
}
llvm_unreachable("bad evaluation kind")__builtin_unreachable();
982}

984void CodeGenFunction::EmitNewArrayInitializer(
  const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy,
  Address BeginPtr, llvm::Value *NumElements,
  llvm::Value *AllocSizeWithoutCookie) {
// If we have a type with trivial initialization and no initializer,
// there's nothing to do.
if (!E->hasInitializer())
27
←
Calling 'CXXNewExpr::hasInitializer'→
30
←
Returning from 'CXXNewExpr::hasInitializer'→
31
←
Taking false branch→
  return;

Address CurPtr = BeginPtr;

unsigned InitListElements = 0;

const Expr *Init = E->getInitializer();
Address EndOfInit = Address::invalid();
QualType::DestructionKind DtorKind = ElementType.isDestructedType();
EHScopeStack::stable_iterator Cleanup;
llvm::Instruction *CleanupDominator = nullptr;

CharUnits ElementSize = getContext().getTypeSizeInChars(ElementType);
CharUnits ElementAlign =
  BeginPtr.getAlignment().alignmentOfArrayElement(ElementSize);

// Attempt to perform zero-initialization using memset.
auto TryMemsetInitialization = [&]() -> bool {
  // FIXME: If the type is a pointer-to-data-member under the Itanium ABI,
  // we can initialize with a memset to -1.
  if (!CGM.getTypes().isZeroInitializable(ElementType))
    return false;

  // Optimization: since zero initialization will just set the memory
  // to all zeroes, generate a single memset to do it in one shot.

  // Subtract out the size of any elements we've already initialized.
  auto *RemainingSize = AllocSizeWithoutCookie;
  if (InitListElements) {
    // We know this can't overflow; we check this when doing the allocation.
    auto *InitializedSize = llvm::ConstantInt::get(
        RemainingSize->getType(),
        getContext().getTypeSizeInChars(ElementType).getQuantity() *
            InitListElements);
    RemainingSize = Builder.CreateSub(RemainingSize, InitializedSize);
  }

  // Create the memset.
  Builder.CreateMemSet(CurPtr, Builder.getInt8(0), RemainingSize, false);
  return true;
};

// If the initializer is an initializer list, first do the explicit elements.
if (const InitListExpr *ILE32.1
'ILE' is non-null
1
'ILE' is non-null
 = dyn_cast<InitListExpr>(Init)) {
32
←
Assuming 'Init' is a 'InitListExpr'→
33
←
Taking true branch→
  // Initializing from a (braced) string literal is a special case; the init
  // list element does not initialize a (single) array element.
  if (ILE->isStringLiteralInit()) {
34
←
Assuming the condition is false→
35
←
Taking false branch→
    // Initialize the initial portion of length equal to that of the string
    // literal. The allocation must be for at least this much; we emitted a
    // check for that earlier.
    AggValueSlot Slot =
        AggValueSlot::forAddr(CurPtr, ElementType.getQualifiers(),
                              AggValueSlot::IsDestructed,
                              AggValueSlot::DoesNotNeedGCBarriers,
                              AggValueSlot::IsNotAliased,
                              AggValueSlot::DoesNotOverlap,
                              AggValueSlot::IsNotZeroed,
                              AggValueSlot::IsSanitizerChecked);
    EmitAggExpr(ILE->getInit(0), Slot);

    // Move past these elements.
    InitListElements =
        cast<ConstantArrayType>(ILE->getType()->getAsArrayTypeUnsafe())
            ->getSize().getZExtValue();
    CurPtr =
        Address(Builder.CreateInBoundsGEP(CurPtr.getElementType(),
                                          CurPtr.getPointer(),
                                          Builder.getSize(InitListElements),
                                          "string.init.end"),
                CurPtr.getAlignment().alignmentAtOffset(InitListElements *
                                                        ElementSize));

    // Zero out the rest, if any remain.
    llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
    if (!ConstNum || !ConstNum->equalsInt(InitListElements)) {
      bool OK = TryMemsetInitialization();
      (void)OK;
      assert(OK && "couldn't memset character type?")((void)0);
    }
    return;
  }

  InitListElements = ILE->getNumInits();

  // If this is a multi-dimensional array new, we will initialize multiple
  // elements with each init list element.
  QualType AllocType = E->getAllocatedType();
  if (const ConstantArrayType *CAT36.1
'CAT' is null
1
'CAT' is null
 = dyn_cast_or_null<ConstantArrayType>(
36
←
Assuming null pointer is passed into cast→
37
←
Taking false branch→
          AllocType->getAsArrayTypeUnsafe())) {
    ElementTy = ConvertTypeForMem(AllocType);
    CurPtr = Builder.CreateElementBitCast(CurPtr, ElementTy);
    InitListElements *= getContext().getConstantArrayElementCount(CAT);
  }

  // Enter a partial-destruction Cleanup if necessary.
  if (needsEHCleanup(DtorKind)) {
38
←
Taking false branch→
    // In principle we could tell the Cleanup where we are more
    // directly, but the control flow can get so varied here that it
    // would actually be quite complex.  Therefore we go through an
    // alloca.
    EndOfInit = CreateTempAlloca(BeginPtr.getType(), getPointerAlign(),
                                 "array.init.end");
    CleanupDominator = Builder.CreateStore(BeginPtr.getPointer(), EndOfInit);
    pushIrregularPartialArrayCleanup(BeginPtr.getPointer(), EndOfInit,
                                     ElementType, ElementAlign,
                                     getDestroyer(DtorKind));
    Cleanup = EHStack.stable_begin();
  }

  CharUnits StartAlign = CurPtr.getAlignment();
  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) {
39
←
Assuming 'i' is equal to 'e'→
40
←
Loop condition is false. Execution continues on line 1124→
    // Tell the cleanup that it needs to destroy up to this
    // element.  TODO: some of these stores can be trivially
    // observed to be unnecessary.
    if (EndOfInit.isValid()) {
      auto FinishedPtr =
        Builder.CreateBitCast(CurPtr.getPointer(), BeginPtr.getType());
      Builder.CreateStore(FinishedPtr, EndOfInit);
    }
    // FIXME: If the last initializer is an incomplete initializer list for
    // an array, and we have an array filler, we can fold together the two
    // initialization loops.
    StoreAnyExprIntoOneUnit(*this, ILE->getInit(i),
                            ILE->getInit(i)->getType(), CurPtr,
                            AggValueSlot::DoesNotOverlap);
    CurPtr = Address(Builder.CreateInBoundsGEP(CurPtr.getElementType(),
                                               CurPtr.getPointer(),
                                               Builder.getSize(1),
                                               "array.exp.next"),
                     StartAlign.alignmentAtOffset((i + 1) * ElementSize));
  }

  // The remaining elements are filled with the array filler expression.
  Init = ILE->getArrayFiller();

  // Extract the initializer for the individual array elements by pulling
  // out the array filler from all the nested initializer lists. This avoids
  // generating a nested loop for the initialization.
  while (Init && Init->getType()->isConstantArrayType()) {
41
←
Assuming 'Init' is null→
42
←
Loop condition is false. Execution continues on line 1138→
    auto *SubILE = dyn_cast<InitListExpr>(Init);
    if (!SubILE)
      break;
    assert(SubILE->getNumInits() == 0 && "explicit inits in array filler?")((void)0);
    Init = SubILE->getArrayFiller();
  }

  // Switch back to initializing one base element at a time.
  CurPtr = Builder.CreateBitCast(CurPtr, BeginPtr.getType());
}

// If all elements have already been initialized, skip any further
// initialization.
llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
if (ConstNum && ConstNum->getZExtValue() <= InitListElements) {
43
←
Assuming 'ConstNum' is null→
  // If there was a Cleanup, deactivate it.
  if (CleanupDominator)
    DeactivateCleanupBlock(Cleanup, CleanupDominator);
  return;
}

assert(Init && "have trailing elements to initialize but no initializer")((void)0);

// If this is a constructor call, try to optimize it out, and failing that
// emit a single loop to initialize all remaining elements.
if (const CXXConstructExpr *CCE = dyn_cast<CXXConstructExpr>(Init)) {
44
←
Assuming 'CCE' is non-null→
45
←
Taking true branch→
  CXXConstructorDecl *Ctor = CCE->getConstructor();
  if (Ctor->isTrivial()) {
46
←
Assuming the condition is false→
47
←
Taking false branch→
    // If new expression did not specify value-initialization, then there
    // is no initialization.
    if (!CCE->requiresZeroInitialization() || Ctor->getParent()->isEmpty())
      return;

    if (TryMemsetInitialization())
      return;
  }

  // Store the new Cleanup position for irregular Cleanups.
  //
  // FIXME: Share this cleanup with the constructor call emission rather than
  // having it create a cleanup of its own.
  if (EndOfInit.isValid())
48
←
Taking false branch→
    Builder.CreateStore(CurPtr.getPointer(), EndOfInit);

  // Emit a constructor call loop to initialize the remaining elements.
  if (InitListElements)
49
←
Assuming 'InitListElements' is not equal to 0→
50
←
Taking true branch→
    NumElements = Builder.CreateSub(
        NumElements,
        llvm::ConstantInt::get(NumElements->getType(), InitListElements));
51
←
Called C++ object pointer is null
  EmitCXXAggrConstructorCall(Ctor, NumElements, CurPtr, CCE,
                             /*NewPointerIsChecked*/true,
                             CCE->requiresZeroInitialization());
  return;
}

// If this is value-initialization, we can usually use memset.
ImplicitValueInitExpr IVIE(ElementType);
if (isa<ImplicitValueInitExpr>(Init)) {
  if (TryMemsetInitialization())
    return;

  // Switch to an ImplicitValueInitExpr for the element type. This handles
  // only one case: multidimensional array new of pointers to members. In
  // all other cases, we already have an initializer for the array element.
  Init = &IVIE;
}

// At this point we should have found an initializer for the individual
// elements of the array.
assert(getContext().hasSameUnqualifiedType(ElementType, Init->getType()) &&((void)0)
       "got wrong type of element to initialize")((void)0);

// If we have an empty initializer list, we can usually use memset.
if (auto *ILE = dyn_cast<InitListExpr>(Init))
  if (ILE->getNumInits() == 0 && TryMemsetInitialization())
    return;

// If we have a struct whose every field is value-initialized, we can
// usually use memset.
if (auto *ILE = dyn_cast<InitListExpr>(Init)) {
  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
    if (RType->getDecl()->isStruct()) {
      unsigned NumElements = 0;
      if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RType->getDecl()))
        NumElements = CXXRD->getNumBases();
      for (auto *Field : RType->getDecl()->fields())
        if (!Field->isUnnamedBitfield())
          ++NumElements;
      // FIXME: Recurse into nested InitListExprs.
      if (ILE->getNumInits() == NumElements)
        for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
          if (!isa<ImplicitValueInitExpr>(ILE->getInit(i)))
            --NumElements;
      if (ILE->getNumInits() == NumElements && TryMemsetInitialization())
        return;
    }
  }
}

// Create the loop blocks.
llvm::BasicBlock *EntryBB = Builder.GetInsertBlock();
llvm::BasicBlock *LoopBB = createBasicBlock("new.loop");
llvm::BasicBlock *ContBB = createBasicBlock("new.loop.end");

// Find the end of the array, hoisted out of the loop.
llvm::Value *EndPtr =
  Builder.CreateInBoundsGEP(BeginPtr.getElementType(), BeginPtr.getPointer(),
                            NumElements, "array.end");

// If the number of elements isn't constant, we have to now check if there is
// anything left to initialize.
if (!ConstNum) {
  llvm::Value *IsEmpty =
    Builder.CreateICmpEQ(CurPtr.getPointer(), EndPtr, "array.isempty");
  Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
}

// Enter the loop.
EmitBlock(LoopBB);

// Set up the current-element phi.
llvm::PHINode *CurPtrPhi =
  Builder.CreatePHI(CurPtr.getType(), 2, "array.cur");
CurPtrPhi->addIncoming(CurPtr.getPointer(), EntryBB);

CurPtr = Address(CurPtrPhi, ElementAlign);

// Store the new Cleanup position for irregular Cleanups.
if (EndOfInit.isValid())
  Builder.CreateStore(CurPtr.getPointer(), EndOfInit);

// Enter a partial-destruction Cleanup if necessary.
if (!CleanupDominator && needsEHCleanup(DtorKind)) {
  pushRegularPartialArrayCleanup(BeginPtr.getPointer(), CurPtr.getPointer(),
                                 ElementType, ElementAlign,
                                 getDestroyer(DtorKind));
  Cleanup = EHStack.stable_begin();
  CleanupDominator = Builder.CreateUnreachable();
}

// Emit the initializer into this element.
StoreAnyExprIntoOneUnit(*this, Init, Init->getType(), CurPtr,
                        AggValueSlot::DoesNotOverlap);

// Leave the Cleanup if we entered one.
if (CleanupDominator) {
  DeactivateCleanupBlock(Cleanup, CleanupDominator);
  CleanupDominator->eraseFromParent();
}

// Advance to the next element by adjusting the pointer type as necessary.
llvm::Value *NextPtr =
  Builder.CreateConstInBoundsGEP1_32(ElementTy, CurPtr.getPointer(), 1,
                                     "array.next");

// Check whether we've gotten to the end of the array and, if so,
// exit the loop.
llvm::Value *IsEnd = Builder.CreateICmpEQ(NextPtr, EndPtr, "array.atend");
Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
CurPtrPhi->addIncoming(NextPtr, Builder.GetInsertBlock());

EmitBlock(ContBB);
1292}

1294static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
                             QualType ElementType, llvm::Type *ElementTy,
                             Address NewPtr, llvm::Value *NumElements,
                             llvm::Value *AllocSizeWithoutCookie) {
ApplyDebugLocation DL(CGF, E);
if (E->isArray())
23
←
Assuming the condition is true→
24
←
Taking true branch→
  CGF.EmitNewArrayInitializer(E, ElementType, ElementTy, NewPtr, NumElements,
25
←
Passing null pointer value via 5th parameter 'NumElements'→
26
←
Calling 'CodeGenFunction::EmitNewArrayInitializer'→
                              AllocSizeWithoutCookie);
else if (const Expr *Init = E->getInitializer())
  StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(), NewPtr,
                          AggValueSlot::DoesNotOverlap);
1305}

1307/// Emit a call to an operator new or operator delete function, as implicitly
1308/// created by new-expressions and delete-expressions.
1309static RValue EmitNewDeleteCall(CodeGenFunction &CGF,
                              const FunctionDecl *CalleeDecl,
                              const FunctionProtoType *CalleeType,
                              const CallArgList &Args) {
llvm::CallBase *CallOrInvoke;
llvm::Constant *CalleePtr = CGF.CGM.GetAddrOfFunction(CalleeDecl);
CGCallee Callee = CGCallee::forDirect(CalleePtr, GlobalDecl(CalleeDecl));
RValue RV =
    CGF.EmitCall(CGF.CGM.getTypes().arrangeFreeFunctionCall(
                     Args, CalleeType, /*ChainCall=*/false),
                 Callee, ReturnValueSlot(), Args, &CallOrInvoke);

/// C++1y [expr.new]p10:
///   [In a new-expression,] an implementation is allowed to omit a call
///   to a replaceable global allocation function.
///
/// We model such elidable calls with the 'builtin' attribute.
llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
if (CalleeDecl->isReplaceableGlobalAllocationFunction() &&
    Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
  CallOrInvoke->addAttribute(llvm::AttributeList::FunctionIndex,
                             llvm::Attribute::Builtin);
}

return RV;
1334}

1336RValue CodeGenFunction::EmitBuiltinNewDeleteCall(const FunctionProtoType *Type,
                                               const CallExpr *TheCall,
                                               bool IsDelete) {
CallArgList Args;
EmitCallArgs(Args, Type, TheCall->arguments());
// Find the allocation or deallocation function that we're calling.
ASTContext &Ctx = getContext();
DeclarationName Name = Ctx.DeclarationNames
    .getCXXOperatorName(IsDelete ? OO_Delete : OO_New);

for (auto *Decl : Ctx.getTranslationUnitDecl()->lookup(Name))
  if (auto *FD = dyn_cast<FunctionDecl>(Decl))
    if (Ctx.hasSameType(FD->getType(), QualType(Type, 0)))
      return EmitNewDeleteCall(*this, FD, Type, Args);
llvm_unreachable("predeclared global operator new/delete is missing")__builtin_unreachable();
1351}

1353namespace {
1354/// The parameters to pass to a usual operator delete.
1355struct UsualDeleteParams {
bool DestroyingDelete = false;
bool Size = false;
bool Alignment = false;
1359};
1360}

1362static UsualDeleteParams getUsualDeleteParams(const FunctionDecl *FD) {
UsualDeleteParams Params;

const FunctionProtoType *FPT = FD->getType()->castAs<FunctionProtoType>();
auto AI = FPT->param_type_begin(), AE = FPT->param_type_end();

// The first argument is always a void*.
++AI;

// The next parameter may be a std::destroying_delete_t.
if (FD->isDestroyingOperatorDelete()) {
  Params.DestroyingDelete = true;
  assert(AI != AE)((void)0);
  ++AI;
}

// Figure out what other parameters we should be implicitly passing.
if (AI != AE && (*AI)->isIntegerType()) {
  Params.Size = true;
  ++AI;
}

if (AI != AE && (*AI)->isAlignValT()) {
  Params.Alignment = true;
  ++AI;
}

assert(AI == AE && "unexpected usual deallocation function parameter")((void)0);
return Params;
1391}

1393namespace {
/// A cleanup to call the given 'operator delete' function upon abnormal
/// exit from a new expression. Templated on a traits type that deals with
/// ensuring that the arguments dominate the cleanup if necessary.
template<typename Traits>
class CallDeleteDuringNew final : public EHScopeStack::Cleanup {
  /// Type used to hold llvm::Value*s.
  typedef typename Traits::ValueTy ValueTy;
  /// Type used to hold RValues.
  typedef typename Traits::RValueTy RValueTy;
  struct PlacementArg {
    RValueTy ArgValue;
    QualType ArgType;
  };

  unsigned NumPlacementArgs : 31;
  unsigned PassAlignmentToPlacementDelete : 1;
  const FunctionDecl *OperatorDelete;
  ValueTy Ptr;
  ValueTy AllocSize;
  CharUnits AllocAlign;

  PlacementArg *getPlacementArgs() {
    return reinterpret_cast<PlacementArg *>(this + 1);
  }

public:
  static size_t getExtraSize(size_t NumPlacementArgs) {
    return NumPlacementArgs * sizeof(PlacementArg);
  }

  CallDeleteDuringNew(size_t NumPlacementArgs,
                      const FunctionDecl *OperatorDelete, ValueTy Ptr,
                      ValueTy AllocSize, bool PassAlignmentToPlacementDelete,
                      CharUnits AllocAlign)
    : NumPlacementArgs(NumPlacementArgs),
      PassAlignmentToPlacementDelete(PassAlignmentToPlacementDelete),
      OperatorDelete(OperatorDelete), Ptr(Ptr), AllocSize(AllocSize),
      AllocAlign(AllocAlign) {}

  void setPlacementArg(unsigned I, RValueTy Arg, QualType Type) {
    assert(I < NumPlacementArgs && "index out of range")((void)0);
    getPlacementArgs()[I] = {Arg, Type};
  }

  void Emit(CodeGenFunction &CGF, Flags flags) override {
    const auto *FPT = OperatorDelete->getType()->castAs<FunctionProtoType>();
    CallArgList DeleteArgs;

    // The first argument is always a void* (or C* for a destroying operator
    // delete for class type C).
    DeleteArgs.add(Traits::get(CGF, Ptr), FPT->getParamType(0));

    // Figure out what other parameters we should be implicitly passing.
    UsualDeleteParams Params;
    if (NumPlacementArgs) {
      // A placement deallocation function is implicitly passed an alignment
      // if the placement allocation function was, but is never passed a size.
      Params.Alignment = PassAlignmentToPlacementDelete;
    } else {
      // For a non-placement new-expression, 'operator delete' can take a
      // size and/or an alignment if it has the right parameters.
      Params = getUsualDeleteParams(OperatorDelete);
    }

    assert(!Params.DestroyingDelete &&((void)0)
           "should not call destroying delete in a new-expression")((void)0);

    // The second argument can be a std::size_t (for non-placement delete).
    if (Params.Size)
      DeleteArgs.add(Traits::get(CGF, AllocSize),
                     CGF.getContext().getSizeType());

    // The next (second or third) argument can be a std::align_val_t, which
    // is an enum whose underlying type is std::size_t.
    // FIXME: Use the right type as the parameter type. Note that in a call
    // to operator delete(size_t, ...), we may not have it available.
    if (Params.Alignment)
      DeleteArgs.add(RValue::get(llvm::ConstantInt::get(
                         CGF.SizeTy, AllocAlign.getQuantity())),
                     CGF.getContext().getSizeType());

    // Pass the rest of the arguments, which must match exactly.
    for (unsigned I = 0; I != NumPlacementArgs; ++I) {
      auto Arg = getPlacementArgs()[I];
      DeleteArgs.add(Traits::get(CGF, Arg.ArgValue), Arg.ArgType);
    }

    // Call 'operator delete'.
    EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
  }
};
1485}

1487/// Enter a cleanup to call 'operator delete' if the initializer in a
1488/// new-expression throws.
1489static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
                                const CXXNewExpr *E,
                                Address NewPtr,
                                llvm::Value *AllocSize,
                                CharUnits AllocAlign,
                                const CallArgList &NewArgs) {
unsigned NumNonPlacementArgs = E->passAlignment() ? 2 : 1;

// If we're not inside a conditional branch, then the cleanup will
// dominate and we can do the easier (and more efficient) thing.
if (!CGF.isInConditionalBranch()) {
  struct DirectCleanupTraits {
    typedef llvm::Value *ValueTy;
    typedef RValue RValueTy;
    static RValue get(CodeGenFunction &, ValueTy V) { return RValue::get(V); }
    static RValue get(CodeGenFunction &, RValueTy V) { return V; }
  };

  typedef CallDeleteDuringNew<DirectCleanupTraits> DirectCleanup;

  DirectCleanup *Cleanup = CGF.EHStack
    .pushCleanupWithExtra<DirectCleanup>(EHCleanup,
                                         E->getNumPlacementArgs(),
                                         E->getOperatorDelete(),
                                         NewPtr.getPointer(),
                                         AllocSize,
                                         E->passAlignment(),
                                         AllocAlign);
  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
    auto &Arg = NewArgs[I + NumNonPlacementArgs];
    Cleanup->setPlacementArg(I, Arg.getRValue(CGF), Arg.Ty);
  }

  return;
}

// Otherwise, we need to save all this stuff.
DominatingValue<RValue>::saved_type SavedNewPtr =
  DominatingValue<RValue>::save(CGF, RValue::get(NewPtr.getPointer()));
DominatingValue<RValue>::saved_type SavedAllocSize =
  DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));

struct ConditionalCleanupTraits {
  typedef DominatingValue<RValue>::saved_type ValueTy;
  typedef DominatingValue<RValue>::saved_type RValueTy;
  static RValue get(CodeGenFunction &CGF, ValueTy V) {
    return V.restore(CGF);
  }
};
typedef CallDeleteDuringNew<ConditionalCleanupTraits> ConditionalCleanup;

ConditionalCleanup *Cleanup = CGF.EHStack
  .pushCleanupWithExtra<ConditionalCleanup>(EHCleanup,
                                            E->getNumPlacementArgs(),
                                            E->getOperatorDelete(),
                                            SavedNewPtr,
                                            SavedAllocSize,
                                            E->passAlignment(),
                                            AllocAlign);
for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I) {
  auto &Arg = NewArgs[I + NumNonPlacementArgs];
  Cleanup->setPlacementArg(
      I, DominatingValue<RValue>::save(CGF, Arg.getRValue(CGF)), Arg.Ty);
}

CGF.initFullExprCleanup();
1555}

1557llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
// The element type being allocated.
QualType allocType = getContext().getBaseElementType(E->getAllocatedType());

// 1. Build a call to the allocation function.
FunctionDecl *allocator = E->getOperatorNew();

// If there is a brace-initializer, cannot allocate fewer elements than inits.
unsigned minElements = 0;
if (E->isArray() && E->hasInitializer()) {
1
Assuming the condition is false→
  const InitListExpr *ILE = dyn_cast<InitListExpr>(E->getInitializer());
  if (ILE && ILE->isStringLiteralInit())
    minElements =
        cast<ConstantArrayType>(ILE->getType()->getAsArrayTypeUnsafe())
            ->getSize().getZExtValue();
  else if (ILE)
    minElements = ILE->getNumInits();
}

llvm::Value *numElements = nullptr;
2
←
'numElements' initialized to a null pointer value→
llvm::Value *allocSizeWithoutCookie = nullptr;
llvm::Value *allocSize =
  EmitCXXNewAllocSize(*this, E, minElements, numElements,
3
←
Calling 'EmitCXXNewAllocSize'→
6
←
Returning from 'EmitCXXNewAllocSize'→
                      allocSizeWithoutCookie);
CharUnits allocAlign = getContext().getPreferredTypeAlignInChars(allocType);

// Emit the allocation call.  If the allocator is a global placement
// operator, just "inline" it directly.
Address allocation = Address::invalid();
CallArgList allocatorArgs;
if (allocator->isReservedGlobalPlacementOperator()) {
7
←
Assuming the condition is false→
8
←
Taking false branch→
  assert(E->getNumPlacementArgs() == 1)((void)0);
  const Expr *arg = *E->placement_arguments().begin();

  LValueBaseInfo BaseInfo;
  allocation = EmitPointerWithAlignment(arg, &BaseInfo);

  // The pointer expression will, in many cases, be an opaque void*.
  // In these cases, discard the computed alignment and use the
  // formal alignment of the allocated type.
  if (BaseInfo.getAlignmentSource() != AlignmentSource::Decl)
    allocation = Address(allocation.getPointer(), allocAlign);

  // Set up allocatorArgs for the call to operator delete if it's not
  // the reserved global operator.
  if (E->getOperatorDelete() &&
      !E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
    allocatorArgs.add(RValue::get(allocSize), getContext().getSizeType());
    allocatorArgs.add(RValue::get(allocation.getPointer()), arg->getType());
  }

} else {
  const FunctionProtoType *allocatorType =
    allocator->getType()->castAs<FunctionProtoType>();
9
←
The object is a 'FunctionProtoType'→
  unsigned ParamsToSkip = 0;

  // The allocation size is the first argument.
  QualType sizeType = getContext().getSizeType();
  allocatorArgs.add(RValue::get(allocSize), sizeType);
  ++ParamsToSkip;

  if (allocSize9.1
'allocSize' is equal to 'allocSizeWithoutCookie'
1
'allocSize' is equal to 'allocSizeWithoutCookie'
 != allocSizeWithoutCookie) {
10
←
Taking false branch→
    CharUnits cookieAlign = getSizeAlign(); // FIXME: Ask the ABI.
    allocAlign = std::max(allocAlign, cookieAlign);
  }

  // The allocation alignment may be passed as the second argument.
  if (E->passAlignment()) {
11
←
Assuming the condition is false→
12
←
Taking false branch→
    QualType AlignValT = sizeType;
    if (allocatorType->getNumParams() > 1) {
      AlignValT = allocatorType->getParamType(1);
      assert(getContext().hasSameUnqualifiedType(((void)0)
                 AlignValT->castAs<EnumType>()->getDecl()->getIntegerType(),((void)0)
                 sizeType) &&((void)0)
             "wrong type for alignment parameter")((void)0);
      ++ParamsToSkip;
    } else {
      // Corner case, passing alignment to 'operator new(size_t, ...)'.
      assert(allocator->isVariadic() && "can't pass alignment to allocator")((void)0);
    }
    allocatorArgs.add(
        RValue::get(llvm::ConstantInt::get(SizeTy, allocAlign.getQuantity())),
        AlignValT);
  }

  // FIXME: Why do we not pass a CalleeDecl here?
  EmitCallArgs(allocatorArgs, allocatorType, E->placement_arguments(),
               /*AC*/AbstractCallee(), /*ParamsToSkip*/ParamsToSkip);

  RValue RV =
    EmitNewDeleteCall(*this, allocator, allocatorType, allocatorArgs);

  // Set !heapallocsite metadata on the call to operator new.
  if (getDebugInfo())
13
←
Assuming the condition is false→
14
←
Taking false branch→
    if (auto *newCall = dyn_cast<llvm::CallBase>(RV.getScalarVal()))
      getDebugInfo()->addHeapAllocSiteMetadata(newCall, allocType,
                                               E->getExprLoc());

  // If this was a call to a global replaceable allocation function that does
  // not take an alignment argument, the allocator is known to produce
  // storage that's suitably aligned for any object that fits, up to a known
  // threshold. Otherwise assume it's suitably aligned for the allocated type.
  CharUnits allocationAlign = allocAlign;
  if (!E->passAlignment() &&
15
←
Assuming the condition is false→
      allocator->isReplaceableGlobalAllocationFunction()) {
    unsigned AllocatorAlign = llvm::PowerOf2Floor(std::min<uint64_t>(
        Target.getNewAlign(), getContext().getTypeSize(allocType)));
    allocationAlign = std::max(
        allocationAlign, getContext().toCharUnitsFromBits(AllocatorAlign));
  }

  allocation = Address(RV.getScalarVal(), allocationAlign);
}

// Emit a null check on the allocation result if the allocation
// function is allowed to return null (because it has a non-throwing
// exception spec or is the reserved placement new) and we have an
// interesting initializer will be running sanitizers on the initialization.
bool nullCheck = E->shouldNullCheckAllocation() &&
16
←
Assuming the condition is false→
                 (!allocType.isPODType(getContext()) || E->hasInitializer() ||
                  sanitizePerformTypeCheck());

llvm::BasicBlock *nullCheckBB = nullptr;
llvm::BasicBlock *contBB = nullptr;

// The null-check means that the initializer is conditionally
// evaluated.
ConditionalEvaluation conditional(*this);

if (nullCheck16.1
'nullCheck' is false
1
'nullCheck' is false
) {
17
←
Taking false branch→
  conditional.begin(*this);

  nullCheckBB = Builder.GetInsertBlock();
  llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull");
  contBB = createBasicBlock("new.cont");

  llvm::Value *isNull =
    Builder.CreateIsNull(allocation.getPointer(), "new.isnull");
  Builder.CreateCondBr(isNull, contBB, notNullBB);
  EmitBlock(notNullBB);
}

// If there's an operator delete, enter a cleanup to call it if an
// exception is thrown.
EHScopeStack::stable_iterator operatorDeleteCleanup;
llvm::Instruction *cleanupDominator = nullptr;
if (E->getOperatorDelete() &&
18
←
Assuming the condition is false→
    !E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
  EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocAlign,
                        allocatorArgs);
  operatorDeleteCleanup = EHStack.stable_begin();
  cleanupDominator = Builder.CreateUnreachable();
}

assert((allocSize == allocSizeWithoutCookie) ==((void)0)
       CalculateCookiePadding(*this, E).isZero())((void)0);
if (allocSize18.1
'allocSize' is equal to 'allocSizeWithoutCookie'
1
'allocSize' is equal to 'allocSizeWithoutCookie'
 != allocSizeWithoutCookie) {
19
←
Taking false branch→
  assert(E->isArray())((void)0);
  allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation,
                                                     numElements,
                                                     E, allocType);
}

llvm::Type *elementTy = ConvertTypeForMem(allocType);
Address result = Builder.CreateElementBitCast(allocation, elementTy);

// Passing pointer through launder.invariant.group to avoid propagation of
// vptrs information which may be included in previous type.
// To not break LTO with different optimizations levels, we do it regardless
// of optimization level.
if (CGM.getCodeGenOpts().StrictVTablePointers &&
20
←
Assuming field 'StrictVTablePointers' is 0→
    allocator->isReservedGlobalPlacementOperator())
  result = Address(Builder.CreateLaunderInvariantGroup(result.getPointer()),
                   result.getAlignment());

// Emit sanitizer checks for pointer value now, so that in the case of an
// array it was checked only once and not at each constructor call. We may
// have already checked that the pointer is non-null.
// FIXME: If we have an array cookie and a potentially-throwing allocator,
// we'll null check the wrong pointer here.
SanitizerSet SkippedChecks;
SkippedChecks.set(SanitizerKind::Null, nullCheck);
EmitTypeCheck(CodeGenFunction::TCK_ConstructorCall,
              E->getAllocatedTypeSourceInfo()->getTypeLoc().getBeginLoc(),
              result.getPointer(), allocType, result.getAlignment(),
              SkippedChecks, numElements);

EmitNewInitializer(*this, E, allocType, elementTy, result, numElements,
21
←
Passing null pointer value via 6th parameter 'NumElements'→
22
←
Calling 'EmitNewInitializer'→
                   allocSizeWithoutCookie);
if (E->isArray()) {
  // NewPtr is a pointer to the base element type.  If we're
  // allocating an array of arrays, we'll need to cast back to the
  // array pointer type.
  llvm::Type *resultType = ConvertTypeForMem(E->getType());
  if (result.getType() != resultType)
    result = Builder.CreateBitCast(result, resultType);
}

// Deactivate the 'operator delete' cleanup if we finished
// initialization.
if (operatorDeleteCleanup.isValid()) {
  DeactivateCleanupBlock(operatorDeleteCleanup, cleanupDominator);
  cleanupDominator->eraseFromParent();
}

llvm::Value *resultPtr = result.getPointer();
if (nullCheck) {
  conditional.end(*this);

  llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
  EmitBlock(contBB);

  llvm::PHINode *PHI = Builder.CreatePHI(resultPtr->getType(), 2);
  PHI->addIncoming(resultPtr, notNullBB);
  PHI->addIncoming(llvm::Constant::getNullValue(resultPtr->getType()),
                   nullCheckBB);

  resultPtr = PHI;
}

return resultPtr;
1778}

1780void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
                                   llvm::Value *Ptr, QualType DeleteTy,
                                   llvm::Value *NumElements,
                                   CharUnits CookieSize) {
assert((!NumElements && CookieSize.isZero()) ||((void)0)
       DeleteFD->getOverloadedOperator() == OO_Array_Delete)((void)0);

const auto *DeleteFTy = DeleteFD->getType()->castAs<FunctionProtoType>();
CallArgList DeleteArgs;

auto Params = getUsualDeleteParams(DeleteFD);
auto ParamTypeIt = DeleteFTy->param_type_begin();

// Pass the pointer itself.
QualType ArgTy = *ParamTypeIt++;
llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
DeleteArgs.add(RValue::get(DeletePtr), ArgTy);

// Pass the std::destroying_delete tag if present.
llvm::AllocaInst *DestroyingDeleteTag = nullptr;
if (Params.DestroyingDelete) {
  QualType DDTag = *ParamTypeIt++;
  llvm::Type *Ty = getTypes().ConvertType(DDTag);
  CharUnits Align = CGM.getNaturalTypeAlignment(DDTag);
  DestroyingDeleteTag = CreateTempAlloca(Ty, "destroying.delete.tag");
  DestroyingDeleteTag->setAlignment(Align.getAsAlign());
  DeleteArgs.add(RValue::getAggregate(Address(DestroyingDeleteTag, Align)), DDTag);
}

// Pass the size if the delete function has a size_t parameter.
if (Params.Size) {
  QualType SizeType = *ParamTypeIt++;
  CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
  llvm::Value *Size = llvm::ConstantInt::get(ConvertType(SizeType),
                                             DeleteTypeSize.getQuantity());

  // For array new, multiply by the number of elements.
  if (NumElements)
    Size = Builder.CreateMul(Size, NumElements);

  // If there is a cookie, add the cookie size.
  if (!CookieSize.isZero())
    Size = Builder.CreateAdd(
        Size, llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity()));

  DeleteArgs.add(RValue::get(Size), SizeType);
}

// Pass the alignment if the delete function has an align_val_t parameter.
if (Params.Alignment) {
  QualType AlignValType = *ParamTypeIt++;
  CharUnits DeleteTypeAlign =
      getContext().toCharUnitsFromBits(getContext().getTypeAlignIfKnown(
          DeleteTy, true /* NeedsPreferredAlignment */));
  llvm::Value *Align = llvm::ConstantInt::get(ConvertType(AlignValType),
                                              DeleteTypeAlign.getQuantity());
  DeleteArgs.add(RValue::get(Align), AlignValType);
}

assert(ParamTypeIt == DeleteFTy->param_type_end() &&((void)0)
       "unknown parameter to usual delete function")((void)0);

// Emit the call to delete.
EmitNewDeleteCall(*this, DeleteFD, DeleteFTy, DeleteArgs);

// If call argument lowering didn't use the destroying_delete_t alloca,
// remove it again.
if (DestroyingDeleteTag && DestroyingDeleteTag->use_empty())
  DestroyingDeleteTag->eraseFromParent();
1849}

1851namespace {
/// Calls the given 'operator delete' on a single object.
struct CallObjectDelete final : EHScopeStack::Cleanup {
  llvm::Value *Ptr;
  const FunctionDecl *OperatorDelete;
  QualType ElementType;

  CallObjectDelete(llvm::Value *Ptr,
                   const FunctionDecl *OperatorDelete,
                   QualType ElementType)
    : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}

  void Emit(CodeGenFunction &CGF, Flags flags) override {
    CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
  }
};
1867}

1869void
1870CodeGenFunction::pushCallObjectDeleteCleanup(const FunctionDecl *OperatorDelete,
                                           llvm::Value *CompletePtr,
                                           QualType ElementType) {
EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup, CompletePtr,
                                      OperatorDelete, ElementType);
1875}

1877/// Emit the code for deleting a single object with a destroying operator
1878/// delete. If the element type has a non-virtual destructor, Ptr has already
1879/// been converted to the type of the parameter of 'operator delete'. Otherwise
1880/// Ptr points to an object of the static type.
1881static void EmitDestroyingObjectDelete(CodeGenFunction &CGF,
                                     const CXXDeleteExpr *DE, Address Ptr,
                                     QualType ElementType) {
auto *Dtor = ElementType->getAsCXXRecordDecl()->getDestructor();
if (Dtor && Dtor->isVirtual())
  CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
                                              Dtor);
else
  CGF.EmitDeleteCall(DE->getOperatorDelete(), Ptr.getPointer(), ElementType);
1890}

1892/// Emit the code for deleting a single object.
1893/// \return \c true if we started emitting UnconditionalDeleteBlock, \c false
1894/// if not.
1895static bool EmitObjectDelete(CodeGenFunction &CGF,
                           const CXXDeleteExpr *DE,
                           Address Ptr,
                           QualType ElementType,
                           llvm::BasicBlock *UnconditionalDeleteBlock) {
// C++11 [expr.delete]p3:
//   If the static type of the object to be deleted is different from its
//   dynamic type, the static type shall be a base class of the dynamic type
//   of the object to be deleted and the static type shall have a virtual
//   destructor or the behavior is undefined.
CGF.EmitTypeCheck(CodeGenFunction::TCK_MemberCall,
                  DE->getExprLoc(), Ptr.getPointer(),
                  ElementType);

const FunctionDecl *OperatorDelete = DE->getOperatorDelete();
assert(!OperatorDelete->isDestroyingOperatorDelete())((void)0);

// Find the destructor for the type, if applicable.  If the
// destructor is virtual, we'll just emit the vcall and return.
const CXXDestructorDecl *Dtor = nullptr;
if (const RecordType *RT = ElementType->getAs<RecordType>()) {
  CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
  if (RD->hasDefinition() && !RD->hasTrivialDestructor()) {
    Dtor = RD->getDestructor();

    if (Dtor->isVirtual()) {
      bool UseVirtualCall = true;
      const Expr *Base = DE->getArgument();
      if (auto *DevirtualizedDtor =
              dyn_cast_or_null<const CXXDestructorDecl>(
                  Dtor->getDevirtualizedMethod(
                      Base, CGF.CGM.getLangOpts().AppleKext))) {
        UseVirtualCall = false;
        const CXXRecordDecl *DevirtualizedClass =
            DevirtualizedDtor->getParent();
        if (declaresSameEntity(getCXXRecord(Base), DevirtualizedClass)) {
          // Devirtualized to the class of the base type (the type of the
          // whole expression).
          Dtor = DevirtualizedDtor;
        } else {
          // Devirtualized to some other type. Would need to cast the this
          // pointer to that type but we don't have support for that yet, so
          // do a virtual call. FIXME: handle the case where it is
          // devirtualized to the derived type (the type of the inner
          // expression) as in EmitCXXMemberOrOperatorMemberCallExpr.
          UseVirtualCall = true;
        }
      }
      if (UseVirtualCall) {
        CGF.CGM.getCXXABI().emitVirtualObjectDelete(CGF, DE, Ptr, ElementType,
                                                    Dtor);
        return false;
      }
    }
  }
}

// Make sure that we call delete even if the dtor throws.
// This doesn't have to a conditional cleanup because we're going
// to pop it off in a second.
CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
                                          Ptr.getPointer(),
                                          OperatorDelete, ElementType);

if (Dtor)
  CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
                            /*ForVirtualBase=*/false,
                            /*Delegating=*/false,
                            Ptr, ElementType);
else if (auto Lifetime = ElementType.getObjCLifetime()) {
  switch (Lifetime) {
  case Qualifiers::OCL_None:
  case Qualifiers::OCL_ExplicitNone:
  case Qualifiers::OCL_Autoreleasing:
    break;

  case Qualifiers::OCL_Strong:
    CGF.EmitARCDestroyStrong(Ptr, ARCPreciseLifetime);
    break;

  case Qualifiers::OCL_Weak:
    CGF.EmitARCDestroyWeak(Ptr);
    break;
  }
}

// When optimizing for size, call 'operator delete' unconditionally.
if (CGF.CGM.getCodeGenOpts().OptimizeSize > 1) {
  CGF.EmitBlock(UnconditionalDeleteBlock);
  CGF.PopCleanupBlock();
  return true;
}

CGF.PopCleanupBlock();
return false;
1990}

1992namespace {
/// Calls the given 'operator delete' on an array of objects.
struct CallArrayDelete final : EHScopeStack::Cleanup {
  llvm::Value *Ptr;
  const FunctionDecl *OperatorDelete;
  llvm::Value *NumElements;
  QualType ElementType;
  CharUnits CookieSize;

  CallArrayDelete(llvm::Value *Ptr,
                  const FunctionDecl *OperatorDelete,
                  llvm::Value *NumElements,
                  QualType ElementType,
                  CharUnits CookieSize)
    : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
      ElementType(ElementType), CookieSize(CookieSize) {}

  void Emit(CodeGenFunction &CGF, Flags flags) override {
    CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType, NumElements,
                       CookieSize);
  }
};
2014}

2016/// Emit the code for deleting an array of objects.
2017static void EmitArrayDelete(CodeGenFunction &CGF,
                          const CXXDeleteExpr *E,
                          Address deletedPtr,
                          QualType elementType) {
llvm::Value *numElements = nullptr;
llvm::Value *allocatedPtr = nullptr;
CharUnits cookieSize;
CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
                                    numElements, allocatedPtr, cookieSize);

assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer")((void)0);

// Make sure that we call delete even if one of the dtors throws.
const FunctionDecl *operatorDelete = E->getOperatorDelete();
CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
                                         allocatedPtr, operatorDelete,
                                         numElements, elementType,
                                         cookieSize);

// Destroy the elements.
if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) {
  assert(numElements && "no element count for a type with a destructor!")((void)0);

  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
  CharUnits elementAlign =
    deletedPtr.getAlignment().alignmentOfArrayElement(elementSize);

  llvm::Value *arrayBegin = deletedPtr.getPointer();
  llvm::Value *arrayEnd = CGF.Builder.CreateInBoundsGEP(
    deletedPtr.getElementType(), arrayBegin, numElements, "delete.end");

  // Note that it is legal to allocate a zero-length array, and we
  // can never fold the check away because the length should always
  // come from a cookie.
  CGF.emitArrayDestroy(arrayBegin, arrayEnd, elementType, elementAlign,
                       CGF.getDestroyer(dtorKind),
                       /*checkZeroLength*/ true,
                       CGF.needsEHCleanup(dtorKind));
}

// Pop the cleanup block.
CGF.PopCleanupBlock();
2059}

2061void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
const Expr *Arg = E->getArgument();
Address Ptr = EmitPointerWithAlignment(Arg);

// Null check the pointer.
//
// We could avoid this null check if we can determine that the object
// destruction is trivial and doesn't require an array cookie; we can
// unconditionally perform the operator delete call in that case. For now, we
// assume that deleted pointers are null rarely enough that it's better to
// keep the branch. This might be worth revisiting for a -O0 code size win.
llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");

llvm::Value *IsNull = Builder.CreateIsNull(Ptr.getPointer(), "isnull");

Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
EmitBlock(DeleteNotNull);

QualType DeleteTy = E->getDestroyedType();

// A destroying operator delete overrides the entire operation of the
// delete expression.
if (E->getOperatorDelete()->isDestroyingOperatorDelete()) {
  EmitDestroyingObjectDelete(*this, E, Ptr, DeleteTy);
  EmitBlock(DeleteEnd);
  return;
}

// We might be deleting a pointer to array.  If so, GEP down to the
// first non-array element.
// (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*)
if (DeleteTy->isConstantArrayType()) {
  llvm::Value *Zero = Builder.getInt32(0);
  SmallVector<llvm::Value*,8> GEP;

  GEP.push_back(Zero); // point at the outermost array

  // For each layer of array type we're pointing at:
  while (const ConstantArrayType *Arr
           = getContext().getAsConstantArrayType(DeleteTy)) {
    // 1. Unpeel the array type.
    DeleteTy = Arr->getElementType();

    // 2. GEP to the first element of the array.
    GEP.push_back(Zero);
  }

  Ptr = Address(Builder.CreateInBoundsGEP(Ptr.getElementType(),
                                          Ptr.getPointer(), GEP, "del.first"),
                Ptr.getAlignment());
}

assert(ConvertTypeForMem(DeleteTy) == Ptr.getElementType())((void)0);

if (E->isArrayForm()) {
  EmitArrayDelete(*this, E, Ptr, DeleteTy);
  EmitBlock(DeleteEnd);
} else {
  if (!EmitObjectDelete(*this, E, Ptr, DeleteTy, DeleteEnd))
    EmitBlock(DeleteEnd);
}
2123}

2125static bool isGLValueFromPointerDeref(const Expr *E) {
E = E->IgnoreParens();

if (const auto *CE = dyn_cast<CastExpr>(E)) {
  if (!CE->getSubExpr()->isGLValue())
    return false;
  return isGLValueFromPointerDeref(CE->getSubExpr());
}

if (const auto *OVE = dyn_cast<OpaqueValueExpr>(E))
  return isGLValueFromPointerDeref(OVE->getSourceExpr());

if (const auto *BO = dyn_cast<BinaryOperator>(E))
  if (BO->getOpcode() == BO_Comma)
    return isGLValueFromPointerDeref(BO->getRHS());

if (const auto *ACO = dyn_cast<AbstractConditionalOperator>(E))
  return isGLValueFromPointerDeref(ACO->getTrueExpr()) ||
         isGLValueFromPointerDeref(ACO->getFalseExpr());

// C++11 [expr.sub]p1:
//   The expression E1[E2] is identical (by definition) to *((E1)+(E2))
if (isa<ArraySubscriptExpr>(E))
  return true;

if (const auto *UO = dyn_cast<UnaryOperator>(E))
  if (UO->getOpcode() == UO_Deref)
    return true;

return false;
2155}

2157static llvm::Value *EmitTypeidFromVTable(CodeGenFunction &CGF, const Expr *E,
                                       llvm::Type *StdTypeInfoPtrTy) {
// Get the vtable pointer.
Address ThisPtr = CGF.EmitLValue(E).getAddress(CGF);

QualType SrcRecordTy = E->getType();

// C++ [class.cdtor]p4:
//   If the operand of typeid refers to the object under construction or
//   destruction and the static type of the operand is neither the constructor
//   or destructor’s class nor one of its bases, the behavior is undefined.
CGF.EmitTypeCheck(CodeGenFunction::TCK_DynamicOperation, E->getExprLoc(),
                  ThisPtr.getPointer(), SrcRecordTy);

// C++ [expr.typeid]p2:
//   If the glvalue expression is obtained by applying the unary * operator to
//   a pointer and the pointer is a null pointer value, the typeid expression
//   throws the std::bad_typeid exception.
//
// However, this paragraph's intent is not clear.  We choose a very generous
// interpretation which implores us to consider comma operators, conditional
// operators, parentheses and other such constructs.
if (CGF.CGM.getCXXABI().shouldTypeidBeNullChecked(
        isGLValueFromPointerDeref(E), SrcRecordTy)) {
  llvm::BasicBlock *BadTypeidBlock =
      CGF.createBasicBlock("typeid.bad_typeid");
  llvm::BasicBlock *EndBlock = CGF.createBasicBlock("typeid.end");

  llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr.getPointer());
  CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);

  CGF.EmitBlock(BadTypeidBlock);
  CGF.CGM.getCXXABI().EmitBadTypeidCall(CGF);
  CGF.EmitBlock(EndBlock);
}

return CGF.CGM.getCXXABI().EmitTypeid(CGF, SrcRecordTy, ThisPtr,
                                      StdTypeInfoPtrTy);
2195}

2197llvm::Value *CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
llvm::Type *StdTypeInfoPtrTy =
  ConvertType(E->getType())->getPointerTo();

if (E->isTypeOperand()) {
  llvm::Constant *TypeInfo =
      CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand(getContext()));
  return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
}

// C++ [expr.typeid]p2:
//   When typeid is applied to a glvalue expression whose type is a
//   polymorphic class type, the result refers to a std::type_info object
//   representing the type of the most derived object (that is, the dynamic
//   type) to which the glvalue refers.
// If the operand is already most derived object, no need to look up vtable.
if (E->isPotentiallyEvaluated() && !E->isMostDerived(getContext()))
  return EmitTypeidFromVTable(*this, E->getExprOperand(),
                              StdTypeInfoPtrTy);

QualType OperandTy = E->getExprOperand()->getType();
return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
                             StdTypeInfoPtrTy);
2220}

2222static llvm::Value *EmitDynamicCastToNull(CodeGenFunction &CGF,
                                        QualType DestTy) {
llvm::Type *DestLTy = CGF.ConvertType(DestTy);
if (DestTy->isPointerType())
  return llvm::Constant::getNullValue(DestLTy);

/// C++ [expr.dynamic.cast]p9:
///   A failed cast to reference type throws std::bad_cast
if (!CGF.CGM.getCXXABI().EmitBadCastCall(CGF))
  return nullptr;

CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
return llvm::UndefValue::get(DestLTy);
2235}

2237llvm::Value *CodeGenFunction::EmitDynamicCast(Address ThisAddr,
                                            const CXXDynamicCastExpr *DCE) {
CGM.EmitExplicitCastExprType(DCE, this);
QualType DestTy = DCE->getTypeAsWritten();

QualType SrcTy = DCE->getSubExpr()->getType();

// C++ [expr.dynamic.cast]p7:
//   If T is "pointer to cv void," then the result is a pointer to the most
//   derived object pointed to by v.
const PointerType *DestPTy = DestTy->getAs<PointerType>();

bool isDynamicCastToVoid;
QualType SrcRecordTy;
QualType DestRecordTy;
if (DestPTy) {
  isDynamicCastToVoid = DestPTy->getPointeeType()->isVoidType();
  SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
  DestRecordTy = DestPTy->getPointeeType();
} else {
  isDynamicCastToVoid = false;
  SrcRecordTy = SrcTy;
  DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
}

// C++ [class.cdtor]p5:
//   If the operand of the dynamic_cast refers to the object under
//   construction or destruction and the static type of the operand is not a
//   pointer to or object of the constructor or destructor’s own class or one
//   of its bases, the dynamic_cast results in undefined behavior.
EmitTypeCheck(TCK_DynamicOperation, DCE->getExprLoc(), ThisAddr.getPointer(),
              SrcRecordTy);

if (DCE->isAlwaysNull())
  if (llvm::Value *T = EmitDynamicCastToNull(*this, DestTy))
    return T;

assert(SrcRecordTy->isRecordType() && "source type must be a record type!")((void)0);

// C++ [expr.dynamic.cast]p4:
//   If the value of v is a null pointer value in the pointer case, the result
//   is the null pointer value of type T.
bool ShouldNullCheckSrcValue =
    CGM.getCXXABI().shouldDynamicCastCallBeNullChecked(SrcTy->isPointerType(),
                                                       SrcRecordTy);

llvm::BasicBlock *CastNull = nullptr;
llvm::BasicBlock *CastNotNull = nullptr;
llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end");

if (ShouldNullCheckSrcValue) {
  CastNull = createBasicBlock("dynamic_cast.null");
  CastNotNull = createBasicBlock("dynamic_cast.notnull");

  llvm::Value *IsNull = Builder.CreateIsNull(ThisAddr.getPointer());
  Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
  EmitBlock(CastNotNull);
}

llvm::Value *Value;
if (isDynamicCastToVoid) {
  Value = CGM.getCXXABI().EmitDynamicCastToVoid(*this, ThisAddr, SrcRecordTy,
                                                DestTy);
} else {
  assert(DestRecordTy->isRecordType() &&((void)0)
         "destination type must be a record type!")((void)0);
  Value = CGM.getCXXABI().EmitDynamicCastCall(*this, ThisAddr, SrcRecordTy,
                                              DestTy, DestRecordTy, CastEnd);
  CastNotNull = Builder.GetInsertBlock();
}

if (ShouldNullCheckSrcValue) {
  EmitBranch(CastEnd);

  EmitBlock(CastNull);
  EmitBranch(CastEnd);
}

EmitBlock(CastEnd);

if (ShouldNullCheckSrcValue) {
  llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
  PHI->addIncoming(Value, CastNotNull);
  PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);

  Value = PHI;
}

return Value;
2326}

←

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include/clang/AST/ExprCXX.h

1//===- ExprCXX.h - Classes for representing expressions ---------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9/// \file
10/// Defines the clang::Expr interface and subclasses for C++ expressions.
11//
12//===----------------------------------------------------------------------===//

14#ifndef LLVM_CLANG_AST_EXPRCXX_H
15#define LLVM_CLANG_AST_EXPRCXX_H

17#include "clang/AST/ASTConcept.h"
18#include "clang/AST/ComputeDependence.h"
19#include "clang/AST/Decl.h"
20#include "clang/AST/DeclBase.h"
21#include "clang/AST/DeclCXX.h"
22#include "clang/AST/DeclTemplate.h"
23#include "clang/AST/DeclarationName.h"
24#include "clang/AST/DependenceFlags.h"
25#include "clang/AST/Expr.h"
26#include "clang/AST/NestedNameSpecifier.h"
27#include "clang/AST/OperationKinds.h"
28#include "clang/AST/Stmt.h"
29#include "clang/AST/StmtCXX.h"
30#include "clang/AST/TemplateBase.h"
31#include "clang/AST/Type.h"
32#include "clang/AST/UnresolvedSet.h"
33#include "clang/Basic/ExceptionSpecificationType.h"
34#include "clang/Basic/ExpressionTraits.h"
35#include "clang/Basic/LLVM.h"
36#include "clang/Basic/Lambda.h"
37#include "clang/Basic/LangOptions.h"
38#include "clang/Basic/OperatorKinds.h"
39#include "clang/Basic/SourceLocation.h"
40#include "clang/Basic/Specifiers.h"
41#include "clang/Basic/TypeTraits.h"
42#include "llvm/ADT/ArrayRef.h"
43#include "llvm/ADT/None.h"
44#include "llvm/ADT/Optional.h"
45#include "llvm/ADT/PointerUnion.h"
46#include "llvm/ADT/StringRef.h"
47#include "llvm/ADT/iterator_range.h"
48#include "llvm/Support/Casting.h"
49#include "llvm/Support/Compiler.h"
50#include "llvm/Support/TrailingObjects.h"
51#include <cassert>
52#include <cstddef>
53#include <cstdint>
54#include <memory>

56namespace clang {

58class ASTContext;
59class DeclAccessPair;
60class IdentifierInfo;
61class LambdaCapture;
62class NonTypeTemplateParmDecl;
63class TemplateParameterList;

65//===--------------------------------------------------------------------===//
66// C++ Expressions.
67//===--------------------------------------------------------------------===//

69/// A call to an overloaded operator written using operator
70/// syntax.
71///
72/// Represents a call to an overloaded operator written using operator
73/// syntax, e.g., "x + y" or "*p". While semantically equivalent to a
74/// normal call, this AST node provides better information about the
75/// syntactic representation of the call.
76///
77/// In a C++ template, this expression node kind will be used whenever
78/// any of the arguments are type-dependent. In this case, the
79/// function itself will be a (possibly empty) set of functions and
80/// function templates that were found by name lookup at template
81/// definition time.
82class CXXOperatorCallExpr final : public CallExpr {
friend class ASTStmtReader;
friend class ASTStmtWriter;

SourceRange Range;

// CXXOperatorCallExpr has some trailing objects belonging
// to CallExpr. See CallExpr for the details.

SourceRange getSourceRangeImpl() const LLVM_READONLY__attribute__((__pure__));

CXXOperatorCallExpr(OverloadedOperatorKind OpKind, Expr *Fn,
                    ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
                    SourceLocation OperatorLoc, FPOptionsOverride FPFeatures,
                    ADLCallKind UsesADL);

CXXOperatorCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);

100public:
static CXXOperatorCallExpr *
Create(const ASTContext &Ctx, OverloadedOperatorKind OpKind, Expr *Fn,
       ArrayRef<Expr *> Args, QualType Ty, ExprValueKind VK,
       SourceLocation OperatorLoc, FPOptionsOverride FPFeatures,
       ADLCallKind UsesADL = NotADL);

static CXXOperatorCallExpr *CreateEmpty(const ASTContext &Ctx,
                                        unsigned NumArgs, bool HasFPFeatures,
                                        EmptyShell Empty);

/// Returns the kind of overloaded operator that this expression refers to.
OverloadedOperatorKind getOperator() const {
  return static_cast<OverloadedOperatorKind>(
      CXXOperatorCallExprBits.OperatorKind);
}

static bool isAssignmentOp(OverloadedOperatorKind Opc) {
  return Opc == OO_Equal || Opc == OO_StarEqual || Opc == OO_SlashEqual ||
         Opc == OO_PercentEqual || Opc == OO_PlusEqual ||
         Opc == OO_MinusEqual || Opc == OO_LessLessEqual ||
         Opc == OO_GreaterGreaterEqual || Opc == OO_AmpEqual ||
         Opc == OO_CaretEqual || Opc == OO_PipeEqual;
}
bool isAssignmentOp() const { return isAssignmentOp(getOperator()); }

static bool isComparisonOp(OverloadedOperatorKind Opc) {
  switch (Opc) {
  case OO_EqualEqual:
  case OO_ExclaimEqual:
  case OO_Greater:
  case OO_GreaterEqual:
  case OO_Less:
  case OO_LessEqual:
  case OO_Spaceship:
    return true;
  default:
    return false;
  }
}
bool isComparisonOp() const { return isComparisonOp(getOperator()); }

/// Is this written as an infix binary operator?
bool isInfixBinaryOp() const;

/// Returns the location of the operator symbol in the expression.
///
/// When \c getOperator()==OO_Call, this is the location of the right
/// parentheses; when \c getOperator()==OO_Subscript, this is the location
/// of the right bracket.
SourceLocation getOperatorLoc() const { return getRParenLoc(); }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  OverloadedOperatorKind Operator = getOperator();
  return (Operator < OO_Plus || Operator >= OO_Arrow ||
          Operator == OO_PlusPlus || Operator == OO_MinusMinus)
             ? getBeginLoc()
             : getOperatorLoc();
}

SourceLocation getBeginLoc() const { return Range.getBegin(); }
SourceLocation getEndLoc() const { return Range.getEnd(); }
SourceRange getSourceRange() const { return Range; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXOperatorCallExprClass;
}
167};

169/// Represents a call to a member function that
170/// may be written either with member call syntax (e.g., "obj.func()"
171/// or "objptr->func()") or with normal function-call syntax
172/// ("func()") within a member function that ends up calling a member
173/// function. The callee in either case is a MemberExpr that contains
174/// both the object argument and the member function, while the
175/// arguments are the arguments within the parentheses (not including
176/// the object argument).
177class CXXMemberCallExpr final : public CallExpr {
// CXXMemberCallExpr has some trailing objects belonging
// to CallExpr. See CallExpr for the details.

CXXMemberCallExpr(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
                  ExprValueKind VK, SourceLocation RP,
                  FPOptionsOverride FPOptions, unsigned MinNumArgs);

CXXMemberCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);

187public:
static CXXMemberCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
                                 ArrayRef<Expr *> Args, QualType Ty,
                                 ExprValueKind VK, SourceLocation RP,
                                 FPOptionsOverride FPFeatures,
                                 unsigned MinNumArgs = 0);

static CXXMemberCallExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs,
                                      bool HasFPFeatures, EmptyShell Empty);

/// Retrieve the implicit object argument for the member call.
///
/// For example, in "x.f(5)", this returns the sub-expression "x".
Expr *getImplicitObjectArgument() const;

/// Retrieve the type of the object argument.
///
/// Note that this always returns a non-pointer type.
QualType getObjectType() const;

/// Retrieve the declaration of the called method.
CXXMethodDecl *getMethodDecl() const;

/// Retrieve the CXXRecordDecl for the underlying type of
/// the implicit object argument.
///
/// Note that this is may not be the same declaration as that of the class
/// context of the CXXMethodDecl which this function is calling.
/// FIXME: Returns 0 for member pointer call exprs.
CXXRecordDecl *getRecordDecl() const;

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  SourceLocation CLoc = getCallee()->getExprLoc();
  if (CLoc.isValid())
    return CLoc;

  return getBeginLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXMemberCallExprClass;
}
229};

231/// Represents a call to a CUDA kernel function.
232class CUDAKernelCallExpr final : public CallExpr {
friend class ASTStmtReader;

enum { CONFIG, END_PREARG };

// CUDAKernelCallExpr has some trailing objects belonging
// to CallExpr. See CallExpr for the details.

CUDAKernelCallExpr(Expr *Fn, CallExpr *Config, ArrayRef<Expr *> Args,
                   QualType Ty, ExprValueKind VK, SourceLocation RP,
                   FPOptionsOverride FPFeatures, unsigned MinNumArgs);

CUDAKernelCallExpr(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);

246public:
static CUDAKernelCallExpr *Create(const ASTContext &Ctx, Expr *Fn,
                                  CallExpr *Config, ArrayRef<Expr *> Args,
                                  QualType Ty, ExprValueKind VK,
                                  SourceLocation RP,
                                  FPOptionsOverride FPFeatures,
                                  unsigned MinNumArgs = 0);

static CUDAKernelCallExpr *CreateEmpty(const ASTContext &Ctx,
                                       unsigned NumArgs, bool HasFPFeatures,
                                       EmptyShell Empty);

const CallExpr *getConfig() const {
  return cast_or_null<CallExpr>(getPreArg(CONFIG));
}
CallExpr *getConfig() { return cast_or_null<CallExpr>(getPreArg(CONFIG)); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CUDAKernelCallExprClass;
}
266};

268/// A rewritten comparison expression that was originally written using
269/// operator syntax.
270///
271/// In C++20, the following rewrites are performed:
272/// - <tt>a == b</tt> -> <tt>b == a</tt>
273/// - <tt>a != b</tt> -> <tt>!(a == b)</tt>
274/// - <tt>a != b</tt> -> <tt>!(b == a)</tt>
275/// - For \c \@ in \c <, \c <=, \c >, \c >=, \c <=>:
276///   - <tt>a @ b</tt> -> <tt>(a <=> b) @ 0</tt>
277///   - <tt>a @ b</tt> -> <tt>0 @ (b <=> a)</tt>
278///
279/// This expression provides access to both the original syntax and the
280/// rewritten expression.
281///
282/// Note that the rewritten calls to \c ==, \c <=>, and \c \@ are typically
283/// \c CXXOperatorCallExprs, but could theoretically be \c BinaryOperators.
284class CXXRewrittenBinaryOperator : public Expr {
friend class ASTStmtReader;

/// The rewritten semantic form.
Stmt *SemanticForm;

290public:
CXXRewrittenBinaryOperator(Expr *SemanticForm, bool IsReversed)
    : Expr(CXXRewrittenBinaryOperatorClass, SemanticForm->getType(),
           SemanticForm->getValueKind(), SemanticForm->getObjectKind()),
      SemanticForm(SemanticForm) {
  CXXRewrittenBinaryOperatorBits.IsReversed = IsReversed;
  setDependence(computeDependence(this));
}
CXXRewrittenBinaryOperator(EmptyShell Empty)
    : Expr(CXXRewrittenBinaryOperatorClass, Empty), SemanticForm() {}

/// Get an equivalent semantic form for this expression.
Expr *getSemanticForm() { return cast<Expr>(SemanticForm); }
const Expr *getSemanticForm() const { return cast<Expr>(SemanticForm); }

struct DecomposedForm {
  /// The original opcode, prior to rewriting.
  BinaryOperatorKind Opcode;
  /// The original left-hand side.
  const Expr *LHS;
  /// The original right-hand side.
  const Expr *RHS;
  /// The inner \c == or \c <=> operator expression.
  const Expr *InnerBinOp;
};

/// Decompose this operator into its syntactic form.
DecomposedForm getDecomposedForm() const LLVM_READONLY__attribute__((__pure__));

/// Determine whether this expression was rewritten in reverse form.
bool isReversed() const { return CXXRewrittenBinaryOperatorBits.IsReversed; }

BinaryOperatorKind getOperator() const { return getDecomposedForm().Opcode; }
BinaryOperatorKind getOpcode() const { return getOperator(); }
static StringRef getOpcodeStr(BinaryOperatorKind Op) {
  return BinaryOperator::getOpcodeStr(Op);
}
StringRef getOpcodeStr() const {
  return BinaryOperator::getOpcodeStr(getOpcode());
}
bool isComparisonOp() const { return true; }
bool isAssignmentOp() const { return false; }

const Expr *getLHS() const { return getDecomposedForm().LHS; }
const Expr *getRHS() const { return getDecomposedForm().RHS; }

SourceLocation getOperatorLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getDecomposedForm().InnerBinOp->getExprLoc();
}
SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) { return getOperatorLoc(); }

/// Compute the begin and end locations from the decomposed form.
/// The locations of the semantic form are not reliable if this is
/// a reversed expression.
//@{
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getDecomposedForm().LHS->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getDecomposedForm().RHS->getEndLoc();
}
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  DecomposedForm DF = getDecomposedForm();
  return SourceRange(DF.LHS->getBeginLoc(), DF.RHS->getEndLoc());
}
//@}

child_range children() {
  return child_range(&SemanticForm, &SemanticForm + 1);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXRewrittenBinaryOperatorClass;
}
364};

366/// Abstract class common to all of the C++ "named"/"keyword" casts.
367///
368/// This abstract class is inherited by all of the classes
369/// representing "named" casts: CXXStaticCastExpr for \c static_cast,
370/// CXXDynamicCastExpr for \c dynamic_cast, CXXReinterpretCastExpr for
371/// reinterpret_cast, CXXConstCastExpr for \c const_cast and
372/// CXXAddrspaceCastExpr for addrspace_cast (in OpenCL).
373class CXXNamedCastExpr : public ExplicitCastExpr {
374private:
// the location of the casting op
SourceLocation Loc;

// the location of the right parenthesis
SourceLocation RParenLoc;

// range for '<' '>'
SourceRange AngleBrackets;

384protected:
friend class ASTStmtReader;

CXXNamedCastExpr(StmtClass SC, QualType ty, ExprValueKind VK, CastKind kind,
                 Expr *op, unsigned PathSize, bool HasFPFeatures,
                 TypeSourceInfo *writtenTy, SourceLocation l,
                 SourceLocation RParenLoc, SourceRange AngleBrackets)
    : ExplicitCastExpr(SC, ty, VK, kind, op, PathSize, HasFPFeatures,
                       writtenTy),
      Loc(l), RParenLoc(RParenLoc), AngleBrackets(AngleBrackets) {}

explicit CXXNamedCastExpr(StmtClass SC, EmptyShell Shell, unsigned PathSize,
                          bool HasFPFeatures)
    : ExplicitCastExpr(SC, Shell, PathSize, HasFPFeatures) {}

399public:
const char *getCastName() const;

/// Retrieve the location of the cast operator keyword, e.g.,
/// \c static_cast.
SourceLocation getOperatorLoc() const { return Loc; }

/// Retrieve the location of the closing parenthesis.
SourceLocation getRParenLoc() const { return RParenLoc; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }
SourceRange getAngleBrackets() const LLVM_READONLY__attribute__((__pure__)) { return AngleBrackets; }

static bool classof(const Stmt *T) {
  switch (T->getStmtClass()) {
  case CXXStaticCastExprClass:
  case CXXDynamicCastExprClass:
  case CXXReinterpretCastExprClass:
  case CXXConstCastExprClass:
  case CXXAddrspaceCastExprClass:
    return true;
  default:
    return false;
  }
}
425};

427/// A C++ \c static_cast expression (C++ [expr.static.cast]).
428///
429/// This expression node represents a C++ static cast, e.g.,
430/// \c static_cast<int>(1.0).
431class CXXStaticCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXStaticCastExpr, CXXBaseSpecifier *,
                                  FPOptionsOverride> {
CXXStaticCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
                  unsigned pathSize, TypeSourceInfo *writtenTy,
                  FPOptionsOverride FPO, SourceLocation l,
                  SourceLocation RParenLoc, SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXStaticCastExprClass, ty, vk, kind, op, pathSize,
                       FPO.requiresTrailingStorage(), writtenTy, l, RParenLoc,
                       AngleBrackets) {
  if (hasStoredFPFeatures())
    *getTrailingFPFeatures() = FPO;
}

explicit CXXStaticCastExpr(EmptyShell Empty, unsigned PathSize,
                           bool HasFPFeatures)
    : CXXNamedCastExpr(CXXStaticCastExprClass, Empty, PathSize,
                       HasFPFeatures) {}

unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
  return path_size();
}

455public:
friend class CastExpr;
friend TrailingObjects;

static CXXStaticCastExpr *
Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K,
       Expr *Op, const CXXCastPath *Path, TypeSourceInfo *Written,
       FPOptionsOverride FPO, SourceLocation L, SourceLocation RParenLoc,
       SourceRange AngleBrackets);
static CXXStaticCastExpr *CreateEmpty(const ASTContext &Context,
                                      unsigned PathSize, bool hasFPFeatures);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXStaticCastExprClass;
}
470};

472/// A C++ @c dynamic_cast expression (C++ [expr.dynamic.cast]).
473///
474/// This expression node represents a dynamic cast, e.g.,
475/// \c dynamic_cast<Derived*>(BasePtr). Such a cast may perform a run-time
476/// check to determine how to perform the type conversion.
477class CXXDynamicCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXDynamicCastExpr, CXXBaseSpecifier *> {
CXXDynamicCastExpr(QualType ty, ExprValueKind VK, CastKind kind, Expr *op,
                   unsigned pathSize, TypeSourceInfo *writtenTy,
                   SourceLocation l, SourceLocation RParenLoc,
                   SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXDynamicCastExprClass, ty, VK, kind, op, pathSize,
                       /*HasFPFeatures*/ false, writtenTy, l, RParenLoc,
                       AngleBrackets) {}

explicit CXXDynamicCastExpr(EmptyShell Empty, unsigned pathSize)
    : CXXNamedCastExpr(CXXDynamicCastExprClass, Empty, pathSize,
                       /*HasFPFeatures*/ false) {}

492public:
friend class CastExpr;
friend TrailingObjects;

static CXXDynamicCastExpr *Create(const ASTContext &Context, QualType T,
                                  ExprValueKind VK, CastKind Kind, Expr *Op,
                                  const CXXCastPath *Path,
                                  TypeSourceInfo *Written, SourceLocation L,
                                  SourceLocation RParenLoc,
                                  SourceRange AngleBrackets);

static CXXDynamicCastExpr *CreateEmpty(const ASTContext &Context,
                                       unsigned pathSize);

bool isAlwaysNull() const;

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDynamicCastExprClass;
}
511};

513/// A C++ @c reinterpret_cast expression (C++ [expr.reinterpret.cast]).
514///
515/// This expression node represents a reinterpret cast, e.g.,
516/// @c reinterpret_cast<int>(VoidPtr).
517///
518/// A reinterpret_cast provides a differently-typed view of a value but
519/// (in Clang, as in most C++ implementations) performs no actual work at
520/// run time.
521class CXXReinterpretCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXReinterpretCastExpr,
                                  CXXBaseSpecifier *> {
CXXReinterpretCastExpr(QualType ty, ExprValueKind vk, CastKind kind, Expr *op,
                       unsigned pathSize, TypeSourceInfo *writtenTy,
                       SourceLocation l, SourceLocation RParenLoc,
                       SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXReinterpretCastExprClass, ty, vk, kind, op,
                       pathSize, /*HasFPFeatures*/ false, writtenTy, l,
                       RParenLoc, AngleBrackets) {}

CXXReinterpretCastExpr(EmptyShell Empty, unsigned pathSize)
    : CXXNamedCastExpr(CXXReinterpretCastExprClass, Empty, pathSize,
                       /*HasFPFeatures*/ false) {}

537public:
friend class CastExpr;
friend TrailingObjects;

static CXXReinterpretCastExpr *Create(const ASTContext &Context, QualType T,
                                      ExprValueKind VK, CastKind Kind,
                                      Expr *Op, const CXXCastPath *Path,
                               TypeSourceInfo *WrittenTy, SourceLocation L,
                                      SourceLocation RParenLoc,
                                      SourceRange AngleBrackets);
static CXXReinterpretCastExpr *CreateEmpty(const ASTContext &Context,
                                           unsigned pathSize);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXReinterpretCastExprClass;
}
553};

555/// A C++ \c const_cast expression (C++ [expr.const.cast]).
556///
557/// This expression node represents a const cast, e.g.,
558/// \c const_cast<char*>(PtrToConstChar).
559///
560/// A const_cast can remove type qualifiers but does not change the underlying
561/// value.
562class CXXConstCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXConstCastExpr, CXXBaseSpecifier *> {
CXXConstCastExpr(QualType ty, ExprValueKind VK, Expr *op,
                 TypeSourceInfo *writtenTy, SourceLocation l,
                 SourceLocation RParenLoc, SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXConstCastExprClass, ty, VK, CK_NoOp, op, 0,
                       /*HasFPFeatures*/ false, writtenTy, l, RParenLoc,
                       AngleBrackets) {}

explicit CXXConstCastExpr(EmptyShell Empty)
    : CXXNamedCastExpr(CXXConstCastExprClass, Empty, 0,
                       /*HasFPFeatures*/ false) {}

576public:
friend class CastExpr;
friend TrailingObjects;

static CXXConstCastExpr *Create(const ASTContext &Context, QualType T,
                                ExprValueKind VK, Expr *Op,
                                TypeSourceInfo *WrittenTy, SourceLocation L,
                                SourceLocation RParenLoc,
                                SourceRange AngleBrackets);
static CXXConstCastExpr *CreateEmpty(const ASTContext &Context);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXConstCastExprClass;
}
590};

592/// A C++ addrspace_cast expression (currently only enabled for OpenCL).
593///
594/// This expression node represents a cast between pointers to objects in
595/// different address spaces e.g.,
596/// \c addrspace_cast<global int*>(PtrToGenericInt).
597///
598/// A addrspace_cast can cast address space type qualifiers but does not change
599/// the underlying value.
600class CXXAddrspaceCastExpr final
  : public CXXNamedCastExpr,
    private llvm::TrailingObjects<CXXAddrspaceCastExpr, CXXBaseSpecifier *> {
CXXAddrspaceCastExpr(QualType ty, ExprValueKind VK, CastKind Kind, Expr *op,
                     TypeSourceInfo *writtenTy, SourceLocation l,
                     SourceLocation RParenLoc, SourceRange AngleBrackets)
    : CXXNamedCastExpr(CXXAddrspaceCastExprClass, ty, VK, Kind, op, 0,
                       /*HasFPFeatures*/ false, writtenTy, l, RParenLoc,
                       AngleBrackets) {}

explicit CXXAddrspaceCastExpr(EmptyShell Empty)
    : CXXNamedCastExpr(CXXAddrspaceCastExprClass, Empty, 0,
                       /*HasFPFeatures*/ false) {}

614public:
friend class CastExpr;
friend TrailingObjects;

static CXXAddrspaceCastExpr *
Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind Kind,
       Expr *Op, TypeSourceInfo *WrittenTy, SourceLocation L,
       SourceLocation RParenLoc, SourceRange AngleBrackets);
static CXXAddrspaceCastExpr *CreateEmpty(const ASTContext &Context);

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXAddrspaceCastExprClass;
}
627};

629/// A call to a literal operator (C++11 [over.literal])
630/// written as a user-defined literal (C++11 [lit.ext]).
631///
632/// Represents a user-defined literal, e.g. "foo"_bar or 1.23_xyz. While this
633/// is semantically equivalent to a normal call, this AST node provides better
634/// information about the syntactic representation of the literal.
635///
636/// Since literal operators are never found by ADL and can only be declared at
637/// namespace scope, a user-defined literal is never dependent.
638class UserDefinedLiteral final : public CallExpr {
friend class ASTStmtReader;
friend class ASTStmtWriter;

/// The location of a ud-suffix within the literal.
SourceLocation UDSuffixLoc;

// UserDefinedLiteral has some trailing objects belonging
// to CallExpr. See CallExpr for the details.

UserDefinedLiteral(Expr *Fn, ArrayRef<Expr *> Args, QualType Ty,
                   ExprValueKind VK, SourceLocation LitEndLoc,
                   SourceLocation SuffixLoc, FPOptionsOverride FPFeatures);

UserDefinedLiteral(unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty);

654public:
static UserDefinedLiteral *Create(const ASTContext &Ctx, Expr *Fn,
                                  ArrayRef<Expr *> Args, QualType Ty,
                                  ExprValueKind VK, SourceLocation LitEndLoc,
                                  SourceLocation SuffixLoc,
                                  FPOptionsOverride FPFeatures);

static UserDefinedLiteral *CreateEmpty(const ASTContext &Ctx,
                                       unsigned NumArgs, bool HasFPOptions,
                                       EmptyShell Empty);

/// The kind of literal operator which is invoked.
enum LiteralOperatorKind {
  /// Raw form: operator "" X (const char *)
  LOK_Raw,

  /// Raw form: operator "" X<cs...> ()
  LOK_Template,

  /// operator "" X (unsigned long long)
  LOK_Integer,

  /// operator "" X (long double)
  LOK_Floating,

  /// operator "" X (const CharT *, size_t)
  LOK_String,

  /// operator "" X (CharT)
  LOK_Character
};

/// Returns the kind of literal operator invocation
/// which this expression represents.
LiteralOperatorKind getLiteralOperatorKind() const;

/// If this is not a raw user-defined literal, get the
/// underlying cooked literal (representing the literal with the suffix
/// removed).
Expr *getCookedLiteral();
const Expr *getCookedLiteral() const {
  return const_cast<UserDefinedLiteral*>(this)->getCookedLiteral();
}

SourceLocation getBeginLoc() const {
  if (getLiteralOperatorKind() == LOK_Template)
    return getRParenLoc();
  return getArg(0)->getBeginLoc();
}

SourceLocation getEndLoc() const { return getRParenLoc(); }

/// Returns the location of a ud-suffix in the expression.
///
/// For a string literal, there may be multiple identical suffixes. This
/// returns the first.
SourceLocation getUDSuffixLoc() const { return UDSuffixLoc; }

/// Returns the ud-suffix specified for this literal.
const IdentifierInfo *getUDSuffix() const;

static bool classof(const Stmt *S) {
  return S->getStmtClass() == UserDefinedLiteralClass;
}
718};

720/// A boolean literal, per ([C++ lex.bool] Boolean literals).
721class CXXBoolLiteralExpr : public Expr {
722public:
CXXBoolLiteralExpr(bool Val, QualType Ty, SourceLocation Loc)
    : Expr(CXXBoolLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
  CXXBoolLiteralExprBits.Value = Val;
  CXXBoolLiteralExprBits.Loc = Loc;
  setDependence(ExprDependence::None);
}

explicit CXXBoolLiteralExpr(EmptyShell Empty)
    : Expr(CXXBoolLiteralExprClass, Empty) {}

bool getValue() const { return CXXBoolLiteralExprBits.Value; }
void setValue(bool V) { CXXBoolLiteralExprBits.Value = V; }

SourceLocation getBeginLoc() const { return getLocation(); }
SourceLocation getEndLoc() const { return getLocation(); }

SourceLocation getLocation() const { return CXXBoolLiteralExprBits.Loc; }
void setLocation(SourceLocation L) { CXXBoolLiteralExprBits.Loc = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXBoolLiteralExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
754};

756/// The null pointer literal (C++11 [lex.nullptr])
757///
758/// Introduced in C++11, the only literal of type \c nullptr_t is \c nullptr.
759class CXXNullPtrLiteralExpr : public Expr {
760public:
CXXNullPtrLiteralExpr(QualType Ty, SourceLocation Loc)
    : Expr(CXXNullPtrLiteralExprClass, Ty, VK_PRValue, OK_Ordinary) {
  CXXNullPtrLiteralExprBits.Loc = Loc;
  setDependence(ExprDependence::None);
}

explicit CXXNullPtrLiteralExpr(EmptyShell Empty)
    : Expr(CXXNullPtrLiteralExprClass, Empty) {}

SourceLocation getBeginLoc() const { return getLocation(); }
SourceLocation getEndLoc() const { return getLocation(); }

SourceLocation getLocation() const { return CXXNullPtrLiteralExprBits.Loc; }
void setLocation(SourceLocation L) { CXXNullPtrLiteralExprBits.Loc = L; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXNullPtrLiteralExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
787};

789/// Implicit construction of a std::initializer_list<T> object from an
790/// array temporary within list-initialization (C++11 [dcl.init.list]p5).
791class CXXStdInitializerListExpr : public Expr {
Stmt *SubExpr = nullptr;

CXXStdInitializerListExpr(EmptyShell Empty)
    : Expr(CXXStdInitializerListExprClass, Empty) {}

797public:
friend class ASTReader;
friend class ASTStmtReader;

CXXStdInitializerListExpr(QualType Ty, Expr *SubExpr)
    : Expr(CXXStdInitializerListExprClass, Ty, VK_PRValue, OK_Ordinary),
      SubExpr(SubExpr) {
  setDependence(computeDependence(this));
}

Expr *getSubExpr() { return static_cast<Expr*>(SubExpr); }
const Expr *getSubExpr() const { return static_cast<const Expr*>(SubExpr); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getBeginLoc();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getEndLoc();
}

/// Retrieve the source range of the expression.
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getSourceRange();
}

static bool classof(const Stmt *S) {
  return S->getStmtClass() == CXXStdInitializerListExprClass;
}

child_range children() { return child_range(&SubExpr, &SubExpr + 1); }

const_child_range children() const {
  return const_child_range(&SubExpr, &SubExpr + 1);
}
832};

834/// A C++ \c typeid expression (C++ [expr.typeid]), which gets
835/// the \c type_info that corresponds to the supplied type, or the (possibly
836/// dynamic) type of the supplied expression.
837///
838/// This represents code like \c typeid(int) or \c typeid(*objPtr)
839class CXXTypeidExpr : public Expr {
friend class ASTStmtReader;

842private:
llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
SourceRange Range;

846public:
CXXTypeidExpr(QualType Ty, TypeSourceInfo *Operand, SourceRange R)
    : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
      Range(R) {
  setDependence(computeDependence(this));
}

CXXTypeidExpr(QualType Ty, Expr *Operand, SourceRange R)
    : Expr(CXXTypeidExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
      Range(R) {
  setDependence(computeDependence(this));
}

CXXTypeidExpr(EmptyShell Empty, bool isExpr)
    : Expr(CXXTypeidExprClass, Empty) {
  if (isExpr)
    Operand = (Expr*)nullptr;
  else
    Operand = (TypeSourceInfo*)nullptr;
}

/// Determine whether this typeid has a type operand which is potentially
/// evaluated, per C++11 [expr.typeid]p3.
bool isPotentiallyEvaluated() const;

/// Best-effort check if the expression operand refers to a most derived
/// object. This is not a strong guarantee.
bool isMostDerived(ASTContext &Context) const;

bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }

/// Retrieves the type operand of this typeid() expression after
/// various required adjustments (removing reference types, cv-qualifiers).
QualType getTypeOperand(ASTContext &Context) const;

/// Retrieve source information for the type operand.
TypeSourceInfo *getTypeOperandSourceInfo() const {
  assert(isTypeOperand() && "Cannot call getTypeOperand for typeid(expr)")((void)0);
  return Operand.get<TypeSourceInfo *>();
}
Expr *getExprOperand() const {
  assert(!isTypeOperand() && "Cannot call getExprOperand for typeid(type)")((void)0);
  return static_cast<Expr*>(Operand.get<Stmt *>());
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
void setSourceRange(SourceRange R) { Range = R; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXTypeidExprClass;
}

// Iterators
child_range children() {
  if (isTypeOperand())
    return child_range(child_iterator(), child_iterator());
  auto **begin = reinterpret_cast<Stmt **>(&Operand);
  return child_range(begin, begin + 1);
}

const_child_range children() const {
  if (isTypeOperand())
    return const_child_range(const_child_iterator(), const_child_iterator());

  auto **begin =
      reinterpret_cast<Stmt **>(&const_cast<CXXTypeidExpr *>(this)->Operand);
  return const_child_range(begin, begin + 1);
}
916};

918/// A member reference to an MSPropertyDecl.
919///
920/// This expression always has pseudo-object type, and therefore it is
921/// typically not encountered in a fully-typechecked expression except
922/// within the syntactic form of a PseudoObjectExpr.
923class MSPropertyRefExpr : public Expr {
Expr *BaseExpr;
MSPropertyDecl *TheDecl;
SourceLocation MemberLoc;
bool IsArrow;
NestedNameSpecifierLoc QualifierLoc;

930public:
friend class ASTStmtReader;

MSPropertyRefExpr(Expr *baseExpr, MSPropertyDecl *decl, bool isArrow,
                  QualType ty, ExprValueKind VK,
                  NestedNameSpecifierLoc qualifierLoc, SourceLocation nameLoc)
    : Expr(MSPropertyRefExprClass, ty, VK, OK_Ordinary), BaseExpr(baseExpr),
      TheDecl(decl), MemberLoc(nameLoc), IsArrow(isArrow),
      QualifierLoc(qualifierLoc) {
  setDependence(computeDependence(this));
}

MSPropertyRefExpr(EmptyShell Empty) : Expr(MSPropertyRefExprClass, Empty) {}

SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) {
  return SourceRange(getBeginLoc(), getEndLoc());
}

bool isImplicitAccess() const {
  return getBaseExpr() && getBaseExpr()->isImplicitCXXThis();
}

SourceLocation getBeginLoc() const {
  if (!isImplicitAccess())
    return BaseExpr->getBeginLoc();
  else if (QualifierLoc)
    return QualifierLoc.getBeginLoc();
  else
      return MemberLoc;
}

SourceLocation getEndLoc() const { return getMemberLoc(); }

child_range children() {
  return child_range((Stmt**)&BaseExpr, (Stmt**)&BaseExpr + 1);
}

const_child_range children() const {
  auto Children = const_cast<MSPropertyRefExpr *>(this)->children();
  return const_child_range(Children.begin(), Children.end());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MSPropertyRefExprClass;
}

Expr *getBaseExpr() const { return BaseExpr; }
MSPropertyDecl *getPropertyDecl() const { return TheDecl; }
bool isArrow() const { return IsArrow; }
SourceLocation getMemberLoc() const { return MemberLoc; }
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
981};

983/// MS property subscript expression.
984/// MSVC supports 'property' attribute and allows to apply it to the
985/// declaration of an empty array in a class or structure definition.
986/// For example:
987/// \code
988/// __declspec(property(get=GetX, put=PutX)) int x[];
989/// \endcode
990/// The above statement indicates that x[] can be used with one or more array
991/// indices. In this case, i=p->x[a][b] will be turned into i=p->GetX(a, b), and
992/// p->x[a][b] = i will be turned into p->PutX(a, b, i).
993/// This is a syntactic pseudo-object expression.
994class MSPropertySubscriptExpr : public Expr {
friend class ASTStmtReader;

enum { BASE_EXPR, IDX_EXPR, NUM_SUBEXPRS = 2 };

Stmt *SubExprs[NUM_SUBEXPRS];
SourceLocation RBracketLoc;

void setBase(Expr *Base) { SubExprs[BASE_EXPR] = Base; }
void setIdx(Expr *Idx) { SubExprs[IDX_EXPR] = Idx; }

1005public:
MSPropertySubscriptExpr(Expr *Base, Expr *Idx, QualType Ty, ExprValueKind VK,
                        ExprObjectKind OK, SourceLocation RBracketLoc)
    : Expr(MSPropertySubscriptExprClass, Ty, VK, OK),
      RBracketLoc(RBracketLoc) {
  SubExprs[BASE_EXPR] = Base;
  SubExprs[IDX_EXPR] = Idx;
  setDependence(computeDependence(this));
}

/// Create an empty array subscript expression.
explicit MSPropertySubscriptExpr(EmptyShell Shell)
    : Expr(MSPropertySubscriptExprClass, Shell) {}

Expr *getBase() { return cast<Expr>(SubExprs[BASE_EXPR]); }
const Expr *getBase() const { return cast<Expr>(SubExprs[BASE_EXPR]); }

Expr *getIdx() { return cast<Expr>(SubExprs[IDX_EXPR]); }
const Expr *getIdx() const { return cast<Expr>(SubExprs[IDX_EXPR]); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getBeginLoc();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RBracketLoc; }

SourceLocation getRBracketLoc() const { return RBracketLoc; }
void setRBracketLoc(SourceLocation L) { RBracketLoc = L; }

SourceLocation getExprLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return getBase()->getExprLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == MSPropertySubscriptExprClass;
}

// Iterators
child_range children() {
  return child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
}

const_child_range children() const {
  return const_child_range(&SubExprs[0], &SubExprs[0] + NUM_SUBEXPRS);
}
1050};

1052/// A Microsoft C++ @c __uuidof expression, which gets
1053/// the _GUID that corresponds to the supplied type or expression.
1054///
1055/// This represents code like @c __uuidof(COMTYPE) or @c __uuidof(*comPtr)
1056class CXXUuidofExpr : public Expr {
friend class ASTStmtReader;

1059private:
llvm::PointerUnion<Stmt *, TypeSourceInfo *> Operand;
MSGuidDecl *Guid;
SourceRange Range;

1064public:
CXXUuidofExpr(QualType Ty, TypeSourceInfo *Operand, MSGuidDecl *Guid,
              SourceRange R)
    : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
      Guid(Guid), Range(R) {
  setDependence(computeDependence(this));
}

CXXUuidofExpr(QualType Ty, Expr *Operand, MSGuidDecl *Guid, SourceRange R)
    : Expr(CXXUuidofExprClass, Ty, VK_LValue, OK_Ordinary), Operand(Operand),
      Guid(Guid), Range(R) {
  setDependence(computeDependence(this));
}

CXXUuidofExpr(EmptyShell Empty, bool isExpr)
  : Expr(CXXUuidofExprClass, Empty) {
  if (isExpr)
    Operand = (Expr*)nullptr;
  else
    Operand = (TypeSourceInfo*)nullptr;
}

bool isTypeOperand() const { return Operand.is<TypeSourceInfo *>(); }

/// Retrieves the type operand of this __uuidof() expression after
/// various required adjustments (removing reference types, cv-qualifiers).
QualType getTypeOperand(ASTContext &Context) const;

/// Retrieve source information for the type operand.
TypeSourceInfo *getTypeOperandSourceInfo() const {
  assert(isTypeOperand() && "Cannot call getTypeOperand for __uuidof(expr)")((void)0);
  return Operand.get<TypeSourceInfo *>();
}
Expr *getExprOperand() const {
  assert(!isTypeOperand() && "Cannot call getExprOperand for __uuidof(type)")((void)0);
  return static_cast<Expr*>(Operand.get<Stmt *>());
}

MSGuidDecl *getGuidDecl() const { return Guid; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getBegin(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Range.getEnd(); }
SourceRange getSourceRange() const LLVM_READONLY__attribute__((__pure__)) { return Range; }
void setSourceRange(SourceRange R) { Range = R; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXUuidofExprClass;
}

// Iterators
child_range children() {
  if (isTypeOperand())
    return child_range(child_iterator(), child_iterator());
  auto **begin = reinterpret_cast<Stmt **>(&Operand);
  return child_range(begin, begin + 1);
}

const_child_range children() const {
  if (isTypeOperand())
    return const_child_range(const_child_iterator(), const_child_iterator());
  auto **begin =
      reinterpret_cast<Stmt **>(&const_cast<CXXUuidofExpr *>(this)->Operand);
  return const_child_range(begin, begin + 1);
}
1128};

1130/// Represents the \c this expression in C++.
1131///
1132/// This is a pointer to the object on which the current member function is
1133/// executing (C++ [expr.prim]p3). Example:
1134///
1135/// \code
1136/// class Foo {
1137/// public:
1138///   void bar();
1139///   void test() { this->bar(); }
1140/// };
1141/// \endcode
1142class CXXThisExpr : public Expr {
1143public:
CXXThisExpr(SourceLocation L, QualType Ty, bool IsImplicit)
    : Expr(CXXThisExprClass, Ty, VK_PRValue, OK_Ordinary) {
  CXXThisExprBits.IsImplicit = IsImplicit;
  CXXThisExprBits.Loc = L;
  setDependence(computeDependence(this));
}

CXXThisExpr(EmptyShell Empty) : Expr(CXXThisExprClass, Empty) {}

SourceLocation getLocation() const { return CXXThisExprBits.Loc; }
void setLocation(SourceLocation L) { CXXThisExprBits.Loc = L; }

SourceLocation getBeginLoc() const { return getLocation(); }
SourceLocation getEndLoc() const { return getLocation(); }

bool isImplicit() const { return CXXThisExprBits.IsImplicit; }
void setImplicit(bool I) { CXXThisExprBits.IsImplicit = I; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXThisExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1174};

1176/// A C++ throw-expression (C++ [except.throw]).
1177///
1178/// This handles 'throw' (for re-throwing the current exception) and
1179/// 'throw' assignment-expression.  When assignment-expression isn't
1180/// present, Op will be null.
1181class CXXThrowExpr : public Expr {
friend class ASTStmtReader;

/// The optional expression in the throw statement.
Stmt *Operand;

1187public:
// \p Ty is the void type which is used as the result type of the
// expression. The \p Loc is the location of the throw keyword.
// \p Operand is the expression in the throw statement, and can be
// null if not present.
CXXThrowExpr(Expr *Operand, QualType Ty, SourceLocation Loc,
             bool IsThrownVariableInScope)
    : Expr(CXXThrowExprClass, Ty, VK_PRValue, OK_Ordinary), Operand(Operand) {
  CXXThrowExprBits.ThrowLoc = Loc;
  CXXThrowExprBits.IsThrownVariableInScope = IsThrownVariableInScope;
  setDependence(computeDependence(this));
}
CXXThrowExpr(EmptyShell Empty) : Expr(CXXThrowExprClass, Empty) {}

const Expr *getSubExpr() const { return cast_or_null<Expr>(Operand); }
Expr *getSubExpr() { return cast_or_null<Expr>(Operand); }

SourceLocation getThrowLoc() const { return CXXThrowExprBits.ThrowLoc; }

/// Determines whether the variable thrown by this expression (if any!)
/// is within the innermost try block.
///
/// This information is required to determine whether the NRVO can apply to
/// this variable.
bool isThrownVariableInScope() const {
  return CXXThrowExprBits.IsThrownVariableInScope;
}

SourceLocation getBeginLoc() const { return getThrowLoc(); }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (!getSubExpr())
    return getThrowLoc();
  return getSubExpr()->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXThrowExprClass;
}

// Iterators
child_range children() {
  return child_range(&Operand, Operand ? &Operand + 1 : &Operand);
}

const_child_range children() const {
  return const_child_range(&Operand, Operand ? &Operand + 1 : &Operand);
}
1234};

1236/// A default argument (C++ [dcl.fct.default]).
1237///
1238/// This wraps up a function call argument that was created from the
1239/// corresponding parameter's default argument, when the call did not
1240/// explicitly supply arguments for all of the parameters.
1241class CXXDefaultArgExpr final : public Expr {
friend class ASTStmtReader;

/// The parameter whose default is being used.
ParmVarDecl *Param;

/// The context where the default argument expression was used.
DeclContext *UsedContext;

CXXDefaultArgExpr(StmtClass SC, SourceLocation Loc, ParmVarDecl *Param,
                  DeclContext *UsedContext)
    : Expr(SC,
           Param->hasUnparsedDefaultArg()
               ? Param->getType().getNonReferenceType()
               : Param->getDefaultArg()->getType(),
           Param->getDefaultArg()->getValueKind(),
           Param->getDefaultArg()->getObjectKind()),
      Param(Param), UsedContext(UsedContext) {
  CXXDefaultArgExprBits.Loc = Loc;
  setDependence(computeDependence(this));
}

1263public:
CXXDefaultArgExpr(EmptyShell Empty) : Expr(CXXDefaultArgExprClass, Empty) {}

// \p Param is the parameter whose default argument is used by this
// expression.
static CXXDefaultArgExpr *Create(const ASTContext &C, SourceLocation Loc,
                                 ParmVarDecl *Param,
                                 DeclContext *UsedContext) {
  return new (C)
      CXXDefaultArgExpr(CXXDefaultArgExprClass, Loc, Param, UsedContext);
}

// Retrieve the parameter that the argument was created from.
const ParmVarDecl *getParam() const { return Param; }
ParmVarDecl *getParam() { return Param; }

// Retrieve the actual argument to the function call.
const Expr *getExpr() const { return getParam()->getDefaultArg(); }
Expr *getExpr() { return getParam()->getDefaultArg(); }

const DeclContext *getUsedContext() const { return UsedContext; }
DeclContext *getUsedContext() { return UsedContext; }

/// Retrieve the location where this default argument was actually used.
SourceLocation getUsedLocation() const { return CXXDefaultArgExprBits.Loc; }

/// Default argument expressions have no representation in the
/// source, so they have an empty source range.
SourceLocation getBeginLoc() const { return SourceLocation(); }
SourceLocation getEndLoc() const { return SourceLocation(); }

SourceLocation getExprLoc() const { return getUsedLocation(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDefaultArgExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1308};

1310/// A use of a default initializer in a constructor or in aggregate
1311/// initialization.
1312///
1313/// This wraps a use of a C++ default initializer (technically,
1314/// a brace-or-equal-initializer for a non-static data member) when it
1315/// is implicitly used in a mem-initializer-list in a constructor
1316/// (C++11 [class.base.init]p8) or in aggregate initialization
1317/// (C++1y [dcl.init.aggr]p7).
1318class CXXDefaultInitExpr : public Expr {
friend class ASTReader;
friend class ASTStmtReader;

/// The field whose default is being used.
FieldDecl *Field;

/// The context where the default initializer expression was used.
DeclContext *UsedContext;

CXXDefaultInitExpr(const ASTContext &Ctx, SourceLocation Loc,
                   FieldDecl *Field, QualType Ty, DeclContext *UsedContext);

CXXDefaultInitExpr(EmptyShell Empty) : Expr(CXXDefaultInitExprClass, Empty) {}

1333public:
/// \p Field is the non-static data member whose default initializer is used
/// by this expression.
static CXXDefaultInitExpr *Create(const ASTContext &Ctx, SourceLocation Loc,
                                  FieldDecl *Field, DeclContext *UsedContext) {
  return new (Ctx) CXXDefaultInitExpr(Ctx, Loc, Field, Field->getType(), UsedContext);
}

/// Get the field whose initializer will be used.
FieldDecl *getField() { return Field; }
const FieldDecl *getField() const { return Field; }

/// Get the initialization expression that will be used.
const Expr *getExpr() const {
  assert(Field->getInClassInitializer() && "initializer hasn't been parsed")((void)0);
  return Field->getInClassInitializer();
}
Expr *getExpr() {
  assert(Field->getInClassInitializer() && "initializer hasn't been parsed")((void)0);
  return Field->getInClassInitializer();
}

const DeclContext *getUsedContext() const { return UsedContext; }
DeclContext *getUsedContext() { return UsedContext; }

/// Retrieve the location where this default initializer expression was
/// actually used.
SourceLocation getUsedLocation() const { return getBeginLoc(); }

SourceLocation getBeginLoc() const { return CXXDefaultInitExprBits.Loc; }
SourceLocation getEndLoc() const { return CXXDefaultInitExprBits.Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDefaultInitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1377};

1379/// Represents a C++ temporary.
1380class CXXTemporary {
/// The destructor that needs to be called.
const CXXDestructorDecl *Destructor;

explicit CXXTemporary(const CXXDestructorDecl *destructor)
    : Destructor(destructor) {}

1387public:
static CXXTemporary *Create(const ASTContext &C,
                            const CXXDestructorDecl *Destructor);

const CXXDestructorDecl *getDestructor() const { return Destructor; }

void setDestructor(const CXXDestructorDecl *Dtor) {
  Destructor = Dtor;
}
1396};

1398/// Represents binding an expression to a temporary.
1399///
1400/// This ensures the destructor is called for the temporary. It should only be
1401/// needed for non-POD, non-trivially destructable class types. For example:
1402///
1403/// \code
1404///   struct S {
1405///     S() { }  // User defined constructor makes S non-POD.
1406///     ~S() { } // User defined destructor makes it non-trivial.
1407///   };
1408///   void test() {
1409///     const S &s_ref = S(); // Requires a CXXBindTemporaryExpr.
1410///   }
1411/// \endcode
1412class CXXBindTemporaryExpr : public Expr {
CXXTemporary *Temp = nullptr;
Stmt *SubExpr = nullptr;

CXXBindTemporaryExpr(CXXTemporary *temp, Expr *SubExpr)
    : Expr(CXXBindTemporaryExprClass, SubExpr->getType(), VK_PRValue,
           OK_Ordinary),
      Temp(temp), SubExpr(SubExpr) {
  setDependence(computeDependence(this));
}

1423public:
CXXBindTemporaryExpr(EmptyShell Empty)
    : Expr(CXXBindTemporaryExprClass, Empty) {}

static CXXBindTemporaryExpr *Create(const ASTContext &C, CXXTemporary *Temp,
                                    Expr* SubExpr);

CXXTemporary *getTemporary() { return Temp; }
const CXXTemporary *getTemporary() const { return Temp; }
void setTemporary(CXXTemporary *T) { Temp = T; }

const Expr *getSubExpr() const { return cast<Expr>(SubExpr); }
Expr *getSubExpr() { return cast<Expr>(SubExpr); }
void setSubExpr(Expr *E) { SubExpr = E; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getBeginLoc();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getEndLoc();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXBindTemporaryExprClass;
}

// Iterators
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }

const_child_range children() const {
  return const_child_range(&SubExpr, &SubExpr + 1);
}
1457};

1459/// Represents a call to a C++ constructor.
1460class CXXConstructExpr : public Expr {
friend class ASTStmtReader;

1463public:
enum ConstructionKind {
  CK_Complete,
  CK_NonVirtualBase,
  CK_VirtualBase,
  CK_Delegating
};

1471private:
/// A pointer to the constructor which will be ultimately called.
CXXConstructorDecl *Constructor;

SourceRange ParenOrBraceRange;

/// The number of arguments.
unsigned NumArgs;

// We would like to stash the arguments of the constructor call after
// CXXConstructExpr. However CXXConstructExpr is used as a base class of
// CXXTemporaryObjectExpr which makes the use of llvm::TrailingObjects
// impossible.
//
// Instead we manually stash the trailing object after the full object
// containing CXXConstructExpr (that is either CXXConstructExpr or
// CXXTemporaryObjectExpr).
//
// The trailing objects are:
//
// * An array of getNumArgs() "Stmt *" for the arguments of the
//   constructor call.

/// Return a pointer to the start of the trailing arguments.
/// Defined just after CXXTemporaryObjectExpr.
inline Stmt **getTrailingArgs();
const Stmt *const *getTrailingArgs() const {
  return const_cast<CXXConstructExpr *>(this)->getTrailingArgs();
}

1501protected:
/// Build a C++ construction expression.
CXXConstructExpr(StmtClass SC, QualType Ty, SourceLocation Loc,
                 CXXConstructorDecl *Ctor, bool Elidable,
                 ArrayRef<Expr *> Args, bool HadMultipleCandidates,
                 bool ListInitialization, bool StdInitListInitialization,
                 bool ZeroInitialization, ConstructionKind ConstructKind,
                 SourceRange ParenOrBraceRange);

/// Build an empty C++ construction expression.
CXXConstructExpr(StmtClass SC, EmptyShell Empty, unsigned NumArgs);

/// Return the size in bytes of the trailing objects. Used by
/// CXXTemporaryObjectExpr to allocate the right amount of storage.
static unsigned sizeOfTrailingObjects(unsigned NumArgs) {
  return NumArgs * sizeof(Stmt *);
}

1519public:
/// Create a C++ construction expression.
static CXXConstructExpr *
Create(const ASTContext &Ctx, QualType Ty, SourceLocation Loc,
       CXXConstructorDecl *Ctor, bool Elidable, ArrayRef<Expr *> Args,
       bool HadMultipleCandidates, bool ListInitialization,
       bool StdInitListInitialization, bool ZeroInitialization,
       ConstructionKind ConstructKind, SourceRange ParenOrBraceRange);

/// Create an empty C++ construction expression.
static CXXConstructExpr *CreateEmpty(const ASTContext &Ctx, unsigned NumArgs);

/// Get the constructor that this expression will (ultimately) call.
CXXConstructorDecl *getConstructor() const { return Constructor; }

SourceLocation getLocation() const { return CXXConstructExprBits.Loc; }
void setLocation(SourceLocation Loc) { CXXConstructExprBits.Loc = Loc; }

/// Whether this construction is elidable.
bool isElidable() const { return CXXConstructExprBits.Elidable; }
void setElidable(bool E) { CXXConstructExprBits.Elidable = E; }

/// Whether the referred constructor was resolved from
/// an overloaded set having size greater than 1.
bool hadMultipleCandidates() const {
  return CXXConstructExprBits.HadMultipleCandidates;
}
void setHadMultipleCandidates(bool V) {
  CXXConstructExprBits.HadMultipleCandidates = V;
}

/// Whether this constructor call was written as list-initialization.
bool isListInitialization() const {
  return CXXConstructExprBits.ListInitialization;
}
void setListInitialization(bool V) {
  CXXConstructExprBits.ListInitialization = V;
}

/// Whether this constructor call was written as list-initialization,
/// but was interpreted as forming a std::initializer_list<T> from the list
/// and passing that as a single constructor argument.
/// See C++11 [over.match.list]p1 bullet 1.
bool isStdInitListInitialization() const {
  return CXXConstructExprBits.StdInitListInitialization;
}
void setStdInitListInitialization(bool V) {
  CXXConstructExprBits.StdInitListInitialization = V;
}

/// Whether this construction first requires
/// zero-initialization before the initializer is called.
bool requiresZeroInitialization() const {
  return CXXConstructExprBits.ZeroInitialization;
}
void setRequiresZeroInitialization(bool ZeroInit) {
  CXXConstructExprBits.ZeroInitialization = ZeroInit;
}

/// Determine whether this constructor is actually constructing
/// a base class (rather than a complete object).
ConstructionKind getConstructionKind() const {
  return static_cast<ConstructionKind>(CXXConstructExprBits.ConstructionKind);
}
void setConstructionKind(ConstructionKind CK) {
  CXXConstructExprBits.ConstructionKind = CK;
}

using arg_iterator = ExprIterator;
using const_arg_iterator = ConstExprIterator;
using arg_range = llvm::iterator_range<arg_iterator>;
using const_arg_range = llvm::iterator_range<const_arg_iterator>;

arg_range arguments() { return arg_range(arg_begin(), arg_end()); }
const_arg_range arguments() const {
  return const_arg_range(arg_begin(), arg_end());
}

arg_iterator arg_begin() { return getTrailingArgs(); }
arg_iterator arg_end() { return arg_begin() + getNumArgs(); }
const_arg_iterator arg_begin() const { return getTrailingArgs(); }
const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }

Expr **getArgs() { return reinterpret_cast<Expr **>(getTrailingArgs()); }
const Expr *const *getArgs() const {
  return reinterpret_cast<const Expr *const *>(getTrailingArgs());
}

/// Return the number of arguments to the constructor call.
unsigned getNumArgs() const { return NumArgs; }

/// Return the specified argument.
Expr *getArg(unsigned Arg) {
  assert(Arg < getNumArgs() && "Arg access out of range!")((void)0);
  return getArgs()[Arg];
}
const Expr *getArg(unsigned Arg) const {
  assert(Arg < getNumArgs() && "Arg access out of range!")((void)0);
  return getArgs()[Arg];
}

/// Set the specified argument.
void setArg(unsigned Arg, Expr *ArgExpr) {
  assert(Arg < getNumArgs() && "Arg access out of range!")((void)0);
  getArgs()[Arg] = ArgExpr;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));
SourceRange getParenOrBraceRange() const { return ParenOrBraceRange; }
void setParenOrBraceRange(SourceRange Range) { ParenOrBraceRange = Range; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXConstructExprClass ||
         T->getStmtClass() == CXXTemporaryObjectExprClass;
}

// Iterators
child_range children() {
  return child_range(getTrailingArgs(), getTrailingArgs() + getNumArgs());
}

const_child_range children() const {
  auto Children = const_cast<CXXConstructExpr *>(this)->children();
  return const_child_range(Children.begin(), Children.end());
}
1645};

1647/// Represents a call to an inherited base class constructor from an
1648/// inheriting constructor. This call implicitly forwards the arguments from
1649/// the enclosing context (an inheriting constructor) to the specified inherited
1650/// base class constructor.
1651class CXXInheritedCtorInitExpr : public Expr {
1652private:
CXXConstructorDecl *Constructor = nullptr;

/// The location of the using declaration.
SourceLocation Loc;

/// Whether this is the construction of a virtual base.
unsigned ConstructsVirtualBase : 1;

/// Whether the constructor is inherited from a virtual base class of the
/// class that we construct.
unsigned InheritedFromVirtualBase : 1;

1665public:
friend class ASTStmtReader;

/// Construct a C++ inheriting construction expression.
CXXInheritedCtorInitExpr(SourceLocation Loc, QualType T,
                         CXXConstructorDecl *Ctor, bool ConstructsVirtualBase,
                         bool InheritedFromVirtualBase)
    : Expr(CXXInheritedCtorInitExprClass, T, VK_PRValue, OK_Ordinary),
      Constructor(Ctor), Loc(Loc),
      ConstructsVirtualBase(ConstructsVirtualBase),
      InheritedFromVirtualBase(InheritedFromVirtualBase) {
  assert(!T->isDependentType())((void)0);
  setDependence(ExprDependence::None);
}

/// Construct an empty C++ inheriting construction expression.
explicit CXXInheritedCtorInitExpr(EmptyShell Empty)
    : Expr(CXXInheritedCtorInitExprClass, Empty),
      ConstructsVirtualBase(false), InheritedFromVirtualBase(false) {}

/// Get the constructor that this expression will call.
CXXConstructorDecl *getConstructor() const { return Constructor; }

/// Determine whether this constructor is actually constructing
/// a base class (rather than a complete object).
bool constructsVBase() const { return ConstructsVirtualBase; }
CXXConstructExpr::ConstructionKind getConstructionKind() const {
  return ConstructsVirtualBase ? CXXConstructExpr::CK_VirtualBase
                               : CXXConstructExpr::CK_NonVirtualBase;
}

/// Determine whether the inherited constructor is inherited from a
/// virtual base of the object we construct. If so, we are not responsible
/// for calling the inherited constructor (the complete object constructor
/// does that), and so we don't need to pass any arguments.
bool inheritedFromVBase() const { return InheritedFromVirtualBase; }

SourceLocation getLocation() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXInheritedCtorInitExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
1717};

1719/// Represents an explicit C++ type conversion that uses "functional"
1720/// notation (C++ [expr.type.conv]).
1721///
1722/// Example:
1723/// \code
1724///   x = int(0.5);
1725/// \endcode
1726class CXXFunctionalCastExpr final
  : public ExplicitCastExpr,
    private llvm::TrailingObjects<CXXFunctionalCastExpr, CXXBaseSpecifier *,
                                  FPOptionsOverride> {
SourceLocation LParenLoc;
SourceLocation RParenLoc;

CXXFunctionalCastExpr(QualType ty, ExprValueKind VK,
                      TypeSourceInfo *writtenTy, CastKind kind,
                      Expr *castExpr, unsigned pathSize,
                      FPOptionsOverride FPO, SourceLocation lParenLoc,
                      SourceLocation rParenLoc)
    : ExplicitCastExpr(CXXFunctionalCastExprClass, ty, VK, kind, castExpr,
                       pathSize, FPO.requiresTrailingStorage(), writtenTy),
      LParenLoc(lParenLoc), RParenLoc(rParenLoc) {
  if (hasStoredFPFeatures())
    *getTrailingFPFeatures() = FPO;
}

explicit CXXFunctionalCastExpr(EmptyShell Shell, unsigned PathSize,
                               bool HasFPFeatures)
    : ExplicitCastExpr(CXXFunctionalCastExprClass, Shell, PathSize,
                       HasFPFeatures) {}

unsigned numTrailingObjects(OverloadToken<CXXBaseSpecifier *>) const {
  return path_size();
}

1754public:
friend class CastExpr;
friend TrailingObjects;

static CXXFunctionalCastExpr *
Create(const ASTContext &Context, QualType T, ExprValueKind VK,
       TypeSourceInfo *Written, CastKind Kind, Expr *Op,
       const CXXCastPath *Path, FPOptionsOverride FPO, SourceLocation LPLoc,
       SourceLocation RPLoc);
static CXXFunctionalCastExpr *
CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures);

SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

/// Determine whether this expression models list-initialization.
bool isListInitialization() const { return LParenLoc.isInvalid(); }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXFunctionalCastExprClass;
}
1780};

1782/// Represents a C++ functional cast expression that builds a
1783/// temporary object.
1784///
1785/// This expression type represents a C++ "functional" cast
1786/// (C++[expr.type.conv]) with N != 1 arguments that invokes a
1787/// constructor to build a temporary object. With N == 1 arguments the
1788/// functional cast expression will be represented by CXXFunctionalCastExpr.
1789/// Example:
1790/// \code
1791/// struct X { X(int, float); }
1792///
1793/// X create_X() {
1794///   return X(1, 3.14f); // creates a CXXTemporaryObjectExpr
1795/// };
1796/// \endcode
1797class CXXTemporaryObjectExpr final : public CXXConstructExpr {
friend class ASTStmtReader;

// CXXTemporaryObjectExpr has some trailing objects belonging
// to CXXConstructExpr. See the comment inside CXXConstructExpr
// for more details.

TypeSourceInfo *TSI;

CXXTemporaryObjectExpr(CXXConstructorDecl *Cons, QualType Ty,
                       TypeSourceInfo *TSI, ArrayRef<Expr *> Args,
                       SourceRange ParenOrBraceRange,
                       bool HadMultipleCandidates, bool ListInitialization,
                       bool StdInitListInitialization,
                       bool ZeroInitialization);

CXXTemporaryObjectExpr(EmptyShell Empty, unsigned NumArgs);

1815public:
static CXXTemporaryObjectExpr *
Create(const ASTContext &Ctx, CXXConstructorDecl *Cons, QualType Ty,
       TypeSourceInfo *TSI, ArrayRef<Expr *> Args,
       SourceRange ParenOrBraceRange, bool HadMultipleCandidates,
       bool ListInitialization, bool StdInitListInitialization,
       bool ZeroInitialization);

static CXXTemporaryObjectExpr *CreateEmpty(const ASTContext &Ctx,
                                           unsigned NumArgs);

TypeSourceInfo *getTypeSourceInfo() const { return TSI; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXTemporaryObjectExprClass;
}
1834};

1836Stmt **CXXConstructExpr::getTrailingArgs() {
if (auto *E = dyn_cast<CXXTemporaryObjectExpr>(this))
  return reinterpret_cast<Stmt **>(E + 1);
assert((getStmtClass() == CXXConstructExprClass) &&((void)0)
       "Unexpected class deriving from CXXConstructExpr!")((void)0);
return reinterpret_cast<Stmt **>(this + 1);
1842}

1844/// A C++ lambda expression, which produces a function object
1845/// (of unspecified type) that can be invoked later.
1846///
1847/// Example:
1848/// \code
1849/// void low_pass_filter(std::vector<double> &values, double cutoff) {
1850///   values.erase(std::remove_if(values.begin(), values.end(),
1851///                               [=](double value) { return value > cutoff; });
1852/// }
1853/// \endcode
1854///
1855/// C++11 lambda expressions can capture local variables, either by copying
1856/// the values of those local variables at the time the function
1857/// object is constructed (not when it is called!) or by holding a
1858/// reference to the local variable. These captures can occur either
1859/// implicitly or can be written explicitly between the square
1860/// brackets ([...]) that start the lambda expression.
1861///
1862/// C++1y introduces a new form of "capture" called an init-capture that
1863/// includes an initializing expression (rather than capturing a variable),
1864/// and which can never occur implicitly.
1865class LambdaExpr final : public Expr,
                       private llvm::TrailingObjects<LambdaExpr, Stmt *> {
// LambdaExpr has some data stored in LambdaExprBits.

/// The source range that covers the lambda introducer ([...]).
SourceRange IntroducerRange;

/// The source location of this lambda's capture-default ('=' or '&').
SourceLocation CaptureDefaultLoc;

/// The location of the closing brace ('}') that completes
/// the lambda.
///
/// The location of the brace is also available by looking up the
/// function call operator in the lambda class. However, it is
/// stored here to improve the performance of getSourceRange(), and
/// to avoid having to deserialize the function call operator from a
/// module file just to determine the source range.
SourceLocation ClosingBrace;

/// Construct a lambda expression.
LambdaExpr(QualType T, SourceRange IntroducerRange,
           LambdaCaptureDefault CaptureDefault,
           SourceLocation CaptureDefaultLoc, bool ExplicitParams,
           bool ExplicitResultType, ArrayRef<Expr *> CaptureInits,
           SourceLocation ClosingBrace, bool ContainsUnexpandedParameterPack);

/// Construct an empty lambda expression.
LambdaExpr(EmptyShell Empty, unsigned NumCaptures);

Stmt **getStoredStmts() { return getTrailingObjects<Stmt *>(); }
Stmt *const *getStoredStmts() const { return getTrailingObjects<Stmt *>(); }

void initBodyIfNeeded() const;

1900public:
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Construct a new lambda expression.
static LambdaExpr *
Create(const ASTContext &C, CXXRecordDecl *Class, SourceRange IntroducerRange,
       LambdaCaptureDefault CaptureDefault, SourceLocation CaptureDefaultLoc,
       bool ExplicitParams, bool ExplicitResultType,
       ArrayRef<Expr *> CaptureInits, SourceLocation ClosingBrace,
       bool ContainsUnexpandedParameterPack);

/// Construct a new lambda expression that will be deserialized from
/// an external source.
static LambdaExpr *CreateDeserialized(const ASTContext &C,
                                      unsigned NumCaptures);

/// Determine the default capture kind for this lambda.
LambdaCaptureDefault getCaptureDefault() const {
  return static_cast<LambdaCaptureDefault>(LambdaExprBits.CaptureDefault);
}

/// Retrieve the location of this lambda's capture-default, if any.
SourceLocation getCaptureDefaultLoc() const { return CaptureDefaultLoc; }

/// Determine whether one of this lambda's captures is an init-capture.
bool isInitCapture(const LambdaCapture *Capture) const;

/// An iterator that walks over the captures of the lambda,
/// both implicit and explicit.
using capture_iterator = const LambdaCapture *;

/// An iterator over a range of lambda captures.
using capture_range = llvm::iterator_range<capture_iterator>;

/// Retrieve this lambda's captures.
capture_range captures() const;

/// Retrieve an iterator pointing to the first lambda capture.
capture_iterator capture_begin() const;

/// Retrieve an iterator pointing past the end of the
/// sequence of lambda captures.
capture_iterator capture_end() const;

/// Determine the number of captures in this lambda.
unsigned capture_size() const { return LambdaExprBits.NumCaptures; }

/// Retrieve this lambda's explicit captures.
capture_range explicit_captures() const;

/// Retrieve an iterator pointing to the first explicit
/// lambda capture.
capture_iterator explicit_capture_begin() const;

/// Retrieve an iterator pointing past the end of the sequence of
/// explicit lambda captures.
capture_iterator explicit_capture_end() const;

/// Retrieve this lambda's implicit captures.
capture_range implicit_captures() const;

/// Retrieve an iterator pointing to the first implicit
/// lambda capture.
capture_iterator implicit_capture_begin() const;

/// Retrieve an iterator pointing past the end of the sequence of
/// implicit lambda captures.
capture_iterator implicit_capture_end() const;

/// Iterator that walks over the capture initialization
/// arguments.
using capture_init_iterator = Expr **;

/// Const iterator that walks over the capture initialization
/// arguments.
/// FIXME: This interface is prone to being used incorrectly.
using const_capture_init_iterator = Expr *const *;

/// Retrieve the initialization expressions for this lambda's captures.
llvm::iterator_range<capture_init_iterator> capture_inits() {
  return llvm::make_range(capture_init_begin(), capture_init_end());
}

/// Retrieve the initialization expressions for this lambda's captures.
llvm::iterator_range<const_capture_init_iterator> capture_inits() const {
  return llvm::make_range(capture_init_begin(), capture_init_end());
}

/// Retrieve the first initialization argument for this
/// lambda expression (which initializes the first capture field).
capture_init_iterator capture_init_begin() {
  return reinterpret_cast<Expr **>(getStoredStmts());
}

/// Retrieve the first initialization argument for this
/// lambda expression (which initializes the first capture field).
const_capture_init_iterator capture_init_begin() const {
  return reinterpret_cast<Expr *const *>(getStoredStmts());
}

/// Retrieve the iterator pointing one past the last
/// initialization argument for this lambda expression.
capture_init_iterator capture_init_end() {
  return capture_init_begin() + capture_size();
}

/// Retrieve the iterator pointing one past the last
/// initialization argument for this lambda expression.
const_capture_init_iterator capture_init_end() const {
  return capture_init_begin() + capture_size();
}

/// Retrieve the source range covering the lambda introducer,
/// which contains the explicit capture list surrounded by square
/// brackets ([...]).
SourceRange getIntroducerRange() const { return IntroducerRange; }

/// Retrieve the class that corresponds to the lambda.
///
/// This is the "closure type" (C++1y [expr.prim.lambda]), and stores the
/// captures in its fields and provides the various operations permitted
/// on a lambda (copying, calling).
CXXRecordDecl *getLambdaClass() const;

/// Retrieve the function call operator associated with this
/// lambda expression.
CXXMethodDecl *getCallOperator() const;

/// Retrieve the function template call operator associated with this
/// lambda expression.
FunctionTemplateDecl *getDependentCallOperator() const;

/// If this is a generic lambda expression, retrieve the template
/// parameter list associated with it, or else return null.
TemplateParameterList *getTemplateParameterList() const;

/// Get the template parameters were explicitly specified (as opposed to being
/// invented by use of an auto parameter).
ArrayRef<NamedDecl *> getExplicitTemplateParameters() const;

/// Get the trailing requires clause, if any.
Expr *getTrailingRequiresClause() const;

/// Whether this is a generic lambda.
bool isGenericLambda() const { return getTemplateParameterList(); }

/// Retrieve the body of the lambda. This will be most of the time
/// a \p CompoundStmt, but can also be \p CoroutineBodyStmt wrapping
/// a \p CompoundStmt. Note that unlike functions, lambda-expressions
/// cannot have a function-try-block.
Stmt *getBody() const;

/// Retrieve the \p CompoundStmt representing the body of the lambda.
/// This is a convenience function for callers who do not need
/// to handle node(s) which may wrap a \p CompoundStmt.
const CompoundStmt *getCompoundStmtBody() const;
CompoundStmt *getCompoundStmtBody() {
  const auto *ConstThis = this;
  return const_cast<CompoundStmt *>(ConstThis->getCompoundStmtBody());
}

/// Determine whether the lambda is mutable, meaning that any
/// captures values can be modified.
bool isMutable() const;

/// Determine whether this lambda has an explicit parameter
/// list vs. an implicit (empty) parameter list.
bool hasExplicitParameters() const { return LambdaExprBits.ExplicitParams; }

/// Whether this lambda had its result type explicitly specified.
bool hasExplicitResultType() const {
  return LambdaExprBits.ExplicitResultType;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == LambdaExprClass;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return IntroducerRange.getBegin();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return ClosingBrace; }

/// Includes the captures and the body of the lambda.
child_range children();
const_child_range children() const;
2089};

2091/// An expression "T()" which creates a value-initialized rvalue of type
2092/// T, which is a non-class type.  See (C++98 [5.2.3p2]).
2093class CXXScalarValueInitExpr : public Expr {
friend class ASTStmtReader;

TypeSourceInfo *TypeInfo;

2098public:
/// Create an explicitly-written scalar-value initialization
/// expression.
CXXScalarValueInitExpr(QualType Type, TypeSourceInfo *TypeInfo,
                       SourceLocation RParenLoc)
    : Expr(CXXScalarValueInitExprClass, Type, VK_PRValue, OK_Ordinary),
      TypeInfo(TypeInfo) {
  CXXScalarValueInitExprBits.RParenLoc = RParenLoc;
  setDependence(computeDependence(this));
}

explicit CXXScalarValueInitExpr(EmptyShell Shell)
    : Expr(CXXScalarValueInitExprClass, Shell) {}

TypeSourceInfo *getTypeSourceInfo() const {
  return TypeInfo;
}

SourceLocation getRParenLoc() const {
  return CXXScalarValueInitExprBits.RParenLoc;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const { return getRParenLoc(); }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXScalarValueInitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
2135};

2137/// Represents a new-expression for memory allocation and constructor
2138/// calls, e.g: "new CXXNewExpr(foo)".
2139class CXXNewExpr final
  : public Expr,
    private llvm::TrailingObjects<CXXNewExpr, Stmt *, SourceRange> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Points to the allocation function used.
FunctionDecl *OperatorNew;

/// Points to the deallocation function used in case of error. May be null.
FunctionDecl *OperatorDelete;

/// The allocated type-source information, as written in the source.
TypeSourceInfo *AllocatedTypeInfo;

/// Range of the entire new expression.
SourceRange Range;

/// Source-range of a paren-delimited initializer.
SourceRange DirectInitRange;

// CXXNewExpr is followed by several optional trailing objects.
// They are in order:
//
// * An optional "Stmt *" for the array size expression.
//    Present if and ony if isArray().
//
// * An optional "Stmt *" for the init expression.
//    Present if and only if hasInitializer().
//
// * An array of getNumPlacementArgs() "Stmt *" for the placement new
//   arguments, if any.
//
// * An optional SourceRange for the range covering the parenthesized type-id
//    if the allocated type was expressed as a parenthesized type-id.
//    Present if and only if isParenTypeId().
unsigned arraySizeOffset() const { return 0; }
unsigned initExprOffset() const { return arraySizeOffset() + isArray(); }
unsigned placementNewArgsOffset() const {
  return initExprOffset() + hasInitializer();
}

unsigned numTrailingObjects(OverloadToken<Stmt *>) const {
  return isArray() + hasInitializer() + getNumPlacementArgs();
}

unsigned numTrailingObjects(OverloadToken<SourceRange>) const {
  return isParenTypeId();
}

2190public:
enum InitializationStyle {
  /// New-expression has no initializer as written.
  NoInit,

  /// New-expression has a C++98 paren-delimited initializer.
  CallInit,

  /// New-expression has a C++11 list-initializer.
  ListInit
};

2202private:
/// Build a c++ new expression.
CXXNewExpr(bool IsGlobalNew, FunctionDecl *OperatorNew,
           FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
           bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
           SourceRange TypeIdParens, Optional<Expr *> ArraySize,
           InitializationStyle InitializationStyle, Expr *Initializer,
           QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
           SourceRange DirectInitRange);

/// Build an empty c++ new expression.
CXXNewExpr(EmptyShell Empty, bool IsArray, unsigned NumPlacementArgs,
           bool IsParenTypeId);

2216public:
/// Create a c++ new expression.
static CXXNewExpr *
Create(const ASTContext &Ctx, bool IsGlobalNew, FunctionDecl *OperatorNew,
       FunctionDecl *OperatorDelete, bool ShouldPassAlignment,
       bool UsualArrayDeleteWantsSize, ArrayRef<Expr *> PlacementArgs,
       SourceRange TypeIdParens, Optional<Expr *> ArraySize,
       InitializationStyle InitializationStyle, Expr *Initializer,
       QualType Ty, TypeSourceInfo *AllocatedTypeInfo, SourceRange Range,
       SourceRange DirectInitRange);

/// Create an empty c++ new expression.
static CXXNewExpr *CreateEmpty(const ASTContext &Ctx, bool IsArray,
                               bool HasInit, unsigned NumPlacementArgs,
                               bool IsParenTypeId);

QualType getAllocatedType() const {
  return getType()->castAs<PointerType>()->getPointeeType();
}

TypeSourceInfo *getAllocatedTypeSourceInfo() const {
  return AllocatedTypeInfo;
}

/// True if the allocation result needs to be null-checked.
///
/// C++11 [expr.new]p13:
///   If the allocation function returns null, initialization shall
///   not be done, the deallocation function shall not be called,
///   and the value of the new-expression shall be null.
///
/// C++ DR1748:
///   If the allocation function is a reserved placement allocation
///   function that returns null, the behavior is undefined.
///
/// An allocation function is not allowed to return null unless it
/// has a non-throwing exception-specification.  The '03 rule is
/// identical except that the definition of a non-throwing
/// exception specification is just "is it throw()?".
bool shouldNullCheckAllocation() const;

FunctionDecl *getOperatorNew() const { return OperatorNew; }
void setOperatorNew(FunctionDecl *D) { OperatorNew = D; }
FunctionDecl *getOperatorDelete() const { return OperatorDelete; }
void setOperatorDelete(FunctionDecl *D) { OperatorDelete = D; }

bool isArray() const { return CXXNewExprBits.IsArray; }

Optional<Expr *> getArraySize() {
  if (!isArray())
    return None;
  return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
}
Optional<const Expr *> getArraySize() const {
  if (!isArray())
    return None;
  return cast_or_null<Expr>(getTrailingObjects<Stmt *>()[arraySizeOffset()]);
}

unsigned getNumPlacementArgs() const {
  return CXXNewExprBits.NumPlacementArgs;
}

Expr **getPlacementArgs() {
  return reinterpret_cast<Expr **>(getTrailingObjects<Stmt *>() +
                                   placementNewArgsOffset());
}

Expr *getPlacementArg(unsigned I) {
  assert((I < getNumPlacementArgs()) && "Index out of range!")((void)0);
  return getPlacementArgs()[I];
}
const Expr *getPlacementArg(unsigned I) const {
  return const_cast<CXXNewExpr *>(this)->getPlacementArg(I);
}

bool isParenTypeId() const { return CXXNewExprBits.IsParenTypeId; }
SourceRange getTypeIdParens() const {
  return isParenTypeId() ? getTrailingObjects<SourceRange>()[0]
                         : SourceRange();
}

bool isGlobalNew() const { return CXXNewExprBits.IsGlobalNew; }

/// Whether this new-expression has any initializer at all.
bool hasInitializer() const {
  return CXXNewExprBits.StoredInitializationStyle > 0;
28
←
Assuming field 'StoredInitializationStyle' is > 0→
29
←
Returning the value 1, which participates in a condition later→
}

/// The kind of initializer this new-expression has.
InitializationStyle getInitializationStyle() const {
  if (CXXNewExprBits.StoredInitializationStyle == 0)
    return NoInit;
  return static_cast<InitializationStyle>(
      CXXNewExprBits.StoredInitializationStyle - 1);
}

/// The initializer of this new-expression.
Expr *getInitializer() {
  return hasInitializer()
             ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
             : nullptr;
}
const Expr *getInitializer() const {
  return hasInitializer()
             ? cast<Expr>(getTrailingObjects<Stmt *>()[initExprOffset()])
             : nullptr;
}

/// Returns the CXXConstructExpr from this new-expression, or null.
const CXXConstructExpr *getConstructExpr() const {
  return dyn_cast_or_null<CXXConstructExpr>(getInitializer());
}

/// Indicates whether the required alignment should be implicitly passed to
/// the allocation function.
bool passAlignment() const { return CXXNewExprBits.ShouldPassAlignment; }

/// Answers whether the usual array deallocation function for the
/// allocated type expects the size of the allocation as a
/// parameter.
bool doesUsualArrayDeleteWantSize() const {
  return CXXNewExprBits.UsualArrayDeleteWantsSize;
}

using arg_iterator = ExprIterator;
using const_arg_iterator = ConstExprIterator;

llvm::iterator_range<arg_iterator> placement_arguments() {
  return llvm::make_range(placement_arg_begin(), placement_arg_end());
}

llvm::iterator_range<const_arg_iterator> placement_arguments() const {
  return llvm::make_range(placement_arg_begin(), placement_arg_end());
}

arg_iterator placement_arg_begin() {
  return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
}
arg_iterator placement_arg_end() {
  return placement_arg_begin() + getNumPlacementArgs();
}
const_arg_iterator placement_arg_begin() const {
  return getTrailingObjects<Stmt *>() + placementNewArgsOffset();
}
const_arg_iterator placement_arg_end() const {
  return placement_arg_begin() + getNumPlacementArgs();
}

using raw_arg_iterator = Stmt **;

raw_arg_iterator raw_arg_begin() { return getTrailingObjects<Stmt *>(); }
raw_arg_iterator raw_arg_end() {
  return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
}
const_arg_iterator raw_arg_begin() const {
  return getTrailingObjects<Stmt *>();
}
const_arg_iterator raw_arg_end() const {
  return raw_arg_begin() + numTrailingObjects(OverloadToken<Stmt *>());
}

SourceLocation getBeginLoc() const { return Range.getBegin(); }
SourceLocation getEndLoc() const { return Range.getEnd(); }

SourceRange getDirectInitRange() const { return DirectInitRange; }
SourceRange getSourceRange() const { return Range; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXNewExprClass;
}

// Iterators
child_range children() { return child_range(raw_arg_begin(), raw_arg_end()); }

const_child_range children() const {
  return const_child_range(const_cast<CXXNewExpr *>(this)->children());
}
2394};

2396/// Represents a \c delete expression for memory deallocation and
2397/// destructor calls, e.g. "delete[] pArray".
2398class CXXDeleteExpr : public Expr {
friend class ASTStmtReader;

/// Points to the operator delete overload that is used. Could be a member.
FunctionDecl *OperatorDelete = nullptr;

/// The pointer expression to be deleted.
Stmt *Argument = nullptr;

2407public:
CXXDeleteExpr(QualType Ty, bool GlobalDelete, bool ArrayForm,
              bool ArrayFormAsWritten, bool UsualArrayDeleteWantsSize,
              FunctionDecl *OperatorDelete, Expr *Arg, SourceLocation Loc)
    : Expr(CXXDeleteExprClass, Ty, VK_PRValue, OK_Ordinary),
      OperatorDelete(OperatorDelete), Argument(Arg) {
  CXXDeleteExprBits.GlobalDelete = GlobalDelete;
  CXXDeleteExprBits.ArrayForm = ArrayForm;
  CXXDeleteExprBits.ArrayFormAsWritten = ArrayFormAsWritten;
  CXXDeleteExprBits.UsualArrayDeleteWantsSize = UsualArrayDeleteWantsSize;
  CXXDeleteExprBits.Loc = Loc;
  setDependence(computeDependence(this));
}

explicit CXXDeleteExpr(EmptyShell Shell) : Expr(CXXDeleteExprClass, Shell) {}

bool isGlobalDelete() const { return CXXDeleteExprBits.GlobalDelete; }
bool isArrayForm() const { return CXXDeleteExprBits.ArrayForm; }
bool isArrayFormAsWritten() const {
  return CXXDeleteExprBits.ArrayFormAsWritten;
}

/// Answers whether the usual array deallocation function for the
/// allocated type expects the size of the allocation as a
/// parameter.  This can be true even if the actual deallocation
/// function that we're using doesn't want a size.
bool doesUsualArrayDeleteWantSize() const {
  return CXXDeleteExprBits.UsualArrayDeleteWantsSize;
}

FunctionDecl *getOperatorDelete() const { return OperatorDelete; }

Expr *getArgument() { return cast<Expr>(Argument); }
const Expr *getArgument() const { return cast<Expr>(Argument); }

/// Retrieve the type being destroyed.
///
/// If the type being destroyed is a dependent type which may or may not
/// be a pointer, return an invalid type.
QualType getDestroyedType() const;

SourceLocation getBeginLoc() const { return CXXDeleteExprBits.Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return Argument->getEndLoc();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXDeleteExprClass;
}

// Iterators
child_range children() { return child_range(&Argument, &Argument + 1); }

const_child_range children() const {
  return const_child_range(&Argument, &Argument + 1);
}
2463};

2465/// Stores the type being destroyed by a pseudo-destructor expression.
2466class PseudoDestructorTypeStorage {
/// Either the type source information or the name of the type, if
/// it couldn't be resolved due to type-dependence.
llvm::PointerUnion<TypeSourceInfo *, IdentifierInfo *> Type;

/// The starting source location of the pseudo-destructor type.
SourceLocation Location;

2474public:
PseudoDestructorTypeStorage() = default;

PseudoDestructorTypeStorage(IdentifierInfo *II, SourceLocation Loc)
    : Type(II), Location(Loc) {}

PseudoDestructorTypeStorage(TypeSourceInfo *Info);

TypeSourceInfo *getTypeSourceInfo() const {
  return Type.dyn_cast<TypeSourceInfo *>();
}

IdentifierInfo *getIdentifier() const {
  return Type.dyn_cast<IdentifierInfo *>();
}

SourceLocation getLocation() const { return Location; }
2491};

2493/// Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
2494///
2495/// A pseudo-destructor is an expression that looks like a member access to a
2496/// destructor of a scalar type, except that scalar types don't have
2497/// destructors. For example:
2498///
2499/// \code
2500/// typedef int T;
2501/// void f(int *p) {
2502///   p->T::~T();
2503/// }
2504/// \endcode
2505///
2506/// Pseudo-destructors typically occur when instantiating templates such as:
2507///
2508/// \code
2509/// template<typename T>
2510/// void destroy(T* ptr) {
2511///   ptr->T::~T();
2512/// }
2513/// \endcode
2514///
2515/// for scalar types. A pseudo-destructor expression has no run-time semantics
2516/// beyond evaluating the base expression.
2517class CXXPseudoDestructorExpr : public Expr {
friend class ASTStmtReader;

/// The base expression (that is being destroyed).
Stmt *Base = nullptr;

/// Whether the operator was an arrow ('->'); otherwise, it was a
/// period ('.').
bool IsArrow : 1;

/// The location of the '.' or '->' operator.
SourceLocation OperatorLoc;

/// The nested-name-specifier that follows the operator, if present.
NestedNameSpecifierLoc QualifierLoc;

/// The type that precedes the '::' in a qualified pseudo-destructor
/// expression.
TypeSourceInfo *ScopeType = nullptr;

/// The location of the '::' in a qualified pseudo-destructor
/// expression.
SourceLocation ColonColonLoc;

/// The location of the '~'.
SourceLocation TildeLoc;

/// The type being destroyed, or its name if we were unable to
/// resolve the name.
PseudoDestructorTypeStorage DestroyedType;

2548public:
CXXPseudoDestructorExpr(const ASTContext &Context,
                        Expr *Base, bool isArrow, SourceLocation OperatorLoc,
                        NestedNameSpecifierLoc QualifierLoc,
                        TypeSourceInfo *ScopeType,
                        SourceLocation ColonColonLoc,
                        SourceLocation TildeLoc,
                        PseudoDestructorTypeStorage DestroyedType);

explicit CXXPseudoDestructorExpr(EmptyShell Shell)
    : Expr(CXXPseudoDestructorExprClass, Shell), IsArrow(false) {}

Expr *getBase() const { return cast<Expr>(Base); }

/// Determines whether this member expression actually had
/// a C++ nested-name-specifier prior to the name of the member, e.g.,
/// x->Base::foo.
bool hasQualifier() const { return QualifierLoc.hasQualifier(); }

/// Retrieves the nested-name-specifier that qualifies the type name,
/// with source-location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// If the member name was qualified, retrieves the
/// nested-name-specifier that precedes the member name. Otherwise, returns
/// null.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Determine whether this pseudo-destructor expression was written
/// using an '->' (otherwise, it used a '.').
bool isArrow() const { return IsArrow; }

/// Retrieve the location of the '.' or '->' operator.
SourceLocation getOperatorLoc() const { return OperatorLoc; }

/// Retrieve the scope type in a qualified pseudo-destructor
/// expression.
///
/// Pseudo-destructor expressions can have extra qualification within them
/// that is not part of the nested-name-specifier, e.g., \c p->T::~T().
/// Here, if the object type of the expression is (or may be) a scalar type,
/// \p T may also be a scalar type and, therefore, cannot be part of a
/// nested-name-specifier. It is stored as the "scope type" of the pseudo-
/// destructor expression.
TypeSourceInfo *getScopeTypeInfo() const { return ScopeType; }

/// Retrieve the location of the '::' in a qualified pseudo-destructor
/// expression.
SourceLocation getColonColonLoc() const { return ColonColonLoc; }

/// Retrieve the location of the '~'.
SourceLocation getTildeLoc() const { return TildeLoc; }

/// Retrieve the source location information for the type
/// being destroyed.
///
/// This type-source information is available for non-dependent
/// pseudo-destructor expressions and some dependent pseudo-destructor
/// expressions. Returns null if we only have the identifier for a
/// dependent pseudo-destructor expression.
TypeSourceInfo *getDestroyedTypeInfo() const {
  return DestroyedType.getTypeSourceInfo();
}

/// In a dependent pseudo-destructor expression for which we do not
/// have full type information on the destroyed type, provides the name
/// of the destroyed type.
IdentifierInfo *getDestroyedTypeIdentifier() const {
  return DestroyedType.getIdentifier();
}

/// Retrieve the type being destroyed.
QualType getDestroyedType() const;

/// Retrieve the starting location of the type being destroyed.
SourceLocation getDestroyedTypeLoc() const {
  return DestroyedType.getLocation();
}

/// Set the name of destroyed type for a dependent pseudo-destructor
/// expression.
void setDestroyedType(IdentifierInfo *II, SourceLocation Loc) {
  DestroyedType = PseudoDestructorTypeStorage(II, Loc);
}

/// Set the destroyed type.
void setDestroyedType(TypeSourceInfo *Info) {
  DestroyedType = PseudoDestructorTypeStorage(Info);
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return Base->getBeginLoc();
}
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__));

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXPseudoDestructorExprClass;
}

// Iterators
child_range children() { return child_range(&Base, &Base + 1); }

const_child_range children() const {
  return const_child_range(&Base, &Base + 1);
}
2655};

2657/// A type trait used in the implementation of various C++11 and
2658/// Library TR1 trait templates.
2659///
2660/// \code
2661///   __is_pod(int) == true
2662///   __is_enum(std::string) == false
2663///   __is_trivially_constructible(vector<int>, int*, int*)
2664/// \endcode
2665class TypeTraitExpr final
  : public Expr,
    private llvm::TrailingObjects<TypeTraitExpr, TypeSourceInfo *> {
/// The location of the type trait keyword.
SourceLocation Loc;

///  The location of the closing parenthesis.
SourceLocation RParenLoc;

// Note: The TypeSourceInfos for the arguments are allocated after the
// TypeTraitExpr.

TypeTraitExpr(QualType T, SourceLocation Loc, TypeTrait Kind,
              ArrayRef<TypeSourceInfo *> Args,
              SourceLocation RParenLoc,
              bool Value);

TypeTraitExpr(EmptyShell Empty) : Expr(TypeTraitExprClass, Empty) {}

size_t numTrailingObjects(OverloadToken<TypeSourceInfo *>) const {
  return getNumArgs();
}

2688public:
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// Create a new type trait expression.
static TypeTraitExpr *Create(const ASTContext &C, QualType T,
                             SourceLocation Loc, TypeTrait Kind,
                             ArrayRef<TypeSourceInfo *> Args,
                             SourceLocation RParenLoc,
                             bool Value);

static TypeTraitExpr *CreateDeserialized(const ASTContext &C,
                                         unsigned NumArgs);

/// Determine which type trait this expression uses.
TypeTrait getTrait() const {
  return static_cast<TypeTrait>(TypeTraitExprBits.Kind);
}

bool getValue() const {
  assert(!isValueDependent())((void)0);
  return TypeTraitExprBits.Value;
}

/// Determine the number of arguments to this type trait.
unsigned getNumArgs() const { return TypeTraitExprBits.NumArgs; }

/// Retrieve the Ith argument.
TypeSourceInfo *getArg(unsigned I) const {
  assert(I < getNumArgs() && "Argument out-of-range")((void)0);
  return getArgs()[I];
}

/// Retrieve the argument types.
ArrayRef<TypeSourceInfo *> getArgs() const {
  return llvm::makeArrayRef(getTrailingObjects<TypeSourceInfo *>(),
                            getNumArgs());
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParenLoc; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == TypeTraitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
2743};

2745/// An Embarcadero array type trait, as used in the implementation of
2746/// __array_rank and __array_extent.
2747///
2748/// Example:
2749/// \code
2750///   __array_rank(int[10][20]) == 2
2751///   __array_extent(int, 1)    == 20
2752/// \endcode
2753class ArrayTypeTraitExpr : public Expr {
/// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
unsigned ATT : 2;

/// The value of the type trait. Unspecified if dependent.
uint64_t Value = 0;

/// The array dimension being queried, or -1 if not used.
Expr *Dimension;

/// The location of the type trait keyword.
SourceLocation Loc;

/// The location of the closing paren.
SourceLocation RParen;

/// The type being queried.
TypeSourceInfo *QueriedType = nullptr;

2772public:
friend class ASTStmtReader;

ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
                   TypeSourceInfo *queried, uint64_t value, Expr *dimension,
                   SourceLocation rparen, QualType ty)
    : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary), ATT(att),
      Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
      QueriedType(queried) {
  assert(att <= ATT_Last && "invalid enum value!")((void)0);
  assert(static_cast<unsigned>(att) == ATT && "ATT overflow!")((void)0);
  setDependence(computeDependence(this));
}

explicit ArrayTypeTraitExpr(EmptyShell Empty)
    : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParen; }

ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }

QualType getQueriedType() const { return QueriedType->getType(); }

TypeSourceInfo *getQueriedTypeSourceInfo() const { return QueriedType; }

uint64_t getValue() const { assert(!isTypeDependent())((void)0); return Value; }

Expr *getDimensionExpression() const { return Dimension; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ArrayTypeTraitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
2814};

2816/// An expression trait intrinsic.
2817///
2818/// Example:
2819/// \code
2820///   __is_lvalue_expr(std::cout) == true
2821///   __is_lvalue_expr(1) == false
2822/// \endcode
2823class ExpressionTraitExpr : public Expr {
/// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
unsigned ET : 31;

/// The value of the type trait. Unspecified if dependent.
unsigned Value : 1;

/// The location of the type trait keyword.
SourceLocation Loc;

/// The location of the closing paren.
SourceLocation RParen;

/// The expression being queried.
Expr* QueriedExpression = nullptr;

2839public:
friend class ASTStmtReader;

ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried,
                    bool value, SourceLocation rparen, QualType resultType)
    : Expr(ExpressionTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
      ET(et), Value(value), Loc(loc), RParen(rparen),
      QueriedExpression(queried) {
  assert(et <= ET_Last && "invalid enum value!")((void)0);
  assert(static_cast<unsigned>(et) == ET && "ET overflow!")((void)0);
  setDependence(computeDependence(this));
}

explicit ExpressionTraitExpr(EmptyShell Empty)
    : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) { return RParen; }

ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }

Expr *getQueriedExpression() const { return QueriedExpression; }

bool getValue() const { return Value; }

static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExpressionTraitExprClass;
}

// Iterators
child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
2876};

2878/// A reference to an overloaded function set, either an
2879/// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.
2880class OverloadExpr : public Expr {
friend class ASTStmtReader;
friend class ASTStmtWriter;

/// The common name of these declarations.
DeclarationNameInfo NameInfo;

/// The nested-name-specifier that qualifies the name, if any.
NestedNameSpecifierLoc QualifierLoc;

2890protected:
OverloadExpr(StmtClass SC, const ASTContext &Context,
             NestedNameSpecifierLoc QualifierLoc,
             SourceLocation TemplateKWLoc,
             const DeclarationNameInfo &NameInfo,
             const TemplateArgumentListInfo *TemplateArgs,
             UnresolvedSetIterator Begin, UnresolvedSetIterator End,
             bool KnownDependent, bool KnownInstantiationDependent,
             bool KnownContainsUnexpandedParameterPack);

OverloadExpr(StmtClass SC, EmptyShell Empty, unsigned NumResults,
             bool HasTemplateKWAndArgsInfo);

/// Return the results. Defined after UnresolvedMemberExpr.
inline DeclAccessPair *getTrailingResults();
const DeclAccessPair *getTrailingResults() const {
  return const_cast<OverloadExpr *>(this)->getTrailingResults();
}

/// Return the optional template keyword and arguments info.
/// Defined after UnresolvedMemberExpr.
inline ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo();
const ASTTemplateKWAndArgsInfo *getTrailingASTTemplateKWAndArgsInfo() const {
  return const_cast<OverloadExpr *>(this)
      ->getTrailingASTTemplateKWAndArgsInfo();
}

/// Return the optional template arguments. Defined after
/// UnresolvedMemberExpr.
inline TemplateArgumentLoc *getTrailingTemplateArgumentLoc();
const TemplateArgumentLoc *getTrailingTemplateArgumentLoc() const {
  return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc();
}

bool hasTemplateKWAndArgsInfo() const {
  return OverloadExprBits.HasTemplateKWAndArgsInfo;
}

2928public:
struct FindResult {
  OverloadExpr *Expression;
  bool IsAddressOfOperand;
  bool HasFormOfMemberPointer;
};

/// Finds the overloaded expression in the given expression \p E of
/// OverloadTy.
///
/// \return the expression (which must be there) and true if it has
/// the particular form of a member pointer expression
static FindResult find(Expr *E) {
  assert(E->getType()->isSpecificBuiltinType(BuiltinType::Overload))((void)0);

  FindResult Result;

  E = E->IgnoreParens();
  if (isa<UnaryOperator>(E)) {
    assert(cast<UnaryOperator>(E)->getOpcode() == UO_AddrOf)((void)0);
    E = cast<UnaryOperator>(E)->getSubExpr();
    auto *Ovl = cast<OverloadExpr>(E->IgnoreParens());

    Result.HasFormOfMemberPointer = (E == Ovl && Ovl->getQualifier());
    Result.IsAddressOfOperand = true;
    Result.Expression = Ovl;
  } else {
    Result.HasFormOfMemberPointer = false;
    Result.IsAddressOfOperand = false;
    Result.Expression = cast<OverloadExpr>(E);
  }

  return Result;
}

/// Gets the naming class of this lookup, if any.
/// Defined after UnresolvedMemberExpr.
inline CXXRecordDecl *getNamingClass();
const CXXRecordDecl *getNamingClass() const {
  return const_cast<OverloadExpr *>(this)->getNamingClass();
}

using decls_iterator = UnresolvedSetImpl::iterator;

decls_iterator decls_begin() const {
  return UnresolvedSetIterator(getTrailingResults());
}
decls_iterator decls_end() const {
  return UnresolvedSetIterator(getTrailingResults() + getNumDecls());
}
llvm::iterator_range<decls_iterator> decls() const {
  return llvm::make_range(decls_begin(), decls_end());
}

/// Gets the number of declarations in the unresolved set.
unsigned getNumDecls() const { return OverloadExprBits.NumResults; }

/// Gets the full name info.
const DeclarationNameInfo &getNameInfo() const { return NameInfo; }

/// Gets the name looked up.
DeclarationName getName() const { return NameInfo.getName(); }

/// Gets the location of the name.
SourceLocation getNameLoc() const { return NameInfo.getLoc(); }

/// Fetches the nested-name qualifier, if one was given.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Fetches the nested-name qualifier with source-location
/// information, if one was given.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// Retrieve the location of the template keyword preceding
/// this name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingASTTemplateKWAndArgsInfo()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingASTTemplateKWAndArgsInfo()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingASTTemplateKWAndArgsInfo()->RAngleLoc;
}

/// Determines whether the name was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this expression had explicit template arguments.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

TemplateArgumentLoc const *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;
  return const_cast<OverloadExpr *>(this)->getTrailingTemplateArgumentLoc();
}

unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingASTTemplateKWAndArgsInfo()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Copies the template arguments into the given structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingASTTemplateKWAndArgsInfo()->copyInto(getTemplateArgs(), List);
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnresolvedLookupExprClass ||
         T->getStmtClass() == UnresolvedMemberExprClass;
}
3060};

3062/// A reference to a name which we were able to look up during
3063/// parsing but could not resolve to a specific declaration.
3064///
3065/// This arises in several ways:
3066///   * we might be waiting for argument-dependent lookup;
3067///   * the name might resolve to an overloaded function;
3068/// and eventually:
3069///   * the lookup might have included a function template.
3070///
3071/// These never include UnresolvedUsingValueDecls, which are always class
3072/// members and therefore appear only in UnresolvedMemberLookupExprs.
3073class UnresolvedLookupExpr final
  : public OverloadExpr,
    private llvm::TrailingObjects<UnresolvedLookupExpr, DeclAccessPair,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
friend class ASTStmtReader;
friend class OverloadExpr;
friend TrailingObjects;

/// The naming class (C++ [class.access.base]p5) of the lookup, if
/// any.  This can generally be recalculated from the context chain,
/// but that can be fairly expensive for unqualified lookups.
CXXRecordDecl *NamingClass;

// UnresolvedLookupExpr is followed by several trailing objects.
// They are in order:
//
// * An array of getNumResults() DeclAccessPair for the results. These are
//   undesugared, which is to say, they may include UsingShadowDecls.
//   Access is relative to the naming class.
//
// * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
//   template keyword and arguments. Present if and only if
//   hasTemplateKWAndArgsInfo().
//
// * An array of getNumTemplateArgs() TemplateArgumentLoc containing
//   location information for the explicitly specified template arguments.

UnresolvedLookupExpr(const ASTContext &Context, CXXRecordDecl *NamingClass,
                     NestedNameSpecifierLoc QualifierLoc,
                     SourceLocation TemplateKWLoc,
                     const DeclarationNameInfo &NameInfo, bool RequiresADL,
                     bool Overloaded,
                     const TemplateArgumentListInfo *TemplateArgs,
                     UnresolvedSetIterator Begin, UnresolvedSetIterator End);

UnresolvedLookupExpr(EmptyShell Empty, unsigned NumResults,
                     bool HasTemplateKWAndArgsInfo);

unsigned numTrailingObjects(OverloadToken<DeclAccessPair>) const {
  return getNumDecls();
}

unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

3120public:
static UnresolvedLookupExpr *
Create(const ASTContext &Context, CXXRecordDecl *NamingClass,
       NestedNameSpecifierLoc QualifierLoc,
       const DeclarationNameInfo &NameInfo, bool RequiresADL, bool Overloaded,
       UnresolvedSetIterator Begin, UnresolvedSetIterator End);

static UnresolvedLookupExpr *
Create(const ASTContext &Context, CXXRecordDecl *NamingClass,
       NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc,
       const DeclarationNameInfo &NameInfo, bool RequiresADL,
       const TemplateArgumentListInfo *Args, UnresolvedSetIterator Begin,
       UnresolvedSetIterator End);

static UnresolvedLookupExpr *CreateEmpty(const ASTContext &Context,
                                         unsigned NumResults,
                                         bool HasTemplateKWAndArgsInfo,
                                         unsigned NumTemplateArgs);

/// True if this declaration should be extended by
/// argument-dependent lookup.
bool requiresADL() const { return UnresolvedLookupExprBits.RequiresADL; }

/// True if this lookup is overloaded.
bool isOverloaded() const { return UnresolvedLookupExprBits.Overloaded; }

/// Gets the 'naming class' (in the sense of C++0x
/// [class.access.base]p5) of the lookup.  This is the scope
/// that was looked in to find these results.
CXXRecordDecl *getNamingClass() { return NamingClass; }
const CXXRecordDecl *getNamingClass() const { return NamingClass; }

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (NestedNameSpecifierLoc l = getQualifierLoc())
    return l.getBeginLoc();
  return getNameInfo().getBeginLoc();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasExplicitTemplateArgs())
    return getRAngleLoc();
  return getNameInfo().getEndLoc();
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == UnresolvedLookupExprClass;
}
3175};

3177/// A qualified reference to a name whose declaration cannot
3178/// yet be resolved.
3179///
3180/// DependentScopeDeclRefExpr is similar to DeclRefExpr in that
3181/// it expresses a reference to a declaration such as
3182/// X<T>::value. The difference, however, is that an
3183/// DependentScopeDeclRefExpr node is used only within C++ templates when
3184/// the qualification (e.g., X<T>::) refers to a dependent type. In
3185/// this case, X<T>::value cannot resolve to a declaration because the
3186/// declaration will differ from one instantiation of X<T> to the
3187/// next. Therefore, DependentScopeDeclRefExpr keeps track of the
3188/// qualifier (X<T>::) and the name of the entity being referenced
3189/// ("value"). Such expressions will instantiate to a DeclRefExpr once the
3190/// declaration can be found.
3191class DependentScopeDeclRefExpr final
  : public Expr,
    private llvm::TrailingObjects<DependentScopeDeclRefExpr,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The nested-name-specifier that qualifies this unresolved
/// declaration name.
NestedNameSpecifierLoc QualifierLoc;

/// The name of the entity we will be referencing.
DeclarationNameInfo NameInfo;

DependentScopeDeclRefExpr(QualType Ty, NestedNameSpecifierLoc QualifierLoc,
                          SourceLocation TemplateKWLoc,
                          const DeclarationNameInfo &NameInfo,
                          const TemplateArgumentListInfo *Args);

size_t numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

bool hasTemplateKWAndArgsInfo() const {
  return DependentScopeDeclRefExprBits.HasTemplateKWAndArgsInfo;
}

3220public:
static DependentScopeDeclRefExpr *
Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, const DeclarationNameInfo &NameInfo,
       const TemplateArgumentListInfo *TemplateArgs);

static DependentScopeDeclRefExpr *CreateEmpty(const ASTContext &Context,
                                              bool HasTemplateKWAndArgsInfo,
                                              unsigned NumTemplateArgs);

/// Retrieve the name that this expression refers to.
const DeclarationNameInfo &getNameInfo() const { return NameInfo; }

/// Retrieve the name that this expression refers to.
DeclarationName getDeclName() const { return NameInfo.getName(); }

/// Retrieve the location of the name within the expression.
///
/// For example, in "X<T>::value" this is the location of "value".
SourceLocation getLocation() const { return NameInfo.getLoc(); }

/// Retrieve the nested-name-specifier that qualifies the
/// name, with source location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// Retrieve the nested-name-specifier that qualifies this
/// declaration.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Retrieve the location of the template keyword preceding
/// this name, if any.
SourceLocation getTemplateKeywordLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->TemplateKWLoc;
}

/// Retrieve the location of the left angle bracket starting the
/// explicit template argument list following the name, if any.
SourceLocation getLAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->LAngleLoc;
}

/// Retrieve the location of the right angle bracket ending the
/// explicit template argument list following the name, if any.
SourceLocation getRAngleLoc() const {
  if (!hasTemplateKWAndArgsInfo())
    return SourceLocation();
  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->RAngleLoc;
}

/// Determines whether the name was preceded by the template keyword.
bool hasTemplateKeyword() const { return getTemplateKeywordLoc().isValid(); }

/// Determines whether this lookup had explicit template arguments.
bool hasExplicitTemplateArgs() const { return getLAngleLoc().isValid(); }

/// Copies the template arguments (if present) into the given
/// structure.
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const {
  if (hasExplicitTemplateArgs())
    getTrailingObjects<ASTTemplateKWAndArgsInfo>()->copyInto(
        getTrailingObjects<TemplateArgumentLoc>(), List);
}

TemplateArgumentLoc const *getTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return nullptr;

  return getTrailingObjects<TemplateArgumentLoc>();
}

unsigned getNumTemplateArgs() const {
  if (!hasExplicitTemplateArgs())
    return 0;

  return getTrailingObjects<ASTTemplateKWAndArgsInfo>()->NumTemplateArgs;
}

ArrayRef<TemplateArgumentLoc> template_arguments() const {
  return {getTemplateArgs(), getNumTemplateArgs()};
}

/// Note: getBeginLoc() is the start of the whole DependentScopeDeclRefExpr,
/// and differs from getLocation().getStart().
SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return QualifierLoc.getBeginLoc();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (hasExplicitTemplateArgs())
    return getRAngleLoc();
  return getLocation();
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == DependentScopeDeclRefExprClass;
}

child_range children() {
  return child_range(child_iterator(), child_iterator());
}

const_child_range children() const {
  return const_child_range(const_child_iterator(), const_child_iterator());
}
3330};

3332/// Represents an expression -- generally a full-expression -- that
3333/// introduces cleanups to be run at the end of the sub-expression's
3334/// evaluation.  The most common source of expression-introduced
3335/// cleanups is temporary objects in C++, but several other kinds of
3336/// expressions can create cleanups, including basically every
3337/// call in ARC that returns an Objective-C pointer.
3338///
3339/// This expression also tracks whether the sub-expression contains a
3340/// potentially-evaluated block literal.  The lifetime of a block
3341/// literal is the extent of the enclosing scope.
3342class ExprWithCleanups final
  : public FullExpr,
    private llvm::TrailingObjects<
        ExprWithCleanups,
        llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>> {
3347public:
/// The type of objects that are kept in the cleanup.
/// It's useful to remember the set of blocks and block-scoped compound
/// literals; we could also remember the set of temporaries, but there's
/// currently no need.
using CleanupObject = llvm::PointerUnion<BlockDecl *, CompoundLiteralExpr *>;

3354private:
friend class ASTStmtReader;
friend TrailingObjects;

ExprWithCleanups(EmptyShell, unsigned NumObjects);
ExprWithCleanups(Expr *SubExpr, bool CleanupsHaveSideEffects,
                 ArrayRef<CleanupObject> Objects);

3362public:
static ExprWithCleanups *Create(const ASTContext &C, EmptyShell empty,
                                unsigned numObjects);

static ExprWithCleanups *Create(const ASTContext &C, Expr *subexpr,
                                bool CleanupsHaveSideEffects,
                                ArrayRef<CleanupObject> objects);

ArrayRef<CleanupObject> getObjects() const {
  return llvm::makeArrayRef(getTrailingObjects<CleanupObject>(),
                            getNumObjects());
}

unsigned getNumObjects() const { return ExprWithCleanupsBits.NumObjects; }

CleanupObject getObject(unsigned i) const {
  assert(i < getNumObjects() && "Index out of range")((void)0);
  return getObjects()[i];
}

bool cleanupsHaveSideEffects() const {
  return ExprWithCleanupsBits.CleanupsHaveSideEffects;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getBeginLoc();
}

SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  return SubExpr->getEndLoc();
}

// Implement isa/cast/dyncast/etc.
static bool classof(const Stmt *T) {
  return T->getStmtClass() == ExprWithCleanupsClass;
}

// Iterators
child_range children() { return child_range(&SubExpr, &SubExpr + 1); }

const_child_range children() const {
  return const_child_range(&SubExpr, &SubExpr + 1);
}
3405};

3407/// Describes an explicit type conversion that uses functional
3408/// notion but could not be resolved because one or more arguments are
3409/// type-dependent.
3410///
3411/// The explicit type conversions expressed by
3412/// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>,
3413/// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and
3414/// either \c T is a dependent type or one or more of the <tt>a</tt>'s is
3415/// type-dependent. For example, this would occur in a template such
3416/// as:
3417///
3418/// \code
3419///   template<typename T, typename A1>
3420///   inline T make_a(const A1& a1) {
3421///     return T(a1);
3422///   }
3423/// \endcode
3424///
3425/// When the returned expression is instantiated, it may resolve to a
3426/// constructor call, conversion function call, or some kind of type
3427/// conversion.
3428class CXXUnresolvedConstructExpr final
  : public Expr,
    private llvm::TrailingObjects<CXXUnresolvedConstructExpr, Expr *> {
friend class ASTStmtReader;
friend TrailingObjects;

/// The type being constructed.
TypeSourceInfo *TSI;

/// The location of the left parentheses ('(').
SourceLocation LParenLoc;

/// The location of the right parentheses (')').
SourceLocation RParenLoc;

CXXUnresolvedConstructExpr(QualType T, TypeSourceInfo *TSI,
                           SourceLocation LParenLoc, ArrayRef<Expr *> Args,
                           SourceLocation RParenLoc);

CXXUnresolvedConstructExpr(EmptyShell Empty, unsigned NumArgs)
    : Expr(CXXUnresolvedConstructExprClass, Empty), TSI(nullptr) {
  CXXUnresolvedConstructExprBits.NumArgs = NumArgs;
}

3452public:
static CXXUnresolvedConstructExpr *Create(const ASTContext &Context,
                                          QualType T, TypeSourceInfo *TSI,
                                          SourceLocation LParenLoc,
                                          ArrayRef<Expr *> Args,
                                          SourceLocation RParenLoc);

static CXXUnresolvedConstructExpr *CreateEmpty(const ASTContext &Context,
                                               unsigned NumArgs);

/// Retrieve the type that is being constructed, as specified
/// in the source code.
QualType getTypeAsWritten() const { return TSI->getType(); }

/// Retrieve the type source information for the type being
/// constructed.
TypeSourceInfo *getTypeSourceInfo() const { return TSI; }

/// Retrieve the location of the left parentheses ('(') that
/// precedes the argument list.
SourceLocation getLParenLoc() const { return LParenLoc; }
void setLParenLoc(SourceLocation L) { LParenLoc = L; }

/// Retrieve the location of the right parentheses (')') that
/// follows the argument list.
SourceLocation getRParenLoc() const { return RParenLoc; }
void setRParenLoc(SourceLocation L) { RParenLoc = L; }

/// Determine whether this expression models list-initialization.
/// If so, there will be exactly one subexpression, which will be
/// an InitListExpr.
bool isListInitialization() const { return LParenLoc.isInvalid(); }

/// Retrieve the number of arguments.
unsigned getNumArgs() const { return CXXUnresolvedConstructExprBits.NumArgs; }

using arg_iterator = Expr **;
using arg_range = llvm::iterator_range<arg_iterator>;

arg_iterator arg_begin() { return getTrailingObjects<Expr *>(); }
arg_iterator arg_end() { return arg_begin() + getNumArgs(); }
arg_range arguments() { return arg_range(arg_begin(), arg_end()); }

using const_arg_iterator = const Expr* const *;
using const_arg_range = llvm::iterator_range<const_arg_iterator>;

const_arg_iterator arg_begin() const { return getTrailingObjects<Expr *>(); }
const_arg_iterator arg_end() const { return arg_begin() + getNumArgs(); }
const_arg_range arguments() const {
  return const_arg_range(arg_begin(), arg_end());
}

Expr *getArg(unsigned I) {
  assert(I < getNumArgs() && "Argument index out-of-range")((void)0);
  return arg_begin()[I];
}

const Expr *getArg(unsigned I) const {
  assert(I < getNumArgs() && "Argument index out-of-range")((void)0);
  return arg_begin()[I];
}

void setArg(unsigned I, Expr *E) {
  assert(I < getNumArgs() && "Argument index out-of-range")((void)0);
  arg_begin()[I] = E;
}

SourceLocation getBeginLoc() const LLVM_READONLY__attribute__((__pure__));
SourceLocation getEndLoc() const LLVM_READONLY__attribute__((__pure__)) {
  if (!RParenLoc.isValid() && getNumArgs() > 0)
    return getArg(getNumArgs() - 1)->getEndLoc();
  return RParenLoc;
}

static bool classof(const Stmt *T) {
  return T->getStmtClass() == CXXUnresolvedConstructExprClass;
}

// Iterators
child_range children() {
  auto **begin = reinterpret_cast<Stmt **>(arg_begin());
  return child_range(begin, begin + getNumArgs());
}

const_child_range children() const {
  auto **begin = reinterpret_cast<Stmt **>(
      const_cast<CXXUnresolvedConstructExpr *>(this)->arg_begin());
  return const_child_range(begin, begin + getNumArgs());
}
3541};

3543/// Represents a C++ member access expression where the actual
3544/// member referenced could not be resolved because the base
3545/// expression or the member name was dependent.
3546///
3547/// Like UnresolvedMemberExprs, these can be either implicit or
3548/// explicit accesses.  It is only possible to get one of these with
3549/// an implicit access if a qualifier is provided.
3550class CXXDependentScopeMemberExpr final
  : public Expr,
    private llvm::TrailingObjects<CXXDependentScopeMemberExpr,
                                  ASTTemplateKWAndArgsInfo,
                                  TemplateArgumentLoc, NamedDecl *> {
friend class ASTStmtReader;
friend class ASTStmtWriter;
friend TrailingObjects;

/// The expression for the base pointer or class reference,
/// e.g., the \c x in x.f.  Can be null in implicit accesses.
Stmt *Base;

/// The type of the base expression.  Never null, even for
/// implicit accesses.
QualType BaseType;

/// The nested-name-specifier that precedes the member name, if any.
/// FIXME: This could be in principle store as a trailing object.
/// However the performance impact of doing so should be investigated first.
NestedNameSpecifierLoc QualifierLoc;

/// The member to which this member expression refers, which
/// can be name, overloaded operator, or destructor.
///
/// FIXME: could also be a template-id
DeclarationNameInfo MemberNameInfo;

// CXXDependentScopeMemberExpr is followed by several trailing objects,
// some of which optional. They are in order:
//
// * An optional ASTTemplateKWAndArgsInfo for the explicitly specified
//   template keyword and arguments. Present if and only if
//   hasTemplateKWAndArgsInfo().
//
// * An array of getNumTemplateArgs() TemplateArgumentLoc containing location
//   information for the explicitly specified template arguments.
//
// * An optional NamedDecl *. In a qualified member access expression such
//   as t->Base::f, this member stores the resolves of name lookup in the
//   context of the member access expression, to be used at instantiation
//   time. Present if and only if hasFirstQualifierFoundInScope().

bool hasTemplateKWAndArgsInfo() const {
  return CXXDependentScopeMemberExprBits.HasTemplateKWAndArgsInfo;
}

bool hasFirstQualifierFoundInScope() const {
  return CXXDependentScopeMemberExprBits.HasFirstQualifierFoundInScope;
}

unsigned numTrailingObjects(OverloadToken<ASTTemplateKWAndArgsInfo>) const {
  return hasTemplateKWAndArgsInfo();
}

unsigned numTrailingObjects(OverloadToken<TemplateArgumentLoc>) const {
  return getNumTemplateArgs();
}

unsigned numTrailingObjects(OverloadToken<NamedDecl *>) const {
  return hasFirstQualifierFoundInScope();
}

CXXDependentScopeMemberExpr(const ASTContext &Ctx, Expr *Base,
                            QualType BaseType, bool IsArrow,
                            SourceLocation OperatorLoc,
                            NestedNameSpecifierLoc QualifierLoc,
                            SourceLocation TemplateKWLoc,
                            NamedDecl *FirstQualifierFoundInScope,
                            DeclarationNameInfo MemberNameInfo,
                            const TemplateArgumentListInfo *TemplateArgs);

CXXDependentScopeMemberExpr(EmptyShell Empty, bool HasTemplateKWAndArgsInfo,
                            bool HasFirstQualifierFoundInScope);

3625public:
static CXXDependentScopeMemberExpr *
Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow,
       SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc,
       SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope,
       DeclarationNameInfo MemberNameInfo,
       const TemplateArgumentListInfo *TemplateArgs);

static CXXDependentScopeMemberExpr *
CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo,
            unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope);

/// True if this is an implicit access, i.e. one in which the
/// member being accessed was not written in the source.  The source
/// location of the operator is invalid in this case.
bool isImplicitAccess() const {
  if (!Base)
    return true;
  return cast<Expr>(Base)->isImplicitCXXThis();
}

/// Retrieve the base object of this member expressions,
/// e.g., the \c x in \c x.m.
Expr *getBase() const {
  assert(!isImplicitAccess())((void)0);
  return cast<Expr>(Base);
}

QualType getBaseType() const { return BaseType; }

/// Determine whether this member expression used the '->'
/// operator; otherwise, it used the '.' operator.
bool isArrow() const { return CXXDependentScopeMemberExprBits.IsArrow; }

/// Retrieve the location of the '->' or '.' operator.
SourceLocation getOperatorLoc() const {
  return CXXDependentScopeMemberExprBits.OperatorLoc;
}

/// Retrieve the nested-name-specifier that qualifies the member name.
NestedNameSpecifier *getQualifier() const {
  return QualifierLoc.getNestedNameSpecifier();
}

/// Retrieve the nested-name-specifier that qualifies the member
/// name, with source location information.
NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }

/// Retrieve the first part of the nested-name-specifier that was
/// found in the scope of the member access expression when the member access
/// was initially parsed.
///
/// This function only returns a useful result when member access expression
/// uses a qualified member name, e.g., "x.Base::f". Here, the declaration
/// returned by this function describes what was found by unqualified name
/// lookup 