CGCXX.cpp revision b9871a253d351e8776cfa5483d6330d5dffe4562 
1//===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===//
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.
11//
12//===----------------------------------------------------------------------===//
13
14// We might split this into multiple files if it gets too unwieldy
15
16#include "CodeGenFunction.h"
17#include "CodeGenModule.h"
18#include "Mangle.h"
19#include "clang/AST/ASTContext.h"
20#include "clang/AST/RecordLayout.h"
21#include "clang/AST/Decl.h"
22#include "clang/AST/DeclCXX.h"
23#include "clang/AST/DeclObjC.h"
24#include "llvm/ADT/StringExtras.h"
25using namespace clang;
26using namespace CodeGen;
27
28void
29CodeGenFunction::EmitCXXGlobalDtorRegistration(const CXXDestructorDecl *Dtor,
30                                               llvm::Constant *DeclPtr) {
31  // FIXME: This is ABI dependent and we use the Itanium ABI.
32
33  const llvm::Type *Int8PtrTy =
34    llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
35
36  std::vector<const llvm::Type *> Params;
37  Params.push_back(Int8PtrTy);
38
39  // Get the destructor function type
40  const llvm::Type *DtorFnTy =
41    llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Params, false);
42  DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy);
43
44  Params.clear();
45  Params.push_back(DtorFnTy);
46  Params.push_back(Int8PtrTy);
47  Params.push_back(Int8PtrTy);
48
49  // Get the __cxa_atexit function type
50  // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d );
51  const llvm::FunctionType *AtExitFnTy =
52    llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false);
53
54  llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy,
55                                                       "__cxa_atexit");
56
57  llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy,
58                                                     "__dso_handle");
59
60  llvm::Constant *DtorFn = CGM.GetAddrOfCXXDestructor(Dtor, Dtor_Complete);
61
62  llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy),
63                           llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy),
64                           llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) };
65  Builder.CreateCall(AtExitFn, &Args[0], llvm::array_endof(Args));
66}
67
68void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
69                                               llvm::Constant *DeclPtr) {
70  assert(D.hasGlobalStorage() &&
71         "VarDecl must have global storage!");
72
73  const Expr *Init = D.getInit();
74  QualType T = D.getType();
75
76  if (T->isReferenceType()) {
77    ErrorUnsupported(Init, "global variable that binds to a reference");
78  } else if (!hasAggregateLLVMType(T)) {
79    llvm::Value *V = EmitScalarExpr(Init);
80    EmitStoreOfScalar(V, DeclPtr, T.isVolatileQualified(), T);
81  } else if (T->isAnyComplexType()) {
82    EmitComplexExprIntoAddr(Init, DeclPtr, T.isVolatileQualified());
83  } else {
84    EmitAggExpr(Init, DeclPtr, T.isVolatileQualified());
85
86    if (const RecordType *RT = T->getAs<RecordType>()) {
87      CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
88      if (!RD->hasTrivialDestructor())
89        EmitCXXGlobalDtorRegistration(RD->getDestructor(getContext()), DeclPtr);
90    }
91  }
92}
93
94void
95CodeGenModule::EmitCXXGlobalInitFunc() {
96  if (CXXGlobalInits.empty())
97    return;
98
99  const llvm::FunctionType *FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
100                                                          false);
101
102  // Create our global initialization function.
103  // FIXME: Should this be tweakable by targets?
104  llvm::Function *Fn =
105    llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
106                           "__cxx_global_initialization", &TheModule);
107
108  CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
109                                                   &CXXGlobalInits[0],
110                                                   CXXGlobalInits.size());
111  AddGlobalCtor(Fn);
112}
113
114void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
115                                                const VarDecl **Decls,
116                                                unsigned NumDecls) {
117  StartFunction(0, getContext().VoidTy, Fn, FunctionArgList(),
118                SourceLocation());
119
120  for (unsigned i = 0; i != NumDecls; ++i) {
121    const VarDecl *D = Decls[i];
122
123    llvm::Constant *DeclPtr = CGM.GetAddrOfGlobalVar(D);
124    EmitCXXGlobalVarDeclInit(*D, DeclPtr);
125  }
126  FinishFunction();
127}
128
129void
130CodeGenFunction::EmitStaticCXXBlockVarDeclInit(const VarDecl &D,
131                                               llvm::GlobalVariable *GV) {
132  // FIXME: This should use __cxa_guard_{acquire,release}?
133
134  assert(!getContext().getLangOptions().ThreadsafeStatics &&
135         "thread safe statics are currently not supported!");
136
137  llvm::SmallString<256> GuardVName;
138  llvm::raw_svector_ostream GuardVOut(GuardVName);
139  mangleGuardVariable(&D, getContext(), GuardVOut);
140
141  // Create the guard variable.
142  llvm::GlobalValue *GuardV =
143    new llvm::GlobalVariable(CGM.getModule(), llvm::Type::getInt64Ty(VMContext), false,
144                             GV->getLinkage(),
145                             llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)),
146                             GuardVName.str());
147
148  // Load the first byte of the guard variable.
149  const llvm::Type *PtrTy = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
150  llvm::Value *V = Builder.CreateLoad(Builder.CreateBitCast(GuardV, PtrTy),
151                                      "tmp");
152
153  // Compare it against 0.
154  llvm::Value *nullValue = llvm::Constant::getNullValue(llvm::Type::getInt8Ty(VMContext));
155  llvm::Value *ICmp = Builder.CreateICmpEQ(V, nullValue , "tobool");
156
157  llvm::BasicBlock *InitBlock = createBasicBlock("init");
158  llvm::BasicBlock *EndBlock = createBasicBlock("init.end");
159
160  // If the guard variable is 0, jump to the initializer code.
161  Builder.CreateCondBr(ICmp, InitBlock, EndBlock);
162
163  EmitBlock(InitBlock);
164
165  EmitCXXGlobalVarDeclInit(D, GV);
166
167  Builder.CreateStore(llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 1),
168                      Builder.CreateBitCast(GuardV, PtrTy));
169
170  EmitBlock(EndBlock);
171}
172
173RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
174                                          llvm::Value *Callee,
175                                          llvm::Value *This,
176                                          CallExpr::const_arg_iterator ArgBeg,
177                                          CallExpr::const_arg_iterator ArgEnd) {
178  assert(MD->isInstance() &&
179         "Trying to emit a member call expr on a static method!");
180
181  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
182
183  CallArgList Args;
184
185  // Push the this ptr.
186  Args.push_back(std::make_pair(RValue::get(This),
187                                MD->getThisType(getContext())));
188
189  // And the rest of the call args
190  EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
191
192  QualType ResultType = MD->getType()->getAsFunctionType()->getResultType();
193  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args),
194                  Callee, Args, MD);
195}
196
197RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE) {
198  const MemberExpr *ME = cast<MemberExpr>(CE->getCallee());
199  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
200
201  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
202
203  if (MD->isVirtual()) {
204    ErrorUnsupported(CE, "virtual dispatch");
205  }
206
207  const llvm::Type *Ty =
208    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
209                                   FPT->isVariadic());
210  llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty);
211
212  llvm::Value *This;
213
214  if (ME->isArrow())
215    This = EmitScalarExpr(ME->getBase());
216  else {
217    LValue BaseLV = EmitLValue(ME->getBase());
218    This = BaseLV.getAddress();
219  }
220
221  return EmitCXXMemberCall(MD, Callee, This,
222                           CE->arg_begin(), CE->arg_end());
223}
224
225RValue
226CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
227                                               const CXXMethodDecl *MD) {
228  assert(MD->isInstance() &&
229         "Trying to emit a member call expr on a static method!");
230
231  if (MD->isCopyAssignment()) {
232    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext());
233    if (ClassDecl->hasTrivialCopyAssignment()) {
234      assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
235             "EmitCXXOperatorMemberCallExpr - user declared copy assignment");
236      llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
237      llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
238      QualType Ty = E->getType();
239      EmitAggregateCopy(This, Src, Ty);
240      return RValue::get(This);
241    }
242  }
243
244  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
245  const llvm::Type *Ty =
246  CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
247                                 FPT->isVariadic());
248  llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), Ty);
249
250  llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
251
252  return EmitCXXMemberCall(MD, Callee, This,
253                           E->arg_begin() + 1, E->arg_end());
254}
255
256llvm::Value *CodeGenFunction::LoadCXXThis() {
257  assert(isa<CXXMethodDecl>(CurFuncDecl) &&
258         "Must be in a C++ member function decl to load 'this'");
259  assert(cast<CXXMethodDecl>(CurFuncDecl)->isInstance() &&
260         "Must be in a C++ member function decl to load 'this'");
261
262  // FIXME: What if we're inside a block?
263  // ans: See how CodeGenFunction::LoadObjCSelf() uses
264  // CodeGenFunction::BlockForwardSelf() for how to do this.
265  return Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this");
266}
267
268static bool
269GetNestedPaths(llvm::SmallVectorImpl<const CXXRecordDecl *> &NestedBasePaths,
270               const CXXRecordDecl *ClassDecl,
271               const CXXRecordDecl *BaseClassDecl) {
272  for (CXXRecordDecl::base_class_const_iterator i = ClassDecl->bases_begin(),
273      e = ClassDecl->bases_end(); i != e; ++i) {
274    if (i->isVirtual())
275      continue;
276    const CXXRecordDecl *Base =
277      cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
278    if (Base == BaseClassDecl) {
279      NestedBasePaths.push_back(BaseClassDecl);
280      return true;
281    }
282  }
283  // BaseClassDecl not an immediate base of ClassDecl.
284  for (CXXRecordDecl::base_class_const_iterator i = ClassDecl->bases_begin(),
285       e = ClassDecl->bases_end(); i != e; ++i) {
286    if (i->isVirtual())
287      continue;
288    const CXXRecordDecl *Base =
289      cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
290    if (GetNestedPaths(NestedBasePaths, Base, BaseClassDecl)) {
291      NestedBasePaths.push_back(Base);
292      return true;
293    }
294  }
295  return false;
296}
297
298llvm::Value *CodeGenFunction::AddressCXXOfBaseClass(llvm::Value *BaseValue,
299                                          const CXXRecordDecl *ClassDecl,
300                                          const CXXRecordDecl *BaseClassDecl) {
301  if (ClassDecl == BaseClassDecl)
302    return BaseValue;
303
304  llvm::Type *I8Ptr = llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
305  llvm::SmallVector<const CXXRecordDecl *, 16> NestedBasePaths;
306  GetNestedPaths(NestedBasePaths, ClassDecl, BaseClassDecl);
307  assert(NestedBasePaths.size() > 0 &&
308         "AddressCXXOfBaseClass - inheritence path failed");
309  NestedBasePaths.push_back(ClassDecl);
310  uint64_t Offset = 0;
311
312  // Accessing a member of the base class. Must add delata to
313  // the load of 'this'.
314  for (unsigned i = NestedBasePaths.size()-1; i > 0; i--) {
315    const CXXRecordDecl *DerivedClass = NestedBasePaths[i];
316    const CXXRecordDecl *BaseClass = NestedBasePaths[i-1];
317    const ASTRecordLayout &Layout =
318      getContext().getASTRecordLayout(DerivedClass);
319    Offset += Layout.getBaseClassOffset(BaseClass) / 8;
320  }
321  llvm::Value *OffsetVal =
322    llvm::ConstantInt::get(
323                  CGM.getTypes().ConvertType(CGM.getContext().LongTy), Offset);
324  BaseValue = Builder.CreateBitCast(BaseValue, I8Ptr);
325  BaseValue = Builder.CreateGEP(BaseValue, OffsetVal, "add.ptr");
326  QualType BTy =
327    getContext().getCanonicalType(
328      getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(BaseClassDecl)));
329  const llvm::Type *BasePtr = ConvertType(BTy);
330  BasePtr = llvm::PointerType::getUnqual(BasePtr);
331  BaseValue = Builder.CreateBitCast(BaseValue, BasePtr);
332  return BaseValue;
333}
334
335/// EmitCXXAggrConstructorCall - This routine essentially creates a (nested)
336/// for-loop to call the default constructor on individual members of the
337/// array. 'Array' is the array type, 'This' is llvm pointer of the start
338/// of the array and 'D' is the default costructor Decl for elements of the
339/// array. It is assumed that all relevant checks have been made by the
340/// caller.
341void
342CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
343                                            const ArrayType *Array,
344                                            llvm::Value *This) {
345  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
346  assert(CA && "Do we support VLA for construction ?");
347
348  // Create a temporary for the loop index and initialize it with 0.
349  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt32Ty(VMContext),
350                                           "loop.index");
351  llvm::Value* zeroConstant =
352    llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
353  Builder.CreateStore(zeroConstant, IndexPtr, false);
354
355  // Start the loop with a block that tests the condition.
356  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
357  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
358
359  EmitBlock(CondBlock);
360
361  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
362
363  // Generate: if (loop-index < number-of-elements fall to the loop body,
364  // otherwise, go to the block after the for-loop.
365  uint64_t NumElements = CA->getSize().getZExtValue();
366  llvm::Value * NumElementsPtr =
367  llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), NumElements);
368  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
369  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
370                                              "isless");
371  // If the condition is true, execute the body.
372  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
373
374  EmitBlock(ForBody);
375
376  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
377  // Inside the loop body, emit the constructor call on the array element.
378  Counter = Builder.CreateLoad(IndexPtr);
379  if (const ConstantArrayType *CAT =
380      dyn_cast<ConstantArrayType>(Array->getElementType())) {
381    uint32_t delta = 1;
382    const ConstantArrayType *CAW = CAT;
383    do {
384      delta *= CAW->getSize().getZExtValue();
385      CAW = dyn_cast<ConstantArrayType>(CAW->getElementType());
386    } while (CAW);
387    // Address = This + delta*Counter for current loop iteration.
388    llvm::Value *DeltaPtr =
389      llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), delta);
390    DeltaPtr = Builder.CreateMul(Counter, DeltaPtr, "mul");
391    llvm::Value *Address =
392      Builder.CreateInBoundsGEP(This, DeltaPtr, "arrayidx");
393    EmitCXXAggrConstructorCall(D, CAT, Address);
394  }
395  else {
396    llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
397    EmitCXXConstructorCall(D, Ctor_Complete, Address, 0, 0);
398  }
399
400  EmitBlock(ContinueBlock);
401
402  // Emit the increment of the loop counter.
403  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
404  Counter = Builder.CreateLoad(IndexPtr);
405  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
406  Builder.CreateStore(NextVal, IndexPtr, false);
407
408  // Finally, branch back up to the condition for the next iteration.
409  EmitBranch(CondBlock);
410
411  // Emit the fall-through block.
412  EmitBlock(AfterFor, true);
413}
414
415/// EmitCXXAggrDestructorCall - calls the default destructor on array
416/// elements in reverse order of construction.
417void
418CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
419                                           const ArrayType *Array,
420                                           llvm::Value *This) {
421  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
422  assert(CA && "Do we support VLA for destruction ?");
423  llvm::Value *One = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
424                                            1);
425  uint64_t ElementCount = 1;
426  const ConstantArrayType *CAW = CA;
427  do {
428    ElementCount *= CAW->getSize().getZExtValue();
429    CAW = dyn_cast<ConstantArrayType>(CAW->getElementType());
430  } while (CAW);
431  // Create a temporary for the loop index and initialize it with count of
432  // array elements.
433  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
434                                           "loop.index");
435  // Index = ElementCount;
436  llvm::Value* UpperCount =
437    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), ElementCount);
438  Builder.CreateStore(UpperCount, IndexPtr, false);
439
440  // Start the loop with a block that tests the condition.
441  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
442  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
443
444  EmitBlock(CondBlock);
445
446  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
447
448  // Generate: if (loop-index != 0 fall to the loop body,
449  // otherwise, go to the block after the for-loop.
450  llvm::Value* zeroConstant =
451    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
452  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
453  llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant,
454                                            "isne");
455  // If the condition is true, execute the body.
456  Builder.CreateCondBr(IsNE, ForBody, AfterFor);
457
458  EmitBlock(ForBody);
459
460  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
461  // Inside the loop body, emit the constructor call on the array element.
462  Counter = Builder.CreateLoad(IndexPtr);
463  Counter = Builder.CreateSub(Counter, One);
464  llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
465  EmitCXXDestructorCall(D, Dtor_Complete, Address);
466
467  EmitBlock(ContinueBlock);
468
469  // Emit the decrement of the loop counter.
470  Counter = Builder.CreateLoad(IndexPtr);
471  Counter = Builder.CreateSub(Counter, One, "dec");
472  Builder.CreateStore(Counter, IndexPtr, false);
473
474  // Finally, branch back up to the condition for the next iteration.
475  EmitBranch(CondBlock);
476
477  // Emit the fall-through block.
478  EmitBlock(AfterFor, true);
479}
480
481void
482CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
483                                        CXXCtorType Type,
484                                        llvm::Value *This,
485                                        CallExpr::const_arg_iterator ArgBeg,
486                                        CallExpr::const_arg_iterator ArgEnd) {
487  if (D->isCopyConstructor(getContext())) {
488    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D->getDeclContext());
489    if (ClassDecl->hasTrivialCopyConstructor()) {
490      assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
491             "EmitCXXConstructorCall - user declared copy constructor");
492      const Expr *E = (*ArgBeg);
493      QualType Ty = E->getType();
494      llvm::Value *Src = EmitLValue(E).getAddress();
495      EmitAggregateCopy(This, Src, Ty);
496      return;
497    }
498  }
499
500  llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
501
502  EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd);
503}
504
505void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D,
506                                            CXXDtorType Type,
507                                            llvm::Value *This) {
508  llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type);
509
510  EmitCXXMemberCall(D, Callee, This, 0, 0);
511}
512
513void
514CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
515                                      const CXXConstructExpr *E) {
516  assert(Dest && "Must have a destination!");
517
518  const CXXRecordDecl *RD =
519  cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
520  if (RD->hasTrivialConstructor())
521    return;
522
523  // Code gen optimization to eliminate copy constructor and return
524  // its first argument instead.
525  if (E->isElidable()) {
526    CXXConstructExpr::const_arg_iterator i = E->arg_begin();
527    EmitAggExpr((*i), Dest, false);
528    return;
529  }
530  // Call the constructor.
531  EmitCXXConstructorCall(E->getConstructor(), Ctor_Complete, Dest,
532                         E->arg_begin(), E->arg_end());
533}
534
535llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
536  if (E->isArray()) {
537    ErrorUnsupported(E, "new[] expression");
538    return llvm::UndefValue::get(ConvertType(E->getType()));
539  }
540
541  QualType AllocType = E->getAllocatedType();
542  FunctionDecl *NewFD = E->getOperatorNew();
543  const FunctionProtoType *NewFTy = NewFD->getType()->getAsFunctionProtoType();
544
545  CallArgList NewArgs;
546
547  // The allocation size is the first argument.
548  QualType SizeTy = getContext().getSizeType();
549  llvm::Value *AllocSize =
550    llvm::ConstantInt::get(ConvertType(SizeTy),
551                           getContext().getTypeSize(AllocType) / 8);
552
553  NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy));
554
555  // Emit the rest of the arguments.
556  // FIXME: Ideally, this should just use EmitCallArgs.
557  CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin();
558
559  // First, use the types from the function type.
560  // We start at 1 here because the first argument (the allocation size)
561  // has already been emitted.
562  for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) {
563    QualType ArgType = NewFTy->getArgType(i);
564
565    assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
566           getTypePtr() ==
567           getContext().getCanonicalType(NewArg->getType()).getTypePtr() &&
568           "type mismatch in call argument!");
569
570    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
571                                     ArgType));
572
573  }
574
575  // Either we've emitted all the call args, or we have a call to a
576  // variadic function.
577  assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) &&
578         "Extra arguments in non-variadic function!");
579
580  // If we still have any arguments, emit them using the type of the argument.
581  for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end();
582       NewArg != NewArgEnd; ++NewArg) {
583    QualType ArgType = NewArg->getType();
584    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
585                                     ArgType));
586  }
587
588  // Emit the call to new.
589  RValue RV =
590    EmitCall(CGM.getTypes().getFunctionInfo(NewFTy->getResultType(), NewArgs),
591             CGM.GetAddrOfFunction(GlobalDecl(NewFD)),
592             NewArgs, NewFD);
593
594  // If an allocation function is declared with an empty exception specification
595  // it returns null to indicate failure to allocate storage. [expr.new]p13.
596  // (We don't need to check for null when there's no new initializer and
597  // we're allocating a POD type).
598  bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() &&
599    !(AllocType->isPODType() && !E->hasInitializer());
600
601  llvm::BasicBlock *NewNull = 0;
602  llvm::BasicBlock *NewNotNull = 0;
603  llvm::BasicBlock *NewEnd = 0;
604
605  llvm::Value *NewPtr = RV.getScalarVal();
606
607  if (NullCheckResult) {
608    NewNull = createBasicBlock("new.null");
609    NewNotNull = createBasicBlock("new.notnull");
610    NewEnd = createBasicBlock("new.end");
611
612    llvm::Value *IsNull =
613      Builder.CreateICmpEQ(NewPtr,
614                           llvm::Constant::getNullValue(NewPtr->getType()),
615                           "isnull");
616
617    Builder.CreateCondBr(IsNull, NewNull, NewNotNull);
618    EmitBlock(NewNotNull);
619  }
620
621  NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
622
623  if (AllocType->isPODType()) {
624    if (E->getNumConstructorArgs() > 0) {
625      assert(E->getNumConstructorArgs() == 1 &&
626             "Can only have one argument to initializer of POD type.");
627
628      const Expr *Init = E->getConstructorArg(0);
629
630      if (!hasAggregateLLVMType(AllocType))
631        Builder.CreateStore(EmitScalarExpr(Init), NewPtr);
632      else if (AllocType->isAnyComplexType())
633        EmitComplexExprIntoAddr(Init, NewPtr, AllocType.isVolatileQualified());
634      else
635        EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified());
636    }
637  } else {
638    // Call the constructor.
639    CXXConstructorDecl *Ctor = E->getConstructor();
640
641    EmitCXXConstructorCall(Ctor, Ctor_Complete, NewPtr,
642                           E->constructor_arg_begin(),
643                           E->constructor_arg_end());
644  }
645
646  if (NullCheckResult) {
647    Builder.CreateBr(NewEnd);
648    EmitBlock(NewNull);
649    Builder.CreateBr(NewEnd);
650    EmitBlock(NewEnd);
651
652    llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
653    PHI->reserveOperandSpace(2);
654    PHI->addIncoming(NewPtr, NewNotNull);
655    PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull);
656
657    NewPtr = PHI;
658  }
659
660  return NewPtr;
661}
662
663void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
664  if (E->isArrayForm()) {
665    ErrorUnsupported(E, "delete[] expression");
666    return;
667  };
668
669  QualType DeleteTy =
670    E->getArgument()->getType()->getAs<PointerType>()->getPointeeType();
671
672  llvm::Value *Ptr = EmitScalarExpr(E->getArgument());
673
674  // Null check the pointer.
675  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
676  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
677
678  llvm::Value *IsNull =
679    Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()),
680                         "isnull");
681
682  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
683  EmitBlock(DeleteNotNull);
684
685  // Call the destructor if necessary.
686  if (const RecordType *RT = DeleteTy->getAs<RecordType>()) {
687    if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
688      if (!RD->hasTrivialDestructor()) {
689        const CXXDestructorDecl *Dtor = RD->getDestructor(getContext());
690        if (Dtor->isVirtual()) {
691          ErrorUnsupported(E, "delete expression with virtual destructor");
692          return;
693        }
694
695        EmitCXXDestructorCall(Dtor, Dtor_Complete, Ptr);
696      }
697    }
698  }
699
700  // Call delete.
701  FunctionDecl *DeleteFD = E->getOperatorDelete();
702  const FunctionProtoType *DeleteFTy =
703    DeleteFD->getType()->getAsFunctionProtoType();
704
705  CallArgList DeleteArgs;
706
707  QualType ArgTy = DeleteFTy->getArgType(0);
708  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
709  DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy));
710
711  // Emit the call to delete.
712  EmitCall(CGM.getTypes().getFunctionInfo(DeleteFTy->getResultType(),
713                                          DeleteArgs),
714           CGM.GetAddrOfFunction(GlobalDecl(DeleteFD)),
715           DeleteArgs, DeleteFD);
716
717  EmitBlock(DeleteEnd);
718}
719
720static bool canGenerateCXXstructor(const CXXRecordDecl *RD,
721                                   ASTContext &Context) {
722  // The class has base classes - we don't support that right now.
723  if (RD->getNumBases() > 0)
724    return false;
725
726  for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
727         I != E; ++I) {
728    // We don't support ctors for fields that aren't POD.
729    if (!I->getType()->isPODType())
730      return false;
731  }
732
733  return true;
734}
735
736void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
737  if (!canGenerateCXXstructor(D->getParent(), getContext())) {
738    ErrorUnsupported(D, "C++ constructor", true);
739    return;
740  }
741
742  EmitGlobal(GlobalDecl(D, Ctor_Complete));
743  EmitGlobal(GlobalDecl(D, Ctor_Base));
744}
745
746void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D,
747                                       CXXCtorType Type) {
748
749  llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type);
750
751  CodeGenFunction(*this).GenerateCode(D, Fn);
752
753  SetFunctionDefinitionAttributes(D, Fn);
754  SetLLVMFunctionAttributesForDefinition(D, Fn);
755}
756
757llvm::Function *
758CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D,
759                                       CXXCtorType Type) {
760  const llvm::FunctionType *FTy =
761    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
762
763  const char *Name = getMangledCXXCtorName(D, Type);
764  return cast<llvm::Function>(
765                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
766}
767
768const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D,
769                                                 CXXCtorType Type) {
770  llvm::SmallString<256> Name;
771  llvm::raw_svector_ostream Out(Name);
772  mangleCXXCtor(D, Type, Context, Out);
773
774  Name += '\0';
775  return UniqueMangledName(Name.begin(), Name.end());
776}
777
778void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
779  if (!canGenerateCXXstructor(D->getParent(), getContext())) {
780    ErrorUnsupported(D, "C++ destructor", true);
781    return;
782  }
783
784  EmitCXXDestructor(D, Dtor_Complete);
785  EmitCXXDestructor(D, Dtor_Base);
786}
787
788void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D,
789                                      CXXDtorType Type) {
790  llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type);
791
792  CodeGenFunction(*this).GenerateCode(D, Fn);
793
794  SetFunctionDefinitionAttributes(D, Fn);
795  SetLLVMFunctionAttributesForDefinition(D, Fn);
796}
797
798llvm::Function *
799CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D,
800                                      CXXDtorType Type) {
801  const llvm::FunctionType *FTy =
802    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
803
804  const char *Name = getMangledCXXDtorName(D, Type);
805  return cast<llvm::Function>(
806                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
807}
808
809const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D,
810                                                 CXXDtorType Type) {
811  llvm::SmallString<256> Name;
812  llvm::raw_svector_ostream Out(Name);
813  mangleCXXDtor(D, Type, Context, Out);
814
815  Name += '\0';
816  return UniqueMangledName(Name.begin(), Name.end());
817}
818
819llvm::Constant *CodeGenModule::GenerateRtti(const CXXRecordDecl *RD) {
820  llvm::Type *Ptr8Ty;
821  Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
822  llvm::Constant *Rtti = llvm::Constant::getNullValue(Ptr8Ty);
823
824  if (!getContext().getLangOptions().Rtti)
825    return Rtti;
826
827  llvm::SmallString<256> OutName;
828  llvm::raw_svector_ostream Out(OutName);
829  QualType ClassTy;
830  ClassTy = getContext().getTagDeclType(RD);
831  mangleCXXRtti(ClassTy, getContext(), Out);
832  llvm::GlobalVariable::LinkageTypes linktype;
833  linktype = llvm::GlobalValue::WeakAnyLinkage;
834  std::vector<llvm::Constant *> info;
835  // assert(0 && "FIXME: implement rtti descriptor");
836  // FIXME: descriptor
837  info.push_back(llvm::Constant::getNullValue(Ptr8Ty));
838  // assert(0 && "FIXME: implement rtti ts");
839  // FIXME: TS
840  info.push_back(llvm::Constant::getNullValue(Ptr8Ty));
841
842  llvm::Constant *C;
843  llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, info.size());
844  C = llvm::ConstantArray::get(type, info);
845  Rtti = new llvm::GlobalVariable(getModule(), type, true, linktype, C,
846                                  Out.str());
847  Rtti = llvm::ConstantExpr::getBitCast(Rtti, Ptr8Ty);
848  return Rtti;
849}
850
851class VtableBuilder {
852  std::vector<llvm::Constant *> &methods;
853  llvm::Type *Ptr8Ty;
854  /// Class - The most derived class that this vtable is being built for.
855  const CXXRecordDecl *Class;
856  /// BLayout - Layout for the most derived class that this vtable is being
857  /// built for.
858  const ASTRecordLayout &BLayout;
859  llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
860  llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
861  llvm::Constant *rtti;
862  llvm::LLVMContext &VMContext;
863  CodeGenModule &CGM;  // Per-module state.
864  /// Index - Maps a method decl into a vtable index.  Useful for virtual
865  /// dispatch codegen.
866  llvm::DenseMap<const CXXMethodDecl *, int32_t> Index;
867  typedef CXXRecordDecl::method_iterator method_iter;
868public:
869  VtableBuilder(std::vector<llvm::Constant *> &meth,
870                const CXXRecordDecl *c,
871                CodeGenModule &cgm)
872    : methods(meth), Class(c), BLayout(cgm.getContext().getASTRecordLayout(c)),
873      rtti(cgm.GenerateRtti(c)), VMContext(cgm.getModule().getContext()),
874      CGM(cgm) {
875    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
876  }
877
878  llvm::Constant *GenerateVcall(const CXXMethodDecl *MD,
879                                const CXXRecordDecl *RD,
880                                bool VBoundary,
881                                bool SecondaryVirtual) {
882    llvm::Constant *m = 0;
883
884    // FIXME: vcall: offset for virtual base for this function
885    if (SecondaryVirtual || VBoundary)
886      m = llvm::Constant::getNullValue(Ptr8Ty);
887    return m;
888  }
889
890  void GenerateVcalls(const CXXRecordDecl *RD, bool VBoundary,
891                      bool SecondaryVirtual) {
892    llvm::Constant *m;
893
894    for (method_iter mi = RD->method_begin(),
895           me = RD->method_end(); mi != me; ++mi) {
896      if (mi->isVirtual()) {
897        m = GenerateVcall(*mi, RD, VBoundary, SecondaryVirtual);
898        if (m)
899          methods.push_back(m);
900      }
901    }
902  }
903
904  void GenerateVBaseOffsets(std::vector<llvm::Constant *> &offsets,
905                            const CXXRecordDecl *RD, uint64_t Offset) {
906    for (CXXRecordDecl::base_class_const_iterator i =RD->bases_begin(),
907           e = RD->bases_end(); i != e; ++i) {
908      const CXXRecordDecl *Base =
909        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
910      if (i->isVirtual() && !SeenVBase.count(Base)) {
911        SeenVBase.insert(Base);
912        int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
913        llvm::Constant *m;
914        m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),BaseOffset);
915        m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
916        offsets.push_back(m);
917      }
918      GenerateVBaseOffsets(offsets, Base, Offset);
919    }
920  }
921
922  void StartNewTable() {
923    SeenVBase.clear();
924  }
925
926  inline uint32_t nottoobig(uint64_t t) {
927    assert(t < (uint32_t)-1ULL || "vtable too big");
928    return t;
929  }
930#if 0
931  inline uint32_t nottoobig(uint32_t t) {
932    return t;
933  }
934#endif
935
936  void AddMethod(const CXXMethodDecl *MD, int32_t FirstIndex) {
937    typedef CXXMethodDecl::method_iterator meth_iter;
938
939    llvm::Constant *m;
940    m = CGM.GetAddrOfFunction(GlobalDecl(MD), Ptr8Ty);
941    m = llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
942
943    // FIXME: Don't like the nested loops.  For very large inheritance
944    // heirarchies we could have a table on the side with the final overridder
945    // and just replace each instance of an overridden method once.  Would be
946    // nice to measure the cost/benefit on real code.
947
948    // If we can find a previously allocated slot for this, reuse it.
949    for (meth_iter mi = MD->begin_overridden_methods(),
950           e = MD->end_overridden_methods();
951         mi != e; ++mi) {
952      const CXXMethodDecl *OMD = *mi;
953      llvm::Constant *om;
954      om = CGM.GetAddrOfFunction(GlobalDecl(OMD), Ptr8Ty);
955      om = llvm::ConstantExpr::getBitCast(om, Ptr8Ty);
956
957      for (int32_t i = FirstIndex, e = nottoobig(methods.size()); i != e; ++i) {
958        // FIXME: begin_overridden_methods might be too lax, covariance */
959        if (methods[i] == om) {
960          methods[i] = m;
961          Index[MD] = i;
962          return;
963        }
964      }
965    }
966
967    // else allocate a new slot.
968    Index[MD] = methods.size();
969    methods.push_back(m);
970  }
971
972  void GenerateMethods(const CXXRecordDecl *RD, int32_t FirstIndex) {
973    for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
974         ++mi)
975      if (mi->isVirtual())
976        AddMethod(*mi, FirstIndex);
977  }
978
979  void GenerateVtableForBase(const CXXRecordDecl *RD,
980                             bool forPrimary,
981                             bool VBoundary,
982                             int64_t Offset,
983                             bool ForVirtualBase,
984                             int32_t FirstIndex) {
985    llvm::Constant *m = llvm::Constant::getNullValue(Ptr8Ty);
986
987    if (RD && !RD->isDynamicClass())
988      return;
989
990    const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
991    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
992    const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
993
994    if (VBoundary || forPrimary || ForVirtualBase) {
995      // then comes the the vcall offsets for all our functions...
996      GenerateVcalls(RD, VBoundary, !forPrimary && ForVirtualBase);
997    }
998
999    // The virtual base offsets come first...
1000    // FIXME: Audit, is this right?
1001    if (PrimaryBase == 0 || forPrimary || !PrimaryBaseWasVirtual) {
1002      std::vector<llvm::Constant *> offsets;
1003      GenerateVBaseOffsets(offsets, RD, Offset);
1004      for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(),
1005             e = offsets.rend(); i != e; ++i)
1006        methods.push_back(*i);
1007    }
1008
1009    bool Top = true;
1010
1011    // vtables are composed from the chain of primaries.
1012    if (PrimaryBase) {
1013      if (PrimaryBaseWasVirtual)
1014        IndirectPrimary.insert(PrimaryBase);
1015      Top = false;
1016      GenerateVtableForBase(PrimaryBase, true, PrimaryBaseWasVirtual|VBoundary,
1017                            Offset, PrimaryBaseWasVirtual, FirstIndex);
1018    }
1019
1020    if (Top) {
1021      int64_t BaseOffset;
1022      if (ForVirtualBase) {
1023        BaseOffset = -(BLayout.getVBaseClassOffset(RD) / 8);
1024      } else
1025        BaseOffset = -Offset/8;
1026      m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), BaseOffset);
1027      m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
1028      methods.push_back(m);
1029      methods.push_back(rtti);
1030    }
1031
1032    // And add the virtuals for the class to the primary vtable.
1033    GenerateMethods(RD, FirstIndex);
1034
1035    // and then the non-virtual bases.
1036    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1037           e = RD->bases_end(); i != e; ++i) {
1038      if (i->isVirtual())
1039        continue;
1040      const CXXRecordDecl *Base =
1041        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1042      if (Base != PrimaryBase || PrimaryBaseWasVirtual) {
1043        uint64_t o = Offset + Layout.getBaseClassOffset(Base);
1044        StartNewTable();
1045        FirstIndex = methods.size();
1046        GenerateVtableForBase(Base, true, false, o, false, FirstIndex);
1047      }
1048    }
1049  }
1050
1051  void GenerateVtableForVBases(const CXXRecordDecl *RD,
1052                               const CXXRecordDecl *Class) {
1053    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1054           e = RD->bases_end(); i != e; ++i) {
1055      const CXXRecordDecl *Base =
1056        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1057      if (i->isVirtual() && !IndirectPrimary.count(Base)) {
1058        // Mark it so we don't output it twice.
1059        IndirectPrimary.insert(Base);
1060        StartNewTable();
1061        int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
1062        int32_t FirstIndex = methods.size();
1063        GenerateVtableForBase(Base, false, true, BaseOffset, true, FirstIndex);
1064      }
1065      if (Base->getNumVBases())
1066        GenerateVtableForVBases(Base, Class);
1067    }
1068  }
1069};
1070
1071llvm::Value *CodeGenFunction::GenerateVtable(const CXXRecordDecl *RD) {
1072  llvm::SmallString<256> OutName;
1073  llvm::raw_svector_ostream Out(OutName);
1074  QualType ClassTy;
1075  ClassTy = getContext().getTagDeclType(RD);
1076  mangleCXXVtable(ClassTy, getContext(), Out);
1077  llvm::GlobalVariable::LinkageTypes linktype;
1078  linktype = llvm::GlobalValue::WeakAnyLinkage;
1079  std::vector<llvm::Constant *> methods;
1080  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1081  int64_t Offset = 0;
1082
1083  Offset += LLVMPointerWidth;
1084  Offset += LLVMPointerWidth;
1085
1086  VtableBuilder b(methods, RD, CGM);
1087
1088  // First comes the vtables for all the non-virtual bases...
1089  b.GenerateVtableForBase(RD, true, false, 0, false, 0);
1090
1091  // then the vtables for all the virtual bases.
1092  b.GenerateVtableForVBases(RD, RD);
1093
1094  llvm::Constant *C;
1095  llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, methods.size());
1096  C = llvm::ConstantArray::get(type, methods);
1097  llvm::Value *vtable = new llvm::GlobalVariable(CGM.getModule(), type, true,
1098                                                 linktype, C, Out.str());
1099  vtable = Builder.CreateBitCast(vtable, Ptr8Ty);
1100  vtable = Builder.CreateGEP(vtable,
1101                       llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
1102                                                    Offset/8));
1103  return vtable;
1104}
1105
1106/// EmitClassMemberwiseCopy - This routine generates code to copy a class
1107/// object from SrcValue to DestValue. Copying can be either a bitwise copy
1108/// of via a copy constructor call.
1109void CodeGenFunction::EmitClassMemberwiseCopy(
1110                        llvm::Value *Dest, llvm::Value *Src,
1111                        const CXXRecordDecl *ClassDecl,
1112                        const CXXRecordDecl *BaseClassDecl, QualType Ty) {
1113  if (ClassDecl) {
1114    Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl);
1115    Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ;
1116  }
1117  if (BaseClassDecl->hasTrivialCopyConstructor()) {
1118    EmitAggregateCopy(Dest, Src, Ty);
1119    return;
1120  }
1121
1122  if (CXXConstructorDecl *BaseCopyCtor =
1123      BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1124    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1125                                                      Ctor_Complete);
1126    CallArgList CallArgs;
1127    // Push the this (Dest) ptr.
1128    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1129                                      BaseCopyCtor->getThisType(getContext())));
1130
1131    // Push the Src ptr.
1132    CallArgs.push_back(std::make_pair(RValue::get(Src),
1133                       BaseCopyCtor->getParamDecl(0)->getType()));
1134    QualType ResultType =
1135    BaseCopyCtor->getType()->getAsFunctionType()->getResultType();
1136    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1137             Callee, CallArgs, BaseCopyCtor);
1138  }
1139}
1140
1141/// EmitClassCopyAssignment - This routine generates code to copy assign a class
1142/// object from SrcValue to DestValue. Assignment can be either a bitwise
1143/// assignment of via an assignment operator call.
1144void CodeGenFunction::EmitClassCopyAssignment(
1145                                        llvm::Value *Dest, llvm::Value *Src,
1146                                        const CXXRecordDecl *ClassDecl,
1147                                        const CXXRecordDecl *BaseClassDecl,
1148                                        QualType Ty) {
1149  if (ClassDecl) {
1150    Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl);
1151    Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ;
1152  }
1153  if (BaseClassDecl->hasTrivialCopyAssignment()) {
1154    EmitAggregateCopy(Dest, Src, Ty);
1155    return;
1156  }
1157
1158  const CXXMethodDecl *MD = 0;
1159  bool ConstCopyAssignOp = BaseClassDecl->hasConstCopyAssignment(getContext(),
1160                                                                 MD);
1161  assert(ConstCopyAssignOp && "EmitClassCopyAssignment - missing copy assign");
1162  (void)ConstCopyAssignOp;
1163
1164  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
1165  const llvm::Type *LTy =
1166    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1167                                   FPT->isVariadic());
1168  llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), LTy);
1169
1170  CallArgList CallArgs;
1171  // Push the this (Dest) ptr.
1172  CallArgs.push_back(std::make_pair(RValue::get(Dest),
1173                                    MD->getThisType(getContext())));
1174
1175  // Push the Src ptr.
1176  CallArgs.push_back(std::make_pair(RValue::get(Src),
1177                                    MD->getParamDecl(0)->getType()));
1178  QualType ResultType =
1179    MD->getType()->getAsFunctionType()->getResultType();
1180  EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1181           Callee, CallArgs, MD);
1182}
1183
1184/// SynthesizeDefaultConstructor - synthesize a default constructor
1185void
1186CodeGenFunction::SynthesizeDefaultConstructor(const CXXConstructorDecl *CD,
1187                                              const FunctionDecl *FD,
1188                                              llvm::Function *Fn,
1189                                              const FunctionArgList &Args) {
1190  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1191  EmitCtorPrologue(CD);
1192  FinishFunction();
1193}
1194
1195/// SynthesizeCXXCopyConstructor - This routine implicitly defines body of a copy
1196/// constructor, in accordance with section 12.8 (p7 and p8) of C++03
1197/// The implicitly-defined copy constructor for class X performs a memberwise
1198/// copy of its subobjects. The order of copying is the same as the order
1199/// of initialization of bases and members in a user-defined constructor
1200/// Each subobject is copied in the manner appropriate to its type:
1201///  if the subobject is of class type, the copy constructor for the class is
1202///  used;
1203///  if the subobject is an array, each element is copied, in the manner
1204///  appropriate to the element type;
1205///  if the subobject is of scalar type, the built-in assignment operator is
1206///  used.
1207/// Virtual base class subobjects shall be copied only once by the
1208/// implicitly-defined copy constructor
1209
1210void CodeGenFunction::SynthesizeCXXCopyConstructor(const CXXConstructorDecl *CD,
1211                                       const FunctionDecl *FD,
1212                                       llvm::Function *Fn,
1213                                       const FunctionArgList &Args) {
1214  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1215  assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
1216         "SynthesizeCXXCopyConstructor - copy constructor has definition already");
1217  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1218
1219  FunctionArgList::const_iterator i = Args.begin();
1220  const VarDecl *ThisArg = i->first;
1221  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1222  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1223  const VarDecl *SrcArg = (i+1)->first;
1224  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1225  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1226
1227  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1228       Base != ClassDecl->bases_end(); ++Base) {
1229    // FIXME. copy constrution of virtual base NYI
1230    if (Base->isVirtual())
1231      continue;
1232
1233    CXXRecordDecl *BaseClassDecl
1234      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1235    EmitClassMemberwiseCopy(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1236                            Base->getType());
1237  }
1238
1239  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1240       FieldEnd = ClassDecl->field_end();
1241       Field != FieldEnd; ++Field) {
1242    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1243
1244    // FIXME. How about copying arrays!
1245    assert(!getContext().getAsArrayType(FieldType) &&
1246           "FIXME. Copying arrays NYI");
1247
1248    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1249      CXXRecordDecl *FieldClassDecl
1250        = cast<CXXRecordDecl>(FieldClassType->getDecl());
1251      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1252      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1253
1254      EmitClassMemberwiseCopy(LHS.getAddress(), RHS.getAddress(),
1255                              0 /*ClassDecl*/, FieldClassDecl, FieldType);
1256      continue;
1257    }
1258    // Do a built-in assignment of scalar data members.
1259    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1260    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1261    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1262    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1263  }
1264  FinishFunction();
1265}
1266
1267/// SynthesizeCXXCopyAssignment - Implicitly define copy assignment operator.
1268/// Before the implicitly-declared copy assignment operator for a class is
1269/// implicitly defined, all implicitly- declared copy assignment operators for
1270/// its direct base classes and its nonstatic data members shall have been
1271/// implicitly defined. [12.8-p12]
1272/// The implicitly-defined copy assignment operator for class X performs
1273/// memberwise assignment of its subob- jects. The direct base classes of X are
1274/// assigned first, in the order of their declaration in
1275/// the base-specifier-list, and then the immediate nonstatic data members of X
1276/// are assigned, in the order in which they were declared in the class
1277/// definition.Each subobject is assigned in the manner appropriate to its type:
1278///   if the subobject is of class type, the copy assignment operator for the
1279///   class is used (as if by explicit qualification; that is, ignoring any
1280///   possible virtual overriding functions in more derived classes);
1281///
1282///   if the subobject is an array, each element is assigned, in the manner
1283///   appropriate to the element type;
1284///
1285///   if the subobject is of scalar type, the built-in assignment operator is
1286///   used.
1287void CodeGenFunction::SynthesizeCXXCopyAssignment(const CXXMethodDecl *CD,
1288                                                  const FunctionDecl *FD,
1289                                                  llvm::Function *Fn,
1290                                                  const FunctionArgList &Args) {
1291
1292  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1293  assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
1294         "SynthesizeCXXCopyAssignment - copy assignment has user declaration");
1295  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1296
1297  FunctionArgList::const_iterator i = Args.begin();
1298  const VarDecl *ThisArg = i->first;
1299  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1300  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1301  const VarDecl *SrcArg = (i+1)->first;
1302  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1303  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1304
1305  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1306       Base != ClassDecl->bases_end(); ++Base) {
1307    // FIXME. copy assignment of virtual base NYI
1308    if (Base->isVirtual())
1309      continue;
1310
1311    CXXRecordDecl *BaseClassDecl
1312      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1313    EmitClassCopyAssignment(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1314                            Base->getType());
1315  }
1316
1317  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1318       FieldEnd = ClassDecl->field_end();
1319       Field != FieldEnd; ++Field) {
1320    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1321
1322    // FIXME. How about copy assignment of  arrays!
1323    assert(!getContext().getAsArrayType(FieldType) &&
1324           "FIXME. Copy assignment of arrays NYI");
1325
1326    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1327      CXXRecordDecl *FieldClassDecl
1328      = cast<CXXRecordDecl>(FieldClassType->getDecl());
1329      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1330      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1331
1332      EmitClassCopyAssignment(LHS.getAddress(), RHS.getAddress(),
1333                              0 /*ClassDecl*/, FieldClassDecl, FieldType);
1334      continue;
1335    }
1336    // Do a built-in assignment of scalar data members.
1337    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1338    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1339    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1340    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1341  }
1342
1343  // return *this;
1344  Builder.CreateStore(LoadOfThis, ReturnValue);
1345
1346  FinishFunction();
1347}
1348
1349/// EmitCtorPrologue - This routine generates necessary code to initialize
1350/// base classes and non-static data members belonging to this constructor.
1351void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD) {
1352  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1353  // FIXME: Add vbase initialization
1354  llvm::Value *LoadOfThis = 0;
1355
1356  for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
1357       E = CD->init_end();
1358       B != E; ++B) {
1359    CXXBaseOrMemberInitializer *Member = (*B);
1360    if (Member->isBaseInitializer()) {
1361      LoadOfThis = LoadCXXThis();
1362      Type *BaseType = Member->getBaseClass();
1363      CXXRecordDecl *BaseClassDecl =
1364        cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
1365      llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl,
1366                                             BaseClassDecl);
1367      EmitCXXConstructorCall(Member->getConstructor(),
1368                             Ctor_Complete, V,
1369                             Member->const_arg_begin(),
1370                             Member->const_arg_end());
1371    } else {
1372      // non-static data member initilaizers.
1373      FieldDecl *Field = Member->getMember();
1374      QualType FieldType = getContext().getCanonicalType((Field)->getType());
1375      assert(!getContext().getAsArrayType(FieldType)
1376             && "FIXME. Field arrays initialization unsupported");
1377
1378      LoadOfThis = LoadCXXThis();
1379      LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
1380      if (FieldType->getAs<RecordType>()) {
1381        if (!Field->isAnonymousStructOrUnion()) {
1382          assert(Member->getConstructor() &&
1383                 "EmitCtorPrologue - no constructor to initialize member");
1384          EmitCXXConstructorCall(Member->getConstructor(),
1385                                 Ctor_Complete, LHS.getAddress(),
1386                                 Member->const_arg_begin(),
1387                                 Member->const_arg_end());
1388          continue;
1389        }
1390        else {
1391          // Initializing an anonymous union data member.
1392          FieldDecl *anonMember = Member->getAnonUnionMember();
1393          LHS = EmitLValueForField(LHS.getAddress(), anonMember, false, 0);
1394          FieldType = anonMember->getType();
1395        }
1396      }
1397
1398      assert(Member->getNumArgs() == 1 && "Initializer count must be 1 only");
1399      Expr *RhsExpr = *Member->arg_begin();
1400      llvm::Value *RHS = EmitScalarExpr(RhsExpr, true);
1401      EmitStoreThroughLValue(RValue::get(RHS), LHS, FieldType);
1402    }
1403  }
1404
1405  if (!CD->getNumBaseOrMemberInitializers() && !CD->isTrivial()) {
1406    // Nontrivial default constructor with no initializer list. It may still
1407    // have bases classes and/or contain non-static data members which require
1408    // construction.
1409    for (CXXRecordDecl::base_class_const_iterator Base =
1410          ClassDecl->bases_begin();
1411          Base != ClassDecl->bases_end(); ++Base) {
1412      // FIXME. copy assignment of virtual base NYI
1413      if (Base->isVirtual())
1414        continue;
1415
1416      CXXRecordDecl *BaseClassDecl
1417        = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1418      if (BaseClassDecl->hasTrivialConstructor())
1419        continue;
1420      if (CXXConstructorDecl *BaseCX =
1421            BaseClassDecl->getDefaultConstructor(getContext())) {
1422        LoadOfThis = LoadCXXThis();
1423        llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl,
1424                                               BaseClassDecl);
1425        EmitCXXConstructorCall(BaseCX, Ctor_Complete, V, 0, 0);
1426      }
1427    }
1428
1429    for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1430         FieldEnd = ClassDecl->field_end();
1431         Field != FieldEnd; ++Field) {
1432      QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1433      const ConstantArrayType *Array =
1434        getContext().getAsConstantArrayType(FieldType);
1435      if (Array)
1436        FieldType = getContext().getBaseElementType(FieldType);
1437      if (!FieldType->getAs<RecordType>() || Field->isAnonymousStructOrUnion())
1438        continue;
1439      const RecordType *ClassRec = FieldType->getAs<RecordType>();
1440      CXXRecordDecl *MemberClassDecl =
1441        dyn_cast<CXXRecordDecl>(ClassRec->getDecl());
1442      if (!MemberClassDecl || MemberClassDecl->hasTrivialConstructor())
1443        continue;
1444      if (CXXConstructorDecl *MamberCX =
1445            MemberClassDecl->getDefaultConstructor(getContext())) {
1446        LoadOfThis = LoadCXXThis();
1447        LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1448        if (Array) {
1449          const llvm::Type *BasePtr = ConvertType(FieldType);
1450          BasePtr = llvm::PointerType::getUnqual(BasePtr);
1451          llvm::Value *BaseAddrPtr =
1452            Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1453          EmitCXXAggrConstructorCall(MamberCX, Array, BaseAddrPtr);
1454        }
1455        else
1456          EmitCXXConstructorCall(MamberCX, Ctor_Complete, LHS.getAddress(),
1457                                 0, 0);
1458      }
1459    }
1460  }
1461
1462  // Initialize the vtable pointer
1463  if (ClassDecl->isDynamicClass()) {
1464    if (!LoadOfThis)
1465      LoadOfThis = LoadCXXThis();
1466    llvm::Value *VtableField;
1467    llvm::Type *Ptr8Ty, *PtrPtr8Ty;
1468    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
1469    PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0);
1470    VtableField = Builder.CreateBitCast(LoadOfThis, PtrPtr8Ty);
1471    llvm::Value *vtable = GenerateVtable(ClassDecl);
1472    Builder.CreateStore(vtable, VtableField);
1473  }
1474}
1475
1476/// EmitDtorEpilogue - Emit all code that comes at the end of class's
1477/// destructor. This is to call destructors on members and base classes
1478/// in reverse order of their construction.
1479void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD) {
1480  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext());
1481  assert(!ClassDecl->isPolymorphic() &&
1482         "FIXME. polymorphic destruction not supported");
1483  (void)ClassDecl;  // prevent warning.
1484
1485  for (CXXDestructorDecl::destr_const_iterator *B = DD->destr_begin(),
1486       *E = DD->destr_end(); B != E; ++B) {
1487    uintptr_t BaseOrMember = (*B);
1488    if (DD->isMemberToDestroy(BaseOrMember)) {
1489      FieldDecl *FD = DD->getMemberToDestroy(BaseOrMember);
1490      QualType FieldType = getContext().getCanonicalType((FD)->getType());
1491      const ConstantArrayType *Array =
1492        getContext().getAsConstantArrayType(FieldType);
1493      if (Array)
1494        FieldType = getContext().getBaseElementType(FieldType);
1495      const RecordType *RT = FieldType->getAs<RecordType>();
1496      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1497      if (FieldClassDecl->hasTrivialDestructor())
1498        continue;
1499      llvm::Value *LoadOfThis = LoadCXXThis();
1500      LValue LHS = EmitLValueForField(LoadOfThis, FD, false, 0);
1501      if (Array) {
1502        const llvm::Type *BasePtr = ConvertType(FieldType);
1503        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1504        llvm::Value *BaseAddrPtr =
1505          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1506        EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1507                                  Array, BaseAddrPtr);
1508      }
1509      else
1510        EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1511                              Dtor_Complete, LHS.getAddress());
1512    } else {
1513      const RecordType *RT =
1514        DD->getAnyBaseClassToDestroy(BaseOrMember)->getAs<RecordType>();
1515      CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1516      if (BaseClassDecl->hasTrivialDestructor())
1517        continue;
1518      llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(),
1519                                             ClassDecl,BaseClassDecl);
1520      EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1521                            Dtor_Complete, V);
1522    }
1523  }
1524  if (DD->getNumBaseOrMemberDestructions() || DD->isTrivial())
1525    return;
1526  // Case of destructor synthesis with fields and base classes
1527  // which have non-trivial destructors. They must be destructed in
1528  // reverse order of their construction.
1529  llvm::SmallVector<FieldDecl *, 16> DestructedFields;
1530
1531  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1532       FieldEnd = ClassDecl->field_end();
1533       Field != FieldEnd; ++Field) {
1534    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1535    if (getContext().getAsConstantArrayType(FieldType))
1536      FieldType = getContext().getBaseElementType(FieldType);
1537    if (const RecordType *RT = FieldType->getAs<RecordType>()) {
1538      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1539      if (FieldClassDecl->hasTrivialDestructor())
1540        continue;
1541      DestructedFields.push_back(*Field);
1542    }
1543  }
1544  if (!DestructedFields.empty())
1545    for (int i = DestructedFields.size() -1; i >= 0; --i) {
1546      FieldDecl *Field = DestructedFields[i];
1547      QualType FieldType = Field->getType();
1548      const ConstantArrayType *Array =
1549        getContext().getAsConstantArrayType(FieldType);
1550        if (Array)
1551          FieldType = getContext().getBaseElementType(FieldType);
1552      const RecordType *RT = FieldType->getAs<RecordType>();
1553      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1554      llvm::Value *LoadOfThis = LoadCXXThis();
1555      LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
1556      if (Array) {
1557        const llvm::Type *BasePtr = ConvertType(FieldType);
1558        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1559        llvm::Value *BaseAddrPtr =
1560        Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1561        EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1562                                  Array, BaseAddrPtr);
1563      }
1564      else
1565        EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1566                              Dtor_Complete, LHS.getAddress());
1567    }
1568
1569  llvm::SmallVector<CXXRecordDecl*, 4> DestructedBases;
1570  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1571       Base != ClassDecl->bases_end(); ++Base) {
1572    // FIXME. copy assignment of virtual base NYI
1573    if (Base->isVirtual())
1574      continue;
1575
1576    CXXRecordDecl *BaseClassDecl
1577      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1578    if (BaseClassDecl->hasTrivialDestructor())
1579      continue;
1580    DestructedBases.push_back(BaseClassDecl);
1581  }
1582  if (DestructedBases.empty())
1583    return;
1584  for (int i = DestructedBases.size() -1; i >= 0; --i) {
1585    CXXRecordDecl *BaseClassDecl = DestructedBases[i];
1586    llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(),
1587                                           ClassDecl,BaseClassDecl);
1588    EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1589                          Dtor_Complete, V);
1590  }
1591}
1592
1593void CodeGenFunction::SynthesizeDefaultDestructor(const CXXDestructorDecl *CD,
1594                                                  const FunctionDecl *FD,
1595                                                  llvm::Function *Fn,
1596                                                  const FunctionArgList &Args) {
1597
1598  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1599  assert(!ClassDecl->hasUserDeclaredDestructor() &&
1600         "SynthesizeDefaultDestructor - destructor has user declaration");
1601  (void) ClassDecl;
1602
1603  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1604  EmitDtorEpilogue(CD);
1605  FinishFunction();
1606}
1607