blob: 0c36ef492b39c1ad08da1e2f40cb4e665b7ca415 [file] [log] [blame]
Anders Carlssondbd920c2009-10-11 22:13:54 +00001//===--- CGVtable.cpp - Emit LLVM Code for C++ vtables --------------------===//
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 of virtual tables.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
15#include "CodeGenFunction.h"
16
17#include "clang/AST/RecordLayout.h"
Zhongxing Xu7fe26ac2009-11-13 05:46:16 +000018#include <cstdio>
Anders Carlssondbd920c2009-10-11 22:13:54 +000019
20using namespace clang;
21using namespace CodeGen;
22
23class VtableBuilder {
24public:
25 /// Index_t - Vtable index type.
26 typedef uint64_t Index_t;
27private:
28 std::vector<llvm::Constant *> &methods;
29 std::vector<llvm::Constant *> submethods;
30 llvm::Type *Ptr8Ty;
31 /// Class - The most derived class that this vtable is being built for.
32 const CXXRecordDecl *Class;
Mike Stumpacfd1e52009-11-13 01:54:23 +000033 /// LayoutClass - The most derived class used for virtual base layout
34 /// information.
35 const CXXRecordDecl *LayoutClass;
Mike Stump4cde6262009-11-13 02:13:54 +000036 /// LayoutOffset - The offset for Class in LayoutClass.
37 uint64_t LayoutOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +000038 /// BLayout - Layout for the most derived class that this vtable is being
39 /// built for.
40 const ASTRecordLayout &BLayout;
41 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
42 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
43 llvm::Constant *rtti;
44 llvm::LLVMContext &VMContext;
45 CodeGenModule &CGM; // Per-module state.
46 /// Index - Maps a method decl into a vtable index. Useful for virtual
47 /// dispatch codegen.
Anders Carlssona0fdd912009-11-13 17:08:56 +000048 llvm::DenseMap<GlobalDecl, Index_t> Index;
49 llvm::DenseMap<GlobalDecl, Index_t> VCall;
50 llvm::DenseMap<GlobalDecl, Index_t> VCallOffset;
Mike Stump9e7e3c62009-11-06 23:27:42 +000051 // This is the offset to the nearest virtual base
Anders Carlssona0fdd912009-11-13 17:08:56 +000052 llvm::DenseMap<GlobalDecl, Index_t> NonVirtualOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +000053 llvm::DenseMap<const CXXRecordDecl *, Index_t> VBIndex;
Mike Stump94aff932009-10-27 23:46:47 +000054
Anders Carlssona0fdd912009-11-13 17:08:56 +000055 typedef llvm::DenseMap<GlobalDecl, int> Pures_t;
Mike Stump94aff932009-10-27 23:46:47 +000056 Pures_t Pures;
Anders Carlssondbd920c2009-10-11 22:13:54 +000057 typedef std::pair<Index_t, Index_t> CallOffset;
Anders Carlssona0fdd912009-11-13 17:08:56 +000058 typedef llvm::DenseMap<GlobalDecl, CallOffset> Thunks_t;
Anders Carlssondbd920c2009-10-11 22:13:54 +000059 Thunks_t Thunks;
Anders Carlssona0fdd912009-11-13 17:08:56 +000060 typedef llvm::DenseMap<GlobalDecl,
Mike Stumpd9878a12009-10-13 10:55:21 +000061 std::pair<std::pair<CallOffset, CallOffset>,
62 CanQualType> > CovariantThunks_t;
Anders Carlssondbd920c2009-10-11 22:13:54 +000063 CovariantThunks_t CovariantThunks;
64 std::vector<Index_t> VCalls;
Mike Stump9840c702009-11-12 20:47:57 +000065
66 typedef std::pair<const CXXRecordDecl *, uint64_t> CtorVtable_t;
Mike Stump23a35422009-11-19 20:52:19 +000067 // subAddressPoints - Used to hold the AddressPoints (offsets) into the built
68 // vtable for use in computing the initializers for the VTT.
69 llvm::DenseMap<CtorVtable_t, int64_t> &subAddressPoints;
Mike Stump9840c702009-11-12 20:47:57 +000070
Anders Carlssondbd920c2009-10-11 22:13:54 +000071 typedef CXXRecordDecl::method_iterator method_iter;
Anders Carlssondbd920c2009-10-11 22:13:54 +000072 const bool Extern;
73 const uint32_t LLVMPointerWidth;
74 Index_t extra;
Mike Stump11dea942009-10-15 02:04:03 +000075 typedef std::vector<std::pair<const CXXRecordDecl *, int64_t> > Path_t;
Mike Stump94aff932009-10-27 23:46:47 +000076 llvm::Constant *cxa_pure;
Mike Stump23a35422009-11-19 20:52:19 +000077 static llvm::DenseMap<CtorVtable_t, int64_t>&
78 AllocAddressPoint(CodeGenModule &cgm, const CXXRecordDecl *l,
79 const CXXRecordDecl *c) {
80 CodeGenModule::AddrMap_t *&oref = cgm.AddressPoints[l];
81 if (oref == 0)
82 oref = new CodeGenModule::AddrMap_t;
83
84 llvm::DenseMap<CtorVtable_t, int64_t> *&ref = (*oref)[c];
85 if (ref == 0)
86 ref = new llvm::DenseMap<CtorVtable_t, int64_t>;
87 return *ref;
88 }
Anders Carlssondbd920c2009-10-11 22:13:54 +000089public:
Mike Stump4cde6262009-11-13 02:13:54 +000090 VtableBuilder(std::vector<llvm::Constant *> &meth, const CXXRecordDecl *c,
91 const CXXRecordDecl *l, uint64_t lo, CodeGenModule &cgm)
92 : methods(meth), Class(c), LayoutClass(l), LayoutOffset(lo),
Mike Stumpacfd1e52009-11-13 01:54:23 +000093 BLayout(cgm.getContext().getASTRecordLayout(l)),
Mike Stumpcbcd4e52009-11-14 23:32:21 +000094 rtti(cgm.GenerateRttiRef(c)), VMContext(cgm.getModule().getContext()),
Mike Stump23a35422009-11-19 20:52:19 +000095 CGM(cgm), subAddressPoints(AllocAddressPoint(cgm, l, c)),
Mike Stump6be2b172009-11-19 00:49:05 +000096 Extern(!l->isInAnonymousNamespace()),
Mike Stump9e7e3c62009-11-06 23:27:42 +000097 LLVMPointerWidth(cgm.getContext().Target.getPointerWidth(0)) {
Anders Carlssondbd920c2009-10-11 22:13:54 +000098 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
Mike Stump7809e0d2009-10-28 00:35:46 +000099
100 // Calculate pointer for ___cxa_pure_virtual.
101 const llvm::FunctionType *FTy;
102 std::vector<const llvm::Type*> ArgTys;
103 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
104 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
105 cxa_pure = wrap(CGM.CreateRuntimeFunction(FTy, "__cxa_pure_virtual"));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000106 }
107
Anders Carlssona0fdd912009-11-13 17:08:56 +0000108 llvm::DenseMap<GlobalDecl, Index_t> &getIndex() { return Index; }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000109 llvm::DenseMap<const CXXRecordDecl *, Index_t> &getVBIndex()
110 { return VBIndex; }
111
112 llvm::Constant *wrap(Index_t i) {
113 llvm::Constant *m;
114 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i);
115 return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
116 }
117
118 llvm::Constant *wrap(llvm::Constant *m) {
119 return llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
120 }
121
Mike Stump80ac2352009-11-12 23:36:21 +0000122//#define D1(x)
123#define D1(X) do { if (getenv("DEBUG")) { X; } } while (0)
Mike Stump6a9612f2009-10-31 20:06:59 +0000124
125 void GenerateVBaseOffsets(const CXXRecordDecl *RD, uint64_t Offset,
Mike Stumpab28c132009-10-13 22:54:56 +0000126 bool updateVBIndex, Index_t current_vbindex) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000127 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
128 e = RD->bases_end(); i != e; ++i) {
129 const CXXRecordDecl *Base =
130 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stumpab28c132009-10-13 22:54:56 +0000131 Index_t next_vbindex = current_vbindex;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000132 if (i->isVirtual() && !SeenVBase.count(Base)) {
133 SeenVBase.insert(Base);
Mike Stumpab28c132009-10-13 22:54:56 +0000134 if (updateVBIndex) {
Mike Stump6a9612f2009-10-31 20:06:59 +0000135 next_vbindex = (ssize_t)(-(VCalls.size()*LLVMPointerWidth/8)
Mike Stumpab28c132009-10-13 22:54:56 +0000136 - 3*LLVMPointerWidth/8);
137 VBIndex[Base] = next_vbindex;
138 }
Mike Stump6a9612f2009-10-31 20:06:59 +0000139 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
140 VCalls.push_back((0?700:0) + BaseOffset);
141 D1(printf(" vbase for %s at %d delta %d most derived %s\n",
142 Base->getNameAsCString(),
143 (int)-VCalls.size()-3, (int)BaseOffset,
144 Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000145 }
Mike Stumpab28c132009-10-13 22:54:56 +0000146 // We also record offsets for non-virtual bases to closest enclosing
147 // virtual base. We do this so that we don't have to search
148 // for the nearst virtual base class when generating thunks.
149 if (updateVBIndex && VBIndex.count(Base) == 0)
150 VBIndex[Base] = next_vbindex;
Mike Stump6a9612f2009-10-31 20:06:59 +0000151 GenerateVBaseOffsets(Base, Offset, updateVBIndex, next_vbindex);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000152 }
153 }
154
155 void StartNewTable() {
156 SeenVBase.clear();
157 }
158
159 Index_t VBlookup(CXXRecordDecl *D, CXXRecordDecl *B);
160
Mike Stump3425b972009-10-15 09:30:16 +0000161 Index_t getNVOffset_1(const CXXRecordDecl *D, const CXXRecordDecl *B,
162 Index_t Offset = 0) {
163
164 if (B == D)
165 return Offset;
166
167 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(D);
168 for (CXXRecordDecl::base_class_const_iterator i = D->bases_begin(),
169 e = D->bases_end(); i != e; ++i) {
170 const CXXRecordDecl *Base =
171 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
172 int64_t BaseOffset = 0;
173 if (!i->isVirtual())
174 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
175 int64_t o = getNVOffset_1(Base, B, BaseOffset);
176 if (o >= 0)
177 return o;
178 }
179
180 return -1;
181 }
182
183 /// getNVOffset - Returns the non-virtual offset for the given (B) base of the
184 /// derived class D.
185 Index_t getNVOffset(QualType qB, QualType qD) {
Mike Stump9c212892009-11-03 19:03:17 +0000186 qD = qD->getPointeeType();
187 qB = qB->getPointeeType();
Mike Stump3425b972009-10-15 09:30:16 +0000188 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
189 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
190 int64_t o = getNVOffset_1(D, B);
191 if (o >= 0)
192 return o;
193
194 assert(false && "FIXME: non-virtual base not found");
195 return 0;
196 }
197
Anders Carlssondbd920c2009-10-11 22:13:54 +0000198 /// getVbaseOffset - Returns the index into the vtable for the virtual base
199 /// offset for the given (B) virtual base of the derived class D.
200 Index_t getVbaseOffset(QualType qB, QualType qD) {
Mike Stump9c212892009-11-03 19:03:17 +0000201 qD = qD->getPointeeType();
202 qB = qB->getPointeeType();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000203 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
204 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
205 if (D != Class)
206 return VBlookup(D, B);
207 llvm::DenseMap<const CXXRecordDecl *, Index_t>::iterator i;
208 i = VBIndex.find(B);
209 if (i != VBIndex.end())
210 return i->second;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000211
Mike Stumpab28c132009-10-13 22:54:56 +0000212 assert(false && "FIXME: Base not found");
Anders Carlssondbd920c2009-10-11 22:13:54 +0000213 return 0;
214 }
215
Anders Carlssona0fdd912009-11-13 17:08:56 +0000216 bool OverrideMethod(GlobalDecl GD, llvm::Constant *m,
Mike Stump3425b972009-10-15 09:30:16 +0000217 bool MorallyVirtual, Index_t OverrideOffset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000218 Index_t Offset, int64_t CurrentVBaseOffset) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000219 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
220
Mike Stump7809e0d2009-10-28 00:35:46 +0000221 const bool isPure = MD->isPure();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000222 typedef CXXMethodDecl::method_iterator meth_iter;
Mike Stump3425b972009-10-15 09:30:16 +0000223 // FIXME: Should OverrideOffset's be Offset?
Anders Carlssondbd920c2009-10-11 22:13:54 +0000224
225 // FIXME: Don't like the nested loops. For very large inheritance
226 // heirarchies we could have a table on the side with the final overridder
227 // and just replace each instance of an overridden method once. Would be
228 // nice to measure the cost/benefit on real code.
229
230 for (meth_iter mi = MD->begin_overridden_methods(),
231 e = MD->end_overridden_methods();
232 mi != e; ++mi) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000233 GlobalDecl OGD;
234
Anders Carlssondbd920c2009-10-11 22:13:54 +0000235 const CXXMethodDecl *OMD = *mi;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000236 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(OMD))
237 OGD = GlobalDecl(DD, GD.getDtorType());
238 else
239 OGD = OMD;
240
Anders Carlssondbd920c2009-10-11 22:13:54 +0000241 llvm::Constant *om;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000242 om = WrapAddrOf(OGD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000243 om = llvm::ConstantExpr::getBitCast(om, Ptr8Ty);
244
245 for (Index_t i = 0, e = submethods.size();
246 i != e; ++i) {
247 // FIXME: begin_overridden_methods might be too lax, covariance */
248 if (submethods[i] != om)
249 continue;
250 QualType nc_oret = OMD->getType()->getAs<FunctionType>()->getResultType();
251 CanQualType oret = CGM.getContext().getCanonicalType(nc_oret);
252 QualType nc_ret = MD->getType()->getAs<FunctionType>()->getResultType();
253 CanQualType ret = CGM.getContext().getCanonicalType(nc_ret);
254 CallOffset ReturnOffset = std::make_pair(0, 0);
255 if (oret != ret) {
256 // FIXME: calculate offsets for covariance
Mike Stumpd9878a12009-10-13 10:55:21 +0000257 if (CovariantThunks.count(OMD)) {
258 oret = CovariantThunks[OMD].second;
259 CovariantThunks.erase(OMD);
260 }
Mike Stump3425b972009-10-15 09:30:16 +0000261 // FIXME: Double check oret
262 Index_t nv = getNVOffset(oret, ret)/8;
Mike Stumpd9878a12009-10-13 10:55:21 +0000263 ReturnOffset = std::make_pair(nv, getVbaseOffset(oret, ret));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000264 }
Anders Carlssona0fdd912009-11-13 17:08:56 +0000265 Index[GD] = i;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000266 submethods[i] = m;
Mike Stump7809e0d2009-10-28 00:35:46 +0000267 if (isPure)
Anders Carlssona0fdd912009-11-13 17:08:56 +0000268 Pures[GD] = 1;
269 Pures.erase(OGD);
270 Thunks.erase(OGD);
271 if (MorallyVirtual || VCall.count(OGD)) {
272 Index_t &idx = VCall[OGD];
Anders Carlssondbd920c2009-10-11 22:13:54 +0000273 if (idx == 0) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000274 NonVirtualOffset[GD] = -OverrideOffset/8 + CurrentVBaseOffset/8;
275 VCallOffset[GD] = OverrideOffset/8;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000276 idx = VCalls.size()+1;
277 VCalls.push_back(0);
Mike Stump6a9612f2009-10-31 20:06:59 +0000278 D1(printf(" vcall for %s at %d with delta %d most derived %s\n",
Mike Stumpe99cc452009-11-13 23:45:53 +0000279 MD->getNameAsString().c_str(), (int)-idx-3,
280 (int)VCalls[idx-1], Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000281 } else {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000282 NonVirtualOffset[GD] = NonVirtualOffset[OGD];
283 VCallOffset[GD] = VCallOffset[OGD];
284 VCalls[idx-1] = -VCallOffset[OGD] + OverrideOffset/8;
Mike Stump6a9612f2009-10-31 20:06:59 +0000285 D1(printf(" vcall patch for %s at %d with delta %d most derived %s\n",
Mike Stumpe99cc452009-11-13 23:45:53 +0000286 MD->getNameAsString().c_str(), (int)-idx-3,
287 (int)VCalls[idx-1], Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000288 }
Anders Carlssona0fdd912009-11-13 17:08:56 +0000289 VCall[GD] = idx;
290 int64_t O = NonVirtualOffset[GD];
Mike Stump9e7e3c62009-11-06 23:27:42 +0000291 int v = -((idx+extra+2)*LLVMPointerWidth/8);
292 // Optimize out virtual adjustments of 0.
293 if (VCalls[idx-1] == 0)
294 v = 0;
295 CallOffset ThisOffset = std::make_pair(O, v);
Mike Stump11dea942009-10-15 02:04:03 +0000296 // FIXME: Do we always have to build a covariant thunk to save oret,
297 // which is the containing virtual base class?
Anders Carlssondbd920c2009-10-11 22:13:54 +0000298 if (ReturnOffset.first || ReturnOffset.second)
Anders Carlssona0fdd912009-11-13 17:08:56 +0000299 CovariantThunks[GD] = std::make_pair(std::make_pair(ThisOffset,
Mike Stumpd9878a12009-10-13 10:55:21 +0000300 ReturnOffset),
301 oret);
Mike Stump9e7e3c62009-11-06 23:27:42 +0000302 else if (!isPure && (ThisOffset.first || ThisOffset.second))
Anders Carlssona0fdd912009-11-13 17:08:56 +0000303 Thunks[GD] = ThisOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000304 return true;
305 }
Mike Stumpab28c132009-10-13 22:54:56 +0000306
Anders Carlssondbd920c2009-10-11 22:13:54 +0000307 // FIXME: finish off
Anders Carlssona0fdd912009-11-13 17:08:56 +0000308 int64_t O = VCallOffset[OGD] - OverrideOffset/8;
Mike Stump33c530e2009-11-06 02:38:24 +0000309
Mike Stumpab28c132009-10-13 22:54:56 +0000310 if (O || ReturnOffset.first || ReturnOffset.second) {
311 CallOffset ThisOffset = std::make_pair(O, 0);
312
313 if (ReturnOffset.first || ReturnOffset.second)
Anders Carlssona0fdd912009-11-13 17:08:56 +0000314 CovariantThunks[GD] = std::make_pair(std::make_pair(ThisOffset,
Mike Stumpab28c132009-10-13 22:54:56 +0000315 ReturnOffset),
316 oret);
Mike Stump7809e0d2009-10-28 00:35:46 +0000317 else if (!isPure)
Anders Carlssona0fdd912009-11-13 17:08:56 +0000318 Thunks[GD] = ThisOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000319 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000320 return true;
321 }
322 }
323
324 return false;
325 }
326
327 void InstallThunks() {
328 for (Thunks_t::iterator i = Thunks.begin(), e = Thunks.end();
329 i != e; ++i) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000330 GlobalDecl GD = i->first;
331 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Mike Stump7809e0d2009-10-28 00:35:46 +0000332 assert(!MD->isPure() && "Trying to thunk a pure");
Anders Carlssona0fdd912009-11-13 17:08:56 +0000333 Index_t idx = Index[GD];
Anders Carlssondbd920c2009-10-11 22:13:54 +0000334 Index_t nv_O = i->second.first;
335 Index_t v_O = i->second.second;
336 submethods[idx] = CGM.BuildThunk(MD, Extern, nv_O, v_O);
337 }
338 Thunks.clear();
339 for (CovariantThunks_t::iterator i = CovariantThunks.begin(),
340 e = CovariantThunks.end();
341 i != e; ++i) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000342 GlobalDecl GD = i->first;
343 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Mike Stump7809e0d2009-10-28 00:35:46 +0000344 if (MD->isPure())
345 continue;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000346 Index_t idx = Index[GD];
Mike Stumpd9878a12009-10-13 10:55:21 +0000347 Index_t nv_t = i->second.first.first.first;
348 Index_t v_t = i->second.first.first.second;
349 Index_t nv_r = i->second.first.second.first;
350 Index_t v_r = i->second.first.second.second;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000351 submethods[idx] = CGM.BuildCovariantThunk(MD, Extern, nv_t, v_t, nv_r,
352 v_r);
353 }
354 CovariantThunks.clear();
Mike Stump94aff932009-10-27 23:46:47 +0000355 for (Pures_t::iterator i = Pures.begin(), e = Pures.end();
356 i != e; ++i) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000357 GlobalDecl GD = i->first;
358 Index_t idx = Index[GD];
Mike Stump94aff932009-10-27 23:46:47 +0000359 submethods[idx] = cxa_pure;
360 }
361 Pures.clear();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000362 }
363
Anders Carlssona0fdd912009-11-13 17:08:56 +0000364 llvm::Constant *WrapAddrOf(GlobalDecl GD) {
365 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
366
Mike Stump1ae31782009-10-27 23:36:26 +0000367 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD))
Anders Carlssona0fdd912009-11-13 17:08:56 +0000368 return wrap(CGM.GetAddrOfCXXDestructor(Dtor, GD.getDtorType()));
Mike Stump1ae31782009-10-27 23:36:26 +0000369
Anders Carlssonecf282b2009-11-24 05:08:52 +0000370 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVtable(MD);
Mike Stump1ae31782009-10-27 23:36:26 +0000371
372 return wrap(CGM.GetAddrOfFunction(MD, Ty));
373 }
374
Mike Stump9e7e3c62009-11-06 23:27:42 +0000375 void OverrideMethods(Path_t *Path, bool MorallyVirtual, int64_t Offset,
376 int64_t CurrentVBaseOffset) {
Mike Stump11dea942009-10-15 02:04:03 +0000377 for (Path_t::reverse_iterator i = Path->rbegin(),
Anders Carlssondbd920c2009-10-11 22:13:54 +0000378 e = Path->rend(); i != e; ++i) {
379 const CXXRecordDecl *RD = i->first;
Mike Stump3425b972009-10-15 09:30:16 +0000380 int64_t OverrideOffset = i->second;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000381 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
382 ++mi) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000383 const CXXMethodDecl *MD = *mi;
384
385 if (!MD->isVirtual())
Anders Carlssondbd920c2009-10-11 22:13:54 +0000386 continue;
387
Anders Carlssona0fdd912009-11-13 17:08:56 +0000388 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
389 // Override both the complete and the deleting destructor.
390 GlobalDecl CompDtor(DD, Dtor_Complete);
391 OverrideMethod(CompDtor, WrapAddrOf(CompDtor), MorallyVirtual,
392 OverrideOffset, Offset, CurrentVBaseOffset);
393
394 GlobalDecl DeletingDtor(DD, Dtor_Deleting);
395 OverrideMethod(DeletingDtor, WrapAddrOf(DeletingDtor), MorallyVirtual,
396 OverrideOffset, Offset, CurrentVBaseOffset);
397 } else {
398 OverrideMethod(MD, WrapAddrOf(MD), MorallyVirtual, OverrideOffset,
399 Offset, CurrentVBaseOffset);
400 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000401 }
402 }
403 }
404
Anders Carlssona0fdd912009-11-13 17:08:56 +0000405 void AddMethod(const GlobalDecl GD, bool MorallyVirtual, Index_t Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000406 bool ForVirtualBase, int64_t CurrentVBaseOffset) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000407 llvm::Constant *m = WrapAddrOf(GD);
Mike Stump1ae31782009-10-27 23:36:26 +0000408
Anders Carlssondbd920c2009-10-11 22:13:54 +0000409 // If we can find a previously allocated slot for this, reuse it.
Anders Carlssona0fdd912009-11-13 17:08:56 +0000410 if (OverrideMethod(GD, m, MorallyVirtual, Offset, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000411 CurrentVBaseOffset))
Anders Carlssondbd920c2009-10-11 22:13:54 +0000412 return;
413
Anders Carlssona0fdd912009-11-13 17:08:56 +0000414 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
415
Anders Carlssondbd920c2009-10-11 22:13:54 +0000416 // else allocate a new slot.
Anders Carlssona0fdd912009-11-13 17:08:56 +0000417 Index[GD] = submethods.size();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000418 submethods.push_back(m);
Mike Stumpe99cc452009-11-13 23:45:53 +0000419 D1(printf(" vfn for %s at %d\n", MD->getNameAsString().c_str(),
420 (int)Index[GD]));
Mike Stump7809e0d2009-10-28 00:35:46 +0000421 if (MD->isPure())
Anders Carlssona0fdd912009-11-13 17:08:56 +0000422 Pures[GD] = 1;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000423 if (MorallyVirtual) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000424 VCallOffset[GD] = Offset/8;
425 Index_t &idx = VCall[GD];
Anders Carlssondbd920c2009-10-11 22:13:54 +0000426 // Allocate the first one, after that, we reuse the previous one.
427 if (idx == 0) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000428 NonVirtualOffset[GD] = CurrentVBaseOffset/8 - Offset/8;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000429 idx = VCalls.size()+1;
430 VCalls.push_back(0);
Mike Stump6a9612f2009-10-31 20:06:59 +0000431 D1(printf(" vcall for %s at %d with delta %d\n",
Mike Stumpe99cc452009-11-13 23:45:53 +0000432 MD->getNameAsString().c_str(), (int)-VCalls.size()-3, 0));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000433 }
434 }
435 }
436
437 void AddMethods(const CXXRecordDecl *RD, bool MorallyVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000438 Index_t Offset, bool RDisVirtualBase,
439 int64_t CurrentVBaseOffset) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000440 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000441 ++mi) {
442 const CXXMethodDecl *MD = *mi;
443 if (!MD->isVirtual())
444 continue;
445
446 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
447 // For destructors, add both the complete and the deleting destructor
448 // to the vtable.
449 AddMethod(GlobalDecl(DD, Dtor_Complete), MorallyVirtual, Offset,
450 RDisVirtualBase, CurrentVBaseOffset);
451 AddMethod(GlobalDecl(DD, Dtor_Deleting), MorallyVirtual, Offset,
452 RDisVirtualBase, CurrentVBaseOffset);
453 } else
454 AddMethod(MD, MorallyVirtual, Offset, RDisVirtualBase,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000455 CurrentVBaseOffset);
Anders Carlssona0fdd912009-11-13 17:08:56 +0000456 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000457 }
458
459 void NonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
460 const CXXRecordDecl *PrimaryBase,
461 bool PrimaryBaseWasVirtual, bool MorallyVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000462 int64_t Offset, int64_t CurrentVBaseOffset,
463 Path_t *Path) {
Mike Stump11dea942009-10-15 02:04:03 +0000464 Path->push_back(std::make_pair(RD, Offset));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000465 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
466 e = RD->bases_end(); i != e; ++i) {
467 if (i->isVirtual())
468 continue;
469 const CXXRecordDecl *Base =
470 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
471 if (Base != PrimaryBase || PrimaryBaseWasVirtual) {
472 uint64_t o = Offset + Layout.getBaseClassOffset(Base);
473 StartNewTable();
Mike Stump4cde6262009-11-13 02:13:54 +0000474 GenerateVtableForBase(Base, o, MorallyVirtual, false,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000475 CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000476 }
477 }
Mike Stump11dea942009-10-15 02:04:03 +0000478 Path->pop_back();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000479 }
480
Mike Stump0ca42792009-10-14 18:14:51 +0000481// #define D(X) do { X; } while (0)
482#define D(X)
483
484 void insertVCalls(int InsertionPoint) {
485 llvm::Constant *e = 0;
Mike Stump6a9612f2009-10-31 20:06:59 +0000486 D1(printf("============= combining vbase/vcall\n"));
Mike Stump0ca42792009-10-14 18:14:51 +0000487 D(VCalls.insert(VCalls.begin(), 673));
488 D(VCalls.push_back(672));
Mike Stump3425b972009-10-15 09:30:16 +0000489 methods.insert(methods.begin() + InsertionPoint, VCalls.size(), e);
Mike Stump0ca42792009-10-14 18:14:51 +0000490 // The vcalls come first...
491 for (std::vector<Index_t>::reverse_iterator i = VCalls.rbegin(),
492 e = VCalls.rend();
493 i != e; ++i)
494 methods[InsertionPoint++] = wrap((0?600:0) + *i);
495 VCalls.clear();
Mike Stumpfbfb52d2009-11-10 02:30:51 +0000496 VCall.clear();
Mike Stump0ca42792009-10-14 18:14:51 +0000497 }
498
Mike Stump65d0e282009-11-13 23:13:20 +0000499 void AddAddressPoints(const CXXRecordDecl *RD, uint64_t Offset,
500 Index_t AddressPoint) {
501 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
502 RD->getNameAsCString(), Class->getNameAsCString(),
503 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump23a35422009-11-19 20:52:19 +0000504 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Mike Stump65d0e282009-11-13 23:13:20 +0000505
506 // Now also add the address point for all our primary bases.
507 while (1) {
508 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
509 RD = Layout.getPrimaryBase();
510 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
511 // FIXME: Double check this.
512 if (RD == 0)
513 break;
514 if (PrimaryBaseWasVirtual &&
515 BLayout.getVBaseClassOffset(RD) != Offset)
516 break;
517 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
518 RD->getNameAsCString(), Class->getNameAsCString(),
519 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump23a35422009-11-19 20:52:19 +0000520 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Mike Stump65d0e282009-11-13 23:13:20 +0000521 }
522 }
523
524
Mike Stump6a9612f2009-10-31 20:06:59 +0000525 Index_t end(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
526 const CXXRecordDecl *PrimaryBase, bool PrimaryBaseWasVirtual,
527 bool MorallyVirtual, int64_t Offset, bool ForVirtualBase,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000528 int64_t CurrentVBaseOffset,
Mike Stump6a9612f2009-10-31 20:06:59 +0000529 Path_t *Path) {
Mike Stump11dea942009-10-15 02:04:03 +0000530 bool alloc = false;
531 if (Path == 0) {
532 alloc = true;
533 Path = new Path_t;
534 }
535
Anders Carlssondbd920c2009-10-11 22:13:54 +0000536 StartNewTable();
537 extra = 0;
Mike Stump0ca42792009-10-14 18:14:51 +0000538 bool DeferVCalls = MorallyVirtual || ForVirtualBase;
539 int VCallInsertionPoint = methods.size();
540 if (!DeferVCalls) {
541 insertVCalls(VCallInsertionPoint);
Mike Stump3425b972009-10-15 09:30:16 +0000542 } else
543 // FIXME: just for extra, or for all uses of VCalls.size post this?
544 extra = -VCalls.size();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000545
Mike Stump4cde6262009-11-13 02:13:54 +0000546 methods.push_back(wrap(-((Offset-LayoutOffset)/8)));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000547 methods.push_back(rtti);
548 Index_t AddressPoint = methods.size();
549
550 InstallThunks();
Mike Stump6a9612f2009-10-31 20:06:59 +0000551 D1(printf("============= combining methods\n"));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000552 methods.insert(methods.end(), submethods.begin(), submethods.end());
553 submethods.clear();
554
555 // and then the non-virtual bases.
556 NonVirtualBases(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000557 MorallyVirtual, Offset, CurrentVBaseOffset, Path);
Mike Stump0ca42792009-10-14 18:14:51 +0000558
559 if (ForVirtualBase) {
Mike Stump9840c702009-11-12 20:47:57 +0000560 // FIXME: We're adding to VCalls in callers, we need to do the overrides
561 // in the inner part, so that we know the complete set of vcalls during
562 // the build and don't have to insert into methods. Saving out the
563 // AddressPoint here, would need to be fixed, if we didn't do that. Also
564 // retroactively adding vcalls for overrides later wind up in the wrong
565 // place, the vcall slot has to be alloted during the walk of the base
566 // when the function is first introduces.
Mike Stump0ca42792009-10-14 18:14:51 +0000567 AddressPoint += VCalls.size();
Mike Stump9840c702009-11-12 20:47:57 +0000568 insertVCalls(VCallInsertionPoint);
Mike Stump0ca42792009-10-14 18:14:51 +0000569 }
570
Mike Stump65d0e282009-11-13 23:13:20 +0000571 AddAddressPoints(RD, Offset, AddressPoint);
Mike Stump9840c702009-11-12 20:47:57 +0000572
Mike Stump11dea942009-10-15 02:04:03 +0000573 if (alloc) {
574 delete Path;
575 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000576 return AddressPoint;
577 }
578
Mike Stump6a9612f2009-10-31 20:06:59 +0000579 void Primaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
580 bool updateVBIndex, Index_t current_vbindex,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000581 bool RDisVirtualBase, int64_t CurrentVBaseOffset) {
Mike Stump6a9612f2009-10-31 20:06:59 +0000582 if (!RD->isDynamicClass())
583 return;
584
585 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
586 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
587 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
588
589 // vtables are composed from the chain of primaries.
590 if (PrimaryBase) {
591 D1(printf(" doing primaries for %s most derived %s\n",
592 RD->getNameAsCString(), Class->getNameAsCString()));
593
Mike Stump9e7e3c62009-11-06 23:27:42 +0000594 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
595 if (PrimaryBaseWasVirtual)
596 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
597
Mike Stump6a9612f2009-10-31 20:06:59 +0000598 if (!PrimaryBaseWasVirtual)
599 Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000600 updateVBIndex, current_vbindex, PrimaryBaseWasVirtual,
601 BaseCurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +0000602 }
603
604 D1(printf(" doing vcall entries for %s most derived %s\n",
605 RD->getNameAsCString(), Class->getNameAsCString()));
606
607 // And add the virtuals for the class to the primary vtable.
Mike Stump9e7e3c62009-11-06 23:27:42 +0000608 AddMethods(RD, MorallyVirtual, Offset, RDisVirtualBase, CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +0000609 }
610
611 void VBPrimaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
612 bool updateVBIndex, Index_t current_vbindex,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000613 bool RDisVirtualBase, int64_t CurrentVBaseOffset,
614 bool bottom=false) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000615 if (!RD->isDynamicClass())
616 return;
617
618 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
619 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
620 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
621
622 // vtables are composed from the chain of primaries.
623 if (PrimaryBase) {
Mike Stump9e7e3c62009-11-06 23:27:42 +0000624 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
625 if (PrimaryBaseWasVirtual) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000626 IndirectPrimary.insert(PrimaryBase);
Mike Stump9e7e3c62009-11-06 23:27:42 +0000627 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
628 }
Mike Stump6a9612f2009-10-31 20:06:59 +0000629
630 D1(printf(" doing primaries for %s most derived %s\n",
631 RD->getNameAsCString(), Class->getNameAsCString()));
632
633 VBPrimaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000634 updateVBIndex, current_vbindex, PrimaryBaseWasVirtual,
635 BaseCurrentVBaseOffset);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000636 }
637
Mike Stump6a9612f2009-10-31 20:06:59 +0000638 D1(printf(" doing vbase entries for %s most derived %s\n",
639 RD->getNameAsCString(), Class->getNameAsCString()));
640 GenerateVBaseOffsets(RD, Offset, updateVBIndex, current_vbindex);
641
642 if (RDisVirtualBase || bottom) {
643 Primaries(RD, MorallyVirtual, Offset, updateVBIndex, current_vbindex,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000644 RDisVirtualBase, CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +0000645 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000646 }
647
Mike Stump4cde6262009-11-13 02:13:54 +0000648 int64_t GenerateVtableForBase(const CXXRecordDecl *RD, int64_t Offset = 0,
649 bool MorallyVirtual = false,
Anders Carlssondbd920c2009-10-11 22:13:54 +0000650 bool ForVirtualBase = false,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000651 int CurrentVBaseOffset = 0,
Mike Stump11dea942009-10-15 02:04:03 +0000652 Path_t *Path = 0) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000653 if (!RD->isDynamicClass())
654 return 0;
655
Mike Stump92774d12009-11-13 02:35:38 +0000656 // Construction vtable don't need parts that have no virtual bases and
657 // aren't morally virtual.
658 if ((LayoutClass != Class) && RD->getNumVBases() == 0 && !MorallyVirtual)
659 return 0;
660
Anders Carlssondbd920c2009-10-11 22:13:54 +0000661 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
662 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
663 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
664
Anders Carlssondbd920c2009-10-11 22:13:54 +0000665 extra = 0;
Mike Stump6a9612f2009-10-31 20:06:59 +0000666 D1(printf("building entries for base %s most derived %s\n",
667 RD->getNameAsCString(), Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000668
Mike Stump6a9612f2009-10-31 20:06:59 +0000669 if (ForVirtualBase)
670 extra = VCalls.size();
671
672 VBPrimaries(RD, MorallyVirtual, Offset, !ForVirtualBase, 0, ForVirtualBase,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000673 CurrentVBaseOffset, true);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000674
675 if (Path)
Mike Stump9e7e3c62009-11-06 23:27:42 +0000676 OverrideMethods(Path, MorallyVirtual, Offset, CurrentVBaseOffset);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000677
Mike Stump6a9612f2009-10-31 20:06:59 +0000678 return end(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual, MorallyVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000679 Offset, ForVirtualBase, CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000680 }
681
682 void GenerateVtableForVBases(const CXXRecordDecl *RD,
683 int64_t Offset = 0,
Mike Stump11dea942009-10-15 02:04:03 +0000684 Path_t *Path = 0) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000685 bool alloc = false;
686 if (Path == 0) {
687 alloc = true;
Mike Stump11dea942009-10-15 02:04:03 +0000688 Path = new Path_t;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000689 }
690 // FIXME: We also need to override using all paths to a virtual base,
691 // right now, we just process the first path
692 Path->push_back(std::make_pair(RD, Offset));
693 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
694 e = RD->bases_end(); i != e; ++i) {
695 const CXXRecordDecl *Base =
696 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
697 if (i->isVirtual() && !IndirectPrimary.count(Base)) {
698 // Mark it so we don't output it twice.
699 IndirectPrimary.insert(Base);
700 StartNewTable();
Mike Stump0ca42792009-10-14 18:14:51 +0000701 VCall.clear();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000702 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump9e7e3c62009-11-06 23:27:42 +0000703 int64_t CurrentVBaseOffset = BaseOffset;
Mike Stump6a9612f2009-10-31 20:06:59 +0000704 D1(printf("vtable %s virtual base %s\n",
705 Class->getNameAsCString(), Base->getNameAsCString()));
Mike Stump4cde6262009-11-13 02:13:54 +0000706 GenerateVtableForBase(Base, BaseOffset, true, true, CurrentVBaseOffset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000707 Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000708 }
Mike Stump9840c702009-11-12 20:47:57 +0000709 int64_t BaseOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000710 if (i->isVirtual())
711 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump9840c702009-11-12 20:47:57 +0000712 else {
713 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
714 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
715 }
716
Mike Stump11dea942009-10-15 02:04:03 +0000717 if (Base->getNumVBases()) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000718 GenerateVtableForVBases(Base, BaseOffset, Path);
Mike Stump11dea942009-10-15 02:04:03 +0000719 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000720 }
721 Path->pop_back();
722 if (alloc)
723 delete Path;
724 }
725};
726
727
728VtableBuilder::Index_t VtableBuilder::VBlookup(CXXRecordDecl *D,
729 CXXRecordDecl *B) {
730 return CGM.getVtableInfo().getVirtualBaseOffsetIndex(D, B);
731}
732
Anders Carlssona0fdd912009-11-13 17:08:56 +0000733int64_t CGVtableInfo::getMethodVtableIndex(GlobalDecl GD) {
734 MethodVtableIndicesTy::iterator I = MethodVtableIndices.find(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000735 if (I != MethodVtableIndices.end())
736 return I->second;
737
Anders Carlssona0fdd912009-11-13 17:08:56 +0000738 const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000739
740 std::vector<llvm::Constant *> methods;
741 // FIXME: This seems expensive. Can we do a partial job to get
742 // just this data.
Mike Stump4cde6262009-11-13 02:13:54 +0000743 VtableBuilder b(methods, RD, RD, 0, CGM);
Mike Stump6a9612f2009-10-31 20:06:59 +0000744 D1(printf("vtable %s\n", RD->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000745 b.GenerateVtableForBase(RD);
746 b.GenerateVtableForVBases(RD);
747
748 MethodVtableIndices.insert(b.getIndex().begin(),
749 b.getIndex().end());
750
Anders Carlssona0fdd912009-11-13 17:08:56 +0000751 I = MethodVtableIndices.find(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000752 assert(I != MethodVtableIndices.end() && "Did not find index!");
753 return I->second;
754}
755
756int64_t CGVtableInfo::getVirtualBaseOffsetIndex(const CXXRecordDecl *RD,
757 const CXXRecordDecl *VBase) {
758 ClassPairTy ClassPair(RD, VBase);
759
760 VirtualBaseClassIndiciesTy::iterator I =
761 VirtualBaseClassIndicies.find(ClassPair);
762 if (I != VirtualBaseClassIndicies.end())
763 return I->second;
764
765 std::vector<llvm::Constant *> methods;
766 // FIXME: This seems expensive. Can we do a partial job to get
767 // just this data.
Mike Stump4cde6262009-11-13 02:13:54 +0000768 VtableBuilder b(methods, RD, RD, 0, CGM);
Mike Stump6a9612f2009-10-31 20:06:59 +0000769 D1(printf("vtable %s\n", RD->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000770 b.GenerateVtableForBase(RD);
771 b.GenerateVtableForVBases(RD);
772
773 for (llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
774 b.getVBIndex().begin(), E = b.getVBIndex().end(); I != E; ++I) {
775 // Insert all types.
776 ClassPairTy ClassPair(RD, I->first);
777
778 VirtualBaseClassIndicies.insert(std::make_pair(ClassPair, I->second));
779 }
780
781 I = VirtualBaseClassIndicies.find(ClassPair);
782 assert(I != VirtualBaseClassIndicies.end() && "Did not find index!");
783
784 return I->second;
785}
786
Mike Stump9840c702009-11-12 20:47:57 +0000787llvm::Constant *CodeGenModule::GenerateVtable(const CXXRecordDecl *LayoutClass,
788 const CXXRecordDecl *RD,
Mike Stump8cfcb522009-11-11 20:26:26 +0000789 uint64_t Offset) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000790 llvm::SmallString<256> OutName;
Mike Stump9840c702009-11-12 20:47:57 +0000791 if (LayoutClass != RD)
Daniel Dunbar94fd26d2009-11-21 09:06:22 +0000792 getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset/8, RD, OutName);
Mike Stump8cfcb522009-11-11 20:26:26 +0000793 else
Daniel Dunbar94fd26d2009-11-21 09:06:22 +0000794 getMangleContext().mangleCXXVtable(RD, OutName);
795 llvm::StringRef Name = OutName.str();
Benjamin Kramer7a9474e2009-10-11 22:57:54 +0000796
Anders Carlssondbd920c2009-10-11 22:13:54 +0000797 std::vector<llvm::Constant *> methods;
798 llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
799 int64_t AddressPoint;
800
Mike Stump85615df2009-11-19 04:04:36 +0000801 llvm::GlobalVariable *GV = getModule().getGlobalVariable(Name);
Mike Stump23a35422009-11-19 20:52:19 +0000802 if (GV && AddressPoints[LayoutClass] && !GV->isDeclaration()) {
Mike Stump85615df2009-11-19 04:04:36 +0000803 AddressPoint=(*(*(AddressPoints[LayoutClass]))[RD])[std::make_pair(RD,
804 Offset)];
Mike Stump23a35422009-11-19 20:52:19 +0000805 // FIXME: We can never have 0 address point. Do this for now so gepping
806 // retains the same structure. Later, we'll just assert.
807 if (AddressPoint == 0)
808 AddressPoint = 1;
809 } else {
Mike Stump85615df2009-11-19 04:04:36 +0000810 VtableBuilder b(methods, RD, LayoutClass, Offset, *this);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000811
Mike Stump85615df2009-11-19 04:04:36 +0000812 D1(printf("vtable %s\n", RD->getNameAsCString()));
813 // First comes the vtables for all the non-virtual bases...
814 AddressPoint = b.GenerateVtableForBase(RD, Offset);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000815
Mike Stump85615df2009-11-19 04:04:36 +0000816 // then the vtables for all the virtual bases.
817 b.GenerateVtableForVBases(RD, Offset);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000818
Mike Stump85615df2009-11-19 04:04:36 +0000819 bool CreateDefinition = true;
820 if (LayoutClass != RD)
821 CreateDefinition = true;
822 else {
823 // We have to convert it to have a record layout.
824 Types.ConvertTagDeclType(LayoutClass);
825 const CGRecordLayout &CGLayout = Types.getCGRecordLayout(LayoutClass);
826 if (const CXXMethodDecl *KeyFunction = CGLayout.getKeyFunction()) {
827 if (!KeyFunction->getBody()) {
828 // If there is a KeyFunction, and it isn't defined, just build a
829 // reference to the vtable.
830 CreateDefinition = false;
831 }
832 }
833 }
834
835 llvm::Constant *C = 0;
836 llvm::Type *type = Ptr8Ty;
837 llvm::GlobalVariable::LinkageTypes linktype
838 = llvm::GlobalValue::ExternalLinkage;
839 if (CreateDefinition) {
840 llvm::ArrayType *ntype = llvm::ArrayType::get(Ptr8Ty, methods.size());
841 C = llvm::ConstantArray::get(ntype, methods);
842 linktype = llvm::GlobalValue::LinkOnceODRLinkage;
843 if (LayoutClass->isInAnonymousNamespace())
844 linktype = llvm::GlobalValue::InternalLinkage;
845 type = ntype;
846 }
847 llvm::GlobalVariable *OGV = GV;
848 GV = new llvm::GlobalVariable(getModule(), type, true, linktype, C, Name);
849 if (OGV) {
850 GV->takeName(OGV);
851 llvm::Constant *NewPtr = llvm::ConstantExpr::getBitCast(GV,
852 OGV->getType());
853 OGV->replaceAllUsesWith(NewPtr);
854 OGV->eraseFromParent();
855 }
856 bool Hidden = getDeclVisibilityMode(RD) == LangOptions::Hidden;
857 if (Hidden)
858 GV->setVisibility(llvm::GlobalVariable::HiddenVisibility);
859 }
Mike Stumpe56ceca2009-11-18 04:00:48 +0000860 llvm::Constant *vtable = llvm::ConstantExpr::getBitCast(GV, Ptr8Ty);
Mike Stump380dd752009-11-10 07:44:33 +0000861 llvm::Constant *AddressPointC;
862 uint32_t LLVMPointerWidth = getContext().Target.getPointerWidth(0);
863 AddressPointC = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
864 AddressPoint*LLVMPointerWidth/8);
Mike Stump9840c702009-11-12 20:47:57 +0000865 vtable = llvm::ConstantExpr::getInBoundsGetElementPtr(vtable, &AddressPointC,
866 1);
Mike Stump380dd752009-11-10 07:44:33 +0000867
Mike Stump23a35422009-11-19 20:52:19 +0000868 assert(vtable->getType() == Ptr8Ty);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000869 return vtable;
870}
Mike Stumpfbfb52d2009-11-10 02:30:51 +0000871
872class VTTBuilder {
873 /// Inits - The list of values built for the VTT.
874 std::vector<llvm::Constant *> &Inits;
875 /// Class - The most derived class that this vtable is being built for.
876 const CXXRecordDecl *Class;
877 CodeGenModule &CGM; // Per-module state.
Mike Stump971977f2009-11-11 00:35:07 +0000878 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
Mike Stumpaee8de32009-11-11 03:08:24 +0000879 /// BLayout - Layout for the most derived class that this vtable is being
880 /// built for.
881 const ASTRecordLayout &BLayout;
Mike Stumpacfd1e52009-11-13 01:54:23 +0000882 CodeGenModule::AddrMap_t &AddressPoints;
Mike Stump9840c702009-11-12 20:47:57 +0000883 // vtbl - A pointer to the vtable for Class.
884 llvm::Constant *ClassVtbl;
885 llvm::LLVMContext &VMContext;
Mike Stumpfbfb52d2009-11-10 02:30:51 +0000886
Mike Stump28f7ce12009-11-12 22:56:32 +0000887 /// BuildVtablePtr - Build up a referene to the given secondary vtable
Mike Stumpacfd1e52009-11-13 01:54:23 +0000888 llvm::Constant *BuildVtablePtr(llvm::Constant *vtbl,
889 const CXXRecordDecl *VtblClass,
890 const CXXRecordDecl *RD,
Mike Stump28f7ce12009-11-12 22:56:32 +0000891 uint64_t Offset) {
892 int64_t AddressPoint;
Mike Stumpacfd1e52009-11-13 01:54:23 +0000893 AddressPoint = (*AddressPoints[VtblClass])[std::make_pair(RD, Offset)];
Mike Stump80ac2352009-11-12 23:36:21 +0000894 // FIXME: We can never have 0 address point. Do this for now so gepping
Mike Stump23a35422009-11-19 20:52:19 +0000895 // retains the same structure. Later we'll just assert.
Mike Stump80ac2352009-11-12 23:36:21 +0000896 if (AddressPoint == 0)
897 AddressPoint = 1;
Mike Stumpacfd1e52009-11-13 01:54:23 +0000898 D1(printf("XXX address point for %s in %s layout %s at offset %d was %d\n",
899 RD->getNameAsCString(), VtblClass->getNameAsCString(),
900 Class->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump28f7ce12009-11-12 22:56:32 +0000901 uint32_t LLVMPointerWidth = CGM.getContext().Target.getPointerWidth(0);
902 llvm::Constant *init;
903 init = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
904 AddressPoint*LLVMPointerWidth/8);
905 init = llvm::ConstantExpr::getInBoundsGetElementPtr(vtbl, &init, 1);
906 return init;
907 }
908
Mike Stump9840c702009-11-12 20:47:57 +0000909 /// Secondary - Add the secondary vtable pointers to Inits. Offset is the
910 /// current offset in bits to the object we're working on.
Mike Stump28f7ce12009-11-12 22:56:32 +0000911 void Secondary(const CXXRecordDecl *RD, llvm::Constant *vtbl,
Mike Stumpacfd1e52009-11-13 01:54:23 +0000912 const CXXRecordDecl *VtblClass, uint64_t Offset=0,
913 bool MorallyVirtual=false) {
Mike Stump971977f2009-11-11 00:35:07 +0000914 if (RD->getNumVBases() == 0 && ! MorallyVirtual)
915 return;
916
917 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
918 e = RD->bases_end(); i != e; ++i) {
919 const CXXRecordDecl *Base =
920 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
921 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
922 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
923 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
924 bool NonVirtualPrimaryBase;
925 NonVirtualPrimaryBase = !PrimaryBaseWasVirtual && Base == PrimaryBase;
926 bool BaseMorallyVirtual = MorallyVirtual | i->isVirtual();
Mike Stumpaee8de32009-11-11 03:08:24 +0000927 uint64_t BaseOffset;
928 if (!i->isVirtual()) {
929 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
930 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
931 } else
932 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump80ac2352009-11-12 23:36:21 +0000933 llvm::Constant *subvtbl = vtbl;
Mike Stumpacfd1e52009-11-13 01:54:23 +0000934 const CXXRecordDecl *subVtblClass = VtblClass;
Mike Stump971977f2009-11-11 00:35:07 +0000935 if ((Base->getNumVBases() || BaseMorallyVirtual)
936 && !NonVirtualPrimaryBase) {
937 // FIXME: Slightly too many of these for __ZTT8test8_B2
Mike Stump28f7ce12009-11-12 22:56:32 +0000938 llvm::Constant *init;
Mike Stump80ac2352009-11-12 23:36:21 +0000939 if (BaseMorallyVirtual)
Mike Stumpacfd1e52009-11-13 01:54:23 +0000940 init = BuildVtablePtr(vtbl, VtblClass, RD, Offset);
Mike Stump80ac2352009-11-12 23:36:21 +0000941 else {
Mike Stump28f7ce12009-11-12 22:56:32 +0000942 init = CGM.getVtableInfo().getCtorVtable(Class, Base, BaseOffset);
Mike Stump80ac2352009-11-12 23:36:21 +0000943 subvtbl = dyn_cast<llvm::Constant>(init->getOperand(0));
Mike Stumpacfd1e52009-11-13 01:54:23 +0000944 subVtblClass = Base;
Mike Stump80ac2352009-11-12 23:36:21 +0000945 }
Mike Stump28f7ce12009-11-12 22:56:32 +0000946 Inits.push_back(init);
Mike Stump971977f2009-11-11 00:35:07 +0000947 }
Mike Stumpacfd1e52009-11-13 01:54:23 +0000948 Secondary(Base, subvtbl, subVtblClass, BaseOffset, BaseMorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +0000949 }
950 }
951
Mike Stump9840c702009-11-12 20:47:57 +0000952 /// BuiltVTT - Add the VTT to Inits. Offset is the offset in bits to the
953 /// currnet object we're working on.
954 void BuildVTT(const CXXRecordDecl *RD, uint64_t Offset, bool MorallyVirtual) {
Mike Stump971977f2009-11-11 00:35:07 +0000955 if (RD->getNumVBases() == 0 && !MorallyVirtual)
956 return;
957
Mike Stump9840c702009-11-12 20:47:57 +0000958 llvm::Constant *init;
Mike Stumpacfd1e52009-11-13 01:54:23 +0000959 const CXXRecordDecl *VtblClass;
960
Mike Stump971977f2009-11-11 00:35:07 +0000961 // First comes the primary virtual table pointer...
Mike Stumpacfd1e52009-11-13 01:54:23 +0000962 if (MorallyVirtual) {
963 init = BuildVtablePtr(ClassVtbl, Class, RD, Offset);
964 VtblClass = Class;
965 } else {
Mike Stump9840c702009-11-12 20:47:57 +0000966 init = CGM.getVtableInfo().getCtorVtable(Class, RD, Offset);
Mike Stumpacfd1e52009-11-13 01:54:23 +0000967 VtblClass = RD;
968 }
Mike Stump28f7ce12009-11-12 22:56:32 +0000969 llvm::Constant *vtbl = dyn_cast<llvm::Constant>(init->getOperand(0));
Mike Stump9840c702009-11-12 20:47:57 +0000970 Inits.push_back(init);
Mike Stump971977f2009-11-11 00:35:07 +0000971
972 // then the secondary VTTs....
Mike Stump9840c702009-11-12 20:47:57 +0000973 SecondaryVTTs(RD, Offset, MorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +0000974
975 // and last the secondary vtable pointers.
Mike Stumpacfd1e52009-11-13 01:54:23 +0000976 Secondary(RD, vtbl, VtblClass, Offset, MorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +0000977 }
978
979 /// SecondaryVTTs - Add the secondary VTTs to Inits. The secondary VTTs are
980 /// built from each direct non-virtual proper base that requires a VTT in
981 /// declaration order.
Mike Stump9840c702009-11-12 20:47:57 +0000982 void SecondaryVTTs(const CXXRecordDecl *RD, uint64_t Offset=0,
983 bool MorallyVirtual=false) {
Mike Stump971977f2009-11-11 00:35:07 +0000984 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
985 e = RD->bases_end(); i != e; ++i) {
986 const CXXRecordDecl *Base =
987 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
988 if (i->isVirtual())
989 continue;
Mike Stump9840c702009-11-12 20:47:57 +0000990 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
991 uint64_t BaseOffset = Offset + Layout.getBaseClassOffset(Base);
992 BuildVTT(Base, BaseOffset, MorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +0000993 }
994 }
995
996 /// VirtualVTTs - Add the VTT for each proper virtual base in inheritance
997 /// graph preorder.
998 void VirtualVTTs(const CXXRecordDecl *RD) {
999 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1000 e = RD->bases_end(); i != e; ++i) {
1001 const CXXRecordDecl *Base =
1002 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1003 if (i->isVirtual() && !SeenVBase.count(Base)) {
1004 SeenVBase.insert(Base);
Mike Stump9840c702009-11-12 20:47:57 +00001005 uint64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
1006 BuildVTT(Base, BaseOffset, true);
Mike Stump971977f2009-11-11 00:35:07 +00001007 }
1008 VirtualVTTs(Base);
1009 }
1010 }
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001011public:
1012 VTTBuilder(std::vector<llvm::Constant *> &inits, const CXXRecordDecl *c,
Mike Stumpaee8de32009-11-11 03:08:24 +00001013 CodeGenModule &cgm)
1014 : Inits(inits), Class(c), CGM(cgm),
Mike Stump9840c702009-11-12 20:47:57 +00001015 BLayout(cgm.getContext().getASTRecordLayout(c)),
Mike Stumpacfd1e52009-11-13 01:54:23 +00001016 AddressPoints(*cgm.AddressPoints[c]),
Mike Stump9840c702009-11-12 20:47:57 +00001017 VMContext(cgm.getModule().getContext()) {
Mike Stump380dd752009-11-10 07:44:33 +00001018
Mike Stump971977f2009-11-11 00:35:07 +00001019 // First comes the primary virtual table pointer for the complete class...
Mike Stump9840c702009-11-12 20:47:57 +00001020 ClassVtbl = CGM.getVtableInfo().getVtable(Class);
1021 Inits.push_back(ClassVtbl);
1022 ClassVtbl = dyn_cast<llvm::Constant>(ClassVtbl->getOperand(0));
1023
Mike Stump971977f2009-11-11 00:35:07 +00001024 // then the secondary VTTs...
1025 SecondaryVTTs(Class);
1026
1027 // then the secondary vtable pointers...
Mike Stumpacfd1e52009-11-13 01:54:23 +00001028 Secondary(Class, ClassVtbl, Class);
Mike Stump971977f2009-11-11 00:35:07 +00001029
1030 // and last, the virtual VTTs.
1031 VirtualVTTs(Class);
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001032 }
1033};
1034
Mike Stump380dd752009-11-10 07:44:33 +00001035llvm::Constant *CodeGenModule::GenerateVTT(const CXXRecordDecl *RD) {
Mike Stumpf1c03332009-11-10 19:13:04 +00001036 // Only classes that have virtual bases need a VTT.
1037 if (RD->getNumVBases() == 0)
1038 return 0;
1039
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001040 llvm::SmallString<256> OutName;
Daniel Dunbar94fd26d2009-11-21 09:06:22 +00001041 getMangleContext().mangleCXXVTT(RD, OutName);
1042 llvm::StringRef Name = OutName.str();
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001043
1044 llvm::GlobalVariable::LinkageTypes linktype;
1045 linktype = llvm::GlobalValue::LinkOnceODRLinkage;
Mike Stump85615df2009-11-19 04:04:36 +00001046 if (RD->isInAnonymousNamespace())
1047 linktype = llvm::GlobalValue::InternalLinkage;
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001048 std::vector<llvm::Constant *> inits;
1049 llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1050
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001051 D1(printf("vtt %s\n", RD->getNameAsCString()));
1052
Mike Stump971977f2009-11-11 00:35:07 +00001053 VTTBuilder b(inits, RD, *this);
1054
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001055 llvm::Constant *C;
1056 llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, inits.size());
1057 C = llvm::ConstantArray::get(type, inits);
Mike Stumpe56ceca2009-11-18 04:00:48 +00001058 llvm::GlobalVariable *vtt = new llvm::GlobalVariable(getModule(), type, true,
Mike Stump85615df2009-11-19 04:04:36 +00001059 linktype, C, Name);
Mike Stumpe56ceca2009-11-18 04:00:48 +00001060 bool Hidden = getDeclVisibilityMode(RD) == LangOptions::Hidden;
1061 if (Hidden)
1062 vtt->setVisibility(llvm::GlobalVariable::HiddenVisibility);
1063 return llvm::ConstantExpr::getBitCast(vtt, Ptr8Ty);
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001064}
Mike Stump380dd752009-11-10 07:44:33 +00001065
Mike Stump58588942009-11-19 01:08:19 +00001066void CGVtableInfo::GenerateClassData(const CXXRecordDecl *RD) {
1067 Vtables[RD] = CGM.GenerateVtable(RD, RD);
1068 CGM.GenerateRtti(RD);
1069 CGM.GenerateVTT(RD);
1070}
1071
Mike Stump8cfcb522009-11-11 20:26:26 +00001072llvm::Constant *CGVtableInfo::getVtable(const CXXRecordDecl *RD) {
Mike Stump380dd752009-11-10 07:44:33 +00001073 llvm::Constant *&vtbl = Vtables[RD];
1074 if (vtbl)
1075 return vtbl;
Mike Stump9840c702009-11-12 20:47:57 +00001076 vtbl = CGM.GenerateVtable(RD, RD);
Mike Stump85615df2009-11-19 04:04:36 +00001077
1078 bool CreateDefinition = true;
1079 // We have to convert it to have a record layout.
1080 CGM.getTypes().ConvertTagDeclType(RD);
1081 const CGRecordLayout &CGLayout = CGM.getTypes().getCGRecordLayout(RD);
1082 if (const CXXMethodDecl *KeyFunction = CGLayout.getKeyFunction()) {
1083 if (!KeyFunction->getBody()) {
1084 // If there is a KeyFunction, and it isn't defined, just build a
1085 // reference to the vtable.
1086 CreateDefinition = false;
1087 }
1088 }
1089
1090 if (CreateDefinition) {
1091 CGM.GenerateRtti(RD);
1092 CGM.GenerateVTT(RD);
1093 }
Mike Stump380dd752009-11-10 07:44:33 +00001094 return vtbl;
1095}
Mike Stump8cfcb522009-11-11 20:26:26 +00001096
Mike Stump9840c702009-11-12 20:47:57 +00001097llvm::Constant *CGVtableInfo::getCtorVtable(const CXXRecordDecl *LayoutClass,
1098 const CXXRecordDecl *RD,
Mike Stump8cfcb522009-11-11 20:26:26 +00001099 uint64_t Offset) {
Mike Stump9840c702009-11-12 20:47:57 +00001100 return CGM.GenerateVtable(LayoutClass, RD, Offset);
Mike Stump8cfcb522009-11-11 20:26:26 +00001101}