CGCXX.cpp revision 5d4d946ec2d88696fd8422aeb64dc29688e6a2c1 
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(llvm::Constant *DtorFn,
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  llvm::Value *Args[3] = { llvm::ConstantExpr::getBitCast(DtorFn, DtorFnTy),
59                           llvm::ConstantExpr::getBitCast(DeclPtr, Int8PtrTy),
60                           llvm::ConstantExpr::getBitCast(Handle, Int8PtrTy) };
61  Builder.CreateCall(AtExitFn, &Args[0], llvm::array_endof(Args));
62}
63
64void CodeGenFunction::EmitCXXGlobalVarDeclInit(const VarDecl &D,
65                                               llvm::Constant *DeclPtr) {
66  assert(D.hasGlobalStorage() &&
67         "VarDecl must have global storage!");
68
69  const Expr *Init = D.getInit();
70  QualType T = D.getType();
71  bool isVolatile = getContext().getCanonicalType(T).isVolatileQualified();
72
73  if (T->isReferenceType()) {
74    ErrorUnsupported(Init, "global variable that binds to a reference");
75  } else if (!hasAggregateLLVMType(T)) {
76    llvm::Value *V = EmitScalarExpr(Init);
77    EmitStoreOfScalar(V, DeclPtr, isVolatile, T);
78  } else if (T->isAnyComplexType()) {
79    EmitComplexExprIntoAddr(Init, DeclPtr, isVolatile);
80  } else {
81    EmitAggExpr(Init, DeclPtr, isVolatile);
82    // Avoid generating destructor(s) for initialized objects.
83    if (!isa<CXXConstructExpr>(Init))
84      return;
85    const ConstantArrayType *Array = getContext().getAsConstantArrayType(T);
86    if (Array)
87      T = getContext().getBaseElementType(Array);
88
89    if (const RecordType *RT = T->getAs<RecordType>()) {
90      CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
91      if (!RD->hasTrivialDestructor()) {
92        llvm::Constant *DtorFn;
93        if (Array) {
94          DtorFn = CodeGenFunction(CGM).GenerateCXXAggrDestructorHelper(
95                                                RD->getDestructor(getContext()),
96                                                Array, DeclPtr);
97          DeclPtr =
98            llvm::Constant::getNullValue(llvm::Type::getInt8PtrTy(VMContext));
99        }
100        else
101          DtorFn = CGM.GetAddrOfCXXDestructor(RD->getDestructor(getContext()),
102                                              Dtor_Complete);
103        EmitCXXGlobalDtorRegistration(DtorFn, DeclPtr);
104      }
105    }
106  }
107}
108
109void
110CodeGenModule::EmitCXXGlobalInitFunc() {
111  if (CXXGlobalInits.empty())
112    return;
113
114  const llvm::FunctionType *FTy
115    = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
116                              false);
117
118  // Create our global initialization function.
119  // FIXME: Should this be tweakable by targets?
120  llvm::Function *Fn =
121    llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
122                           "__cxx_global_initialization", &TheModule);
123
124  CodeGenFunction(*this).GenerateCXXGlobalInitFunc(Fn,
125                                                   &CXXGlobalInits[0],
126                                                   CXXGlobalInits.size());
127  AddGlobalCtor(Fn);
128}
129
130void CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
131                                                const VarDecl **Decls,
132                                                unsigned NumDecls) {
133  StartFunction(GlobalDecl(), getContext().VoidTy, Fn, FunctionArgList(),
134                SourceLocation());
135
136  for (unsigned i = 0; i != NumDecls; ++i) {
137    const VarDecl *D = Decls[i];
138
139    llvm::Constant *DeclPtr = CGM.GetAddrOfGlobalVar(D);
140    EmitCXXGlobalVarDeclInit(*D, DeclPtr);
141  }
142  FinishFunction();
143}
144
145void
146CodeGenFunction::EmitStaticCXXBlockVarDeclInit(const VarDecl &D,
147                                               llvm::GlobalVariable *GV) {
148  // FIXME: This should use __cxa_guard_{acquire,release}?
149
150  assert(!getContext().getLangOptions().ThreadsafeStatics &&
151         "thread safe statics are currently not supported!");
152
153  llvm::SmallString<256> GuardVName;
154  CGM.getMangleContext().mangleGuardVariable(&D, GuardVName);
155
156  // Create the guard variable.
157  llvm::GlobalValue *GuardV =
158    new llvm::GlobalVariable(CGM.getModule(), llvm::Type::getInt64Ty(VMContext),
159                             false, GV->getLinkage(),
160                llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext)),
161                             GuardVName.str());
162
163  // Load the first byte of the guard variable.
164  const llvm::Type *PtrTy
165    = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
166  llvm::Value *V = Builder.CreateLoad(Builder.CreateBitCast(GuardV, PtrTy),
167                                      "tmp");
168
169  // Compare it against 0.
170  llvm::Value *nullValue
171    = llvm::Constant::getNullValue(llvm::Type::getInt8Ty(VMContext));
172  llvm::Value *ICmp = Builder.CreateICmpEQ(V, nullValue , "tobool");
173
174  llvm::BasicBlock *InitBlock = createBasicBlock("init");
175  llvm::BasicBlock *EndBlock = createBasicBlock("init.end");
176
177  // If the guard variable is 0, jump to the initializer code.
178  Builder.CreateCondBr(ICmp, InitBlock, EndBlock);
179
180  EmitBlock(InitBlock);
181
182  EmitCXXGlobalVarDeclInit(D, GV);
183
184  Builder.CreateStore(llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext),
185                                             1),
186                      Builder.CreateBitCast(GuardV, PtrTy));
187
188  EmitBlock(EndBlock);
189}
190
191RValue CodeGenFunction::EmitCXXMemberCall(const CXXMethodDecl *MD,
192                                          llvm::Value *Callee,
193                                          llvm::Value *This,
194                                          CallExpr::const_arg_iterator ArgBeg,
195                                          CallExpr::const_arg_iterator ArgEnd) {
196  assert(MD->isInstance() &&
197         "Trying to emit a member call expr on a static method!");
198
199  // A call to a trivial destructor requires no code generation.
200  if (const CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(MD))
201    if (Destructor->isTrivial())
202      return RValue::get(0);
203
204  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
205
206  CallArgList Args;
207
208  // Push the this ptr.
209  Args.push_back(std::make_pair(RValue::get(This),
210                                MD->getThisType(getContext())));
211
212  // And the rest of the call args
213  EmitCallArgs(Args, FPT, ArgBeg, ArgEnd);
214
215  QualType ResultType = MD->getType()->getAs<FunctionType>()->getResultType();
216  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args),
217                  Callee, Args, MD);
218}
219
220/// canDevirtualizeMemberFunctionCalls - Checks whether virtual calls on given
221/// expr can be devirtualized.
222static bool canDevirtualizeMemberFunctionCalls(const Expr *Base) {
223  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
224    if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
225      // This is a record decl. We know the type and can devirtualize it.
226      return VD->getType()->isRecordType();
227    }
228
229    return false;
230  }
231
232  // We can always devirtualize calls on temporary object expressions.
233  if (isa<CXXTemporaryObjectExpr>(Base))
234    return true;
235
236  // And calls on bound temporaries.
237  if (isa<CXXBindTemporaryExpr>(Base))
238    return true;
239
240  // Check if this is a call expr that returns a record type.
241  if (const CallExpr *CE = dyn_cast<CallExpr>(Base))
242    return CE->getCallReturnType()->isRecordType();
243
244  // We can't devirtualize the call.
245  return false;
246}
247
248RValue CodeGenFunction::EmitCXXMemberCallExpr(const CXXMemberCallExpr *CE) {
249  if (isa<BinaryOperator>(CE->getCallee()))
250    return EmitCXXMemberPointerCallExpr(CE);
251
252  const MemberExpr *ME = cast<MemberExpr>(CE->getCallee());
253  const CXXMethodDecl *MD = cast<CXXMethodDecl>(ME->getMemberDecl());
254
255  if (MD->isStatic()) {
256    // The method is static, emit it as we would a regular call.
257    llvm::Value *Callee = CGM.GetAddrOfFunction(MD);
258    return EmitCall(Callee, getContext().getPointerType(MD->getType()),
259                    CE->arg_begin(), CE->arg_end(), 0);
260
261  }
262
263  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
264
265  const llvm::Type *Ty =
266    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
267                                   FPT->isVariadic());
268  llvm::Value *This;
269
270  if (ME->isArrow())
271    This = EmitScalarExpr(ME->getBase());
272  else {
273    LValue BaseLV = EmitLValue(ME->getBase());
274    This = BaseLV.getAddress();
275  }
276
277  // C++ [class.virtual]p12:
278  //   Explicit qualification with the scope operator (5.1) suppresses the
279  //   virtual call mechanism.
280  //
281  // We also don't emit a virtual call if the base expression has a record type
282  // because then we know what the type is.
283  llvm::Value *Callee;
284  if (const CXXDestructorDecl *Destructor
285             = dyn_cast<CXXDestructorDecl>(MD)) {
286    if (MD->isVirtual() && !ME->hasQualifier() &&
287        !canDevirtualizeMemberFunctionCalls(ME->getBase())) {
288      Callee = BuildVirtualCall(Destructor, Dtor_Complete, This, Ty);
289    } else {
290      Callee = CGM.GetAddrOfFunction(GlobalDecl(Destructor, Dtor_Complete), Ty);
291    }
292  } else if (MD->isVirtual() && !ME->hasQualifier() &&
293             !canDevirtualizeMemberFunctionCalls(ME->getBase())) {
294    Callee = BuildVirtualCall(MD, This, Ty);
295  } else {
296    Callee = CGM.GetAddrOfFunction(MD, Ty);
297  }
298
299  return EmitCXXMemberCall(MD, Callee, This,
300                           CE->arg_begin(), CE->arg_end());
301}
302
303RValue
304CodeGenFunction::EmitCXXMemberPointerCallExpr(const CXXMemberCallExpr *E) {
305  const BinaryOperator *BO = cast<BinaryOperator>(E->getCallee());
306  const Expr *BaseExpr = BO->getLHS();
307  const Expr *MemFnExpr = BO->getRHS();
308
309  const MemberPointerType *MPT =
310    MemFnExpr->getType()->getAs<MemberPointerType>();
311  const FunctionProtoType *FPT =
312    MPT->getPointeeType()->getAs<FunctionProtoType>();
313  const CXXRecordDecl *RD =
314    cast<CXXRecordDecl>(MPT->getClass()->getAs<RecordType>()->getDecl());
315
316  const llvm::FunctionType *FTy =
317    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(RD, FPT),
318                                   FPT->isVariadic());
319
320  const llvm::Type *Int8PtrTy =
321    llvm::Type::getInt8Ty(VMContext)->getPointerTo();
322
323  // Get the member function pointer.
324  llvm::Value *MemFnPtr =
325    CreateTempAlloca(ConvertType(MemFnExpr->getType()), "mem.fn");
326  EmitAggExpr(MemFnExpr, MemFnPtr, /*VolatileDest=*/false);
327
328  // Emit the 'this' pointer.
329  llvm::Value *This;
330
331  if (BO->getOpcode() == BinaryOperator::PtrMemI)
332    This = EmitScalarExpr(BaseExpr);
333  else
334    This = EmitLValue(BaseExpr).getAddress();
335
336  // Adjust it.
337  llvm::Value *Adj = Builder.CreateStructGEP(MemFnPtr, 1);
338  Adj = Builder.CreateLoad(Adj, "mem.fn.adj");
339
340  llvm::Value *Ptr = Builder.CreateBitCast(This, Int8PtrTy, "ptr");
341  Ptr = Builder.CreateGEP(Ptr, Adj, "adj");
342
343  This = Builder.CreateBitCast(Ptr, This->getType(), "this");
344
345  llvm::Value *FnPtr = Builder.CreateStructGEP(MemFnPtr, 0, "mem.fn.ptr");
346
347  const llvm::Type *PtrDiffTy = ConvertType(getContext().getPointerDiffType());
348
349  llvm::Value *FnAsInt = Builder.CreateLoad(FnPtr, "fn");
350
351  // If the LSB in the function pointer is 1, the function pointer points to
352  // a virtual function.
353  llvm::Value *IsVirtual
354    = Builder.CreateAnd(FnAsInt, llvm::ConstantInt::get(PtrDiffTy, 1),
355                        "and");
356
357  IsVirtual = Builder.CreateTrunc(IsVirtual,
358                                  llvm::Type::getInt1Ty(VMContext));
359
360  llvm::BasicBlock *FnVirtual = createBasicBlock("fn.virtual");
361  llvm::BasicBlock *FnNonVirtual = createBasicBlock("fn.nonvirtual");
362  llvm::BasicBlock *FnEnd = createBasicBlock("fn.end");
363
364  Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
365  EmitBlock(FnVirtual);
366
367  const llvm::Type *VTableTy =
368    FTy->getPointerTo()->getPointerTo()->getPointerTo();
369
370  llvm::Value *VTable = Builder.CreateBitCast(This, VTableTy);
371  VTable = Builder.CreateLoad(VTable);
372
373  VTable = Builder.CreateGEP(VTable, FnAsInt, "fn");
374
375  // Since the function pointer is 1 plus the virtual table offset, we
376  // subtract 1 by using a GEP.
377  VTable = Builder.CreateConstGEP1_64(VTable, (uint64_t)-1);
378
379  llvm::Value *VirtualFn = Builder.CreateLoad(VTable, "virtualfn");
380
381  EmitBranch(FnEnd);
382  EmitBlock(FnNonVirtual);
383
384  // If the function is not virtual, just load the pointer.
385  llvm::Value *NonVirtualFn = Builder.CreateLoad(FnPtr, "fn");
386  NonVirtualFn = Builder.CreateIntToPtr(NonVirtualFn, FTy->getPointerTo());
387
388  EmitBlock(FnEnd);
389
390  llvm::PHINode *Callee = Builder.CreatePHI(FTy->getPointerTo());
391  Callee->reserveOperandSpace(2);
392  Callee->addIncoming(VirtualFn, FnVirtual);
393  Callee->addIncoming(NonVirtualFn, FnNonVirtual);
394
395  CallArgList Args;
396
397  QualType ThisType =
398    getContext().getPointerType(getContext().getTagDeclType(RD));
399
400  // Push the this ptr.
401  Args.push_back(std::make_pair(RValue::get(This), ThisType));
402
403  // And the rest of the call args
404  EmitCallArgs(Args, FPT, E->arg_begin(), E->arg_end());
405  QualType ResultType = BO->getType()->getAs<FunctionType>()->getResultType();
406  return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args),
407                  Callee, Args, 0);
408}
409
410RValue
411CodeGenFunction::EmitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *E,
412                                               const CXXMethodDecl *MD) {
413  assert(MD->isInstance() &&
414         "Trying to emit a member call expr on a static method!");
415
416  if (MD->isCopyAssignment()) {
417    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(MD->getDeclContext());
418    if (ClassDecl->hasTrivialCopyAssignment()) {
419      assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
420             "EmitCXXOperatorMemberCallExpr - user declared copy assignment");
421      llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
422      llvm::Value *Src = EmitLValue(E->getArg(1)).getAddress();
423      QualType Ty = E->getType();
424      EmitAggregateCopy(This, Src, Ty);
425      return RValue::get(This);
426    }
427  }
428
429  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
430  const llvm::Type *Ty =
431    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
432                                   FPT->isVariadic());
433
434  llvm::Value *This = EmitLValue(E->getArg(0)).getAddress();
435
436  llvm::Value *Callee;
437  if (MD->isVirtual() && !canDevirtualizeMemberFunctionCalls(E->getArg(0)))
438    Callee = BuildVirtualCall(MD, This, Ty);
439  else
440    Callee = CGM.GetAddrOfFunction(MD, Ty);
441
442  return EmitCXXMemberCall(MD, Callee, This,
443                           E->arg_begin() + 1, E->arg_end());
444}
445
446llvm::Value *CodeGenFunction::LoadCXXThis() {
447  assert(isa<CXXMethodDecl>(CurFuncDecl) &&
448         "Must be in a C++ member function decl to load 'this'");
449  assert(cast<CXXMethodDecl>(CurFuncDecl)->isInstance() &&
450         "Must be in a C++ member function decl to load 'this'");
451
452  // FIXME: What if we're inside a block?
453  // ans: See how CodeGenFunction::LoadObjCSelf() uses
454  // CodeGenFunction::BlockForwardSelf() for how to do this.
455  return Builder.CreateLoad(LocalDeclMap[CXXThisDecl], "this");
456}
457
458/// EmitCXXAggrConstructorCall - This routine essentially creates a (nested)
459/// for-loop to call the default constructor on individual members of the
460/// array.
461/// 'D' is the default constructor for elements of the array, 'ArrayTy' is the
462/// array type and 'ArrayPtr' points to the beginning fo the array.
463/// It is assumed that all relevant checks have been made by the caller.
464void
465CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
466                                          const ConstantArrayType *ArrayTy,
467                                          llvm::Value *ArrayPtr,
468                                          CallExpr::const_arg_iterator ArgBeg,
469                                          CallExpr::const_arg_iterator ArgEnd) {
470
471  const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
472  llvm::Value * NumElements =
473    llvm::ConstantInt::get(SizeTy,
474                           getContext().getConstantArrayElementCount(ArrayTy));
475
476  EmitCXXAggrConstructorCall(D, NumElements, ArrayPtr, ArgBeg, ArgEnd);
477}
478
479void
480CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
481                                          llvm::Value *NumElements,
482                                          llvm::Value *ArrayPtr,
483                                          CallExpr::const_arg_iterator ArgBeg,
484                                          CallExpr::const_arg_iterator ArgEnd) {
485  const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
486
487  // Create a temporary for the loop index and initialize it with 0.
488  llvm::Value *IndexPtr = CreateTempAlloca(SizeTy, "loop.index");
489  llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
490  Builder.CreateStore(Zero, IndexPtr, false);
491
492  // Start the loop with a block that tests the condition.
493  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
494  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
495
496  EmitBlock(CondBlock);
497
498  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
499
500  // Generate: if (loop-index < number-of-elements fall to the loop body,
501  // otherwise, go to the block after the for-loop.
502  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
503  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElements, "isless");
504  // If the condition is true, execute the body.
505  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
506
507  EmitBlock(ForBody);
508
509  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
510  // Inside the loop body, emit the constructor call on the array element.
511  Counter = Builder.CreateLoad(IndexPtr);
512  llvm::Value *Address = Builder.CreateInBoundsGEP(ArrayPtr, Counter,
513                                                   "arrayidx");
514
515  // C++ [class.temporary]p4:
516  // There are two contexts in which temporaries are destroyed at a different
517  // point than the end of the full- expression. The first context is when a
518  // default constructor is called to initialize an element of an array.
519  // If the constructor has one or more default arguments, the destruction of
520  // every temporary created in a default argument expression is sequenced
521  // before the construction of the next array element, if any.
522
523  // Keep track of the current number of live temporaries.
524  unsigned OldNumLiveTemporaries = LiveTemporaries.size();
525
526  EmitCXXConstructorCall(D, Ctor_Complete, Address, ArgBeg, ArgEnd);
527
528  // Pop temporaries.
529  while (LiveTemporaries.size() > OldNumLiveTemporaries)
530    PopCXXTemporary();
531
532  EmitBlock(ContinueBlock);
533
534  // Emit the increment of the loop counter.
535  llvm::Value *NextVal = llvm::ConstantInt::get(SizeTy, 1);
536  Counter = Builder.CreateLoad(IndexPtr);
537  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
538  Builder.CreateStore(NextVal, IndexPtr, false);
539
540  // Finally, branch back up to the condition for the next iteration.
541  EmitBranch(CondBlock);
542
543  // Emit the fall-through block.
544  EmitBlock(AfterFor, true);
545}
546
547/// EmitCXXAggrDestructorCall - calls the default destructor on array
548/// elements in reverse order of construction.
549void
550CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
551                                           const ArrayType *Array,
552                                           llvm::Value *This) {
553  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
554  assert(CA && "Do we support VLA for destruction ?");
555  uint64_t ElementCount = getContext().getConstantArrayElementCount(CA);
556  llvm::Value* ElementCountPtr =
557    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), ElementCount);
558  EmitCXXAggrDestructorCall(D, ElementCountPtr, This);
559}
560
561/// EmitCXXAggrDestructorCall - calls the default destructor on array
562/// elements in reverse order of construction.
563void
564CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
565                                           llvm::Value *UpperCount,
566                                           llvm::Value *This) {
567  llvm::Value *One = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
568                                            1);
569  // Create a temporary for the loop index and initialize it with count of
570  // array elements.
571  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
572                                           "loop.index");
573  // Index = ElementCount;
574  Builder.CreateStore(UpperCount, IndexPtr, false);
575
576  // Start the loop with a block that tests the condition.
577  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
578  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
579
580  EmitBlock(CondBlock);
581
582  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
583
584  // Generate: if (loop-index != 0 fall to the loop body,
585  // otherwise, go to the block after the for-loop.
586  llvm::Value* zeroConstant =
587    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
588  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
589  llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant,
590                                            "isne");
591  // If the condition is true, execute the body.
592  Builder.CreateCondBr(IsNE, ForBody, AfterFor);
593
594  EmitBlock(ForBody);
595
596  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
597  // Inside the loop body, emit the constructor call on the array element.
598  Counter = Builder.CreateLoad(IndexPtr);
599  Counter = Builder.CreateSub(Counter, One);
600  llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
601  if (D->isVirtual()) {
602    const llvm::Type *Ty =
603      CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(D),
604                                     /*isVariadic=*/false);
605
606    llvm::Value *Callee = BuildVirtualCall(D, Dtor_Deleting, Address, Ty);
607    EmitCXXMemberCall(D, Callee, Address, 0, 0);
608  }
609  else
610    EmitCXXDestructorCall(D, Dtor_Complete, Address);
611
612  EmitBlock(ContinueBlock);
613
614  // Emit the decrement of the loop counter.
615  Counter = Builder.CreateLoad(IndexPtr);
616  Counter = Builder.CreateSub(Counter, One, "dec");
617  Builder.CreateStore(Counter, IndexPtr, false);
618
619  // Finally, branch back up to the condition for the next iteration.
620  EmitBranch(CondBlock);
621
622  // Emit the fall-through block.
623  EmitBlock(AfterFor, true);
624}
625
626/// GenerateCXXAggrDestructorHelper - Generates a helper function which when
627/// invoked, calls the default destructor on array elements in reverse order of
628/// construction.
629llvm::Constant *
630CodeGenFunction::GenerateCXXAggrDestructorHelper(const CXXDestructorDecl *D,
631                                                 const ArrayType *Array,
632                                                 llvm::Value *This) {
633  static int UniqueCount;
634  FunctionArgList Args;
635  ImplicitParamDecl *Dst =
636    ImplicitParamDecl::Create(getContext(), 0,
637                              SourceLocation(), 0,
638                              getContext().getPointerType(getContext().VoidTy));
639  Args.push_back(std::make_pair(Dst, Dst->getType()));
640
641  llvm::SmallString<16> Name;
642  llvm::raw_svector_ostream(Name) << "__tcf_" << (++UniqueCount);
643  QualType R = getContext().VoidTy;
644  const CGFunctionInfo &FI = CGM.getTypes().getFunctionInfo(R, Args);
645  const llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI, false);
646  llvm::Function *Fn =
647    llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
648                           Name.c_str(),
649                           &CGM.getModule());
650  IdentifierInfo *II
651    = &CGM.getContext().Idents.get(Name.c_str());
652  FunctionDecl *FD = FunctionDecl::Create(getContext(),
653                                          getContext().getTranslationUnitDecl(),
654                                          SourceLocation(), II, R, 0,
655                                          FunctionDecl::Static,
656                                          false, true);
657  StartFunction(FD, R, Fn, Args, SourceLocation());
658  QualType BaseElementTy = getContext().getBaseElementType(Array);
659  const llvm::Type *BasePtr = ConvertType(BaseElementTy);
660  BasePtr = llvm::PointerType::getUnqual(BasePtr);
661  llvm::Value *BaseAddrPtr = Builder.CreateBitCast(This, BasePtr);
662  EmitCXXAggrDestructorCall(D, Array, BaseAddrPtr);
663  FinishFunction();
664  llvm::Type *Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),
665                                              0);
666  llvm::Constant *m = llvm::ConstantExpr::getBitCast(Fn, Ptr8Ty);
667  return m;
668}
669
670void
671CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
672                                        CXXCtorType Type,
673                                        llvm::Value *This,
674                                        CallExpr::const_arg_iterator ArgBeg,
675                                        CallExpr::const_arg_iterator ArgEnd) {
676  if (D->isCopyConstructor(getContext())) {
677    const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(D->getDeclContext());
678    if (ClassDecl->hasTrivialCopyConstructor()) {
679      assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
680             "EmitCXXConstructorCall - user declared copy constructor");
681      const Expr *E = (*ArgBeg);
682      QualType Ty = E->getType();
683      llvm::Value *Src = EmitLValue(E).getAddress();
684      EmitAggregateCopy(This, Src, Ty);
685      return;
686    }
687  }
688
689  llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
690
691  EmitCXXMemberCall(D, Callee, This, ArgBeg, ArgEnd);
692}
693
694void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *D,
695                                            CXXDtorType Type,
696                                            llvm::Value *This) {
697  llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(D, Type);
698
699  EmitCXXMemberCall(D, Callee, This, 0, 0);
700}
701
702void
703CodeGenFunction::EmitCXXConstructExpr(llvm::Value *Dest,
704                                      const CXXConstructExpr *E) {
705  assert(Dest && "Must have a destination!");
706  const CXXConstructorDecl *CD = E->getConstructor();
707  const ConstantArrayType *Array =
708    getContext().getAsConstantArrayType(E->getType());
709  // For a copy constructor, even if it is trivial, must fall thru so
710  // its argument is code-gen'ed.
711  if (!CD->isCopyConstructor(getContext())) {
712    QualType InitType = E->getType();
713    if (Array)
714      InitType = getContext().getBaseElementType(Array);
715    const CXXRecordDecl *RD =
716      cast<CXXRecordDecl>(InitType->getAs<RecordType>()->getDecl());
717    if (RD->hasTrivialConstructor())
718    return;
719  }
720  // Code gen optimization to eliminate copy constructor and return
721  // its first argument instead.
722  if (getContext().getLangOptions().ElideConstructors && E->isElidable()) {
723    const Expr *Arg = E->getArg(0);
724
725    if (const CXXBindTemporaryExpr *BindExpr =
726          dyn_cast<CXXBindTemporaryExpr>(Arg))
727      Arg = BindExpr->getSubExpr();
728
729    EmitAggExpr(Arg, Dest, false);
730    return;
731  }
732  if (Array) {
733    QualType BaseElementTy = getContext().getBaseElementType(Array);
734    const llvm::Type *BasePtr = ConvertType(BaseElementTy);
735    BasePtr = llvm::PointerType::getUnqual(BasePtr);
736    llvm::Value *BaseAddrPtr =
737      Builder.CreateBitCast(Dest, BasePtr);
738    EmitCXXAggrConstructorCall(CD, Array, BaseAddrPtr,
739                               E->arg_begin(), E->arg_end());
740  }
741  else
742    // Call the constructor.
743    EmitCXXConstructorCall(CD, Ctor_Complete, Dest,
744                           E->arg_begin(), E->arg_end());
745}
746
747void CodeGenModule::EmitCXXConstructors(const CXXConstructorDecl *D) {
748  EmitGlobal(GlobalDecl(D, Ctor_Complete));
749  EmitGlobal(GlobalDecl(D, Ctor_Base));
750}
751
752void CodeGenModule::EmitCXXConstructor(const CXXConstructorDecl *D,
753                                       CXXCtorType Type) {
754
755  llvm::Function *Fn = GetAddrOfCXXConstructor(D, Type);
756
757  CodeGenFunction(*this).GenerateCode(GlobalDecl(D, Type), Fn);
758
759  SetFunctionDefinitionAttributes(D, Fn);
760  SetLLVMFunctionAttributesForDefinition(D, Fn);
761}
762
763llvm::Function *
764CodeGenModule::GetAddrOfCXXConstructor(const CXXConstructorDecl *D,
765                                       CXXCtorType Type) {
766  const FunctionProtoType *FPT = D->getType()->getAs<FunctionProtoType>();
767  const llvm::FunctionType *FTy =
768    getTypes().GetFunctionType(getTypes().getFunctionInfo(D),
769                               FPT->isVariadic());
770
771  const char *Name = getMangledCXXCtorName(D, Type);
772  return cast<llvm::Function>(
773                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
774}
775
776const char *CodeGenModule::getMangledCXXCtorName(const CXXConstructorDecl *D,
777                                                 CXXCtorType Type) {
778  llvm::SmallString<256> Name;
779  getMangleContext().mangleCXXCtor(D, Type, Name);
780
781  Name += '\0';
782  return UniqueMangledName(Name.begin(), Name.end());
783}
784
785void CodeGenModule::EmitCXXDestructors(const CXXDestructorDecl *D) {
786  if (D->isVirtual())
787    EmitCXXDestructor(D, Dtor_Deleting);
788  EmitCXXDestructor(D, Dtor_Complete);
789  EmitCXXDestructor(D, Dtor_Base);
790}
791
792void CodeGenModule::EmitCXXDestructor(const CXXDestructorDecl *D,
793                                      CXXDtorType Type) {
794  llvm::Function *Fn = GetAddrOfCXXDestructor(D, Type);
795
796  CodeGenFunction(*this).GenerateCode(GlobalDecl(D, Type), Fn);
797
798  SetFunctionDefinitionAttributes(D, Fn);
799  SetLLVMFunctionAttributesForDefinition(D, Fn);
800}
801
802llvm::Function *
803CodeGenModule::GetAddrOfCXXDestructor(const CXXDestructorDecl *D,
804                                      CXXDtorType Type) {
805  const llvm::FunctionType *FTy =
806    getTypes().GetFunctionType(getTypes().getFunctionInfo(D), false);
807
808  const char *Name = getMangledCXXDtorName(D, Type);
809  return cast<llvm::Function>(
810                      GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(D, Type)));
811}
812
813const char *CodeGenModule::getMangledCXXDtorName(const CXXDestructorDecl *D,
814                                                 CXXDtorType Type) {
815  llvm::SmallString<256> Name;
816  getMangleContext().mangleCXXDtor(D, Type, Name);
817
818  Name += '\0';
819  return UniqueMangledName(Name.begin(), Name.end());
820}
821
822llvm::Constant *CodeGenFunction::GenerateThunk(llvm::Function *Fn,
823                                               const CXXMethodDecl *MD,
824                                               bool Extern, int64_t nv,
825                                               int64_t v) {
826  return GenerateCovariantThunk(Fn, MD, Extern, nv, v, 0, 0);
827}
828
829llvm::Value *CodeGenFunction::DynamicTypeAdjust(llvm::Value *V, int64_t nv,
830                                                int64_t v) {
831  llvm::Type *Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),
832                                              0);
833  const llvm::Type *OrigTy = V->getType();
834  if (nv) {
835    // Do the non-virtual adjustment
836    V = Builder.CreateBitCast(V, Ptr8Ty);
837    V = Builder.CreateConstInBoundsGEP1_64(V, nv);
838    V = Builder.CreateBitCast(V, OrigTy);
839  }
840  if (v) {
841    // Do the virtual this adjustment
842    const llvm::Type *PtrDiffTy =
843      ConvertType(getContext().getPointerDiffType());
844    llvm::Type *PtrPtr8Ty, *PtrPtrDiffTy;
845    PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0);
846    PtrPtrDiffTy = llvm::PointerType::get(PtrDiffTy, 0);
847    llvm::Value *ThisVal = Builder.CreateBitCast(V, Ptr8Ty);
848    V = Builder.CreateBitCast(V, PtrPtrDiffTy->getPointerTo());
849    V = Builder.CreateLoad(V, "vtable");
850    llvm::Value *VTablePtr = V;
851    assert(v % (LLVMPointerWidth/8) == 0 && "vtable entry unaligned");
852    v /= LLVMPointerWidth/8;
853    V = Builder.CreateConstInBoundsGEP1_64(VTablePtr, v);
854    V = Builder.CreateLoad(V);
855    V = Builder.CreateGEP(ThisVal, V);
856    V = Builder.CreateBitCast(V, OrigTy);
857  }
858  return V;
859}
860
861llvm::Constant *CodeGenFunction::GenerateCovariantThunk(llvm::Function *Fn,
862                                                        const CXXMethodDecl *MD,
863                                                        bool Extern,
864                                                        int64_t nv_t,
865                                                        int64_t v_t,
866                                                        int64_t nv_r,
867                                                        int64_t v_r) {
868  QualType ResultType = MD->getType()->getAs<FunctionType>()->getResultType();
869
870  FunctionArgList Args;
871  ImplicitParamDecl *ThisDecl =
872    ImplicitParamDecl::Create(getContext(), 0, SourceLocation(), 0,
873                              MD->getThisType(getContext()));
874  Args.push_back(std::make_pair(ThisDecl, ThisDecl->getType()));
875  for (FunctionDecl::param_const_iterator i = MD->param_begin(),
876         e = MD->param_end();
877       i != e; ++i) {
878    ParmVarDecl *D = *i;
879    Args.push_back(std::make_pair(D, D->getType()));
880  }
881  IdentifierInfo *II
882    = &CGM.getContext().Idents.get("__thunk_named_foo_");
883  FunctionDecl *FD = FunctionDecl::Create(getContext(),
884                                          getContext().getTranslationUnitDecl(),
885                                          SourceLocation(), II, ResultType, 0,
886                                          Extern
887                                            ? FunctionDecl::Extern
888                                            : FunctionDecl::Static,
889                                          false, true);
890  StartFunction(FD, ResultType, Fn, Args, SourceLocation());
891
892  // generate body
893  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
894  const llvm::Type *Ty =
895    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
896                                   FPT->isVariadic());
897  llvm::Value *Callee = CGM.GetAddrOfFunction(MD, Ty);
898  CallArgList CallArgs;
899
900  QualType ArgType = MD->getThisType(getContext());
901  llvm::Value *Arg = Builder.CreateLoad(LocalDeclMap[ThisDecl], "this");
902  if (nv_t || v_t) {
903    // Do the this adjustment.
904    const llvm::Type *OrigTy = Callee->getType();
905    Arg = DynamicTypeAdjust(Arg, nv_t, v_t);
906    if (nv_r || v_r) {
907      Callee = CGM.BuildCovariantThunk(MD, Extern, 0, 0, nv_r, v_r);
908      Callee = Builder.CreateBitCast(Callee, OrigTy);
909      nv_r = v_r = 0;
910    }
911  }
912
913  CallArgs.push_back(std::make_pair(RValue::get(Arg), ArgType));
914
915  for (FunctionDecl::param_const_iterator i = MD->param_begin(),
916         e = MD->param_end();
917       i != e; ++i) {
918    ParmVarDecl *D = *i;
919    QualType ArgType = D->getType();
920
921    // llvm::Value *Arg = CGF.GetAddrOfLocalVar(Dst);
922    Expr *Arg = new (getContext()) DeclRefExpr(D, ArgType, SourceLocation());
923    CallArgs.push_back(std::make_pair(EmitCallArg(Arg, ArgType), ArgType));
924  }
925
926  RValue RV = EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
927                       Callee, CallArgs, MD);
928  if (nv_r || v_r) {
929    bool CanBeZero = !(ResultType->isReferenceType()
930    // FIXME: attr nonnull can't be zero either
931                       /* || ResultType->hasAttr<NonNullAttr>() */ );
932    // Do the return result adjustment.
933    if (CanBeZero) {
934      llvm::BasicBlock *NonZeroBlock = createBasicBlock();
935      llvm::BasicBlock *ZeroBlock = createBasicBlock();
936      llvm::BasicBlock *ContBlock = createBasicBlock();
937
938      const llvm::Type *Ty = RV.getScalarVal()->getType();
939      llvm::Value *Zero = llvm::Constant::getNullValue(Ty);
940      Builder.CreateCondBr(Builder.CreateICmpNE(RV.getScalarVal(), Zero),
941                           NonZeroBlock, ZeroBlock);
942      EmitBlock(NonZeroBlock);
943      llvm::Value *NZ = DynamicTypeAdjust(RV.getScalarVal(), nv_r, v_r);
944      EmitBranch(ContBlock);
945      EmitBlock(ZeroBlock);
946      llvm::Value *Z = RV.getScalarVal();
947      EmitBlock(ContBlock);
948      llvm::PHINode *RVOrZero = Builder.CreatePHI(Ty);
949      RVOrZero->reserveOperandSpace(2);
950      RVOrZero->addIncoming(NZ, NonZeroBlock);
951      RVOrZero->addIncoming(Z, ZeroBlock);
952      RV = RValue::get(RVOrZero);
953    } else
954      RV = RValue::get(DynamicTypeAdjust(RV.getScalarVal(), nv_r, v_r));
955  }
956
957  if (!ResultType->isVoidType())
958    EmitReturnOfRValue(RV, ResultType);
959
960  FinishFunction();
961  return Fn;
962}
963
964llvm::Constant *CodeGenModule::BuildThunk(const CXXMethodDecl *MD, bool Extern,
965                                          int64_t nv, int64_t v) {
966  llvm::SmallString<256> OutName;
967  getMangleContext().mangleThunk(MD, nv, v, OutName);
968  llvm::GlobalVariable::LinkageTypes linktype;
969  linktype = llvm::GlobalValue::WeakAnyLinkage;
970  if (!Extern)
971    linktype = llvm::GlobalValue::InternalLinkage;
972  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
973  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
974  const llvm::FunctionType *FTy =
975    getTypes().GetFunctionType(getTypes().getFunctionInfo(MD),
976                               FPT->isVariadic());
977
978  llvm::Function *Fn = llvm::Function::Create(FTy, linktype, OutName.str(),
979                                              &getModule());
980  CodeGenFunction(*this).GenerateThunk(Fn, MD, Extern, nv, v);
981  llvm::Constant *m = llvm::ConstantExpr::getBitCast(Fn, Ptr8Ty);
982  return m;
983}
984
985llvm::Constant *CodeGenModule::BuildCovariantThunk(const CXXMethodDecl *MD,
986                                                   bool Extern, int64_t nv_t,
987                                                   int64_t v_t, int64_t nv_r,
988                                                   int64_t v_r) {
989  llvm::SmallString<256> OutName;
990  getMangleContext().mangleCovariantThunk(MD, nv_t, v_t, nv_r, v_r, OutName);
991  llvm::GlobalVariable::LinkageTypes linktype;
992  linktype = llvm::GlobalValue::WeakAnyLinkage;
993  if (!Extern)
994    linktype = llvm::GlobalValue::InternalLinkage;
995  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
996  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
997  const llvm::FunctionType *FTy =
998    getTypes().GetFunctionType(getTypes().getFunctionInfo(MD),
999                               FPT->isVariadic());
1000
1001  llvm::Function *Fn = llvm::Function::Create(FTy, linktype, OutName.str(),
1002                                              &getModule());
1003  CodeGenFunction(*this).GenerateCovariantThunk(Fn, MD, Extern, nv_t, v_t, nv_r,
1004                                               v_r);
1005  llvm::Constant *m = llvm::ConstantExpr::getBitCast(Fn, Ptr8Ty);
1006  return m;
1007}
1008
1009llvm::Value *
1010CodeGenFunction::GetVirtualCXXBaseClassOffset(llvm::Value *This,
1011                                              const CXXRecordDecl *ClassDecl,
1012                                           const CXXRecordDecl *BaseClassDecl) {
1013  const llvm::Type *Int8PtrTy =
1014    llvm::Type::getInt8Ty(VMContext)->getPointerTo();
1015
1016  llvm::Value *VTablePtr = Builder.CreateBitCast(This,
1017                                                 Int8PtrTy->getPointerTo());
1018  VTablePtr = Builder.CreateLoad(VTablePtr, "vtable");
1019
1020  int64_t VBaseOffsetIndex =
1021    CGM.getVtableInfo().getVirtualBaseOffsetIndex(ClassDecl, BaseClassDecl);
1022
1023  llvm::Value *VBaseOffsetPtr =
1024    Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetIndex, "vbase.offset.ptr");
1025  const llvm::Type *PtrDiffTy =
1026    ConvertType(getContext().getPointerDiffType());
1027
1028  VBaseOffsetPtr = Builder.CreateBitCast(VBaseOffsetPtr,
1029                                         PtrDiffTy->getPointerTo());
1030
1031  llvm::Value *VBaseOffset = Builder.CreateLoad(VBaseOffsetPtr, "vbase.offset");
1032
1033  return VBaseOffset;
1034}
1035
1036static llvm::Value *BuildVirtualCall(CodeGenFunction &CGF, int64_t VtableIndex,
1037                                     llvm::Value *This, const llvm::Type *Ty) {
1038  Ty = Ty->getPointerTo()->getPointerTo()->getPointerTo();
1039
1040  llvm::Value *Vtable = CGF.Builder.CreateBitCast(This, Ty);
1041  Vtable = CGF.Builder.CreateLoad(Vtable);
1042
1043  llvm::Value *VFuncPtr =
1044    CGF.Builder.CreateConstInBoundsGEP1_64(Vtable, VtableIndex, "vfn");
1045  return CGF.Builder.CreateLoad(VFuncPtr);
1046}
1047
1048llvm::Value *
1049CodeGenFunction::BuildVirtualCall(const CXXMethodDecl *MD, llvm::Value *This,
1050                                  const llvm::Type *Ty) {
1051  MD = MD->getCanonicalDecl();
1052  int64_t VtableIndex = CGM.getVtableInfo().getMethodVtableIndex(MD);
1053
1054  return ::BuildVirtualCall(*this, VtableIndex, This, Ty);
1055}
1056
1057llvm::Value *
1058CodeGenFunction::BuildVirtualCall(const CXXDestructorDecl *DD, CXXDtorType Type,
1059                                  llvm::Value *&This, const llvm::Type *Ty) {
1060  DD = cast<CXXDestructorDecl>(DD->getCanonicalDecl());
1061  int64_t VtableIndex =
1062    CGM.getVtableInfo().getMethodVtableIndex(GlobalDecl(DD, Type));
1063
1064  return ::BuildVirtualCall(*this, VtableIndex, This, Ty);
1065}
1066
1067/// EmitClassAggrMemberwiseCopy - This routine generates code to copy a class
1068/// array of objects from SrcValue to DestValue. Copying can be either a bitwise
1069/// copy or via a copy constructor call.
1070//  FIXME. Consolidate this with EmitCXXAggrConstructorCall.
1071void CodeGenFunction::EmitClassAggrMemberwiseCopy(llvm::Value *Dest,
1072                                            llvm::Value *Src,
1073                                            const ArrayType *Array,
1074                                            const CXXRecordDecl *BaseClassDecl,
1075                                            QualType Ty) {
1076  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
1077  assert(CA && "VLA cannot be copied over");
1078  bool BitwiseCopy = BaseClassDecl->hasTrivialCopyConstructor();
1079
1080  // Create a temporary for the loop index and initialize it with 0.
1081  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
1082                                           "loop.index");
1083  llvm::Value* zeroConstant =
1084    llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
1085  Builder.CreateStore(zeroConstant, IndexPtr, false);
1086  // Start the loop with a block that tests the condition.
1087  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
1088  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
1089
1090  EmitBlock(CondBlock);
1091
1092  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
1093  // Generate: if (loop-index < number-of-elements fall to the loop body,
1094  // otherwise, go to the block after the for-loop.
1095  uint64_t NumElements = getContext().getConstantArrayElementCount(CA);
1096  llvm::Value * NumElementsPtr =
1097    llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements);
1098  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1099  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
1100                                              "isless");
1101  // If the condition is true, execute the body.
1102  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
1103
1104  EmitBlock(ForBody);
1105  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1106  // Inside the loop body, emit the constructor call on the array element.
1107  Counter = Builder.CreateLoad(IndexPtr);
1108  Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress");
1109  Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress");
1110  if (BitwiseCopy)
1111    EmitAggregateCopy(Dest, Src, Ty);
1112  else if (CXXConstructorDecl *BaseCopyCtor =
1113           BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1114    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1115                                                      Ctor_Complete);
1116    CallArgList CallArgs;
1117    // Push the this (Dest) ptr.
1118    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1119                                      BaseCopyCtor->getThisType(getContext())));
1120
1121    // Push the Src ptr.
1122    CallArgs.push_back(std::make_pair(RValue::get(Src),
1123                                     BaseCopyCtor->getParamDecl(0)->getType()));
1124    QualType ResultType =
1125      BaseCopyCtor->getType()->getAs<FunctionType>()->getResultType();
1126    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1127             Callee, CallArgs, BaseCopyCtor);
1128  }
1129  EmitBlock(ContinueBlock);
1130
1131  // Emit the increment of the loop counter.
1132  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
1133  Counter = Builder.CreateLoad(IndexPtr);
1134  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
1135  Builder.CreateStore(NextVal, IndexPtr, false);
1136
1137  // Finally, branch back up to the condition for the next iteration.
1138  EmitBranch(CondBlock);
1139
1140  // Emit the fall-through block.
1141  EmitBlock(AfterFor, true);
1142}
1143
1144/// EmitClassAggrCopyAssignment - This routine generates code to assign a class
1145/// array of objects from SrcValue to DestValue. Assignment can be either a
1146/// bitwise assignment or via a copy assignment operator function call.
1147/// FIXME. This can be consolidated with EmitClassAggrMemberwiseCopy
1148void CodeGenFunction::EmitClassAggrCopyAssignment(llvm::Value *Dest,
1149                                            llvm::Value *Src,
1150                                            const ArrayType *Array,
1151                                            const CXXRecordDecl *BaseClassDecl,
1152                                            QualType Ty) {
1153  const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
1154  assert(CA && "VLA cannot be asssigned");
1155  bool BitwiseAssign = BaseClassDecl->hasTrivialCopyAssignment();
1156
1157  // Create a temporary for the loop index and initialize it with 0.
1158  llvm::Value *IndexPtr = CreateTempAlloca(llvm::Type::getInt64Ty(VMContext),
1159                                           "loop.index");
1160  llvm::Value* zeroConstant =
1161  llvm::Constant::getNullValue(llvm::Type::getInt64Ty(VMContext));
1162  Builder.CreateStore(zeroConstant, IndexPtr, false);
1163  // Start the loop with a block that tests the condition.
1164  llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
1165  llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
1166
1167  EmitBlock(CondBlock);
1168
1169  llvm::BasicBlock *ForBody = createBasicBlock("for.body");
1170  // Generate: if (loop-index < number-of-elements fall to the loop body,
1171  // otherwise, go to the block after the for-loop.
1172  uint64_t NumElements = getContext().getConstantArrayElementCount(CA);
1173  llvm::Value * NumElementsPtr =
1174  llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), NumElements);
1175  llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1176  llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElementsPtr,
1177                                              "isless");
1178  // If the condition is true, execute the body.
1179  Builder.CreateCondBr(IsLess, ForBody, AfterFor);
1180
1181  EmitBlock(ForBody);
1182  llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1183  // Inside the loop body, emit the assignment operator call on array element.
1184  Counter = Builder.CreateLoad(IndexPtr);
1185  Src = Builder.CreateInBoundsGEP(Src, Counter, "srcaddress");
1186  Dest = Builder.CreateInBoundsGEP(Dest, Counter, "destaddress");
1187  const CXXMethodDecl *MD = 0;
1188  if (BitwiseAssign)
1189    EmitAggregateCopy(Dest, Src, Ty);
1190  else {
1191    bool hasCopyAssign = BaseClassDecl->hasConstCopyAssignment(getContext(),
1192                                                               MD);
1193    assert(hasCopyAssign && "EmitClassAggrCopyAssignment - No user assign");
1194    (void)hasCopyAssign;
1195    const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1196    const llvm::Type *LTy =
1197    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1198                                   FPT->isVariadic());
1199    llvm::Constant *Callee = CGM.GetAddrOfFunction(MD, LTy);
1200
1201    CallArgList CallArgs;
1202    // Push the this (Dest) ptr.
1203    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1204                                      MD->getThisType(getContext())));
1205
1206    // Push the Src ptr.
1207    CallArgs.push_back(std::make_pair(RValue::get(Src),
1208                                      MD->getParamDecl(0)->getType()));
1209    QualType ResultType = MD->getType()->getAs<FunctionType>()->getResultType();
1210    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1211             Callee, CallArgs, MD);
1212  }
1213  EmitBlock(ContinueBlock);
1214
1215  // Emit the increment of the loop counter.
1216  llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
1217  Counter = Builder.CreateLoad(IndexPtr);
1218  NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
1219  Builder.CreateStore(NextVal, IndexPtr, false);
1220
1221  // Finally, branch back up to the condition for the next iteration.
1222  EmitBranch(CondBlock);
1223
1224  // Emit the fall-through block.
1225  EmitBlock(AfterFor, true);
1226}
1227
1228/// EmitClassMemberwiseCopy - This routine generates code to copy a class
1229/// object from SrcValue to DestValue. Copying can be either a bitwise copy
1230/// or via a copy constructor call.
1231void CodeGenFunction::EmitClassMemberwiseCopy(
1232                        llvm::Value *Dest, llvm::Value *Src,
1233                        const CXXRecordDecl *ClassDecl,
1234                        const CXXRecordDecl *BaseClassDecl, QualType Ty) {
1235  if (ClassDecl) {
1236    Dest = GetAddressOfBaseClass(Dest, ClassDecl, BaseClassDecl,
1237                                 /*NullCheckValue=*/false);
1238    Src = GetAddressOfBaseClass(Src, ClassDecl, BaseClassDecl,
1239                                /*NullCheckValue=*/false);
1240  }
1241  if (BaseClassDecl->hasTrivialCopyConstructor()) {
1242    EmitAggregateCopy(Dest, Src, Ty);
1243    return;
1244  }
1245
1246  if (CXXConstructorDecl *BaseCopyCtor =
1247      BaseClassDecl->getCopyConstructor(getContext(), 0)) {
1248    llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(BaseCopyCtor,
1249                                                      Ctor_Complete);
1250    CallArgList CallArgs;
1251    // Push the this (Dest) ptr.
1252    CallArgs.push_back(std::make_pair(RValue::get(Dest),
1253                                      BaseCopyCtor->getThisType(getContext())));
1254
1255    // Push the Src ptr.
1256    CallArgs.push_back(std::make_pair(RValue::get(Src),
1257                       BaseCopyCtor->getParamDecl(0)->getType()));
1258    QualType ResultType =
1259    BaseCopyCtor->getType()->getAs<FunctionType>()->getResultType();
1260    EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1261             Callee, CallArgs, BaseCopyCtor);
1262  }
1263}
1264
1265/// EmitClassCopyAssignment - This routine generates code to copy assign a class
1266/// object from SrcValue to DestValue. Assignment can be either a bitwise
1267/// assignment of via an assignment operator call.
1268// FIXME. Consolidate this with EmitClassMemberwiseCopy as they share a lot.
1269void CodeGenFunction::EmitClassCopyAssignment(
1270                                        llvm::Value *Dest, llvm::Value *Src,
1271                                        const CXXRecordDecl *ClassDecl,
1272                                        const CXXRecordDecl *BaseClassDecl,
1273                                        QualType Ty) {
1274  if (ClassDecl) {
1275    Dest = GetAddressOfBaseClass(Dest, ClassDecl, BaseClassDecl,
1276                                 /*NullCheckValue=*/false);
1277    Src = GetAddressOfBaseClass(Src, ClassDecl, BaseClassDecl,
1278                                /*NullCheckValue=*/false);
1279  }
1280  if (BaseClassDecl->hasTrivialCopyAssignment()) {
1281    EmitAggregateCopy(Dest, Src, Ty);
1282    return;
1283  }
1284
1285  const CXXMethodDecl *MD = 0;
1286  bool ConstCopyAssignOp = BaseClassDecl->hasConstCopyAssignment(getContext(),
1287                                                                 MD);
1288  assert(ConstCopyAssignOp && "EmitClassCopyAssignment - missing copy assign");
1289  (void)ConstCopyAssignOp;
1290
1291  const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
1292  const llvm::Type *LTy =
1293    CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
1294                                   FPT->isVariadic());
1295  llvm::Constant *Callee = CGM.GetAddrOfFunction(MD, LTy);
1296
1297  CallArgList CallArgs;
1298  // Push the this (Dest) ptr.
1299  CallArgs.push_back(std::make_pair(RValue::get(Dest),
1300                                    MD->getThisType(getContext())));
1301
1302  // Push the Src ptr.
1303  CallArgs.push_back(std::make_pair(RValue::get(Src),
1304                                    MD->getParamDecl(0)->getType()));
1305  QualType ResultType =
1306    MD->getType()->getAs<FunctionType>()->getResultType();
1307  EmitCall(CGM.getTypes().getFunctionInfo(ResultType, CallArgs),
1308           Callee, CallArgs, MD);
1309}
1310
1311/// SynthesizeDefaultConstructor - synthesize a default constructor
1312void
1313CodeGenFunction::SynthesizeDefaultConstructor(const CXXConstructorDecl *Ctor,
1314                                              CXXCtorType Type,
1315                                              llvm::Function *Fn,
1316                                              const FunctionArgList &Args) {
1317  StartFunction(GlobalDecl(Ctor, Type), Ctor->getResultType(), Fn, Args,
1318                SourceLocation());
1319  EmitCtorPrologue(Ctor, Type);
1320  FinishFunction();
1321}
1322
1323/// SynthesizeCXXCopyConstructor - This routine implicitly defines body of a
1324/// copy constructor, in accordance with section 12.8 (p7 and p8) of C++03
1325/// The implicitly-defined copy constructor for class X performs a memberwise
1326/// copy of its subobjects. The order of copying is the same as the order of
1327/// initialization of bases and members in a user-defined constructor
1328/// Each subobject is copied in the manner appropriate to its type:
1329///  if the subobject is of class type, the copy constructor for the class is
1330///  used;
1331///  if the subobject is an array, each element is copied, in the manner
1332///  appropriate to the element type;
1333///  if the subobject is of scalar type, the built-in assignment operator is
1334///  used.
1335/// Virtual base class subobjects shall be copied only once by the
1336/// implicitly-defined copy constructor
1337
1338void
1339CodeGenFunction::SynthesizeCXXCopyConstructor(const CXXConstructorDecl *Ctor,
1340                                              CXXCtorType Type,
1341                                              llvm::Function *Fn,
1342                                              const FunctionArgList &Args) {
1343  const CXXRecordDecl *ClassDecl = Ctor->getParent();
1344  assert(!ClassDecl->hasUserDeclaredCopyConstructor() &&
1345      "SynthesizeCXXCopyConstructor - copy constructor has definition already");
1346  StartFunction(GlobalDecl(Ctor, Type), Ctor->getResultType(), Fn, Args,
1347                SourceLocation());
1348
1349  FunctionArgList::const_iterator i = Args.begin();
1350  const VarDecl *ThisArg = i->first;
1351  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1352  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1353  const VarDecl *SrcArg = (i+1)->first;
1354  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1355  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1356
1357  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1358       Base != ClassDecl->bases_end(); ++Base) {
1359    // FIXME. copy constrution of virtual base NYI
1360    if (Base->isVirtual())
1361      continue;
1362
1363    CXXRecordDecl *BaseClassDecl
1364      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1365    EmitClassMemberwiseCopy(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1366                            Base->getType());
1367  }
1368
1369  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1370       FieldEnd = ClassDecl->field_end();
1371       Field != FieldEnd; ++Field) {
1372    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1373    const ConstantArrayType *Array =
1374      getContext().getAsConstantArrayType(FieldType);
1375    if (Array)
1376      FieldType = getContext().getBaseElementType(FieldType);
1377
1378    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1379      CXXRecordDecl *FieldClassDecl
1380        = cast<CXXRecordDecl>(FieldClassType->getDecl());
1381      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1382      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1383      if (Array) {
1384        const llvm::Type *BasePtr = ConvertType(FieldType);
1385        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1386        llvm::Value *DestBaseAddrPtr =
1387          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1388        llvm::Value *SrcBaseAddrPtr =
1389          Builder.CreateBitCast(RHS.getAddress(), BasePtr);
1390        EmitClassAggrMemberwiseCopy(DestBaseAddrPtr, SrcBaseAddrPtr, Array,
1391                                    FieldClassDecl, FieldType);
1392      }
1393      else
1394        EmitClassMemberwiseCopy(LHS.getAddress(), RHS.getAddress(),
1395                                0 /*ClassDecl*/, FieldClassDecl, FieldType);
1396      continue;
1397    }
1398    // Do a built-in assignment of scalar data members.
1399    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1400    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1401    if (!hasAggregateLLVMType(Field->getType())) {
1402      RValue RVRHS = EmitLoadOfLValue(RHS, Field->getType());
1403      EmitStoreThroughLValue(RVRHS, LHS, Field->getType());
1404    } else if (Field->getType()->isAnyComplexType()) {
1405      ComplexPairTy Pair = LoadComplexFromAddr(RHS.getAddress(),
1406                                               RHS.isVolatileQualified());
1407      StoreComplexToAddr(Pair, LHS.getAddress(), LHS.isVolatileQualified());
1408    } else {
1409      EmitAggregateCopy(LHS.getAddress(), RHS.getAddress(), Field->getType());
1410    }
1411  }
1412  FinishFunction();
1413}
1414
1415/// SynthesizeCXXCopyAssignment - Implicitly define copy assignment operator.
1416/// Before the implicitly-declared copy assignment operator for a class is
1417/// implicitly defined, all implicitly- declared copy assignment operators for
1418/// its direct base classes and its nonstatic data members shall have been
1419/// implicitly defined. [12.8-p12]
1420/// The implicitly-defined copy assignment operator for class X performs
1421/// memberwise assignment of its subob- jects. The direct base classes of X are
1422/// assigned first, in the order of their declaration in
1423/// the base-specifier-list, and then the immediate nonstatic data members of X
1424/// are assigned, in the order in which they were declared in the class
1425/// definition.Each subobject is assigned in the manner appropriate to its type:
1426///   if the subobject is of class type, the copy assignment operator for the
1427///   class is used (as if by explicit qualification; that is, ignoring any
1428///   possible virtual overriding functions in more derived classes);
1429///
1430///   if the subobject is an array, each element is assigned, in the manner
1431///   appropriate to the element type;
1432///
1433///   if the subobject is of scalar type, the built-in assignment operator is
1434///   used.
1435void CodeGenFunction::SynthesizeCXXCopyAssignment(const CXXMethodDecl *CD,
1436                                                  llvm::Function *Fn,
1437                                                  const FunctionArgList &Args) {
1438
1439  const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext());
1440  assert(!ClassDecl->hasUserDeclaredCopyAssignment() &&
1441         "SynthesizeCXXCopyAssignment - copy assignment has user declaration");
1442  StartFunction(CD, CD->getResultType(), Fn, Args, SourceLocation());
1443
1444  FunctionArgList::const_iterator i = Args.begin();
1445  const VarDecl *ThisArg = i->first;
1446  llvm::Value *ThisObj = GetAddrOfLocalVar(ThisArg);
1447  llvm::Value *LoadOfThis = Builder.CreateLoad(ThisObj, "this");
1448  const VarDecl *SrcArg = (i+1)->first;
1449  llvm::Value *SrcObj = GetAddrOfLocalVar(SrcArg);
1450  llvm::Value *LoadOfSrc = Builder.CreateLoad(SrcObj);
1451
1452  for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin();
1453       Base != ClassDecl->bases_end(); ++Base) {
1454    // FIXME. copy assignment of virtual base NYI
1455    if (Base->isVirtual())
1456      continue;
1457
1458    CXXRecordDecl *BaseClassDecl
1459      = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
1460    EmitClassCopyAssignment(LoadOfThis, LoadOfSrc, ClassDecl, BaseClassDecl,
1461                            Base->getType());
1462  }
1463
1464  for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(),
1465       FieldEnd = ClassDecl->field_end();
1466       Field != FieldEnd; ++Field) {
1467    QualType FieldType = getContext().getCanonicalType((*Field)->getType());
1468    const ConstantArrayType *Array =
1469      getContext().getAsConstantArrayType(FieldType);
1470    if (Array)
1471      FieldType = getContext().getBaseElementType(FieldType);
1472
1473    if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) {
1474      CXXRecordDecl *FieldClassDecl
1475      = cast<CXXRecordDecl>(FieldClassType->getDecl());
1476      LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1477      LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1478      if (Array) {
1479        const llvm::Type *BasePtr = ConvertType(FieldType);
1480        BasePtr = llvm::PointerType::getUnqual(BasePtr);
1481        llvm::Value *DestBaseAddrPtr =
1482          Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1483        llvm::Value *SrcBaseAddrPtr =
1484          Builder.CreateBitCast(RHS.getAddress(), BasePtr);
1485        EmitClassAggrCopyAssignment(DestBaseAddrPtr, SrcBaseAddrPtr, Array,
1486                                    FieldClassDecl, FieldType);
1487      }
1488      else
1489        EmitClassCopyAssignment(LHS.getAddress(), RHS.getAddress(),
1490                               0 /*ClassDecl*/, FieldClassDecl, FieldType);
1491      continue;
1492    }
1493    // Do a built-in assignment of scalar data members.
1494    LValue LHS = EmitLValueForField(LoadOfThis, *Field, false, 0);
1495    LValue RHS = EmitLValueForField(LoadOfSrc, *Field, false, 0);
1496    RValue RVRHS = EmitLoadOfLValue(RHS, FieldType);
1497    EmitStoreThroughLValue(RVRHS, LHS, FieldType);
1498  }
1499
1500  // return *this;
1501  Builder.CreateStore(LoadOfThis, ReturnValue);
1502
1503  FinishFunction();
1504}
1505
1506static void EmitBaseInitializer(CodeGenFunction &CGF,
1507                                const CXXRecordDecl *ClassDecl,
1508                                CXXBaseOrMemberInitializer *BaseInit,
1509                                CXXCtorType CtorType) {
1510  assert(BaseInit->isBaseInitializer() &&
1511         "Must have base initializer!");
1512
1513  llvm::Value *ThisPtr = CGF.LoadCXXThis();
1514
1515  const Type *BaseType = BaseInit->getBaseClass();
1516  CXXRecordDecl *BaseClassDecl =
1517    cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
1518  llvm::Value *V = CGF.GetAddressOfBaseClass(ThisPtr, ClassDecl,
1519                                             BaseClassDecl,
1520                                             /*NullCheckValue=*/false);
1521  CGF.EmitCXXConstructorCall(BaseInit->getConstructor(),
1522                             CtorType, V,
1523                             BaseInit->const_arg_begin(),
1524                             BaseInit->const_arg_end());
1525}
1526
1527static void EmitMemberInitializer(CodeGenFunction &CGF,
1528                                  const CXXRecordDecl *ClassDecl,
1529                                  CXXBaseOrMemberInitializer *MemberInit) {
1530  assert(MemberInit->isMemberInitializer() &&
1531         "Must have member initializer!");
1532
1533  // non-static data member initializers.
1534  FieldDecl *Field = MemberInit->getMember();
1535  QualType FieldType = CGF.getContext().getCanonicalType(Field->getType());
1536
1537  llvm::Value *ThisPtr = CGF.LoadCXXThis();
1538  LValue LHS;
1539  if (FieldType->isReferenceType()) {
1540    // FIXME: This is really ugly; should be refactored somehow
1541    unsigned idx = CGF.CGM.getTypes().getLLVMFieldNo(Field);
1542    llvm::Value *V = CGF.Builder.CreateStructGEP(ThisPtr, idx, "tmp");
1543    assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1544    LHS = LValue::MakeAddr(V, CGF.MakeQualifiers(FieldType));
1545  } else {
1546    LHS = CGF.EmitLValueForField(ThisPtr, Field, ClassDecl->isUnion(), 0);
1547  }
1548
1549  // If we are initializing an anonymous union field, drill down to the field.
1550  if (MemberInit->getAnonUnionMember()) {
1551    Field = MemberInit->getAnonUnionMember();
1552    LHS = CGF.EmitLValueForField(LHS.getAddress(), Field,
1553                                 /*IsUnion=*/true, 0);
1554    FieldType = Field->getType();
1555  }
1556
1557  // If the field is an array, branch based on the element type.
1558  const ConstantArrayType *Array =
1559    CGF.getContext().getAsConstantArrayType(FieldType);
1560  if (Array)
1561    FieldType = CGF.getContext().getBaseElementType(FieldType);
1562
1563  // We lose the constructor for anonymous union members, so handle them
1564  // explicitly.
1565  // FIXME: This is somwhat ugly.
1566  if (MemberInit->getAnonUnionMember() && FieldType->getAs<RecordType>()) {
1567    if (MemberInit->getNumArgs())
1568      CGF.EmitAggExpr(*MemberInit->arg_begin(), LHS.getAddress(),
1569                      LHS.isVolatileQualified());
1570    else
1571      CGF.EmitAggregateClear(LHS.getAddress(), Field->getType());
1572    return;
1573  }
1574
1575  if (FieldType->getAs<RecordType>()) {
1576    assert(MemberInit->getConstructor() &&
1577           "EmitCtorPrologue - no constructor to initialize member");
1578    if (Array) {
1579      const llvm::Type *BasePtr = CGF.ConvertType(FieldType);
1580      BasePtr = llvm::PointerType::getUnqual(BasePtr);
1581      llvm::Value *BaseAddrPtr =
1582        CGF.Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1583      CGF.EmitCXXAggrConstructorCall(MemberInit->getConstructor(),
1584                                     Array, BaseAddrPtr,
1585                                     MemberInit->const_arg_begin(),
1586                                     MemberInit->const_arg_end());
1587    }
1588    else
1589      CGF.EmitCXXConstructorCall(MemberInit->getConstructor(),
1590                                 Ctor_Complete, LHS.getAddress(),
1591                                 MemberInit->const_arg_begin(),
1592                                 MemberInit->const_arg_end());
1593    return;
1594  }
1595
1596  assert(MemberInit->getNumArgs() == 1 && "Initializer count must be 1 only");
1597  Expr *RhsExpr = *MemberInit->arg_begin();
1598  RValue RHS;
1599  if (FieldType->isReferenceType()) {
1600    RHS = CGF.EmitReferenceBindingToExpr(RhsExpr, FieldType,
1601                                    /*IsInitializer=*/true);
1602    CGF.EmitStoreThroughLValue(RHS, LHS, FieldType);
1603  } else if (Array) {
1604    CGF.EmitMemSetToZero(LHS.getAddress(), Field->getType());
1605  } else if (!CGF.hasAggregateLLVMType(RhsExpr->getType())) {
1606    RHS = RValue::get(CGF.EmitScalarExpr(RhsExpr, true));
1607    CGF.EmitStoreThroughLValue(RHS, LHS, FieldType);
1608  } else if (RhsExpr->getType()->isAnyComplexType()) {
1609    CGF.EmitComplexExprIntoAddr(RhsExpr, LHS.getAddress(),
1610                                LHS.isVolatileQualified());
1611  } else {
1612    // Handle member function pointers; other aggregates shouldn't get this far.
1613    CGF.EmitAggExpr(RhsExpr, LHS.getAddress(), LHS.isVolatileQualified());
1614  }
1615}
1616
1617/// EmitCtorPrologue - This routine generates necessary code to initialize
1618/// base classes and non-static data members belonging to this constructor.
1619/// FIXME: This needs to take a CXXCtorType.
1620void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD,
1621                                       CXXCtorType CtorType) {
1622  const CXXRecordDecl *ClassDecl = CD->getParent();
1623
1624  // FIXME: Add vbase initialization
1625  llvm::Value *LoadOfThis = 0;
1626
1627  for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
1628       E = CD->init_end();
1629       B != E; ++B) {
1630    CXXBaseOrMemberInitializer *Member = (*B);
1631
1632    assert(LiveTemporaries.empty() &&
1633           "Should not have any live temporaries at initializer start!");
1634
1635    if (Member->isBaseInitializer())
1636      EmitBaseInitializer(*this, ClassDecl, Member, CtorType);
1637    else
1638      EmitMemberInitializer(*this, ClassDecl, Member);
1639
1640    // Pop any live temporaries that the initializers might have pushed.
1641    while (!LiveTemporaries.empty())
1642      PopCXXTemporary();
1643  }
1644
1645  // Initialize the vtable pointer
1646  if (ClassDecl->isDynamicClass()) {
1647    if (!LoadOfThis)
1648      LoadOfThis = LoadCXXThis();
1649    llvm::Value *VtableField;
1650    llvm::Type *Ptr8Ty, *PtrPtr8Ty;
1651    Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
1652    PtrPtr8Ty = llvm::PointerType::get(Ptr8Ty, 0);
1653    VtableField = Builder.CreateBitCast(LoadOfThis, PtrPtr8Ty);
1654    llvm::Value *vtable = CGM.getVtableInfo().getVtable(ClassDecl);
1655    Builder.CreateStore(vtable, VtableField);
1656  }
1657}
1658
1659/// EmitDtorEpilogue - Emit all code that comes at the end of class's
1660/// destructor. This is to call destructors on members and base classes
1661/// in reverse order of their construction.
1662/// FIXME: This needs to take a CXXDtorType.
1663void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD,
1664                                       CXXDtorType DtorType) {
1665  assert(!DD->isTrivial() &&
1666         "Should not emit dtor epilogue for trivial dtor!");
1667
1668  const CXXRecordDecl *ClassDecl = DD->getParent();
1669
1670  // Collect the fields.
1671  llvm::SmallVector<const FieldDecl *, 16> FieldDecls;
1672  for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
1673       E = ClassDecl->field_end(); I != E; ++I) {
1674    const FieldDecl *Field = *I;
1675
1676    QualType FieldType = getContext().getCanonicalType(Field->getType());
1677    FieldType = getContext().getBaseElementType(FieldType);
1678
1679    const RecordType *RT = FieldType->getAs<RecordType>();
1680    if (!RT)
1681      continue;
1682
1683    CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1684    if (FieldClassDecl->hasTrivialDestructor())
1685        continue;
1686
1687    FieldDecls.push_back(Field);
1688  }
1689
1690  // Now destroy the fields.
1691  for (size_t i = FieldDecls.size(); i > 0; --i) {
1692    const FieldDecl *Field = FieldDecls[i - 1];
1693
1694    QualType FieldType = Field->getType();
1695    const ConstantArrayType *Array =
1696      getContext().getAsConstantArrayType(FieldType);
1697    if (Array)
1698      FieldType = getContext().getBaseElementType(FieldType);
1699
1700    const RecordType *RT = FieldType->getAs<RecordType>();
1701    CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
1702
1703    llvm::Value *ThisPtr = LoadCXXThis();
1704
1705    LValue LHS = EmitLValueForField(ThisPtr, Field,
1706                                    /*isUnion=*/false,
1707                                    // FIXME: Qualifiers?
1708                                    /*CVRQualifiers=*/0);
1709    if (Array) {
1710      const llvm::Type *BasePtr = ConvertType(FieldType);
1711      BasePtr = llvm::PointerType::getUnqual(BasePtr);
1712      llvm::Value *BaseAddrPtr =
1713        Builder.CreateBitCast(LHS.getAddress(), BasePtr);
1714      EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(getContext()),
1715                                Array, BaseAddrPtr);
1716    } else
1717      EmitCXXDestructorCall(FieldClassDecl->getDestructor(getContext()),
1718                            Dtor_Complete, LHS.getAddress());
1719  }
1720
1721  // Destroy non-virtual bases.
1722  for (CXXRecordDecl::reverse_base_class_const_iterator I =
1723        ClassDecl->bases_rbegin(), E = ClassDecl->bases_rend(); I != E; ++I) {
1724    const CXXBaseSpecifier &Base = *I;
1725
1726    // Ignore virtual bases.
1727    if (Base.isVirtual())
1728      continue;
1729
1730    CXXRecordDecl *BaseClassDecl
1731      = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
1732
1733    // Ignore trivial destructors.
1734    if (BaseClassDecl->hasTrivialDestructor())
1735      continue;
1736
1737    llvm::Value *V = GetAddressOfBaseClass(LoadCXXThis(),
1738                                           ClassDecl, BaseClassDecl,
1739                                           /*NullCheckValue=*/false);
1740    EmitCXXDestructorCall(BaseClassDecl->getDestructor(getContext()),
1741                          Dtor_Base, V);
1742  }
1743
1744  // If we're emitting a base destructor, we don't want to emit calls to the
1745  // virtual bases.
1746  if (DtorType == Dtor_Base)
1747    return;
1748
1749  // FIXME: Handle virtual bases.
1750  for (CXXRecordDecl::reverse_base_class_const_iterator I =
1751       ClassDecl->vbases_rbegin(), E = ClassDecl->vbases_rend(); I != E; ++I) {
1752    assert(false && "FIXME: Handle virtual bases.");
1753  }
1754
1755  // If we have a deleting destructor, emit a call to the delete operator.
1756  if (DtorType == Dtor_Deleting)
1757    EmitDeleteCall(DD->getOperatorDelete(), LoadCXXThis(),
1758                   getContext().getTagDeclType(ClassDecl));
1759}
1760
1761void CodeGenFunction::SynthesizeDefaultDestructor(const CXXDestructorDecl *Dtor,
1762                                                  CXXDtorType DtorType,
1763                                                  llvm::Function *Fn,
1764                                                  const FunctionArgList &Args) {
1765  assert(!Dtor->getParent()->hasUserDeclaredDestructor() &&
1766         "SynthesizeDefaultDestructor - destructor has user declaration");
1767
1768  StartFunction(GlobalDecl(Dtor, DtorType), Dtor->getResultType(), Fn, Args,
1769                SourceLocation());
1770
1771  EmitDtorEpilogue(Dtor, DtorType);
1772  FinishFunction();
1773}
1774