contrib/llvm/tools/clang/lib/CodeGen/CGExprCXX.cpp

   1 //===--- CGExprCXX.cpp - Emit LLVM Code for C++ expressions ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This contains code dealing with code generation of C++ expressions
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CGCUDARuntime.h"
  16 #include "CGCXXABI.h"
  17 #include "CGDebugInfo.h"
  18 #include "CGObjCRuntime.h"
  19 #include "clang/Frontend/CodeGenOptions.h"
  20 #include "llvm/IR/Intrinsics.h"
  21 #include "llvm/Support/CallSite.h"
  22
  23 using namespace clang;
  24 using namespace CodeGen;
  25
  26 RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
  27                                           SourceLocation CallLoc,
  28                                           llvm::Value *Callee,
  29                                           ReturnValueSlot ReturnValue,
  30                                           llvm::Value *This,
  31                                           llvm::Value *ImplicitParam,
  32                                           QualType ImplicitParamTy,
  33                                           CallExpr::const_arg_iterator ArgBeg,
  34                                           CallExpr::const_arg_iterator ArgEnd) {
  35   assert(MD->isInstance() &&
  36          "Trying to emit a member call expr on a static method!");
  37
  38   // C++11 [class.mfct.non-static]p2:
  39   //   If a non-static member function of a class X is called for an object that
  40   //   is not of type X, or of a type derived from X, the behavior is undefined.
  41   EmitTypeCheck(isa<CXXConstructorDecl>(MD) ? TCK_ConstructorCall
  42                                             : TCK_MemberCall,
  43                 CallLoc, This, getContext().getRecordType(MD->getParent()));
  44
  45   CallArgList Args;
  46
  47   // Push the this ptr.
  48   Args.add(RValue::get(This), MD->getThisType(getContext()));
  49
  50   // If there is an implicit parameter (e.g. VTT), emit it.
  51   if (ImplicitParam) {
  52     Args.add(RValue::get(ImplicitParam), ImplicitParamTy);
  53   }
  54
  55   const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
  56   RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, Args.size());
  57
  58   // And the rest of the call args.
  59   EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
  60
  61   return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required),
  62                   Callee, ReturnValue, Args, MD);
  63 }
  64
  65 // FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do
  66 // quite what we want.
  67 static const Expr *skipNoOpCastsAndParens(const Expr *E) {
  68   while (true) {
  69     if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
  70       E = PE->getSubExpr();
  71       continue;
  72     }
  73
  74     if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
  75       if (CE->getCastKind() == CK_NoOp) {
  76         E = CE->getSubExpr();
  77         continue;
  78       }
  79     }
  80     if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
  81       if (UO->getOpcode() == UO_Extension) {
  82         E = UO->getSubExpr();
  83         continue;
  84       }
  85     }
  86     return E;
  87   }
  88 }
  89
  90 /// canDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given
  91 /// expr can be devirtualized.
  92 static bool canDevirtualizeMemberFunctionCalls(ASTContext &Context,
  93                                                const Expr *Base,
  94                                                const CXXMethodDecl *MD) {
  95
  96   // When building with -fapple-kext, all calls must go through the vtable since
  97   // the kernel linker can do runtime patching of vtables.
  98   if (Context.getLangOpts().AppleKext)
  99     return false;
 100
 101   // If the most derived class is marked final, we know that no subclass can
 102   // override this member function and so we can devirtualize it. For example:
 103   //
 104   // struct A { virtual void f(); }
 105   // struct B final : A { };
 106   //
 107   // void f(B *b) {
 108   //   b->f();
 109   // }
 110   //
 111   const CXXRecordDecl *MostDerivedClassDecl = Base->getBestDynamicClassType();
 112   if (MostDerivedClassDecl->hasAttr<FinalAttr>())
 113     return true;
 114
 115   // If the member function is marked 'final', we know that it can't be
 116   // overridden and can therefore devirtualize it.
 117   if (MD->hasAttr<FinalAttr>())
 118     return true;
 119
 120   // Similarly, if the class itself is marked 'final' it can't be overridden
 121   // and we can therefore devirtualize the member function call.
 122   if (MD->getParent()->hasAttr<FinalAttr>())
 123     return true;
 124
 125   Base = skipNoOpCastsAndParens(Base);
 126   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
 127     if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
 128       // This is a record decl. We know the type and can devirtualize it.
 129       return VD->getType()->isRecordType();
 130     }
 131
 132     return false;
 133   }
 134
 135   // We can devirtualize calls on an object accessed by a class member access
 136   // expression, since by C++11 [basic.life]p6 we know that it can't refer to
 137   // a derived class object constructed in the same location.
 138   if (const MemberExpr *ME = dyn_cast<MemberExpr>(Base))
 139     if (const ValueDecl *VD = dyn_cast<ValueDecl>(ME->getMemberDecl()))
 140       return VD->getType()->isRecordType();
 141
 142   // We can always devirtualize calls on temporary object expressions.
 143   if (isa<CXXConstructExpr>(Base))
 144     return true;
 145
 146   // And calls on bound temporaries.
 147   if (isa<CXXBindTemporaryExpr>(Base))
 148     return true;
 149
 150   // Check if this is a call expr that returns a record type.
 151   if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
 152     return CE->getCallReturnType()->isRecordType();
 153
 154   // We can't devirtualize the call.
 155   return false;
 156 }
 157
 158 static CXXRecordDecl *getCXXRecord(const Expr *E) {
 159   QualType T = E->getType();
 160   if (const PointerType *PTy = T->getAs<PointerType>())
 161     T = PTy->getPointeeType();
 162   const RecordType *Ty = T->castAs<RecordType>();
 163   return cast<CXXRecordDecl>(Ty->getDecl());
 164 }
 165
 166 // Note: This function also emit constructor calls to support a MSVC
 167 // extensions allowing explicit constructor function call.
 168 RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
 169                                               ReturnValueSlot ReturnValue) {
 170   const Expr *callee = CE->getCallee()->IgnoreParens();
 171
 172   if (isa<BinaryOperator>(callee))
 173     return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
 174
 175   const MemberExpr *ME = cast<MemberExpr>(callee);
 176   const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
 177
 178   CGDebugInfo *DI = getDebugInfo();
 179   if (DI &&
 180       CGM.getCodeGenOpts().getDebugInfo() == CodeGenOptions::LimitedDebugInfo &&
 181       !isa<CallExpr>(ME->getBase())) {
 182     QualType PQTy = ME->getBase()->IgnoreParenImpCasts()->getType();
 183     if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) {
 184       DI->getOrCreateRecordType(PTy->getPointeeType(),
 185                                 MD->getParent()->getLocation());
 186     }
 187   }
 188
 189   if (MD->isStatic()) {
 190     // The method is static, emit it as we would a regular call.
 191     llvm::Value *Callee = CGM.GetAddrOfFunction(MD);
 192     return EmitCall(getContext().getPointerType(MD->getType()), Callee,
 193                     ReturnValue, CE->arg_begin(), CE->arg_end());
 194   }
 195
 196   // Compute the object pointer.
 197   const Expr *Base = ME->getBase();
 198   bool CanUseVirtualCall = MD->isVirtual() && !ME->hasQualifier();
 199
 200   const CXXMethodDecl *DevirtualizedMethod = NULL;
 201   if (CanUseVirtualCall &&
 202       canDevirtualizeMemberFunctionCalls(getContext(), Base, MD)) {
 203     const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
 204     DevirtualizedMethod = MD->getCorrespondingMethodInClass(BestDynamicDecl);
 205     assert(DevirtualizedMethod);
 206     const CXXRecordDecl *DevirtualizedClass = DevirtualizedMethod->getParent();
 207     const Expr *Inner = Base->ignoreParenBaseCasts();
 208     if (getCXXRecord(Inner) == DevirtualizedClass)
 209       // If the class of the Inner expression is where the dynamic method
 210       // is defined, build the this pointer from it.
 211       Base = Inner;
 212     else if (getCXXRecord(Base) != DevirtualizedClass) {
 213       // If the method is defined in a class that is not the best dynamic
 214       // one or the one of the full expression, we would have to build
 215       // a derived-to-base cast to compute the correct this pointer, but
 216       // we don't have support for that yet, so do a virtual call.
 217       DevirtualizedMethod = NULL;
 218     }
 219     // If the return types are not the same, this might be a case where more
 220     // code needs to run to compensate for it. For example, the derived
 221     // method might return a type that inherits form from the return
 222     // type of MD and has a prefix.
 223     // For now we just avoid devirtualizing these covariant cases.
 224     if (DevirtualizedMethod &&
 225         DevirtualizedMethod->getResultType().getCanonicalType() !=
 226         MD->getResultType().getCanonicalType())
 227       DevirtualizedMethod = NULL;
 228   }
 229
 230   llvm::Value *This;
 231   if (ME->isArrow())
 232     This = EmitScalarExpr(Base);
 233   else
 234     This = EmitLValue(Base).getAddress();
 235
 236
 237   if (MD->isTrivial()) {
 238     if (isa<CXXDestructorDecl>(MD)) return RValue::get(0);
 239     if (isa<CXXConstructorDecl>(MD) &&
 240         cast<CXXConstructorDecl>(MD)->isDefaultConstructor())
 241       return RValue::get(0);
 242
 243     if (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) {
 244       // We don't like to generate the trivial copy/move assignment operator
 245       // when it isn't necessary; just produce the proper effect here.
 246       llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
 247       EmitAggregateAssign(This, RHS, CE->getType());
 248       return RValue::get(This);
 249     }
 250
 251     if (isa<CXXConstructorDecl>(MD) &&
 252         cast<CXXConstructorDecl>(MD)->isCopyOrMoveConstructor()) {
 253       // Trivial move and copy ctor are the same.
 254       llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
 255       EmitSynthesizedCXXCopyCtorCall(cast<CXXConstructorDecl>(MD), This, RHS,
 256                                      CE->arg_begin(), CE->arg_end());
 257       return RValue::get(This);
 258     }
 259     llvm_unreachable("unknown trivial member function");
 260   }
 261
 262   // Compute the function type we're calling.
 263   const CXXMethodDecl *CalleeDecl = DevirtualizedMethod ? DevirtualizedMethod : MD;
 264   const CGFunctionInfo *FInfo = 0;
 265   if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(CalleeDecl))
 266     FInfo = &CGM.getTypes().arrangeCXXDestructor(Dtor,
 267                                                  Dtor_Complete);
 268   else if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(CalleeDecl))
 269     FInfo = &CGM.getTypes().arrangeCXXConstructorDeclaration(Ctor,
 270                                                              Ctor_Complete);
 271   else
 272     FInfo = &CGM.getTypes().arrangeCXXMethodDeclaration(CalleeDecl);
 273
 274   llvm::Type *Ty = CGM.getTypes().GetFunctionType(*FInfo);
 275
 276   // C++ [class.virtual]p12:
 277   //   Explicit qualification with the scope operator (5.1) suppresses the
 278   //   virtual call mechanism.
 279   //
 280   // We also don't emit a virtual call if the base expression has a record type
 281   // because then we know what the type is.
 282   bool UseVirtualCall = CanUseVirtualCall && !DevirtualizedMethod;
 283
 284   llvm::Value *Callee;
 285   if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD)) {
 286     if (UseVirtualCall) {
 287       assert(CE->arg_begin() == CE->arg_end() &&
 288              "Virtual destructor shouldn't have explicit parameters");
 289       return CGM.getCXXABI().EmitVirtualDestructorCall(*this, Dtor,
 290                                                        Dtor_Complete,
 291                                                        CE->getExprLoc(),
 292                                                        ReturnValue, This);
 293     } else {
 294       if (getLangOpts().AppleKext &&
 295           MD->isVirtual() &&
 296           ME->hasQualifier())
 297         Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), Ty);
 298       else if (!DevirtualizedMethod)
 299         Callee = CGM.GetAddrOfFunction(GlobalDecl(Dtor, Dtor_Complete), Ty);
 300       else {
 301         const CXXDestructorDecl *DDtor =
 302           cast<CXXDestructorDecl>(DevirtualizedMethod);
 303         Callee = CGM.GetAddrOfFunction(GlobalDecl(DDtor, Dtor_Complete), Ty);
 304       }
 305     }
 306   } else if (const CXXConstructorDecl *Ctor =
 307                dyn_cast<CXXConstructorDecl>(MD)) {
 308     Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty);
 309   } else if (UseVirtualCall) {
 310       Callee = BuildVirtualCall(MD, This, Ty);
 311   } else {
 312     if (getLangOpts().AppleKext &&
 313         MD->isVirtual() &&
 314         ME->hasQualifier())
 315       Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), Ty);
 316     else if (!DevirtualizedMethod)
 317       Callee = CGM.GetAddrOfFunction(MD, Ty);
 318     else {
 319       Callee = CGM.GetAddrOfFunction(DevirtualizedMethod, Ty);
 320     }
 321   }
 322
 323   return EmitCXXMemberCall(MD, CE->getExprLoc(), Callee, ReturnValue, This,
 324                            /*ImplicitParam=*/0, QualType(),
 325                            CE->arg_begin(), CE->arg_end());
 326 }
 327
 328 RValue
 329 CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
 330                                               ReturnValueSlot ReturnValue) {
 331   const BinaryOperator *BO =
 332       cast<BinaryOperator>(E->getCallee()->IgnoreParens());
 333   const Expr *BaseExpr = BO->getLHS();
 334   const Expr *MemFnExpr = BO->getRHS();
 335
 336   const MemberPointerType *MPT =
 337     MemFnExpr->getType()->castAs<MemberPointerType>();
 338
 339   const FunctionProtoType *FPT =
 340     MPT->getPointeeType()->castAs<FunctionProtoType>();
 341   const CXXRecordDecl *RD =
 342     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
 343
 344   // Get the member function pointer.
 345   llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
 346
 347   // Emit the 'this' pointer.
 348   llvm::Value *This;
 349
 350   if (BO->getOpcode() == BO_PtrMemI)
 351     This = EmitScalarExpr(BaseExpr);
 352   else
 353     This = EmitLValue(BaseExpr).getAddress();
 354
 355   EmitTypeCheck(TCK_MemberCall, E->getExprLoc(), This,
 356                 QualType(MPT->getClass(), 0));
 357
 358   // Ask the ABI to load the callee.  Note that This is modified.
 359   llvm::Value *Callee =
 360     CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(*this, This, MemFnPtr, MPT);
 361
 362   CallArgList Args;
 363
 364   QualType ThisType =
 365     getContext().getPointerType(getContext().getTagDeclType(RD));
 366
 367   // Push the this ptr.
 368   Args.add(RValue::get(This), ThisType);
 369
 370   RequiredArgs required = RequiredArgs::forPrototypePlus(FPT, 1);
 371
 372   // And the rest of the call args
 373   EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end());
 374   return EmitCall(CGM.getTypes().arrangeCXXMethodCall(Args, FPT, required), Callee,
 375                   ReturnValue, Args);
 376 }
 377
 378 RValue
 379 CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
 380                                                const CXXMethodDecl *MD,
 381                                                ReturnValueSlot ReturnValue) {
 382   assert(MD->isInstance() &&
 383          "Trying to emit a member call expr on a static method!");
 384   LValue LV = EmitLValue(E->getArg(0));
 385   llvm::Value *This = LV.getAddress();
 386
 387   if ((MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) &&
 388       MD->isTrivial()) {
 389     llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
 390     QualType Ty = E->getType();
 391     EmitAggregateAssign(This, Src, Ty);
 392     return RValue::get(This);
 393   }
 394
 395   llvm::Value *Callee = EmitCXXOperatorMemberCallee(E, MD, This);
 396   return EmitCXXMemberCall(MD, E->getExprLoc(), Callee, ReturnValue, This,
 397                            /*ImplicitParam=*/0, QualType(),
 398                            E->arg_begin() + 1, E->arg_end());
 399 }
 400
 401 RValue CodeGenFunction::EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
 402                                                ReturnValueSlot ReturnValue) {
 403   return CGM.getCUDARuntime().EmitCUDAKernelCallExpr(*this, E, ReturnValue);
 404 }
 405
 406 static void EmitNullBaseClassInitialization(CodeGenFunction &CGF,
 407                                             llvm::Value *DestPtr,
 408                                             const CXXRecordDecl *Base) {
 409   if (Base->isEmpty())
 410     return;
 411
 412   DestPtr = CGF.EmitCastToVoidPtr(DestPtr);
 413
 414   const ASTRecordLayout &Layout = CGF.getContext().getASTRecordLayout(Base);
 415   CharUnits Size = Layout.getNonVirtualSize();
 416   CharUnits Align = Layout.getNonVirtualAlign();
 417
 418   llvm::Value *SizeVal = CGF.CGM.getSize(Size);
 419
 420   // If the type contains a pointer to data member we can't memset it to zero.
 421   // Instead, create a null constant and copy it to the destination.
 422   // TODO: there are other patterns besides zero that we can usefully memset,
 423   // like -1, which happens to be the pattern used by member-pointers.
 424   // TODO: isZeroInitializable can be over-conservative in the case where a
 425   // virtual base contains a member pointer.
 426   if (!CGF.CGM.getTypes().isZeroInitializable(Base)) {
 427     llvm::Constant *NullConstant = CGF.CGM.EmitNullConstantForBase(Base);
 428
 429     llvm::GlobalVariable *NullVariable =
 430       new llvm::GlobalVariable(CGF.CGM.getModule(), NullConstant->getType(),
 431                                /*isConstant=*/true,
 432                                llvm::GlobalVariable::PrivateLinkage,
 433                                NullConstant, Twine());
 434     NullVariable->setAlignment(Align.getQuantity());
 435     llvm::Value *SrcPtr = CGF.EmitCastToVoidPtr(NullVariable);
 436
 437     // Get and call the appropriate llvm.memcpy overload.
 438     CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity());
 439     return;
 440   }
 441
 442   // Otherwise, just memset the whole thing to zero.  This is legal
 443   // because in LLVM, all default initializers (other than the ones we just
 444   // handled above) are guaranteed to have a bit pattern of all zeros.
 445   CGF.Builder.CreateMemSet(DestPtr, CGF.Builder.getInt8(0), SizeVal,
 446                            Align.getQuantity());
 447 }
 448
 449 void
 450 CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,
 451                                       AggValueSlot Dest) {
 452   assert(!Dest.isIgnored() && "Must have a destination!");
 453   const CXXConstructorDecl *CD = E->getConstructor();
 454
 455   // If we require zero initialization before (or instead of) calling the
 456   // constructor, as can be the case with a non-user-provided default
 457   // constructor, emit the zero initialization now, unless destination is
 458   // already zeroed.
 459   if (E->requiresZeroInitialization() && !Dest.isZeroed()) {
 460     switch (E->getConstructionKind()) {
 461     case CXXConstructExpr::CK_Delegating:
 462     case CXXConstructExpr::CK_Complete:
 463       EmitNullInitialization(Dest.getAddr(), E->getType());
 464       break;
 465     case CXXConstructExpr::CK_VirtualBase:
 466     case CXXConstructExpr::CK_NonVirtualBase:
 467       EmitNullBaseClassInitialization(*this, Dest.getAddr(), CD->getParent());
 468       break;
 469     }
 470   }
 471
 472   // If this is a call to a trivial default constructor, do nothing.
 473   if (CD->isTrivial() && CD->isDefaultConstructor())
 474     return;
 475
 476   // Elide the constructor if we're constructing from a temporary.
 477   // The temporary check is required because Sema sets this on NRVO
 478   // returns.
 479   if (getLangOpts().ElideConstructors && E->isElidable()) {
 480     assert(getContext().hasSameUnqualifiedType(E->getType(),
 481                                                E->getArg(0)->getType()));
 482     if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
 483       EmitAggExpr(E->getArg(0), Dest);
 484       return;
 485     }
 486   }
 487
 488   if (const ConstantArrayType *arrayType
 489         = getContext().getAsConstantArrayType(E->getType())) {
 490     EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddr(),
 491                                E->arg_begin(), E->arg_end());
 492   } else {
 493     CXXCtorType Type = Ctor_Complete;
 494     bool ForVirtualBase = false;
 495     bool Delegating = false;
 496
 497     switch (E->getConstructionKind()) {
 498      case CXXConstructExpr::CK_Delegating:
 499       // We should be emitting a constructor; GlobalDecl will assert this
 500       Type = CurGD.getCtorType();
 501       Delegating = true;
 502       break;
 503
 504      case CXXConstructExpr::CK_Complete:
 505       Type = Ctor_Complete;
 506       break;
 507
 508      case CXXConstructExpr::CK_VirtualBase:
 509       ForVirtualBase = true;
 510       // fall-through
 511
 512      case CXXConstructExpr::CK_NonVirtualBase:
 513       Type = Ctor_Base;
 514     }
 515
 516     // Call the constructor.
 517     EmitCXXConstructorCall(CD, Type, ForVirtualBase, Delegating, Dest.getAddr(),
 518                            E->arg_begin(), E->arg_end());
 519   }
 520 }
 521
 522 void
 523 CodeGenFunction::EmitSynthesizedCXXCopyCtor(llvm::Value *Dest,
 524                                             llvm::Value *Src,
 525                                             const Expr *Exp) {
 526   if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
 527     Exp = E->getSubExpr();
 528   assert(isa<CXXConstructExpr>(Exp) &&
 529          "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
 530   const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
 531   const CXXConstructorDecl *CD = E->getConstructor();
 532   RunCleanupsScope Scope(*this);
 533
 534   // If we require zero initialization before (or instead of) calling the
 535   // constructor, as can be the case with a non-user-provided default
 536   // constructor, emit the zero initialization now.
 537   // FIXME. Do I still need this for a copy ctor synthesis?
 538   if (E->requiresZeroInitialization())
 539     EmitNullInitialization(Dest, E->getType());
 540
 541   assert(!getContext().getAsConstantArrayType(E->getType())
 542          && "EmitSynthesizedCXXCopyCtor - Copied-in Array");
 543   EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src,
 544                                  E->arg_begin(), E->arg_end());
 545 }
 546
 547 static CharUnits CalculateCookiePadding(CodeGenFunction &CGF,
 548                                         const CXXNewExpr *E) {
 549   if (!E->isArray())
 550     return CharUnits::Zero();
 551
 552   // No cookie is required if the operator new[] being used is the
 553   // reserved placement operator new[].
 554   if (E->getOperatorNew()->isReservedGlobalPlacementOperator())
 555     return CharUnits::Zero();
 556
 557   return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
 558 }
 559
 560 static llvm::Value *EmitCXXNewAllocSize(CodeGenFunction &CGF,
 561                                         const CXXNewExpr *e,
 562                                         unsigned minElements,
 563                                         llvm::Value *&numElements,
 564                                         llvm::Value *&sizeWithoutCookie) {
 565   QualType type = e->getAllocatedType();
 566
 567   if (!e->isArray()) {
 568     CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
 569     sizeWithoutCookie
 570       = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
 571     return sizeWithoutCookie;
 572   }
 573
 574   // The width of size_t.
 575   unsigned sizeWidth = CGF.SizeTy->getBitWidth();
 576
 577   // Figure out the cookie size.
 578   llvm::APInt cookieSize(sizeWidth,
 579                          CalculateCookiePadding(CGF, e).getQuantity());
 580
 581   // Emit the array size expression.
 582   // We multiply the size of all dimensions for NumElements.
 583   // e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
 584   numElements = CGF.EmitScalarExpr(e->getArraySize());
 585   assert(isa<llvm::IntegerType>(numElements->getType()));
 586
 587   // The number of elements can be have an arbitrary integer type;
 588   // essentially, we need to multiply it by a constant factor, add a
 589   // cookie size, and verify that the result is representable as a
 590   // size_t.  That's just a gloss, though, and it's wrong in one
 591   // important way: if the count is negative, it's an error even if
 592   // the cookie size would bring the total size >= 0.
 593   bool isSigned
 594     = e->getArraySize()->getType()->isSignedIntegerOrEnumerationType();
 595   llvm::IntegerType *numElementsType
 596     = cast<llvm::IntegerType>(numElements->getType());
 597   unsigned numElementsWidth = numElementsType->getBitWidth();
 598
 599   // Compute the constant factor.
 600   llvm::APInt arraySizeMultiplier(sizeWidth, 1);
 601   while (const ConstantArrayType *CAT
 602              = CGF.getContext().getAsConstantArrayType(type)) {
 603     type = CAT->getElementType();
 604     arraySizeMultiplier *= CAT->getSize();
 605   }
 606
 607   CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
 608   llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity());
 609   typeSizeMultiplier *= arraySizeMultiplier;
 610
 611   // This will be a size_t.
 612   llvm::Value *size;
 613
 614   // If someone is doing 'new int[42]' there is no need to do a dynamic check.
 615   // Don't bloat the -O0 code.
 616   if (llvm::ConstantInt *numElementsC =
 617         dyn_cast<llvm::ConstantInt>(numElements)) {
 618     const llvm::APInt &count = numElementsC->getValue();
 619
 620     bool hasAnyOverflow = false;
 621
 622     // If 'count' was a negative number, it's an overflow.
 623     if (isSigned && count.isNegative())
 624       hasAnyOverflow = true;
 625
 626     // We want to do all this arithmetic in size_t.  If numElements is
 627     // wider than that, check whether it's already too big, and if so,
 628     // overflow.
 629     else if (numElementsWidth > sizeWidth &&
 630              numElementsWidth - sizeWidth > count.countLeadingZeros())
 631       hasAnyOverflow = true;
 632
 633     // Okay, compute a count at the right width.
 634     llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);
 635
 636     // If there is a brace-initializer, we cannot allocate fewer elements than
 637     // there are initializers. If we do, that's treated like an overflow.
 638     if (adjustedCount.ult(minElements))
 639       hasAnyOverflow = true;
 640
 641     // Scale numElements by that.  This might overflow, but we don't
 642     // care because it only overflows if allocationSize does, too, and
 643     // if that overflows then we shouldn't use this.
 644     numElements = llvm::ConstantInt::get(CGF.SizeTy,
 645                                          adjustedCount * arraySizeMultiplier);
 646
 647     // Compute the size before cookie, and track whether it overflowed.
 648     bool overflow;
 649     llvm::APInt allocationSize
 650       = adjustedCount.umul_ov(typeSizeMultiplier, overflow);
 651     hasAnyOverflow |= overflow;
 652
 653     // Add in the cookie, and check whether it's overflowed.
 654     if (cookieSize != 0) {
 655       // Save the current size without a cookie.  This shouldn't be
 656       // used if there was overflow.
 657       sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
 658
 659       allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
 660       hasAnyOverflow |= overflow;
 661     }
 662
 663     // On overflow, produce a -1 so operator new will fail.
 664     if (hasAnyOverflow) {
 665       size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
 666     } else {
 667       size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
 668     }
 669
 670   // Otherwise, we might need to use the overflow intrinsics.
 671   } else {
 672     // There are up to five conditions we need to test for:
 673     // 1) if isSigned, we need to check whether numElements is negative;
 674     // 2) if numElementsWidth > sizeWidth, we need to check whether
 675     //   numElements is larger than something representable in size_t;
 676     // 3) if minElements > 0, we need to check whether numElements is smaller
 677     //    than that.
 678     // 4) we need to compute
 679     //      sizeWithoutCookie := numElements * typeSizeMultiplier
 680     //    and check whether it overflows; and
 681     // 5) if we need a cookie, we need to compute
 682     //      size := sizeWithoutCookie + cookieSize
 683     //    and check whether it overflows.
 684
 685     llvm::Value *hasOverflow = 0;
 686
 687     // If numElementsWidth > sizeWidth, then one way or another, we're
 688     // going to have to do a comparison for (2), and this happens to
 689     // take care of (1), too.
 690     if (numElementsWidth > sizeWidth) {
 691       llvm::APInt threshold(numElementsWidth, 1);
 692       threshold <<= sizeWidth;
 693
 694       llvm::Value *thresholdV
 695         = llvm::ConstantInt::get(numElementsType, threshold);
 696
 697       hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
 698       numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);
 699
 700     // Otherwise, if we're signed, we want to sext up to size_t.
 701     } else if (isSigned) {
 702       if (numElementsWidth < sizeWidth)
 703         numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);
 704
 705       // If there's a non-1 type size multiplier, then we can do the
 706       // signedness check at the same time as we do the multiply
 707       // because a negative number times anything will cause an
 708       // unsigned overflow.  Otherwise, we have to do it here. But at least
 709       // in this case, we can subsume the >= minElements check.
 710       if (typeSizeMultiplier == 1)
 711         hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
 712                               llvm::ConstantInt::get(CGF.SizeTy, minElements));
 713
 714     // Otherwise, zext up to size_t if necessary.
 715     } else if (numElementsWidth < sizeWidth) {
 716       numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
 717     }
 718
 719     assert(numElements->getType() == CGF.SizeTy);
 720
 721     if (minElements) {
 722       // Don't allow allocation of fewer elements than we have initializers.
 723       if (!hasOverflow) {
 724         hasOverflow = CGF.Builder.CreateICmpULT(numElements,
 725                               llvm::ConstantInt::get(CGF.SizeTy, minElements));
 726       } else if (numElementsWidth > sizeWidth) {
 727         // The other existing overflow subsumes this check.
 728         // We do an unsigned comparison, since any signed value < -1 is
 729         // taken care of either above or below.
 730         hasOverflow = CGF.Builder.CreateOr(hasOverflow,
 731                           CGF.Builder.CreateICmpULT(numElements,
 732                               llvm::ConstantInt::get(CGF.SizeTy, minElements)));
 733       }
 734     }
 735
 736     size = numElements;
 737
 738     // Multiply by the type size if necessary.  This multiplier
 739     // includes all the factors for nested arrays.
 740     //
 741     // This step also causes numElements to be scaled up by the
 742     // nested-array factor if necessary.  Overflow on this computation
 743     // can be ignored because the result shouldn't be used if
 744     // allocation fails.
 745     if (typeSizeMultiplier != 1) {
 746       llvm::Value *umul_with_overflow
 747         = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy);
 748
 749       llvm::Value *tsmV =
 750         llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
 751       llvm::Value *result =
 752         CGF.Builder.CreateCall2(umul_with_overflow, size, tsmV);
 753
 754       llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
 755       if (hasOverflow)
 756         hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
 757       else
 758         hasOverflow = overflowed;
 759
 760       size = CGF.Builder.CreateExtractValue(result, 0);
 761
 762       // Also scale up numElements by the array size multiplier.
 763       if (arraySizeMultiplier != 1) {
 764         // If the base element type size is 1, then we can re-use the
 765         // multiply we just did.
 766         if (typeSize.isOne()) {
 767           assert(arraySizeMultiplier == typeSizeMultiplier);
 768           numElements = size;
 769
 770         // Otherwise we need a separate multiply.
 771         } else {
 772           llvm::Value *asmV =
 773             llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
 774           numElements = CGF.Builder.CreateMul(numElements, asmV);
 775         }
 776       }
 777     } else {
 778       // numElements doesn't need to be scaled.
 779       assert(arraySizeMultiplier == 1);
 780     }
 781
 782     // Add in the cookie size if necessary.
 783     if (cookieSize != 0) {
 784       sizeWithoutCookie = size;
 785
 786       llvm::Value *uadd_with_overflow
 787         = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy);
 788
 789       llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
 790       llvm::Value *result =
 791         CGF.Builder.CreateCall2(uadd_with_overflow, size, cookieSizeV);
 792
 793       llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
 794       if (hasOverflow)
 795         hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
 796       else
 797         hasOverflow = overflowed;
 798
 799       size = CGF.Builder.CreateExtractValue(result, 0);
 800     }
 801
 802     // If we had any possibility of dynamic overflow, make a select to
 803     // overwrite 'size' with an all-ones value, which should cause
 804     // operator new to throw.
 805     if (hasOverflow)
 806       size = CGF.Builder.CreateSelect(hasOverflow,
 807                                  llvm::Constant::getAllOnesValue(CGF.SizeTy),
 808                                       size);
 809   }
 810
 811   if (cookieSize == 0)
 812     sizeWithoutCookie = size;
 813   else
 814     assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?");
 815
 816   return size;
 817 }
 818
 819 static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const Expr *Init,
 820                                     QualType AllocType, llvm::Value *NewPtr) {
 821
 822   CharUnits Alignment = CGF.getContext().getTypeAlignInChars(AllocType);
 823   switch (CGF.getEvaluationKind(AllocType)) {
 824   case TEK_Scalar:
 825     CGF.EmitScalarInit(Init, 0, CGF.MakeAddrLValue(NewPtr, AllocType,
 826                                                    Alignment),
 827                        false);
 828     return;
 829   case TEK_Complex:
 830     CGF.EmitComplexExprIntoLValue(Init, CGF.MakeAddrLValue(NewPtr, AllocType,
 831                                                            Alignment),
 832                                   /*isInit*/ true);
 833     return;
 834   case TEK_Aggregate: {
 835     AggValueSlot Slot
 836       = AggValueSlot::forAddr(NewPtr, Alignment, AllocType.getQualifiers(),
 837                               AggValueSlot::IsDestructed,
 838                               AggValueSlot::DoesNotNeedGCBarriers,
 839                               AggValueSlot::IsNotAliased);
 840     CGF.EmitAggExpr(Init, Slot);
 841
 842     CGF.MaybeEmitStdInitializerListCleanup(NewPtr, Init);
 843     return;
 844   }
 845   }
 846   llvm_unreachable("bad evaluation kind");
 847 }
 848
 849 void
 850 CodeGenFunction::EmitNewArrayInitializer(const CXXNewExpr *E,
 851                                          QualType elementType,
 852                                          llvm::Value *beginPtr,
 853                                          llvm::Value *numElements) {
 854   if (!E->hasInitializer())
 855     return; // We have a POD type.
 856
 857   llvm::Value *explicitPtr = beginPtr;
 858   // Find the end of the array, hoisted out of the loop.
 859   llvm::Value *endPtr =
 860     Builder.CreateInBoundsGEP(beginPtr, numElements, "array.end");
 861
 862   unsigned initializerElements = 0;
 863
 864   const Expr *Init = E->getInitializer();
 865   llvm::AllocaInst *endOfInit = 0;
 866   QualType::DestructionKind dtorKind = elementType.isDestructedType();
 867   EHScopeStack::stable_iterator cleanup;
 868   llvm::Instruction *cleanupDominator = 0;
 869   // If the initializer is an initializer list, first do the explicit elements.
 870   if (const InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
 871     initializerElements = ILE->getNumInits();
 872
 873     // Enter a partial-destruction cleanup if necessary.
 874     if (needsEHCleanup(dtorKind)) {
 875       // In principle we could tell the cleanup where we are more
 876       // directly, but the control flow can get so varied here that it
 877       // would actually be quite complex.  Therefore we go through an
 878       // alloca.
 879       endOfInit = CreateTempAlloca(beginPtr->getType(), "array.endOfInit");
 880       cleanupDominator = Builder.CreateStore(beginPtr, endOfInit);
 881       pushIrregularPartialArrayCleanup(beginPtr, endOfInit, elementType,
 882                                        getDestroyer(dtorKind));
 883       cleanup = EHStack.stable_begin();
 884     }
 885
 886     for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i) {
 887       // Tell the cleanup that it needs to destroy up to this
 888       // element.  TODO: some of these stores can be trivially
 889       // observed to be unnecessary.
 890       if (endOfInit) Builder.CreateStore(explicitPtr, endOfInit);
 891       StoreAnyExprIntoOneUnit(*this, ILE->getInit(i), elementType, explicitPtr);
 892       explicitPtr =Builder.CreateConstGEP1_32(explicitPtr, 1, "array.exp.next");
 893     }
 894
 895     // The remaining elements are filled with the array filler expression.
 896     Init = ILE->getArrayFiller();
 897   }
 898
 899   // Create the continuation block.
 900   llvm::BasicBlock *contBB = createBasicBlock("new.loop.end");
 901
 902   // If the number of elements isn't constant, we have to now check if there is
 903   // anything left to initialize.
 904   if (llvm::ConstantInt *constNum = dyn_cast<llvm::ConstantInt>(numElements)) {
 905     // If all elements have already been initialized, skip the whole loop.
 906     if (constNum->getZExtValue() <= initializerElements) {
 907       // If there was a cleanup, deactivate it.
 908       if (cleanupDominator)
 909         DeactivateCleanupBlock(cleanup, cleanupDominator);
 910       return;
 911     }
 912   } else {
 913     llvm::BasicBlock *nonEmptyBB = createBasicBlock("new.loop.nonempty");
 914     llvm::Value *isEmpty = Builder.CreateICmpEQ(explicitPtr, endPtr,
 915                                                 "array.isempty");
 916     Builder.CreateCondBr(isEmpty, contBB, nonEmptyBB);
 917     EmitBlock(nonEmptyBB);
 918   }
 919
 920   // Enter the loop.
 921   llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
 922   llvm::BasicBlock *loopBB = createBasicBlock("new.loop");
 923
 924   EmitBlock(loopBB);
 925
 926   // Set up the current-element phi.
 927   llvm::PHINode *curPtr =
 928     Builder.CreatePHI(explicitPtr->getType(), 2, "array.cur");
 929   curPtr->addIncoming(explicitPtr, entryBB);
 930
 931   // Store the new cleanup position for irregular cleanups.
 932   if (endOfInit) Builder.CreateStore(curPtr, endOfInit);
 933
 934   // Enter a partial-destruction cleanup if necessary.
 935   if (!cleanupDominator && needsEHCleanup(dtorKind)) {
 936     pushRegularPartialArrayCleanup(beginPtr, curPtr, elementType,
 937                                    getDestroyer(dtorKind));
 938     cleanup = EHStack.stable_begin();
 939     cleanupDominator = Builder.CreateUnreachable();
 940   }
 941
 942   // Emit the initializer into this element.
 943   StoreAnyExprIntoOneUnit(*this, Init, E->getAllocatedType(), curPtr);
 944
 945   // Leave the cleanup if we entered one.
 946   if (cleanupDominator) {
 947     DeactivateCleanupBlock(cleanup, cleanupDominator);
 948     cleanupDominator->eraseFromParent();
 949   }
 950
 951   // Advance to the next element.
 952   llvm::Value *nextPtr = Builder.CreateConstGEP1_32(curPtr, 1, "array.next");
 953
 954   // Check whether we've gotten to the end of the array and, if so,
 955   // exit the loop.
 956   llvm::Value *isEnd = Builder.CreateICmpEQ(nextPtr, endPtr, "array.atend");
 957   Builder.CreateCondBr(isEnd, contBB, loopBB);
 958   curPtr->addIncoming(nextPtr, Builder.GetInsertBlock());
 959
 960   EmitBlock(contBB);
 961 }
 962
 963 static void EmitZeroMemSet(CodeGenFunction &CGF, QualType T,
 964                            llvm::Value *NewPtr, llvm::Value *Size) {
 965   CGF.EmitCastToVoidPtr(NewPtr);
 966   CharUnits Alignment = CGF.getContext().getTypeAlignInChars(T);
 967   CGF.Builder.CreateMemSet(NewPtr, CGF.Builder.getInt8(0), Size,
 968                            Alignment.getQuantity(), false);
 969 }
 970
 971 static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
 972                                QualType ElementType,
 973                                llvm::Value *NewPtr,
 974                                llvm::Value *NumElements,
 975                                llvm::Value *AllocSizeWithoutCookie) {
 976   const Expr *Init = E->getInitializer();
 977   if (E->isArray()) {
 978     if (const CXXConstructExpr *CCE = dyn_cast_or_null<CXXConstructExpr>(Init)){
 979       CXXConstructorDecl *Ctor = CCE->getConstructor();
 980       if (Ctor->isTrivial()) {
 981         // If new expression did not specify value-initialization, then there
 982         // is no initialization.
 983         if (!CCE->requiresZeroInitialization() || Ctor->getParent()->isEmpty())
 984           return;
 985
 986         if (CGF.CGM.getTypes().isZeroInitializable(ElementType)) {
 987           // Optimization: since zero initialization will just set the memory
 988           // to all zeroes, generate a single memset to do it in one shot.
 989           EmitZeroMemSet(CGF, ElementType, NewPtr, AllocSizeWithoutCookie);
 990           return;
 991         }
 992       }
 993
 994       CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr,
 995                                      CCE->arg_begin(),  CCE->arg_end(),
 996                                      CCE->requiresZeroInitialization());
 997       return;
 998     } else if (Init && isa<ImplicitValueInitExpr>(Init) &&
 999                CGF.CGM.getTypes().isZeroInitializable(ElementType)) {
1000       // Optimization: since zero initialization will just set the memory
1001       // to all zeroes, generate a single memset to do it in one shot.
1002       EmitZeroMemSet(CGF, ElementType, NewPtr, AllocSizeWithoutCookie);
1003       return;
1004     }
1005     CGF.EmitNewArrayInitializer(E, ElementType, NewPtr, NumElements);
1006     return;
1007   }
1008
1009   if (!Init)
1010     return;
1011
1012   StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(), NewPtr);
1013 }
1014
1015 namespace {
1016   /// A cleanup to call the given 'operator delete' function upon
1017   /// abnormal exit from a new expression.
1018   class CallDeleteDuringNew : public EHScopeStack::Cleanup {
1019     size_t NumPlacementArgs;
1020     const FunctionDecl *OperatorDelete;
1021     llvm::Value *Ptr;
1022     llvm::Value *AllocSize;
1023
1024     RValue *getPlacementArgs() { return reinterpret_cast<RValue*>(this+1); }
1025
1026   public:
1027     static size_t getExtraSize(size_t NumPlacementArgs) {
1028       return NumPlacementArgs * sizeof(RValue);
1029     }
1030
1031     CallDeleteDuringNew(size_t NumPlacementArgs,
1032                         const FunctionDecl *OperatorDelete,
1033                         llvm::Value *Ptr,
1034                         llvm::Value *AllocSize)
1035       : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
1036         Ptr(Ptr), AllocSize(AllocSize) {}
1037
1038     void setPlacementArg(unsigned I, RValue Arg) {
1039       assert(I < NumPlacementArgs && "index out of range");
1040       getPlacementArgs()[I] = Arg;
1041     }
1042
1043     void Emit(CodeGenFunction &CGF, Flags flags) {
1044       const FunctionProtoType *FPT
1045         = OperatorDelete->getType()->getAs<FunctionProtoType>();
1046       assert(FPT->getNumArgs() == NumPlacementArgs + 1 ||
1047              (FPT->getNumArgs() == 2 && NumPlacementArgs == 0));
1048
1049       CallArgList DeleteArgs;
1050
1051       // The first argument is always a void*.
1052       FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin();
1053       DeleteArgs.add(RValue::get(Ptr), *AI++);
1054
1055       // A member 'operator delete' can take an extra 'size_t' argument.
1056       if (FPT->getNumArgs() == NumPlacementArgs + 2)
1057         DeleteArgs.add(RValue::get(AllocSize), *AI++);
1058
1059       // Pass the rest of the arguments, which must match exactly.
1060       for (unsigned I = 0; I != NumPlacementArgs; ++I)
1061         DeleteArgs.add(getPlacementArgs()[I], *AI++);
1062
1063       // Call 'operator delete'.
1064       CGF.EmitCall(CGF.CGM.getTypes().arrangeFreeFunctionCall(DeleteArgs, FPT),
1065                    CGF.CGM.GetAddrOfFunction(OperatorDelete),
1066                    ReturnValueSlot(), DeleteArgs, OperatorDelete);
1067     }
1068   };
1069
1070   /// A cleanup to call the given 'operator delete' function upon
1071   /// abnormal exit from a new expression when the new expression is
1072   /// conditional.
1073   class CallDeleteDuringConditionalNew : public EHScopeStack::Cleanup {
1074     size_t NumPlacementArgs;
1075     const FunctionDecl *OperatorDelete;
1076     DominatingValue<RValue>::saved_type Ptr;
1077     DominatingValue<RValue>::saved_type AllocSize;
1078
1079     DominatingValue<RValue>::saved_type *getPlacementArgs() {
1080       return reinterpret_cast<DominatingValue<RValue>::saved_type*>(this+1);
1081     }
1082
1083   public:
1084     static size_t getExtraSize(size_t NumPlacementArgs) {
1085       return NumPlacementArgs * sizeof(DominatingValue<RValue>::saved_type);
1086     }
1087
1088     CallDeleteDuringConditionalNew(size_t NumPlacementArgs,
1089                                    const FunctionDecl *OperatorDelete,
1090                                    DominatingValue<RValue>::saved_type Ptr,
1091                               DominatingValue<RValue>::saved_type AllocSize)
1092       : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
1093         Ptr(Ptr), AllocSize(AllocSize) {}
1094
1095     void setPlacementArg(unsigned I, DominatingValue<RValue>::saved_type Arg) {
1096       assert(I < NumPlacementArgs && "index out of range");
1097       getPlacementArgs()[I] = Arg;
1098     }
1099
1100     void Emit(CodeGenFunction &CGF, Flags flags) {
1101       const FunctionProtoType *FPT
1102         = OperatorDelete->getType()->getAs<FunctionProtoType>();
1103       assert(FPT->getNumArgs() == NumPlacementArgs + 1 ||
1104              (FPT->getNumArgs() == 2 && NumPlacementArgs == 0));
1105
1106       CallArgList DeleteArgs;
1107
1108       // The first argument is always a void*.
1109       FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin();
1110       DeleteArgs.add(Ptr.restore(CGF), *AI++);
1111
1112       // A member 'operator delete' can take an extra 'size_t' argument.
1113       if (FPT->getNumArgs() == NumPlacementArgs + 2) {
1114         RValue RV = AllocSize.restore(CGF);
1115         DeleteArgs.add(RV, *AI++);
1116       }
1117
1118       // Pass the rest of the arguments, which must match exactly.
1119       for (unsigned I = 0; I != NumPlacementArgs; ++I) {
1120         RValue RV = getPlacementArgs()[I].restore(CGF);
1121         DeleteArgs.add(RV, *AI++);
1122       }
1123
1124       // Call 'operator delete'.
1125       CGF.EmitCall(CGF.CGM.getTypes().arrangeFreeFunctionCall(DeleteArgs, FPT),
1126                    CGF.CGM.GetAddrOfFunction(OperatorDelete),
1127                    ReturnValueSlot(), DeleteArgs, OperatorDelete);
1128     }
1129   };
1130 }
1131
1132 /// Enter a cleanup to call 'operator delete' if the initializer in a
1133 /// new-expression throws.
1134 static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
1135                                   const CXXNewExpr *E,
1136                                   llvm::Value *NewPtr,
1137                                   llvm::Value *AllocSize,
1138                                   const CallArgList &NewArgs) {
1139   // If we're not inside a conditional branch, then the cleanup will
1140   // dominate and we can do the easier (and more efficient) thing.
1141   if (!CGF.isInConditionalBranch()) {
1142     CallDeleteDuringNew *Cleanup = CGF.EHStack
1143       .pushCleanupWithExtra<CallDeleteDuringNew>(EHCleanup,
1144                                                  E->getNumPlacementArgs(),
1145                                                  E->getOperatorDelete(),
1146                                                  NewPtr, AllocSize);
1147     for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1148       Cleanup->setPlacementArg(I, NewArgs[I+1].RV);
1149
1150     return;
1151   }
1152
1153   // Otherwise, we need to save all this stuff.
1154   DominatingValue<RValue>::saved_type SavedNewPtr =
1155     DominatingValue<RValue>::save(CGF, RValue::get(NewPtr));
1156   DominatingValue<RValue>::saved_type SavedAllocSize =
1157     DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1158
1159   CallDeleteDuringConditionalNew *Cleanup = CGF.EHStack
1160     .pushCleanupWithExtra<CallDeleteDuringConditionalNew>(EHCleanup,
1161                                                  E->getNumPlacementArgs(),
1162                                                  E->getOperatorDelete(),
1163                                                  SavedNewPtr,
1164                                                  SavedAllocSize);
1165   for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1166     Cleanup->setPlacementArg(I,
1167                      DominatingValue<RValue>::save(CGF, NewArgs[I+1].RV));
1168
1169   CGF.initFullExprCleanup();
1170 }
1171
1172 llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
1173   // The element type being allocated.
1174   QualType allocType = getContext().getBaseElementType(E->getAllocatedType());
1175
1176   // 1. Build a call to the allocation function.
1177   FunctionDecl *allocator = E->getOperatorNew();
1178   const FunctionProtoType *allocatorType =
1179     allocator->getType()->castAs<FunctionProtoType>();
1180
1181   CallArgList allocatorArgs;
1182
1183   // The allocation size is the first argument.
1184   QualType sizeType = getContext().getSizeType();
1185
1186   // If there is a brace-initializer, cannot allocate fewer elements than inits.
1187   unsigned minElements = 0;
1188   if (E->isArray() && E->hasInitializer()) {
1189     if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E->getInitializer()))
1190       minElements = ILE->getNumInits();
1191   }
1192
1193   llvm::Value *numElements = 0;
1194   llvm::Value *allocSizeWithoutCookie = 0;
1195   llvm::Value *allocSize =
1196     EmitCXXNewAllocSize(*this, E, minElements, numElements,
1197                         allocSizeWithoutCookie);
1198
1199   allocatorArgs.add(RValue::get(allocSize), sizeType);
1200
1201   // Emit the rest of the arguments.
1202   // FIXME: Ideally, this should just use EmitCallArgs.
1203   CXXNewExpr::const_arg_iterator placementArg = E->placement_arg_begin();
1204
1205   // First, use the types from the function type.
1206   // We start at 1 here because the first argument (the allocation size)
1207   // has already been emitted.
1208   for (unsigned i = 1, e = allocatorType->getNumArgs(); i != e;
1209        ++i, ++placementArg) {
1210     QualType argType = allocatorType->getArgType(i);
1211
1212     assert(getContext().hasSameUnqualifiedType(argType.getNonReferenceType(),
1213                                                placementArg->getType()) &&
1214            "type mismatch in call argument!");
1215
1216     EmitCallArg(allocatorArgs, *placementArg, argType);
1217   }
1218
1219   // Either we've emitted all the call args, or we have a call to a
1220   // variadic function.
1221   assert((placementArg == E->placement_arg_end() ||
1222           allocatorType->isVariadic()) &&
1223          "Extra arguments to non-variadic function!");
1224
1225   // If we still have any arguments, emit them using the type of the argument.
1226   for (CXXNewExpr::const_arg_iterator placementArgsEnd = E->placement_arg_end();
1227        placementArg != placementArgsEnd; ++placementArg) {
1228     EmitCallArg(allocatorArgs, *placementArg, placementArg->getType());
1229   }
1230
1231   // Emit the allocation call.  If the allocator is a global placement
1232   // operator, just "inline" it directly.
1233   RValue RV;
1234   if (allocator->isReservedGlobalPlacementOperator()) {
1235     assert(allocatorArgs.size() == 2);
1236     RV = allocatorArgs[1].RV;
1237     // TODO: kill any unnecessary computations done for the size
1238     // argument.
1239   } else {
1240     RV = EmitCall(CGM.getTypes().arrangeFreeFunctionCall(allocatorArgs,
1241                                                          allocatorType),
1242                   CGM.GetAddrOfFunction(allocator), ReturnValueSlot(),
1243                   allocatorArgs, allocator);
1244   }
1245
1246   // Emit a null check on the allocation result if the allocation
1247   // function is allowed to return null (because it has a non-throwing
1248   // exception spec; for this part, we inline
1249   // CXXNewExpr::shouldNullCheckAllocation()) and we have an
1250   // interesting initializer.
1251   bool nullCheck = allocatorType->isNothrow(getContext()) &&
1252     (!allocType.isPODType(getContext()) || E->hasInitializer());
1253
1254   llvm::BasicBlock *nullCheckBB = 0;
1255   llvm::BasicBlock *contBB = 0;
1256
1257   llvm::Value *allocation = RV.getScalarVal();
1258   unsigned AS = allocation->getType()->getPointerAddressSpace();
1259
1260   // The null-check means that the initializer is conditionally
1261   // evaluated.
1262   ConditionalEvaluation conditional(*this);
1263
1264   if (nullCheck) {
1265     conditional.begin(*this);
1266
1267     nullCheckBB = Builder.GetInsertBlock();
1268     llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull");
1269     contBB = createBasicBlock("new.cont");
1270
1271     llvm::Value *isNull = Builder.CreateIsNull(allocation, "new.isnull");
1272     Builder.CreateCondBr(isNull, contBB, notNullBB);
1273     EmitBlock(notNullBB);
1274   }
1275
1276   // If there's an operator delete, enter a cleanup to call it if an
1277   // exception is thrown.
1278   EHScopeStack::stable_iterator operatorDeleteCleanup;
1279   llvm::Instruction *cleanupDominator = 0;
1280   if (E->getOperatorDelete() &&
1281       !E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
1282     EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocatorArgs);
1283     operatorDeleteCleanup = EHStack.stable_begin();
1284     cleanupDominator = Builder.CreateUnreachable();
1285   }
1286
1287   assert((allocSize == allocSizeWithoutCookie) ==
1288          CalculateCookiePadding(*this, E).isZero());
1289   if (allocSize != allocSizeWithoutCookie) {
1290     assert(E->isArray());
1291     allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation,
1292                                                        numElements,
1293                                                        E, allocType);
1294   }
1295
1296   llvm::Type *elementPtrTy
1297     = ConvertTypeForMem(allocType)->getPointerTo(AS);
1298   llvm::Value *result = Builder.CreateBitCast(allocation, elementPtrTy);
1299
1300   EmitNewInitializer(*this, E, allocType, result, numElements,
1301                      allocSizeWithoutCookie);
1302   if (E->isArray()) {
1303     // NewPtr is a pointer to the base element type.  If we're
1304     // allocating an array of arrays, we'll need to cast back to the
1305     // array pointer type.
1306     llvm::Type *resultType = ConvertTypeForMem(E->getType());
1307     if (result->getType() != resultType)
1308       result = Builder.CreateBitCast(result, resultType);
1309   }
1310
1311   // Deactivate the 'operator delete' cleanup if we finished
1312   // initialization.
1313   if (operatorDeleteCleanup.isValid()) {
1314     DeactivateCleanupBlock(operatorDeleteCleanup, cleanupDominator);
1315     cleanupDominator->eraseFromParent();
1316   }
1317
1318   if (nullCheck) {
1319     conditional.end(*this);
1320
1321     llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
1322     EmitBlock(contBB);
1323
1324     llvm::PHINode *PHI = Builder.CreatePHI(result->getType(), 2);
1325     PHI->addIncoming(result, notNullBB);
1326     PHI->addIncoming(llvm::Constant::getNullValue(result->getType()),
1327                      nullCheckBB);
1328
1329     result = PHI;
1330   }
1331
1332   return result;
1333 }
1334
1335 void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
1336                                      llvm::Value *Ptr,
1337                                      QualType DeleteTy) {
1338   assert(DeleteFD->getOverloadedOperator() == OO_Delete);
1339
1340   const FunctionProtoType *DeleteFTy =
1341     DeleteFD->getType()->getAs<FunctionProtoType>();
1342
1343   CallArgList DeleteArgs;
1344
1345   // Check if we need to pass the size to the delete operator.
1346   llvm::Value *Size = 0;
1347   QualType SizeTy;
1348   if (DeleteFTy->getNumArgs() == 2) {
1349     SizeTy = DeleteFTy->getArgType(1);
1350     CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1351     Size = llvm::ConstantInt::get(ConvertType(SizeTy),
1352                                   DeleteTypeSize.getQuantity());
1353   }
1354
1355   QualType ArgTy = DeleteFTy->getArgType(0);
1356   llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1357   DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
1358
1359   if (Size)
1360     DeleteArgs.add(RValue::get(Size), SizeTy);
1361
1362   // Emit the call to delete.
1363   EmitCall(CGM.getTypes().arrangeFreeFunctionCall(DeleteArgs, DeleteFTy),
1364            CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(),
1365            DeleteArgs, DeleteFD);
1366 }
1367
1368 namespace {
1369   /// Calls the given 'operator delete' on a single object.
1370   struct CallObjectDelete : EHScopeStack::Cleanup {
1371     llvm::Value *Ptr;
1372     const FunctionDecl *OperatorDelete;
1373     QualType ElementType;
1374
1375     CallObjectDelete(llvm::Value *Ptr,
1376                      const FunctionDecl *OperatorDelete,
1377                      QualType ElementType)
1378       : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1379
1380     void Emit(CodeGenFunction &CGF, Flags flags) {
1381       CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
1382     }
1383   };
1384 }
1385
1386 /// Emit the code for deleting a single object.
1387 static void EmitObjectDelete(CodeGenFunction &CGF,
1388                              const FunctionDecl *OperatorDelete,
1389                              llvm::Value *Ptr,
1390                              QualType ElementType,
1391                              bool UseGlobalDelete) {
1392   // Find the destructor for the type, if applicable.  If the
1393   // destructor is virtual, we'll just emit the vcall and return.
1394   const CXXDestructorDecl *Dtor = 0;
1395   if (const RecordType *RT = ElementType->getAs<RecordType>()) {
1396     CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1397     if (RD->hasDefinition() && !RD->hasTrivialDestructor()) {
1398       Dtor = RD->getDestructor();
1399
1400       if (Dtor->isVirtual()) {
1401         if (UseGlobalDelete) {
1402           // If we're supposed to call the global delete, make sure we do so
1403           // even if the destructor throws.
1404
1405           // Derive the complete-object pointer, which is what we need
1406           // to pass to the deallocation function.
1407           llvm::Value *completePtr =
1408             CGF.CGM.getCXXABI().adjustToCompleteObject(CGF, Ptr, ElementType);
1409
1410           CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1411                                                     completePtr, OperatorDelete,
1412                                                     ElementType);
1413         }
1414
1415         // FIXME: Provide a source location here.
1416         CXXDtorType DtorType = UseGlobalDelete ? Dtor_Complete : Dtor_Deleting;
1417         CGF.CGM.getCXXABI().EmitVirtualDestructorCall(CGF, Dtor, DtorType,
1418                                                       SourceLocation(),
1419                                                       ReturnValueSlot(), Ptr);
1420
1421         if (UseGlobalDelete) {
1422           CGF.PopCleanupBlock();
1423         }
1424
1425         return;
1426       }
1427     }
1428   }
1429
1430   // Make sure that we call delete even if the dtor throws.
1431   // This doesn't have to a conditional cleanup because we're going
1432   // to pop it off in a second.
1433   CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1434                                             Ptr, OperatorDelete, ElementType);
1435
1436   if (Dtor)
1437     CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
1438                               /*ForVirtualBase=*/false,
1439                               /*Delegating=*/false,
1440                               Ptr);
1441   else if (CGF.getLangOpts().ObjCAutoRefCount &&
1442            ElementType->isObjCLifetimeType()) {
1443     switch (ElementType.getObjCLifetime()) {
1444     case Qualifiers::OCL_None:
1445     case Qualifiers::OCL_ExplicitNone:
1446     case Qualifiers::OCL_Autoreleasing:
1447       break;
1448
1449     case Qualifiers::OCL_Strong: {
1450       // Load the pointer value.
1451       llvm::Value *PtrValue = CGF.Builder.CreateLoad(Ptr,
1452                                              ElementType.isVolatileQualified());
1453
1454       CGF.EmitARCRelease(PtrValue, ARCPreciseLifetime);
1455       break;
1456     }
1457
1458     case Qualifiers::OCL_Weak:
1459       CGF.EmitARCDestroyWeak(Ptr);
1460       break;
1461     }
1462   }
1463
1464   CGF.PopCleanupBlock();
1465 }
1466
1467 namespace {
1468   /// Calls the given 'operator delete' on an array of objects.
1469   struct CallArrayDelete : EHScopeStack::Cleanup {
1470     llvm::Value *Ptr;
1471     const FunctionDecl *OperatorDelete;
1472     llvm::Value *NumElements;
1473     QualType ElementType;
1474     CharUnits CookieSize;
1475
1476     CallArrayDelete(llvm::Value *Ptr,
1477                     const FunctionDecl *OperatorDelete,
1478                     llvm::Value *NumElements,
1479                     QualType ElementType,
1480                     CharUnits CookieSize)
1481       : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
1482         ElementType(ElementType), CookieSize(CookieSize) {}
1483
1484     void Emit(CodeGenFunction &CGF, Flags flags) {
1485       const FunctionProtoType *DeleteFTy =
1486         OperatorDelete->getType()->getAs<FunctionProtoType>();
1487       assert(DeleteFTy->getNumArgs() == 1 || DeleteFTy->getNumArgs() == 2);
1488
1489       CallArgList Args;
1490
1491       // Pass the pointer as the first argument.
1492       QualType VoidPtrTy = DeleteFTy->getArgType(0);
1493       llvm::Value *DeletePtr
1494         = CGF.Builder.CreateBitCast(Ptr, CGF.ConvertType(VoidPtrTy));
1495       Args.add(RValue::get(DeletePtr), VoidPtrTy);
1496
1497       // Pass the original requested size as the second argument.
1498       if (DeleteFTy->getNumArgs() == 2) {
1499         QualType size_t = DeleteFTy->getArgType(1);
1500         llvm::IntegerType *SizeTy
1501           = cast<llvm::IntegerType>(CGF.ConvertType(size_t));
1502
1503         CharUnits ElementTypeSize =
1504           CGF.CGM.getContext().getTypeSizeInChars(ElementType);
1505
1506         // The size of an element, multiplied by the number of elements.
1507         llvm::Value *Size
1508           = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity());
1509         Size = CGF.Builder.CreateMul(Size, NumElements);
1510
1511         // Plus the size of the cookie if applicable.
1512         if (!CookieSize.isZero()) {
1513           llvm::Value *CookieSizeV
1514             = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
1515           Size = CGF.Builder.CreateAdd(Size, CookieSizeV);
1516         }
1517
1518         Args.add(RValue::get(Size), size_t);
1519       }
1520
1521       // Emit the call to delete.
1522       CGF.EmitCall(CGF.getTypes().arrangeFreeFunctionCall(Args, DeleteFTy),
1523                    CGF.CGM.GetAddrOfFunction(OperatorDelete),
1524                    ReturnValueSlot(), Args, OperatorDelete);
1525     }
1526   };
1527 }
1528
1529 /// Emit the code for deleting an array of objects.
1530 static void EmitArrayDelete(CodeGenFunction &CGF,
1531                             const CXXDeleteExpr *E,
1532                             llvm::Value *deletedPtr,
1533                             QualType elementType) {
1534   llvm::Value *numElements = 0;
1535   llvm::Value *allocatedPtr = 0;
1536   CharUnits cookieSize;
1537   CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
1538                                       numElements, allocatedPtr, cookieSize);
1539
1540   assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer");
1541
1542   // Make sure that we call delete even if one of the dtors throws.
1543   const FunctionDecl *operatorDelete = E->getOperatorDelete();
1544   CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
1545                                            allocatedPtr, operatorDelete,
1546                                            numElements, elementType,
1547                                            cookieSize);
1548
1549   // Destroy the elements.
1550   if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) {
1551     assert(numElements && "no element count for a type with a destructor!");
1552
1553     llvm::Value *arrayEnd =
1554       CGF.Builder.CreateInBoundsGEP(deletedPtr, numElements, "delete.end");
1555
1556     // Note that it is legal to allocate a zero-length array, and we
1557     // can never fold the check away because the length should always
1558     // come from a cookie.
1559     CGF.emitArrayDestroy(deletedPtr, arrayEnd, elementType,
1560                          CGF.getDestroyer(dtorKind),
1561                          /*checkZeroLength*/ true,
1562                          CGF.needsEHCleanup(dtorKind));
1563   }
1564
1565   // Pop the cleanup block.
1566   CGF.PopCleanupBlock();
1567 }
1568
1569 void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
1570   const Expr *Arg = E->getArgument();
1571   llvm::Value *Ptr = EmitScalarExpr(Arg);
1572
1573   // Null check the pointer.
1574   llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
1575   llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
1576
1577   llvm::Value *IsNull = Builder.CreateIsNull(Ptr, "isnull");
1578
1579   Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
1580   EmitBlock(DeleteNotNull);
1581
1582   // We might be deleting a pointer to array.  If so, GEP down to the
1583   // first non-array element.
1584   // (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*)
1585   QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType();
1586   if (DeleteTy->isConstantArrayType()) {
1587     llvm::Value *Zero = Builder.getInt32(0);
1588     SmallVector<llvm::Value*,8> GEP;
1589
1590     GEP.push_back(Zero); // point at the outermost array
1591
1592     // For each layer of array type we're pointing at:
1593     while (const ConstantArrayType *Arr
1594              = getContext().getAsConstantArrayType(DeleteTy)) {
1595       // 1. Unpeel the array type.
1596       DeleteTy = Arr->getElementType();
1597
1598       // 2. GEP to the first element of the array.
1599       GEP.push_back(Zero);
1600     }
1601
1602     Ptr = Builder.CreateInBoundsGEP(Ptr, GEP, "del.first");
1603   }
1604
1605   assert(ConvertTypeForMem(DeleteTy) ==
1606          cast<llvm::PointerType>(Ptr->getType())->getElementType());
1607
1608   if (E->isArrayForm()) {
1609     EmitArrayDelete(*this, E, Ptr, DeleteTy);
1610   } else {
1611     EmitObjectDelete(*this, E->getOperatorDelete(), Ptr, DeleteTy,
1612                      E->isGlobalDelete());
1613   }
1614
1615   EmitBlock(DeleteEnd);
1616 }
1617
1618 static llvm::Constant *getBadTypeidFn(CodeGenFunction &CGF) {
1619   // void __cxa_bad_typeid();
1620   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1621
1622   return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1623 }
1624
1625 static void EmitBadTypeidCall(CodeGenFunction &CGF) {
1626   llvm::Value *Fn = getBadTypeidFn(CGF);
1627   CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1628   CGF.Builder.CreateUnreachable();
1629 }
1630
1631 static llvm::Value *EmitTypeidFromVTable(CodeGenFunction &CGF,
1632                                          const Expr *E,
1633                                          llvm::Type *StdTypeInfoPtrTy) {
1634   // Get the vtable pointer.
1635   llvm::Value *ThisPtr = CGF.EmitLValue(E).getAddress();
1636
1637   // C++ [expr.typeid]p2:
1638   //   If the glvalue expression is obtained by applying the unary * operator to
1639   //   a pointer and the pointer is a null pointer value, the typeid expression
1640   //   throws the std::bad_typeid exception.
1641   if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParens())) {
1642     if (UO->getOpcode() == UO_Deref) {
1643       llvm::BasicBlock *BadTypeidBlock =
1644         CGF.createBasicBlock("typeid.bad_typeid");
1645       llvm::BasicBlock *EndBlock =
1646         CGF.createBasicBlock("typeid.end");
1647
1648       llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr);
1649       CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
1650
1651       CGF.EmitBlock(BadTypeidBlock);
1652       EmitBadTypeidCall(CGF);
1653       CGF.EmitBlock(EndBlock);
1654     }
1655   }
1656
1657   llvm::Value *Value = CGF.GetVTablePtr(ThisPtr,
1658                                         StdTypeInfoPtrTy->getPointerTo());
1659
1660   // Load the type info.
1661   Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1662   return CGF.Builder.CreateLoad(Value);
1663 }
1664
1665 llvm::Value *CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
1666   llvm::Type *StdTypeInfoPtrTy =
1667     ConvertType(E->getType())->getPointerTo();
1668
1669   if (E->isTypeOperand()) {
1670     llvm::Constant *TypeInfo =
1671       CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand());
1672     return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
1673   }
1674
1675   // C++ [expr.typeid]p2:
1676   //   When typeid is applied to a glvalue expression whose type is a
1677   //   polymorphic class type, the result refers to a std::type_info object
1678   //   representing the type of the most derived object (that is, the dynamic
1679   //   type) to which the glvalue refers.
1680   if (E->isPotentiallyEvaluated())
1681     return EmitTypeidFromVTable(*this, E->getExprOperand(),
1682                                 StdTypeInfoPtrTy);
1683
1684   QualType OperandTy = E->getExprOperand()->getType();
1685   return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
1686                                StdTypeInfoPtrTy);
1687 }
1688
1689 static llvm::Constant *getDynamicCastFn(CodeGenFunction &CGF) {
1690   // void *__dynamic_cast(const void *sub,
1691   //                      const abi::__class_type_info *src,
1692   //                      const abi::__class_type_info *dst,
1693   //                      std::ptrdiff_t src2dst_offset);
1694
1695   llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1696   llvm::Type *PtrDiffTy =
1697     CGF.ConvertType(CGF.getContext().getPointerDiffType());
1698
1699   llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
1700
1701   llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
1702
1703   // Mark the function as nounwind readonly.
1704   llvm::Attribute::AttrKind FuncAttrs[] = { llvm::Attribute::NoUnwind,
1705                                             llvm::Attribute::ReadOnly };
1706   llvm::AttributeSet Attrs = llvm::AttributeSet::get(
1707       CGF.getLLVMContext(), llvm::AttributeSet::FunctionIndex, FuncAttrs);
1708
1709   return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast", Attrs);
1710 }
1711
1712 static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) {
1713   // void __cxa_bad_cast();
1714   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
1715   return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1716 }
1717
1718 static void EmitBadCastCall(CodeGenFunction &CGF) {
1719   llvm::Value *Fn = getBadCastFn(CGF);
1720   CGF.EmitRuntimeCallOrInvoke(Fn).setDoesNotReturn();
1721   CGF.Builder.CreateUnreachable();
1722 }
1723
1724 /// \brief Compute the src2dst_offset hint as described in the
1725 /// Itanium C++ ABI [2.9.7]
1726 static CharUnits computeOffsetHint(ASTContext &Context,
1727                                    const CXXRecordDecl *Src,
1728                                    const CXXRecordDecl *Dst) {
1729   CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
1730                      /*DetectVirtual=*/false);
1731
1732   // If Dst is not derived from Src we can skip the whole computation below and
1733   // return that Src is not a public base of Dst.  Record all inheritance paths.
1734   if (!Dst->isDerivedFrom(Src, Paths))
1735     return CharUnits::fromQuantity(-2ULL);
1736
1737   unsigned NumPublicPaths = 0;
1738   CharUnits Offset;
1739
1740   // Now walk all possible inheritance paths.
1741   for (CXXBasePaths::paths_iterator I = Paths.begin(), E = Paths.end();
1742        I != E; ++I) {
1743     if (I->Access != AS_public) // Ignore non-public inheritance.
1744       continue;
1745
1746     ++NumPublicPaths;
1747
1748     for (CXXBasePath::iterator J = I->begin(), JE = I->end(); J != JE; ++J) {
1749       // If the path contains a virtual base class we can't give any hint.
1750       // -1: no hint.
1751       if (J->Base->isVirtual())
1752         return CharUnits::fromQuantity(-1ULL);
1753
1754       if (NumPublicPaths > 1) // Won't use offsets, skip computation.
1755         continue;
1756
1757       // Accumulate the base class offsets.
1758       const ASTRecordLayout &L = Context.getASTRecordLayout(J->Class);
1759       Offset += L.getBaseClassOffset(J->Base->getType()->getAsCXXRecordDecl());
1760     }
1761   }
1762
1763   // -2: Src is not a public base of Dst.
1764   if (NumPublicPaths == 0)
1765     return CharUnits::fromQuantity(-2ULL);
1766
1767   // -3: Src is a multiple public base type but never a virtual base type.
1768   if (NumPublicPaths > 1)
1769     return CharUnits::fromQuantity(-3ULL);
1770
1771   // Otherwise, the Src type is a unique public nonvirtual base type of Dst.
1772   // Return the offset of Src from the origin of Dst.
1773   return Offset;
1774 }
1775
1776 static llvm::Value *
1777 EmitDynamicCastCall(CodeGenFunction &CGF, llvm::Value *Value,
1778                     QualType SrcTy, QualType DestTy,
1779                     llvm::BasicBlock *CastEnd) {
1780   llvm::Type *PtrDiffLTy =
1781     CGF.ConvertType(CGF.getContext().getPointerDiffType());
1782   llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1783
1784   if (const PointerType *PTy = DestTy->getAs<PointerType>()) {
1785     if (PTy->getPointeeType()->isVoidType()) {
1786       // C++ [expr.dynamic.cast]p7:
1787       //   If T is "pointer to cv void," then the result is a pointer to the
1788       //   most derived object pointed to by v.
1789
1790       // Get the vtable pointer.
1791       llvm::Value *VTable = CGF.GetVTablePtr(Value, PtrDiffLTy->getPointerTo());
1792
1793       // Get the offset-to-top from the vtable.
1794       llvm::Value *OffsetToTop =
1795         CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1796       OffsetToTop = CGF.Builder.CreateLoad(OffsetToTop, "offset.to.top");
1797
1798       // Finally, add the offset to the pointer.
1799       Value = CGF.EmitCastToVoidPtr(Value);
1800       Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1801
1802       return CGF.Builder.CreateBitCast(Value, DestLTy);
1803     }
1804   }
1805
1806   QualType SrcRecordTy;
1807   QualType DestRecordTy;
1808
1809   if (const PointerType *DestPTy = DestTy->getAs<PointerType>()) {
1810     SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
1811     DestRecordTy = DestPTy->getPointeeType();
1812   } else {
1813     SrcRecordTy = SrcTy;
1814     DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
1815   }
1816
1817   assert(SrcRecordTy->isRecordType() && "source type must be a record type!");
1818   assert(DestRecordTy->isRecordType() && "dest type must be a record type!");
1819
1820   llvm::Value *SrcRTTI =
1821     CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1822   llvm::Value *DestRTTI =
1823     CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1824
1825   // Compute the offset hint.
1826   const CXXRecordDecl *SrcDecl = SrcRecordTy->getAsCXXRecordDecl();
1827   const CXXRecordDecl *DestDecl = DestRecordTy->getAsCXXRecordDecl();
1828   llvm::Value *OffsetHint =
1829     llvm::ConstantInt::get(PtrDiffLTy,
1830                            computeOffsetHint(CGF.getContext(), SrcDecl,
1831                                              DestDecl).getQuantity());
1832
1833   // Emit the call to __dynamic_cast.
1834   Value = CGF.EmitCastToVoidPtr(Value);
1835
1836   llvm::Value *args[] = { Value, SrcRTTI, DestRTTI, OffsetHint };
1837   Value = CGF.EmitNounwindRuntimeCall(getDynamicCastFn(CGF), args);
1838   Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1839
1840   /// C++ [expr.dynamic.cast]p9:
1841   ///   A failed cast to reference type throws std::bad_cast
1842   if (DestTy->isReferenceType()) {
1843     llvm::BasicBlock *BadCastBlock =
1844       CGF.createBasicBlock("dynamic_cast.bad_cast");
1845
1846     llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1847     CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1848
1849     CGF.EmitBlock(BadCastBlock);
1850     EmitBadCastCall(CGF);
1851   }
1852
1853   return Value;
1854 }
1855
1856 static llvm::Value *EmitDynamicCastToNull(CodeGenFunction &CGF,
1857                                           QualType DestTy) {
1858   llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1859   if (DestTy->isPointerType())
1860     return llvm::Constant::getNullValue(DestLTy);
1861
1862   /// C++ [expr.dynamic.cast]p9:
1863   ///   A failed cast to reference type throws std::bad_cast
1864   EmitBadCastCall(CGF);
1865
1866   CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
1867   return llvm::UndefValue::get(DestLTy);
1868 }
1869
1870 llvm::Value *CodeGenFunction::EmitDynamicCast(llvm::Value *Value,
1871                                               const CXXDynamicCastExpr *DCE) {
1872   QualType DestTy = DCE->getTypeAsWritten();
1873
1874   if (DCE->isAlwaysNull())
1875     return EmitDynamicCastToNull(*this, DestTy);
1876
1877   QualType SrcTy = DCE->getSubExpr()->getType();
1878
1879   // C++ [expr.dynamic.cast]p4:
1880   //   If the value of v is a null pointer value in the pointer case, the result
1881   //   is the null pointer value of type T.
1882   bool ShouldNullCheckSrcValue = SrcTy->isPointerType();
1883
1884   llvm::BasicBlock *CastNull = 0;
1885   llvm::BasicBlock *CastNotNull = 0;
1886   llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end");
1887
1888   if (ShouldNullCheckSrcValue) {
1889     CastNull = createBasicBlock("dynamic_cast.null");
1890     CastNotNull = createBasicBlock("dynamic_cast.notnull");
1891
1892     llvm::Value *IsNull = Builder.CreateIsNull(Value);
1893     Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
1894     EmitBlock(CastNotNull);
1895   }
1896
1897   Value = EmitDynamicCastCall(*this, Value, SrcTy, DestTy, CastEnd);
1898
1899   if (ShouldNullCheckSrcValue) {
1900     EmitBranch(CastEnd);
1901
1902     EmitBlock(CastNull);
1903     EmitBranch(CastEnd);
1904   }
1905
1906   EmitBlock(CastEnd);
1907
1908   if (ShouldNullCheckSrcValue) {
1909     llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
1910     PHI->addIncoming(Value, CastNotNull);
1911     PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
1912
1913     Value = PHI;
1914   }
1915
1916   return Value;
1917 }
1918
1919 void CodeGenFunction::EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Slot) {
1920   RunCleanupsScope Scope(*this);
1921   LValue SlotLV = MakeAddrLValue(Slot.getAddr(), E->getType(),
1922                                  Slot.getAlignment());
1923
1924   CXXRecordDecl::field_iterator CurField = E->getLambdaClass()->field_begin();
1925   for (LambdaExpr::capture_init_iterator i = E->capture_init_begin(),
1926                                          e = E->capture_init_end();
1927        i != e; ++i, ++CurField) {
1928     // Emit initialization
1929
1930     LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField);
1931     ArrayRef<VarDecl *> ArrayIndexes;
1932     if (CurField->getType()->isArrayType())
1933       ArrayIndexes = E->getCaptureInitIndexVars(i);
1934     EmitInitializerForField(*CurField, LV, *i, ArrayIndexes);
1935   }
1936 }