blob: 93ed111955e288606d3c2fcc94e9d3c87b60755a [file] [log] [blame]
Anders Carlsson2bb27f52009-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 Carlssonf942ee02009-11-27 20:47:55 +000016#include "clang/AST/CXXInheritance.h"
Anders Carlsson2bb27f52009-10-11 22:13:54 +000017#include "clang/AST/RecordLayout.h"
Anders Carlssond420a312009-11-26 19:32:45 +000018#include "llvm/ADT/DenseSet.h"
Chandler Carruth94eab4a2010-02-13 10:38:52 +000019#include "llvm/Support/Compiler.h"
Anders Carlsson5d40c6f2010-02-11 08:02:13 +000020#include "llvm/Support/Format.h"
Zhongxing Xu1721ef72009-11-13 05:46:16 +000021#include <cstdio>
Anders Carlsson2bb27f52009-10-11 22:13:54 +000022
23using namespace clang;
24using namespace CodeGen;
25
Anders Carlssond59885022009-11-27 22:21:51 +000026namespace {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +000027
Anders Carlsson075056a2010-02-23 01:34:28 +000028/// BaseOffset - Represents an offset from a derived class to a direct or
29/// indirect base class.
30struct BaseOffset {
31 /// DerivedClass - The derived class.
32 const CXXRecordDecl *DerivedClass;
33
34 /// VirtualBase - If the path from the derived class to the base class
35 /// involves a virtual base class, this holds its declaration.
36 const CXXRecordDecl *VirtualBase;
37
38 /// NonVirtualOffset - The offset from the derived class to the base class.
39 /// (Or the offset from the virtual base class to the base class, if the
40 /// path from the derived class to the base class involves a virtual base
41 /// class.
42 int64_t NonVirtualOffset;
43
44 BaseOffset() : DerivedClass(0), VirtualBase(0), NonVirtualOffset(0) { }
45 BaseOffset(const CXXRecordDecl *DerivedClass,
46 const CXXRecordDecl *VirtualBase, int64_t NonVirtualOffset)
47 : DerivedClass(DerivedClass), VirtualBase(VirtualBase),
48 NonVirtualOffset(NonVirtualOffset) { }
49
50 bool isEmpty() const { return !NonVirtualOffset && !VirtualBase; }
51};
52
Anders Carlssone8ac42a2010-02-11 21:24:32 +000053/// FinalOverriders - Contains the final overrider member functions for all
54/// member functions in the base subobjects of a class.
55class FinalOverriders {
Anders Carlsson136bd192010-02-12 16:55:34 +000056public:
57 /// OverriderInfo - Information about a final overrider.
58 struct OverriderInfo {
59 /// Method - The method decl of the overrider.
60 const CXXMethodDecl *Method;
Anders Carlsson5a7654a2010-02-18 16:29:24 +000061
62 /// BaseOffset - the base offset of the overrider.
63 uint64_t BaseOffset;
Anders Carlsson136bd192010-02-12 16:55:34 +000064
Anders Carlsson5a7654a2010-02-18 16:29:24 +000065 OverriderInfo() : Method(0), BaseOffset(0) { }
Anders Carlsson136bd192010-02-12 16:55:34 +000066 };
67
68private:
Anders Carlssone8ac42a2010-02-11 21:24:32 +000069 /// MostDerivedClass - The most derived class for which the final overriders
70 /// are stored.
71 const CXXRecordDecl *MostDerivedClass;
72
73 ASTContext &Context;
74
75 /// MostDerivedClassLayout - the AST record layout of the most derived class.
76 const ASTRecordLayout &MostDerivedClassLayout;
77
Anders Carlssoneee53d92010-02-13 02:02:03 +000078 /// BaseSubobjectMethodPairTy - Uniquely identifies a member function
79 /// in a base subobject.
80 typedef std::pair<BaseSubobject, const CXXMethodDecl *>
81 BaseSubobjectMethodPairTy;
82
83 typedef llvm::DenseMap<BaseSubobjectMethodPairTy,
Anders Carlsson136bd192010-02-12 16:55:34 +000084 OverriderInfo> OverridersMapTy;
Anders Carlssone8ac42a2010-02-11 21:24:32 +000085
86 /// OverridersMap - The final overriders for all virtual member functions of
87 /// all the base subobjects of the most derived class.
88 OverridersMapTy OverridersMap;
89
Anders Carlsson6a7e6a42010-02-14 00:37:35 +000090 /// VisitedVirtualBases - A set of all the visited virtual bases, used to
91 /// avoid visiting virtual bases more than once.
92 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
93
Anders Carlssoneee53d92010-02-13 02:02:03 +000094 typedef llvm::DenseMap<BaseSubobjectMethodPairTy, BaseOffset>
95 AdjustmentOffsetsMapTy;
96
97 /// ReturnAdjustments - Holds return adjustments for all the overriders that
98 /// need to perform return value adjustments.
99 AdjustmentOffsetsMapTy ReturnAdjustments;
100
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000101 /// ThisAdjustments - Holds 'this' adjustments for all the overriders that
102 /// need them.
103 AdjustmentOffsetsMapTy ThisAdjustments;
104
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000105 typedef llvm::SmallVector<uint64_t, 1> OffsetVectorTy;
106
107 /// SubobjectOffsetsMapTy - This map is used for keeping track of all the
108 /// base subobject offsets that a single class declaration might refer to.
109 ///
110 /// For example, in:
111 ///
112 /// struct A { virtual void f(); };
113 /// struct B1 : A { };
114 /// struct B2 : A { };
115 /// struct C : B1, B2 { virtual void f(); };
116 ///
117 /// when we determine that C::f() overrides A::f(), we need to update the
118 /// overriders map for both A-in-B1 and A-in-B2 and the subobject offsets map
119 /// will have the subobject offsets for both A copies.
120 typedef llvm::DenseMap<const CXXRecordDecl *, OffsetVectorTy>
121 SubobjectOffsetsMapTy;
122
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000123 /// ComputeFinalOverriders - Compute the final overriders for a given base
124 /// subobject (and all its direct and indirect bases).
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000125 void ComputeFinalOverriders(BaseSubobject Base,
Anders Carlsson231461f2010-02-17 17:48:25 +0000126 bool BaseSubobjectIsVisitedVBase,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000127 SubobjectOffsetsMapTy &Offsets);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000128
129 /// AddOverriders - Add the final overriders for this base subobject to the
130 /// map of final overriders.
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000131 void AddOverriders(BaseSubobject Base, SubobjectOffsetsMapTy &Offsets);
132
133 /// PropagateOverrider - Propagate the NewMD overrider to all the functions
134 /// that OldMD overrides. For example, if we have:
135 ///
136 /// struct A { virtual void f(); };
137 /// struct B : A { virtual void f(); };
138 /// struct C : B { virtual void f(); };
139 ///
140 /// and we want to override B::f with C::f, we also need to override A::f with
141 /// C::f.
142 void PropagateOverrider(const CXXMethodDecl *OldMD,
Anders Carlssona678aa12010-02-13 22:23:31 +0000143 BaseSubobject NewBase,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000144 const CXXMethodDecl *NewMD,
145 SubobjectOffsetsMapTy &Offsets);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000146
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000147 /// ComputeThisAdjustmentBaseOffset - Compute the base offset for adjusting
Anders Carlsson258a1e32010-02-14 00:16:19 +0000148 /// the 'this' pointer from the base subobject to the derived subobject.
Anders Carlsson073a0c82010-02-14 00:44:19 +0000149 BaseOffset ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
Anders Carlsson258a1e32010-02-14 00:16:19 +0000150 BaseSubobject Derived);
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000151
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000152 static void MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
153 SubobjectOffsetsMapTy &Offsets);
154
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000155public:
156 explicit FinalOverriders(const CXXRecordDecl *MostDerivedClass);
157
158 /// getOverrider - Get the final overrider for the given method declaration in
159 /// the given base subobject.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000160 OverriderInfo getOverrider(BaseSubobject Base,
161 const CXXMethodDecl *MD) const {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000162 assert(OverridersMap.count(std::make_pair(Base, MD)) &&
163 "Did not find overrider!");
164
165 return OverridersMap.lookup(std::make_pair(Base, MD));
166 }
167
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000168 /// getReturnAdjustmentOffset - Get the return adjustment offset for the
169 /// method decl in the given base subobject. Returns an empty base offset if
170 /// no adjustment is needed.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000171 BaseOffset getReturnAdjustmentOffset(BaseSubobject Base,
172 const CXXMethodDecl *MD) const {
173 return ReturnAdjustments.lookup(std::make_pair(Base, MD));
174 }
175
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000176 /// getThisAdjustmentOffset - Get the 'this' pointer adjustment offset for the
177 /// method decl in the given base subobject. Returns an empty base offset if
178 /// no adjustment is needed.
179 BaseOffset getThisAdjustmentOffset(BaseSubobject Base,
180 const CXXMethodDecl *MD) const {
181 return ThisAdjustments.lookup(std::make_pair(Base, MD));
182 }
183
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000184 /// dump - dump the final overriders.
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000185 void dump() {
186 assert(VisitedVirtualBases.empty() &&
187 "Visited virtual bases aren't empty!");
188 dump(llvm::errs(), BaseSubobject(MostDerivedClass, 0));
189 VisitedVirtualBases.clear();
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000190 }
191
192 /// dump - dump the final overriders for a base subobject, and all its direct
193 /// and indirect base subobjects.
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000194 void dump(llvm::raw_ostream &Out, BaseSubobject Base);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000195};
Anders Carlssoneee53d92010-02-13 02:02:03 +0000196
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000197FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass)
198 : MostDerivedClass(MostDerivedClass),
199 Context(MostDerivedClass->getASTContext()),
200 MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
201
202 // Compute the final overriders.
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000203 SubobjectOffsetsMapTy Offsets;
Anders Carlsson231461f2010-02-17 17:48:25 +0000204 ComputeFinalOverriders(BaseSubobject(MostDerivedClass, 0),
205 /*BaseSubobjectIsVisitedVBase=*/false, Offsets);
206 VisitedVirtualBases.clear();
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000207
208 // And dump them (for now).
209 dump();
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000210
211 // Also dump the base offsets (for now).
212 for (SubobjectOffsetsMapTy::const_iterator I = Offsets.begin(),
213 E = Offsets.end(); I != E; ++I) {
214 const OffsetVectorTy& OffsetVector = I->second;
215
216 llvm::errs() << "Base offsets for ";
217 llvm::errs() << I->first->getQualifiedNameAsString() << '\n';
218
219 for (unsigned I = 0, E = OffsetVector.size(); I != E; ++I)
220 llvm::errs() << " " << I << " - " << OffsetVector[I] << '\n';
221 }
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000222}
223
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000224void FinalOverriders::AddOverriders(BaseSubobject Base,
225 SubobjectOffsetsMapTy &Offsets) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000226 const CXXRecordDecl *RD = Base.getBase();
227
228 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
229 E = RD->method_end(); I != E; ++I) {
230 const CXXMethodDecl *MD = *I;
231
232 if (!MD->isVirtual())
233 continue;
234
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000235 // First, propagate the overrider.
Anders Carlssona678aa12010-02-13 22:23:31 +0000236 PropagateOverrider(MD, Base, MD, Offsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000237
238 // Add the overrider as the final overrider of itself.
Anders Carlsson136bd192010-02-12 16:55:34 +0000239 OverriderInfo& Overrider = OverridersMap[std::make_pair(Base, MD)];
240 assert(!Overrider.Method && "Overrider should not exist yet!");
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000241
Anders Carlsson5a7654a2010-02-18 16:29:24 +0000242 Overrider.BaseOffset = Base.getBaseOffset();
Anders Carlsson136bd192010-02-12 16:55:34 +0000243 Overrider.Method = MD;
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000244 }
245}
246
Anders Carlsson075056a2010-02-23 01:34:28 +0000247static BaseOffset ComputeBaseOffset(ASTContext &Context,
248 const CXXRecordDecl *DerivedRD,
249 const CXXBasePath &Path) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000250 int64_t NonVirtualOffset = 0;
Anders Carlssoneee53d92010-02-13 02:02:03 +0000251
Anders Carlssonf3f67842010-02-13 20:41:15 +0000252 unsigned NonVirtualStart = 0;
253 const CXXRecordDecl *VirtualBase = 0;
254
255 // First, look for the virtual base class.
256 for (unsigned I = 0, E = Path.size(); I != E; ++I) {
257 const CXXBasePathElement &Element = Path[I];
258
259 if (Element.Base->isVirtual()) {
260 // FIXME: Can we break when we find the first virtual base?
261 // (If we can't, can't we just iterate over the path in reverse order?)
262 NonVirtualStart = I + 1;
263 QualType VBaseType = Element.Base->getType();
264 VirtualBase =
265 cast<CXXRecordDecl>(VBaseType->getAs<RecordType>()->getDecl());
266 }
267 }
268
269 // Now compute the non-virtual offset.
270 for (unsigned I = NonVirtualStart, E = Path.size(); I != E; ++I) {
271 const CXXBasePathElement &Element = Path[I];
Anders Carlssoneee53d92010-02-13 02:02:03 +0000272
273 // Check the base class offset.
274 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Element.Class);
275
276 const RecordType *BaseType = Element.Base->getType()->getAs<RecordType>();
277 const CXXRecordDecl *Base = cast<CXXRecordDecl>(BaseType->getDecl());
278
279 NonVirtualOffset += Layout.getBaseClassOffset(Base);
280 }
281
282 // FIXME: This should probably use CharUnits or something. Maybe we should
283 // even change the base offsets in ASTRecordLayout to be specified in
284 // CharUnits.
Anders Carlsson075056a2010-02-23 01:34:28 +0000285 return BaseOffset(DerivedRD, VirtualBase, NonVirtualOffset / 8);
Anders Carlsson258a1e32010-02-14 00:16:19 +0000286
287}
288
Anders Carlsson075056a2010-02-23 01:34:28 +0000289static BaseOffset ComputeBaseOffset(ASTContext &Context,
290 const CXXRecordDecl *BaseRD,
291 const CXXRecordDecl *DerivedRD) {
Anders Carlsson258a1e32010-02-14 00:16:19 +0000292 CXXBasePaths Paths(/*FindAmbiguities=*/false,
293 /*RecordPaths=*/true, /*DetectVirtual=*/false);
294
295 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
296 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
297 assert(false && "Class must be derived from the passed in base class!");
Anders Carlsson075056a2010-02-23 01:34:28 +0000298 return BaseOffset();
Anders Carlsson258a1e32010-02-14 00:16:19 +0000299 }
300
301 return ComputeBaseOffset(Context, DerivedRD, Paths.front());
Anders Carlssoneee53d92010-02-13 02:02:03 +0000302}
303
Anders Carlsson075056a2010-02-23 01:34:28 +0000304static BaseOffset
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000305ComputeReturnAdjustmentBaseOffset(ASTContext &Context,
306 const CXXMethodDecl *DerivedMD,
307 const CXXMethodDecl *BaseMD) {
Anders Carlssoneee53d92010-02-13 02:02:03 +0000308 const FunctionType *BaseFT = BaseMD->getType()->getAs<FunctionType>();
309 const FunctionType *DerivedFT = DerivedMD->getType()->getAs<FunctionType>();
310
311 // Canonicalize the return types.
312 CanQualType CanDerivedReturnType =
313 Context.getCanonicalType(DerivedFT->getResultType());
314 CanQualType CanBaseReturnType =
315 Context.getCanonicalType(BaseFT->getResultType());
316
317 assert(CanDerivedReturnType->getTypeClass() ==
318 CanBaseReturnType->getTypeClass() &&
319 "Types must have same type class!");
320
321 if (CanDerivedReturnType == CanBaseReturnType) {
322 // No adjustment needed.
Anders Carlsson075056a2010-02-23 01:34:28 +0000323 return BaseOffset();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000324 }
325
326 if (isa<ReferenceType>(CanDerivedReturnType)) {
327 CanDerivedReturnType =
328 CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType();
329 CanBaseReturnType =
330 CanBaseReturnType->getAs<ReferenceType>()->getPointeeType();
331 } else if (isa<PointerType>(CanDerivedReturnType)) {
332 CanDerivedReturnType =
333 CanDerivedReturnType->getAs<PointerType>()->getPointeeType();
334 CanBaseReturnType =
335 CanBaseReturnType->getAs<PointerType>()->getPointeeType();
336 } else {
337 assert(false && "Unexpected return type!");
338 }
339
340 // We need to compare unqualified types here; consider
341 // const T *Base::foo();
342 // T *Derived::foo();
343 if (CanDerivedReturnType.getUnqualifiedType() ==
344 CanBaseReturnType.getUnqualifiedType()) {
345 // No adjustment needed.
Anders Carlsson075056a2010-02-23 01:34:28 +0000346 return BaseOffset();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000347 }
348
349 const CXXRecordDecl *DerivedRD =
350 cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl());
351
352 const CXXRecordDecl *BaseRD =
353 cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl());
354
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000355 return ComputeBaseOffset(Context, BaseRD, DerivedRD);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000356}
357
Anders Carlsson075056a2010-02-23 01:34:28 +0000358BaseOffset
Anders Carlsson258a1e32010-02-14 00:16:19 +0000359FinalOverriders::ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
360 BaseSubobject Derived) {
361 const CXXRecordDecl *BaseRD = Base.getBase();
362 const CXXRecordDecl *DerivedRD = Derived.getBase();
363
364 CXXBasePaths Paths(/*FindAmbiguities=*/true,
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000365 /*RecordPaths=*/true, /*DetectVirtual=*/true);
366
367 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
368 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
369 assert(false && "Class must be derived from the passed in base class!");
Anders Carlsson03db9e92010-02-17 02:05:23 +0000370 return BaseOffset();
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000371 }
372
Anders Carlsson03db9e92010-02-17 02:05:23 +0000373 // We have to go through all the paths, and see which one leads us to the
374 // right base subobject.
375 for (CXXBasePaths::const_paths_iterator I = Paths.begin(), E = Paths.end();
376 I != E; ++I) {
377 BaseOffset Offset = ComputeBaseOffset(Context, DerivedRD, *I);
378
379 // FIXME: Should not use * 8 here.
380 uint64_t OffsetToBaseSubobject = Offset.NonVirtualOffset * 8;
381
382 if (Offset.VirtualBase) {
383 // If we have a virtual base class, the non-virtual offset is relative
384 // to the virtual base class offset.
385 const ASTRecordLayout &MostDerivedClassLayout =
386 Context.getASTRecordLayout(MostDerivedClass);
387
388 /// Get the virtual base offset, relative to the most derived class
389 /// layout.
390 OffsetToBaseSubobject +=
391 MostDerivedClassLayout.getVBaseClassOffset(Offset.VirtualBase);
392 } else {
393 // Otherwise, the non-virtual offset is relative to the derived class
394 // offset.
395 OffsetToBaseSubobject += Derived.getBaseOffset();
396 }
397
398 // Check if this path gives us the right base subobject.
399 if (OffsetToBaseSubobject == Base.getBaseOffset()) {
400 // Since we're going from the base class _to_ the derived class, we'll
401 // invert the non-virtual offset here.
402 Offset.NonVirtualOffset = -Offset.NonVirtualOffset;
403 return Offset;
404 }
405 }
406
407 return BaseOffset();
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000408}
409
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000410void FinalOverriders::PropagateOverrider(const CXXMethodDecl *OldMD,
Anders Carlssona678aa12010-02-13 22:23:31 +0000411 BaseSubobject NewBase,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000412 const CXXMethodDecl *NewMD,
413 SubobjectOffsetsMapTy &Offsets) {
414 for (CXXMethodDecl::method_iterator I = OldMD->begin_overridden_methods(),
415 E = OldMD->end_overridden_methods(); I != E; ++I) {
416 const CXXMethodDecl *OverriddenMD = *I;
417 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
418
419 // We want to override OverriddenMD in all subobjects, for example:
420 //
421 /// struct A { virtual void f(); };
422 /// struct B1 : A { };
423 /// struct B2 : A { };
424 /// struct C : B1, B2 { virtual void f(); };
425 ///
426 /// When overriding A::f with C::f we need to do so in both A subobjects.
427 const OffsetVectorTy &OffsetVector = Offsets[OverriddenRD];
428
429 // Go through all the subobjects.
430 for (unsigned I = 0, E = OffsetVector.size(); I != E; ++I) {
431 uint64_t Offset = OffsetVector[I];
432
Anders Carlsson258a1e32010-02-14 00:16:19 +0000433 BaseSubobject OverriddenSubobject = BaseSubobject(OverriddenRD, Offset);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000434 BaseSubobjectMethodPairTy SubobjectAndMethod =
Anders Carlsson258a1e32010-02-14 00:16:19 +0000435 std::make_pair(OverriddenSubobject, OverriddenMD);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000436
437 OverriderInfo &Overrider = OverridersMap[SubobjectAndMethod];
438
Anders Carlsson136bd192010-02-12 16:55:34 +0000439 assert(Overrider.Method && "Did not find existing overrider!");
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000440
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000441 // Check if we need return adjustments or base adjustments.
Anders Carlssonc1290ad2010-02-13 21:16:54 +0000442 // (We don't want to do this for pure virtual member functions).
443 if (!NewMD->isPure()) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000444 // Get the return adjustment base offset.
Anders Carlssonc1290ad2010-02-13 21:16:54 +0000445 BaseOffset ReturnBaseOffset =
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000446 ComputeReturnAdjustmentBaseOffset(Context, NewMD, OverriddenMD);
447
Anders Carlssonc1290ad2010-02-13 21:16:54 +0000448 if (!ReturnBaseOffset.isEmpty()) {
449 // Store the return adjustment base offset.
450 ReturnAdjustments[SubobjectAndMethod] = ReturnBaseOffset;
451 }
Anders Carlssona678aa12010-02-13 22:23:31 +0000452
453 // Check if we need a 'this' adjustment base offset as well.
454 if (Offset != NewBase.getBaseOffset()) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000455 BaseOffset ThisBaseOffset =
Anders Carlsson258a1e32010-02-14 00:16:19 +0000456 ComputeThisAdjustmentBaseOffset(OverriddenSubobject,
457 NewBase);
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000458 assert(!ThisBaseOffset.isEmpty() &&
459 "Should not get an empty 'this' adjustment!");
460
461 ThisAdjustments[SubobjectAndMethod] = ThisBaseOffset;
Anders Carlssona678aa12010-02-13 22:23:31 +0000462 }
Anders Carlsson8e661e12010-02-12 17:13:23 +0000463 }
464
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000465 // Set the new overrider.
Anders Carlsson5a7654a2010-02-18 16:29:24 +0000466 Overrider.BaseOffset = NewBase.getBaseOffset();
Anders Carlsson136bd192010-02-12 16:55:34 +0000467 Overrider.Method = NewMD;
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000468
469 // And propagate it further.
Anders Carlssona678aa12010-02-13 22:23:31 +0000470 PropagateOverrider(OverriddenMD, NewBase, NewMD, Offsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000471 }
472 }
473}
474
475void
476FinalOverriders::MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
477 SubobjectOffsetsMapTy &Offsets) {
478 // Iterate over the new offsets.
479 for (SubobjectOffsetsMapTy::const_iterator I = NewOffsets.begin(),
480 E = NewOffsets.end(); I != E; ++I) {
481 const CXXRecordDecl *NewRD = I->first;
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000482 const OffsetVectorTy& NewOffsetVector = I->second;
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000483
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000484 OffsetVectorTy &OffsetVector = Offsets[NewRD];
485 if (OffsetVector.empty()) {
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000486 // There were no previous offsets in this vector, just insert all entries
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000487 // from the new offset vector.
488 OffsetVector.append(NewOffsetVector.begin(), NewOffsetVector.end());
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000489 continue;
490 }
491
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000492 // We need to merge the new offsets vector into the old, but we don't want
493 // to have duplicate entries. Do this by inserting the old offsets in a set
494 // so they'll be unique. After this, we iterate over the new offset vector
495 // and only append elements that aren't in the set.
496
497 // First, add the existing offsets to the set.
498 llvm::SmallSet<uint64_t, 4> OffsetSet;
499 for (unsigned I = 0, E = OffsetVector.size(); I != E; ++I) {
500 bool Inserted = OffsetSet.insert(OffsetVector[I]);
501 if (!Inserted)
502 assert(false && "Set of offsets should be unique!");
503 }
504
505 // Next, only add the new offsets if they are not already in the set.
506 for (unsigned I = 0, E = NewOffsetVector.size(); I != E; ++I) {
507 uint64_t Offset = NewOffsetVector[I];
508
509 if (OffsetSet.count(Offset)) {
510 // Ignore the offset.
511 continue;
512 }
513
514 // Otherwise, add it to the offsets vector.
515 OffsetVector.push_back(Offset);
516 }
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000517 }
518}
519
520void FinalOverriders::ComputeFinalOverriders(BaseSubobject Base,
Anders Carlsson231461f2010-02-17 17:48:25 +0000521 bool BaseSubobjectIsVisitedVBase,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000522 SubobjectOffsetsMapTy &Offsets) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000523 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000524 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000525
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000526 SubobjectOffsetsMapTy NewOffsets;
527
528 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
529 E = RD->bases_end(); I != E; ++I) {
530 const CXXRecordDecl *BaseDecl =
531 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
532
Anders Carlsson033d4862010-02-14 17:05:59 +0000533 // Ignore bases that don't have any virtual member functions.
534 if (!BaseDecl->isPolymorphic())
535 continue;
536
Anders Carlsson231461f2010-02-17 17:48:25 +0000537 bool IsVisitedVirtualBase = false;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000538 uint64_t BaseOffset;
539 if (I->isVirtual()) {
Anders Carlsson231461f2010-02-17 17:48:25 +0000540 if (!VisitedVirtualBases.insert(BaseDecl))
541 IsVisitedVirtualBase = true;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000542 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
543 } else {
544 BaseOffset = Layout.getBaseClassOffset(BaseDecl) + Base.getBaseOffset();
545 }
546
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000547 // Compute the final overriders for this base.
Anders Carlsson231461f2010-02-17 17:48:25 +0000548 // We always want to compute the final overriders, even if the base is a
549 // visited virtual base. Consider:
550 //
551 // struct A {
552 // virtual void f();
553 // virtual void g();
554 // };
555 //
556 // struct B : virtual A {
557 // void f();
558 // };
559 //
560 // struct C : virtual A {
561 // void g ();
562 // };
563 //
564 // struct D : B, C { };
565 //
566 // Here, we still want to compute the overriders for A as a base of C,
567 // because otherwise we'll miss that C::g overrides A::f.
568 ComputeFinalOverriders(BaseSubobject(BaseDecl, BaseOffset),
569 IsVisitedVirtualBase, NewOffsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000570 }
571
572 /// Now add the overriders for this particular subobject.
Anders Carlsson231461f2010-02-17 17:48:25 +0000573 /// (We don't want to do this more than once for a virtual base).
574 if (!BaseSubobjectIsVisitedVBase)
575 AddOverriders(Base, NewOffsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000576
577 // And merge the newly discovered subobject offsets.
578 MergeSubobjectOffsets(NewOffsets, Offsets);
579
580 /// Finally, add the offset for our own subobject.
581 Offsets[RD].push_back(Base.getBaseOffset());
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000582}
583
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000584void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000585 const CXXRecordDecl *RD = Base.getBase();
586 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
587
588 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
589 E = RD->bases_end(); I != E; ++I) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000590 const CXXRecordDecl *BaseDecl =
591 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
592
Anders Carlsson033d4862010-02-14 17:05:59 +0000593 // Ignore bases that don't have any virtual member functions.
594 if (!BaseDecl->isPolymorphic())
595 continue;
596
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000597 uint64_t BaseOffset;
598 if (I->isVirtual()) {
599 if (!VisitedVirtualBases.insert(BaseDecl)) {
600 // We've visited this base before.
601 continue;
602 }
603
604 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
605 } else {
606 BaseOffset = Layout.getBaseClassOffset(BaseDecl) +
607 Base.getBaseOffset();
608 }
609
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000610 dump(Out, BaseSubobject(BaseDecl, BaseOffset));
611 }
612
613 Out << "Final overriders for (" << RD->getQualifiedNameAsString() << ", ";
614 Out << Base.getBaseOffset() << ")\n";
615
616 // Now dump the overriders for this base subobject.
617 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
618 E = RD->method_end(); I != E; ++I) {
619 const CXXMethodDecl *MD = *I;
620
621 if (!MD->isVirtual())
622 continue;
623
Anders Carlsson136bd192010-02-12 16:55:34 +0000624 OverriderInfo Overrider = getOverrider(Base, MD);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000625
626 Out << " " << MD->getQualifiedNameAsString() << " - ";
Anders Carlsson8e661e12010-02-12 17:13:23 +0000627 Out << Overrider.Method->getQualifiedNameAsString();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000628
Benjamin Kramer02c67372010-02-13 09:11:28 +0000629 AdjustmentOffsetsMapTy::const_iterator AI =
Anders Carlssoneee53d92010-02-13 02:02:03 +0000630 ReturnAdjustments.find(std::make_pair(Base, MD));
Benjamin Kramer02c67372010-02-13 09:11:28 +0000631 if (AI != ReturnAdjustments.end()) {
632 const BaseOffset &Offset = AI->second;
Anders Carlssonf3f67842010-02-13 20:41:15 +0000633
634 Out << " [ret-adj: ";
635 if (Offset.VirtualBase)
636 Out << Offset.VirtualBase->getQualifiedNameAsString() << " vbase, ";
Anders Carlssoneee53d92010-02-13 02:02:03 +0000637
Anders Carlssonf3f67842010-02-13 20:41:15 +0000638 Out << Offset.NonVirtualOffset << " nv]";
Anders Carlssoneee53d92010-02-13 02:02:03 +0000639 }
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000640
641 AI = ThisAdjustments.find(std::make_pair(Base, MD));
642 if (AI != ThisAdjustments.end()) {
643 const BaseOffset &Offset = AI->second;
644
645 Out << " [this-adj: ";
646 if (Offset.VirtualBase)
647 Out << Offset.VirtualBase->getQualifiedNameAsString() << " vbase, ";
648
649 Out << Offset.NonVirtualOffset << " nv]";
650 }
651
Anders Carlsson8e661e12010-02-12 17:13:23 +0000652 Out << "\n";
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000653 }
654}
655
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000656/// VtableComponent - Represents a single component in a vtable.
657class VtableComponent {
658public:
659 enum Kind {
660 CK_VCallOffset,
661 CK_VBaseOffset,
662 CK_OffsetToTop,
663 CK_RTTI,
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000664 CK_FunctionPointer,
665
666 /// CK_CompleteDtorPointer - A pointer to the complete destructor.
667 CK_CompleteDtorPointer,
668
669 /// CK_DeletingDtorPointer - A pointer to the deleting destructor.
Anders Carlsson350b56e2010-02-19 20:08:13 +0000670 CK_DeletingDtorPointer,
671
672 /// CK_UnusedFunctionPointer - In some cases, a vtable function pointer
673 /// will end up never being called. Such vtable function pointers are
674 /// represented as a CK_UnusedFunctionPointer.
675 CK_UnusedFunctionPointer
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000676 };
677
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000678 static VtableComponent MakeVCallOffset(int64_t Offset) {
679 return VtableComponent(CK_VCallOffset, Offset);
680 }
681
Anders Carlssondc2dba32010-02-16 04:49:44 +0000682 static VtableComponent MakeVBaseOffset(int64_t Offset) {
683 return VtableComponent(CK_VBaseOffset, Offset);
684 }
685
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000686 static VtableComponent MakeOffsetToTop(int64_t Offset) {
687 return VtableComponent(CK_OffsetToTop, Offset);
688 }
689
690 static VtableComponent MakeRTTI(const CXXRecordDecl *RD) {
691 return VtableComponent(CK_RTTI, reinterpret_cast<uintptr_t>(RD));
692 }
693
694 static VtableComponent MakeFunction(const CXXMethodDecl *MD) {
695 assert(!isa<CXXDestructorDecl>(MD) &&
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000696 "Don't use MakeFunction with destructors!");
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000697
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000698 return VtableComponent(CK_FunctionPointer,
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000699 reinterpret_cast<uintptr_t>(MD));
700 }
701
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000702 static VtableComponent MakeCompleteDtor(const CXXDestructorDecl *DD) {
703 return VtableComponent(CK_CompleteDtorPointer,
704 reinterpret_cast<uintptr_t>(DD));
705 }
706
707 static VtableComponent MakeDeletingDtor(const CXXDestructorDecl *DD) {
708 return VtableComponent(CK_DeletingDtorPointer,
709 reinterpret_cast<uintptr_t>(DD));
710 }
711
Anders Carlsson350b56e2010-02-19 20:08:13 +0000712 static VtableComponent MakeUnusedFunction(const CXXMethodDecl *MD) {
713 assert(!isa<CXXDestructorDecl>(MD) &&
714 "Don't use MakeUnusedFunction with destructors!");
715 return VtableComponent(CK_UnusedFunctionPointer,
716 reinterpret_cast<uintptr_t>(MD));
717 }
718
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000719 /// getKind - Get the kind of this vtable component.
720 Kind getKind() const {
721 return (Kind)(Value & 0x7);
722 }
723
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000724 int64_t getVCallOffset() const {
725 assert(getKind() == CK_VCallOffset && "Invalid component kind!");
726
727 return getOffset();
728 }
729
Anders Carlssondc2dba32010-02-16 04:49:44 +0000730 int64_t getVBaseOffset() const {
731 assert(getKind() == CK_VBaseOffset && "Invalid component kind!");
732
733 return getOffset();
734 }
735
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000736 int64_t getOffsetToTop() const {
737 assert(getKind() == CK_OffsetToTop && "Invalid component kind!");
738
739 return getOffset();
740 }
741
742 const CXXRecordDecl *getRTTIDecl() const {
743 assert(getKind() == CK_RTTI && "Invalid component kind!");
744
745 return reinterpret_cast<CXXRecordDecl *>(getPointer());
746 }
747
748 const CXXMethodDecl *getFunctionDecl() const {
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000749 assert(getKind() == CK_FunctionPointer);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000750
751 return reinterpret_cast<CXXMethodDecl *>(getPointer());
752 }
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000753
754 const CXXDestructorDecl *getDestructorDecl() const {
755 assert((getKind() == CK_CompleteDtorPointer ||
756 getKind() == CK_DeletingDtorPointer) && "Invalid component kind!");
757
758 return reinterpret_cast<CXXDestructorDecl *>(getPointer());
759 }
760
Anders Carlsson350b56e2010-02-19 20:08:13 +0000761 const CXXMethodDecl *getUnusedFunctionDecl() const {
762 assert(getKind() == CK_UnusedFunctionPointer);
763
764 return reinterpret_cast<CXXMethodDecl *>(getPointer());
765 }
766
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000767private:
768 VtableComponent(Kind ComponentKind, int64_t Offset) {
769 assert((ComponentKind == CK_VCallOffset ||
770 ComponentKind == CK_VBaseOffset ||
771 ComponentKind == CK_OffsetToTop) && "Invalid component kind!");
772 assert(Offset <= ((1LL << 56) - 1) && "Offset is too big!");
773
774 Value = ((Offset << 3) | ComponentKind);
775 }
776
777 VtableComponent(Kind ComponentKind, uintptr_t Ptr) {
778 assert((ComponentKind == CK_RTTI ||
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000779 ComponentKind == CK_FunctionPointer ||
780 ComponentKind == CK_CompleteDtorPointer ||
Anders Carlsson350b56e2010-02-19 20:08:13 +0000781 ComponentKind == CK_DeletingDtorPointer ||
782 ComponentKind == CK_UnusedFunctionPointer) &&
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000783 "Invalid component kind!");
784
785 assert((Ptr & 7) == 0 && "Pointer not sufficiently aligned!");
786
787 Value = Ptr | ComponentKind;
788 }
789
790 int64_t getOffset() const {
791 assert((getKind() == CK_VCallOffset || getKind() == CK_VBaseOffset ||
792 getKind() == CK_OffsetToTop) && "Invalid component kind!");
793
794 return Value >> 3;
795 }
796
797 uintptr_t getPointer() const {
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000798 assert((getKind() == CK_RTTI ||
799 getKind() == CK_FunctionPointer ||
800 getKind() == CK_CompleteDtorPointer ||
Anders Carlsson350b56e2010-02-19 20:08:13 +0000801 getKind() == CK_DeletingDtorPointer ||
802 getKind() == CK_UnusedFunctionPointer) &&
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000803 "Invalid component kind!");
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000804
805 return static_cast<uintptr_t>(Value & ~7ULL);
806 }
807
808 /// The kind is stored in the lower 3 bits of the value. For offsets, we
809 /// make use of the facts that classes can't be larger than 2^55 bytes,
810 /// so we store the offset in the lower part of the 61 bytes that remain.
811 /// (The reason that we're not simply using a PointerIntPair here is that we
812 /// need the offsets to be 64-bit, even when on a 32-bit machine).
813 int64_t Value;
814};
815
Anders Carlsson78277c72010-02-18 17:00:09 +0000816/// VCallOffsetMap - Keeps track of vcall offsets when building a vtable.
817struct VCallOffsetMap {
818
819 typedef std::pair<const CXXMethodDecl *, int64_t> MethodAndOffsetPairTy;
820
821 /// Offsets - Keeps track of methods and their offsets.
822 // FIXME: This should be a real map and not a vector.
823 llvm::SmallVector<MethodAndOffsetPairTy, 16> Offsets;
824
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000825 /// MethodsCanShareVCallOffset - Returns whether two virtual member functions
826 /// can share the same vcall offset.
827 static bool MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
828 const CXXMethodDecl *RHS);
829
Anders Carlsson78277c72010-02-18 17:00:09 +0000830public:
831 /// AddVCallOffset - Adds a vcall offset to the map. Returns true if the
832 /// add was successful, or false if there was already a member function with
833 /// the same signature in the map.
834 bool AddVCallOffset(const CXXMethodDecl *MD, int64_t OffsetOffset);
835
836 /// getVCallOffsetOffset - Returns the vcall offset offset (relative to the
837 /// vtable address point) for the given virtual member function.
838 int64_t getVCallOffsetOffset(const CXXMethodDecl *MD);
839
840 /// clear - Clear the offset map.
841 void clear() { Offsets.clear(); }
842};
843
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000844bool VCallOffsetMap::MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
845 const CXXMethodDecl *RHS) {
846 assert(LHS->isVirtual() && "LHS must be virtual!");
847 assert(RHS->isVirtual() && "LHS must be virtual!");
848
849 // FIXME: We need to check more things here.
850
851 DeclarationName LHSName = LHS->getDeclName();
852 DeclarationName RHSName = RHS->getDeclName();
853 if (LHSName.getNameKind() != LHSName.getNameKind())
854 return false;
855
856 switch (LHSName.getNameKind()) {
857 default:
858 assert(false && "Unhandled name kind!");
859 case DeclarationName::Identifier:
860 if (LHSName.getAsIdentifierInfo() != RHSName.getAsIdentifierInfo())
861 return false;
862 }
863
864 return true;
865}
866
Anders Carlsson78277c72010-02-18 17:00:09 +0000867bool VCallOffsetMap::AddVCallOffset(const CXXMethodDecl *MD,
868 int64_t OffsetOffset) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000869 // Check if we can reuse an offset.
870 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
871 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
872 return false;
873 }
874
875 // Add the offset.
876 Offsets.push_back(MethodAndOffsetPairTy(MD, OffsetOffset));
Anders Carlsson78277c72010-02-18 17:00:09 +0000877 return true;
878}
879
880int64_t VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000881 // Look for an offset.
882 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
883 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
884 return Offsets[I].second;
885 }
886
887 assert(false && "Should always find a vcall offset offset!");
Anders Carlsson78277c72010-02-18 17:00:09 +0000888 return 0;
889}
890
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000891/// VtableBuilder - Class for building vtable layout information.
Benjamin Kramer337e3a52009-11-28 19:45:26 +0000892class VtableBuilder {
Anders Carlsson65b49782010-02-12 05:25:12 +0000893public:
894 /// PrimaryBasesSetTy - A set of direct and indirect primary bases.
895 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 8> PrimaryBasesSetTy;
896
897private:
Anders Carlssoncf5a8822010-02-13 21:07:32 +0000898 /// VtableInfo - Global vtable information.
899 CGVtableInfo &VtableInfo;
900
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000901 /// MostDerivedClass - The most derived class for which we're building this
902 /// vtable.
903 const CXXRecordDecl *MostDerivedClass;
904
905 /// Context - The ASTContext which we will use for layout information.
Anders Carlsson65b49782010-02-12 05:25:12 +0000906 ASTContext &Context;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000907
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000908 /// FinalOverriders - The final overriders of the most derived class.
909 FinalOverriders Overriders;
910
Anders Carlssondc2dba32010-02-16 04:49:44 +0000911 /// VCallAndVBaseOffsets - The vcall and vbase offset, of the vtable we're
912 // building (in reverse order).
913 llvm::SmallVector<VtableComponent, 64> VCallAndVBaseOffsets;
914
Anders Carlsson78277c72010-02-18 17:00:09 +0000915 /// VCallOffsets - Keeps track of vcall offsets for the current vtable.
916 VCallOffsetMap VCallOffsets;
917
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000918 /// Components - The components of the vtable being built.
919 llvm::SmallVector<VtableComponent, 64> Components;
920
Anders Carlsson932c2f22010-02-11 17:18:51 +0000921 /// AddressPoints - Address points for the vtable being built.
922 CGVtableInfo::AddressPointsMapTy AddressPoints;
923
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000924 /// ReturnAdjustment - A return adjustment.
Anders Carlsson5272c252010-02-12 17:37:14 +0000925 struct ReturnAdjustment {
926 /// NonVirtual - The non-virtual adjustment from the derived object to its
927 /// nearest virtual base.
928 int64_t NonVirtual;
929
Anders Carlsson78277c72010-02-18 17:00:09 +0000930 /// VBaseOffsetOffset - The offset (in bytes), relative to the address point
Anders Carlssoncf5a8822010-02-13 21:07:32 +0000931 /// of the virtual base class offset.
932 int64_t VBaseOffsetOffset;
Anders Carlsson5272c252010-02-12 17:37:14 +0000933
Anders Carlssoncf5a8822010-02-13 21:07:32 +0000934 ReturnAdjustment() : NonVirtual(0), VBaseOffsetOffset(0) { }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000935
Anders Carlssoncf5a8822010-02-13 21:07:32 +0000936 bool isEmpty() const { return !NonVirtual && !VBaseOffsetOffset; }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000937 };
938
939 /// ReturnAdjustments - The return adjustments needed in this vtable.
940 llvm::SmallVector<std::pair<uint64_t, ReturnAdjustment>, 16>
941 ReturnAdjustments;
942
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000943 /// ThisAdjustment - A 'this' pointer adjustment thunk.
944 struct ThisAdjustment {
945 /// NonVirtual - The non-virtual adjustment from the derived object to its
946 /// nearest virtual base.
947 int64_t NonVirtual;
948
Anders Carlsson78277c72010-02-18 17:00:09 +0000949 /// VCallOffsetOffset - The offset (in bytes), relative to the address point
950 /// of the virtual call offset.
951 int64_t VCallOffsetOffset;
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000952
Anders Carlsson78277c72010-02-18 17:00:09 +0000953 ThisAdjustment() : NonVirtual(0), VCallOffsetOffset(0) { }
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000954
Anders Carlsson78277c72010-02-18 17:00:09 +0000955 bool isEmpty() const { return !NonVirtual && !VCallOffsetOffset; }
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000956 };
957
958 /// ThisAdjustments - The 'this' pointer adjustments needed in this vtable.
959 llvm::SmallVector<std::pair<uint64_t, ThisAdjustment>, 16>
960 ThisAdjustments;
961
Anders Carlssondc2dba32010-02-16 04:49:44 +0000962 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
963
Anders Carlsson0570f712010-02-23 03:48:14 +0000964 /// PrimaryVirtualBases - All known virtual bases who is a primary base of
965 /// some other base.
966 VisitedVirtualBasesSetTy PrimaryVirtualBases;
967
Anders Carlssondc2dba32010-02-16 04:49:44 +0000968 /// AddVCallAndVBaseOffsets - Add vcall offsets and vbase offsets for the
Anders Carlssondb042202010-02-17 03:11:55 +0000969 /// given base subobject.
970 void AddVCallAndVBaseOffsets(BaseSubobject Base, bool BaseIsVirtual,
Anders Carlssondc2dba32010-02-16 04:49:44 +0000971 VisitedVirtualBasesSetTy &VBases);
972
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000973 /// AddVCallOffsets - Add vcall offsets for the given base subobject.
Anders Carlsson510d22d2010-02-23 03:14:49 +0000974 void AddVCallOffsets(BaseSubobject Base, uint64_t VBaseOffset);
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000975
Anders Carlssondc2dba32010-02-16 04:49:44 +0000976 /// AddVBaseOffsets - Add vbase offsets for the given class.
Anders Carlssondb042202010-02-17 03:11:55 +0000977 void AddVBaseOffsets(const CXXRecordDecl *Base, int64_t OffsetToTop,
Anders Carlssondc2dba32010-02-16 04:49:44 +0000978 VisitedVirtualBasesSetTy &VBases);
979
Anders Carlssoncf5a8822010-02-13 21:07:32 +0000980 /// ComputeReturnAdjustment - Compute the return adjustment given a return
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000981 /// adjustment base offset.
Anders Carlsson075056a2010-02-23 01:34:28 +0000982 ReturnAdjustment ComputeReturnAdjustment(BaseOffset Offset);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000983
Anders Carlsson78277c72010-02-18 17:00:09 +0000984 /// ComputeThisAdjustment - Compute the 'this' pointer adjustment for the
985 /// given virtual member function and the 'this' pointer adjustment base
986 /// offset.
987 ThisAdjustment ComputeThisAdjustment(const CXXMethodDecl *MD,
Anders Carlsson075056a2010-02-23 01:34:28 +0000988 BaseOffset Offset);
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000989
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000990 /// AddMethod - Add a single virtual member function to the vtable
991 /// components vector.
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000992 void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment,
993 ThisAdjustment ThisAdjustment);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000994
Anders Carlssona8796c62010-02-23 04:26:39 +0000995 /// IsOverriderUsed - Returns whether the overrider will ever be used in this
996 /// part of the vtable.
997 ///
998 /// Itanium C++ ABI 2.5.2:
999 ///
1000 /// struct A { virtual void f(); };
1001 /// struct B : virtual public A { int i; };
1002 /// struct C : virtual public A { int j; };
1003 /// struct D : public B, public C {};
1004 ///
1005 /// When B and C are declared, A is a primary base in each case, so although
1006 /// vcall offsets are allocated in the A-in-B and A-in-C vtables, no this
1007 /// adjustment is required and no thunk is generated. However, inside D
1008 /// objects, A is no longer a primary base of C, so if we allowed calls to
1009 /// C::f() to use the copy of A's vtable in the C subobject, we would need
1010 /// to adjust this from C* to B::A*, which would require a third-party
1011 /// thunk. Since we require that a call to C::f() first convert to A*,
1012 /// C-in-D's copy of A's vtable is never referenced, so this is not
1013 /// necessary.
1014 bool IsOverriderUsed(BaseSubobject Base,
1015 BaseSubobject FirstBaseInPrimaryBaseChain,
1016 FinalOverriders::OverriderInfo Overrider) const;
1017
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001018 /// AddMethods - Add the methods of this base subobject and all its
1019 /// primary bases to the vtable components vector.
Anders Carlssona8796c62010-02-23 04:26:39 +00001020 void AddMethods(BaseSubobject Base, BaseSubobject FirstBaseInPrimaryBaseChain,
1021 PrimaryBasesSetTy &PrimaryBases);
Anders Carlssonb716a542010-02-16 16:26:28 +00001022
1023 // LayoutVtable - Layout the vtable for the most derived class, including its
1024 // secondary vtables and any vtables for virtual bases.
1025 void LayoutVtable();
1026
1027 /// LayoutPrimaryAndAndSecondaryVtables - Layout the primary vtable for the
1028 /// given base subobject, as well as all its secondary vtables.
Anders Carlssondb042202010-02-17 03:11:55 +00001029 void LayoutPrimaryAndAndSecondaryVtables(BaseSubobject Base,
1030 bool BaseIsVirtual);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001031
Anders Carlsson14157932010-02-16 16:02:57 +00001032 /// LayoutSecondaryVtables - Layout the secondary vtables for the given base
1033 /// subobject.
1034 void LayoutSecondaryVtables(BaseSubobject Base);
1035
Anders Carlsson13f0f662010-02-16 16:49:35 +00001036 /// LayoutVtablesForVirtualBases - Layout vtables for all virtual bases of the
1037 /// given base (excluding any primary bases).
1038 void LayoutVtablesForVirtualBases(const CXXRecordDecl *RD,
1039 VisitedVirtualBasesSetTy &VBases);
1040
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001041public:
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001042 VtableBuilder(CGVtableInfo &VtableInfo, const CXXRecordDecl *MostDerivedClass)
1043 : VtableInfo(VtableInfo), MostDerivedClass(MostDerivedClass),
Anders Carlssone8ac42a2010-02-11 21:24:32 +00001044 Context(MostDerivedClass->getASTContext()), Overriders(MostDerivedClass) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001045
Anders Carlssonb716a542010-02-16 16:26:28 +00001046 LayoutVtable();
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001047 }
1048
1049 /// dumpLayout - Dump the vtable layout.
1050 void dumpLayout(llvm::raw_ostream&);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001051};
1052
Anders Carlsson65b49782010-02-12 05:25:12 +00001053/// OverridesMethodInPrimaryBase - Checks whether whether this virtual member
1054/// function overrides a member function in a direct or indirect primary base.
1055/// Returns the overridden member function, or null if none was found.
1056static const CXXMethodDecl *
1057OverridesMethodInPrimaryBase(const CXXMethodDecl *MD,
1058 VtableBuilder::PrimaryBasesSetTy &PrimaryBases) {
1059 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1060 E = MD->end_overridden_methods(); I != E; ++I) {
1061 const CXXMethodDecl *OverriddenMD = *I;
1062 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
1063 assert(OverriddenMD->isCanonicalDecl() &&
1064 "Should have the canonical decl of the overridden RD!");
1065
1066 if (PrimaryBases.count(OverriddenRD))
1067 return OverriddenMD;
1068 }
1069
1070 return 0;
1071}
1072
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001073VtableBuilder::ReturnAdjustment
Anders Carlsson075056a2010-02-23 01:34:28 +00001074VtableBuilder::ComputeReturnAdjustment(BaseOffset Offset) {
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001075 ReturnAdjustment Adjustment;
1076
1077 if (!Offset.isEmpty()) {
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001078 if (Offset.VirtualBase) {
1079 // Get the virtual base offset offset.
1080 Adjustment.VBaseOffsetOffset =
1081 VtableInfo.getVirtualBaseOffsetIndex(Offset.DerivedClass,
1082 Offset.VirtualBase);
1083 // FIXME: Once the assert in getVirtualBaseOffsetIndex is back again,
1084 // we can get rid of this assert.
1085 assert(Adjustment.VBaseOffsetOffset != 0 &&
1086 "Invalid base offset offset!");
1087 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001088
1089 Adjustment.NonVirtual = Offset.NonVirtualOffset;
1090 }
1091
1092 return Adjustment;
1093}
1094
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001095VtableBuilder::ThisAdjustment
Anders Carlsson78277c72010-02-18 17:00:09 +00001096VtableBuilder::ComputeThisAdjustment(const CXXMethodDecl *MD,
Anders Carlsson075056a2010-02-23 01:34:28 +00001097 BaseOffset Offset) {
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001098 ThisAdjustment Adjustment;
1099
1100 if (!Offset.isEmpty()) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001101 if (Offset.VirtualBase) {
1102 // Get the vcall offset offset.
1103 Adjustment.VCallOffsetOffset = VCallOffsets.getVCallOffsetOffset(MD);
1104 }
1105
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001106 Adjustment.NonVirtual = Offset.NonVirtualOffset;
1107 }
1108
1109 return Adjustment;
1110}
1111
Anders Carlsson65b49782010-02-12 05:25:12 +00001112void
Anders Carlssondb042202010-02-17 03:11:55 +00001113VtableBuilder::AddVCallAndVBaseOffsets(BaseSubobject Base,
1114 bool BaseIsVirtual,
Anders Carlssondc2dba32010-02-16 04:49:44 +00001115 VisitedVirtualBasesSetTy &VBases) {
Anders Carlssondb042202010-02-17 03:11:55 +00001116 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base.getBase());
Anders Carlssondc2dba32010-02-16 04:49:44 +00001117
1118 // Itanium C++ ABI 2.5.2:
1119 // ..in classes sharing a virtual table with a primary base class, the vcall
1120 // and vbase offsets added by the derived class all come before the vcall
1121 // and vbase offsets required by the base class, so that the latter may be
1122 // laid out as required by the base class without regard to additions from
1123 // the derived class(es).
1124
1125 // (Since we're emitting the vcall and vbase offsets in reverse order, we'll
1126 // emit them for the primary base first).
Anders Carlssondb042202010-02-17 03:11:55 +00001127 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
1128 bool PrimaryBaseIsVirtual = Layout.getPrimaryBaseWasVirtual();
1129 AddVCallAndVBaseOffsets(BaseSubobject(PrimaryBase, Base.getBaseOffset()),
1130 PrimaryBaseIsVirtual, VBases);
1131 }
Anders Carlssondc2dba32010-02-16 04:49:44 +00001132
Anders Carlssondb042202010-02-17 03:11:55 +00001133 // FIXME: Don't use /8 here.
1134 int64_t OffsetToTop = -(int64_t)Base.getBaseOffset() / 8;
1135 AddVBaseOffsets(Base.getBase(), OffsetToTop, VBases);
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001136
Anders Carlsson30f53012010-02-23 02:47:31 +00001137 // We only want to add vcall offsets for virtual bases.
Anders Carlsson0570f712010-02-23 03:48:14 +00001138 if (BaseIsVirtual)
Anders Carlsson510d22d2010-02-23 03:14:49 +00001139 AddVCallOffsets(Base, Base.getBaseOffset());
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001140}
1141
Anders Carlsson510d22d2010-02-23 03:14:49 +00001142void VtableBuilder::AddVCallOffsets(BaseSubobject Base, uint64_t VBaseOffset) {
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001143 const CXXRecordDecl *RD = Base.getBase();
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001144 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Anders Carlssond2fd3022010-02-17 06:30:02 +00001145
1146 // Handle the primary base first.
Anders Carlssonbae46272010-02-23 03:26:17 +00001147 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson0570f712010-02-23 03:48:14 +00001148 uint64_t PrimaryBaseOffset;
1149
Anders Carlssond2fd3022010-02-17 06:30:02 +00001150 // Get the base offset of the primary base.
Anders Carlsson0570f712010-02-23 03:48:14 +00001151 if (Layout.getPrimaryBaseWasVirtual()) {
1152 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1153 "Primary vbase should have a zero offset!");
1154
1155 const ASTRecordLayout &MostDerivedClassLayout =
1156 Context.getASTRecordLayout(MostDerivedClass);
1157
1158 PrimaryBaseOffset =
1159 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
1160 } else {
1161 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1162 "Primary base should have a zero offset!");
1163
1164 PrimaryBaseOffset = Base.getBaseOffset();
1165 }
Anders Carlssond2fd3022010-02-17 06:30:02 +00001166
Anders Carlsson510d22d2010-02-23 03:14:49 +00001167 AddVCallOffsets(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
1168 VBaseOffset);
Anders Carlssond2fd3022010-02-17 06:30:02 +00001169 }
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001170
1171 // Add the vcall offsets.
1172 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1173 E = RD->method_end(); I != E; ++I) {
1174 const CXXMethodDecl *MD = *I;
1175
1176 if (!MD->isVirtual())
1177 continue;
1178
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001179 // OffsetIndex is the index of this vcall offset, relative to the vtable
1180 // address point. (We subtract 3 to account for the information just
1181 // above the address point, the RTTI info, the offset to top, and the
1182 // vcall offset itself).
Anders Carlssonf8b53532010-02-18 18:20:49 +00001183 int64_t OffsetIndex = -(int64_t)(3 + VCallAndVBaseOffsets.size());
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001184
1185 // FIXME: We shouldn't use / 8 here.
1186 int64_t OffsetOffset = OffsetIndex *
1187 (int64_t)Context.Target.getPointerWidth(0) / 8;
1188
1189 // Don't add a vcall offset if we already have one for this member function
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001190 // signature.
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001191 if (!VCallOffsets.AddVCallOffset(MD, OffsetOffset))
1192 continue;
Anders Carlssone5faca72010-02-18 17:32:33 +00001193
Anders Carlsson510d22d2010-02-23 03:14:49 +00001194 // Get the final overrider.
1195 FinalOverriders::OverriderInfo Overrider =
1196 Overriders.getOverrider(Base, MD);
1197
1198 /// The vcall offset is the offset from the virtual base to the object where
1199 /// the function was overridden.
1200 // FIXME: We should not use / 8 here.
1201 int64_t Offset = (int64_t)(Overrider.BaseOffset - VBaseOffset) / 8;
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001202
1203 VCallAndVBaseOffsets.push_back(VtableComponent::MakeVCallOffset(Offset));
1204 }
1205
1206 // And iterate over all non-virtual bases (ignoring the primary base).
1207 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1208 E = RD->bases_end(); I != E; ++I) {
1209
1210 if (I->isVirtual())
1211 continue;
1212
1213 const CXXRecordDecl *BaseDecl =
1214 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1215
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001216 // Get the base offset of this base.
1217 uint64_t BaseOffset = Base.getBaseOffset() +
1218 Layout.getBaseClassOffset(BaseDecl);
1219
Anders Carlsson510d22d2010-02-23 03:14:49 +00001220 AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset), VBaseOffset);
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001221 }
Anders Carlssondc2dba32010-02-16 04:49:44 +00001222}
1223
1224void VtableBuilder::AddVBaseOffsets(const CXXRecordDecl *RD,
1225 int64_t OffsetToTop,
1226 VisitedVirtualBasesSetTy &VBases) {
Anders Carlsson77904f12010-02-16 04:59:55 +00001227 const ASTRecordLayout &MostDerivedClassLayout =
1228 Context.getASTRecordLayout(MostDerivedClass);
1229
1230 // Add vbase offsets.
1231 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1232 E = RD->bases_end(); I != E; ++I) {
1233 const CXXRecordDecl *BaseDecl =
1234 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1235
1236 // Check if this is a virtual base that we haven't visited before.
1237 if (I->isVirtual() && VBases.insert(BaseDecl)) {
1238 // FIXME: We shouldn't use / 8 here.
1239 uint64_t Offset =
1240 OffsetToTop + MostDerivedClassLayout.getVBaseClassOffset(BaseDecl) / 8;
1241
1242 VCallAndVBaseOffsets.push_back(VtableComponent::MakeVBaseOffset(Offset));
1243 }
1244
1245 // Check the base class looking for more vbase offsets.
1246 AddVBaseOffsets(BaseDecl, OffsetToTop, VBases);
1247 }
Anders Carlssondc2dba32010-02-16 04:49:44 +00001248}
1249
1250void
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001251VtableBuilder::AddMethod(const CXXMethodDecl *MD,
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001252 ReturnAdjustment ReturnAdjustment,
1253 ThisAdjustment ThisAdjustment) {
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001254 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1255 assert(ReturnAdjustment.isEmpty() &&
1256 "Destructor can't have return adjustment!");
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001257 // Add the 'this' pointer adjustments if necessary.
1258 if (!ThisAdjustment.isEmpty()) {
1259 ThisAdjustments.push_back(std::make_pair(Components.size(),
1260 ThisAdjustment));
1261 ThisAdjustments.push_back(std::make_pair(Components.size() + 1,
1262 ThisAdjustment));
1263 }
1264
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001265 // Add both the complete destructor and the deleting destructor.
1266 Components.push_back(VtableComponent::MakeCompleteDtor(DD));
1267 Components.push_back(VtableComponent::MakeDeletingDtor(DD));
1268 } else {
1269 // Add the return adjustment if necessary.
1270 if (!ReturnAdjustment.isEmpty())
1271 ReturnAdjustments.push_back(std::make_pair(Components.size(),
1272 ReturnAdjustment));
1273
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001274 // Add the 'this' pointer adjustment if necessary.
1275 if (!ThisAdjustment.isEmpty())
1276 ThisAdjustments.push_back(std::make_pair(Components.size(),
1277 ThisAdjustment));
1278
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001279 // Add the function.
1280 Components.push_back(VtableComponent::MakeFunction(MD));
1281 }
1282}
1283
Anders Carlssona8796c62010-02-23 04:26:39 +00001284bool
1285VtableBuilder::IsOverriderUsed(BaseSubobject Base,
1286 BaseSubobject FirstBaseInPrimaryBaseChain,
1287 FinalOverriders::OverriderInfo Overrider) const {
1288 // If the base and the first base in the primary base chain have the same
1289 // offsets, then this overrider will be used.
1290 if (Base.getBaseOffset() == FirstBaseInPrimaryBaseChain.getBaseOffset())
Anders Carlsson8939e402010-02-23 06:34:44 +00001291 return true;
1292
1293 // We know now that Base (or a direct or indirect base of it) is a primary
1294 // base in part of the class hierarchy, but not a primary base in the most
1295 // derived class.
1296
1297 // If the overrider is the first base in the primary base chain, we know
1298 // that the overrider will be used.
1299 if (Overrider.Method->getParent() == FirstBaseInPrimaryBaseChain.getBase())
Anders Carlssona8796c62010-02-23 04:26:39 +00001300 return true;
1301
Anders Carlsson8939e402010-02-23 06:34:44 +00001302 VtableBuilder::PrimaryBasesSetTy PrimaryBases;
1303
1304 const CXXRecordDecl *RD = FirstBaseInPrimaryBaseChain.getBase();
1305 PrimaryBases.insert(RD);
1306
1307 // Now traverse the base chain, starting with the first base, until we find
1308 // the base that is no longer a primary base.
1309 while (true) {
1310 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1311 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1312
1313 if (!PrimaryBase)
1314 break;
1315
1316 if (Layout.getPrimaryBaseWasVirtual()) {
1317 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1318 "Primary base should always be at offset 0!");
1319
1320 const ASTRecordLayout &MostDerivedClassLayout =
1321 Context.getASTRecordLayout(MostDerivedClass);
1322
1323 // Now check if this is the primary base that is not a primary base in the
1324 // most derived class.
1325 if (MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase) !=
1326 FirstBaseInPrimaryBaseChain.getBaseOffset()) {
1327 // We found it, stop walking the chain.
1328 break;
1329 }
1330 } else {
1331 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1332 "Primary base should always be at offset 0!");
1333 }
1334 }
1335
1336 // If the final overrider is an override of one of the primary bases,
1337 // then we know that it will be used.
1338 return OverridesMethodInPrimaryBase(Overrider.Method, PrimaryBases);
Anders Carlssona8796c62010-02-23 04:26:39 +00001339}
1340
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001341void
Anders Carlssona8796c62010-02-23 04:26:39 +00001342VtableBuilder::AddMethods(BaseSubobject Base,
1343 BaseSubobject FirstBaseInPrimaryBaseChain,
1344 PrimaryBasesSetTy &PrimaryBases) {
Anders Carlsson65b49782010-02-12 05:25:12 +00001345 const CXXRecordDecl *RD = Base.getBase();
1346
1347 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1348
1349 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson0570f712010-02-23 03:48:14 +00001350 uint64_t BaseOffset;
1351 if (Layout.getPrimaryBaseWasVirtual()) {
1352 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1353 "Primary vbase should have a zero offset!");
1354
1355 const ASTRecordLayout &MostDerivedClassLayout =
1356 Context.getASTRecordLayout(MostDerivedClass);
1357
1358 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
1359
1360 // Keep track of this primary virtual base.
1361 PrimaryVirtualBases.insert(PrimaryBase);
1362 } else {
Anders Carlsson65b49782010-02-12 05:25:12 +00001363 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1364 "Primary base should have a zero offset!");
Anders Carlsson0570f712010-02-23 03:48:14 +00001365
1366 BaseOffset = Base.getBaseOffset();
1367 }
Anders Carlsson65b49782010-02-12 05:25:12 +00001368
Anders Carlssona8796c62010-02-23 04:26:39 +00001369 AddMethods(BaseSubobject(PrimaryBase, BaseOffset),
1370 FirstBaseInPrimaryBaseChain, PrimaryBases);
Anders Carlsson65b49782010-02-12 05:25:12 +00001371
1372 if (!PrimaryBases.insert(PrimaryBase))
1373 assert(false && "Found a duplicate primary base!");
1374 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00001375
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001376 // Now go through all virtual member functions and add them.
1377 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1378 E = RD->method_end(); I != E; ++I) {
1379 const CXXMethodDecl *MD = *I;
Anders Carlsson65b49782010-02-12 05:25:12 +00001380
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001381 if (!MD->isVirtual())
1382 continue;
Anders Carlsson65b49782010-02-12 05:25:12 +00001383
1384 // Get the final overrider.
Anders Carlsson136bd192010-02-12 16:55:34 +00001385 FinalOverriders::OverriderInfo Overrider =
1386 Overriders.getOverrider(Base, MD);
Anders Carlsson65b49782010-02-12 05:25:12 +00001387
1388 // Check if this virtual member function overrides a method in a primary
1389 // base. If this is the case, and the return type doesn't require adjustment
1390 // then we can just use the member function from the primary base.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001391 if (const CXXMethodDecl *OverriddenMD =
1392 OverridesMethodInPrimaryBase(MD, PrimaryBases)) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +00001393 if (ComputeReturnAdjustmentBaseOffset(Context, MD,
1394 OverriddenMD).isEmpty())
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001395 continue;
1396 }
Anders Carlssoneee53d92010-02-13 02:02:03 +00001397
Anders Carlssona8796c62010-02-23 04:26:39 +00001398 // Check if this overrider is going to be used.
1399 if (!IsOverriderUsed(Base, FirstBaseInPrimaryBaseChain, Overrider)) {
1400 const CXXMethodDecl *OverriderMD = Overrider.Method;
1401 Components.push_back(VtableComponent::MakeUnusedFunction(OverriderMD));
1402 continue;
1403 }
1404
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001405 // Check if this overrider needs a return adjustment.
Anders Carlsson075056a2010-02-23 01:34:28 +00001406 BaseOffset ReturnAdjustmentOffset =
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001407 Overriders.getReturnAdjustmentOffset(Base, MD);
1408
1409 ReturnAdjustment ReturnAdjustment =
1410 ComputeReturnAdjustment(ReturnAdjustmentOffset);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001411
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001412 // Check if this overrider needs a 'this' pointer adjustment.
Anders Carlsson075056a2010-02-23 01:34:28 +00001413 BaseOffset ThisAdjustmentOffset =
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001414 Overriders.getThisAdjustmentOffset(Base, MD);
1415
Anders Carlsson78277c72010-02-18 17:00:09 +00001416 ThisAdjustment ThisAdjustment = ComputeThisAdjustment(Overrider.Method,
1417 ThisAdjustmentOffset);
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001418
1419 AddMethod(Overrider.Method, ReturnAdjustment, ThisAdjustment);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001420 }
1421}
1422
Anders Carlssonb716a542010-02-16 16:26:28 +00001423void VtableBuilder::LayoutVtable() {
Anders Carlssondb042202010-02-17 03:11:55 +00001424 LayoutPrimaryAndAndSecondaryVtables(BaseSubobject(MostDerivedClass, 0),
1425 /*BaseIsVirtual=*/false);
Anders Carlssonb716a542010-02-16 16:26:28 +00001426
Anders Carlsson13f0f662010-02-16 16:49:35 +00001427 VisitedVirtualBasesSetTy VBases;
1428 LayoutVtablesForVirtualBases(MostDerivedClass, VBases);
Anders Carlssonb716a542010-02-16 16:26:28 +00001429}
1430
Anders Carlssondb042202010-02-17 03:11:55 +00001431void VtableBuilder::LayoutPrimaryAndAndSecondaryVtables(BaseSubobject Base,
1432 bool BaseIsVirtual) {
Chris Lattnerd2408f72010-02-17 21:42:34 +00001433 assert(Base.getBase()->isDynamicClass() && "class does not have a vtable!");
Anders Carlsson033d4862010-02-14 17:05:59 +00001434
Anders Carlsson77904f12010-02-16 04:59:55 +00001435 // Add vcall and vbase offsets for this vtable.
1436 VisitedVirtualBasesSetTy VBases;
Anders Carlssondb042202010-02-17 03:11:55 +00001437 AddVCallAndVBaseOffsets(Base, BaseIsVirtual, VBases);
Anders Carlsson77904f12010-02-16 04:59:55 +00001438
1439 // Reverse them and add them to the vtable components.
1440 std::reverse(VCallAndVBaseOffsets.begin(), VCallAndVBaseOffsets.end());
1441 Components.append(VCallAndVBaseOffsets.begin(), VCallAndVBaseOffsets.end());
1442 VCallAndVBaseOffsets.clear();
1443
1444 // Add the offset to top.
Anders Carlssone75aaa92010-02-13 22:05:23 +00001445 // FIXME: This is not going to be right for construction vtables.
Anders Carlsson258a1e32010-02-14 00:16:19 +00001446 // FIXME: We should not use / 8 here.
Anders Carlssondb042202010-02-17 03:11:55 +00001447 int64_t OffsetToTop = -(int64_t)Base.getBaseOffset() / 8;
Anders Carlssone75aaa92010-02-13 22:05:23 +00001448 Components.push_back(VtableComponent::MakeOffsetToTop(OffsetToTop));
Anders Carlsson65b49782010-02-12 05:25:12 +00001449
1450 // Next, add the RTTI.
Anders Carlssone75aaa92010-02-13 22:05:23 +00001451 Components.push_back(VtableComponent::MakeRTTI(MostDerivedClass));
Anders Carlsson65b49782010-02-12 05:25:12 +00001452
Anders Carlssone8a97562010-02-12 07:43:48 +00001453 uint64_t AddressPoint = Components.size();
Anders Carlsson65b49782010-02-12 05:25:12 +00001454
1455 // Now go through all virtual member functions and add them.
1456 PrimaryBasesSetTy PrimaryBases;
Anders Carlssona8796c62010-02-23 04:26:39 +00001457 AddMethods(Base, Base, PrimaryBases);
Anders Carlsson65b49782010-02-12 05:25:12 +00001458
Anders Carlssone8a97562010-02-12 07:43:48 +00001459 // Record the address point.
1460 AddressPoints.insert(std::make_pair(Base, AddressPoint));
1461
1462 // Record the address points for all primary bases.
1463 for (PrimaryBasesSetTy::const_iterator I = PrimaryBases.begin(),
1464 E = PrimaryBases.end(); I != E; ++I) {
1465 const CXXRecordDecl *BaseDecl = *I;
1466
1467 // We know that all the primary bases have the same offset as the base
1468 // subobject.
1469 BaseSubobject PrimaryBase(BaseDecl, Base.getBaseOffset());
1470 AddressPoints.insert(std::make_pair(PrimaryBase, AddressPoint));
1471 }
1472
Anders Carlsson14157932010-02-16 16:02:57 +00001473 // Layout secondary vtables.
1474 LayoutSecondaryVtables(Base);
Anders Carlsson78277c72010-02-18 17:00:09 +00001475
1476 // Clear the vcall offsets.
1477 VCallOffsets.clear();
Anders Carlsson14157932010-02-16 16:02:57 +00001478}
1479
1480void VtableBuilder::LayoutSecondaryVtables(BaseSubobject Base) {
1481 // Itanium C++ ABI 2.5.2:
1482 // Following the primary virtual table of a derived class are secondary
1483 // virtual tables for each of its proper base classes, except any primary
1484 // base(s) with which it shares its primary virtual table.
1485
1486 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson65b49782010-02-12 05:25:12 +00001487 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1488 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
Anders Carlsson14157932010-02-16 16:02:57 +00001489
Anders Carlsson65b49782010-02-12 05:25:12 +00001490 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1491 E = RD->bases_end(); I != E; ++I) {
Anders Carlsson14157932010-02-16 16:02:57 +00001492 // Ignore virtual bases, we'll emit them later.
1493 if (I->isVirtual())
1494 continue;
1495
Anders Carlsson65b49782010-02-12 05:25:12 +00001496 const CXXRecordDecl *BaseDecl =
1497 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson033d4862010-02-14 17:05:59 +00001498
Anders Carlssondc2dba32010-02-16 04:49:44 +00001499 // Ignore bases that don't have a vtable.
1500 if (!BaseDecl->isDynamicClass())
1501 continue;
Anders Carlsson033d4862010-02-14 17:05:59 +00001502
Anders Carlssone75aaa92010-02-13 22:05:23 +00001503 // Get the base offset of this base.
1504 uint64_t BaseOffset = Base.getBaseOffset() +
1505 Layout.getBaseClassOffset(BaseDecl);
Anders Carlsson14157932010-02-16 16:02:57 +00001506
1507 // Don't emit a secondary vtable for a primary base. We might however want
1508 // to emit secondary vtables for other bases of this base.
1509 if (BaseDecl == PrimaryBase) {
1510 LayoutSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset));
1511 continue;
1512 }
Anders Carlssone75aaa92010-02-13 22:05:23 +00001513
Anders Carlssonb716a542010-02-16 16:26:28 +00001514 // Layout the primary vtable (and any secondary vtables) for this base.
Anders Carlssondb042202010-02-17 03:11:55 +00001515 LayoutPrimaryAndAndSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
1516 /*BaseIsVirtual=*/false);
Anders Carlsson65b49782010-02-12 05:25:12 +00001517 }
1518}
1519
Anders Carlsson13f0f662010-02-16 16:49:35 +00001520void
1521VtableBuilder::LayoutVtablesForVirtualBases(const CXXRecordDecl *RD,
1522 VisitedVirtualBasesSetTy &VBases) {
1523 // Itanium C++ ABI 2.5.2:
1524 // Then come the virtual base virtual tables, also in inheritance graph
1525 // order, and again excluding primary bases (which share virtual tables with
1526 // the classes for which they are primary).
1527 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1528 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1529
1530 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1531 E = RD->bases_end(); I != E; ++I) {
1532 const CXXRecordDecl *BaseDecl =
1533 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1534
Anders Carlsson0570f712010-02-23 03:48:14 +00001535 // Check if this base needs a vtable. (If it's virtual, not a primary base
1536 // of some other class, and we haven't visited it before).
Anders Carlsson13f0f662010-02-16 16:49:35 +00001537 if (I->isVirtual() && BaseDecl->isDynamicClass() &&
Anders Carlsson0570f712010-02-23 03:48:14 +00001538 BaseDecl != PrimaryBase && !PrimaryVirtualBases.count(BaseDecl) &&
1539 VBases.insert(BaseDecl)) {
Anders Carlsson13f0f662010-02-16 16:49:35 +00001540 const ASTRecordLayout &MostDerivedClassLayout =
1541 Context.getASTRecordLayout(MostDerivedClass);
1542 uint64_t BaseOffset =
1543 MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
1544
Anders Carlssondb042202010-02-17 03:11:55 +00001545 LayoutPrimaryAndAndSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
1546 /*BaseIsVirtual=*/true);
Anders Carlsson13f0f662010-02-16 16:49:35 +00001547 }
1548
1549 // We only need to check the base for virtual base vtables if it actually
1550 // has virtual bases.
1551 if (BaseDecl->getNumVBases())
1552 LayoutVtablesForVirtualBases(BaseDecl, VBases);
1553 }
1554}
1555
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001556/// dumpLayout - Dump the vtable layout.
1557void VtableBuilder::dumpLayout(llvm::raw_ostream& Out) {
1558
1559 Out << "Vtable for '" << MostDerivedClass->getQualifiedNameAsString();
1560 Out << "' (" << Components.size() << " entries).\n";
1561
Anders Carlsson932c2f22010-02-11 17:18:51 +00001562 // Iterate through the address points and insert them into a new map where
1563 // they are keyed by the index and not the base object.
1564 // Since an address point can be shared by multiple subobjects, we use an
1565 // STL multimap.
1566 std::multimap<uint64_t, BaseSubobject> AddressPointsByIndex;
1567 for (CGVtableInfo::AddressPointsMapTy::const_iterator I =
1568 AddressPoints.begin(), E = AddressPoints.end(); I != E; ++I) {
1569 const BaseSubobject& Base = I->first;
1570 uint64_t Index = I->second;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001571
Anders Carlsson932c2f22010-02-11 17:18:51 +00001572 AddressPointsByIndex.insert(std::make_pair(Index, Base));
1573 }
1574
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001575 unsigned NextReturnAdjustmentIndex = 0;
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001576 unsigned NextThisAdjustmentIndex = 0;
Anders Carlsson932c2f22010-02-11 17:18:51 +00001577 for (unsigned I = 0, E = Components.size(); I != E; ++I) {
Anders Carlssone8a97562010-02-12 07:43:48 +00001578 uint64_t Index = I;
1579
Anders Carlsson932c2f22010-02-11 17:18:51 +00001580 if (AddressPointsByIndex.count(I)) {
Anders Carlssone8a97562010-02-12 07:43:48 +00001581 if (AddressPointsByIndex.count(Index) == 1) {
1582 const BaseSubobject &Base = AddressPointsByIndex.find(Index)->second;
1583
1584 // FIXME: Instead of dividing by 8, we should be using CharUnits.
1585 Out << " -- (" << Base.getBase()->getQualifiedNameAsString();
1586 Out << ", " << Base.getBaseOffset() / 8 << ") vtable address --\n";
1587 } else {
1588 uint64_t BaseOffset =
1589 AddressPointsByIndex.lower_bound(Index)->second.getBaseOffset();
1590
1591 // We store the class names in a set to get a stable order.
1592 std::set<std::string> ClassNames;
1593 for (std::multimap<uint64_t, BaseSubobject>::const_iterator I =
1594 AddressPointsByIndex.lower_bound(Index), E =
1595 AddressPointsByIndex.upper_bound(Index); I != E; ++I) {
1596 assert(I->second.getBaseOffset() == BaseOffset &&
1597 "Invalid base offset!");
1598 const CXXRecordDecl *RD = I->second.getBase();
1599 ClassNames.insert(RD->getQualifiedNameAsString());
1600 }
1601
1602 for (std::set<std::string>::const_iterator I = ClassNames.begin(),
1603 E = ClassNames.end(); I != E; ++I) {
1604 // FIXME: Instead of dividing by 8, we should be using CharUnits.
1605 Out << " -- (" << *I;
1606 Out << ", " << BaseOffset / 8 << ") vtable address --\n";
1607 }
1608 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00001609 }
1610
1611 Out << llvm::format("%4d | ", I);
1612
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001613 const VtableComponent &Component = Components[I];
1614
1615 // Dump the component.
1616 switch (Component.getKind()) {
Anders Carlssonb0a588f2010-02-17 06:07:19 +00001617
1618 case VtableComponent::CK_VCallOffset:
1619 Out << "vcall_offset (" << Component.getVCallOffset() << ")";
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001620 break;
Anders Carlsson77904f12010-02-16 04:59:55 +00001621
1622 case VtableComponent::CK_VBaseOffset:
1623 Out << "vbase_offset (" << Component.getVBaseOffset() << ")";
1624 break;
1625
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001626 case VtableComponent::CK_OffsetToTop:
1627 Out << "offset_to_top (" << Component.getOffsetToTop() << ")";
1628 break;
1629
1630 case VtableComponent::CK_RTTI:
1631 Out << Component.getRTTIDecl()->getQualifiedNameAsString() << " RTTI";
1632 break;
1633
Anders Carlsson5bd8d192010-02-11 18:20:28 +00001634 case VtableComponent::CK_FunctionPointer: {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001635 const CXXMethodDecl *MD = Component.getFunctionDecl();
1636
Anders Carlsson5bd8d192010-02-11 18:20:28 +00001637 std::string Str =
1638 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
1639 MD);
1640 Out << Str;
Anders Carlsson09da3372010-02-12 02:38:13 +00001641 if (MD->isPure())
1642 Out << " [pure]";
1643
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001644 // If this function pointer has a return adjustment, dump it.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001645 if (NextReturnAdjustmentIndex < ReturnAdjustments.size() &&
1646 ReturnAdjustments[NextReturnAdjustmentIndex].first == I) {
1647 const ReturnAdjustment Adjustment =
1648 ReturnAdjustments[NextReturnAdjustmentIndex].second;
1649
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001650 Out << "\n [return adjustment: ";
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001651 Out << Adjustment.NonVirtual << " non-virtual";
1652
1653 if (Adjustment.VBaseOffsetOffset)
1654 Out << ", " << Adjustment.VBaseOffsetOffset << " vbase offset offset";
Anders Carlsson78277c72010-02-18 17:00:09 +00001655
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001656 Out << ']';
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001657
1658 NextReturnAdjustmentIndex++;
1659 }
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001660
1661 // If this function pointer has a 'this' pointer adjustment, dump it.
1662 if (NextThisAdjustmentIndex < ThisAdjustments.size() &&
1663 ThisAdjustments[NextThisAdjustmentIndex].first == I) {
1664 const ThisAdjustment Adjustment =
1665 ThisAdjustments[NextThisAdjustmentIndex].second;
1666
1667 Out << "\n [this adjustment: ";
1668 Out << Adjustment.NonVirtual << " non-virtual";
Anders Carlsson78277c72010-02-18 17:00:09 +00001669
1670 if (Adjustment.VCallOffsetOffset)
1671 Out << ", " << Adjustment.VCallOffsetOffset << " vcall offset offset";
1672
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001673 Out << ']';
1674
1675 NextThisAdjustmentIndex++;
1676 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001677
Anders Carlsson5bd8d192010-02-11 18:20:28 +00001678 break;
1679 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001680
Anders Carlsson2d3d9032010-02-19 06:03:53 +00001681 case VtableComponent::CK_CompleteDtorPointer:
Anders Carlsson5bd8d192010-02-11 18:20:28 +00001682 case VtableComponent::CK_DeletingDtorPointer: {
Anders Carlsson2d3d9032010-02-19 06:03:53 +00001683 bool IsComplete =
1684 Component.getKind() == VtableComponent::CK_CompleteDtorPointer;
1685
Anders Carlsson5bd8d192010-02-11 18:20:28 +00001686 const CXXDestructorDecl *DD = Component.getDestructorDecl();
1687
Anders Carlsson2d3d9032010-02-19 06:03:53 +00001688 Out << DD->getQualifiedNameAsString();
1689 if (IsComplete)
1690 Out << "() [complete]";
1691 else
1692 Out << "() [deleting]";
1693
Anders Carlsson09da3372010-02-12 02:38:13 +00001694 if (DD->isPure())
1695 Out << " [pure]";
1696
Anders Carlsson2d3d9032010-02-19 06:03:53 +00001697 // If this destructor has a 'this' pointer adjustment, dump it.
1698 if (NextThisAdjustmentIndex < ThisAdjustments.size() &&
1699 ThisAdjustments[NextThisAdjustmentIndex].first == I) {
1700 const ThisAdjustment Adjustment =
1701 ThisAdjustments[NextThisAdjustmentIndex].second;
1702
1703 Out << "\n [this adjustment: ";
1704 Out << Adjustment.NonVirtual << " non-virtual";
1705
1706 if (Adjustment.VCallOffsetOffset)
1707 Out << ", " << Adjustment.VCallOffsetOffset << " vcall offset offset";
1708
1709 Out << ']';
1710
1711 NextThisAdjustmentIndex++;
1712 }
1713
1714
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001715 break;
1716 }
1717
Anders Carlsson350b56e2010-02-19 20:08:13 +00001718 case VtableComponent::CK_UnusedFunctionPointer: {
1719 const CXXMethodDecl *MD = Component.getUnusedFunctionDecl();
1720
1721 std::string Str =
1722 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
1723 MD);
1724 Out << "[unused] " << Str;
1725 if (MD->isPure())
1726 Out << " [pure]";
1727 }
1728
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001729 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00001730
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001731 Out << '\n';
1732 }
1733
1734}
1735
1736}
1737
1738namespace {
1739class OldVtableBuilder {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001740public:
1741 /// Index_t - Vtable index type.
1742 typedef uint64_t Index_t;
Eli Friedman31bc3ad2009-12-07 23:56:34 +00001743 typedef std::vector<std::pair<GlobalDecl,
1744 std::pair<GlobalDecl, ThunkAdjustment> > >
1745 SavedAdjustmentsVectorTy;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001746private:
Anders Carlsson472404f2009-12-04 16:19:30 +00001747
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00001748 // VtableComponents - The components of the vtable being built.
1749 typedef llvm::SmallVector<llvm::Constant *, 64> VtableComponentsVectorTy;
1750 VtableComponentsVectorTy VtableComponents;
1751
Eli Friedman6c08ce72009-12-05 01:05:03 +00001752 const bool BuildVtable;
1753
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001754 llvm::Type *Ptr8Ty;
Anders Carlssonbad80eb2009-12-04 18:36:22 +00001755
1756 /// MostDerivedClass - The most derived class that this vtable is being
1757 /// built for.
1758 const CXXRecordDecl *MostDerivedClass;
1759
Mike Stump83066c82009-11-13 01:54:23 +00001760 /// LayoutClass - The most derived class used for virtual base layout
1761 /// information.
1762 const CXXRecordDecl *LayoutClass;
Mike Stump653d0b92009-11-13 02:13:54 +00001763 /// LayoutOffset - The offset for Class in LayoutClass.
1764 uint64_t LayoutOffset;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001765 /// BLayout - Layout for the most derived class that this vtable is being
1766 /// built for.
1767 const ASTRecordLayout &BLayout;
1768 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
1769 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
1770 llvm::Constant *rtti;
1771 llvm::LLVMContext &VMContext;
1772 CodeGenModule &CGM; // Per-module state.
Anders Carlssonf2f31f42009-12-04 03:46:21 +00001773
Mike Stump90181eb2010-01-26 00:05:04 +00001774 llvm::DenseMap<const CXXMethodDecl *, Index_t> VCall;
Anders Carlssonfb4dda42009-11-13 17:08:56 +00001775 llvm::DenseMap<GlobalDecl, Index_t> VCallOffset;
Mike Stump77537b12010-01-26 03:42:22 +00001776 llvm::DenseMap<GlobalDecl, Index_t> VCallOffsetForVCall;
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00001777 // This is the offset to the nearest virtual base
Mike Stump90181eb2010-01-26 00:05:04 +00001778 llvm::DenseMap<const CXXMethodDecl *, Index_t> NonVirtualOffset;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001779 llvm::DenseMap<const CXXRecordDecl *, Index_t> VBIndex;
Mike Stumpbb9ff052009-10-27 23:46:47 +00001780
Anders Carlsson323bb042009-11-26 19:54:33 +00001781 /// PureVirtualFunction - Points to __cxa_pure_virtual.
1782 llvm::Constant *PureVirtualFn;
1783
Anders Carlssona84b6e82009-12-04 02:01:07 +00001784 /// VtableMethods - A data structure for keeping track of methods in a vtable.
1785 /// Can add methods, override methods and iterate in vtable order.
1786 class VtableMethods {
1787 // MethodToIndexMap - Maps from a global decl to the index it has in the
1788 // Methods vector.
1789 llvm::DenseMap<GlobalDecl, uint64_t> MethodToIndexMap;
1790
1791 /// Methods - The methods, in vtable order.
1792 typedef llvm::SmallVector<GlobalDecl, 16> MethodsVectorTy;
1793 MethodsVectorTy Methods;
Eli Friedman8174f2c2009-12-06 22:01:30 +00001794 MethodsVectorTy OrigMethods;
Anders Carlssona84b6e82009-12-04 02:01:07 +00001795
1796 public:
1797 /// AddMethod - Add a method to the vtable methods.
1798 void AddMethod(GlobalDecl GD) {
1799 assert(!MethodToIndexMap.count(GD) &&
1800 "Method has already been added!");
1801
1802 MethodToIndexMap[GD] = Methods.size();
1803 Methods.push_back(GD);
Eli Friedman8174f2c2009-12-06 22:01:30 +00001804 OrigMethods.push_back(GD);
Anders Carlssona84b6e82009-12-04 02:01:07 +00001805 }
1806
1807 /// OverrideMethod - Replace a method with another.
1808 void OverrideMethod(GlobalDecl OverriddenGD, GlobalDecl GD) {
1809 llvm::DenseMap<GlobalDecl, uint64_t>::iterator i
1810 = MethodToIndexMap.find(OverriddenGD);
1811 assert(i != MethodToIndexMap.end() && "Did not find entry!");
1812
1813 // Get the index of the old decl.
1814 uint64_t Index = i->second;
1815
1816 // Replace the old decl with the new decl.
1817 Methods[Index] = GD;
1818
Anders Carlssona84b6e82009-12-04 02:01:07 +00001819 // And add the new.
1820 MethodToIndexMap[GD] = Index;
1821 }
1822
Anders Carlsson7bb70762009-12-04 15:49:02 +00001823 /// getIndex - Gives the index of a passed in GlobalDecl. Returns false if
1824 /// the index couldn't be found.
Benjamin Kramer62ab6162009-12-04 22:45:27 +00001825 bool getIndex(GlobalDecl GD, uint64_t &Index) const {
Anders Carlsson7bb70762009-12-04 15:49:02 +00001826 llvm::DenseMap<GlobalDecl, uint64_t>::const_iterator i
1827 = MethodToIndexMap.find(GD);
Eli Friedman3d2e9de2009-12-04 08:34:14 +00001828
Anders Carlsson7bb70762009-12-04 15:49:02 +00001829 if (i == MethodToIndexMap.end())
1830 return false;
Anders Carlssone6096362009-12-04 03:41:37 +00001831
Anders Carlsson7bb70762009-12-04 15:49:02 +00001832 Index = i->second;
1833 return true;
Anders Carlssone6096362009-12-04 03:41:37 +00001834 }
1835
Eli Friedman8174f2c2009-12-06 22:01:30 +00001836 GlobalDecl getOrigMethod(uint64_t Index) const {
1837 return OrigMethods[Index];
1838 }
1839
Anders Carlssona84b6e82009-12-04 02:01:07 +00001840 MethodsVectorTy::size_type size() const {
1841 return Methods.size();
1842 }
1843
1844 void clear() {
1845 MethodToIndexMap.clear();
1846 Methods.clear();
Eli Friedman8174f2c2009-12-06 22:01:30 +00001847 OrigMethods.clear();
Anders Carlssona84b6e82009-12-04 02:01:07 +00001848 }
1849
Anders Carlssone6096362009-12-04 03:41:37 +00001850 GlobalDecl operator[](uint64_t Index) const {
Anders Carlssona84b6e82009-12-04 02:01:07 +00001851 return Methods[Index];
1852 }
1853 };
1854
1855 /// Methods - The vtable methods we're currently building.
1856 VtableMethods Methods;
1857
Anders Carlsson4c837d22009-12-04 02:26:15 +00001858 /// ThisAdjustments - For a given index in the vtable, contains the 'this'
1859 /// pointer adjustment needed for a method.
1860 typedef llvm::DenseMap<uint64_t, ThunkAdjustment> ThisAdjustmentsMapTy;
1861 ThisAdjustmentsMapTy ThisAdjustments;
Anders Carlssond420a312009-11-26 19:32:45 +00001862
Eli Friedman31bc3ad2009-12-07 23:56:34 +00001863 SavedAdjustmentsVectorTy SavedAdjustments;
Eli Friedman8174f2c2009-12-06 22:01:30 +00001864
Anders Carlssonc521f952009-12-04 02:22:02 +00001865 /// BaseReturnTypes - Contains the base return types of methods who have been
1866 /// overridden with methods whose return types require adjustment. Used for
1867 /// generating covariant thunk information.
1868 typedef llvm::DenseMap<uint64_t, CanQualType> BaseReturnTypesMapTy;
1869 BaseReturnTypesMapTy BaseReturnTypes;
Anders Carlssond420a312009-11-26 19:32:45 +00001870
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001871 std::vector<Index_t> VCalls;
Mike Stump2cefe382009-11-12 20:47:57 +00001872
1873 typedef std::pair<const CXXRecordDecl *, uint64_t> CtorVtable_t;
Mike Stumpcd2b8212009-11-19 20:52:19 +00001874 // subAddressPoints - Used to hold the AddressPoints (offsets) into the built
1875 // vtable for use in computing the initializers for the VTT.
1876 llvm::DenseMap<CtorVtable_t, int64_t> &subAddressPoints;
Mike Stump2cefe382009-11-12 20:47:57 +00001877
Anders Carlsson5f9a8812010-01-14 02:29:07 +00001878 /// AddressPoints - Address points for this vtable.
1879 CGVtableInfo::AddressPointsMapTy& AddressPoints;
1880
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001881 typedef CXXRecordDecl::method_iterator method_iter;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00001882 const uint32_t LLVMPointerWidth;
1883 Index_t extra;
Mike Stump37dbe962009-10-15 02:04:03 +00001884 typedef std::vector<std::pair<const CXXRecordDecl *, int64_t> > Path_t;
Mike Stumpcd2b8212009-11-19 20:52:19 +00001885 static llvm::DenseMap<CtorVtable_t, int64_t>&
1886 AllocAddressPoint(CodeGenModule &cgm, const CXXRecordDecl *l,
1887 const CXXRecordDecl *c) {
Anders Carlsson93a18842010-01-02 18:02:32 +00001888 CGVtableInfo::AddrMap_t *&oref = cgm.getVtableInfo().AddressPoints[l];
Mike Stumpcd2b8212009-11-19 20:52:19 +00001889 if (oref == 0)
Anders Carlsson93a18842010-01-02 18:02:32 +00001890 oref = new CGVtableInfo::AddrMap_t;
Mike Stumpcd2b8212009-11-19 20:52:19 +00001891
1892 llvm::DenseMap<CtorVtable_t, int64_t> *&ref = (*oref)[c];
1893 if (ref == 0)
1894 ref = new llvm::DenseMap<CtorVtable_t, int64_t>;
1895 return *ref;
1896 }
Anders Carlsson323bb042009-11-26 19:54:33 +00001897
Mike Stump90181eb2010-01-26 00:05:04 +00001898 bool DclIsSame(const FunctionDecl *New, const FunctionDecl *Old) {
1899 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1900 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1901
1902 // C++ [temp.fct]p2:
1903 // A function template can be overloaded with other function templates
1904 // and with normal (non-template) functions.
1905 if ((OldTemplate == 0) != (NewTemplate == 0))
1906 return false;
1907
1908 // Is the function New an overload of the function Old?
1909 QualType OldQType = CGM.getContext().getCanonicalType(Old->getType());
1910 QualType NewQType = CGM.getContext().getCanonicalType(New->getType());
1911
1912 // Compare the signatures (C++ 1.3.10) of the two functions to
1913 // determine whether they are overloads. If we find any mismatch
1914 // in the signature, they are overloads.
1915
1916 // If either of these functions is a K&R-style function (no
1917 // prototype), then we consider them to have matching signatures.
1918 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1919 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1920 return true;
1921
1922 FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType);
1923 FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType);
1924
1925 // The signature of a function includes the types of its
1926 // parameters (C++ 1.3.10), which includes the presence or absence
1927 // of the ellipsis; see C++ DR 357).
1928 if (OldQType != NewQType &&
1929 (OldType->getNumArgs() != NewType->getNumArgs() ||
1930 OldType->isVariadic() != NewType->isVariadic() ||
1931 !std::equal(OldType->arg_type_begin(), OldType->arg_type_end(),
1932 NewType->arg_type_begin())))
1933 return false;
1934
1935#if 0
1936 // C++ [temp.over.link]p4:
1937 // The signature of a function template consists of its function
1938 // signature, its return type and its template parameter list. The names
1939 // of the template parameters are significant only for establishing the
1940 // relationship between the template parameters and the rest of the
1941 // signature.
1942 //
1943 // We check the return type and template parameter lists for function
1944 // templates first; the remaining checks follow.
1945 if (NewTemplate &&
1946 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1947 OldTemplate->getTemplateParameters(),
1948 TPL_TemplateMatch) ||
1949 OldType->getResultType() != NewType->getResultType()))
1950 return false;
1951#endif
1952
1953 // If the function is a class member, its signature includes the
1954 // cv-qualifiers (if any) on the function itself.
1955 //
1956 // As part of this, also check whether one of the member functions
1957 // is static, in which case they are not overloads (C++
1958 // 13.1p2). While not part of the definition of the signature,
1959 // this check is important to determine whether these functions
1960 // can be overloaded.
1961 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
1962 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
1963 if (OldMethod && NewMethod &&
1964 !OldMethod->isStatic() && !NewMethod->isStatic() &&
1965 OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers())
1966 return false;
1967
1968 // The signatures match; this is not an overload.
1969 return true;
1970 }
1971
1972 typedef llvm::DenseMap<const CXXMethodDecl *, const CXXMethodDecl*>
1973 ForwardUnique_t;
1974 ForwardUnique_t ForwardUnique;
1975 llvm::DenseMap<const CXXMethodDecl*, const CXXMethodDecl*> UniqueOverrider;
1976
1977 void BuildUniqueOverrider(const CXXMethodDecl *U, const CXXMethodDecl *MD) {
1978 const CXXMethodDecl *PrevU = UniqueOverrider[MD];
1979 assert(U && "no unique overrider");
1980 if (PrevU == U)
1981 return;
1982 if (PrevU != U && PrevU != 0) {
1983 // If already set, note the two sets as the same
1984 if (0)
1985 printf("%s::%s same as %s::%s\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00001986 PrevU->getParent()->getNameAsString().c_str(),
1987 PrevU->getNameAsString().c_str(),
1988 U->getParent()->getNameAsString().c_str(),
1989 U->getNameAsString().c_str());
Mike Stump90181eb2010-01-26 00:05:04 +00001990 ForwardUnique[PrevU] = U;
1991 return;
1992 }
1993
1994 // Not set, set it now
1995 if (0)
1996 printf("marking %s::%s %p override as %s::%s\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00001997 MD->getParent()->getNameAsString().c_str(),
1998 MD->getNameAsString().c_str(),
Mike Stump90181eb2010-01-26 00:05:04 +00001999 (void*)MD,
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002000 U->getParent()->getNameAsString().c_str(),
2001 U->getNameAsString().c_str());
Mike Stump90181eb2010-01-26 00:05:04 +00002002 UniqueOverrider[MD] = U;
2003
2004 for (CXXMethodDecl::method_iterator mi = MD->begin_overridden_methods(),
2005 me = MD->end_overridden_methods(); mi != me; ++mi) {
2006 BuildUniqueOverrider(U, *mi);
2007 }
2008 }
2009
2010 void BuildUniqueOverriders(const CXXRecordDecl *RD) {
2011 if (0) printf("walking %s\n", RD->getNameAsCString());
2012 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
2013 e = RD->method_end(); i != e; ++i) {
2014 const CXXMethodDecl *MD = *i;
2015 if (!MD->isVirtual())
2016 continue;
2017
2018 if (UniqueOverrider[MD] == 0) {
2019 // Only set this, if it hasn't been set yet.
2020 BuildUniqueOverrider(MD, MD);
2021 if (0)
2022 printf("top set is %s::%s %p\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002023 MD->getParent()->getNameAsString().c_str(),
2024 MD->getNameAsString().c_str(),
Mike Stump90181eb2010-01-26 00:05:04 +00002025 (void*)MD);
2026 ForwardUnique[MD] = MD;
2027 }
2028 }
2029 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2030 e = RD->bases_end(); i != e; ++i) {
2031 const CXXRecordDecl *Base =
2032 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2033 BuildUniqueOverriders(Base);
2034 }
2035 }
2036
2037 static int DclCmp(const void *p1, const void *p2) {
John McCallef3057c2010-02-13 01:04:05 +00002038 const CXXMethodDecl *MD1 = *(const CXXMethodDecl *const *)p1;
2039 const CXXMethodDecl *MD2 = *(const CXXMethodDecl *const *)p2;
2040
2041 return (DeclarationName::compare(MD1->getDeclName(), MD2->getDeclName()));
Mike Stump90181eb2010-01-26 00:05:04 +00002042 }
2043
2044 void MergeForwarding() {
2045 typedef llvm::SmallVector<const CXXMethodDecl *, 100> A_t;
2046 A_t A;
2047 for (ForwardUnique_t::iterator I = ForwardUnique.begin(),
2048 E = ForwardUnique.end(); I != E; ++I) {
2049 if (I->first == I->second)
2050 // Only add the roots of all trees
2051 A.push_back(I->first);
2052 }
2053 llvm::array_pod_sort(A.begin(), A.end(), DclCmp);
2054 for (A_t::iterator I = A.begin(),
2055 E = A.end(); I != E; ++I) {
2056 A_t::iterator J = I;
John McCallef3057c2010-02-13 01:04:05 +00002057 while (++J != E && DclCmp(I, J) == 0)
Mike Stump90181eb2010-01-26 00:05:04 +00002058 if (DclIsSame(*I, *J)) {
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002059 if (0) printf("connecting %s\n", (*I)->getNameAsString().c_str());
Mike Stump90181eb2010-01-26 00:05:04 +00002060 ForwardUnique[*J] = *I;
2061 }
2062 }
2063 }
2064
2065 const CXXMethodDecl *getUnique(const CXXMethodDecl *MD) {
2066 const CXXMethodDecl *U = UniqueOverrider[MD];
2067 assert(U && "unique overrider not found");
2068 while (ForwardUnique.count(U)) {
2069 const CXXMethodDecl *NU = ForwardUnique[U];
2070 if (NU == U) break;
2071 U = NU;
2072 }
2073 return U;
2074 }
Anders Carlsson72281172010-01-26 17:36:47 +00002075
2076 GlobalDecl getUnique(GlobalDecl GD) {
2077 const CXXMethodDecl *Unique = getUnique(cast<CXXMethodDecl>(GD.getDecl()));
2078
2079 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Unique))
2080 return GlobalDecl(CD, GD.getCtorType());
2081
2082 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Unique))
2083 return GlobalDecl(DD, GD.getDtorType());
2084
2085 return Unique;
Mike Stump90181eb2010-01-26 00:05:04 +00002086 }
2087
Anders Carlsson323bb042009-11-26 19:54:33 +00002088 /// getPureVirtualFn - Return the __cxa_pure_virtual function.
2089 llvm::Constant* getPureVirtualFn() {
2090 if (!PureVirtualFn) {
2091 const llvm::FunctionType *Ty =
2092 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
2093 /*isVarArg=*/false);
2094 PureVirtualFn = wrap(CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual"));
2095 }
2096
2097 return PureVirtualFn;
2098 }
2099
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002100public:
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002101 OldVtableBuilder(const CXXRecordDecl *MostDerivedClass,
Eli Friedman6c08ce72009-12-05 01:05:03 +00002102 const CXXRecordDecl *l, uint64_t lo, CodeGenModule &cgm,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002103 bool build, CGVtableInfo::AddressPointsMapTy& AddressPoints)
Eli Friedman6c08ce72009-12-05 01:05:03 +00002104 : BuildVtable(build), MostDerivedClass(MostDerivedClass), LayoutClass(l),
2105 LayoutOffset(lo), BLayout(cgm.getContext().getASTRecordLayout(l)),
2106 rtti(0), VMContext(cgm.getModule().getContext()),CGM(cgm),
2107 PureVirtualFn(0),
Anders Carlssonbad80eb2009-12-04 18:36:22 +00002108 subAddressPoints(AllocAddressPoint(cgm, l, MostDerivedClass)),
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002109 AddressPoints(AddressPoints),
2110 LLVMPointerWidth(cgm.getContext().Target.getPointerWidth(0))
2111 {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002112 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
Anders Carlsson3f4336c2009-12-17 07:09:17 +00002113 if (BuildVtable) {
2114 QualType ClassType = CGM.getContext().getTagDeclType(MostDerivedClass);
2115 rtti = CGM.GetAddrOfRTTIDescriptor(ClassType);
2116 }
Mike Stump90181eb2010-01-26 00:05:04 +00002117 BuildUniqueOverriders(MostDerivedClass);
2118 MergeForwarding();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002119 }
2120
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002121 // getVtableComponents - Returns a reference to the vtable components.
2122 const VtableComponentsVectorTy &getVtableComponents() const {
2123 return VtableComponents;
Anders Carlsson472404f2009-12-04 16:19:30 +00002124 }
2125
Anders Carlssone36a6b32010-01-02 01:01:18 +00002126 llvm::DenseMap<const CXXRecordDecl *, uint64_t> &getVBIndex()
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002127 { return VBIndex; }
2128
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002129 SavedAdjustmentsVectorTy &getSavedAdjustments()
2130 { return SavedAdjustments; }
Eli Friedman8174f2c2009-12-06 22:01:30 +00002131
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002132 llvm::Constant *wrap(Index_t i) {
2133 llvm::Constant *m;
2134 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i);
2135 return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
2136 }
2137
2138 llvm::Constant *wrap(llvm::Constant *m) {
2139 return llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
2140 }
2141
Mike Stumpd2808442010-01-22 02:51:26 +00002142//#define D1(x)
Douglas Gregorf4f2e022010-02-22 16:48:26 +00002143#define D1(X) do { if (getenv("CLANG_VTABLE_DEBUG")) { X; } } while (0)
Mike Stump75ce5732009-10-31 20:06:59 +00002144
2145 void GenerateVBaseOffsets(const CXXRecordDecl *RD, uint64_t Offset,
Mike Stump28431212009-10-13 22:54:56 +00002146 bool updateVBIndex, Index_t current_vbindex) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002147 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2148 e = RD->bases_end(); i != e; ++i) {
2149 const CXXRecordDecl *Base =
2150 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stump28431212009-10-13 22:54:56 +00002151 Index_t next_vbindex = current_vbindex;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002152 if (i->isVirtual() && !SeenVBase.count(Base)) {
2153 SeenVBase.insert(Base);
Mike Stump28431212009-10-13 22:54:56 +00002154 if (updateVBIndex) {
Mike Stump75ce5732009-10-31 20:06:59 +00002155 next_vbindex = (ssize_t)(-(VCalls.size()*LLVMPointerWidth/8)
Mike Stump28431212009-10-13 22:54:56 +00002156 - 3*LLVMPointerWidth/8);
2157 VBIndex[Base] = next_vbindex;
2158 }
Mike Stump75ce5732009-10-31 20:06:59 +00002159 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
2160 VCalls.push_back((0?700:0) + BaseOffset);
2161 D1(printf(" vbase for %s at %d delta %d most derived %s\n",
2162 Base->getNameAsCString(),
2163 (int)-VCalls.size()-3, (int)BaseOffset,
Mike Stumpd2808442010-01-22 02:51:26 +00002164 MostDerivedClass->getNameAsCString()));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002165 }
Mike Stump28431212009-10-13 22:54:56 +00002166 // We also record offsets for non-virtual bases to closest enclosing
2167 // virtual base. We do this so that we don't have to search
2168 // for the nearst virtual base class when generating thunks.
2169 if (updateVBIndex && VBIndex.count(Base) == 0)
2170 VBIndex[Base] = next_vbindex;
Mike Stump75ce5732009-10-31 20:06:59 +00002171 GenerateVBaseOffsets(Base, Offset, updateVBIndex, next_vbindex);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002172 }
2173 }
2174
2175 void StartNewTable() {
2176 SeenVBase.clear();
2177 }
2178
Mike Stump8bccbfd2009-10-15 09:30:16 +00002179 Index_t getNVOffset_1(const CXXRecordDecl *D, const CXXRecordDecl *B,
2180 Index_t Offset = 0) {
2181
2182 if (B == D)
2183 return Offset;
2184
2185 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(D);
2186 for (CXXRecordDecl::base_class_const_iterator i = D->bases_begin(),
2187 e = D->bases_end(); i != e; ++i) {
2188 const CXXRecordDecl *Base =
2189 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2190 int64_t BaseOffset = 0;
2191 if (!i->isVirtual())
2192 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
2193 int64_t o = getNVOffset_1(Base, B, BaseOffset);
2194 if (o >= 0)
2195 return o;
2196 }
2197
2198 return -1;
2199 }
2200
2201 /// getNVOffset - Returns the non-virtual offset for the given (B) base of the
2202 /// derived class D.
2203 Index_t getNVOffset(QualType qB, QualType qD) {
Mike Stump46271322009-11-03 19:03:17 +00002204 qD = qD->getPointeeType();
2205 qB = qB->getPointeeType();
Mike Stump8bccbfd2009-10-15 09:30:16 +00002206 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
2207 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
2208 int64_t o = getNVOffset_1(D, B);
2209 if (o >= 0)
2210 return o;
2211
2212 assert(false && "FIXME: non-virtual base not found");
2213 return 0;
2214 }
2215
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002216 /// getVbaseOffset - Returns the index into the vtable for the virtual base
2217 /// offset for the given (B) virtual base of the derived class D.
2218 Index_t getVbaseOffset(QualType qB, QualType qD) {
Mike Stump46271322009-11-03 19:03:17 +00002219 qD = qD->getPointeeType();
2220 qB = qB->getPointeeType();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002221 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
2222 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
Anders Carlssonbad80eb2009-12-04 18:36:22 +00002223 if (D != MostDerivedClass)
Eli Friedman03aa2f12009-11-30 01:19:33 +00002224 return CGM.getVtableInfo().getVirtualBaseOffsetIndex(D, B);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002225 llvm::DenseMap<const CXXRecordDecl *, Index_t>::iterator i;
2226 i = VBIndex.find(B);
2227 if (i != VBIndex.end())
2228 return i->second;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002229
Mike Stump28431212009-10-13 22:54:56 +00002230 assert(false && "FIXME: Base not found");
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002231 return 0;
2232 }
2233
Eli Friedman81fb0d22009-12-04 08:40:51 +00002234 bool OverrideMethod(GlobalDecl GD, bool MorallyVirtual,
2235 Index_t OverrideOffset, Index_t Offset,
2236 int64_t CurrentVBaseOffset);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002237
Anders Carlsson495634e2009-12-04 02:39:04 +00002238 /// AppendMethods - Append the current methods to the vtable.
Anders Carlssonddf42c82009-12-04 02:56:03 +00002239 void AppendMethodsToVtable();
Anders Carlsson495634e2009-12-04 02:39:04 +00002240
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002241 llvm::Constant *WrapAddrOf(GlobalDecl GD) {
2242 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2243
Anders Carlsson64457732009-11-24 05:08:52 +00002244 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVtable(MD);
Mike Stump18e8b472009-10-27 23:36:26 +00002245
Mike Stumpcdeb8002009-12-03 16:55:20 +00002246 return wrap(CGM.GetAddrOfFunction(GD, Ty));
Mike Stump18e8b472009-10-27 23:36:26 +00002247 }
2248
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002249 void OverrideMethods(Path_t *Path, bool MorallyVirtual, int64_t Offset,
2250 int64_t CurrentVBaseOffset) {
Mike Stump37dbe962009-10-15 02:04:03 +00002251 for (Path_t::reverse_iterator i = Path->rbegin(),
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002252 e = Path->rend(); i != e; ++i) {
2253 const CXXRecordDecl *RD = i->first;
Mike Stump8bccbfd2009-10-15 09:30:16 +00002254 int64_t OverrideOffset = i->second;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002255 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
2256 ++mi) {
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002257 const CXXMethodDecl *MD = *mi;
2258
2259 if (!MD->isVirtual())
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002260 continue;
2261
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002262 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2263 // Override both the complete and the deleting destructor.
2264 GlobalDecl CompDtor(DD, Dtor_Complete);
Eli Friedman81fb0d22009-12-04 08:40:51 +00002265 OverrideMethod(CompDtor, MorallyVirtual, OverrideOffset, Offset,
2266 CurrentVBaseOffset);
2267
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002268 GlobalDecl DeletingDtor(DD, Dtor_Deleting);
Eli Friedman81fb0d22009-12-04 08:40:51 +00002269 OverrideMethod(DeletingDtor, MorallyVirtual, OverrideOffset, Offset,
2270 CurrentVBaseOffset);
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002271 } else {
Eli Friedman81fb0d22009-12-04 08:40:51 +00002272 OverrideMethod(MD, MorallyVirtual, OverrideOffset, Offset,
2273 CurrentVBaseOffset);
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002274 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002275 }
2276 }
2277 }
2278
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002279 void AddMethod(const GlobalDecl GD, bool MorallyVirtual, Index_t Offset,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002280 int64_t CurrentVBaseOffset) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002281 // If we can find a previously allocated slot for this, reuse it.
Eli Friedman81fb0d22009-12-04 08:40:51 +00002282 if (OverrideMethod(GD, MorallyVirtual, Offset, Offset,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002283 CurrentVBaseOffset))
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002284 return;
2285
Mike Stump1f49d652010-01-22 18:48:47 +00002286 D1(printf(" vfn for %s at %d\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002287 dyn_cast<CXXMethodDecl>(GD.getDecl())->getNameAsString().c_str(),
Mike Stump1f49d652010-01-22 18:48:47 +00002288 (int)Methods.size()));
2289
Anders Carlssoncdf18982009-12-04 02:08:24 +00002290 // We didn't find an entry in the vtable that we could use, add a new
2291 // entry.
2292 Methods.AddMethod(GD);
2293
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002294 VCallOffset[GD] = Offset/8 - CurrentVBaseOffset/8;
2295
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002296 if (MorallyVirtual) {
Anders Carlsson72281172010-01-26 17:36:47 +00002297 GlobalDecl UGD = getUnique(GD);
2298 const CXXMethodDecl *UMD = cast<CXXMethodDecl>(UGD.getDecl());
2299
Mike Stump90181eb2010-01-26 00:05:04 +00002300 assert(UMD && "final overrider not found");
2301
2302 Index_t &idx = VCall[UMD];
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002303 // Allocate the first one, after that, we reuse the previous one.
2304 if (idx == 0) {
Anders Carlsson72281172010-01-26 17:36:47 +00002305 VCallOffsetForVCall[UGD] = Offset/8;
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002306 NonVirtualOffset[UMD] = Offset/8 - CurrentVBaseOffset/8;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002307 idx = VCalls.size()+1;
Mike Stump90181eb2010-01-26 00:05:04 +00002308 VCalls.push_back(Offset/8 - CurrentVBaseOffset/8);
Mike Stump75ce5732009-10-31 20:06:59 +00002309 D1(printf(" vcall for %s at %d with delta %d\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002310 dyn_cast<CXXMethodDecl>(GD.getDecl())->getNameAsString().c_str(),
Mike Stump90181eb2010-01-26 00:05:04 +00002311 (int)-VCalls.size()-3, (int)VCalls[idx-1]));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002312 }
2313 }
2314 }
2315
2316 void AddMethods(const CXXRecordDecl *RD, bool MorallyVirtual,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002317 Index_t Offset, int64_t CurrentVBaseOffset) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002318 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002319 ++mi) {
2320 const CXXMethodDecl *MD = *mi;
2321 if (!MD->isVirtual())
2322 continue;
2323
2324 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2325 // For destructors, add both the complete and the deleting destructor
2326 // to the vtable.
2327 AddMethod(GlobalDecl(DD, Dtor_Complete), MorallyVirtual, Offset,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002328 CurrentVBaseOffset);
Eli Friedman03aa2f12009-11-30 01:19:33 +00002329 AddMethod(GlobalDecl(DD, Dtor_Deleting), MorallyVirtual, Offset,
2330 CurrentVBaseOffset);
2331 } else
2332 AddMethod(MD, MorallyVirtual, Offset, CurrentVBaseOffset);
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002333 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002334 }
2335
2336 void NonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
2337 const CXXRecordDecl *PrimaryBase,
2338 bool PrimaryBaseWasVirtual, bool MorallyVirtual,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002339 int64_t Offset, int64_t CurrentVBaseOffset,
2340 Path_t *Path) {
Mike Stump37dbe962009-10-15 02:04:03 +00002341 Path->push_back(std::make_pair(RD, Offset));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002342 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2343 e = RD->bases_end(); i != e; ++i) {
2344 if (i->isVirtual())
2345 continue;
2346 const CXXRecordDecl *Base =
2347 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stump9eb76d42010-01-22 06:45:05 +00002348 uint64_t o = Offset + Layout.getBaseClassOffset(Base);
2349 StartNewTable();
2350 GenerateVtableForBase(Base, o, MorallyVirtual, false,
2351 true, Base == PrimaryBase && !PrimaryBaseWasVirtual,
2352 CurrentVBaseOffset, Path);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002353 }
Mike Stump37dbe962009-10-15 02:04:03 +00002354 Path->pop_back();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002355 }
2356
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002357// #define D(X) do { X; } while (0)
2358#define D(X)
2359
2360 void insertVCalls(int InsertionPoint) {
Mike Stump75ce5732009-10-31 20:06:59 +00002361 D1(printf("============= combining vbase/vcall\n"));
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002362 D(VCalls.insert(VCalls.begin(), 673));
2363 D(VCalls.push_back(672));
Eli Friedman6c08ce72009-12-05 01:05:03 +00002364
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002365 VtableComponents.insert(VtableComponents.begin() + InsertionPoint,
2366 VCalls.size(), 0);
Eli Friedman6c08ce72009-12-05 01:05:03 +00002367 if (BuildVtable) {
2368 // The vcalls come first...
2369 for (std::vector<Index_t>::reverse_iterator i = VCalls.rbegin(),
2370 e = VCalls.rend();
2371 i != e; ++i)
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002372 VtableComponents[InsertionPoint++] = wrap((0?600:0) + *i);
Eli Friedman6c08ce72009-12-05 01:05:03 +00002373 }
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002374 VCalls.clear();
Mike Stump9f23a142009-11-10 02:30:51 +00002375 VCall.clear();
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002376 VCallOffsetForVCall.clear();
2377 VCallOffset.clear();
2378 NonVirtualOffset.clear();
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002379 }
2380
Mike Stump559387f2009-11-13 23:13:20 +00002381 void AddAddressPoints(const CXXRecordDecl *RD, uint64_t Offset,
2382 Index_t AddressPoint) {
2383 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002384 RD->getNameAsCString(), MostDerivedClass->getNameAsCString(),
Mike Stump559387f2009-11-13 23:13:20 +00002385 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stumpcd2b8212009-11-19 20:52:19 +00002386 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002387 AddressPoints[BaseSubobject(RD, Offset)] = AddressPoint;
Mike Stump559387f2009-11-13 23:13:20 +00002388
2389 // Now also add the address point for all our primary bases.
2390 while (1) {
2391 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2392 RD = Layout.getPrimaryBase();
2393 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2394 // FIXME: Double check this.
2395 if (RD == 0)
2396 break;
2397 if (PrimaryBaseWasVirtual &&
2398 BLayout.getVBaseClassOffset(RD) != Offset)
2399 break;
2400 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002401 RD->getNameAsCString(), MostDerivedClass->getNameAsCString(),
Mike Stump559387f2009-11-13 23:13:20 +00002402 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stumpcd2b8212009-11-19 20:52:19 +00002403 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002404 AddressPoints[BaseSubobject(RD, Offset)] = AddressPoint;
Mike Stump559387f2009-11-13 23:13:20 +00002405 }
2406 }
2407
2408
Mike Stumpd538a6d2009-12-24 07:29:41 +00002409 void FinishGenerateVtable(const CXXRecordDecl *RD,
2410 const ASTRecordLayout &Layout,
2411 const CXXRecordDecl *PrimaryBase,
Mike Stump9eb76d42010-01-22 06:45:05 +00002412 bool ForNPNVBases, bool WasPrimaryBase,
Mike Stumpd538a6d2009-12-24 07:29:41 +00002413 bool PrimaryBaseWasVirtual,
2414 bool MorallyVirtual, int64_t Offset,
2415 bool ForVirtualBase, int64_t CurrentVBaseOffset,
2416 Path_t *Path) {
Mike Stump37dbe962009-10-15 02:04:03 +00002417 bool alloc = false;
2418 if (Path == 0) {
2419 alloc = true;
2420 Path = new Path_t;
2421 }
2422
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002423 StartNewTable();
2424 extra = 0;
Mike Stump9eb76d42010-01-22 06:45:05 +00002425 Index_t AddressPoint = 0;
2426 int VCallInsertionPoint = 0;
2427 if (!ForNPNVBases || !WasPrimaryBase) {
2428 bool DeferVCalls = MorallyVirtual || ForVirtualBase;
2429 VCallInsertionPoint = VtableComponents.size();
2430 if (!DeferVCalls) {
2431 insertVCalls(VCallInsertionPoint);
2432 } else
2433 // FIXME: just for extra, or for all uses of VCalls.size post this?
2434 extra = -VCalls.size();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002435
Mike Stump9eb76d42010-01-22 06:45:05 +00002436 // Add the offset to top.
2437 VtableComponents.push_back(BuildVtable ? wrap(-((Offset-LayoutOffset)/8)) : 0);
Anders Carlsson472404f2009-12-04 16:19:30 +00002438
Mike Stump9eb76d42010-01-22 06:45:05 +00002439 // Add the RTTI information.
2440 VtableComponents.push_back(rtti);
Anders Carlsson472404f2009-12-04 16:19:30 +00002441
Mike Stump9eb76d42010-01-22 06:45:05 +00002442 AddressPoint = VtableComponents.size();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002443
Mike Stump9eb76d42010-01-22 06:45:05 +00002444 AppendMethodsToVtable();
2445 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002446
2447 // and then the non-virtual bases.
2448 NonVirtualBases(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002449 MorallyVirtual, Offset, CurrentVBaseOffset, Path);
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002450
2451 if (ForVirtualBase) {
Mike Stump2cefe382009-11-12 20:47:57 +00002452 // FIXME: We're adding to VCalls in callers, we need to do the overrides
2453 // in the inner part, so that we know the complete set of vcalls during
2454 // the build and don't have to insert into methods. Saving out the
2455 // AddressPoint here, would need to be fixed, if we didn't do that. Also
2456 // retroactively adding vcalls for overrides later wind up in the wrong
2457 // place, the vcall slot has to be alloted during the walk of the base
2458 // when the function is first introduces.
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002459 AddressPoint += VCalls.size();
Mike Stump2cefe382009-11-12 20:47:57 +00002460 insertVCalls(VCallInsertionPoint);
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002461 }
2462
Mike Stump9eb76d42010-01-22 06:45:05 +00002463 if (!ForNPNVBases || !WasPrimaryBase)
2464 AddAddressPoints(RD, Offset, AddressPoint);
Mike Stump2cefe382009-11-12 20:47:57 +00002465
Mike Stump37dbe962009-10-15 02:04:03 +00002466 if (alloc) {
2467 delete Path;
2468 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002469 }
2470
Mike Stump75ce5732009-10-31 20:06:59 +00002471 void Primaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
2472 bool updateVBIndex, Index_t current_vbindex,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002473 int64_t CurrentVBaseOffset) {
Mike Stump75ce5732009-10-31 20:06:59 +00002474 if (!RD->isDynamicClass())
2475 return;
2476
2477 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2478 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2479 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2480
2481 // vtables are composed from the chain of primaries.
Eli Friedman65d87222009-12-04 08:52:11 +00002482 if (PrimaryBase && !PrimaryBaseWasVirtual) {
Mike Stump75ce5732009-10-31 20:06:59 +00002483 D1(printf(" doing primaries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002484 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Eli Friedman65d87222009-12-04 08:52:11 +00002485 Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
2486 updateVBIndex, current_vbindex, CurrentVBaseOffset);
Mike Stump75ce5732009-10-31 20:06:59 +00002487 }
2488
2489 D1(printf(" doing vcall entries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002490 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump75ce5732009-10-31 20:06:59 +00002491
2492 // And add the virtuals for the class to the primary vtable.
Eli Friedman03aa2f12009-11-30 01:19:33 +00002493 AddMethods(RD, MorallyVirtual, Offset, CurrentVBaseOffset);
Mike Stump75ce5732009-10-31 20:06:59 +00002494 }
2495
2496 void VBPrimaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
2497 bool updateVBIndex, Index_t current_vbindex,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002498 bool RDisVirtualBase, int64_t CurrentVBaseOffset,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002499 bool bottom) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002500 if (!RD->isDynamicClass())
2501 return;
2502
2503 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2504 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2505 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2506
2507 // vtables are composed from the chain of primaries.
2508 if (PrimaryBase) {
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002509 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
2510 if (PrimaryBaseWasVirtual) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002511 IndirectPrimary.insert(PrimaryBase);
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002512 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
2513 }
Mike Stump75ce5732009-10-31 20:06:59 +00002514
2515 D1(printf(" doing primaries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002516 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump75ce5732009-10-31 20:06:59 +00002517
2518 VBPrimaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002519 updateVBIndex, current_vbindex, PrimaryBaseWasVirtual,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002520 BaseCurrentVBaseOffset, false);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002521 }
2522
Mike Stump75ce5732009-10-31 20:06:59 +00002523 D1(printf(" doing vbase entries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002524 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump75ce5732009-10-31 20:06:59 +00002525 GenerateVBaseOffsets(RD, Offset, updateVBIndex, current_vbindex);
2526
2527 if (RDisVirtualBase || bottom) {
2528 Primaries(RD, MorallyVirtual, Offset, updateVBIndex, current_vbindex,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002529 CurrentVBaseOffset);
Mike Stump75ce5732009-10-31 20:06:59 +00002530 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002531 }
2532
Mike Stumpd538a6d2009-12-24 07:29:41 +00002533 void GenerateVtableForBase(const CXXRecordDecl *RD, int64_t Offset = 0,
2534 bool MorallyVirtual = false,
2535 bool ForVirtualBase = false,
Mike Stump9eb76d42010-01-22 06:45:05 +00002536 bool ForNPNVBases = false,
2537 bool WasPrimaryBase = true,
Mike Stumpd538a6d2009-12-24 07:29:41 +00002538 int CurrentVBaseOffset = 0,
2539 Path_t *Path = 0) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002540 if (!RD->isDynamicClass())
Mike Stumpd538a6d2009-12-24 07:29:41 +00002541 return;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002542
Mike Stumpfa818082009-11-13 02:35:38 +00002543 // Construction vtable don't need parts that have no virtual bases and
2544 // aren't morally virtual.
Anders Carlssonbad80eb2009-12-04 18:36:22 +00002545 if ((LayoutClass != MostDerivedClass) &&
2546 RD->getNumVBases() == 0 && !MorallyVirtual)
Mike Stumpd538a6d2009-12-24 07:29:41 +00002547 return;
Mike Stumpfa818082009-11-13 02:35:38 +00002548
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002549 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2550 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2551 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2552
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002553 extra = 0;
Mike Stump75ce5732009-10-31 20:06:59 +00002554 D1(printf("building entries for base %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002555 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002556
Mike Stump75ce5732009-10-31 20:06:59 +00002557 if (ForVirtualBase)
2558 extra = VCalls.size();
2559
Mike Stump9eb76d42010-01-22 06:45:05 +00002560 if (!ForNPNVBases || !WasPrimaryBase) {
2561 VBPrimaries(RD, MorallyVirtual, Offset, !ForVirtualBase, 0,
2562 ForVirtualBase, CurrentVBaseOffset, true);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002563
Mike Stump9eb76d42010-01-22 06:45:05 +00002564 if (Path)
2565 OverrideMethods(Path, MorallyVirtual, Offset, CurrentVBaseOffset);
2566 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002567
Mike Stump9eb76d42010-01-22 06:45:05 +00002568 FinishGenerateVtable(RD, Layout, PrimaryBase, ForNPNVBases, WasPrimaryBase,
2569 PrimaryBaseWasVirtual, MorallyVirtual, Offset,
2570 ForVirtualBase, CurrentVBaseOffset, Path);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002571 }
2572
2573 void GenerateVtableForVBases(const CXXRecordDecl *RD,
2574 int64_t Offset = 0,
Mike Stump37dbe962009-10-15 02:04:03 +00002575 Path_t *Path = 0) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002576 bool alloc = false;
2577 if (Path == 0) {
2578 alloc = true;
Mike Stump37dbe962009-10-15 02:04:03 +00002579 Path = new Path_t;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002580 }
2581 // FIXME: We also need to override using all paths to a virtual base,
2582 // right now, we just process the first path
2583 Path->push_back(std::make_pair(RD, Offset));
2584 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2585 e = RD->bases_end(); i != e; ++i) {
2586 const CXXRecordDecl *Base =
2587 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2588 if (i->isVirtual() && !IndirectPrimary.count(Base)) {
2589 // Mark it so we don't output it twice.
2590 IndirectPrimary.insert(Base);
2591 StartNewTable();
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002592 VCall.clear();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002593 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002594 int64_t CurrentVBaseOffset = BaseOffset;
Mike Stump75ce5732009-10-31 20:06:59 +00002595 D1(printf("vtable %s virtual base %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002596 MostDerivedClass->getNameAsCString(), Base->getNameAsCString()));
Mike Stump9eb76d42010-01-22 06:45:05 +00002597 GenerateVtableForBase(Base, BaseOffset, true, true, false,
2598 true, CurrentVBaseOffset, Path);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002599 }
Mike Stump2cefe382009-11-12 20:47:57 +00002600 int64_t BaseOffset;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002601 if (i->isVirtual())
2602 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump2cefe382009-11-12 20:47:57 +00002603 else {
2604 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2605 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
2606 }
2607
Mike Stump37dbe962009-10-15 02:04:03 +00002608 if (Base->getNumVBases()) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002609 GenerateVtableForVBases(Base, BaseOffset, Path);
Mike Stump37dbe962009-10-15 02:04:03 +00002610 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002611 }
2612 Path->pop_back();
2613 if (alloc)
2614 delete Path;
2615 }
2616};
Anders Carlssonca1bf682009-12-03 01:54:02 +00002617} // end anonymous namespace
2618
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002619bool OldVtableBuilder::OverrideMethod(GlobalDecl GD, bool MorallyVirtual,
Eli Friedman81fb0d22009-12-04 08:40:51 +00002620 Index_t OverrideOffset, Index_t Offset,
2621 int64_t CurrentVBaseOffset) {
Anders Carlssonca1bf682009-12-03 01:54:02 +00002622 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2623
2624 const bool isPure = MD->isPure();
Anders Carlsson21bbc1e2009-12-05 17:04:47 +00002625
Anders Carlssonca1bf682009-12-03 01:54:02 +00002626 // FIXME: Should OverrideOffset's be Offset?
2627
Anders Carlsson21bbc1e2009-12-05 17:04:47 +00002628 for (CXXMethodDecl::method_iterator mi = MD->begin_overridden_methods(),
2629 e = MD->end_overridden_methods(); mi != e; ++mi) {
Anders Carlssonca1bf682009-12-03 01:54:02 +00002630 GlobalDecl OGD;
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002631 GlobalDecl OGD2;
Anders Carlssonca1bf682009-12-03 01:54:02 +00002632
Anders Carlssonf3935b42009-12-04 05:51:56 +00002633 const CXXMethodDecl *OMD = *mi;
Anders Carlssonca1bf682009-12-03 01:54:02 +00002634 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(OMD))
2635 OGD = GlobalDecl(DD, GD.getDtorType());
2636 else
2637 OGD = OMD;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002638
Eli Friedman8174f2c2009-12-06 22:01:30 +00002639 // Check whether this is the method being overridden in this section of
2640 // the vtable.
Anders Carlsson7bb70762009-12-04 15:49:02 +00002641 uint64_t Index;
2642 if (!Methods.getIndex(OGD, Index))
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002643 continue;
2644
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002645 OGD2 = OGD;
2646
Eli Friedman8174f2c2009-12-06 22:01:30 +00002647 // Get the original method, which we should be computing thunks, etc,
2648 // against.
2649 OGD = Methods.getOrigMethod(Index);
2650 OMD = cast<CXXMethodDecl>(OGD.getDecl());
2651
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002652 QualType ReturnType =
2653 MD->getType()->getAs<FunctionType>()->getResultType();
2654 QualType OverriddenReturnType =
2655 OMD->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssonca1bf682009-12-03 01:54:02 +00002656
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002657 // Check if we need a return type adjustment.
Anders Carlssoncce9ee82010-02-13 23:17:31 +00002658 if (!ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
2659 OMD).isEmpty()) {
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002660 CanQualType &BaseReturnType = BaseReturnTypes[Index];
Anders Carlssonca1bf682009-12-03 01:54:02 +00002661
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002662 // Insert the base return type.
2663 if (BaseReturnType.isNull())
2664 BaseReturnType =
2665 CGM.getContext().getCanonicalType(OverriddenReturnType);
2666 }
Anders Carlssona93e9802009-12-04 03:52:52 +00002667
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002668 Methods.OverrideMethod(OGD, GD);
2669
Anders Carlsson72281172010-01-26 17:36:47 +00002670 GlobalDecl UGD = getUnique(GD);
2671 const CXXMethodDecl *UMD = cast<CXXMethodDecl>(UGD.getDecl());
2672 assert(UGD.getDecl() && "unique overrider not found");
2673 assert(UGD == getUnique(OGD) && "unique overrider not unique");
Mike Stump90181eb2010-01-26 00:05:04 +00002674
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002675 ThisAdjustments.erase(Index);
Mike Stump90181eb2010-01-26 00:05:04 +00002676 if (MorallyVirtual || VCall.count(UMD)) {
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002677
Mike Stump90181eb2010-01-26 00:05:04 +00002678 Index_t &idx = VCall[UMD];
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002679 if (idx == 0) {
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002680 VCallOffset[GD] = VCallOffset[OGD];
2681 // NonVirtualOffset[UMD] = CurrentVBaseOffset/8 - OverrideOffset/8;
2682 NonVirtualOffset[UMD] = VCallOffset[OGD];
Mike Stump77537b12010-01-26 03:42:22 +00002683 VCallOffsetForVCall[UMD] = OverrideOffset/8;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002684 idx = VCalls.size()+1;
Mike Stump77537b12010-01-26 03:42:22 +00002685 VCalls.push_back(OverrideOffset/8 - CurrentVBaseOffset/8);
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002686 D1(printf(" vcall for %s at %d with delta %d most derived %s\n",
2687 MD->getNameAsString().c_str(), (int)-idx-3,
Mike Stumpd2808442010-01-22 02:51:26 +00002688 (int)VCalls[idx-1], MostDerivedClass->getNameAsCString()));
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002689 } else {
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002690 VCallOffset[GD] = NonVirtualOffset[UMD];
Anders Carlsson72281172010-01-26 17:36:47 +00002691 VCalls[idx-1] = -VCallOffsetForVCall[UGD] + OverrideOffset/8;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002692 D1(printf(" vcall patch for %s at %d with delta %d most derived %s\n",
2693 MD->getNameAsString().c_str(), (int)-idx-3,
Mike Stumpd2808442010-01-22 02:51:26 +00002694 (int)VCalls[idx-1], MostDerivedClass->getNameAsCString()));
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002695 }
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002696 int64_t NonVirtualAdjustment = -VCallOffset[OGD];
Mike Stumpded0a402010-01-26 22:44:01 +00002697 QualType DerivedType = MD->getThisType(CGM.getContext());
2698 QualType BaseType = cast<const CXXMethodDecl>(OGD.getDecl())->getThisType(CGM.getContext());
2699 int64_t NonVirtualAdjustment2 = -(getNVOffset(BaseType, DerivedType)/8);
2700 if (NonVirtualAdjustment2 != NonVirtualAdjustment) {
2701 NonVirtualAdjustment = NonVirtualAdjustment2;
2702 }
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002703 int64_t VirtualAdjustment =
2704 -((idx + extra + 2) * LLVMPointerWidth / 8);
Anders Carlsson657f1392009-12-03 02:32:59 +00002705
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002706 // Optimize out virtual adjustments of 0.
2707 if (VCalls[idx-1] == 0)
2708 VirtualAdjustment = 0;
Anders Carlsson657f1392009-12-03 02:32:59 +00002709
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002710 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment,
2711 VirtualAdjustment);
Anders Carlsson2ca285f2009-12-03 02:22:59 +00002712
Eli Friedman8174f2c2009-12-06 22:01:30 +00002713 if (!isPure && !ThisAdjustment.isEmpty()) {
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002714 ThisAdjustments[Index] = ThisAdjustment;
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002715 SavedAdjustments.push_back(
2716 std::make_pair(GD, std::make_pair(OGD, ThisAdjustment)));
Eli Friedman8174f2c2009-12-06 22:01:30 +00002717 }
Anders Carlssonca1bf682009-12-03 01:54:02 +00002718 return true;
2719 }
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002720
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002721 VCallOffset[GD] = VCallOffset[OGD2] - OverrideOffset/8;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002722
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002723 int64_t NonVirtualAdjustment = -VCallOffset[GD];
2724 QualType DerivedType = MD->getThisType(CGM.getContext());
2725 QualType BaseType = cast<const CXXMethodDecl>(OGD.getDecl())->getThisType(CGM.getContext());
2726 int64_t NonVirtualAdjustment2 = -(getNVOffset(BaseType, DerivedType)/8);
2727 if (NonVirtualAdjustment2 != NonVirtualAdjustment) {
2728 NonVirtualAdjustment = NonVirtualAdjustment2;
2729 }
2730
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002731 if (NonVirtualAdjustment) {
2732 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment, 0);
2733
Eli Friedmanf2eda5e2009-12-06 22:33:51 +00002734 if (!isPure) {
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002735 ThisAdjustments[Index] = ThisAdjustment;
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002736 SavedAdjustments.push_back(
2737 std::make_pair(GD, std::make_pair(OGD, ThisAdjustment)));
Eli Friedmanf2eda5e2009-12-06 22:33:51 +00002738 }
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002739 }
2740 return true;
Anders Carlssonca1bf682009-12-03 01:54:02 +00002741 }
2742
2743 return false;
Anders Carlssond59885022009-11-27 22:21:51 +00002744}
2745
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002746void OldVtableBuilder::AppendMethodsToVtable() {
Eli Friedman6c08ce72009-12-05 01:05:03 +00002747 if (!BuildVtable) {
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002748 VtableComponents.insert(VtableComponents.end(), Methods.size(),
2749 (llvm::Constant *)0);
Eli Friedman6c08ce72009-12-05 01:05:03 +00002750 ThisAdjustments.clear();
2751 BaseReturnTypes.clear();
2752 Methods.clear();
2753 return;
2754 }
2755
Anders Carlsson472404f2009-12-04 16:19:30 +00002756 // Reserve room in the vtable for our new methods.
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002757 VtableComponents.reserve(VtableComponents.size() + Methods.size());
Anders Carlssonb07567c2009-12-04 03:07:26 +00002758
Anders Carlsson86809cd2009-12-04 02:43:50 +00002759 for (unsigned i = 0, e = Methods.size(); i != e; ++i) {
2760 GlobalDecl GD = Methods[i];
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00002761 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2762
2763 // Get the 'this' pointer adjustment.
Anders Carlsson86809cd2009-12-04 02:43:50 +00002764 ThunkAdjustment ThisAdjustment = ThisAdjustments.lookup(i);
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00002765
2766 // Construct the return type adjustment.
2767 ThunkAdjustment ReturnAdjustment;
2768
2769 QualType BaseReturnType = BaseReturnTypes.lookup(i);
2770 if (!BaseReturnType.isNull() && !MD->isPure()) {
2771 QualType DerivedType =
2772 MD->getType()->getAs<FunctionType>()->getResultType();
2773
2774 int64_t NonVirtualAdjustment =
2775 getNVOffset(BaseReturnType, DerivedType) / 8;
2776
2777 int64_t VirtualAdjustment =
2778 getVbaseOffset(BaseReturnType, DerivedType);
2779
2780 ReturnAdjustment = ThunkAdjustment(NonVirtualAdjustment,
2781 VirtualAdjustment);
2782 }
2783
Anders Carlsson50f14742009-12-04 03:06:03 +00002784 llvm::Constant *Method = 0;
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00002785 if (!ReturnAdjustment.isEmpty()) {
2786 // Build a covariant thunk.
2787 CovariantThunkAdjustment Adjustment(ThisAdjustment, ReturnAdjustment);
Eli Friedman8174f2c2009-12-06 22:01:30 +00002788 Method = wrap(CGM.GetAddrOfCovariantThunk(GD, Adjustment));
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00002789 } else if (!ThisAdjustment.isEmpty()) {
2790 // Build a "regular" thunk.
Eli Friedman8174f2c2009-12-06 22:01:30 +00002791 Method = wrap(CGM.GetAddrOfThunk(GD, ThisAdjustment));
Anders Carlssonddf42c82009-12-04 02:56:03 +00002792 } else if (MD->isPure()) {
2793 // We have a pure virtual method.
Anders Carlsson50f14742009-12-04 03:06:03 +00002794 Method = getPureVirtualFn();
2795 } else {
2796 // We have a good old regular method.
2797 Method = WrapAddrOf(GD);
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00002798 }
Anders Carlsson50f14742009-12-04 03:06:03 +00002799
2800 // Add the method to the vtable.
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002801 VtableComponents.push_back(Method);
Anders Carlsson86809cd2009-12-04 02:43:50 +00002802 }
2803
Anders Carlsson50f14742009-12-04 03:06:03 +00002804
Anders Carlsson86809cd2009-12-04 02:43:50 +00002805 ThisAdjustments.clear();
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00002806 BaseReturnTypes.clear();
Anders Carlsson86809cd2009-12-04 02:43:50 +00002807
Anders Carlsson495634e2009-12-04 02:39:04 +00002808 Methods.clear();
Anders Carlsson495634e2009-12-04 02:39:04 +00002809}
2810
Anders Carlssonf942ee02009-11-27 20:47:55 +00002811void CGVtableInfo::ComputeMethodVtableIndices(const CXXRecordDecl *RD) {
2812
2813 // Itanium C++ ABI 2.5.2:
Anders Carlsson259688c2010-02-02 03:37:46 +00002814 // The order of the virtual function pointers in a virtual table is the
2815 // order of declaration of the corresponding member functions in the class.
Anders Carlssonf942ee02009-11-27 20:47:55 +00002816 //
Anders Carlsson259688c2010-02-02 03:37:46 +00002817 // There is an entry for any virtual function declared in a class,
2818 // whether it is a new function or overrides a base class function,
2819 // unless it overrides a function from the primary base, and conversion
2820 // between their return types does not require an adjustment.
Anders Carlssonf942ee02009-11-27 20:47:55 +00002821
2822 int64_t CurrentIndex = 0;
2823
2824 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2825 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2826
2827 if (PrimaryBase) {
Anders Carlssonc920fa22009-11-30 19:43:26 +00002828 assert(PrimaryBase->isDefinition() &&
2829 "Should have the definition decl of the primary base!");
Anders Carlssonf942ee02009-11-27 20:47:55 +00002830
2831 // Since the record decl shares its vtable pointer with the primary base
2832 // we need to start counting at the end of the primary base's vtable.
2833 CurrentIndex = getNumVirtualFunctionPointers(PrimaryBase);
2834 }
Eli Friedman21517252009-12-15 03:31:17 +00002835
2836 // Collect all the primary bases, so we can check whether methods override
2837 // a method from the base.
Anders Carlsson65b49782010-02-12 05:25:12 +00002838 VtableBuilder::PrimaryBasesSetTy PrimaryBases;
Eli Friedman21517252009-12-15 03:31:17 +00002839 for (ASTRecordLayout::primary_base_info_iterator
2840 I = Layout.primary_base_begin(), E = Layout.primary_base_end();
2841 I != E; ++I)
2842 PrimaryBases.insert((*I).getBase());
2843
Anders Carlssonf942ee02009-11-27 20:47:55 +00002844 const CXXDestructorDecl *ImplicitVirtualDtor = 0;
2845
2846 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
2847 e = RD->method_end(); i != e; ++i) {
2848 const CXXMethodDecl *MD = *i;
2849
2850 // We only want virtual methods.
2851 if (!MD->isVirtual())
2852 continue;
2853
Anders Carlssonf942ee02009-11-27 20:47:55 +00002854 // Check if this method overrides a method in the primary base.
Anders Carlsson65b49782010-02-12 05:25:12 +00002855 if (const CXXMethodDecl *OverriddenMD =
2856 OverridesMethodInPrimaryBase(MD, PrimaryBases)) {
2857 // Check if converting from the return type of the method to the
2858 // return type of the overridden method requires conversion.
Anders Carlssoncce9ee82010-02-13 23:17:31 +00002859 if (ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
2860 OverriddenMD).isEmpty()) {
Anders Carlsson65b49782010-02-12 05:25:12 +00002861 // This index is shared between the index in the vtable of the primary
2862 // base class.
2863 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2864 const CXXDestructorDecl *OverriddenDD =
2865 cast<CXXDestructorDecl>(OverriddenMD);
Anders Carlssonf942ee02009-11-27 20:47:55 +00002866
Anders Carlsson65b49782010-02-12 05:25:12 +00002867 // Add both the complete and deleting entries.
2868 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] =
2869 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Complete));
2870 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] =
2871 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
2872 } else {
2873 MethodVtableIndices[MD] = getMethodVtableIndex(OverriddenMD);
2874 }
2875
2876 // We don't need to add an entry for this method.
Anders Carlsson07604812010-02-12 18:14:46 +00002877 continue;
Anders Carlssonf942ee02009-11-27 20:47:55 +00002878 }
2879 }
2880
Anders Carlssonf942ee02009-11-27 20:47:55 +00002881 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2882 if (MD->isImplicit()) {
2883 assert(!ImplicitVirtualDtor &&
2884 "Did already see an implicit virtual dtor!");
2885 ImplicitVirtualDtor = DD;
2886 continue;
2887 }
2888
2889 // Add the complete dtor.
2890 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++;
2891
2892 // Add the deleting dtor.
2893 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
2894 } else {
2895 // Add the entry.
2896 MethodVtableIndices[MD] = CurrentIndex++;
2897 }
2898 }
2899
2900 if (ImplicitVirtualDtor) {
2901 // Itanium C++ ABI 2.5.2:
Anders Carlssondc2dba32010-02-16 04:49:44 +00002902 // If a class has an implicitly-defined virtual destructor,
2903 // its entries come after the declared virtual function pointers.
Anders Carlssonf942ee02009-11-27 20:47:55 +00002904
2905 // Add the complete dtor.
2906 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Complete)] =
2907 CurrentIndex++;
2908
2909 // Add the deleting dtor.
2910 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Deleting)] =
2911 CurrentIndex++;
2912 }
2913
2914 NumVirtualFunctionPointers[RD] = CurrentIndex;
2915}
2916
2917uint64_t CGVtableInfo::getNumVirtualFunctionPointers(const CXXRecordDecl *RD) {
2918 llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
2919 NumVirtualFunctionPointers.find(RD);
2920 if (I != NumVirtualFunctionPointers.end())
2921 return I->second;
2922
2923 ComputeMethodVtableIndices(RD);
2924
2925 I = NumVirtualFunctionPointers.find(RD);
2926 assert(I != NumVirtualFunctionPointers.end() && "Did not find entry!");
2927 return I->second;
2928}
2929
2930uint64_t CGVtableInfo::getMethodVtableIndex(GlobalDecl GD) {
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002931 MethodVtableIndicesTy::iterator I = MethodVtableIndices.find(GD);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002932 if (I != MethodVtableIndices.end())
2933 return I->second;
2934
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002935 const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
Anders Carlssonf942ee02009-11-27 20:47:55 +00002936
2937 ComputeMethodVtableIndices(RD);
2938
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002939 I = MethodVtableIndices.find(GD);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002940 assert(I != MethodVtableIndices.end() && "Did not find index!");
2941 return I->second;
2942}
2943
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002944CGVtableInfo::AdjustmentVectorTy*
2945CGVtableInfo::getAdjustments(GlobalDecl GD) {
2946 SavedAdjustmentsTy::iterator I = SavedAdjustments.find(GD);
2947 if (I != SavedAdjustments.end())
2948 return &I->second;
Eli Friedman8174f2c2009-12-06 22:01:30 +00002949
2950 const CXXRecordDecl *RD = cast<CXXRecordDecl>(GD.getDecl()->getDeclContext());
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002951 if (!SavedAdjustmentRecords.insert(RD).second)
2952 return 0;
Eli Friedman8174f2c2009-12-06 22:01:30 +00002953
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002954 AddressPointsMapTy AddressPoints;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002955 OldVtableBuilder b(RD, RD, 0, CGM, false, AddressPoints);
Eli Friedman8174f2c2009-12-06 22:01:30 +00002956 D1(printf("vtable %s\n", RD->getNameAsCString()));
2957 b.GenerateVtableForBase(RD);
2958 b.GenerateVtableForVBases(RD);
Eli Friedman8174f2c2009-12-06 22:01:30 +00002959
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002960 for (OldVtableBuilder::SavedAdjustmentsVectorTy::iterator
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002961 i = b.getSavedAdjustments().begin(),
2962 e = b.getSavedAdjustments().end(); i != e; i++)
2963 SavedAdjustments[i->first].push_back(i->second);
Eli Friedman8174f2c2009-12-06 22:01:30 +00002964
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002965 I = SavedAdjustments.find(GD);
2966 if (I != SavedAdjustments.end())
2967 return &I->second;
2968
2969 return 0;
Eli Friedman8174f2c2009-12-06 22:01:30 +00002970}
2971
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002972int64_t CGVtableInfo::getVirtualBaseOffsetIndex(const CXXRecordDecl *RD,
2973 const CXXRecordDecl *VBase) {
2974 ClassPairTy ClassPair(RD, VBase);
2975
2976 VirtualBaseClassIndiciesTy::iterator I =
2977 VirtualBaseClassIndicies.find(ClassPair);
2978 if (I != VirtualBaseClassIndicies.end())
2979 return I->second;
2980
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002981 // FIXME: This seems expensive. Can we do a partial job to get
2982 // just this data.
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002983 AddressPointsMapTy AddressPoints;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002984 OldVtableBuilder b(RD, RD, 0, CGM, false, AddressPoints);
Mike Stump75ce5732009-10-31 20:06:59 +00002985 D1(printf("vtable %s\n", RD->getNameAsCString()));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002986 b.GenerateVtableForBase(RD);
2987 b.GenerateVtableForVBases(RD);
2988
2989 for (llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
2990 b.getVBIndex().begin(), E = b.getVBIndex().end(); I != E; ++I) {
2991 // Insert all types.
2992 ClassPairTy ClassPair(RD, I->first);
2993
2994 VirtualBaseClassIndicies.insert(std::make_pair(ClassPair, I->second));
2995 }
2996
2997 I = VirtualBaseClassIndicies.find(ClassPair);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00002998 // FIXME: The assertion below assertion currently fails with the old vtable
2999 /// layout code if there is a non-virtual thunk adjustment in a vtable.
3000 // Once the new layout is in place, this return should be removed.
3001 if (I == VirtualBaseClassIndicies.end())
3002 return 0;
3003
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003004 assert(I != VirtualBaseClassIndicies.end() && "Did not find index!");
3005
3006 return I->second;
3007}
3008
Anders Carlssonc8e39ec2009-12-05 21:03:56 +00003009uint64_t CGVtableInfo::getVtableAddressPoint(const CXXRecordDecl *RD) {
3010 uint64_t AddressPoint =
Anders Carlsson93a18842010-01-02 18:02:32 +00003011 (*(*(CGM.getVtableInfo().AddressPoints[RD]))[RD])[std::make_pair(RD, 0)];
Anders Carlssonc8e39ec2009-12-05 21:03:56 +00003012
3013 return AddressPoint;
3014}
3015
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003016llvm::GlobalVariable *
Anders Carlsson0911ae82009-12-06 00:23:49 +00003017CGVtableInfo::GenerateVtable(llvm::GlobalVariable::LinkageTypes Linkage,
Anders Carlsson232324c2009-12-06 00:53:22 +00003018 bool GenerateDefinition,
Anders Carlsson0911ae82009-12-06 00:23:49 +00003019 const CXXRecordDecl *LayoutClass,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003020 const CXXRecordDecl *RD, uint64_t Offset,
3021 AddressPointsMapTy& AddressPoints) {
Anders Carlsson1888b442010-02-14 00:22:59 +00003022 if (GenerateDefinition && CGM.getLangOptions().DumpVtableLayouts &&
3023 LayoutClass == RD) {
Anders Carlssoncf5a8822010-02-13 21:07:32 +00003024 VtableBuilder Builder(*this, RD);
Anders Carlssoneee53d92010-02-13 02:02:03 +00003025
3026 Builder.dumpLayout(llvm::errs());
3027 }
3028
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003029 llvm::SmallString<256> OutName;
Mike Stump2cefe382009-11-12 20:47:57 +00003030 if (LayoutClass != RD)
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003031 CGM.getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset / 8,
3032 RD, OutName);
Mike Stumpeac45592009-11-11 20:26:26 +00003033 else
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003034 CGM.getMangleContext().mangleCXXVtable(RD, OutName);
Daniel Dunbare128dd12009-11-21 09:06:22 +00003035 llvm::StringRef Name = OutName.str();
Benjamin Kramerbb0a07b2009-10-11 22:57:54 +00003036
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003037 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
Anders Carlsson93a18842010-01-02 18:02:32 +00003038 if (GV == 0 || CGM.getVtableInfo().AddressPoints[LayoutClass] == 0 ||
3039 GV->isDeclaration()) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00003040 OldVtableBuilder b(RD, LayoutClass, Offset, CGM, GenerateDefinition,
3041 AddressPoints);
Eli Friedman6c08ce72009-12-05 01:05:03 +00003042
3043 D1(printf("vtable %s\n", RD->getNameAsCString()));
3044 // First comes the vtables for all the non-virtual bases...
Mike Stumpd538a6d2009-12-24 07:29:41 +00003045 b.GenerateVtableForBase(RD, Offset);
Eli Friedman6c08ce72009-12-05 01:05:03 +00003046
3047 // then the vtables for all the virtual bases.
3048 b.GenerateVtableForVBases(RD, Offset);
3049
Anders Carlsson58b271d2009-12-05 22:19:10 +00003050 llvm::Constant *Init = 0;
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003051 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
Anders Carlsson58b271d2009-12-05 22:19:10 +00003052 llvm::ArrayType *ArrayType =
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003053 llvm::ArrayType::get(Int8PtrTy, b.getVtableComponents().size());
Anders Carlssona95d4c52009-12-05 21:09:05 +00003054
Anders Carlsson232324c2009-12-06 00:53:22 +00003055 if (GenerateDefinition)
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003056 Init = llvm::ConstantArray::get(ArrayType, &b.getVtableComponents()[0],
3057 b.getVtableComponents().size());
Anders Carlsson232324c2009-12-06 00:53:22 +00003058
Mike Stumpaa51ad62009-11-19 04:04:36 +00003059 llvm::GlobalVariable *OGV = GV;
Anders Carlsson232324c2009-12-06 00:53:22 +00003060
3061 GV = new llvm::GlobalVariable(CGM.getModule(), ArrayType,
3062 /*isConstant=*/true, Linkage, Init, Name);
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003063 CGM.setGlobalVisibility(GV, RD);
3064
Mike Stumpaa51ad62009-11-19 04:04:36 +00003065 if (OGV) {
3066 GV->takeName(OGV);
Anders Carlsson58b271d2009-12-05 22:19:10 +00003067 llvm::Constant *NewPtr =
3068 llvm::ConstantExpr::getBitCast(GV, OGV->getType());
Mike Stumpaa51ad62009-11-19 04:04:36 +00003069 OGV->replaceAllUsesWith(NewPtr);
3070 OGV->eraseFromParent();
3071 }
Mike Stumpaa51ad62009-11-19 04:04:36 +00003072 }
Anders Carlssonb3f54b72009-12-05 21:28:12 +00003073
3074 return GV;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003075}
Mike Stump9f23a142009-11-10 02:30:51 +00003076
Anders Carlsson232324c2009-12-06 00:53:22 +00003077void CGVtableInfo::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage,
3078 const CXXRecordDecl *RD) {
Anders Carlssone1b3e622009-12-07 07:59:52 +00003079 llvm::GlobalVariable *&Vtable = Vtables[RD];
3080 if (Vtable) {
3081 assert(Vtable->getInitializer() && "Vtable doesn't have a definition!");
3082 return;
3083 }
3084
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003085 AddressPointsMapTy AddressPoints;
3086 Vtable = GenerateVtable(Linkage, /*GenerateDefinition=*/true, RD, RD, 0,
3087 AddressPoints);
Anders Carlssone36a6b32010-01-02 01:01:18 +00003088 GenerateVTT(Linkage, /*GenerateDefinition=*/true, RD);
Mike Stump1a139f82009-11-19 01:08:19 +00003089}
3090
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003091llvm::GlobalVariable *CGVtableInfo::getVtable(const CXXRecordDecl *RD) {
Anders Carlsson232324c2009-12-06 00:53:22 +00003092 llvm::GlobalVariable *Vtable = Vtables.lookup(RD);
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003093
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003094 if (!Vtable) {
3095 AddressPointsMapTy AddressPoints;
Anders Carlsson232324c2009-12-06 00:53:22 +00003096 Vtable = GenerateVtable(llvm::GlobalValue::ExternalLinkage,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003097 /*GenerateDefinition=*/false, RD, RD, 0,
3098 AddressPoints);
3099 }
Mike Stumpaa51ad62009-11-19 04:04:36 +00003100
Anders Carlsson4ed44eb2009-12-05 22:42:54 +00003101 return Vtable;
Mike Stumpd846d082009-11-10 07:44:33 +00003102}
Mike Stumpeac45592009-11-11 20:26:26 +00003103
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003104void CGVtableInfo::MaybeEmitVtable(GlobalDecl GD) {
3105 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3106 const CXXRecordDecl *RD = MD->getParent();
3107
Anders Carlsson4ed44eb2009-12-05 22:42:54 +00003108 // If the class doesn't have a vtable we don't need to emit one.
3109 if (!RD->isDynamicClass())
3110 return;
3111
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003112 // Get the key function.
Anders Carlsson5ebf8b42009-12-07 04:35:11 +00003113 const CXXMethodDecl *KeyFunction = CGM.getContext().getKeyFunction(RD);
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003114
Anders Carlsson4ed44eb2009-12-05 22:42:54 +00003115 if (KeyFunction) {
3116 // We don't have the right key function.
3117 if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl())
3118 return;
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003119 }
3120
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003121 // Emit the data.
Douglas Gregorccecc1b2010-01-06 20:27:16 +00003122 GenerateClassData(CGM.getVtableLinkage(RD), RD);
Eli Friedman8174f2c2009-12-06 22:01:30 +00003123
3124 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
3125 e = RD->method_end(); i != e; ++i) {
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003126 if ((*i)->isVirtual() && ((*i)->hasInlineBody() || (*i)->isImplicit())) {
Eli Friedman8174f2c2009-12-06 22:01:30 +00003127 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(*i)) {
3128 CGM.BuildThunksForVirtual(GlobalDecl(DD, Dtor_Complete));
3129 CGM.BuildThunksForVirtual(GlobalDecl(DD, Dtor_Deleting));
3130 } else {
3131 CGM.BuildThunksForVirtual(GlobalDecl(*i));
3132 }
3133 }
3134 }
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003135}
3136