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