blob: 81b41109e1771e34a3639403bae0ad24ada9e813 [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"
Anders Carlssond46ed892010-02-27 16:18:19 +000019#include "llvm/ADT/SetVector.h"
Chandler Carruth94eab4a2010-02-13 10:38:52 +000020#include "llvm/Support/Compiler.h"
Anders Carlsson5d40c6f2010-02-11 08:02:13 +000021#include "llvm/Support/Format.h"
Zhongxing Xu1721ef72009-11-13 05:46:16 +000022#include <cstdio>
Anders Carlsson2bb27f52009-10-11 22:13:54 +000023
24using namespace clang;
25using namespace CodeGen;
26
Anders Carlssond59885022009-11-27 22:21:51 +000027namespace {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +000028
Anders Carlsson075056a2010-02-23 01:34:28 +000029/// BaseOffset - Represents an offset from a derived class to a direct or
30/// indirect base class.
31struct BaseOffset {
32 /// DerivedClass - The derived class.
33 const CXXRecordDecl *DerivedClass;
34
35 /// VirtualBase - If the path from the derived class to the base class
36 /// involves a virtual base class, this holds its declaration.
37 const CXXRecordDecl *VirtualBase;
38
39 /// NonVirtualOffset - The offset from the derived class to the base class.
40 /// (Or the offset from the virtual base class to the base class, if the
41 /// path from the derived class to the base class involves a virtual base
42 /// class.
43 int64_t NonVirtualOffset;
44
45 BaseOffset() : DerivedClass(0), VirtualBase(0), NonVirtualOffset(0) { }
46 BaseOffset(const CXXRecordDecl *DerivedClass,
47 const CXXRecordDecl *VirtualBase, int64_t NonVirtualOffset)
48 : DerivedClass(DerivedClass), VirtualBase(VirtualBase),
49 NonVirtualOffset(NonVirtualOffset) { }
50
51 bool isEmpty() const { return !NonVirtualOffset && !VirtualBase; }
52};
53
Anders Carlssone8ac42a2010-02-11 21:24:32 +000054/// FinalOverriders - Contains the final overrider member functions for all
55/// member functions in the base subobjects of a class.
56class FinalOverriders {
Anders Carlsson136bd192010-02-12 16:55:34 +000057public:
58 /// OverriderInfo - Information about a final overrider.
59 struct OverriderInfo {
60 /// Method - The method decl of the overrider.
61 const CXXMethodDecl *Method;
Anders Carlsson5a7654a2010-02-18 16:29:24 +000062
Anders Carlssonca82a4f2010-03-10 02:33:41 +000063 /// Offset - the base offset of the overrider in the layout class.
64 uint64_t Offset;
Anders Carlsson136bd192010-02-12 16:55:34 +000065
Anders Carlsson3c289672010-03-12 05:02:01 +000066 OverriderInfo() : Method(0), Offset(0) { }
Anders Carlsson136bd192010-02-12 16:55:34 +000067 };
68
69private:
Anders Carlssone8ac42a2010-02-11 21:24:32 +000070 /// MostDerivedClass - The most derived class for which the final overriders
71 /// are stored.
72 const CXXRecordDecl *MostDerivedClass;
73
Anders Carlssonca82a4f2010-03-10 02:33:41 +000074 /// MostDerivedClassOffset - If we're building final overriders for a
75 /// construction vtable, this holds the offset from the layout class to the
76 /// most derived class.
77 const uint64_t MostDerivedClassOffset;
78
79 /// LayoutClass - The class we're using for layout information. Will be
80 /// different than the most derived class if the final overriders are for a
81 /// construction vtable.
82 const CXXRecordDecl *LayoutClass;
83
Anders Carlssone8ac42a2010-02-11 21:24:32 +000084 ASTContext &Context;
85
86 /// MostDerivedClassLayout - the AST record layout of the most derived class.
87 const ASTRecordLayout &MostDerivedClassLayout;
88
Anders Carlssoneee53d92010-02-13 02:02:03 +000089 /// BaseSubobjectMethodPairTy - Uniquely identifies a member function
90 /// in a base subobject.
91 typedef std::pair<BaseSubobject, const CXXMethodDecl *>
92 BaseSubobjectMethodPairTy;
93
94 typedef llvm::DenseMap<BaseSubobjectMethodPairTy,
Anders Carlsson136bd192010-02-12 16:55:34 +000095 OverriderInfo> OverridersMapTy;
Anders Carlssone8ac42a2010-02-11 21:24:32 +000096
97 /// OverridersMap - The final overriders for all virtual member functions of
98 /// all the base subobjects of the most derived class.
99 OverridersMapTy OverridersMap;
100
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000101 /// VisitedVirtualBases - A set of all the visited virtual bases, used to
102 /// avoid visiting virtual bases more than once.
103 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
104
Anders Carlssoneee53d92010-02-13 02:02:03 +0000105 typedef llvm::DenseMap<BaseSubobjectMethodPairTy, BaseOffset>
106 AdjustmentOffsetsMapTy;
107
108 /// ReturnAdjustments - Holds return adjustments for all the overriders that
109 /// need to perform return value adjustments.
110 AdjustmentOffsetsMapTy ReturnAdjustments;
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000111
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000112 // FIXME: We might be able to get away with making this a SmallSet.
113 typedef llvm::SmallSetVector<uint64_t, 2> OffsetSetVectorTy;
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000114
115 /// SubobjectOffsetsMapTy - This map is used for keeping track of all the
116 /// base subobject offsets that a single class declaration might refer to.
117 ///
118 /// For example, in:
119 ///
120 /// struct A { virtual void f(); };
121 /// struct B1 : A { };
122 /// struct B2 : A { };
123 /// struct C : B1, B2 { virtual void f(); };
124 ///
125 /// when we determine that C::f() overrides A::f(), we need to update the
126 /// overriders map for both A-in-B1 and A-in-B2 and the subobject offsets map
127 /// will have the subobject offsets for both A copies.
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000128 typedef llvm::DenseMap<const CXXRecordDecl *, OffsetSetVectorTy>
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000129 SubobjectOffsetsMapTy;
130
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000131 /// ComputeFinalOverriders - Compute the final overriders for a given base
132 /// subobject (and all its direct and indirect bases).
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000133 void ComputeFinalOverriders(BaseSubobject Base,
Anders Carlsson231461f2010-02-17 17:48:25 +0000134 bool BaseSubobjectIsVisitedVBase,
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000135 uint64_t OffsetInLayoutClass,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000136 SubobjectOffsetsMapTy &Offsets);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000137
138 /// AddOverriders - Add the final overriders for this base subobject to the
139 /// map of final overriders.
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000140 void AddOverriders(BaseSubobject Base,uint64_t OffsetInLayoutClass,
141 SubobjectOffsetsMapTy &Offsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000142
143 /// PropagateOverrider - Propagate the NewMD overrider to all the functions
144 /// that OldMD overrides. For example, if we have:
145 ///
146 /// struct A { virtual void f(); };
147 /// struct B : A { virtual void f(); };
148 /// struct C : B { virtual void f(); };
149 ///
150 /// and we want to override B::f with C::f, we also need to override A::f with
151 /// C::f.
152 void PropagateOverrider(const CXXMethodDecl *OldMD,
Anders Carlssona678aa12010-02-13 22:23:31 +0000153 BaseSubobject NewBase,
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000154 uint64_t OverriderOffsetInLayoutClass,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000155 const CXXMethodDecl *NewMD,
156 SubobjectOffsetsMapTy &Offsets);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000157
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000158 static void MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
159 SubobjectOffsetsMapTy &Offsets);
160
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000161public:
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000162 FinalOverriders(const CXXRecordDecl *MostDerivedClass,
163 uint64_t MostDerivedClassOffset,
164 const CXXRecordDecl *LayoutClass);
Anders Carlsson8025e7b2010-02-24 22:18:01 +0000165
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000166 /// getOverrider - Get the final overrider for the given method declaration in
167 /// the given base subobject.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000168 OverriderInfo getOverrider(BaseSubobject Base,
169 const CXXMethodDecl *MD) const {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000170 assert(OverridersMap.count(std::make_pair(Base, MD)) &&
171 "Did not find overrider!");
172
173 return OverridersMap.lookup(std::make_pair(Base, MD));
174 }
175
Anders Carlssond3adb0c2010-02-13 23:40:17 +0000176 /// getReturnAdjustmentOffset - Get the return adjustment offset for the
177 /// method decl in the given base subobject. Returns an empty base offset if
178 /// no adjustment is needed.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +0000179 BaseOffset getReturnAdjustmentOffset(BaseSubobject Base,
180 const CXXMethodDecl *MD) const {
181 return ReturnAdjustments.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 Carlsson603d7d12010-02-27 20:02:53 +0000197#define DUMP_OVERRIDERS 0
198
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000199FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
200 uint64_t MostDerivedClassOffset,
201 const CXXRecordDecl *LayoutClass)
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000202 : MostDerivedClass(MostDerivedClass),
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000203 MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass),
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000204 Context(MostDerivedClass->getASTContext()),
205 MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
206
207 // Compute the final overriders.
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000208 SubobjectOffsetsMapTy Offsets;
Anders Carlsson231461f2010-02-17 17:48:25 +0000209 ComputeFinalOverriders(BaseSubobject(MostDerivedClass, 0),
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000210 /*BaseSubobjectIsVisitedVBase=*/false,
211 MostDerivedClassOffset, Offsets);
Anders Carlsson231461f2010-02-17 17:48:25 +0000212 VisitedVirtualBases.clear();
Anders Carlsson603d7d12010-02-27 20:02:53 +0000213
214#if DUMP_OVERRIDERS
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000215 // And dump them (for now).
216 dump();
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000217
218 // Also dump the base offsets (for now).
219 for (SubobjectOffsetsMapTy::const_iterator I = Offsets.begin(),
220 E = Offsets.end(); I != E; ++I) {
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000221 const OffsetSetVectorTy& OffsetSetVector = I->second;
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000222
223 llvm::errs() << "Base offsets for ";
224 llvm::errs() << I->first->getQualifiedNameAsString() << '\n';
225
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000226 for (unsigned I = 0, E = OffsetSetVector.size(); I != E; ++I)
227 llvm::errs() << " " << I << " - " << OffsetSetVector[I] / 8 << '\n';
Anders Carlsson3f9917d2010-02-13 21:33:22 +0000228 }
Anders Carlsson603d7d12010-02-27 20:02:53 +0000229#endif
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000230}
231
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000232void FinalOverriders::AddOverriders(BaseSubobject Base,
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000233 uint64_t OffsetInLayoutClass,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000234 SubobjectOffsetsMapTy &Offsets) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000235 const CXXRecordDecl *RD = Base.getBase();
236
237 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
238 E = RD->method_end(); I != E; ++I) {
239 const CXXMethodDecl *MD = *I;
240
241 if (!MD->isVirtual())
242 continue;
243
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000244 // First, propagate the overrider.
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000245 PropagateOverrider(MD, Base, OffsetInLayoutClass, MD, Offsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000246
247 // Add the overrider as the final overrider of itself.
Anders Carlsson136bd192010-02-12 16:55:34 +0000248 OverriderInfo& Overrider = OverridersMap[std::make_pair(Base, MD)];
249 assert(!Overrider.Method && "Overrider should not exist yet!");
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000250
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000251 Overrider.Offset = OffsetInLayoutClass;
Anders Carlsson136bd192010-02-12 16:55:34 +0000252 Overrider.Method = MD;
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000253 }
254}
255
Anders Carlsson075056a2010-02-23 01:34:28 +0000256static BaseOffset ComputeBaseOffset(ASTContext &Context,
257 const CXXRecordDecl *DerivedRD,
258 const CXXBasePath &Path) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000259 int64_t NonVirtualOffset = 0;
Anders Carlssoneee53d92010-02-13 02:02:03 +0000260
Anders Carlssonf3f67842010-02-13 20:41:15 +0000261 unsigned NonVirtualStart = 0;
262 const CXXRecordDecl *VirtualBase = 0;
263
264 // First, look for the virtual base class.
265 for (unsigned I = 0, E = Path.size(); I != E; ++I) {
266 const CXXBasePathElement &Element = Path[I];
267
268 if (Element.Base->isVirtual()) {
269 // FIXME: Can we break when we find the first virtual base?
270 // (If we can't, can't we just iterate over the path in reverse order?)
271 NonVirtualStart = I + 1;
272 QualType VBaseType = Element.Base->getType();
273 VirtualBase =
274 cast<CXXRecordDecl>(VBaseType->getAs<RecordType>()->getDecl());
275 }
276 }
277
278 // Now compute the non-virtual offset.
279 for (unsigned I = NonVirtualStart, E = Path.size(); I != E; ++I) {
280 const CXXBasePathElement &Element = Path[I];
Anders Carlssoneee53d92010-02-13 02:02:03 +0000281
282 // Check the base class offset.
283 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Element.Class);
Anders Carlssoned7d0e82010-02-25 22:18:35 +0000284
Anders Carlssoneee53d92010-02-13 02:02:03 +0000285 const RecordType *BaseType = Element.Base->getType()->getAs<RecordType>();
286 const CXXRecordDecl *Base = cast<CXXRecordDecl>(BaseType->getDecl());
Anders Carlssoned7d0e82010-02-25 22:18:35 +0000287
Anders Carlssoneee53d92010-02-13 02:02:03 +0000288 NonVirtualOffset += Layout.getBaseClassOffset(Base);
289 }
290
291 // FIXME: This should probably use CharUnits or something. Maybe we should
292 // even change the base offsets in ASTRecordLayout to be specified in
293 // CharUnits.
Anders Carlsson075056a2010-02-23 01:34:28 +0000294 return BaseOffset(DerivedRD, VirtualBase, NonVirtualOffset / 8);
Anders Carlsson258a1e32010-02-14 00:16:19 +0000295
296}
297
Anders Carlsson075056a2010-02-23 01:34:28 +0000298static BaseOffset ComputeBaseOffset(ASTContext &Context,
299 const CXXRecordDecl *BaseRD,
300 const CXXRecordDecl *DerivedRD) {
Anders Carlsson258a1e32010-02-14 00:16:19 +0000301 CXXBasePaths Paths(/*FindAmbiguities=*/false,
302 /*RecordPaths=*/true, /*DetectVirtual=*/false);
303
304 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
305 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
306 assert(false && "Class must be derived from the passed in base class!");
Anders Carlsson075056a2010-02-23 01:34:28 +0000307 return BaseOffset();
Anders Carlsson258a1e32010-02-14 00:16:19 +0000308 }
309
310 return ComputeBaseOffset(Context, DerivedRD, Paths.front());
Anders Carlssoneee53d92010-02-13 02:02:03 +0000311}
312
Anders Carlsson075056a2010-02-23 01:34:28 +0000313static BaseOffset
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000314ComputeReturnAdjustmentBaseOffset(ASTContext &Context,
315 const CXXMethodDecl *DerivedMD,
316 const CXXMethodDecl *BaseMD) {
Anders Carlssoneee53d92010-02-13 02:02:03 +0000317 const FunctionType *BaseFT = BaseMD->getType()->getAs<FunctionType>();
318 const FunctionType *DerivedFT = DerivedMD->getType()->getAs<FunctionType>();
319
320 // Canonicalize the return types.
321 CanQualType CanDerivedReturnType =
322 Context.getCanonicalType(DerivedFT->getResultType());
323 CanQualType CanBaseReturnType =
324 Context.getCanonicalType(BaseFT->getResultType());
325
326 assert(CanDerivedReturnType->getTypeClass() ==
327 CanBaseReturnType->getTypeClass() &&
328 "Types must have same type class!");
329
330 if (CanDerivedReturnType == CanBaseReturnType) {
331 // No adjustment needed.
Anders Carlsson075056a2010-02-23 01:34:28 +0000332 return BaseOffset();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000333 }
334
335 if (isa<ReferenceType>(CanDerivedReturnType)) {
336 CanDerivedReturnType =
337 CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType();
338 CanBaseReturnType =
339 CanBaseReturnType->getAs<ReferenceType>()->getPointeeType();
340 } else if (isa<PointerType>(CanDerivedReturnType)) {
341 CanDerivedReturnType =
342 CanDerivedReturnType->getAs<PointerType>()->getPointeeType();
343 CanBaseReturnType =
344 CanBaseReturnType->getAs<PointerType>()->getPointeeType();
345 } else {
346 assert(false && "Unexpected return type!");
347 }
348
349 // We need to compare unqualified types here; consider
350 // const T *Base::foo();
351 // T *Derived::foo();
352 if (CanDerivedReturnType.getUnqualifiedType() ==
353 CanBaseReturnType.getUnqualifiedType()) {
354 // No adjustment needed.
Anders Carlsson075056a2010-02-23 01:34:28 +0000355 return BaseOffset();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000356 }
357
358 const CXXRecordDecl *DerivedRD =
359 cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl());
360
361 const CXXRecordDecl *BaseRD =
362 cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl());
363
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000364 return ComputeBaseOffset(Context, BaseRD, DerivedRD);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000365}
366
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000367void FinalOverriders::PropagateOverrider(const CXXMethodDecl *OldMD,
Anders Carlssona678aa12010-02-13 22:23:31 +0000368 BaseSubobject NewBase,
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000369 uint64_t OverriderOffsetInLayoutClass,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000370 const CXXMethodDecl *NewMD,
371 SubobjectOffsetsMapTy &Offsets) {
372 for (CXXMethodDecl::method_iterator I = OldMD->begin_overridden_methods(),
373 E = OldMD->end_overridden_methods(); I != E; ++I) {
374 const CXXMethodDecl *OverriddenMD = *I;
375 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
376
377 // We want to override OverriddenMD in all subobjects, for example:
378 //
379 /// struct A { virtual void f(); };
380 /// struct B1 : A { };
381 /// struct B2 : A { };
382 /// struct C : B1, B2 { virtual void f(); };
383 ///
384 /// When overriding A::f with C::f we need to do so in both A subobjects.
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000385 const OffsetSetVectorTy &OffsetVector = Offsets[OverriddenRD];
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000386
387 // Go through all the subobjects.
388 for (unsigned I = 0, E = OffsetVector.size(); I != E; ++I) {
389 uint64_t Offset = OffsetVector[I];
390
Anders Carlsson258a1e32010-02-14 00:16:19 +0000391 BaseSubobject OverriddenSubobject = BaseSubobject(OverriddenRD, Offset);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000392 BaseSubobjectMethodPairTy SubobjectAndMethod =
Anders Carlsson258a1e32010-02-14 00:16:19 +0000393 std::make_pair(OverriddenSubobject, OverriddenMD);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000394
395 OverriderInfo &Overrider = OverridersMap[SubobjectAndMethod];
396
Anders Carlsson136bd192010-02-12 16:55:34 +0000397 assert(Overrider.Method && "Did not find existing overrider!");
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000398
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000399 // Check if we need return adjustments or base adjustments.
Anders Carlssonc1290ad2010-02-13 21:16:54 +0000400 // (We don't want to do this for pure virtual member functions).
401 if (!NewMD->isPure()) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000402 // Get the return adjustment base offset.
Anders Carlssonc1290ad2010-02-13 21:16:54 +0000403 BaseOffset ReturnBaseOffset =
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000404 ComputeReturnAdjustmentBaseOffset(Context, NewMD, OverriddenMD);
405
Anders Carlssonc1290ad2010-02-13 21:16:54 +0000406 if (!ReturnBaseOffset.isEmpty()) {
407 // Store the return adjustment base offset.
408 ReturnAdjustments[SubobjectAndMethod] = ReturnBaseOffset;
409 }
Anders Carlsson8e661e12010-02-12 17:13:23 +0000410 }
411
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000412 // Set the new overrider.
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000413 Overrider.Offset = OverriderOffsetInLayoutClass;
Anders Carlsson136bd192010-02-12 16:55:34 +0000414 Overrider.Method = NewMD;
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000415
416 // And propagate it further.
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000417 PropagateOverrider(OverriddenMD, NewBase, OverriderOffsetInLayoutClass,
418 NewMD, Offsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000419 }
420 }
421}
422
423void
424FinalOverriders::MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
425 SubobjectOffsetsMapTy &Offsets) {
426 // Iterate over the new offsets.
427 for (SubobjectOffsetsMapTy::const_iterator I = NewOffsets.begin(),
428 E = NewOffsets.end(); I != E; ++I) {
429 const CXXRecordDecl *NewRD = I->first;
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000430 const OffsetSetVectorTy& NewOffsetVector = I->second;
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000431
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000432 OffsetSetVectorTy &OffsetVector = Offsets[NewRD];
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000433
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000434 // Merge the new offsets set vector into the old.
435 OffsetVector.insert(NewOffsetVector.begin(), NewOffsetVector.end());
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000436 }
437}
438
439void FinalOverriders::ComputeFinalOverriders(BaseSubobject Base,
Anders Carlsson231461f2010-02-17 17:48:25 +0000440 bool BaseSubobjectIsVisitedVBase,
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000441 uint64_t OffsetInLayoutClass,
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000442 SubobjectOffsetsMapTy &Offsets) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000443 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000444 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000445
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000446 SubobjectOffsetsMapTy NewOffsets;
447
448 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
449 E = RD->bases_end(); I != E; ++I) {
450 const CXXRecordDecl *BaseDecl =
451 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
452
Anders Carlsson033d4862010-02-14 17:05:59 +0000453 // Ignore bases that don't have any virtual member functions.
454 if (!BaseDecl->isPolymorphic())
455 continue;
456
Anders Carlssoned7d0e82010-02-25 22:18:35 +0000457 bool IsVisitedVirtualBase = BaseSubobjectIsVisitedVBase;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000458 uint64_t BaseOffset;
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000459 uint64_t BaseOffsetInLayoutClass;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000460 if (I->isVirtual()) {
Anders Carlsson231461f2010-02-17 17:48:25 +0000461 if (!VisitedVirtualBases.insert(BaseDecl))
462 IsVisitedVirtualBase = true;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000463 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000464
465 const ASTRecordLayout &LayoutClassLayout =
466 Context.getASTRecordLayout(LayoutClass);
467 BaseOffsetInLayoutClass =
468 LayoutClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000469 } else {
470 BaseOffset = Layout.getBaseClassOffset(BaseDecl) + Base.getBaseOffset();
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000471 BaseOffsetInLayoutClass = Layout.getBaseClassOffset(BaseDecl) +
472 OffsetInLayoutClass;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000473 }
474
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000475 // Compute the final overriders for this base.
Anders Carlsson231461f2010-02-17 17:48:25 +0000476 // We always want to compute the final overriders, even if the base is a
477 // visited virtual base. Consider:
478 //
479 // struct A {
480 // virtual void f();
481 // virtual void g();
482 // };
483 //
484 // struct B : virtual A {
485 // void f();
486 // };
487 //
488 // struct C : virtual A {
489 // void g ();
490 // };
491 //
492 // struct D : B, C { };
493 //
494 // Here, we still want to compute the overriders for A as a base of C,
495 // because otherwise we'll miss that C::g overrides A::f.
496 ComputeFinalOverriders(BaseSubobject(BaseDecl, BaseOffset),
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000497 IsVisitedVirtualBase, BaseOffsetInLayoutClass,
498 NewOffsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000499 }
500
501 /// Now add the overriders for this particular subobject.
Anders Carlsson231461f2010-02-17 17:48:25 +0000502 /// (We don't want to do this more than once for a virtual base).
503 if (!BaseSubobjectIsVisitedVBase)
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000504 AddOverriders(Base, OffsetInLayoutClass, NewOffsets);
Anders Carlsson9fbf6d92010-02-12 01:40:03 +0000505
506 // And merge the newly discovered subobject offsets.
507 MergeSubobjectOffsets(NewOffsets, Offsets);
508
509 /// Finally, add the offset for our own subobject.
Anders Carlsson5b0057c2010-03-03 04:58:02 +0000510 Offsets[RD].insert(Base.getBaseOffset());
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000511}
512
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000513void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000514 const CXXRecordDecl *RD = Base.getBase();
515 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
516
517 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
518 E = RD->bases_end(); I != E; ++I) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000519 const CXXRecordDecl *BaseDecl =
520 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
521
Anders Carlsson033d4862010-02-14 17:05:59 +0000522 // Ignore bases that don't have any virtual member functions.
523 if (!BaseDecl->isPolymorphic())
524 continue;
525
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000526 uint64_t BaseOffset;
527 if (I->isVirtual()) {
528 if (!VisitedVirtualBases.insert(BaseDecl)) {
529 // We've visited this base before.
530 continue;
531 }
532
533 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
534 } else {
535 BaseOffset = Layout.getBaseClassOffset(BaseDecl) +
536 Base.getBaseOffset();
537 }
538
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000539 dump(Out, BaseSubobject(BaseDecl, BaseOffset));
540 }
541
542 Out << "Final overriders for (" << RD->getQualifiedNameAsString() << ", ";
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000543 Out << Base.getBaseOffset() / 8 << ")\n";
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000544
545 // Now dump the overriders for this base subobject.
546 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
547 E = RD->method_end(); I != E; ++I) {
548 const CXXMethodDecl *MD = *I;
549
550 if (!MD->isVirtual())
551 continue;
552
Anders Carlsson136bd192010-02-12 16:55:34 +0000553 OverriderInfo Overrider = getOverrider(Base, MD);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000554
Anders Carlsson6f1f0022010-03-02 03:44:06 +0000555 Out << " " << MD->getQualifiedNameAsString() << " - (";
Anders Carlsson8e661e12010-02-12 17:13:23 +0000556 Out << Overrider.Method->getQualifiedNameAsString();
Anders Carlsson3c289672010-03-12 05:02:01 +0000557 Out << ", " << ", " << Overrider.Offset / 8 << ')';
Anders Carlsson6f1f0022010-03-02 03:44:06 +0000558
Benjamin Kramer02c67372010-02-13 09:11:28 +0000559 AdjustmentOffsetsMapTy::const_iterator AI =
Anders Carlssoneee53d92010-02-13 02:02:03 +0000560 ReturnAdjustments.find(std::make_pair(Base, MD));
Benjamin Kramer02c67372010-02-13 09:11:28 +0000561 if (AI != ReturnAdjustments.end()) {
562 const BaseOffset &Offset = AI->second;
Anders Carlssonf3f67842010-02-13 20:41:15 +0000563
564 Out << " [ret-adj: ";
565 if (Offset.VirtualBase)
566 Out << Offset.VirtualBase->getQualifiedNameAsString() << " vbase, ";
Anders Carlssoneee53d92010-02-13 02:02:03 +0000567
Anders Carlssonf3f67842010-02-13 20:41:15 +0000568 Out << Offset.NonVirtualOffset << " nv]";
Anders Carlssoneee53d92010-02-13 02:02:03 +0000569 }
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000570
Anders Carlsson8e661e12010-02-12 17:13:23 +0000571 Out << "\n";
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000572 }
573}
574
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000575/// VtableComponent - Represents a single component in a vtable.
576class VtableComponent {
577public:
578 enum Kind {
579 CK_VCallOffset,
580 CK_VBaseOffset,
581 CK_OffsetToTop,
582 CK_RTTI,
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000583 CK_FunctionPointer,
584
585 /// CK_CompleteDtorPointer - A pointer to the complete destructor.
586 CK_CompleteDtorPointer,
587
588 /// CK_DeletingDtorPointer - A pointer to the deleting destructor.
Anders Carlsson350b56e2010-02-19 20:08:13 +0000589 CK_DeletingDtorPointer,
590
591 /// CK_UnusedFunctionPointer - In some cases, a vtable function pointer
592 /// will end up never being called. Such vtable function pointers are
593 /// represented as a CK_UnusedFunctionPointer.
594 CK_UnusedFunctionPointer
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000595 };
596
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000597 static VtableComponent MakeVCallOffset(int64_t Offset) {
598 return VtableComponent(CK_VCallOffset, Offset);
599 }
600
Anders Carlssondc2dba32010-02-16 04:49:44 +0000601 static VtableComponent MakeVBaseOffset(int64_t Offset) {
602 return VtableComponent(CK_VBaseOffset, Offset);
603 }
604
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000605 static VtableComponent MakeOffsetToTop(int64_t Offset) {
606 return VtableComponent(CK_OffsetToTop, Offset);
607 }
608
609 static VtableComponent MakeRTTI(const CXXRecordDecl *RD) {
610 return VtableComponent(CK_RTTI, reinterpret_cast<uintptr_t>(RD));
611 }
612
613 static VtableComponent MakeFunction(const CXXMethodDecl *MD) {
614 assert(!isa<CXXDestructorDecl>(MD) &&
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000615 "Don't use MakeFunction with destructors!");
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000616
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000617 return VtableComponent(CK_FunctionPointer,
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000618 reinterpret_cast<uintptr_t>(MD));
619 }
620
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000621 static VtableComponent MakeCompleteDtor(const CXXDestructorDecl *DD) {
622 return VtableComponent(CK_CompleteDtorPointer,
623 reinterpret_cast<uintptr_t>(DD));
624 }
625
626 static VtableComponent MakeDeletingDtor(const CXXDestructorDecl *DD) {
627 return VtableComponent(CK_DeletingDtorPointer,
628 reinterpret_cast<uintptr_t>(DD));
629 }
630
Anders Carlsson350b56e2010-02-19 20:08:13 +0000631 static VtableComponent MakeUnusedFunction(const CXXMethodDecl *MD) {
632 assert(!isa<CXXDestructorDecl>(MD) &&
633 "Don't use MakeUnusedFunction with destructors!");
634 return VtableComponent(CK_UnusedFunctionPointer,
635 reinterpret_cast<uintptr_t>(MD));
636 }
637
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000638 /// getKind - Get the kind of this vtable component.
639 Kind getKind() const {
640 return (Kind)(Value & 0x7);
641 }
642
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000643 int64_t getVCallOffset() const {
644 assert(getKind() == CK_VCallOffset && "Invalid component kind!");
645
646 return getOffset();
647 }
648
Anders Carlssondc2dba32010-02-16 04:49:44 +0000649 int64_t getVBaseOffset() const {
650 assert(getKind() == CK_VBaseOffset && "Invalid component kind!");
651
652 return getOffset();
653 }
654
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000655 int64_t getOffsetToTop() const {
656 assert(getKind() == CK_OffsetToTop && "Invalid component kind!");
657
658 return getOffset();
659 }
660
661 const CXXRecordDecl *getRTTIDecl() const {
662 assert(getKind() == CK_RTTI && "Invalid component kind!");
663
664 return reinterpret_cast<CXXRecordDecl *>(getPointer());
665 }
666
667 const CXXMethodDecl *getFunctionDecl() const {
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000668 assert(getKind() == CK_FunctionPointer);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000669
670 return reinterpret_cast<CXXMethodDecl *>(getPointer());
671 }
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000672
673 const CXXDestructorDecl *getDestructorDecl() const {
674 assert((getKind() == CK_CompleteDtorPointer ||
675 getKind() == CK_DeletingDtorPointer) && "Invalid component kind!");
676
677 return reinterpret_cast<CXXDestructorDecl *>(getPointer());
678 }
679
Anders Carlsson350b56e2010-02-19 20:08:13 +0000680 const CXXMethodDecl *getUnusedFunctionDecl() const {
681 assert(getKind() == CK_UnusedFunctionPointer);
682
683 return reinterpret_cast<CXXMethodDecl *>(getPointer());
684 }
685
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000686private:
687 VtableComponent(Kind ComponentKind, int64_t Offset) {
688 assert((ComponentKind == CK_VCallOffset ||
689 ComponentKind == CK_VBaseOffset ||
690 ComponentKind == CK_OffsetToTop) && "Invalid component kind!");
691 assert(Offset <= ((1LL << 56) - 1) && "Offset is too big!");
692
693 Value = ((Offset << 3) | ComponentKind);
694 }
695
696 VtableComponent(Kind ComponentKind, uintptr_t Ptr) {
697 assert((ComponentKind == CK_RTTI ||
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000698 ComponentKind == CK_FunctionPointer ||
699 ComponentKind == CK_CompleteDtorPointer ||
Anders Carlsson350b56e2010-02-19 20:08:13 +0000700 ComponentKind == CK_DeletingDtorPointer ||
701 ComponentKind == CK_UnusedFunctionPointer) &&
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000702 "Invalid component kind!");
703
704 assert((Ptr & 7) == 0 && "Pointer not sufficiently aligned!");
705
706 Value = Ptr | ComponentKind;
707 }
708
709 int64_t getOffset() const {
710 assert((getKind() == CK_VCallOffset || getKind() == CK_VBaseOffset ||
711 getKind() == CK_OffsetToTop) && "Invalid component kind!");
712
713 return Value >> 3;
714 }
715
716 uintptr_t getPointer() const {
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000717 assert((getKind() == CK_RTTI ||
718 getKind() == CK_FunctionPointer ||
719 getKind() == CK_CompleteDtorPointer ||
Anders Carlsson350b56e2010-02-19 20:08:13 +0000720 getKind() == CK_DeletingDtorPointer ||
721 getKind() == CK_UnusedFunctionPointer) &&
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000722 "Invalid component kind!");
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000723
724 return static_cast<uintptr_t>(Value & ~7ULL);
725 }
726
727 /// The kind is stored in the lower 3 bits of the value. For offsets, we
728 /// make use of the facts that classes can't be larger than 2^55 bytes,
729 /// so we store the offset in the lower part of the 61 bytes that remain.
730 /// (The reason that we're not simply using a PointerIntPair here is that we
731 /// need the offsets to be 64-bit, even when on a 32-bit machine).
732 int64_t Value;
733};
734
Anders Carlsson78277c72010-02-18 17:00:09 +0000735/// VCallOffsetMap - Keeps track of vcall offsets when building a vtable.
736struct VCallOffsetMap {
737
738 typedef std::pair<const CXXMethodDecl *, int64_t> MethodAndOffsetPairTy;
739
740 /// Offsets - Keeps track of methods and their offsets.
741 // FIXME: This should be a real map and not a vector.
742 llvm::SmallVector<MethodAndOffsetPairTy, 16> Offsets;
743
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000744 /// MethodsCanShareVCallOffset - Returns whether two virtual member functions
745 /// can share the same vcall offset.
746 static bool MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
747 const CXXMethodDecl *RHS);
748
Anders Carlsson78277c72010-02-18 17:00:09 +0000749public:
750 /// AddVCallOffset - Adds a vcall offset to the map. Returns true if the
751 /// add was successful, or false if there was already a member function with
752 /// the same signature in the map.
753 bool AddVCallOffset(const CXXMethodDecl *MD, int64_t OffsetOffset);
754
755 /// getVCallOffsetOffset - Returns the vcall offset offset (relative to the
756 /// vtable address point) for the given virtual member function.
757 int64_t getVCallOffsetOffset(const CXXMethodDecl *MD);
758
Anders Carlsson9e3b3a32010-02-25 22:23:13 +0000759 // empty - Return whether the offset map is empty or not.
760 bool empty() const { return Offsets.empty(); }
Anders Carlsson78277c72010-02-18 17:00:09 +0000761};
762
John McCall43c6ffb2010-02-26 20:22:44 +0000763static bool HasSameVirtualSignature(const CXXMethodDecl *LHS,
764 const CXXMethodDecl *RHS) {
765 ASTContext &C = LHS->getASTContext(); // TODO: thread this down
766 CanQual<FunctionProtoType>
767 LT = C.getCanonicalType(LHS->getType()).getAs<FunctionProtoType>(),
768 RT = C.getCanonicalType(RHS->getType()).getAs<FunctionProtoType>();
769
770 // Fast-path matches in the canonical types.
771 if (LT == RT) return true;
772
773 // Force the signatures to match. We can't rely on the overrides
774 // list here because there isn't necessarily an inheritance
775 // relationship between the two methods.
776 if (LT.getQualifiers() != RT.getQualifiers() ||
777 LT->getNumArgs() != RT->getNumArgs())
778 return false;
779 for (unsigned I = 0, E = LT->getNumArgs(); I != E; ++I)
780 if (LT->getArgType(I) != RT->getArgType(I))
781 return false;
782 return true;
783}
784
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000785bool VCallOffsetMap::MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
786 const CXXMethodDecl *RHS) {
787 assert(LHS->isVirtual() && "LHS must be virtual!");
788 assert(RHS->isVirtual() && "LHS must be virtual!");
789
Anders Carlssond69b2f92010-02-27 04:12:52 +0000790 // A destructor can share a vcall offset with another destructor.
791 if (isa<CXXDestructorDecl>(LHS))
792 return isa<CXXDestructorDecl>(RHS);
793
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000794 // FIXME: We need to check more things here.
795
Anders Carlssond69b2f92010-02-27 04:12:52 +0000796 // The methods must have the same name.
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000797 DeclarationName LHSName = LHS->getDeclName();
798 DeclarationName RHSName = RHS->getDeclName();
John McCall43c6ffb2010-02-26 20:22:44 +0000799 if (LHSName != RHSName)
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000800 return false;
John McCall43c6ffb2010-02-26 20:22:44 +0000801
Anders Carlssond69b2f92010-02-27 04:12:52 +0000802 // And the same signatures.
803 return HasSameVirtualSignature(LHS, RHS);
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000804}
805
Anders Carlsson78277c72010-02-18 17:00:09 +0000806bool VCallOffsetMap::AddVCallOffset(const CXXMethodDecl *MD,
807 int64_t OffsetOffset) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000808 // Check if we can reuse an offset.
809 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
810 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
811 return false;
812 }
813
814 // Add the offset.
815 Offsets.push_back(MethodAndOffsetPairTy(MD, OffsetOffset));
Anders Carlsson78277c72010-02-18 17:00:09 +0000816 return true;
817}
818
819int64_t VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000820 // Look for an offset.
821 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
822 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
823 return Offsets[I].second;
824 }
825
826 assert(false && "Should always find a vcall offset offset!");
Anders Carlsson78277c72010-02-18 17:00:09 +0000827 return 0;
828}
829
Anders Carlsson422f7782010-02-25 03:45:56 +0000830/// VCallAndVBaseOffsetBuilder - Class for building vcall and vbase offsets.
831class VCallAndVBaseOffsetBuilder {
Anders Carlssondd819c92010-03-11 16:06:20 +0000832public:
833 typedef llvm::DenseMap<const CXXRecordDecl *, int64_t>
834 VBaseOffsetOffsetsMapTy;
835
836private:
Anders Carlssone3385f52010-02-28 01:43:58 +0000837 /// MostDerivedClass - The most derived class for which we're building vcall
838 /// and vbase offsets.
Anders Carlsson422f7782010-02-25 03:45:56 +0000839 const CXXRecordDecl *MostDerivedClass;
840
Anders Carlssonc3f92a12010-02-27 21:09:00 +0000841 /// LayoutClass - The class we're using for layout information. Will be
842 /// different than the most derived class if we're building a construction
843 /// vtable.
844 const CXXRecordDecl *LayoutClass;
845
Anders Carlsson422f7782010-02-25 03:45:56 +0000846 /// Context - The ASTContext which we will use for layout information.
847 ASTContext &Context;
848
849 /// Components - vcall and vbase offset components
850 typedef llvm::SmallVector<VtableComponent, 64> VtableComponentVectorTy;
851 VtableComponentVectorTy Components;
852
853 /// VisitedVirtualBases - Visited virtual bases.
854 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
855
856 /// VCallOffsets - Keeps track of vcall offsets.
857 VCallOffsetMap VCallOffsets;
858
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000859
860 /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets,
861 /// relative to the address point.
862 VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
863
Anders Carlsson422f7782010-02-25 03:45:56 +0000864 /// FinalOverriders - The final overriders of the most derived class.
865 /// (Can be null when we're not building a vtable of the most derived class).
866 const FinalOverriders *Overriders;
867
868 /// AddVCallAndVBaseOffsets - Add vcall offsets and vbase offsets for the
869 /// given base subobject.
870 void AddVCallAndVBaseOffsets(BaseSubobject Base, bool BaseIsVirtual,
871 uint64_t RealBaseOffset);
872
873 /// AddVCallOffsets - Add vcall offsets for the given base subobject.
874 void AddVCallOffsets(BaseSubobject Base, uint64_t VBaseOffset);
875
876 /// AddVBaseOffsets - Add vbase offsets for the given class.
Anders Carlsson93b1b492010-03-02 05:40:45 +0000877 void AddVBaseOffsets(const CXXRecordDecl *Base, uint64_t OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +0000878
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000879 /// getCurrentOffsetOffset - Get the current vcall or vbase offset offset in
880 /// bytes, relative to the vtable address point.
881 int64_t getCurrentOffsetOffset() const;
882
Anders Carlsson422f7782010-02-25 03:45:56 +0000883public:
884 VCallAndVBaseOffsetBuilder(const CXXRecordDecl *MostDerivedClass,
Anders Carlssonc3f92a12010-02-27 21:09:00 +0000885 const CXXRecordDecl *LayoutClass,
Anders Carlsson422f7782010-02-25 03:45:56 +0000886 const FinalOverriders *Overriders,
Anders Carlssone3385f52010-02-28 01:43:58 +0000887 BaseSubobject Base, bool BaseIsVirtual,
888 uint64_t OffsetInLayoutClass)
889 : MostDerivedClass(MostDerivedClass), LayoutClass(LayoutClass),
Anders Carlsson422f7782010-02-25 03:45:56 +0000890 Context(MostDerivedClass->getASTContext()), Overriders(Overriders) {
891
892 // Add vcall and vbase offsets.
Anders Carlssone3385f52010-02-28 01:43:58 +0000893 AddVCallAndVBaseOffsets(Base, BaseIsVirtual, OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +0000894 }
895
896 /// Methods for iterating over the components.
897 typedef VtableComponentVectorTy::const_reverse_iterator const_iterator;
898 const_iterator components_begin() const { return Components.rbegin(); }
899 const_iterator components_end() const { return Components.rend(); }
900
Anders Carlssondd819c92010-03-11 16:06:20 +0000901 const VCallOffsetMap &getVCallOffsets() const { return VCallOffsets; }
902 const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000903 return VBaseOffsetOffsets;
904 }
Anders Carlsson422f7782010-02-25 03:45:56 +0000905};
906
907void
908VCallAndVBaseOffsetBuilder::AddVCallAndVBaseOffsets(BaseSubobject Base,
909 bool BaseIsVirtual,
910 uint64_t RealBaseOffset) {
911 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base.getBase());
912
913 // Itanium C++ ABI 2.5.2:
914 // ..in classes sharing a virtual table with a primary base class, the vcall
915 // and vbase offsets added by the derived class all come before the vcall
916 // and vbase offsets required by the base class, so that the latter may be
917 // laid out as required by the base class without regard to additions from
918 // the derived class(es).
919
920 // (Since we're emitting the vcall and vbase offsets in reverse order, we'll
921 // emit them for the primary base first).
922 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
923 bool PrimaryBaseIsVirtual = Layout.getPrimaryBaseWasVirtual();
924
925 uint64_t PrimaryBaseOffset;
926
927 // Get the base offset of the primary base.
928 if (PrimaryBaseIsVirtual) {
929 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
930 "Primary vbase should have a zero offset!");
931
932 const ASTRecordLayout &MostDerivedClassLayout =
933 Context.getASTRecordLayout(MostDerivedClass);
934
935 PrimaryBaseOffset =
936 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
937 } else {
938 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
939 "Primary base should have a zero offset!");
940
941 PrimaryBaseOffset = Base.getBaseOffset();
942 }
943
944 AddVCallAndVBaseOffsets(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
945 PrimaryBaseIsVirtual, RealBaseOffset);
946 }
947
Anders Carlsson93b1b492010-03-02 05:40:45 +0000948 AddVBaseOffsets(Base.getBase(), RealBaseOffset);
Anders Carlsson422f7782010-02-25 03:45:56 +0000949
950 // We only want to add vcall offsets for virtual bases.
951 if (BaseIsVirtual)
952 AddVCallOffsets(Base, RealBaseOffset);
953}
954
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000955int64_t VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const {
956 // OffsetIndex is the index of this vcall or vbase offset, relative to the
957 // vtable address point. (We subtract 3 to account for the information just
958 // above the address point, the RTTI info, the offset to top, and the
959 // vcall offset itself).
960 int64_t OffsetIndex = -(int64_t)(3 + Components.size());
961
962 // FIXME: We shouldn't use / 8 here.
963 int64_t OffsetOffset = OffsetIndex *
964 (int64_t)Context.Target.getPointerWidth(0) / 8;
965
966 return OffsetOffset;
967}
968
Anders Carlsson422f7782010-02-25 03:45:56 +0000969void VCallAndVBaseOffsetBuilder::AddVCallOffsets(BaseSubobject Base,
970 uint64_t VBaseOffset) {
971 const CXXRecordDecl *RD = Base.getBase();
972 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
973
John McCall43c6ffb2010-02-26 20:22:44 +0000974 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
975
Anders Carlsson422f7782010-02-25 03:45:56 +0000976 // Handle the primary base first.
John McCall43c6ffb2010-02-26 20:22:44 +0000977 if (PrimaryBase) {
Anders Carlsson422f7782010-02-25 03:45:56 +0000978 uint64_t PrimaryBaseOffset;
979
980 // Get the base offset of the primary base.
981 if (Layout.getPrimaryBaseWasVirtual()) {
982 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
983 "Primary vbase should have a zero offset!");
984
985 const ASTRecordLayout &MostDerivedClassLayout =
986 Context.getASTRecordLayout(MostDerivedClass);
987
988 PrimaryBaseOffset =
989 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
990 } else {
991 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
992 "Primary base should have a zero offset!");
993
994 PrimaryBaseOffset = Base.getBaseOffset();
995 }
996
997 AddVCallOffsets(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
998 VBaseOffset);
999 }
1000
1001 // Add the vcall offsets.
1002 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1003 E = RD->method_end(); I != E; ++I) {
1004 const CXXMethodDecl *MD = *I;
1005
1006 if (!MD->isVirtual())
1007 continue;
1008
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001009 int64_t OffsetOffset = getCurrentOffsetOffset();
Anders Carlsson422f7782010-02-25 03:45:56 +00001010
1011 // Don't add a vcall offset if we already have one for this member function
1012 // signature.
1013 if (!VCallOffsets.AddVCallOffset(MD, OffsetOffset))
1014 continue;
1015
1016 int64_t Offset = 0;
1017
1018 if (Overriders) {
1019 // Get the final overrider.
1020 FinalOverriders::OverriderInfo Overrider =
1021 Overriders->getOverrider(Base, MD);
1022
Anders Carlsson31f595f2010-02-28 00:10:58 +00001023 /// The vcall offset is the offset from the virtual base to the object
1024 /// where the function was overridden.
Anders Carlsson422f7782010-02-25 03:45:56 +00001025 // FIXME: We should not use / 8 here.
Anders Carlsson6f1f0022010-03-02 03:44:06 +00001026 Offset = (int64_t)(Overrider.Offset - VBaseOffset) / 8;
Anders Carlsson422f7782010-02-25 03:45:56 +00001027 }
1028
1029 Components.push_back(VtableComponent::MakeVCallOffset(Offset));
1030 }
1031
1032 // And iterate over all non-virtual bases (ignoring the primary base).
1033 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1034 E = RD->bases_end(); I != E; ++I) {
1035
1036 if (I->isVirtual())
1037 continue;
1038
1039 const CXXRecordDecl *BaseDecl =
1040 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
John McCall43c6ffb2010-02-26 20:22:44 +00001041 if (BaseDecl == PrimaryBase)
1042 continue;
Anders Carlsson422f7782010-02-25 03:45:56 +00001043
1044 // Get the base offset of this base.
1045 uint64_t BaseOffset = Base.getBaseOffset() +
1046 Layout.getBaseClassOffset(BaseDecl);
1047
1048 AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset), VBaseOffset);
1049 }
1050}
1051
Anders Carlsson422f7782010-02-25 03:45:56 +00001052void VCallAndVBaseOffsetBuilder::AddVBaseOffsets(const CXXRecordDecl *RD,
Anders Carlsson93b1b492010-03-02 05:40:45 +00001053 uint64_t OffsetInLayoutClass) {
Anders Carlssonc3f92a12010-02-27 21:09:00 +00001054 const ASTRecordLayout &LayoutClassLayout =
1055 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +00001056
1057 // Add vbase offsets.
1058 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1059 E = RD->bases_end(); I != E; ++I) {
1060 const CXXRecordDecl *BaseDecl =
1061 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1062
1063 // Check if this is a virtual base that we haven't visited before.
1064 if (I->isVirtual() && VisitedVirtualBases.insert(BaseDecl)) {
1065 // FIXME: We shouldn't use / 8 here.
Anders Carlsson93b1b492010-03-02 05:40:45 +00001066 int64_t Offset =
1067 (int64_t)(LayoutClassLayout.getVBaseClassOffset(BaseDecl) -
1068 OffsetInLayoutClass) / 8;
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001069
1070 // Add the vbase offset offset.
1071 assert(!VBaseOffsetOffsets.count(BaseDecl) &&
1072 "vbase offset offset already exists!");
1073
1074 int64_t VBaseOffsetOffset = getCurrentOffsetOffset();
1075 VBaseOffsetOffsets.insert(std::make_pair(BaseDecl, VBaseOffsetOffset));
1076
Anders Carlsson422f7782010-02-25 03:45:56 +00001077 Components.push_back(VtableComponent::MakeVBaseOffset(Offset));
1078 }
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001079
Anders Carlsson422f7782010-02-25 03:45:56 +00001080 // Check the base class looking for more vbase offsets.
Anders Carlsson93b1b492010-03-02 05:40:45 +00001081 AddVBaseOffsets(BaseDecl, OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +00001082 }
1083}
1084
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001085/// VtableBuilder - Class for building vtable layout information.
Benjamin Kramer337e3a52009-11-28 19:45:26 +00001086class VtableBuilder {
Anders Carlsson65b49782010-02-12 05:25:12 +00001087public:
Anders Carlssond46ed892010-02-27 16:18:19 +00001088 /// PrimaryBasesSetVectorTy - A set vector of direct and indirect
1089 /// primary bases.
1090 typedef llvm::SmallSetVector<const CXXRecordDecl *, 8>
1091 PrimaryBasesSetVectorTy;
1092
Anders Carlsson65b49782010-02-12 05:25:12 +00001093private:
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001094 /// VtableInfo - Global vtable information.
1095 CGVtableInfo &VtableInfo;
1096
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001097 /// MostDerivedClass - The most derived class for which we're building this
1098 /// vtable.
1099 const CXXRecordDecl *MostDerivedClass;
1100
Anders Carlsson93913752010-02-27 20:39:05 +00001101 /// MostDerivedClassOffset - If we're building a construction vtable, this
1102 /// holds the offset from the layout class to the most derived class.
1103 const uint64_t MostDerivedClassOffset;
1104
Anders Carlsson62c6c722010-02-28 00:36:23 +00001105 /// MostDerivedClassIsVirtual - Whether the most derived class is a virtual
1106 /// base. (This only makes sense when building a construction vtable).
1107 bool MostDerivedClassIsVirtual;
1108
Anders Carlsson93913752010-02-27 20:39:05 +00001109 /// LayoutClass - The class we're using for layout information. Will be
1110 /// different than the most derived class if we're building a construction
1111 /// vtable.
1112 const CXXRecordDecl *LayoutClass;
1113
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001114 /// Context - The ASTContext which we will use for layout information.
Anders Carlsson65b49782010-02-12 05:25:12 +00001115 ASTContext &Context;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001116
Anders Carlssone8ac42a2010-02-11 21:24:32 +00001117 /// FinalOverriders - The final overriders of the most derived class.
Anders Carlsson422f7782010-02-25 03:45:56 +00001118 const FinalOverriders Overriders;
Anders Carlssone8ac42a2010-02-11 21:24:32 +00001119
Anders Carlsson9e3b3a32010-02-25 22:23:13 +00001120 /// VCallOffsetsForVBases - Keeps track of vcall offsets for the virtual
1121 /// bases in this vtable.
1122 llvm::DenseMap<const CXXRecordDecl *, VCallOffsetMap> VCallOffsetsForVBases;
Anders Carlsson78277c72010-02-18 17:00:09 +00001123
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001124 typedef llvm::DenseMap<const CXXRecordDecl *, int64_t>
1125 VBaseOffsetOffsetsMapTy;
1126
1127 /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets for
1128 /// the most derived class.
1129 VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
1130
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001131 /// Components - The components of the vtable being built.
1132 llvm::SmallVector<VtableComponent, 64> Components;
1133
Anders Carlsson932c2f22010-02-11 17:18:51 +00001134 /// AddressPoints - Address points for the vtable being built.
1135 CGVtableInfo::AddressPointsMapTy AddressPoints;
1136
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001137 /// ReturnAdjustment - A return adjustment.
Anders Carlsson5272c252010-02-12 17:37:14 +00001138 struct ReturnAdjustment {
1139 /// NonVirtual - The non-virtual adjustment from the derived object to its
1140 /// nearest virtual base.
1141 int64_t NonVirtual;
1142
Anders Carlsson78277c72010-02-18 17:00:09 +00001143 /// VBaseOffsetOffset - The offset (in bytes), relative to the address point
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001144 /// of the virtual base class offset.
1145 int64_t VBaseOffsetOffset;
Anders Carlsson5272c252010-02-12 17:37:14 +00001146
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001147 ReturnAdjustment() : NonVirtual(0), VBaseOffsetOffset(0) { }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001148
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001149 bool isEmpty() const { return !NonVirtual && !VBaseOffsetOffset; }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001150 };
1151
Anders Carlssond46ed892010-02-27 16:18:19 +00001152 /// MethodInfo - Contains information about a method in a vtable.
1153 /// (Used for computing 'this' pointer adjustment thunks.
1154 struct MethodInfo {
1155 /// BaseOffset - The base offset of this method.
1156 const uint64_t BaseOffset;
1157
Anders Carlsson423406f32010-03-10 21:25:37 +00001158 /// BaseOffsetInLayoutClass - The base offset in the layout class of this
1159 /// method.
1160 const uint64_t BaseOffsetInLayoutClass;
1161
Anders Carlssond46ed892010-02-27 16:18:19 +00001162 /// VtableIndex - The index in the vtable that this method has.
1163 /// (For destructors, this is the index of the complete destructor).
1164 const uint64_t VtableIndex;
1165
Anders Carlsson423406f32010-03-10 21:25:37 +00001166 MethodInfo(uint64_t BaseOffset, uint64_t BaseOffsetInLayoutClass,
1167 uint64_t VtableIndex)
1168 : BaseOffset(BaseOffset),
1169 BaseOffsetInLayoutClass(BaseOffsetInLayoutClass),
1170 VtableIndex(VtableIndex) { }
Anders Carlsson40687982010-02-27 16:52:49 +00001171
Anders Carlsson423406f32010-03-10 21:25:37 +00001172 MethodInfo() : BaseOffset(0), BaseOffsetInLayoutClass(0), VtableIndex(0) { }
Anders Carlssond46ed892010-02-27 16:18:19 +00001173 };
1174
1175 typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
1176
1177 /// MethodInfoMap - The information for all methods in the vtable we're
1178 /// currently building.
1179 MethodInfoMapTy MethodInfoMap;
1180
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001181 /// ThisAdjustment - A 'this' pointer adjustment thunk.
1182 struct ThisAdjustment {
1183 /// NonVirtual - The non-virtual adjustment from the derived object to its
1184 /// nearest virtual base.
1185 int64_t NonVirtual;
1186
John McCall43c6ffb2010-02-26 20:22:44 +00001187 /// VCallOffsetOffset - The offset (in bytes), relative to the address point,
Anders Carlsson78277c72010-02-18 17:00:09 +00001188 /// of the virtual call offset.
1189 int64_t VCallOffsetOffset;
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001190
Anders Carlsson78277c72010-02-18 17:00:09 +00001191 ThisAdjustment() : NonVirtual(0), VCallOffsetOffset(0) { }
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001192
Anders Carlsson78277c72010-02-18 17:00:09 +00001193 bool isEmpty() const { return !NonVirtual && !VCallOffsetOffset; }
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001194 };
1195
Anders Carlsson8a240292010-03-12 04:54:20 +00001196 /// ThunkInfo - The 'this' pointer adjustment as well as an optional return
1197 /// adjustment for a thunk.
1198 struct ThunkInfo {
1199 /// This - The 'this' pointer adjustment.
1200 ThisAdjustment This;
1201
1202 /// Return - The return adjustment.
1203 ReturnAdjustment Return;
1204
1205 ThunkInfo() { }
1206
1207 ThunkInfo(const ThisAdjustment &This, const ReturnAdjustment &Return)
1208 : This(This), Return(Return) { }
1209
1210 bool isEmpty() const { return This.isEmpty() && Return.isEmpty(); }
1211 };
1212
1213 typedef llvm::DenseMap<uint64_t, ThunkInfo> ThunksInfoMapTy;
1214
1215 /// Thunks - The thunks by vtable index in the vtable currently being built.
1216 ThunksInfoMapTy Thunks;
Anders Carlssond46ed892010-02-27 16:18:19 +00001217
Anders Carlsson40687982010-02-27 16:52:49 +00001218 /// ComputeThisAdjustments - Compute the 'this' pointer adjustments for the
1219 /// part of the vtable we're currently building.
1220 void ComputeThisAdjustments();
1221
Anders Carlssondc2dba32010-02-16 04:49:44 +00001222 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
1223
Anders Carlssond46ed892010-02-27 16:18:19 +00001224 /// PrimaryVirtualBases - All known virtual bases who are a primary base of
Anders Carlsson0570f712010-02-23 03:48:14 +00001225 /// some other base.
1226 VisitedVirtualBasesSetTy PrimaryVirtualBases;
1227
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001228 /// ComputeReturnAdjustment - Compute the return adjustment given a return
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001229 /// adjustment base offset.
Anders Carlsson075056a2010-02-23 01:34:28 +00001230 ReturnAdjustment ComputeReturnAdjustment(BaseOffset Offset);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001231
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001232 /// ComputeThisAdjustmentBaseOffset - Compute the base offset for adjusting
1233 /// the 'this' pointer from the base subobject to the derived subobject.
1234 BaseOffset ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
1235 BaseSubobject Derived) const;
1236
Anders Carlsson78277c72010-02-18 17:00:09 +00001237 /// ComputeThisAdjustment - Compute the 'this' pointer adjustment for the
1238 /// given virtual member function and the 'this' pointer adjustment base
1239 /// offset.
1240 ThisAdjustment ComputeThisAdjustment(const CXXMethodDecl *MD,
Anders Carlsson075056a2010-02-23 01:34:28 +00001241 BaseOffset Offset);
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001242
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001243 /// AddMethod - Add a single virtual member function to the vtable
1244 /// components vector.
Anders Carlsson40687982010-02-27 16:52:49 +00001245 void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001246
Anders Carlssona8796c62010-02-23 04:26:39 +00001247 /// IsOverriderUsed - Returns whether the overrider will ever be used in this
1248 /// part of the vtable.
1249 ///
1250 /// Itanium C++ ABI 2.5.2:
1251 ///
1252 /// struct A { virtual void f(); };
1253 /// struct B : virtual public A { int i; };
1254 /// struct C : virtual public A { int j; };
1255 /// struct D : public B, public C {};
1256 ///
1257 /// When B and C are declared, A is a primary base in each case, so although
1258 /// vcall offsets are allocated in the A-in-B and A-in-C vtables, no this
1259 /// adjustment is required and no thunk is generated. However, inside D
1260 /// objects, A is no longer a primary base of C, so if we allowed calls to
1261 /// C::f() to use the copy of A's vtable in the C subobject, we would need
1262 /// to adjust this from C* to B::A*, which would require a third-party
1263 /// thunk. Since we require that a call to C::f() first convert to A*,
1264 /// C-in-D's copy of A's vtable is never referenced, so this is not
1265 /// necessary.
Anders Carlsson804cf512010-03-10 06:51:42 +00001266 bool IsOverriderUsed(const CXXMethodDecl *Overrider,
1267 uint64_t BaseOffsetInLayoutClass,
1268 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1269 uint64_t FirstBaseOffsetInLayoutClass) const;
1270
Anders Carlssona8796c62010-02-23 04:26:39 +00001271
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001272 /// AddMethods - Add the methods of this base subobject and all its
1273 /// primary bases to the vtable components vector.
Anders Carlsson804cf512010-03-10 06:51:42 +00001274 void AddMethods(BaseSubobject Base, uint64_t BaseOffsetInLayoutClass,
1275 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1276 uint64_t FirstBaseOffsetInLayoutClass,
Anders Carlssond46ed892010-02-27 16:18:19 +00001277 PrimaryBasesSetVectorTy &PrimaryBases);
Anders Carlssonb716a542010-02-16 16:26:28 +00001278
Anders Carlsson62c6c722010-02-28 00:36:23 +00001279 // LayoutVtable - Layout the vtable for the given base class, including its
Anders Carlssonb716a542010-02-16 16:26:28 +00001280 // secondary vtables and any vtables for virtual bases.
1281 void LayoutVtable();
1282
Anders Carlssone3385f52010-02-28 01:43:58 +00001283 /// LayoutPrimaryAndSecondaryVtables - Layout the primary vtable for the
Anders Carlssonb716a542010-02-16 16:26:28 +00001284 /// given base subobject, as well as all its secondary vtables.
Anders Carlssone3385f52010-02-28 01:43:58 +00001285 void LayoutPrimaryAndSecondaryVtables(BaseSubobject Base,
1286 bool BaseIsVirtual,
1287 uint64_t OffsetInLayoutClass);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001288
Anders Carlsson14157932010-02-16 16:02:57 +00001289 /// LayoutSecondaryVtables - Layout the secondary vtables for the given base
1290 /// subobject.
Anders Carlsson115b4752010-03-10 19:39:11 +00001291 ///
1292 /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
1293 /// or a direct or indirect base of a virtual base.
1294 void LayoutSecondaryVtables(BaseSubobject Base, bool BaseIsMorallyVirtual,
1295 uint64_t OffsetInLayoutClass);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001296
1297 /// DeterminePrimaryVirtualBases - Determine the primary virtual bases in this
1298 /// class hierarchy.
1299 void DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
Anders Carlsson02b99d62010-03-10 03:02:01 +00001300 uint64_t OffsetInLayoutClass,
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001301 VisitedVirtualBasesSetTy &VBases);
1302
Anders Carlsson13f0f662010-02-16 16:49:35 +00001303 /// LayoutVtablesForVirtualBases - Layout vtables for all virtual bases of the
1304 /// given base (excluding any primary bases).
1305 void LayoutVtablesForVirtualBases(const CXXRecordDecl *RD,
1306 VisitedVirtualBasesSetTy &VBases);
1307
Anders Carlsson31f595f2010-02-28 00:10:58 +00001308 /// isBuildingConstructionVtable - Return whether this vtable builder is
1309 /// building a construction vtable.
1310 bool isBuildingConstructorVtable() const {
1311 return MostDerivedClass != LayoutClass;
1312 }
1313
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001314public:
Anders Carlsson93913752010-02-27 20:39:05 +00001315 VtableBuilder(CGVtableInfo &VtableInfo, const CXXRecordDecl *MostDerivedClass,
Anders Carlsson62c6c722010-02-28 00:36:23 +00001316 uint64_t MostDerivedClassOffset, bool MostDerivedClassIsVirtual,
Anders Carlsson93913752010-02-27 20:39:05 +00001317 const CXXRecordDecl *LayoutClass)
1318 : VtableInfo(VtableInfo), MostDerivedClass(MostDerivedClass),
Anders Carlsson62c6c722010-02-28 00:36:23 +00001319 MostDerivedClassOffset(MostDerivedClassOffset),
1320 MostDerivedClassIsVirtual(MostDerivedClassIsVirtual),
1321 LayoutClass(LayoutClass), Context(MostDerivedClass->getASTContext()),
Anders Carlssonca82a4f2010-03-10 02:33:41 +00001322 Overriders(MostDerivedClass, MostDerivedClassOffset, LayoutClass) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001323
Anders Carlssonb716a542010-02-16 16:26:28 +00001324 LayoutVtable();
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001325 }
1326
1327 /// dumpLayout - Dump the vtable layout.
1328 void dumpLayout(llvm::raw_ostream&);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001329};
1330
Anders Carlssond2025412010-02-27 06:38:03 +00001331/// OverridesMethodInBases - Checks whether whether this virtual member
1332/// function overrides a member function in any of the given bases.
Anders Carlsson65b49782010-02-12 05:25:12 +00001333/// Returns the overridden member function, or null if none was found.
1334static const CXXMethodDecl *
Anders Carlssond2025412010-02-27 06:38:03 +00001335OverridesMethodInBases(const CXXMethodDecl *MD,
Anders Carlssond46ed892010-02-27 16:18:19 +00001336 VtableBuilder::PrimaryBasesSetVectorTy &Bases) {
Anders Carlsson65b49782010-02-12 05:25:12 +00001337 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1338 E = MD->end_overridden_methods(); I != E; ++I) {
1339 const CXXMethodDecl *OverriddenMD = *I;
1340 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
1341 assert(OverriddenMD->isCanonicalDecl() &&
1342 "Should have the canonical decl of the overridden RD!");
1343
Anders Carlssond2025412010-02-27 06:38:03 +00001344 if (Bases.count(OverriddenRD))
Anders Carlsson65b49782010-02-12 05:25:12 +00001345 return OverriddenMD;
1346 }
1347
1348 return 0;
1349}
1350
Anders Carlsson40687982010-02-27 16:52:49 +00001351void VtableBuilder::ComputeThisAdjustments() {
1352 // Now go through the method info map and see if any of the methods need
1353 // 'this' pointer adjustments.
1354 for (MethodInfoMapTy::const_iterator I = MethodInfoMap.begin(),
1355 E = MethodInfoMap.end(); I != E; ++I) {
1356 const CXXMethodDecl *MD = I->first;
1357 const MethodInfo &MethodInfo = I->second;
1358
Anders Carlsson40687982010-02-27 16:52:49 +00001359 // Get the final overrider for this method.
1360 FinalOverriders::OverriderInfo Overrider =
Anders Carlsson423406f32010-03-10 21:25:37 +00001361 Overriders.getOverrider(BaseSubobject(MD->getParent(),
1362 MethodInfo.BaseOffset), MD);
Anders Carlsson40687982010-02-27 16:52:49 +00001363
1364 // Check if we need an adjustment.
Anders Carlsson423406f32010-03-10 21:25:37 +00001365 if (Overrider.Offset == MethodInfo.BaseOffsetInLayoutClass)
Anders Carlsson40687982010-02-27 16:52:49 +00001366 continue;
1367
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001368 uint64_t VtableIndex = MethodInfo.VtableIndex;
Anders Carlsson2b381bb2010-02-27 18:16:50 +00001369
1370 // Ignore adjustments for pure virtual member functions.
1371 if (Overrider.Method->isPure())
1372 continue;
1373
1374 // Ignore adjustments for unused function pointers.
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001375 if (Components[VtableIndex].getKind() ==
1376 VtableComponent::CK_UnusedFunctionPointer)
1377 continue;
1378
Anders Carlsson423406f32010-03-10 21:25:37 +00001379 BaseSubobject OverriddenBaseSubobject(MD->getParent(),
1380 MethodInfo.BaseOffsetInLayoutClass);
1381
Anders Carlsson40687982010-02-27 16:52:49 +00001382 BaseSubobject OverriderBaseSubobject(Overrider.Method->getParent(),
Anders Carlsson423406f32010-03-10 21:25:37 +00001383 Overrider.Offset);
Anders Carlsson40687982010-02-27 16:52:49 +00001384
1385 // Compute the adjustment offset.
1386 BaseOffset ThisAdjustmentOffset =
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001387 ComputeThisAdjustmentBaseOffset(OverriddenBaseSubobject,
1388 OverriderBaseSubobject);
1389
Anders Carlsson40687982010-02-27 16:52:49 +00001390 // Then compute the adjustment itself.
1391 ThisAdjustment ThisAdjustment = ComputeThisAdjustment(Overrider.Method,
1392 ThisAdjustmentOffset);
1393
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001394 // Add it.
Anders Carlsson8a240292010-03-12 04:54:20 +00001395 Thunks[VtableIndex].This = ThisAdjustment;
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001396
Anders Carlsson40687982010-02-27 16:52:49 +00001397 if (isa<CXXDestructorDecl>(MD)) {
1398 // Add an adjustment for the deleting destructor as well.
Anders Carlsson8a240292010-03-12 04:54:20 +00001399 Thunks[VtableIndex + 1].This = ThisAdjustment;
Anders Carlsson40687982010-02-27 16:52:49 +00001400 }
1401 }
1402
1403 /// Clear the method info map.
1404 MethodInfoMap.clear();
1405}
1406
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001407VtableBuilder::ReturnAdjustment
Anders Carlsson075056a2010-02-23 01:34:28 +00001408VtableBuilder::ComputeReturnAdjustment(BaseOffset Offset) {
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001409 ReturnAdjustment Adjustment;
1410
1411 if (!Offset.isEmpty()) {
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001412 if (Offset.VirtualBase) {
1413 // Get the virtual base offset offset.
Anders Carlssone4424882010-03-11 07:00:45 +00001414 if (Offset.DerivedClass == MostDerivedClass) {
1415 // We can get the offset offset directly from our map.
1416 Adjustment.VBaseOffsetOffset =
1417 VBaseOffsetOffsets.lookup(Offset.VirtualBase);
1418 } else {
1419 Adjustment.VBaseOffsetOffset =
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00001420 VtableInfo.getVirtualBaseOffsetOffset(Offset.DerivedClass,
1421 Offset.VirtualBase);
Anders Carlssone4424882010-03-11 07:00:45 +00001422 }
1423
Anders Carlssondd819c92010-03-11 16:06:20 +00001424 // FIXME: Once the assert in getVirtualBaseOffsetOffset is back again,
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001425 // we can get rid of this assert.
1426 assert(Adjustment.VBaseOffsetOffset != 0 &&
Anders Carlssondd819c92010-03-11 16:06:20 +00001427 "Invalid vbase offset offset!");
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001428 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001429
1430 Adjustment.NonVirtual = Offset.NonVirtualOffset;
1431 }
1432
1433 return Adjustment;
1434}
1435
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001436BaseOffset
1437VtableBuilder::ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
1438 BaseSubobject Derived) const {
1439 const CXXRecordDecl *BaseRD = Base.getBase();
1440 const CXXRecordDecl *DerivedRD = Derived.getBase();
1441
1442 CXXBasePaths Paths(/*FindAmbiguities=*/true,
1443 /*RecordPaths=*/true, /*DetectVirtual=*/true);
1444
1445 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
1446 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
1447 assert(false && "Class must be derived from the passed in base class!");
1448 return BaseOffset();
1449 }
1450
1451 // We have to go through all the paths, and see which one leads us to the
1452 // right base subobject.
1453 for (CXXBasePaths::const_paths_iterator I = Paths.begin(), E = Paths.end();
1454 I != E; ++I) {
1455 BaseOffset Offset = ComputeBaseOffset(Context, DerivedRD, *I);
1456
1457 // FIXME: Should not use * 8 here.
1458 uint64_t OffsetToBaseSubobject = Offset.NonVirtualOffset * 8;
1459
1460 if (Offset.VirtualBase) {
1461 // If we have a virtual base class, the non-virtual offset is relative
1462 // to the virtual base class offset.
Anders Carlsson423406f32010-03-10 21:25:37 +00001463 const ASTRecordLayout &LayoutClassLayout =
1464 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001465
1466 /// Get the virtual base offset, relative to the most derived class
1467 /// layout.
1468 OffsetToBaseSubobject +=
Anders Carlsson423406f32010-03-10 21:25:37 +00001469 LayoutClassLayout.getVBaseClassOffset(Offset.VirtualBase);
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001470 } else {
1471 // Otherwise, the non-virtual offset is relative to the derived class
1472 // offset.
1473 OffsetToBaseSubobject += Derived.getBaseOffset();
1474 }
1475
1476 // Check if this path gives us the right base subobject.
1477 if (OffsetToBaseSubobject == Base.getBaseOffset()) {
1478 // Since we're going from the base class _to_ the derived class, we'll
1479 // invert the non-virtual offset here.
1480 Offset.NonVirtualOffset = -Offset.NonVirtualOffset;
1481 return Offset;
1482 }
1483 }
1484
1485 return BaseOffset();
1486}
1487
1488
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001489VtableBuilder::ThisAdjustment
Anders Carlsson78277c72010-02-18 17:00:09 +00001490VtableBuilder::ComputeThisAdjustment(const CXXMethodDecl *MD,
Anders Carlsson075056a2010-02-23 01:34:28 +00001491 BaseOffset Offset) {
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001492 ThisAdjustment Adjustment;
1493
1494 if (!Offset.isEmpty()) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001495 if (Offset.VirtualBase) {
Anders Carlsson9e3b3a32010-02-25 22:23:13 +00001496 // Get the vcall offset map for this virtual base.
1497 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Offset.VirtualBase];
1498
1499 if (VCallOffsets.empty()) {
1500 // We don't have vcall offsets for this virtual base, go ahead and
1501 // build them.
Anders Carlssone3385f52010-02-28 01:43:58 +00001502 VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, MostDerivedClass,
1503 /*FinalOverriders=*/0,
1504 BaseSubobject(Offset.VirtualBase, 0),
1505 /*BaseIsVirtual=*/true,
1506 /*OffsetInLayoutClass=*/0);
Anders Carlsson9e3b3a32010-02-25 22:23:13 +00001507
1508 VCallOffsets = Builder.getVCallOffsets();
1509 }
1510
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001511 Adjustment.VCallOffsetOffset = VCallOffsets.getVCallOffsetOffset(MD);
1512 }
1513
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001514 Adjustment.NonVirtual = Offset.NonVirtualOffset;
1515 }
1516
1517 return Adjustment;
1518}
1519
Anders Carlsson65b49782010-02-12 05:25:12 +00001520void
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001521VtableBuilder::AddMethod(const CXXMethodDecl *MD,
Anders Carlsson40687982010-02-27 16:52:49 +00001522 ReturnAdjustment ReturnAdjustment) {
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001523 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1524 assert(ReturnAdjustment.isEmpty() &&
1525 "Destructor can't have return adjustment!");
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001526
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001527 // Add both the complete destructor and the deleting destructor.
1528 Components.push_back(VtableComponent::MakeCompleteDtor(DD));
1529 Components.push_back(VtableComponent::MakeDeletingDtor(DD));
1530 } else {
1531 // Add the return adjustment if necessary.
1532 if (!ReturnAdjustment.isEmpty())
Anders Carlsson8a240292010-03-12 04:54:20 +00001533 Thunks[Components.size()].Return = ReturnAdjustment;
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001534
1535 // Add the function.
1536 Components.push_back(VtableComponent::MakeFunction(MD));
1537 }
1538}
1539
Anders Carlssond2025412010-02-27 06:38:03 +00001540/// OverridesIndirectMethodInBase - Return whether the given member function
1541/// overrides any methods in the set of given bases.
1542/// Unlike OverridesMethodInBase, this checks "overriders of overriders".
1543/// For example, if we have:
1544///
1545/// struct A { virtual void f(); }
1546/// struct B : A { virtual void f(); }
1547/// struct C : B { virtual void f(); }
1548///
1549/// OverridesIndirectMethodInBase will return true if given C::f as the method
1550/// and { A } as the set of bases.
1551static bool
1552OverridesIndirectMethodInBases(const CXXMethodDecl *MD,
Anders Carlssond46ed892010-02-27 16:18:19 +00001553 VtableBuilder::PrimaryBasesSetVectorTy &Bases) {
Anders Carlssond2025412010-02-27 06:38:03 +00001554 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1555 E = MD->end_overridden_methods(); I != E; ++I) {
1556 const CXXMethodDecl *OverriddenMD = *I;
1557 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
1558 assert(OverriddenMD->isCanonicalDecl() &&
1559 "Should have the canonical decl of the overridden RD!");
1560
1561 if (Bases.count(OverriddenRD))
1562 return true;
1563
1564 // Check "indirect overriders".
1565 if (OverridesIndirectMethodInBases(OverriddenMD, Bases))
1566 return true;
1567 }
1568
1569 return false;
1570}
1571
Anders Carlssona8796c62010-02-23 04:26:39 +00001572bool
Anders Carlsson804cf512010-03-10 06:51:42 +00001573VtableBuilder::IsOverriderUsed(const CXXMethodDecl *Overrider,
1574 uint64_t BaseOffsetInLayoutClass,
1575 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1576 uint64_t FirstBaseOffsetInLayoutClass) const {
Anders Carlssona8796c62010-02-23 04:26:39 +00001577 // If the base and the first base in the primary base chain have the same
1578 // offsets, then this overrider will be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001579 if (BaseOffsetInLayoutClass == FirstBaseOffsetInLayoutClass)
Anders Carlsson8939e402010-02-23 06:34:44 +00001580 return true;
1581
1582 // We know now that Base (or a direct or indirect base of it) is a primary
1583 // base in part of the class hierarchy, but not a primary base in the most
1584 // derived class.
1585
1586 // If the overrider is the first base in the primary base chain, we know
1587 // that the overrider will be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001588 if (Overrider->getParent() == FirstBaseInPrimaryBaseChain)
Anders Carlssona8796c62010-02-23 04:26:39 +00001589 return true;
1590
Anders Carlssond46ed892010-02-27 16:18:19 +00001591 VtableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlsson8939e402010-02-23 06:34:44 +00001592
Anders Carlsson804cf512010-03-10 06:51:42 +00001593 const CXXRecordDecl *RD = FirstBaseInPrimaryBaseChain;
Anders Carlsson8939e402010-02-23 06:34:44 +00001594 PrimaryBases.insert(RD);
1595
1596 // Now traverse the base chain, starting with the first base, until we find
1597 // the base that is no longer a primary base.
1598 while (true) {
1599 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1600 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1601
1602 if (!PrimaryBase)
1603 break;
1604
1605 if (Layout.getPrimaryBaseWasVirtual()) {
1606 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1607 "Primary base should always be at offset 0!");
1608
Anders Carlsson7162ab92010-02-28 18:37:33 +00001609 const ASTRecordLayout &LayoutClassLayout =
1610 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson8939e402010-02-23 06:34:44 +00001611
1612 // Now check if this is the primary base that is not a primary base in the
1613 // most derived class.
Anders Carlsson7162ab92010-02-28 18:37:33 +00001614 if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) !=
Anders Carlsson804cf512010-03-10 06:51:42 +00001615 FirstBaseOffsetInLayoutClass) {
Anders Carlsson8939e402010-02-23 06:34:44 +00001616 // We found it, stop walking the chain.
1617 break;
1618 }
1619 } else {
1620 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1621 "Primary base should always be at offset 0!");
1622 }
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001623
Anders Carlssonb26c2ab2010-02-27 19:51:04 +00001624 if (!PrimaryBases.insert(PrimaryBase))
1625 assert(false && "Found a duplicate primary base!");
1626
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001627 RD = PrimaryBase;
Anders Carlsson8939e402010-02-23 06:34:44 +00001628 }
1629
1630 // If the final overrider is an override of one of the primary bases,
1631 // then we know that it will be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001632 return OverridesIndirectMethodInBases(Overrider, PrimaryBases);
Anders Carlssona8796c62010-02-23 04:26:39 +00001633}
1634
Anders Carlsson40687982010-02-27 16:52:49 +00001635/// FindNearestOverriddenMethod - Given a method, returns the overridden method
1636/// from the nearest base. Returns null if no method was found.
1637static const CXXMethodDecl *
1638FindNearestOverriddenMethod(const CXXMethodDecl *MD,
1639 VtableBuilder::PrimaryBasesSetVectorTy &Bases) {
1640 for (int I = Bases.size(), E = 0; I != E; --I) {
1641 const CXXRecordDecl *PrimaryBase = Bases[I - 1];
1642
1643 // Now check the overriden methods.
1644 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1645 E = MD->end_overridden_methods(); I != E; ++I) {
1646 const CXXMethodDecl *OverriddenMD = *I;
1647
1648 // We found our overridden method.
1649 if (OverriddenMD->getParent() == PrimaryBase)
1650 return OverriddenMD;
1651 }
1652 }
1653
1654 return 0;
1655}
1656
Anders Carlsson804cf512010-03-10 06:51:42 +00001657void
1658VtableBuilder::AddMethods(BaseSubobject Base, uint64_t BaseOffsetInLayoutClass,
1659 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1660 uint64_t FirstBaseOffsetInLayoutClass,
Anders Carlssond46ed892010-02-27 16:18:19 +00001661 PrimaryBasesSetVectorTy &PrimaryBases) {
Anders Carlsson65b49782010-02-12 05:25:12 +00001662 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson65b49782010-02-12 05:25:12 +00001663 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1664
1665 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson804cf512010-03-10 06:51:42 +00001666 uint64_t PrimaryBaseOffset;
1667 uint64_t PrimaryBaseOffsetInLayoutClass;
Anders Carlsson0570f712010-02-23 03:48:14 +00001668 if (Layout.getPrimaryBaseWasVirtual()) {
1669 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1670 "Primary vbase should have a zero offset!");
1671
1672 const ASTRecordLayout &MostDerivedClassLayout =
1673 Context.getASTRecordLayout(MostDerivedClass);
1674
Anders Carlsson804cf512010-03-10 06:51:42 +00001675 PrimaryBaseOffset =
1676 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
1677
1678 const ASTRecordLayout &LayoutClassLayout =
1679 Context.getASTRecordLayout(LayoutClass);
1680
1681 PrimaryBaseOffsetInLayoutClass =
1682 LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
Anders Carlsson0570f712010-02-23 03:48:14 +00001683 } else {
Anders Carlsson65b49782010-02-12 05:25:12 +00001684 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1685 "Primary base should have a zero offset!");
Anders Carlsson0570f712010-02-23 03:48:14 +00001686
Anders Carlsson804cf512010-03-10 06:51:42 +00001687 PrimaryBaseOffset = Base.getBaseOffset();
1688 PrimaryBaseOffsetInLayoutClass = BaseOffsetInLayoutClass;
Anders Carlsson0570f712010-02-23 03:48:14 +00001689 }
Anders Carlsson7162ab92010-02-28 18:37:33 +00001690
Anders Carlsson804cf512010-03-10 06:51:42 +00001691 AddMethods(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
1692 PrimaryBaseOffsetInLayoutClass, FirstBaseInPrimaryBaseChain,
1693 FirstBaseOffsetInLayoutClass, PrimaryBases);
Anders Carlsson65b49782010-02-12 05:25:12 +00001694
1695 if (!PrimaryBases.insert(PrimaryBase))
1696 assert(false && "Found a duplicate primary base!");
1697 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00001698
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001699 // Now go through all virtual member functions and add them.
1700 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1701 E = RD->method_end(); I != E; ++I) {
1702 const CXXMethodDecl *MD = *I;
Anders Carlsson65b49782010-02-12 05:25:12 +00001703
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001704 if (!MD->isVirtual())
1705 continue;
Anders Carlsson65b49782010-02-12 05:25:12 +00001706
1707 // Get the final overrider.
Anders Carlsson136bd192010-02-12 16:55:34 +00001708 FinalOverriders::OverriderInfo Overrider =
1709 Overriders.getOverrider(Base, MD);
Anders Carlsson65b49782010-02-12 05:25:12 +00001710
1711 // Check if this virtual member function overrides a method in a primary
1712 // base. If this is the case, and the return type doesn't require adjustment
1713 // then we can just use the member function from the primary base.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001714 if (const CXXMethodDecl *OverriddenMD =
Anders Carlsson40687982010-02-27 16:52:49 +00001715 FindNearestOverriddenMethod(MD, PrimaryBases)) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +00001716 if (ComputeReturnAdjustmentBaseOffset(Context, MD,
Anders Carlsson40687982010-02-27 16:52:49 +00001717 OverriddenMD).isEmpty()) {
1718 // Replace the method info of the overridden method with our own
1719 // method.
1720 assert(MethodInfoMap.count(OverriddenMD) &&
1721 "Did not find the overridden method!");
1722 MethodInfo &OverriddenMethodInfo = MethodInfoMap[OverriddenMD];
1723
1724 MethodInfo MethodInfo(Base.getBaseOffset(),
Anders Carlsson423406f32010-03-10 21:25:37 +00001725 BaseOffsetInLayoutClass,
Anders Carlsson40687982010-02-27 16:52:49 +00001726 OverriddenMethodInfo.VtableIndex);
1727
1728 assert(!MethodInfoMap.count(MD) &&
1729 "Should not have method info for this method yet!");
1730
1731 MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
1732 MethodInfoMap.erase(OverriddenMD);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001733 continue;
Anders Carlsson40687982010-02-27 16:52:49 +00001734 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001735 }
Anders Carlssoneee53d92010-02-13 02:02:03 +00001736
Anders Carlsson40687982010-02-27 16:52:49 +00001737 // Insert the method info for this method.
Anders Carlsson423406f32010-03-10 21:25:37 +00001738 MethodInfo MethodInfo(Base.getBaseOffset(), BaseOffsetInLayoutClass,
1739 Components.size());
Anders Carlsson40687982010-02-27 16:52:49 +00001740
1741 assert(!MethodInfoMap.count(MD) &&
1742 "Should not have method info for this method yet!");
1743 MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001744
1745 // Check if this overrider is going to be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001746 const CXXMethodDecl *OverriderMD = Overrider.Method;
1747 if (!IsOverriderUsed(OverriderMD, BaseOffsetInLayoutClass,
1748 FirstBaseInPrimaryBaseChain,
1749 FirstBaseOffsetInLayoutClass)) {
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001750 Components.push_back(VtableComponent::MakeUnusedFunction(OverriderMD));
1751 continue;
1752 }
Anders Carlssona8796c62010-02-23 04:26:39 +00001753
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001754 // Check if this overrider needs a return adjustment.
Anders Carlsson075056a2010-02-23 01:34:28 +00001755 BaseOffset ReturnAdjustmentOffset =
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001756 Overriders.getReturnAdjustmentOffset(Base, MD);
1757
1758 ReturnAdjustment ReturnAdjustment =
1759 ComputeReturnAdjustment(ReturnAdjustmentOffset);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001760
Anders Carlsson40687982010-02-27 16:52:49 +00001761 AddMethod(Overrider.Method, ReturnAdjustment);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001762 }
1763}
1764
Anders Carlssonb716a542010-02-16 16:26:28 +00001765void VtableBuilder::LayoutVtable() {
Anders Carlssone3385f52010-02-28 01:43:58 +00001766 LayoutPrimaryAndSecondaryVtables(BaseSubobject(MostDerivedClass, 0),
1767 MostDerivedClassIsVirtual,
1768 MostDerivedClassOffset);
Anders Carlssonb716a542010-02-16 16:26:28 +00001769
Anders Carlsson13f0f662010-02-16 16:49:35 +00001770 VisitedVirtualBasesSetTy VBases;
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001771
1772 // Determine the primary virtual bases.
Anders Carlsson02b99d62010-03-10 03:02:01 +00001773 DeterminePrimaryVirtualBases(MostDerivedClass, MostDerivedClassOffset,
1774 VBases);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001775 VBases.clear();
1776
Anders Carlsson13f0f662010-02-16 16:49:35 +00001777 LayoutVtablesForVirtualBases(MostDerivedClass, VBases);
Anders Carlssonb716a542010-02-16 16:26:28 +00001778}
1779
Anders Carlssone3385f52010-02-28 01:43:58 +00001780void
1781VtableBuilder::LayoutPrimaryAndSecondaryVtables(BaseSubobject Base,
1782 bool BaseIsVirtual,
1783 uint64_t OffsetInLayoutClass) {
Chris Lattnerd2408f72010-02-17 21:42:34 +00001784 assert(Base.getBase()->isDynamicClass() && "class does not have a vtable!");
Anders Carlsson033d4862010-02-14 17:05:59 +00001785
Anders Carlsson77904f12010-02-16 04:59:55 +00001786 // Add vcall and vbase offsets for this vtable.
Anders Carlssone3385f52010-02-28 01:43:58 +00001787 VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, LayoutClass, &Overriders,
1788 Base, BaseIsVirtual, OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +00001789 Components.append(Builder.components_begin(), Builder.components_end());
1790
Anders Carlsson9e3b3a32010-02-25 22:23:13 +00001791 // Check if we need to add these vcall offsets.
1792 if (BaseIsVirtual && !Builder.getVCallOffsets().empty()) {
1793 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Base.getBase()];
1794
1795 if (VCallOffsets.empty())
1796 VCallOffsets = Builder.getVCallOffsets();
1797 }
1798
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001799 // If we're laying out the most derived class we want to keep track of the
1800 // virtual base class offset offsets.
1801 if (Base.getBase() == MostDerivedClass)
1802 VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets();
1803
Anders Carlsson77904f12010-02-16 04:59:55 +00001804 // Add the offset to top.
Anders Carlsson258a1e32010-02-14 00:16:19 +00001805 // FIXME: We should not use / 8 here.
Anders Carlssone3385f52010-02-28 01:43:58 +00001806 int64_t OffsetToTop = -(int64_t)(OffsetInLayoutClass -
1807 MostDerivedClassOffset) / 8;
Anders Carlssone75aaa92010-02-13 22:05:23 +00001808 Components.push_back(VtableComponent::MakeOffsetToTop(OffsetToTop));
Anders Carlsson65b49782010-02-12 05:25:12 +00001809
1810 // Next, add the RTTI.
Anders Carlssone75aaa92010-02-13 22:05:23 +00001811 Components.push_back(VtableComponent::MakeRTTI(MostDerivedClass));
Anders Carlsson65b49782010-02-12 05:25:12 +00001812
Anders Carlssone8a97562010-02-12 07:43:48 +00001813 uint64_t AddressPoint = Components.size();
Anders Carlsson65b49782010-02-12 05:25:12 +00001814
1815 // Now go through all virtual member functions and add them.
Anders Carlssond46ed892010-02-27 16:18:19 +00001816 PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlsson804cf512010-03-10 06:51:42 +00001817 AddMethods(Base, OffsetInLayoutClass, Base.getBase(), OffsetInLayoutClass,
1818 PrimaryBases);
Anders Carlsson65b49782010-02-12 05:25:12 +00001819
Anders Carlsson40687982010-02-27 16:52:49 +00001820 // Compute 'this' pointer adjustments.
1821 ComputeThisAdjustments();
1822
Anders Carlssone8a97562010-02-12 07:43:48 +00001823 // Record the address point.
Anders Carlssone3385f52010-02-28 01:43:58 +00001824 AddressPoints.insert(std::make_pair(BaseSubobject(Base.getBase(),
1825 OffsetInLayoutClass),
1826 AddressPoint));
Anders Carlssone8a97562010-02-12 07:43:48 +00001827
1828 // Record the address points for all primary bases.
Anders Carlssond46ed892010-02-27 16:18:19 +00001829 for (PrimaryBasesSetVectorTy::const_iterator I = PrimaryBases.begin(),
Anders Carlssone8a97562010-02-12 07:43:48 +00001830 E = PrimaryBases.end(); I != E; ++I) {
1831 const CXXRecordDecl *BaseDecl = *I;
1832
1833 // We know that all the primary bases have the same offset as the base
1834 // subobject.
Anders Carlssone3385f52010-02-28 01:43:58 +00001835 BaseSubobject PrimaryBase(BaseDecl, OffsetInLayoutClass);
Anders Carlssone8a97562010-02-12 07:43:48 +00001836 AddressPoints.insert(std::make_pair(PrimaryBase, AddressPoint));
1837 }
1838
Anders Carlsson115b4752010-03-10 19:39:11 +00001839 bool BaseIsMorallyVirtual = BaseIsVirtual;
1840 if (isBuildingConstructorVtable() && Base.getBase() == MostDerivedClass)
1841 BaseIsMorallyVirtual = false;
1842
Anders Carlssona9f633b2010-02-24 16:43:12 +00001843 // Layout secondary vtables.
Anders Carlsson115b4752010-03-10 19:39:11 +00001844 LayoutSecondaryVtables(Base, BaseIsMorallyVirtual, OffsetInLayoutClass);
Anders Carlsson14157932010-02-16 16:02:57 +00001845}
1846
Anders Carlssone3385f52010-02-28 01:43:58 +00001847void VtableBuilder::LayoutSecondaryVtables(BaseSubobject Base,
Anders Carlsson115b4752010-03-10 19:39:11 +00001848 bool BaseIsMorallyVirtual,
Anders Carlssone3385f52010-02-28 01:43:58 +00001849 uint64_t OffsetInLayoutClass) {
Anders Carlsson14157932010-02-16 16:02:57 +00001850 // Itanium C++ ABI 2.5.2:
1851 // Following the primary virtual table of a derived class are secondary
1852 // virtual tables for each of its proper base classes, except any primary
1853 // base(s) with which it shares its primary virtual table.
1854
1855 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson65b49782010-02-12 05:25:12 +00001856 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1857 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
Anders Carlsson14157932010-02-16 16:02:57 +00001858
Anders Carlsson65b49782010-02-12 05:25:12 +00001859 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1860 E = RD->bases_end(); I != E; ++I) {
Anders Carlsson14157932010-02-16 16:02:57 +00001861 // Ignore virtual bases, we'll emit them later.
1862 if (I->isVirtual())
1863 continue;
1864
Anders Carlsson65b49782010-02-12 05:25:12 +00001865 const CXXRecordDecl *BaseDecl =
1866 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson033d4862010-02-14 17:05:59 +00001867
Anders Carlssondc2dba32010-02-16 04:49:44 +00001868 // Ignore bases that don't have a vtable.
1869 if (!BaseDecl->isDynamicClass())
1870 continue;
Anders Carlsson033d4862010-02-14 17:05:59 +00001871
Anders Carlsson703a0862010-03-10 19:15:26 +00001872 if (isBuildingConstructorVtable()) {
1873 // Itanium C++ ABI 2.6.4:
1874 // Some of the base class subobjects may not need construction virtual
1875 // tables, which will therefore not be present in the construction
1876 // virtual table group, even though the subobject virtual tables are
1877 // present in the main virtual table group for the complete object.
Anders Carlsson115b4752010-03-10 19:39:11 +00001878 if (!BaseIsMorallyVirtual && !BaseDecl->getNumVBases())
Anders Carlsson703a0862010-03-10 19:15:26 +00001879 continue;
Anders Carlsson703a0862010-03-10 19:15:26 +00001880 }
1881
Anders Carlssone75aaa92010-02-13 22:05:23 +00001882 // Get the base offset of this base.
Anders Carlssone3385f52010-02-28 01:43:58 +00001883 uint64_t RelativeBaseOffset = Layout.getBaseClassOffset(BaseDecl);
1884 uint64_t BaseOffset = Base.getBaseOffset() + RelativeBaseOffset;
1885
1886 uint64_t BaseOffsetInLayoutClass = OffsetInLayoutClass + RelativeBaseOffset;
Anders Carlsson14157932010-02-16 16:02:57 +00001887
1888 // Don't emit a secondary vtable for a primary base. We might however want
1889 // to emit secondary vtables for other bases of this base.
1890 if (BaseDecl == PrimaryBase) {
Anders Carlssone3385f52010-02-28 01:43:58 +00001891 LayoutSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
Anders Carlsson115b4752010-03-10 19:39:11 +00001892 BaseIsMorallyVirtual, BaseOffsetInLayoutClass);
Anders Carlsson14157932010-02-16 16:02:57 +00001893 continue;
1894 }
Anders Carlssone75aaa92010-02-13 22:05:23 +00001895
Anders Carlssonb716a542010-02-16 16:26:28 +00001896 // Layout the primary vtable (and any secondary vtables) for this base.
Anders Carlssone3385f52010-02-28 01:43:58 +00001897 LayoutPrimaryAndSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
1898 /*BaseIsVirtual=*/false,
1899 BaseOffsetInLayoutClass);
Anders Carlsson65b49782010-02-12 05:25:12 +00001900 }
1901}
1902
Anders Carlsson13f0f662010-02-16 16:49:35 +00001903void
Anders Carlsson02b99d62010-03-10 03:02:01 +00001904VtableBuilder::DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
1905 uint64_t OffsetInLayoutClass,
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001906 VisitedVirtualBasesSetTy &VBases) {
1907 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1908
1909 // Check if this base has a primary base.
1910 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson8b37bb72010-02-28 18:08:38 +00001911
1912 // Check if it's virtual.
1913 if (Layout.getPrimaryBaseWasVirtual()) {
1914 bool IsPrimaryVirtualBase = true;
1915
1916 if (isBuildingConstructorVtable()) {
1917 // Check if the base is actually a primary base in the class we use for
1918 // layout.
Anders Carlsson02b99d62010-03-10 03:02:01 +00001919 const ASTRecordLayout &LayoutClassLayout =
1920 Context.getASTRecordLayout(LayoutClass);
1921
1922 uint64_t PrimaryBaseOffsetInLayoutClass =
1923 LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
1924
1925 // We know that the base is not a primary base in the layout class if
1926 // the base offsets are different.
1927 if (PrimaryBaseOffsetInLayoutClass != OffsetInLayoutClass)
Anders Carlsson8b37bb72010-02-28 18:08:38 +00001928 IsPrimaryVirtualBase = false;
1929 }
1930
1931 if (IsPrimaryVirtualBase)
1932 PrimaryVirtualBases.insert(PrimaryBase);
1933 }
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001934 }
1935
1936 // Traverse bases, looking for more primary virtual bases.
1937 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1938 E = RD->bases_end(); I != E; ++I) {
1939 const CXXRecordDecl *BaseDecl =
1940 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1941
Anders Carlsson02b99d62010-03-10 03:02:01 +00001942 uint64_t BaseOffsetInLayoutClass;
1943
1944 if (I->isVirtual()) {
1945 if (!VBases.insert(BaseDecl))
1946 continue;
1947
1948 const ASTRecordLayout &LayoutClassLayout =
1949 Context.getASTRecordLayout(LayoutClass);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001950
Anders Carlsson02b99d62010-03-10 03:02:01 +00001951 BaseOffsetInLayoutClass = LayoutClassLayout.getVBaseClassOffset(BaseDecl);
1952 } else {
1953 BaseOffsetInLayoutClass =
1954 OffsetInLayoutClass + Layout.getBaseClassOffset(BaseDecl);
1955 }
1956
1957 DeterminePrimaryVirtualBases(BaseDecl, BaseOffsetInLayoutClass, VBases);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001958 }
1959}
1960
1961void
Anders Carlsson13f0f662010-02-16 16:49:35 +00001962VtableBuilder::LayoutVtablesForVirtualBases(const CXXRecordDecl *RD,
1963 VisitedVirtualBasesSetTy &VBases) {
1964 // Itanium C++ ABI 2.5.2:
1965 // Then come the virtual base virtual tables, also in inheritance graph
1966 // order, and again excluding primary bases (which share virtual tables with
1967 // the classes for which they are primary).
Anders Carlsson13f0f662010-02-16 16:49:35 +00001968 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1969 E = RD->bases_end(); I != E; ++I) {
1970 const CXXRecordDecl *BaseDecl =
1971 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1972
Anders Carlsson0570f712010-02-23 03:48:14 +00001973 // Check if this base needs a vtable. (If it's virtual, not a primary base
1974 // of some other class, and we haven't visited it before).
Anders Carlsson13f0f662010-02-16 16:49:35 +00001975 if (I->isVirtual() && BaseDecl->isDynamicClass() &&
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001976 !PrimaryVirtualBases.count(BaseDecl) && VBases.insert(BaseDecl)) {
Anders Carlsson13f0f662010-02-16 16:49:35 +00001977 const ASTRecordLayout &MostDerivedClassLayout =
1978 Context.getASTRecordLayout(MostDerivedClass);
1979 uint64_t BaseOffset =
1980 MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
1981
Anders Carlssone3385f52010-02-28 01:43:58 +00001982 const ASTRecordLayout &LayoutClassLayout =
1983 Context.getASTRecordLayout(LayoutClass);
1984 uint64_t BaseOffsetInLayoutClass =
1985 LayoutClassLayout.getVBaseClassOffset(BaseDecl);
1986
1987 LayoutPrimaryAndSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
1988 /*BaseIsVirtual=*/true,
1989 BaseOffsetInLayoutClass);
Anders Carlsson13f0f662010-02-16 16:49:35 +00001990 }
1991
1992 // We only need to check the base for virtual base vtables if it actually
1993 // has virtual bases.
1994 if (BaseDecl->getNumVBases())
1995 LayoutVtablesForVirtualBases(BaseDecl, VBases);
1996 }
1997}
1998
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001999/// dumpLayout - Dump the vtable layout.
2000void VtableBuilder::dumpLayout(llvm::raw_ostream& Out) {
Anders Carlsson93913752010-02-27 20:39:05 +00002001
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002002 if (isBuildingConstructorVtable()) {
Anders Carlsson93913752010-02-27 20:39:05 +00002003 Out << "Construction vtable for ('";
2004 Out << MostDerivedClass->getQualifiedNameAsString() << "', ";
2005 // FIXME: Don't use / 8 .
2006 Out << MostDerivedClassOffset / 8 << ") in '";
2007 Out << LayoutClass->getQualifiedNameAsString();
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002008 } else {
2009 Out << "Vtable for '";
2010 Out << MostDerivedClass->getQualifiedNameAsString();
Anders Carlsson93913752010-02-27 20:39:05 +00002011 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002012 Out << "' (" << Components.size() << " entries).\n";
2013
Anders Carlsson932c2f22010-02-11 17:18:51 +00002014 // Iterate through the address points and insert them into a new map where
2015 // they are keyed by the index and not the base object.
2016 // Since an address point can be shared by multiple subobjects, we use an
2017 // STL multimap.
2018 std::multimap<uint64_t, BaseSubobject> AddressPointsByIndex;
2019 for (CGVtableInfo::AddressPointsMapTy::const_iterator I =
2020 AddressPoints.begin(), E = AddressPoints.end(); I != E; ++I) {
2021 const BaseSubobject& Base = I->first;
2022 uint64_t Index = I->second;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002023
Anders Carlsson932c2f22010-02-11 17:18:51 +00002024 AddressPointsByIndex.insert(std::make_pair(Index, Base));
2025 }
2026
2027 for (unsigned I = 0, E = Components.size(); I != E; ++I) {
Anders Carlssone8a97562010-02-12 07:43:48 +00002028 uint64_t Index = I;
Anders Carlsson932c2f22010-02-11 17:18:51 +00002029
2030 Out << llvm::format("%4d | ", I);
2031
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002032 const VtableComponent &Component = Components[I];
2033
2034 // Dump the component.
2035 switch (Component.getKind()) {
Anders Carlssonb0a588f2010-02-17 06:07:19 +00002036
2037 case VtableComponent::CK_VCallOffset:
2038 Out << "vcall_offset (" << Component.getVCallOffset() << ")";
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002039 break;
Anders Carlsson77904f12010-02-16 04:59:55 +00002040
2041 case VtableComponent::CK_VBaseOffset:
2042 Out << "vbase_offset (" << Component.getVBaseOffset() << ")";
2043 break;
2044
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002045 case VtableComponent::CK_OffsetToTop:
2046 Out << "offset_to_top (" << Component.getOffsetToTop() << ")";
2047 break;
2048
2049 case VtableComponent::CK_RTTI:
2050 Out << Component.getRTTIDecl()->getQualifiedNameAsString() << " RTTI";
2051 break;
2052
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002053 case VtableComponent::CK_FunctionPointer: {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002054 const CXXMethodDecl *MD = Component.getFunctionDecl();
2055
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002056 std::string Str =
2057 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2058 MD);
2059 Out << Str;
Anders Carlsson09da3372010-02-12 02:38:13 +00002060 if (MD->isPure())
2061 Out << " [pure]";
2062
Anders Carlsson8a240292010-03-12 04:54:20 +00002063 ThunkInfo Thunk = Thunks.lookup(I);
2064 if (!Thunk.isEmpty()) {
2065 // If this function pointer has a return adjustment, dump it.
2066 if (!Thunk.Return.isEmpty()) {
2067 Out << "\n [return adjustment: ";
2068 Out << Thunk.Return.NonVirtual << " non-virtual";
2069
2070 if (Thunk.Return.VBaseOffsetOffset) {
2071 Out << ", " << Thunk.Return.VBaseOffsetOffset;
2072 Out << " vbase offset offset";
2073 }
Anders Carlsson78277c72010-02-18 17:00:09 +00002074
Anders Carlsson8a240292010-03-12 04:54:20 +00002075 Out << ']';
2076 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00002077
Anders Carlsson8a240292010-03-12 04:54:20 +00002078 // If this function pointer has a 'this' pointer adjustment, dump it.
2079 if (!Thunk.This.isEmpty()) {
2080 Out << "\n [this adjustment: ";
2081 Out << Thunk.This.NonVirtual << " non-virtual";
2082
2083 if (Thunk.This.VCallOffsetOffset) {
2084 Out << ", " << Thunk.This.VCallOffsetOffset;
2085 Out << " vcall offset offset";
2086 }
Anders Carlsson78277c72010-02-18 17:00:09 +00002087
Anders Carlsson8a240292010-03-12 04:54:20 +00002088 Out << ']';
2089 }
Anders Carlssond3adb0c2010-02-13 23:40:17 +00002090 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00002091
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002092 break;
2093 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002094
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002095 case VtableComponent::CK_CompleteDtorPointer:
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002096 case VtableComponent::CK_DeletingDtorPointer: {
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002097 bool IsComplete =
2098 Component.getKind() == VtableComponent::CK_CompleteDtorPointer;
2099
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002100 const CXXDestructorDecl *DD = Component.getDestructorDecl();
2101
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002102 Out << DD->getQualifiedNameAsString();
2103 if (IsComplete)
2104 Out << "() [complete]";
2105 else
2106 Out << "() [deleting]";
2107
Anders Carlsson09da3372010-02-12 02:38:13 +00002108 if (DD->isPure())
2109 Out << " [pure]";
2110
Anders Carlsson8a240292010-03-12 04:54:20 +00002111 ThunkInfo Thunk = Thunks.lookup(I);
2112 if (!Thunk.isEmpty()) {
2113 // If this destructor has a 'this' pointer adjustment, dump it.
2114 if (!Thunk.This.isEmpty()) {
2115 Out << "\n [this adjustment: ";
2116 Out << Thunk.This.NonVirtual << " non-virtual";
2117
2118 if (Thunk.This.VCallOffsetOffset) {
2119 Out << ", " << Thunk.This.VCallOffsetOffset;
2120 Out << " vcall offset offset";
2121 }
2122
2123 Out << ']';
2124 }
2125 }
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002126
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002127 break;
2128 }
2129
Anders Carlsson350b56e2010-02-19 20:08:13 +00002130 case VtableComponent::CK_UnusedFunctionPointer: {
2131 const CXXMethodDecl *MD = Component.getUnusedFunctionDecl();
2132
2133 std::string Str =
2134 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2135 MD);
2136 Out << "[unused] " << Str;
2137 if (MD->isPure())
2138 Out << " [pure]";
2139 }
2140
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002141 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00002142
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002143 Out << '\n';
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002144
2145 // Dump the next address point.
2146 uint64_t NextIndex = Index + 1;
2147 if (AddressPointsByIndex.count(NextIndex)) {
2148 if (AddressPointsByIndex.count(NextIndex) == 1) {
2149 const BaseSubobject &Base =
2150 AddressPointsByIndex.find(NextIndex)->second;
2151
2152 // FIXME: Instead of dividing by 8, we should be using CharUnits.
2153 Out << " -- (" << Base.getBase()->getQualifiedNameAsString();
2154 Out << ", " << Base.getBaseOffset() / 8 << ") vtable address --\n";
2155 } else {
2156 uint64_t BaseOffset =
2157 AddressPointsByIndex.lower_bound(NextIndex)->second.getBaseOffset();
2158
2159 // We store the class names in a set to get a stable order.
2160 std::set<std::string> ClassNames;
2161 for (std::multimap<uint64_t, BaseSubobject>::const_iterator I =
2162 AddressPointsByIndex.lower_bound(NextIndex), E =
2163 AddressPointsByIndex.upper_bound(NextIndex); I != E; ++I) {
2164 assert(I->second.getBaseOffset() == BaseOffset &&
2165 "Invalid base offset!");
2166 const CXXRecordDecl *RD = I->second.getBase();
2167 ClassNames.insert(RD->getQualifiedNameAsString());
2168 }
2169
2170 for (std::set<std::string>::const_iterator I = ClassNames.begin(),
2171 E = ClassNames.end(); I != E; ++I) {
2172 // FIXME: Instead of dividing by 8, we should be using CharUnits.
2173 Out << " -- (" << *I;
2174 Out << ", " << BaseOffset / 8 << ") vtable address --\n";
2175 }
2176 }
2177 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002178 }
Anders Carlsson93913752010-02-27 20:39:05 +00002179
2180 Out << '\n';
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002181
Anders Carlsson8a240292010-03-12 04:54:20 +00002182 if (!isBuildingConstructorVtable() && MostDerivedClass->getNumVBases()) {
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002183 Out << "Virtual base offset offsets for '";
2184 Out << MostDerivedClass->getQualifiedNameAsString() << "'.\n";
2185
2186 // We store the virtual base class names and their offsets in a map to get
2187 // a stable order.
2188 std::map<std::string, int64_t> ClassNamesAndOffsets;
2189
2190 for (VBaseOffsetOffsetsMapTy::const_iterator I = VBaseOffsetOffsets.begin(),
2191 E = VBaseOffsetOffsets.end(); I != E; ++I) {
2192 std::string ClassName = I->first->getQualifiedNameAsString();
2193 int64_t OffsetOffset = I->second;
2194 ClassNamesAndOffsets.insert(std::make_pair(ClassName, OffsetOffset));
2195 }
2196
2197 for (std::map<std::string, int64_t>::const_iterator I =
2198 ClassNamesAndOffsets.begin(), E = ClassNamesAndOffsets.end();
2199 I != E; ++I)
2200 Out << " " << I->first << " | " << I->second << '\n';
2201
2202 Out << "\n";
2203 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002204}
2205
2206}
2207
2208namespace {
2209class OldVtableBuilder {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002210public:
2211 /// Index_t - Vtable index type.
2212 typedef uint64_t Index_t;
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002213 typedef std::vector<std::pair<GlobalDecl,
2214 std::pair<GlobalDecl, ThunkAdjustment> > >
2215 SavedAdjustmentsVectorTy;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002216private:
Anders Carlsson472404f2009-12-04 16:19:30 +00002217
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002218 // VtableComponents - The components of the vtable being built.
2219 typedef llvm::SmallVector<llvm::Constant *, 64> VtableComponentsVectorTy;
2220 VtableComponentsVectorTy VtableComponents;
2221
Eli Friedman6c08ce72009-12-05 01:05:03 +00002222 const bool BuildVtable;
2223
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002224 llvm::Type *Ptr8Ty;
Anders Carlssonbad80eb2009-12-04 18:36:22 +00002225
2226 /// MostDerivedClass - The most derived class that this vtable is being
2227 /// built for.
2228 const CXXRecordDecl *MostDerivedClass;
2229
Mike Stump83066c82009-11-13 01:54:23 +00002230 /// LayoutClass - The most derived class used for virtual base layout
2231 /// information.
2232 const CXXRecordDecl *LayoutClass;
Mike Stump653d0b92009-11-13 02:13:54 +00002233 /// LayoutOffset - The offset for Class in LayoutClass.
2234 uint64_t LayoutOffset;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002235 /// BLayout - Layout for the most derived class that this vtable is being
2236 /// built for.
2237 const ASTRecordLayout &BLayout;
2238 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
2239 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
2240 llvm::Constant *rtti;
2241 llvm::LLVMContext &VMContext;
2242 CodeGenModule &CGM; // Per-module state.
Anders Carlssonf2f31f42009-12-04 03:46:21 +00002243
Mike Stump90181eb2010-01-26 00:05:04 +00002244 llvm::DenseMap<const CXXMethodDecl *, Index_t> VCall;
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002245 llvm::DenseMap<GlobalDecl, Index_t> VCallOffset;
Mike Stump77537b12010-01-26 03:42:22 +00002246 llvm::DenseMap<GlobalDecl, Index_t> VCallOffsetForVCall;
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002247 // This is the offset to the nearest virtual base
Mike Stump90181eb2010-01-26 00:05:04 +00002248 llvm::DenseMap<const CXXMethodDecl *, Index_t> NonVirtualOffset;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002249 llvm::DenseMap<const CXXRecordDecl *, Index_t> VBIndex;
Mike Stumpbb9ff052009-10-27 23:46:47 +00002250
Anders Carlsson323bb042009-11-26 19:54:33 +00002251 /// PureVirtualFunction - Points to __cxa_pure_virtual.
2252 llvm::Constant *PureVirtualFn;
2253
Anders Carlssona84b6e82009-12-04 02:01:07 +00002254 /// VtableMethods - A data structure for keeping track of methods in a vtable.
2255 /// Can add methods, override methods and iterate in vtable order.
2256 class VtableMethods {
2257 // MethodToIndexMap - Maps from a global decl to the index it has in the
2258 // Methods vector.
2259 llvm::DenseMap<GlobalDecl, uint64_t> MethodToIndexMap;
2260
2261 /// Methods - The methods, in vtable order.
2262 typedef llvm::SmallVector<GlobalDecl, 16> MethodsVectorTy;
2263 MethodsVectorTy Methods;
Eli Friedman8174f2c2009-12-06 22:01:30 +00002264 MethodsVectorTy OrigMethods;
Anders Carlssona84b6e82009-12-04 02:01:07 +00002265
2266 public:
2267 /// AddMethod - Add a method to the vtable methods.
2268 void AddMethod(GlobalDecl GD) {
2269 assert(!MethodToIndexMap.count(GD) &&
2270 "Method has already been added!");
2271
2272 MethodToIndexMap[GD] = Methods.size();
2273 Methods.push_back(GD);
Eli Friedman8174f2c2009-12-06 22:01:30 +00002274 OrigMethods.push_back(GD);
Anders Carlssona84b6e82009-12-04 02:01:07 +00002275 }
2276
2277 /// OverrideMethod - Replace a method with another.
2278 void OverrideMethod(GlobalDecl OverriddenGD, GlobalDecl GD) {
2279 llvm::DenseMap<GlobalDecl, uint64_t>::iterator i
2280 = MethodToIndexMap.find(OverriddenGD);
2281 assert(i != MethodToIndexMap.end() && "Did not find entry!");
2282
2283 // Get the index of the old decl.
2284 uint64_t Index = i->second;
2285
2286 // Replace the old decl with the new decl.
2287 Methods[Index] = GD;
2288
Anders Carlssona84b6e82009-12-04 02:01:07 +00002289 // And add the new.
2290 MethodToIndexMap[GD] = Index;
2291 }
2292
Anders Carlsson7bb70762009-12-04 15:49:02 +00002293 /// getIndex - Gives the index of a passed in GlobalDecl. Returns false if
2294 /// the index couldn't be found.
Benjamin Kramer62ab6162009-12-04 22:45:27 +00002295 bool getIndex(GlobalDecl GD, uint64_t &Index) const {
Anders Carlsson7bb70762009-12-04 15:49:02 +00002296 llvm::DenseMap<GlobalDecl, uint64_t>::const_iterator i
2297 = MethodToIndexMap.find(GD);
Eli Friedman3d2e9de2009-12-04 08:34:14 +00002298
Anders Carlsson7bb70762009-12-04 15:49:02 +00002299 if (i == MethodToIndexMap.end())
2300 return false;
Anders Carlssone6096362009-12-04 03:41:37 +00002301
Anders Carlsson7bb70762009-12-04 15:49:02 +00002302 Index = i->second;
2303 return true;
Anders Carlssone6096362009-12-04 03:41:37 +00002304 }
2305
Eli Friedman8174f2c2009-12-06 22:01:30 +00002306 GlobalDecl getOrigMethod(uint64_t Index) const {
2307 return OrigMethods[Index];
2308 }
2309
Anders Carlssona84b6e82009-12-04 02:01:07 +00002310 MethodsVectorTy::size_type size() const {
2311 return Methods.size();
2312 }
2313
2314 void clear() {
2315 MethodToIndexMap.clear();
2316 Methods.clear();
Eli Friedman8174f2c2009-12-06 22:01:30 +00002317 OrigMethods.clear();
Anders Carlssona84b6e82009-12-04 02:01:07 +00002318 }
2319
Anders Carlssone6096362009-12-04 03:41:37 +00002320 GlobalDecl operator[](uint64_t Index) const {
Anders Carlssona84b6e82009-12-04 02:01:07 +00002321 return Methods[Index];
2322 }
2323 };
2324
2325 /// Methods - The vtable methods we're currently building.
2326 VtableMethods Methods;
2327
Anders Carlsson4c837d22009-12-04 02:26:15 +00002328 /// ThisAdjustments - For a given index in the vtable, contains the 'this'
2329 /// pointer adjustment needed for a method.
2330 typedef llvm::DenseMap<uint64_t, ThunkAdjustment> ThisAdjustmentsMapTy;
2331 ThisAdjustmentsMapTy ThisAdjustments;
Anders Carlssond420a312009-11-26 19:32:45 +00002332
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002333 SavedAdjustmentsVectorTy SavedAdjustments;
Eli Friedman8174f2c2009-12-06 22:01:30 +00002334
Anders Carlssonc521f952009-12-04 02:22:02 +00002335 /// BaseReturnTypes - Contains the base return types of methods who have been
2336 /// overridden with methods whose return types require adjustment. Used for
2337 /// generating covariant thunk information.
2338 typedef llvm::DenseMap<uint64_t, CanQualType> BaseReturnTypesMapTy;
2339 BaseReturnTypesMapTy BaseReturnTypes;
Anders Carlssond420a312009-11-26 19:32:45 +00002340
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002341 std::vector<Index_t> VCalls;
Mike Stump2cefe382009-11-12 20:47:57 +00002342
2343 typedef std::pair<const CXXRecordDecl *, uint64_t> CtorVtable_t;
Mike Stumpcd2b8212009-11-19 20:52:19 +00002344 // subAddressPoints - Used to hold the AddressPoints (offsets) into the built
2345 // vtable for use in computing the initializers for the VTT.
2346 llvm::DenseMap<CtorVtable_t, int64_t> &subAddressPoints;
Mike Stump2cefe382009-11-12 20:47:57 +00002347
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002348 /// AddressPoints - Address points for this vtable.
2349 CGVtableInfo::AddressPointsMapTy& AddressPoints;
2350
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002351 typedef CXXRecordDecl::method_iterator method_iter;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002352 const uint32_t LLVMPointerWidth;
2353 Index_t extra;
Mike Stump37dbe962009-10-15 02:04:03 +00002354 typedef std::vector<std::pair<const CXXRecordDecl *, int64_t> > Path_t;
Mike Stumpcd2b8212009-11-19 20:52:19 +00002355 static llvm::DenseMap<CtorVtable_t, int64_t>&
2356 AllocAddressPoint(CodeGenModule &cgm, const CXXRecordDecl *l,
2357 const CXXRecordDecl *c) {
Anders Carlsson93a18842010-01-02 18:02:32 +00002358 CGVtableInfo::AddrMap_t *&oref = cgm.getVtableInfo().AddressPoints[l];
Mike Stumpcd2b8212009-11-19 20:52:19 +00002359 if (oref == 0)
Anders Carlsson93a18842010-01-02 18:02:32 +00002360 oref = new CGVtableInfo::AddrMap_t;
Mike Stumpcd2b8212009-11-19 20:52:19 +00002361
2362 llvm::DenseMap<CtorVtable_t, int64_t> *&ref = (*oref)[c];
2363 if (ref == 0)
2364 ref = new llvm::DenseMap<CtorVtable_t, int64_t>;
2365 return *ref;
2366 }
Anders Carlsson323bb042009-11-26 19:54:33 +00002367
Mike Stump90181eb2010-01-26 00:05:04 +00002368 bool DclIsSame(const FunctionDecl *New, const FunctionDecl *Old) {
2369 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
2370 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
2371
2372 // C++ [temp.fct]p2:
2373 // A function template can be overloaded with other function templates
2374 // and with normal (non-template) functions.
2375 if ((OldTemplate == 0) != (NewTemplate == 0))
2376 return false;
2377
2378 // Is the function New an overload of the function Old?
2379 QualType OldQType = CGM.getContext().getCanonicalType(Old->getType());
2380 QualType NewQType = CGM.getContext().getCanonicalType(New->getType());
2381
2382 // Compare the signatures (C++ 1.3.10) of the two functions to
2383 // determine whether they are overloads. If we find any mismatch
2384 // in the signature, they are overloads.
2385
2386 // If either of these functions is a K&R-style function (no
2387 // prototype), then we consider them to have matching signatures.
2388 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
2389 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
2390 return true;
2391
2392 FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType);
2393 FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType);
2394
2395 // The signature of a function includes the types of its
2396 // parameters (C++ 1.3.10), which includes the presence or absence
2397 // of the ellipsis; see C++ DR 357).
2398 if (OldQType != NewQType &&
2399 (OldType->getNumArgs() != NewType->getNumArgs() ||
2400 OldType->isVariadic() != NewType->isVariadic() ||
2401 !std::equal(OldType->arg_type_begin(), OldType->arg_type_end(),
2402 NewType->arg_type_begin())))
2403 return false;
2404
2405#if 0
2406 // C++ [temp.over.link]p4:
2407 // The signature of a function template consists of its function
2408 // signature, its return type and its template parameter list. The names
2409 // of the template parameters are significant only for establishing the
2410 // relationship between the template parameters and the rest of the
2411 // signature.
2412 //
2413 // We check the return type and template parameter lists for function
2414 // templates first; the remaining checks follow.
2415 if (NewTemplate &&
2416 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
2417 OldTemplate->getTemplateParameters(),
2418 TPL_TemplateMatch) ||
2419 OldType->getResultType() != NewType->getResultType()))
2420 return false;
2421#endif
2422
2423 // If the function is a class member, its signature includes the
2424 // cv-qualifiers (if any) on the function itself.
2425 //
2426 // As part of this, also check whether one of the member functions
2427 // is static, in which case they are not overloads (C++
2428 // 13.1p2). While not part of the definition of the signature,
2429 // this check is important to determine whether these functions
2430 // can be overloaded.
2431 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
2432 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
2433 if (OldMethod && NewMethod &&
2434 !OldMethod->isStatic() && !NewMethod->isStatic() &&
2435 OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers())
2436 return false;
2437
2438 // The signatures match; this is not an overload.
2439 return true;
2440 }
2441
2442 typedef llvm::DenseMap<const CXXMethodDecl *, const CXXMethodDecl*>
2443 ForwardUnique_t;
2444 ForwardUnique_t ForwardUnique;
2445 llvm::DenseMap<const CXXMethodDecl*, const CXXMethodDecl*> UniqueOverrider;
2446
2447 void BuildUniqueOverrider(const CXXMethodDecl *U, const CXXMethodDecl *MD) {
2448 const CXXMethodDecl *PrevU = UniqueOverrider[MD];
2449 assert(U && "no unique overrider");
2450 if (PrevU == U)
2451 return;
2452 if (PrevU != U && PrevU != 0) {
2453 // If already set, note the two sets as the same
2454 if (0)
2455 printf("%s::%s same as %s::%s\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002456 PrevU->getParent()->getNameAsString().c_str(),
2457 PrevU->getNameAsString().c_str(),
2458 U->getParent()->getNameAsString().c_str(),
2459 U->getNameAsString().c_str());
Mike Stump90181eb2010-01-26 00:05:04 +00002460 ForwardUnique[PrevU] = U;
2461 return;
2462 }
2463
2464 // Not set, set it now
2465 if (0)
2466 printf("marking %s::%s %p override as %s::%s\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002467 MD->getParent()->getNameAsString().c_str(),
2468 MD->getNameAsString().c_str(),
Mike Stump90181eb2010-01-26 00:05:04 +00002469 (void*)MD,
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002470 U->getParent()->getNameAsString().c_str(),
2471 U->getNameAsString().c_str());
Mike Stump90181eb2010-01-26 00:05:04 +00002472 UniqueOverrider[MD] = U;
2473
2474 for (CXXMethodDecl::method_iterator mi = MD->begin_overridden_methods(),
2475 me = MD->end_overridden_methods(); mi != me; ++mi) {
2476 BuildUniqueOverrider(U, *mi);
2477 }
2478 }
2479
2480 void BuildUniqueOverriders(const CXXRecordDecl *RD) {
2481 if (0) printf("walking %s\n", RD->getNameAsCString());
2482 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
2483 e = RD->method_end(); i != e; ++i) {
2484 const CXXMethodDecl *MD = *i;
2485 if (!MD->isVirtual())
2486 continue;
2487
2488 if (UniqueOverrider[MD] == 0) {
2489 // Only set this, if it hasn't been set yet.
2490 BuildUniqueOverrider(MD, MD);
2491 if (0)
2492 printf("top set is %s::%s %p\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002493 MD->getParent()->getNameAsString().c_str(),
2494 MD->getNameAsString().c_str(),
Mike Stump90181eb2010-01-26 00:05:04 +00002495 (void*)MD);
2496 ForwardUnique[MD] = MD;
2497 }
2498 }
2499 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2500 e = RD->bases_end(); i != e; ++i) {
2501 const CXXRecordDecl *Base =
2502 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2503 BuildUniqueOverriders(Base);
2504 }
2505 }
2506
2507 static int DclCmp(const void *p1, const void *p2) {
John McCallef3057c2010-02-13 01:04:05 +00002508 const CXXMethodDecl *MD1 = *(const CXXMethodDecl *const *)p1;
2509 const CXXMethodDecl *MD2 = *(const CXXMethodDecl *const *)p2;
2510
2511 return (DeclarationName::compare(MD1->getDeclName(), MD2->getDeclName()));
Mike Stump90181eb2010-01-26 00:05:04 +00002512 }
2513
2514 void MergeForwarding() {
2515 typedef llvm::SmallVector<const CXXMethodDecl *, 100> A_t;
2516 A_t A;
2517 for (ForwardUnique_t::iterator I = ForwardUnique.begin(),
2518 E = ForwardUnique.end(); I != E; ++I) {
2519 if (I->first == I->second)
2520 // Only add the roots of all trees
2521 A.push_back(I->first);
2522 }
2523 llvm::array_pod_sort(A.begin(), A.end(), DclCmp);
2524 for (A_t::iterator I = A.begin(),
2525 E = A.end(); I != E; ++I) {
2526 A_t::iterator J = I;
John McCallef3057c2010-02-13 01:04:05 +00002527 while (++J != E && DclCmp(I, J) == 0)
Mike Stump90181eb2010-01-26 00:05:04 +00002528 if (DclIsSame(*I, *J)) {
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002529 if (0) printf("connecting %s\n", (*I)->getNameAsString().c_str());
Mike Stump90181eb2010-01-26 00:05:04 +00002530 ForwardUnique[*J] = *I;
2531 }
2532 }
2533 }
2534
2535 const CXXMethodDecl *getUnique(const CXXMethodDecl *MD) {
2536 const CXXMethodDecl *U = UniqueOverrider[MD];
2537 assert(U && "unique overrider not found");
2538 while (ForwardUnique.count(U)) {
2539 const CXXMethodDecl *NU = ForwardUnique[U];
2540 if (NU == U) break;
2541 U = NU;
2542 }
2543 return U;
2544 }
Anders Carlsson72281172010-01-26 17:36:47 +00002545
2546 GlobalDecl getUnique(GlobalDecl GD) {
2547 const CXXMethodDecl *Unique = getUnique(cast<CXXMethodDecl>(GD.getDecl()));
2548
2549 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Unique))
2550 return GlobalDecl(CD, GD.getCtorType());
2551
2552 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Unique))
2553 return GlobalDecl(DD, GD.getDtorType());
2554
2555 return Unique;
Mike Stump90181eb2010-01-26 00:05:04 +00002556 }
2557
Anders Carlsson323bb042009-11-26 19:54:33 +00002558 /// getPureVirtualFn - Return the __cxa_pure_virtual function.
2559 llvm::Constant* getPureVirtualFn() {
2560 if (!PureVirtualFn) {
2561 const llvm::FunctionType *Ty =
2562 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
2563 /*isVarArg=*/false);
2564 PureVirtualFn = wrap(CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual"));
2565 }
2566
2567 return PureVirtualFn;
2568 }
2569
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002570public:
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002571 OldVtableBuilder(const CXXRecordDecl *MostDerivedClass,
Eli Friedman6c08ce72009-12-05 01:05:03 +00002572 const CXXRecordDecl *l, uint64_t lo, CodeGenModule &cgm,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002573 bool build, CGVtableInfo::AddressPointsMapTy& AddressPoints)
Eli Friedman6c08ce72009-12-05 01:05:03 +00002574 : BuildVtable(build), MostDerivedClass(MostDerivedClass), LayoutClass(l),
2575 LayoutOffset(lo), BLayout(cgm.getContext().getASTRecordLayout(l)),
2576 rtti(0), VMContext(cgm.getModule().getContext()),CGM(cgm),
2577 PureVirtualFn(0),
Anders Carlssonbad80eb2009-12-04 18:36:22 +00002578 subAddressPoints(AllocAddressPoint(cgm, l, MostDerivedClass)),
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002579 AddressPoints(AddressPoints),
2580 LLVMPointerWidth(cgm.getContext().Target.getPointerWidth(0))
2581 {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002582 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
Anders Carlsson3f4336c2009-12-17 07:09:17 +00002583 if (BuildVtable) {
2584 QualType ClassType = CGM.getContext().getTagDeclType(MostDerivedClass);
2585 rtti = CGM.GetAddrOfRTTIDescriptor(ClassType);
2586 }
Mike Stump90181eb2010-01-26 00:05:04 +00002587 BuildUniqueOverriders(MostDerivedClass);
2588 MergeForwarding();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002589 }
2590
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002591 // getVtableComponents - Returns a reference to the vtable components.
2592 const VtableComponentsVectorTy &getVtableComponents() const {
2593 return VtableComponents;
Anders Carlsson472404f2009-12-04 16:19:30 +00002594 }
2595
Anders Carlssone36a6b32010-01-02 01:01:18 +00002596 llvm::DenseMap<const CXXRecordDecl *, uint64_t> &getVBIndex()
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002597 { return VBIndex; }
2598
Eli Friedman31bc3ad2009-12-07 23:56:34 +00002599 SavedAdjustmentsVectorTy &getSavedAdjustments()
2600 { return SavedAdjustments; }
Eli Friedman8174f2c2009-12-06 22:01:30 +00002601
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002602 llvm::Constant *wrap(Index_t i) {
2603 llvm::Constant *m;
2604 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i);
2605 return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
2606 }
2607
2608 llvm::Constant *wrap(llvm::Constant *m) {
2609 return llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
2610 }
2611
Mike Stumpd2808442010-01-22 02:51:26 +00002612//#define D1(x)
Douglas Gregorf4f2e022010-02-22 16:48:26 +00002613#define D1(X) do { if (getenv("CLANG_VTABLE_DEBUG")) { X; } } while (0)
Mike Stump75ce5732009-10-31 20:06:59 +00002614
2615 void GenerateVBaseOffsets(const CXXRecordDecl *RD, uint64_t Offset,
Mike Stump28431212009-10-13 22:54:56 +00002616 bool updateVBIndex, Index_t current_vbindex) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002617 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2618 e = RD->bases_end(); i != e; ++i) {
2619 const CXXRecordDecl *Base =
2620 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stump28431212009-10-13 22:54:56 +00002621 Index_t next_vbindex = current_vbindex;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002622 if (i->isVirtual() && !SeenVBase.count(Base)) {
2623 SeenVBase.insert(Base);
Mike Stump28431212009-10-13 22:54:56 +00002624 if (updateVBIndex) {
Mike Stump75ce5732009-10-31 20:06:59 +00002625 next_vbindex = (ssize_t)(-(VCalls.size()*LLVMPointerWidth/8)
Mike Stump28431212009-10-13 22:54:56 +00002626 - 3*LLVMPointerWidth/8);
2627 VBIndex[Base] = next_vbindex;
2628 }
Mike Stump75ce5732009-10-31 20:06:59 +00002629 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
2630 VCalls.push_back((0?700:0) + BaseOffset);
2631 D1(printf(" vbase for %s at %d delta %d most derived %s\n",
2632 Base->getNameAsCString(),
2633 (int)-VCalls.size()-3, (int)BaseOffset,
Mike Stumpd2808442010-01-22 02:51:26 +00002634 MostDerivedClass->getNameAsCString()));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002635 }
Mike Stump28431212009-10-13 22:54:56 +00002636 // We also record offsets for non-virtual bases to closest enclosing
2637 // virtual base. We do this so that we don't have to search
2638 // for the nearst virtual base class when generating thunks.
2639 if (updateVBIndex && VBIndex.count(Base) == 0)
2640 VBIndex[Base] = next_vbindex;
Mike Stump75ce5732009-10-31 20:06:59 +00002641 GenerateVBaseOffsets(Base, Offset, updateVBIndex, next_vbindex);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002642 }
2643 }
2644
2645 void StartNewTable() {
2646 SeenVBase.clear();
2647 }
2648
Mike Stump8bccbfd2009-10-15 09:30:16 +00002649 Index_t getNVOffset_1(const CXXRecordDecl *D, const CXXRecordDecl *B,
2650 Index_t Offset = 0) {
2651
2652 if (B == D)
2653 return Offset;
2654
2655 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(D);
2656 for (CXXRecordDecl::base_class_const_iterator i = D->bases_begin(),
2657 e = D->bases_end(); i != e; ++i) {
2658 const CXXRecordDecl *Base =
2659 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2660 int64_t BaseOffset = 0;
2661 if (!i->isVirtual())
2662 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
2663 int64_t o = getNVOffset_1(Base, B, BaseOffset);
2664 if (o >= 0)
2665 return o;
2666 }
2667
2668 return -1;
2669 }
2670
2671 /// getNVOffset - Returns the non-virtual offset for the given (B) base of the
2672 /// derived class D.
2673 Index_t getNVOffset(QualType qB, QualType qD) {
Mike Stump46271322009-11-03 19:03:17 +00002674 qD = qD->getPointeeType();
2675 qB = qB->getPointeeType();
Mike Stump8bccbfd2009-10-15 09:30:16 +00002676 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
2677 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
2678 int64_t o = getNVOffset_1(D, B);
2679 if (o >= 0)
2680 return o;
2681
2682 assert(false && "FIXME: non-virtual base not found");
2683 return 0;
2684 }
2685
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002686 /// getVbaseOffset - Returns the index into the vtable for the virtual base
2687 /// offset for the given (B) virtual base of the derived class D.
2688 Index_t getVbaseOffset(QualType qB, QualType qD) {
Mike Stump46271322009-11-03 19:03:17 +00002689 qD = qD->getPointeeType();
2690 qB = qB->getPointeeType();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002691 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
2692 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
Anders Carlssonbad80eb2009-12-04 18:36:22 +00002693 if (D != MostDerivedClass)
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00002694 return CGM.getVtableInfo().getVirtualBaseOffsetOffset(D, B);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002695 llvm::DenseMap<const CXXRecordDecl *, Index_t>::iterator i;
2696 i = VBIndex.find(B);
2697 if (i != VBIndex.end())
2698 return i->second;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002699
Mike Stump28431212009-10-13 22:54:56 +00002700 assert(false && "FIXME: Base not found");
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002701 return 0;
2702 }
2703
Eli Friedman81fb0d22009-12-04 08:40:51 +00002704 bool OverrideMethod(GlobalDecl GD, bool MorallyVirtual,
2705 Index_t OverrideOffset, Index_t Offset,
2706 int64_t CurrentVBaseOffset);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002707
Anders Carlsson495634e2009-12-04 02:39:04 +00002708 /// AppendMethods - Append the current methods to the vtable.
Anders Carlssonddf42c82009-12-04 02:56:03 +00002709 void AppendMethodsToVtable();
Anders Carlsson495634e2009-12-04 02:39:04 +00002710
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002711 llvm::Constant *WrapAddrOf(GlobalDecl GD) {
2712 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2713
Anders Carlsson64457732009-11-24 05:08:52 +00002714 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVtable(MD);
Mike Stump18e8b472009-10-27 23:36:26 +00002715
Mike Stumpcdeb8002009-12-03 16:55:20 +00002716 return wrap(CGM.GetAddrOfFunction(GD, Ty));
Mike Stump18e8b472009-10-27 23:36:26 +00002717 }
2718
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002719 void OverrideMethods(Path_t *Path, bool MorallyVirtual, int64_t Offset,
2720 int64_t CurrentVBaseOffset) {
Mike Stump37dbe962009-10-15 02:04:03 +00002721 for (Path_t::reverse_iterator i = Path->rbegin(),
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002722 e = Path->rend(); i != e; ++i) {
2723 const CXXRecordDecl *RD = i->first;
Mike Stump8bccbfd2009-10-15 09:30:16 +00002724 int64_t OverrideOffset = i->second;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002725 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
2726 ++mi) {
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002727 const CXXMethodDecl *MD = *mi;
2728
2729 if (!MD->isVirtual())
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002730 continue;
2731
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002732 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2733 // Override both the complete and the deleting destructor.
2734 GlobalDecl CompDtor(DD, Dtor_Complete);
Eli Friedman81fb0d22009-12-04 08:40:51 +00002735 OverrideMethod(CompDtor, MorallyVirtual, OverrideOffset, Offset,
2736 CurrentVBaseOffset);
2737
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002738 GlobalDecl DeletingDtor(DD, Dtor_Deleting);
Eli Friedman81fb0d22009-12-04 08:40:51 +00002739 OverrideMethod(DeletingDtor, MorallyVirtual, OverrideOffset, Offset,
2740 CurrentVBaseOffset);
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002741 } else {
Eli Friedman81fb0d22009-12-04 08:40:51 +00002742 OverrideMethod(MD, MorallyVirtual, OverrideOffset, Offset,
2743 CurrentVBaseOffset);
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002744 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002745 }
2746 }
2747 }
2748
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002749 void AddMethod(const GlobalDecl GD, bool MorallyVirtual, Index_t Offset,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002750 int64_t CurrentVBaseOffset) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002751 // If we can find a previously allocated slot for this, reuse it.
Eli Friedman81fb0d22009-12-04 08:40:51 +00002752 if (OverrideMethod(GD, MorallyVirtual, Offset, Offset,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002753 CurrentVBaseOffset))
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002754 return;
2755
Mike Stump1f49d652010-01-22 18:48:47 +00002756 D1(printf(" vfn for %s at %d\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002757 dyn_cast<CXXMethodDecl>(GD.getDecl())->getNameAsString().c_str(),
Mike Stump1f49d652010-01-22 18:48:47 +00002758 (int)Methods.size()));
2759
Anders Carlssoncdf18982009-12-04 02:08:24 +00002760 // We didn't find an entry in the vtable that we could use, add a new
2761 // entry.
2762 Methods.AddMethod(GD);
2763
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002764 VCallOffset[GD] = Offset/8 - CurrentVBaseOffset/8;
2765
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002766 if (MorallyVirtual) {
Anders Carlsson72281172010-01-26 17:36:47 +00002767 GlobalDecl UGD = getUnique(GD);
2768 const CXXMethodDecl *UMD = cast<CXXMethodDecl>(UGD.getDecl());
2769
Mike Stump90181eb2010-01-26 00:05:04 +00002770 assert(UMD && "final overrider not found");
2771
2772 Index_t &idx = VCall[UMD];
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002773 // Allocate the first one, after that, we reuse the previous one.
2774 if (idx == 0) {
Anders Carlsson72281172010-01-26 17:36:47 +00002775 VCallOffsetForVCall[UGD] = Offset/8;
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002776 NonVirtualOffset[UMD] = Offset/8 - CurrentVBaseOffset/8;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002777 idx = VCalls.size()+1;
Mike Stump90181eb2010-01-26 00:05:04 +00002778 VCalls.push_back(Offset/8 - CurrentVBaseOffset/8);
Mike Stump75ce5732009-10-31 20:06:59 +00002779 D1(printf(" vcall for %s at %d with delta %d\n",
Douglas Gregor76eb74a2010-02-22 16:44:27 +00002780 dyn_cast<CXXMethodDecl>(GD.getDecl())->getNameAsString().c_str(),
Mike Stump90181eb2010-01-26 00:05:04 +00002781 (int)-VCalls.size()-3, (int)VCalls[idx-1]));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002782 }
2783 }
2784 }
2785
2786 void AddMethods(const CXXRecordDecl *RD, bool MorallyVirtual,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002787 Index_t Offset, int64_t CurrentVBaseOffset) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002788 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002789 ++mi) {
2790 const CXXMethodDecl *MD = *mi;
2791 if (!MD->isVirtual())
2792 continue;
2793
2794 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2795 // For destructors, add both the complete and the deleting destructor
2796 // to the vtable.
2797 AddMethod(GlobalDecl(DD, Dtor_Complete), MorallyVirtual, Offset,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002798 CurrentVBaseOffset);
Eli Friedman03aa2f12009-11-30 01:19:33 +00002799 AddMethod(GlobalDecl(DD, Dtor_Deleting), MorallyVirtual, Offset,
2800 CurrentVBaseOffset);
2801 } else
2802 AddMethod(MD, MorallyVirtual, Offset, CurrentVBaseOffset);
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002803 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002804 }
2805
2806 void NonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
2807 const CXXRecordDecl *PrimaryBase,
2808 bool PrimaryBaseWasVirtual, bool MorallyVirtual,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002809 int64_t Offset, int64_t CurrentVBaseOffset,
2810 Path_t *Path) {
Mike Stump37dbe962009-10-15 02:04:03 +00002811 Path->push_back(std::make_pair(RD, Offset));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002812 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2813 e = RD->bases_end(); i != e; ++i) {
2814 if (i->isVirtual())
2815 continue;
2816 const CXXRecordDecl *Base =
2817 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stump9eb76d42010-01-22 06:45:05 +00002818 uint64_t o = Offset + Layout.getBaseClassOffset(Base);
2819 StartNewTable();
2820 GenerateVtableForBase(Base, o, MorallyVirtual, false,
2821 true, Base == PrimaryBase && !PrimaryBaseWasVirtual,
2822 CurrentVBaseOffset, Path);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002823 }
Mike Stump37dbe962009-10-15 02:04:03 +00002824 Path->pop_back();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002825 }
2826
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002827// #define D(X) do { X; } while (0)
2828#define D(X)
2829
2830 void insertVCalls(int InsertionPoint) {
Mike Stump75ce5732009-10-31 20:06:59 +00002831 D1(printf("============= combining vbase/vcall\n"));
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002832 D(VCalls.insert(VCalls.begin(), 673));
2833 D(VCalls.push_back(672));
Eli Friedman6c08ce72009-12-05 01:05:03 +00002834
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002835 VtableComponents.insert(VtableComponents.begin() + InsertionPoint,
2836 VCalls.size(), 0);
Eli Friedman6c08ce72009-12-05 01:05:03 +00002837 if (BuildVtable) {
2838 // The vcalls come first...
2839 for (std::vector<Index_t>::reverse_iterator i = VCalls.rbegin(),
2840 e = VCalls.rend();
2841 i != e; ++i)
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00002842 VtableComponents[InsertionPoint++] = wrap((0?600:0) + *i);
Eli Friedman6c08ce72009-12-05 01:05:03 +00002843 }
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002844 VCalls.clear();
Mike Stump9f23a142009-11-10 02:30:51 +00002845 VCall.clear();
Mike Stumpa04ecfb2010-01-26 21:35:27 +00002846 VCallOffsetForVCall.clear();
2847 VCallOffset.clear();
2848 NonVirtualOffset.clear();
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002849 }
2850
Mike Stump559387f2009-11-13 23:13:20 +00002851 void AddAddressPoints(const CXXRecordDecl *RD, uint64_t Offset,
2852 Index_t AddressPoint) {
2853 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002854 RD->getNameAsCString(), MostDerivedClass->getNameAsCString(),
Mike Stump559387f2009-11-13 23:13:20 +00002855 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stumpcd2b8212009-11-19 20:52:19 +00002856 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002857 AddressPoints[BaseSubobject(RD, Offset)] = AddressPoint;
Mike Stump559387f2009-11-13 23:13:20 +00002858
2859 // Now also add the address point for all our primary bases.
2860 while (1) {
2861 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2862 RD = Layout.getPrimaryBase();
2863 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2864 // FIXME: Double check this.
2865 if (RD == 0)
2866 break;
2867 if (PrimaryBaseWasVirtual &&
2868 BLayout.getVBaseClassOffset(RD) != Offset)
2869 break;
2870 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002871 RD->getNameAsCString(), MostDerivedClass->getNameAsCString(),
Mike Stump559387f2009-11-13 23:13:20 +00002872 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stumpcd2b8212009-11-19 20:52:19 +00002873 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Anders Carlsson5f9a8812010-01-14 02:29:07 +00002874 AddressPoints[BaseSubobject(RD, Offset)] = AddressPoint;
Mike Stump559387f2009-11-13 23:13:20 +00002875 }
2876 }
2877
2878
Mike Stumpd538a6d2009-12-24 07:29:41 +00002879 void FinishGenerateVtable(const CXXRecordDecl *RD,
2880 const ASTRecordLayout &Layout,
2881 const CXXRecordDecl *PrimaryBase,
Mike Stump9eb76d42010-01-22 06:45:05 +00002882 bool ForNPNVBases, bool WasPrimaryBase,
Mike Stumpd538a6d2009-12-24 07:29:41 +00002883 bool PrimaryBaseWasVirtual,
2884 bool MorallyVirtual, int64_t Offset,
2885 bool ForVirtualBase, int64_t CurrentVBaseOffset,
2886 Path_t *Path) {
Mike Stump37dbe962009-10-15 02:04:03 +00002887 bool alloc = false;
2888 if (Path == 0) {
2889 alloc = true;
2890 Path = new Path_t;
2891 }
2892
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002893 StartNewTable();
2894 extra = 0;
Mike Stump9eb76d42010-01-22 06:45:05 +00002895 Index_t AddressPoint = 0;
2896 int VCallInsertionPoint = 0;
2897 if (!ForNPNVBases || !WasPrimaryBase) {
2898 bool DeferVCalls = MorallyVirtual || ForVirtualBase;
2899 VCallInsertionPoint = VtableComponents.size();
2900 if (!DeferVCalls) {
2901 insertVCalls(VCallInsertionPoint);
2902 } else
2903 // FIXME: just for extra, or for all uses of VCalls.size post this?
2904 extra = -VCalls.size();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002905
Mike Stump9eb76d42010-01-22 06:45:05 +00002906 // Add the offset to top.
2907 VtableComponents.push_back(BuildVtable ? wrap(-((Offset-LayoutOffset)/8)) : 0);
Anders Carlsson472404f2009-12-04 16:19:30 +00002908
Mike Stump9eb76d42010-01-22 06:45:05 +00002909 // Add the RTTI information.
2910 VtableComponents.push_back(rtti);
Anders Carlsson472404f2009-12-04 16:19:30 +00002911
Mike Stump9eb76d42010-01-22 06:45:05 +00002912 AddressPoint = VtableComponents.size();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002913
Mike Stump9eb76d42010-01-22 06:45:05 +00002914 AppendMethodsToVtable();
2915 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002916
2917 // and then the non-virtual bases.
2918 NonVirtualBases(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002919 MorallyVirtual, Offset, CurrentVBaseOffset, Path);
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002920
2921 if (ForVirtualBase) {
Mike Stump2cefe382009-11-12 20:47:57 +00002922 // FIXME: We're adding to VCalls in callers, we need to do the overrides
2923 // in the inner part, so that we know the complete set of vcalls during
2924 // the build and don't have to insert into methods. Saving out the
2925 // AddressPoint here, would need to be fixed, if we didn't do that. Also
2926 // retroactively adding vcalls for overrides later wind up in the wrong
2927 // place, the vcall slot has to be alloted during the walk of the base
2928 // when the function is first introduces.
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002929 AddressPoint += VCalls.size();
Mike Stump2cefe382009-11-12 20:47:57 +00002930 insertVCalls(VCallInsertionPoint);
Mike Stumpb21c4ee2009-10-14 18:14:51 +00002931 }
2932
Mike Stump9eb76d42010-01-22 06:45:05 +00002933 if (!ForNPNVBases || !WasPrimaryBase)
2934 AddAddressPoints(RD, Offset, AddressPoint);
Mike Stump2cefe382009-11-12 20:47:57 +00002935
Mike Stump37dbe962009-10-15 02:04:03 +00002936 if (alloc) {
2937 delete Path;
2938 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002939 }
2940
Mike Stump75ce5732009-10-31 20:06:59 +00002941 void Primaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
2942 bool updateVBIndex, Index_t current_vbindex,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002943 int64_t CurrentVBaseOffset) {
Mike Stump75ce5732009-10-31 20:06:59 +00002944 if (!RD->isDynamicClass())
2945 return;
2946
2947 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2948 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2949 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2950
2951 // vtables are composed from the chain of primaries.
Eli Friedman65d87222009-12-04 08:52:11 +00002952 if (PrimaryBase && !PrimaryBaseWasVirtual) {
Mike Stump75ce5732009-10-31 20:06:59 +00002953 D1(printf(" doing primaries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002954 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Eli Friedman65d87222009-12-04 08:52:11 +00002955 Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
2956 updateVBIndex, current_vbindex, CurrentVBaseOffset);
Mike Stump75ce5732009-10-31 20:06:59 +00002957 }
2958
2959 D1(printf(" doing vcall entries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002960 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump75ce5732009-10-31 20:06:59 +00002961
2962 // And add the virtuals for the class to the primary vtable.
Eli Friedman03aa2f12009-11-30 01:19:33 +00002963 AddMethods(RD, MorallyVirtual, Offset, CurrentVBaseOffset);
Mike Stump75ce5732009-10-31 20:06:59 +00002964 }
2965
2966 void VBPrimaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
2967 bool updateVBIndex, Index_t current_vbindex,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002968 bool RDisVirtualBase, int64_t CurrentVBaseOffset,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002969 bool bottom) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002970 if (!RD->isDynamicClass())
2971 return;
2972
2973 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2974 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2975 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
2976
2977 // vtables are composed from the chain of primaries.
2978 if (PrimaryBase) {
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002979 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
2980 if (PrimaryBaseWasVirtual) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002981 IndirectPrimary.insert(PrimaryBase);
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002982 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
2983 }
Mike Stump75ce5732009-10-31 20:06:59 +00002984
2985 D1(printf(" doing primaries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002986 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump75ce5732009-10-31 20:06:59 +00002987
2988 VBPrimaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00002989 updateVBIndex, current_vbindex, PrimaryBaseWasVirtual,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002990 BaseCurrentVBaseOffset, false);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002991 }
2992
Mike Stump75ce5732009-10-31 20:06:59 +00002993 D1(printf(" doing vbase entries for %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00002994 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump75ce5732009-10-31 20:06:59 +00002995 GenerateVBaseOffsets(RD, Offset, updateVBIndex, current_vbindex);
2996
2997 if (RDisVirtualBase || bottom) {
2998 Primaries(RD, MorallyVirtual, Offset, updateVBIndex, current_vbindex,
Eli Friedman03aa2f12009-11-30 01:19:33 +00002999 CurrentVBaseOffset);
Mike Stump75ce5732009-10-31 20:06:59 +00003000 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003001 }
3002
Mike Stumpd538a6d2009-12-24 07:29:41 +00003003 void GenerateVtableForBase(const CXXRecordDecl *RD, int64_t Offset = 0,
3004 bool MorallyVirtual = false,
3005 bool ForVirtualBase = false,
Mike Stump9eb76d42010-01-22 06:45:05 +00003006 bool ForNPNVBases = false,
3007 bool WasPrimaryBase = true,
Mike Stumpd538a6d2009-12-24 07:29:41 +00003008 int CurrentVBaseOffset = 0,
3009 Path_t *Path = 0) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003010 if (!RD->isDynamicClass())
Mike Stumpd538a6d2009-12-24 07:29:41 +00003011 return;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003012
Mike Stumpfa818082009-11-13 02:35:38 +00003013 // Construction vtable don't need parts that have no virtual bases and
3014 // aren't morally virtual.
Anders Carlssonbad80eb2009-12-04 18:36:22 +00003015 if ((LayoutClass != MostDerivedClass) &&
3016 RD->getNumVBases() == 0 && !MorallyVirtual)
Mike Stumpd538a6d2009-12-24 07:29:41 +00003017 return;
Mike Stumpfa818082009-11-13 02:35:38 +00003018
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003019 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3020 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
3021 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
3022
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003023 extra = 0;
Mike Stump75ce5732009-10-31 20:06:59 +00003024 D1(printf("building entries for base %s most derived %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00003025 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003026
Mike Stump75ce5732009-10-31 20:06:59 +00003027 if (ForVirtualBase)
3028 extra = VCalls.size();
3029
Mike Stump9eb76d42010-01-22 06:45:05 +00003030 if (!ForNPNVBases || !WasPrimaryBase) {
3031 VBPrimaries(RD, MorallyVirtual, Offset, !ForVirtualBase, 0,
3032 ForVirtualBase, CurrentVBaseOffset, true);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003033
Mike Stump9eb76d42010-01-22 06:45:05 +00003034 if (Path)
3035 OverrideMethods(Path, MorallyVirtual, Offset, CurrentVBaseOffset);
3036 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003037
Mike Stump9eb76d42010-01-22 06:45:05 +00003038 FinishGenerateVtable(RD, Layout, PrimaryBase, ForNPNVBases, WasPrimaryBase,
3039 PrimaryBaseWasVirtual, MorallyVirtual, Offset,
3040 ForVirtualBase, CurrentVBaseOffset, Path);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003041 }
3042
3043 void GenerateVtableForVBases(const CXXRecordDecl *RD,
3044 int64_t Offset = 0,
Mike Stump37dbe962009-10-15 02:04:03 +00003045 Path_t *Path = 0) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003046 bool alloc = false;
3047 if (Path == 0) {
3048 alloc = true;
Mike Stump37dbe962009-10-15 02:04:03 +00003049 Path = new Path_t;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003050 }
3051 // FIXME: We also need to override using all paths to a virtual base,
3052 // right now, we just process the first path
3053 Path->push_back(std::make_pair(RD, Offset));
3054 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
3055 e = RD->bases_end(); i != e; ++i) {
3056 const CXXRecordDecl *Base =
3057 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
3058 if (i->isVirtual() && !IndirectPrimary.count(Base)) {
3059 // Mark it so we don't output it twice.
3060 IndirectPrimary.insert(Base);
3061 StartNewTable();
Mike Stumpb21c4ee2009-10-14 18:14:51 +00003062 VCall.clear();
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003063 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stumpcd6f9ed2009-11-06 23:27:42 +00003064 int64_t CurrentVBaseOffset = BaseOffset;
Mike Stump75ce5732009-10-31 20:06:59 +00003065 D1(printf("vtable %s virtual base %s\n",
Mike Stumpd2808442010-01-22 02:51:26 +00003066 MostDerivedClass->getNameAsCString(), Base->getNameAsCString()));
Mike Stump9eb76d42010-01-22 06:45:05 +00003067 GenerateVtableForBase(Base, BaseOffset, true, true, false,
3068 true, CurrentVBaseOffset, Path);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003069 }
Mike Stump2cefe382009-11-12 20:47:57 +00003070 int64_t BaseOffset;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003071 if (i->isVirtual())
3072 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump2cefe382009-11-12 20:47:57 +00003073 else {
3074 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3075 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
3076 }
3077
Mike Stump37dbe962009-10-15 02:04:03 +00003078 if (Base->getNumVBases()) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003079 GenerateVtableForVBases(Base, BaseOffset, Path);
Mike Stump37dbe962009-10-15 02:04:03 +00003080 }
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003081 }
3082 Path->pop_back();
3083 if (alloc)
3084 delete Path;
3085 }
3086};
Anders Carlssonca1bf682009-12-03 01:54:02 +00003087} // end anonymous namespace
3088
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00003089bool OldVtableBuilder::OverrideMethod(GlobalDecl GD, bool MorallyVirtual,
Eli Friedman81fb0d22009-12-04 08:40:51 +00003090 Index_t OverrideOffset, Index_t Offset,
3091 int64_t CurrentVBaseOffset) {
Anders Carlssonca1bf682009-12-03 01:54:02 +00003092 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3093
3094 const bool isPure = MD->isPure();
Anders Carlsson21bbc1e2009-12-05 17:04:47 +00003095
Anders Carlssonca1bf682009-12-03 01:54:02 +00003096 // FIXME: Should OverrideOffset's be Offset?
3097
Anders Carlsson21bbc1e2009-12-05 17:04:47 +00003098 for (CXXMethodDecl::method_iterator mi = MD->begin_overridden_methods(),
3099 e = MD->end_overridden_methods(); mi != e; ++mi) {
Anders Carlssonca1bf682009-12-03 01:54:02 +00003100 GlobalDecl OGD;
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003101 GlobalDecl OGD2;
Anders Carlssonca1bf682009-12-03 01:54:02 +00003102
Anders Carlssonf3935b42009-12-04 05:51:56 +00003103 const CXXMethodDecl *OMD = *mi;
Anders Carlssonca1bf682009-12-03 01:54:02 +00003104 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(OMD))
3105 OGD = GlobalDecl(DD, GD.getDtorType());
3106 else
3107 OGD = OMD;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003108
Eli Friedman8174f2c2009-12-06 22:01:30 +00003109 // Check whether this is the method being overridden in this section of
3110 // the vtable.
Anders Carlsson7bb70762009-12-04 15:49:02 +00003111 uint64_t Index;
3112 if (!Methods.getIndex(OGD, Index))
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003113 continue;
3114
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003115 OGD2 = OGD;
3116
Eli Friedman8174f2c2009-12-06 22:01:30 +00003117 // Get the original method, which we should be computing thunks, etc,
3118 // against.
3119 OGD = Methods.getOrigMethod(Index);
3120 OMD = cast<CXXMethodDecl>(OGD.getDecl());
3121
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003122 QualType ReturnType =
3123 MD->getType()->getAs<FunctionType>()->getResultType();
3124 QualType OverriddenReturnType =
3125 OMD->getType()->getAs<FunctionType>()->getResultType();
Anders Carlssonca1bf682009-12-03 01:54:02 +00003126
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003127 // Check if we need a return type adjustment.
Anders Carlssoncce9ee82010-02-13 23:17:31 +00003128 if (!ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
3129 OMD).isEmpty()) {
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003130 CanQualType &BaseReturnType = BaseReturnTypes[Index];
Anders Carlssonca1bf682009-12-03 01:54:02 +00003131
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003132 // Insert the base return type.
3133 if (BaseReturnType.isNull())
3134 BaseReturnType =
3135 CGM.getContext().getCanonicalType(OverriddenReturnType);
3136 }
Anders Carlssona93e9802009-12-04 03:52:52 +00003137
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003138 Methods.OverrideMethod(OGD, GD);
3139
Anders Carlsson72281172010-01-26 17:36:47 +00003140 GlobalDecl UGD = getUnique(GD);
3141 const CXXMethodDecl *UMD = cast<CXXMethodDecl>(UGD.getDecl());
3142 assert(UGD.getDecl() && "unique overrider not found");
3143 assert(UGD == getUnique(OGD) && "unique overrider not unique");
Mike Stump90181eb2010-01-26 00:05:04 +00003144
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003145 ThisAdjustments.erase(Index);
Mike Stump90181eb2010-01-26 00:05:04 +00003146 if (MorallyVirtual || VCall.count(UMD)) {
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003147
Mike Stump90181eb2010-01-26 00:05:04 +00003148 Index_t &idx = VCall[UMD];
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003149 if (idx == 0) {
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003150 VCallOffset[GD] = VCallOffset[OGD];
3151 // NonVirtualOffset[UMD] = CurrentVBaseOffset/8 - OverrideOffset/8;
3152 NonVirtualOffset[UMD] = VCallOffset[OGD];
Mike Stump77537b12010-01-26 03:42:22 +00003153 VCallOffsetForVCall[UMD] = OverrideOffset/8;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003154 idx = VCalls.size()+1;
Mike Stump77537b12010-01-26 03:42:22 +00003155 VCalls.push_back(OverrideOffset/8 - CurrentVBaseOffset/8);
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003156 D1(printf(" vcall for %s at %d with delta %d most derived %s\n",
3157 MD->getNameAsString().c_str(), (int)-idx-3,
Mike Stumpd2808442010-01-22 02:51:26 +00003158 (int)VCalls[idx-1], MostDerivedClass->getNameAsCString()));
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003159 } else {
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003160 VCallOffset[GD] = NonVirtualOffset[UMD];
Anders Carlsson72281172010-01-26 17:36:47 +00003161 VCalls[idx-1] = -VCallOffsetForVCall[UGD] + OverrideOffset/8;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003162 D1(printf(" vcall patch for %s at %d with delta %d most derived %s\n",
3163 MD->getNameAsString().c_str(), (int)-idx-3,
Mike Stumpd2808442010-01-22 02:51:26 +00003164 (int)VCalls[idx-1], MostDerivedClass->getNameAsCString()));
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003165 }
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003166 int64_t NonVirtualAdjustment = -VCallOffset[OGD];
Mike Stumpded0a402010-01-26 22:44:01 +00003167 QualType DerivedType = MD->getThisType(CGM.getContext());
3168 QualType BaseType = cast<const CXXMethodDecl>(OGD.getDecl())->getThisType(CGM.getContext());
3169 int64_t NonVirtualAdjustment2 = -(getNVOffset(BaseType, DerivedType)/8);
3170 if (NonVirtualAdjustment2 != NonVirtualAdjustment) {
3171 NonVirtualAdjustment = NonVirtualAdjustment2;
3172 }
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003173 int64_t VirtualAdjustment =
3174 -((idx + extra + 2) * LLVMPointerWidth / 8);
Anders Carlsson657f1392009-12-03 02:32:59 +00003175
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003176 // Optimize out virtual adjustments of 0.
3177 if (VCalls[idx-1] == 0)
3178 VirtualAdjustment = 0;
Anders Carlsson657f1392009-12-03 02:32:59 +00003179
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003180 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment,
3181 VirtualAdjustment);
Anders Carlsson2ca285f2009-12-03 02:22:59 +00003182
Eli Friedman8174f2c2009-12-06 22:01:30 +00003183 if (!isPure && !ThisAdjustment.isEmpty()) {
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003184 ThisAdjustments[Index] = ThisAdjustment;
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003185 SavedAdjustments.push_back(
3186 std::make_pair(GD, std::make_pair(OGD, ThisAdjustment)));
Eli Friedman8174f2c2009-12-06 22:01:30 +00003187 }
Anders Carlssonca1bf682009-12-03 01:54:02 +00003188 return true;
3189 }
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003190
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003191 VCallOffset[GD] = VCallOffset[OGD2] - OverrideOffset/8;
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003192
Mike Stumpa04ecfb2010-01-26 21:35:27 +00003193 int64_t NonVirtualAdjustment = -VCallOffset[GD];
3194 QualType DerivedType = MD->getThisType(CGM.getContext());
3195 QualType BaseType = cast<const CXXMethodDecl>(OGD.getDecl())->getThisType(CGM.getContext());
3196 int64_t NonVirtualAdjustment2 = -(getNVOffset(BaseType, DerivedType)/8);
3197 if (NonVirtualAdjustment2 != NonVirtualAdjustment) {
3198 NonVirtualAdjustment = NonVirtualAdjustment2;
3199 }
3200
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003201 if (NonVirtualAdjustment) {
3202 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment, 0);
3203
Eli Friedmanf2eda5e2009-12-06 22:33:51 +00003204 if (!isPure) {
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003205 ThisAdjustments[Index] = ThisAdjustment;
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003206 SavedAdjustments.push_back(
3207 std::make_pair(GD, std::make_pair(OGD, ThisAdjustment)));
Eli Friedmanf2eda5e2009-12-06 22:33:51 +00003208 }
Eli Friedman3d2e9de2009-12-04 08:34:14 +00003209 }
3210 return true;
Anders Carlssonca1bf682009-12-03 01:54:02 +00003211 }
3212
3213 return false;
Anders Carlssond59885022009-11-27 22:21:51 +00003214}
3215
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00003216void OldVtableBuilder::AppendMethodsToVtable() {
Eli Friedman6c08ce72009-12-05 01:05:03 +00003217 if (!BuildVtable) {
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003218 VtableComponents.insert(VtableComponents.end(), Methods.size(),
3219 (llvm::Constant *)0);
Eli Friedman6c08ce72009-12-05 01:05:03 +00003220 ThisAdjustments.clear();
3221 BaseReturnTypes.clear();
3222 Methods.clear();
3223 return;
3224 }
3225
Anders Carlsson472404f2009-12-04 16:19:30 +00003226 // Reserve room in the vtable for our new methods.
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003227 VtableComponents.reserve(VtableComponents.size() + Methods.size());
Anders Carlssonb07567c2009-12-04 03:07:26 +00003228
Anders Carlsson86809cd2009-12-04 02:43:50 +00003229 for (unsigned i = 0, e = Methods.size(); i != e; ++i) {
3230 GlobalDecl GD = Methods[i];
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00003231 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3232
3233 // Get the 'this' pointer adjustment.
Anders Carlsson86809cd2009-12-04 02:43:50 +00003234 ThunkAdjustment ThisAdjustment = ThisAdjustments.lookup(i);
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00003235
3236 // Construct the return type adjustment.
3237 ThunkAdjustment ReturnAdjustment;
3238
3239 QualType BaseReturnType = BaseReturnTypes.lookup(i);
3240 if (!BaseReturnType.isNull() && !MD->isPure()) {
3241 QualType DerivedType =
3242 MD->getType()->getAs<FunctionType>()->getResultType();
3243
3244 int64_t NonVirtualAdjustment =
3245 getNVOffset(BaseReturnType, DerivedType) / 8;
3246
3247 int64_t VirtualAdjustment =
3248 getVbaseOffset(BaseReturnType, DerivedType);
3249
3250 ReturnAdjustment = ThunkAdjustment(NonVirtualAdjustment,
3251 VirtualAdjustment);
3252 }
3253
Anders Carlsson50f14742009-12-04 03:06:03 +00003254 llvm::Constant *Method = 0;
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00003255 if (!ReturnAdjustment.isEmpty()) {
3256 // Build a covariant thunk.
3257 CovariantThunkAdjustment Adjustment(ThisAdjustment, ReturnAdjustment);
Eli Friedman8174f2c2009-12-06 22:01:30 +00003258 Method = wrap(CGM.GetAddrOfCovariantThunk(GD, Adjustment));
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00003259 } else if (!ThisAdjustment.isEmpty()) {
3260 // Build a "regular" thunk.
Eli Friedman8174f2c2009-12-06 22:01:30 +00003261 Method = wrap(CGM.GetAddrOfThunk(GD, ThisAdjustment));
Anders Carlssonddf42c82009-12-04 02:56:03 +00003262 } else if (MD->isPure()) {
3263 // We have a pure virtual method.
Anders Carlsson50f14742009-12-04 03:06:03 +00003264 Method = getPureVirtualFn();
3265 } else {
3266 // We have a good old regular method.
3267 Method = WrapAddrOf(GD);
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00003268 }
Anders Carlsson50f14742009-12-04 03:06:03 +00003269
3270 // Add the method to the vtable.
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003271 VtableComponents.push_back(Method);
Anders Carlsson86809cd2009-12-04 02:43:50 +00003272 }
3273
Anders Carlsson50f14742009-12-04 03:06:03 +00003274
Anders Carlsson86809cd2009-12-04 02:43:50 +00003275 ThisAdjustments.clear();
Anders Carlsson5b3ea9b2009-12-04 02:52:22 +00003276 BaseReturnTypes.clear();
Anders Carlsson86809cd2009-12-04 02:43:50 +00003277
Anders Carlsson495634e2009-12-04 02:39:04 +00003278 Methods.clear();
Anders Carlsson495634e2009-12-04 02:39:04 +00003279}
3280
Anders Carlssonf942ee02009-11-27 20:47:55 +00003281void CGVtableInfo::ComputeMethodVtableIndices(const CXXRecordDecl *RD) {
3282
3283 // Itanium C++ ABI 2.5.2:
Anders Carlsson259688c2010-02-02 03:37:46 +00003284 // The order of the virtual function pointers in a virtual table is the
3285 // order of declaration of the corresponding member functions in the class.
Anders Carlssonf942ee02009-11-27 20:47:55 +00003286 //
Anders Carlsson259688c2010-02-02 03:37:46 +00003287 // There is an entry for any virtual function declared in a class,
3288 // whether it is a new function or overrides a base class function,
3289 // unless it overrides a function from the primary base, and conversion
3290 // between their return types does not require an adjustment.
Anders Carlssonf942ee02009-11-27 20:47:55 +00003291
3292 int64_t CurrentIndex = 0;
3293
3294 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3295 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
3296
3297 if (PrimaryBase) {
Anders Carlssonc920fa22009-11-30 19:43:26 +00003298 assert(PrimaryBase->isDefinition() &&
3299 "Should have the definition decl of the primary base!");
Anders Carlssonf942ee02009-11-27 20:47:55 +00003300
3301 // Since the record decl shares its vtable pointer with the primary base
3302 // we need to start counting at the end of the primary base's vtable.
3303 CurrentIndex = getNumVirtualFunctionPointers(PrimaryBase);
3304 }
Eli Friedman21517252009-12-15 03:31:17 +00003305
3306 // Collect all the primary bases, so we can check whether methods override
3307 // a method from the base.
Anders Carlssond46ed892010-02-27 16:18:19 +00003308 VtableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
Eli Friedman21517252009-12-15 03:31:17 +00003309 for (ASTRecordLayout::primary_base_info_iterator
3310 I = Layout.primary_base_begin(), E = Layout.primary_base_end();
3311 I != E; ++I)
3312 PrimaryBases.insert((*I).getBase());
3313
Anders Carlssonf942ee02009-11-27 20:47:55 +00003314 const CXXDestructorDecl *ImplicitVirtualDtor = 0;
3315
3316 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
3317 e = RD->method_end(); i != e; ++i) {
3318 const CXXMethodDecl *MD = *i;
3319
3320 // We only want virtual methods.
3321 if (!MD->isVirtual())
3322 continue;
3323
Anders Carlssonf942ee02009-11-27 20:47:55 +00003324 // Check if this method overrides a method in the primary base.
Anders Carlsson65b49782010-02-12 05:25:12 +00003325 if (const CXXMethodDecl *OverriddenMD =
Anders Carlssond2025412010-02-27 06:38:03 +00003326 OverridesMethodInBases(MD, PrimaryBases)) {
Anders Carlsson65b49782010-02-12 05:25:12 +00003327 // Check if converting from the return type of the method to the
3328 // return type of the overridden method requires conversion.
Anders Carlssoncce9ee82010-02-13 23:17:31 +00003329 if (ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
3330 OverriddenMD).isEmpty()) {
Anders Carlsson65b49782010-02-12 05:25:12 +00003331 // This index is shared between the index in the vtable of the primary
3332 // base class.
3333 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3334 const CXXDestructorDecl *OverriddenDD =
3335 cast<CXXDestructorDecl>(OverriddenMD);
Anders Carlssonf942ee02009-11-27 20:47:55 +00003336
Anders Carlsson65b49782010-02-12 05:25:12 +00003337 // Add both the complete and deleting entries.
3338 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] =
3339 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Complete));
3340 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] =
3341 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
3342 } else {
3343 MethodVtableIndices[MD] = getMethodVtableIndex(OverriddenMD);
3344 }
3345
3346 // We don't need to add an entry for this method.
Anders Carlsson07604812010-02-12 18:14:46 +00003347 continue;
Anders Carlssonf942ee02009-11-27 20:47:55 +00003348 }
3349 }
3350
Anders Carlssonf942ee02009-11-27 20:47:55 +00003351 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3352 if (MD->isImplicit()) {
3353 assert(!ImplicitVirtualDtor &&
3354 "Did already see an implicit virtual dtor!");
3355 ImplicitVirtualDtor = DD;
3356 continue;
3357 }
3358
3359 // Add the complete dtor.
3360 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++;
3361
3362 // Add the deleting dtor.
3363 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
3364 } else {
3365 // Add the entry.
3366 MethodVtableIndices[MD] = CurrentIndex++;
3367 }
3368 }
3369
3370 if (ImplicitVirtualDtor) {
3371 // Itanium C++ ABI 2.5.2:
Anders Carlssondc2dba32010-02-16 04:49:44 +00003372 // If a class has an implicitly-defined virtual destructor,
3373 // its entries come after the declared virtual function pointers.
Anders Carlssonf942ee02009-11-27 20:47:55 +00003374
3375 // Add the complete dtor.
3376 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Complete)] =
3377 CurrentIndex++;
3378
3379 // Add the deleting dtor.
3380 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Deleting)] =
3381 CurrentIndex++;
3382 }
3383
3384 NumVirtualFunctionPointers[RD] = CurrentIndex;
3385}
3386
3387uint64_t CGVtableInfo::getNumVirtualFunctionPointers(const CXXRecordDecl *RD) {
3388 llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
3389 NumVirtualFunctionPointers.find(RD);
3390 if (I != NumVirtualFunctionPointers.end())
3391 return I->second;
3392
3393 ComputeMethodVtableIndices(RD);
3394
3395 I = NumVirtualFunctionPointers.find(RD);
3396 assert(I != NumVirtualFunctionPointers.end() && "Did not find entry!");
3397 return I->second;
3398}
3399
3400uint64_t CGVtableInfo::getMethodVtableIndex(GlobalDecl GD) {
Anders Carlssonfb4dda42009-11-13 17:08:56 +00003401 MethodVtableIndicesTy::iterator I = MethodVtableIndices.find(GD);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003402 if (I != MethodVtableIndices.end())
3403 return I->second;
3404
Anders Carlssonfb4dda42009-11-13 17:08:56 +00003405 const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
Anders Carlssonf942ee02009-11-27 20:47:55 +00003406
3407 ComputeMethodVtableIndices(RD);
3408
Anders Carlssonfb4dda42009-11-13 17:08:56 +00003409 I = MethodVtableIndices.find(GD);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003410 assert(I != MethodVtableIndices.end() && "Did not find index!");
3411 return I->second;
3412}
3413
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003414CGVtableInfo::AdjustmentVectorTy*
3415CGVtableInfo::getAdjustments(GlobalDecl GD) {
3416 SavedAdjustmentsTy::iterator I = SavedAdjustments.find(GD);
3417 if (I != SavedAdjustments.end())
3418 return &I->second;
Eli Friedman8174f2c2009-12-06 22:01:30 +00003419
3420 const CXXRecordDecl *RD = cast<CXXRecordDecl>(GD.getDecl()->getDeclContext());
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003421 if (!SavedAdjustmentRecords.insert(RD).second)
3422 return 0;
Eli Friedman8174f2c2009-12-06 22:01:30 +00003423
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003424 AddressPointsMapTy AddressPoints;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00003425 OldVtableBuilder b(RD, RD, 0, CGM, false, AddressPoints);
Eli Friedman8174f2c2009-12-06 22:01:30 +00003426 D1(printf("vtable %s\n", RD->getNameAsCString()));
3427 b.GenerateVtableForBase(RD);
3428 b.GenerateVtableForVBases(RD);
Eli Friedman8174f2c2009-12-06 22:01:30 +00003429
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00003430 for (OldVtableBuilder::SavedAdjustmentsVectorTy::iterator
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003431 i = b.getSavedAdjustments().begin(),
3432 e = b.getSavedAdjustments().end(); i != e; i++)
3433 SavedAdjustments[i->first].push_back(i->second);
Eli Friedman8174f2c2009-12-06 22:01:30 +00003434
Eli Friedman31bc3ad2009-12-07 23:56:34 +00003435 I = SavedAdjustments.find(GD);
3436 if (I != SavedAdjustments.end())
3437 return &I->second;
3438
3439 return 0;
Eli Friedman8174f2c2009-12-06 22:01:30 +00003440}
3441
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00003442int64_t CGVtableInfo::getVirtualBaseOffsetOffset(const CXXRecordDecl *RD,
3443 const CXXRecordDecl *VBase) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003444 ClassPairTy ClassPair(RD, VBase);
3445
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00003446 VirtualBaseClassOffsetOffsetsMapTy::iterator I =
3447 VirtualBaseClassOffsetOffsets.find(ClassPair);
3448 if (I != VirtualBaseClassOffsetOffsets.end())
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003449 return I->second;
3450
Anders Carlssondd819c92010-03-11 16:06:20 +00003451 VCallAndVBaseOffsetBuilder Builder(RD, RD, /*FinalOverriders=*/0,
3452 BaseSubobject(RD, 0),
3453 /*BaseIsVirtual=*/false,
3454 /*OffsetInLayoutClass=*/0);
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003455
Anders Carlssondd819c92010-03-11 16:06:20 +00003456
3457 for (VCallAndVBaseOffsetBuilder::VBaseOffsetOffsetsMapTy::const_iterator I =
3458 Builder.getVBaseOffsetOffsets().begin(),
3459 E = Builder.getVBaseOffsetOffsets().end(); I != E; ++I) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003460 // Insert all types.
3461 ClassPairTy ClassPair(RD, I->first);
3462
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00003463 VirtualBaseClassOffsetOffsets.insert(std::make_pair(ClassPair, I->second));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003464 }
3465
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00003466 I = VirtualBaseClassOffsetOffsets.find(ClassPair);
Anders Carlssondd819c92010-03-11 16:06:20 +00003467
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00003468 // FIXME: The assertion below assertion currently fails with the old vtable
3469 /// layout code if there is a non-virtual thunk adjustment in a vtable.
3470 // Once the new layout is in place, this return should be removed.
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00003471 if (I == VirtualBaseClassOffsetOffsets.end())
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00003472 return 0;
3473
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00003474 assert(I != VirtualBaseClassOffsetOffsets.end() && "Did not find index!");
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003475
3476 return I->second;
3477}
3478
Anders Carlssonc8e39ec2009-12-05 21:03:56 +00003479uint64_t CGVtableInfo::getVtableAddressPoint(const CXXRecordDecl *RD) {
3480 uint64_t AddressPoint =
Anders Carlsson93a18842010-01-02 18:02:32 +00003481 (*(*(CGM.getVtableInfo().AddressPoints[RD]))[RD])[std::make_pair(RD, 0)];
Anders Carlssonc8e39ec2009-12-05 21:03:56 +00003482
3483 return AddressPoint;
3484}
3485
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003486llvm::GlobalVariable *
Anders Carlsson0911ae82009-12-06 00:23:49 +00003487CGVtableInfo::GenerateVtable(llvm::GlobalVariable::LinkageTypes Linkage,
Anders Carlsson232324c2009-12-06 00:53:22 +00003488 bool GenerateDefinition,
Anders Carlsson0911ae82009-12-06 00:23:49 +00003489 const CXXRecordDecl *LayoutClass,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003490 const CXXRecordDecl *RD, uint64_t Offset,
Anders Carlsson62c6c722010-02-28 00:36:23 +00003491 bool IsVirtual,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003492 AddressPointsMapTy& AddressPoints) {
Anders Carlsson93913752010-02-27 20:39:05 +00003493 if (GenerateDefinition) {
3494 if (LayoutClass == RD) {
Anders Carlsson62c6c722010-02-28 00:36:23 +00003495 assert(!IsVirtual &&
Anders Carlssond5531e22010-03-11 05:48:21 +00003496 "Can only have a virtual base in construction vtables!");
3497 assert(!Offset &&
3498 "Can only have a base offset in construction vtables!");
Anders Carlsson93913752010-02-27 20:39:05 +00003499 }
Anders Carlssond5531e22010-03-11 05:48:21 +00003500
3501 VtableBuilder Builder(*this, RD, Offset,
Anders Carlsson9f28dbc2010-03-11 06:10:52 +00003502 /*MostDerivedClassIsVirtual=*/IsVirtual,
Anders Carlssond5531e22010-03-11 05:48:21 +00003503 LayoutClass);
3504
3505 if (CGM.getLangOptions().DumpVtableLayouts)
3506 Builder.dumpLayout(llvm::errs());
Anders Carlssoneee53d92010-02-13 02:02:03 +00003507 }
3508
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003509 llvm::SmallString<256> OutName;
Mike Stump2cefe382009-11-12 20:47:57 +00003510 if (LayoutClass != RD)
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003511 CGM.getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset / 8,
3512 RD, OutName);
Mike Stumpeac45592009-11-11 20:26:26 +00003513 else
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003514 CGM.getMangleContext().mangleCXXVtable(RD, OutName);
Daniel Dunbare128dd12009-11-21 09:06:22 +00003515 llvm::StringRef Name = OutName.str();
Benjamin Kramerbb0a07b2009-10-11 22:57:54 +00003516
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003517 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
Anders Carlsson93a18842010-01-02 18:02:32 +00003518 if (GV == 0 || CGM.getVtableInfo().AddressPoints[LayoutClass] == 0 ||
3519 GV->isDeclaration()) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00003520 OldVtableBuilder b(RD, LayoutClass, Offset, CGM, GenerateDefinition,
3521 AddressPoints);
Eli Friedman6c08ce72009-12-05 01:05:03 +00003522
3523 D1(printf("vtable %s\n", RD->getNameAsCString()));
3524 // First comes the vtables for all the non-virtual bases...
Mike Stumpd538a6d2009-12-24 07:29:41 +00003525 b.GenerateVtableForBase(RD, Offset);
Eli Friedman6c08ce72009-12-05 01:05:03 +00003526
3527 // then the vtables for all the virtual bases.
3528 b.GenerateVtableForVBases(RD, Offset);
3529
Anders Carlsson58b271d2009-12-05 22:19:10 +00003530 llvm::Constant *Init = 0;
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003531 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
Anders Carlsson58b271d2009-12-05 22:19:10 +00003532 llvm::ArrayType *ArrayType =
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003533 llvm::ArrayType::get(Int8PtrTy, b.getVtableComponents().size());
Anders Carlssona95d4c52009-12-05 21:09:05 +00003534
Anders Carlsson232324c2009-12-06 00:53:22 +00003535 if (GenerateDefinition)
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003536 Init = llvm::ConstantArray::get(ArrayType, &b.getVtableComponents()[0],
3537 b.getVtableComponents().size());
Anders Carlsson232324c2009-12-06 00:53:22 +00003538
Mike Stumpaa51ad62009-11-19 04:04:36 +00003539 llvm::GlobalVariable *OGV = GV;
Anders Carlsson232324c2009-12-06 00:53:22 +00003540
3541 GV = new llvm::GlobalVariable(CGM.getModule(), ArrayType,
3542 /*isConstant=*/true, Linkage, Init, Name);
Anders Carlssonfe5f7d92009-12-06 01:09:21 +00003543 CGM.setGlobalVisibility(GV, RD);
3544
Mike Stumpaa51ad62009-11-19 04:04:36 +00003545 if (OGV) {
3546 GV->takeName(OGV);
Anders Carlsson58b271d2009-12-05 22:19:10 +00003547 llvm::Constant *NewPtr =
3548 llvm::ConstantExpr::getBitCast(GV, OGV->getType());
Mike Stumpaa51ad62009-11-19 04:04:36 +00003549 OGV->replaceAllUsesWith(NewPtr);
3550 OGV->eraseFromParent();
3551 }
Mike Stumpaa51ad62009-11-19 04:04:36 +00003552 }
Anders Carlssonb3f54b72009-12-05 21:28:12 +00003553
3554 return GV;
Anders Carlsson2bb27f52009-10-11 22:13:54 +00003555}
Mike Stump9f23a142009-11-10 02:30:51 +00003556
Anders Carlsson232324c2009-12-06 00:53:22 +00003557void CGVtableInfo::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage,
3558 const CXXRecordDecl *RD) {
Anders Carlssone1b3e622009-12-07 07:59:52 +00003559 llvm::GlobalVariable *&Vtable = Vtables[RD];
3560 if (Vtable) {
3561 assert(Vtable->getInitializer() && "Vtable doesn't have a definition!");
3562 return;
3563 }
3564
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003565 AddressPointsMapTy AddressPoints;
3566 Vtable = GenerateVtable(Linkage, /*GenerateDefinition=*/true, RD, RD, 0,
Anders Carlsson62c6c722010-02-28 00:36:23 +00003567 /*IsVirtual=*/false,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003568 AddressPoints);
Rafael Espindolae7113ca2010-03-10 02:19:29 +00003569 GenerateVTT(Linkage, /*GenerateDefinition=*/true, RD);
3570
3571 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
3572 e = RD->method_end(); i != e; ++i) {
3573 if (!(*i)->isVirtual())
3574 continue;
3575 if(!(*i)->hasInlineBody() && !(*i)->isImplicit())
3576 continue;
3577
3578 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(*i)) {
3579 CGM.BuildThunksForVirtual(GlobalDecl(DD, Dtor_Complete));
3580 CGM.BuildThunksForVirtual(GlobalDecl(DD, Dtor_Deleting));
3581 } else {
3582 CGM.BuildThunksForVirtual(GlobalDecl(*i));
3583 }
3584 }
Mike Stump1a139f82009-11-19 01:08:19 +00003585}
3586
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003587llvm::GlobalVariable *CGVtableInfo::getVtable(const CXXRecordDecl *RD) {
Anders Carlsson232324c2009-12-06 00:53:22 +00003588 llvm::GlobalVariable *Vtable = Vtables.lookup(RD);
Anders Carlsson7e28c5f2009-12-06 00:01:05 +00003589
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003590 if (!Vtable) {
3591 AddressPointsMapTy AddressPoints;
Anders Carlsson232324c2009-12-06 00:53:22 +00003592 Vtable = GenerateVtable(llvm::GlobalValue::ExternalLinkage,
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003593 /*GenerateDefinition=*/false, RD, RD, 0,
Anders Carlsson62c6c722010-02-28 00:36:23 +00003594 /*IsVirtual=*/false, AddressPoints);
Anders Carlsson5f9a8812010-01-14 02:29:07 +00003595 }
Mike Stumpaa51ad62009-11-19 04:04:36 +00003596
Anders Carlsson4ed44eb2009-12-05 22:42:54 +00003597 return Vtable;
Mike Stumpd846d082009-11-10 07:44:33 +00003598}
Mike Stumpeac45592009-11-11 20:26:26 +00003599
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003600void CGVtableInfo::MaybeEmitVtable(GlobalDecl GD) {
3601 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3602 const CXXRecordDecl *RD = MD->getParent();
3603
Anders Carlsson4ed44eb2009-12-05 22:42:54 +00003604 // If the class doesn't have a vtable we don't need to emit one.
3605 if (!RD->isDynamicClass())
3606 return;
3607
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003608 // Get the key function.
Anders Carlsson5ebf8b42009-12-07 04:35:11 +00003609 const CXXMethodDecl *KeyFunction = CGM.getContext().getKeyFunction(RD);
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003610
Anders Carlsson4ed44eb2009-12-05 22:42:54 +00003611 if (KeyFunction) {
3612 // We don't have the right key function.
3613 if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl())
3614 return;
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003615 }
3616
Rafael Espindolae7113ca2010-03-10 02:19:29 +00003617 if (Vtables.count(RD))
3618 return;
Eli Friedman8174f2c2009-12-06 22:01:30 +00003619
Rafael Espindolae7113ca2010-03-10 02:19:29 +00003620 TemplateSpecializationKind kind = RD->getTemplateSpecializationKind();
3621 if (kind == TSK_ImplicitInstantiation)
3622 CGM.DeferredVtables.push_back(RD);
3623 else
3624 GenerateClassData(CGM.getVtableLinkage(RD), RD);
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +00003625}