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