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