CGExprCXX.cpp revision 1d110e05e0ff48c1c7a483d6b7fd094cdf28316a 
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"
16using namespace clang;
17using namespace CodeGen;
18
19RValue 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.
54static 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
80RValue 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
145RValue
146CodeGenFunction::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
253RValue
254CodeGenFunction::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      EmitAggregateCopy(This, Src, Ty);
279      return RValue::get(This);
280    }
281  }
282
283  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
284  const llvm::Type *Ty =
285    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
286                                   FPT->isVariadic());
287  LValue LV = EmitLValue(E->getArg(0));
288  llvm::Value *This;
289  if (LV.isPropertyRef()) {
290    RValue RV = EmitLoadOfPropertyRefLValue(LV, E->getArg(0)->getType());
291    assert (!RV.isScalar() && "EmitCXXOperatorMemberCallExpr");
292    This = RV.getAggregateAddr();
293  }
294  else
295    This = LV.getAddress();
296
297  llvm::Value *Callee;
298  if (MD->isVirtual() && !canDevirtualizeMemberFunctionCalls(E->getArg(0)))
299    Callee = BuildVirtualCall(MD, This, Ty);
300  else
301    Callee = CGM.GetAddrOfFunction(MD, Ty);
302
303  return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
304                           E->arg_begin() + 1, E->arg_end());
305}
306
307void
308CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
309                                      const CXXConstructExpr *E) {
310  assert(Dest && "Must have a destination!");
311  const CXXConstructorDecl *CD = E->getConstructor();
312  const ConstantArrayType *Array =
313  getContext().getAsConstantArrayType(E->getType());
314  // For a copy constructor, even if it is trivial, must fall thru so
315  // its argument is code-gen'ed.
316  if (!CD->isCopyConstructor()) {
317    QualType InitType = E->getType();
318    if (Array)
319      InitType = getContext().getBaseElementType(Array);
320    const CXXRecordDecl *RD =
321    cast<CXXRecordDecl>(InitType->getAs<RecordType>()->getDecl());
322    if (RD->hasTrivialConstructor())
323      return;
324  }
325  // Code gen optimization to eliminate copy constructor and return
326  // its first argument instead, if in fact that argument is a temporary
327  // object.
328  if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
329    if (const Expr *Arg = E->getArg(0)->getTemporaryObject()) {
330      EmitAggExpr(Arg, Dest, false);
331      return;
332    }
333  }
334  if (Array) {
335    QualType BaseElementTy = getContext().getBaseElementType(Array);
336    const llvm::Type *BasePtr = ConvertType(BaseElementTy);
337    BasePtr = llvm::PointerType::getUnqual(BasePtr);
338    llvm::Value *BaseAddrPtr =
339      Builder.CreateBitCast(Dest, BasePtr);
340
341    EmitCXXAggrConstructorCall(CD, Array, BaseAddrPtr,
342                               E->arg_begin(), E->arg_end());
343  }
344  else {
345    CXXCtorType Type =
346      (E->getConstructionKind() == CXXConstructExpr::CK_Complete)
347      ? Ctor_Complete : Ctor_Base;
348    bool ForVirtualBase =
349      E->getConstructionKind() == CXXConstructExpr::CK_VirtualBase;
350
351    // Call the constructor.
352    EmitCXXConstructorCall(CD, Type, ForVirtualBase, Dest,
353                           E->arg_begin(), E->arg_end());
354  }
355}
356
357static CharUnits CalculateCookiePadding(ASTContext &Ctx, QualType ElementType) {
358  const RecordType *RT = ElementType->getAs<RecordType>();
359  if (!RT)
360    return CharUnits::Zero();
361
362  const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl());
363  if (!RD)
364    return CharUnits::Zero();
365
366  // Check if the class has a trivial destructor.
367  if (RD->hasTrivialDestructor()) {
368    // Check if the usual deallocation function takes two arguments.
369    const CXXMethodDecl *UsualDeallocationFunction = 0;
370
371    DeclarationName OpName =
372      Ctx.DeclarationNames.getCXXOperatorName(OO_Array_Delete);
373    DeclContext::lookup_const_iterator Op, OpEnd;
374    for (llvm::tie(Op, OpEnd) = RD->lookup(OpName);
375         Op != OpEnd; ++Op) {
376      const CXXMethodDecl *Delete = cast<CXXMethodDecl>(*Op);
377
378      if (Delete->isUsualDeallocationFunction()) {
379        UsualDeallocationFunction = Delete;
380        break;
381      }
382    }
383
384    // No usual deallocation function, we don't need a cookie.
385    if (!UsualDeallocationFunction)
386      return CharUnits::Zero();
387
388    // The usual deallocation function doesn't take a size_t argument, so we
389    // don't need a cookie.
390    if (UsualDeallocationFunction->getNumParams() == 1)
391      return CharUnits::Zero();
392
393    assert(UsualDeallocationFunction->getNumParams() == 2 &&
394           "Unexpected deallocation function type!");
395  }
396
397  // Padding is the maximum of sizeof(size_t) and alignof(ElementType)
398  return std::max(Ctx.getTypeSizeInChars(Ctx.getSizeType()),
399                  Ctx.getTypeAlignInChars(ElementType));
400}
401
402static CharUnits CalculateCookiePadding(ASTContext &Ctx, const CXXNewExpr *E) {
403  if (!E->isArray())
404    return CharUnits::Zero();
405
406  // No cookie is required if the new operator being used is
407  // ::operator new[](size_t, void*).
408  const FunctionDecl *OperatorNew = E->getOperatorNew();
409  if (OperatorNew->getDeclContext()->getLookupContext()->isFileContext()) {
410    if (OperatorNew->getNumParams() == 2) {
411      CanQualType ParamType =
412        Ctx.getCanonicalType(OperatorNew->getParamDecl(1)->getType());
413
414      if (ParamType == Ctx.VoidPtrTy)
415        return CharUnits::Zero();
416    }
417  }
418
419  return CalculateCookiePadding(Ctx, E->getAllocatedType());
420}
421
422static llvm::Value *EmitCXXNewAllocSize(ASTContext &Context,
423                                        CodeGenFunction &CGF,
424                                        const CXXNewExpr *E,
425                                        llvm::Value *& NumElements) {
426  QualType Type = E->getAllocatedType();
427  CharUnits TypeSize = CGF.getContext().getTypeSizeInChars(Type);
428  const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
429
430  if (!E->isArray())
431    return llvm::ConstantInt::get(SizeTy, TypeSize.getQuantity());
432
433  CharUnits CookiePadding = CalculateCookiePadding(CGF.getContext(), E);
434
435  Expr::EvalResult Result;
436  if (E->getArraySize()->Evaluate(Result, CGF.getContext()) &&
437      !Result.HasSideEffects && Result.Val.isInt()) {
438
439    CharUnits AllocSize =
440      Result.Val.getInt().getZExtValue() * TypeSize + CookiePadding;
441
442    NumElements =
443      llvm::ConstantInt::get(SizeTy, Result.Val.getInt().getZExtValue());
444    while (const ArrayType *AType = Context.getAsArrayType(Type)) {
445      const llvm::ArrayType *llvmAType =
446        cast<llvm::ArrayType>(CGF.ConvertType(Type));
447      NumElements =
448        CGF.Builder.CreateMul(NumElements,
449                              llvm::ConstantInt::get(
450                                        SizeTy, llvmAType->getNumElements()));
451      Type = AType->getElementType();
452    }
453
454    return llvm::ConstantInt::get(SizeTy, AllocSize.getQuantity());
455  }
456
457  // Emit the array size expression.
458  NumElements = CGF.EmitScalarExpr(E->getArraySize());
459
460  // Multiply with the type size.
461  llvm::Value *V =
462    CGF.Builder.CreateMul(NumElements,
463                          llvm::ConstantInt::get(SizeTy,
464                                                 TypeSize.getQuantity()));
465
466  while (const ArrayType *AType = Context.getAsArrayType(Type)) {
467    const llvm::ArrayType *llvmAType =
468      cast<llvm::ArrayType>(CGF.ConvertType(Type));
469    NumElements =
470      CGF.Builder.CreateMul(NumElements,
471                            llvm::ConstantInt::get(
472                                          SizeTy, llvmAType->getNumElements()));
473    Type = AType->getElementType();
474  }
475
476  // And add the cookie padding if necessary.
477  if (!CookiePadding.isZero())
478    V = CGF.Builder.CreateAdd(V,
479        llvm::ConstantInt::get(SizeTy, CookiePadding.getQuantity()));
480
481  return V;
482}
483
484static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const CXXNewExpr *E,
485                                    llvm::Value *NewPtr) {
486
487  assert(E->getNumConstructorArgs() == 1 &&
488         "Can only have one argument to initializer of POD type.");
489
490  const Expr *Init = E->getConstructorArg(0);
491  QualType AllocType = E->getAllocatedType();
492
493  if (!CGF.hasAggregateLLVMType(AllocType))
494    CGF.EmitStoreOfScalar(CGF.EmitScalarExpr(Init), NewPtr,
495                          AllocType.isVolatileQualified(), AllocType);
496  else if (AllocType->isAnyComplexType())
497    CGF.EmitComplexExprIntoAddr(Init, NewPtr,
498                                AllocType.isVolatileQualified());
499  else
500    CGF.EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified());
501}
502
503void
504CodeGenFunction::EmitNewArrayInitializer(const CXXNewExpr *E,
505                                         llvm::Value *NewPtr,
506                                         llvm::Value *NumElements) {
507  // We have a POD type.
508  if (E->getNumConstructorArgs() == 0)
509    return;
510
511  const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
512
513  // Create a temporary for the loop index and initialize it with 0.
514  llvm::Value *IndexPtr = CreateTempAlloca(SizeTy, "loop.index");
515  llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
516  Builder.CreateStore(Zero, IndexPtr);
517
518  // Start the loop with a block that tests the condition.
519  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
520  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
521
522  EmitBlock(CondBlock);
523
524  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
525
526  // Generate: if (loop-index < number-of-elements fall to the loop body,
527  // otherwise, go to the block after the for-loop.
528  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
529  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElements, "isless");
530  // If the condition is true, execute the body.
531  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
532
533  EmitBlock(ForBody);
534
535  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
536  // Inside the loop body, emit the constructor call on the array element.
537  Counter = Builder.CreateLoad(IndexPtr);
538  llvm::Value *Address = Builder.CreateInBoundsGEP(NewPtr, Counter,
539                                                   "arrayidx");
540  StoreAnyExprIntoOneUnit(*this, E, Address);
541
542  EmitBlock(ContinueBlock);
543
544  // Emit the increment of the loop counter.
545  llvm::Value *NextVal = llvm::ConstantInt::get(SizeTy, 1);
546  Counter = Builder.CreateLoad(IndexPtr);
547  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
548  Builder.CreateStore(NextVal, IndexPtr);
549
550  // Finally, branch back up to the condition for the next iteration.
551  EmitBranch(CondBlock);
552
553  // Emit the fall-through block.
554  EmitBlock(AfterFor, true);
555}
556
557static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
558                               llvm::Value *NewPtr,
559                               llvm::Value *NumElements) {
560  if (E->isArray()) {
561    if (CXXConstructorDecl *Ctor = E->getConstructor()) {
562      if (!Ctor->getParent()->hasTrivialConstructor())
563        CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr,
564                                       E->constructor_arg_begin(),
565                                       E->constructor_arg_end());
566      return;
567    }
568    else {
569      CGF.EmitNewArrayInitializer(E, NewPtr, NumElements);
570      return;
571    }
572  }
573
574  if (CXXConstructorDecl *Ctor = E->getConstructor()) {
575    CGF.EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false,
576                               NewPtr, E->constructor_arg_begin(),
577                               E->constructor_arg_end());
578
579    return;
580  }
581  // We have a POD type.
582  if (E->getNumConstructorArgs() == 0)
583    return;
584
585  StoreAnyExprIntoOneUnit(CGF, E, NewPtr);
586}
587
588llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
589  QualType AllocType = E->getAllocatedType();
590  FunctionDecl *NewFD = E->getOperatorNew();
591  const FunctionProtoType *NewFTy = NewFD->getType()->getAs<FunctionProtoType>();
592
593  CallArgList NewArgs;
594
595  // The allocation size is the first argument.
596  QualType SizeTy = getContext().getSizeType();
597
598  llvm::Value *NumElements = 0;
599  llvm::Value *AllocSize = EmitCXXNewAllocSize(getContext(),
600                                               *this, E, NumElements);
601
602  NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy));
603
604  // Emit the rest of the arguments.
605  // FIXME: Ideally, this should just use EmitCallArgs.
606  CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin();
607
608  // First, use the types from the function type.
609  // We start at 1 here because the first argument (the allocation size)
610  // has already been emitted.
611  for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) {
612    QualType ArgType = NewFTy->getArgType(i);
613
614    assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
615           getTypePtr() ==
616           getContext().getCanonicalType(NewArg->getType()).getTypePtr() &&
617           "type mismatch in call argument!");
618
619    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
620                                     ArgType));
621
622  }
623
624  // Either we've emitted all the call args, or we have a call to a
625  // variadic function.
626  assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) &&
627         "Extra arguments in non-variadic function!");
628
629  // If we still have any arguments, emit them using the type of the argument.
630  for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end();
631       NewArg != NewArgEnd; ++NewArg) {
632    QualType ArgType = NewArg->getType();
633    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
634                                     ArgType));
635  }
636
637  // Emit the call to new.
638  RValue RV =
639    EmitCall(CGM.getTypes().getFunctionInfo(NewArgs, NewFTy),
640             CGM.GetAddrOfFunction(NewFD), ReturnValueSlot(), NewArgs, NewFD);
641
642  // If an allocation function is declared with an empty exception specification
643  // it returns null to indicate failure to allocate storage. [expr.new]p13.
644  // (We don't need to check for null when there's no new initializer and
645  // we're allocating a POD type).
646  bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() &&
647    !(AllocType->isPODType() && !E->hasInitializer());
648
649  llvm::BasicBlock *NewNull = 0;
650  llvm::BasicBlock *NewNotNull = 0;
651  llvm::BasicBlock *NewEnd = 0;
652
653  llvm::Value *NewPtr = RV.getScalarVal();
654
655  if (NullCheckResult) {
656    NewNull = createBasicBlock("new.null");
657    NewNotNull = createBasicBlock("new.notnull");
658    NewEnd = createBasicBlock("new.end");
659
660    llvm::Value *IsNull =
661      Builder.CreateICmpEQ(NewPtr,
662                           llvm::Constant::getNullValue(NewPtr->getType()),
663                           "isnull");
664
665    Builder.CreateCondBr(IsNull, NewNull, NewNotNull);
666    EmitBlock(NewNotNull);
667  }
668
669  CharUnits CookiePadding = CalculateCookiePadding(getContext(), E);
670  if (!CookiePadding.isZero()) {
671    CharUnits CookieOffset =
672      CookiePadding - getContext().getTypeSizeInChars(SizeTy);
673
674    llvm::Value *NumElementsPtr =
675      Builder.CreateConstInBoundsGEP1_64(NewPtr, CookieOffset.getQuantity());
676
677    NumElementsPtr = Builder.CreateBitCast(NumElementsPtr,
678                                           ConvertType(SizeTy)->getPointerTo());
679    Builder.CreateStore(NumElements, NumElementsPtr);
680
681    // Now add the padding to the new ptr.
682    NewPtr = Builder.CreateConstInBoundsGEP1_64(NewPtr,
683                                                CookiePadding.getQuantity());
684  }
685
686  if (AllocType->isArrayType()) {
687    while (const ArrayType *AType = getContext().getAsArrayType(AllocType))
688      AllocType = AType->getElementType();
689    NewPtr =
690      Builder.CreateBitCast(NewPtr,
691                          ConvertType(getContext().getPointerType(AllocType)));
692    EmitNewInitializer(*this, E, NewPtr, NumElements);
693    NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
694  }
695  else {
696    NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
697    EmitNewInitializer(*this, E, NewPtr, NumElements);
698  }
699
700  if (NullCheckResult) {
701    Builder.CreateBr(NewEnd);
702    NewNotNull = Builder.GetInsertBlock();
703    EmitBlock(NewNull);
704    Builder.CreateBr(NewEnd);
705    EmitBlock(NewEnd);
706
707    llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
708    PHI->reserveOperandSpace(2);
709    PHI->addIncoming(NewPtr, NewNotNull);
710    PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull);
711
712    NewPtr = PHI;
713  }
714
715  return NewPtr;
716}
717
718static std::pair<llvm::Value *, llvm::Value *>
719GetAllocatedObjectPtrAndNumElements(CodeGenFunction &CGF,
720                                    llvm::Value *Ptr, QualType DeleteTy) {
721  QualType SizeTy = CGF.getContext().getSizeType();
722  const llvm::Type *SizeLTy = CGF.ConvertType(SizeTy);
723
724  CharUnits DeleteTypeAlign = CGF.getContext().getTypeAlignInChars(DeleteTy);
725  CharUnits CookiePadding =
726    std::max(CGF.getContext().getTypeSizeInChars(SizeTy),
727             DeleteTypeAlign);
728  assert(!CookiePadding.isZero() && "CookiePadding should not be 0.");
729
730  const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
731  CharUnits CookieOffset =
732    CookiePadding - CGF.getContext().getTypeSizeInChars(SizeTy);
733
734  llvm::Value *AllocatedObjectPtr = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
735  AllocatedObjectPtr =
736    CGF.Builder.CreateConstInBoundsGEP1_64(AllocatedObjectPtr,
737                                           -CookiePadding.getQuantity());
738
739  llvm::Value *NumElementsPtr =
740    CGF.Builder.CreateConstInBoundsGEP1_64(AllocatedObjectPtr,
741                                           CookieOffset.getQuantity());
742  NumElementsPtr =
743    CGF.Builder.CreateBitCast(NumElementsPtr, SizeLTy->getPointerTo());
744
745  llvm::Value *NumElements = CGF.Builder.CreateLoad(NumElementsPtr);
746  NumElements =
747    CGF.Builder.CreateIntCast(NumElements, SizeLTy, /*isSigned=*/false);
748
749  return std::make_pair(AllocatedObjectPtr, NumElements);
750}
751
752void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
753                                     llvm::Value *Ptr,
754                                     QualType DeleteTy) {
755  const FunctionProtoType *DeleteFTy =
756    DeleteFD->getType()->getAs<FunctionProtoType>();
757
758  CallArgList DeleteArgs;
759
760  // Check if we need to pass the size to the delete operator.
761  llvm::Value *Size = 0;
762  QualType SizeTy;
763  if (DeleteFTy->getNumArgs() == 2) {
764    SizeTy = DeleteFTy->getArgType(1);
765    CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
766    Size = llvm::ConstantInt::get(ConvertType(SizeTy),
767                                  DeleteTypeSize.getQuantity());
768  }
769
770  if (DeleteFD->getOverloadedOperator() == OO_Array_Delete &&
771      !CalculateCookiePadding(getContext(), DeleteTy).isZero()) {
772    // We need to get the number of elements in the array from the cookie.
773    llvm::Value *AllocatedObjectPtr;
774    llvm::Value *NumElements;
775    llvm::tie(AllocatedObjectPtr, NumElements) =
776      GetAllocatedObjectPtrAndNumElements(*this, Ptr, DeleteTy);
777
778    // Multiply the size with the number of elements.
779    if (Size)
780      Size = Builder.CreateMul(NumElements, Size);
781
782    Ptr = AllocatedObjectPtr;
783  }
784
785  QualType ArgTy = DeleteFTy->getArgType(0);
786  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
787  DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy));
788
789  if (Size)
790    DeleteArgs.push_back(std::make_pair(RValue::get(Size), SizeTy));
791
792  // Emit the call to delete.
793  EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy),
794           CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(),
795           DeleteArgs, DeleteFD);
796}
797
798void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
799
800  // Get at the argument before we performed the implicit conversion
801  // to void*.
802  const Expr *Arg = E->getArgument();
803  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
804    if (ICE->getCastKind() != CastExpr::CK_UserDefinedConversion &&
805        ICE->getType()->isVoidPointerType())
806      Arg = ICE->getSubExpr();
807    else
808      break;
809  }
810
811  QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType();
812
813  llvm::Value *Ptr = EmitScalarExpr(Arg);
814
815  // Null check the pointer.
816  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
817  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
818
819  llvm::Value *IsNull =
820    Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()),
821                         "isnull");
822
823  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
824  EmitBlock(DeleteNotNull);
825
826  bool ShouldCallDelete = true;
827
828  // Call the destructor if necessary.
829  if (const RecordType *RT = DeleteTy->getAs<RecordType>()) {
830    if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
831      if (!RD->hasTrivialDestructor()) {
832        const CXXDestructorDecl *Dtor = RD->getDestructor();
833        if (E->isArrayForm()) {
834          llvm::Value *AllocatedObjectPtr;
835          llvm::Value *NumElements;
836          llvm::tie(AllocatedObjectPtr, NumElements) =
837            GetAllocatedObjectPtrAndNumElements(*this, Ptr, DeleteTy);
838
839          EmitCXXAggrDestructorCall(Dtor, NumElements, Ptr);
840        } else if (Dtor->isVirtual()) {
841          const llvm::Type *Ty =
842            CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(Dtor),
843                                           /*isVariadic=*/false);
844
845          llvm::Value *Callee = BuildVirtualCall(Dtor, Dtor_Deleting, Ptr, Ty);
846          EmitCXXMemberCall(Dtor, Callee, ReturnValueSlot(), Ptr, /*VTT=*/0,
847                            0, 0);
848
849          // The dtor took care of deleting the object.
850          ShouldCallDelete = false;
851        } else
852          EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
853                                Ptr);
854      }
855    }
856  }
857
858  if (ShouldCallDelete)
859    EmitDeleteCall(E->getOperatorDelete(), Ptr, DeleteTy);
860
861  EmitBlock(DeleteEnd);
862}
863
864llvm::Value * CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
865  QualType Ty = E->getType();
866  const llvm::Type *LTy = ConvertType(Ty)->getPointerTo();
867
868  if (E->isTypeOperand()) {
869    llvm::Constant *TypeInfo =
870      CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand());
871    return Builder.CreateBitCast(TypeInfo, LTy);
872  }
873
874  Expr *subE = E->getExprOperand();
875  Ty = subE->getType();
876  CanQualType CanTy = CGM.getContext().getCanonicalType(Ty);
877  Ty = CanTy.getUnqualifiedType().getNonReferenceType();
878  if (const RecordType *RT = Ty->getAs<RecordType>()) {
879    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
880    if (RD->isPolymorphic()) {
881      // FIXME: if subE is an lvalue do
882      LValue Obj = EmitLValue(subE);
883      llvm::Value *This = Obj.getAddress();
884      LTy = LTy->getPointerTo()->getPointerTo();
885      llvm::Value *V = Builder.CreateBitCast(This, LTy);
886      // We need to do a zero check for *p, unless it has NonNullAttr.
887      // FIXME: PointerType->hasAttr<NonNullAttr>()
888      bool CanBeZero = false;
889      if (UnaryOperator *UO = dyn_cast<UnaryOperator>(subE->IgnoreParens()))
890        if (UO->getOpcode() == UnaryOperator::Deref)
891          CanBeZero = true;
892      if (CanBeZero) {
893        llvm::BasicBlock *NonZeroBlock = createBasicBlock();
894        llvm::BasicBlock *ZeroBlock = createBasicBlock();
895
896        llvm::Value *Zero = llvm::Constant::getNullValue(LTy);
897        Builder.CreateCondBr(Builder.CreateICmpNE(V, Zero),
898                             NonZeroBlock, ZeroBlock);
899        EmitBlock(ZeroBlock);
900        /// Call __cxa_bad_typeid
901        const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
902        const llvm::FunctionType *FTy;
903        FTy = llvm::FunctionType::get(ResultType, false);
904        llvm::Value *F = CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
905        Builder.CreateCall(F)->setDoesNotReturn();
906        Builder.CreateUnreachable();
907        EmitBlock(NonZeroBlock);
908      }
909      V = Builder.CreateLoad(V, "vtable");
910      V = Builder.CreateConstInBoundsGEP1_64(V, -1ULL);
911      V = Builder.CreateLoad(V);
912      return V;
913    }
914  }
915  return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(Ty), LTy);
916}
917
918llvm::Value *CodeGenFunction::EmitDynamicCast(llvm::Value *V,
919                                              const CXXDynamicCastExpr *DCE) {
920  QualType SrcTy = DCE->getSubExpr()->getType();
921  QualType DestTy = DCE->getTypeAsWritten();
922  QualType InnerType = DestTy->getPointeeType();
923
924  const llvm::Type *LTy = ConvertType(DCE->getType());
925
926  bool CanBeZero = false;
927  bool ToVoid = false;
928  bool ThrowOnBad = false;
929  if (DestTy->isPointerType()) {
930    // FIXME: if PointerType->hasAttr<NonNullAttr>(), we don't set this
931    CanBeZero = true;
932    if (InnerType->isVoidType())
933      ToVoid = true;
934  } else {
935    LTy = LTy->getPointerTo();
936
937    // FIXME: What if exceptions are disabled?
938    ThrowOnBad = true;
939  }
940
941  if (SrcTy->isPointerType() || SrcTy->isReferenceType())
942    SrcTy = SrcTy->getPointeeType();
943  SrcTy = SrcTy.getUnqualifiedType();
944
945  if (DestTy->isPointerType() || DestTy->isReferenceType())
946    DestTy = DestTy->getPointeeType();
947  DestTy = DestTy.getUnqualifiedType();
948
949  llvm::BasicBlock *ContBlock = createBasicBlock();
950  llvm::BasicBlock *NullBlock = 0;
951  llvm::BasicBlock *NonZeroBlock = 0;
952  if (CanBeZero) {
953    NonZeroBlock = createBasicBlock();
954    NullBlock = createBasicBlock();
955    Builder.CreateCondBr(Builder.CreateIsNotNull(V), NonZeroBlock, NullBlock);
956    EmitBlock(NonZeroBlock);
957  }
958
959  llvm::BasicBlock *BadCastBlock = 0;
960
961  const llvm::Type *PtrDiffTy = ConvertType(getContext().getPointerDiffType());
962
963  // See if this is a dynamic_cast(void*)
964  if (ToVoid) {
965    llvm::Value *This = V;
966    V = Builder.CreateBitCast(This, PtrDiffTy->getPointerTo()->getPointerTo());
967    V = Builder.CreateLoad(V, "vtable");
968    V = Builder.CreateConstInBoundsGEP1_64(V, -2ULL);
969    V = Builder.CreateLoad(V, "offset to top");
970    This = Builder.CreateBitCast(This, llvm::Type::getInt8PtrTy(VMContext));
971    V = Builder.CreateInBoundsGEP(This, V);
972    V = Builder.CreateBitCast(V, LTy);
973  } else {
974    /// Call __dynamic_cast
975    const llvm::Type *ResultType = llvm::Type::getInt8PtrTy(VMContext);
976    const llvm::FunctionType *FTy;
977    std::vector<const llvm::Type*> ArgTys;
978    const llvm::Type *PtrToInt8Ty
979      = llvm::Type::getInt8Ty(VMContext)->getPointerTo();
980    ArgTys.push_back(PtrToInt8Ty);
981    ArgTys.push_back(PtrToInt8Ty);
982    ArgTys.push_back(PtrToInt8Ty);
983    ArgTys.push_back(PtrDiffTy);
984    FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
985
986    // FIXME: Calculate better hint.
987    llvm::Value *hint = llvm::ConstantInt::get(PtrDiffTy, -1ULL);
988
989    assert(SrcTy->isRecordType() && "Src type must be record type!");
990    assert(DestTy->isRecordType() && "Dest type must be record type!");
991
992    llvm::Value *SrcArg
993      = CGM.GetAddrOfRTTIDescriptor(SrcTy.getUnqualifiedType());
994    llvm::Value *DestArg
995      = CGM.GetAddrOfRTTIDescriptor(DestTy.getUnqualifiedType());
996
997    V = Builder.CreateBitCast(V, PtrToInt8Ty);
998    V = Builder.CreateCall4(CGM.CreateRuntimeFunction(FTy, "__dynamic_cast"),
999                            V, SrcArg, DestArg, hint);
1000    V = Builder.CreateBitCast(V, LTy);
1001
1002    if (ThrowOnBad) {
1003      BadCastBlock = createBasicBlock();
1004      Builder.CreateCondBr(Builder.CreateIsNotNull(V), ContBlock, BadCastBlock);
1005      EmitBlock(BadCastBlock);
1006      /// Invoke __cxa_bad_cast
1007      ResultType = llvm::Type::getVoidTy(VMContext);
1008      const llvm::FunctionType *FBadTy;
1009      FBadTy = llvm::FunctionType::get(ResultType, false);
1010      llvm::Value *F = CGM.CreateRuntimeFunction(FBadTy, "__cxa_bad_cast");
1011      if (llvm::BasicBlock *InvokeDest = getInvokeDest()) {
1012        llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
1013        Builder.CreateInvoke(F, Cont, InvokeDest)->setDoesNotReturn();
1014        EmitBlock(Cont);
1015      } else {
1016        // FIXME: Does this ever make sense?
1017        Builder.CreateCall(F)->setDoesNotReturn();
1018      }
1019      Builder.CreateUnreachable();
1020    }
1021  }
1022
1023  if (CanBeZero) {
1024    Builder.CreateBr(ContBlock);
1025    EmitBlock(NullBlock);
1026    Builder.CreateBr(ContBlock);
1027  }
1028  EmitBlock(ContBlock);
1029  if (CanBeZero) {
1030    llvm::PHINode *PHI = Builder.CreatePHI(LTy);
1031    PHI->reserveOperandSpace(2);
1032    PHI->addIncoming(V, NonZeroBlock);
1033    PHI->addIncoming(llvm::Constant::getNullValue(LTy), NullBlock);
1034    V = PHI;
1035  }
1036
1037  return V;
1038}
1039