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