CGCXX.cpp revision 4f68d537c3f072366b25f3137f052eee36fddfcd 
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::getInt64Ty(VMContext),
350                                           "loop.index");
351  llvm::Value* zeroConstant =
352    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(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 = getContext().getConstantArrayElementCount(CA);
366  llvm::Value * NumElementsPtr =
367    llvm::ConstantInt::get(llvm::Type::getInt64Ty(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  llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
380  EmitCXXConstructorCall(D, Ctor_Complete, Address, 0, 0);
381
382  EmitBlock(ContinueBlock);
383
384  // Emit the increment of the loop counter.
385  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
386  Counter = Builder.CreateLoad(IndexPtr);
387  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
388  Builder.CreateStore(NextVal, IndexPtr, false);
389
390  // Finally, branch back up to the condition for the next iteration.
391  EmitBranch(CondBlock);
392
393  // Emit the fall-through block.
394  EmitBlock(AfterFor, true);
395}
396
397/// EmitCXXAggrDestructorCall - calls the default destructor on array
398/// elements in reverse order of construction.
399void
400CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
401                                           const ArrayType *Array,
402                                           llvm::Value *This) {
403  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
404  assert(CA && "Do we support VLA for destruction ?");
405  llvm::Value *One = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
406                                            1);
407  uint64_t ElementCount = getContext().getConstantArrayElementCount(CA);
408  // Create a temporary for the loop index and initialize it with count of
409  // array elements.
410  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
411                                           "loop.index");
412  // Index = ElementCount;
413  llvm::Value* UpperCount =
414    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), ElementCount);
415  Builder.CreateStore(UpperCount, IndexPtr, false);
416
417  // Start the loop with a block that tests the condition.
418  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
419  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
420
421  EmitBlock(CondBlock);
422
423  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
424
425  // Generate: if (loop-index != 0 fall to the loop body,
426  // otherwise, go to the block after the for-loop.
427  llvm::Value* zeroConstant =
428    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
429  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
430  llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant,
431                                            "isne");
432  // If the condition is true, execute the body.
433  Builder.CreateCondBr(IsNE, ForBody, AfterFor);
434
435  EmitBlock(ForBody);
436
437  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
438  // Inside the loop body, emit the constructor call on the array element.
439  Counter = Builder.CreateLoad(IndexPtr);
440  Counter = Builder.CreateSub(Counter, One);
441  llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
442  EmitCXXDestructorCall(D, Dtor_Complete, Address);
443
444  EmitBlock(ContinueBlock);
445
446  // Emit the decrement of the loop counter.
447  Counter = Builder.CreateLoad(IndexPtr);
448  Counter = Builder.CreateSub(Counter, One, "dec");
449  Builder.CreateStore(Counter, IndexPtr, false);
450
451  // Finally, branch back up to the condition for the next iteration.
452  EmitBranch(CondBlock);
453
454  // Emit the fall-through block.
455  EmitBlock(AfterFor, true);
456}
457
458void
459CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
460                                        CXXCtorType Type,
461                                        llvm::Value *This,
462                                        CallExpr::const_arg_iterator ArgBeg,
463                                        CallExpr::const_arg_iterator ArgEnd) {
464  if (D->isCopyConstructor(getContext())) {
465    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D->getDeclContext());
466    if (ClassDecl->hasTrivialCopyConstructor()) {
467      assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
468             "EmitCXXConstructorCall - user declared copy constructor");
469      const Expr *E = (*ArgBeg);
470      QualType Ty = E->getType();
471      llvm::Value *Src = EmitLValue(E).getAddress();
472      EmitAggregateCopy(This, Src, Ty);
473      return;
474    }
475  }
476
477  llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
478
479  EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd);
480}
481
482void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D,
483                                            CXXDtorType Type,
484                                            llvm::Value *This) {
485  llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type);
486
487  EmitCXXMemberCall(D, Callee, This, 0, 0);
488}
489
490void
491CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
492                                      const CXXConstructExpr *E) {
493  assert(Dest && "Must have a destination!");
494
495  const CXXRecordDecl *RD =
496  cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
497  if (RD->hasTrivialConstructor())
498    return;
499
500  // Code gen optimization to eliminate copy constructor and return
501  // its first argument instead.
502  if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
503    CXXConstructExpr::const_arg_iterator i = E->arg_begin();
504    EmitAggExpr((*i), Dest, false);
505    return;
506  }
507  // Call the constructor.
508  EmitCXXConstructorCall(E->getConstructor(), Ctor_Complete, Dest,
509                         E->arg_begin(), E->arg_end());
510}
511
512llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
513  if (E->isArray()) {
514    ErrorUnsupported(E, "new[] expression");
515    return llvm::UndefValue::get(ConvertType(E->getType()));
516  }
517
518  QualType AllocType = E->getAllocatedType();
519  FunctionDecl *NewFD = E->getOperatorNew();
520  const FunctionProtoType *NewFTy = NewFD->getType()->getAsFunctionProtoType();
521
522  CallArgList NewArgs;
523
524  // The allocation size is the first argument.
525  QualType SizeTy = getContext().getSizeType();
526  llvm::Value *AllocSize =
527    llvm::ConstantInt::get(ConvertType(SizeTy),
528                           getContext().getTypeSize(AllocType) / 8);
529
530  NewArgs.push_back(std::make_pair(RValue::get(AllocSize), SizeTy));
531
532  // Emit the rest of the arguments.
533  // FIXME: Ideally, this should just use EmitCallArgs.
534  CXXNewExpr::const_arg_iterator NewArg = E->placement_arg_begin();
535
536  // First, use the types from the function type.
537  // We start at 1 here because the first argument (the allocation size)
538  // has already been emitted.
539  for (unsigned i = 1, e = NewFTy->getNumArgs(); i != e; ++i, ++NewArg) {
540    QualType ArgType = NewFTy->getArgType(i);
541
542    assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
543           getTypePtr() ==
544           getContext().getCanonicalType(NewArg->getType()).getTypePtr() &&
545           "type mismatch in call argument!");
546
547    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
548                                     ArgType));
549
550  }
551
552  // Either we've emitted all the call args, or we have a call to a
553  // variadic function.
554  assert((NewArg == E->placement_arg_end() || NewFTy->isVariadic()) &&
555         "Extra arguments in non-variadic function!");
556
557  // If we still have any arguments, emit them using the type of the argument.
558  for (CXXNewExpr::const_arg_iterator NewArgEnd = E->placement_arg_end();
559       NewArg != NewArgEnd; ++NewArg) {
560    QualType ArgType = NewArg->getType();
561    NewArgs.push_back(std::make_pair(EmitCallArg(*NewArg, ArgType),
562                                     ArgType));
563  }
564
565  // Emit the call to new.
566  RValue RV =
567    EmitCall(CGM.getTypes().getFunctionInfo(NewFTy->getResultType(), NewArgs),
568             CGM.GetAddrOfFunction(GlobalDecl(NewFD)),
569             NewArgs, NewFD);
570
571  // If an allocation function is declared with an empty exception specification
572  // it returns null to indicate failure to allocate storage. [expr.new]p13.
573  // (We don't need to check for null when there's no new initializer and
574  // we're allocating a POD type).
575  bool NullCheckResult = NewFTy->hasEmptyExceptionSpec() &&
576    !(AllocType->isPODType() && !E->hasInitializer());
577
578  llvm::BasicBlock *NewNull = 0;
579  llvm::BasicBlock *NewNotNull = 0;
580  llvm::BasicBlock *NewEnd = 0;
581
582  llvm::Value *NewPtr = RV.getScalarVal();
583
584  if (NullCheckResult) {
585    NewNull = createBasicBlock("new.null");
586    NewNotNull = createBasicBlock("new.notnull");
587    NewEnd = createBasicBlock("new.end");
588
589    llvm::Value *IsNull =
590      Builder.CreateICmpEQ(NewPtr,
591                           llvm::Constant::getNullValue(NewPtr->getType()),
592                           "isnull");
593
594    Builder.CreateCondBr(IsNull, NewNull, NewNotNull);
595    EmitBlock(NewNotNull);
596  }
597
598  NewPtr = Builder.CreateBitCast(NewPtr, ConvertType(E->getType()));
599
600  if (AllocType->isPODType()) {
601    if (E->getNumConstructorArgs() > 0) {
602      assert(E->getNumConstructorArgs() == 1 &&
603             "Can only have one argument to initializer of POD type.");
604
605      const Expr *Init = E->getConstructorArg(0);
606
607      if (!hasAggregateLLVMType(AllocType))
608        Builder.CreateStore(EmitScalarExpr(Init), NewPtr);
609      else if (AllocType->isAnyComplexType())
610        EmitComplexExprIntoAddr(Init, NewPtr, AllocType.isVolatileQualified());
611      else
612        EmitAggExpr(Init, NewPtr, AllocType.isVolatileQualified());
613    }
614  } else {
615    // Call the constructor.
616    CXXConstructorDecl *Ctor = E->getConstructor();
617
618    EmitCXXConstructorCall(Ctor, Ctor_Complete, NewPtr,
619                           E->constructor_arg_begin(),
620                           E->constructor_arg_end());
621  }
622
623  if (NullCheckResult) {
624    Builder.CreateBr(NewEnd);
625    EmitBlock(NewNull);
626    Builder.CreateBr(NewEnd);
627    EmitBlock(NewEnd);
628
629    llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
630    PHI->reserveOperandSpace(2);
631    PHI->addIncoming(NewPtr, NewNotNull);
632    PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull);
633
634    NewPtr = PHI;
635  }
636
637  return NewPtr;
638}
639
640void CodeGenFunction::EmitCXXDeleteExpr(const CXXDeleteExpr *E) {
641  if (E->isArrayForm()) {
642    ErrorUnsupported(E, "delete[] expression");
643    return;
644  };
645
646  QualType DeleteTy =
647    E->getArgument()->getType()->getAs<PointerType>()->getPointeeType();
648
649  llvm::Value *Ptr = EmitScalarExpr(E->getArgument());
650
651  // Null check the pointer.
652  llvm::BasicBlock *DeleteNotNull = createBasicBlock("delete.notnull");
653  llvm::BasicBlock *DeleteEnd = createBasicBlock("delete.end");
654
655  llvm::Value *IsNull =
656    Builder.CreateICmpEQ(Ptr, llvm::Constant::getNullValue(Ptr->getType()),
657                         "isnull");
658
659  Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
660  EmitBlock(DeleteNotNull);
661
662  // Call the destructor if necessary.
663  if (const RecordType *RT = DeleteTy->getAs<RecordType>()) {
664    if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
665      if (!RD->hasTrivialDestructor()) {
666        const CXXDestructorDecl *Dtor = RD->getDestructor(getContext());
667        if (Dtor->isVirtual()) {
668          ErrorUnsupported(E, "delete expression with virtual destructor");
669          return;
670        }
671
672        EmitCXXDestructorCall(Dtor, Dtor_Complete, Ptr);
673      }
674    }
675  }
676
677  // Call delete.
678  FunctionDecl *DeleteFD = E->getOperatorDelete();
679  const FunctionProtoType *DeleteFTy =
680    DeleteFD->getType()->getAsFunctionProtoType();
681
682  CallArgList DeleteArgs;
683
684  QualType ArgTy = DeleteFTy->getArgType(0);
685  llvm::Value *DeletePtr = Builder.CreateBitCast(Ptr, ConvertType(ArgTy));
686  DeleteArgs.push_back(std::make_pair(RValue::get(DeletePtr), ArgTy));
687
688  // Emit the call to delete.
689  EmitCall(CGM.getTypes().getFunctionInfo(DeleteFTy->getResultType(),
690                                          DeleteArgs),
691           CGM.GetAddrOfFunction(GlobalDecl(DeleteFD)),
692           DeleteArgs, DeleteFD);
693
694  EmitBlock(DeleteEnd);
695}
696
697static bool canGenerateCXXstructor(const CXXRecordDecl *RD,
698                                   ASTContext &Context) {
699  // The class has base classes - we don't support that right now.
700  if (RD->getNumBases() > 0)
701    return false;
702
703  for (CXXRecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
704         I != E; ++I) {
705    // We don't support ctors for fields that aren't POD.
706    if (!I->getType()->isPODType())
707      return false;
708  }
709
710  return true;
711}
712
713void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
714  if (!canGenerateCXXstructor(D->getParent(), getContext())) {
715    ErrorUnsupported(D, "C++ constructor", true);
716    return;
717  }
718
719  EmitGlobal(GlobalDecl(D, Ctor_Complete));
720  EmitGlobal(GlobalDecl(D, Ctor_Base));
721}
722
723void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D,
724                                       CXXCtorType Type) {
725
726  llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type);
727
728  CodeGenFunction(*this).GenerateCode(D, Fn);
729
730  SetFunctionDefinitionAttributes(D, Fn);
731  SetLLVMFunctionAttributesForDefinition(D, Fn);
732}
733
734llvm::Function *
735CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D,
736                                       CXXCtorType Type) {
737  const llvm::FunctionType *FTy =
738    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
739
740  const char *Name = getMangledCXXCtorName(D, Type);
741  return cast<llvm::Function>(
742                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
743}
744
745const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D,
746                                                 CXXCtorType Type) {
747  llvm::SmallString<256> Name;
748  llvm::raw_svector_ostream Out(Name);
749  mangleCXXCtor(D, Type, Context, Out);
750
751  Name += '\0';
752  return UniqueMangledName(Name.begin(), Name.end());
753}
754
755void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
756  if (!canGenerateCXXstructor(D->getParent(), getContext())) {
757    ErrorUnsupported(D, "C++ destructor", true);
758    return;
759  }
760
761  EmitCXXDestructor(D, Dtor_Complete);
762  EmitCXXDestructor(D, Dtor_Base);
763}
764
765void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D,
766                                      CXXDtorType Type) {
767  llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type);
768
769  CodeGenFunction(*this).GenerateCode(D, Fn);
770
771  SetFunctionDefinitionAttributes(D, Fn);
772  SetLLVMFunctionAttributesForDefinition(D, Fn);
773}
774
775llvm::Function *
776CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D,
777                                      CXXDtorType Type) {
778  const llvm::FunctionType *FTy =
779    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
780
781  const char *Name = getMangledCXXDtorName(D, Type);
782  return cast<llvm::Function>(
783                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
784}
785
786const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D,
787                                                 CXXDtorType Type) {
788  llvm::SmallString<256> Name;
789  llvm::raw_svector_ostream Out(Name);
790  mangleCXXDtor(D, Type, Context, Out);
791
792  Name += '\0';
793  return UniqueMangledName(Name.begin(), Name.end());
794}
795
796llvm::Constant *CodeGenModule::GenerateRtti(const CXXRecordDecl *RD) {
797  llvm::Type *Ptr8Ty;
798  Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
799  llvm::Constant *Rtti = llvm::Constant::getNullValue(Ptr8Ty);
800
801  if (!getContext().getLangOptions().Rtti)
802    return Rtti;
803
804  llvm::SmallString<256> OutName;
805  llvm::raw_svector_ostream Out(OutName);
806  QualType ClassTy;
807  ClassTy = getContext().getTagDeclType(RD);
808  mangleCXXRtti(ClassTy, getContext(), Out);
809  llvm::GlobalVariable::LinkageTypes linktype;
810  linktype = llvm::GlobalValue::WeakAnyLinkage;
811  std::vector<llvm::Constant *> info;
812  // assert(0 && "FIXME: implement rtti descriptor");
813  // FIXME: descriptor
814  info.push_back(llvm::Constant::getNullValue(Ptr8Ty));
815  // assert(0 && "FIXME: implement rtti ts");
816  // FIXME: TS
817  info.push_back(llvm::Constant::getNullValue(Ptr8Ty));
818
819  llvm::Constant *C;
820  llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, info.size());
821  C = llvm::ConstantArray::get(type, info);
822  Rtti = new llvm::GlobalVariable(getModule(), type, true, linktype, C,
823                                  Out.str());
824  Rtti = llvm::ConstantExpr::getBitCast(Rtti, Ptr8Ty);
825  return Rtti;
826}
827
828class VtableBuilder {
829  std::vector<llvm::Constant *> &methods;
830  llvm::Type *Ptr8Ty;
831  /// Class - The most derived class that this vtable is being built for.
832  const CXXRecordDecl *Class;
833  /// BLayout - Layout for the most derived class that this vtable is being
834  /// built for.
835  const ASTRecordLayout &BLayout;
836  llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
837  llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
838  llvm::Constant *rtti;
839  llvm::LLVMContext &VMContext;
840  CodeGenModule &CGM;  // Per-module state.
841  /// Index - Maps a method decl into a vtable index.  Useful for virtual
842  /// dispatch codegen.
843  llvm::DenseMap<const CXXMethodDecl *, int32_t> Index;
844  typedef CXXRecordDecl::method_iterator method_iter;
845public:
846  VtableBuilder(std::vector<llvm::Constant *> &meth,
847                const CXXRecordDecl *c,
848                CodeGenModule &cgm)
849    : methods(meth), Class(c), BLayout(cgm.getContext().getASTRecordLayout(c)),
850      rtti(cgm.GenerateRtti(c)), VMContext(cgm.getModule().getContext()),
851      CGM(cgm) {
852    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
853  }
854
855  llvm::Constant *GenerateVcall(const CXXMethodDecl *MD,
856                                const CXXRecordDecl *RD,
857                                bool VBoundary,
858                                bool SecondaryVirtual) {
859    typedef CXXMethodDecl::method_iterator meth_iter;
860    // No vcall for methods that don't override in primary vtables.
861    llvm::Constant *m = 0;
862
863    if (SecondaryVirtual || VBoundary)
864      m = llvm::Constant::getNullValue(Ptr8Ty);
865
866    int64_t Offset = 0;
867    int64_t BaseOffset = 0;
868    for (meth_iter mi = MD->begin_overridden_methods(),
869           me = MD->end_overridden_methods();
870         mi != me; ++mi) {
871      const CXXRecordDecl *DefBase = (*mi)->getParent();
872      // FIXME: vcall: offset for virtual base for this function
873      // m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), 900);
874      // m = llvm::Constant::getNullValue(Ptr8Ty);
875      for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
876             e = RD->bases_end(); i != e; ++i) {
877        const CXXRecordDecl *Base =
878          cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
879        if (DefBase == Base) {
880          if (!i->isVirtual())
881            break;
882
883          // FIXME: drop the 700-, just for debugging
884          BaseOffset = 700- -(BLayout.getVBaseClassOffset(Base) / 8);
885          m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
886                                     BaseOffset);
887          m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
888          break;
889        } else {
890          // FIXME: more searching.
891          (void)Offset;
892        }
893      }
894    }
895
896    return m;
897  }
898
899  void GenerateVcalls(const CXXRecordDecl *RD, bool VBoundary,
900                      bool SecondaryVirtual) {
901    llvm::Constant *m;
902
903    for (method_iter mi = RD->method_begin(),
904           me = RD->method_end(); mi != me; ++mi) {
905      if (mi->isVirtual()) {
906        m = GenerateVcall(*mi, RD, VBoundary, SecondaryVirtual);
907        if (m)
908          methods.push_back(m);
909      }
910    }
911  }
912
913  void GenerateVBaseOffsets(std::vector<llvm::Constant *> &offsets,
914                            const CXXRecordDecl *RD, uint64_t Offset) {
915    for (CXXRecordDecl::base_class_const_iterator i =RD->bases_begin(),
916           e = RD->bases_end(); i != e; ++i) {
917      const CXXRecordDecl *Base =
918        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
919      if (i->isVirtual() && !SeenVBase.count(Base)) {
920        SeenVBase.insert(Base);
921        int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
922        llvm::Constant *m;
923        m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),BaseOffset);
924        m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
925        offsets.push_back(m);
926      }
927      GenerateVBaseOffsets(offsets, Base, Offset);
928    }
929  }
930
931  void StartNewTable() {
932    SeenVBase.clear();
933  }
934
935  inline uint32_t nottoobig(uint64_t t) {
936    assert(t < (uint32_t)-1ULL || "vtable too big");
937    return t;
938  }
939#if 0
940  inline uint32_t nottoobig(uint32_t t) {
941    return t;
942  }
943#endif
944
945  void AddMethod(const CXXMethodDecl *MD, int32_t FirstIndex) {
946    typedef CXXMethodDecl::method_iterator meth_iter;
947
948    llvm::Constant *m;
949    m = CGM.GetAddrOfFunction(GlobalDecl(MD), Ptr8Ty);
950    m = llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
951
952    // FIXME: Don't like the nested loops.  For very large inheritance
953    // heirarchies we could have a table on the side with the final overridder
954    // and just replace each instance of an overridden method once.  Would be
955    // nice to measure the cost/benefit on real code.
956
957    // If we can find a previously allocated slot for this, reuse it.
958    for (meth_iter mi = MD->begin_overridden_methods(),
959           e = MD->end_overridden_methods();
960         mi != e; ++mi) {
961      const CXXMethodDecl *OMD = *mi;
962      llvm::Constant *om;
963      om = CGM.GetAddrOfFunction(GlobalDecl(OMD), Ptr8Ty);
964      om = llvm::ConstantExpr::getBitCast(om, Ptr8Ty);
965
966      for (int32_t i = FirstIndex, e = nottoobig(methods.size()); i != e; ++i) {
967        // FIXME: begin_overridden_methods might be too lax, covariance */
968        if (methods[i] == om) {
969          methods[i] = m;
970          Index[MD] = i;
971          return;
972        }
973      }
974    }
975
976    // else allocate a new slot.
977    Index[MD] = methods.size();
978    methods.push_back(m);
979  }
980
981  void GenerateMethods(const CXXRecordDecl *RD, int32_t FirstIndex) {
982    for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
983         ++mi)
984      if (mi->isVirtual())
985        AddMethod(*mi, FirstIndex);
986  }
987
988  int64_t GenerateVtableForBase(const CXXRecordDecl *RD,
989                                bool forPrimary,
990                                bool VBoundary,
991                                int64_t Offset,
992                                bool ForVirtualBase,
993                                int32_t FirstIndex) {
994    llvm::Constant *m = llvm::Constant::getNullValue(Ptr8Ty);
995    int64_t AddressPoint=0;
996
997    if (RD && !RD->isDynamicClass())
998      return 0;
999
1000    const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1001    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1002    const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
1003
1004    if (VBoundary || forPrimary || ForVirtualBase) {
1005      // then comes the the vcall offsets for all our functions...
1006      GenerateVcalls(RD, VBoundary, !forPrimary && ForVirtualBase);
1007    }
1008
1009    // The virtual base offsets come first...
1010    // FIXME: Audit, is this right?
1011    if (PrimaryBase == 0 || forPrimary || !PrimaryBaseWasVirtual) {
1012      std::vector<llvm::Constant *> offsets;
1013      GenerateVBaseOffsets(offsets, RD, Offset);
1014      for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(),
1015             e = offsets.rend(); i != e; ++i)
1016        methods.push_back(*i);
1017    }
1018
1019    bool Top = true;
1020
1021    // vtables are composed from the chain of primaries.
1022    if (PrimaryBase) {
1023      if (PrimaryBaseWasVirtual)
1024        IndirectPrimary.insert(PrimaryBase);
1025      Top = false;
1026      AddressPoint = GenerateVtableForBase(PrimaryBase, true, PrimaryBaseWasVirtual|VBoundary,
1027                                           Offset, PrimaryBaseWasVirtual, FirstIndex);
1028    }
1029
1030    if (Top) {
1031      int64_t BaseOffset;
1032      if (ForVirtualBase) {
1033        BaseOffset = -(BLayout.getVBaseClassOffset(RD) / 8);
1034      } else
1035        BaseOffset = -Offset/8;
1036      m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), BaseOffset);
1037      m = llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
1038      methods.push_back(m);
1039      methods.push_back(rtti);
1040      AddressPoint = methods.size();
1041    }
1042
1043    // And add the virtuals for the class to the primary vtable.
1044    GenerateMethods(RD, FirstIndex);
1045
1046    // and then the non-virtual bases.
1047    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1048           e = RD->bases_end(); i != e; ++i) {
1049      if (i->isVirtual())
1050        continue;
1051      const CXXRecordDecl *Base =
1052        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1053      if (Base != PrimaryBase || PrimaryBaseWasVirtual) {
1054        uint64_t o = Offset + Layout.getBaseClassOffset(Base);
1055        StartNewTable();
1056        FirstIndex = methods.size();
1057        GenerateVtableForBase(Base, true, false, o, false, FirstIndex);
1058      }
1059    }
1060    return AddressPoint;
1061  }
1062
1063  void GenerateVtableForVBases(const CXXRecordDecl *RD,
1064                               const CXXRecordDecl *Class) {
1065    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1066           e = RD->bases_end(); i != e; ++i) {
1067      const CXXRecordDecl *Base =
1068        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1069      if (i->isVirtual() && !IndirectPrimary.count(Base)) {
1070        // Mark it so we don't output it twice.
1071        IndirectPrimary.insert(Base);
1072        StartNewTable();
1073        int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
1074        int32_t FirstIndex = methods.size();
1075        GenerateVtableForBase(Base, false, true, BaseOffset, true, FirstIndex);
1076      }
1077      if (Base->getNumVBases())
1078        GenerateVtableForVBases(Base, Class);
1079    }
1080  }
1081};
1082
1083llvm::Value *CodeGenFunction::GenerateVtable(const CXXRecordDecl *RD) {
1084  llvm::SmallString<256> OutName;
1085  llvm::raw_svector_ostream Out(OutName);
1086  QualType ClassTy;
1087  ClassTy = getContext().getTagDeclType(RD);
1088  mangleCXXVtable(ClassTy, getContext(), Out);
1089  llvm::GlobalVariable::LinkageTypes linktype;
1090  linktype = llvm::GlobalValue::WeakAnyLinkage;
1091  std::vector<llvm::Constant *> methods;
1092  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1093  int64_t Offset;
1094
1095  VtableBuilder b(methods, RD, CGM);
1096
1097  // First comes the vtables for all the non-virtual bases...
1098  Offset = b.GenerateVtableForBase(RD, true, false, 0, false, 0);
1099
1100  // then the vtables for all the virtual bases.
1101  b.GenerateVtableForVBases(RD, RD);
1102
1103  llvm::Constant *C;
1104  llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, methods.size());
1105  C = llvm::ConstantArray::get(type, methods);
1106  llvm::Value *vtable = new llvm::GlobalVariable(CGM.getModule(), type, true,
1107                                                 linktype, C, Out.str());
1108  vtable = Builder.CreateBitCast(vtable, Ptr8Ty);
1109  vtable = Builder.CreateGEP(vtable,
1110                       llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
1111                                              Offset*LLVMPointerWidth/8));
1112  return vtable;
1113}
1114
1115/// EmitClassAggrMemberwiseCopy - This routine generates code to copy a class
1116/// array of objects from SrcValue to DestValue. Copying can be either a bitwise
1117/// copy or via a copy constructor call.
1118//  FIXME. Consolidate this with EmitCXXAggrConstructorCall.
1119void CodeGenFunction::EmitClassAggrMemberwiseCopy(llvm::Value *Dest,
1120                                            llvm::Value *Src,
1121                                            const ArrayType *Array,
1122                                            const CXXRecordDecl *BaseClassDecl,
1123                                            QualType Ty) {
1124  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
1125  assert(CA && "VLA cannot be copied over");
1126  bool BitwiseCopy = BaseClassDecl->hasTrivialCopyConstructor();
1127
1128  // Create a temporary for the loop index and initialize it with 0.
1129  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
1130                                           "loop.index");
1131  llvm::Value* zeroConstant =
1132    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
1133    Builder.CreateStore(zeroConstant, IndexPtr, false);
1134  // Start the loop with a block that tests the condition.
1135  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
1136  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
1137
1138  EmitBlock(CondBlock);
1139
1140  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
1141  // Generate: if (loop-index < number-of-elements fall to the loop body,
1142  // otherwise, go to the block after the for-loop.
1143  uint64_t NumElements = getContext().getConstantArrayElementCount(CA);
1144  llvm::Value * NumElementsPtr =
1145    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements);
1146  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1147  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
1148                                              "isless");
1149  // If the condition is true, execute the body.
1150  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
1151
1152  EmitBlock(ForBody);
1153  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1154  // Inside the loop body, emit the constructor call on the array element.
1155  Counter = Builder.CreateLoad(IndexPtr);
1156  Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress");
1157  Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress");
1158  if (BitwiseCopy)
1159    EmitAggregateCopy(Dest, Src, Ty);
1160  else if (CXXConstructorDecl *BaseCopyCtor =
1161           BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1162    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1163                                                      Ctor_Complete);
1164    CallArgList CallArgs;
1165    // Push the this (Dest) ptr.
1166    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1167                                      BaseCopyCtor->getThisType(getContext())));
1168
1169    // Push the Src ptr.
1170    CallArgs.push_back(std::make_pair(RValue::get(Src),
1171                                      BaseCopyCtor->getParamDecl(0)->getType()));
1172    QualType ResultType =
1173      BaseCopyCtor->getType()->getAsFunctionType()->getResultType();
1174    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1175             Callee, CallArgs, BaseCopyCtor);
1176  }
1177  EmitBlock(ContinueBlock);
1178
1179  // Emit the increment of the loop counter.
1180  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
1181  Counter = Builder.CreateLoad(IndexPtr);
1182  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
1183  Builder.CreateStore(NextVal, IndexPtr, false);
1184
1185  // Finally, branch back up to the condition for the next iteration.
1186  EmitBranch(CondBlock);
1187
1188  // Emit the fall-through block.
1189  EmitBlock(AfterFor, true);
1190}
1191
1192/// EmitClassAggrCopyAssignment - This routine generates code to assign a class
1193/// array of objects from SrcValue to DestValue. Assignment can be either a
1194/// bitwise assignment or via a copy assignment operator function call.
1195/// FIXME. This can be consolidated with EmitClassAggrMemberwiseCopy
1196void CodeGenFunction::EmitClassAggrCopyAssignment(llvm::Value *Dest,
1197                                            llvm::Value *Src,
1198                                            const ArrayType *Array,
1199                                            const CXXRecordDecl *BaseClassDecl,
1200                                            QualType Ty) {
1201  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
1202  assert(CA && "VLA cannot be asssigned");
1203  bool BitwiseAssign = BaseClassDecl->hasTrivialCopyAssignment();
1204
1205  // Create a temporary for the loop index and initialize it with 0.
1206  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
1207                                           "loop.index");
1208  llvm::Value* zeroConstant =
1209  llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
1210  Builder.CreateStore(zeroConstant, IndexPtr, false);
1211  // Start the loop with a block that tests the condition.
1212  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
1213  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
1214
1215  EmitBlock(CondBlock);
1216
1217  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
1218  // Generate: if (loop-index < number-of-elements fall to the loop body,
1219  // otherwise, go to the block after the for-loop.
1220  uint64_t NumElements = getContext().getConstantArrayElementCount(CA);
1221  llvm::Value * NumElementsPtr =
1222  llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements);
1223  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1224  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
1225                                              "isless");
1226  // If the condition is true, execute the body.
1227  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
1228
1229  EmitBlock(ForBody);
1230  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1231  // Inside the loop body, emit the assignment operator call on array element.
1232  Counter = Builder.CreateLoad(IndexPtr);
1233  Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress");
1234  Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress");
1235  const CXXMethodDecl *MD = 0;
1236  if (BitwiseAssign)
1237    EmitAggregateCopy(Dest, Src, Ty);
1238  else {
1239    bool hasCopyAssign = BaseClassDecl->hasConstCopyAssignment(getContext(),
1240                                                               MD);
1241    assert(hasCopyAssign && "EmitClassAggrCopyAssignment - No user assign");
1242    (void)hasCopyAssign;
1243    const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
1244    const llvm::Type *LTy =
1245    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1246                                   FPT->isVariadic());
1247    llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), LTy);
1248
1249    CallArgList CallArgs;
1250    // Push the this (Dest) ptr.
1251    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1252                                      MD->getThisType(getContext())));
1253
1254    // Push the Src ptr.
1255    CallArgs.push_back(std::make_pair(RValue::get(Src),
1256                                      MD->getParamDecl(0)->getType()));
1257    QualType ResultType =
1258    MD->getType()->getAsFunctionType()->getResultType();
1259    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1260             Callee, CallArgs, MD);
1261  }
1262  EmitBlock(ContinueBlock);
1263
1264  // Emit the increment of the loop counter.
1265  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
1266  Counter = Builder.CreateLoad(IndexPtr);
1267  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
1268  Builder.CreateStore(NextVal, IndexPtr, false);
1269
1270  // Finally, branch back up to the condition for the next iteration.
1271  EmitBranch(CondBlock);
1272
1273  // Emit the fall-through block.
1274  EmitBlock(AfterFor, true);
1275}
1276
1277/// EmitClassMemberwiseCopy - This routine generates code to copy a class
1278/// object from SrcValue to DestValue. Copying can be either a bitwise copy
1279/// or via a copy constructor call.
1280void CodeGenFunction::EmitClassMemberwiseCopy(
1281                        llvm::Value *Dest, llvm::Value *Src,
1282                        const CXXRecordDecl *ClassDecl,
1283                        const CXXRecordDecl *BaseClassDecl, QualType Ty) {
1284  if (ClassDecl) {
1285    Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl);
1286    Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ;
1287  }
1288  if (BaseClassDecl->hasTrivialCopyConstructor()) {
1289    EmitAggregateCopy(Dest, Src, Ty);
1290    return;
1291  }
1292
1293  if (CXXConstructorDecl *BaseCopyCtor =
1294      BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1295    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1296                                                      Ctor_Complete);
1297    CallArgList CallArgs;
1298    // Push the this (Dest) ptr.
1299    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1300                                      BaseCopyCtor->getThisType(getContext())));
1301
1302    // Push the Src ptr.
1303    CallArgs.push_back(std::make_pair(RValue::get(Src),
1304                       BaseCopyCtor->getParamDecl(0)->getType()));
1305    QualType ResultType =
1306    BaseCopyCtor->getType()->getAsFunctionType()->getResultType();
1307    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1308             Callee, CallArgs, BaseCopyCtor);
1309  }
1310}
1311
1312/// EmitClassCopyAssignment - This routine generates code to copy assign a class
1313/// object from SrcValue to DestValue. Assignment can be either a bitwise
1314/// assignment of via an assignment operator call.
1315// FIXME. Consolidate this with EmitClassMemberwiseCopy as they share a lot.
1316void CodeGenFunction::EmitClassCopyAssignment(
1317                                        llvm::Value *Dest, llvm::Value *Src,
1318                                        const CXXRecordDecl *ClassDecl,
1319                                        const CXXRecordDecl *BaseClassDecl,
1320                                        QualType Ty) {
1321  if (ClassDecl) {
1322    Dest = AddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl);
1323    Src = AddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl) ;
1324  }
1325  if (BaseClassDecl->hasTrivialCopyAssignment()) {
1326    EmitAggregateCopy(Dest, Src, Ty);
1327    return;
1328  }
1329
1330  const CXXMethodDecl *MD = 0;
1331  bool ConstCopyAssignOp = BaseClassDecl->hasConstCopyAssignment(getContext(),
1332                                                                 MD);
1333  assert(ConstCopyAssignOp && "EmitClassCopyAssignment - missing copy assign");
1334  (void)ConstCopyAssignOp;
1335
1336  const FunctionProtoType *FPT = MD->getType()->getAsFunctionProtoType();
1337  const llvm::Type *LTy =
1338    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1339                                   FPT->isVariadic());
1340  llvm::Constant *Callee = CGM.GetAddrOfFunction(GlobalDecl(MD), LTy);
1341
1342  CallArgList CallArgs;
1343  // Push the this (Dest) ptr.
1344  CallArgs.push_back(std::make_pair(RValue::get(Dest),
1345                                    MD->getThisType(getContext())));
1346
1347  // Push the Src ptr.
1348  CallArgs.push_back(std::make_pair(RValue::get(Src),
1349                                    MD->getParamDecl(0)->getType()));
1350  QualType ResultType =
1351    MD->getType()->getAsFunctionType()->getResultType();
1352  EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1353           Callee, CallArgs, MD);
1354}
1355
1356/// SynthesizeDefaultConstructor - synthesize a default constructor
1357void
1358CodeGenFunction::SynthesizeDefaultConstructor(const CXXConstructorDecl *CD,
1359                                              const FunctionDecl *FD,
1360                                              llvm::Function *Fn,
1361                                              const FunctionArgList &Args) {
1362  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1363  EmitCtorPrologue(CD);
1364  FinishFunction();
1365}
1366
1367/// SynthesizeCXXCopyConstructor - This routine implicitly defines body of a copy
1368/// constructor, in accordance with section 12.8 (p7 and p8) of C++03
1369/// The implicitly-defined copy constructor for class X performs a memberwise
1370/// copy of its subobjects. The order of copying is the same as the order
1371/// of initialization of bases and members in a user-defined constructor
1372/// Each subobject is copied in the manner appropriate to its type:
1373///  if the subobject is of class type, the copy constructor for the class is
1374///  used;
1375///  if the subobject is an array, each element is copied, in the manner
1376///  appropriate to the element type;
1377///  if the subobject is of scalar type, the built-in assignment operator is
1378///  used.
1379/// Virtual base class subobjects shall be copied only once by the
1380/// implicitly-defined copy constructor
1381
1382void CodeGenFunction::SynthesizeCXXCopyConstructor(const CXXConstructorDecl *CD,
1383                                       const FunctionDecl *FD,
1384                                       llvm::Function *Fn,
1385                                       const FunctionArgList &Args) {
1386  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1387  assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
1388         "SynthesizeCXXCopyConstructor - copy constructor has definition already");
1389  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1390
1391  FunctionArgList::const_iterator i = Args.begin();
1392  const VarDecl *ThisArg = i->first;
1393  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1394  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1395  const VarDecl *SrcArg = (i+1)->first;
1396  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1397  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1398
1399  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1400       Base != ClassDecl->bases_end(); ++Base) {
1401    // FIXME. copy constrution of virtual base NYI
1402    if (Base->isVirtual())
1403      continue;
1404
1405    CXXRecordDecl *BaseClassDecl
1406      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1407    EmitClassMemberwiseCopy(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1408                            Base->getType());
1409  }
1410
1411  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1412       FieldEnd = ClassDecl->field_end();
1413       Field != FieldEnd; ++Field) {
1414    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1415    const ConstantArrayType *Array =
1416      getContext().getAsConstantArrayType(FieldType);
1417    if (Array)
1418      FieldType = getContext().getBaseElementType(FieldType);
1419
1420    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1421      CXXRecordDecl *FieldClassDecl
1422        = cast<CXXRecordDecl>(FieldClassType->getDecl());
1423      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1424      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1425      if (Array) {
1426        const llvm::Type *BasePtr = ConvertType(FieldType);
1427        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1428        llvm::Value *DestBaseAddrPtr =
1429          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1430        llvm::Value *SrcBaseAddrPtr =
1431          Builder.CreateBitCast(RHS.getAddress(), BasePtr);
1432        EmitClassAggrMemberwiseCopy(DestBaseAddrPtr, SrcBaseAddrPtr, Array,
1433                                    FieldClassDecl, FieldType);
1434      }
1435      else
1436        EmitClassMemberwiseCopy(LHS.getAddress(), RHS.getAddress(),
1437                                0 /*ClassDecl*/, FieldClassDecl, FieldType);
1438      continue;
1439    }
1440    // Do a built-in assignment of scalar data members.
1441    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1442    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1443    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1444    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1445  }
1446  FinishFunction();
1447}
1448
1449/// SynthesizeCXXCopyAssignment - Implicitly define copy assignment operator.
1450/// Before the implicitly-declared copy assignment operator for a class is
1451/// implicitly defined, all implicitly- declared copy assignment operators for
1452/// its direct base classes and its nonstatic data members shall have been
1453/// implicitly defined. [12.8-p12]
1454/// The implicitly-defined copy assignment operator for class X performs
1455/// memberwise assignment of its subob- jects. The direct base classes of X are
1456/// assigned first, in the order of their declaration in
1457/// the base-specifier-list, and then the immediate nonstatic data members of X
1458/// are assigned, in the order in which they were declared in the class
1459/// definition.Each subobject is assigned in the manner appropriate to its type:
1460///   if the subobject is of class type, the copy assignment operator for the
1461///   class is used (as if by explicit qualification; that is, ignoring any
1462///   possible virtual overriding functions in more derived classes);
1463///
1464///   if the subobject is an array, each element is assigned, in the manner
1465///   appropriate to the element type;
1466///
1467///   if the subobject is of scalar type, the built-in assignment operator is
1468///   used.
1469void CodeGenFunction::SynthesizeCXXCopyAssignment(const CXXMethodDecl *CD,
1470                                                  const FunctionDecl *FD,
1471                                                  llvm::Function *Fn,
1472                                                  const FunctionArgList &Args) {
1473
1474  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1475  assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
1476         "SynthesizeCXXCopyAssignment - copy assignment has user declaration");
1477  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1478
1479  FunctionArgList::const_iterator i = Args.begin();
1480  const VarDecl *ThisArg = i->first;
1481  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1482  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1483  const VarDecl *SrcArg = (i+1)->first;
1484  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1485  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1486
1487  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1488       Base != ClassDecl->bases_end(); ++Base) {
1489    // FIXME. copy assignment of virtual base NYI
1490    if (Base->isVirtual())
1491      continue;
1492
1493    CXXRecordDecl *BaseClassDecl
1494      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1495    EmitClassCopyAssignment(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1496                            Base->getType());
1497  }
1498
1499  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1500       FieldEnd = ClassDecl->field_end();
1501       Field != FieldEnd; ++Field) {
1502    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1503    const ConstantArrayType *Array =
1504      getContext().getAsConstantArrayType(FieldType);
1505    if (Array)
1506      FieldType = getContext().getBaseElementType(FieldType);
1507
1508    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1509      CXXRecordDecl *FieldClassDecl
1510      = cast<CXXRecordDecl>(FieldClassType->getDecl());
1511      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1512      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1513      if (Array) {
1514        const llvm::Type *BasePtr = ConvertType(FieldType);
1515        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1516        llvm::Value *DestBaseAddrPtr =
1517          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1518        llvm::Value *SrcBaseAddrPtr =
1519          Builder.CreateBitCast(RHS.getAddress(), BasePtr);
1520        EmitClassAggrCopyAssignment(DestBaseAddrPtr, SrcBaseAddrPtr, Array,
1521                                    FieldClassDecl, FieldType);
1522      }
1523      else
1524        EmitClassCopyAssignment(LHS.getAddress(), RHS.getAddress(),
1525                               0 /*ClassDecl*/, FieldClassDecl, FieldType);
1526      continue;
1527    }
1528    // Do a built-in assignment of scalar data members.
1529    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1530    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1531    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1532    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1533  }
1534
1535  // return *this;
1536  Builder.CreateStore(LoadOfThis, ReturnValue);
1537
1538  FinishFunction();
1539}
1540
1541/// EmitCtorPrologue - This routine generates necessary code to initialize
1542/// base classes and non-static data members belonging to this constructor.
1543void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD) {
1544  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1545  // FIXME: Add vbase initialization
1546  llvm::Value *LoadOfThis = 0;
1547
1548  for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
1549       E = CD->init_end();
1550       B != E; ++B) {
1551    CXXBaseOrMemberInitializer *Member = (*B);
1552    if (Member->isBaseInitializer()) {
1553      LoadOfThis = LoadCXXThis();
1554      Type *BaseType = Member->getBaseClass();
1555      CXXRecordDecl *BaseClassDecl =
1556        cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
1557      llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl,
1558                                             BaseClassDecl);
1559      EmitCXXConstructorCall(Member->getConstructor(),
1560                             Ctor_Complete, V,
1561                             Member->const_arg_begin(),
1562                             Member->const_arg_end());
1563    } else {
1564      // non-static data member initilaizers.
1565      FieldDecl *Field = Member->getMember();
1566      QualType FieldType = getContext().getCanonicalType((Field)->getType());
1567      const ConstantArrayType *Array =
1568        getContext().getAsConstantArrayType(FieldType);
1569      if (Array)
1570        FieldType = getContext().getBaseElementType(FieldType);
1571
1572      LoadOfThis = LoadCXXThis();
1573      LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
1574      if (FieldType->getAs<RecordType>()) {
1575        if (!Field->isAnonymousStructOrUnion()) {
1576          assert(Member->getConstructor() &&
1577                 "EmitCtorPrologue - no constructor to initialize member");
1578          if (Array) {
1579            const llvm::Type *BasePtr = ConvertType(FieldType);
1580            BasePtr = llvm::PointerType::getUnqual(BasePtr);
1581            llvm::Value *BaseAddrPtr =
1582            Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1583            EmitCXXAggrConstructorCall(Member->getConstructor(),
1584                                       Array, BaseAddrPtr);
1585          }
1586          else
1587            EmitCXXConstructorCall(Member->getConstructor(),
1588                                   Ctor_Complete, LHS.getAddress(),
1589                                   Member->const_arg_begin(),
1590                                   Member->const_arg_end());
1591          continue;
1592        }
1593        else {
1594          // Initializing an anonymous union data member.
1595          FieldDecl *anonMember = Member->getAnonUnionMember();
1596          LHS = EmitLValueForField(LHS.getAddress(), anonMember, false, 0);
1597          FieldType = anonMember->getType();
1598        }
1599      }
1600
1601      assert(Member->getNumArgs() == 1 && "Initializer count must be 1 only");
1602      Expr *RhsExpr = *Member->arg_begin();
1603      llvm::Value *RHS = EmitScalarExpr(RhsExpr, true);
1604      EmitStoreThroughLValue(RValue::get(RHS), LHS, FieldType);
1605    }
1606  }
1607
1608  if (!CD->getNumBaseOrMemberInitializers() && !CD->isTrivial()) {
1609    // Nontrivial default constructor with no initializer list. It may still
1610    // have bases classes and/or contain non-static data members which require
1611    // construction.
1612    for (CXXRecordDecl::base_class_const_iterator Base =
1613          ClassDecl->bases_begin();
1614          Base != ClassDecl->bases_end(); ++Base) {
1615      // FIXME. copy assignment of virtual base NYI
1616      if (Base->isVirtual())
1617        continue;
1618
1619      CXXRecordDecl *BaseClassDecl
1620        = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1621      if (BaseClassDecl->hasTrivialConstructor())
1622        continue;
1623      if (CXXConstructorDecl *BaseCX =
1624            BaseClassDecl->getDefaultConstructor(getContext())) {
1625        LoadOfThis = LoadCXXThis();
1626        llvm::Value *V = AddressCXXOfBaseClass(LoadOfThis, ClassDecl,
1627                                               BaseClassDecl);
1628        EmitCXXConstructorCall(BaseCX, Ctor_Complete, V, 0, 0);
1629      }
1630    }
1631
1632    for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1633         FieldEnd = ClassDecl->field_end();
1634         Field != FieldEnd; ++Field) {
1635      QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1636      const ConstantArrayType *Array =
1637        getContext().getAsConstantArrayType(FieldType);
1638      if (Array)
1639        FieldType = getContext().getBaseElementType(FieldType);
1640      if (!FieldType->getAs<RecordType>() || Field->isAnonymousStructOrUnion())
1641        continue;
1642      const RecordType *ClassRec = FieldType->getAs<RecordType>();
1643      CXXRecordDecl *MemberClassDecl =
1644        dyn_cast<CXXRecordDecl>(ClassRec->getDecl());
1645      if (!MemberClassDecl || MemberClassDecl->hasTrivialConstructor())
1646        continue;
1647      if (CXXConstructorDecl *MamberCX =
1648            MemberClassDecl->getDefaultConstructor(getContext())) {
1649        LoadOfThis = LoadCXXThis();
1650        LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1651        if (Array) {
1652          const llvm::Type *BasePtr = ConvertType(FieldType);
1653          BasePtr = llvm::PointerType::getUnqual(BasePtr);
1654          llvm::Value *BaseAddrPtr =
1655            Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1656          EmitCXXAggrConstructorCall(MamberCX, Array, BaseAddrPtr);
1657        }
1658        else
1659          EmitCXXConstructorCall(MamberCX, Ctor_Complete, LHS.getAddress(),
1660                                 0, 0);
1661      }
1662    }
1663  }
1664
1665  // Initialize the vtable pointer
1666  if (ClassDecl->isDynamicClass()) {
1667    if (!LoadOfThis)
1668      LoadOfThis = LoadCXXThis();
1669    llvm::Value *VtableField;
1670    llvm::Type *Ptr8Ty, *PtrPtr8Ty;
1671    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
1672    PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0);
1673    VtableField = Builder.CreateBitCast(LoadOfThis, PtrPtr8Ty);
1674    llvm::Value *vtable = GenerateVtable(ClassDecl);
1675    Builder.CreateStore(vtable, VtableField);
1676  }
1677}
1678
1679/// EmitDtorEpilogue - Emit all code that comes at the end of class's
1680/// destructor. This is to call destructors on members and base classes
1681/// in reverse order of their construction.
1682void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD) {
1683  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext());
1684  assert(!ClassDecl->isPolymorphic() &&
1685         "FIXME. polymorphic destruction not supported");
1686  (void)ClassDecl;  // prevent warning.
1687
1688  for (CXXDestructorDecl::destr_const_iterator *B = DD->destr_begin(),
1689       *E = DD->destr_end(); B != E; ++B) {
1690    uintptr_t BaseOrMember = (*B);
1691    if (DD->isMemberToDestroy(BaseOrMember)) {
1692      FieldDecl *FD = DD->getMemberToDestroy(BaseOrMember);
1693      QualType FieldType = getContext().getCanonicalType((FD)->getType());
1694      const ConstantArrayType *Array =
1695        getContext().getAsConstantArrayType(FieldType);
1696      if (Array)
1697        FieldType = getContext().getBaseElementType(FieldType);
1698      const RecordType *RT = FieldType->getAs<RecordType>();
1699      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1700      if (FieldClassDecl->hasTrivialDestructor())
1701        continue;
1702      llvm::Value *LoadOfThis = LoadCXXThis();
1703      LValue LHS = EmitLValueForField(LoadOfThis, FD, false, 0);
1704      if (Array) {
1705        const llvm::Type *BasePtr = ConvertType(FieldType);
1706        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1707        llvm::Value *BaseAddrPtr =
1708          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1709        EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1710                                  Array, BaseAddrPtr);
1711      }
1712      else
1713        EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1714                              Dtor_Complete, LHS.getAddress());
1715    } else {
1716      const RecordType *RT =
1717        DD->getAnyBaseClassToDestroy(BaseOrMember)->getAs<RecordType>();
1718      CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1719      if (BaseClassDecl->hasTrivialDestructor())
1720        continue;
1721      llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(),
1722                                             ClassDecl,BaseClassDecl);
1723      EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1724                            Dtor_Complete, V);
1725    }
1726  }
1727  if (DD->getNumBaseOrMemberDestructions() || DD->isTrivial())
1728    return;
1729  // Case of destructor synthesis with fields and base classes
1730  // which have non-trivial destructors. They must be destructed in
1731  // reverse order of their construction.
1732  llvm::SmallVector<FieldDecl *, 16> DestructedFields;
1733
1734  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1735       FieldEnd = ClassDecl->field_end();
1736       Field != FieldEnd; ++Field) {
1737    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1738    if (getContext().getAsConstantArrayType(FieldType))
1739      FieldType = getContext().getBaseElementType(FieldType);
1740    if (const RecordType *RT = FieldType->getAs<RecordType>()) {
1741      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1742      if (FieldClassDecl->hasTrivialDestructor())
1743        continue;
1744      DestructedFields.push_back(*Field);
1745    }
1746  }
1747  if (!DestructedFields.empty())
1748    for (int i = DestructedFields.size() -1; i >= 0; --i) {
1749      FieldDecl *Field = DestructedFields[i];
1750      QualType FieldType = Field->getType();
1751      const ConstantArrayType *Array =
1752        getContext().getAsConstantArrayType(FieldType);
1753        if (Array)
1754          FieldType = getContext().getBaseElementType(FieldType);
1755      const RecordType *RT = FieldType->getAs<RecordType>();
1756      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1757      llvm::Value *LoadOfThis = LoadCXXThis();
1758      LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
1759      if (Array) {
1760        const llvm::Type *BasePtr = ConvertType(FieldType);
1761        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1762        llvm::Value *BaseAddrPtr =
1763        Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1764        EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1765                                  Array, BaseAddrPtr);
1766      }
1767      else
1768        EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1769                              Dtor_Complete, LHS.getAddress());
1770    }
1771
1772  llvm::SmallVector<CXXRecordDecl*, 4> DestructedBases;
1773  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1774       Base != ClassDecl->bases_end(); ++Base) {
1775    // FIXME. copy assignment of virtual base NYI
1776    if (Base->isVirtual())
1777      continue;
1778
1779    CXXRecordDecl *BaseClassDecl
1780      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1781    if (BaseClassDecl->hasTrivialDestructor())
1782      continue;
1783    DestructedBases.push_back(BaseClassDecl);
1784  }
1785  if (DestructedBases.empty())
1786    return;
1787  for (int i = DestructedBases.size() -1; i >= 0; --i) {
1788    CXXRecordDecl *BaseClassDecl = DestructedBases[i];
1789    llvm::Value *V = AddressCXXOfBaseClass(LoadCXXThis(),
1790                                           ClassDecl,BaseClassDecl);
1791    EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1792                          Dtor_Complete, V);
1793  }
1794}
1795
1796void CodeGenFunction::SynthesizeDefaultDestructor(const CXXDestructorDecl *CD,
1797                                                  const FunctionDecl *FD,
1798                                                  llvm::Function *Fn,
1799                                                  const FunctionArgList &Args) {
1800
1801  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1802  assert(!ClassDecl->hasUserDeclaredDestructor() &&
1803         "SynthesizeDefaultDestructor - destructor has user declaration");
1804  (void) ClassDecl;
1805
1806  StartFunction(FD, FD->getResultType(), Fn, Args, SourceLocation());
1807  EmitDtorEpilogue(CD);
1808  FinishFunction();
1809}
1810