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 }
949