//===--- CGExprCXX.cpp - Emit LLVM Code for C++ expressions ---------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This contains code dealing with code generation of C++ expressions

//

//===----------------------------------------------------------------------===//

#include "CGCUDARuntime.h"

#include "CGCXXABI.h"

#include "CGDebugInfo.h"

#include "CGObjCRuntime.h"

#include "CodeGenFunction.h"

#include "ConstantEmitter.h"

#include "TargetInfo.h"

#include "clang/Basic/CodeGenOptions.h"

#include "clang/CodeGen/CGFunctionInfo.h"

#include "llvm/IR/Intrinsics.h"

using namespace clang;

using namespace CodeGen;

namespace {

struct MemberCallInfo {

  RequiredArgs ReqArgs;

  // Number of prefix arguments for the call. Ignores the `this` pointer.

  unsigned PrefixSize;

};

}

static MemberCallInfo

commonEmitCXXMemberOrOperatorCall(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) ||

         isa<CXXOperatorCallExpr>(CE));

  assert(MD->isInstance() &&

         "Trying to emit a member or operator call expr on a static method!");

  // 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) ? 
17.75k
 : 
066.2k
;

    CGF.EmitCallArgs(Args, FPT, drop_begin(CE->arguments(), ArgsToSkip),

                     CE->getDirectCallee());

  } else {

    assert(

        FPT->getNumParams() == 0 &&

        "No CallExpr specified for function with non-zero number of arguments");

  }

  return {required, PrefixSize};

}

RValue 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()0
);

}

RValue 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());

  assert(ThisTy->getAsCXXRecordDecl() == DtorDecl->getParent() &&

         "Pointer/Object mixup");

  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 == MustTailCall194
,

                  CE ? 
CE->getExprLoc()194
 : 
SourceLocation{}29.9k
);

}

RValue 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);

}

static 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());

}

// Note: This function also emit constructor calls to support a MSVC

// extensions allowing explicit constructor function call.

RValue 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()1.43k
 : 
nullptr65.1k
;

  bool IsArrow = ME->isArrow();

  const Expr *Base = ME->getBase();

  return EmitCXXMemberOrOperatorMemberCallExpr(

      CE, MD, ReturnValue, HasQualifier, Qualifier, IsArrow, Base);

}

RValue 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));

  // Compute the object pointer.

  bool CanUseVirtualCall = MD->isVirtual() && 
!HasQualifier1.34k
;

  const CXXMethodDecl *DevirtualizedMethod = nullptr;

  if (CanUseVirtualCall &&

      
MD->getDevirtualizedMethod(Base, getLangOpts().AppleKext)1.30k
) {

    const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();

    DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);

    assert(DevirtualizedMethod);

    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() || 
(74.9k
MD->isDefaulted()74.9k
 && 
MD->getParent()->isUnion()210
);

  bool TrivialAssignment =

      TrivialForCodegen &&

      
(2.88k
MD->isCopyAssignmentOperator()2.88k
 || 
MD->isMoveAssignmentOperator()828
) &&

      
!MD->getParent()->mayInsertExtraPadding()2.71k
;

  // 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);

    assert(ReturnValue.isNull() && "Constructor shouldn't have return value");

    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)

                       ? 
TrivialAssignmentRHS2.52k

                       : 
EmitLValue(*CE->arg_begin())181
;

      EmitAggregateAssign(This, RHS, CE->getType());

      return RValue::get(This.getPointer(*this));

    }

    assert(MD->getParent()->mayInsertExtraPadding() &&

           "unknown trivial member function");

  }

  // Compute the function type we're calling.

  const CXXMethodDecl *CalleeDecl =

      DevirtualizedMethod ? 
DevirtualizedMethod414
 : 
MD74.5k
;

  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)42.6k
)

      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 && 
!DevirtualizedMethod1.30k
;

  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl)) {

    assert(CE->arg_begin() == CE->arg_end() &&

           "Destructor shouldn't have explicit parameters");

    assert(ReturnValue.isNull() && "Destructor shouldn't have return value");

    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()2
 && 
HasQualifier2
)

        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()168
 : 
Base->getType()22
;

      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()8
) {

      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()6
 && 
HasQualifier6
)

      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);

}

RValue

CodeGenFunction::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());

}

RValue

CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,

                                               const CXXMethodDecl *MD,

                                               ReturnValueSlot ReturnValue) {

  assert(MD->isInstance() &&

         "Trying to emit a member call expr on a static method!");

  return EmitCXXMemberOrOperatorMemberCallExpr(

      E, MD, ReturnValue, /*HasQualifier=*/false, /*Qualifier=*/nullptr,

      /*IsArrow=*/false, E->getArg(0));

}

RValue CodeGenFunction::EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,

                                               ReturnValueSlot ReturnValue) {

  return CGM.getCUDARuntime().EmitCUDAKernelCallExpr(*this, E, ReturnValue);

}

static 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!");

    if (!SplitBeforeSize.isZero())

      Stores.emplace_back(SplitBeforeOffset, SplitBeforeSize);

    CharUnits SplitAfterOffset = VBPtrOffset + VBPtrWidth;

    CharUnits SplitAfterSize = LastStoreSize - SplitAfterOffset;

    assert(!SplitAfterSize.isNegative() && "negative store size!");

    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), CGF.Int8Ty, 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);

    }

  }

}

void

CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,

                                      AggValueSlot Dest) {

  assert(!Dest.isIgnored() && "Must have a destination!");

  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()6.99k
) {

    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()23.5k
)

    return;

  // Elide the constructor if we're constructing from a temporary.

  if (getLangOpts().ElideConstructors && 
E->isElidable()57.5k
) {

    // 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()));

    assert(

        getContext().hasSameUnqualifiedType(E->getType(), SrcObj->getType()));

    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;

     case CXXConstructExpr::CK_NonVirtualBase:

      Type = Ctor_Base;

     }

     // Call the constructor.

     EmitCXXConstructorCall(CD, Type, ForVirtualBase, Delegating, Dest, E);

  }

}

void CodeGenFunction::EmitSynthesizedCXXCopyCtor(Address Dest, Address Src,

                                                 const Expr *Exp) {

  if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))

    Exp = E->getSubExpr();

  assert(isa<CXXConstructExpr>(Exp) &&

         "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");

  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())

         && "EmitSynthesizedCXXCopyCtor - Copied-in Array");

  EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src, E);

}

static 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);

}

static llvm::Value *EmitCXXNewAllocSize(CodeGenFunction &CGF,

                                        const CXXNewExpr *e,

                                        unsigned minElements,

                                        llvm::Value *&numElements,

                                        llvm::Value *&sizeWithoutCookie) {

  QualType type = e->getAllocatedType();

  if (!e->isArray()) {

    CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);

    sizeWithoutCookie

      = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());

    return sizeWithoutCookie;

  }

  // 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()));

  // 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()158
)

      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()0
)

      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);

    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 (3
numElementsWidth > sizeWidth3
) {

        // 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);

          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);

    }

    // 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?");

  return size;

}

static 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");

}

void 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())

    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);