blob: 548f7ebee765ae30efdd2a020f726d3512a09b1f [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"
Anders Carlssond6b07fb2009-11-27 20:47:55 +000016#include "clang/AST/CXXInheritance.h"
Anders Carlssondbd920c2009-10-11 22:13:54 +000017#include "clang/AST/RecordLayout.h"
Anders Carlsson5dd730a2009-11-26 19:32:45 +000018#include "llvm/ADT/DenseSet.h"
Zhongxing Xu7fe26ac2009-11-13 05:46:16 +000019#include <cstdio>
Anders Carlssondbd920c2009-10-11 22:13:54 +000020
21using namespace clang;
22using namespace CodeGen;
23
Anders Carlsson27f69d02009-11-27 22:21:51 +000024namespace {
Benjamin Kramer85b45212009-11-28 19:45:26 +000025class VtableBuilder {
Anders Carlssondbd920c2009-10-11 22:13:54 +000026public:
27 /// Index_t - Vtable index type.
28 typedef uint64_t Index_t;
29private:
30 std::vector<llvm::Constant *> &methods;
31 std::vector<llvm::Constant *> submethods;
32 llvm::Type *Ptr8Ty;
33 /// Class - The most derived class that this vtable is being built for.
34 const CXXRecordDecl *Class;
Mike Stumpacfd1e52009-11-13 01:54:23 +000035 /// LayoutClass - The most derived class used for virtual base layout
36 /// information.
37 const CXXRecordDecl *LayoutClass;
Mike Stump4cde6262009-11-13 02:13:54 +000038 /// LayoutOffset - The offset for Class in LayoutClass.
39 uint64_t LayoutOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +000040 /// BLayout - Layout for the most derived class that this vtable is being
41 /// built for.
42 const ASTRecordLayout &BLayout;
43 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
44 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
45 llvm::Constant *rtti;
46 llvm::LLVMContext &VMContext;
47 CodeGenModule &CGM; // Per-module state.
48 /// Index - Maps a method decl into a vtable index. Useful for virtual
49 /// dispatch codegen.
Anders Carlssona0fdd912009-11-13 17:08:56 +000050 llvm::DenseMap<GlobalDecl, Index_t> Index;
51 llvm::DenseMap<GlobalDecl, Index_t> VCall;
52 llvm::DenseMap<GlobalDecl, Index_t> VCallOffset;
Mike Stump9e7e3c62009-11-06 23:27:42 +000053 // This is the offset to the nearest virtual base
Anders Carlssona0fdd912009-11-13 17:08:56 +000054 llvm::DenseMap<GlobalDecl, Index_t> NonVirtualOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +000055 llvm::DenseMap<const CXXRecordDecl *, Index_t> VBIndex;
Mike Stump94aff932009-10-27 23:46:47 +000056
Anders Carlsson6d4ccb72009-11-26 19:54:33 +000057 /// PureVirtualFunction - Points to __cxa_pure_virtual.
58 llvm::Constant *PureVirtualFn;
59
Anders Carlssondb131512009-11-26 03:25:13 +000060 /// Thunk - Represents a single thunk.
61 struct Thunk {
62 Thunk()
63 : Index(0) { }
64
65 Thunk(uint64_t Index, const ThunkAdjustment &Adjustment)
66 : Index(Index), Adjustment(Adjustment) { }
67
68 /// Index - The index in the vtable.
69 uint64_t Index;
70
Anders Carlsson5dd730a2009-11-26 19:32:45 +000071 /// Adjustment - The thunk adjustment.
Anders Carlssondb131512009-11-26 03:25:13 +000072 ThunkAdjustment Adjustment;
73 };
Anders Carlsson5dd730a2009-11-26 19:32:45 +000074
75 /// Thunks - The thunks in a vtable.
Anders Carlssondb131512009-11-26 03:25:13 +000076 typedef llvm::DenseMap<GlobalDecl, Thunk> ThunksMapTy;
77 ThunksMapTy Thunks;
Anders Carlsson5dd730a2009-11-26 19:32:45 +000078
79 /// CovariantThunk - Represents a single covariant thunk.
80 struct CovariantThunk {
81 CovariantThunk()
82 : Index(0) { }
83
84 CovariantThunk(uint64_t Index, const ThunkAdjustment &ThisAdjustment,
85 const ThunkAdjustment &ReturnAdjustment,
86 CanQualType ReturnType)
87 : Index(Index), Adjustment(ThisAdjustment, ReturnAdjustment),
88 ReturnType(ReturnType) { }
89
90 // Index - The index in the vtable.
91 uint64_t Index;
92
93 /// Adjustment - The covariant thunk adjustment.
94 CovariantThunkAdjustment Adjustment;
95
96 /// ReturnType - The return type of the function.
97 CanQualType ReturnType;
98 };
Anders Carlssondb131512009-11-26 03:25:13 +000099
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000100 /// CovariantThunks - The covariant thunks in a vtable.
101 typedef llvm::DenseMap<GlobalDecl, CovariantThunk> CovariantThunksMapTy;
102 CovariantThunksMapTy CovariantThunks;
103
104 /// PureVirtualMethods - Pure virtual methods.
105 typedef llvm::DenseSet<GlobalDecl> PureVirtualMethodsSetTy;
106 PureVirtualMethodsSetTy PureVirtualMethods;
107
Anders Carlssondbd920c2009-10-11 22:13:54 +0000108 std::vector<Index_t> VCalls;
Mike Stump9840c702009-11-12 20:47:57 +0000109
110 typedef std::pair<const CXXRecordDecl *, uint64_t> CtorVtable_t;
Mike Stump23a35422009-11-19 20:52:19 +0000111 // subAddressPoints - Used to hold the AddressPoints (offsets) into the built
112 // vtable for use in computing the initializers for the VTT.
113 llvm::DenseMap<CtorVtable_t, int64_t> &subAddressPoints;
Mike Stump9840c702009-11-12 20:47:57 +0000114
Anders Carlssondbd920c2009-10-11 22:13:54 +0000115 typedef CXXRecordDecl::method_iterator method_iter;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000116 const bool Extern;
117 const uint32_t LLVMPointerWidth;
118 Index_t extra;
Mike Stump11dea942009-10-15 02:04:03 +0000119 typedef std::vector<std::pair<const CXXRecordDecl *, int64_t> > Path_t;
Mike Stump23a35422009-11-19 20:52:19 +0000120 static llvm::DenseMap<CtorVtable_t, int64_t>&
121 AllocAddressPoint(CodeGenModule &cgm, const CXXRecordDecl *l,
122 const CXXRecordDecl *c) {
123 CodeGenModule::AddrMap_t *&oref = cgm.AddressPoints[l];
124 if (oref == 0)
125 oref = new CodeGenModule::AddrMap_t;
126
127 llvm::DenseMap<CtorVtable_t, int64_t> *&ref = (*oref)[c];
128 if (ref == 0)
129 ref = new llvm::DenseMap<CtorVtable_t, int64_t>;
130 return *ref;
131 }
Anders Carlsson6d4ccb72009-11-26 19:54:33 +0000132
133 /// getPureVirtualFn - Return the __cxa_pure_virtual function.
134 llvm::Constant* getPureVirtualFn() {
135 if (!PureVirtualFn) {
136 const llvm::FunctionType *Ty =
137 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
138 /*isVarArg=*/false);
139 PureVirtualFn = wrap(CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual"));
140 }
141
142 return PureVirtualFn;
143 }
144
Anders Carlssondbd920c2009-10-11 22:13:54 +0000145public:
Mike Stump4cde6262009-11-13 02:13:54 +0000146 VtableBuilder(std::vector<llvm::Constant *> &meth, const CXXRecordDecl *c,
147 const CXXRecordDecl *l, uint64_t lo, CodeGenModule &cgm)
148 : methods(meth), Class(c), LayoutClass(l), LayoutOffset(lo),
Mike Stumpacfd1e52009-11-13 01:54:23 +0000149 BLayout(cgm.getContext().getASTRecordLayout(l)),
Mike Stumpde050572009-12-02 18:57:08 +0000150 rtti(cgm.GenerateRTTIRef(c)), VMContext(cgm.getModule().getContext()),
Anders Carlsson6d4ccb72009-11-26 19:54:33 +0000151 CGM(cgm), PureVirtualFn(0),subAddressPoints(AllocAddressPoint(cgm, l, c)),
Mike Stump6be2b172009-11-19 00:49:05 +0000152 Extern(!l->isInAnonymousNamespace()),
Anders Carlsson6d4ccb72009-11-26 19:54:33 +0000153 LLVMPointerWidth(cgm.getContext().Target.getPointerWidth(0)) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000154 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
155 }
156
Anders Carlssona0fdd912009-11-13 17:08:56 +0000157 llvm::DenseMap<GlobalDecl, Index_t> &getIndex() { return Index; }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000158 llvm::DenseMap<const CXXRecordDecl *, Index_t> &getVBIndex()
159 { return VBIndex; }
160
161 llvm::Constant *wrap(Index_t i) {
162 llvm::Constant *m;
163 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i);
164 return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
165 }
166
167 llvm::Constant *wrap(llvm::Constant *m) {
168 return llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
169 }
170
Mike Stump79336282009-12-02 19:50:41 +0000171#define D1(x)
172//#define D1(X) do { if (getenv("DEBUG")) { X; } } while (0)
Mike Stump6a9612f2009-10-31 20:06:59 +0000173
174 void GenerateVBaseOffsets(const CXXRecordDecl *RD, uint64_t Offset,
Mike Stumpab28c132009-10-13 22:54:56 +0000175 bool updateVBIndex, Index_t current_vbindex) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000176 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
177 e = RD->bases_end(); i != e; ++i) {
178 const CXXRecordDecl *Base =
179 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stumpab28c132009-10-13 22:54:56 +0000180 Index_t next_vbindex = current_vbindex;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000181 if (i->isVirtual() && !SeenVBase.count(Base)) {
182 SeenVBase.insert(Base);
Mike Stumpab28c132009-10-13 22:54:56 +0000183 if (updateVBIndex) {
Mike Stump6a9612f2009-10-31 20:06:59 +0000184 next_vbindex = (ssize_t)(-(VCalls.size()*LLVMPointerWidth/8)
Mike Stumpab28c132009-10-13 22:54:56 +0000185 - 3*LLVMPointerWidth/8);
186 VBIndex[Base] = next_vbindex;
187 }
Mike Stump6a9612f2009-10-31 20:06:59 +0000188 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
189 VCalls.push_back((0?700:0) + BaseOffset);
190 D1(printf(" vbase for %s at %d delta %d most derived %s\n",
191 Base->getNameAsCString(),
192 (int)-VCalls.size()-3, (int)BaseOffset,
193 Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000194 }
Mike Stumpab28c132009-10-13 22:54:56 +0000195 // We also record offsets for non-virtual bases to closest enclosing
196 // virtual base. We do this so that we don't have to search
197 // for the nearst virtual base class when generating thunks.
198 if (updateVBIndex && VBIndex.count(Base) == 0)
199 VBIndex[Base] = next_vbindex;
Mike Stump6a9612f2009-10-31 20:06:59 +0000200 GenerateVBaseOffsets(Base, Offset, updateVBIndex, next_vbindex);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000201 }
202 }
203
204 void StartNewTable() {
205 SeenVBase.clear();
206 }
207
Mike Stump3425b972009-10-15 09:30:16 +0000208 Index_t getNVOffset_1(const CXXRecordDecl *D, const CXXRecordDecl *B,
209 Index_t Offset = 0) {
210
211 if (B == D)
212 return Offset;
213
214 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(D);
215 for (CXXRecordDecl::base_class_const_iterator i = D->bases_begin(),
216 e = D->bases_end(); i != e; ++i) {
217 const CXXRecordDecl *Base =
218 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
219 int64_t BaseOffset = 0;
220 if (!i->isVirtual())
221 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
222 int64_t o = getNVOffset_1(Base, B, BaseOffset);
223 if (o >= 0)
224 return o;
225 }
226
227 return -1;
228 }
229
230 /// getNVOffset - Returns the non-virtual offset for the given (B) base of the
231 /// derived class D.
232 Index_t getNVOffset(QualType qB, QualType qD) {
Mike Stump9c212892009-11-03 19:03:17 +0000233 qD = qD->getPointeeType();
234 qB = qB->getPointeeType();
Mike Stump3425b972009-10-15 09:30:16 +0000235 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
236 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
237 int64_t o = getNVOffset_1(D, B);
238 if (o >= 0)
239 return o;
240
241 assert(false && "FIXME: non-virtual base not found");
242 return 0;
243 }
244
Anders Carlssondbd920c2009-10-11 22:13:54 +0000245 /// getVbaseOffset - Returns the index into the vtable for the virtual base
246 /// offset for the given (B) virtual base of the derived class D.
247 Index_t getVbaseOffset(QualType qB, QualType qD) {
Mike Stump9c212892009-11-03 19:03:17 +0000248 qD = qD->getPointeeType();
249 qB = qB->getPointeeType();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000250 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
251 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
252 if (D != Class)
Eli Friedman76ed1f72009-11-30 01:19:33 +0000253 return CGM.getVtableInfo().getVirtualBaseOffsetIndex(D, B);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000254 llvm::DenseMap<const CXXRecordDecl *, Index_t>::iterator i;
255 i = VBIndex.find(B);
256 if (i != VBIndex.end())
257 return i->second;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000258
Mike Stumpab28c132009-10-13 22:54:56 +0000259 assert(false && "FIXME: Base not found");
Anders Carlssondbd920c2009-10-11 22:13:54 +0000260 return 0;
261 }
262
Anders Carlssona0fdd912009-11-13 17:08:56 +0000263 bool OverrideMethod(GlobalDecl GD, llvm::Constant *m,
Mike Stump3425b972009-10-15 09:30:16 +0000264 bool MorallyVirtual, Index_t OverrideOffset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000265 Index_t Offset, int64_t CurrentVBaseOffset) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000266 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
267
Mike Stump7809e0d2009-10-28 00:35:46 +0000268 const bool isPure = MD->isPure();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000269 typedef CXXMethodDecl::method_iterator meth_iter;
Mike Stump3425b972009-10-15 09:30:16 +0000270 // FIXME: Should OverrideOffset's be Offset?
Anders Carlssondbd920c2009-10-11 22:13:54 +0000271
272 // FIXME: Don't like the nested loops. For very large inheritance
273 // heirarchies we could have a table on the side with the final overridder
274 // and just replace each instance of an overridden method once. Would be
275 // nice to measure the cost/benefit on real code.
276
277 for (meth_iter mi = MD->begin_overridden_methods(),
278 e = MD->end_overridden_methods();
279 mi != e; ++mi) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000280 GlobalDecl OGD;
281
Anders Carlssondbd920c2009-10-11 22:13:54 +0000282 const CXXMethodDecl *OMD = *mi;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000283 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(OMD))
284 OGD = GlobalDecl(DD, GD.getDtorType());
285 else
286 OGD = OMD;
287
Anders Carlssondbd920c2009-10-11 22:13:54 +0000288 llvm::Constant *om;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000289 om = WrapAddrOf(OGD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000290 om = llvm::ConstantExpr::getBitCast(om, Ptr8Ty);
291
292 for (Index_t i = 0, e = submethods.size();
293 i != e; ++i) {
294 // FIXME: begin_overridden_methods might be too lax, covariance */
295 if (submethods[i] != om)
296 continue;
297 QualType nc_oret = OMD->getType()->getAs<FunctionType>()->getResultType();
298 CanQualType oret = CGM.getContext().getCanonicalType(nc_oret);
299 QualType nc_ret = MD->getType()->getAs<FunctionType>()->getResultType();
300 CanQualType ret = CGM.getContext().getCanonicalType(nc_ret);
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000301 ThunkAdjustment ReturnAdjustment;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000302 if (oret != ret) {
303 // FIXME: calculate offsets for covariance
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000304 CovariantThunksMapTy::iterator i = CovariantThunks.find(OMD);
305 if (i != CovariantThunks.end()) {
306 oret = i->second.ReturnType;
307 CovariantThunks.erase(i);
Mike Stumpd9878a12009-10-13 10:55:21 +0000308 }
Mike Stump3425b972009-10-15 09:30:16 +0000309 // FIXME: Double check oret
310 Index_t nv = getNVOffset(oret, ret)/8;
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000311 ReturnAdjustment = ThunkAdjustment(nv, getVbaseOffset(oret, ret));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000312 }
Anders Carlssona0fdd912009-11-13 17:08:56 +0000313 Index[GD] = i;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000314 submethods[i] = m;
Mike Stump7809e0d2009-10-28 00:35:46 +0000315 if (isPure)
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000316 PureVirtualMethods.insert(GD);
317 PureVirtualMethods.erase(OGD);
Anders Carlssona0fdd912009-11-13 17:08:56 +0000318 Thunks.erase(OGD);
319 if (MorallyVirtual || VCall.count(OGD)) {
320 Index_t &idx = VCall[OGD];
Anders Carlssondbd920c2009-10-11 22:13:54 +0000321 if (idx == 0) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000322 NonVirtualOffset[GD] = -OverrideOffset/8 + CurrentVBaseOffset/8;
323 VCallOffset[GD] = OverrideOffset/8;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000324 idx = VCalls.size()+1;
325 VCalls.push_back(0);
Mike Stump6a9612f2009-10-31 20:06:59 +0000326 D1(printf(" vcall for %s at %d with delta %d most derived %s\n",
Mike Stumpe99cc452009-11-13 23:45:53 +0000327 MD->getNameAsString().c_str(), (int)-idx-3,
328 (int)VCalls[idx-1], Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000329 } else {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000330 NonVirtualOffset[GD] = NonVirtualOffset[OGD];
331 VCallOffset[GD] = VCallOffset[OGD];
332 VCalls[idx-1] = -VCallOffset[OGD] + OverrideOffset/8;
Mike Stump6a9612f2009-10-31 20:06:59 +0000333 D1(printf(" vcall patch for %s at %d with delta %d most derived %s\n",
Mike Stumpe99cc452009-11-13 23:45:53 +0000334 MD->getNameAsString().c_str(), (int)-idx-3,
335 (int)VCalls[idx-1], Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000336 }
Anders Carlssona0fdd912009-11-13 17:08:56 +0000337 VCall[GD] = idx;
Anders Carlssondb131512009-11-26 03:25:13 +0000338 int64_t NonVirtualAdjustment = NonVirtualOffset[GD];
339 int64_t VirtualAdjustment =
340 -((idx + extra + 2) * LLVMPointerWidth / 8);
341
Mike Stump9e7e3c62009-11-06 23:27:42 +0000342 // Optimize out virtual adjustments of 0.
343 if (VCalls[idx-1] == 0)
Anders Carlssondb131512009-11-26 03:25:13 +0000344 VirtualAdjustment = 0;
345
Anders Carlssondb131512009-11-26 03:25:13 +0000346 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment,
347 VirtualAdjustment);
348
Mike Stump11dea942009-10-15 02:04:03 +0000349 // FIXME: Do we always have to build a covariant thunk to save oret,
350 // which is the containing virtual base class?
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000351 if (!ReturnAdjustment.isEmpty()) {
352 CovariantThunks[GD] =
353 CovariantThunk(i, ThisAdjustment, ReturnAdjustment, oret);
354 } else if (!isPure && !ThisAdjustment.isEmpty())
Anders Carlssondb131512009-11-26 03:25:13 +0000355 Thunks[GD] = Thunk(i, ThisAdjustment);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000356 return true;
357 }
Mike Stumpab28c132009-10-13 22:54:56 +0000358
Anders Carlssondbd920c2009-10-11 22:13:54 +0000359 // FIXME: finish off
Anders Carlssondb131512009-11-26 03:25:13 +0000360 int64_t NonVirtualAdjustment = VCallOffset[OGD] - OverrideOffset/8;
Mike Stump33c530e2009-11-06 02:38:24 +0000361
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000362 if (NonVirtualAdjustment || !ReturnAdjustment.isEmpty()) {
Anders Carlssondb131512009-11-26 03:25:13 +0000363 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment, 0);
Mike Stumpab28c132009-10-13 22:54:56 +0000364
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000365 if (!ReturnAdjustment.isEmpty()) {
366 CovariantThunks[GD] =
367 CovariantThunk(i, ThisAdjustment, ReturnAdjustment, oret);
368 } else if (!isPure)
Anders Carlssondb131512009-11-26 03:25:13 +0000369 Thunks[GD] = Thunk(i, ThisAdjustment);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000370 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000371 return true;
372 }
373 }
374
375 return false;
376 }
377
378 void InstallThunks() {
Anders Carlssondb131512009-11-26 03:25:13 +0000379 for (ThunksMapTy::const_iterator i = Thunks.begin(), e = Thunks.end();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000380 i != e; ++i) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000381 GlobalDecl GD = i->first;
382 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Anders Carlssondb131512009-11-26 03:25:13 +0000383 assert(!MD->isPure() && "Can't thunk pure virtual methods!");
384
385 const Thunk& Thunk = i->second;
386 assert(Thunk.Index == Index[GD] && "Thunk index mismatch!");
387
388 submethods[Thunk.Index] = CGM.BuildThunk(MD, Extern, Thunk.Adjustment);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000389 }
390 Thunks.clear();
Anders Carlssondb131512009-11-26 03:25:13 +0000391
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000392 for (CovariantThunksMapTy::const_iterator i = CovariantThunks.begin(),
393 e = CovariantThunks.end(); i != e; ++i) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000394 GlobalDecl GD = i->first;
395 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Mike Stump7809e0d2009-10-28 00:35:46 +0000396 if (MD->isPure())
397 continue;
Anders Carlsson7622cd32009-11-26 03:09:37 +0000398
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000399 const CovariantThunk &Thunk = i->second;
400 assert(Thunk.Index == Index[GD] && "Thunk index mismatch!");
401 submethods[Thunk.Index] =
402 CGM.BuildCovariantThunk(MD, Extern, Thunk.Adjustment);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000403 }
404 CovariantThunks.clear();
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000405
406 for (PureVirtualMethodsSetTy::iterator i = PureVirtualMethods.begin(),
407 e = PureVirtualMethods.end(); i != e; ++i) {
408 GlobalDecl GD = *i;
Anders Carlsson6d4ccb72009-11-26 19:54:33 +0000409 submethods[Index[GD]] = getPureVirtualFn();
Mike Stump94aff932009-10-27 23:46:47 +0000410 }
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000411 PureVirtualMethods.clear();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000412 }
413
Anders Carlssona0fdd912009-11-13 17:08:56 +0000414 llvm::Constant *WrapAddrOf(GlobalDecl GD) {
415 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
416
Mike Stump1ae31782009-10-27 23:36:26 +0000417 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(MD))
Anders Carlssona0fdd912009-11-13 17:08:56 +0000418 return wrap(CGM.GetAddrOfCXXDestructor(Dtor, GD.getDtorType()));
Mike Stump1ae31782009-10-27 23:36:26 +0000419
Anders Carlssonecf282b2009-11-24 05:08:52 +0000420 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVtable(MD);
Mike Stump1ae31782009-10-27 23:36:26 +0000421
422 return wrap(CGM.GetAddrOfFunction(MD, Ty));
423 }
424
Mike Stump9e7e3c62009-11-06 23:27:42 +0000425 void OverrideMethods(Path_t *Path, bool MorallyVirtual, int64_t Offset,
426 int64_t CurrentVBaseOffset) {
Mike Stump11dea942009-10-15 02:04:03 +0000427 for (Path_t::reverse_iterator i = Path->rbegin(),
Anders Carlssondbd920c2009-10-11 22:13:54 +0000428 e = Path->rend(); i != e; ++i) {
429 const CXXRecordDecl *RD = i->first;
Mike Stump3425b972009-10-15 09:30:16 +0000430 int64_t OverrideOffset = i->second;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000431 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
432 ++mi) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000433 const CXXMethodDecl *MD = *mi;
434
435 if (!MD->isVirtual())
Anders Carlssondbd920c2009-10-11 22:13:54 +0000436 continue;
437
Anders Carlssona0fdd912009-11-13 17:08:56 +0000438 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
439 // Override both the complete and the deleting destructor.
440 GlobalDecl CompDtor(DD, Dtor_Complete);
441 OverrideMethod(CompDtor, WrapAddrOf(CompDtor), MorallyVirtual,
442 OverrideOffset, Offset, CurrentVBaseOffset);
443
444 GlobalDecl DeletingDtor(DD, Dtor_Deleting);
445 OverrideMethod(DeletingDtor, WrapAddrOf(DeletingDtor), MorallyVirtual,
446 OverrideOffset, Offset, CurrentVBaseOffset);
447 } else {
448 OverrideMethod(MD, WrapAddrOf(MD), MorallyVirtual, OverrideOffset,
449 Offset, CurrentVBaseOffset);
450 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000451 }
452 }
453 }
454
Anders Carlssona0fdd912009-11-13 17:08:56 +0000455 void AddMethod(const GlobalDecl GD, bool MorallyVirtual, Index_t Offset,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000456 int64_t CurrentVBaseOffset) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000457 llvm::Constant *m = WrapAddrOf(GD);
Mike Stump1ae31782009-10-27 23:36:26 +0000458
Anders Carlssondbd920c2009-10-11 22:13:54 +0000459 // If we can find a previously allocated slot for this, reuse it.
Anders Carlssona0fdd912009-11-13 17:08:56 +0000460 if (OverrideMethod(GD, m, MorallyVirtual, Offset, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000461 CurrentVBaseOffset))
Anders Carlssondbd920c2009-10-11 22:13:54 +0000462 return;
463
Anders Carlssona0fdd912009-11-13 17:08:56 +0000464 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
465
Anders Carlssondbd920c2009-10-11 22:13:54 +0000466 // else allocate a new slot.
Anders Carlssona0fdd912009-11-13 17:08:56 +0000467 Index[GD] = submethods.size();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000468 submethods.push_back(m);
Mike Stumpe99cc452009-11-13 23:45:53 +0000469 D1(printf(" vfn for %s at %d\n", MD->getNameAsString().c_str(),
470 (int)Index[GD]));
Mike Stump7809e0d2009-10-28 00:35:46 +0000471 if (MD->isPure())
Anders Carlsson5dd730a2009-11-26 19:32:45 +0000472 PureVirtualMethods.insert(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000473 if (MorallyVirtual) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000474 VCallOffset[GD] = Offset/8;
475 Index_t &idx = VCall[GD];
Anders Carlssondbd920c2009-10-11 22:13:54 +0000476 // Allocate the first one, after that, we reuse the previous one.
477 if (idx == 0) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000478 NonVirtualOffset[GD] = CurrentVBaseOffset/8 - Offset/8;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000479 idx = VCalls.size()+1;
480 VCalls.push_back(0);
Mike Stump6a9612f2009-10-31 20:06:59 +0000481 D1(printf(" vcall for %s at %d with delta %d\n",
Mike Stumpe99cc452009-11-13 23:45:53 +0000482 MD->getNameAsString().c_str(), (int)-VCalls.size()-3, 0));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000483 }
484 }
485 }
486
487 void AddMethods(const CXXRecordDecl *RD, bool MorallyVirtual,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000488 Index_t Offset, int64_t CurrentVBaseOffset) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000489 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
Anders Carlssona0fdd912009-11-13 17:08:56 +0000490 ++mi) {
491 const CXXMethodDecl *MD = *mi;
492 if (!MD->isVirtual())
493 continue;
494
495 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
496 // For destructors, add both the complete and the deleting destructor
497 // to the vtable.
498 AddMethod(GlobalDecl(DD, Dtor_Complete), MorallyVirtual, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000499 CurrentVBaseOffset);
Eli Friedman76ed1f72009-11-30 01:19:33 +0000500 AddMethod(GlobalDecl(DD, Dtor_Deleting), MorallyVirtual, Offset,
501 CurrentVBaseOffset);
502 } else
503 AddMethod(MD, MorallyVirtual, Offset, CurrentVBaseOffset);
Anders Carlssona0fdd912009-11-13 17:08:56 +0000504 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000505 }
506
507 void NonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
508 const CXXRecordDecl *PrimaryBase,
509 bool PrimaryBaseWasVirtual, bool MorallyVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000510 int64_t Offset, int64_t CurrentVBaseOffset,
511 Path_t *Path) {
Mike Stump11dea942009-10-15 02:04:03 +0000512 Path->push_back(std::make_pair(RD, Offset));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000513 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
514 e = RD->bases_end(); i != e; ++i) {
515 if (i->isVirtual())
516 continue;
517 const CXXRecordDecl *Base =
518 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
519 if (Base != PrimaryBase || PrimaryBaseWasVirtual) {
520 uint64_t o = Offset + Layout.getBaseClassOffset(Base);
521 StartNewTable();
Mike Stump4cde6262009-11-13 02:13:54 +0000522 GenerateVtableForBase(Base, o, MorallyVirtual, false,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000523 CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000524 }
525 }
Mike Stump11dea942009-10-15 02:04:03 +0000526 Path->pop_back();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000527 }
528
Mike Stump0ca42792009-10-14 18:14:51 +0000529// #define D(X) do { X; } while (0)
530#define D(X)
531
532 void insertVCalls(int InsertionPoint) {
533 llvm::Constant *e = 0;
Mike Stump6a9612f2009-10-31 20:06:59 +0000534 D1(printf("============= combining vbase/vcall\n"));
Mike Stump0ca42792009-10-14 18:14:51 +0000535 D(VCalls.insert(VCalls.begin(), 673));
536 D(VCalls.push_back(672));
Mike Stump3425b972009-10-15 09:30:16 +0000537 methods.insert(methods.begin() + InsertionPoint, VCalls.size(), e);
Mike Stump0ca42792009-10-14 18:14:51 +0000538 // The vcalls come first...
539 for (std::vector<Index_t>::reverse_iterator i = VCalls.rbegin(),
540 e = VCalls.rend();
541 i != e; ++i)
542 methods[InsertionPoint++] = wrap((0?600:0) + *i);
543 VCalls.clear();
Mike Stumpfbfb52d2009-11-10 02:30:51 +0000544 VCall.clear();
Mike Stump0ca42792009-10-14 18:14:51 +0000545 }
546
Mike Stump65d0e282009-11-13 23:13:20 +0000547 void AddAddressPoints(const CXXRecordDecl *RD, uint64_t Offset,
548 Index_t AddressPoint) {
549 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
550 RD->getNameAsCString(), Class->getNameAsCString(),
551 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump23a35422009-11-19 20:52:19 +0000552 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Mike Stump65d0e282009-11-13 23:13:20 +0000553
554 // Now also add the address point for all our primary bases.
555 while (1) {
556 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
557 RD = Layout.getPrimaryBase();
558 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
559 // FIXME: Double check this.
560 if (RD == 0)
561 break;
562 if (PrimaryBaseWasVirtual &&
563 BLayout.getVBaseClassOffset(RD) != Offset)
564 break;
565 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
566 RD->getNameAsCString(), Class->getNameAsCString(),
567 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump23a35422009-11-19 20:52:19 +0000568 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Mike Stump65d0e282009-11-13 23:13:20 +0000569 }
570 }
571
572
Mike Stump6a9612f2009-10-31 20:06:59 +0000573 Index_t end(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
574 const CXXRecordDecl *PrimaryBase, bool PrimaryBaseWasVirtual,
575 bool MorallyVirtual, int64_t Offset, bool ForVirtualBase,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000576 int64_t CurrentVBaseOffset,
Mike Stump6a9612f2009-10-31 20:06:59 +0000577 Path_t *Path) {
Mike Stump11dea942009-10-15 02:04:03 +0000578 bool alloc = false;
579 if (Path == 0) {
580 alloc = true;
581 Path = new Path_t;
582 }
583
Anders Carlssondbd920c2009-10-11 22:13:54 +0000584 StartNewTable();
585 extra = 0;
Mike Stump0ca42792009-10-14 18:14:51 +0000586 bool DeferVCalls = MorallyVirtual || ForVirtualBase;
587 int VCallInsertionPoint = methods.size();
588 if (!DeferVCalls) {
589 insertVCalls(VCallInsertionPoint);
Mike Stump3425b972009-10-15 09:30:16 +0000590 } else
591 // FIXME: just for extra, or for all uses of VCalls.size post this?
592 extra = -VCalls.size();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000593
Mike Stump4cde6262009-11-13 02:13:54 +0000594 methods.push_back(wrap(-((Offset-LayoutOffset)/8)));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000595 methods.push_back(rtti);
596 Index_t AddressPoint = methods.size();
597
598 InstallThunks();
Mike Stump6a9612f2009-10-31 20:06:59 +0000599 D1(printf("============= combining methods\n"));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000600 methods.insert(methods.end(), submethods.begin(), submethods.end());
601 submethods.clear();
602
603 // and then the non-virtual bases.
604 NonVirtualBases(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000605 MorallyVirtual, Offset, CurrentVBaseOffset, Path);
Mike Stump0ca42792009-10-14 18:14:51 +0000606
607 if (ForVirtualBase) {
Mike Stump9840c702009-11-12 20:47:57 +0000608 // FIXME: We're adding to VCalls in callers, we need to do the overrides
609 // in the inner part, so that we know the complete set of vcalls during
610 // the build and don't have to insert into methods. Saving out the
611 // AddressPoint here, would need to be fixed, if we didn't do that. Also
612 // retroactively adding vcalls for overrides later wind up in the wrong
613 // place, the vcall slot has to be alloted during the walk of the base
614 // when the function is first introduces.
Mike Stump0ca42792009-10-14 18:14:51 +0000615 AddressPoint += VCalls.size();
Mike Stump9840c702009-11-12 20:47:57 +0000616 insertVCalls(VCallInsertionPoint);
Mike Stump0ca42792009-10-14 18:14:51 +0000617 }
618
Mike Stump65d0e282009-11-13 23:13:20 +0000619 AddAddressPoints(RD, Offset, AddressPoint);
Mike Stump9840c702009-11-12 20:47:57 +0000620
Mike Stump11dea942009-10-15 02:04:03 +0000621 if (alloc) {
622 delete Path;
623 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000624 return AddressPoint;
625 }
626
Mike Stump6a9612f2009-10-31 20:06:59 +0000627 void Primaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
628 bool updateVBIndex, Index_t current_vbindex,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000629 int64_t CurrentVBaseOffset) {
Mike Stump6a9612f2009-10-31 20:06:59 +0000630 if (!RD->isDynamicClass())
631 return;
632
633 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
634 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
635 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
636
637 // vtables are composed from the chain of primaries.
638 if (PrimaryBase) {
639 D1(printf(" doing primaries for %s most derived %s\n",
640 RD->getNameAsCString(), Class->getNameAsCString()));
641
Mike Stump9e7e3c62009-11-06 23:27:42 +0000642 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
643 if (PrimaryBaseWasVirtual)
644 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
645
Mike Stump6a9612f2009-10-31 20:06:59 +0000646 if (!PrimaryBaseWasVirtual)
647 Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000648 updateVBIndex, current_vbindex, BaseCurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +0000649 }
650
651 D1(printf(" doing vcall entries for %s most derived %s\n",
652 RD->getNameAsCString(), Class->getNameAsCString()));
653
654 // And add the virtuals for the class to the primary vtable.
Eli Friedman76ed1f72009-11-30 01:19:33 +0000655 AddMethods(RD, MorallyVirtual, Offset, CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +0000656 }
657
658 void VBPrimaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
659 bool updateVBIndex, Index_t current_vbindex,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000660 bool RDisVirtualBase, int64_t CurrentVBaseOffset,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000661 bool bottom) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000662 if (!RD->isDynamicClass())
663 return;
664
665 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
666 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
667 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
668
669 // vtables are composed from the chain of primaries.
670 if (PrimaryBase) {
Mike Stump9e7e3c62009-11-06 23:27:42 +0000671 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
672 if (PrimaryBaseWasVirtual) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000673 IndirectPrimary.insert(PrimaryBase);
Mike Stump9e7e3c62009-11-06 23:27:42 +0000674 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
675 }
Mike Stump6a9612f2009-10-31 20:06:59 +0000676
677 D1(printf(" doing primaries for %s most derived %s\n",
678 RD->getNameAsCString(), Class->getNameAsCString()));
679
680 VBPrimaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000681 updateVBIndex, current_vbindex, PrimaryBaseWasVirtual,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000682 BaseCurrentVBaseOffset, false);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000683 }
684
Mike Stump6a9612f2009-10-31 20:06:59 +0000685 D1(printf(" doing vbase entries for %s most derived %s\n",
686 RD->getNameAsCString(), Class->getNameAsCString()));
687 GenerateVBaseOffsets(RD, Offset, updateVBIndex, current_vbindex);
688
689 if (RDisVirtualBase || bottom) {
690 Primaries(RD, MorallyVirtual, Offset, updateVBIndex, current_vbindex,
Eli Friedman76ed1f72009-11-30 01:19:33 +0000691 CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +0000692 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000693 }
694
Mike Stump4cde6262009-11-13 02:13:54 +0000695 int64_t GenerateVtableForBase(const CXXRecordDecl *RD, int64_t Offset = 0,
696 bool MorallyVirtual = false,
Anders Carlssondbd920c2009-10-11 22:13:54 +0000697 bool ForVirtualBase = false,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000698 int CurrentVBaseOffset = 0,
Mike Stump11dea942009-10-15 02:04:03 +0000699 Path_t *Path = 0) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000700 if (!RD->isDynamicClass())
701 return 0;
702
Mike Stump92774d12009-11-13 02:35:38 +0000703 // Construction vtable don't need parts that have no virtual bases and
704 // aren't morally virtual.
705 if ((LayoutClass != Class) && RD->getNumVBases() == 0 && !MorallyVirtual)
706 return 0;
707
Anders Carlssondbd920c2009-10-11 22:13:54 +0000708 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
709 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
710 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
711
Anders Carlssondbd920c2009-10-11 22:13:54 +0000712 extra = 0;
Mike Stump6a9612f2009-10-31 20:06:59 +0000713 D1(printf("building entries for base %s most derived %s\n",
714 RD->getNameAsCString(), Class->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +0000715
Mike Stump6a9612f2009-10-31 20:06:59 +0000716 if (ForVirtualBase)
717 extra = VCalls.size();
718
719 VBPrimaries(RD, MorallyVirtual, Offset, !ForVirtualBase, 0, ForVirtualBase,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000720 CurrentVBaseOffset, true);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000721
722 if (Path)
Mike Stump9e7e3c62009-11-06 23:27:42 +0000723 OverrideMethods(Path, MorallyVirtual, Offset, CurrentVBaseOffset);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000724
Mike Stump6a9612f2009-10-31 20:06:59 +0000725 return end(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual, MorallyVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000726 Offset, ForVirtualBase, CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000727 }
728
729 void GenerateVtableForVBases(const CXXRecordDecl *RD,
730 int64_t Offset = 0,
Mike Stump11dea942009-10-15 02:04:03 +0000731 Path_t *Path = 0) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000732 bool alloc = false;
733 if (Path == 0) {
734 alloc = true;
Mike Stump11dea942009-10-15 02:04:03 +0000735 Path = new Path_t;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000736 }
737 // FIXME: We also need to override using all paths to a virtual base,
738 // right now, we just process the first path
739 Path->push_back(std::make_pair(RD, Offset));
740 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
741 e = RD->bases_end(); i != e; ++i) {
742 const CXXRecordDecl *Base =
743 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
744 if (i->isVirtual() && !IndirectPrimary.count(Base)) {
745 // Mark it so we don't output it twice.
746 IndirectPrimary.insert(Base);
747 StartNewTable();
Mike Stump0ca42792009-10-14 18:14:51 +0000748 VCall.clear();
Anders Carlssondbd920c2009-10-11 22:13:54 +0000749 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump9e7e3c62009-11-06 23:27:42 +0000750 int64_t CurrentVBaseOffset = BaseOffset;
Mike Stump6a9612f2009-10-31 20:06:59 +0000751 D1(printf("vtable %s virtual base %s\n",
752 Class->getNameAsCString(), Base->getNameAsCString()));
Mike Stump4cde6262009-11-13 02:13:54 +0000753 GenerateVtableForBase(Base, BaseOffset, true, true, CurrentVBaseOffset,
Mike Stump9e7e3c62009-11-06 23:27:42 +0000754 Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000755 }
Mike Stump9840c702009-11-12 20:47:57 +0000756 int64_t BaseOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +0000757 if (i->isVirtual())
758 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump9840c702009-11-12 20:47:57 +0000759 else {
760 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
761 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
762 }
763
Mike Stump11dea942009-10-15 02:04:03 +0000764 if (Base->getNumVBases()) {
Anders Carlssondbd920c2009-10-11 22:13:54 +0000765 GenerateVtableForVBases(Base, BaseOffset, Path);
Mike Stump11dea942009-10-15 02:04:03 +0000766 }
Anders Carlssondbd920c2009-10-11 22:13:54 +0000767 }
768 Path->pop_back();
769 if (alloc)
770 delete Path;
771 }
772};
Anders Carlsson27f69d02009-11-27 22:21:51 +0000773}
774
Anders Carlssond6b07fb2009-11-27 20:47:55 +0000775/// TypeConversionRequiresAdjustment - Returns whether conversion from a
776/// derived type to a base type requires adjustment.
777static bool
778TypeConversionRequiresAdjustment(ASTContext &Ctx,
779 const CXXRecordDecl *DerivedDecl,
780 const CXXRecordDecl *BaseDecl) {
781 CXXBasePaths Paths(/*FindAmbiguities=*/false,
782 /*RecordPaths=*/true, /*DetectVirtual=*/true);
783 if (!const_cast<CXXRecordDecl *>(DerivedDecl)->
784 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseDecl), Paths)) {
785 assert(false && "Class must be derived from the passed in base class!");
786 return false;
787 }
788
Anders Carlsson724e3e22009-11-28 03:03:52 +0000789 // If we found a virtual base we always want to require adjustment.
790 if (Paths.getDetectedVirtual())
791 return true;
792
Anders Carlssond6b07fb2009-11-27 20:47:55 +0000793 const CXXBasePath &Path = Paths.front();
794
Anders Carlsson724e3e22009-11-28 03:03:52 +0000795 for (size_t Start = 0, End = Path.size(); Start != End; ++Start) {
Anders Carlssond6b07fb2009-11-27 20:47:55 +0000796 const CXXBasePathElement &Element = Path[Start];
797
798 // Check the base class offset.
799 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(Element.Class);
800
801 const RecordType *BaseType = Element.Base->getType()->getAs<RecordType>();
802 const CXXRecordDecl *Base = cast<CXXRecordDecl>(BaseType->getDecl());
803
804 if (Layout.getBaseClassOffset(Base) != 0) {
805 // This requires an adjustment.
806 return true;
807 }
808 }
809
810 return false;
811}
812
813static bool
814TypeConversionRequiresAdjustment(ASTContext &Ctx,
815 QualType DerivedType, QualType BaseType) {
816 // Canonicalize the types.
817 QualType CanDerivedType = Ctx.getCanonicalType(DerivedType);
818 QualType CanBaseType = Ctx.getCanonicalType(BaseType);
819
820 assert(CanDerivedType->getTypeClass() == CanBaseType->getTypeClass() &&
821 "Types must have same type class!");
822
823 if (CanDerivedType == CanBaseType) {
824 // No adjustment needed.
825 return false;
826 }
827
828 if (const ReferenceType *RT = dyn_cast<ReferenceType>(CanDerivedType)) {
829 CanDerivedType = RT->getPointeeType();
830 CanBaseType = cast<ReferenceType>(CanBaseType)->getPointeeType();
831 } else if (const PointerType *PT = dyn_cast<PointerType>(CanDerivedType)) {
832 CanDerivedType = PT->getPointeeType();
833 CanBaseType = cast<PointerType>(CanBaseType)->getPointeeType();
834 } else {
835 assert(false && "Unexpected return type!");
836 }
837
838 if (CanDerivedType == CanBaseType) {
839 // No adjustment needed.
840 return false;
841 }
842
843 const CXXRecordDecl *DerivedDecl =
844 cast<CXXRecordDecl>(cast<RecordType>(CanDerivedType)->getDecl());
845
846 const CXXRecordDecl *BaseDecl =
847 cast<CXXRecordDecl>(cast<RecordType>(CanBaseType)->getDecl());
848
849 return TypeConversionRequiresAdjustment(Ctx, DerivedDecl, BaseDecl);
850}
851
852void CGVtableInfo::ComputeMethodVtableIndices(const CXXRecordDecl *RD) {
853
854 // Itanium C++ ABI 2.5.2:
855 // The order of the virtual function pointers in a virtual table is the
856 // order of declaration of the corresponding member functions in the class.
857 //
858 // There is an entry for any virtual function declared in a class,
859 // whether it is a new function or overrides a base class function,
860 // unless it overrides a function from the primary base, and conversion
861 // between their return types does not require an adjustment.
862
863 int64_t CurrentIndex = 0;
864
865 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
866 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
867
868 if (PrimaryBase) {
Anders Carlsson0121fbd2009-11-30 19:43:26 +0000869 assert(PrimaryBase->isDefinition() &&
870 "Should have the definition decl of the primary base!");
Anders Carlssond6b07fb2009-11-27 20:47:55 +0000871
872 // Since the record decl shares its vtable pointer with the primary base
873 // we need to start counting at the end of the primary base's vtable.
874 CurrentIndex = getNumVirtualFunctionPointers(PrimaryBase);
875 }
876
877 const CXXDestructorDecl *ImplicitVirtualDtor = 0;
878
879 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
880 e = RD->method_end(); i != e; ++i) {
881 const CXXMethodDecl *MD = *i;
882
883 // We only want virtual methods.
884 if (!MD->isVirtual())
885 continue;
886
887 bool ShouldAddEntryForMethod = true;
888
889 // Check if this method overrides a method in the primary base.
890 for (CXXMethodDecl::method_iterator i = MD->begin_overridden_methods(),
891 e = MD->end_overridden_methods(); i != e; ++i) {
892 const CXXMethodDecl *OverriddenMD = *i;
893 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
894 assert(OverriddenMD->isCanonicalDecl() &&
895 "Should have the canonical decl of the overridden RD!");
896
897 if (OverriddenRD == PrimaryBase) {
898 // Check if converting from the return type of the method to the
899 // return type of the overridden method requires conversion.
900 QualType ReturnType =
901 MD->getType()->getAs<FunctionType>()->getResultType();
902 QualType OverriddenReturnType =
903 OverriddenMD->getType()->getAs<FunctionType>()->getResultType();
904
905 if (!TypeConversionRequiresAdjustment(CGM.getContext(),
906 ReturnType, OverriddenReturnType)) {
907 // This index is shared between the index in the vtable of the primary
908 // base class.
909 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
910 const CXXDestructorDecl *OverriddenDD =
911 cast<CXXDestructorDecl>(OverriddenMD);
912
913 // Add both the complete and deleting entries.
914 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] =
915 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Complete));
916 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] =
917 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
918 } else {
919 MethodVtableIndices[MD] = getMethodVtableIndex(OverriddenMD);
920 }
921
922 // We don't need to add an entry for this method.
923 ShouldAddEntryForMethod = false;
924 break;
925 }
926 }
927 }
928
929 if (!ShouldAddEntryForMethod)
930 continue;
931
932 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
933 if (MD->isImplicit()) {
934 assert(!ImplicitVirtualDtor &&
935 "Did already see an implicit virtual dtor!");
936 ImplicitVirtualDtor = DD;
937 continue;
938 }
939
940 // Add the complete dtor.
941 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++;
942
943 // Add the deleting dtor.
944 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
945 } else {
946 // Add the entry.
947 MethodVtableIndices[MD] = CurrentIndex++;
948 }
949 }
950
951 if (ImplicitVirtualDtor) {
952 // Itanium C++ ABI 2.5.2:
953 // If a class has an implicitly-defined virtual destructor,
954 // its entries come after the declared virtual function pointers.
955
956 // Add the complete dtor.
957 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Complete)] =
958 CurrentIndex++;
959
960 // Add the deleting dtor.
961 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Deleting)] =
962 CurrentIndex++;
963 }
964
965 NumVirtualFunctionPointers[RD] = CurrentIndex;
966}
967
968uint64_t CGVtableInfo::getNumVirtualFunctionPointers(const CXXRecordDecl *RD) {
969 llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
970 NumVirtualFunctionPointers.find(RD);
971 if (I != NumVirtualFunctionPointers.end())
972 return I->second;
973
974 ComputeMethodVtableIndices(RD);
975
976 I = NumVirtualFunctionPointers.find(RD);
977 assert(I != NumVirtualFunctionPointers.end() && "Did not find entry!");
978 return I->second;
979}
980
981uint64_t CGVtableInfo::getMethodVtableIndex(GlobalDecl GD) {
Anders Carlssona0fdd912009-11-13 17:08:56 +0000982 MethodVtableIndicesTy::iterator I = MethodVtableIndices.find(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000983 if (I != MethodVtableIndices.end())
984 return I->second;
985
Anders Carlssona0fdd912009-11-13 17:08:56 +0000986 const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
Anders Carlssond6b07fb2009-11-27 20:47:55 +0000987
988 ComputeMethodVtableIndices(RD);
989
Anders Carlssona0fdd912009-11-13 17:08:56 +0000990 I = MethodVtableIndices.find(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +0000991 assert(I != MethodVtableIndices.end() && "Did not find index!");
992 return I->second;
993}
994
995int64_t CGVtableInfo::getVirtualBaseOffsetIndex(const CXXRecordDecl *RD,
996 const CXXRecordDecl *VBase) {
997 ClassPairTy ClassPair(RD, VBase);
998
999 VirtualBaseClassIndiciesTy::iterator I =
1000 VirtualBaseClassIndicies.find(ClassPair);
1001 if (I != VirtualBaseClassIndicies.end())
1002 return I->second;
1003
1004 std::vector<llvm::Constant *> methods;
1005 // FIXME: This seems expensive. Can we do a partial job to get
1006 // just this data.
Mike Stump4cde6262009-11-13 02:13:54 +00001007 VtableBuilder b(methods, RD, RD, 0, CGM);
Mike Stump6a9612f2009-10-31 20:06:59 +00001008 D1(printf("vtable %s\n", RD->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +00001009 b.GenerateVtableForBase(RD);
1010 b.GenerateVtableForVBases(RD);
1011
1012 for (llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
1013 b.getVBIndex().begin(), E = b.getVBIndex().end(); I != E; ++I) {
1014 // Insert all types.
1015 ClassPairTy ClassPair(RD, I->first);
1016
1017 VirtualBaseClassIndicies.insert(std::make_pair(ClassPair, I->second));
1018 }
1019
1020 I = VirtualBaseClassIndicies.find(ClassPair);
1021 assert(I != VirtualBaseClassIndicies.end() && "Did not find index!");
1022
1023 return I->second;
1024}
1025
Mike Stump9840c702009-11-12 20:47:57 +00001026llvm::Constant *CodeGenModule::GenerateVtable(const CXXRecordDecl *LayoutClass,
1027 const CXXRecordDecl *RD,
Mike Stump8cfcb522009-11-11 20:26:26 +00001028 uint64_t Offset) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00001029 llvm::SmallString<256> OutName;
Mike Stump9840c702009-11-12 20:47:57 +00001030 if (LayoutClass != RD)
Daniel Dunbar94fd26d2009-11-21 09:06:22 +00001031 getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset/8, RD, OutName);
Mike Stump8cfcb522009-11-11 20:26:26 +00001032 else
Daniel Dunbar94fd26d2009-11-21 09:06:22 +00001033 getMangleContext().mangleCXXVtable(RD, OutName);
1034 llvm::StringRef Name = OutName.str();
Benjamin Kramer7a9474e2009-10-11 22:57:54 +00001035
Anders Carlssondbd920c2009-10-11 22:13:54 +00001036 std::vector<llvm::Constant *> methods;
1037 llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1038 int64_t AddressPoint;
1039
Mike Stump85615df2009-11-19 04:04:36 +00001040 llvm::GlobalVariable *GV = getModule().getGlobalVariable(Name);
Mike Stump23a35422009-11-19 20:52:19 +00001041 if (GV && AddressPoints[LayoutClass] && !GV->isDeclaration()) {
Mike Stump85615df2009-11-19 04:04:36 +00001042 AddressPoint=(*(*(AddressPoints[LayoutClass]))[RD])[std::make_pair(RD,
1043 Offset)];
Mike Stump23a35422009-11-19 20:52:19 +00001044 // FIXME: We can never have 0 address point. Do this for now so gepping
1045 // retains the same structure. Later, we'll just assert.
1046 if (AddressPoint == 0)
1047 AddressPoint = 1;
1048 } else {
Mike Stump85615df2009-11-19 04:04:36 +00001049 VtableBuilder b(methods, RD, LayoutClass, Offset, *this);
Anders Carlssondbd920c2009-10-11 22:13:54 +00001050
Mike Stump85615df2009-11-19 04:04:36 +00001051 D1(printf("vtable %s\n", RD->getNameAsCString()));
1052 // First comes the vtables for all the non-virtual bases...
1053 AddressPoint = b.GenerateVtableForBase(RD, Offset);
Anders Carlssondbd920c2009-10-11 22:13:54 +00001054
Mike Stump85615df2009-11-19 04:04:36 +00001055 // then the vtables for all the virtual bases.
1056 b.GenerateVtableForVBases(RD, Offset);
Anders Carlssondbd920c2009-10-11 22:13:54 +00001057
Mike Stump85615df2009-11-19 04:04:36 +00001058 bool CreateDefinition = true;
1059 if (LayoutClass != RD)
1060 CreateDefinition = true;
1061 else {
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00001062 const ASTRecordLayout &Layout =
1063 getContext().getASTRecordLayout(LayoutClass);
1064
1065 if (const CXXMethodDecl *KeyFunction = Layout.getKeyFunction()) {
Mike Stump85615df2009-11-19 04:04:36 +00001066 if (!KeyFunction->getBody()) {
1067 // If there is a KeyFunction, and it isn't defined, just build a
1068 // reference to the vtable.
1069 CreateDefinition = false;
1070 }
1071 }
1072 }
1073
1074 llvm::Constant *C = 0;
1075 llvm::Type *type = Ptr8Ty;
1076 llvm::GlobalVariable::LinkageTypes linktype
1077 = llvm::GlobalValue::ExternalLinkage;
1078 if (CreateDefinition) {
1079 llvm::ArrayType *ntype = llvm::ArrayType::get(Ptr8Ty, methods.size());
1080 C = llvm::ConstantArray::get(ntype, methods);
1081 linktype = llvm::GlobalValue::LinkOnceODRLinkage;
1082 if (LayoutClass->isInAnonymousNamespace())
1083 linktype = llvm::GlobalValue::InternalLinkage;
1084 type = ntype;
1085 }
1086 llvm::GlobalVariable *OGV = GV;
1087 GV = new llvm::GlobalVariable(getModule(), type, true, linktype, C, Name);
1088 if (OGV) {
1089 GV->takeName(OGV);
1090 llvm::Constant *NewPtr = llvm::ConstantExpr::getBitCast(GV,
1091 OGV->getType());
1092 OGV->replaceAllUsesWith(NewPtr);
1093 OGV->eraseFromParent();
1094 }
1095 bool Hidden = getDeclVisibilityMode(RD) == LangOptions::Hidden;
1096 if (Hidden)
1097 GV->setVisibility(llvm::GlobalVariable::HiddenVisibility);
1098 }
Mike Stumpe56ceca2009-11-18 04:00:48 +00001099 llvm::Constant *vtable = llvm::ConstantExpr::getBitCast(GV, Ptr8Ty);
Mike Stump380dd752009-11-10 07:44:33 +00001100 llvm::Constant *AddressPointC;
1101 uint32_t LLVMPointerWidth = getContext().Target.getPointerWidth(0);
1102 AddressPointC = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
1103 AddressPoint*LLVMPointerWidth/8);
Mike Stump9840c702009-11-12 20:47:57 +00001104 vtable = llvm::ConstantExpr::getInBoundsGetElementPtr(vtable, &AddressPointC,
1105 1);
Mike Stump380dd752009-11-10 07:44:33 +00001106
Mike Stump23a35422009-11-19 20:52:19 +00001107 assert(vtable->getType() == Ptr8Ty);
Anders Carlssondbd920c2009-10-11 22:13:54 +00001108 return vtable;
1109}
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001110
Mike Stump92f2fe22009-12-02 19:07:44 +00001111namespace {
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001112class VTTBuilder {
1113 /// Inits - The list of values built for the VTT.
1114 std::vector<llvm::Constant *> &Inits;
1115 /// Class - The most derived class that this vtable is being built for.
1116 const CXXRecordDecl *Class;
1117 CodeGenModule &CGM; // Per-module state.
Mike Stump971977f2009-11-11 00:35:07 +00001118 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
Mike Stumpaee8de32009-11-11 03:08:24 +00001119 /// BLayout - Layout for the most derived class that this vtable is being
1120 /// built for.
1121 const ASTRecordLayout &BLayout;
Mike Stumpacfd1e52009-11-13 01:54:23 +00001122 CodeGenModule::AddrMap_t &AddressPoints;
Mike Stump9840c702009-11-12 20:47:57 +00001123 // vtbl - A pointer to the vtable for Class.
1124 llvm::Constant *ClassVtbl;
1125 llvm::LLVMContext &VMContext;
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001126
Mike Stump28f7ce12009-11-12 22:56:32 +00001127 /// BuildVtablePtr - Build up a referene to the given secondary vtable
Mike Stumpacfd1e52009-11-13 01:54:23 +00001128 llvm::Constant *BuildVtablePtr(llvm::Constant *vtbl,
1129 const CXXRecordDecl *VtblClass,
1130 const CXXRecordDecl *RD,
Mike Stump28f7ce12009-11-12 22:56:32 +00001131 uint64_t Offset) {
1132 int64_t AddressPoint;
Mike Stumpacfd1e52009-11-13 01:54:23 +00001133 AddressPoint = (*AddressPoints[VtblClass])[std::make_pair(RD, Offset)];
Mike Stump80ac2352009-11-12 23:36:21 +00001134 // FIXME: We can never have 0 address point. Do this for now so gepping
Mike Stump23a35422009-11-19 20:52:19 +00001135 // retains the same structure. Later we'll just assert.
Mike Stump80ac2352009-11-12 23:36:21 +00001136 if (AddressPoint == 0)
1137 AddressPoint = 1;
Mike Stumpacfd1e52009-11-13 01:54:23 +00001138 D1(printf("XXX address point for %s in %s layout %s at offset %d was %d\n",
1139 RD->getNameAsCString(), VtblClass->getNameAsCString(),
1140 Class->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump28f7ce12009-11-12 22:56:32 +00001141 uint32_t LLVMPointerWidth = CGM.getContext().Target.getPointerWidth(0);
1142 llvm::Constant *init;
1143 init = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
1144 AddressPoint*LLVMPointerWidth/8);
1145 init = llvm::ConstantExpr::getInBoundsGetElementPtr(vtbl, &init, 1);
1146 return init;
1147 }
1148
Mike Stump9840c702009-11-12 20:47:57 +00001149 /// Secondary - Add the secondary vtable pointers to Inits. Offset is the
1150 /// current offset in bits to the object we're working on.
Mike Stump28f7ce12009-11-12 22:56:32 +00001151 void Secondary(const CXXRecordDecl *RD, llvm::Constant *vtbl,
Mike Stumpacfd1e52009-11-13 01:54:23 +00001152 const CXXRecordDecl *VtblClass, uint64_t Offset=0,
1153 bool MorallyVirtual=false) {
Mike Stump971977f2009-11-11 00:35:07 +00001154 if (RD->getNumVBases() == 0 && ! MorallyVirtual)
1155 return;
1156
1157 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1158 e = RD->bases_end(); i != e; ++i) {
1159 const CXXRecordDecl *Base =
1160 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1161 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1162 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1163 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
1164 bool NonVirtualPrimaryBase;
1165 NonVirtualPrimaryBase = !PrimaryBaseWasVirtual && Base == PrimaryBase;
1166 bool BaseMorallyVirtual = MorallyVirtual | i->isVirtual();
Mike Stumpaee8de32009-11-11 03:08:24 +00001167 uint64_t BaseOffset;
1168 if (!i->isVirtual()) {
1169 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1170 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
1171 } else
1172 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump80ac2352009-11-12 23:36:21 +00001173 llvm::Constant *subvtbl = vtbl;
Mike Stumpacfd1e52009-11-13 01:54:23 +00001174 const CXXRecordDecl *subVtblClass = VtblClass;
Mike Stump971977f2009-11-11 00:35:07 +00001175 if ((Base->getNumVBases() || BaseMorallyVirtual)
1176 && !NonVirtualPrimaryBase) {
1177 // FIXME: Slightly too many of these for __ZTT8test8_B2
Mike Stump28f7ce12009-11-12 22:56:32 +00001178 llvm::Constant *init;
Mike Stump80ac2352009-11-12 23:36:21 +00001179 if (BaseMorallyVirtual)
Mike Stumpacfd1e52009-11-13 01:54:23 +00001180 init = BuildVtablePtr(vtbl, VtblClass, RD, Offset);
Mike Stump80ac2352009-11-12 23:36:21 +00001181 else {
Mike Stump28f7ce12009-11-12 22:56:32 +00001182 init = CGM.getVtableInfo().getCtorVtable(Class, Base, BaseOffset);
Mike Stump80ac2352009-11-12 23:36:21 +00001183 subvtbl = dyn_cast<llvm::Constant>(init->getOperand(0));
Mike Stumpacfd1e52009-11-13 01:54:23 +00001184 subVtblClass = Base;
Mike Stump80ac2352009-11-12 23:36:21 +00001185 }
Mike Stump28f7ce12009-11-12 22:56:32 +00001186 Inits.push_back(init);
Mike Stump971977f2009-11-11 00:35:07 +00001187 }
Mike Stumpacfd1e52009-11-13 01:54:23 +00001188 Secondary(Base, subvtbl, subVtblClass, BaseOffset, BaseMorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +00001189 }
1190 }
1191
Mike Stump9840c702009-11-12 20:47:57 +00001192 /// BuiltVTT - Add the VTT to Inits. Offset is the offset in bits to the
1193 /// currnet object we're working on.
1194 void BuildVTT(const CXXRecordDecl *RD, uint64_t Offset, bool MorallyVirtual) {
Mike Stump971977f2009-11-11 00:35:07 +00001195 if (RD->getNumVBases() == 0 && !MorallyVirtual)
1196 return;
1197
Mike Stump9840c702009-11-12 20:47:57 +00001198 llvm::Constant *init;
Mike Stumpacfd1e52009-11-13 01:54:23 +00001199 const CXXRecordDecl *VtblClass;
1200
Mike Stump971977f2009-11-11 00:35:07 +00001201 // First comes the primary virtual table pointer...
Mike Stumpacfd1e52009-11-13 01:54:23 +00001202 if (MorallyVirtual) {
1203 init = BuildVtablePtr(ClassVtbl, Class, RD, Offset);
1204 VtblClass = Class;
1205 } else {
Mike Stump9840c702009-11-12 20:47:57 +00001206 init = CGM.getVtableInfo().getCtorVtable(Class, RD, Offset);
Mike Stumpacfd1e52009-11-13 01:54:23 +00001207 VtblClass = RD;
1208 }
Mike Stump28f7ce12009-11-12 22:56:32 +00001209 llvm::Constant *vtbl = dyn_cast<llvm::Constant>(init->getOperand(0));
Mike Stump9840c702009-11-12 20:47:57 +00001210 Inits.push_back(init);
Mike Stump971977f2009-11-11 00:35:07 +00001211
1212 // then the secondary VTTs....
Mike Stump9840c702009-11-12 20:47:57 +00001213 SecondaryVTTs(RD, Offset, MorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +00001214
1215 // and last the secondary vtable pointers.
Mike Stumpacfd1e52009-11-13 01:54:23 +00001216 Secondary(RD, vtbl, VtblClass, Offset, MorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +00001217 }
1218
1219 /// SecondaryVTTs - Add the secondary VTTs to Inits. The secondary VTTs are
1220 /// built from each direct non-virtual proper base that requires a VTT in
1221 /// declaration order.
Mike Stump9840c702009-11-12 20:47:57 +00001222 void SecondaryVTTs(const CXXRecordDecl *RD, uint64_t Offset=0,
1223 bool MorallyVirtual=false) {
Mike Stump971977f2009-11-11 00:35:07 +00001224 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1225 e = RD->bases_end(); i != e; ++i) {
1226 const CXXRecordDecl *Base =
1227 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1228 if (i->isVirtual())
1229 continue;
Mike Stump9840c702009-11-12 20:47:57 +00001230 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1231 uint64_t BaseOffset = Offset + Layout.getBaseClassOffset(Base);
1232 BuildVTT(Base, BaseOffset, MorallyVirtual);
Mike Stump971977f2009-11-11 00:35:07 +00001233 }
1234 }
1235
1236 /// VirtualVTTs - Add the VTT for each proper virtual base in inheritance
1237 /// graph preorder.
1238 void VirtualVTTs(const CXXRecordDecl *RD) {
1239 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
1240 e = RD->bases_end(); i != e; ++i) {
1241 const CXXRecordDecl *Base =
1242 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
1243 if (i->isVirtual() && !SeenVBase.count(Base)) {
1244 SeenVBase.insert(Base);
Mike Stump9840c702009-11-12 20:47:57 +00001245 uint64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
1246 BuildVTT(Base, BaseOffset, true);
Mike Stump971977f2009-11-11 00:35:07 +00001247 }
1248 VirtualVTTs(Base);
1249 }
1250 }
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001251public:
1252 VTTBuilder(std::vector<llvm::Constant *> &inits, const CXXRecordDecl *c,
Mike Stumpaee8de32009-11-11 03:08:24 +00001253 CodeGenModule &cgm)
1254 : Inits(inits), Class(c), CGM(cgm),
Mike Stump9840c702009-11-12 20:47:57 +00001255 BLayout(cgm.getContext().getASTRecordLayout(c)),
Mike Stumpacfd1e52009-11-13 01:54:23 +00001256 AddressPoints(*cgm.AddressPoints[c]),
Mike Stump9840c702009-11-12 20:47:57 +00001257 VMContext(cgm.getModule().getContext()) {
Mike Stump380dd752009-11-10 07:44:33 +00001258
Mike Stump971977f2009-11-11 00:35:07 +00001259 // First comes the primary virtual table pointer for the complete class...
Mike Stump9840c702009-11-12 20:47:57 +00001260 ClassVtbl = CGM.getVtableInfo().getVtable(Class);
1261 Inits.push_back(ClassVtbl);
1262 ClassVtbl = dyn_cast<llvm::Constant>(ClassVtbl->getOperand(0));
1263
Mike Stump971977f2009-11-11 00:35:07 +00001264 // then the secondary VTTs...
1265 SecondaryVTTs(Class);
1266
1267 // then the secondary vtable pointers...
Mike Stumpacfd1e52009-11-13 01:54:23 +00001268 Secondary(Class, ClassVtbl, Class);
Mike Stump971977f2009-11-11 00:35:07 +00001269
1270 // and last, the virtual VTTs.
1271 VirtualVTTs(Class);
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001272 }
1273};
Mike Stump92f2fe22009-12-02 19:07:44 +00001274}
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001275
Mike Stump380dd752009-11-10 07:44:33 +00001276llvm::Constant *CodeGenModule::GenerateVTT(const CXXRecordDecl *RD) {
Mike Stumpf1c03332009-11-10 19:13:04 +00001277 // Only classes that have virtual bases need a VTT.
1278 if (RD->getNumVBases() == 0)
1279 return 0;
1280
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001281 llvm::SmallString<256> OutName;
Daniel Dunbar94fd26d2009-11-21 09:06:22 +00001282 getMangleContext().mangleCXXVTT(RD, OutName);
1283 llvm::StringRef Name = OutName.str();
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001284
1285 llvm::GlobalVariable::LinkageTypes linktype;
1286 linktype = llvm::GlobalValue::LinkOnceODRLinkage;
Mike Stump85615df2009-11-19 04:04:36 +00001287 if (RD->isInAnonymousNamespace())
1288 linktype = llvm::GlobalValue::InternalLinkage;
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001289 std::vector<llvm::Constant *> inits;
1290 llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
1291
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001292 D1(printf("vtt %s\n", RD->getNameAsCString()));
1293
Mike Stump971977f2009-11-11 00:35:07 +00001294 VTTBuilder b(inits, RD, *this);
1295
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001296 llvm::Constant *C;
1297 llvm::ArrayType *type = llvm::ArrayType::get(Ptr8Ty, inits.size());
1298 C = llvm::ConstantArray::get(type, inits);
Mike Stumpe56ceca2009-11-18 04:00:48 +00001299 llvm::GlobalVariable *vtt = new llvm::GlobalVariable(getModule(), type, true,
Mike Stump85615df2009-11-19 04:04:36 +00001300 linktype, C, Name);
Mike Stumpe56ceca2009-11-18 04:00:48 +00001301 bool Hidden = getDeclVisibilityMode(RD) == LangOptions::Hidden;
1302 if (Hidden)
1303 vtt->setVisibility(llvm::GlobalVariable::HiddenVisibility);
1304 return llvm::ConstantExpr::getBitCast(vtt, Ptr8Ty);
Mike Stumpfbfb52d2009-11-10 02:30:51 +00001305}
Mike Stump380dd752009-11-10 07:44:33 +00001306
Mike Stump58588942009-11-19 01:08:19 +00001307void CGVtableInfo::GenerateClassData(const CXXRecordDecl *RD) {
1308 Vtables[RD] = CGM.GenerateVtable(RD, RD);
Mike Stumpde050572009-12-02 18:57:08 +00001309 CGM.GenerateRTTI(RD);
Mike Stump58588942009-11-19 01:08:19 +00001310 CGM.GenerateVTT(RD);
1311}
1312
Mike Stump8cfcb522009-11-11 20:26:26 +00001313llvm::Constant *CGVtableInfo::getVtable(const CXXRecordDecl *RD) {
Mike Stump380dd752009-11-10 07:44:33 +00001314 llvm::Constant *&vtbl = Vtables[RD];
1315 if (vtbl)
1316 return vtbl;
Mike Stump9840c702009-11-12 20:47:57 +00001317 vtbl = CGM.GenerateVtable(RD, RD);
Mike Stump85615df2009-11-19 04:04:36 +00001318
1319 bool CreateDefinition = true;
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00001320
1321 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1322 if (const CXXMethodDecl *KeyFunction = Layout.getKeyFunction()) {
Mike Stump85615df2009-11-19 04:04:36 +00001323 if (!KeyFunction->getBody()) {
1324 // If there is a KeyFunction, and it isn't defined, just build a
1325 // reference to the vtable.
1326 CreateDefinition = false;
1327 }
1328 }
1329
1330 if (CreateDefinition) {
Mike Stumpde050572009-12-02 18:57:08 +00001331 CGM.GenerateRTTI(RD);
Mike Stump85615df2009-11-19 04:04:36 +00001332 CGM.GenerateVTT(RD);
1333 }
Mike Stump380dd752009-11-10 07:44:33 +00001334 return vtbl;
1335}
Mike Stump8cfcb522009-11-11 20:26:26 +00001336
Mike Stump9840c702009-11-12 20:47:57 +00001337llvm::Constant *CGVtableInfo::getCtorVtable(const CXXRecordDecl *LayoutClass,
1338 const CXXRecordDecl *RD,
Mike Stump8cfcb522009-11-11 20:26:26 +00001339 uint64_t Offset) {
Mike Stump9840c702009-11-12 20:47:57 +00001340 return CGM.GenerateVtable(LayoutClass, RD, Offset);
Mike Stump8cfcb522009-11-11 20:26:26 +00001341}
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00001342
1343void CGVtableInfo::MaybeEmitVtable(GlobalDecl GD) {
1344 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
1345 const CXXRecordDecl *RD = MD->getParent();
1346
1347 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1348
1349 // Get the key function.
1350 const CXXMethodDecl *KeyFunction = Layout.getKeyFunction();
1351
1352 if (!KeyFunction) {
1353 // If there's no key function, we don't want to emit the vtable here.
1354 return;
1355 }
1356
1357 // Check if we have the key function.
1358 if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl())
1359 return;
1360
1361 // If the key function is a destructor, we only want to emit the vtable once,
1362 // so do it for the complete destructor.
1363 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() != Dtor_Complete)
1364 return;
1365
1366 // Emit the data.
1367 GenerateClassData(RD);
1368}
1369