CGCXX.cpp revision 6815e941998659a55c20c147861b0f437928c3d8 
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 "clang/AST/StmtCXX.h"
25#include "llvm/ADT/StringExtras.h"
26using namespace clang;
27using namespace CodeGen;
28
29void
30CodeGenFunction::EmitCXXGlobalDtorRegistration(const CXXDestructorDecl *Dtor,
31                                               llvm::Constant *DeclPtr) {
32  const llvm::Type *Int8PtrTy =
33    llvm::Type::getInt8Ty(VMContext)->getPointerTo();
34
35  std::vector<const llvm::Type *> Params;
36  Params.push_back(Int8PtrTy);
37
38  // Get the destructor function type
39  const llvm::Type *DtorFnTy =
40    llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), Params, false);
41  DtorFnTy = llvm::PointerType::getUnqual(DtorFnTy);
42
43  Params.clear();
44  Params.push_back(DtorFnTy);
45  Params.push_back(Int8PtrTy);
46  Params.push_back(Int8PtrTy);
47
48  // Get the __cxa_atexit function type
49  // extern "C" int __cxa_atexit ( void (*f)(void *), void *p, void *d );
50  const llvm::FunctionType *AtExitFnTy =
51    llvm::FunctionType::get(ConvertType(getContext().IntTy), Params, false);
52
53  llvm::Constant *AtExitFn = CGM.CreateRuntimeFunction(AtExitFnTy,
54                                                       "__cxa_atexit");
55
56  llvm::Constant *Handle = CGM.CreateRuntimeVariable(Int8PtrTy,
57                                                     "__dso_handle");
58
59  llvm::Constant *DtorFn = CGM.GetAddrOfCXXDestructor(Dtor, Dtor_Complete);
60
61  llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy),
62                           llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy),
63                           llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) };
64  Builder.CreateCall(AtExitFn, &Args[0], llvm::array_endof(Args));
65}
66
67void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
68                                               llvm::Constant *DeclPtr) {
69  assert(D.hasGlobalStorage() &&
70         "VarDecl must have global storage!");
71
72  const Expr *Init = D.getInit();
73  QualType T = D.getType();
74
75  if (T->isReferenceType()) {
76    ErrorUnsupported(Init, "global variable that binds to a reference");
77  } else if (!hasAggregateLLVMType(T)) {
78    llvm::Value *V = EmitScalarExpr(Init);
79    EmitStoreOfScalar(V, DeclPtr, T.isVolatileQualified(), T);
80  } else if (T->isAnyComplexType()) {
81    EmitComplexExprIntoAddr(Init, DeclPtr, T.isVolatileQualified());
82  } else {
83    EmitAggExpr(Init, DeclPtr, T.isVolatileQualified());
84
85    if (const RecordType *RT = T->getAs<RecordType>()) {
86      CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
87      if (!RD->hasTrivialDestructor())
88        EmitCXXGlobalDtorRegistration(RD->getDestructor(getContext()), DeclPtr);
89    }
90  }
91}
92
93void
94CodeGenModule::EmitCXXGlobalInitFunc() {
95  if (CXXGlobalInits.empty())
96    return;
97
98  const llvm::FunctionType *FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
99                                                          false);
100
101  // Create our global initialization function.
102  // FIXME: Should this be tweakable by targets?
103  llvm::Function *Fn =
104    llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
105                           "__cxx_global_initialization", &TheModule);
106
107  CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
108                                                   &CXXGlobalInits[0],
109                                                   CXXGlobalInits.size());
110  AddGlobalCtor(Fn);
111}
112
113void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
114                                                const VarDecl **Decls,
115                                                unsigned NumDecls) {
116  StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(),
117                SourceLocation());
118
119  for (unsigned i = 0; i != NumDecls; ++i) {
120    const VarDecl *D = Decls[i];
121
122    llvm::Constant *DeclPtr = CGM.GetAddrOfGlobalVar(D);
123    EmitCXXGlobalVarDeclInit(*D, DeclPtr);
124  }
125  FinishFunction();
126}
127
128void
129CodeGenFunction::EmitStaticCXXBlockVarDeclInit(const VarDecl &D,
130                                               llvm::GlobalVariable *GV) {
131  // FIXME: This should use __cxa_guard_{acquire,release}?
132
133  assert(!getContext().getLangOptions().ThreadsafeStatics &&
134         "thread safe statics are currently not supported!");
135
136  llvm::SmallString<256> GuardVName;
137  llvm::raw_svector_ostream GuardVOut(GuardVName);
138  mangleGuardVariable(&D, getContext(), GuardVOut);
139
140  // Create the guard variable.
141  llvm::GlobalValue *GuardV =
142    new llvm::GlobalVariable(CGM.getModule(), llvm::Type::getInt64Ty(VMContext), false,
143                             GV->getLinkage(),
144                             llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)),
145                             GuardVName.str());
146
147  // Load the first byte of the guard variable.
148  const llvm::Type *PtrTy = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
149  llvm::Value *V = Builder.CreateLoad(Builder.CreateBitCast(GuardV, PtrTy),
150                                      "tmp");
151
152  // Compare it against 0.
153  llvm::Value *nullValue = llvm::Constant::getNullValue(llvm::Type::getInt8Ty(VMContext));
154  llvm::Value *ICmp = Builder.CreateICmpEQ(V, nullValue , "tobool");
155
156  llvm::BasicBlock *InitBlock = createBasicBlock("init");
157  llvm::BasicBlock *EndBlock = createBasicBlock("init.end");
158
159  // If the guard variable is 0, jump to the initializer code.
160  Builder.CreateCondBr(ICmp, InitBlock, EndBlock);
161
162  EmitBlock(InitBlock);
163
164  EmitCXXGlobalVarDeclInit(D, GV);
165
166  Builder.CreateStore(llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 1),
167                      Builder.CreateBitCast(GuardV, PtrTy));
168
169  EmitBlock(EndBlock);
170}
171
172RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
173                                          llvm::Value *Callee,
174                                          llvm::Value *This,
175                                          CallExpr::const_arg_iterator ArgBeg,
176                                          CallExpr::const_arg_iterator ArgEnd) {
177  assert(MD->isInstance() &&
178         "Trying to emit a member call expr on a static method!");
179
180  // A call to a trivial destructor requires no code generation.
181  if (const CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(MD))
182    if (Destructor->isTrivial())
183      return RValue::get(0);
184
185  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
186
187  CallArgList Args;
188
189  // Push the this ptr.
190  Args.push_back(std::make_pair(RValue::get(This),
191                                MD->getThisType(getContext())));
192
193  // And the rest of the call args
194  EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
195
196  QualType ResultType = MD->getType()->getAs<FunctionType>()->getResultType();
197  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args),
198                  Callee, Args, MD);
199}
200
201RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE) {
202  const MemberExpr *ME = cast<MemberExpr>(CE->getCallee());
203  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
204
205  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
206
207  const llvm::Type *Ty =
208    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
209                                   FPT->isVariadic());
210  llvm::Value *This;
211
212  if (ME->isArrow())
213    This = EmitScalarExpr(ME->getBase());
214  else {
215    LValue BaseLV = EmitLValue(ME->getBase());
216    This = BaseLV.getAddress();
217  }
218
219  // C++ [class.virtual]p12:
220  //   Explicit qualification with the scope operator (5.1) suppresses the
221  //   virtual call mechanism.
222  llvm::Value *Callee;
223  if (MD->isVirtual() && !ME->hasQualifier())
224    Callee = BuildVirtualCall(MD, This, Ty);
225  else if (const CXXDestructorDecl *Destructor
226             = dyn_cast<CXXDestructorDecl>(MD))
227    Callee = CGM.GetAddrOfFunction(GlobalDecl(Destructor, Dtor_Complete), Ty);
228  else
229    Callee = CGM.GetAddrOfFunction(MD, Ty);
230
231  return EmitCXXMemberCall(MD, Callee, This,
232                           CE->arg_begin(), CE->arg_end());
233}
234
235RValue
236CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
237                                               const CXXMethodDecl *MD) {
238  assert(MD->isInstance() &&
239         "Trying to emit a member call expr on a static method!");
240
241  if (MD->isCopyAssignment()) {
242    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext());
243    if (ClassDecl->hasTrivialCopyAssignment()) {
244      assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
245             "EmitCXXOperatorMemberCallExpr - user declared copy assignment");
246      llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
247      llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
248      QualType Ty = E->getType();
249      EmitAggregateCopy(This, Src, Ty);
250      return RValue::get(This);
251    }
252  }
253
254  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
255  const llvm::Type *Ty =
256    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
257                                   FPT->isVariadic());
258  llvm::Constant *Callee = CGM.GetAddrOfFunction(MD, Ty);
259
260  llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
261
262  return EmitCXXMemberCall(MD, Callee, This,
263                           E->arg_begin() + 1, E->arg_end());
264}
265
266llvm::Value *CodeGenFunction::LoadCXXThis() {
267  assert(isa<CXXMethodDecl>(CurFuncDecl) &&
268         "Must be in a C++ member function decl to load 'this'");
269  assert(cast<CXXMethodDecl>(CurFuncDecl)->isInstance() &&
270         "Must be in a C++ member function decl to load 'this'");
271
272  // FIXME: What if we're inside a block?
273  // ans: See how CodeGenFunction::LoadObjCSelf() uses
274  // CodeGenFunction::BlockForwardSelf() for how to do this.
275  return Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this");
276}
277
278/// EmitCXXAggrConstructorCall - This routine essentially creates a (nested)
279/// for-loop to call the default constructor on individual members of the
280/// array.
281/// 'D' is the default constructor for elements of the array, 'ArrayTy' is the
282/// array type and 'ArrayPtr' points to the beginning fo the array.
283/// It is assumed that all relevant checks have been made by the caller.
284void
285CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
286                                            const ConstantArrayType *ArrayTy,
287                                            llvm::Value *ArrayPtr) {
288  const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
289  llvm::Value * NumElements =
290    llvm::ConstantInt::get(SizeTy,
291                           getContext().getConstantArrayElementCount(ArrayTy));
292
293  EmitCXXAggrConstructorCall(D, NumElements, ArrayPtr);
294}
295
296void
297CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
298                                            llvm::Value *NumElements,
299                                            llvm::Value *ArrayPtr) {
300  const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
301
302  // Create a temporary for the loop index and initialize it with 0.
303  llvm::Value *IndexPtr = CreateTempAlloca(SizeTy, "loop.index");
304  llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
305  Builder.CreateStore(Zero, IndexPtr, false);
306
307  // Start the loop with a block that tests the condition.
308  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
309  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
310
311  EmitBlock(CondBlock);
312
313  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
314
315  // Generate: if (loop-index < number-of-elements fall to the loop body,
316  // otherwise, go to the block after the for-loop.
317  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
318  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElements, "isless");
319  // If the condition is true, execute the body.
320  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
321
322  EmitBlock(ForBody);
323
324  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
325  // Inside the loop body, emit the constructor call on the array element.
326  Counter = Builder.CreateLoad(IndexPtr);
327  llvm::Value *Address = Builder.CreateInBoundsGEP(ArrayPtr, Counter,
328                                                   "arrayidx");
329  EmitCXXConstructorCall(D, Ctor_Complete, Address, 0, 0);
330
331  EmitBlock(ContinueBlock);
332
333  // Emit the increment of the loop counter.
334  llvm::Value *NextVal = llvm::ConstantInt::get(SizeTy, 1);
335  Counter = Builder.CreateLoad(IndexPtr);
336  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
337  Builder.CreateStore(NextVal, IndexPtr, false);
338
339  // Finally, branch back up to the condition for the next iteration.
340  EmitBranch(CondBlock);
341
342  // Emit the fall-through block.
343  EmitBlock(AfterFor, true);
344}
345
346/// EmitCXXAggrDestructorCall - calls the default destructor on array
347/// elements in reverse order of construction.
348void
349CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
350                                           const ArrayType *Array,
351                                           llvm::Value *This) {
352  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
353  assert(CA && "Do we support VLA for destruction ?");
354  llvm::Value *One = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
355                                            1);
356  uint64_t ElementCount = getContext().getConstantArrayElementCount(CA);
357  // Create a temporary for the loop index and initialize it with count of
358  // array elements.
359  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
360                                           "loop.index");
361  // Index = ElementCount;
362  llvm::Value* UpperCount =
363    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), ElementCount);
364  Builder.CreateStore(UpperCount, IndexPtr, false);
365
366  // Start the loop with a block that tests the condition.
367  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
368  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
369
370  EmitBlock(CondBlock);
371
372  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
373
374  // Generate: if (loop-index != 0 fall to the loop body,
375  // otherwise, go to the block after the for-loop.
376  llvm::Value* zeroConstant =
377    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
378  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
379  llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant,
380                                            "isne");
381  // If the condition is true, execute the body.
382  Builder.CreateCondBr(IsNE, ForBody, AfterFor);
383
384  EmitBlock(ForBody);
385
386  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
387  // Inside the loop body, emit the constructor call on the array element.
388  Counter = Builder.CreateLoad(IndexPtr);
389  Counter = Builder.CreateSub(Counter, One);
390  llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
391  EmitCXXDestructorCall(D, Dtor_Complete, Address);
392
393  EmitBlock(ContinueBlock);
394
395  // Emit the decrement of the loop counter.
396  Counter = Builder.CreateLoad(IndexPtr);
397  Counter = Builder.CreateSub(Counter, One, "dec");
398  Builder.CreateStore(Counter, IndexPtr, false);
399
400  // Finally, branch back up to the condition for the next iteration.
401  EmitBranch(CondBlock);
402
403  // Emit the fall-through block.
404  EmitBlock(AfterFor, true);
405}
406
407void
408CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
409                                        CXXCtorType Type,
410                                        llvm::Value *This,
411                                        CallExpr::const_arg_iterator ArgBeg,
412                                        CallExpr::const_arg_iterator ArgEnd) {
413  if (D->isCopyConstructor(getContext())) {
414    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D->getDeclContext());
415    if (ClassDecl->hasTrivialCopyConstructor()) {
416      assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
417             "EmitCXXConstructorCall - user declared copy constructor");
418      const Expr *E = (*ArgBeg);
419      QualType Ty = E->getType();
420      llvm::Value *Src = EmitLValue(E).getAddress();
421      EmitAggregateCopy(This, Src, Ty);
422      return;
423    }
424  }
425
426  llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
427
428  EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd);
429}
430
431void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D,
432                                            CXXDtorType Type,
433                                            llvm::Value *This) {
434  llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type);
435
436  EmitCXXMemberCall(D, Callee, This, 0, 0);
437}
438
439void
440CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
441                                      const CXXConstructExpr *E) {
442  assert(Dest && "Must have a destination!");
443
444  const CXXRecordDecl *RD =
445  cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
446  if (RD->hasTrivialConstructor())
447    return;
448
449  // Code gen optimization to eliminate copy constructor and return
450  // its first argument instead.
451  if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
452    CXXConstructExpr::const_arg_iterator i = E->arg_begin();
453    EmitAggExpr((*i), Dest, false);
454    return;
455  }
456  // Call the constructor.
457  EmitCXXConstructorCall(E->getConstructor(), Ctor_Complete, Dest,
458                         E->arg_begin(), E->arg_end());
459}
460
461void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
462  EmitGlobal(GlobalDecl(D, Ctor_Complete));
463  EmitGlobal(GlobalDecl(D, Ctor_Base));
464}
465
466void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D,
467                                       CXXCtorType Type) {
468
469  llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type);
470
471  CodeGenFunction(*this).GenerateCode(GlobalDecl(D, Type), Fn);
472
473  SetFunctionDefinitionAttributes(D, Fn);
474  SetLLVMFunctionAttributesForDefinition(D, Fn);
475}
476
477llvm::Function *
478CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D,
479                                       CXXCtorType Type) {
480  const llvm::FunctionType *FTy =
481    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
482
483  const char *Name = getMangledCXXCtorName(D, Type);
484  return cast<llvm::Function>(
485                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
486}
487
488const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D,
489                                                 CXXCtorType Type) {
490  llvm::SmallString<256> Name;
491  llvm::raw_svector_ostream Out(Name);
492  mangleCXXCtor(D, Type, Context, Out);
493
494  Name += '\0';
495  return UniqueMangledName(Name.begin(), Name.end());
496}
497
498void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
499  EmitCXXDestructor(D, Dtor_Complete);
500  EmitCXXDestructor(D, Dtor_Base);
501}
502
503void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D,
504                                      CXXDtorType Type) {
505  llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type);
506
507  CodeGenFunction(*this).GenerateCode(GlobalDecl(D, Type), Fn);
508
509  SetFunctionDefinitionAttributes(D, Fn);
510  SetLLVMFunctionAttributesForDefinition(D, Fn);
511}
512
513llvm::Function *
514CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D,
515                                      CXXDtorType Type) {
516  const llvm::FunctionType *FTy =
517    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
518
519  const char *Name = getMangledCXXDtorName(D, Type);
520  return cast<llvm::Function>(
521                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
522}
523
524const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D,
525                                                 CXXDtorType Type) {
526  llvm::SmallString<256> Name;
527  llvm::raw_svector_ostream Out(Name);
528  mangleCXXDtor(D, Type, Context, Out);
529
530  Name += '\0';
531  return UniqueMangledName(Name.begin(), Name.end());
532}
533
534llvm::Constant *CodeGenModule::GenerateRtti(const CXXRecordDecl *RD) {
535  llvm::Type *Ptr8Ty;
536  Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
537  llvm::Constant *Rtti = llvm::Constant::getNullValue(Ptr8Ty);
538
539  if (!getContext().getLangOptions().Rtti)
540    return Rtti;
541
542  llvm::SmallString<256> OutName;
543  llvm::raw_svector_ostream Out(OutName);
544  QualType ClassTy;
545  ClassTy = getContext().getTagDeclType(RD);
546  mangleCXXRtti(ClassTy, getContext(), Out);
547  llvm::GlobalVariable::LinkageTypes linktype;
548  linktype = llvm::GlobalValue::WeakAnyLinkage;
549  std::vector<llvm::Constant *> info;
550  // assert(0 && "FIXME: implement rtti descriptor");
551  // FIXME: descriptor
552  info.push_back(llvm::Constant::getNullValue(Ptr8Ty));
553  // assert(0 && "FIXME: implement rtti ts");
554  // FIXME: TS
555  info.push_back(llvm::Constant::getNullValue(Ptr8Ty));
556
557  llvm::Constant *C;
558  llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, info.size());
559  C = llvm::ConstantArray::get(type, info);
560  Rtti = new llvm::GlobalVariable(getModule(), type, true, linktype, C,
561                                  Out.str());
562  Rtti = llvm::ConstantExpr::getBitCast(Rtti, Ptr8Ty);
563  return Rtti;
564}
565
566class VtableBuilder {
567public:
568  /// Index_t - Vtable index type.
569  typedef uint64_t Index_t;
570private:
571  std::vector<llvm::Constant *> &methods;
572  std::vector<llvm::Constant *> submethods;
573  llvm::Type *Ptr8Ty;
574  /// Class - The most derived class that this vtable is being built for.
575  const CXXRecordDecl *Class;
576  /// BLayout - Layout for the most derived class that this vtable is being
577  /// built for.
578  const ASTRecordLayout &BLayout;
579  llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
580  llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
581  llvm::Constant *rtti;
582  llvm::LLVMContext &VMContext;
583  CodeGenModule &CGM;  // Per-module state.
584  /// Index - Maps a method decl into a vtable index.  Useful for virtual
585  /// dispatch codegen.
586  llvm::DenseMap<const CXXMethodDecl *, Index_t> Index;
587  llvm::DenseMap<const CXXMethodDecl *, Index_t> VCall;
588  llvm::DenseMap<const CXXMethodDecl *, Index_t> VCallOffset;
589  llvm::DenseMap<const CXXRecordDecl *, Index_t> VBIndex;
590  typedef std::pair<Index_t, Index_t>  CallOffset;
591  typedef llvm::DenseMap<const CXXMethodDecl *, CallOffset> Thunks_t;
592  Thunks_t Thunks;
593  typedef llvm::DenseMap<const CXXMethodDecl *,
594                         std::pair<CallOffset, CallOffset> > CovariantThunks_t;
595  CovariantThunks_t CovariantThunks;
596  std::vector<Index_t> VCalls;
597  typedef CXXRecordDecl::method_iterator method_iter;
598  // FIXME: Linkage should follow vtable
599  const bool Extern;
600  const uint32_t LLVMPointerWidth;
601  Index_t extra;
602public:
603  VtableBuilder(std::vector<llvm::Constant *> &meth,
604                const CXXRecordDecl *c,
605                CodeGenModule &cgm)
606    : methods(meth), Class(c), BLayout(cgm.getContext().getASTRecordLayout(c)),
607      rtti(cgm.GenerateRtti(c)), VMContext(cgm.getModule().getContext()),
608      CGM(cgm), Extern(true),
609      LLVMPointerWidth(cgm.getContext().Target.getPointerWidth(0)) {
610    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
611  }
612
613  llvm::DenseMap<const CXXMethodDecl *, Index_t> &getIndex() { return Index; }
614  llvm::DenseMap<const CXXRecordDecl *, Index_t> &getVBIndex()
615    { return VBIndex; }
616
617  llvm::Constant *wrap(Index_t i) {
618    llvm::Constant *m;
619    m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i);
620    return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
621  }
622
623  llvm::Constant *wrap(llvm::Constant *m) {
624    return llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
625  }
626
627  void GenerateVBaseOffsets(std::vector<llvm::Constant *> &offsets,
628                            const CXXRecordDecl *RD, uint64_t Offset) {
629    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
630           e = RD->bases_end(); i != e; ++i) {
631      const CXXRecordDecl *Base =
632        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
633      if (i->isVirtual() && !SeenVBase.count(Base)) {
634        SeenVBase.insert(Base);
635        int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
636        llvm::Constant *m = wrap(BaseOffset);
637        m = wrap((0?700:0) + BaseOffset);
638        VBIndex[Base] = -(offsets.size()*LLVMPointerWidth/8)
639          - 3*LLVMPointerWidth/8;
640        offsets.push_back(m);
641      }
642      GenerateVBaseOffsets(offsets, Base, Offset);
643    }
644  }
645
646  void StartNewTable() {
647    SeenVBase.clear();
648  }
649
650  Index_t VBlookup(CXXRecordDecl *D, CXXRecordDecl *B);
651
652  /// getVbaseOffset - Returns the index into the vtable for the virtual base
653  /// offset for the given (B) virtual base of the derived class D.
654  Index_t getVbaseOffset(QualType qB, QualType qD) {
655    qD = qD->getAs<PointerType>()->getPointeeType();
656    qB = qB->getAs<PointerType>()->getPointeeType();
657    CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
658    CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
659    if (D != Class)
660      return VBlookup(D, B);
661    llvm::DenseMap<const CXXRecordDecl *, Index_t>::iterator i;
662    i = VBIndex.find(B);
663    if (i != VBIndex.end())
664      return i->second;
665    // FIXME: temporal botch, is this data here, by the time we need it?
666
667    // FIXME: Locate the containing virtual base first.
668    return 42;
669  }
670
671  bool OverrideMethod(const CXXMethodDecl *MD, llvm::Constant *m,
672                      bool MorallyVirtual, Index_t Offset) {
673    typedef CXXMethodDecl::method_iterator meth_iter;
674
675    // FIXME: Don't like the nested loops.  For very large inheritance
676    // heirarchies we could have a table on the side with the final overridder
677    // and just replace each instance of an overridden method once.  Would be
678    // nice to measure the cost/benefit on real code.
679
680    for (meth_iter mi = MD->begin_overridden_methods(),
681           e = MD->end_overridden_methods();
682         mi != e; ++mi) {
683      const CXXMethodDecl *OMD = *mi;
684      llvm::Constant *om;
685      om = CGM.GetAddrOfFunction(OMD, Ptr8Ty);
686      om = llvm::ConstantExpr::getBitCast(om, Ptr8Ty);
687
688      for (Index_t i = 0, e = submethods.size();
689           i != e; ++i) {
690        // FIXME: begin_overridden_methods might be too lax, covariance */
691        if (submethods[i] != om)
692          continue;
693        QualType nc_oret = OMD->getType()->getAs<FunctionType>()->getResultType();
694        CanQualType oret = CGM.getContext().getCanonicalType(nc_oret);
695        QualType nc_ret = MD->getType()->getAs<FunctionType>()->getResultType();
696        CanQualType ret = CGM.getContext().getCanonicalType(nc_ret);
697        CallOffset ReturnOffset = std::make_pair(0, 0);
698        if (oret != ret) {
699          // FIXME: calculate offsets for covariance
700          ReturnOffset = std::make_pair(42,getVbaseOffset(oret, ret));
701        }
702        Index[MD] = i;
703        submethods[i] = m;
704
705        Thunks.erase(OMD);
706        if (MorallyVirtual) {
707          Index_t &idx = VCall[OMD];
708          if (idx == 0) {
709            VCallOffset[MD] = Offset/8;
710            idx = VCalls.size()+1;
711            VCalls.push_back(0);
712          } else {
713            VCallOffset[MD] = VCallOffset[OMD];
714            VCalls[idx-1] = -VCallOffset[OMD] + Offset/8;
715          }
716          VCall[MD] = idx;
717          CallOffset ThisOffset;
718          // FIXME: calculate non-virtual offset
719          ThisOffset = std::make_pair(0, -((idx+extra+2)*LLVMPointerWidth/8));
720          if (ReturnOffset.first || ReturnOffset.second)
721            CovariantThunks[MD] = std::make_pair(ThisOffset, ReturnOffset);
722          else
723            Thunks[MD] = ThisOffset;
724          return true;
725        }
726#if 0
727        // FIXME: finish off
728        int64_t O = VCallOffset[OMD] - Offset/8;
729        if (O) {
730          Thunks[MD] = std::make_pair(O, 0);
731        }
732#endif
733        return true;
734      }
735    }
736
737    return false;
738  }
739
740  void InstallThunks() {
741    for (Thunks_t::iterator i = Thunks.begin(), e = Thunks.end();
742         i != e; ++i) {
743      const CXXMethodDecl *MD = i->first;
744      Index_t idx = Index[MD];
745      Index_t nv_O = i->second.first;
746      Index_t v_O = i->second.second;
747      submethods[idx] = CGM.BuildThunk(MD, Extern, nv_O, v_O);
748    }
749    Thunks.clear();
750    for (CovariantThunks_t::iterator i = CovariantThunks.begin(),
751           e = CovariantThunks.end();
752         i != e; ++i) {
753      const CXXMethodDecl *MD = i->first;
754      Index_t idx = Index[MD];
755      Index_t nv_t = i->second.first.first;
756      Index_t v_t = i->second.first.second;
757      Index_t nv_r = i->second.second.first;
758      Index_t v_r = i->second.second.second;
759      submethods[idx] = CGM.BuildCovariantThunk(MD, Extern, nv_t, v_t, nv_r,
760                                                v_r);
761    }
762    CovariantThunks.clear();
763  }
764
765  void OverrideMethods(std::vector<std::pair<const CXXRecordDecl *,
766                       int64_t> > *Path, bool MorallyVirtual) {
767      for (std::vector<std::pair<const CXXRecordDecl *,
768             int64_t> >::reverse_iterator i =Path->rbegin(),
769           e = Path->rend(); i != e; ++i) {
770      const CXXRecordDecl *RD = i->first;
771      int64_t Offset = i->second;
772      for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
773           ++mi)
774        if (mi->isVirtual()) {
775          const CXXMethodDecl *MD = *mi;
776          llvm::Constant *m = wrap(CGM.GetAddrOfFunction(MD));
777          OverrideMethod(MD, m, MorallyVirtual, Offset);
778        }
779    }
780  }
781
782  void AddMethod(const CXXMethodDecl *MD, bool MorallyVirtual, Index_t Offset) {
783    llvm::Constant *m = 0;
784    if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD))
785      m = wrap(CGM.GetAddrOfCXXDestructor(Dtor, Dtor_Complete));
786    else
787      m = wrap(CGM.GetAddrOfFunction(MD));
788
789    // If we can find a previously allocated slot for this, reuse it.
790    if (OverrideMethod(MD, m, MorallyVirtual, Offset))
791      return;
792
793    // else allocate a new slot.
794    Index[MD] = submethods.size();
795    submethods.push_back(m);
796    if (MorallyVirtual) {
797      VCallOffset[MD] = Offset/8;
798      Index_t &idx = VCall[MD];
799      // Allocate the first one, after that, we reuse the previous one.
800      if (idx == 0) {
801        idx = VCalls.size()+1;
802        VCalls.push_back(0);
803      }
804    }
805  }
806
807  void AddMethods(const CXXRecordDecl *RD, bool MorallyVirtual,
808                  Index_t Offset) {
809    for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
810         ++mi)
811      if (mi->isVirtual())
812        AddMethod(*mi, MorallyVirtual, Offset);
813  }
814
815  void NonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
816                       const CXXRecordDecl *PrimaryBase,
817                       bool PrimaryBaseWasVirtual, bool MorallyVirtual,
818                       int64_t Offset) {
819    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
820           e = RD->bases_end(); i != e; ++i) {
821      if (i->isVirtual())
822        continue;
823      const CXXRecordDecl *Base =
824        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
825      if (Base != PrimaryBase || PrimaryBaseWasVirtual) {
826        uint64_t o = Offset + Layout.getBaseClassOffset(Base);
827        StartNewTable();
828        std::vector<std::pair<const CXXRecordDecl *,
829          int64_t> > S;
830        S.push_back(std::make_pair(RD, Offset));
831        GenerateVtableForBase(Base, MorallyVirtual, o, false, &S);
832      }
833    }
834  }
835
836  Index_t end(const CXXRecordDecl *RD, std::vector<llvm::Constant *> &offsets,
837              const ASTRecordLayout &Layout,
838              const CXXRecordDecl *PrimaryBase,
839              bool PrimaryBaseWasVirtual, bool MorallyVirtual,
840              int64_t Offset, bool ForVirtualBase) {
841    StartNewTable();
842    extra = 0;
843    // FIXME: Cleanup.
844    if (!ForVirtualBase) {
845      // then virtual base offsets...
846      for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(),
847             e = offsets.rend(); i != e; ++i)
848        methods.push_back(*i);
849    }
850
851    // The vcalls come first...
852    for (std::vector<Index_t>::reverse_iterator i=VCalls.rbegin(),
853           e=VCalls.rend();
854         i != e; ++i)
855      methods.push_back(wrap((0?600:0) + *i));
856    VCalls.clear();
857
858    if (ForVirtualBase) {
859      // then virtual base offsets...
860      for (std::vector<llvm::Constant *>::reverse_iterator i = offsets.rbegin(),
861             e = offsets.rend(); i != e; ++i)
862        methods.push_back(*i);
863    }
864
865    methods.push_back(wrap(-(Offset/8)));
866    methods.push_back(rtti);
867    Index_t AddressPoint = methods.size();
868
869    InstallThunks();
870    methods.insert(methods.end(), submethods.begin(), submethods.end());
871    submethods.clear();
872
873    // and then the non-virtual bases.
874    NonVirtualBases(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual,
875                    MorallyVirtual, Offset);
876    return AddressPoint;
877  }
878
879  void Primaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset) {
880    if (!RD->isDynamicClass())
881      return;
882
883    const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
884    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
885    const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
886
887    // vtables are composed from the chain of primaries.
888    if (PrimaryBase) {
889      if (PrimaryBaseWasVirtual)
890        IndirectPrimary.insert(PrimaryBase);
891      Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset);
892    }
893
894    // And add the virtuals for the class to the primary vtable.
895    AddMethods(RD, MorallyVirtual, Offset);
896  }
897
898  int64_t GenerateVtableForBase(const CXXRecordDecl *RD,
899                                bool MorallyVirtual = false, int64_t Offset = 0,
900                                bool ForVirtualBase = false,
901                                std::vector<std::pair<const CXXRecordDecl *,
902                                int64_t> > *Path = 0) {
903    if (!RD->isDynamicClass())
904      return 0;
905
906    const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
907    const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
908    const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
909
910    std::vector<llvm::Constant *> offsets;
911    extra = 0;
912    GenerateVBaseOffsets(offsets, RD, Offset);
913    if (ForVirtualBase)
914      extra = offsets.size();
915
916    // vtables are composed from the chain of primaries.
917    if (PrimaryBase) {
918      if (PrimaryBaseWasVirtual)
919        IndirectPrimary.insert(PrimaryBase);
920      Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset);
921    }
922
923    // And add the virtuals for the class to the primary vtable.
924    AddMethods(RD, MorallyVirtual, Offset);
925
926    if (Path)
927      OverrideMethods(Path, MorallyVirtual);
928
929    return end(RD, offsets, Layout, PrimaryBase, PrimaryBaseWasVirtual,
930               MorallyVirtual, Offset, ForVirtualBase);
931  }
932
933  void GenerateVtableForVBases(const CXXRecordDecl *RD,
934                               int64_t Offset = 0,
935                               std::vector<std::pair<const CXXRecordDecl *,
936                               int64_t> > *Path = 0) {
937    bool alloc = false;
938    if (Path == 0) {
939      alloc = true;
940      Path = new std::vector<std::pair<const CXXRecordDecl *,
941        int64_t> >;
942    }
943    // FIXME: We also need to override using all paths to a virtual base,
944    // right now, we just process the first path
945    Path->push_back(std::make_pair(RD, Offset));
946    for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
947           e = RD->bases_end(); i != e; ++i) {
948      const CXXRecordDecl *Base =
949        cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
950      if (i->isVirtual() && !IndirectPrimary.count(Base)) {
951        // Mark it so we don't output it twice.
952        IndirectPrimary.insert(Base);
953        StartNewTable();
954        int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
955        GenerateVtableForBase(Base, true, BaseOffset, true, Path);
956      }
957      int64_t BaseOffset = Offset;
958      if (i->isVirtual())
959        BaseOffset = BLayout.getVBaseClassOffset(Base);
960      if (Base->getNumVBases())
961        GenerateVtableForVBases(Base, BaseOffset, Path);
962    }
963    Path->pop_back();
964    if (alloc)
965      delete Path;
966  }
967};
968
969class VtableInfo {
970public:
971  typedef VtableBuilder::Index_t Index_t;
972private:
973  CodeGenModule &CGM;  // Per-module state.
974  /// Index_t - Vtable index type.
975  typedef llvm::DenseMap<const CXXMethodDecl *, Index_t> ElTy;
976  typedef llvm::DenseMap<const CXXRecordDecl *, ElTy *> MapTy;
977  // FIXME: Move to Context.
978  static MapTy IndexFor;
979
980  typedef llvm::DenseMap<const CXXRecordDecl *, Index_t> VBElTy;
981  typedef llvm::DenseMap<const CXXRecordDecl *, VBElTy *> VBMapTy;
982  // FIXME: Move to Context.
983  static VBMapTy VBIndexFor;
984public:
985  VtableInfo(CodeGenModule &cgm) : CGM(cgm) { }
986  void RegisterIndex(const CXXRecordDecl *RD, const ElTy &e) {
987    assert(IndexFor.find(RD) == IndexFor.end() && "Don't compute vtbl twice");
988    // We own a copy of this, it will go away shortly.
989    IndexFor[RD] = new ElTy (e);
990  }
991  void RegisterVBIndex(const CXXRecordDecl *RD, const VBElTy &e) {
992    assert(VBIndexFor.find(RD) == VBIndexFor.end() && "Don't compute vtbl twice");
993    // We own a copy of this, it will go away shortly.
994    VBIndexFor[RD] = new VBElTy (e);
995  }
996  Index_t lookup(const CXXMethodDecl *MD) {
997    const CXXRecordDecl *RD = MD->getParent();
998    MapTy::iterator I = IndexFor.find(RD);
999    if (I == IndexFor.end()) {
1000      std::vector<llvm::Constant *> methods;
1001      // FIXME: This seems expensive.  Can we do a partial job to get
1002      // just this data.
1003      VtableBuilder b(methods, RD, CGM);
1004      b.GenerateVtableForBase(RD);
1005      b.GenerateVtableForVBases(RD);
1006      RegisterIndex(RD, b.getIndex());
1007      I = IndexFor.find(RD);
1008    }
1009    assert(I->second->find(MD)!=I->second->end() && "Can't find vtable index");
1010    return (*I->second)[MD];
1011  }
1012  Index_t VBlookup(const CXXRecordDecl *RD, const CXXRecordDecl *BD) {
1013    VBMapTy::iterator I = VBIndexFor.find(RD);
1014    if (I == VBIndexFor.end()) {
1015      std::vector<llvm::Constant *> methods;
1016      // FIXME: This seems expensive.  Can we do a partial job to get
1017      // just this data.
1018      VtableBuilder b(methods, RD, CGM);
1019      b.GenerateVtableForBase(RD);
1020      b.GenerateVtableForVBases(RD);
1021      RegisterVBIndex(RD, b.getVBIndex());
1022      I = VBIndexFor.find(RD);
1023    }
1024    assert(I->second->find(BD)!=I->second->end() && "Can't find vtable index");
1025    return (*I->second)[BD];
1026  }
1027};
1028
1029// FIXME: move to Context
1030static VtableInfo *vtableinfo;
1031
1032VtableBuilder::Index_t VtableBuilder::VBlookup(CXXRecordDecl *D,
1033                                               CXXRecordDecl *B) {
1034  if (vtableinfo == 0)
1035    vtableinfo = new VtableInfo(CGM);
1036
1037  return vtableinfo->VBlookup(D, B);
1038}
1039
1040
1041// FIXME: Move to Context.
1042VtableInfo::MapTy VtableInfo::IndexFor;
1043
1044// FIXME: Move to Context.
1045VtableInfo::VBMapTy VtableInfo::VBIndexFor;
1046
1047llvm::Value *CodeGenFunction::GenerateVtable(const CXXRecordDecl *RD) {
1048  llvm::SmallString<256> OutName;
1049  llvm::raw_svector_ostream Out(OutName);
1050  QualType ClassTy;
1051  ClassTy = getContext().getTagDeclType(RD);
1052  mangleCXXVtable(ClassTy, getContext(), Out);
1053  llvm::GlobalVariable::LinkageTypes linktype;
1054  linktype = llvm::GlobalValue::WeakAnyLinkage;
1055  std::vector<llvm::Constant *> methods;
1056  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1057  int64_t AddressPoint;
1058
1059  VtableBuilder b(methods, RD, CGM);
1060
1061  // First comes the vtables for all the non-virtual bases...
1062  AddressPoint = b.GenerateVtableForBase(RD);
1063
1064  // then the vtables for all the virtual bases.
1065  b.GenerateVtableForVBases(RD);
1066
1067  llvm::Constant *C;
1068  llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, methods.size());
1069  C = llvm::ConstantArray::get(type, methods);
1070  llvm::Value *vtable = new llvm::GlobalVariable(CGM.getModule(), type, true,
1071                                                 linktype, C, Out.str());
1072  vtable = Builder.CreateBitCast(vtable, Ptr8Ty);
1073  vtable = Builder.CreateGEP(vtable,
1074                       llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
1075                                              AddressPoint*LLVMPointerWidth/8));
1076  return vtable;
1077}
1078
1079llvm::Constant *CodeGenFunction::GenerateThunk(llvm::Function *Fn,
1080                                               const CXXMethodDecl *MD,
1081                                               bool Extern, int64_t nv,
1082                                               int64_t v) {
1083  QualType R = MD->getType()->getAs<FunctionType>()->getResultType();
1084
1085  FunctionArgList Args;
1086  ImplicitParamDecl *ThisDecl =
1087    ImplicitParamDecl::Create(getContext(), 0, SourceLocation(), 0,
1088                              MD->getThisType(getContext()));
1089  Args.push_back(std::make_pair(ThisDecl, ThisDecl->getType()));
1090  for (FunctionDecl::param_const_iterator i = MD->param_begin(),
1091         e = MD->param_end();
1092       i != e; ++i) {
1093    ParmVarDecl *D = *i;
1094    Args.push_back(std::make_pair(D, D->getType()));
1095  }
1096  IdentifierInfo *II
1097    = &CGM.getContext().Idents.get("__thunk_named_foo_");
1098  FunctionDecl *FD = FunctionDecl::Create(getContext(),
1099                                          getContext().getTranslationUnitDecl(),
1100                                          SourceLocation(), II, R, 0,
1101                                          Extern
1102                                            ? FunctionDecl::Extern
1103                                            : FunctionDecl::Static,
1104                                          false, true);
1105  StartFunction(FD, R, Fn, Args, SourceLocation());
1106  // FIXME: generate body
1107  FinishFunction();
1108  return Fn;
1109}
1110
1111llvm::Constant *CodeGenFunction::GenerateCovariantThunk(llvm::Function *Fn,
1112                                                        const CXXMethodDecl *MD,
1113                                                        bool Extern,
1114                                                        int64_t nv_t,
1115                                                        int64_t v_t,
1116                                                        int64_t nv_r,
1117                                                        int64_t v_r) {
1118  QualType R = MD->getType()->getAs<FunctionType>()->getResultType();
1119
1120  FunctionArgList Args;
1121  ImplicitParamDecl *ThisDecl =
1122    ImplicitParamDecl::Create(getContext(), 0, SourceLocation(), 0,
1123                              MD->getThisType(getContext()));
1124  Args.push_back(std::make_pair(ThisDecl, ThisDecl->getType()));
1125  for (FunctionDecl::param_const_iterator i = MD->param_begin(),
1126         e = MD->param_end();
1127       i != e; ++i) {
1128    ParmVarDecl *D = *i;
1129    Args.push_back(std::make_pair(D, D->getType()));
1130  }
1131  IdentifierInfo *II
1132    = &CGM.getContext().Idents.get("__thunk_named_foo_");
1133  FunctionDecl *FD = FunctionDecl::Create(getContext(),
1134                                          getContext().getTranslationUnitDecl(),
1135                                          SourceLocation(), II, R, 0,
1136                                          Extern
1137                                            ? FunctionDecl::Extern
1138                                            : FunctionDecl::Static,
1139                                          false, true);
1140  StartFunction(FD, R, Fn, Args, SourceLocation());
1141  // FIXME: generate body
1142  FinishFunction();
1143  return Fn;
1144}
1145
1146llvm::Constant *CodeGenModule::BuildThunk(const CXXMethodDecl *MD, bool Extern,
1147                                          int64_t nv, int64_t v) {
1148  llvm::SmallString<256> OutName;
1149  llvm::raw_svector_ostream Out(OutName);
1150  mangleThunk(MD, nv, v, getContext(), Out);
1151  llvm::GlobalVariable::LinkageTypes linktype;
1152  linktype = llvm::GlobalValue::WeakAnyLinkage;
1153  if (!Extern)
1154    linktype = llvm::GlobalValue::InternalLinkage;
1155  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1156  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1157  const llvm::FunctionType *FTy =
1158    getTypes().GetFunctionType(getTypes().getFunctionInfo(MD),
1159                               FPT->isVariadic());
1160
1161  llvm::Function *Fn = llvm::Function::Create(FTy, linktype, Out.str(),
1162                                              &getModule());
1163  CodeGenFunction(*this).GenerateThunk(Fn, MD, Extern, nv, v);
1164  // Fn = Builder.CreateBitCast(Fn, Ptr8Ty);
1165  llvm::Constant *m = llvm::ConstantExpr::getBitCast(Fn, Ptr8Ty);
1166  return m;
1167}
1168
1169llvm::Constant *CodeGenModule::BuildCovariantThunk(const CXXMethodDecl *MD,
1170                                                   bool Extern, int64_t nv_t,
1171                                                   int64_t v_t, int64_t nv_r,
1172                                                   int64_t v_r) {
1173  llvm::SmallString<256> OutName;
1174  llvm::raw_svector_ostream Out(OutName);
1175  mangleCovariantThunk(MD, nv_t, v_t, nv_r, v_r, getContext(), Out);
1176  llvm::GlobalVariable::LinkageTypes linktype;
1177  linktype = llvm::GlobalValue::WeakAnyLinkage;
1178  if (!Extern)
1179    linktype = llvm::GlobalValue::InternalLinkage;
1180  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1181  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1182  const llvm::FunctionType *FTy =
1183    getTypes().GetFunctionType(getTypes().getFunctionInfo(MD),
1184                               FPT->isVariadic());
1185
1186  llvm::Function *Fn = llvm::Function::Create(FTy, linktype, Out.str(),
1187                                              &getModule());
1188  CodeGenFunction(*this).GenerateCovariantThunk(Fn, MD, Extern, nv_t, v_t, nv_r,
1189                                               v_r);
1190  // Fn = Builder.CreateBitCast(Fn, Ptr8Ty);
1191  llvm::Constant *m = llvm::ConstantExpr::getBitCast(Fn, Ptr8Ty);
1192  return m;
1193}
1194
1195llvm::Value *
1196CodeGenFunction::BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *&This,
1197                                  const llvm::Type *Ty) {
1198  // FIXME: If we know the dynamic type, we don't have to do a virtual dispatch.
1199
1200  // FIXME: move to Context
1201  if (vtableinfo == 0)
1202    vtableinfo = new VtableInfo(CGM);
1203
1204  VtableInfo::Index_t Idx = vtableinfo->lookup(MD);
1205
1206  Ty = llvm::PointerType::get(Ty, 0);
1207  Ty = llvm::PointerType::get(Ty, 0);
1208  Ty = llvm::PointerType::get(Ty, 0);
1209  llvm::Value *vtbl = Builder.CreateBitCast(This, Ty);
1210  vtbl = Builder.CreateLoad(vtbl);
1211  llvm::Value *vfn = Builder.CreateConstInBoundsGEP1_64(vtbl,
1212                                                        Idx, "vfn");
1213  vfn = Builder.CreateLoad(vfn);
1214  return vfn;
1215}
1216
1217/// EmitClassAggrMemberwiseCopy - This routine generates code to copy a class
1218/// array of objects from SrcValue to DestValue. Copying can be either a bitwise
1219/// copy or via a copy constructor call.
1220//  FIXME. Consolidate this with EmitCXXAggrConstructorCall.
1221void CodeGenFunction::EmitClassAggrMemberwiseCopy(llvm::Value *Dest,
1222                                            llvm::Value *Src,
1223                                            const ArrayType *Array,
1224                                            const CXXRecordDecl *BaseClassDecl,
1225                                            QualType Ty) {
1226  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
1227  assert(CA && "VLA cannot be copied over");
1228  bool BitwiseCopy = BaseClassDecl->hasTrivialCopyConstructor();
1229
1230  // Create a temporary for the loop index and initialize it with 0.
1231  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
1232                                           "loop.index");
1233  llvm::Value* zeroConstant =
1234    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
1235    Builder.CreateStore(zeroConstant, IndexPtr, false);
1236  // Start the loop with a block that tests the condition.
1237  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
1238  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
1239
1240  EmitBlock(CondBlock);
1241
1242  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
1243  // Generate: if (loop-index < number-of-elements fall to the loop body,
1244  // otherwise, go to the block after the for-loop.
1245  uint64_t NumElements = getContext().getConstantArrayElementCount(CA);
1246  llvm::Value * NumElementsPtr =
1247    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements);
1248  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1249  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
1250                                              "isless");
1251  // If the condition is true, execute the body.
1252  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
1253
1254  EmitBlock(ForBody);
1255  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1256  // Inside the loop body, emit the constructor call on the array element.
1257  Counter = Builder.CreateLoad(IndexPtr);
1258  Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress");
1259  Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress");
1260  if (BitwiseCopy)
1261    EmitAggregateCopy(Dest, Src, Ty);
1262  else if (CXXConstructorDecl *BaseCopyCtor =
1263           BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1264    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1265                                                      Ctor_Complete);
1266    CallArgList CallArgs;
1267    // Push the this (Dest) ptr.
1268    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1269                                      BaseCopyCtor->getThisType(getContext())));
1270
1271    // Push the Src ptr.
1272    CallArgs.push_back(std::make_pair(RValue::get(Src),
1273                                      BaseCopyCtor->getParamDecl(0)->getType()));
1274    QualType ResultType =
1275      BaseCopyCtor->getType()->getAs<FunctionType>()->getResultType();
1276    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1277             Callee, CallArgs, BaseCopyCtor);
1278  }
1279  EmitBlock(ContinueBlock);
1280
1281  // Emit the increment of the loop counter.
1282  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
1283  Counter = Builder.CreateLoad(IndexPtr);
1284  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
1285  Builder.CreateStore(NextVal, IndexPtr, false);
1286
1287  // Finally, branch back up to the condition for the next iteration.
1288  EmitBranch(CondBlock);
1289
1290  // Emit the fall-through block.
1291  EmitBlock(AfterFor, true);
1292}
1293
1294/// EmitClassAggrCopyAssignment - This routine generates code to assign a class
1295/// array of objects from SrcValue to DestValue. Assignment can be either a
1296/// bitwise assignment or via a copy assignment operator function call.
1297/// FIXME. This can be consolidated with EmitClassAggrMemberwiseCopy
1298void CodeGenFunction::EmitClassAggrCopyAssignment(llvm::Value *Dest,
1299                                            llvm::Value *Src,
1300                                            const ArrayType *Array,
1301                                            const CXXRecordDecl *BaseClassDecl,
1302                                            QualType Ty) {
1303  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
1304  assert(CA && "VLA cannot be asssigned");
1305  bool BitwiseAssign = BaseClassDecl->hasTrivialCopyAssignment();
1306
1307  // Create a temporary for the loop index and initialize it with 0.
1308  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
1309                                           "loop.index");
1310  llvm::Value* zeroConstant =
1311  llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
1312  Builder.CreateStore(zeroConstant, IndexPtr, false);
1313  // Start the loop with a block that tests the condition.
1314  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
1315  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
1316
1317  EmitBlock(CondBlock);
1318
1319  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
1320  // Generate: if (loop-index < number-of-elements fall to the loop body,
1321  // otherwise, go to the block after the for-loop.
1322  uint64_t NumElements = getContext().getConstantArrayElementCount(CA);
1323  llvm::Value * NumElementsPtr =
1324  llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements);
1325  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1326  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
1327                                              "isless");
1328  // If the condition is true, execute the body.
1329  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
1330
1331  EmitBlock(ForBody);
1332  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1333  // Inside the loop body, emit the assignment operator call on array element.
1334  Counter = Builder.CreateLoad(IndexPtr);
1335  Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress");
1336  Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress");
1337  const CXXMethodDecl *MD = 0;
1338  if (BitwiseAssign)
1339    EmitAggregateCopy(Dest, Src, Ty);
1340  else {
1341    bool hasCopyAssign = BaseClassDecl->hasConstCopyAssignment(getContext(),
1342                                                               MD);
1343    assert(hasCopyAssign && "EmitClassAggrCopyAssignment - No user assign");
1344    (void)hasCopyAssign;
1345    const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1346    const llvm::Type *LTy =
1347    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1348                                   FPT->isVariadic());
1349    llvm::Constant *Callee = CGM.GetAddrOfFunction(MD, LTy);
1350
1351    CallArgList CallArgs;
1352    // Push the this (Dest) ptr.
1353    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1354                                      MD->getThisType(getContext())));
1355
1356    // Push the Src ptr.
1357    CallArgs.push_back(std::make_pair(RValue::get(Src),
1358                                      MD->getParamDecl(0)->getType()));
1359    QualType ResultType = MD->getType()->getAs<FunctionType>()->getResultType();
1360    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1361             Callee, CallArgs, MD);
1362  }
1363  EmitBlock(ContinueBlock);
1364
1365  // Emit the increment of the loop counter.
1366  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
1367  Counter = Builder.CreateLoad(IndexPtr);
1368  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
1369  Builder.CreateStore(NextVal, IndexPtr, false);
1370
1371  // Finally, branch back up to the condition for the next iteration.
1372  EmitBranch(CondBlock);
1373
1374  // Emit the fall-through block.
1375  EmitBlock(AfterFor, true);
1376}
1377
1378/// EmitClassMemberwiseCopy - This routine generates code to copy a class
1379/// object from SrcValue to DestValue. Copying can be either a bitwise copy
1380/// or via a copy constructor call.
1381void CodeGenFunction::EmitClassMemberwiseCopy(
1382                        llvm::Value *Dest, llvm::Value *Src,
1383                        const CXXRecordDecl *ClassDecl,
1384                        const CXXRecordDecl *BaseClassDecl, QualType Ty) {
1385  if (ClassDecl) {
1386    Dest = GetAddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl,
1387                                    /*NullCheckValue=*/false);
1388    Src = GetAddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl,
1389                                   /*NullCheckValue=*/false);
1390  }
1391  if (BaseClassDecl->hasTrivialCopyConstructor()) {
1392    EmitAggregateCopy(Dest, Src, Ty);
1393    return;
1394  }
1395
1396  if (CXXConstructorDecl *BaseCopyCtor =
1397      BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1398    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1399                                                      Ctor_Complete);
1400    CallArgList CallArgs;
1401    // Push the this (Dest) ptr.
1402    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1403                                      BaseCopyCtor->getThisType(getContext())));
1404
1405    // Push the Src ptr.
1406    CallArgs.push_back(std::make_pair(RValue::get(Src),
1407                       BaseCopyCtor->getParamDecl(0)->getType()));
1408    QualType ResultType =
1409    BaseCopyCtor->getType()->getAs<FunctionType>()->getResultType();
1410    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1411             Callee, CallArgs, BaseCopyCtor);
1412  }
1413}
1414
1415/// EmitClassCopyAssignment - This routine generates code to copy assign a class
1416/// object from SrcValue to DestValue. Assignment can be either a bitwise
1417/// assignment of via an assignment operator call.
1418// FIXME. Consolidate this with EmitClassMemberwiseCopy as they share a lot.
1419void CodeGenFunction::EmitClassCopyAssignment(
1420                                        llvm::Value *Dest, llvm::Value *Src,
1421                                        const CXXRecordDecl *ClassDecl,
1422                                        const CXXRecordDecl *BaseClassDecl,
1423                                        QualType Ty) {
1424  if (ClassDecl) {
1425    Dest = GetAddressCXXOfBaseClass(Dest, ClassDecl, BaseClassDecl,
1426                                    /*NullCheckValue=*/false);
1427    Src = GetAddressCXXOfBaseClass(Src, ClassDecl, BaseClassDecl,
1428                                   /*NullCheckValue=*/false);
1429  }
1430  if (BaseClassDecl->hasTrivialCopyAssignment()) {
1431    EmitAggregateCopy(Dest, Src, Ty);
1432    return;
1433  }
1434
1435  const CXXMethodDecl *MD = 0;
1436  bool ConstCopyAssignOp = BaseClassDecl->hasConstCopyAssignment(getContext(),
1437                                                                 MD);
1438  assert(ConstCopyAssignOp && "EmitClassCopyAssignment - missing copy assign");
1439  (void)ConstCopyAssignOp;
1440
1441  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1442  const llvm::Type *LTy =
1443    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1444                                   FPT->isVariadic());
1445  llvm::Constant *Callee = CGM.GetAddrOfFunction(MD, LTy);
1446
1447  CallArgList CallArgs;
1448  // Push the this (Dest) ptr.
1449  CallArgs.push_back(std::make_pair(RValue::get(Dest),
1450                                    MD->getThisType(getContext())));
1451
1452  // Push the Src ptr.
1453  CallArgs.push_back(std::make_pair(RValue::get(Src),
1454                                    MD->getParamDecl(0)->getType()));
1455  QualType ResultType =
1456    MD->getType()->getAs<FunctionType>()->getResultType();
1457  EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1458           Callee, CallArgs, MD);
1459}
1460
1461/// SynthesizeDefaultConstructor - synthesize a default constructor
1462void
1463CodeGenFunction::SynthesizeDefaultConstructor(const CXXConstructorDecl *Ctor,
1464                                              CXXCtorType Type,
1465                                              llvm::Function *Fn,
1466                                              const FunctionArgList &Args) {
1467  StartFunction(GlobalDecl(Ctor, Type), Ctor->getResultType(), Fn, Args,
1468                SourceLocation());
1469  EmitCtorPrologue(Ctor, Type);
1470  FinishFunction();
1471}
1472
1473/// SynthesizeCXXCopyConstructor - This routine implicitly defines body of a copy
1474/// constructor, in accordance with section 12.8 (p7 and p8) of C++03
1475/// The implicitly-defined copy constructor for class X performs a memberwise
1476/// copy of its subobjects. The order of copying is the same as the order
1477/// of initialization of bases and members in a user-defined constructor
1478/// Each subobject is copied in the manner appropriate to its type:
1479///  if the subobject is of class type, the copy constructor for the class is
1480///  used;
1481///  if the subobject is an array, each element is copied, in the manner
1482///  appropriate to the element type;
1483///  if the subobject is of scalar type, the built-in assignment operator is
1484///  used.
1485/// Virtual base class subobjects shall be copied only once by the
1486/// implicitly-defined copy constructor
1487
1488void
1489CodeGenFunction::SynthesizeCXXCopyConstructor(const CXXConstructorDecl *Ctor,
1490                                              CXXCtorType Type,
1491                                              llvm::Function *Fn,
1492                                              const FunctionArgList &Args) {
1493  const CXXRecordDecl *ClassDecl = Ctor->getParent();
1494  assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
1495         "SynthesizeCXXCopyConstructor - copy constructor has definition already");
1496  StartFunction(GlobalDecl(Ctor, Type), Ctor->getResultType(), Fn, Args,
1497                SourceLocation());
1498
1499  FunctionArgList::const_iterator i = Args.begin();
1500  const VarDecl *ThisArg = i->first;
1501  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1502  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1503  const VarDecl *SrcArg = (i+1)->first;
1504  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1505  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1506
1507  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1508       Base != ClassDecl->bases_end(); ++Base) {
1509    // FIXME. copy constrution of virtual base NYI
1510    if (Base->isVirtual())
1511      continue;
1512
1513    CXXRecordDecl *BaseClassDecl
1514      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1515    EmitClassMemberwiseCopy(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1516                            Base->getType());
1517  }
1518
1519  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1520       FieldEnd = ClassDecl->field_end();
1521       Field != FieldEnd; ++Field) {
1522    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1523    const ConstantArrayType *Array =
1524      getContext().getAsConstantArrayType(FieldType);
1525    if (Array)
1526      FieldType = getContext().getBaseElementType(FieldType);
1527
1528    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1529      CXXRecordDecl *FieldClassDecl
1530        = cast<CXXRecordDecl>(FieldClassType->getDecl());
1531      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1532      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1533      if (Array) {
1534        const llvm::Type *BasePtr = ConvertType(FieldType);
1535        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1536        llvm::Value *DestBaseAddrPtr =
1537          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1538        llvm::Value *SrcBaseAddrPtr =
1539          Builder.CreateBitCast(RHS.getAddress(), BasePtr);
1540        EmitClassAggrMemberwiseCopy(DestBaseAddrPtr, SrcBaseAddrPtr, Array,
1541                                    FieldClassDecl, FieldType);
1542      }
1543      else
1544        EmitClassMemberwiseCopy(LHS.getAddress(), RHS.getAddress(),
1545                                0 /*ClassDecl*/, FieldClassDecl, FieldType);
1546      continue;
1547    }
1548    // Do a built-in assignment of scalar data members.
1549    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1550    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1551    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1552    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1553  }
1554  FinishFunction();
1555}
1556
1557/// SynthesizeCXXCopyAssignment - Implicitly define copy assignment operator.
1558/// Before the implicitly-declared copy assignment operator for a class is
1559/// implicitly defined, all implicitly- declared copy assignment operators for
1560/// its direct base classes and its nonstatic data members shall have been
1561/// implicitly defined. [12.8-p12]
1562/// The implicitly-defined copy assignment operator for class X performs
1563/// memberwise assignment of its subob- jects. The direct base classes of X are
1564/// assigned first, in the order of their declaration in
1565/// the base-specifier-list, and then the immediate nonstatic data members of X
1566/// are assigned, in the order in which they were declared in the class
1567/// definition.Each subobject is assigned in the manner appropriate to its type:
1568///   if the subobject is of class type, the copy assignment operator for the
1569///   class is used (as if by explicit qualification; that is, ignoring any
1570///   possible virtual overriding functions in more derived classes);
1571///
1572///   if the subobject is an array, each element is assigned, in the manner
1573///   appropriate to the element type;
1574///
1575///   if the subobject is of scalar type, the built-in assignment operator is
1576///   used.
1577void CodeGenFunction::SynthesizeCXXCopyAssignment(const CXXMethodDecl *CD,
1578                                                  llvm::Function *Fn,
1579                                                  const FunctionArgList &Args) {
1580
1581  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1582  assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
1583         "SynthesizeCXXCopyAssignment - copy assignment has user declaration");
1584  StartFunction(CD, CD->getResultType(), Fn, Args, SourceLocation());
1585
1586  FunctionArgList::const_iterator i = Args.begin();
1587  const VarDecl *ThisArg = i->first;
1588  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1589  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1590  const VarDecl *SrcArg = (i+1)->first;
1591  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1592  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1593
1594  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1595       Base != ClassDecl->bases_end(); ++Base) {
1596    // FIXME. copy assignment of virtual base NYI
1597    if (Base->isVirtual())
1598      continue;
1599
1600    CXXRecordDecl *BaseClassDecl
1601      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1602    EmitClassCopyAssignment(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1603                            Base->getType());
1604  }
1605
1606  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1607       FieldEnd = ClassDecl->field_end();
1608       Field != FieldEnd; ++Field) {
1609    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1610    const ConstantArrayType *Array =
1611      getContext().getAsConstantArrayType(FieldType);
1612    if (Array)
1613      FieldType = getContext().getBaseElementType(FieldType);
1614
1615    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1616      CXXRecordDecl *FieldClassDecl
1617      = cast<CXXRecordDecl>(FieldClassType->getDecl());
1618      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1619      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1620      if (Array) {
1621        const llvm::Type *BasePtr = ConvertType(FieldType);
1622        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1623        llvm::Value *DestBaseAddrPtr =
1624          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1625        llvm::Value *SrcBaseAddrPtr =
1626          Builder.CreateBitCast(RHS.getAddress(), BasePtr);
1627        EmitClassAggrCopyAssignment(DestBaseAddrPtr, SrcBaseAddrPtr, Array,
1628                                    FieldClassDecl, FieldType);
1629      }
1630      else
1631        EmitClassCopyAssignment(LHS.getAddress(), RHS.getAddress(),
1632                               0 /*ClassDecl*/, FieldClassDecl, FieldType);
1633      continue;
1634    }
1635    // Do a built-in assignment of scalar data members.
1636    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1637    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1638    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1639    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1640  }
1641
1642  // return *this;
1643  Builder.CreateStore(LoadOfThis, ReturnValue);
1644
1645  FinishFunction();
1646}
1647
1648/// EmitCtorPrologue - This routine generates necessary code to initialize
1649/// base classes and non-static data members belonging to this constructor.
1650/// FIXME: This needs to take a CXXCtorType.
1651void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD,
1652                                       CXXCtorType CtorType) {
1653  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1654  // FIXME: Add vbase initialization
1655  llvm::Value *LoadOfThis = 0;
1656
1657  for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
1658       E = CD->init_end();
1659       B != E; ++B) {
1660    CXXBaseOrMemberInitializer *Member = (*B);
1661    if (Member->isBaseInitializer()) {
1662      LoadOfThis = LoadCXXThis();
1663      Type *BaseType = Member->getBaseClass();
1664      CXXRecordDecl *BaseClassDecl =
1665        cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
1666      llvm::Value *V = GetAddressCXXOfBaseClass(LoadOfThis, ClassDecl,
1667                                                BaseClassDecl,
1668                                                /*NullCheckValue=*/false);
1669      EmitCXXConstructorCall(Member->getConstructor(),
1670                             CtorType, V,
1671                             Member->const_arg_begin(),
1672                             Member->const_arg_end());
1673    } else {
1674      // non-static data member initilaizers.
1675      FieldDecl *Field = Member->getMember();
1676      QualType FieldType = getContext().getCanonicalType((Field)->getType());
1677      const ConstantArrayType *Array =
1678        getContext().getAsConstantArrayType(FieldType);
1679      if (Array)
1680        FieldType = getContext().getBaseElementType(FieldType);
1681
1682      LoadOfThis = LoadCXXThis();
1683      LValue LHS;
1684      if (FieldType->isReferenceType()) {
1685        // FIXME: This is really ugly; should be refactored somehow
1686        unsigned idx = CGM.getTypes().getLLVMFieldNo(Field);
1687        llvm::Value *V = Builder.CreateStructGEP(LoadOfThis, idx, "tmp");
1688        assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1689        LHS = LValue::MakeAddr(V, MakeQualifiers(FieldType));
1690      } else {
1691        LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
1692      }
1693      if (FieldType->getAs<RecordType>()) {
1694        if (!Field->isAnonymousStructOrUnion()) {
1695          assert(Member->getConstructor() &&
1696                 "EmitCtorPrologue - no constructor to initialize member");
1697          if (Array) {
1698            const llvm::Type *BasePtr = ConvertType(FieldType);
1699            BasePtr = llvm::PointerType::getUnqual(BasePtr);
1700            llvm::Value *BaseAddrPtr =
1701            Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1702            EmitCXXAggrConstructorCall(Member->getConstructor(),
1703                                       Array, BaseAddrPtr);
1704          }
1705          else
1706            EmitCXXConstructorCall(Member->getConstructor(),
1707                                   Ctor_Complete, LHS.getAddress(),
1708                                   Member->const_arg_begin(),
1709                                   Member->const_arg_end());
1710          continue;
1711        }
1712        else {
1713          // Initializing an anonymous union data member.
1714          FieldDecl *anonMember = Member->getAnonUnionMember();
1715          LHS = EmitLValueForField(LHS.getAddress(), anonMember,
1716                                   /*IsUnion=*/true, 0);
1717          FieldType = anonMember->getType();
1718        }
1719      }
1720
1721      assert(Member->getNumArgs() == 1 && "Initializer count must be 1 only");
1722      Expr *RhsExpr = *Member->arg_begin();
1723      RValue RHS;
1724      if (FieldType->isReferenceType())
1725        RHS = EmitReferenceBindingToExpr(RhsExpr, FieldType,
1726                                        /*IsInitializer=*/true);
1727      else
1728        RHS = RValue::get(EmitScalarExpr(RhsExpr, true));
1729      EmitStoreThroughLValue(RHS, LHS, FieldType);
1730    }
1731  }
1732
1733  if (!CD->getNumBaseOrMemberInitializers() && !CD->isTrivial()) {
1734    // Nontrivial default constructor with no initializer list. It may still
1735    // have bases classes and/or contain non-static data members which require
1736    // construction.
1737    for (CXXRecordDecl::base_class_const_iterator Base =
1738          ClassDecl->bases_begin();
1739          Base != ClassDecl->bases_end(); ++Base) {
1740      // FIXME. copy assignment of virtual base NYI
1741      if (Base->isVirtual())
1742        continue;
1743
1744      CXXRecordDecl *BaseClassDecl
1745        = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1746      if (BaseClassDecl->hasTrivialConstructor())
1747        continue;
1748      if (CXXConstructorDecl *BaseCX =
1749            BaseClassDecl->getDefaultConstructor(getContext())) {
1750        LoadOfThis = LoadCXXThis();
1751        llvm::Value *V = GetAddressCXXOfBaseClass(LoadOfThis, ClassDecl,
1752                                                  BaseClassDecl,
1753                                                  /*NullCheckValue=*/false);
1754        EmitCXXConstructorCall(BaseCX, Ctor_Complete, V, 0, 0);
1755      }
1756    }
1757
1758    for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1759         FieldEnd = ClassDecl->field_end();
1760         Field != FieldEnd; ++Field) {
1761      QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1762      const ConstantArrayType *Array =
1763        getContext().getAsConstantArrayType(FieldType);
1764      if (Array)
1765        FieldType = getContext().getBaseElementType(FieldType);
1766      if (!FieldType->getAs<RecordType>() || Field->isAnonymousStructOrUnion())
1767        continue;
1768      const RecordType *ClassRec = FieldType->getAs<RecordType>();
1769      CXXRecordDecl *MemberClassDecl =
1770        dyn_cast<CXXRecordDecl>(ClassRec->getDecl());
1771      if (!MemberClassDecl || MemberClassDecl->hasTrivialConstructor())
1772        continue;
1773      if (CXXConstructorDecl *MamberCX =
1774            MemberClassDecl->getDefaultConstructor(getContext())) {
1775        LoadOfThis = LoadCXXThis();
1776        LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1777        if (Array) {
1778          const llvm::Type *BasePtr = ConvertType(FieldType);
1779          BasePtr = llvm::PointerType::getUnqual(BasePtr);
1780          llvm::Value *BaseAddrPtr =
1781            Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1782          EmitCXXAggrConstructorCall(MamberCX, Array, BaseAddrPtr);
1783        }
1784        else
1785          EmitCXXConstructorCall(MamberCX, Ctor_Complete, LHS.getAddress(),
1786                                 0, 0);
1787      }
1788    }
1789  }
1790
1791  // Initialize the vtable pointer
1792  if (ClassDecl->isDynamicClass()) {
1793    if (!LoadOfThis)
1794      LoadOfThis = LoadCXXThis();
1795    llvm::Value *VtableField;
1796    llvm::Type *Ptr8Ty, *PtrPtr8Ty;
1797    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
1798    PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0);
1799    VtableField = Builder.CreateBitCast(LoadOfThis, PtrPtr8Ty);
1800    llvm::Value *vtable = GenerateVtable(ClassDecl);
1801    Builder.CreateStore(vtable, VtableField);
1802  }
1803}
1804
1805/// EmitDtorEpilogue - Emit all code that comes at the end of class's
1806/// destructor. This is to call destructors on members and base classes
1807/// in reverse order of their construction.
1808/// FIXME: This needs to take a CXXDtorType.
1809void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD,
1810                                       CXXDtorType DtorType) {
1811  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext());
1812  assert(!ClassDecl->getNumVBases() &&
1813         "FIXME: Destruction of virtual bases not supported");
1814  (void)ClassDecl;  // prevent warning.
1815
1816  for (CXXDestructorDecl::destr_const_iterator *B = DD->destr_begin(),
1817       *E = DD->destr_end(); B != E; ++B) {
1818    uintptr_t BaseOrMember = (*B);
1819    if (DD->isMemberToDestroy(BaseOrMember)) {
1820      FieldDecl *FD = DD->getMemberToDestroy(BaseOrMember);
1821      QualType FieldType = getContext().getCanonicalType((FD)->getType());
1822      const ConstantArrayType *Array =
1823        getContext().getAsConstantArrayType(FieldType);
1824      if (Array)
1825        FieldType = getContext().getBaseElementType(FieldType);
1826      const RecordType *RT = FieldType->getAs<RecordType>();
1827      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1828      if (FieldClassDecl->hasTrivialDestructor())
1829        continue;
1830      llvm::Value *LoadOfThis = LoadCXXThis();
1831      LValue LHS = EmitLValueForField(LoadOfThis, FD, false, 0);
1832      if (Array) {
1833        const llvm::Type *BasePtr = ConvertType(FieldType);
1834        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1835        llvm::Value *BaseAddrPtr =
1836          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1837        EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1838                                  Array, BaseAddrPtr);
1839      }
1840      else
1841        EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1842                              Dtor_Complete, LHS.getAddress());
1843    } else {
1844      const RecordType *RT =
1845        DD->getAnyBaseClassToDestroy(BaseOrMember)->getAs<RecordType>();
1846      CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1847      if (BaseClassDecl->hasTrivialDestructor())
1848        continue;
1849      llvm::Value *V = GetAddressCXXOfBaseClass(LoadCXXThis(),
1850                                                ClassDecl, BaseClassDecl,
1851                                                /*NullCheckValue=*/false);
1852      EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1853                            DtorType, V);
1854    }
1855  }
1856  if (DD->getNumBaseOrMemberDestructions() || DD->isTrivial())
1857    return;
1858  // Case of destructor synthesis with fields and base classes
1859  // which have non-trivial destructors. They must be destructed in
1860  // reverse order of their construction.
1861  llvm::SmallVector<FieldDecl *, 16> DestructedFields;
1862
1863  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1864       FieldEnd = ClassDecl->field_end();
1865       Field != FieldEnd; ++Field) {
1866    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1867    if (getContext().getAsConstantArrayType(FieldType))
1868      FieldType = getContext().getBaseElementType(FieldType);
1869    if (const RecordType *RT = FieldType->getAs<RecordType>()) {
1870      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1871      if (FieldClassDecl->hasTrivialDestructor())
1872        continue;
1873      DestructedFields.push_back(*Field);
1874    }
1875  }
1876  if (!DestructedFields.empty())
1877    for (int i = DestructedFields.size() -1; i >= 0; --i) {
1878      FieldDecl *Field = DestructedFields[i];
1879      QualType FieldType = Field->getType();
1880      const ConstantArrayType *Array =
1881        getContext().getAsConstantArrayType(FieldType);
1882        if (Array)
1883          FieldType = getContext().getBaseElementType(FieldType);
1884      const RecordType *RT = FieldType->getAs<RecordType>();
1885      CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1886      llvm::Value *LoadOfThis = LoadCXXThis();
1887      LValue LHS = EmitLValueForField(LoadOfThis, Field, false, 0);
1888      if (Array) {
1889        const llvm::Type *BasePtr = ConvertType(FieldType);
1890        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1891        llvm::Value *BaseAddrPtr =
1892        Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1893        EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1894                                  Array, BaseAddrPtr);
1895      }
1896      else
1897        EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1898                              Dtor_Complete, LHS.getAddress());
1899    }
1900
1901  llvm::SmallVector<CXXRecordDecl*, 4> DestructedBases;
1902  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1903       Base != ClassDecl->bases_end(); ++Base) {
1904    // FIXME. copy assignment of virtual base NYI
1905    if (Base->isVirtual())
1906      continue;
1907
1908    CXXRecordDecl *BaseClassDecl
1909      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1910    if (BaseClassDecl->hasTrivialDestructor())
1911      continue;
1912    DestructedBases.push_back(BaseClassDecl);
1913  }
1914  if (DestructedBases.empty())
1915    return;
1916  for (int i = DestructedBases.size() -1; i >= 0; --i) {
1917    CXXRecordDecl *BaseClassDecl = DestructedBases[i];
1918    llvm::Value *V = GetAddressCXXOfBaseClass(LoadCXXThis(),
1919                                              ClassDecl,BaseClassDecl,
1920                                              /*NullCheckValue=*/false);
1921    EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1922                          Dtor_Complete, V);
1923  }
1924}
1925
1926void CodeGenFunction::SynthesizeDefaultDestructor(const CXXDestructorDecl *Dtor,
1927                                                  CXXDtorType DtorType,
1928                                                  llvm::Function *Fn,
1929                                                  const FunctionArgList &Args) {
1930
1931  const CXXRecordDecl *ClassDecl = Dtor->getParent();
1932  assert(!ClassDecl->hasUserDeclaredDestructor() &&
1933         "SynthesizeDefaultDestructor - destructor has user declaration");
1934  (void) ClassDecl;
1935
1936  StartFunction(GlobalDecl(Dtor, DtorType), Dtor->getResultType(), Fn, Args,
1937                SourceLocation());
1938  EmitDtorEpilogue(Dtor, DtorType);
1939  FinishFunction();
1940}
1941
1942// FIXME: Move this to CGCXXStmt.cpp
1943void CodeGenFunction::EmitCXXTryStmt(const CXXTryStmt &S) {
1944  // FIXME: We need to do more here.
1945  EmitStmt(S.getTryBlock());
1946}
1947