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 using namespace clang;
  16 using namespace CodeGen;
  17
  18 RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
  19                                           llvm::Value *Callee,
  20                                           ReturnValueSlot ReturnValue,
  21                                           llvm::Value *This,
  22                                           llvm::Value *VTT,
  23                                           CallExpr::const_arg_iterator ArgBeg,
  24                                           CallExpr::const_arg_iterator ArgEnd) {
  25   assert(MD->isInstance() &&
  26          "Trying to emit a member call expr on a static method!");
  27
  28   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
  29
  30   CallArgList Args;
  31
  32   // Push the this ptr.
  33   Args.push_back(std::make_pair(RValue::get(This),
  34                                 MD->getThisType(getContext())));
  35
  36   // If there is a VTT parameter, emit it.
  37   if (VTT) {
  38     QualType T = getContext().getPointerType(getContext().VoidPtrTy);
  39     Args.push_back(std::make_pair(RValue::get(VTT), T));
  40   }
  41
  42   // And the rest of the call args
  43   EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
  44
  45   QualType ResultType = FPT->getResultType();
  46   return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
  47                                                  FPT->getExtInfo()),
  48                   Callee, ReturnValue, Args, MD);
  49 }
  50
  51 /// canDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given
  52 /// expr can be devirtualized.
  53 static bool canDevirtualizeMemberFunctionCalls(const Expr *Base) {
  54   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
  55     if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
  56       // This is a record decl. We know the type and can devirtualize it.
  57       return VD->getType()->isRecordType();
  58     }
  59
  60     return false;
  61   }
  62
  63   // We can always devirtualize calls on temporary object expressions.
  64   if (isa<CXXConstructExpr>(Base))
  65     return true;
  66
  67   // And calls on bound temporaries.
  68   if (isa<CXXBindTemporaryExpr>(Base))
  69     return true;
  70
  71   // Check if this is a call expr that returns a record type.
  72   if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
  73     return CE->getCallReturnType()->isRecordType();
  74
  75   // We can't devirtualize the call.
  76   return false;
  77 }
  78
  79 RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
  80                                               ReturnValueSlot ReturnValue) {
  81   if (isa<BinaryOperator>(CE->getCallee()->IgnoreParens()))
  82     return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
  83
  84   const MemberExpr *ME = cast<MemberExpr>(CE->getCallee()->IgnoreParens());
  85   const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
  86
  87   if (MD->isStatic()) {
  88     // The method is static, emit it as we would a regular call.
  89     llvm::Value *Callee = CGM.GetAddrOfFunction(MD);
  90     return EmitCall(getContext().getPointerType(MD->getType()), Callee,
  91                     ReturnValue, CE->arg_begin(), CE->arg_end());
  92   }
  93
  94   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
  95
  96   const llvm::Type *Ty =
  97     CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
  98                                    FPT->isVariadic());
  99   llvm::Value *This;
 100
 101   if (ME->isArrow())
 102     This = EmitScalarExpr(ME->getBase());
 103   else {
 104     LValue BaseLV = EmitLValue(ME->getBase());
 105     This = BaseLV.getAddress();
 106   }
 107
 108   if (MD->isCopyAssignment() && MD->isTrivial()) {
 109     // We don't like to generate the trivial copy assignment operator when
 110     // it isn't necessary; just produce the proper effect here.
 111     llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
 112     EmitAggregateCopy(This, RHS, CE->getType());
 113     return RValue::get(This);
 114   }
 115
 116   // C++ [class.virtual]p12:
 117   //   Explicit qualification with the scope operator (5.1) suppresses the
 118   //   virtual call mechanism.
 119   //
 120   // We also don't emit a virtual call if the base expression has a record type
 121   // because then we know what the type is.
 122   llvm::Value *Callee;
 123   if (const CXXDestructorDecl *Destructor
 124              = dyn_cast<CXXDestructorDecl>(MD)) {
 125     if (Destructor->isTrivial())
 126       return RValue::get(0);
 127     if (MD->isVirtual() && !ME->hasQualifier() &&
 128         !canDevirtualizeMemberFunctionCalls(ME->getBase())) {
 129       Callee = BuildVirtualCall(Destructor, Dtor_Complete, This, Ty);
 130     } else {
 131       Callee = CGM.GetAddrOfFunction(GlobalDecl(Destructor, Dtor_Complete), Ty);
 132     }
 133   } else if (MD->isVirtual() && !ME->hasQualifier() &&
 134              !canDevirtualizeMemberFunctionCalls(ME->getBase())) {
 135     Callee = BuildVirtualCall(MD, This, Ty);
 136   } else {
 137     Callee = CGM.GetAddrOfFunction(MD, Ty);
 138   }
 139
 140   return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
 141                            CE->arg_begin(), CE->arg_end());
 142 }
 143
 144 RValue
 145 CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
 146                                               ReturnValueSlot ReturnValue) {
 147   const BinaryOperator *BO =
 148       cast<BinaryOperator>(E->getCallee()->IgnoreParens());
 149   const Expr *BaseExpr = BO->getLHS();
 150   const Expr *MemFnExpr = BO->getRHS();
 151
 152   const MemberPointerType *MPT =
 153     MemFnExpr->getType()->getAs<MemberPointerType>();
 154   const FunctionProtoType *FPT =
 155     MPT->getPointeeType()->getAs<FunctionProtoType>();
 156   const CXXRecordDecl *RD =
 157     cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
 158
 159   const llvm::FunctionType *FTy =
 160     CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(RD, FPT),
 161                                    FPT->isVariadic());
 162
 163   const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(VMContext);
 164
 165   // Get the member function pointer.
 166   llvm::Value *MemFnPtr = CreateMemTemp(MemFnExpr->getType(), "mem.fn");
 167   EmitAggExpr(MemFnExpr, MemFnPtr, /*VolatileDest=*/false);
 168
 169   // Emit the 'this' pointer.
 170   llvm::Value *This;
 171
 172   if (BO->getOpcode() == BinaryOperator::PtrMemI)
 173     This = EmitScalarExpr(BaseExpr);
 174   else
 175     This = EmitLValue(BaseExpr).getAddress();
 176
 177   // Adjust it.
 178   llvm::Value *Adj = Builder.CreateStructGEP(MemFnPtr, 1);
 179   Adj = Builder.CreateLoad(Adj, "mem.fn.adj");
 180
 181   llvm::Value *Ptr = Builder.CreateBitCast(This, Int8PtrTy, "ptr");
 182   Ptr = Builder.CreateGEP(Ptr, Adj, "adj");
 183
 184   This = Builder.CreateBitCast(Ptr, This->getType(), "this");
 185
 186   llvm::Value *FnPtr = Builder.CreateStructGEP(MemFnPtr, 0, "mem.fn.ptr");
 187
 188   const llvm::Type *PtrDiffTy = ConvertType(getContext().getPointerDiffType());
 189
 190   llvm::Value *FnAsInt = Builder.CreateLoad(FnPtr, "fn");
 191
 192   // If the LSB in the function pointer is 1, the function pointer points to
 193   // a virtual function.
 194   llvm::Value *IsVirtual
 195     = Builder.CreateAnd(FnAsInt, llvm::ConstantInt::get(PtrDiffTy, 1),
 196                         "and");
 197
 198   IsVirtual = Builder.CreateTrunc(IsVirtual,
 199                                   llvm::Type::getInt1Ty(VMContext));
 200
 201   llvm::BasicBlock *FnVirtual = createBasicBlock("fn.virtual");
 202   llvm::BasicBlock *FnNonVirtual = createBasicBlock("fn.nonvirtual");
 203   llvm::BasicBlock *FnEnd = createBasicBlock("fn.end");
 204
 205   Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
 206   EmitBlock(FnVirtual);
 207
 208   const llvm::Type *VTableTy =
 209     FTy->getPointerTo()->getPointerTo();
 210
 211   llvm::Value *VTable = Builder.CreateBitCast(This, VTableTy->getPointerTo());
 212   VTable = Builder.CreateLoad(VTable);
 213
 214   VTable = Builder.CreateBitCast(VTable, Int8PtrTy);
 215   llvm::Value *VTableOffset =
 216     Builder.CreateSub(FnAsInt, llvm::ConstantInt::get(PtrDiffTy, 1));
 217
 218   VTable = Builder.CreateGEP(VTable, VTableOffset, "fn");
 219   VTable = Builder.CreateBitCast(VTable, VTableTy);
 220
 221   llvm::Value *VirtualFn = Builder.CreateLoad(VTable, "virtualfn");
 222
 223   EmitBranch(FnEnd);
 224   EmitBlock(FnNonVirtual);
 225
 226   // If the function is not virtual, just load the pointer.
 227   llvm::Value *NonVirtualFn = Builder.CreateLoad(FnPtr, "fn");
 228   NonVirtualFn = Builder.CreateIntToPtr(NonVirtualFn, FTy->getPointerTo());
 229
 230   EmitBlock(FnEnd);
 231
 232   llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo());
 233   Callee->reserveOperandSpace(2);
 234   Callee->addIncoming(VirtualFn, FnVirtual);
 235   Callee->addIncoming(NonVirtualFn, FnNonVirtual);
 236
 237   CallArgList Args;
 238
 239   QualType ThisType =
 240     getContext().getPointerType(getContext().getTagDeclType(RD));
 241
 242   // Push the this ptr.
 243   Args.push_back(std::make_pair(RValue::get(This), ThisType));
 244
 245   // And the rest of the call args
 246   EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end());
 247   const FunctionType *BO_FPT = BO->getType()->getAs<FunctionProtoType>();
 248   return EmitCall(CGM.getTypes().getFunctionInfo(Args, BO_FPT), Callee,
 249                   ReturnValue, Args);
 250 }
 251
 252 RValue
 253 CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
 254                                                const CXXMethodDecl *MD,
 255                                                ReturnValueSlot ReturnValue) {
 256   assert(MD->isInstance() &&
 257          "Trying to emit a member call expr on a static method!");
 258
 259   if (MD->isCopyAssignment()) {
 260     const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext());
 261     if (ClassDecl->hasTrivialCopyAssignment()) {
 262       assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
 263              "EmitCXXOperatorMemberCallExpr - user declared copy assignment");
 264       llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
 265       llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
 266       QualType Ty = E->getType();
 267       EmitAggregateCopy(This, Src, Ty);
 268       return RValue::get(This);
 269     }
 270   }
 271
 272   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 273   const llvm::Type *Ty =
 274     CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
 275                                    FPT->isVariadic());
 276
 277   llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
 278
 279   llvm::Value *Callee;
 280   if (MD->isVirtual() && !canDevirtualizeMemberFunctionCalls(E->getArg(0)))
 281     Callee = BuildVirtualCall(MD, This, Ty);
 282   else
 283     Callee = CGM.GetAddrOfFunction(MD, Ty);
 284
 285   return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
 286                            E->arg_begin() + 1, E->arg_end());
 287 }
 288
 289 void
 290 CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
 291                                       const CXXConstructExpr *E) {
 292   assert(Dest && "Must have a destination!");
 293   const CXXConstructorDecl *CD = E->getConstructor();
 294   const ConstantArrayType *Array =
 295   getContext().getAsConstantArrayType(E->getType());
 296   // For a copy constructor, even if it is trivial, must fall thru so
 297   // its argument is code-gen'ed.
 298   if (!CD->isCopyConstructor()) {
 299     QualType InitType = E->getType();
 300     if (Array)
 301       InitType = getContext().getBaseElementType(Array);
 302     const CXXRecordDecl *RD =
 303     cast<CXXRecordDecl>(InitType->getAs<RecordType>()->getDecl());
 304     if (RD->hasTrivialConstructor())
 305       return;
 306   }
 307   // Code gen optimization to eliminate copy constructor and return
 308   // its first argument instead.
 309   if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
 310     const Expr *Arg = E->getArg(0)->getTemporaryObject();
 311     EmitAggExpr(Arg, Dest, false);
 312     return;
 313   }
 314   if (Array) {
 315     QualType BaseElementTy = getContext().getBaseElementType(Array);
 316     const llvm::Type *BasePtr = ConvertType(BaseElementTy);
 317     BasePtr = llvm::PointerType::getUnqual(BasePtr);
 318     llvm::Value *BaseAddrPtr =
 319       Builder.CreateBitCast(Dest, BasePtr);
 320
 321     EmitCXXAggrConstructorCall(CD, Array, BaseAddrPtr,
 322                                E->arg_begin(), E->arg_end());
 323   }
 324   else {
 325     CXXCtorType Type =
 326       (E->getConstructionKind() == CXXConstructExpr::CK_Complete)
 327       ? Ctor_Complete : Ctor_Base;
 328     bool ForVirtualBase =
 329       E->getConstructionKind() == CXXConstructExpr::CK_VirtualBase;
 330
 331     // Call the constructor.
 332     EmitCXXConstructorCall(CD, Type, ForVirtualBase, Dest,
 333                            E->arg_begin(), E->arg_end());
 334   }
 335 }
 336
 337 static CharUnits CalculateCookiePadding(ASTContext &Ctx, QualType ElementType) {
 338   const RecordType *RT = ElementType->getAs<RecordType>();
 339   if (!RT)
 340     return CharUnits::Zero();
 341
 342   const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
 343   if (!RD)
 344     return CharUnits::Zero();
 345
 346   // Check if the class has a trivial destructor.
 347   if (RD->hasTrivialDestructor()) {
 348     // Check if the usual deallocation function takes two arguments.
 349     const CXXMethodDecl *UsualDeallocationFunction = 0;
 350
 351     DeclarationName OpName =
 352       Ctx.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
 353     DeclContext::lookup_const_iterator Op, OpEnd;
 354     for (llvm::tie(Op, OpEnd) = RD->lookup(OpName);
 355          Op != OpEnd; ++Op) {
 356       const CXXMethodDecl *Delete = cast<CXXMethodDecl>(*Op);
 357
 358       if (Delete->isUsualDeallocationFunction()) {
 359         UsualDeallocationFunction = Delete;
 360         break;
 361       }
 362     }
 363
 364     // No usual deallocation function, we don't need a cookie.
 365     if (!UsualDeallocationFunction)
 366       return CharUnits::Zero();
 367
 368     // The usual deallocation function doesn't take a size_t argument, so we
 369     // don't need a cookie.
 370     if (UsualDeallocationFunction->getNumParams() == 1)
 371       return CharUnits::Zero();
 372
 373     assert(UsualDeallocationFunction->getNumParams() == 2 &&
 374            "Unexpected deallocation function type!");
 375   }
 376
 377   // Padding is the maximum of sizeof(size_t) and alignof(ElementType)
 378   return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
 379                   Ctx.getTypeAlignInChars(ElementType));
 380 }
 381
 382 static CharUnits CalculateCookiePadding(ASTContext &Ctx, const CXXNewExpr *E) {
 383   if (!E->isArray())
 384     return CharUnits::Zero();
 385
 386   // No cookie is required if the new operator being used is
 387   // ::operator new[](size_t, void*).
 388   const FunctionDecl *OperatorNew = E->getOperatorNew();
 389   if (OperatorNew->getDeclContext()->getLookupContext()->isFileContext()) {
 390     if (OperatorNew->getNumParams() == 2) {
 391       CanQualType ParamType =
 392         Ctx.getCanonicalType(OperatorNew->getParamDecl(1)->getType());
 393
 394       if (ParamType == Ctx.VoidPtrTy)
 395         return CharUnits::Zero();
 396     }
 397   }
 398
 399   return CalculateCookiePadding(Ctx, E->getAllocatedType());
 400 }
 401
 402 static llvm::Value *EmitCXXNewAllocSize(ASTContext &Context,
 403                                         CodeGenFunction &CGF,
 404                                         const CXXNewExpr *E,
 405                                         llvm::Value *& NumElements) {
 406   QualType Type = E->getAllocatedType();
 407   CharUnits TypeSize = CGF.getContext().getTypeSizeInChars(Type);
 408   const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
 409
 410   if (!E->isArray())
 411     return llvm::ConstantInt::get(SizeTy, TypeSize.getQuantity());
 412
 413   CharUnits CookiePadding = CalculateCookiePadding(CGF.getContext(), E);
 414
 415   Expr::EvalResult Result;
 416   if (E->getArraySize()->Evaluate(Result, CGF.getContext()) &&
 417       !Result.HasSideEffects && Result.Val.isInt()) {
 418
 419     CharUnits AllocSize =
 420       Result.Val.getInt().getZExtValue() * TypeSize + CookiePadding;
 421
 422     NumElements =
 423       llvm::ConstantInt::get(SizeTy, Result.Val.getInt().getZExtValue());
 424     while (const ArrayType *AType = Context.getAsArrayType(Type)) {
 425       const llvm::ArrayType *llvmAType =
 426         cast<llvm::ArrayType>(CGF.ConvertType(Type));
 427       NumElements =
 428         CGF.Builder.CreateMul(NumElements,
 429                               llvm::ConstantInt::get(
 430                                         SizeTy, llvmAType->getNumElements()));
 431       Type = AType->getElementType();
 432     }
 433
 434     return llvm::ConstantInt::get(SizeTy, AllocSize.getQuantity());
 435   }
 436
 437   // Emit the array size expression.
 438   NumElements = CGF.EmitScalarExpr(E->getArraySize());
 439
 440   // Multiply with the type size.
 441   llvm::Value *V =
 442     CGF.Builder.CreateMul(NumElements,
 443                           llvm::ConstantInt::get(SizeTy,
 444                                                  TypeSize.getQuantity()));
 445
 446   while (const ArrayType *AType = Context.getAsArrayType(Type)) {
 447     const llvm::ArrayType *llvmAType =
 448       cast<llvm::ArrayType>(CGF.ConvertType(Type));
 449     NumElements =
 450       CGF.Builder.CreateMul(NumElements,
 451                             llvm::ConstantInt::get(
 452                                           SizeTy, llvmAType->getNumElements()));
 453     Type = AType->getElementType();
 454   }
 455
 456   // And add the cookie padding if necessary.
 457   if (!CookiePadding.isZero())
 458     V = CGF.Builder.CreateAdd(V,
 459         llvm::ConstantInt::get(SizeTy, CookiePadding.getQuantity()));
 460
 461   return V;
 462 }
 463
 464 static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
 465                                llvm::Value *NewPtr,
 466                                llvm::Value *NumElements) {
 467   if (E->isArray()) {
 468     if (CXXConstructorDecl *Ctor = E->getConstructor()) {
 469       if (!Ctor->getParent()->hasTrivialConstructor())
 470         CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr,
 471                                        E->constructor_arg_begin(),
 472                                        E->constructor_arg_end());
 473       return;
 474     }
 475   }
 476
 477   QualType AllocType = E->getAllocatedType();
 478
 479   if (CXXConstructorDecl *Ctor = E->getConstructor()) {
 480     CGF.EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false,
 481                                NewPtr, E->constructor_arg_begin(),
 482                                E->constructor_arg_end());
 483
 484     return;
 485   }
 486
 487   // We have a POD type.
 488   if (E->getNumConstructorArgs() == 0)
 489     return;
 490
 491   assert(E->getNumConstructorArgs() == 1 &&
 492          "Can only have one argument to initializer of POD type.");
 493
 494   const Expr *Init = E->getConstructorArg(0);
 495
 496   if (!CGF.hasAggregateLLVMType(AllocType))
 497     CGF.EmitStoreOfScalar(CGF.EmitScalarExpr(Init), NewPtr,
 498                           AllocType.isVolatileQualified(), AllocType);
 499   else if (AllocType->isAnyComplexType())
 500     CGF.EmitComplexExprIntoAddr(Init, NewPtr,
 501                                 AllocType.isVolatileQualified());
 502   else
 503     CGF.EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified());
 504 }
 505
 506 llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
 507   QualType AllocType = E->getAllocatedType();
 508   FunctionDecl *NewFD = E->getOperatorNew();
 509   const FunctionProtoType *NewFTy = NewFD->getType()->getAs<FunctionProtoType>();
 510
 511   CallArgList NewArgs;
 512
 513   // The allocation size is the first argument.
 514   QualType SizeTy = getContext().getSizeType();
 515
 516   llvm::Value *NumElements = 0;
 517   llvm::Value *AllocSize = EmitCXXNewAllocSize(getContext(),
 518                                                *this, E, NumElements);
 519
 520   NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy));
 521
 522   // Emit the rest of the arguments.
 523   // FIXME: Ideally, this should just use EmitCallArgs.
 524   CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin();
 525
 526   // First, use the types from the function type.
 527   // We start at 1 here because the first argument (the allocation size)
 528   // has already been emitted.
 529   for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) {
 530     QualType ArgType = NewFTy->getArgType(i);
 531
 532     assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
 533            getTypePtr() ==
 534            getContext().getCanonicalType(NewArg->getType()).getTypePtr() &&
 535            "type mismatch in call argument!");
 536
 537     NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
 538                                      ArgType));
 539
 540   }
 541
 542   // Either we've emitted all the call args, or we have a call to a
 543   // variadic function.
 544   assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) &&
 545          "Extra arguments in non-variadic function!");
 546
 547   // If we still have any arguments, emit them using the type of the argument.
 548   for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end();
 549        NewArg != NewArgEnd; ++NewArg) {
 550     QualType ArgType = NewArg->getType();
 551     NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
 552                                      ArgType));
 553   }
 554
 555   // Emit the call to new.
 556   RValue RV =
 557     EmitCall(CGM.getTypes().getFunctionInfo(NewArgs, NewFTy),
 558              CGM.GetAddrOfFunction(NewFD), ReturnValueSlot(), NewArgs, NewFD);
 559
 560   // If an allocation function is declared with an empty exception specification
 561   // it returns null to indicate failure to allocate storage. [expr.new]p13.
 562   // (We don't need to check for null when there's no new initializer and
 563   // we're allocating a POD type).
 564   bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() &&
 565     !(AllocType->isPODType() && !E->hasInitializer());
 566
 567   llvm::BasicBlock *NewNull = 0;
 568   llvm::BasicBlock *NewNotNull = 0;
 569   llvm::BasicBlock *NewEnd = 0;
 570
 571   llvm::Value *NewPtr = RV.getScalarVal();
 572
 573   if (NullCheckResult) {
 574     NewNull = createBasicBlock("new.null");
 575     NewNotNull = createBasicBlock("new.notnull");
 576     NewEnd = createBasicBlock("new.end");
 577
 578     llvm::Value *IsNull =
 579       Builder.CreateICmpEQ(NewPtr,
 580                            llvm::Constant::getNullValue(NewPtr->getType()),
 581                            "isnull");
 582
 583     Builder.CreateCondBr(IsNull, NewNull, NewNotNull);
 584     EmitBlock(NewNotNull);
 585   }
 586
 587   CharUnits CookiePadding = CalculateCookiePadding(getContext(), E);
 588   if (!CookiePadding.isZero()) {
 589     CharUnits CookieOffset =
 590       CookiePadding - getContext().getTypeSizeInChars(SizeTy);
 591
 592     llvm::Value *NumElementsPtr =
 593       Builder.CreateConstInBoundsGEP1_64(NewPtr, CookieOffset.getQuantity());
 594
 595     NumElementsPtr = Builder.CreateBitCast(NumElementsPtr,
 596                                            ConvertType(SizeTy)->getPointerTo());
 597     Builder.CreateStore(NumElements, NumElementsPtr);
 598
 599     // Now add the padding to the new ptr.
 600     NewPtr = Builder.CreateConstInBoundsGEP1_64(NewPtr,
 601                                                 CookiePadding.getQuantity());
 602   }
 603
 604   if (AllocType->isArrayType()) {
 605     while (const ArrayType *AType = getContext().getAsArrayType(AllocType))
 606       AllocType = AType->getElementType();
 607     NewPtr =
 608       Builder.CreateBitCast(NewPtr,
 609                           ConvertType(getContext().getPointerType(AllocType)));
 610     EmitNewInitializer(*this, E, NewPtr, NumElements);
 611     NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
 612   }
 613   else {
 614     NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
 615     EmitNewInitializer(*this, E, NewPtr, NumElements);
 616   }
 617
 618   if (NullCheckResult) {
 619     Builder.CreateBr(NewEnd);
 620     NewNotNull = Builder.GetInsertBlock();
 621     EmitBlock(NewNull);
 622     Builder.CreateBr(NewEnd);
 623     EmitBlock(NewEnd);
 624
 625     llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
 626     PHI->reserveOperandSpace(2);
 627     PHI->addIncoming(NewPtr, NewNotNull);
 628     PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull);
 629
 630     NewPtr = PHI;
 631   }
 632
 633   return NewPtr;
 634 }
 635
 636 static std::pair<llvm::Value *, llvm::Value *>
 637 GetAllocatedObjectPtrAndNumElements(CodeGenFunction &CGF,
 638                                     llvm::Value *Ptr, QualType DeleteTy) {
 639   QualType SizeTy = CGF.getContext().getSizeType();
 640   const llvm::Type *SizeLTy = CGF.ConvertType(SizeTy);
 641
 642   CharUnits DeleteTypeAlign = CGF.getContext().getTypeAlignInChars(DeleteTy);
 643   CharUnits CookiePadding =
 644     std::max(CGF.getContext().getTypeSizeInChars(SizeTy),
 645              DeleteTypeAlign);
 646   assert(!CookiePadding.isZero() && "CookiePadding should not be 0.");
 647
 648   const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
 649   CharUnits CookieOffset =
 650     CookiePadding - CGF.getContext().getTypeSizeInChars(SizeTy);
 651
 652   llvm::Value *AllocatedObjectPtr = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
 653   AllocatedObjectPtr =
 654     CGF.Builder.CreateConstInBoundsGEP1_64(AllocatedObjectPtr,
 655                                            -CookiePadding.getQuantity());
 656
 657   llvm::Value *NumElementsPtr =
 658     CGF.Builder.CreateConstInBoundsGEP1_64(AllocatedObjectPtr,
 659                                            CookieOffset.getQuantity());
 660   NumElementsPtr =
 661     CGF.Builder.CreateBitCast(NumElementsPtr, SizeLTy->getPointerTo());
 662
 663   llvm::Value *NumElements = CGF.Builder.CreateLoad(NumElementsPtr);
 664   NumElements =
 665     CGF.Builder.CreateIntCast(NumElements, SizeLTy, /*isSigned=*/false);
 666
 667   return std::make_pair(AllocatedObjectPtr, NumElements);
 668 }
 669
 670 void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
 671                                      llvm::Value *Ptr,
 672                                      QualType DeleteTy) {
 673   const FunctionProtoType *DeleteFTy =
 674     DeleteFD->getType()->getAs<FunctionProtoType>();
 675
 676   CallArgList DeleteArgs;
 677
 678   // Check if we need to pass the size to the delete operator.
 679   llvm::Value *Size = 0;
 680   QualType SizeTy;
 681   if (DeleteFTy->getNumArgs() == 2) {
 682     SizeTy = DeleteFTy->getArgType(1);
 683     CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
 684     Size = llvm::ConstantInt::get(ConvertType(SizeTy),
 685                                   DeleteTypeSize.getQuantity());
 686   }
 687
 688   if (DeleteFD->getOverloadedOperator() == OO_Array_Delete &&
 689       !CalculateCookiePadding(getContext(), DeleteTy).isZero()) {
 690     // We need to get the number of elements in the array from the cookie.
 691     llvm::Value *AllocatedObjectPtr;
 692     llvm::Value *NumElements;
 693     llvm::tie(AllocatedObjectPtr, NumElements) =
 694       GetAllocatedObjectPtrAndNumElements(*this, Ptr, DeleteTy);
 695
 696     // Multiply the size with the number of elements.
 697     if (Size)
 698       Size = Builder.CreateMul(NumElements, Size);
 699
 700     Ptr = AllocatedObjectPtr;
 701   }
 702
 703   QualType ArgTy = DeleteFTy->getArgType(0);
 704   llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
 705   DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy));
 706
 707   if (Size)
 708     DeleteArgs.push_back(std::make_pair(RValue::get(Size), SizeTy));
 709
 710   // Emit the call to delete.
 711   EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy),
 712            CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(),
 713            DeleteArgs, DeleteFD);
 714 }
 715
 716 void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
 717
 718   // Get at the argument before we performed the implicit conversion
 719   // to void*.
 720   const Expr *Arg = E->getArgument();
 721   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
 722     if (ICE->getCastKind() != CastExpr::CK_UserDefinedConversion &&
 723         ICE->getType()->isVoidPointerType())
 724       Arg = ICE->getSubExpr();
 725     else
 726       break;
 727   }
 728
 729   QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType();
 730
 731   llvm::Value *Ptr = EmitScalarExpr(Arg);
 732
 733   // Null check the pointer.
 734   llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
 735   llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
 736
 737   llvm::Value *IsNull =
 738     Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()),
 739                          "isnull");
 740
 741   Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
 742   EmitBlock(DeleteNotNull);
 743
 744   bool ShouldCallDelete = true;
 745
 746   // Call the destructor if necessary.
 747   if (const RecordType *RT = DeleteTy->getAs<RecordType>()) {
 748     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
 749       if (!RD->hasTrivialDestructor()) {
 750         const CXXDestructorDecl *Dtor = RD->getDestructor(getContext());
 751         if (E->isArrayForm()) {
 752           llvm::Value *AllocatedObjectPtr;
 753           llvm::Value *NumElements;
 754           llvm::tie(AllocatedObjectPtr, NumElements) =
 755             GetAllocatedObjectPtrAndNumElements(*this, Ptr, DeleteTy);
 756
 757           EmitCXXAggrDestructorCall(Dtor, NumElements, Ptr);
 758         } else if (Dtor->isVirtual()) {
 759           const llvm::Type *Ty =
 760             CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(Dtor),
 761                                            /*isVariadic=*/false);
 762
 763           llvm::Value *Callee = BuildVirtualCall(Dtor, Dtor_Deleting, Ptr, Ty);
 764           EmitCXXMemberCall(Dtor, Callee, ReturnValueSlot(), Ptr, /*VTT=*/0,
 765                             0, 0);
 766
 767           // The dtor took care of deleting the object.
 768           ShouldCallDelete = false;
 769         } else
 770           EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
 771                                 Ptr);
 772       }
 773     }
 774   }
 775
 776   if (ShouldCallDelete)
 777     EmitDeleteCall(E->getOperatorDelete(), Ptr, DeleteTy);
 778
 779   EmitBlock(DeleteEnd);
 780 }
 781
 782 llvm::Value * CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
 783   QualType Ty = E->getType();
 784   const llvm::Type *LTy = ConvertType(Ty)->getPointerTo();
 785
 786   if (E->isTypeOperand()) {
 787     llvm::Constant *TypeInfo =
 788       CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand());
 789     return Builder.CreateBitCast(TypeInfo, LTy);
 790   }
 791
 792   Expr *subE = E->getExprOperand();
 793   Ty = subE->getType();
 794   CanQualType CanTy = CGM.getContext().getCanonicalType(Ty);
 795   Ty = CanTy.getUnqualifiedType().getNonReferenceType();
 796   if (const RecordType *RT = Ty->getAs<RecordType>()) {
 797     const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 798     if (RD->isPolymorphic()) {
 799       // FIXME: if subE is an lvalue do
 800       LValue Obj = EmitLValue(subE);
 801       llvm::Value *This = Obj.getAddress();
 802       LTy = LTy->getPointerTo()->getPointerTo();
 803       llvm::Value *V = Builder.CreateBitCast(This, LTy);
 804       // We need to do a zero check for *p, unless it has NonNullAttr.
 805       // FIXME: PointerType->hasAttr<NonNullAttr>()
 806       bool CanBeZero = false;
 807       if (UnaryOperator *UO = dyn_cast<UnaryOperator>(subE->IgnoreParens()))
 808         if (UO->getOpcode() == UnaryOperator::Deref)
 809           CanBeZero = true;
 810       if (CanBeZero) {
 811         llvm::BasicBlock *NonZeroBlock = createBasicBlock();
 812         llvm::BasicBlock *ZeroBlock = createBasicBlock();
 813
 814         llvm::Value *Zero = llvm::Constant::getNullValue(LTy);
 815         Builder.CreateCondBr(Builder.CreateICmpNE(V, Zero),
 816                              NonZeroBlock, ZeroBlock);
 817         EmitBlock(ZeroBlock);
 818         /// Call __cxa_bad_typeid
 819         const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
 820         const llvm::FunctionType *FTy;
 821         FTy = llvm::FunctionType::get(ResultType, false);
 822         llvm::Value *F = CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
 823         Builder.CreateCall(F)->setDoesNotReturn();
 824         Builder.CreateUnreachable();
 825         EmitBlock(NonZeroBlock);
 826       }
 827       V = Builder.CreateLoad(V, "vtable");
 828       V = Builder.CreateConstInBoundsGEP1_64(V, -1ULL);
 829       V = Builder.CreateLoad(V);
 830       return V;
 831     }
 832   }
 833   return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(Ty), LTy);
 834 }
 835
 836 llvm::Value *CodeGenFunction::EmitDynamicCast(llvm::Value *V,
 837                                               const CXXDynamicCastExpr *DCE) {
 838   QualType SrcTy = DCE->getSubExpr()->getType();
 839   QualType DestTy = DCE->getTypeAsWritten();
 840   QualType InnerType = DestTy->getPointeeType();
 841
 842   const llvm::Type *LTy = ConvertType(DCE->getType());
 843
 844   bool CanBeZero = false;
 845   bool ToVoid = false;
 846   bool ThrowOnBad = false;
 847   if (DestTy->isPointerType()) {
 848     // FIXME: if PointerType->hasAttr<NonNullAttr>(), we don't set this
 849     CanBeZero = true;
 850     if (InnerType->isVoidType())
 851       ToVoid = true;
 852   } else {
 853     LTy = LTy->getPointerTo();
 854     ThrowOnBad = true;
 855   }
 856
 857   if (SrcTy->isPointerType() || SrcTy->isReferenceType())
 858     SrcTy = SrcTy->getPointeeType();
 859   SrcTy = SrcTy.getUnqualifiedType();
 860
 861   if (DestTy->isPointerType() || DestTy->isReferenceType())
 862     DestTy = DestTy->getPointeeType();
 863   DestTy = DestTy.getUnqualifiedType();
 864
 865   llvm::BasicBlock *ContBlock = createBasicBlock();
 866   llvm::BasicBlock *NullBlock = 0;
 867   llvm::BasicBlock *NonZeroBlock = 0;
 868   if (CanBeZero) {
 869     NonZeroBlock = createBasicBlock();
 870     NullBlock = createBasicBlock();
 871     Builder.CreateCondBr(Builder.CreateIsNotNull(V), NonZeroBlock, NullBlock);
 872     EmitBlock(NonZeroBlock);
 873   }
 874
 875   llvm::BasicBlock *BadCastBlock = 0;
 876
 877   const llvm::Type *PtrDiffTy = ConvertType(getContext().getPointerDiffType());
 878
 879   // See if this is a dynamic_cast(void*)
 880   if (ToVoid) {
 881     llvm::Value *This = V;
 882     V = Builder.CreateBitCast(This, PtrDiffTy->getPointerTo()->getPointerTo());
 883     V = Builder.CreateLoad(V, "vtable");
 884     V = Builder.CreateConstInBoundsGEP1_64(V, -2ULL);
 885     V = Builder.CreateLoad(V, "offset to top");
 886     This = Builder.CreateBitCast(This, llvm::Type::getInt8PtrTy(VMContext));
 887     V = Builder.CreateInBoundsGEP(This, V);
 888     V = Builder.CreateBitCast(V, LTy);
 889   } else {
 890     /// Call __dynamic_cast
 891     const llvm::Type *ResultType = llvm::Type::getInt8PtrTy(VMContext);
 892     const llvm::FunctionType *FTy;
 893     std::vector<const llvm::Type*> ArgTys;
 894     const llvm::Type *PtrToInt8Ty
 895       = llvm::Type::getInt8Ty(VMContext)->getPointerTo();
 896     ArgTys.push_back(PtrToInt8Ty);
 897     ArgTys.push_back(PtrToInt8Ty);
 898     ArgTys.push_back(PtrToInt8Ty);
 899     ArgTys.push_back(PtrDiffTy);
 900     FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
 901
 902     // FIXME: Calculate better hint.
 903     llvm::Value *hint = llvm::ConstantInt::get(PtrDiffTy, -1ULL);
 904
 905     assert(SrcTy->isRecordType() && "Src type must be record type!");
 906     assert(DestTy->isRecordType() && "Dest type must be record type!");
 907
 908     llvm::Value *SrcArg
 909       = CGM.GetAddrOfRTTIDescriptor(SrcTy.getUnqualifiedType());
 910     llvm::Value *DestArg
 911       = CGM.GetAddrOfRTTIDescriptor(DestTy.getUnqualifiedType());
 912
 913     V = Builder.CreateBitCast(V, PtrToInt8Ty);
 914     V = Builder.CreateCall4(CGM.CreateRuntimeFunction(FTy, "__dynamic_cast"),
 915                             V, SrcArg, DestArg, hint);
 916     V = Builder.CreateBitCast(V, LTy);
 917
 918     if (ThrowOnBad) {
 919       BadCastBlock = createBasicBlock();
 920
 921       Builder.CreateCondBr(Builder.CreateIsNotNull(V), ContBlock, BadCastBlock);
 922       EmitBlock(BadCastBlock);
 923       /// Call __cxa_bad_cast
 924       ResultType = llvm::Type::getVoidTy(VMContext);
 925       const llvm::FunctionType *FBadTy;
 926       FBadTy = llvm::FunctionType::get(ResultType, false);
 927       llvm::Value *F = CGM.CreateRuntimeFunction(FBadTy, "__cxa_bad_cast");
 928       Builder.CreateCall(F)->setDoesNotReturn();
 929       Builder.CreateUnreachable();
 930     }
 931   }
 932
 933   if (CanBeZero) {
 934     Builder.CreateBr(ContBlock);
 935     EmitBlock(NullBlock);
 936     Builder.CreateBr(ContBlock);
 937   }
 938   EmitBlock(ContBlock);
 939   if (CanBeZero) {
 940     llvm::PHINode *PHI = Builder.CreatePHI(LTy);
 941     PHI->reserveOperandSpace(2);
 942     PHI->addIncoming(V, NonZeroBlock);
 943     PHI->addIncoming(llvm::Constant::getNullValue(LTy), NullBlock);
 944     V = PHI;
 945   }
 946
 947   return V;
 948 }