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