CGExprCXX.cpp revision 6da2c716017d5c8530ec99779524491ebc5dadb8 
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 "CGCUDARuntime.h"
17#include "CGCXXABI.h"
18#include "CGObjCRuntime.h"
19#include "CGDebugInfo.h"
20#include "llvm/Intrinsics.h"
21#include "llvm/Support/CallSite.h"
22
23using namespace clang;
24using namespace CodeGen;
25
26RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
27                                          llvm::Value *Callee,
28                                          ReturnValueSlot ReturnValue,
29                                          llvm::Value *This,
30                                          llvm::Value *VTT,
31                                          CallExpr::const_arg_iterator ArgBeg,
32                                          CallExpr::const_arg_iterator ArgEnd) {
33  assert(MD->isInstance() &&
34         "Trying to emit a member call expr on a static method!");
35
36  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
37
38  CallArgList Args;
39
40  // Push the this ptr.
41  Args.add(RValue::get(This), MD->getThisType(getContext()));
42
43  // If there is a VTT parameter, emit it.
44  if (VTT) {
45    QualType T = getContext().getPointerType(getContext().VoidPtrTy);
46    Args.add(RValue::get(VTT), T);
47  }
48
49  // And the rest of the call args
50  EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
51
52  QualType ResultType = FPT->getResultType();
53  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
54                                                 FPT->getExtInfo()),
55                  Callee, ReturnValue, Args, MD);
56}
57
58static const CXXRecordDecl *getMostDerivedClassDecl(const Expr *Base) {
59  const Expr *E = Base;
60
61  while (true) {
62    E = E->IgnoreParens();
63    if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
64      if (CE->getCastKind() == CK_DerivedToBase ||
65          CE->getCastKind() == CK_UncheckedDerivedToBase ||
66          CE->getCastKind() == CK_NoOp) {
67        E = CE->getSubExpr();
68        continue;
69      }
70    }
71
72    break;
73  }
74
75  QualType DerivedType = E->getType();
76  if (const PointerType *PTy = DerivedType->getAs<PointerType>())
77    DerivedType = PTy->getPointeeType();
78
79  return cast<CXXRecordDecl>(DerivedType->castAs<RecordType>()->getDecl());
80}
81
82// FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do
83// quite what we want.
84static const Expr *skipNoOpCastsAndParens(const Expr *E) {
85  while (true) {
86    if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
87      E = PE->getSubExpr();
88      continue;
89    }
90
91    if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
92      if (CE->getCastKind() == CK_NoOp) {
93        E = CE->getSubExpr();
94        continue;
95      }
96    }
97    if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
98      if (UO->getOpcode() == UO_Extension) {
99        E = UO->getSubExpr();
100        continue;
101      }
102    }
103    return E;
104  }
105}
106
107/// canDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given
108/// expr can be devirtualized.
109static bool canDevirtualizeMemberFunctionCalls(ASTContext &Context,
110                                               const Expr *Base,
111                                               const CXXMethodDecl *MD) {
112
113  // When building with -fapple-kext, all calls must go through the vtable since
114  // the kernel linker can do runtime patching of vtables.
115  if (Context.getLangOptions().AppleKext)
116    return false;
117
118  // If the most derived class is marked final, we know that no subclass can
119  // override this member function and so we can devirtualize it. For example:
120  //
121  // struct A { virtual void f(); }
122  // struct B final : A { };
123  //
124  // void f(B *b) {
125  //   b->f();
126  // }
127  //
128  const CXXRecordDecl *MostDerivedClassDecl = getMostDerivedClassDecl(Base);
129  if (MostDerivedClassDecl->hasAttr<FinalAttr>())
130    return true;
131
132  // If the member function is marked 'final', we know that it can't be
133  // overridden and can therefore devirtualize it.
134  if (MD->hasAttr<FinalAttr>())
135    return true;
136
137  // Similarly, if the class itself is marked 'final' it can't be overridden
138  // and we can therefore devirtualize the member function call.
139  if (MD->getParent()->hasAttr<FinalAttr>())
140    return true;
141
142  Base = skipNoOpCastsAndParens(Base);
143  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
144    if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
145      // This is a record decl. We know the type and can devirtualize it.
146      return VD->getType()->isRecordType();
147    }
148
149    return false;
150  }
151
152  // We can always devirtualize calls on temporary object expressions.
153  if (isa<CXXConstructExpr>(Base))
154    return true;
155
156  // And calls on bound temporaries.
157  if (isa<CXXBindTemporaryExpr>(Base))
158    return true;
159
160  // Check if this is a call expr that returns a record type.
161  if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
162    return CE->getCallReturnType()->isRecordType();
163
164  // We can't devirtualize the call.
165  return false;
166}
167
168// Note: This function also emit constructor calls to support a MSVC
169// extensions allowing explicit constructor function call.
170RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE,
171                                              ReturnValueSlot ReturnValue) {
172  const Expr *callee = CE->getCallee()->IgnoreParens();
173
174  if (isa<BinaryOperator>(callee))
175    return EmitCXXMemberPointerCallExpr(CE, ReturnValue);
176
177  const MemberExpr *ME = cast<MemberExpr>(callee);
178  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
179
180  CGDebugInfo *DI = getDebugInfo();
181  if (DI && CGM.getCodeGenOpts().LimitDebugInfo
182      && !isa<CallExpr>(ME->getBase())) {
183    QualType PQTy = ME->getBase()->IgnoreParenImpCasts()->getType();
184    if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) {
185      DI->getOrCreateRecordType(PTy->getPointeeType(),
186                                MD->getParent()->getLocation());
187    }
188  }
189
190  if (MD->isStatic()) {
191    // The method is static, emit it as we would a regular call.
192    llvm::Value *Callee = CGM.GetAddrOfFunction(MD);
193    return EmitCall(getContext().getPointerType(MD->getType()), Callee,
194                    ReturnValue, CE->arg_begin(), CE->arg_end());
195  }
196
197  // Compute the object pointer.
198  llvm::Value *This;
199  if (ME->isArrow())
200    This = EmitScalarExpr(ME->getBase());
201  else
202    This = EmitLValue(ME->getBase()).getAddress();
203
204  if (MD->isTrivial()) {
205    if (isa<CXXDestructorDecl>(MD)) return RValue::get(0);
206    if (isa<CXXConstructorDecl>(MD) &&
207        cast<CXXConstructorDecl>(MD)->isDefaultConstructor())
208      return RValue::get(0);
209
210    if (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) {
211      // We don't like to generate the trivial copy/move assignment operator
212      // when it isn't necessary; just produce the proper effect here.
213      llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
214      EmitAggregateCopy(This, RHS, CE->getType());
215      return RValue::get(This);
216    }
217
218    if (isa<CXXConstructorDecl>(MD) &&
219        cast<CXXConstructorDecl>(MD)->isCopyOrMoveConstructor()) {
220      // Trivial move and copy ctor are the same.
221      llvm::Value *RHS = EmitLValue(*CE->arg_begin()).getAddress();
222      EmitSynthesizedCXXCopyCtorCall(cast<CXXConstructorDecl>(MD), This, RHS,
223                                     CE->arg_begin(), CE->arg_end());
224      return RValue::get(This);
225    }
226    llvm_unreachable("unknown trivial member function");
227  }
228
229  // Compute the function type we're calling.
230  const CGFunctionInfo *FInfo = 0;
231  if (isa<CXXDestructorDecl>(MD))
232    FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXDestructorDecl>(MD),
233                                           Dtor_Complete);
234  else if (isa<CXXConstructorDecl>(MD))
235    FInfo = &CGM.getTypes().getFunctionInfo(cast<CXXConstructorDecl>(MD),
236                                            Ctor_Complete);
237  else
238    FInfo = &CGM.getTypes().getFunctionInfo(MD);
239
240  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
241  llvm::Type *Ty
242    = CGM.getTypes().GetFunctionType(*FInfo, FPT->isVariadic());
243
244  // C++ [class.virtual]p12:
245  //   Explicit qualification with the scope operator (5.1) suppresses the
246  //   virtual call mechanism.
247  //
248  // We also don't emit a virtual call if the base expression has a record type
249  // because then we know what the type is.
250  bool UseVirtualCall;
251  UseVirtualCall = MD->isVirtual() && !ME->hasQualifier()
252                   && !canDevirtualizeMemberFunctionCalls(getContext(),
253                                                          ME->getBase(), MD);
254  llvm::Value *Callee;
255  if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD)) {
256    if (UseVirtualCall) {
257      Callee = BuildVirtualCall(Dtor, Dtor_Complete, This, Ty);
258    } else {
259      if (getContext().getLangOptions().AppleKext &&
260          MD->isVirtual() &&
261          ME->hasQualifier())
262        Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), Ty);
263      else
264        Callee = CGM.GetAddrOfFunction(GlobalDecl(Dtor, Dtor_Complete), Ty);
265    }
266  } else if (const CXXConstructorDecl *Ctor =
267               dyn_cast<CXXConstructorDecl>(MD)) {
268    Callee = CGM.GetAddrOfFunction(GlobalDecl(Ctor, Ctor_Complete), Ty);
269  } else if (UseVirtualCall) {
270      Callee = BuildVirtualCall(MD, This, Ty);
271  } else {
272    if (getContext().getLangOptions().AppleKext &&
273        MD->isVirtual() &&
274        ME->hasQualifier())
275      Callee = BuildAppleKextVirtualCall(MD, ME->getQualifier(), Ty);
276    else
277      Callee = CGM.GetAddrOfFunction(MD, Ty);
278  }
279
280  return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
281                           CE->arg_begin(), CE->arg_end());
282}
283
284RValue
285CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E,
286                                              ReturnValueSlot ReturnValue) {
287  const BinaryOperator *BO =
288      cast<BinaryOperator>(E->getCallee()->IgnoreParens());
289  const Expr *BaseExpr = BO->getLHS();
290  const Expr *MemFnExpr = BO->getRHS();
291
292  const MemberPointerType *MPT =
293    MemFnExpr->getType()->castAs<MemberPointerType>();
294
295  const FunctionProtoType *FPT =
296    MPT->getPointeeType()->castAs<FunctionProtoType>();
297  const CXXRecordDecl *RD =
298    cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
299
300  // Get the member function pointer.
301  llvm::Value *MemFnPtr = EmitScalarExpr(MemFnExpr);
302
303  // Emit the 'this' pointer.
304  llvm::Value *This;
305
306  if (BO->getOpcode() == BO_PtrMemI)
307    This = EmitScalarExpr(BaseExpr);
308  else
309    This = EmitLValue(BaseExpr).getAddress();
310
311  // Ask the ABI to load the callee.  Note that This is modified.
312  llvm::Value *Callee =
313    CGM.getCXXABI().EmitLoadOfMemberFunctionPointer(*this, This, MemFnPtr, MPT);
314
315  CallArgList Args;
316
317  QualType ThisType =
318    getContext().getPointerType(getContext().getTagDeclType(RD));
319
320  // Push the this ptr.
321  Args.add(RValue::get(This), ThisType);
322
323  // And the rest of the call args
324  EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end());
325  return EmitCall(CGM.getTypes().getFunctionInfo(Args, FPT), Callee,
326                  ReturnValue, Args);
327}
328
329RValue
330CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
331                                               const CXXMethodDecl *MD,
332                                               ReturnValueSlot ReturnValue) {
333  assert(MD->isInstance() &&
334         "Trying to emit a member call expr on a static method!");
335  LValue LV = EmitLValue(E->getArg(0));
336  llvm::Value *This = LV.getAddress();
337
338  if ((MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) &&
339      MD->isTrivial()) {
340    llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
341    QualType Ty = E->getType();
342    EmitAggregateCopy(This, Src, Ty);
343    return RValue::get(This);
344  }
345
346  llvm::Value *Callee = EmitCXXOperatorMemberCallee(E, MD, This);
347  return EmitCXXMemberCall(MD, Callee, ReturnValue, This, /*VTT=*/0,
348                           E->arg_begin() + 1, E->arg_end());
349}
350
351RValue CodeGenFunction::EmitCUDAKernelCallExpr(const CUDAKernelCallExpr *E,
352                                               ReturnValueSlot ReturnValue) {
353  return CGM.getCUDARuntime().EmitCUDAKernelCallExpr(*this, E, ReturnValue);
354}
355
356static void EmitNullBaseClassInitialization(CodeGenFunction &CGF,
357                                            llvm::Value *DestPtr,
358                                            const CXXRecordDecl *Base) {
359  if (Base->isEmpty())
360    return;
361
362  DestPtr = CGF.EmitCastToVoidPtr(DestPtr);
363
364  const ASTRecordLayout &Layout = CGF.getContext().getASTRecordLayout(Base);
365  CharUnits Size = Layout.getNonVirtualSize();
366  CharUnits Align = Layout.getNonVirtualAlign();
367
368  llvm::Value *SizeVal = CGF.CGM.getSize(Size);
369
370  // If the type contains a pointer to data member we can't memset it to zero.
371  // Instead, create a null constant and copy it to the destination.
372  // TODO: there are other patterns besides zero that we can usefully memset,
373  // like -1, which happens to be the pattern used by member-pointers.
374  // TODO: isZeroInitializable can be over-conservative in the case where a
375  // virtual base contains a member pointer.
376  if (!CGF.CGM.getTypes().isZeroInitializable(Base)) {
377    llvm::Constant *NullConstant = CGF.CGM.EmitNullConstantForBase(Base);
378
379    llvm::GlobalVariable *NullVariable =
380      new llvm::GlobalVariable(CGF.CGM.getModule(), NullConstant->getType(),
381                               /*isConstant=*/true,
382                               llvm::GlobalVariable::PrivateLinkage,
383                               NullConstant, Twine());
384    NullVariable->setAlignment(Align.getQuantity());
385    llvm::Value *SrcPtr = CGF.EmitCastToVoidPtr(NullVariable);
386
387    // Get and call the appropriate llvm.memcpy overload.
388    CGF.Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, Align.getQuantity());
389    return;
390  }
391
392  // Otherwise, just memset the whole thing to zero.  This is legal
393  // because in LLVM, all default initializers (other than the ones we just
394  // handled above) are guaranteed to have a bit pattern of all zeros.
395  CGF.Builder.CreateMemSet(DestPtr, CGF.Builder.getInt8(0), SizeVal,
396                           Align.getQuantity());
397}
398
399void
400CodeGenFunction::EmitCXXConstructExpr(const CXXConstructExpr *E,
401                                      AggValueSlot Dest) {
402  assert(!Dest.isIgnored() && "Must have a destination!");
403  const CXXConstructorDecl *CD = E->getConstructor();
404
405  // If we require zero initialization before (or instead of) calling the
406  // constructor, as can be the case with a non-user-provided default
407  // constructor, emit the zero initialization now, unless destination is
408  // already zeroed.
409  if (E->requiresZeroInitialization() && !Dest.isZeroed()) {
410    switch (E->getConstructionKind()) {
411    case CXXConstructExpr::CK_Delegating:
412      assert(0 && "Delegating constructor should not need zeroing");
413    case CXXConstructExpr::CK_Complete:
414      EmitNullInitialization(Dest.getAddr(), E->getType());
415      break;
416    case CXXConstructExpr::CK_VirtualBase:
417    case CXXConstructExpr::CK_NonVirtualBase:
418      EmitNullBaseClassInitialization(*this, Dest.getAddr(), CD->getParent());
419      break;
420    }
421  }
422
423  // If this is a call to a trivial default constructor, do nothing.
424  if (CD->isTrivial() && CD->isDefaultConstructor())
425    return;
426
427  // Elide the constructor if we're constructing from a temporary.
428  // The temporary check is required because Sema sets this on NRVO
429  // returns.
430  if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
431    assert(getContext().hasSameUnqualifiedType(E->getType(),
432                                               E->getArg(0)->getType()));
433    if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
434      EmitAggExpr(E->getArg(0), Dest);
435      return;
436    }
437  }
438
439  if (const ConstantArrayType *arrayType
440        = getContext().getAsConstantArrayType(E->getType())) {
441    EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddr(),
442                               E->arg_begin(), E->arg_end());
443  } else {
444    CXXCtorType Type = Ctor_Complete;
445    bool ForVirtualBase = false;
446
447    switch (E->getConstructionKind()) {
448     case CXXConstructExpr::CK_Delegating:
449      // We should be emitting a constructor; GlobalDecl will assert this
450      Type = CurGD.getCtorType();
451      break;
452
453     case CXXConstructExpr::CK_Complete:
454      Type = Ctor_Complete;
455      break;
456
457     case CXXConstructExpr::CK_VirtualBase:
458      ForVirtualBase = true;
459      // fall-through
460
461     case CXXConstructExpr::CK_NonVirtualBase:
462      Type = Ctor_Base;
463    }
464
465    // Call the constructor.
466    EmitCXXConstructorCall(CD, Type, ForVirtualBase, Dest.getAddr(),
467                           E->arg_begin(), E->arg_end());
468  }
469}
470
471void
472CodeGenFunction::EmitSynthesizedCXXCopyCtor(llvm::Value *Dest,
473                                            llvm::Value *Src,
474                                            const Expr *Exp) {
475  if (const ExprWithCleanups *E = dyn_cast<ExprWithCleanups>(Exp))
476    Exp = E->getSubExpr();
477  assert(isa<CXXConstructExpr>(Exp) &&
478         "EmitSynthesizedCXXCopyCtor - unknown copy ctor expr");
479  const CXXConstructExpr* E = cast<CXXConstructExpr>(Exp);
480  const CXXConstructorDecl *CD = E->getConstructor();
481  RunCleanupsScope Scope(*this);
482
483  // If we require zero initialization before (or instead of) calling the
484  // constructor, as can be the case with a non-user-provided default
485  // constructor, emit the zero initialization now.
486  // FIXME. Do I still need this for a copy ctor synthesis?
487  if (E->requiresZeroInitialization())
488    EmitNullInitialization(Dest, E->getType());
489
490  assert(!getContext().getAsConstantArrayType(E->getType())
491         && "EmitSynthesizedCXXCopyCtor - Copied-in Array");
492  EmitSynthesizedCXXCopyCtorCall(CD, Dest, Src,
493                                 E->arg_begin(), E->arg_end());
494}
495
496static CharUnits CalculateCookiePadding(CodeGenFunction &CGF,
497                                        const CXXNewExpr *E) {
498  if (!E->isArray())
499    return CharUnits::Zero();
500
501  // No cookie is required if the operator new[] being used is the
502  // reserved placement operator new[].
503  if (E->getOperatorNew()->isReservedGlobalPlacementOperator())
504    return CharUnits::Zero();
505
506  return CGF.CGM.getCXXABI().GetArrayCookieSize(E);
507}
508
509static llvm::Value *EmitCXXNewAllocSize(CodeGenFunction &CGF,
510                                        const CXXNewExpr *e,
511                                        llvm::Value *&numElements,
512                                        llvm::Value *&sizeWithoutCookie) {
513  QualType type = e->getAllocatedType();
514
515  if (!e->isArray()) {
516    CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
517    sizeWithoutCookie
518      = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
519    return sizeWithoutCookie;
520  }
521
522  // The width of size_t.
523  unsigned sizeWidth = CGF.SizeTy->getBitWidth();
524
525  // Figure out the cookie size.
526  llvm::APInt cookieSize(sizeWidth,
527                         CalculateCookiePadding(CGF, e).getQuantity());
528
529  // Emit the array size expression.
530  // We multiply the size of all dimensions for NumElements.
531  // e.g for 'int[2][3]', ElemType is 'int' and NumElements is 6.
532  numElements = CGF.EmitScalarExpr(e->getArraySize());
533  assert(isa<llvm::IntegerType>(numElements->getType()));
534
535  // The number of elements can be have an arbitrary integer type;
536  // essentially, we need to multiply it by a constant factor, add a
537  // cookie size, and verify that the result is representable as a
538  // size_t.  That's just a gloss, though, and it's wrong in one
539  // important way: if the count is negative, it's an error even if
540  // the cookie size would bring the total size >= 0.
541  bool isSigned
542    = e->getArraySize()->getType()->isSignedIntegerOrEnumerationType();
543  llvm::IntegerType *numElementsType
544    = cast<llvm::IntegerType>(numElements->getType());
545  unsigned numElementsWidth = numElementsType->getBitWidth();
546
547  // Compute the constant factor.
548  llvm::APInt arraySizeMultiplier(sizeWidth, 1);
549  while (const ConstantArrayType *CAT
550             = CGF.getContext().getAsConstantArrayType(type)) {
551    type = CAT->getElementType();
552    arraySizeMultiplier *= CAT->getSize();
553  }
554
555  CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
556  llvm::APInt typeSizeMultiplier(sizeWidth, typeSize.getQuantity());
557  typeSizeMultiplier *= arraySizeMultiplier;
558
559  // This will be a size_t.
560  llvm::Value *size;
561
562  // If someone is doing 'new int[42]' there is no need to do a dynamic check.
563  // Don't bloat the -O0 code.
564  if (llvm::ConstantInt *numElementsC =
565        dyn_cast<llvm::ConstantInt>(numElements)) {
566    const llvm::APInt &count = numElementsC->getValue();
567
568    bool hasAnyOverflow = false;
569
570    // If 'count' was a negative number, it's an overflow.
571    if (isSigned && count.isNegative())
572      hasAnyOverflow = true;
573
574    // We want to do all this arithmetic in size_t.  If numElements is
575    // wider than that, check whether it's already too big, and if so,
576    // overflow.
577    else if (numElementsWidth > sizeWidth &&
578             numElementsWidth - sizeWidth > count.countLeadingZeros())
579      hasAnyOverflow = true;
580
581    // Okay, compute a count at the right width.
582    llvm::APInt adjustedCount = count.zextOrTrunc(sizeWidth);
583
584    // Scale numElements by that.  This might overflow, but we don't
585    // care because it only overflows if allocationSize does, too, and
586    // if that overflows then we shouldn't use this.
587    numElements = llvm::ConstantInt::get(CGF.SizeTy,
588                                         adjustedCount * arraySizeMultiplier);
589
590    // Compute the size before cookie, and track whether it overflowed.
591    bool overflow;
592    llvm::APInt allocationSize
593      = adjustedCount.umul_ov(typeSizeMultiplier, overflow);
594    hasAnyOverflow |= overflow;
595
596    // Add in the cookie, and check whether it's overflowed.
597    if (cookieSize != 0) {
598      // Save the current size without a cookie.  This shouldn't be
599      // used if there was overflow.
600      sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
601
602      allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
603      hasAnyOverflow |= overflow;
604    }
605
606    // On overflow, produce a -1 so operator new will fail.
607    if (hasAnyOverflow) {
608      size = llvm::Constant::getAllOnesValue(CGF.SizeTy);
609    } else {
610      size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
611    }
612
613  // Otherwise, we might need to use the overflow intrinsics.
614  } else {
615    // There are up to four conditions we need to test for:
616    // 1) if isSigned, we need to check whether numElements is negative;
617    // 2) if numElementsWidth > sizeWidth, we need to check whether
618    //   numElements is larger than something representable in size_t;
619    // 3) we need to compute
620    //      sizeWithoutCookie := numElements * typeSizeMultiplier
621    //    and check whether it overflows; and
622    // 4) if we need a cookie, we need to compute
623    //      size := sizeWithoutCookie + cookieSize
624    //    and check whether it overflows.
625
626    llvm::Value *hasOverflow = 0;
627
628    // If numElementsWidth > sizeWidth, then one way or another, we're
629    // going to have to do a comparison for (2), and this happens to
630    // take care of (1), too.
631    if (numElementsWidth > sizeWidth) {
632      llvm::APInt threshold(numElementsWidth, 1);
633      threshold <<= sizeWidth;
634
635      llvm::Value *thresholdV
636        = llvm::ConstantInt::get(numElementsType, threshold);
637
638      hasOverflow = CGF.Builder.CreateICmpUGE(numElements, thresholdV);
639      numElements = CGF.Builder.CreateTrunc(numElements, CGF.SizeTy);
640
641    // Otherwise, if we're signed, we want to sext up to size_t.
642    } else if (isSigned) {
643      if (numElementsWidth < sizeWidth)
644        numElements = CGF.Builder.CreateSExt(numElements, CGF.SizeTy);
645
646      // If there's a non-1 type size multiplier, then we can do the
647      // signedness check at the same time as we do the multiply
648      // because a negative number times anything will cause an
649      // unsigned overflow.  Otherwise, we have to do it here.
650      if (typeSizeMultiplier == 1)
651        hasOverflow = CGF.Builder.CreateICmpSLT(numElements,
652                                      llvm::ConstantInt::get(CGF.SizeTy, 0));
653
654    // Otherwise, zext up to size_t if necessary.
655    } else if (numElementsWidth < sizeWidth) {
656      numElements = CGF.Builder.CreateZExt(numElements, CGF.SizeTy);
657    }
658
659    assert(numElements->getType() == CGF.SizeTy);
660
661    size = numElements;
662
663    // Multiply by the type size if necessary.  This multiplier
664    // includes all the factors for nested arrays.
665    //
666    // This step also causes numElements to be scaled up by the
667    // nested-array factor if necessary.  Overflow on this computation
668    // can be ignored because the result shouldn't be used if
669    // allocation fails.
670    if (typeSizeMultiplier != 1) {
671      llvm::Value *umul_with_overflow
672        = CGF.CGM.getIntrinsic(llvm::Intrinsic::umul_with_overflow, CGF.SizeTy);
673
674      llvm::Value *tsmV =
675        llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
676      llvm::Value *result =
677        CGF.Builder.CreateCall2(umul_with_overflow, size, tsmV);
678
679      llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
680      if (hasOverflow)
681        hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
682      else
683        hasOverflow = overflowed;
684
685      size = CGF.Builder.CreateExtractValue(result, 0);
686
687      // Also scale up numElements by the array size multiplier.
688      if (arraySizeMultiplier != 1) {
689        // If the base element type size is 1, then we can re-use the
690        // multiply we just did.
691        if (typeSize.isOne()) {
692          assert(arraySizeMultiplier == typeSizeMultiplier);
693          numElements = size;
694
695        // Otherwise we need a separate multiply.
696        } else {
697          llvm::Value *asmV =
698            llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
699          numElements = CGF.Builder.CreateMul(numElements, asmV);
700        }
701      }
702    } else {
703      // numElements doesn't need to be scaled.
704      assert(arraySizeMultiplier == 1);
705    }
706
707    // Add in the cookie size if necessary.
708    if (cookieSize != 0) {
709      sizeWithoutCookie = size;
710
711      llvm::Value *uadd_with_overflow
712        = CGF.CGM.getIntrinsic(llvm::Intrinsic::uadd_with_overflow, CGF.SizeTy);
713
714      llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
715      llvm::Value *result =
716        CGF.Builder.CreateCall2(uadd_with_overflow, size, cookieSizeV);
717
718      llvm::Value *overflowed = CGF.Builder.CreateExtractValue(result, 1);
719      if (hasOverflow)
720        hasOverflow = CGF.Builder.CreateOr(hasOverflow, overflowed);
721      else
722        hasOverflow = overflowed;
723
724      size = CGF.Builder.CreateExtractValue(result, 0);
725    }
726
727    // If we had any possibility of dynamic overflow, make a select to
728    // overwrite 'size' with an all-ones value, which should cause
729    // operator new to throw.
730    if (hasOverflow)
731      size = CGF.Builder.CreateSelect(hasOverflow,
732                                 llvm::Constant::getAllOnesValue(CGF.SizeTy),
733                                      size);
734  }
735
736  if (cookieSize == 0)
737    sizeWithoutCookie = size;
738  else
739    assert(sizeWithoutCookie && "didn't set sizeWithoutCookie?");
740
741  return size;
742}
743
744static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const CXXNewExpr *E,
745                                    llvm::Value *NewPtr) {
746
747  assert(E->getNumConstructorArgs() == 1 &&
748         "Can only have one argument to initializer of POD type.");
749
750  const Expr *Init = E->getConstructorArg(0);
751  QualType AllocType = E->getAllocatedType();
752
753  CharUnits Alignment = CGF.getContext().getTypeAlignInChars(AllocType);
754  if (!CGF.hasAggregateLLVMType(AllocType))
755    CGF.EmitScalarInit(Init, 0, CGF.MakeAddrLValue(NewPtr, AllocType,
756                                                   Alignment),
757                       false);
758  else if (AllocType->isAnyComplexType())
759    CGF.EmitComplexExprIntoAddr(Init, NewPtr,
760                                AllocType.isVolatileQualified());
761  else {
762    AggValueSlot Slot
763      = AggValueSlot::forAddr(NewPtr, Alignment, AllocType.getQualifiers(),
764                              AggValueSlot::IsDestructed,
765                              AggValueSlot::DoesNotNeedGCBarriers,
766                              AggValueSlot::IsNotAliased);
767    CGF.EmitAggExpr(Init, Slot);
768  }
769}
770
771void
772CodeGenFunction::EmitNewArrayInitializer(const CXXNewExpr *E,
773                                         QualType elementType,
774                                         llvm::Value *beginPtr,
775                                         llvm::Value *numElements) {
776  // We have a POD type.
777  if (E->getNumConstructorArgs() == 0)
778    return;
779
780  // Check if the number of elements is constant.
781  bool checkZero = true;
782  if (llvm::ConstantInt *constNum = dyn_cast<llvm::ConstantInt>(numElements)) {
783    // If it's constant zero, skip the whole loop.
784    if (constNum->isZero()) return;
785
786    checkZero = false;
787  }
788
789  // Find the end of the array, hoisted out of the loop.
790  llvm::Value *endPtr =
791    Builder.CreateInBoundsGEP(beginPtr, numElements, "array.end");
792
793  // Create the continuation block.
794  llvm::BasicBlock *contBB = createBasicBlock("new.loop.end");
795
796  // If we need to check for zero, do so now.
797  if (checkZero) {
798    llvm::BasicBlock *nonEmptyBB = createBasicBlock("new.loop.nonempty");
799    llvm::Value *isEmpty = Builder.CreateICmpEQ(beginPtr, endPtr,
800                                                "array.isempty");
801    Builder.CreateCondBr(isEmpty, contBB, nonEmptyBB);
802    EmitBlock(nonEmptyBB);
803  }
804
805  // Enter the loop.
806  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
807  llvm::BasicBlock *loopBB = createBasicBlock("new.loop");
808
809  EmitBlock(loopBB);
810
811  // Set up the current-element phi.
812  llvm::PHINode *curPtr =
813    Builder.CreatePHI(beginPtr->getType(), 2, "array.cur");
814  curPtr->addIncoming(beginPtr, entryBB);
815
816  // Enter a partial-destruction cleanup if necessary.
817  QualType::DestructionKind dtorKind = elementType.isDestructedType();
818  EHScopeStack::stable_iterator cleanup;
819  llvm::Instruction *cleanupDominator = 0;
820  if (needsEHCleanup(dtorKind)) {
821    pushRegularPartialArrayCleanup(beginPtr, curPtr, elementType,
822                                   getDestroyer(dtorKind));
823    cleanup = EHStack.stable_begin();
824    cleanupDominator = Builder.CreateUnreachable();
825  }
826
827  // Emit the initializer into this element.
828  StoreAnyExprIntoOneUnit(*this, E, curPtr);
829
830  // Leave the cleanup if we entered one.
831  if (cleanup != EHStack.stable_end()) {
832    DeactivateCleanupBlock(cleanup, cleanupDominator);
833    cleanupDominator->eraseFromParent();
834  }
835
836  // Advance to the next element.
837  llvm::Value *nextPtr = Builder.CreateConstGEP1_32(curPtr, 1, "array.next");
838
839  // Check whether we've gotten to the end of the array and, if so,
840  // exit the loop.
841  llvm::Value *isEnd = Builder.CreateICmpEQ(nextPtr, endPtr, "array.atend");
842  Builder.CreateCondBr(isEnd, contBB, loopBB);
843  curPtr->addIncoming(nextPtr, Builder.GetInsertBlock());
844
845  EmitBlock(contBB);
846}
847
848static void EmitZeroMemSet(CodeGenFunction &CGF, QualType T,
849                           llvm::Value *NewPtr, llvm::Value *Size) {
850  CGF.EmitCastToVoidPtr(NewPtr);
851  CharUnits Alignment = CGF.getContext().getTypeAlignInChars(T);
852  CGF.Builder.CreateMemSet(NewPtr, CGF.Builder.getInt8(0), Size,
853                           Alignment.getQuantity(), false);
854}
855
856static void EmitNewInitializer(CodeGenFunction &CGF, const CXXNewExpr *E,
857                               QualType ElementType,
858                               llvm::Value *NewPtr,
859                               llvm::Value *NumElements,
860                               llvm::Value *AllocSizeWithoutCookie) {
861  if (E->isArray()) {
862    if (CXXConstructorDecl *Ctor = E->getConstructor()) {
863      bool RequiresZeroInitialization = false;
864      if (Ctor->getParent()->hasTrivialDefaultConstructor()) {
865        // If new expression did not specify value-initialization, then there
866        // is no initialization.
867        if (!E->hasInitializer() || Ctor->getParent()->isEmpty())
868          return;
869
870        if (CGF.CGM.getTypes().isZeroInitializable(ElementType)) {
871          // Optimization: since zero initialization will just set the memory
872          // to all zeroes, generate a single memset to do it in one shot.
873          EmitZeroMemSet(CGF, ElementType, NewPtr, AllocSizeWithoutCookie);
874          return;
875        }
876
877        RequiresZeroInitialization = true;
878      }
879
880      CGF.EmitCXXAggrConstructorCall(Ctor, NumElements, NewPtr,
881                                     E->constructor_arg_begin(),
882                                     E->constructor_arg_end(),
883                                     RequiresZeroInitialization);
884      return;
885    } else if (E->getNumConstructorArgs() == 1 &&
886               isa<ImplicitValueInitExpr>(E->getConstructorArg(0))) {
887      // Optimization: since zero initialization will just set the memory
888      // to all zeroes, generate a single memset to do it in one shot.
889      EmitZeroMemSet(CGF, ElementType, NewPtr, AllocSizeWithoutCookie);
890      return;
891    } else {
892      CGF.EmitNewArrayInitializer(E, ElementType, NewPtr, NumElements);
893      return;
894    }
895  }
896
897  if (CXXConstructorDecl *Ctor = E->getConstructor()) {
898    // Per C++ [expr.new]p15, if we have an initializer, then we're performing
899    // direct initialization. C++ [dcl.init]p5 requires that we
900    // zero-initialize storage if there are no user-declared constructors.
901    if (E->hasInitializer() &&
902        !Ctor->getParent()->hasUserDeclaredConstructor() &&
903        !Ctor->getParent()->isEmpty())
904      CGF.EmitNullInitialization(NewPtr, ElementType);
905
906    CGF.EmitCXXConstructorCall(Ctor, Ctor_Complete, /*ForVirtualBase=*/false,
907                               NewPtr, E->constructor_arg_begin(),
908                               E->constructor_arg_end());
909
910    return;
911  }
912  // We have a POD type.
913  if (E->getNumConstructorArgs() == 0)
914    return;
915
916  StoreAnyExprIntoOneUnit(CGF, E, NewPtr);
917}
918
919namespace {
920  /// A cleanup to call the given 'operator delete' function upon
921  /// abnormal exit from a new expression.
922  class CallDeleteDuringNew : public EHScopeStack::Cleanup {
923    size_t NumPlacementArgs;
924    const FunctionDecl *OperatorDelete;
925    llvm::Value *Ptr;
926    llvm::Value *AllocSize;
927
928    RValue *getPlacementArgs() { return reinterpret_cast<RValue*>(this+1); }
929
930  public:
931    static size_t getExtraSize(size_t NumPlacementArgs) {
932      return NumPlacementArgs * sizeof(RValue);
933    }
934
935    CallDeleteDuringNew(size_t NumPlacementArgs,
936                        const FunctionDecl *OperatorDelete,
937                        llvm::Value *Ptr,
938                        llvm::Value *AllocSize)
939      : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
940        Ptr(Ptr), AllocSize(AllocSize) {}
941
942    void setPlacementArg(unsigned I, RValue Arg) {
943      assert(I < NumPlacementArgs && "index out of range");
944      getPlacementArgs()[I] = Arg;
945    }
946
947    void Emit(CodeGenFunction &CGF, Flags flags) {
948      const FunctionProtoType *FPT
949        = OperatorDelete->getType()->getAs<FunctionProtoType>();
950      assert(FPT->getNumArgs() == NumPlacementArgs + 1 ||
951             (FPT->getNumArgs() == 2 && NumPlacementArgs == 0));
952
953      CallArgList DeleteArgs;
954
955      // The first argument is always a void*.
956      FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin();
957      DeleteArgs.add(RValue::get(Ptr), *AI++);
958
959      // A member 'operator delete' can take an extra 'size_t' argument.
960      if (FPT->getNumArgs() == NumPlacementArgs + 2)
961        DeleteArgs.add(RValue::get(AllocSize), *AI++);
962
963      // Pass the rest of the arguments, which must match exactly.
964      for (unsigned I = 0; I != NumPlacementArgs; ++I)
965        DeleteArgs.add(getPlacementArgs()[I], *AI++);
966
967      // Call 'operator delete'.
968      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT),
969                   CGF.CGM.GetAddrOfFunction(OperatorDelete),
970                   ReturnValueSlot(), DeleteArgs, OperatorDelete);
971    }
972  };
973
974  /// A cleanup to call the given 'operator delete' function upon
975  /// abnormal exit from a new expression when the new expression is
976  /// conditional.
977  class CallDeleteDuringConditionalNew : public EHScopeStack::Cleanup {
978    size_t NumPlacementArgs;
979    const FunctionDecl *OperatorDelete;
980    DominatingValue<RValue>::saved_type Ptr;
981    DominatingValue<RValue>::saved_type AllocSize;
982
983    DominatingValue<RValue>::saved_type *getPlacementArgs() {
984      return reinterpret_cast<DominatingValue<RValue>::saved_type*>(this+1);
985    }
986
987  public:
988    static size_t getExtraSize(size_t NumPlacementArgs) {
989      return NumPlacementArgs * sizeof(DominatingValue<RValue>::saved_type);
990    }
991
992    CallDeleteDuringConditionalNew(size_t NumPlacementArgs,
993                                   const FunctionDecl *OperatorDelete,
994                                   DominatingValue<RValue>::saved_type Ptr,
995                              DominatingValue<RValue>::saved_type AllocSize)
996      : NumPlacementArgs(NumPlacementArgs), OperatorDelete(OperatorDelete),
997        Ptr(Ptr), AllocSize(AllocSize) {}
998
999    void setPlacementArg(unsigned I, DominatingValue<RValue>::saved_type Arg) {
1000      assert(I < NumPlacementArgs && "index out of range");
1001      getPlacementArgs()[I] = Arg;
1002    }
1003
1004    void Emit(CodeGenFunction &CGF, Flags flags) {
1005      const FunctionProtoType *FPT
1006        = OperatorDelete->getType()->getAs<FunctionProtoType>();
1007      assert(FPT->getNumArgs() == NumPlacementArgs + 1 ||
1008             (FPT->getNumArgs() == 2 && NumPlacementArgs == 0));
1009
1010      CallArgList DeleteArgs;
1011
1012      // The first argument is always a void*.
1013      FunctionProtoType::arg_type_iterator AI = FPT->arg_type_begin();
1014      DeleteArgs.add(Ptr.restore(CGF), *AI++);
1015
1016      // A member 'operator delete' can take an extra 'size_t' argument.
1017      if (FPT->getNumArgs() == NumPlacementArgs + 2) {
1018        RValue RV = AllocSize.restore(CGF);
1019        DeleteArgs.add(RV, *AI++);
1020      }
1021
1022      // Pass the rest of the arguments, which must match exactly.
1023      for (unsigned I = 0; I != NumPlacementArgs; ++I) {
1024        RValue RV = getPlacementArgs()[I].restore(CGF);
1025        DeleteArgs.add(RV, *AI++);
1026      }
1027
1028      // Call 'operator delete'.
1029      CGF.EmitCall(CGF.CGM.getTypes().getFunctionInfo(DeleteArgs, FPT),
1030                   CGF.CGM.GetAddrOfFunction(OperatorDelete),
1031                   ReturnValueSlot(), DeleteArgs, OperatorDelete);
1032    }
1033  };
1034}
1035
1036/// Enter a cleanup to call 'operator delete' if the initializer in a
1037/// new-expression throws.
1038static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
1039                                  const CXXNewExpr *E,
1040                                  llvm::Value *NewPtr,
1041                                  llvm::Value *AllocSize,
1042                                  const CallArgList &NewArgs) {
1043  // If we're not inside a conditional branch, then the cleanup will
1044  // dominate and we can do the easier (and more efficient) thing.
1045  if (!CGF.isInConditionalBranch()) {
1046    CallDeleteDuringNew *Cleanup = CGF.EHStack
1047      .pushCleanupWithExtra<CallDeleteDuringNew>(EHCleanup,
1048                                                 E->getNumPlacementArgs(),
1049                                                 E->getOperatorDelete(),
1050                                                 NewPtr, AllocSize);
1051    for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1052      Cleanup->setPlacementArg(I, NewArgs[I+1].RV);
1053
1054    return;
1055  }
1056
1057  // Otherwise, we need to save all this stuff.
1058  DominatingValue<RValue>::saved_type SavedNewPtr =
1059    DominatingValue<RValue>::save(CGF, RValue::get(NewPtr));
1060  DominatingValue<RValue>::saved_type SavedAllocSize =
1061    DominatingValue<RValue>::save(CGF, RValue::get(AllocSize));
1062
1063  CallDeleteDuringConditionalNew *Cleanup = CGF.EHStack
1064    .pushCleanupWithExtra<CallDeleteDuringConditionalNew>(EHCleanup,
1065                                                 E->getNumPlacementArgs(),
1066                                                 E->getOperatorDelete(),
1067                                                 SavedNewPtr,
1068                                                 SavedAllocSize);
1069  for (unsigned I = 0, N = E->getNumPlacementArgs(); I != N; ++I)
1070    Cleanup->setPlacementArg(I,
1071                     DominatingValue<RValue>::save(CGF, NewArgs[I+1].RV));
1072
1073  CGF.initFullExprCleanup();
1074}
1075
1076llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
1077  // The element type being allocated.
1078  QualType allocType = getContext().getBaseElementType(E->getAllocatedType());
1079
1080  // 1. Build a call to the allocation function.
1081  FunctionDecl *allocator = E->getOperatorNew();
1082  const FunctionProtoType *allocatorType =
1083    allocator->getType()->castAs<FunctionProtoType>();
1084
1085  CallArgList allocatorArgs;
1086
1087  // The allocation size is the first argument.
1088  QualType sizeType = getContext().getSizeType();
1089
1090  llvm::Value *numElements = 0;
1091  llvm::Value *allocSizeWithoutCookie = 0;
1092  llvm::Value *allocSize =
1093    EmitCXXNewAllocSize(*this, E, numElements, allocSizeWithoutCookie);
1094
1095  allocatorArgs.add(RValue::get(allocSize), sizeType);
1096
1097  // Emit the rest of the arguments.
1098  // FIXME: Ideally, this should just use EmitCallArgs.
1099  CXXNewExpr::const_arg_iterator placementArg = E->placement_arg_begin();
1100
1101  // First, use the types from the function type.
1102  // We start at 1 here because the first argument (the allocation size)
1103  // has already been emitted.
1104  for (unsigned i = 1, e = allocatorType->getNumArgs(); i != e;
1105       ++i, ++placementArg) {
1106    QualType argType = allocatorType->getArgType(i);
1107
1108    assert(getContext().hasSameUnqualifiedType(argType.getNonReferenceType(),
1109                                               placementArg->getType()) &&
1110           "type mismatch in call argument!");
1111
1112    EmitCallArg(allocatorArgs, *placementArg, argType);
1113  }
1114
1115  // Either we've emitted all the call args, or we have a call to a
1116  // variadic function.
1117  assert((placementArg == E->placement_arg_end() ||
1118          allocatorType->isVariadic()) &&
1119         "Extra arguments to non-variadic function!");
1120
1121  // If we still have any arguments, emit them using the type of the argument.
1122  for (CXXNewExpr::const_arg_iterator placementArgsEnd = E->placement_arg_end();
1123       placementArg != placementArgsEnd; ++placementArg) {
1124    EmitCallArg(allocatorArgs, *placementArg, placementArg->getType());
1125  }
1126
1127  // Emit the allocation call.  If the allocator is a global placement
1128  // operator, just "inline" it directly.
1129  RValue RV;
1130  if (allocator->isReservedGlobalPlacementOperator()) {
1131    assert(allocatorArgs.size() == 2);
1132    RV = allocatorArgs[1].RV;
1133    // TODO: kill any unnecessary computations done for the size
1134    // argument.
1135  } else {
1136    RV = EmitCall(CGM.getTypes().getFunctionInfo(allocatorArgs, allocatorType),
1137                  CGM.GetAddrOfFunction(allocator), ReturnValueSlot(),
1138                  allocatorArgs, allocator);
1139  }
1140
1141  // Emit a null check on the allocation result if the allocation
1142  // function is allowed to return null (because it has a non-throwing
1143  // exception spec; for this part, we inline
1144  // CXXNewExpr::shouldNullCheckAllocation()) and we have an
1145  // interesting initializer.
1146  bool nullCheck = allocatorType->isNothrow(getContext()) &&
1147    !(allocType.isPODType(getContext()) && !E->hasInitializer());
1148
1149  llvm::BasicBlock *nullCheckBB = 0;
1150  llvm::BasicBlock *contBB = 0;
1151
1152  llvm::Value *allocation = RV.getScalarVal();
1153  unsigned AS =
1154    cast<llvm::PointerType>(allocation->getType())->getAddressSpace();
1155
1156  // The null-check means that the initializer is conditionally
1157  // evaluated.
1158  ConditionalEvaluation conditional(*this);
1159
1160  if (nullCheck) {
1161    conditional.begin(*this);
1162
1163    nullCheckBB = Builder.GetInsertBlock();
1164    llvm::BasicBlock *notNullBB = createBasicBlock("new.notnull");
1165    contBB = createBasicBlock("new.cont");
1166
1167    llvm::Value *isNull = Builder.CreateIsNull(allocation, "new.isnull");
1168    Builder.CreateCondBr(isNull, contBB, notNullBB);
1169    EmitBlock(notNullBB);
1170  }
1171
1172  // If there's an operator delete, enter a cleanup to call it if an
1173  // exception is thrown.
1174  EHScopeStack::stable_iterator operatorDeleteCleanup;
1175  llvm::Instruction *cleanupDominator = 0;
1176  if (E->getOperatorDelete() &&
1177      !E->getOperatorDelete()->isReservedGlobalPlacementOperator()) {
1178    EnterNewDeleteCleanup(*this, E, allocation, allocSize, allocatorArgs);
1179    operatorDeleteCleanup = EHStack.stable_begin();
1180    cleanupDominator = Builder.CreateUnreachable();
1181  }
1182
1183  assert((allocSize == allocSizeWithoutCookie) ==
1184         CalculateCookiePadding(*this, E).isZero());
1185  if (allocSize != allocSizeWithoutCookie) {
1186    assert(E->isArray());
1187    allocation = CGM.getCXXABI().InitializeArrayCookie(*this, allocation,
1188                                                       numElements,
1189                                                       E, allocType);
1190  }
1191
1192  llvm::Type *elementPtrTy
1193    = ConvertTypeForMem(allocType)->getPointerTo(AS);
1194  llvm::Value *result = Builder.CreateBitCast(allocation, elementPtrTy);
1195
1196  EmitNewInitializer(*this, E, allocType, result, numElements,
1197                     allocSizeWithoutCookie);
1198  if (E->isArray()) {
1199    // NewPtr is a pointer to the base element type.  If we're
1200    // allocating an array of arrays, we'll need to cast back to the
1201    // array pointer type.
1202    llvm::Type *resultType = ConvertTypeForMem(E->getType());
1203    if (result->getType() != resultType)
1204      result = Builder.CreateBitCast(result, resultType);
1205  }
1206
1207  // Deactivate the 'operator delete' cleanup if we finished
1208  // initialization.
1209  if (operatorDeleteCleanup.isValid()) {
1210    DeactivateCleanupBlock(operatorDeleteCleanup, cleanupDominator);
1211    cleanupDominator->eraseFromParent();
1212  }
1213
1214  if (nullCheck) {
1215    conditional.end(*this);
1216
1217    llvm::BasicBlock *notNullBB = Builder.GetInsertBlock();
1218    EmitBlock(contBB);
1219
1220    llvm::PHINode *PHI = Builder.CreatePHI(result->getType(), 2);
1221    PHI->addIncoming(result, notNullBB);
1222    PHI->addIncoming(llvm::Constant::getNullValue(result->getType()),
1223                     nullCheckBB);
1224
1225    result = PHI;
1226  }
1227
1228  return result;
1229}
1230
1231void CodeGenFunction::EmitDeleteCall(const FunctionDecl *DeleteFD,
1232                                     llvm::Value *Ptr,
1233                                     QualType DeleteTy) {
1234  assert(DeleteFD->getOverloadedOperator() == OO_Delete);
1235
1236  const FunctionProtoType *DeleteFTy =
1237    DeleteFD->getType()->getAs<FunctionProtoType>();
1238
1239  CallArgList DeleteArgs;
1240
1241  // Check if we need to pass the size to the delete operator.
1242  llvm::Value *Size = 0;
1243  QualType SizeTy;
1244  if (DeleteFTy->getNumArgs() == 2) {
1245    SizeTy = DeleteFTy->getArgType(1);
1246    CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1247    Size = llvm::ConstantInt::get(ConvertType(SizeTy),
1248                                  DeleteTypeSize.getQuantity());
1249  }
1250
1251  QualType ArgTy = DeleteFTy->getArgType(0);
1252  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
1253  DeleteArgs.add(RValue::get(DeletePtr), ArgTy);
1254
1255  if (Size)
1256    DeleteArgs.add(RValue::get(Size), SizeTy);
1257
1258  // Emit the call to delete.
1259  EmitCall(CGM.getTypes().getFunctionInfo(DeleteArgs, DeleteFTy),
1260           CGM.GetAddrOfFunction(DeleteFD), ReturnValueSlot(),
1261           DeleteArgs, DeleteFD);
1262}
1263
1264namespace {
1265  /// Calls the given 'operator delete' on a single object.
1266  struct CallObjectDelete : EHScopeStack::Cleanup {
1267    llvm::Value *Ptr;
1268    const FunctionDecl *OperatorDelete;
1269    QualType ElementType;
1270
1271    CallObjectDelete(llvm::Value *Ptr,
1272                     const FunctionDecl *OperatorDelete,
1273                     QualType ElementType)
1274      : Ptr(Ptr), OperatorDelete(OperatorDelete), ElementType(ElementType) {}
1275
1276    void Emit(CodeGenFunction &CGF, Flags flags) {
1277      CGF.EmitDeleteCall(OperatorDelete, Ptr, ElementType);
1278    }
1279  };
1280}
1281
1282/// Emit the code for deleting a single object.
1283static void EmitObjectDelete(CodeGenFunction &CGF,
1284                             const FunctionDecl *OperatorDelete,
1285                             llvm::Value *Ptr,
1286                             QualType ElementType,
1287                             bool UseGlobalDelete) {
1288  // Find the destructor for the type, if applicable.  If the
1289  // destructor is virtual, we'll just emit the vcall and return.
1290  const CXXDestructorDecl *Dtor = 0;
1291  if (const RecordType *RT = ElementType->getAs<RecordType>()) {
1292    CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1293    if (RD->hasDefinition() && !RD->hasTrivialDestructor()) {
1294      Dtor = RD->getDestructor();
1295
1296      if (Dtor->isVirtual()) {
1297        if (UseGlobalDelete) {
1298          // If we're supposed to call the global delete, make sure we do so
1299          // even if the destructor throws.
1300          CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1301                                                    Ptr, OperatorDelete,
1302                                                    ElementType);
1303        }
1304
1305        llvm::Type *Ty =
1306          CGF.getTypes().GetFunctionType(CGF.getTypes().getFunctionInfo(Dtor,
1307                                                               Dtor_Complete),
1308                                         /*isVariadic=*/false);
1309
1310        llvm::Value *Callee
1311          = CGF.BuildVirtualCall(Dtor,
1312                                 UseGlobalDelete? Dtor_Complete : Dtor_Deleting,
1313                                 Ptr, Ty);
1314        CGF.EmitCXXMemberCall(Dtor, Callee, ReturnValueSlot(), Ptr, /*VTT=*/0,
1315                              0, 0);
1316
1317        if (UseGlobalDelete) {
1318          CGF.PopCleanupBlock();
1319        }
1320
1321        return;
1322      }
1323    }
1324  }
1325
1326  // Make sure that we call delete even if the dtor throws.
1327  // This doesn't have to a conditional cleanup because we're going
1328  // to pop it off in a second.
1329  CGF.EHStack.pushCleanup<CallObjectDelete>(NormalAndEHCleanup,
1330                                            Ptr, OperatorDelete, ElementType);
1331
1332  if (Dtor)
1333    CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
1334                              /*ForVirtualBase=*/false, Ptr);
1335  else if (CGF.getLangOptions().ObjCAutoRefCount &&
1336           ElementType->isObjCLifetimeType()) {
1337    switch (ElementType.getObjCLifetime()) {
1338    case Qualifiers::OCL_None:
1339    case Qualifiers::OCL_ExplicitNone:
1340    case Qualifiers::OCL_Autoreleasing:
1341      break;
1342
1343    case Qualifiers::OCL_Strong: {
1344      // Load the pointer value.
1345      llvm::Value *PtrValue = CGF.Builder.CreateLoad(Ptr,
1346                                             ElementType.isVolatileQualified());
1347
1348      CGF.EmitARCRelease(PtrValue, /*precise*/ true);
1349      break;
1350    }
1351
1352    case Qualifiers::OCL_Weak:
1353      CGF.EmitARCDestroyWeak(Ptr);
1354      break;
1355    }
1356  }
1357
1358  CGF.PopCleanupBlock();
1359}
1360
1361namespace {
1362  /// Calls the given 'operator delete' on an array of objects.
1363  struct CallArrayDelete : EHScopeStack::Cleanup {
1364    llvm::Value *Ptr;
1365    const FunctionDecl *OperatorDelete;
1366    llvm::Value *NumElements;
1367    QualType ElementType;
1368    CharUnits CookieSize;
1369
1370    CallArrayDelete(llvm::Value *Ptr,
1371                    const FunctionDecl *OperatorDelete,
1372                    llvm::Value *NumElements,
1373                    QualType ElementType,
1374                    CharUnits CookieSize)
1375      : Ptr(Ptr), OperatorDelete(OperatorDelete), NumElements(NumElements),
1376        ElementType(ElementType), CookieSize(CookieSize) {}
1377
1378    void Emit(CodeGenFunction &CGF, Flags flags) {
1379      const FunctionProtoType *DeleteFTy =
1380        OperatorDelete->getType()->getAs<FunctionProtoType>();
1381      assert(DeleteFTy->getNumArgs() == 1 || DeleteFTy->getNumArgs() == 2);
1382
1383      CallArgList Args;
1384
1385      // Pass the pointer as the first argument.
1386      QualType VoidPtrTy = DeleteFTy->getArgType(0);
1387      llvm::Value *DeletePtr
1388        = CGF.Builder.CreateBitCast(Ptr, CGF.ConvertType(VoidPtrTy));
1389      Args.add(RValue::get(DeletePtr), VoidPtrTy);
1390
1391      // Pass the original requested size as the second argument.
1392      if (DeleteFTy->getNumArgs() == 2) {
1393        QualType size_t = DeleteFTy->getArgType(1);
1394        llvm::IntegerType *SizeTy
1395          = cast<llvm::IntegerType>(CGF.ConvertType(size_t));
1396
1397        CharUnits ElementTypeSize =
1398          CGF.CGM.getContext().getTypeSizeInChars(ElementType);
1399
1400        // The size of an element, multiplied by the number of elements.
1401        llvm::Value *Size
1402          = llvm::ConstantInt::get(SizeTy, ElementTypeSize.getQuantity());
1403        Size = CGF.Builder.CreateMul(Size, NumElements);
1404
1405        // Plus the size of the cookie if applicable.
1406        if (!CookieSize.isZero()) {
1407          llvm::Value *CookieSizeV
1408            = llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity());
1409          Size = CGF.Builder.CreateAdd(Size, CookieSizeV);
1410        }
1411
1412        Args.add(RValue::get(Size), size_t);
1413      }
1414
1415      // Emit the call to delete.
1416      CGF.EmitCall(CGF.getTypes().getFunctionInfo(Args, DeleteFTy),
1417                   CGF.CGM.GetAddrOfFunction(OperatorDelete),
1418                   ReturnValueSlot(), Args, OperatorDelete);
1419    }
1420  };
1421}
1422
1423/// Emit the code for deleting an array of objects.
1424static void EmitArrayDelete(CodeGenFunction &CGF,
1425                            const CXXDeleteExpr *E,
1426                            llvm::Value *deletedPtr,
1427                            QualType elementType) {
1428  llvm::Value *numElements = 0;
1429  llvm::Value *allocatedPtr = 0;
1430  CharUnits cookieSize;
1431  CGF.CGM.getCXXABI().ReadArrayCookie(CGF, deletedPtr, E, elementType,
1432                                      numElements, allocatedPtr, cookieSize);
1433
1434  assert(allocatedPtr && "ReadArrayCookie didn't set allocated pointer");
1435
1436  // Make sure that we call delete even if one of the dtors throws.
1437  const FunctionDecl *operatorDelete = E->getOperatorDelete();
1438  CGF.EHStack.pushCleanup<CallArrayDelete>(NormalAndEHCleanup,
1439                                           allocatedPtr, operatorDelete,
1440                                           numElements, elementType,
1441                                           cookieSize);
1442
1443  // Destroy the elements.
1444  if (QualType::DestructionKind dtorKind = elementType.isDestructedType()) {
1445    assert(numElements && "no element count for a type with a destructor!");
1446
1447    llvm::Value *arrayEnd =
1448      CGF.Builder.CreateInBoundsGEP(deletedPtr, numElements, "delete.end");
1449
1450    // Note that it is legal to allocate a zero-length array, and we
1451    // can never fold the check away because the length should always
1452    // come from a cookie.
1453    CGF.emitArrayDestroy(deletedPtr, arrayEnd, elementType,
1454                         CGF.getDestroyer(dtorKind),
1455                         /*checkZeroLength*/ true,
1456                         CGF.needsEHCleanup(dtorKind));
1457  }
1458
1459  // Pop the cleanup block.
1460  CGF.PopCleanupBlock();
1461}
1462
1463void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
1464
1465  // Get at the argument before we performed the implicit conversion
1466  // to void*.
1467  const Expr *Arg = E->getArgument();
1468  while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(Arg)) {
1469    if (ICE->getCastKind() != CK_UserDefinedConversion &&
1470        ICE->getType()->isVoidPointerType())
1471      Arg = ICE->getSubExpr();
1472    else
1473      break;
1474  }
1475
1476  llvm::Value *Ptr = EmitScalarExpr(Arg);
1477
1478  // Null check the pointer.
1479  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
1480  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
1481
1482  llvm::Value *IsNull = Builder.CreateIsNull(Ptr, "isnull");
1483
1484  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
1485  EmitBlock(DeleteNotNull);
1486
1487  // We might be deleting a pointer to array.  If so, GEP down to the
1488  // first non-array element.
1489  // (this assumes that A(*)[3][7] is converted to [3 x [7 x %A]]*)
1490  QualType DeleteTy = Arg->getType()->getAs<PointerType>()->getPointeeType();
1491  if (DeleteTy->isConstantArrayType()) {
1492    llvm::Value *Zero = Builder.getInt32(0);
1493    SmallVector<llvm::Value*,8> GEP;
1494
1495    GEP.push_back(Zero); // point at the outermost array
1496
1497    // For each layer of array type we're pointing at:
1498    while (const ConstantArrayType *Arr
1499             = getContext().getAsConstantArrayType(DeleteTy)) {
1500      // 1. Unpeel the array type.
1501      DeleteTy = Arr->getElementType();
1502
1503      // 2. GEP to the first element of the array.
1504      GEP.push_back(Zero);
1505    }
1506
1507    Ptr = Builder.CreateInBoundsGEP(Ptr, GEP, "del.first");
1508  }
1509
1510  assert(ConvertTypeForMem(DeleteTy) ==
1511         cast<llvm::PointerType>(Ptr->getType())->getElementType());
1512
1513  if (E->isArrayForm()) {
1514    EmitArrayDelete(*this, E, Ptr, DeleteTy);
1515  } else {
1516    EmitObjectDelete(*this, E->getOperatorDelete(), Ptr, DeleteTy,
1517                     E->isGlobalDelete());
1518  }
1519
1520  EmitBlock(DeleteEnd);
1521}
1522
1523static llvm::Constant *getBadTypeidFn(CodeGenFunction &CGF) {
1524  // void __cxa_bad_typeid();
1525
1526  llvm::Type *VoidTy = llvm::Type::getVoidTy(CGF.getLLVMContext());
1527  llvm::FunctionType *FTy =
1528  llvm::FunctionType::get(VoidTy, false);
1529
1530  return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_typeid");
1531}
1532
1533static void EmitBadTypeidCall(CodeGenFunction &CGF) {
1534  llvm::Value *Fn = getBadTypeidFn(CGF);
1535  CGF.EmitCallOrInvoke(Fn).setDoesNotReturn();
1536  CGF.Builder.CreateUnreachable();
1537}
1538
1539static llvm::Value *EmitTypeidFromVTable(CodeGenFunction &CGF,
1540                                         const Expr *E,
1541                                         llvm::Type *StdTypeInfoPtrTy) {
1542  // Get the vtable pointer.
1543  llvm::Value *ThisPtr = CGF.EmitLValue(E).getAddress();
1544
1545  // C++ [expr.typeid]p2:
1546  //   If the glvalue expression is obtained by applying the unary * operator to
1547  //   a pointer and the pointer is a null pointer value, the typeid expression
1548  //   throws the std::bad_typeid exception.
1549  if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParens())) {
1550    if (UO->getOpcode() == UO_Deref) {
1551      llvm::BasicBlock *BadTypeidBlock =
1552        CGF.createBasicBlock("typeid.bad_typeid");
1553      llvm::BasicBlock *EndBlock =
1554        CGF.createBasicBlock("typeid.end");
1555
1556      llvm::Value *IsNull = CGF.Builder.CreateIsNull(ThisPtr);
1557      CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
1558
1559      CGF.EmitBlock(BadTypeidBlock);
1560      EmitBadTypeidCall(CGF);
1561      CGF.EmitBlock(EndBlock);
1562    }
1563  }
1564
1565  llvm::Value *Value = CGF.GetVTablePtr(ThisPtr,
1566                                        StdTypeInfoPtrTy->getPointerTo());
1567
1568  // Load the type info.
1569  Value = CGF.Builder.CreateConstInBoundsGEP1_64(Value, -1ULL);
1570  return CGF.Builder.CreateLoad(Value);
1571}
1572
1573llvm::Value *CodeGenFunction::EmitCXXTypeidExpr(const CXXTypeidExpr *E) {
1574  llvm::Type *StdTypeInfoPtrTy =
1575    ConvertType(E->getType())->getPointerTo();
1576
1577  if (E->isTypeOperand()) {
1578    llvm::Constant *TypeInfo =
1579      CGM.GetAddrOfRTTIDescriptor(E->getTypeOperand());
1580    return Builder.CreateBitCast(TypeInfo, StdTypeInfoPtrTy);
1581  }
1582
1583  // C++ [expr.typeid]p2:
1584  //   When typeid is applied to a glvalue expression whose type is a
1585  //   polymorphic class type, the result refers to a std::type_info object
1586  //   representing the type of the most derived object (that is, the dynamic
1587  //   type) to which the glvalue refers.
1588  if (E->getExprOperand()->isGLValue()) {
1589    if (const RecordType *RT =
1590          E->getExprOperand()->getType()->getAs<RecordType>()) {
1591      const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1592      if (RD->isPolymorphic())
1593        return EmitTypeidFromVTable(*this, E->getExprOperand(),
1594                                    StdTypeInfoPtrTy);
1595    }
1596  }
1597
1598  QualType OperandTy = E->getExprOperand()->getType();
1599  return Builder.CreateBitCast(CGM.GetAddrOfRTTIDescriptor(OperandTy),
1600                               StdTypeInfoPtrTy);
1601}
1602
1603static llvm::Constant *getDynamicCastFn(CodeGenFunction &CGF) {
1604  // void *__dynamic_cast(const void *sub,
1605  //                      const abi::__class_type_info *src,
1606  //                      const abi::__class_type_info *dst,
1607  //                      std::ptrdiff_t src2dst_offset);
1608
1609  llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
1610  llvm::Type *PtrDiffTy =
1611    CGF.ConvertType(CGF.getContext().getPointerDiffType());
1612
1613  llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
1614
1615  llvm::FunctionType *FTy =
1616    llvm::FunctionType::get(Int8PtrTy, Args, false);
1617
1618  return CGF.CGM.CreateRuntimeFunction(FTy, "__dynamic_cast");
1619}
1620
1621static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) {
1622  // void __cxa_bad_cast();
1623
1624  llvm::Type *VoidTy = llvm::Type::getVoidTy(CGF.getLLVMContext());
1625  llvm::FunctionType *FTy =
1626    llvm::FunctionType::get(VoidTy, false);
1627
1628  return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast");
1629}
1630
1631static void EmitBadCastCall(CodeGenFunction &CGF) {
1632  llvm::Value *Fn = getBadCastFn(CGF);
1633  CGF.EmitCallOrInvoke(Fn).setDoesNotReturn();
1634  CGF.Builder.CreateUnreachable();
1635}
1636
1637static llvm::Value *
1638EmitDynamicCastCall(CodeGenFunction &CGF, llvm::Value *Value,
1639                    QualType SrcTy, QualType DestTy,
1640                    llvm::BasicBlock *CastEnd) {
1641  llvm::Type *PtrDiffLTy =
1642    CGF.ConvertType(CGF.getContext().getPointerDiffType());
1643  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1644
1645  if (const PointerType *PTy = DestTy->getAs<PointerType>()) {
1646    if (PTy->getPointeeType()->isVoidType()) {
1647      // C++ [expr.dynamic.cast]p7:
1648      //   If T is "pointer to cv void," then the result is a pointer to the
1649      //   most derived object pointed to by v.
1650
1651      // Get the vtable pointer.
1652      llvm::Value *VTable = CGF.GetVTablePtr(Value, PtrDiffLTy->getPointerTo());
1653
1654      // Get the offset-to-top from the vtable.
1655      llvm::Value *OffsetToTop =
1656        CGF.Builder.CreateConstInBoundsGEP1_64(VTable, -2ULL);
1657      OffsetToTop = CGF.Builder.CreateLoad(OffsetToTop, "offset.to.top");
1658
1659      // Finally, add the offset to the pointer.
1660      Value = CGF.EmitCastToVoidPtr(Value);
1661      Value = CGF.Builder.CreateInBoundsGEP(Value, OffsetToTop);
1662
1663      return CGF.Builder.CreateBitCast(Value, DestLTy);
1664    }
1665  }
1666
1667  QualType SrcRecordTy;
1668  QualType DestRecordTy;
1669
1670  if (const PointerType *DestPTy = DestTy->getAs<PointerType>()) {
1671    SrcRecordTy = SrcTy->castAs<PointerType>()->getPointeeType();
1672    DestRecordTy = DestPTy->getPointeeType();
1673  } else {
1674    SrcRecordTy = SrcTy;
1675    DestRecordTy = DestTy->castAs<ReferenceType>()->getPointeeType();
1676  }
1677
1678  assert(SrcRecordTy->isRecordType() && "source type must be a record type!");
1679  assert(DestRecordTy->isRecordType() && "dest type must be a record type!");
1680
1681  llvm::Value *SrcRTTI =
1682    CGF.CGM.GetAddrOfRTTIDescriptor(SrcRecordTy.getUnqualifiedType());
1683  llvm::Value *DestRTTI =
1684    CGF.CGM.GetAddrOfRTTIDescriptor(DestRecordTy.getUnqualifiedType());
1685
1686  // FIXME: Actually compute a hint here.
1687  llvm::Value *OffsetHint = llvm::ConstantInt::get(PtrDiffLTy, -1ULL);
1688
1689  // Emit the call to __dynamic_cast.
1690  Value = CGF.EmitCastToVoidPtr(Value);
1691  Value = CGF.Builder.CreateCall4(getDynamicCastFn(CGF), Value,
1692                                  SrcRTTI, DestRTTI, OffsetHint);
1693  Value = CGF.Builder.CreateBitCast(Value, DestLTy);
1694
1695  /// C++ [expr.dynamic.cast]p9:
1696  ///   A failed cast to reference type throws std::bad_cast
1697  if (DestTy->isReferenceType()) {
1698    llvm::BasicBlock *BadCastBlock =
1699      CGF.createBasicBlock("dynamic_cast.bad_cast");
1700
1701    llvm::Value *IsNull = CGF.Builder.CreateIsNull(Value);
1702    CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
1703
1704    CGF.EmitBlock(BadCastBlock);
1705    EmitBadCastCall(CGF);
1706  }
1707
1708  return Value;
1709}
1710
1711static llvm::Value *EmitDynamicCastToNull(CodeGenFunction &CGF,
1712                                          QualType DestTy) {
1713  llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1714  if (DestTy->isPointerType())
1715    return llvm::Constant::getNullValue(DestLTy);
1716
1717  /// C++ [expr.dynamic.cast]p9:
1718  ///   A failed cast to reference type throws std::bad_cast
1719  EmitBadCastCall(CGF);
1720
1721  CGF.EmitBlock(CGF.createBasicBlock("dynamic_cast.end"));
1722  return llvm::UndefValue::get(DestLTy);
1723}
1724
1725llvm::Value *CodeGenFunction::EmitDynamicCast(llvm::Value *Value,
1726                                              const CXXDynamicCastExpr *DCE) {
1727  QualType DestTy = DCE->getTypeAsWritten();
1728
1729  if (DCE->isAlwaysNull())
1730    return EmitDynamicCastToNull(*this, DestTy);
1731
1732  QualType SrcTy = DCE->getSubExpr()->getType();
1733
1734  // C++ [expr.dynamic.cast]p4:
1735  //   If the value of v is a null pointer value in the pointer case, the result
1736  //   is the null pointer value of type T.
1737  bool ShouldNullCheckSrcValue = SrcTy->isPointerType();
1738
1739  llvm::BasicBlock *CastNull = 0;
1740  llvm::BasicBlock *CastNotNull = 0;
1741  llvm::BasicBlock *CastEnd = createBasicBlock("dynamic_cast.end");
1742
1743  if (ShouldNullCheckSrcValue) {
1744    CastNull = createBasicBlock("dynamic_cast.null");
1745    CastNotNull = createBasicBlock("dynamic_cast.notnull");
1746
1747    llvm::Value *IsNull = Builder.CreateIsNull(Value);
1748    Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
1749    EmitBlock(CastNotNull);
1750  }
1751
1752  Value = EmitDynamicCastCall(*this, Value, SrcTy, DestTy, CastEnd);
1753
1754  if (ShouldNullCheckSrcValue) {
1755    EmitBranch(CastEnd);
1756
1757    EmitBlock(CastNull);
1758    EmitBranch(CastEnd);
1759  }
1760
1761  EmitBlock(CastEnd);
1762
1763  if (ShouldNullCheckSrcValue) {
1764    llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
1765    PHI->addIncoming(Value, CastNotNull);
1766    PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()), CastNull);
1767
1768    Value = PHI;
1769  }
1770
1771  return Value;
1772}
1773