blob: a69a3f956687d995785d72619d0c025f2d5cd711 [file] [log] [blame]
Anders Carlsson5b955922009-11-24 05:51:11 +00001//===--- CGClass.cpp - Emit LLVM Code for C++ classes ---------------------===//
Anders Carlsson5d58a1d2009-09-12 04:27:24 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code dealing with C++ code generation of classes
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
Anders Carlsson2f1986b2009-10-06 22:43:30 +000015#include "clang/AST/CXXInheritance.h"
Anders Carlsson5d58a1d2009-09-12 04:27:24 +000016#include "clang/AST/RecordLayout.h"
John McCall9fc6a772010-02-19 09:25:03 +000017#include "clang/AST/StmtCXX.h"
Anders Carlsson2f1986b2009-10-06 22:43:30 +000018
Anders Carlsson5d58a1d2009-09-12 04:27:24 +000019using namespace clang;
20using namespace CodeGen;
21
Anders Carlsson2f1986b2009-10-06 22:43:30 +000022static uint64_t
Anders Carlsson34a2d382010-04-24 21:06:20 +000023ComputeNonVirtualBaseClassOffset(ASTContext &Context,
24 const CXXRecordDecl *DerivedClass,
25 CXXBaseSpecifierArray::iterator Start,
26 CXXBaseSpecifierArray::iterator End) {
27 uint64_t Offset = 0;
28
29 const CXXRecordDecl *RD = DerivedClass;
30
31 for (CXXBaseSpecifierArray::iterator I = Start; I != End; ++I) {
32 const CXXBaseSpecifier *Base = *I;
33 assert(!Base->isVirtual() && "Should not see virtual bases here!");
34
35 // Get the layout.
36 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
37
38 const CXXRecordDecl *BaseDecl =
39 cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl());
40
41 // Add the offset.
42 Offset += Layout.getBaseClassOffset(BaseDecl);
43
44 RD = BaseDecl;
45 }
46
47 // FIXME: We should not use / 8 here.
48 return Offset / 8;
49}
Anders Carlsson5d58a1d2009-09-12 04:27:24 +000050
Anders Carlsson84080ec2009-09-29 03:13:20 +000051llvm::Constant *
Anders Carlssona04efdf2010-04-24 21:23:59 +000052CodeGenModule::GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,
53 const CXXBaseSpecifierArray &BasePath) {
54 assert(!BasePath.empty() && "Base path should not be empty!");
55
56 uint64_t Offset =
57 ComputeNonVirtualBaseClassOffset(getContext(), ClassDecl,
58 BasePath.begin(), BasePath.end());
59 if (!Offset)
60 return 0;
61
62 const llvm::Type *PtrDiffTy =
63 Types.ConvertType(getContext().getPointerDiffType());
64
65 return llvm::ConstantInt::get(PtrDiffTy, Offset);
Anders Carlsson84080ec2009-09-29 03:13:20 +000066}
67
Anders Carlsson8561a862010-04-24 23:01:49 +000068/// Gets the address of a direct base class within a complete object.
John McCallbff225e2010-02-16 04:15:37 +000069/// This should only be used for (1) non-virtual bases or (2) virtual bases
70/// when the type is known to be complete (e.g. in complete destructors).
71///
72/// The object pointed to by 'This' is assumed to be non-null.
73llvm::Value *
Anders Carlsson8561a862010-04-24 23:01:49 +000074CodeGenFunction::GetAddressOfDirectBaseInCompleteClass(llvm::Value *This,
75 const CXXRecordDecl *Derived,
76 const CXXRecordDecl *Base,
77 bool BaseIsVirtual) {
John McCallbff225e2010-02-16 04:15:37 +000078 // 'this' must be a pointer (in some address space) to Derived.
79 assert(This->getType()->isPointerTy() &&
80 cast<llvm::PointerType>(This->getType())->getElementType()
81 == ConvertType(Derived));
82
83 // Compute the offset of the virtual base.
84 uint64_t Offset;
85 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Derived);
Anders Carlsson8561a862010-04-24 23:01:49 +000086 if (BaseIsVirtual)
John McCallbff225e2010-02-16 04:15:37 +000087 Offset = Layout.getVBaseClassOffset(Base);
88 else
89 Offset = Layout.getBaseClassOffset(Base);
90
91 // Shift and cast down to the base type.
92 // TODO: for complete types, this should be possible with a GEP.
93 llvm::Value *V = This;
94 if (Offset) {
95 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(getLLVMContext());
96 V = Builder.CreateBitCast(V, Int8PtrTy);
97 V = Builder.CreateConstInBoundsGEP1_64(V, Offset / 8);
98 }
99 V = Builder.CreateBitCast(V, ConvertType(Base)->getPointerTo());
100
101 return V;
Anders Carlssond103f9f2010-03-28 19:40:00 +0000102}
John McCallbff225e2010-02-16 04:15:37 +0000103
Anders Carlsson9dc228a2010-04-20 16:03:35 +0000104static llvm::Value *
105ApplyNonVirtualAndVirtualOffset(CodeGenFunction &CGF, llvm::Value *ThisPtr,
106 uint64_t NonVirtual, llvm::Value *Virtual) {
107 const llvm::Type *PtrDiffTy =
108 CGF.ConvertType(CGF.getContext().getPointerDiffType());
109
110 llvm::Value *NonVirtualOffset = 0;
111 if (NonVirtual)
112 NonVirtualOffset = llvm::ConstantInt::get(PtrDiffTy, NonVirtual);
113
114 llvm::Value *BaseOffset;
115 if (Virtual) {
116 if (NonVirtualOffset)
117 BaseOffset = CGF.Builder.CreateAdd(Virtual, NonVirtualOffset);
118 else
119 BaseOffset = Virtual;
120 } else
121 BaseOffset = NonVirtualOffset;
122
123 // Apply the base offset.
124 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
125 ThisPtr = CGF.Builder.CreateBitCast(ThisPtr, Int8PtrTy);
126 ThisPtr = CGF.Builder.CreateGEP(ThisPtr, BaseOffset, "add.ptr");
127
128 return ThisPtr;
129}
130
Anders Carlsson5d58a1d2009-09-12 04:27:24 +0000131llvm::Value *
Anders Carlsson34a2d382010-04-24 21:06:20 +0000132CodeGenFunction::GetAddressOfBaseClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +0000133 const CXXRecordDecl *Derived,
Anders Carlsson34a2d382010-04-24 21:06:20 +0000134 const CXXBaseSpecifierArray &BasePath,
135 bool NullCheckValue) {
136 assert(!BasePath.empty() && "Base path should not be empty!");
137
138 CXXBaseSpecifierArray::iterator Start = BasePath.begin();
139 const CXXRecordDecl *VBase = 0;
140
141 // Get the virtual base.
142 if ((*Start)->isVirtual()) {
143 VBase =
144 cast<CXXRecordDecl>((*Start)->getType()->getAs<RecordType>()->getDecl());
145 ++Start;
146 }
147
148 uint64_t NonVirtualOffset =
Anders Carlsson8561a862010-04-24 23:01:49 +0000149 ComputeNonVirtualBaseClassOffset(getContext(), VBase ? VBase : Derived,
Anders Carlsson34a2d382010-04-24 21:06:20 +0000150 Start, BasePath.end());
151
152 // Get the base pointer type.
153 const llvm::Type *BasePtrTy =
Anders Carlssonfc89c312010-04-24 21:12:55 +0000154 ConvertType((BasePath.end()[-1])->getType())->getPointerTo();
Anders Carlsson34a2d382010-04-24 21:06:20 +0000155
156 if (!NonVirtualOffset && !VBase) {
157 // Just cast back.
158 return Builder.CreateBitCast(Value, BasePtrTy);
159 }
160
161 llvm::BasicBlock *CastNull = 0;
162 llvm::BasicBlock *CastNotNull = 0;
163 llvm::BasicBlock *CastEnd = 0;
164
165 if (NullCheckValue) {
166 CastNull = createBasicBlock("cast.null");
167 CastNotNull = createBasicBlock("cast.notnull");
168 CastEnd = createBasicBlock("cast.end");
169
170 llvm::Value *IsNull =
171 Builder.CreateICmpEQ(Value,
172 llvm::Constant::getNullValue(Value->getType()));
173 Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
174 EmitBlock(CastNotNull);
175 }
176
177 llvm::Value *VirtualOffset = 0;
178
179 if (VBase)
Anders Carlsson8561a862010-04-24 23:01:49 +0000180 VirtualOffset = GetVirtualBaseClassOffset(Value, Derived, VBase);
Anders Carlsson34a2d382010-04-24 21:06:20 +0000181
182 // Apply the offsets.
183 Value = ApplyNonVirtualAndVirtualOffset(*this, Value, NonVirtualOffset,
184 VirtualOffset);
185
186 // Cast back.
187 Value = Builder.CreateBitCast(Value, BasePtrTy);
188
189 if (NullCheckValue) {
190 Builder.CreateBr(CastEnd);
191 EmitBlock(CastNull);
192 Builder.CreateBr(CastEnd);
193 EmitBlock(CastEnd);
194
195 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType());
196 PHI->reserveOperandSpace(2);
197 PHI->addIncoming(Value, CastNotNull);
198 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()),
199 CastNull);
200 Value = PHI;
201 }
202
203 return Value;
204}
205
206llvm::Value *
Anders Carlssona3697c92009-11-23 17:57:54 +0000207CodeGenFunction::GetAddressOfDerivedClass(llvm::Value *Value,
Anders Carlsson8561a862010-04-24 23:01:49 +0000208 const CXXRecordDecl *Derived,
Anders Carlssona04efdf2010-04-24 21:23:59 +0000209 const CXXBaseSpecifierArray &BasePath,
Anders Carlssona3697c92009-11-23 17:57:54 +0000210 bool NullCheckValue) {
Anders Carlssona04efdf2010-04-24 21:23:59 +0000211 assert(!BasePath.empty() && "Base path should not be empty!");
212
Anders Carlssona3697c92009-11-23 17:57:54 +0000213 QualType DerivedTy =
Anders Carlsson8561a862010-04-24 23:01:49 +0000214 getContext().getCanonicalType(getContext().getTagDeclType(Derived));
Anders Carlssona3697c92009-11-23 17:57:54 +0000215 const llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo();
216
Anders Carlssona552ea72010-01-31 01:43:37 +0000217 llvm::Value *NonVirtualOffset =
Anders Carlsson8561a862010-04-24 23:01:49 +0000218 CGM.GetNonVirtualBaseClassOffset(Derived, BasePath);
Anders Carlssona552ea72010-01-31 01:43:37 +0000219
220 if (!NonVirtualOffset) {
221 // No offset, we can just cast back.
222 return Builder.CreateBitCast(Value, DerivedPtrTy);
223 }
224
Anders Carlssona3697c92009-11-23 17:57:54 +0000225 llvm::BasicBlock *CastNull = 0;
226 llvm::BasicBlock *CastNotNull = 0;
227 llvm::BasicBlock *CastEnd = 0;
228
229 if (NullCheckValue) {
230 CastNull = createBasicBlock("cast.null");
231 CastNotNull = createBasicBlock("cast.notnull");
232 CastEnd = createBasicBlock("cast.end");
233
234 llvm::Value *IsNull =
235 Builder.CreateICmpEQ(Value,
236 llvm::Constant::getNullValue(Value->getType()));
237 Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
238 EmitBlock(CastNotNull);
239 }
240
Anders Carlssona552ea72010-01-31 01:43:37 +0000241 // Apply the offset.
242 Value = Builder.CreatePtrToInt(Value, NonVirtualOffset->getType());
243 Value = Builder.CreateSub(Value, NonVirtualOffset);
244 Value = Builder.CreateIntToPtr(Value, DerivedPtrTy);
245
246 // Just cast.
247 Value = Builder.CreateBitCast(Value, DerivedPtrTy);
Anders Carlssona3697c92009-11-23 17:57:54 +0000248
249 if (NullCheckValue) {
250 Builder.CreateBr(CastEnd);
251 EmitBlock(CastNull);
252 Builder.CreateBr(CastEnd);
253 EmitBlock(CastEnd);
254
255 llvm::PHINode *PHI = Builder.CreatePHI(Value->getType());
256 PHI->reserveOperandSpace(2);
257 PHI->addIncoming(Value, CastNotNull);
258 PHI->addIncoming(llvm::Constant::getNullValue(Value->getType()),
259 CastNull);
260 Value = PHI;
261 }
262
263 return Value;
Anders Carlsson5d58a1d2009-09-12 04:27:24 +0000264}
Anders Carlsson21c9ad92010-03-30 03:27:09 +0000265
Anders Carlssonc997d422010-01-02 01:01:18 +0000266/// GetVTTParameter - Return the VTT parameter that should be passed to a
267/// base constructor/destructor with virtual bases.
Anders Carlsson314e6222010-05-02 23:33:10 +0000268static llvm::Value *GetVTTParameter(CodeGenFunction &CGF, GlobalDecl GD,
269 bool ForVirtualBase) {
Anders Carlssonaf440352010-03-23 04:11:45 +0000270 if (!CodeGenVTables::needsVTTParameter(GD)) {
Anders Carlssonc997d422010-01-02 01:01:18 +0000271 // This constructor/destructor does not need a VTT parameter.
272 return 0;
273 }
274
275 const CXXRecordDecl *RD = cast<CXXMethodDecl>(CGF.CurFuncDecl)->getParent();
276 const CXXRecordDecl *Base = cast<CXXMethodDecl>(GD.getDecl())->getParent();
John McCall3b477332010-02-18 19:59:28 +0000277
Anders Carlssonc997d422010-01-02 01:01:18 +0000278 llvm::Value *VTT;
279
John McCall3b477332010-02-18 19:59:28 +0000280 uint64_t SubVTTIndex;
281
282 // If the record matches the base, this is the complete ctor/dtor
283 // variant calling the base variant in a class with virtual bases.
284 if (RD == Base) {
Anders Carlssonaf440352010-03-23 04:11:45 +0000285 assert(!CodeGenVTables::needsVTTParameter(CGF.CurGD) &&
John McCall3b477332010-02-18 19:59:28 +0000286 "doing no-op VTT offset in base dtor/ctor?");
Anders Carlsson314e6222010-05-02 23:33:10 +0000287 assert(!ForVirtualBase && "Can't have same class as virtual base!");
John McCall3b477332010-02-18 19:59:28 +0000288 SubVTTIndex = 0;
289 } else {
Anders Carlssonc11bb212010-05-02 23:53:25 +0000290 const ASTRecordLayout &Layout =
291 CGF.getContext().getASTRecordLayout(RD);
292 uint64_t BaseOffset = ForVirtualBase ?
293 Layout.getVBaseClassOffset(Base) : Layout.getBaseClassOffset(Base);
294
295 SubVTTIndex =
296 CGF.CGM.getVTables().getSubVTTIndex(RD, BaseSubobject(Base, BaseOffset));
John McCall3b477332010-02-18 19:59:28 +0000297 assert(SubVTTIndex != 0 && "Sub-VTT index must be greater than zero!");
298 }
Anders Carlssonc997d422010-01-02 01:01:18 +0000299
Anders Carlssonaf440352010-03-23 04:11:45 +0000300 if (CodeGenVTables::needsVTTParameter(CGF.CurGD)) {
Anders Carlssonc997d422010-01-02 01:01:18 +0000301 // A VTT parameter was passed to the constructor, use it.
302 VTT = CGF.LoadCXXVTT();
303 VTT = CGF.Builder.CreateConstInBoundsGEP1_64(VTT, SubVTTIndex);
304 } else {
305 // We're the complete constructor, so get the VTT by name.
Anders Carlssonaf440352010-03-23 04:11:45 +0000306 VTT = CGF.CGM.getVTables().getVTT(RD);
Anders Carlssonc997d422010-01-02 01:01:18 +0000307 VTT = CGF.Builder.CreateConstInBoundsGEP2_64(VTT, 0, SubVTTIndex);
308 }
309
310 return VTT;
311}
312
Anders Carlsson607d0372009-12-24 22:46:43 +0000313static void EmitBaseInitializer(CodeGenFunction &CGF,
314 const CXXRecordDecl *ClassDecl,
315 CXXBaseOrMemberInitializer *BaseInit,
316 CXXCtorType CtorType) {
317 assert(BaseInit->isBaseInitializer() &&
318 "Must have base initializer!");
319
320 llvm::Value *ThisPtr = CGF.LoadCXXThis();
321
322 const Type *BaseType = BaseInit->getBaseClass();
323 CXXRecordDecl *BaseClassDecl =
324 cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
325
Anders Carlsson80638c52010-04-12 00:51:03 +0000326 bool isBaseVirtual = BaseInit->isBaseVirtual();
Anders Carlsson607d0372009-12-24 22:46:43 +0000327
328 // The base constructor doesn't construct virtual bases.
329 if (CtorType == Ctor_Base && isBaseVirtual)
330 return;
331
John McCallbff225e2010-02-16 04:15:37 +0000332 // We can pretend to be a complete class because it only matters for
333 // virtual bases, and we only do virtual bases for complete ctors.
Anders Carlsson8561a862010-04-24 23:01:49 +0000334 llvm::Value *V =
335 CGF.GetAddressOfDirectBaseInCompleteClass(ThisPtr, ClassDecl,
336 BaseClassDecl,
337 BaseInit->isBaseVirtual());
John McCallbff225e2010-02-16 04:15:37 +0000338
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000339 CGF.EmitAggExpr(BaseInit->getInit(), V, false, false, true);
Anders Carlsson594d5e82010-02-06 20:00:21 +0000340
341 if (CGF.Exceptions && !BaseClassDecl->hasTrivialDestructor()) {
342 // FIXME: Is this OK for C++0x delegating constructors?
John McCallf1549f62010-07-06 01:34:17 +0000343 CodeGenFunction::CleanupBlock Cleanup(CGF, CodeGenFunction::EHCleanup);
Anders Carlsson594d5e82010-02-06 20:00:21 +0000344
Douglas Gregor1d110e02010-07-01 14:13:13 +0000345 CXXDestructorDecl *DD = BaseClassDecl->getDestructor();
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000346 CGF.EmitCXXDestructorCall(DD, Dtor_Base, isBaseVirtual, V);
Anders Carlsson594d5e82010-02-06 20:00:21 +0000347 }
Anders Carlsson607d0372009-12-24 22:46:43 +0000348}
349
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000350static void EmitAggMemberInitializer(CodeGenFunction &CGF,
351 LValue LHS,
352 llvm::Value *ArrayIndexVar,
353 CXXBaseOrMemberInitializer *MemberInit,
354 QualType T,
355 unsigned Index) {
356 if (Index == MemberInit->getNumArrayIndices()) {
John McCallf1549f62010-07-06 01:34:17 +0000357 CodeGenFunction::RunCleanupsScope Cleanups(CGF);
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000358
359 llvm::Value *Dest = LHS.getAddress();
360 if (ArrayIndexVar) {
361 // If we have an array index variable, load it and use it as an offset.
362 // Then, increment the value.
363 llvm::Value *ArrayIndex = CGF.Builder.CreateLoad(ArrayIndexVar);
364 Dest = CGF.Builder.CreateInBoundsGEP(Dest, ArrayIndex, "destaddress");
365 llvm::Value *Next = llvm::ConstantInt::get(ArrayIndex->getType(), 1);
366 Next = CGF.Builder.CreateAdd(ArrayIndex, Next, "inc");
367 CGF.Builder.CreateStore(Next, ArrayIndexVar);
368 }
369
370 CGF.EmitAggExpr(MemberInit->getInit(), Dest,
371 LHS.isVolatileQualified(),
372 /*IgnoreResult*/ false,
373 /*IsInitializer*/ true);
374
375 return;
376 }
377
378 const ConstantArrayType *Array = CGF.getContext().getAsConstantArrayType(T);
379 assert(Array && "Array initialization without the array type?");
380 llvm::Value *IndexVar
381 = CGF.GetAddrOfLocalVar(MemberInit->getArrayIndex(Index));
382 assert(IndexVar && "Array index variable not loaded");
383
384 // Initialize this index variable to zero.
385 llvm::Value* Zero
386 = llvm::Constant::getNullValue(
387 CGF.ConvertType(CGF.getContext().getSizeType()));
388 CGF.Builder.CreateStore(Zero, IndexVar);
389
390 // Start the loop with a block that tests the condition.
391 llvm::BasicBlock *CondBlock = CGF.createBasicBlock("for.cond");
392 llvm::BasicBlock *AfterFor = CGF.createBasicBlock("for.end");
393
394 CGF.EmitBlock(CondBlock);
395
396 llvm::BasicBlock *ForBody = CGF.createBasicBlock("for.body");
397 // Generate: if (loop-index < number-of-elements) fall to the loop body,
398 // otherwise, go to the block after the for-loop.
399 uint64_t NumElements = Array->getSize().getZExtValue();
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000400 llvm::Value *Counter = CGF.Builder.CreateLoad(IndexVar);
Chris Lattner985f7392010-05-06 06:35:23 +0000401 llvm::Value *NumElementsPtr =
402 llvm::ConstantInt::get(Counter->getType(), NumElements);
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000403 llvm::Value *IsLess = CGF.Builder.CreateICmpULT(Counter, NumElementsPtr,
404 "isless");
405
406 // If the condition is true, execute the body.
407 CGF.Builder.CreateCondBr(IsLess, ForBody, AfterFor);
408
409 CGF.EmitBlock(ForBody);
410 llvm::BasicBlock *ContinueBlock = CGF.createBasicBlock("for.inc");
411
412 {
John McCallf1549f62010-07-06 01:34:17 +0000413 CodeGenFunction::RunCleanupsScope Cleanups(CGF);
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000414
415 // Inside the loop body recurse to emit the inner loop or, eventually, the
416 // constructor call.
417 EmitAggMemberInitializer(CGF, LHS, ArrayIndexVar, MemberInit,
418 Array->getElementType(), Index + 1);
419 }
420
421 CGF.EmitBlock(ContinueBlock);
422
423 // Emit the increment of the loop counter.
424 llvm::Value *NextVal = llvm::ConstantInt::get(Counter->getType(), 1);
425 Counter = CGF.Builder.CreateLoad(IndexVar);
426 NextVal = CGF.Builder.CreateAdd(Counter, NextVal, "inc");
427 CGF.Builder.CreateStore(NextVal, IndexVar);
428
429 // Finally, branch back up to the condition for the next iteration.
430 CGF.EmitBranch(CondBlock);
431
432 // Emit the fall-through block.
433 CGF.EmitBlock(AfterFor, true);
434}
435
Anders Carlsson607d0372009-12-24 22:46:43 +0000436static void EmitMemberInitializer(CodeGenFunction &CGF,
437 const CXXRecordDecl *ClassDecl,
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000438 CXXBaseOrMemberInitializer *MemberInit,
439 const CXXConstructorDecl *Constructor,
440 FunctionArgList &Args) {
Anders Carlsson607d0372009-12-24 22:46:43 +0000441 assert(MemberInit->isMemberInitializer() &&
442 "Must have member initializer!");
443
444 // non-static data member initializers.
445 FieldDecl *Field = MemberInit->getMember();
446 QualType FieldType = CGF.getContext().getCanonicalType(Field->getType());
447
448 llvm::Value *ThisPtr = CGF.LoadCXXThis();
John McCalla9976d32010-05-21 01:18:57 +0000449 LValue LHS;
Anders Carlsson06a29702010-01-29 05:24:29 +0000450
Anders Carlsson607d0372009-12-24 22:46:43 +0000451 // If we are initializing an anonymous union field, drill down to the field.
452 if (MemberInit->getAnonUnionMember()) {
453 Field = MemberInit->getAnonUnionMember();
John McCalla9976d32010-05-21 01:18:57 +0000454 LHS = CGF.EmitLValueForAnonRecordField(ThisPtr, Field, 0);
Anders Carlsson607d0372009-12-24 22:46:43 +0000455 FieldType = Field->getType();
John McCalla9976d32010-05-21 01:18:57 +0000456 } else {
457 LHS = CGF.EmitLValueForFieldInitialization(ThisPtr, Field, 0);
Anders Carlsson607d0372009-12-24 22:46:43 +0000458 }
459
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000460 // FIXME: If there's no initializer and the CXXBaseOrMemberInitializer
461 // was implicitly generated, we shouldn't be zeroing memory.
Anders Carlsson607d0372009-12-24 22:46:43 +0000462 RValue RHS;
463 if (FieldType->isReferenceType()) {
Anders Carlsson32f36ba2010-06-26 16:35:32 +0000464 RHS = CGF.EmitReferenceBindingToExpr(MemberInit->getInit(), Field);
Anders Carlsson607d0372009-12-24 22:46:43 +0000465 CGF.EmitStoreThroughLValue(RHS, LHS, FieldType);
Eli Friedman3bb94122010-01-31 19:07:50 +0000466 } else if (FieldType->isArrayType() && !MemberInit->getInit()) {
Anders Carlsson1884eb02010-05-22 17:35:42 +0000467 CGF.EmitNullInitialization(LHS.getAddress(), Field->getType());
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000468 } else if (!CGF.hasAggregateLLVMType(Field->getType())) {
Eli Friedman0b292272010-06-03 19:58:07 +0000469 RHS = RValue::get(CGF.EmitScalarExpr(MemberInit->getInit()));
Anders Carlsson607d0372009-12-24 22:46:43 +0000470 CGF.EmitStoreThroughLValue(RHS, LHS, FieldType);
Douglas Gregor9db7dbb2010-01-31 09:12:51 +0000471 } else if (MemberInit->getInit()->getType()->isAnyComplexType()) {
472 CGF.EmitComplexExprIntoAddr(MemberInit->getInit(), LHS.getAddress(),
Anders Carlsson607d0372009-12-24 22:46:43 +0000473 LHS.isVolatileQualified());
474 } else {
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000475 llvm::Value *ArrayIndexVar = 0;
476 const ConstantArrayType *Array
477 = CGF.getContext().getAsConstantArrayType(FieldType);
478 if (Array && Constructor->isImplicit() &&
479 Constructor->isCopyConstructor()) {
480 const llvm::Type *SizeTy
481 = CGF.ConvertType(CGF.getContext().getSizeType());
482
483 // The LHS is a pointer to the first object we'll be constructing, as
484 // a flat array.
485 QualType BaseElementTy = CGF.getContext().getBaseElementType(Array);
486 const llvm::Type *BasePtr = CGF.ConvertType(BaseElementTy);
487 BasePtr = llvm::PointerType::getUnqual(BasePtr);
488 llvm::Value *BaseAddrPtr = CGF.Builder.CreateBitCast(LHS.getAddress(),
489 BasePtr);
490 LHS = LValue::MakeAddr(BaseAddrPtr, CGF.MakeQualifiers(BaseElementTy));
491
492 // Create an array index that will be used to walk over all of the
493 // objects we're constructing.
494 ArrayIndexVar = CGF.CreateTempAlloca(SizeTy, "object.index");
495 llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
496 CGF.Builder.CreateStore(Zero, ArrayIndexVar);
497
498 // If we are copying an array of scalars or classes with trivial copy
499 // constructors, perform a single aggregate copy.
500 const RecordType *Record = BaseElementTy->getAs<RecordType>();
501 if (!Record ||
502 cast<CXXRecordDecl>(Record->getDecl())->hasTrivialCopyConstructor()) {
503 // Find the source pointer. We knows it's the last argument because
504 // we know we're in a copy constructor.
505 unsigned SrcArgIndex = Args.size() - 1;
506 llvm::Value *SrcPtr
507 = CGF.Builder.CreateLoad(
508 CGF.GetAddrOfLocalVar(Args[SrcArgIndex].first));
509 LValue Src = CGF.EmitLValueForFieldInitialization(SrcPtr, Field, 0);
510
511 // Copy the aggregate.
512 CGF.EmitAggregateCopy(LHS.getAddress(), Src.getAddress(), FieldType,
513 LHS.isVolatileQualified());
514 return;
515 }
516
517 // Emit the block variables for the array indices, if any.
518 for (unsigned I = 0, N = MemberInit->getNumArrayIndices(); I != N; ++I)
519 CGF.EmitLocalBlockVarDecl(*MemberInit->getArrayIndex(I));
520 }
521
522 EmitAggMemberInitializer(CGF, LHS, ArrayIndexVar, MemberInit, FieldType, 0);
Anders Carlsson9405dcd2010-02-06 19:50:17 +0000523
524 if (!CGF.Exceptions)
525 return;
526
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000527 // FIXME: If we have an array of classes w/ non-trivial destructors,
528 // we need to destroy in reverse order of construction along the exception
529 // path.
Anders Carlsson9405dcd2010-02-06 19:50:17 +0000530 const RecordType *RT = FieldType->getAs<RecordType>();
531 if (!RT)
532 return;
533
534 CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
535 if (!RD->hasTrivialDestructor()) {
536 // FIXME: Is this OK for C++0x delegating constructors?
John McCallf1549f62010-07-06 01:34:17 +0000537 CodeGenFunction::CleanupBlock Cleanup(CGF, CodeGenFunction::EHCleanup);
Anders Carlsson9405dcd2010-02-06 19:50:17 +0000538
539 llvm::Value *ThisPtr = CGF.LoadCXXThis();
540 LValue LHS = CGF.EmitLValueForField(ThisPtr, Field, 0);
541
Douglas Gregor1d110e02010-07-01 14:13:13 +0000542 CXXDestructorDecl *DD = RD->getDestructor();
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000543 CGF.EmitCXXDestructorCall(DD, Dtor_Complete, /*ForVirtualBase=*/false,
544 LHS.getAddress());
Anders Carlsson9405dcd2010-02-06 19:50:17 +0000545 }
Anders Carlsson607d0372009-12-24 22:46:43 +0000546 }
547}
548
John McCallc0bf4622010-02-23 00:48:20 +0000549/// Checks whether the given constructor is a valid subject for the
550/// complete-to-base constructor delegation optimization, i.e.
551/// emitting the complete constructor as a simple call to the base
552/// constructor.
553static bool IsConstructorDelegationValid(const CXXConstructorDecl *Ctor) {
554
555 // Currently we disable the optimization for classes with virtual
556 // bases because (1) the addresses of parameter variables need to be
557 // consistent across all initializers but (2) the delegate function
558 // call necessarily creates a second copy of the parameter variable.
559 //
560 // The limiting example (purely theoretical AFAIK):
561 // struct A { A(int &c) { c++; } };
562 // struct B : virtual A {
563 // B(int count) : A(count) { printf("%d\n", count); }
564 // };
565 // ...although even this example could in principle be emitted as a
566 // delegation since the address of the parameter doesn't escape.
567 if (Ctor->getParent()->getNumVBases()) {
568 // TODO: white-list trivial vbase initializers. This case wouldn't
569 // be subject to the restrictions below.
570
571 // TODO: white-list cases where:
572 // - there are no non-reference parameters to the constructor
573 // - the initializers don't access any non-reference parameters
574 // - the initializers don't take the address of non-reference
575 // parameters
576 // - etc.
577 // If we ever add any of the above cases, remember that:
578 // - function-try-blocks will always blacklist this optimization
579 // - we need to perform the constructor prologue and cleanup in
580 // EmitConstructorBody.
581
582 return false;
583 }
584
585 // We also disable the optimization for variadic functions because
586 // it's impossible to "re-pass" varargs.
587 if (Ctor->getType()->getAs<FunctionProtoType>()->isVariadic())
588 return false;
589
590 return true;
591}
592
John McCall9fc6a772010-02-19 09:25:03 +0000593/// EmitConstructorBody - Emits the body of the current constructor.
594void CodeGenFunction::EmitConstructorBody(FunctionArgList &Args) {
595 const CXXConstructorDecl *Ctor = cast<CXXConstructorDecl>(CurGD.getDecl());
596 CXXCtorType CtorType = CurGD.getCtorType();
597
John McCallc0bf4622010-02-23 00:48:20 +0000598 // Before we go any further, try the complete->base constructor
599 // delegation optimization.
600 if (CtorType == Ctor_Complete && IsConstructorDelegationValid(Ctor)) {
601 EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args);
602 return;
603 }
604
John McCall9fc6a772010-02-19 09:25:03 +0000605 Stmt *Body = Ctor->getBody();
606
John McCallc0bf4622010-02-23 00:48:20 +0000607 // Enter the function-try-block before the constructor prologue if
608 // applicable.
John McCall9fc6a772010-02-19 09:25:03 +0000609 CXXTryStmtInfo TryInfo;
John McCallc0bf4622010-02-23 00:48:20 +0000610 bool IsTryBody = (Body && isa<CXXTryStmt>(Body));
611
612 if (IsTryBody)
John McCall9fc6a772010-02-19 09:25:03 +0000613 TryInfo = EnterCXXTryStmt(*cast<CXXTryStmt>(Body));
614
John McCallf1549f62010-07-06 01:34:17 +0000615 EHScopeStack::stable_iterator CleanupDepth = EHStack.stable_begin();
John McCall9fc6a772010-02-19 09:25:03 +0000616
John McCallc0bf4622010-02-23 00:48:20 +0000617 // Emit the constructor prologue, i.e. the base and member
618 // initializers.
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000619 EmitCtorPrologue(Ctor, CtorType, Args);
John McCall9fc6a772010-02-19 09:25:03 +0000620
621 // Emit the body of the statement.
John McCallc0bf4622010-02-23 00:48:20 +0000622 if (IsTryBody)
John McCall9fc6a772010-02-19 09:25:03 +0000623 EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
624 else if (Body)
625 EmitStmt(Body);
John McCall9fc6a772010-02-19 09:25:03 +0000626
627 // Emit any cleanup blocks associated with the member or base
628 // initializers, which includes (along the exceptional path) the
629 // destructors for those members and bases that were fully
630 // constructed.
John McCallf1549f62010-07-06 01:34:17 +0000631 PopCleanupBlocks(CleanupDepth);
John McCall9fc6a772010-02-19 09:25:03 +0000632
John McCallc0bf4622010-02-23 00:48:20 +0000633 if (IsTryBody)
John McCall9fc6a772010-02-19 09:25:03 +0000634 ExitCXXTryStmt(*cast<CXXTryStmt>(Body), TryInfo);
635}
636
Anders Carlsson607d0372009-12-24 22:46:43 +0000637/// EmitCtorPrologue - This routine generates necessary code to initialize
638/// base classes and non-static data members belonging to this constructor.
Anders Carlsson607d0372009-12-24 22:46:43 +0000639void CodeGenFunction::EmitCtorPrologue(const CXXConstructorDecl *CD,
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000640 CXXCtorType CtorType,
641 FunctionArgList &Args) {
Anders Carlsson607d0372009-12-24 22:46:43 +0000642 const CXXRecordDecl *ClassDecl = CD->getParent();
Anders Carlssona78fa2c2010-02-02 19:58:43 +0000643
644 llvm::SmallVector<CXXBaseOrMemberInitializer *, 8> MemberInitializers;
Anders Carlsson607d0372009-12-24 22:46:43 +0000645
Anders Carlsson607d0372009-12-24 22:46:43 +0000646 for (CXXConstructorDecl::init_const_iterator B = CD->init_begin(),
647 E = CD->init_end();
648 B != E; ++B) {
649 CXXBaseOrMemberInitializer *Member = (*B);
650
Anders Carlsson607d0372009-12-24 22:46:43 +0000651 if (Member->isBaseInitializer())
652 EmitBaseInitializer(*this, ClassDecl, Member, CtorType);
653 else
Anders Carlssona78fa2c2010-02-02 19:58:43 +0000654 MemberInitializers.push_back(Member);
Anders Carlsson607d0372009-12-24 22:46:43 +0000655 }
656
Anders Carlsson603d6d12010-03-28 21:07:49 +0000657 InitializeVTablePointers(ClassDecl);
Anders Carlssona78fa2c2010-02-02 19:58:43 +0000658
John McCallf1549f62010-07-06 01:34:17 +0000659 for (unsigned I = 0, E = MemberInitializers.size(); I != E; ++I)
Douglas Gregorfb8cc252010-05-05 05:51:00 +0000660 EmitMemberInitializer(*this, ClassDecl, MemberInitializers[I], CD, Args);
Anders Carlsson607d0372009-12-24 22:46:43 +0000661}
662
John McCall9fc6a772010-02-19 09:25:03 +0000663/// EmitDestructorBody - Emits the body of the current destructor.
664void CodeGenFunction::EmitDestructorBody(FunctionArgList &Args) {
665 const CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(CurGD.getDecl());
666 CXXDtorType DtorType = CurGD.getDtorType();
667
668 Stmt *Body = Dtor->getBody();
669
670 // If the body is a function-try-block, enter the try before
671 // anything else --- unless we're in a deleting destructor, in which
672 // case we're just going to call the complete destructor and then
673 // call operator delete() on the way out.
674 CXXTryStmtInfo TryInfo;
675 bool isTryBody = (DtorType != Dtor_Deleting &&
676 Body && isa<CXXTryStmt>(Body));
677 if (isTryBody)
678 TryInfo = EnterCXXTryStmt(*cast<CXXTryStmt>(Body));
679
John McCallf1549f62010-07-06 01:34:17 +0000680 // Emit the destructor epilogue now. If this is a complete
681 // destructor with a function-try-block, perform the base epilogue
682 // as well.
683 //
684 // FIXME: This isn't really right, because an exception in the
685 // non-EH epilogue should jump to the appropriate place in the
686 // EH epilogue.
687 {
688 CleanupBlock Cleanup(*this, NormalCleanup);
689
690 if (isTryBody && DtorType == Dtor_Complete)
691 EmitDtorEpilogue(Dtor, Dtor_Base);
692 EmitDtorEpilogue(Dtor, DtorType);
693
694 if (Exceptions) {
695 Cleanup.beginEHCleanup();
696
697 if (isTryBody && DtorType == Dtor_Complete)
698 EmitDtorEpilogue(Dtor, Dtor_Base);
699 EmitDtorEpilogue(Dtor, DtorType);
700 }
701 }
John McCall9fc6a772010-02-19 09:25:03 +0000702
703 bool SkipBody = false; // should get jump-threaded
704
705 // If this is the deleting variant, just invoke the complete
706 // variant, then call the appropriate operator delete() on the way
707 // out.
708 if (DtorType == Dtor_Deleting) {
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000709 EmitCXXDestructorCall(Dtor, Dtor_Complete, /*ForVirtualBase=*/false,
710 LoadCXXThis());
John McCall9fc6a772010-02-19 09:25:03 +0000711 SkipBody = true;
712
713 // If this is the complete variant, just invoke the base variant;
714 // the epilogue will destruct the virtual bases. But we can't do
715 // this optimization if the body is a function-try-block, because
716 // we'd introduce *two* handler blocks.
717 } else if (!isTryBody && DtorType == Dtor_Complete) {
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000718 EmitCXXDestructorCall(Dtor, Dtor_Base, /*ForVirtualBase=*/false,
719 LoadCXXThis());
John McCall9fc6a772010-02-19 09:25:03 +0000720 SkipBody = true;
721
722 // Otherwise, we're in the base variant, so we need to ensure the
723 // vtable ptrs are right before emitting the body.
724 } else {
Anders Carlsson603d6d12010-03-28 21:07:49 +0000725 InitializeVTablePointers(Dtor->getParent());
John McCall9fc6a772010-02-19 09:25:03 +0000726 }
727
728 // Emit the body of the statement.
729 if (SkipBody)
730 (void) 0;
731 else if (isTryBody)
732 EmitStmt(cast<CXXTryStmt>(Body)->getTryBlock());
733 else if (Body)
734 EmitStmt(Body);
735 else {
736 assert(Dtor->isImplicit() && "bodyless dtor not implicit");
737 // nothing to do besides what's in the epilogue
738 }
739
John McCallf1549f62010-07-06 01:34:17 +0000740 // We're done with the epilogue cleanup.
741 PopCleanupBlock();
John McCall9fc6a772010-02-19 09:25:03 +0000742
743 // Exit the try if applicable.
744 if (isTryBody)
745 ExitCXXTryStmt(*cast<CXXTryStmt>(Body), TryInfo);
746}
747
Anders Carlsson607d0372009-12-24 22:46:43 +0000748/// EmitDtorEpilogue - Emit all code that comes at the end of class's
749/// destructor. This is to call destructors on members and base classes
750/// in reverse order of their construction.
Anders Carlsson607d0372009-12-24 22:46:43 +0000751void CodeGenFunction::EmitDtorEpilogue(const CXXDestructorDecl *DD,
752 CXXDtorType DtorType) {
753 assert(!DD->isTrivial() &&
754 "Should not emit dtor epilogue for trivial dtor!");
755
756 const CXXRecordDecl *ClassDecl = DD->getParent();
757
John McCall3b477332010-02-18 19:59:28 +0000758 // In a deleting destructor, we've already called the complete
759 // destructor as a subroutine, so we just have to delete the
760 // appropriate value.
761 if (DtorType == Dtor_Deleting) {
762 assert(DD->getOperatorDelete() &&
763 "operator delete missing - EmitDtorEpilogue");
764 EmitDeleteCall(DD->getOperatorDelete(), LoadCXXThis(),
765 getContext().getTagDeclType(ClassDecl));
766 return;
767 }
768
769 // For complete destructors, we've already called the base
770 // destructor (in GenerateBody), so we just need to destruct all the
771 // virtual bases.
772 if (DtorType == Dtor_Complete) {
773 // Handle virtual bases.
774 for (CXXRecordDecl::reverse_base_class_const_iterator I =
775 ClassDecl->vbases_rbegin(), E = ClassDecl->vbases_rend();
776 I != E; ++I) {
777 const CXXBaseSpecifier &Base = *I;
778 CXXRecordDecl *BaseClassDecl
779 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
780
781 // Ignore trivial destructors.
782 if (BaseClassDecl->hasTrivialDestructor())
783 continue;
Douglas Gregor1d110e02010-07-01 14:13:13 +0000784 const CXXDestructorDecl *D = BaseClassDecl->getDestructor();
Anders Carlsson8561a862010-04-24 23:01:49 +0000785 llvm::Value *V =
786 GetAddressOfDirectBaseInCompleteClass(LoadCXXThis(),
787 ClassDecl, BaseClassDecl,
788 /*BaseIsVirtual=*/true);
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000789 EmitCXXDestructorCall(D, Dtor_Base, /*ForVirtualBase=*/true, V);
John McCall3b477332010-02-18 19:59:28 +0000790 }
791 return;
792 }
793
794 assert(DtorType == Dtor_Base);
795
Anders Carlsson607d0372009-12-24 22:46:43 +0000796 // Collect the fields.
797 llvm::SmallVector<const FieldDecl *, 16> FieldDecls;
798 for (CXXRecordDecl::field_iterator I = ClassDecl->field_begin(),
799 E = ClassDecl->field_end(); I != E; ++I) {
800 const FieldDecl *Field = *I;
801
802 QualType FieldType = getContext().getCanonicalType(Field->getType());
803 FieldType = getContext().getBaseElementType(FieldType);
804
805 const RecordType *RT = FieldType->getAs<RecordType>();
806 if (!RT)
807 continue;
808
809 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
810 if (FieldClassDecl->hasTrivialDestructor())
811 continue;
812
813 FieldDecls.push_back(Field);
814 }
815
816 // Now destroy the fields.
817 for (size_t i = FieldDecls.size(); i > 0; --i) {
818 const FieldDecl *Field = FieldDecls[i - 1];
819
820 QualType FieldType = Field->getType();
821 const ConstantArrayType *Array =
822 getContext().getAsConstantArrayType(FieldType);
823 if (Array)
824 FieldType = getContext().getBaseElementType(FieldType);
825
826 const RecordType *RT = FieldType->getAs<RecordType>();
827 CXXRecordDecl *FieldClassDecl = cast<CXXRecordDecl>(RT->getDecl());
828
829 llvm::Value *ThisPtr = LoadCXXThis();
830
831 LValue LHS = EmitLValueForField(ThisPtr, Field,
Anders Carlsson607d0372009-12-24 22:46:43 +0000832 // FIXME: Qualifiers?
833 /*CVRQualifiers=*/0);
834 if (Array) {
835 const llvm::Type *BasePtr = ConvertType(FieldType);
836 BasePtr = llvm::PointerType::getUnqual(BasePtr);
837 llvm::Value *BaseAddrPtr =
838 Builder.CreateBitCast(LHS.getAddress(), BasePtr);
Douglas Gregor1d110e02010-07-01 14:13:13 +0000839 EmitCXXAggrDestructorCall(FieldClassDecl->getDestructor(),
Anders Carlsson607d0372009-12-24 22:46:43 +0000840 Array, BaseAddrPtr);
841 } else
Douglas Gregor1d110e02010-07-01 14:13:13 +0000842 EmitCXXDestructorCall(FieldClassDecl->getDestructor(),
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000843 Dtor_Complete, /*ForVirtualBase=*/false,
844 LHS.getAddress());
Anders Carlsson607d0372009-12-24 22:46:43 +0000845 }
846
847 // Destroy non-virtual bases.
848 for (CXXRecordDecl::reverse_base_class_const_iterator I =
849 ClassDecl->bases_rbegin(), E = ClassDecl->bases_rend(); I != E; ++I) {
850 const CXXBaseSpecifier &Base = *I;
851
852 // Ignore virtual bases.
853 if (Base.isVirtual())
854 continue;
855
856 CXXRecordDecl *BaseClassDecl
857 = cast<CXXRecordDecl>(Base.getType()->getAs<RecordType>()->getDecl());
858
859 // Ignore trivial destructors.
860 if (BaseClassDecl->hasTrivialDestructor())
861 continue;
Anders Carlsson77fae582010-05-02 23:57:15 +0000862
Douglas Gregor1d110e02010-07-01 14:13:13 +0000863 const CXXDestructorDecl *D = BaseClassDecl->getDestructor();
Anders Carlsson77fae582010-05-02 23:57:15 +0000864 llvm::Value *V =
865 GetAddressOfDirectBaseInCompleteClass(LoadCXXThis(), ClassDecl,
866 BaseClassDecl,
867 /*BaseIsVirtual=*/false);
868
Anders Carlsson8e6404c2010-05-02 23:29:11 +0000869 EmitCXXDestructorCall(D, Dtor_Base, /*ForVirtualBase=*/false, V);
Anders Carlsson607d0372009-12-24 22:46:43 +0000870 }
Anders Carlsson607d0372009-12-24 22:46:43 +0000871}
872
Anders Carlsson3b5ad222010-01-01 20:29:01 +0000873/// EmitCXXAggrConstructorCall - This routine essentially creates a (nested)
874/// for-loop to call the default constructor on individual members of the
875/// array.
876/// 'D' is the default constructor for elements of the array, 'ArrayTy' is the
877/// array type and 'ArrayPtr' points to the beginning fo the array.
878/// It is assumed that all relevant checks have been made by the caller.
879void
880CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
881 const ConstantArrayType *ArrayTy,
882 llvm::Value *ArrayPtr,
883 CallExpr::const_arg_iterator ArgBeg,
884 CallExpr::const_arg_iterator ArgEnd) {
885
886 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
887 llvm::Value * NumElements =
888 llvm::ConstantInt::get(SizeTy,
889 getContext().getConstantArrayElementCount(ArrayTy));
890
891 EmitCXXAggrConstructorCall(D, NumElements, ArrayPtr, ArgBeg, ArgEnd);
892}
893
894void
895CodeGenFunction::EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
896 llvm::Value *NumElements,
897 llvm::Value *ArrayPtr,
898 CallExpr::const_arg_iterator ArgBeg,
899 CallExpr::const_arg_iterator ArgEnd) {
900 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
901
902 // Create a temporary for the loop index and initialize it with 0.
903 llvm::Value *IndexPtr = CreateTempAlloca(SizeTy, "loop.index");
904 llvm::Value *Zero = llvm::Constant::getNullValue(SizeTy);
905 Builder.CreateStore(Zero, IndexPtr);
906
907 // Start the loop with a block that tests the condition.
908 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
909 llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
910
911 EmitBlock(CondBlock);
912
913 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
914
915 // Generate: if (loop-index < number-of-elements fall to the loop body,
916 // otherwise, go to the block after the for-loop.
917 llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
918 llvm::Value *IsLess = Builder.CreateICmpULT(Counter, NumElements, "isless");
919 // If the condition is true, execute the body.
920 Builder.CreateCondBr(IsLess, ForBody, AfterFor);
921
922 EmitBlock(ForBody);
923
924 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
925 // Inside the loop body, emit the constructor call on the array element.
926 Counter = Builder.CreateLoad(IndexPtr);
927 llvm::Value *Address = Builder.CreateInBoundsGEP(ArrayPtr, Counter,
928 "arrayidx");
929
930 // C++ [class.temporary]p4:
931 // There are two contexts in which temporaries are destroyed at a different
932 // point than the end of the full-expression. The first context is when a
933 // default constructor is called to initialize an element of an array.
934 // If the constructor has one or more default arguments, the destruction of
935 // every temporary created in a default argument expression is sequenced
936 // before the construction of the next array element, if any.
937
938 // Keep track of the current number of live temporaries.
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000939 {
John McCallf1549f62010-07-06 01:34:17 +0000940 RunCleanupsScope Scope(*this);
Anders Carlsson3b5ad222010-01-01 20:29:01 +0000941
Anders Carlsson155ed4a2010-05-02 23:20:53 +0000942 EmitCXXConstructorCall(D, Ctor_Complete, /*ForVirtualBase=*/false, Address,
Anders Carlsson24eb78e2010-05-02 23:01:10 +0000943 ArgBeg, ArgEnd);
Anders Carlsson44ec82b2010-03-30 03:14:41 +0000944 }
Anders Carlsson3b5ad222010-01-01 20:29:01 +0000945
Anders Carlsson3b5ad222010-01-01 20:29:01 +0000946 EmitBlock(ContinueBlock);
947
948 // Emit the increment of the loop counter.
949 llvm::Value *NextVal = llvm::ConstantInt::get(SizeTy, 1);
950 Counter = Builder.CreateLoad(IndexPtr);
951 NextVal = Builder.CreateAdd(Counter, NextVal, "inc");
952 Builder.CreateStore(NextVal, IndexPtr);
953
954 // Finally, branch back up to the condition for the next iteration.
955 EmitBranch(CondBlock);
956
957 // Emit the fall-through block.
958 EmitBlock(AfterFor, true);
959}
960
961/// EmitCXXAggrDestructorCall - calls the default destructor on array
962/// elements in reverse order of construction.
963void
964CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
965 const ArrayType *Array,
966 llvm::Value *This) {
967 const ConstantArrayType *CA = dyn_cast<ConstantArrayType>(Array);
968 assert(CA && "Do we support VLA for destruction ?");
969 uint64_t ElementCount = getContext().getConstantArrayElementCount(CA);
970
971 const llvm::Type *SizeLTy = ConvertType(getContext().getSizeType());
972 llvm::Value* ElementCountPtr = llvm::ConstantInt::get(SizeLTy, ElementCount);
973 EmitCXXAggrDestructorCall(D, ElementCountPtr, This);
974}
975
976/// EmitCXXAggrDestructorCall - calls the default destructor on array
977/// elements in reverse order of construction.
978void
979CodeGenFunction::EmitCXXAggrDestructorCall(const CXXDestructorDecl *D,
980 llvm::Value *UpperCount,
981 llvm::Value *This) {
982 const llvm::Type *SizeLTy = ConvertType(getContext().getSizeType());
983 llvm::Value *One = llvm::ConstantInt::get(SizeLTy, 1);
984
985 // Create a temporary for the loop index and initialize it with count of
986 // array elements.
987 llvm::Value *IndexPtr = CreateTempAlloca(SizeLTy, "loop.index");
988
989 // Store the number of elements in the index pointer.
990 Builder.CreateStore(UpperCount, IndexPtr);
991
992 // Start the loop with a block that tests the condition.
993 llvm::BasicBlock *CondBlock = createBasicBlock("for.cond");
994 llvm::BasicBlock *AfterFor = createBasicBlock("for.end");
995
996 EmitBlock(CondBlock);
997
998 llvm::BasicBlock *ForBody = createBasicBlock("for.body");
999
1000 // Generate: if (loop-index != 0 fall to the loop body,
1001 // otherwise, go to the block after the for-loop.
1002 llvm::Value* zeroConstant =
1003 llvm::Constant::getNullValue(SizeLTy);
1004 llvm::Value *Counter = Builder.CreateLoad(IndexPtr);
1005 llvm::Value *IsNE = Builder.CreateICmpNE(Counter, zeroConstant,
1006 "isne");
1007 // If the condition is true, execute the body.
1008 Builder.CreateCondBr(IsNE, ForBody, AfterFor);
1009
1010 EmitBlock(ForBody);
1011
1012 llvm::BasicBlock *ContinueBlock = createBasicBlock("for.inc");
1013 // Inside the loop body, emit the constructor call on the array element.
1014 Counter = Builder.CreateLoad(IndexPtr);
1015 Counter = Builder.CreateSub(Counter, One);
1016 llvm::Value *Address = Builder.CreateInBoundsGEP(This, Counter, "arrayidx");
Anders Carlsson8e6404c2010-05-02 23:29:11 +00001017 EmitCXXDestructorCall(D, Dtor_Complete, /*ForVirtualBase=*/false, Address);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001018
1019 EmitBlock(ContinueBlock);
1020
1021 // Emit the decrement of the loop counter.
1022 Counter = Builder.CreateLoad(IndexPtr);
1023 Counter = Builder.CreateSub(Counter, One, "dec");
1024 Builder.CreateStore(Counter, IndexPtr);
1025
1026 // Finally, branch back up to the condition for the next iteration.
1027 EmitBranch(CondBlock);
1028
1029 // Emit the fall-through block.
1030 EmitBlock(AfterFor, true);
1031}
1032
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001033void
1034CodeGenFunction::EmitCXXConstructorCall(const CXXConstructorDecl *D,
Anders Carlsson155ed4a2010-05-02 23:20:53 +00001035 CXXCtorType Type, bool ForVirtualBase,
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001036 llvm::Value *This,
1037 CallExpr::const_arg_iterator ArgBeg,
1038 CallExpr::const_arg_iterator ArgEnd) {
John McCall8b6bbeb2010-02-06 00:25:16 +00001039 if (D->isTrivial()) {
1040 if (ArgBeg == ArgEnd) {
1041 // Trivial default constructor, no codegen required.
1042 assert(D->isDefaultConstructor() &&
1043 "trivial 0-arg ctor not a default ctor");
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001044 return;
1045 }
John McCall8b6bbeb2010-02-06 00:25:16 +00001046
1047 assert(ArgBeg + 1 == ArgEnd && "unexpected argcount for trivial ctor");
1048 assert(D->isCopyConstructor() && "trivial 1-arg ctor not a copy ctor");
1049
John McCall8b6bbeb2010-02-06 00:25:16 +00001050 const Expr *E = (*ArgBeg);
1051 QualType Ty = E->getType();
1052 llvm::Value *Src = EmitLValue(E).getAddress();
1053 EmitAggregateCopy(This, Src, Ty);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001054 return;
1055 }
1056
Anders Carlsson314e6222010-05-02 23:33:10 +00001057 llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(D, Type), ForVirtualBase);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001058 llvm::Value *Callee = CGM.GetAddrOfCXXConstructor(D, Type);
1059
Anders Carlssonc997d422010-01-02 01:01:18 +00001060 EmitCXXMemberCall(D, Callee, ReturnValueSlot(), This, VTT, ArgBeg, ArgEnd);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001061}
1062
John McCallc0bf4622010-02-23 00:48:20 +00001063void
1064CodeGenFunction::EmitDelegateCXXConstructorCall(const CXXConstructorDecl *Ctor,
1065 CXXCtorType CtorType,
1066 const FunctionArgList &Args) {
1067 CallArgList DelegateArgs;
1068
1069 FunctionArgList::const_iterator I = Args.begin(), E = Args.end();
1070 assert(I != E && "no parameters to constructor");
1071
1072 // this
1073 DelegateArgs.push_back(std::make_pair(RValue::get(LoadCXXThis()),
1074 I->second));
1075 ++I;
1076
1077 // vtt
Anders Carlsson314e6222010-05-02 23:33:10 +00001078 if (llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(Ctor, CtorType),
1079 /*ForVirtualBase=*/false)) {
John McCallc0bf4622010-02-23 00:48:20 +00001080 QualType VoidPP = getContext().getPointerType(getContext().VoidPtrTy);
1081 DelegateArgs.push_back(std::make_pair(RValue::get(VTT), VoidPP));
1082
Anders Carlssonaf440352010-03-23 04:11:45 +00001083 if (CodeGenVTables::needsVTTParameter(CurGD)) {
John McCallc0bf4622010-02-23 00:48:20 +00001084 assert(I != E && "cannot skip vtt parameter, already done with args");
1085 assert(I->second == VoidPP && "skipping parameter not of vtt type");
1086 ++I;
1087 }
1088 }
1089
1090 // Explicit arguments.
1091 for (; I != E; ++I) {
John McCallc0bf4622010-02-23 00:48:20 +00001092 const VarDecl *Param = I->first;
1093 QualType ArgType = Param->getType(); // because we're passing it to itself
John McCall27360712010-05-26 22:34:26 +00001094 RValue Arg = EmitDelegateCallArg(Param);
John McCallc0bf4622010-02-23 00:48:20 +00001095
1096 DelegateArgs.push_back(std::make_pair(Arg, ArgType));
1097 }
1098
1099 EmitCall(CGM.getTypes().getFunctionInfo(Ctor, CtorType),
1100 CGM.GetAddrOfCXXConstructor(Ctor, CtorType),
1101 ReturnValueSlot(), DelegateArgs, Ctor);
1102}
1103
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001104void CodeGenFunction::EmitCXXDestructorCall(const CXXDestructorDecl *DD,
1105 CXXDtorType Type,
Anders Carlsson8e6404c2010-05-02 23:29:11 +00001106 bool ForVirtualBase,
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001107 llvm::Value *This) {
Anders Carlsson314e6222010-05-02 23:33:10 +00001108 llvm::Value *VTT = GetVTTParameter(*this, GlobalDecl(DD, Type),
1109 ForVirtualBase);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001110 llvm::Value *Callee = CGM.GetAddrOfCXXDestructor(DD, Type);
1111
Anders Carlssonc997d422010-01-02 01:01:18 +00001112 EmitCXXMemberCall(DD, Callee, ReturnValueSlot(), This, VTT, 0, 0);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001113}
1114
John McCallf1549f62010-07-06 01:34:17 +00001115void CodeGenFunction::PushDestructorCleanup(QualType T, llvm::Value *Addr) {
1116 CXXRecordDecl *ClassDecl = T->getAsCXXRecordDecl();
1117 if (!ClassDecl) return;
1118 if (ClassDecl->hasTrivialDestructor()) return;
1119
1120 const CXXDestructorDecl *D = ClassDecl->getDestructor();
1121
1122 CleanupBlock Scope(*this, NormalCleanup);
1123
1124 EmitCXXDestructorCall(D, Dtor_Complete, /*ForVirtualBase=*/false, Addr);
1125
1126 if (Exceptions) {
1127 Scope.beginEHCleanup();
1128 EmitCXXDestructorCall(D, Dtor_Complete, /*ForVirtualBase=*/false, Addr);
1129 }
1130}
1131
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001132llvm::Value *
Anders Carlssonbb7e17b2010-01-31 01:36:53 +00001133CodeGenFunction::GetVirtualBaseClassOffset(llvm::Value *This,
1134 const CXXRecordDecl *ClassDecl,
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001135 const CXXRecordDecl *BaseClassDecl) {
1136 const llvm::Type *Int8PtrTy =
1137 llvm::Type::getInt8Ty(VMContext)->getPointerTo();
1138
1139 llvm::Value *VTablePtr = Builder.CreateBitCast(This,
1140 Int8PtrTy->getPointerTo());
1141 VTablePtr = Builder.CreateLoad(VTablePtr, "vtable");
1142
Anders Carlssonbba16072010-03-11 07:15:17 +00001143 int64_t VBaseOffsetOffset =
Anders Carlssonaf440352010-03-23 04:11:45 +00001144 CGM.getVTables().getVirtualBaseOffsetOffset(ClassDecl, BaseClassDecl);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001145
1146 llvm::Value *VBaseOffsetPtr =
Anders Carlssonbba16072010-03-11 07:15:17 +00001147 Builder.CreateConstGEP1_64(VTablePtr, VBaseOffsetOffset, "vbase.offset.ptr");
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001148 const llvm::Type *PtrDiffTy =
1149 ConvertType(getContext().getPointerDiffType());
1150
1151 VBaseOffsetPtr = Builder.CreateBitCast(VBaseOffsetPtr,
1152 PtrDiffTy->getPointerTo());
1153
1154 llvm::Value *VBaseOffset = Builder.CreateLoad(VBaseOffsetPtr, "vbase.offset");
1155
1156 return VBaseOffset;
1157}
1158
Anders Carlssond103f9f2010-03-28 19:40:00 +00001159void
1160CodeGenFunction::InitializeVTablePointer(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001161 const CXXRecordDecl *NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +00001162 uint64_t OffsetFromNearestVBase,
Anders Carlssond103f9f2010-03-28 19:40:00 +00001163 llvm::Constant *VTable,
1164 const CXXRecordDecl *VTableClass) {
Anders Carlssonc83f1062010-03-29 01:08:49 +00001165 const CXXRecordDecl *RD = Base.getBase();
1166
Anders Carlssond103f9f2010-03-28 19:40:00 +00001167 // Compute the address point.
Anders Carlssonc83f1062010-03-29 01:08:49 +00001168 llvm::Value *VTableAddressPoint;
Anders Carlsson851853d2010-03-29 02:38:51 +00001169
Anders Carlssonc83f1062010-03-29 01:08:49 +00001170 // Check if we need to use a vtable from the VTT.
Anders Carlsson851853d2010-03-29 02:38:51 +00001171 if (CodeGenVTables::needsVTTParameter(CurGD) &&
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001172 (RD->getNumVBases() || NearestVBase)) {
Anders Carlssonc83f1062010-03-29 01:08:49 +00001173 // Get the secondary vpointer index.
1174 uint64_t VirtualPointerIndex =
1175 CGM.getVTables().getSecondaryVirtualPointerIndex(VTableClass, Base);
1176
1177 /// Load the VTT.
1178 llvm::Value *VTT = LoadCXXVTT();
1179 if (VirtualPointerIndex)
1180 VTT = Builder.CreateConstInBoundsGEP1_64(VTT, VirtualPointerIndex);
1181
1182 // And load the address point from the VTT.
1183 VTableAddressPoint = Builder.CreateLoad(VTT);
1184 } else {
Anders Carlsson64c9eca2010-03-29 02:08:26 +00001185 uint64_t AddressPoint = CGM.getVTables().getAddressPoint(Base, VTableClass);
Anders Carlssonc83f1062010-03-29 01:08:49 +00001186 VTableAddressPoint =
Anders Carlssond103f9f2010-03-28 19:40:00 +00001187 Builder.CreateConstInBoundsGEP2_64(VTable, 0, AddressPoint);
Anders Carlssonc83f1062010-03-29 01:08:49 +00001188 }
Anders Carlssond103f9f2010-03-28 19:40:00 +00001189
Anders Carlsson36fd6be2010-04-20 16:22:16 +00001190 // Compute where to store the address point.
Anders Carlsson8246cc72010-05-03 00:29:58 +00001191 llvm::Value *VirtualOffset = 0;
1192 uint64_t NonVirtualOffset = 0;
Anders Carlsson3e79c302010-04-20 18:05:10 +00001193
1194 if (CodeGenVTables::needsVTTParameter(CurGD) && NearestVBase) {
1195 // We need to use the virtual base offset offset because the virtual base
1196 // might have a different offset in the most derived class.
Anders Carlsson8246cc72010-05-03 00:29:58 +00001197 VirtualOffset = GetVirtualBaseClassOffset(LoadCXXThis(), VTableClass,
1198 NearestVBase);
1199 NonVirtualOffset = OffsetFromNearestVBase / 8;
Anders Carlsson3e79c302010-04-20 18:05:10 +00001200 } else {
Anders Carlsson8246cc72010-05-03 00:29:58 +00001201 // We can just use the base offset in the complete class.
1202 NonVirtualOffset = Base.getBaseOffset() / 8;
Anders Carlsson3e79c302010-04-20 18:05:10 +00001203 }
Anders Carlsson8246cc72010-05-03 00:29:58 +00001204
1205 // Apply the offsets.
1206 llvm::Value *VTableField = LoadCXXThis();
1207
1208 if (NonVirtualOffset || VirtualOffset)
1209 VTableField = ApplyNonVirtualAndVirtualOffset(*this, VTableField,
1210 NonVirtualOffset,
1211 VirtualOffset);
Anders Carlsson36fd6be2010-04-20 16:22:16 +00001212
Anders Carlssond103f9f2010-03-28 19:40:00 +00001213 // Finally, store the address point.
1214 const llvm::Type *AddressPointPtrTy =
1215 VTableAddressPoint->getType()->getPointerTo();
1216 VTableField = Builder.CreateBitCast(VTableField, AddressPointPtrTy);
1217 Builder.CreateStore(VTableAddressPoint, VTableField);
1218}
1219
Anders Carlsson603d6d12010-03-28 21:07:49 +00001220void
1221CodeGenFunction::InitializeVTablePointers(BaseSubobject Base,
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001222 const CXXRecordDecl *NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +00001223 uint64_t OffsetFromNearestVBase,
Anders Carlsson603d6d12010-03-28 21:07:49 +00001224 bool BaseIsNonVirtualPrimaryBase,
1225 llvm::Constant *VTable,
1226 const CXXRecordDecl *VTableClass,
1227 VisitedVirtualBasesSetTy& VBases) {
1228 // If this base is a non-virtual primary base the address point has already
1229 // been set.
1230 if (!BaseIsNonVirtualPrimaryBase) {
1231 // Initialize the vtable pointer for this base.
Anders Carlsson42358402010-05-03 00:07:07 +00001232 InitializeVTablePointer(Base, NearestVBase, OffsetFromNearestVBase,
1233 VTable, VTableClass);
Anders Carlsson603d6d12010-03-28 21:07:49 +00001234 }
1235
1236 const CXXRecordDecl *RD = Base.getBase();
1237
1238 // Traverse bases.
1239 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1240 E = RD->bases_end(); I != E; ++I) {
1241 CXXRecordDecl *BaseDecl
1242 = cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1243
1244 // Ignore classes without a vtable.
1245 if (!BaseDecl->isDynamicClass())
1246 continue;
1247
1248 uint64_t BaseOffset;
Anders Carlsson42358402010-05-03 00:07:07 +00001249 uint64_t BaseOffsetFromNearestVBase;
Anders Carlsson14da9de2010-03-29 01:16:41 +00001250 bool BaseDeclIsNonVirtualPrimaryBase;
Anders Carlsson603d6d12010-03-28 21:07:49 +00001251
1252 if (I->isVirtual()) {
1253 // Check if we've visited this virtual base before.
1254 if (!VBases.insert(BaseDecl))
1255 continue;
1256
1257 const ASTRecordLayout &Layout =
1258 getContext().getASTRecordLayout(VTableClass);
1259
Anders Carlsson603d6d12010-03-28 21:07:49 +00001260 BaseOffset = Layout.getVBaseClassOffset(BaseDecl);
Anders Carlsson42358402010-05-03 00:07:07 +00001261 BaseOffsetFromNearestVBase = 0;
Anders Carlsson14da9de2010-03-29 01:16:41 +00001262 BaseDeclIsNonVirtualPrimaryBase = false;
Anders Carlsson603d6d12010-03-28 21:07:49 +00001263 } else {
1264 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
1265
1266 BaseOffset = Base.getBaseOffset() + Layout.getBaseClassOffset(BaseDecl);
Anders Carlsson42358402010-05-03 00:07:07 +00001267 BaseOffsetFromNearestVBase =
Anders Carlsson8246cc72010-05-03 00:29:58 +00001268 OffsetFromNearestVBase + Layout.getBaseClassOffset(BaseDecl);
Anders Carlsson14da9de2010-03-29 01:16:41 +00001269 BaseDeclIsNonVirtualPrimaryBase = Layout.getPrimaryBase() == BaseDecl;
Anders Carlsson603d6d12010-03-28 21:07:49 +00001270 }
1271
1272 InitializeVTablePointers(BaseSubobject(BaseDecl, BaseOffset),
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001273 I->isVirtual() ? BaseDecl : NearestVBase,
Anders Carlsson42358402010-05-03 00:07:07 +00001274 BaseOffsetFromNearestVBase,
Anders Carlsson14da9de2010-03-29 01:16:41 +00001275 BaseDeclIsNonVirtualPrimaryBase,
Anders Carlsson603d6d12010-03-28 21:07:49 +00001276 VTable, VTableClass, VBases);
1277 }
1278}
1279
1280void CodeGenFunction::InitializeVTablePointers(const CXXRecordDecl *RD) {
1281 // Ignore classes without a vtable.
Anders Carlsson07036902010-03-26 04:39:42 +00001282 if (!RD->isDynamicClass())
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001283 return;
1284
Anders Carlsson07036902010-03-26 04:39:42 +00001285 // Get the VTable.
1286 llvm::Constant *VTable = CGM.getVTables().GetAddrOfVTable(RD);
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00001287
Anders Carlsson603d6d12010-03-28 21:07:49 +00001288 // Initialize the vtable pointers for this class and all of its bases.
1289 VisitedVirtualBasesSetTy VBases;
Anders Carlssonb3b772e2010-04-20 05:22:15 +00001290 InitializeVTablePointers(BaseSubobject(RD, 0), /*NearestVBase=*/0,
Anders Carlsson42358402010-05-03 00:07:07 +00001291 /*OffsetFromNearestVBase=*/0,
Anders Carlsson603d6d12010-03-28 21:07:49 +00001292 /*BaseIsNonVirtualPrimaryBase=*/false,
1293 VTable, RD, VBases);
Anders Carlsson3b5ad222010-01-01 20:29:01 +00001294}