contrib/llvm/tools/clang/lib/CodeGen/CGClass.cpp

   1 //===--- CGClass.cpp - Emit LLVM Code for C++ classes ---------------------===//
   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 C++ code generation of classes
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CGDebugInfo.h"
  15 #include "CodeGenFunction.h"
  16 #include "clang/AST/CXXInheritance.h"
  17 #include "clang/AST/EvaluatedExprVisitor.h"
  18 #include "clang/AST/RecordLayout.h"
  19 #include "clang/AST/StmtCXX.h"
  20 #include "clang/Frontend/CodeGenOptions.h"
  21
  22 using namespace clang;
  23 using namespace CodeGen;
  24
  25 static CharUnits
  26 ComputeNonVirtualBaseClassOffset(ASTContext &Context,
  27                                  const CXXRecordDecl *DerivedClass,
  28                                  CastExpr::path_const_iterator Start,
  29                                  CastExpr::path_const_iterator End) {
  30   CharUnits Offset = CharUnits::Zero();
  31
  32   const CXXRecordDecl *RD = DerivedClass;
  33
  34   for (CastExpr::path_const_iterator I = Start; I != End; ++I) {
  35     const CXXBaseSpecifier *Base = *I;
  36     assert(!Base->isVirtual() && "Should not see virtual bases here!");
  37
  38     // Get the layout.
  39     const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
  40
  41     const CXXRecordDecl *BaseDecl =
  42       cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
  43
  44     // Add the offset.
  45     Offset += Layout.getBaseClassOffset(BaseDecl);
  46
  47     RD = BaseDecl;
  48   }
  49
  50   return Offset;
  51 }
  52
  53 llvm::Constant *
  54 CodeGenModule::GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,
  55                                    CastExpr::path_const_iterator PathBegin,
  56                                    CastExpr::path_const_iterator PathEnd) {
  57   assert(PathBegin != PathEnd && "Base path should not be empty!");
  58
  59   CharUnits Offset =
  60     ComputeNonVirtualBaseClassOffset(getContext(), ClassDecl,
  61                                      PathBegin, PathEnd);
  62   if (Offset.isZero())
  63     return 0;
  64
  65   const llvm::Type *PtrDiffTy =
  66   Types.ConvertType(getContext().getPointerDiffType());
  67
  68   return llvm::ConstantInt::get(PtrDiffTy, Offset.getQuantity());
  69 }
  70
  71 /// Gets the address of a direct base class within a complete object.
  72 /// This should only be used for (1) non-virtual bases or (2) virtual bases
  73 /// when the type is known to be complete (e.g. in complete destructors).
  74 ///
  75 /// The object pointed to by 'This' is assumed to be non-null.
  76 llvm::Value *
  77 CodeGenFunction::GetAddressOfDirectBaseInCompleteClass(llvm::Value *This,
  78                                                    const CXXRecordDecl *Derived,
  79                                                    const CXXRecordDecl *Base,
  80                                                    bool BaseIsVirtual) {
  81   // 'this' must be a pointer (in some address space) to Derived.
  82   assert(This->getType()->isPointerTy() &&
  83          cast<llvm::PointerType>(This->getType())->getElementType()
  84            == ConvertType(Derived));
  85
  86   // Compute the offset of the virtual base.
  87   CharUnits Offset;
  88   const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived);
  89   if (BaseIsVirtual)
  90     Offset = Layout.getVBaseClassOffset(Base);
  91   else
  92     Offset = Layout.getBaseClassOffset(Base);
  93
  94   // Shift and cast down to the base type.
  95   // TODO: for complete types, this should be possible with a GEP.
  96   llvm::Value *V = This;
  97   if (Offset.isPositive()) {
  98     const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext());
  99     V = Builder.CreateBitCast(V, Int8PtrTy);
 100     V = Builder.CreateConstInBoundsGEP1_64(V, Offset.getQuantity());
 101   }
 102   V = Builder.CreateBitCast(V, ConvertType(Base)->getPointerTo());
 103
 104   return V;
 105 }
 106
 107 static llvm::Value *
 108 ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, llvm::Value *ThisPtr,
 109                                 CharUnits NonVirtual, llvm::Value *Virtual) {
 110   const llvm::Type *PtrDiffTy =
 111     CGF.ConvertType(CGF.getContext().getPointerDiffType());
 112
 113   llvm::Value *NonVirtualOffset = 0;
 114   if (!NonVirtual.isZero())
 115     NonVirtualOffset = llvm::ConstantInt::get(PtrDiffTy,
 116                                               NonVirtual.getQuantity());
 117
 118   llvm::Value *BaseOffset;
 119   if (Virtual) {
 120     if (NonVirtualOffset)
 121       BaseOffset = CGF.Builder.CreateAdd(Virtual, NonVirtualOffset);
 122     else
 123       BaseOffset = Virtual;
 124   } else
 125     BaseOffset = NonVirtualOffset;
 126
 127   // Apply the base offset.
 128   const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
 129   ThisPtr = CGF.Builder.CreateBitCast(ThisPtr, Int8PtrTy);
 130   ThisPtr = CGF.Builder.CreateGEP(ThisPtr, BaseOffset, "add.ptr");
 131
 132   return ThisPtr;
 133 }
 134
 135 llvm::Value *
 136 CodeGenFunction::GetAddressOfBaseClass(llvm::Value *Value,
 137                                        const CXXRecordDecl *Derived,
 138                                        CastExpr::path_const_iterator PathBegin,
 139                                        CastExpr::path_const_iterator PathEnd,
 140                                        bool NullCheckValue) {
 141   assert(PathBegin != PathEnd && "Base path should not be empty!");
 142
 143   CastExpr::path_const_iterator Start = PathBegin;
 144   const CXXRecordDecl *VBase = 0;
 145
 146   // Get the virtual base.
 147   if ((*Start)->isVirtual()) {
 148     VBase =
 149       cast<CXXRecordDecl>((*Start)->getType()->getAs<RecordType>()->getDecl());
 150     ++Start;
 151   }
 152
 153   CharUnits NonVirtualOffset =
 154     ComputeNonVirtualBaseClassOffset(getContext(), VBase ? VBase : Derived,
 155                                      Start, PathEnd);
 156
 157   // Get the base pointer type.
 158   const llvm::Type *BasePtrTy =
 159     ConvertType((PathEnd[-1])->getType())->getPointerTo();
 160
 161   if (NonVirtualOffset.isZero() && !VBase) {
 162     // Just cast back.
 163     return Builder.CreateBitCast(Value, BasePtrTy);
 164   }
 165
 166   llvm::BasicBlock *CastNull = 0;
 167   llvm::BasicBlock *CastNotNull = 0;
 168   llvm::BasicBlock *CastEnd = 0;
 169
 170   if (NullCheckValue) {
 171     CastNull = createBasicBlock("cast.null");
 172     CastNotNull = createBasicBlock("cast.notnull");
 173     CastEnd = createBasicBlock("cast.end");
 174
 175     llvm::Value *IsNull = Builder.CreateIsNull(Value);
 176     Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
 177     EmitBlock(CastNotNull);
 178   }
 179
 180   llvm::Value *VirtualOffset = 0;
 181
 182   if (VBase) {
 183     if (Derived->hasAttr<FinalAttr>()) {
 184       VirtualOffset = 0;
 185
 186       const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived);
 187
 188       CharUnits VBaseOffset = Layout.getVBaseClassOffset(VBase);
 189       NonVirtualOffset += VBaseOffset;
 190     } else
 191       VirtualOffset = GetVirtualBaseClassOffset(Value, Derived, VBase);
 192   }
 193
 194   // Apply the offsets.
 195   Value = ApplyNonVirtualAndVirtualOffset(*this, Value,
 196                                           NonVirtualOffset,
 197                                           VirtualOffset);
 198
 199   // Cast back.
 200   Value = Builder.CreateBitCast(Value, BasePtrTy);
 201
 202   if (NullCheckValue) {
 203     Builder.CreateBr(CastEnd);
 204     EmitBlock(CastNull);
 205     Builder.CreateBr(CastEnd);
 206     EmitBlock(CastEnd);
 207
 208     llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
 209     PHI->addIncoming(Value, CastNotNull);
 210     PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()),
 211                      CastNull);
 212     Value = PHI;
 213   }
 214
 215   return Value;
 216 }
 217
 218 llvm::Value *
 219 CodeGenFunction::GetAddressOfDerivedClass(llvm::Value *Value,
 220                                           const CXXRecordDecl *Derived,
 221                                         CastExpr::path_const_iterator PathBegin,
 222                                           CastExpr::path_const_iterator PathEnd,
 223                                           bool NullCheckValue) {
 224   assert(PathBegin != PathEnd && "Base path should not be empty!");
 225
 226   QualType DerivedTy =
 227     getContext().getCanonicalType(getContext().getTagDeclType(Derived));
 228   const llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo();
 229
 230   llvm::Value *NonVirtualOffset =
 231     CGM.GetNonVirtualBaseClassOffset(Derived, PathBegin, PathEnd);
 232
 233   if (!NonVirtualOffset) {
 234     // No offset, we can just cast back.
 235     return Builder.CreateBitCast(Value, DerivedPtrTy);
 236   }
 237
 238   llvm::BasicBlock *CastNull = 0;
 239   llvm::BasicBlock *CastNotNull = 0;
 240   llvm::BasicBlock *CastEnd = 0;
 241
 242   if (NullCheckValue) {
 243     CastNull = createBasicBlock("cast.null");
 244     CastNotNull = createBasicBlock("cast.notnull");
 245     CastEnd = createBasicBlock("cast.end");
 246
 247     llvm::Value *IsNull = Builder.CreateIsNull(Value);
 248     Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
 249     EmitBlock(CastNotNull);
 250   }
 251
 252   // Apply the offset.
 253   Value = Builder.CreatePtrToInt(Value, NonVirtualOffset->getType());
 254   Value = Builder.CreateSub(Value, NonVirtualOffset);
 255   Value = Builder.CreateIntToPtr(Value, DerivedPtrTy);
 256
 257   // Just cast.
 258   Value = Builder.CreateBitCast(Value, DerivedPtrTy);
 259
 260   if (NullCheckValue) {
 261     Builder.CreateBr(CastEnd);
 262     EmitBlock(CastNull);
 263     Builder.CreateBr(CastEnd);
 264     EmitBlock(CastEnd);
 265
 266     llvm::PHINode *PHI = Builder.CreatePHI(Value->getType(), 2);
 267     PHI->addIncoming(Value, CastNotNull);
 268     PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()),
 269                      CastNull);
 270     Value = PHI;
 271   }
 272
 273   return Value;
 274 }
 275
 276 /// GetVTTParameter - Return the VTT parameter that should be passed to a
 277 /// base constructor/destructor with virtual bases.
 278 static llvm::Value *GetVTTParameter(CodeGenFunction &CGF, GlobalDecl GD,
 279                                     bool ForVirtualBase) {
 280   if (!CodeGenVTables::needsVTTParameter(GD)) {
 281     // This constructor/destructor does not need a VTT parameter.
 282     return 0;
 283   }
 284
 285   const CXXRecordDecl *RD = cast<CXXMethodDecl>(CGF.CurFuncDecl)->getParent();
 286   const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent();
 287
 288   llvm::Value *VTT;
 289
 290   uint64_t SubVTTIndex;
 291
 292   // If the record matches the base, this is the complete ctor/dtor
 293   // variant calling the base variant in a class with virtual bases.
 294   if (RD == Base) {
 295     assert(!CodeGenVTables::needsVTTParameter(CGF.CurGD) &&
 296            "doing no-op VTT offset in base dtor/ctor?");
 297     assert(!ForVirtualBase && "Can't have same class as virtual base!");
 298     SubVTTIndex = 0;
 299   } else {
 300     const ASTRecordLayout &Layout =
 301       CGF.getContext().getASTRecordLayout(RD);
 302     CharUnits BaseOffset = ForVirtualBase ?
 303       Layout.getVBaseClassOffset(Base) :
 304       Layout.getBaseClassOffset(Base);
 305
 306     SubVTTIndex =
 307       CGF.CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset));
 308     assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!");
 309   }
 310
 311   if (CodeGenVTables::needsVTTParameter(CGF.CurGD)) {
 312     // A VTT parameter was passed to the constructor, use it.
 313     VTT = CGF.LoadCXXVTT();
 314     VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex);
 315   } else {
 316     // We're the complete constructor, so get the VTT by name.
 317     VTT = CGF.CGM.getVTables().GetAddrOfVTT(RD);
 318     VTT = CGF.Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex);
 319   }
 320
 321   return VTT;
 322 }
 323
 324 namespace {
 325   /// Call the destructor for a direct base class.
 326   struct CallBaseDtor : EHScopeStack::Cleanup {
 327     const CXXRecordDecl *BaseClass;
 328     bool BaseIsVirtual;
 329     CallBaseDtor(const CXXRecordDecl *Base, bool BaseIsVirtual)
 330       : BaseClass(Base), BaseIsVirtual(BaseIsVirtual) {}
 331
 332     void Emit(CodeGenFunction &CGF, Flags flags) {
 333       const CXXRecordDecl *DerivedClass =
 334         cast<CXXMethodDecl>(CGF.CurCodeDecl)->getParent();
 335
 336       const CXXDestructorDecl *D = BaseClass->getDestructor();
 337       llvm::Value *Addr =
 338         CGF.GetAddressOfDirectBaseInCompleteClass(CGF.LoadCXXThis(),
 339                                                   DerivedClass, BaseClass,
 340                                                   BaseIsVirtual);
 341       CGF.EmitCXXDestructorCall(D, Dtor_Base, BaseIsVirtual, Addr);
 342     }
 343   };
 344
 345   /// A visitor which checks whether an initializer uses 'this' in a
 346   /// way which requires the vtable to be properly set.
 347   struct DynamicThisUseChecker : EvaluatedExprVisitor<DynamicThisUseChecker> {
 348     typedef EvaluatedExprVisitor<DynamicThisUseChecker> super;
 349
 350     bool UsesThis;
 351
 352     DynamicThisUseChecker(ASTContext &C) : super(C), UsesThis(false) {}
 353
 354     // Black-list all explicit and implicit references to 'this'.
 355     //
 356     // Do we need to worry about external references to 'this' derived
 357     // from arbitrary code?  If so, then anything which runs arbitrary
 358     // external code might potentially access the vtable.
 359     void VisitCXXThisExpr(CXXThisExpr *E) { UsesThis = true; }
 360   };
 361 }
 362
 363 static bool BaseInitializerUsesThis(ASTContext &C, const Expr *Init) {
 364   DynamicThisUseChecker Checker(C);
 365   Checker.Visit(const_cast<Expr*>(Init));
 366   return Checker.UsesThis;
 367 }
 368
 369 static void EmitBaseInitializer(CodeGenFunction &CGF,
 370                                 const CXXRecordDecl *ClassDecl,
 371                                 CXXCtorInitializer *BaseInit,
 372                                 CXXCtorType CtorType) {
 373   assert(BaseInit->isBaseInitializer() &&
 374          "Must have base initializer!");
 375
 376   llvm::Value *ThisPtr = CGF.LoadCXXThis();
 377
 378   const Type *BaseType = BaseInit->getBaseClass();
 379   CXXRecordDecl *BaseClassDecl =
 380     cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
 381
 382   bool isBaseVirtual = BaseInit->isBaseVirtual();
 383
 384   // The base constructor doesn't construct virtual bases.
 385   if (CtorType == Ctor_Base && isBaseVirtual)
 386     return;
 387
 388   // If the initializer for the base (other than the constructor
 389   // itself) accesses 'this' in any way, we need to initialize the
 390   // vtables.
 391   if (BaseInitializerUsesThis(CGF.getContext(), BaseInit->getInit()))
 392     CGF.InitializeVTablePointers(ClassDecl);
 393
 394   // We can pretend to be a complete class because it only matters for
 395   // virtual bases, and we only do virtual bases for complete ctors.
 396   llvm::Value *V =
 397     CGF.GetAddressOfDirectBaseInCompleteClass(ThisPtr, ClassDecl,
 398                                               BaseClassDecl,
 399                                               isBaseVirtual);
 400
 401   AggValueSlot AggSlot = AggValueSlot::forAddr(V, Qualifiers(),
 402                                                /*Lifetime*/ true);
 403
 404   CGF.EmitAggExpr(BaseInit->getInit(), AggSlot);
 405
 406   if (CGF.CGM.getLangOptions().Exceptions &&
 407       !BaseClassDecl->hasTrivialDestructor())
 408     CGF.EHStack.pushCleanup<CallBaseDtor>(EHCleanup, BaseClassDecl,
 409                                           isBaseVirtual);
 410 }
 411
 412 static void EmitAggMemberInitializer(CodeGenFunction &CGF,
 413                                      LValue LHS,
 414                                      llvm::Value *ArrayIndexVar,
 415                                      CXXCtorInitializer *MemberInit,
 416                                      QualType T,
 417                                      unsigned Index) {
 418   if (Index == MemberInit->getNumArrayIndices()) {
 419     CodeGenFunction::RunCleanupsScope Cleanups(CGF);
 420
 421     llvm::Value *Dest = LHS.getAddress();
 422     if (ArrayIndexVar) {
 423       // If we have an array index variable, load it and use it as an offset.
 424       // Then, increment the value.
 425       llvm::Value *ArrayIndex = CGF.Builder.CreateLoad(ArrayIndexVar);
 426       Dest = CGF.Builder.CreateInBoundsGEP(Dest, ArrayIndex, "destaddress");
 427       llvm::Value *Next = llvm::ConstantInt::get(ArrayIndex->getType(), 1);
 428       Next = CGF.Builder.CreateAdd(ArrayIndex, Next, "inc");
 429       CGF.Builder.CreateStore(Next, ArrayIndexVar);
 430     }
 431
 432     if (!CGF.hasAggregateLLVMType(T)) {
 433       LValue lvalue = CGF.MakeAddrLValue(Dest, T);
 434       CGF.EmitScalarInit(MemberInit->getInit(), /*decl*/ 0, lvalue, false);
 435     } else if (T->isAnyComplexType()) {
 436       CGF.EmitComplexExprIntoAddr(MemberInit->getInit(), Dest,
 437                                   LHS.isVolatileQualified());
 438     } else {
 439       AggValueSlot Slot = AggValueSlot::forAddr(Dest, LHS.getQuals(),
 440                                                 /*Lifetime*/ true);
 441
 442       CGF.EmitAggExpr(MemberInit->getInit(), Slot);
 443     }
 444
 445     return;
 446   }
 447
 448   const ConstantArrayType *Array = CGF.getContext().getAsConstantArrayType(T);
 449   assert(Array && "Array initialization without the array type?");
 450   llvm::Value *IndexVar
 451     = CGF.GetAddrOfLocalVar(MemberInit->getArrayIndex(Index));
 452   assert(IndexVar && "Array index variable not loaded");
 453
 454   // Initialize this index variable to zero.
 455   llvm::Value* Zero
 456     = llvm::Constant::getNullValue(
 457                               CGF.ConvertType(CGF.getContext().getSizeType()));
 458   CGF.Builder.CreateStore(Zero, IndexVar);
 459
 460   // Start the loop with a block that tests the condition.
 461   llvm::BasicBlock *CondBlock = CGF.createBasicBlock("for.cond");
 462   llvm::BasicBlock *AfterFor = CGF.createBasicBlock("for.end");
 463
 464   CGF.EmitBlock(CondBlock);
 465
 466   llvm::BasicBlock *ForBody = CGF.createBasicBlock("for.body");
 467   // Generate: if (loop-index < number-of-elements) fall to the loop body,
 468   // otherwise, go to the block after the for-loop.
 469   uint64_t NumElements = Array->getSize().getZExtValue();
 470   llvm::Value *Counter = CGF.Builder.CreateLoad(IndexVar);
 471   llvm::Value *NumElementsPtr =
 472     llvm::ConstantInt::get(Counter->getType(), NumElements);
 473   llvm::Value *IsLess = CGF.Builder.CreateICmpULT(Counter, NumElementsPtr,
 474                                                   "isless");
 475
 476   // If the condition is true, execute the body.
 477   CGF.Builder.CreateCondBr(IsLess, ForBody, AfterFor);
 478
 479   CGF.EmitBlock(ForBody);
 480   llvm::BasicBlock *ContinueBlock = CGF.createBasicBlock("for.inc");
 481
 482   {
 483     CodeGenFunction::RunCleanupsScope Cleanups(CGF);
 484
 485     // Inside the loop body recurse to emit the inner loop or, eventually, the
 486     // constructor call.
 487     EmitAggMemberInitializer(CGF, LHS, ArrayIndexVar, MemberInit,
 488                              Array->getElementType(), Index + 1);
 489   }
 490
 491   CGF.EmitBlock(ContinueBlock);
 492
 493   // Emit the increment of the loop counter.
 494   llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
 495   Counter = CGF.Builder.CreateLoad(IndexVar);
 496   NextVal = CGF.Builder.CreateAdd(Counter, NextVal, "inc");
 497   CGF.Builder.CreateStore(NextVal, IndexVar);
 498
 499   // Finally, branch back up to the condition for the next iteration.
 500   CGF.EmitBranch(CondBlock);
 501
 502   // Emit the fall-through block.
 503   CGF.EmitBlock(AfterFor, true);
 504 }
 505
 506 namespace {
 507   struct CallMemberDtor : EHScopeStack::Cleanup {
 508     FieldDecl *Field;
 509     CXXDestructorDecl *Dtor;
 510
 511     CallMemberDtor(FieldDecl *Field, CXXDestructorDecl *Dtor)
 512       : Field(Field), Dtor(Dtor) {}
 513
 514     void Emit(CodeGenFunction &CGF, Flags flags) {
 515       // FIXME: Is this OK for C++0x delegating constructors?
 516       llvm::Value *ThisPtr = CGF.LoadCXXThis();
 517       LValue LHS = CGF.EmitLValueForField(ThisPtr, Field, 0);
 518
 519       CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
 520                                 LHS.getAddress());
 521     }
 522   };
 523 }
 524
 525 static void EmitMemberInitializer(CodeGenFunction &CGF,
 526                                   const CXXRecordDecl *ClassDecl,
 527                                   CXXCtorInitializer *MemberInit,
 528                                   const CXXConstructorDecl *Constructor,
 529                                   FunctionArgList &Args) {
 530   assert(MemberInit->isAnyMemberInitializer() &&
 531          "Must have member initializer!");
 532   assert(MemberInit->getInit() && "Must have initializer!");
 533
 534   // non-static data member initializers.
 535   FieldDecl *Field = MemberInit->getAnyMember();
 536   QualType FieldType = CGF.getContext().getCanonicalType(Field->getType());
 537
 538   llvm::Value *ThisPtr = CGF.LoadCXXThis();
 539   LValue LHS;
 540
 541   // If we are initializing an anonymous union field, drill down to the field.
 542   if (MemberInit->isIndirectMemberInitializer()) {
 543     LHS = CGF.EmitLValueForAnonRecordField(ThisPtr,
 544                                            MemberInit->getIndirectMember(), 0);
 545     FieldType = MemberInit->getIndirectMember()->getAnonField()->getType();
 546   } else {
 547     LHS = CGF.EmitLValueForFieldInitialization(ThisPtr, Field, 0);
 548   }
 549
 550   // FIXME: If there's no initializer and the CXXCtorInitializer
 551   // was implicitly generated, we shouldn't be zeroing memory.
 552   if (FieldType->isArrayType() && !MemberInit->getInit()) {
 553     CGF.EmitNullInitialization(LHS.getAddress(), Field->getType());
 554   } else if (!CGF.hasAggregateLLVMType(Field->getType())) {
 555     if (LHS.isSimple()) {
 556       CGF.EmitExprAsInit(MemberInit->getInit(), Field, LHS, false);
 557     } else {
 558       RValue RHS = RValue::get(CGF.EmitScalarExpr(MemberInit->getInit()));
 559       CGF.EmitStoreThroughLValue(RHS, LHS);
 560     }
 561   } else if (MemberInit->getInit()->getType()->isAnyComplexType()) {
 562     CGF.EmitComplexExprIntoAddr(MemberInit->getInit(), LHS.getAddress(),
 563                                 LHS.isVolatileQualified());
 564   } else {
 565     llvm::Value *ArrayIndexVar = 0;
 566     const ConstantArrayType *Array
 567       = CGF.getContext().getAsConstantArrayType(FieldType);
 568     if (Array && Constructor->isImplicit() &&
 569         Constructor->isCopyConstructor()) {
 570       const llvm::Type *SizeTy
 571         = CGF.ConvertType(CGF.getContext().getSizeType());
 572
 573       // The LHS is a pointer to the first object we'll be constructing, as
 574       // a flat array.
 575       QualType BaseElementTy = CGF.getContext().getBaseElementType(Array);
 576       const llvm::Type *BasePtr = CGF.ConvertType(BaseElementTy);
 577       BasePtr = llvm::PointerType::getUnqual(BasePtr);
 578       llvm::Value *BaseAddrPtr = CGF.Builder.CreateBitCast(LHS.getAddress(),
 579                                                            BasePtr);
 580       LHS = CGF.MakeAddrLValue(BaseAddrPtr, BaseElementTy);
 581
 582       // Create an array index that will be used to walk over all of the
 583       // objects we're constructing.
 584       ArrayIndexVar = CGF.CreateTempAlloca(SizeTy, "object.index");
 585       llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
 586       CGF.Builder.CreateStore(Zero, ArrayIndexVar);
 587
 588       // If we are copying an array of PODs or classes with trivial copy
 589       // constructors, perform a single aggregate copy.
 590       const CXXRecordDecl *Record = BaseElementTy->getAsCXXRecordDecl();
 591       if (BaseElementTy.isPODType(CGF.getContext()) ||
 592           (Record && Record->hasTrivialCopyConstructor())) {
 593         // Find the source pointer. We knows it's the last argument because
 594         // we know we're in a copy constructor.
 595         unsigned SrcArgIndex = Args.size() - 1;
 596         llvm::Value *SrcPtr
 597           = CGF.Builder.CreateLoad(CGF.GetAddrOfLocalVar(Args[SrcArgIndex]));
 598         LValue Src = CGF.EmitLValueForFieldInitialization(SrcPtr, Field, 0);
 599
 600         // Copy the aggregate.
 601         CGF.EmitAggregateCopy(LHS.getAddress(), Src.getAddress(), FieldType,
 602                               LHS.isVolatileQualified());
 603         return;
 604       }
 605
 606       // Emit the block variables for the array indices, if any.
 607       for (unsigned I = 0, N = MemberInit->getNumArrayIndices(); I != N; ++I)
 608         CGF.EmitAutoVarDecl(*MemberInit->getArrayIndex(I));
 609     }
 610
 611     EmitAggMemberInitializer(CGF, LHS, ArrayIndexVar, MemberInit, FieldType, 0);
 612
 613     if (!CGF.CGM.getLangOptions().Exceptions)
 614       return;
 615
 616     // FIXME: If we have an array of classes w/ non-trivial destructors,
 617     // we need to destroy in reverse order of construction along the exception
 618     // path.
 619     const RecordType *RT = FieldType->getAs<RecordType>();
 620     if (!RT)
 621       return;
 622
 623     CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
 624     if (!RD->hasTrivialDestructor())
 625       CGF.EHStack.pushCleanup<CallMemberDtor>(EHCleanup, Field,
 626                                               RD->getDestructor());
 627   }
 628 }
 629
 630 /// Checks whether the given constructor is a valid subject for the
 631 /// complete-to-base constructor delegation optimization, i.e.
 632 /// emitting the complete constructor as a simple call to the base
 633 /// constructor.
 634 static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor) {
 635
 636   // Currently we disable the optimization for classes with virtual
 637   // bases because (1) the addresses of parameter variables need to be
 638   // consistent across all initializers but (2) the delegate function
 639   // call necessarily creates a second copy of the parameter variable.
 640   //
 641   // The limiting example (purely theoretical AFAIK):
 642   //   struct A { A(int &c) { c++; } };
 643   //   struct B : virtual A {
 644   //     B(int count) : A(count) { printf("%d\n", count); }
 645   //   };
 646   // ...although even this example could in principle be emitted as a
 647   // delegation since the address of the parameter doesn't escape.
 648   if (Ctor->getParent()->getNumVBases()) {
 649     // TODO: white-list trivial vbase initializers.  This case wouldn't
 650     // be subject to the restrictions below.
 651
 652     // TODO: white-list cases where:
 653     //  - there are no non-reference parameters to the constructor
 654     //  - the initializers don't access any non-reference parameters
 655     //  - the initializers don't take the address of non-reference
 656     //    parameters
 657     //  - etc.
 658     // If we ever add any of the above cases, remember that:
 659     //  - function-try-blocks will always blacklist this optimization
 660     //  - we need to perform the constructor prologue and cleanup in
 661     //    EmitConstructorBody.
 662
 663     return false;
 664   }
 665
 666   // We also disable the optimization for variadic functions because
 667   // it's impossible to "re-pass" varargs.
 668   if (Ctor->getType()->getAs<FunctionProtoType>()->isVariadic())
 669     return false;
 670
 671   // FIXME: Decide if we can do a delegation of a delegating constructor.
 672   if (Ctor->isDelegatingConstructor())
 673     return false;
 674
 675   return true;
 676 }
 677
 678 /// EmitConstructorBody - Emits the body of the current constructor.
 679 void CodeGenFunction::EmitConstructorBody(FunctionArgList &Args) {
 680   const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(CurGD.getDecl());
 681   CXXCtorType CtorType = CurGD.getCtorType();
 682
 683   // Before we go any further, try the complete->base constructor
 684   // delegation optimization.
 685   if (CtorType == Ctor_Complete && IsConstructorDelegationValid(Ctor)) {
 686     if (CGDebugInfo *DI = getDebugInfo())
 687       DI->EmitStopPoint(Builder);
 688     EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args);
 689     return;
 690   }
 691
 692   Stmt *Body = Ctor->getBody();
 693
 694   // Enter the function-try-block before the constructor prologue if
 695   // applicable.
 696   bool IsTryBody = (Body && isa<CXXTryStmt>(Body));
 697   if (IsTryBody)
 698     EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);
 699
 700   EHScopeStack::stable_iterator CleanupDepth = EHStack.stable_begin();
 701
 702   // Emit the constructor prologue, i.e. the base and member
 703   // initializers.
 704   EmitCtorPrologue(Ctor, CtorType, Args);
 705
 706   // Emit the body of the statement.
 707   if (IsTryBody)
 708     EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
 709   else if (Body)
 710     EmitStmt(Body);
 711
 712   // Emit any cleanup blocks associated with the member or base
 713   // initializers, which includes (along the exceptional path) the
 714   // destructors for those members and bases that were fully
 715   // constructed.
 716   PopCleanupBlocks(CleanupDepth);
 717
 718   if (IsTryBody)
 719     ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);
 720 }
 721
 722 /// EmitCtorPrologue - This routine generates necessary code to initialize
 723 /// base classes and non-static data members belonging to this constructor.
 724 void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD,
 725                                        CXXCtorType CtorType,
 726                                        FunctionArgList &Args) {
 727   if (CD->isDelegatingConstructor())
 728     return EmitDelegatingCXXConstructorCall(CD, Args);
 729
 730   const CXXRecordDecl *ClassDecl = CD->getParent();
 731
 732   llvm::SmallVector<CXXCtorInitializer *, 8> MemberInitializers;
 733
 734   for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
 735        E = CD->init_end();
 736        B != E; ++B) {
 737     CXXCtorInitializer *Member = (*B);
 738
 739     if (Member->isBaseInitializer()) {
 740       EmitBaseInitializer(*this, ClassDecl, Member, CtorType);
 741     } else {
 742       assert(Member->isAnyMemberInitializer() &&
 743             "Delegating initializer on non-delegating constructor");
 744       MemberInitializers.push_back(Member);
 745     }
 746   }
 747
 748   InitializeVTablePointers(ClassDecl);
 749
 750   for (unsigned I = 0, E = MemberInitializers.size(); I != E; ++I)
 751     EmitMemberInitializer(*this, ClassDecl, MemberInitializers[I], CD, Args);
 752 }
 753
 754 static bool
 755 FieldHasTrivialDestructorBody(ASTContext &Context, const FieldDecl *Field);
 756
 757 static bool
 758 HasTrivialDestructorBody(ASTContext &Context,
 759                          const CXXRecordDecl *BaseClassDecl,
 760                          const CXXRecordDecl *MostDerivedClassDecl)
 761 {
 762   // If the destructor is trivial we don't have to check anything else.
 763   if (BaseClassDecl->hasTrivialDestructor())
 764     return true;
 765
 766   if (!BaseClassDecl->getDestructor()->hasTrivialBody())
 767     return false;
 768
 769   // Check fields.
 770   for (CXXRecordDecl::field_iterator I = BaseClassDecl->field_begin(),
 771        E = BaseClassDecl->field_end(); I != E; ++I) {
 772     const FieldDecl *Field = *I;
 773
 774     if (!FieldHasTrivialDestructorBody(Context, Field))
 775       return false;
 776   }
 777
 778   // Check non-virtual bases.
 779   for (CXXRecordDecl::base_class_const_iterator I =
 780        BaseClassDecl->bases_begin(), E = BaseClassDecl->bases_end();
 781        I != E; ++I) {
 782     if (I->isVirtual())
 783       continue;
 784
 785     const CXXRecordDecl *NonVirtualBase =
 786       cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
 787     if (!HasTrivialDestructorBody(Context, NonVirtualBase,
 788                                   MostDerivedClassDecl))
 789       return false;
 790   }
 791
 792   if (BaseClassDecl == MostDerivedClassDecl) {
 793     // Check virtual bases.
 794     for (CXXRecordDecl::base_class_const_iterator I =
 795          BaseClassDecl->vbases_begin(), E = BaseClassDecl->vbases_end();
 796          I != E; ++I) {
 797       const CXXRecordDecl *VirtualBase =
 798         cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
 799       if (!HasTrivialDestructorBody(Context, VirtualBase,
 800                                     MostDerivedClassDecl))
 801         return false;
 802     }
 803   }
 804
 805   return true;
 806 }
 807
 808 static bool
 809 FieldHasTrivialDestructorBody(ASTContext &Context,
 810                               const FieldDecl *Field)
 811 {
 812   QualType FieldBaseElementType = Context.getBaseElementType(Field->getType());
 813
 814   const RecordType *RT = FieldBaseElementType->getAs<RecordType>();
 815   if (!RT)
 816     return true;
 817
 818   CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
 819   return HasTrivialDestructorBody(Context, FieldClassDecl, FieldClassDecl);
 820 }
 821
 822 /// CanSkipVTablePointerInitialization - Check whether we need to initialize
 823 /// any vtable pointers before calling this destructor.
 824 static bool CanSkipVTablePointerInitialization(ASTContext &Context,
 825                                                const CXXDestructorDecl *Dtor) {
 826   if (!Dtor->hasTrivialBody())
 827     return false;
 828
 829   // Check the fields.
 830   const CXXRecordDecl *ClassDecl = Dtor->getParent();
 831   for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
 832        E = ClassDecl->field_end(); I != E; ++I) {
 833     const FieldDecl *Field = *I;
 834
 835     if (!FieldHasTrivialDestructorBody(Context, Field))
 836       return false;
 837   }
 838
 839   return true;
 840 }
 841
 842 /// EmitDestructorBody - Emits the body of the current destructor.
 843 void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
 844   const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CurGD.getDecl());
 845   CXXDtorType DtorType = CurGD.getDtorType();
 846
 847   // The call to operator delete in a deleting destructor happens
 848   // outside of the function-try-block, which means it's always
 849   // possible to delegate the destructor body to the complete
 850   // destructor.  Do so.
 851   if (DtorType == Dtor_Deleting) {
 852     EnterDtorCleanups(Dtor, Dtor_Deleting);
 853     EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
 854                           LoadCXXThis());
 855     PopCleanupBlock();
 856     return;
 857   }
 858
 859   Stmt *Body = Dtor->getBody();
 860
 861   // If the body is a function-try-block, enter the try before
 862   // anything else.
 863   bool isTryBody = (Body && isa<CXXTryStmt>(Body));
 864   if (isTryBody)
 865     EnterCXXTryStmt(*cast<CXXTryStmt>(Body), true);
 866
 867   // Enter the epilogue cleanups.
 868   RunCleanupsScope DtorEpilogue(*this);
 869
 870   // If this is the complete variant, just invoke the base variant;
 871   // the epilogue will destruct the virtual bases.  But we can't do
 872   // this optimization if the body is a function-try-block, because
 873   // we'd introduce *two* handler blocks.
 874   switch (DtorType) {
 875   case Dtor_Deleting: llvm_unreachable("already handled deleting case");
 876
 877   case Dtor_Complete:
 878     // Enter the cleanup scopes for virtual bases.
 879     EnterDtorCleanups(Dtor, Dtor_Complete);
 880
 881     if (!isTryBody) {
 882       EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false,
 883                             LoadCXXThis());
 884       break;
 885     }
 886     // Fallthrough: act like we're in the base variant.
 887
 888   case Dtor_Base:
 889     // Enter the cleanup scopes for fields and non-virtual bases.
 890     EnterDtorCleanups(Dtor, Dtor_Base);
 891
 892     // Initialize the vtable pointers before entering the body.
 893     if (!CanSkipVTablePointerInitialization(getContext(), Dtor))
 894         InitializeVTablePointers(Dtor->getParent());
 895
 896     if (isTryBody)
 897       EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
 898     else if (Body)
 899       EmitStmt(Body);
 900     else {
 901       assert(Dtor->isImplicit() && "bodyless dtor not implicit");
 902       // nothing to do besides what's in the epilogue
 903     }
 904     // -fapple-kext must inline any call to this dtor into
 905     // the caller's body.
 906     if (getContext().getLangOptions().AppleKext)
 907       CurFn->addFnAttr(llvm::Attribute::AlwaysInline);
 908     break;
 909   }
 910
 911   // Jump out through the epilogue cleanups.
 912   DtorEpilogue.ForceCleanup();
 913
 914   // Exit the try if applicable.
 915   if (isTryBody)
 916     ExitCXXTryStmt(*cast<CXXTryStmt>(Body), true);
 917 }
 918
 919 namespace {
 920   /// Call the operator delete associated with the current destructor.
 921   struct CallDtorDelete : EHScopeStack::Cleanup {
 922     CallDtorDelete() {}
 923
 924     void Emit(CodeGenFunction &CGF, Flags flags) {
 925       const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CGF.CurCodeDecl);
 926       const CXXRecordDecl *ClassDecl = Dtor->getParent();
 927       CGF.EmitDeleteCall(Dtor->getOperatorDelete(), CGF.LoadCXXThis(),
 928                          CGF.getContext().getTagDeclType(ClassDecl));
 929     }
 930   };
 931
 932   class DestroyField  : public EHScopeStack::Cleanup {
 933     const FieldDecl *field;
 934     CodeGenFunction::Destroyer &destroyer;
 935     bool useEHCleanupForArray;
 936
 937   public:
 938     DestroyField(const FieldDecl *field, CodeGenFunction::Destroyer *destroyer,
 939                  bool useEHCleanupForArray)
 940       : field(field), destroyer(*destroyer),
 941         useEHCleanupForArray(useEHCleanupForArray) {}
 942
 943     void Emit(CodeGenFunction &CGF, Flags flags) {
 944       // Find the address of the field.
 945       llvm::Value *thisValue = CGF.LoadCXXThis();
 946       LValue LV = CGF.EmitLValueForField(thisValue, field, /*CVRQualifiers=*/0);
 947       assert(LV.isSimple());
 948
 949       CGF.emitDestroy(LV.getAddress(), field->getType(), destroyer,
 950                       flags.isForNormalCleanup() && useEHCleanupForArray);
 951     }
 952   };
 953 }
 954
 955 /// EmitDtorEpilogue - Emit all code that comes at the end of class's
 956 /// destructor. This is to call destructors on members and base classes
 957 /// in reverse order of their construction.
 958 void CodeGenFunction::EnterDtorCleanups(const CXXDestructorDecl *DD,
 959                                         CXXDtorType DtorType) {
 960   assert(!DD->isTrivial() &&
 961          "Should not emit dtor epilogue for trivial dtor!");
 962
 963   // The deleting-destructor phase just needs to call the appropriate
 964   // operator delete that Sema picked up.
 965   if (DtorType == Dtor_Deleting) {
 966     assert(DD->getOperatorDelete() &&
 967            "operator delete missing - EmitDtorEpilogue");
 968     EHStack.pushCleanup<CallDtorDelete>(NormalAndEHCleanup);
 969     return;
 970   }
 971
 972   const CXXRecordDecl *ClassDecl = DD->getParent();
 973
 974   // The complete-destructor phase just destructs all the virtual bases.
 975   if (DtorType == Dtor_Complete) {
 976
 977     // We push them in the forward order so that they'll be popped in
 978     // the reverse order.
 979     for (CXXRecordDecl::base_class_const_iterator I =
 980            ClassDecl->vbases_begin(), E = ClassDecl->vbases_end();
 981               I != E; ++I) {
 982       const CXXBaseSpecifier &Base = *I;
 983       CXXRecordDecl *BaseClassDecl
 984         = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
 985
 986       // Ignore trivial destructors.
 987       if (BaseClassDecl->hasTrivialDestructor())
 988         continue;
 989
 990       EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup,
 991                                         BaseClassDecl,
 992                                         /*BaseIsVirtual*/ true);
 993     }
 994
 995     return;
 996   }
 997
 998   assert(DtorType == Dtor_Base);
 999
1000   // Destroy non-virtual bases.
1001   for (CXXRecordDecl::base_class_const_iterator I =
1002         ClassDecl->bases_begin(), E = ClassDecl->bases_end(); I != E; ++I) {
1003     const CXXBaseSpecifier &Base = *I;
1004
1005     // Ignore virtual bases.
1006     if (Base.isVirtual())
1007       continue;
1008
1009     CXXRecordDecl *BaseClassDecl = Base.getType()->getAsCXXRecordDecl();
1010
1011     // Ignore trivial destructors.
1012     if (BaseClassDecl->hasTrivialDestructor())
1013       continue;
1014
1015     EHStack.pushCleanup<CallBaseDtor>(NormalAndEHCleanup,
1016                                       BaseClassDecl,
1017                                       /*BaseIsVirtual*/ false);
1018   }
1019
1020   // Destroy direct fields.
1021   llvm::SmallVector<const FieldDecl *, 16> FieldDecls;
1022   for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
1023        E = ClassDecl->field_end(); I != E; ++I) {
1024     const FieldDecl *field = *I;
1025     QualType type = field->getType();
1026     QualType::DestructionKind dtorKind = type.isDestructedType();
1027     if (!dtorKind) continue;
1028
1029     CleanupKind cleanupKind = getCleanupKind(dtorKind);
1030     EHStack.pushCleanup<DestroyField>(cleanupKind, field,
1031                                       getDestroyer(dtorKind),
1032                                       cleanupKind & EHCleanup);
1033   }
1034 }
1035
1036 /// EmitCXXAggrConstructorCall - Emit a loop to call a particular
1037 /// constructor for each of several members of an array.
1038 ///
1039 /// \param ctor the constructor to call for each element
1040 /// \param argBegin,argEnd the arguments to evaluate and pass to the
1041 ///   constructor
1042 /// \param arrayType the type of the array to initialize
1043 /// \param arrayBegin an arrayType*
1044 /// \param zeroInitialize true if each element should be
1045 ///   zero-initialized before it is constructed
1046 void
1047 CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor,
1048                                             const ConstantArrayType *arrayType,
1049                                             llvm::Value *arrayBegin,
1050                                           CallExpr::const_arg_iterator argBegin,
1051                                             CallExpr::const_arg_iterator argEnd,
1052                                             bool zeroInitialize) {
1053   QualType elementType;
1054   llvm::Value *numElements =
1055     emitArrayLength(arrayType, elementType, arrayBegin);
1056
1057   EmitCXXAggrConstructorCall(ctor, numElements, arrayBegin,
1058                              argBegin, argEnd, zeroInitialize);
1059 }
1060
1061 /// EmitCXXAggrConstructorCall - Emit a loop to call a particular
1062 /// constructor for each of several members of an array.
1063 ///
1064 /// \param ctor the constructor to call for each element
1065 /// \param numElements the number of elements in the array;
1066 ///   may be zero
1067 /// \param argBegin,argEnd the arguments to evaluate and pass to the
1068 ///   constructor
1069 /// \param arrayBegin a T*, where T is the type constructed by ctor
1070 /// \param zeroInitialize true if each element should be
1071 ///   zero-initialized before it is constructed
1072 void
1073 CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *ctor,
1074                                             llvm::Value *numElements,
1075                                             llvm::Value *arrayBegin,
1076                                          CallExpr::const_arg_iterator argBegin,
1077                                            CallExpr::const_arg_iterator argEnd,
1078                                             bool zeroInitialize) {
1079
1080   // It's legal for numElements to be zero.  This can happen both
1081   // dynamically, because x can be zero in 'new A[x]', and statically,
1082   // because of GCC extensions that permit zero-length arrays.  There
1083   // are probably legitimate places where we could assume that this
1084   // doesn't happen, but it's not clear that it's worth it.
1085   llvm::BranchInst *zeroCheckBranch = 0;
1086
1087   // Optimize for a constant count.
1088   llvm::ConstantInt *constantCount
1089     = dyn_cast<llvm::ConstantInt>(numElements);
1090   if (constantCount) {
1091     // Just skip out if the constant count is zero.
1092     if (constantCount->isZero()) return;
1093
1094   // Otherwise, emit the check.
1095   } else {
1096     llvm::BasicBlock *loopBB = createBasicBlock("new.ctorloop");
1097     llvm::Value *iszero = Builder.CreateIsNull(numElements, "isempty");
1098     zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB);
1099     EmitBlock(loopBB);
1100   }
1101
1102   // Find the end of the array.
1103   llvm::Value *arrayEnd = Builder.CreateInBoundsGEP(arrayBegin, numElements,
1104                                                     "arrayctor.end");
1105
1106   // Enter the loop, setting up a phi for the current location to initialize.
1107   llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1108   llvm::BasicBlock *loopBB = createBasicBlock("arrayctor.loop");
1109   EmitBlock(loopBB);
1110   llvm::PHINode *cur = Builder.CreatePHI(arrayBegin->getType(), 2,
1111                                          "arrayctor.cur");
1112   cur->addIncoming(arrayBegin, entryBB);
1113
1114   // Inside the loop body, emit the constructor call on the array element.
1115
1116   QualType type = getContext().getTypeDeclType(ctor->getParent());
1117
1118   // Zero initialize the storage, if requested.
1119   if (zeroInitialize)
1120     EmitNullInitialization(cur, type);
1121
1122   // C++ [class.temporary]p4:
1123   // There are two contexts in which temporaries are destroyed at a different
1124   // point than the end of the full-expression. The first context is when a
1125   // default constructor is called to initialize an element of an array.
1126   // If the constructor has one or more default arguments, the destruction of
1127   // every temporary created in a default argument expression is sequenced
1128   // before the construction of the next array element, if any.
1129
1130   {
1131     RunCleanupsScope Scope(*this);
1132
1133     // Evaluate the constructor and its arguments in a regular
1134     // partial-destroy cleanup.
1135     if (getLangOptions().Exceptions &&
1136         !ctor->getParent()->hasTrivialDestructor()) {
1137       Destroyer *destroyer = destroyCXXObject;
1138       pushRegularPartialArrayCleanup(arrayBegin, cur, type, *destroyer);
1139     }
1140
1141     EmitCXXConstructorCall(ctor, Ctor_Complete, /*ForVirtualBase=*/ false,
1142                            cur, argBegin, argEnd);
1143   }
1144
1145   // Go to the next element.
1146   llvm::Value *next =
1147     Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1),
1148                               "arrayctor.next");
1149   cur->addIncoming(next, Builder.GetInsertBlock());
1150
1151   // Check whether that's the end of the loop.
1152   llvm::Value *done = Builder.CreateICmpEQ(next, arrayEnd, "arrayctor.done");
1153   llvm::BasicBlock *contBB = createBasicBlock("arrayctor.cont");
1154   Builder.CreateCondBr(done, contBB, loopBB);
1155
1156   // Patch the earlier check to skip over the loop.
1157   if (zeroCheckBranch) zeroCheckBranch->setSuccessor(0, contBB);
1158
1159   EmitBlock(contBB);
1160 }
1161
1162 void CodeGenFunction::destroyCXXObject(CodeGenFunction &CGF,
1163                                        llvm::Value *addr,
1164                                        QualType type) {
1165   const RecordType *rtype = type->castAs<RecordType>();
1166   const CXXRecordDecl *record = cast<CXXRecordDecl>(rtype->getDecl());
1167   const CXXDestructorDecl *dtor = record->getDestructor();
1168   assert(!dtor->isTrivial());
1169   CGF.EmitCXXDestructorCall(dtor, Dtor_Complete, /*for vbase*/ false,
1170                             addr);
1171 }
1172
1173 void
1174 CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
1175                                         CXXCtorType Type, bool ForVirtualBase,
1176                                         llvm::Value *This,
1177                                         CallExpr::const_arg_iterator ArgBeg,
1178                                         CallExpr::const_arg_iterator ArgEnd) {
1179
1180   CGDebugInfo *DI = getDebugInfo();
1181   if (DI && CGM.getCodeGenOpts().LimitDebugInfo) {
1182     // If debug info for this class has been emitted then this is the right time
1183     // to do so.
1184     const CXXRecordDecl *Parent = D->getParent();
1185     DI->getOrCreateRecordType(CGM.getContext().getTypeDeclType(Parent),
1186                               Parent->getLocation());
1187   }
1188
1189   if (D->isTrivial()) {
1190     if (ArgBeg == ArgEnd) {
1191       // Trivial default constructor, no codegen required.
1192       assert(D->isDefaultConstructor() &&
1193              "trivial 0-arg ctor not a default ctor");
1194       return;
1195     }
1196
1197     assert(ArgBeg + 1 == ArgEnd && "unexpected argcount for trivial ctor");
1198     assert(D->isCopyConstructor() && "trivial 1-arg ctor not a copy ctor");
1199
1200     const Expr *E = (*ArgBeg);
1201     QualType Ty = E->getType();
1202     llvm::Value *Src = EmitLValue(E).getAddress();
1203     EmitAggregateCopy(This, Src, Ty);
1204     return;
1205   }
1206
1207   llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(D, Type), ForVirtualBase);
1208   llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
1209
1210   EmitCXXMemberCall(D, Callee, ReturnValueSlot(), This, VTT, ArgBeg, ArgEnd);
1211 }
1212
1213 void
1214 CodeGenFunction::EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
1215                                         llvm::Value *This, llvm::Value *Src,
1216                                         CallExpr::const_arg_iterator ArgBeg,
1217                                         CallExpr::const_arg_iterator ArgEnd) {
1218   if (D->isTrivial()) {
1219     assert(ArgBeg + 1 == ArgEnd && "unexpected argcount for trivial ctor");
1220     assert(D->isCopyConstructor() && "trivial 1-arg ctor not a copy ctor");
1221     EmitAggregateCopy(This, Src, (*ArgBeg)->getType());
1222     return;
1223   }
1224   llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D,
1225                                                     clang::Ctor_Complete);
1226   assert(D->isInstance() &&
1227          "Trying to emit a member call expr on a static method!");
1228
1229   const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>();
1230
1231   CallArgList Args;
1232
1233   // Push the this ptr.
1234   Args.add(RValue::get(This), D->getThisType(getContext()));
1235
1236
1237   // Push the src ptr.
1238   QualType QT = *(FPT->arg_type_begin());
1239   const llvm::Type *t = CGM.getTypes().ConvertType(QT);
1240   Src = Builder.CreateBitCast(Src, t);
1241   Args.add(RValue::get(Src), QT);
1242
1243   // Skip over first argument (Src).
1244   ++ArgBeg;
1245   CallExpr::const_arg_iterator Arg = ArgBeg;
1246   for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin()+1,
1247        E = FPT->arg_type_end(); I != E; ++I, ++Arg) {
1248     assert(Arg != ArgEnd && "Running over edge of argument list!");
1249     EmitCallArg(Args, *Arg, *I);
1250   }
1251   // Either we've emitted all the call args, or we have a call to a
1252   // variadic function.
1253   assert((Arg == ArgEnd || FPT->isVariadic()) &&
1254          "Extra arguments in non-variadic function!");
1255   // If we still have any arguments, emit them using the type of the argument.
1256   for (; Arg != ArgEnd; ++Arg) {
1257     QualType ArgType = Arg->getType();
1258     EmitCallArg(Args, *Arg, ArgType);
1259   }
1260
1261   QualType ResultType = FPT->getResultType();
1262   EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args,
1263                                           FPT->getExtInfo()),
1264                   Callee, ReturnValueSlot(), Args, D);
1265 }
1266
1267 void
1268 CodeGenFunction::EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1269                                                 CXXCtorType CtorType,
1270                                                 const FunctionArgList &Args) {
1271   CallArgList DelegateArgs;
1272
1273   FunctionArgList::const_iterator I = Args.begin(), E = Args.end();
1274   assert(I != E && "no parameters to constructor");
1275
1276   // this
1277   DelegateArgs.add(RValue::get(LoadCXXThis()), (*I)->getType());
1278   ++I;
1279
1280   // vtt
1281   if (llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(Ctor, CtorType),
1282                                          /*ForVirtualBase=*/false)) {
1283     QualType VoidPP = getContext().getPointerType(getContext().VoidPtrTy);
1284     DelegateArgs.add(RValue::get(VTT), VoidPP);
1285
1286     if (CodeGenVTables::needsVTTParameter(CurGD)) {
1287       assert(I != E && "cannot skip vtt parameter, already done with args");
1288       assert((*I)->getType() == VoidPP && "skipping parameter not of vtt type");
1289       ++I;
1290     }
1291   }
1292
1293   // Explicit arguments.
1294   for (; I != E; ++I) {
1295     const VarDecl *param = *I;
1296     EmitDelegateCallArg(DelegateArgs, param);
1297   }
1298
1299   EmitCall(CGM.getTypes().getFunctionInfo(Ctor, CtorType),
1300            CGM.GetAddrOfCXXConstructor(Ctor, CtorType),
1301            ReturnValueSlot(), DelegateArgs, Ctor);
1302 }
1303
1304 namespace {
1305   struct CallDelegatingCtorDtor : EHScopeStack::Cleanup {
1306     const CXXDestructorDecl *Dtor;
1307     llvm::Value *Addr;
1308     CXXDtorType Type;
1309
1310     CallDelegatingCtorDtor(const CXXDestructorDecl *D, llvm::Value *Addr,
1311                            CXXDtorType Type)
1312       : Dtor(D), Addr(Addr), Type(Type) {}
1313
1314     void Emit(CodeGenFunction &CGF, Flags flags) {
1315       CGF.EmitCXXDestructorCall(Dtor, Type, /*ForVirtualBase=*/false,
1316                                 Addr);
1317     }
1318   };
1319 }
1320
1321 void
1322 CodeGenFunction::EmitDelegatingCXXConstructorCall(const CXXConstructorDecl *Ctor,
1323                                                   const FunctionArgList &Args) {
1324   assert(Ctor->isDelegatingConstructor());
1325
1326   llvm::Value *ThisPtr = LoadCXXThis();
1327
1328   AggValueSlot AggSlot =
1329     AggValueSlot::forAddr(ThisPtr, Qualifiers(), /*Lifetime*/ true);
1330
1331   EmitAggExpr(Ctor->init_begin()[0]->getInit(), AggSlot);
1332
1333   const CXXRecordDecl *ClassDecl = Ctor->getParent();
1334   if (CGM.getLangOptions().Exceptions && !ClassDecl->hasTrivialDestructor()) {
1335     CXXDtorType Type =
1336       CurGD.getCtorType() == Ctor_Complete ? Dtor_Complete : Dtor_Base;
1337
1338     EHStack.pushCleanup<CallDelegatingCtorDtor>(EHCleanup,
1339                                                 ClassDecl->getDestructor(),
1340                                                 ThisPtr, Type);
1341   }
1342 }
1343
1344 void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *DD,
1345                                             CXXDtorType Type,
1346                                             bool ForVirtualBase,
1347                                             llvm::Value *This) {
1348   llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(DD, Type),
1349                                      ForVirtualBase);
1350   llvm::Value *Callee = 0;
1351   if (getContext().getLangOptions().AppleKext)
1352     Callee = BuildAppleKextVirtualDestructorCall(DD, Type,
1353                                                  DD->getParent());
1354
1355   if (!Callee)
1356     Callee = CGM.GetAddrOfCXXDestructor(DD, Type);
1357
1358   EmitCXXMemberCall(DD, Callee, ReturnValueSlot(), This, VTT, 0, 0);
1359 }
1360
1361 namespace {
1362   struct CallLocalDtor : EHScopeStack::Cleanup {
1363     const CXXDestructorDecl *Dtor;
1364     llvm::Value *Addr;
1365
1366     CallLocalDtor(const CXXDestructorDecl *D, llvm::Value *Addr)
1367       : Dtor(D), Addr(Addr) {}
1368
1369     void Emit(CodeGenFunction &CGF, Flags flags) {
1370       CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
1371                                 /*ForVirtualBase=*/false, Addr);
1372     }
1373   };
1374 }
1375
1376 void CodeGenFunction::PushDestructorCleanup(const CXXDestructorDecl *D,
1377                                             llvm::Value *Addr) {
1378   EHStack.pushCleanup<CallLocalDtor>(NormalAndEHCleanup, D, Addr);
1379 }
1380
1381 void CodeGenFunction::PushDestructorCleanup(QualType T, llvm::Value *Addr) {
1382   CXXRecordDecl *ClassDecl = T->getAsCXXRecordDecl();
1383   if (!ClassDecl) return;
1384   if (ClassDecl->hasTrivialDestructor()) return;
1385
1386   const CXXDestructorDecl *D = ClassDecl->getDestructor();
1387   assert(D && D->isUsed() && "destructor not marked as used!");
1388   PushDestructorCleanup(D, Addr);
1389 }
1390
1391 llvm::Value *
1392 CodeGenFunction::GetVirtualBaseClassOffset(llvm::Value *This,
1393                                            const CXXRecordDecl *ClassDecl,
1394                                            const CXXRecordDecl *BaseClassDecl) {
1395   llvm::Value *VTablePtr = GetVTablePtr(This, Int8PtrTy);
1396   CharUnits VBaseOffsetOffset =
1397     CGM.getVTables().getVirtualBaseOffsetOffset(ClassDecl, BaseClassDecl);
1398
1399   llvm::Value *VBaseOffsetPtr =
1400     Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset.getQuantity(),
1401                                "vbase.offset.ptr");
1402   const llvm::Type *PtrDiffTy =
1403     ConvertType(getContext().getPointerDiffType());
1404
1405   VBaseOffsetPtr = Builder.CreateBitCast(VBaseOffsetPtr,
1406                                          PtrDiffTy->getPointerTo());
1407
1408   llvm::Value *VBaseOffset = Builder.CreateLoad(VBaseOffsetPtr, "vbase.offset");
1409
1410   return VBaseOffset;
1411 }
1412
1413 void
1414 CodeGenFunction::InitializeVTablePointer(BaseSubobject Base,
1415                                          const CXXRecordDecl *NearestVBase,
1416                                          CharUnits OffsetFromNearestVBase,
1417                                          llvm::Constant *VTable,
1418                                          const CXXRecordDecl *VTableClass) {
1419   const CXXRecordDecl *RD = Base.getBase();
1420
1421   // Compute the address point.
1422   llvm::Value *VTableAddressPoint;
1423
1424   // Check if we need to use a vtable from the VTT.
1425   if (CodeGenVTables::needsVTTParameter(CurGD) &&
1426       (RD->getNumVBases() || NearestVBase)) {
1427     // Get the secondary vpointer index.
1428     uint64_t VirtualPointerIndex =
1429      CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1430
1431     /// Load the VTT.
1432     llvm::Value *VTT = LoadCXXVTT();
1433     if (VirtualPointerIndex)
1434       VTT = Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1435
1436     // And load the address point from the VTT.
1437     VTableAddressPoint = Builder.CreateLoad(VTT);
1438   } else {
1439     uint64_t AddressPoint = CGM.getVTables().getAddressPoint(Base, VTableClass);
1440     VTableAddressPoint =
1441       Builder.CreateConstInBoundsGEP2_64(VTable, 0, AddressPoint);
1442   }
1443
1444   // Compute where to store the address point.
1445   llvm::Value *VirtualOffset = 0;
1446   CharUnits NonVirtualOffset = CharUnits::Zero();
1447
1448   if (CodeGenVTables::needsVTTParameter(CurGD) && NearestVBase) {
1449     // We need to use the virtual base offset offset because the virtual base
1450     // might have a different offset in the most derived class.
1451     VirtualOffset = GetVirtualBaseClassOffset(LoadCXXThis(), VTableClass,
1452                                               NearestVBase);
1453     NonVirtualOffset = OffsetFromNearestVBase;
1454   } else {
1455     // We can just use the base offset in the complete class.
1456     NonVirtualOffset = Base.getBaseOffset();
1457   }
1458
1459   // Apply the offsets.
1460   llvm::Value *VTableField = LoadCXXThis();
1461
1462   if (!NonVirtualOffset.isZero() || VirtualOffset)
1463     VTableField = ApplyNonVirtualAndVirtualOffset(*this, VTableField,
1464                                                   NonVirtualOffset,
1465                                                   VirtualOffset);
1466
1467   // Finally, store the address point.
1468   const llvm::Type *AddressPointPtrTy =
1469     VTableAddressPoint->getType()->getPointerTo();
1470   VTableField = Builder.CreateBitCast(VTableField, AddressPointPtrTy);
1471   Builder.CreateStore(VTableAddressPoint, VTableField);
1472 }
1473
1474 void
1475 CodeGenFunction::InitializeVTablePointers(BaseSubobject Base,
1476                                           const CXXRecordDecl *NearestVBase,
1477                                           CharUnits OffsetFromNearestVBase,
1478                                           bool BaseIsNonVirtualPrimaryBase,
1479                                           llvm::Constant *VTable,
1480                                           const CXXRecordDecl *VTableClass,
1481                                           VisitedVirtualBasesSetTy& VBases) {
1482   // If this base is a non-virtual primary base the address point has already
1483   // been set.
1484   if (!BaseIsNonVirtualPrimaryBase) {
1485     // Initialize the vtable pointer for this base.
1486     InitializeVTablePointer(Base, NearestVBase, OffsetFromNearestVBase,
1487                             VTable, VTableClass);
1488   }
1489
1490   const CXXRecordDecl *RD = Base.getBase();
1491
1492   // Traverse bases.
1493   for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1494        E = RD->bases_end(); I != E; ++I) {
1495     CXXRecordDecl *BaseDecl
1496       = cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1497
1498     // Ignore classes without a vtable.
1499     if (!BaseDecl->isDynamicClass())
1500       continue;
1501
1502     CharUnits BaseOffset;
1503     CharUnits BaseOffsetFromNearestVBase;
1504     bool BaseDeclIsNonVirtualPrimaryBase;
1505
1506     if (I->isVirtual()) {
1507       // Check if we've visited this virtual base before.
1508       if (!VBases.insert(BaseDecl))
1509         continue;
1510
1511       const ASTRecordLayout &Layout =
1512         getContext().getASTRecordLayout(VTableClass);
1513
1514       BaseOffset = Layout.getVBaseClassOffset(BaseDecl);
1515       BaseOffsetFromNearestVBase = CharUnits::Zero();
1516       BaseDeclIsNonVirtualPrimaryBase = false;
1517     } else {
1518       const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
1519
1520       BaseOffset = Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
1521       BaseOffsetFromNearestVBase =
1522         OffsetFromNearestVBase + Layout.getBaseClassOffset(BaseDecl);
1523       BaseDeclIsNonVirtualPrimaryBase = Layout.getPrimaryBase() == BaseDecl;
1524     }
1525
1526     InitializeVTablePointers(BaseSubobject(BaseDecl, BaseOffset),
1527                              I->isVirtual() ? BaseDecl : NearestVBase,
1528                              BaseOffsetFromNearestVBase,
1529                              BaseDeclIsNonVirtualPrimaryBase,
1530                              VTable, VTableClass, VBases);
1531   }
1532 }
1533
1534 void CodeGenFunction::InitializeVTablePointers(const CXXRecordDecl *RD) {
1535   // Ignore classes without a vtable.
1536   if (!RD->isDynamicClass())
1537     return;
1538
1539   // Get the VTable.
1540   llvm::Constant *VTable = CGM.getVTables().GetAddrOfVTable(RD);
1541
1542   // Initialize the vtable pointers for this class and all of its bases.
1543   VisitedVirtualBasesSetTy VBases;
1544   InitializeVTablePointers(BaseSubobject(RD, CharUnits::Zero()),
1545                            /*NearestVBase=*/0,
1546                            /*OffsetFromNearestVBase=*/CharUnits::Zero(),
1547                            /*BaseIsNonVirtualPrimaryBase=*/false,
1548                            VTable, RD, VBases);
1549 }
1550
1551 llvm::Value *CodeGenFunction::GetVTablePtr(llvm::Value *This,
1552                                            const llvm::Type *Ty) {
1553   llvm::Value *VTablePtrSrc = Builder.CreateBitCast(This, Ty->getPointerTo());
1554   return Builder.CreateLoad(VTablePtrSrc, "vtable");
1555 }
1556
1557 static const CXXRecordDecl *getMostDerivedClassDecl(const Expr *Base) {
1558   const Expr *E = Base;
1559
1560   while (true) {
1561     E = E->IgnoreParens();
1562     if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
1563       if (CE->getCastKind() == CK_DerivedToBase ||
1564           CE->getCastKind() == CK_UncheckedDerivedToBase ||
1565           CE->getCastKind() == CK_NoOp) {
1566         E = CE->getSubExpr();
1567         continue;
1568       }
1569     }
1570
1571     break;
1572   }
1573
1574   QualType DerivedType = E->getType();
1575   if (const PointerType *PTy = DerivedType->getAs<PointerType>())
1576     DerivedType = PTy->getPointeeType();
1577
1578   return cast<CXXRecordDecl>(DerivedType->castAs<RecordType>()->getDecl());
1579 }
1580
1581 // FIXME: Ideally Expr::IgnoreParenNoopCasts should do this, but it doesn't do
1582 // quite what we want.
1583 static const Expr *skipNoOpCastsAndParens(const Expr *E) {
1584   while (true) {
1585     if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
1586       E = PE->getSubExpr();
1587       continue;
1588     }
1589
1590     if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
1591       if (CE->getCastKind() == CK_NoOp) {
1592         E = CE->getSubExpr();
1593         continue;
1594       }
1595     }
1596     if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) {
1597       if (UO->getOpcode() == UO_Extension) {
1598         E = UO->getSubExpr();
1599         continue;
1600       }
1601     }
1602     return E;
1603   }
1604 }
1605
1606 /// canDevirtualizeMemberFunctionCall - Checks whether the given virtual member
1607 /// function call on the given expr can be devirtualized.
1608 /// expr can be devirtualized.
1609 static bool canDevirtualizeMemberFunctionCall(const Expr *Base,
1610                                               const CXXMethodDecl *MD) {
1611   // If the most derived class is marked final, we know that no subclass can
1612   // override this member function and so we can devirtualize it. For example:
1613   //
1614   // struct A { virtual void f(); }
1615   // struct B final : A { };
1616   //
1617   // void f(B *b) {
1618   //   b->f();
1619   // }
1620   //
1621   const CXXRecordDecl *MostDerivedClassDecl = getMostDerivedClassDecl(Base);
1622   if (MostDerivedClassDecl->hasAttr<FinalAttr>())
1623     return true;
1624
1625   // If the member function is marked 'final', we know that it can't be
1626   // overridden and can therefore devirtualize it.
1627   if (MD->hasAttr<FinalAttr>())
1628     return true;
1629
1630   // Similarly, if the class itself is marked 'final' it can't be overridden
1631   // and we can therefore devirtualize the member function call.
1632   if (MD->getParent()->hasAttr<FinalAttr>())
1633     return true;
1634
1635   Base = skipNoOpCastsAndParens(Base);
1636   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
1637     if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
1638       // This is a record decl. We know the type and can devirtualize it.
1639       return VD->getType()->isRecordType();
1640     }
1641
1642     return false;
1643   }
1644
1645   // We can always devirtualize calls on temporary object expressions.
1646   if (isa<CXXConstructExpr>(Base))
1647     return true;
1648
1649   // And calls on bound temporaries.
1650   if (isa<CXXBindTemporaryExpr>(Base))
1651     return true;
1652
1653   // Check if this is a call expr that returns a record type.
1654   if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
1655     return CE->getCallReturnType()->isRecordType();
1656
1657   // We can't devirtualize the call.
1658   return false;
1659 }
1660
1661 static bool UseVirtualCall(ASTContext &Context,
1662                            const CXXOperatorCallExpr *CE,
1663                            const CXXMethodDecl *MD) {
1664   if (!MD->isVirtual())
1665     return false;
1666
1667   // When building with -fapple-kext, all calls must go through the vtable since
1668   // the kernel linker can do runtime patching of vtables.
1669   if (Context.getLangOptions().AppleKext)
1670     return true;
1671
1672   return !canDevirtualizeMemberFunctionCall(CE->getArg(0), MD);
1673 }
1674
1675 llvm::Value *
1676 CodeGenFunction::EmitCXXOperatorMemberCallee(const CXXOperatorCallExpr *E,
1677                                              const CXXMethodDecl *MD,
1678                                              llvm::Value *This) {
1679   const FunctionProtoType *FPT = MD->getType()->castAs<FunctionProtoType>();
1680   const llvm::Type *Ty =
1681     CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1682                                    FPT->isVariadic());
1683
1684   if (UseVirtualCall(getContext(), E, MD))
1685     return BuildVirtualCall(MD, This, Ty);
1686
1687   return CGM.GetAddrOfFunction(MD, Ty);
1688 }