CGExprCXX.cpp revision 804b807ea918184d6de63bd745e1ff75a9bfc679 
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 "clang/Frontend/CodeGenOptions.h"
15#include "CodeGenFunction.h"
16#include "CGCXXABI.h"
17#include "CGObjCRuntime.h"
18#include "CGDebugInfo.h"
19#include "llvm/Intrinsics.h"
20using namespace clang;
21using namespace CodeGen;
22
23RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
24                                          llvm::Value *Callee,
25                                          ReturnValueSlot ReturnValue,
26                                          llvm::Value *This,
27                                          llvm::Value *VTT,
28                                          CallExpr::const_arg_iterator ArgBeg,
29                                          CallExpr::const_arg_iterator ArgEnd) {
30  assert(MD->isInstance() &&
31         "Trying to emit a member call expr on a static method!");
32
33  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
34
35  CallArgList Args;
36
37  // Push the this ptr.
38  Args.push_back(std::make_pair(RValue::get(This),
39                                MD->getThisType(getContext())));
40
41  // If there is a VTT parameter, emit it.
42  if (VTT) {
43    QualType T = getContext().getPointerType(getContext().VoidPtrTy);
44    Args.push_back(std::make_pair(RValue::get(VTT), T));
45  }
46
47  // And the rest of the call args
48  EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
49
50  QualType ResultType = FPT->getResultType();
51  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
52                                                 FPT->getExtInfo()),
53                  Callee, ReturnValue, Args, MD);
54}
55
56/// canDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given
57/// expr can be devirtualized.
58static bool canDevirtualizeMemberFunctionCalls(ASTContext &Context,
59                                               const Expr *Base,
60                                               const CXXMethodDecl *MD) {
61
62  // Cannot divirtualize in kext mode.
63  if (Context.getLangOptions().AppleKext)
64    return false;
65
66  // If the member function is marked 'final', we know that it can't be
67  // overridden and can therefore devirtualize it.
68  if (MD->hasAttr<FinalAttr>())
69    return true;
70
71  // Similarly, if the class itself is marked 'final' it can't be overridden
72  // and we can therefore devirtualize the member function call.
73  if (MD->getParent()->hasAttr<FinalAttr>())
74    return true;
75
76  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
77    if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
78      // This is a record decl. We know the type and can devirtualize it.
79      return VD->getType()->isRecordType();
80    }
81
82    return false;
83  }
84
85  // We can always devirtualize calls on temporary object expressions.
86  if (isa<CXXConstructExpr>(Base))
87    return true;
88
89  // And calls on bound temporaries.
90  if (isa<CXXBindTemporaryExpr>(Base))
91    return true;
92
93  // Check if this is a call expr that returns a record type.
94  if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
95    return CE->getCallReturnType()->isRecordType();
96
97  // We can't devirtualize the call.
98  return false;
99}
100
101// Note: This function also emit constructor calls to support a MSVC
102// extensions allowing explicit constructor function call.
103RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
104                                              ReturnValueSlot ReturnValue) {
105  if (isa<BinaryOperator>(CE->getCallee()->IgnoreParens()))
106    return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
107
108  const MemberExpr *ME = cast<MemberExpr>(CE->getCallee()->IgnoreParens());
109  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
110
111  CGDebugInfo *DI = getDebugInfo();
112  if (DI && CGM.getCodeGenOpts().LimitDebugInfo
113      && !isa<CallExpr>(ME->getBase())) {
114    QualType PQTy = ME->getBase()->IgnoreParenImpCasts()->getType();
115    if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) {
116      DI->getOrCreateRecordType(PTy->getPointeeType(),
117                                MD->getParent()->getLocation());
118    }
119  }
120
121  if (MD->isStatic()) {
122    // The method is static, emit it as we would a regular call.
123    llvm::Value *Callee = CGM.GetAddrOfFunction(MD);
124    return EmitCall(getContext().getPointerType(MD->getType()), Callee,
125                    ReturnValue, CE->arg_begin(), CE->arg_end());
126  }
127
128  // Compute the object pointer.
129  llvm::Value *This;
130  if (ME->isArrow())
131    This = EmitScalarExpr(ME->getBase());
132  else
133    This = EmitLValue(ME->getBase()).getAddress();
134
135  if (MD->isTrivial()) {
136    if (isa<CXXDestructorDecl>(MD)) return RValue::get(0);
137    if (isa<CXXConstructorDecl>(MD) &&
138        cast<CXXConstructorDecl>(MD)->isDefaultConstructor())
139      return RValue::get(0);
140
141    if (MD->isCopyAssignmentOperator()) {
142      // We don't like to generate the trivial copy assignment operator when
143      // it isn't necessary; just produce the proper effect here.
144      llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
145      EmitAggregateCopy(This, RHS, CE->getType());
146      return RValue::get(This);
147    }
148
149    if (isa<CXXConstructorDecl>(MD) &&
150        cast<CXXConstructorDecl>(MD)->isCopyConstructor()) {
151      llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
152      EmitSynthesizedCXXCopyCtorCall(cast<CXXConstructorDecl>(MD), This, RHS,
153                                     CE->arg_begin(), CE->arg_end());
154      return RValue::get(This);
155    }
156    llvm_unreachable("unknown trivial member function");
157  }
158
159  // Compute the function type we're calling.
160  const CGFunctionInfo *FInfo = 0;
161  if (isa<CXXDestructorDecl>(MD))
162    FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXDestructorDecl>(MD),
163                                           Dtor_Complete);
164  else if (isa<CXXConstructorDecl>(MD))
165    FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXConstructorDecl>(MD),
166                                            Ctor_Complete);
167  else
168    FInfo = &CGM.getTypes().getFunctionInfo(MD);
169
170  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
171  const llvm::Type *Ty
172    = CGM.getTypes().GetFunctionType(*FInfo, FPT->isVariadic());
173
174  // C++ [class.virtual]p12:
175  //   Explicit qualification with the scope operator (5.1) suppresses the
176  //   virtual call mechanism.
177  //
178  // We also don't emit a virtual call if the base expression has a record type
179  // because then we know what the type is.
180  bool UseVirtualCall;
181  UseVirtualCall = MD->isVirtual() && !ME->hasQualifier()
182                   && !canDevirtualizeMemberFunctionCalls(getContext(),
183                                                          ME->getBase(), MD);
184  llvm::Value *Callee;
185  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD)) {
186    if (UseVirtualCall) {
187      Callee = BuildVirtualCall(Dtor, Dtor_Complete, This, Ty);
188    } else {
189      Callee = CGM.GetAddrOfFunction(GlobalDecl(Dtor, Dtor_Complete), Ty);
190    }
191  } else if (const CXXConstructorDecl *Ctor =
192               dyn_cast<CXXConstructorDecl>(MD)) {
193    Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty);
194  } else if (UseVirtualCall) {
195      Callee = BuildVirtualCall(MD, This, Ty);
196  } else {
197    if (getContext().getLangOptions().AppleKext &&
198        ME->hasQualifier())
199      Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), This, Ty);
200    else
201      Callee = CGM.GetAddrOfFunction(MD, Ty);
202  }
203
204  return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
205                           CE->arg_begin(), CE->arg_end());
206}
207
208RValue
209CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
210                                              ReturnValueSlot ReturnValue) {
211  const BinaryOperator *BO =
212      cast<BinaryOperator>(E->getCallee()->IgnoreParens());
213  const Expr *BaseExpr = BO->getLHS();
214  const Expr *MemFnExpr = BO->getRHS();
215
216  const MemberPointerType *MPT =
217    MemFnExpr->getType()->getAs<MemberPointerType>();
218
219  const FunctionProtoType *FPT =
220    MPT->getPointeeType()->getAs<FunctionProtoType>();
221  const CXXRecordDecl *RD =
222    cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
223
224  // Get the member function pointer.
225  llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
226
227  // Emit the 'this' pointer.
228  llvm::Value *This;
229
230  if (BO->getOpcode() == BO_PtrMemI)
231    This = EmitScalarExpr(BaseExpr);
232  else
233    This = EmitLValue(BaseExpr).getAddress();
234
235  // Ask the ABI to load the callee.  Note that This is modified.
236  llvm::Value *Callee =
237    CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(CGF, This, MemFnPtr, MPT);
238
239  CallArgList Args;
240
241  QualType ThisType =
242    getContext().getPointerType(getContext().getTagDeclType(RD));
243
244  // Push the this ptr.
245  Args.push_back(std::make_pair(RValue::get(This), ThisType));
246
247  // And the rest of the call args
248  EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end());
249  const FunctionType *BO_FPT = BO->getType()->getAs<FunctionProtoType>();
250  return EmitCall(CGM.getTypes().getFunctionInfo(Args, BO_FPT), Callee,
251                  ReturnValue, Args);
252}
253
254RValue
255CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
256                                               const CXXMethodDecl *MD,
257                                               ReturnValueSlot ReturnValue) {
258  assert(MD->isInstance() &&
259         "Trying to emit a member call expr on a static method!");
260  LValue LV = EmitLValue(E->getArg(0));
261  llvm::Value *This = LV.getAddress();
262
263  if (MD->isCopyAssignmentOperator()) {
264    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext());
265    if (ClassDecl->hasTrivialCopyAssignment()) {
266      assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
267             "EmitCXXOperatorMemberCallExpr - user declared copy assignment");
268      llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
269      QualType Ty = E->getType();
270      EmitAggregateCopy(This, Src, Ty);
271      return RValue::get(This);
272    }
273  }
274
275  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
276  const llvm::Type *Ty =
277    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
278                                   FPT->isVariadic());
279  llvm::Value *Callee;
280  if (MD->isVirtual() &&
281      !canDevirtualizeMemberFunctionCalls(getContext(),
282                                           E->getArg(0), MD))
283    Callee = BuildVirtualCall(MD, This, Ty);
284  else
285    Callee = CGM.GetAddrOfFunction(MD, Ty);
286
287  return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
288                           E->arg_begin() + 1, E->arg_end());
289}
290
291void
292CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,
293                                      AggValueSlot Dest) {
294  assert(!Dest.isIgnored() && "Must have a destination!");
295  const CXXConstructorDecl *CD = E->getConstructor();
296
297  // If we require zero initialization before (or instead of) calling the
298  // constructor, as can be the case with a non-user-provided default
299  // constructor, emit the zero initialization now.
300  if (E->requiresZeroInitialization())
301    EmitNullInitialization(Dest.getAddr(), E->getType());
302
303  // If this is a call to a trivial default constructor, do nothing.
304  if (CD->isTrivial() && CD->isDefaultConstructor())
305    return;
306
307  // Elide the constructor if we're constructing from a temporary.
308  // The temporary check is required because Sema sets this on NRVO
309  // returns.
310  if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
311    assert(getContext().hasSameUnqualifiedType(E->getType(),
312                                               E->getArg(0)->getType()));
313    if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
314      EmitAggExpr(E->getArg(0), Dest);
315      return;
316    }
317  }
318
319  const ConstantArrayType *Array
320    = getContext().getAsConstantArrayType(E->getType());
321  if (Array) {
322    QualType BaseElementTy = getContext().getBaseElementType(Array);
323    const llvm::Type *BasePtr = ConvertType(BaseElementTy);
324    BasePtr = llvm::PointerType::getUnqual(BasePtr);
325    llvm::Value *BaseAddrPtr =
326      Builder.CreateBitCast(Dest.getAddr(), BasePtr);
327
328    EmitCXXAggrConstructorCall(CD, Array, BaseAddrPtr,
329                               E->arg_begin(), E->arg_end());
330  }
331  else {
332    CXXCtorType Type =
333      (E->getConstructionKind() == CXXConstructExpr::CK_Complete)
334      ? Ctor_Complete : Ctor_Base;
335    bool ForVirtualBase =
336      E->getConstructionKind() == CXXConstructExpr::CK_VirtualBase;
337
338    // Call the constructor.
339    EmitCXXConstructorCall(CD, Type, ForVirtualBase, Dest.getAddr(),
340                           E->arg_begin(), E->arg_end());
341  }
342}
343
344void
345CodeGenFunction::EmitSynthesizedCXXCopyCtor(llvm::Value *Dest,
346                                            llvm::Value *Src,
347                                            const Expr *Exp) {
348  if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
349    Exp = E->getSubExpr();
350  assert(isa<CXXConstructExpr>(Exp) &&
351         "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
352  const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
353  const CXXConstructorDecl *CD = E->getConstructor();
354  RunCleanupsScope Scope(*this);
355
356  // If we require zero initialization before (or instead of) calling the
357  // constructor, as can be the case with a non-user-provided default
358  // constructor, emit the zero initialization now.
359  // FIXME. Do I still need this for a copy ctor synthesis?
360  if (E->requiresZeroInitialization())
361    EmitNullInitialization(Dest, E->getType());
362
363  assert(!getContext().getAsConstantArrayType(E->getType())
364         && "EmitSynthesizedCXXCopyCtor - Copied-in Array");
365  EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src,
366                                 E->arg_begin(), E->arg_end());
367}
368
369/// Check whether the given operator new[] is the global placement
370/// operator new[].
371static bool IsPlacementOperatorNewArray(ASTContext &Ctx,
372                                        const FunctionDecl *Fn) {
373  // Must be in global scope.  Note that allocation functions can't be
374  // declared in namespaces.
375  if (!Fn->getDeclContext()->getRedeclContext()->isFileContext())
376    return false;
377
378  // Signature must be void *operator new[](size_t, void*).
379  // The size_t is common to all operator new[]s.
380  if (Fn->getNumParams() != 2)
381    return false;
382
383  CanQualType ParamType = Ctx.getCanonicalType(Fn->getParamDecl(1)->getType());
384  return (ParamType == Ctx.VoidPtrTy);
385}
386
387static CharUnits CalculateCookiePadding(CodeGenFunction &CGF,
388                                        const CXXNewExpr *E) {
389  if (!E->isArray())
390    return CharUnits::Zero();
391
392  // No cookie is required if the new operator being used is
393  // ::operator new[](size_t, void*).
394  const FunctionDecl *OperatorNew = E->getOperatorNew();
395  if (IsPlacementOperatorNewArray(CGF.getContext(), OperatorNew))
396    return CharUnits::Zero();
397
398  return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
399}
400
401static llvm::Value *EmitCXXNewAllocSize(ASTContext &Context,
402                                        CodeGenFunction &CGF,
403                                        const CXXNewExpr *E,
404                                        llvm::Value *&NumElements,
405                                        llvm::Value *&SizeWithoutCookie) {
406  QualType ElemType = E->getAllocatedType();
407
408  const llvm::IntegerType *SizeTy =
409    cast<llvm::IntegerType>(CGF.ConvertType(CGF.getContext().getSizeType()));
410
411  CharUnits TypeSize = CGF.getContext().getTypeSizeInChars(ElemType);
412
413  if (!E->isArray()) {
414    SizeWithoutCookie = llvm::ConstantInt::get(SizeTy, TypeSize.getQuantity());
415    return SizeWithoutCookie;
416  }
417
418  // Figure out the cookie size.
419  CharUnits CookieSize = CalculateCookiePadding(CGF, E);
420
421  // Emit the array size expression.
422  // We multiply the size of all dimensions for NumElements.
423  // e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
424  NumElements = CGF.EmitScalarExpr(E->getArraySize());
425  assert(NumElements->getType() == SizeTy && "element count not a size_t");
426
427  uint64_t ArraySizeMultiplier = 1;
428  while (const ConstantArrayType *CAT
429             = CGF.getContext().getAsConstantArrayType(ElemType)) {
430    ElemType = CAT->getElementType();
431    ArraySizeMultiplier *= CAT->getSize().getZExtValue();
432  }
433
434  llvm::Value *Size;
435
436  // If someone is doing 'new int[42]' there is no need to do a dynamic check.
437  // Don't bloat the -O0 code.
438  if (llvm::ConstantInt *NumElementsC =
439        dyn_cast<llvm::ConstantInt>(NumElements)) {
440    llvm::APInt NEC = NumElementsC->getValue();
441    unsigned SizeWidth = NEC.getBitWidth();
442
443    // Determine if there is an overflow here by doing an extended multiply.
444    NEC = NEC.zext(SizeWidth*2);
445    llvm::APInt SC(SizeWidth*2, TypeSize.getQuantity());
446    SC *= NEC;
447
448    if (!CookieSize.isZero()) {
449      // Save the current size without a cookie.  We don't care if an
450      // overflow's already happened because SizeWithoutCookie isn't
451      // used if the allocator returns null or throws, as it should
452      // always do on an overflow.
453      llvm::APInt SWC = SC.trunc(SizeWidth);
454      SizeWithoutCookie = llvm::ConstantInt::get(SizeTy, SWC);
455
456      // Add the cookie size.
457      SC += llvm::APInt(SizeWidth*2, CookieSize.getQuantity());
458    }
459
460    if (SC.countLeadingZeros() >= SizeWidth) {
461      SC = SC.trunc(SizeWidth);
462      Size = llvm::ConstantInt::get(SizeTy, SC);
463    } else {
464      // On overflow, produce a -1 so operator new throws.
465      Size = llvm::Constant::getAllOnesValue(SizeTy);
466    }
467
468    // Scale NumElements while we're at it.
469    uint64_t N = NEC.getZExtValue() * ArraySizeMultiplier;
470    NumElements = llvm::ConstantInt::get(SizeTy, N);
471
472  // Otherwise, we don't need to do an overflow-checked multiplication if
473  // we're multiplying by one.
474  } else if (TypeSize.isOne()) {
475    assert(ArraySizeMultiplier == 1);
476
477    Size = NumElements;
478
479    // If we need a cookie, add its size in with an overflow check.
480    // This is maybe a little paranoid.
481    if (!CookieSize.isZero()) {
482      SizeWithoutCookie = Size;
483
484      llvm::Value *CookieSizeV
485        = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
486
487      const llvm::Type *Types[] = { SizeTy };
488      llvm::Value *UAddF
489        = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, Types, 1);
490      llvm::Value *AddRes
491        = CGF.Builder.CreateCall2(UAddF, Size, CookieSizeV);
492
493      Size = CGF.Builder.CreateExtractValue(AddRes, 0);
494      llvm::Value *DidOverflow = CGF.Builder.CreateExtractValue(AddRes, 1);
495      Size = CGF.Builder.CreateSelect(DidOverflow,
496                                      llvm::ConstantInt::get(SizeTy, -1),
497                                      Size);
498    }
499
500  // Otherwise use the int.umul.with.overflow intrinsic.
501  } else {
502    llvm::Value *OutermostElementSize
503      = llvm::ConstantInt::get(SizeTy, TypeSize.getQuantity());
504
505    llvm::Value *NumOutermostElements = NumElements;
506
507    // Scale NumElements by the array size multiplier.  This might
508    // overflow, but only if the multiplication below also overflows,
509    // in which case this multiplication isn't used.
510    if (ArraySizeMultiplier != 1)
511      NumElements = CGF.Builder.CreateMul(NumElements,
512                         llvm::ConstantInt::get(SizeTy, ArraySizeMultiplier));
513
514    // The requested size of the outermost array is non-constant.
515    // Multiply that by the static size of the elements of that array;
516    // on unsigned overflow, set the size to -1 to trigger an
517    // exception from the allocation routine.  This is sufficient to
518    // prevent buffer overruns from the allocator returning a
519    // seemingly valid pointer to insufficient space.  This idea comes
520    // originally from MSVC, and GCC has an open bug requesting
521    // similar behavior:
522    //   http://gcc.gnu.org/bugzilla/show_bug.cgi?id=19351
523    //
524    // This will not be sufficient for C++0x, which requires a
525    // specific exception class (std::bad_array_new_length).
526    // That will require ABI support that has not yet been specified.
527    const llvm::Type *Types[] = { SizeTy };
528    llvm::Value *UMulF
529      = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, Types, 1);
530    llvm::Value *MulRes = CGF.Builder.CreateCall2(UMulF, NumOutermostElements,
531                                                  OutermostElementSize);
532
533    // The overflow bit.
534    llvm::Value *DidOverflow = CGF.Builder.CreateExtractValue(MulRes, 1);
535
536    // The result of the multiplication.
537    Size = CGF.Builder.CreateExtractValue(MulRes, 0);
538
539    // If we have a cookie, we need to add that size in, too.
540    if (!CookieSize.isZero()) {
541      SizeWithoutCookie = Size;
542
543      llvm::Value *CookieSizeV
544        = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
545      llvm::Value *UAddF
546        = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, Types, 1);
547      llvm::Value *AddRes
548        = CGF.Builder.CreateCall2(UAddF, SizeWithoutCookie, CookieSizeV);
549
550      Size = CGF.Builder.CreateExtractValue(AddRes, 0);
551
552      llvm::Value *AddDidOverflow = CGF.Builder.CreateExtractValue(AddRes, 1);
553      DidOverflow = CGF.Builder.CreateAnd(DidOverflow, AddDidOverflow);
554    }
555
556    Size = CGF.Builder.CreateSelect(DidOverflow,
557                                    llvm::ConstantInt::get(SizeTy, -1),
558                                    Size);
559  }
560
561  if (CookieSize.isZero())
562    SizeWithoutCookie = Size;
563  else
564    assert(SizeWithoutCookie && "didn't set SizeWithoutCookie?");
565
566  return Size;
567}
568
569static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const CXXNewExpr *E,
570                                    llvm::Value *NewPtr) {
571
572  assert(E->getNumConstructorArgs() == 1 &&
573         "Can only have one argument to initializer of POD type.");
574
575  const Expr *Init = E->getConstructorArg(0);
576  QualType AllocType = E->getAllocatedType();
577
578  unsigned Alignment =
579    CGF.getContext().getTypeAlignInChars(AllocType).getQuantity();
580  if (!CGF.hasAggregateLLVMType(AllocType))
581    CGF.EmitStoreOfScalar(CGF.EmitScalarExpr(Init), NewPtr,
582                          AllocType.isVolatileQualified(), Alignment,
583                          AllocType);
584  else if (AllocType->isAnyComplexType())
585    CGF.EmitComplexExprIntoAddr(Init, NewPtr,
586                                AllocType.isVolatileQualified());
587  else {
588    AggValueSlot Slot
589      = AggValueSlot::forAddr(NewPtr, AllocType.isVolatileQualified(), true);
590    CGF.EmitAggExpr(Init, Slot);
591  }
592}
593
594void
595CodeGenFunction::EmitNewArrayInitializer(const CXXNewExpr *E,
596                                         llvm::Value *NewPtr,
597                                         llvm::Value *NumElements) {
598  // We have a POD type.
599  if (E->getNumConstructorArgs() == 0)
600    return;
601
602  const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
603
604  // Create a temporary for the loop index and initialize it with 0.
605  llvm::Value *IndexPtr = CreateTempAlloca(SizeTy, "loop.index");
606  llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
607  Builder.CreateStore(Zero, IndexPtr);
608
609  // Start the loop with a block that tests the condition.
610  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
611  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
612
613  EmitBlock(CondBlock);
614
615  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
616
617  // Generate: if (loop-index < number-of-elements fall to the loop body,
618  // otherwise, go to the block after the for-loop.
619  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
620  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElements, "isless");
621  // If the condition is true, execute the body.
622  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
623
624  EmitBlock(ForBody);
625
626  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
627  // Inside the loop body, emit the constructor call on the array element.
628  Counter = Builder.CreateLoad(IndexPtr);
629  llvm::Value *Address = Builder.CreateInBoundsGEP(NewPtr, Counter,
630                                                   "arrayidx");
631  StoreAnyExprIntoOneUnit(*this, E, Address);
632
633  EmitBlock(ContinueBlock);
634
635  // Emit the increment of the loop counter.
636  llvm::Value *NextVal = llvm::ConstantInt::get(SizeTy, 1);
637  Counter = Builder.CreateLoad(IndexPtr);
638  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
639  Builder.CreateStore(NextVal, IndexPtr);
640
641  // Finally, branch back up to the condition for the next iteration.
642  EmitBranch(CondBlock);
643
644  // Emit the fall-through block.
645  EmitBlock(AfterFor, true);
646}
647
648static void EmitZeroMemSet(CodeGenFunction &CGF, QualType T,
649                           llvm::Value *NewPtr, llvm::Value *Size) {
650  llvm::LLVMContext &VMContext = CGF.CGM.getLLVMContext();
651  const llvm::Type *BP = llvm::Type::getInt8PtrTy(VMContext);
652  if (NewPtr->getType() != BP)
653    NewPtr = CGF.Builder.CreateBitCast(NewPtr, BP, "tmp");
654
655  CharUnits Alignment = CGF.getContext().getTypeAlignInChars(T);
656  CGF.Builder.CreateMemSet(NewPtr, CGF.Builder.getInt8(0), Size,
657                           Alignment.getQuantity(), false);
658}
659
660static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
661                               llvm::Value *NewPtr,
662                               llvm::Value *NumElements,
663                               llvm::Value *AllocSizeWithoutCookie) {
664  if (E->isArray()) {
665    if (CXXConstructorDecl *Ctor = E->getConstructor()) {
666      bool RequiresZeroInitialization = false;
667      if (Ctor->getParent()->hasTrivialConstructor()) {
668        // If new expression did not specify value-initialization, then there
669        // is no initialization.
670        if (!E->hasInitializer() || Ctor->getParent()->isEmpty())
671          return;
672
673        if (CGF.CGM.getTypes().isZeroInitializable(E->getAllocatedType())) {
674          // Optimization: since zero initialization will just set the memory
675          // to all zeroes, generate a single memset to do it in one shot.
676          EmitZeroMemSet(CGF, E->getAllocatedType(), NewPtr,
677                         AllocSizeWithoutCookie);
678          return;
679        }
680
681        RequiresZeroInitialization = true;
682      }
683
684      CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr,
685                                     E->constructor_arg_begin(),
686                                     E->constructor_arg_end(),
687                                     RequiresZeroInitialization);
688      return;
689    } else if (E->getNumConstructorArgs() == 1 &&
690               isa<ImplicitValueInitExpr>(E->getConstructorArg(0))) {
691      // Optimization: since zero initialization will just set the memory
692      // to all zeroes, generate a single memset to do it in one shot.
693      EmitZeroMemSet(CGF, E->getAllocatedType(), NewPtr,
694                     AllocSizeWithoutCookie);
695      return;
696    } else {
697      CGF.EmitNewArrayInitializer(E, NewPtr, NumElements);
698      return;
699    }
700  }
701
702  if (CXXConstructorDecl *Ctor = E->getConstructor()) {
703    // Per C++ [expr.new]p15, if we have an initializer, then we're performing
704    // direct initialization. C++ [dcl.init]p5 requires that we
705    // zero-initialize storage if there are no user-declared constructors.
706    if (E->hasInitializer() &&
707        !Ctor->getParent()->hasUserDeclaredConstructor() &&
708        !Ctor->getParent()->isEmpty())
709      CGF.EmitNullInitialization(NewPtr, E->getAllocatedType());
710
711    CGF.EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false,
712                               NewPtr, E->constructor_arg_begin(),
713                               E->constructor_arg_end());
714
715    return;
716  }
717  // We have a POD type.
718  if (E->getNumConstructorArgs() == 0)
719    return;
720
721  StoreAnyExprIntoOneUnit(CGF, E, NewPtr);
722}
723
724bool DominatingValue<RValue>::saved_type::needsSaving(RValue rv) {
725  if (rv.isScalar())
726    return DominatingLLVMValue::needsSaving(rv.getScalarVal());
727  if (rv.isAggregate())
728    return DominatingLLVMValue::needsSaving(rv.getAggregateAddr());
729  return true;
730}
731
732DominatingValue<RValue>::saved_type
733DominatingValue<RValue>::saved_type::save(CodeGenFunction &CGF, RValue rv) {
734  if (rv.isScalar()) {
735    llvm::Value *V = rv.getScalarVal();
736
737    // These automatically dominate and don't need to be saved.
738    if (!DominatingLLVMValue::needsSaving(V))
739      return saved_type(V, ScalarLiteral);
740
741    // Everything else needs an alloca.
742    llvm::Value *addr = CGF.CreateTempAlloca(V->getType(), "saved-rvalue");
743    CGF.Builder.CreateStore(V, addr);
744    return saved_type(addr, ScalarAddress);
745  }
746
747  if (rv.isComplex()) {
748    CodeGenFunction::ComplexPairTy V = rv.getComplexVal();
749    const llvm::Type *ComplexTy =
750      llvm::StructType::get(CGF.getLLVMContext(),
751                            V.first->getType(), V.second->getType(),
752                            (void*) 0);
753    llvm::Value *addr = CGF.CreateTempAlloca(ComplexTy, "saved-complex");
754    CGF.StoreComplexToAddr(V, addr, /*volatile*/ false);
755    return saved_type(addr, ComplexAddress);
756  }
757
758  assert(rv.isAggregate());
759  llvm::Value *V = rv.getAggregateAddr(); // TODO: volatile?
760  if (!DominatingLLVMValue::needsSaving(V))
761    return saved_type(V, AggregateLiteral);
762
763  llvm::Value *addr = CGF.CreateTempAlloca(V->getType(), "saved-rvalue");
764  CGF.Builder.CreateStore(V, addr);
765  return saved_type(addr, AggregateAddress);
766}
767
768/// Given a saved r-value produced by SaveRValue, perform the code
769/// necessary to restore it to usability at the current insertion
770/// point.
771RValue DominatingValue<RValue>::saved_type::restore(CodeGenFunction &CGF) {
772  switch (K) {
773  case ScalarLiteral:
774    return RValue::get(Value);
775  case ScalarAddress:
776    return RValue::get(CGF.Builder.CreateLoad(Value));
777  case AggregateLiteral:
778    return RValue::getAggregate(Value);
779  case AggregateAddress:
780    return RValue::getAggregate(CGF.Builder.CreateLoad(Value));
781  case ComplexAddress:
782    return RValue::getComplex(CGF.LoadComplexFromAddr(Value, false));
783  }
784
785  llvm_unreachable("bad saved r-value kind");
786  return RValue();
787}
788
789namespace {
790  /// A cleanup to call the given 'operator delete' function upon
791  /// abnormal exit from a new expression.
792  class CallDeleteDuringNew : public EHScopeStack::Cleanup {
793    size_t NumPlacementArgs;
794    const FunctionDecl *OperatorDelete;
795    llvm::Value *Ptr;
796    llvm::Value *AllocSize;
797
798    RValue *getPlacementArgs() { return reinterpret_cast<RValue*>(this+1); }
799
800  public:
801    static size_t getExtraSize(size_t NumPlacementArgs) {
802      return NumPlacementArgs * sizeof(RValue);
803    }
804
805    CallDeleteDuringNew(size_t NumPlacementArgs,
806                        const FunctionDecl *OperatorDelete,
807                        llvm::Value *Ptr,
808                        llvm::Value *AllocSize)
809      : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
810        Ptr(Ptr), AllocSize(AllocSize) {}
811
812    void setPlacementArg(unsigned I, RValue Arg) {
813      assert(I < NumPlacementArgs && "index out of range");
814      getPlacementArgs()[I] = Arg;
815    }
816
817    void Emit(CodeGenFunction &CGF, bool IsForEH) {
818      const FunctionProtoType *FPT
819        = OperatorDelete->getType()->getAs<FunctionProtoType>();
820      assert(FPT->getNumArgs() == NumPlacementArgs + 1 ||
821             (FPT->getNumArgs() == 2 && NumPlacementArgs == 0));
822
823      CallArgList DeleteArgs;
824
825      // The first argument is always a void*.
826      FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin();
827      DeleteArgs.push_back(std::make_pair(RValue::get(Ptr), *AI++));
828
829      // A member 'operator delete' can take an extra 'size_t' argument.
830      if (FPT->getNumArgs() == NumPlacementArgs + 2)
831        DeleteArgs.push_back(std::make_pair(RValue::get(AllocSize), *AI++));
832
833      // Pass the rest of the arguments, which must match exactly.
834      for (unsigned I = 0; I != NumPlacementArgs; ++I)
835        DeleteArgs.push_back(std::make_pair(getPlacementArgs()[I], *AI++));
836
837      // Call 'operator delete'.
838      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT),
839                   CGF.CGM.GetAddrOfFunction(OperatorDelete),
840                   ReturnValueSlot(), DeleteArgs, OperatorDelete);
841    }
842  };
843
844  /// A cleanup to call the given 'operator delete' function upon
845  /// abnormal exit from a new expression when the new expression is
846  /// conditional.
847  class CallDeleteDuringConditionalNew : public EHScopeStack::Cleanup {
848    size_t NumPlacementArgs;
849    const FunctionDecl *OperatorDelete;
850    DominatingValue<RValue>::saved_type Ptr;
851    DominatingValue<RValue>::saved_type AllocSize;
852
853    DominatingValue<RValue>::saved_type *getPlacementArgs() {
854      return reinterpret_cast<DominatingValue<RValue>::saved_type*>(this+1);
855    }
856
857  public:
858    static size_t getExtraSize(size_t NumPlacementArgs) {
859      return NumPlacementArgs * sizeof(DominatingValue<RValue>::saved_type);
860    }
861
862    CallDeleteDuringConditionalNew(size_t NumPlacementArgs,
863                                   const FunctionDecl *OperatorDelete,
864                                   DominatingValue<RValue>::saved_type Ptr,
865                              DominatingValue<RValue>::saved_type AllocSize)
866      : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
867        Ptr(Ptr), AllocSize(AllocSize) {}
868
869    void setPlacementArg(unsigned I, DominatingValue<RValue>::saved_type Arg) {
870      assert(I < NumPlacementArgs && "index out of range");
871      getPlacementArgs()[I] = Arg;
872    }
873
874    void Emit(CodeGenFunction &CGF, bool IsForEH) {
875      const FunctionProtoType *FPT
876        = OperatorDelete->getType()->getAs<FunctionProtoType>();
877      assert(FPT->getNumArgs() == NumPlacementArgs + 1 ||
878             (FPT->getNumArgs() == 2 && NumPlacementArgs == 0));
879
880      CallArgList DeleteArgs;
881
882      // The first argument is always a void*.
883      FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin();
884      DeleteArgs.push_back(std::make_pair(Ptr.restore(CGF), *AI++));
885
886      // A member 'operator delete' can take an extra 'size_t' argument.
887      if (FPT->getNumArgs() == NumPlacementArgs + 2) {
888        RValue RV = AllocSize.restore(CGF);
889        DeleteArgs.push_back(std::make_pair(RV, *AI++));
890      }
891
892      // Pass the rest of the arguments, which must match exactly.
893      for (unsigned I = 0; I != NumPlacementArgs; ++I) {
894        RValue RV = getPlacementArgs()[I].restore(CGF);
895        DeleteArgs.push_back(std::make_pair(RV, *AI++));
896      }
897
898      // Call 'operator delete'.
899      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT),
900                   CGF.CGM.GetAddrOfFunction(OperatorDelete),
901                   ReturnValueSlot(), DeleteArgs, OperatorDelete);
902    }
903  };
904}
905
906/// Enter a cleanup to call 'operator delete' if the initializer in a
907/// new-expression throws.
908static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
909                                  const CXXNewExpr *E,
910                                  llvm::Value *NewPtr,
911                                  llvm::Value *AllocSize,
912                                  const CallArgList &NewArgs) {
913  // If we're not inside a conditional branch, then the cleanup will
914  // dominate and we can do the easier (and more efficient) thing.
915  if (!CGF.isInConditionalBranch()) {
916    CallDeleteDuringNew *Cleanup = CGF.EHStack
917      .pushCleanupWithExtra<CallDeleteDuringNew>(EHCleanup,
918                                                 E->getNumPlacementArgs(),
919                                                 E->getOperatorDelete(),
920                                                 NewPtr, AllocSize);
921    for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
922      Cleanup->setPlacementArg(I, NewArgs[I+1].first);
923
924    return;
925  }
926
927  // Otherwise, we need to save all this stuff.
928  DominatingValue<RValue>::saved_type SavedNewPtr =
929    DominatingValue<RValue>::save(CGF, RValue::get(NewPtr));
930  DominatingValue<RValue>::saved_type SavedAllocSize =
931    DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
932
933  CallDeleteDuringConditionalNew *Cleanup = CGF.EHStack
934    .pushCleanupWithExtra<CallDeleteDuringConditionalNew>(InactiveEHCleanup,
935                                                 E->getNumPlacementArgs(),
936                                                 E->getOperatorDelete(),
937                                                 SavedNewPtr,
938                                                 SavedAllocSize);
939  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
940    Cleanup->setPlacementArg(I,
941                     DominatingValue<RValue>::save(CGF, NewArgs[I+1].first));
942
943  CGF.ActivateCleanupBlock(CGF.EHStack.stable_begin());
944}
945
946llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
947  QualType AllocType = E->getAllocatedType();
948  if (AllocType->isArrayType())
949    while (const ArrayType *AType = getContext().getAsArrayType(AllocType))
950      AllocType = AType->getElementType();
951
952  FunctionDecl *NewFD = E->getOperatorNew();
953  const FunctionProtoType *NewFTy = NewFD->getType()->getAs<FunctionProtoType>();
954
955  CallArgList NewArgs;
956
957  // The allocation size is the first argument.
958  QualType SizeTy = getContext().getSizeType();
959
960  llvm::Value *NumElements = 0;
961  llvm::Value *AllocSizeWithoutCookie = 0;
962  llvm::Value *AllocSize = EmitCXXNewAllocSize(getContext(),
963                                               *this, E, NumElements,
964                                               AllocSizeWithoutCookie);
965
966  NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy));
967
968  // Emit the rest of the arguments.
969  // FIXME: Ideally, this should just use EmitCallArgs.
970  CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin();
971
972  // First, use the types from the function type.
973  // We start at 1 here because the first argument (the allocation size)
974  // has already been emitted.
975  for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) {
976    QualType ArgType = NewFTy->getArgType(i);
977
978    assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
979           getTypePtr() ==
980           getContext().getCanonicalType(NewArg->getType()).getTypePtr() &&
981           "type mismatch in call argument!");
982
983    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
984                                     ArgType));
985
986  }
987
988  // Either we've emitted all the call args, or we have a call to a
989  // variadic function.
990  assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) &&
991         "Extra arguments in non-variadic function!");
992
993  // If we still have any arguments, emit them using the type of the argument.
994  for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end();
995       NewArg != NewArgEnd; ++NewArg) {
996    QualType ArgType = NewArg->getType();
997    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
998                                     ArgType));
999  }
1000
1001  // Emit the call to new.
1002  RValue RV =
1003    EmitCall(CGM.getTypes().getFunctionInfo(NewArgs, NewFTy),
1004             CGM.GetAddrOfFunction(NewFD), ReturnValueSlot(), NewArgs, NewFD);
1005
1006  // If an allocation function is declared with an empty exception specification
1007  // it returns null to indicate failure to allocate storage. [expr.new]p13.
1008  // (We don't need to check for null when there's no new initializer and
1009  // we're allocating a POD type).
1010  bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() &&
1011    !(AllocType->isPODType() && !E->hasInitializer());
1012
1013  llvm::BasicBlock *NullCheckSource = 0;
1014  llvm::BasicBlock *NewNotNull = 0;
1015  llvm::BasicBlock *NewEnd = 0;
1016
1017  llvm::Value *NewPtr = RV.getScalarVal();
1018  unsigned AS = cast<llvm::PointerType>(NewPtr->getType())->getAddressSpace();
1019
1020  if (NullCheckResult) {
1021    NullCheckSource = Builder.GetInsertBlock();
1022    NewNotNull = createBasicBlock("new.notnull");
1023    NewEnd = createBasicBlock("new.end");
1024
1025    llvm::Value *IsNull = Builder.CreateIsNull(NewPtr, "new.isnull");
1026    Builder.CreateCondBr(IsNull, NewEnd, NewNotNull);
1027    EmitBlock(NewNotNull);
1028  }
1029
1030  assert((AllocSize == AllocSizeWithoutCookie) ==
1031         CalculateCookiePadding(*this, E).isZero());
1032  if (AllocSize != AllocSizeWithoutCookie) {
1033    assert(E->isArray());
1034    NewPtr = CGM.getCXXABI().InitializeArrayCookie(CGF, NewPtr, NumElements,
1035                                                   E, AllocType);
1036  }
1037
1038  // If there's an operator delete, enter a cleanup to call it if an
1039  // exception is thrown.
1040  EHScopeStack::stable_iterator CallOperatorDelete;
1041  if (E->getOperatorDelete()) {
1042    EnterNewDeleteCleanup(*this, E, NewPtr, AllocSize, NewArgs);
1043    CallOperatorDelete = EHStack.stable_begin();
1044  }
1045
1046  const llvm::Type *ElementPtrTy
1047    = ConvertTypeForMem(AllocType)->getPointerTo(AS);
1048  NewPtr = Builder.CreateBitCast(NewPtr, ElementPtrTy);
1049
1050  if (E->isArray()) {
1051    EmitNewInitializer(*this, E, NewPtr, NumElements, AllocSizeWithoutCookie);
1052
1053    // NewPtr is a pointer to the base element type.  If we're
1054    // allocating an array of arrays, we'll need to cast back to the
1055    // array pointer type.
1056    const llvm::Type *ResultTy = ConvertTypeForMem(E->getType());
1057    if (NewPtr->getType() != ResultTy)
1058      NewPtr = Builder.CreateBitCast(NewPtr, ResultTy);
1059  } else {
1060    EmitNewInitializer(*this, E, NewPtr, NumElements, AllocSizeWithoutCookie);
1061  }
1062
1063  // Deactivate the 'operator delete' cleanup if we finished
1064  // initialization.
1065  if (CallOperatorDelete.isValid())
1066    DeactivateCleanupBlock(CallOperatorDelete);
1067
1068  if (NullCheckResult) {
1069    Builder.CreateBr(NewEnd);
1070    llvm::BasicBlock *NotNullSource = Builder.GetInsertBlock();
1071    EmitBlock(NewEnd);
1072
1073    llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
1074    PHI->reserveOperandSpace(2);
1075    PHI->addIncoming(NewPtr, NotNullSource);
1076    PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()),
1077                     NullCheckSource);
1078
1079    NewPtr = PHI;
1080  }
1081
1082  return NewPtr;
1083}
1084
1085void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
1086                                     llvm::Value *Ptr,
1087                                     QualType DeleteTy) {
1088  assert(DeleteFD->getOverloadedOperator() == OO_Delete);
1089
1090  const FunctionProtoType *DeleteFTy =
1091    DeleteFD->getType()->getAs<FunctionProtoType>();
1092
1093  CallArgList DeleteArgs;
1094
1095  // Check if we need to pass the size to the delete operator.
1096  llvm::Value *Size = 0;
1097  QualType SizeTy;
1098  if (DeleteFTy->getNumArgs() == 2) {
1099    SizeTy = DeleteFTy->getArgType(1);
1100    CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1101    Size = llvm::ConstantInt::get(ConvertType(SizeTy),
1102                                  DeleteTypeSize.getQuantity());
1103  }
1104
1105  QualType ArgTy = DeleteFTy->getArgType(0);
1106  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1107  DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy));
1108
1109  if (Size)
1110    DeleteArgs.push_back(std::make_pair(RValue::get(Size), SizeTy));
1111
1112  // Emit the call to delete.
1113  EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy),
1114           CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(),
1115           DeleteArgs, DeleteFD);
1116}
1117
1118namespace {
1119  /// Calls the given 'operator delete' on a single object.
1120  struct CallObjectDelete : EHScopeStack::Cleanup {
1121    llvm::Value *Ptr;
1122    const FunctionDecl *OperatorDelete;
1123    QualType ElementType;
1124
1125    CallObjectDelete(llvm::Value *Ptr,
1126                     const FunctionDecl *OperatorDelete,
1127                     QualType ElementType)
1128      : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1129
1130    void Emit(CodeGenFunction &CGF, bool IsForEH) {
1131      CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
1132    }
1133  };
1134}
1135
1136/// Emit the code for deleting a single object.
1137static void EmitObjectDelete(CodeGenFunction &CGF,
1138                             const FunctionDecl *OperatorDelete,
1139                             llvm::Value *Ptr,
1140                             QualType ElementType) {
1141  // Find the destructor for the type, if applicable.  If the
1142  // destructor is virtual, we'll just emit the vcall and return.
1143  const CXXDestructorDecl *Dtor = 0;
1144  if (const RecordType *RT = ElementType->getAs<RecordType>()) {
1145    CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1146    if (!RD->hasTrivialDestructor()) {
1147      Dtor = RD->getDestructor();
1148
1149      if (Dtor->isVirtual()) {
1150        const llvm::Type *Ty =
1151          CGF.getTypes().GetFunctionType(CGF.getTypes().getFunctionInfo(Dtor,
1152                                                               Dtor_Complete),
1153                                         /*isVariadic=*/false);
1154
1155        llvm::Value *Callee
1156          = CGF.BuildVirtualCall(Dtor, Dtor_Deleting, Ptr, Ty);
1157        CGF.EmitCXXMemberCall(Dtor, Callee, ReturnValueSlot(), Ptr, /*VTT=*/0,
1158                              0, 0);
1159
1160        // The dtor took care of deleting the object.
1161        return;
1162      }
1163    }
1164  }
1165
1166  // Make sure that we call delete even if the dtor throws.
1167  // This doesn't have to a conditional cleanup because we're going
1168  // to pop it off in a second.
1169  CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1170                                            Ptr, OperatorDelete, ElementType);
1171
1172  if (Dtor)
1173    CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
1174                              /*ForVirtualBase=*/false, Ptr);
1175
1176  CGF.PopCleanupBlock();
1177}
1178
1179namespace {
1180  /// Calls the given 'operator delete' on an array of objects.
1181  struct CallArrayDelete : EHScopeStack::Cleanup {
1182    llvm::Value *Ptr;
1183    const FunctionDecl *OperatorDelete;
1184    llvm::Value *NumElements;
1185    QualType ElementType;
1186    CharUnits CookieSize;
1187
1188    CallArrayDelete(llvm::Value *Ptr,
1189                    const FunctionDecl *OperatorDelete,
1190                    llvm::Value *NumElements,
1191                    QualType ElementType,
1192                    CharUnits CookieSize)
1193      : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
1194        ElementType(ElementType), CookieSize(CookieSize) {}
1195
1196    void Emit(CodeGenFunction &CGF, bool IsForEH) {
1197      const FunctionProtoType *DeleteFTy =
1198        OperatorDelete->getType()->getAs<FunctionProtoType>();
1199      assert(DeleteFTy->getNumArgs() == 1 || DeleteFTy->getNumArgs() == 2);
1200
1201      CallArgList Args;
1202
1203      // Pass the pointer as the first argument.
1204      QualType VoidPtrTy = DeleteFTy->getArgType(0);
1205      llvm::Value *DeletePtr
1206        = CGF.Builder.CreateBitCast(Ptr, CGF.ConvertType(VoidPtrTy));
1207      Args.push_back(std::make_pair(RValue::get(DeletePtr), VoidPtrTy));
1208
1209      // Pass the original requested size as the second argument.
1210      if (DeleteFTy->getNumArgs() == 2) {
1211        QualType size_t = DeleteFTy->getArgType(1);
1212        const llvm::IntegerType *SizeTy
1213          = cast<llvm::IntegerType>(CGF.ConvertType(size_t));
1214
1215        CharUnits ElementTypeSize =
1216          CGF.CGM.getContext().getTypeSizeInChars(ElementType);
1217
1218        // The size of an element, multiplied by the number of elements.
1219        llvm::Value *Size
1220          = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity());
1221        Size = CGF.Builder.CreateMul(Size, NumElements);
1222
1223        // Plus the size of the cookie if applicable.
1224        if (!CookieSize.isZero()) {
1225          llvm::Value *CookieSizeV
1226            = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
1227          Size = CGF.Builder.CreateAdd(Size, CookieSizeV);
1228        }
1229
1230        Args.push_back(std::make_pair(RValue::get(Size), size_t));
1231      }
1232
1233      // Emit the call to delete.
1234      CGF.EmitCall(CGF.getTypes().getFunctionInfo(Args, DeleteFTy),
1235                   CGF.CGM.GetAddrOfFunction(OperatorDelete),
1236                   ReturnValueSlot(), Args, OperatorDelete);
1237    }
1238  };
1239}
1240
1241/// Emit the code for deleting an array of objects.
1242static void EmitArrayDelete(CodeGenFunction &CGF,
1243                            const CXXDeleteExpr *E,
1244                            llvm::Value *Ptr,
1245                            QualType ElementType) {
1246  llvm::Value *NumElements = 0;
1247  llvm::Value *AllocatedPtr = 0;
1248  CharUnits CookieSize;
1249  CGF.CGM.getCXXABI().ReadArrayCookie(CGF, Ptr, E, ElementType,
1250                                      NumElements, AllocatedPtr, CookieSize);
1251
1252  assert(AllocatedPtr && "ReadArrayCookie didn't set AllocatedPtr");
1253
1254  // Make sure that we call delete even if one of the dtors throws.
1255  const FunctionDecl *OperatorDelete = E->getOperatorDelete();
1256  CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
1257                                           AllocatedPtr, OperatorDelete,
1258                                           NumElements, ElementType,
1259                                           CookieSize);
1260
1261  if (const CXXRecordDecl *RD = ElementType->getAsCXXRecordDecl()) {
1262    if (!RD->hasTrivialDestructor()) {
1263      assert(NumElements && "ReadArrayCookie didn't find element count"
1264                            " for a class with destructor");
1265      CGF.EmitCXXAggrDestructorCall(RD->getDestructor(), NumElements, Ptr);
1266    }
1267  }
1268
1269  CGF.PopCleanupBlock();
1270}
1271
1272void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
1273
1274  // Get at the argument before we performed the implicit conversion
1275  // to void*.
1276  const Expr *Arg = E->getArgument();
1277  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
1278    if (ICE->getCastKind() != CK_UserDefinedConversion &&
1279        ICE->getType()->isVoidPointerType())
1280      Arg = ICE->getSubExpr();
1281    else
1282      break;
1283  }
1284
1285  llvm::Value *Ptr = EmitScalarExpr(Arg);
1286
1287  // Null check the pointer.
1288  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
1289  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
1290
1291  llvm::Value *IsNull =
1292    Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()),
1293                         "isnull");
1294
1295  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
1296  EmitBlock(DeleteNotNull);
1297
1298  // We might be deleting a pointer to array.  If so, GEP down to the
1299  // first non-array element.
1300  // (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*)
1301  QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType();
1302  if (DeleteTy->isConstantArrayType()) {
1303    llvm::Value *Zero = Builder.getInt32(0);
1304    llvm::SmallVector<llvm::Value*,8> GEP;
1305
1306    GEP.push_back(Zero); // point at the outermost array
1307
1308    // For each layer of array type we're pointing at:
1309    while (const ConstantArrayType *Arr
1310             = getContext().getAsConstantArrayType(DeleteTy)) {
1311      // 1. Unpeel the array type.
1312      DeleteTy = Arr->getElementType();
1313
1314      // 2. GEP to the first element of the array.
1315      GEP.push_back(Zero);
1316    }
1317
1318    Ptr = Builder.CreateInBoundsGEP(Ptr, GEP.begin(), GEP.end(), "del.first");
1319  }
1320
1321  assert(ConvertTypeForMem(DeleteTy) ==
1322         cast<llvm::PointerType>(Ptr->getType())->getElementType());
1323
1324  if (E->isArrayForm()) {
1325    EmitArrayDelete(*this, E, Ptr, DeleteTy);
1326  } else {
1327    EmitObjectDelete(*this, E->getOperatorDelete(), Ptr, DeleteTy);
1328  }
1329
1330  EmitBlock(DeleteEnd);
1331}
1332
1333llvm::Value *CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
1334  QualType Ty = E->getType();
1335  const llvm::Type *LTy = ConvertType(Ty)->getPointerTo();
1336
1337  if (E->isTypeOperand()) {
1338    llvm::Constant *TypeInfo =
1339      CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand());
1340    return Builder.CreateBitCast(TypeInfo, LTy);
1341  }
1342
1343  Expr *subE = E->getExprOperand();
1344  Ty = subE->getType();
1345  CanQualType CanTy = CGM.getContext().getCanonicalType(Ty);
1346  Ty = CanTy.getUnqualifiedType().getNonReferenceType();
1347  if (const RecordType *RT = Ty->getAs<RecordType>()) {
1348    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1349    if (RD->isPolymorphic()) {
1350      // FIXME: if subE is an lvalue do
1351      LValue Obj = EmitLValue(subE);
1352      llvm::Value *This = Obj.getAddress();
1353      // We need to do a zero check for *p, unless it has NonNullAttr.
1354      // FIXME: PointerType->hasAttr<NonNullAttr>()
1355      bool CanBeZero = false;
1356      if (UnaryOperator *UO = dyn_cast<UnaryOperator>(subE->IgnoreParens()))
1357        if (UO->getOpcode() == UO_Deref)
1358          CanBeZero = true;
1359      if (CanBeZero) {
1360        llvm::BasicBlock *NonZeroBlock = createBasicBlock();
1361        llvm::BasicBlock *ZeroBlock = createBasicBlock();
1362
1363        llvm::Value *Zero = llvm::Constant::getNullValue(This->getType());
1364        Builder.CreateCondBr(Builder.CreateICmpNE(This, Zero),
1365                             NonZeroBlock, ZeroBlock);
1366        EmitBlock(ZeroBlock);
1367        /// Call __cxa_bad_typeid
1368        const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
1369        const llvm::FunctionType *FTy;
1370        FTy = llvm::FunctionType::get(ResultType, false);
1371        llvm::Value *F = CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1372        Builder.CreateCall(F)->setDoesNotReturn();
1373        Builder.CreateUnreachable();
1374        EmitBlock(NonZeroBlock);
1375      }
1376      llvm::Value *V = GetVTablePtr(This, LTy->getPointerTo());
1377      V = Builder.CreateConstInBoundsGEP1_64(V, -1ULL);
1378      V = Builder.CreateLoad(V);
1379      return V;
1380    }
1381  }
1382  return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(Ty), LTy);
1383}
1384
1385llvm::Value *CodeGenFunction::EmitDynamicCast(llvm::Value *V,
1386                                              const CXXDynamicCastExpr *DCE) {
1387  QualType SrcTy = DCE->getSubExpr()->getType();
1388  QualType DestTy = DCE->getTypeAsWritten();
1389  QualType InnerType = DestTy->getPointeeType();
1390
1391  const llvm::Type *LTy = ConvertType(DCE->getType());
1392
1393  bool CanBeZero = false;
1394  bool ToVoid = false;
1395  bool ThrowOnBad = false;
1396  if (DestTy->isPointerType()) {
1397    // FIXME: if PointerType->hasAttr<NonNullAttr>(), we don't set this
1398    CanBeZero = true;
1399    if (InnerType->isVoidType())
1400      ToVoid = true;
1401  } else {
1402    LTy = LTy->getPointerTo();
1403
1404    // FIXME: What if exceptions are disabled?
1405    ThrowOnBad = true;
1406  }
1407
1408  if (SrcTy->isPointerType() || SrcTy->isReferenceType())
1409    SrcTy = SrcTy->getPointeeType();
1410  SrcTy = SrcTy.getUnqualifiedType();
1411
1412  if (DestTy->isPointerType() || DestTy->isReferenceType())
1413    DestTy = DestTy->getPointeeType();
1414  DestTy = DestTy.getUnqualifiedType();
1415
1416  llvm::BasicBlock *ContBlock = createBasicBlock();
1417  llvm::BasicBlock *NullBlock = 0;
1418  llvm::BasicBlock *NonZeroBlock = 0;
1419  if (CanBeZero) {
1420    NonZeroBlock = createBasicBlock();
1421    NullBlock = createBasicBlock();
1422    Builder.CreateCondBr(Builder.CreateIsNotNull(V), NonZeroBlock, NullBlock);
1423    EmitBlock(NonZeroBlock);
1424  }
1425
1426  llvm::BasicBlock *BadCastBlock = 0;
1427
1428  const llvm::Type *PtrDiffTy = ConvertType(getContext().getPointerDiffType());
1429
1430  // See if this is a dynamic_cast(void*)
1431  if (ToVoid) {
1432    llvm::Value *This = V;
1433    V = GetVTablePtr(This, PtrDiffTy->getPointerTo());
1434    V = Builder.CreateConstInBoundsGEP1_64(V, -2ULL);
1435    V = Builder.CreateLoad(V, "offset to top");
1436    This = Builder.CreateBitCast(This, llvm::Type::getInt8PtrTy(VMContext));
1437    V = Builder.CreateInBoundsGEP(This, V);
1438    V = Builder.CreateBitCast(V, LTy);
1439  } else {
1440    /// Call __dynamic_cast
1441    const llvm::Type *ResultType = llvm::Type::getInt8PtrTy(VMContext);
1442    const llvm::FunctionType *FTy;
1443    std::vector<const llvm::Type*> ArgTys;
1444    const llvm::Type *PtrToInt8Ty
1445      = llvm::Type::getInt8Ty(VMContext)->getPointerTo();
1446    ArgTys.push_back(PtrToInt8Ty);
1447    ArgTys.push_back(PtrToInt8Ty);
1448    ArgTys.push_back(PtrToInt8Ty);
1449    ArgTys.push_back(PtrDiffTy);
1450    FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
1451
1452    // FIXME: Calculate better hint.
1453    llvm::Value *hint = llvm::ConstantInt::get(PtrDiffTy, -1ULL);
1454
1455    assert(SrcTy->isRecordType() && "Src type must be record type!");
1456    assert(DestTy->isRecordType() && "Dest type must be record type!");
1457
1458    llvm::Value *SrcArg
1459      = CGM.GetAddrOfRTTIDescriptor(SrcTy.getUnqualifiedType());
1460    llvm::Value *DestArg
1461      = CGM.GetAddrOfRTTIDescriptor(DestTy.getUnqualifiedType());
1462
1463    V = Builder.CreateBitCast(V, PtrToInt8Ty);
1464    V = Builder.CreateCall4(CGM.CreateRuntimeFunction(FTy, "__dynamic_cast"),
1465                            V, SrcArg, DestArg, hint);
1466    V = Builder.CreateBitCast(V, LTy);
1467
1468    if (ThrowOnBad) {
1469      BadCastBlock = createBasicBlock();
1470      Builder.CreateCondBr(Builder.CreateIsNotNull(V), ContBlock, BadCastBlock);
1471      EmitBlock(BadCastBlock);
1472      /// Invoke __cxa_bad_cast
1473      ResultType = llvm::Type::getVoidTy(VMContext);
1474      const llvm::FunctionType *FBadTy;
1475      FBadTy = llvm::FunctionType::get(ResultType, false);
1476      llvm::Value *F = CGM.CreateRuntimeFunction(FBadTy, "__cxa_bad_cast");
1477      if (llvm::BasicBlock *InvokeDest = getInvokeDest()) {
1478        llvm::BasicBlock *Cont = createBasicBlock("invoke.cont");
1479        Builder.CreateInvoke(F, Cont, InvokeDest)->setDoesNotReturn();
1480        EmitBlock(Cont);
1481      } else {
1482        // FIXME: Does this ever make sense?
1483        Builder.CreateCall(F)->setDoesNotReturn();
1484      }
1485      Builder.CreateUnreachable();
1486    }
1487  }
1488
1489  if (CanBeZero) {
1490    Builder.CreateBr(ContBlock);
1491    EmitBlock(NullBlock);
1492    Builder.CreateBr(ContBlock);
1493  }
1494  EmitBlock(ContBlock);
1495  if (CanBeZero) {
1496    llvm::PHINode *PHI = Builder.CreatePHI(LTy);
1497    PHI->reserveOperandSpace(2);
1498    PHI->addIncoming(V, NonZeroBlock);
1499    PHI->addIncoming(llvm::Constant::getNullValue(LTy), NullBlock);
1500    V = PHI;
1501  }
1502
1503  return V;
1504}
1505