blob: f44b7ccb189d6b5b54c2fac7f8c60f42e7fbe390 [file] [log] [blame]
Anders Carlssondbd920c2009-10-11 22:13:54 +00001//===--- CGVtable.cpp - Emit LLVM Code for C++ vtables --------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code dealing with C++ code generation of virtual tables.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
15#include "CodeGenFunction.h"
Anders Carlssond6b07fb2009-11-27 20:47:55 +000016#include "clang/AST/CXXInheritance.h"
Anders Carlssondbd920c2009-10-11 22:13:54 +000017#include "clang/AST/RecordLayout.h"
Anders Carlsson5dd730a2009-11-26 19:32:45 +000018#include "llvm/ADT/DenseSet.h"
Anders Carlssonb9021e92010-02-27 16:18:19 +000019#include "llvm/ADT/SetVector.h"
Chandler Carruthe087f072010-02-13 10:38:52 +000020#include "llvm/Support/Compiler.h"
Anders Carlsson824d7ea2010-02-11 08:02:13 +000021#include "llvm/Support/Format.h"
Anders Carlsson5e454aa2010-03-17 20:06:32 +000022#include <algorithm>
Zhongxing Xu7fe26ac2009-11-13 05:46:16 +000023#include <cstdio>
Anders Carlssondbd920c2009-10-11 22:13:54 +000024
25using namespace clang;
26using namespace CodeGen;
27
Anders Carlsson27f69d02009-11-27 22:21:51 +000028namespace {
Anders Carlsson824d7ea2010-02-11 08:02:13 +000029
Anders Carlsson2fca9be2010-02-23 01:34:28 +000030/// BaseOffset - Represents an offset from a derived class to a direct or
31/// indirect base class.
32struct BaseOffset {
33 /// DerivedClass - The derived class.
34 const CXXRecordDecl *DerivedClass;
35
36 /// VirtualBase - If the path from the derived class to the base class
37 /// involves a virtual base class, this holds its declaration.
38 const CXXRecordDecl *VirtualBase;
39
40 /// NonVirtualOffset - The offset from the derived class to the base class.
41 /// (Or the offset from the virtual base class to the base class, if the
42 /// path from the derived class to the base class involves a virtual base
43 /// class.
44 int64_t NonVirtualOffset;
45
46 BaseOffset() : DerivedClass(0), VirtualBase(0), NonVirtualOffset(0) { }
47 BaseOffset(const CXXRecordDecl *DerivedClass,
48 const CXXRecordDecl *VirtualBase, int64_t NonVirtualOffset)
49 : DerivedClass(DerivedClass), VirtualBase(VirtualBase),
50 NonVirtualOffset(NonVirtualOffset) { }
51
52 bool isEmpty() const { return !NonVirtualOffset && !VirtualBase; }
53};
54
Anders Carlssonbdf73d82010-02-11 21:24:32 +000055/// FinalOverriders - Contains the final overrider member functions for all
56/// member functions in the base subobjects of a class.
57class FinalOverriders {
Anders Carlssona7575822010-02-12 16:55:34 +000058public:
59 /// OverriderInfo - Information about a final overrider.
60 struct OverriderInfo {
61 /// Method - The method decl of the overrider.
62 const CXXMethodDecl *Method;
Anders Carlsson96309c42010-02-18 16:29:24 +000063
Anders Carlssondb4022c2010-03-10 02:33:41 +000064 /// Offset - the base offset of the overrider in the layout class.
65 uint64_t Offset;
Anders Carlssona7575822010-02-12 16:55:34 +000066
Anders Carlssoncd0d27f2010-03-12 05:02:01 +000067 OverriderInfo() : Method(0), Offset(0) { }
Anders Carlssona7575822010-02-12 16:55:34 +000068 };
69
70private:
Anders Carlssonbdf73d82010-02-11 21:24:32 +000071 /// MostDerivedClass - The most derived class for which the final overriders
72 /// are stored.
73 const CXXRecordDecl *MostDerivedClass;
74
Anders Carlssondb4022c2010-03-10 02:33:41 +000075 /// MostDerivedClassOffset - If we're building final overriders for a
76 /// construction vtable, this holds the offset from the layout class to the
77 /// most derived class.
78 const uint64_t MostDerivedClassOffset;
79
80 /// LayoutClass - The class we're using for layout information. Will be
81 /// different than the most derived class if the final overriders are for a
82 /// construction vtable.
83 const CXXRecordDecl *LayoutClass;
84
Anders Carlssonbdf73d82010-02-11 21:24:32 +000085 ASTContext &Context;
86
87 /// MostDerivedClassLayout - the AST record layout of the most derived class.
88 const ASTRecordLayout &MostDerivedClassLayout;
89
Anders Carlsson0c0eeb22010-02-13 02:02:03 +000090 /// BaseSubobjectMethodPairTy - Uniquely identifies a member function
91 /// in a base subobject.
92 typedef std::pair<BaseSubobject, const CXXMethodDecl *>
93 BaseSubobjectMethodPairTy;
94
95 typedef llvm::DenseMap<BaseSubobjectMethodPairTy,
Anders Carlssona7575822010-02-12 16:55:34 +000096 OverriderInfo> OverridersMapTy;
Anders Carlssonbdf73d82010-02-11 21:24:32 +000097
98 /// OverridersMap - The final overriders for all virtual member functions of
99 /// all the base subobjects of the most derived class.
100 OverridersMapTy OverridersMap;
101
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000102 /// VisitedVirtualBases - A set of all the visited virtual bases, used to
103 /// avoid visiting virtual bases more than once.
104 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
105
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000106 typedef llvm::DenseMap<BaseSubobjectMethodPairTy, BaseOffset>
107 AdjustmentOffsetsMapTy;
108
109 /// ReturnAdjustments - Holds return adjustments for all the overriders that
110 /// need to perform return value adjustments.
111 AdjustmentOffsetsMapTy ReturnAdjustments;
Anders Carlssondf31af12010-02-13 23:17:31 +0000112
Anders Carlssonce57dd52010-03-03 04:58:02 +0000113 // FIXME: We might be able to get away with making this a SmallSet.
114 typedef llvm::SmallSetVector<uint64_t, 2> OffsetSetVectorTy;
Anders Carlssonb8358d82010-02-12 01:40:03 +0000115
116 /// SubobjectOffsetsMapTy - This map is used for keeping track of all the
117 /// base subobject offsets that a single class declaration might refer to.
118 ///
119 /// For example, in:
120 ///
121 /// struct A { virtual void f(); };
122 /// struct B1 : A { };
123 /// struct B2 : A { };
124 /// struct C : B1, B2 { virtual void f(); };
125 ///
126 /// when we determine that C::f() overrides A::f(), we need to update the
127 /// overriders map for both A-in-B1 and A-in-B2 and the subobject offsets map
128 /// will have the subobject offsets for both A copies.
Anders Carlssonce57dd52010-03-03 04:58:02 +0000129 typedef llvm::DenseMap<const CXXRecordDecl *, OffsetSetVectorTy>
Anders Carlssonb8358d82010-02-12 01:40:03 +0000130 SubobjectOffsetsMapTy;
131
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000132 /// ComputeFinalOverriders - Compute the final overriders for a given base
133 /// subobject (and all its direct and indirect bases).
Anders Carlssonb8358d82010-02-12 01:40:03 +0000134 void ComputeFinalOverriders(BaseSubobject Base,
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000135 bool BaseSubobjectIsVisitedVBase,
Anders Carlssondb4022c2010-03-10 02:33:41 +0000136 uint64_t OffsetInLayoutClass,
Anders Carlssonb8358d82010-02-12 01:40:03 +0000137 SubobjectOffsetsMapTy &Offsets);
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000138
139 /// AddOverriders - Add the final overriders for this base subobject to the
140 /// map of final overriders.
Anders Carlssonc1246c82010-03-26 00:35:45 +0000141 void AddOverriders(BaseSubobject Base, uint64_t OffsetInLayoutClass,
Anders Carlssondb4022c2010-03-10 02:33:41 +0000142 SubobjectOffsetsMapTy &Offsets);
Anders Carlssonb8358d82010-02-12 01:40:03 +0000143
144 /// PropagateOverrider - Propagate the NewMD overrider to all the functions
145 /// that OldMD overrides. For example, if we have:
146 ///
147 /// struct A { virtual void f(); };
148 /// struct B : A { virtual void f(); };
149 /// struct C : B { virtual void f(); };
150 ///
151 /// and we want to override B::f with C::f, we also need to override A::f with
152 /// C::f.
153 void PropagateOverrider(const CXXMethodDecl *OldMD,
Anders Carlsson74c364e2010-02-13 22:23:31 +0000154 BaseSubobject NewBase,
Anders Carlssondb4022c2010-03-10 02:33:41 +0000155 uint64_t OverriderOffsetInLayoutClass,
Anders Carlssonb8358d82010-02-12 01:40:03 +0000156 const CXXMethodDecl *NewMD,
157 SubobjectOffsetsMapTy &Offsets);
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000158
Anders Carlssonb8358d82010-02-12 01:40:03 +0000159 static void MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
160 SubobjectOffsetsMapTy &Offsets);
161
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000162public:
Anders Carlssondb4022c2010-03-10 02:33:41 +0000163 FinalOverriders(const CXXRecordDecl *MostDerivedClass,
164 uint64_t MostDerivedClassOffset,
165 const CXXRecordDecl *LayoutClass);
Anders Carlsson2157d302010-02-24 22:18:01 +0000166
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000167 /// getOverrider - Get the final overrider for the given method declaration in
168 /// the given base subobject.
Anders Carlsson7dbf47a2010-02-13 20:11:51 +0000169 OverriderInfo getOverrider(BaseSubobject Base,
170 const CXXMethodDecl *MD) const {
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000171 assert(OverridersMap.count(std::make_pair(Base, MD)) &&
172 "Did not find overrider!");
173
174 return OverridersMap.lookup(std::make_pair(Base, MD));
175 }
176
Anders Carlsson49bac9a2010-02-13 23:40:17 +0000177 /// getReturnAdjustmentOffset - Get the return adjustment offset for the
178 /// method decl in the given base subobject. Returns an empty base offset if
179 /// no adjustment is needed.
Anders Carlsson7dbf47a2010-02-13 20:11:51 +0000180 BaseOffset getReturnAdjustmentOffset(BaseSubobject Base,
181 const CXXMethodDecl *MD) const {
182 return ReturnAdjustments.lookup(std::make_pair(Base, MD));
183 }
184
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000185 /// dump - dump the final overriders.
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000186 void dump() {
187 assert(VisitedVirtualBases.empty() &&
188 "Visited virtual bases aren't empty!");
189 dump(llvm::errs(), BaseSubobject(MostDerivedClass, 0));
190 VisitedVirtualBases.clear();
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000191 }
192
193 /// dump - dump the final overriders for a base subobject, and all its direct
194 /// and indirect base subobjects.
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000195 void dump(llvm::raw_ostream &Out, BaseSubobject Base);
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000196};
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000197
Anders Carlsson327568e2010-02-27 20:02:53 +0000198#define DUMP_OVERRIDERS 0
199
Anders Carlssondb4022c2010-03-10 02:33:41 +0000200FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
201 uint64_t MostDerivedClassOffset,
202 const CXXRecordDecl *LayoutClass)
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000203 : MostDerivedClass(MostDerivedClass),
Anders Carlssondb4022c2010-03-10 02:33:41 +0000204 MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass),
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000205 Context(MostDerivedClass->getASTContext()),
206 MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
207
208 // Compute the final overriders.
Anders Carlssonb8358d82010-02-12 01:40:03 +0000209 SubobjectOffsetsMapTy Offsets;
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000210 ComputeFinalOverriders(BaseSubobject(MostDerivedClass, 0),
Anders Carlssondb4022c2010-03-10 02:33:41 +0000211 /*BaseSubobjectIsVisitedVBase=*/false,
212 MostDerivedClassOffset, Offsets);
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000213 VisitedVirtualBases.clear();
Anders Carlsson327568e2010-02-27 20:02:53 +0000214
215#if DUMP_OVERRIDERS
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000216 // And dump them (for now).
217 dump();
Anders Carlssona4699882010-02-13 21:33:22 +0000218
219 // Also dump the base offsets (for now).
220 for (SubobjectOffsetsMapTy::const_iterator I = Offsets.begin(),
221 E = Offsets.end(); I != E; ++I) {
Anders Carlssondb4022c2010-03-10 02:33:41 +0000222 const OffsetSetVectorTy& OffsetSetVector = I->second;
Anders Carlssona4699882010-02-13 21:33:22 +0000223
224 llvm::errs() << "Base offsets for ";
225 llvm::errs() << I->first->getQualifiedNameAsString() << '\n';
226
Anders Carlssondb4022c2010-03-10 02:33:41 +0000227 for (unsigned I = 0, E = OffsetSetVector.size(); I != E; ++I)
228 llvm::errs() << " " << I << " - " << OffsetSetVector[I] / 8 << '\n';
Anders Carlssona4699882010-02-13 21:33:22 +0000229 }
Anders Carlsson327568e2010-02-27 20:02:53 +0000230#endif
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000231}
232
Anders Carlssonb8358d82010-02-12 01:40:03 +0000233void FinalOverriders::AddOverriders(BaseSubobject Base,
Anders Carlssondb4022c2010-03-10 02:33:41 +0000234 uint64_t OffsetInLayoutClass,
Anders Carlssonb8358d82010-02-12 01:40:03 +0000235 SubobjectOffsetsMapTy &Offsets) {
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000236 const CXXRecordDecl *RD = Base.getBase();
237
238 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
239 E = RD->method_end(); I != E; ++I) {
240 const CXXMethodDecl *MD = *I;
241
242 if (!MD->isVirtual())
243 continue;
244
Anders Carlssonb8358d82010-02-12 01:40:03 +0000245 // First, propagate the overrider.
Anders Carlssondb4022c2010-03-10 02:33:41 +0000246 PropagateOverrider(MD, Base, OffsetInLayoutClass, MD, Offsets);
Anders Carlssonb8358d82010-02-12 01:40:03 +0000247
248 // Add the overrider as the final overrider of itself.
Anders Carlssona7575822010-02-12 16:55:34 +0000249 OverriderInfo& Overrider = OverridersMap[std::make_pair(Base, MD)];
250 assert(!Overrider.Method && "Overrider should not exist yet!");
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000251
Anders Carlssondb4022c2010-03-10 02:33:41 +0000252 Overrider.Offset = OffsetInLayoutClass;
Anders Carlssona7575822010-02-12 16:55:34 +0000253 Overrider.Method = MD;
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000254 }
255}
256
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000257static BaseOffset ComputeBaseOffset(ASTContext &Context,
258 const CXXRecordDecl *DerivedRD,
259 const CXXBasePath &Path) {
Anders Carlssondf31af12010-02-13 23:17:31 +0000260 int64_t NonVirtualOffset = 0;
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000261
Anders Carlssona4a54172010-02-13 20:41:15 +0000262 unsigned NonVirtualStart = 0;
263 const CXXRecordDecl *VirtualBase = 0;
264
265 // First, look for the virtual base class.
266 for (unsigned I = 0, E = Path.size(); I != E; ++I) {
267 const CXXBasePathElement &Element = Path[I];
268
269 if (Element.Base->isVirtual()) {
270 // FIXME: Can we break when we find the first virtual base?
271 // (If we can't, can't we just iterate over the path in reverse order?)
272 NonVirtualStart = I + 1;
273 QualType VBaseType = Element.Base->getType();
274 VirtualBase =
275 cast<CXXRecordDecl>(VBaseType->getAs<RecordType>()->getDecl());
276 }
277 }
278
279 // Now compute the non-virtual offset.
280 for (unsigned I = NonVirtualStart, E = Path.size(); I != E; ++I) {
281 const CXXBasePathElement &Element = Path[I];
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000282
283 // Check the base class offset.
284 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Element.Class);
Anders Carlssonbf554f62010-02-25 22:18:35 +0000285
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000286 const RecordType *BaseType = Element.Base->getType()->getAs<RecordType>();
287 const CXXRecordDecl *Base = cast<CXXRecordDecl>(BaseType->getDecl());
Anders Carlssonbf554f62010-02-25 22:18:35 +0000288
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000289 NonVirtualOffset += Layout.getBaseClassOffset(Base);
290 }
291
292 // FIXME: This should probably use CharUnits or something. Maybe we should
293 // even change the base offsets in ASTRecordLayout to be specified in
294 // CharUnits.
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000295 return BaseOffset(DerivedRD, VirtualBase, NonVirtualOffset / 8);
Anders Carlssone67dc302010-02-14 00:16:19 +0000296
297}
298
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000299static BaseOffset ComputeBaseOffset(ASTContext &Context,
300 const CXXRecordDecl *BaseRD,
301 const CXXRecordDecl *DerivedRD) {
Anders Carlssone67dc302010-02-14 00:16:19 +0000302 CXXBasePaths Paths(/*FindAmbiguities=*/false,
303 /*RecordPaths=*/true, /*DetectVirtual=*/false);
304
305 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
306 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
307 assert(false && "Class must be derived from the passed in base class!");
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000308 return BaseOffset();
Anders Carlssone67dc302010-02-14 00:16:19 +0000309 }
310
311 return ComputeBaseOffset(Context, DerivedRD, Paths.front());
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000312}
313
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000314static BaseOffset
Anders Carlssondf31af12010-02-13 23:17:31 +0000315ComputeReturnAdjustmentBaseOffset(ASTContext &Context,
316 const CXXMethodDecl *DerivedMD,
317 const CXXMethodDecl *BaseMD) {
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000318 const FunctionType *BaseFT = BaseMD->getType()->getAs<FunctionType>();
319 const FunctionType *DerivedFT = DerivedMD->getType()->getAs<FunctionType>();
320
321 // Canonicalize the return types.
322 CanQualType CanDerivedReturnType =
323 Context.getCanonicalType(DerivedFT->getResultType());
324 CanQualType CanBaseReturnType =
325 Context.getCanonicalType(BaseFT->getResultType());
326
327 assert(CanDerivedReturnType->getTypeClass() ==
328 CanBaseReturnType->getTypeClass() &&
329 "Types must have same type class!");
330
331 if (CanDerivedReturnType == CanBaseReturnType) {
332 // No adjustment needed.
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000333 return BaseOffset();
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000334 }
335
336 if (isa<ReferenceType>(CanDerivedReturnType)) {
337 CanDerivedReturnType =
338 CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType();
339 CanBaseReturnType =
340 CanBaseReturnType->getAs<ReferenceType>()->getPointeeType();
341 } else if (isa<PointerType>(CanDerivedReturnType)) {
342 CanDerivedReturnType =
343 CanDerivedReturnType->getAs<PointerType>()->getPointeeType();
344 CanBaseReturnType =
345 CanBaseReturnType->getAs<PointerType>()->getPointeeType();
346 } else {
347 assert(false && "Unexpected return type!");
348 }
349
350 // We need to compare unqualified types here; consider
351 // const T *Base::foo();
352 // T *Derived::foo();
353 if (CanDerivedReturnType.getUnqualifiedType() ==
354 CanBaseReturnType.getUnqualifiedType()) {
355 // No adjustment needed.
Anders Carlsson2fca9be2010-02-23 01:34:28 +0000356 return BaseOffset();
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000357 }
358
359 const CXXRecordDecl *DerivedRD =
360 cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl());
361
362 const CXXRecordDecl *BaseRD =
363 cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl());
364
Anders Carlssondf31af12010-02-13 23:17:31 +0000365 return ComputeBaseOffset(Context, BaseRD, DerivedRD);
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000366}
367
Anders Carlssonb8358d82010-02-12 01:40:03 +0000368void FinalOverriders::PropagateOverrider(const CXXMethodDecl *OldMD,
Anders Carlsson74c364e2010-02-13 22:23:31 +0000369 BaseSubobject NewBase,
Anders Carlssondb4022c2010-03-10 02:33:41 +0000370 uint64_t OverriderOffsetInLayoutClass,
Anders Carlssonb8358d82010-02-12 01:40:03 +0000371 const CXXMethodDecl *NewMD,
372 SubobjectOffsetsMapTy &Offsets) {
373 for (CXXMethodDecl::method_iterator I = OldMD->begin_overridden_methods(),
374 E = OldMD->end_overridden_methods(); I != E; ++I) {
375 const CXXMethodDecl *OverriddenMD = *I;
376 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
377
378 // We want to override OverriddenMD in all subobjects, for example:
379 //
380 /// struct A { virtual void f(); };
381 /// struct B1 : A { };
382 /// struct B2 : A { };
383 /// struct C : B1, B2 { virtual void f(); };
384 ///
385 /// When overriding A::f with C::f we need to do so in both A subobjects.
Anders Carlssonce57dd52010-03-03 04:58:02 +0000386 const OffsetSetVectorTy &OffsetVector = Offsets[OverriddenRD];
Anders Carlssonb8358d82010-02-12 01:40:03 +0000387
388 // Go through all the subobjects.
389 for (unsigned I = 0, E = OffsetVector.size(); I != E; ++I) {
390 uint64_t Offset = OffsetVector[I];
391
Anders Carlssone67dc302010-02-14 00:16:19 +0000392 BaseSubobject OverriddenSubobject = BaseSubobject(OverriddenRD, Offset);
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000393 BaseSubobjectMethodPairTy SubobjectAndMethod =
Anders Carlssone67dc302010-02-14 00:16:19 +0000394 std::make_pair(OverriddenSubobject, OverriddenMD);
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000395
396 OverriderInfo &Overrider = OverridersMap[SubobjectAndMethod];
397
Anders Carlssona7575822010-02-12 16:55:34 +0000398 assert(Overrider.Method && "Did not find existing overrider!");
Anders Carlssonb8358d82010-02-12 01:40:03 +0000399
Anders Carlssondf31af12010-02-13 23:17:31 +0000400 // Check if we need return adjustments or base adjustments.
Anders Carlsson1d05be52010-02-13 21:16:54 +0000401 // (We don't want to do this for pure virtual member functions).
402 if (!NewMD->isPure()) {
Anders Carlssondf31af12010-02-13 23:17:31 +0000403 // Get the return adjustment base offset.
Anders Carlsson1d05be52010-02-13 21:16:54 +0000404 BaseOffset ReturnBaseOffset =
Anders Carlssondf31af12010-02-13 23:17:31 +0000405 ComputeReturnAdjustmentBaseOffset(Context, NewMD, OverriddenMD);
406
Anders Carlsson1d05be52010-02-13 21:16:54 +0000407 if (!ReturnBaseOffset.isEmpty()) {
408 // Store the return adjustment base offset.
409 ReturnAdjustments[SubobjectAndMethod] = ReturnBaseOffset;
410 }
Anders Carlsson16b73122010-02-12 17:13:23 +0000411 }
412
Anders Carlssonb8358d82010-02-12 01:40:03 +0000413 // Set the new overrider.
Anders Carlssondb4022c2010-03-10 02:33:41 +0000414 Overrider.Offset = OverriderOffsetInLayoutClass;
Anders Carlssona7575822010-02-12 16:55:34 +0000415 Overrider.Method = NewMD;
Anders Carlssonb8358d82010-02-12 01:40:03 +0000416
417 // And propagate it further.
Anders Carlssondb4022c2010-03-10 02:33:41 +0000418 PropagateOverrider(OverriddenMD, NewBase, OverriderOffsetInLayoutClass,
419 NewMD, Offsets);
Anders Carlssonb8358d82010-02-12 01:40:03 +0000420 }
421 }
422}
423
424void
425FinalOverriders::MergeSubobjectOffsets(const SubobjectOffsetsMapTy &NewOffsets,
426 SubobjectOffsetsMapTy &Offsets) {
427 // Iterate over the new offsets.
428 for (SubobjectOffsetsMapTy::const_iterator I = NewOffsets.begin(),
429 E = NewOffsets.end(); I != E; ++I) {
430 const CXXRecordDecl *NewRD = I->first;
Anders Carlssonce57dd52010-03-03 04:58:02 +0000431 const OffsetSetVectorTy& NewOffsetVector = I->second;
Anders Carlssonb8358d82010-02-12 01:40:03 +0000432
Anders Carlssonce57dd52010-03-03 04:58:02 +0000433 OffsetSetVectorTy &OffsetVector = Offsets[NewRD];
Anders Carlssonb8358d82010-02-12 01:40:03 +0000434
Anders Carlssonce57dd52010-03-03 04:58:02 +0000435 // Merge the new offsets set vector into the old.
436 OffsetVector.insert(NewOffsetVector.begin(), NewOffsetVector.end());
Anders Carlssonb8358d82010-02-12 01:40:03 +0000437 }
438}
439
440void FinalOverriders::ComputeFinalOverriders(BaseSubobject Base,
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000441 bool BaseSubobjectIsVisitedVBase,
Anders Carlssondb4022c2010-03-10 02:33:41 +0000442 uint64_t OffsetInLayoutClass,
Anders Carlssonb8358d82010-02-12 01:40:03 +0000443 SubobjectOffsetsMapTy &Offsets) {
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000444 const CXXRecordDecl *RD = Base.getBase();
Anders Carlssonb8358d82010-02-12 01:40:03 +0000445 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000446
Anders Carlssonb8358d82010-02-12 01:40:03 +0000447 SubobjectOffsetsMapTy NewOffsets;
448
449 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
450 E = RD->bases_end(); I != E; ++I) {
451 const CXXRecordDecl *BaseDecl =
452 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
453
Anders Carlssonb828afa2010-02-14 17:05:59 +0000454 // Ignore bases that don't have any virtual member functions.
455 if (!BaseDecl->isPolymorphic())
456 continue;
457
Anders Carlssonbf554f62010-02-25 22:18:35 +0000458 bool IsVisitedVirtualBase = BaseSubobjectIsVisitedVBase;
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000459 uint64_t BaseOffset;
Anders Carlssondb4022c2010-03-10 02:33:41 +0000460 uint64_t BaseOffsetInLayoutClass;
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000461 if (I->isVirtual()) {
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000462 if (!VisitedVirtualBases.insert(BaseDecl))
463 IsVisitedVirtualBase = true;
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000464 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlssondb4022c2010-03-10 02:33:41 +0000465
466 const ASTRecordLayout &LayoutClassLayout =
467 Context.getASTRecordLayout(LayoutClass);
468 BaseOffsetInLayoutClass =
469 LayoutClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000470 } else {
471 BaseOffset = Layout.getBaseClassOffset(BaseDecl) + Base.getBaseOffset();
Anders Carlssondb4022c2010-03-10 02:33:41 +0000472 BaseOffsetInLayoutClass = Layout.getBaseClassOffset(BaseDecl) +
473 OffsetInLayoutClass;
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000474 }
475
Anders Carlssonb8358d82010-02-12 01:40:03 +0000476 // Compute the final overriders for this base.
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000477 // We always want to compute the final overriders, even if the base is a
478 // visited virtual base. Consider:
479 //
480 // struct A {
481 // virtual void f();
482 // virtual void g();
483 // };
484 //
485 // struct B : virtual A {
486 // void f();
487 // };
488 //
489 // struct C : virtual A {
490 // void g ();
491 // };
492 //
493 // struct D : B, C { };
494 //
495 // Here, we still want to compute the overriders for A as a base of C,
496 // because otherwise we'll miss that C::g overrides A::f.
497 ComputeFinalOverriders(BaseSubobject(BaseDecl, BaseOffset),
Anders Carlssondb4022c2010-03-10 02:33:41 +0000498 IsVisitedVirtualBase, BaseOffsetInLayoutClass,
499 NewOffsets);
Anders Carlssonb8358d82010-02-12 01:40:03 +0000500 }
501
502 /// Now add the overriders for this particular subobject.
Anders Carlssond5c7cca2010-02-17 17:48:25 +0000503 /// (We don't want to do this more than once for a virtual base).
504 if (!BaseSubobjectIsVisitedVBase)
Anders Carlssondb4022c2010-03-10 02:33:41 +0000505 AddOverriders(Base, OffsetInLayoutClass, NewOffsets);
Anders Carlssonb8358d82010-02-12 01:40:03 +0000506
507 // And merge the newly discovered subobject offsets.
508 MergeSubobjectOffsets(NewOffsets, Offsets);
509
510 /// Finally, add the offset for our own subobject.
Anders Carlssonce57dd52010-03-03 04:58:02 +0000511 Offsets[RD].insert(Base.getBaseOffset());
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000512}
513
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000514void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base) {
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000515 const CXXRecordDecl *RD = Base.getBase();
516 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
517
518 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
519 E = RD->bases_end(); I != E; ++I) {
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000520 const CXXRecordDecl *BaseDecl =
521 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
522
Anders Carlssonb828afa2010-02-14 17:05:59 +0000523 // Ignore bases that don't have any virtual member functions.
524 if (!BaseDecl->isPolymorphic())
525 continue;
526
Anders Carlsson9d6f0d52010-02-14 00:37:35 +0000527 uint64_t BaseOffset;
528 if (I->isVirtual()) {
529 if (!VisitedVirtualBases.insert(BaseDecl)) {
530 // We've visited this base before.
531 continue;
532 }
533
534 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
535 } else {
536 BaseOffset = Layout.getBaseClassOffset(BaseDecl) +
537 Base.getBaseOffset();
538 }
539
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000540 dump(Out, BaseSubobject(BaseDecl, BaseOffset));
541 }
542
543 Out << "Final overriders for (" << RD->getQualifiedNameAsString() << ", ";
Anders Carlssondb4022c2010-03-10 02:33:41 +0000544 Out << Base.getBaseOffset() / 8 << ")\n";
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000545
546 // Now dump the overriders for this base subobject.
547 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
548 E = RD->method_end(); I != E; ++I) {
549 const CXXMethodDecl *MD = *I;
550
551 if (!MD->isVirtual())
552 continue;
553
Anders Carlssona7575822010-02-12 16:55:34 +0000554 OverriderInfo Overrider = getOverrider(Base, MD);
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000555
Anders Carlssond86e5d82010-03-02 03:44:06 +0000556 Out << " " << MD->getQualifiedNameAsString() << " - (";
Anders Carlsson16b73122010-02-12 17:13:23 +0000557 Out << Overrider.Method->getQualifiedNameAsString();
Anders Carlssoncd0d27f2010-03-12 05:02:01 +0000558 Out << ", " << ", " << Overrider.Offset / 8 << ')';
Anders Carlssond86e5d82010-03-02 03:44:06 +0000559
Benjamin Kramere3d0b1c2010-02-13 09:11:28 +0000560 AdjustmentOffsetsMapTy::const_iterator AI =
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000561 ReturnAdjustments.find(std::make_pair(Base, MD));
Benjamin Kramere3d0b1c2010-02-13 09:11:28 +0000562 if (AI != ReturnAdjustments.end()) {
563 const BaseOffset &Offset = AI->second;
Anders Carlssona4a54172010-02-13 20:41:15 +0000564
565 Out << " [ret-adj: ";
566 if (Offset.VirtualBase)
567 Out << Offset.VirtualBase->getQualifiedNameAsString() << " vbase, ";
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000568
Anders Carlssona4a54172010-02-13 20:41:15 +0000569 Out << Offset.NonVirtualOffset << " nv]";
Anders Carlsson0c0eeb22010-02-13 02:02:03 +0000570 }
Anders Carlssondf31af12010-02-13 23:17:31 +0000571
Anders Carlsson16b73122010-02-12 17:13:23 +0000572 Out << "\n";
Anders Carlssonbdf73d82010-02-11 21:24:32 +0000573 }
574}
575
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000576/// VtableComponent - Represents a single component in a vtable.
577class VtableComponent {
578public:
579 enum Kind {
580 CK_VCallOffset,
581 CK_VBaseOffset,
582 CK_OffsetToTop,
583 CK_RTTI,
Anders Carlsson848fa642010-02-11 18:20:28 +0000584 CK_FunctionPointer,
585
586 /// CK_CompleteDtorPointer - A pointer to the complete destructor.
587 CK_CompleteDtorPointer,
588
589 /// CK_DeletingDtorPointer - A pointer to the deleting destructor.
Anders Carlsson1f464662010-02-19 20:08:13 +0000590 CK_DeletingDtorPointer,
591
592 /// CK_UnusedFunctionPointer - In some cases, a vtable function pointer
593 /// will end up never being called. Such vtable function pointers are
594 /// represented as a CK_UnusedFunctionPointer.
595 CK_UnusedFunctionPointer
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000596 };
597
Anders Carlssond9a67042010-02-17 06:07:19 +0000598 static VtableComponent MakeVCallOffset(int64_t Offset) {
599 return VtableComponent(CK_VCallOffset, Offset);
600 }
601
Anders Carlssona661a542010-02-16 04:49:44 +0000602 static VtableComponent MakeVBaseOffset(int64_t Offset) {
603 return VtableComponent(CK_VBaseOffset, Offset);
604 }
605
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000606 static VtableComponent MakeOffsetToTop(int64_t Offset) {
607 return VtableComponent(CK_OffsetToTop, Offset);
608 }
609
610 static VtableComponent MakeRTTI(const CXXRecordDecl *RD) {
611 return VtableComponent(CK_RTTI, reinterpret_cast<uintptr_t>(RD));
612 }
613
614 static VtableComponent MakeFunction(const CXXMethodDecl *MD) {
615 assert(!isa<CXXDestructorDecl>(MD) &&
Anders Carlsson848fa642010-02-11 18:20:28 +0000616 "Don't use MakeFunction with destructors!");
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000617
Anders Carlsson848fa642010-02-11 18:20:28 +0000618 return VtableComponent(CK_FunctionPointer,
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000619 reinterpret_cast<uintptr_t>(MD));
620 }
621
Anders Carlsson848fa642010-02-11 18:20:28 +0000622 static VtableComponent MakeCompleteDtor(const CXXDestructorDecl *DD) {
623 return VtableComponent(CK_CompleteDtorPointer,
624 reinterpret_cast<uintptr_t>(DD));
625 }
626
627 static VtableComponent MakeDeletingDtor(const CXXDestructorDecl *DD) {
628 return VtableComponent(CK_DeletingDtorPointer,
629 reinterpret_cast<uintptr_t>(DD));
630 }
631
Anders Carlsson1f464662010-02-19 20:08:13 +0000632 static VtableComponent MakeUnusedFunction(const CXXMethodDecl *MD) {
633 assert(!isa<CXXDestructorDecl>(MD) &&
634 "Don't use MakeUnusedFunction with destructors!");
635 return VtableComponent(CK_UnusedFunctionPointer,
636 reinterpret_cast<uintptr_t>(MD));
637 }
638
Anders Carlsson6a5ab5d2010-03-25 16:49:53 +0000639 static VtableComponent getFromOpaqueInteger(uint64_t I) {
640 return VtableComponent(I);
641 }
642
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000643 /// getKind - Get the kind of this vtable component.
644 Kind getKind() const {
645 return (Kind)(Value & 0x7);
646 }
647
Anders Carlssond9a67042010-02-17 06:07:19 +0000648 int64_t getVCallOffset() const {
649 assert(getKind() == CK_VCallOffset && "Invalid component kind!");
650
651 return getOffset();
652 }
653
Anders Carlssona661a542010-02-16 04:49:44 +0000654 int64_t getVBaseOffset() const {
655 assert(getKind() == CK_VBaseOffset && "Invalid component kind!");
656
657 return getOffset();
658 }
659
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000660 int64_t getOffsetToTop() const {
661 assert(getKind() == CK_OffsetToTop && "Invalid component kind!");
662
663 return getOffset();
664 }
665
666 const CXXRecordDecl *getRTTIDecl() const {
667 assert(getKind() == CK_RTTI && "Invalid component kind!");
668
669 return reinterpret_cast<CXXRecordDecl *>(getPointer());
670 }
671
672 const CXXMethodDecl *getFunctionDecl() const {
Anders Carlsson848fa642010-02-11 18:20:28 +0000673 assert(getKind() == CK_FunctionPointer);
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000674
675 return reinterpret_cast<CXXMethodDecl *>(getPointer());
676 }
Anders Carlsson848fa642010-02-11 18:20:28 +0000677
678 const CXXDestructorDecl *getDestructorDecl() const {
679 assert((getKind() == CK_CompleteDtorPointer ||
680 getKind() == CK_DeletingDtorPointer) && "Invalid component kind!");
681
682 return reinterpret_cast<CXXDestructorDecl *>(getPointer());
683 }
684
Anders Carlsson1f464662010-02-19 20:08:13 +0000685 const CXXMethodDecl *getUnusedFunctionDecl() const {
686 assert(getKind() == CK_UnusedFunctionPointer);
687
688 return reinterpret_cast<CXXMethodDecl *>(getPointer());
689 }
690
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000691private:
692 VtableComponent(Kind ComponentKind, int64_t Offset) {
693 assert((ComponentKind == CK_VCallOffset ||
694 ComponentKind == CK_VBaseOffset ||
695 ComponentKind == CK_OffsetToTop) && "Invalid component kind!");
696 assert(Offset <= ((1LL << 56) - 1) && "Offset is too big!");
697
698 Value = ((Offset << 3) | ComponentKind);
699 }
700
701 VtableComponent(Kind ComponentKind, uintptr_t Ptr) {
702 assert((ComponentKind == CK_RTTI ||
Anders Carlsson848fa642010-02-11 18:20:28 +0000703 ComponentKind == CK_FunctionPointer ||
704 ComponentKind == CK_CompleteDtorPointer ||
Anders Carlsson1f464662010-02-19 20:08:13 +0000705 ComponentKind == CK_DeletingDtorPointer ||
706 ComponentKind == CK_UnusedFunctionPointer) &&
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000707 "Invalid component kind!");
708
709 assert((Ptr & 7) == 0 && "Pointer not sufficiently aligned!");
710
711 Value = Ptr | ComponentKind;
712 }
713
714 int64_t getOffset() const {
715 assert((getKind() == CK_VCallOffset || getKind() == CK_VBaseOffset ||
716 getKind() == CK_OffsetToTop) && "Invalid component kind!");
717
718 return Value >> 3;
719 }
720
721 uintptr_t getPointer() const {
Anders Carlsson848fa642010-02-11 18:20:28 +0000722 assert((getKind() == CK_RTTI ||
723 getKind() == CK_FunctionPointer ||
724 getKind() == CK_CompleteDtorPointer ||
Anders Carlsson1f464662010-02-19 20:08:13 +0000725 getKind() == CK_DeletingDtorPointer ||
726 getKind() == CK_UnusedFunctionPointer) &&
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000727 "Invalid component kind!");
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000728
729 return static_cast<uintptr_t>(Value & ~7ULL);
730 }
731
Anders Carlsson6a5ab5d2010-03-25 16:49:53 +0000732 explicit VtableComponent(uint64_t Value)
733 : Value(Value) { }
734
Anders Carlsson824d7ea2010-02-11 08:02:13 +0000735 /// The kind is stored in the lower 3 bits of the value. For offsets, we
736 /// make use of the facts that classes can't be larger than 2^55 bytes,
737 /// so we store the offset in the lower part of the 61 bytes that remain.
738 /// (The reason that we're not simply using a PointerIntPair here is that we
739 /// need the offsets to be 64-bit, even when on a 32-bit machine).
740 int64_t Value;
741};
742
Anders Carlsson60cc72a2010-02-18 17:00:09 +0000743/// VCallOffsetMap - Keeps track of vcall offsets when building a vtable.
744struct VCallOffsetMap {
745
746 typedef std::pair<const CXXMethodDecl *, int64_t> MethodAndOffsetPairTy;
747
748 /// Offsets - Keeps track of methods and their offsets.
749 // FIXME: This should be a real map and not a vector.
750 llvm::SmallVector<MethodAndOffsetPairTy, 16> Offsets;
751
Anders Carlssoneb577d02010-02-18 17:26:40 +0000752 /// MethodsCanShareVCallOffset - Returns whether two virtual member functions
753 /// can share the same vcall offset.
754 static bool MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
755 const CXXMethodDecl *RHS);
756
Anders Carlsson60cc72a2010-02-18 17:00:09 +0000757public:
758 /// AddVCallOffset - Adds a vcall offset to the map. Returns true if the
759 /// add was successful, or false if there was already a member function with
760 /// the same signature in the map.
761 bool AddVCallOffset(const CXXMethodDecl *MD, int64_t OffsetOffset);
762
763 /// getVCallOffsetOffset - Returns the vcall offset offset (relative to the
764 /// vtable address point) for the given virtual member function.
765 int64_t getVCallOffsetOffset(const CXXMethodDecl *MD);
766
Anders Carlssondba6ef82010-02-25 22:23:13 +0000767 // empty - Return whether the offset map is empty or not.
768 bool empty() const { return Offsets.empty(); }
Anders Carlsson60cc72a2010-02-18 17:00:09 +0000769};
770
John McCall331a03a2010-02-26 20:22:44 +0000771static bool HasSameVirtualSignature(const CXXMethodDecl *LHS,
772 const CXXMethodDecl *RHS) {
773 ASTContext &C = LHS->getASTContext(); // TODO: thread this down
774 CanQual<FunctionProtoType>
775 LT = C.getCanonicalType(LHS->getType()).getAs<FunctionProtoType>(),
776 RT = C.getCanonicalType(RHS->getType()).getAs<FunctionProtoType>();
777
778 // Fast-path matches in the canonical types.
779 if (LT == RT) return true;
780
781 // Force the signatures to match. We can't rely on the overrides
782 // list here because there isn't necessarily an inheritance
783 // relationship between the two methods.
784 if (LT.getQualifiers() != RT.getQualifiers() ||
785 LT->getNumArgs() != RT->getNumArgs())
786 return false;
787 for (unsigned I = 0, E = LT->getNumArgs(); I != E; ++I)
788 if (LT->getArgType(I) != RT->getArgType(I))
789 return false;
790 return true;
791}
792
Anders Carlssoneb577d02010-02-18 17:26:40 +0000793bool VCallOffsetMap::MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
794 const CXXMethodDecl *RHS) {
795 assert(LHS->isVirtual() && "LHS must be virtual!");
796 assert(RHS->isVirtual() && "LHS must be virtual!");
797
Anders Carlsson55609692010-02-27 04:12:52 +0000798 // A destructor can share a vcall offset with another destructor.
799 if (isa<CXXDestructorDecl>(LHS))
800 return isa<CXXDestructorDecl>(RHS);
801
Anders Carlssoneb577d02010-02-18 17:26:40 +0000802 // FIXME: We need to check more things here.
803
Anders Carlsson55609692010-02-27 04:12:52 +0000804 // The methods must have the same name.
Anders Carlssoneb577d02010-02-18 17:26:40 +0000805 DeclarationName LHSName = LHS->getDeclName();
806 DeclarationName RHSName = RHS->getDeclName();
John McCall331a03a2010-02-26 20:22:44 +0000807 if (LHSName != RHSName)
Anders Carlssoneb577d02010-02-18 17:26:40 +0000808 return false;
John McCall331a03a2010-02-26 20:22:44 +0000809
Anders Carlsson55609692010-02-27 04:12:52 +0000810 // And the same signatures.
811 return HasSameVirtualSignature(LHS, RHS);
Anders Carlssoneb577d02010-02-18 17:26:40 +0000812}
813
Anders Carlsson60cc72a2010-02-18 17:00:09 +0000814bool VCallOffsetMap::AddVCallOffset(const CXXMethodDecl *MD,
815 int64_t OffsetOffset) {
Anders Carlssoneb577d02010-02-18 17:26:40 +0000816 // Check if we can reuse an offset.
817 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
818 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
819 return false;
820 }
821
822 // Add the offset.
823 Offsets.push_back(MethodAndOffsetPairTy(MD, OffsetOffset));
Anders Carlsson60cc72a2010-02-18 17:00:09 +0000824 return true;
825}
826
827int64_t VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
Anders Carlssoneb577d02010-02-18 17:26:40 +0000828 // Look for an offset.
829 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
830 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
831 return Offsets[I].second;
832 }
833
834 assert(false && "Should always find a vcall offset offset!");
Anders Carlsson60cc72a2010-02-18 17:00:09 +0000835 return 0;
836}
837
Anders Carlssond68c0832010-02-25 03:45:56 +0000838/// VCallAndVBaseOffsetBuilder - Class for building vcall and vbase offsets.
839class VCallAndVBaseOffsetBuilder {
Anders Carlssonc89a7cf2010-03-11 16:06:20 +0000840public:
841 typedef llvm::DenseMap<const CXXRecordDecl *, int64_t>
842 VBaseOffsetOffsetsMapTy;
843
844private:
Anders Carlsson530c40c2010-02-28 01:43:58 +0000845 /// MostDerivedClass - The most derived class for which we're building vcall
846 /// and vbase offsets.
Anders Carlssond68c0832010-02-25 03:45:56 +0000847 const CXXRecordDecl *MostDerivedClass;
848
Anders Carlsson0041a642010-02-27 21:09:00 +0000849 /// LayoutClass - The class we're using for layout information. Will be
850 /// different than the most derived class if we're building a construction
851 /// vtable.
852 const CXXRecordDecl *LayoutClass;
853
Anders Carlssond68c0832010-02-25 03:45:56 +0000854 /// Context - The ASTContext which we will use for layout information.
855 ASTContext &Context;
856
857 /// Components - vcall and vbase offset components
858 typedef llvm::SmallVector<VtableComponent, 64> VtableComponentVectorTy;
859 VtableComponentVectorTy Components;
860
861 /// VisitedVirtualBases - Visited virtual bases.
862 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
863
864 /// VCallOffsets - Keeps track of vcall offsets.
865 VCallOffsetMap VCallOffsets;
866
Anders Carlssonbb6305b2010-03-11 06:43:12 +0000867
868 /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets,
869 /// relative to the address point.
870 VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
871
Anders Carlssond68c0832010-02-25 03:45:56 +0000872 /// FinalOverriders - The final overriders of the most derived class.
873 /// (Can be null when we're not building a vtable of the most derived class).
874 const FinalOverriders *Overriders;
875
876 /// AddVCallAndVBaseOffsets - Add vcall offsets and vbase offsets for the
877 /// given base subobject.
878 void AddVCallAndVBaseOffsets(BaseSubobject Base, bool BaseIsVirtual,
879 uint64_t RealBaseOffset);
880
881 /// AddVCallOffsets - Add vcall offsets for the given base subobject.
882 void AddVCallOffsets(BaseSubobject Base, uint64_t VBaseOffset);
883
884 /// AddVBaseOffsets - Add vbase offsets for the given class.
Anders Carlsson88800662010-03-02 05:40:45 +0000885 void AddVBaseOffsets(const CXXRecordDecl *Base, uint64_t OffsetInLayoutClass);
Anders Carlssond68c0832010-02-25 03:45:56 +0000886
Anders Carlssonbb6305b2010-03-11 06:43:12 +0000887 /// getCurrentOffsetOffset - Get the current vcall or vbase offset offset in
888 /// bytes, relative to the vtable address point.
889 int64_t getCurrentOffsetOffset() const;
890
Anders Carlssond68c0832010-02-25 03:45:56 +0000891public:
892 VCallAndVBaseOffsetBuilder(const CXXRecordDecl *MostDerivedClass,
Anders Carlsson0041a642010-02-27 21:09:00 +0000893 const CXXRecordDecl *LayoutClass,
Anders Carlssond68c0832010-02-25 03:45:56 +0000894 const FinalOverriders *Overriders,
Anders Carlsson530c40c2010-02-28 01:43:58 +0000895 BaseSubobject Base, bool BaseIsVirtual,
896 uint64_t OffsetInLayoutClass)
897 : MostDerivedClass(MostDerivedClass), LayoutClass(LayoutClass),
Anders Carlssond68c0832010-02-25 03:45:56 +0000898 Context(MostDerivedClass->getASTContext()), Overriders(Overriders) {
899
900 // Add vcall and vbase offsets.
Anders Carlsson530c40c2010-02-28 01:43:58 +0000901 AddVCallAndVBaseOffsets(Base, BaseIsVirtual, OffsetInLayoutClass);
Anders Carlssond68c0832010-02-25 03:45:56 +0000902 }
903
904 /// Methods for iterating over the components.
905 typedef VtableComponentVectorTy::const_reverse_iterator const_iterator;
906 const_iterator components_begin() const { return Components.rbegin(); }
907 const_iterator components_end() const { return Components.rend(); }
908
Anders Carlssonc89a7cf2010-03-11 16:06:20 +0000909 const VCallOffsetMap &getVCallOffsets() const { return VCallOffsets; }
910 const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
Anders Carlssonbb6305b2010-03-11 06:43:12 +0000911 return VBaseOffsetOffsets;
912 }
Anders Carlssond68c0832010-02-25 03:45:56 +0000913};
914
915void
916VCallAndVBaseOffsetBuilder::AddVCallAndVBaseOffsets(BaseSubobject Base,
917 bool BaseIsVirtual,
918 uint64_t RealBaseOffset) {
919 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base.getBase());
920
921 // Itanium C++ ABI 2.5.2:
922 // ..in classes sharing a virtual table with a primary base class, the vcall
923 // and vbase offsets added by the derived class all come before the vcall
924 // and vbase offsets required by the base class, so that the latter may be
925 // laid out as required by the base class without regard to additions from
926 // the derived class(es).
927
928 // (Since we're emitting the vcall and vbase offsets in reverse order, we'll
929 // emit them for the primary base first).
930 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
931 bool PrimaryBaseIsVirtual = Layout.getPrimaryBaseWasVirtual();
932
933 uint64_t PrimaryBaseOffset;
934
935 // Get the base offset of the primary base.
936 if (PrimaryBaseIsVirtual) {
937 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
938 "Primary vbase should have a zero offset!");
939
940 const ASTRecordLayout &MostDerivedClassLayout =
941 Context.getASTRecordLayout(MostDerivedClass);
942
943 PrimaryBaseOffset =
944 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
945 } else {
946 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
947 "Primary base should have a zero offset!");
948
949 PrimaryBaseOffset = Base.getBaseOffset();
950 }
951
952 AddVCallAndVBaseOffsets(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
953 PrimaryBaseIsVirtual, RealBaseOffset);
954 }
955
Anders Carlsson88800662010-03-02 05:40:45 +0000956 AddVBaseOffsets(Base.getBase(), RealBaseOffset);
Anders Carlssond68c0832010-02-25 03:45:56 +0000957
958 // We only want to add vcall offsets for virtual bases.
959 if (BaseIsVirtual)
960 AddVCallOffsets(Base, RealBaseOffset);
961}
962
Anders Carlssonbb6305b2010-03-11 06:43:12 +0000963int64_t VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const {
964 // OffsetIndex is the index of this vcall or vbase offset, relative to the
965 // vtable address point. (We subtract 3 to account for the information just
966 // above the address point, the RTTI info, the offset to top, and the
967 // vcall offset itself).
968 int64_t OffsetIndex = -(int64_t)(3 + Components.size());
969
970 // FIXME: We shouldn't use / 8 here.
971 int64_t OffsetOffset = OffsetIndex *
972 (int64_t)Context.Target.getPointerWidth(0) / 8;
973
974 return OffsetOffset;
975}
976
Anders Carlssond68c0832010-02-25 03:45:56 +0000977void VCallAndVBaseOffsetBuilder::AddVCallOffsets(BaseSubobject Base,
978 uint64_t VBaseOffset) {
979 const CXXRecordDecl *RD = Base.getBase();
980 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
981
John McCall331a03a2010-02-26 20:22:44 +0000982 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
983
Anders Carlssond68c0832010-02-25 03:45:56 +0000984 // Handle the primary base first.
John McCall331a03a2010-02-26 20:22:44 +0000985 if (PrimaryBase) {
Anders Carlssond68c0832010-02-25 03:45:56 +0000986 uint64_t PrimaryBaseOffset;
987
988 // Get the base offset of the primary base.
989 if (Layout.getPrimaryBaseWasVirtual()) {
990 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
991 "Primary vbase should have a zero offset!");
992
993 const ASTRecordLayout &MostDerivedClassLayout =
994 Context.getASTRecordLayout(MostDerivedClass);
995
996 PrimaryBaseOffset =
997 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
998 } else {
999 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1000 "Primary base should have a zero offset!");
1001
1002 PrimaryBaseOffset = Base.getBaseOffset();
1003 }
1004
1005 AddVCallOffsets(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
1006 VBaseOffset);
1007 }
1008
1009 // Add the vcall offsets.
1010 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1011 E = RD->method_end(); I != E; ++I) {
1012 const CXXMethodDecl *MD = *I;
1013
1014 if (!MD->isVirtual())
1015 continue;
1016
Anders Carlssonbb6305b2010-03-11 06:43:12 +00001017 int64_t OffsetOffset = getCurrentOffsetOffset();
Anders Carlssond68c0832010-02-25 03:45:56 +00001018
1019 // Don't add a vcall offset if we already have one for this member function
1020 // signature.
1021 if (!VCallOffsets.AddVCallOffset(MD, OffsetOffset))
1022 continue;
1023
1024 int64_t Offset = 0;
1025
1026 if (Overriders) {
1027 // Get the final overrider.
1028 FinalOverriders::OverriderInfo Overrider =
1029 Overriders->getOverrider(Base, MD);
1030
Anders Carlsson438bc422010-02-28 00:10:58 +00001031 /// The vcall offset is the offset from the virtual base to the object
1032 /// where the function was overridden.
Anders Carlssond68c0832010-02-25 03:45:56 +00001033 // FIXME: We should not use / 8 here.
Anders Carlssond86e5d82010-03-02 03:44:06 +00001034 Offset = (int64_t)(Overrider.Offset - VBaseOffset) / 8;
Anders Carlssond68c0832010-02-25 03:45:56 +00001035 }
1036
1037 Components.push_back(VtableComponent::MakeVCallOffset(Offset));
1038 }
1039
1040 // And iterate over all non-virtual bases (ignoring the primary base).
1041 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1042 E = RD->bases_end(); I != E; ++I) {
1043
1044 if (I->isVirtual())
1045 continue;
1046
1047 const CXXRecordDecl *BaseDecl =
1048 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
John McCall331a03a2010-02-26 20:22:44 +00001049 if (BaseDecl == PrimaryBase)
1050 continue;
Anders Carlssond68c0832010-02-25 03:45:56 +00001051
1052 // Get the base offset of this base.
1053 uint64_t BaseOffset = Base.getBaseOffset() +
1054 Layout.getBaseClassOffset(BaseDecl);
1055
1056 AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset), VBaseOffset);
1057 }
1058}
1059
Anders Carlssond68c0832010-02-25 03:45:56 +00001060void VCallAndVBaseOffsetBuilder::AddVBaseOffsets(const CXXRecordDecl *RD,
Anders Carlsson88800662010-03-02 05:40:45 +00001061 uint64_t OffsetInLayoutClass) {
Anders Carlsson0041a642010-02-27 21:09:00 +00001062 const ASTRecordLayout &LayoutClassLayout =
1063 Context.getASTRecordLayout(LayoutClass);
Anders Carlssond68c0832010-02-25 03:45:56 +00001064
1065 // Add vbase offsets.
1066 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1067 E = RD->bases_end(); I != E; ++I) {
1068 const CXXRecordDecl *BaseDecl =
1069 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1070
1071 // Check if this is a virtual base that we haven't visited before.
1072 if (I->isVirtual() && VisitedVirtualBases.insert(BaseDecl)) {
1073 // FIXME: We shouldn't use / 8 here.
Anders Carlsson88800662010-03-02 05:40:45 +00001074 int64_t Offset =
1075 (int64_t)(LayoutClassLayout.getVBaseClassOffset(BaseDecl) -
1076 OffsetInLayoutClass) / 8;
Anders Carlssonbb6305b2010-03-11 06:43:12 +00001077
1078 // Add the vbase offset offset.
1079 assert(!VBaseOffsetOffsets.count(BaseDecl) &&
1080 "vbase offset offset already exists!");
1081
1082 int64_t VBaseOffsetOffset = getCurrentOffsetOffset();
1083 VBaseOffsetOffsets.insert(std::make_pair(BaseDecl, VBaseOffsetOffset));
1084
Anders Carlssond68c0832010-02-25 03:45:56 +00001085 Components.push_back(VtableComponent::MakeVBaseOffset(Offset));
1086 }
Anders Carlssonbb6305b2010-03-11 06:43:12 +00001087
Anders Carlssond68c0832010-02-25 03:45:56 +00001088 // Check the base class looking for more vbase offsets.
Anders Carlsson88800662010-03-02 05:40:45 +00001089 AddVBaseOffsets(BaseDecl, OffsetInLayoutClass);
Anders Carlssond68c0832010-02-25 03:45:56 +00001090 }
1091}
1092
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001093/// VtableBuilder - Class for building vtable layout information.
Benjamin Kramer85b45212009-11-28 19:45:26 +00001094class VtableBuilder {
Anders Carlsson57071e22010-02-12 05:25:12 +00001095public:
Anders Carlssonb9021e92010-02-27 16:18:19 +00001096 /// PrimaryBasesSetVectorTy - A set vector of direct and indirect
1097 /// primary bases.
1098 typedef llvm::SmallSetVector<const CXXRecordDecl *, 8>
1099 PrimaryBasesSetVectorTy;
1100
Anders Carlssonccd83d72010-03-24 16:42:11 +00001101 typedef llvm::DenseMap<const CXXRecordDecl *, int64_t>
1102 VBaseOffsetOffsetsMapTy;
Anders Carlsson66d567d2010-03-25 00:51:13 +00001103
1104 typedef llvm::DenseMap<BaseSubobject, uint64_t>
1105 AddressPointsMapTy;
Anders Carlssonccd83d72010-03-24 16:42:11 +00001106
Anders Carlsson57071e22010-02-12 05:25:12 +00001107private:
Anders Carlssonaf440352010-03-23 04:11:45 +00001108 /// VTables - Global vtable information.
1109 CodeGenVTables &VTables;
Anders Carlsson60db0ee2010-02-13 21:07:32 +00001110
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001111 /// MostDerivedClass - The most derived class for which we're building this
1112 /// vtable.
1113 const CXXRecordDecl *MostDerivedClass;
1114
Anders Carlssond03a3262010-02-27 20:39:05 +00001115 /// MostDerivedClassOffset - If we're building a construction vtable, this
1116 /// holds the offset from the layout class to the most derived class.
1117 const uint64_t MostDerivedClassOffset;
1118
Anders Carlsson5d7af6b2010-02-28 00:36:23 +00001119 /// MostDerivedClassIsVirtual - Whether the most derived class is a virtual
1120 /// base. (This only makes sense when building a construction vtable).
1121 bool MostDerivedClassIsVirtual;
1122
Anders Carlssond03a3262010-02-27 20:39:05 +00001123 /// LayoutClass - The class we're using for layout information. Will be
1124 /// different than the most derived class if we're building a construction
1125 /// vtable.
1126 const CXXRecordDecl *LayoutClass;
1127
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001128 /// Context - The ASTContext which we will use for layout information.
Anders Carlsson57071e22010-02-12 05:25:12 +00001129 ASTContext &Context;
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001130
Anders Carlssonbdf73d82010-02-11 21:24:32 +00001131 /// FinalOverriders - The final overriders of the most derived class.
Anders Carlssond68c0832010-02-25 03:45:56 +00001132 const FinalOverriders Overriders;
Anders Carlssonbdf73d82010-02-11 21:24:32 +00001133
Anders Carlssondba6ef82010-02-25 22:23:13 +00001134 /// VCallOffsetsForVBases - Keeps track of vcall offsets for the virtual
1135 /// bases in this vtable.
1136 llvm::DenseMap<const CXXRecordDecl *, VCallOffsetMap> VCallOffsetsForVBases;
Anders Carlsson60cc72a2010-02-18 17:00:09 +00001137
Anders Carlssonbb6305b2010-03-11 06:43:12 +00001138 /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets for
1139 /// the most derived class.
1140 VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
1141
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001142 /// Components - The components of the vtable being built.
1143 llvm::SmallVector<VtableComponent, 64> Components;
1144
Anders Carlsson822307b2010-02-11 17:18:51 +00001145 /// AddressPoints - Address points for the vtable being built.
Anders Carlssonff143f82010-03-25 00:35:49 +00001146 AddressPointsMapTy AddressPoints;
Anders Carlsson822307b2010-02-11 17:18:51 +00001147
Anders Carlssonb9021e92010-02-27 16:18:19 +00001148 /// MethodInfo - Contains information about a method in a vtable.
1149 /// (Used for computing 'this' pointer adjustment thunks.
1150 struct MethodInfo {
1151 /// BaseOffset - The base offset of this method.
1152 const uint64_t BaseOffset;
1153
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001154 /// BaseOffsetInLayoutClass - The base offset in the layout class of this
1155 /// method.
1156 const uint64_t BaseOffsetInLayoutClass;
1157
Anders Carlssonb9021e92010-02-27 16:18:19 +00001158 /// VtableIndex - The index in the vtable that this method has.
1159 /// (For destructors, this is the index of the complete destructor).
1160 const uint64_t VtableIndex;
1161
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001162 MethodInfo(uint64_t BaseOffset, uint64_t BaseOffsetInLayoutClass,
1163 uint64_t VtableIndex)
1164 : BaseOffset(BaseOffset),
1165 BaseOffsetInLayoutClass(BaseOffsetInLayoutClass),
1166 VtableIndex(VtableIndex) { }
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001167
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001168 MethodInfo() : BaseOffset(0), BaseOffsetInLayoutClass(0), VtableIndex(0) { }
Anders Carlssonb9021e92010-02-27 16:18:19 +00001169 };
1170
1171 typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
1172
1173 /// MethodInfoMap - The information for all methods in the vtable we're
1174 /// currently building.
1175 MethodInfoMapTy MethodInfoMap;
1176
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00001177 typedef llvm::DenseMap<uint64_t, ThunkInfo> VtableThunksMapTy;
Anders Carlssondd366812010-03-12 04:54:20 +00001178
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001179 /// VTableThunks - The thunks by vtable index in the vtable currently being
1180 /// built.
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00001181 VtableThunksMapTy VTableThunks;
Anders Carlssonb9021e92010-02-27 16:18:19 +00001182
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00001183 typedef llvm::SmallVector<ThunkInfo, 1> ThunkInfoVectorTy;
1184 typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
Anders Carlsson5e454aa2010-03-17 20:06:32 +00001185
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001186 /// Thunks - A map that contains all the thunks needed for all methods in the
1187 /// most derived class for which the vtable is currently being built.
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00001188 ThunksMapTy Thunks;
Anders Carlsson5e454aa2010-03-17 20:06:32 +00001189
1190 /// AddThunk - Add a thunk for the given method.
Anders Carlsson9d734f32010-03-21 20:27:14 +00001191 void AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk);
Anders Carlsson5e454aa2010-03-17 20:06:32 +00001192
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001193 /// ComputeThisAdjustments - Compute the 'this' pointer adjustments for the
1194 /// part of the vtable we're currently building.
1195 void ComputeThisAdjustments();
1196
Anders Carlssona661a542010-02-16 04:49:44 +00001197 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
1198
Anders Carlssonb9021e92010-02-27 16:18:19 +00001199 /// PrimaryVirtualBases - All known virtual bases who are a primary base of
Anders Carlssonaf280c02010-02-23 03:48:14 +00001200 /// some other base.
1201 VisitedVirtualBasesSetTy PrimaryVirtualBases;
1202
Anders Carlsson60db0ee2010-02-13 21:07:32 +00001203 /// ComputeReturnAdjustment - Compute the return adjustment given a return
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001204 /// adjustment base offset.
Anders Carlsson2fca9be2010-02-23 01:34:28 +00001205 ReturnAdjustment ComputeReturnAdjustment(BaseOffset Offset);
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001206
Anders Carlsson379017f2010-02-27 19:57:44 +00001207 /// ComputeThisAdjustmentBaseOffset - Compute the base offset for adjusting
1208 /// the 'this' pointer from the base subobject to the derived subobject.
1209 BaseOffset ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
1210 BaseSubobject Derived) const;
1211
Anders Carlsson60cc72a2010-02-18 17:00:09 +00001212 /// ComputeThisAdjustment - Compute the 'this' pointer adjustment for the
Anders Carlsson617def32010-03-12 05:28:07 +00001213 /// given virtual member function, its offset in the layout class and its
1214 /// final overrider.
1215 ThisAdjustment
1216 ComputeThisAdjustment(const CXXMethodDecl *MD,
1217 uint64_t BaseOffsetInLayoutClass,
1218 FinalOverriders::OverriderInfo Overrider);
1219
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001220 /// AddMethod - Add a single virtual member function to the vtable
1221 /// components vector.
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001222 void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment);
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001223
Anders Carlsson464c8f12010-02-23 04:26:39 +00001224 /// IsOverriderUsed - Returns whether the overrider will ever be used in this
1225 /// part of the vtable.
1226 ///
1227 /// Itanium C++ ABI 2.5.2:
1228 ///
1229 /// struct A { virtual void f(); };
1230 /// struct B : virtual public A { int i; };
1231 /// struct C : virtual public A { int j; };
1232 /// struct D : public B, public C {};
1233 ///
1234 /// When B and C are declared, A is a primary base in each case, so although
1235 /// vcall offsets are allocated in the A-in-B and A-in-C vtables, no this
1236 /// adjustment is required and no thunk is generated. However, inside D
1237 /// objects, A is no longer a primary base of C, so if we allowed calls to
1238 /// C::f() to use the copy of A's vtable in the C subobject, we would need
1239 /// to adjust this from C* to B::A*, which would require a third-party
1240 /// thunk. Since we require that a call to C::f() first convert to A*,
1241 /// C-in-D's copy of A's vtable is never referenced, so this is not
1242 /// necessary.
Anders Carlsson60396612010-03-10 06:51:42 +00001243 bool IsOverriderUsed(const CXXMethodDecl *Overrider,
1244 uint64_t BaseOffsetInLayoutClass,
1245 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1246 uint64_t FirstBaseOffsetInLayoutClass) const;
1247
Anders Carlsson464c8f12010-02-23 04:26:39 +00001248
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001249 /// AddMethods - Add the methods of this base subobject and all its
1250 /// primary bases to the vtable components vector.
Anders Carlsson60396612010-03-10 06:51:42 +00001251 void AddMethods(BaseSubobject Base, uint64_t BaseOffsetInLayoutClass,
1252 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1253 uint64_t FirstBaseOffsetInLayoutClass,
Anders Carlssonb9021e92010-02-27 16:18:19 +00001254 PrimaryBasesSetVectorTy &PrimaryBases);
Anders Carlsson89ad4212010-02-16 16:26:28 +00001255
Anders Carlsson5d7af6b2010-02-28 00:36:23 +00001256 // LayoutVtable - Layout the vtable for the given base class, including its
Anders Carlsson89ad4212010-02-16 16:26:28 +00001257 // secondary vtables and any vtables for virtual bases.
1258 void LayoutVtable();
1259
Anders Carlsson530c40c2010-02-28 01:43:58 +00001260 /// LayoutPrimaryAndSecondaryVtables - Layout the primary vtable for the
Anders Carlsson89ad4212010-02-16 16:26:28 +00001261 /// given base subobject, as well as all its secondary vtables.
Anders Carlsson530c40c2010-02-28 01:43:58 +00001262 void LayoutPrimaryAndSecondaryVtables(BaseSubobject Base,
1263 bool BaseIsVirtual,
1264 uint64_t OffsetInLayoutClass);
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001265
Anders Carlssonc7b63162010-02-16 16:02:57 +00001266 /// LayoutSecondaryVtables - Layout the secondary vtables for the given base
1267 /// subobject.
Anders Carlssona96a2e92010-03-10 19:39:11 +00001268 ///
1269 /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
1270 /// or a direct or indirect base of a virtual base.
1271 void LayoutSecondaryVtables(BaseSubobject Base, bool BaseIsMorallyVirtual,
1272 uint64_t OffsetInLayoutClass);
Anders Carlsson08c26752010-02-27 04:05:52 +00001273
1274 /// DeterminePrimaryVirtualBases - Determine the primary virtual bases in this
1275 /// class hierarchy.
1276 void DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
Anders Carlssond7fdae52010-03-10 03:02:01 +00001277 uint64_t OffsetInLayoutClass,
Anders Carlsson08c26752010-02-27 04:05:52 +00001278 VisitedVirtualBasesSetTy &VBases);
1279
Anders Carlsson69dc04e2010-02-16 16:49:35 +00001280 /// LayoutVtablesForVirtualBases - Layout vtables for all virtual bases of the
1281 /// given base (excluding any primary bases).
1282 void LayoutVtablesForVirtualBases(const CXXRecordDecl *RD,
1283 VisitedVirtualBasesSetTy &VBases);
1284
Anders Carlsson438bc422010-02-28 00:10:58 +00001285 /// isBuildingConstructionVtable - Return whether this vtable builder is
1286 /// building a construction vtable.
1287 bool isBuildingConstructorVtable() const {
1288 return MostDerivedClass != LayoutClass;
1289 }
1290
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001291public:
Anders Carlssonaf440352010-03-23 04:11:45 +00001292 VtableBuilder(CodeGenVTables &VTables, const CXXRecordDecl *MostDerivedClass,
Anders Carlsson5d7af6b2010-02-28 00:36:23 +00001293 uint64_t MostDerivedClassOffset, bool MostDerivedClassIsVirtual,
Anders Carlssond03a3262010-02-27 20:39:05 +00001294 const CXXRecordDecl *LayoutClass)
Anders Carlssonaf440352010-03-23 04:11:45 +00001295 : VTables(VTables), MostDerivedClass(MostDerivedClass),
Anders Carlsson5d7af6b2010-02-28 00:36:23 +00001296 MostDerivedClassOffset(MostDerivedClassOffset),
1297 MostDerivedClassIsVirtual(MostDerivedClassIsVirtual),
1298 LayoutClass(LayoutClass), Context(MostDerivedClass->getASTContext()),
Anders Carlssondb4022c2010-03-10 02:33:41 +00001299 Overriders(MostDerivedClass, MostDerivedClassOffset, LayoutClass) {
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001300
Anders Carlsson89ad4212010-02-16 16:26:28 +00001301 LayoutVtable();
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001302 }
1303
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00001304 ThunksMapTy::const_iterator thunks_begin() const {
1305 return Thunks.begin();
1306 }
1307
1308 ThunksMapTy::const_iterator thunks_end() const {
1309 return Thunks.end();
1310 }
1311
Anders Carlssonccd83d72010-03-24 16:42:11 +00001312 const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
1313 return VBaseOffsetOffsets;
1314 }
1315
1316 /// getNumVTableComponents - Return the number of components in the vtable
1317 /// currently built.
1318 uint64_t getNumVTableComponents() const {
1319 return Components.size();
1320 }
1321
Anders Carlsson66d567d2010-03-25 00:51:13 +00001322 const uint64_t *vtable_components_data_begin() const {
Anders Carlssonccd83d72010-03-24 16:42:11 +00001323 return reinterpret_cast<const uint64_t *>(Components.begin());
1324 }
1325
Anders Carlsson66d567d2010-03-25 00:51:13 +00001326 const uint64_t *vtable_components_data_end() const {
Anders Carlssonccd83d72010-03-24 16:42:11 +00001327 return reinterpret_cast<const uint64_t *>(Components.end());
1328 }
1329
Anders Carlsson66d567d2010-03-25 00:51:13 +00001330 AddressPointsMapTy::const_iterator address_points_begin() const {
1331 return AddressPoints.begin();
1332 }
1333
1334 AddressPointsMapTy::const_iterator address_points_end() const {
1335 return AddressPoints.end();
1336 }
1337
Anders Carlsson0d1407e2010-03-25 15:26:28 +00001338 VtableThunksMapTy::const_iterator vtable_thunks_begin() const {
1339 return VTableThunks.begin();
1340 }
1341
1342 VtableThunksMapTy::const_iterator vtable_thunks_end() const {
1343 return VTableThunks.end();
1344 }
1345
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001346 /// dumpLayout - Dump the vtable layout.
1347 void dumpLayout(llvm::raw_ostream&);
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001348};
1349
Anders Carlsson9d734f32010-03-21 20:27:14 +00001350void VtableBuilder::AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk) {
Anders Carlssonbca5d372010-03-22 20:06:40 +00001351 assert(!isBuildingConstructorVtable() &&
1352 "Can't add thunks for construction vtable");
Anders Carlsson9135a842010-03-18 02:44:19 +00001353
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001354 llvm::SmallVector<ThunkInfo, 1> &ThunksVector = Thunks[MD];
Anders Carlsson5e454aa2010-03-17 20:06:32 +00001355
1356 // Check if we have this thunk already.
1357 if (std::find(ThunksVector.begin(), ThunksVector.end(), Thunk) !=
1358 ThunksVector.end())
1359 return;
1360
1361 ThunksVector.push_back(Thunk);
1362}
1363
Anders Carlssonc784ba22010-02-27 06:38:03 +00001364/// OverridesMethodInBases - Checks whether whether this virtual member
1365/// function overrides a member function in any of the given bases.
Anders Carlsson57071e22010-02-12 05:25:12 +00001366/// Returns the overridden member function, or null if none was found.
1367static const CXXMethodDecl *
Anders Carlssonc784ba22010-02-27 06:38:03 +00001368OverridesMethodInBases(const CXXMethodDecl *MD,
Anders Carlssonb9021e92010-02-27 16:18:19 +00001369 VtableBuilder::PrimaryBasesSetVectorTy &Bases) {
Anders Carlsson57071e22010-02-12 05:25:12 +00001370 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1371 E = MD->end_overridden_methods(); I != E; ++I) {
1372 const CXXMethodDecl *OverriddenMD = *I;
1373 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
1374 assert(OverriddenMD->isCanonicalDecl() &&
1375 "Should have the canonical decl of the overridden RD!");
1376
Anders Carlssonc784ba22010-02-27 06:38:03 +00001377 if (Bases.count(OverriddenRD))
Anders Carlsson57071e22010-02-12 05:25:12 +00001378 return OverriddenMD;
1379 }
1380
1381 return 0;
1382}
1383
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001384void VtableBuilder::ComputeThisAdjustments() {
1385 // Now go through the method info map and see if any of the methods need
1386 // 'this' pointer adjustments.
1387 for (MethodInfoMapTy::const_iterator I = MethodInfoMap.begin(),
1388 E = MethodInfoMap.end(); I != E; ++I) {
1389 const CXXMethodDecl *MD = I->first;
1390 const MethodInfo &MethodInfo = I->second;
1391
Anders Carlsson617def32010-03-12 05:28:07 +00001392 // Ignore adjustments for unused function pointers.
1393 uint64_t VtableIndex = MethodInfo.VtableIndex;
1394 if (Components[VtableIndex].getKind() ==
1395 VtableComponent::CK_UnusedFunctionPointer)
1396 continue;
1397
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001398 // Get the final overrider for this method.
1399 FinalOverriders::OverriderInfo Overrider =
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001400 Overriders.getOverrider(BaseSubobject(MD->getParent(),
1401 MethodInfo.BaseOffset), MD);
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001402
Anders Carlssonbca5d372010-03-22 20:06:40 +00001403 // Check if we need an adjustment at all.
1404 if (MethodInfo.BaseOffsetInLayoutClass == Overrider.Offset)
1405 continue;
1406
Anders Carlsson617def32010-03-12 05:28:07 +00001407 ThisAdjustment ThisAdjustment =
1408 ComputeThisAdjustment(MD, MethodInfo.BaseOffsetInLayoutClass, Overrider);
1409
1410 if (ThisAdjustment.isEmpty())
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001411 continue;
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001412
Anders Carlssoncd4e6372010-02-27 18:09:40 +00001413 // Add it.
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001414 VTableThunks[VtableIndex].This = ThisAdjustment;
Anders Carlsson617def32010-03-12 05:28:07 +00001415
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001416 if (isa<CXXDestructorDecl>(MD)) {
1417 // Add an adjustment for the deleting destructor as well.
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001418 VTableThunks[VtableIndex + 1].This = ThisAdjustment;
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001419 }
1420 }
1421
1422 /// Clear the method info map.
1423 MethodInfoMap.clear();
Anders Carlsson25394212010-03-22 15:47:01 +00001424
1425 if (isBuildingConstructorVtable()) {
1426 // We don't need to store thunk information for construction vtables.
1427 return;
1428 }
1429
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00001430 for (VtableThunksMapTy::const_iterator I = VTableThunks.begin(),
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001431 E = VTableThunks.end(); I != E; ++I) {
Anders Carlsson25394212010-03-22 15:47:01 +00001432 const VtableComponent &Component = Components[I->first];
1433 const ThunkInfo &Thunk = I->second;
Anders Carlssonbca5d372010-03-22 20:06:40 +00001434 const CXXMethodDecl *MD;
Anders Carlsson25394212010-03-22 15:47:01 +00001435
1436 switch (Component.getKind()) {
1437 default:
1438 llvm_unreachable("Unexpected vtable component kind!");
1439 case VtableComponent::CK_FunctionPointer:
Anders Carlssonbca5d372010-03-22 20:06:40 +00001440 MD = Component.getFunctionDecl();
Anders Carlsson25394212010-03-22 15:47:01 +00001441 break;
1442 case VtableComponent::CK_CompleteDtorPointer:
Anders Carlssonbca5d372010-03-22 20:06:40 +00001443 MD = Component.getDestructorDecl();
Anders Carlsson25394212010-03-22 15:47:01 +00001444 break;
1445 case VtableComponent::CK_DeletingDtorPointer:
1446 // We've already added the thunk when we saw the complete dtor pointer.
Anders Carlssonbca5d372010-03-22 20:06:40 +00001447 continue;
Anders Carlsson25394212010-03-22 15:47:01 +00001448 }
Anders Carlssonbca5d372010-03-22 20:06:40 +00001449
1450 if (MD->getParent() == MostDerivedClass)
1451 AddThunk(MD, Thunk);
Anders Carlsson25394212010-03-22 15:47:01 +00001452 }
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001453}
1454
Anders Carlsson80d8d7d2010-03-23 15:13:06 +00001455ReturnAdjustment VtableBuilder::ComputeReturnAdjustment(BaseOffset Offset) {
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001456 ReturnAdjustment Adjustment;
1457
1458 if (!Offset.isEmpty()) {
Anders Carlsson60db0ee2010-02-13 21:07:32 +00001459 if (Offset.VirtualBase) {
1460 // Get the virtual base offset offset.
Anders Carlsson1972ced2010-03-11 07:00:45 +00001461 if (Offset.DerivedClass == MostDerivedClass) {
1462 // We can get the offset offset directly from our map.
1463 Adjustment.VBaseOffsetOffset =
1464 VBaseOffsetOffsets.lookup(Offset.VirtualBase);
1465 } else {
1466 Adjustment.VBaseOffsetOffset =
Anders Carlssonaf440352010-03-23 04:11:45 +00001467 VTables.getVirtualBaseOffsetOffset(Offset.DerivedClass,
1468 Offset.VirtualBase);
Anders Carlsson1972ced2010-03-11 07:00:45 +00001469 }
1470
Anders Carlssonc89a7cf2010-03-11 16:06:20 +00001471 // FIXME: Once the assert in getVirtualBaseOffsetOffset is back again,
Anders Carlsson60db0ee2010-02-13 21:07:32 +00001472 // we can get rid of this assert.
1473 assert(Adjustment.VBaseOffsetOffset != 0 &&
Anders Carlssonc89a7cf2010-03-11 16:06:20 +00001474 "Invalid vbase offset offset!");
Anders Carlsson60db0ee2010-02-13 21:07:32 +00001475 }
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001476
1477 Adjustment.NonVirtual = Offset.NonVirtualOffset;
1478 }
1479
1480 return Adjustment;
1481}
1482
Anders Carlsson379017f2010-02-27 19:57:44 +00001483BaseOffset
1484VtableBuilder::ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
1485 BaseSubobject Derived) const {
1486 const CXXRecordDecl *BaseRD = Base.getBase();
1487 const CXXRecordDecl *DerivedRD = Derived.getBase();
1488
1489 CXXBasePaths Paths(/*FindAmbiguities=*/true,
1490 /*RecordPaths=*/true, /*DetectVirtual=*/true);
1491
1492 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
1493 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
1494 assert(false && "Class must be derived from the passed in base class!");
1495 return BaseOffset();
1496 }
1497
1498 // We have to go through all the paths, and see which one leads us to the
1499 // right base subobject.
1500 for (CXXBasePaths::const_paths_iterator I = Paths.begin(), E = Paths.end();
1501 I != E; ++I) {
1502 BaseOffset Offset = ComputeBaseOffset(Context, DerivedRD, *I);
1503
1504 // FIXME: Should not use * 8 here.
1505 uint64_t OffsetToBaseSubobject = Offset.NonVirtualOffset * 8;
1506
1507 if (Offset.VirtualBase) {
1508 // If we have a virtual base class, the non-virtual offset is relative
1509 // to the virtual base class offset.
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001510 const ASTRecordLayout &LayoutClassLayout =
1511 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson379017f2010-02-27 19:57:44 +00001512
1513 /// Get the virtual base offset, relative to the most derived class
1514 /// layout.
1515 OffsetToBaseSubobject +=
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001516 LayoutClassLayout.getVBaseClassOffset(Offset.VirtualBase);
Anders Carlsson379017f2010-02-27 19:57:44 +00001517 } else {
1518 // Otherwise, the non-virtual offset is relative to the derived class
1519 // offset.
1520 OffsetToBaseSubobject += Derived.getBaseOffset();
1521 }
1522
1523 // Check if this path gives us the right base subobject.
1524 if (OffsetToBaseSubobject == Base.getBaseOffset()) {
1525 // Since we're going from the base class _to_ the derived class, we'll
1526 // invert the non-virtual offset here.
1527 Offset.NonVirtualOffset = -Offset.NonVirtualOffset;
1528 return Offset;
1529 }
1530 }
1531
1532 return BaseOffset();
1533}
1534
Anders Carlsson80d8d7d2010-03-23 15:13:06 +00001535ThisAdjustment
Anders Carlsson617def32010-03-12 05:28:07 +00001536VtableBuilder::ComputeThisAdjustment(const CXXMethodDecl *MD,
1537 uint64_t BaseOffsetInLayoutClass,
1538 FinalOverriders::OverriderInfo Overrider) {
Anders Carlsson617def32010-03-12 05:28:07 +00001539 // Ignore adjustments for pure virtual member functions.
1540 if (Overrider.Method->isPure())
1541 return ThisAdjustment();
1542
1543 BaseSubobject OverriddenBaseSubobject(MD->getParent(),
1544 BaseOffsetInLayoutClass);
1545
1546 BaseSubobject OverriderBaseSubobject(Overrider.Method->getParent(),
1547 Overrider.Offset);
1548
1549 // Compute the adjustment offset.
1550 BaseOffset Offset = ComputeThisAdjustmentBaseOffset(OverriddenBaseSubobject,
1551 OverriderBaseSubobject);
1552 if (Offset.isEmpty())
1553 return ThisAdjustment();
1554
Anders Carlsson49bac9a2010-02-13 23:40:17 +00001555 ThisAdjustment Adjustment;
1556
Anders Carlsson617def32010-03-12 05:28:07 +00001557 if (Offset.VirtualBase) {
1558 // Get the vcall offset map for this virtual base.
1559 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Offset.VirtualBase];
Anders Carlssoneb577d02010-02-18 17:26:40 +00001560
Anders Carlsson617def32010-03-12 05:28:07 +00001561 if (VCallOffsets.empty()) {
1562 // We don't have vcall offsets for this virtual base, go ahead and
1563 // build them.
1564 VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, MostDerivedClass,
1565 /*FinalOverriders=*/0,
1566 BaseSubobject(Offset.VirtualBase, 0),
1567 /*BaseIsVirtual=*/true,
1568 /*OffsetInLayoutClass=*/0);
1569
1570 VCallOffsets = Builder.getVCallOffsets();
1571 }
1572
1573 Adjustment.VCallOffsetOffset = VCallOffsets.getVCallOffsetOffset(MD);
Anders Carlsson49bac9a2010-02-13 23:40:17 +00001574 }
Anders Carlsson617def32010-03-12 05:28:07 +00001575
1576 // Set the non-virtual part of the adjustment.
1577 Adjustment.NonVirtual = Offset.NonVirtualOffset;
Anders Carlsson49bac9a2010-02-13 23:40:17 +00001578
1579 return Adjustment;
1580}
Anders Carlsson617def32010-03-12 05:28:07 +00001581
Anders Carlsson57071e22010-02-12 05:25:12 +00001582void
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001583VtableBuilder::AddMethod(const CXXMethodDecl *MD,
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001584 ReturnAdjustment ReturnAdjustment) {
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001585 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1586 assert(ReturnAdjustment.isEmpty() &&
1587 "Destructor can't have return adjustment!");
Anders Carlsson49bac9a2010-02-13 23:40:17 +00001588
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001589 // Add both the complete destructor and the deleting destructor.
1590 Components.push_back(VtableComponent::MakeCompleteDtor(DD));
1591 Components.push_back(VtableComponent::MakeDeletingDtor(DD));
1592 } else {
1593 // Add the return adjustment if necessary.
1594 if (!ReturnAdjustment.isEmpty())
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00001595 VTableThunks[Components.size()].Return = ReturnAdjustment;
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001596
1597 // Add the function.
1598 Components.push_back(VtableComponent::MakeFunction(MD));
1599 }
1600}
1601
Anders Carlssonc784ba22010-02-27 06:38:03 +00001602/// OverridesIndirectMethodInBase - Return whether the given member function
1603/// overrides any methods in the set of given bases.
1604/// Unlike OverridesMethodInBase, this checks "overriders of overriders".
1605/// For example, if we have:
1606///
1607/// struct A { virtual void f(); }
1608/// struct B : A { virtual void f(); }
1609/// struct C : B { virtual void f(); }
1610///
1611/// OverridesIndirectMethodInBase will return true if given C::f as the method
1612/// and { A } as the set of bases.
1613static bool
1614OverridesIndirectMethodInBases(const CXXMethodDecl *MD,
Anders Carlssonb9021e92010-02-27 16:18:19 +00001615 VtableBuilder::PrimaryBasesSetVectorTy &Bases) {
Anders Carlssonc784ba22010-02-27 06:38:03 +00001616 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1617 E = MD->end_overridden_methods(); I != E; ++I) {
1618 const CXXMethodDecl *OverriddenMD = *I;
1619 const CXXRecordDecl *OverriddenRD = OverriddenMD->getParent();
1620 assert(OverriddenMD->isCanonicalDecl() &&
1621 "Should have the canonical decl of the overridden RD!");
1622
1623 if (Bases.count(OverriddenRD))
1624 return true;
1625
1626 // Check "indirect overriders".
1627 if (OverridesIndirectMethodInBases(OverriddenMD, Bases))
1628 return true;
1629 }
1630
1631 return false;
1632}
1633
Anders Carlsson464c8f12010-02-23 04:26:39 +00001634bool
Anders Carlsson60396612010-03-10 06:51:42 +00001635VtableBuilder::IsOverriderUsed(const CXXMethodDecl *Overrider,
1636 uint64_t BaseOffsetInLayoutClass,
1637 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1638 uint64_t FirstBaseOffsetInLayoutClass) const {
Anders Carlsson464c8f12010-02-23 04:26:39 +00001639 // If the base and the first base in the primary base chain have the same
1640 // offsets, then this overrider will be used.
Anders Carlsson60396612010-03-10 06:51:42 +00001641 if (BaseOffsetInLayoutClass == FirstBaseOffsetInLayoutClass)
Anders Carlssonf9fbc712010-02-23 06:34:44 +00001642 return true;
1643
1644 // We know now that Base (or a direct or indirect base of it) is a primary
1645 // base in part of the class hierarchy, but not a primary base in the most
1646 // derived class.
1647
1648 // If the overrider is the first base in the primary base chain, we know
1649 // that the overrider will be used.
Anders Carlsson60396612010-03-10 06:51:42 +00001650 if (Overrider->getParent() == FirstBaseInPrimaryBaseChain)
Anders Carlsson464c8f12010-02-23 04:26:39 +00001651 return true;
1652
Anders Carlssonb9021e92010-02-27 16:18:19 +00001653 VtableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlssonf9fbc712010-02-23 06:34:44 +00001654
Anders Carlsson60396612010-03-10 06:51:42 +00001655 const CXXRecordDecl *RD = FirstBaseInPrimaryBaseChain;
Anders Carlssonf9fbc712010-02-23 06:34:44 +00001656 PrimaryBases.insert(RD);
1657
1658 // Now traverse the base chain, starting with the first base, until we find
1659 // the base that is no longer a primary base.
1660 while (true) {
1661 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1662 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1663
1664 if (!PrimaryBase)
1665 break;
1666
1667 if (Layout.getPrimaryBaseWasVirtual()) {
1668 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1669 "Primary base should always be at offset 0!");
1670
Anders Carlssondad0f992010-02-28 18:37:33 +00001671 const ASTRecordLayout &LayoutClassLayout =
1672 Context.getASTRecordLayout(LayoutClass);
Anders Carlssonf9fbc712010-02-23 06:34:44 +00001673
1674 // Now check if this is the primary base that is not a primary base in the
1675 // most derived class.
Anders Carlssondad0f992010-02-28 18:37:33 +00001676 if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) !=
Anders Carlsson60396612010-03-10 06:51:42 +00001677 FirstBaseOffsetInLayoutClass) {
Anders Carlssonf9fbc712010-02-23 06:34:44 +00001678 // We found it, stop walking the chain.
1679 break;
1680 }
1681 } else {
1682 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1683 "Primary base should always be at offset 0!");
1684 }
Anders Carlssoncd4e6372010-02-27 18:09:40 +00001685
Anders Carlssonf89bb6c2010-02-27 19:51:04 +00001686 if (!PrimaryBases.insert(PrimaryBase))
1687 assert(false && "Found a duplicate primary base!");
1688
Anders Carlssoncd4e6372010-02-27 18:09:40 +00001689 RD = PrimaryBase;
Anders Carlssonf9fbc712010-02-23 06:34:44 +00001690 }
1691
1692 // If the final overrider is an override of one of the primary bases,
1693 // then we know that it will be used.
Anders Carlsson60396612010-03-10 06:51:42 +00001694 return OverridesIndirectMethodInBases(Overrider, PrimaryBases);
Anders Carlsson464c8f12010-02-23 04:26:39 +00001695}
1696
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001697/// FindNearestOverriddenMethod - Given a method, returns the overridden method
1698/// from the nearest base. Returns null if no method was found.
1699static const CXXMethodDecl *
1700FindNearestOverriddenMethod(const CXXMethodDecl *MD,
1701 VtableBuilder::PrimaryBasesSetVectorTy &Bases) {
1702 for (int I = Bases.size(), E = 0; I != E; --I) {
1703 const CXXRecordDecl *PrimaryBase = Bases[I - 1];
1704
1705 // Now check the overriden methods.
1706 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1707 E = MD->end_overridden_methods(); I != E; ++I) {
1708 const CXXMethodDecl *OverriddenMD = *I;
1709
1710 // We found our overridden method.
1711 if (OverriddenMD->getParent() == PrimaryBase)
1712 return OverriddenMD;
1713 }
1714 }
1715
1716 return 0;
1717}
1718
Anders Carlsson60396612010-03-10 06:51:42 +00001719void
1720VtableBuilder::AddMethods(BaseSubobject Base, uint64_t BaseOffsetInLayoutClass,
1721 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1722 uint64_t FirstBaseOffsetInLayoutClass,
Anders Carlssonb9021e92010-02-27 16:18:19 +00001723 PrimaryBasesSetVectorTy &PrimaryBases) {
Anders Carlsson57071e22010-02-12 05:25:12 +00001724 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson57071e22010-02-12 05:25:12 +00001725 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1726
1727 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson60396612010-03-10 06:51:42 +00001728 uint64_t PrimaryBaseOffset;
1729 uint64_t PrimaryBaseOffsetInLayoutClass;
Anders Carlssonaf280c02010-02-23 03:48:14 +00001730 if (Layout.getPrimaryBaseWasVirtual()) {
1731 assert(Layout.getVBaseClassOffset(PrimaryBase) == 0 &&
1732 "Primary vbase should have a zero offset!");
1733
1734 const ASTRecordLayout &MostDerivedClassLayout =
1735 Context.getASTRecordLayout(MostDerivedClass);
1736
Anders Carlsson60396612010-03-10 06:51:42 +00001737 PrimaryBaseOffset =
1738 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
1739
1740 const ASTRecordLayout &LayoutClassLayout =
1741 Context.getASTRecordLayout(LayoutClass);
1742
1743 PrimaryBaseOffsetInLayoutClass =
1744 LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
Anders Carlssonaf280c02010-02-23 03:48:14 +00001745 } else {
Anders Carlsson57071e22010-02-12 05:25:12 +00001746 assert(Layout.getBaseClassOffset(PrimaryBase) == 0 &&
1747 "Primary base should have a zero offset!");
Anders Carlssonaf280c02010-02-23 03:48:14 +00001748
Anders Carlsson60396612010-03-10 06:51:42 +00001749 PrimaryBaseOffset = Base.getBaseOffset();
1750 PrimaryBaseOffsetInLayoutClass = BaseOffsetInLayoutClass;
Anders Carlssonaf280c02010-02-23 03:48:14 +00001751 }
Anders Carlssondad0f992010-02-28 18:37:33 +00001752
Anders Carlsson60396612010-03-10 06:51:42 +00001753 AddMethods(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
1754 PrimaryBaseOffsetInLayoutClass, FirstBaseInPrimaryBaseChain,
1755 FirstBaseOffsetInLayoutClass, PrimaryBases);
Anders Carlsson57071e22010-02-12 05:25:12 +00001756
1757 if (!PrimaryBases.insert(PrimaryBase))
1758 assert(false && "Found a duplicate primary base!");
1759 }
Anders Carlsson822307b2010-02-11 17:18:51 +00001760
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001761 // Now go through all virtual member functions and add them.
1762 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1763 E = RD->method_end(); I != E; ++I) {
1764 const CXXMethodDecl *MD = *I;
Anders Carlsson57071e22010-02-12 05:25:12 +00001765
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001766 if (!MD->isVirtual())
1767 continue;
Anders Carlsson57071e22010-02-12 05:25:12 +00001768
1769 // Get the final overrider.
Anders Carlssona7575822010-02-12 16:55:34 +00001770 FinalOverriders::OverriderInfo Overrider =
1771 Overriders.getOverrider(Base, MD);
Anders Carlsson57071e22010-02-12 05:25:12 +00001772
1773 // Check if this virtual member function overrides a method in a primary
1774 // base. If this is the case, and the return type doesn't require adjustment
1775 // then we can just use the member function from the primary base.
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001776 if (const CXXMethodDecl *OverriddenMD =
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001777 FindNearestOverriddenMethod(MD, PrimaryBases)) {
Anders Carlssondf31af12010-02-13 23:17:31 +00001778 if (ComputeReturnAdjustmentBaseOffset(Context, MD,
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001779 OverriddenMD).isEmpty()) {
1780 // Replace the method info of the overridden method with our own
1781 // method.
1782 assert(MethodInfoMap.count(OverriddenMD) &&
1783 "Did not find the overridden method!");
1784 MethodInfo &OverriddenMethodInfo = MethodInfoMap[OverriddenMD];
1785
1786 MethodInfo MethodInfo(Base.getBaseOffset(),
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001787 BaseOffsetInLayoutClass,
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001788 OverriddenMethodInfo.VtableIndex);
1789
1790 assert(!MethodInfoMap.count(MD) &&
1791 "Should not have method info for this method yet!");
1792
1793 MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
1794 MethodInfoMap.erase(OverriddenMD);
Anders Carlssonbca5d372010-03-22 20:06:40 +00001795
1796 // If the overridden method exists in a virtual base class or a direct
1797 // or indirect base class of a virtual base class, we need to emit a
1798 // thunk if we ever have a class hierarchy where the base class is not
1799 // a primary base in the complete object.
1800 if (!isBuildingConstructorVtable() && OverriddenMD != MD) {
1801 // Compute the this adjustment.
1802 ThisAdjustment ThisAdjustment =
1803 ComputeThisAdjustment(OverriddenMD, BaseOffsetInLayoutClass,
1804 Overrider);
1805
Anders Carlssonacfa6ae2010-03-29 02:53:58 +00001806 if (ThisAdjustment.VCallOffsetOffset &&
1807 Overrider.Method->getParent() == MostDerivedClass) {
1808 // This is a virtual thunk for the most derived class, add it.
Anders Carlssonbca5d372010-03-22 20:06:40 +00001809 AddThunk(Overrider.Method,
1810 ThunkInfo(ThisAdjustment, ReturnAdjustment()));
1811 }
1812 }
1813
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001814 continue;
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001815 }
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001816 }
Anders Carlsson0c0eeb22010-02-13 02:02:03 +00001817
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001818 // Insert the method info for this method.
Anders Carlsson2bc1d3a2010-03-10 21:25:37 +00001819 MethodInfo MethodInfo(Base.getBaseOffset(), BaseOffsetInLayoutClass,
1820 Components.size());
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001821
1822 assert(!MethodInfoMap.count(MD) &&
1823 "Should not have method info for this method yet!");
1824 MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
Anders Carlssoncd4e6372010-02-27 18:09:40 +00001825
1826 // Check if this overrider is going to be used.
Anders Carlsson60396612010-03-10 06:51:42 +00001827 const CXXMethodDecl *OverriderMD = Overrider.Method;
1828 if (!IsOverriderUsed(OverriderMD, BaseOffsetInLayoutClass,
1829 FirstBaseInPrimaryBaseChain,
1830 FirstBaseOffsetInLayoutClass)) {
Anders Carlssoncd4e6372010-02-27 18:09:40 +00001831 Components.push_back(VtableComponent::MakeUnusedFunction(OverriderMD));
1832 continue;
1833 }
Anders Carlsson464c8f12010-02-23 04:26:39 +00001834
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001835 // Check if this overrider needs a return adjustment.
Anders Carlsson2fca9be2010-02-23 01:34:28 +00001836 BaseOffset ReturnAdjustmentOffset =
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00001837 Overriders.getReturnAdjustmentOffset(Base, MD);
1838
1839 ReturnAdjustment ReturnAdjustment =
1840 ComputeReturnAdjustment(ReturnAdjustmentOffset);
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001841
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001842 AddMethod(Overrider.Method, ReturnAdjustment);
Anders Carlsson824d7ea2010-02-11 08:02:13 +00001843 }
1844}
1845
Anders Carlsson89ad4212010-02-16 16:26:28 +00001846void VtableBuilder::LayoutVtable() {
Anders Carlsson530c40c2010-02-28 01:43:58 +00001847 LayoutPrimaryAndSecondaryVtables(BaseSubobject(MostDerivedClass, 0),
1848 MostDerivedClassIsVirtual,
1849 MostDerivedClassOffset);
Anders Carlsson89ad4212010-02-16 16:26:28 +00001850
Anders Carlsson69dc04e2010-02-16 16:49:35 +00001851 VisitedVirtualBasesSetTy VBases;
Anders Carlsson08c26752010-02-27 04:05:52 +00001852
1853 // Determine the primary virtual bases.
Anders Carlssond7fdae52010-03-10 03:02:01 +00001854 DeterminePrimaryVirtualBases(MostDerivedClass, MostDerivedClassOffset,
1855 VBases);
Anders Carlsson08c26752010-02-27 04:05:52 +00001856 VBases.clear();
1857
Anders Carlsson69dc04e2010-02-16 16:49:35 +00001858 LayoutVtablesForVirtualBases(MostDerivedClass, VBases);
Anders Carlsson89ad4212010-02-16 16:26:28 +00001859}
1860
Anders Carlsson530c40c2010-02-28 01:43:58 +00001861void
1862VtableBuilder::LayoutPrimaryAndSecondaryVtables(BaseSubobject Base,
1863 bool BaseIsVirtual,
1864 uint64_t OffsetInLayoutClass) {
Chris Lattner04a23112010-02-17 21:42:34 +00001865 assert(Base.getBase()->isDynamicClass() && "class does not have a vtable!");
Anders Carlssonb828afa2010-02-14 17:05:59 +00001866
Anders Carlsson852213e2010-02-16 04:59:55 +00001867 // Add vcall and vbase offsets for this vtable.
Anders Carlsson530c40c2010-02-28 01:43:58 +00001868 VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, LayoutClass, &Overriders,
1869 Base, BaseIsVirtual, OffsetInLayoutClass);
Anders Carlssond68c0832010-02-25 03:45:56 +00001870 Components.append(Builder.components_begin(), Builder.components_end());
1871
Anders Carlssondba6ef82010-02-25 22:23:13 +00001872 // Check if we need to add these vcall offsets.
1873 if (BaseIsVirtual && !Builder.getVCallOffsets().empty()) {
1874 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Base.getBase()];
1875
1876 if (VCallOffsets.empty())
1877 VCallOffsets = Builder.getVCallOffsets();
1878 }
1879
Anders Carlssonbb6305b2010-03-11 06:43:12 +00001880 // If we're laying out the most derived class we want to keep track of the
1881 // virtual base class offset offsets.
1882 if (Base.getBase() == MostDerivedClass)
1883 VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets();
1884
Anders Carlsson852213e2010-02-16 04:59:55 +00001885 // Add the offset to top.
Anders Carlssone67dc302010-02-14 00:16:19 +00001886 // FIXME: We should not use / 8 here.
Anders Carlsson530c40c2010-02-28 01:43:58 +00001887 int64_t OffsetToTop = -(int64_t)(OffsetInLayoutClass -
1888 MostDerivedClassOffset) / 8;
Anders Carlsson76f1aa72010-02-13 22:05:23 +00001889 Components.push_back(VtableComponent::MakeOffsetToTop(OffsetToTop));
Anders Carlsson57071e22010-02-12 05:25:12 +00001890
1891 // Next, add the RTTI.
Anders Carlsson76f1aa72010-02-13 22:05:23 +00001892 Components.push_back(VtableComponent::MakeRTTI(MostDerivedClass));
Anders Carlsson57071e22010-02-12 05:25:12 +00001893
Anders Carlsson28cbc8b2010-02-12 07:43:48 +00001894 uint64_t AddressPoint = Components.size();
Anders Carlsson57071e22010-02-12 05:25:12 +00001895
1896 // Now go through all virtual member functions and add them.
Anders Carlssonb9021e92010-02-27 16:18:19 +00001897 PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlsson60396612010-03-10 06:51:42 +00001898 AddMethods(Base, OffsetInLayoutClass, Base.getBase(), OffsetInLayoutClass,
1899 PrimaryBases);
Anders Carlsson57071e22010-02-12 05:25:12 +00001900
Anders Carlsson2ef9d6b2010-02-27 16:52:49 +00001901 // Compute 'this' pointer adjustments.
1902 ComputeThisAdjustments();
1903
Anders Carlsson014a3582010-03-25 21:45:14 +00001904 // Add all address points.
1905 const CXXRecordDecl *RD = Base.getBase();
1906 while (true) {
1907 AddressPoints.insert(std::make_pair(BaseSubobject(RD, OffsetInLayoutClass),
1908 AddressPoint));
1909
1910 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1911 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
Anders Carlsson28cbc8b2010-02-12 07:43:48 +00001912
Anders Carlsson014a3582010-03-25 21:45:14 +00001913 if (!PrimaryBase)
1914 break;
1915
1916 if (Layout.getPrimaryBaseWasVirtual()) {
1917 // Check if this virtual primary base is a primary base in the layout
1918 // class. If it's not, we don't want to add it.
1919 const ASTRecordLayout &LayoutClassLayout =
1920 Context.getASTRecordLayout(LayoutClass);
1921
1922 if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) !=
1923 OffsetInLayoutClass) {
1924 // We don't want to add this class (or any of its primary bases).
1925 break;
1926 }
1927 }
1928
1929 RD = PrimaryBase;
Anders Carlsson28cbc8b2010-02-12 07:43:48 +00001930 }
1931
Anders Carlssona96a2e92010-03-10 19:39:11 +00001932 bool BaseIsMorallyVirtual = BaseIsVirtual;
1933 if (isBuildingConstructorVtable() && Base.getBase() == MostDerivedClass)
1934 BaseIsMorallyVirtual = false;
1935
Anders Carlsson5edcc372010-02-24 16:43:12 +00001936 // Layout secondary vtables.
Anders Carlssona96a2e92010-03-10 19:39:11 +00001937 LayoutSecondaryVtables(Base, BaseIsMorallyVirtual, OffsetInLayoutClass);
Anders Carlssonc7b63162010-02-16 16:02:57 +00001938}
1939
Anders Carlsson530c40c2010-02-28 01:43:58 +00001940void VtableBuilder::LayoutSecondaryVtables(BaseSubobject Base,
Anders Carlssona96a2e92010-03-10 19:39:11 +00001941 bool BaseIsMorallyVirtual,
Anders Carlsson530c40c2010-02-28 01:43:58 +00001942 uint64_t OffsetInLayoutClass) {
Anders Carlssonc7b63162010-02-16 16:02:57 +00001943 // Itanium C++ ABI 2.5.2:
1944 // Following the primary virtual table of a derived class are secondary
1945 // virtual tables for each of its proper base classes, except any primary
1946 // base(s) with which it shares its primary virtual table.
1947
1948 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson57071e22010-02-12 05:25:12 +00001949 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1950 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
Anders Carlssonc7b63162010-02-16 16:02:57 +00001951
Anders Carlsson57071e22010-02-12 05:25:12 +00001952 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1953 E = RD->bases_end(); I != E; ++I) {
Anders Carlssonc7b63162010-02-16 16:02:57 +00001954 // Ignore virtual bases, we'll emit them later.
1955 if (I->isVirtual())
1956 continue;
1957
Anders Carlsson57071e22010-02-12 05:25:12 +00001958 const CXXRecordDecl *BaseDecl =
1959 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
Anders Carlssonb828afa2010-02-14 17:05:59 +00001960
Anders Carlssona661a542010-02-16 04:49:44 +00001961 // Ignore bases that don't have a vtable.
1962 if (!BaseDecl->isDynamicClass())
1963 continue;
Anders Carlssonb828afa2010-02-14 17:05:59 +00001964
Anders Carlssonf2c98ce2010-03-10 19:15:26 +00001965 if (isBuildingConstructorVtable()) {
1966 // Itanium C++ ABI 2.6.4:
1967 // Some of the base class subobjects may not need construction virtual
1968 // tables, which will therefore not be present in the construction
1969 // virtual table group, even though the subobject virtual tables are
1970 // present in the main virtual table group for the complete object.
Anders Carlssona96a2e92010-03-10 19:39:11 +00001971 if (!BaseIsMorallyVirtual && !BaseDecl->getNumVBases())
Anders Carlssonf2c98ce2010-03-10 19:15:26 +00001972 continue;
Anders Carlssonf2c98ce2010-03-10 19:15:26 +00001973 }
1974
Anders Carlsson76f1aa72010-02-13 22:05:23 +00001975 // Get the base offset of this base.
Anders Carlsson530c40c2010-02-28 01:43:58 +00001976 uint64_t RelativeBaseOffset = Layout.getBaseClassOffset(BaseDecl);
1977 uint64_t BaseOffset = Base.getBaseOffset() + RelativeBaseOffset;
1978
1979 uint64_t BaseOffsetInLayoutClass = OffsetInLayoutClass + RelativeBaseOffset;
Anders Carlssonc7b63162010-02-16 16:02:57 +00001980
1981 // Don't emit a secondary vtable for a primary base. We might however want
1982 // to emit secondary vtables for other bases of this base.
1983 if (BaseDecl == PrimaryBase) {
Anders Carlsson530c40c2010-02-28 01:43:58 +00001984 LayoutSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
Anders Carlssona96a2e92010-03-10 19:39:11 +00001985 BaseIsMorallyVirtual, BaseOffsetInLayoutClass);
Anders Carlssonc7b63162010-02-16 16:02:57 +00001986 continue;
1987 }
Anders Carlsson76f1aa72010-02-13 22:05:23 +00001988
Anders Carlsson89ad4212010-02-16 16:26:28 +00001989 // Layout the primary vtable (and any secondary vtables) for this base.
Anders Carlsson530c40c2010-02-28 01:43:58 +00001990 LayoutPrimaryAndSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
1991 /*BaseIsVirtual=*/false,
1992 BaseOffsetInLayoutClass);
Anders Carlsson57071e22010-02-12 05:25:12 +00001993 }
1994}
1995
Anders Carlsson69dc04e2010-02-16 16:49:35 +00001996void
Anders Carlssond7fdae52010-03-10 03:02:01 +00001997VtableBuilder::DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
1998 uint64_t OffsetInLayoutClass,
Anders Carlsson08c26752010-02-27 04:05:52 +00001999 VisitedVirtualBasesSetTy &VBases) {
2000 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
2001
2002 // Check if this base has a primary base.
2003 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson0378bf02010-02-28 18:08:38 +00002004
2005 // Check if it's virtual.
2006 if (Layout.getPrimaryBaseWasVirtual()) {
2007 bool IsPrimaryVirtualBase = true;
2008
2009 if (isBuildingConstructorVtable()) {
2010 // Check if the base is actually a primary base in the class we use for
2011 // layout.
Anders Carlssond7fdae52010-03-10 03:02:01 +00002012 const ASTRecordLayout &LayoutClassLayout =
2013 Context.getASTRecordLayout(LayoutClass);
2014
2015 uint64_t PrimaryBaseOffsetInLayoutClass =
2016 LayoutClassLayout.getVBaseClassOffset(PrimaryBase);
2017
2018 // We know that the base is not a primary base in the layout class if
2019 // the base offsets are different.
2020 if (PrimaryBaseOffsetInLayoutClass != OffsetInLayoutClass)
Anders Carlsson0378bf02010-02-28 18:08:38 +00002021 IsPrimaryVirtualBase = false;
2022 }
2023
2024 if (IsPrimaryVirtualBase)
2025 PrimaryVirtualBases.insert(PrimaryBase);
2026 }
Anders Carlsson08c26752010-02-27 04:05:52 +00002027 }
2028
2029 // Traverse bases, looking for more primary virtual bases.
2030 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
2031 E = RD->bases_end(); I != E; ++I) {
2032 const CXXRecordDecl *BaseDecl =
2033 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
2034
Anders Carlssond7fdae52010-03-10 03:02:01 +00002035 uint64_t BaseOffsetInLayoutClass;
2036
2037 if (I->isVirtual()) {
2038 if (!VBases.insert(BaseDecl))
2039 continue;
2040
2041 const ASTRecordLayout &LayoutClassLayout =
2042 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson08c26752010-02-27 04:05:52 +00002043
Anders Carlssond7fdae52010-03-10 03:02:01 +00002044 BaseOffsetInLayoutClass = LayoutClassLayout.getVBaseClassOffset(BaseDecl);
2045 } else {
2046 BaseOffsetInLayoutClass =
2047 OffsetInLayoutClass + Layout.getBaseClassOffset(BaseDecl);
2048 }
2049
2050 DeterminePrimaryVirtualBases(BaseDecl, BaseOffsetInLayoutClass, VBases);
Anders Carlsson08c26752010-02-27 04:05:52 +00002051 }
2052}
2053
2054void
Anders Carlsson69dc04e2010-02-16 16:49:35 +00002055VtableBuilder::LayoutVtablesForVirtualBases(const CXXRecordDecl *RD,
2056 VisitedVirtualBasesSetTy &VBases) {
2057 // Itanium C++ ABI 2.5.2:
2058 // Then come the virtual base virtual tables, also in inheritance graph
2059 // order, and again excluding primary bases (which share virtual tables with
2060 // the classes for which they are primary).
Anders Carlsson69dc04e2010-02-16 16:49:35 +00002061 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
2062 E = RD->bases_end(); I != E; ++I) {
2063 const CXXRecordDecl *BaseDecl =
2064 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
2065
Anders Carlssonaf280c02010-02-23 03:48:14 +00002066 // Check if this base needs a vtable. (If it's virtual, not a primary base
2067 // of some other class, and we haven't visited it before).
Anders Carlsson69dc04e2010-02-16 16:49:35 +00002068 if (I->isVirtual() && BaseDecl->isDynamicClass() &&
Anders Carlsson08c26752010-02-27 04:05:52 +00002069 !PrimaryVirtualBases.count(BaseDecl) && VBases.insert(BaseDecl)) {
Anders Carlsson69dc04e2010-02-16 16:49:35 +00002070 const ASTRecordLayout &MostDerivedClassLayout =
2071 Context.getASTRecordLayout(MostDerivedClass);
2072 uint64_t BaseOffset =
2073 MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
2074
Anders Carlsson530c40c2010-02-28 01:43:58 +00002075 const ASTRecordLayout &LayoutClassLayout =
2076 Context.getASTRecordLayout(LayoutClass);
2077 uint64_t BaseOffsetInLayoutClass =
2078 LayoutClassLayout.getVBaseClassOffset(BaseDecl);
2079
2080 LayoutPrimaryAndSecondaryVtables(BaseSubobject(BaseDecl, BaseOffset),
2081 /*BaseIsVirtual=*/true,
2082 BaseOffsetInLayoutClass);
Anders Carlsson69dc04e2010-02-16 16:49:35 +00002083 }
2084
2085 // We only need to check the base for virtual base vtables if it actually
2086 // has virtual bases.
2087 if (BaseDecl->getNumVBases())
2088 LayoutVtablesForVirtualBases(BaseDecl, VBases);
2089 }
2090}
2091
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002092/// dumpLayout - Dump the vtable layout.
2093void VtableBuilder::dumpLayout(llvm::raw_ostream& Out) {
Anders Carlssond03a3262010-02-27 20:39:05 +00002094
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002095 if (isBuildingConstructorVtable()) {
Anders Carlssond03a3262010-02-27 20:39:05 +00002096 Out << "Construction vtable for ('";
2097 Out << MostDerivedClass->getQualifiedNameAsString() << "', ";
2098 // FIXME: Don't use / 8 .
2099 Out << MostDerivedClassOffset / 8 << ") in '";
2100 Out << LayoutClass->getQualifiedNameAsString();
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002101 } else {
2102 Out << "Vtable for '";
2103 Out << MostDerivedClass->getQualifiedNameAsString();
Anders Carlssond03a3262010-02-27 20:39:05 +00002104 }
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002105 Out << "' (" << Components.size() << " entries).\n";
2106
Anders Carlsson822307b2010-02-11 17:18:51 +00002107 // Iterate through the address points and insert them into a new map where
2108 // they are keyed by the index and not the base object.
2109 // Since an address point can be shared by multiple subobjects, we use an
2110 // STL multimap.
2111 std::multimap<uint64_t, BaseSubobject> AddressPointsByIndex;
Anders Carlssonff143f82010-03-25 00:35:49 +00002112 for (AddressPointsMapTy::const_iterator I = AddressPoints.begin(),
2113 E = AddressPoints.end(); I != E; ++I) {
Anders Carlsson822307b2010-02-11 17:18:51 +00002114 const BaseSubobject& Base = I->first;
2115 uint64_t Index = I->second;
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002116
Anders Carlsson822307b2010-02-11 17:18:51 +00002117 AddressPointsByIndex.insert(std::make_pair(Index, Base));
2118 }
2119
2120 for (unsigned I = 0, E = Components.size(); I != E; ++I) {
Anders Carlsson28cbc8b2010-02-12 07:43:48 +00002121 uint64_t Index = I;
Anders Carlsson822307b2010-02-11 17:18:51 +00002122
2123 Out << llvm::format("%4d | ", I);
2124
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002125 const VtableComponent &Component = Components[I];
2126
2127 // Dump the component.
2128 switch (Component.getKind()) {
Anders Carlssond9a67042010-02-17 06:07:19 +00002129
2130 case VtableComponent::CK_VCallOffset:
2131 Out << "vcall_offset (" << Component.getVCallOffset() << ")";
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002132 break;
Anders Carlsson852213e2010-02-16 04:59:55 +00002133
2134 case VtableComponent::CK_VBaseOffset:
2135 Out << "vbase_offset (" << Component.getVBaseOffset() << ")";
2136 break;
2137
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002138 case VtableComponent::CK_OffsetToTop:
2139 Out << "offset_to_top (" << Component.getOffsetToTop() << ")";
2140 break;
2141
2142 case VtableComponent::CK_RTTI:
2143 Out << Component.getRTTIDecl()->getQualifiedNameAsString() << " RTTI";
2144 break;
2145
Anders Carlsson848fa642010-02-11 18:20:28 +00002146 case VtableComponent::CK_FunctionPointer: {
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002147 const CXXMethodDecl *MD = Component.getFunctionDecl();
2148
Anders Carlsson848fa642010-02-11 18:20:28 +00002149 std::string Str =
2150 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2151 MD);
2152 Out << Str;
Anders Carlsson98241422010-02-12 02:38:13 +00002153 if (MD->isPure())
2154 Out << " [pure]";
2155
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00002156 ThunkInfo Thunk = VTableThunks.lookup(I);
Anders Carlssondd366812010-03-12 04:54:20 +00002157 if (!Thunk.isEmpty()) {
2158 // If this function pointer has a return adjustment, dump it.
2159 if (!Thunk.Return.isEmpty()) {
2160 Out << "\n [return adjustment: ";
2161 Out << Thunk.Return.NonVirtual << " non-virtual";
2162
2163 if (Thunk.Return.VBaseOffsetOffset) {
2164 Out << ", " << Thunk.Return.VBaseOffsetOffset;
2165 Out << " vbase offset offset";
2166 }
Anders Carlsson60cc72a2010-02-18 17:00:09 +00002167
Anders Carlssondd366812010-03-12 04:54:20 +00002168 Out << ']';
2169 }
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00002170
Anders Carlssondd366812010-03-12 04:54:20 +00002171 // If this function pointer has a 'this' pointer adjustment, dump it.
2172 if (!Thunk.This.isEmpty()) {
2173 Out << "\n [this adjustment: ";
2174 Out << Thunk.This.NonVirtual << " non-virtual";
2175
2176 if (Thunk.This.VCallOffsetOffset) {
2177 Out << ", " << Thunk.This.VCallOffsetOffset;
2178 Out << " vcall offset offset";
2179 }
Anders Carlsson60cc72a2010-02-18 17:00:09 +00002180
Anders Carlssondd366812010-03-12 04:54:20 +00002181 Out << ']';
2182 }
Anders Carlsson49bac9a2010-02-13 23:40:17 +00002183 }
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00002184
Anders Carlsson848fa642010-02-11 18:20:28 +00002185 break;
2186 }
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002187
Anders Carlsson6065e022010-02-19 06:03:53 +00002188 case VtableComponent::CK_CompleteDtorPointer:
Anders Carlsson848fa642010-02-11 18:20:28 +00002189 case VtableComponent::CK_DeletingDtorPointer: {
Anders Carlsson6065e022010-02-19 06:03:53 +00002190 bool IsComplete =
2191 Component.getKind() == VtableComponent::CK_CompleteDtorPointer;
2192
Anders Carlsson848fa642010-02-11 18:20:28 +00002193 const CXXDestructorDecl *DD = Component.getDestructorDecl();
2194
Anders Carlsson6065e022010-02-19 06:03:53 +00002195 Out << DD->getQualifiedNameAsString();
2196 if (IsComplete)
2197 Out << "() [complete]";
2198 else
2199 Out << "() [deleting]";
2200
Anders Carlsson98241422010-02-12 02:38:13 +00002201 if (DD->isPure())
2202 Out << " [pure]";
2203
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00002204 ThunkInfo Thunk = VTableThunks.lookup(I);
Anders Carlssondd366812010-03-12 04:54:20 +00002205 if (!Thunk.isEmpty()) {
2206 // If this destructor has a 'this' pointer adjustment, dump it.
2207 if (!Thunk.This.isEmpty()) {
2208 Out << "\n [this adjustment: ";
2209 Out << Thunk.This.NonVirtual << " non-virtual";
2210
2211 if (Thunk.This.VCallOffsetOffset) {
2212 Out << ", " << Thunk.This.VCallOffsetOffset;
2213 Out << " vcall offset offset";
2214 }
2215
2216 Out << ']';
2217 }
2218 }
Anders Carlsson6065e022010-02-19 06:03:53 +00002219
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002220 break;
2221 }
2222
Anders Carlsson1f464662010-02-19 20:08:13 +00002223 case VtableComponent::CK_UnusedFunctionPointer: {
2224 const CXXMethodDecl *MD = Component.getUnusedFunctionDecl();
2225
2226 std::string Str =
2227 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2228 MD);
2229 Out << "[unused] " << Str;
2230 if (MD->isPure())
2231 Out << " [pure]";
2232 }
2233
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002234 }
Anders Carlsson822307b2010-02-11 17:18:51 +00002235
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002236 Out << '\n';
Anders Carlssond2c3a7c2010-02-27 23:58:01 +00002237
2238 // Dump the next address point.
2239 uint64_t NextIndex = Index + 1;
2240 if (AddressPointsByIndex.count(NextIndex)) {
2241 if (AddressPointsByIndex.count(NextIndex) == 1) {
2242 const BaseSubobject &Base =
2243 AddressPointsByIndex.find(NextIndex)->second;
2244
2245 // FIXME: Instead of dividing by 8, we should be using CharUnits.
2246 Out << " -- (" << Base.getBase()->getQualifiedNameAsString();
2247 Out << ", " << Base.getBaseOffset() / 8 << ") vtable address --\n";
2248 } else {
2249 uint64_t BaseOffset =
2250 AddressPointsByIndex.lower_bound(NextIndex)->second.getBaseOffset();
2251
2252 // We store the class names in a set to get a stable order.
2253 std::set<std::string> ClassNames;
2254 for (std::multimap<uint64_t, BaseSubobject>::const_iterator I =
2255 AddressPointsByIndex.lower_bound(NextIndex), E =
2256 AddressPointsByIndex.upper_bound(NextIndex); I != E; ++I) {
2257 assert(I->second.getBaseOffset() == BaseOffset &&
2258 "Invalid base offset!");
2259 const CXXRecordDecl *RD = I->second.getBase();
2260 ClassNames.insert(RD->getQualifiedNameAsString());
2261 }
2262
2263 for (std::set<std::string>::const_iterator I = ClassNames.begin(),
2264 E = ClassNames.end(); I != E; ++I) {
2265 // FIXME: Instead of dividing by 8, we should be using CharUnits.
2266 Out << " -- (" << *I;
2267 Out << ", " << BaseOffset / 8 << ") vtable address --\n";
2268 }
2269 }
2270 }
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002271 }
Anders Carlssond03a3262010-02-27 20:39:05 +00002272
2273 Out << '\n';
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002274
Anders Carlsson9135a842010-03-18 02:44:19 +00002275 if (isBuildingConstructorVtable())
2276 return;
2277
2278 if (MostDerivedClass->getNumVBases()) {
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002279 // We store the virtual base class names and their offsets in a map to get
2280 // a stable order.
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002281
Anders Carlsson9135a842010-03-18 02:44:19 +00002282 std::map<std::string, int64_t> ClassNamesAndOffsets;
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002283 for (VBaseOffsetOffsetsMapTy::const_iterator I = VBaseOffsetOffsets.begin(),
2284 E = VBaseOffsetOffsets.end(); I != E; ++I) {
2285 std::string ClassName = I->first->getQualifiedNameAsString();
2286 int64_t OffsetOffset = I->second;
2287 ClassNamesAndOffsets.insert(std::make_pair(ClassName, OffsetOffset));
2288 }
Anders Carlsson9135a842010-03-18 02:44:19 +00002289
2290 Out << "Virtual base offset offsets for '";
2291 Out << MostDerivedClass->getQualifiedNameAsString() << "' (";
2292 Out << ClassNamesAndOffsets.size();
2293 Out << (ClassNamesAndOffsets.size() == 1 ? " entry" : " entries") << ").\n";
Anders Carlssonbb6305b2010-03-11 06:43:12 +00002294
2295 for (std::map<std::string, int64_t>::const_iterator I =
2296 ClassNamesAndOffsets.begin(), E = ClassNamesAndOffsets.end();
2297 I != E; ++I)
2298 Out << " " << I->first << " | " << I->second << '\n';
2299
2300 Out << "\n";
2301 }
Anders Carlsson9135a842010-03-18 02:44:19 +00002302
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00002303 if (!Thunks.empty()) {
Anders Carlsson9135a842010-03-18 02:44:19 +00002304 // We store the method names in a map to get a stable order.
2305 std::map<std::string, const CXXMethodDecl *> MethodNamesAndDecls;
2306
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00002307 for (ThunksMapTy::const_iterator I = Thunks.begin(), E = Thunks.end();
Anders Carlsson3a5df3f2010-03-23 04:44:10 +00002308 I != E; ++I) {
Anders Carlsson9135a842010-03-18 02:44:19 +00002309 const CXXMethodDecl *MD = I->first;
2310 std::string MethodName =
2311 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2312 MD);
2313
2314 MethodNamesAndDecls.insert(std::make_pair(MethodName, MD));
2315 }
2316
2317 for (std::map<std::string, const CXXMethodDecl *>::const_iterator I =
2318 MethodNamesAndDecls.begin(), E = MethodNamesAndDecls.end();
2319 I != E; ++I) {
2320 const std::string &MethodName = I->first;
2321 const CXXMethodDecl *MD = I->second;
Anders Carlsson87e0ac82010-03-22 16:30:44 +00002322
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00002323 ThunkInfoVectorTy ThunksVector = Thunks[MD];
Anders Carlsson87e0ac82010-03-22 16:30:44 +00002324 std::sort(ThunksVector.begin(), ThunksVector.end());
Anders Carlsson9135a842010-03-18 02:44:19 +00002325
2326 Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();
2327 Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
2328
2329 for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) {
2330 const ThunkInfo &Thunk = ThunksVector[I];
2331
2332 Out << llvm::format("%4d | ", I);
2333
Anders Carlsson09daa502010-03-22 16:10:59 +00002334 // If this function pointer has a return pointer adjustment, dump it.
2335 if (!Thunk.Return.isEmpty()) {
2336 Out << "return adjustment: " << Thunk.This.NonVirtual;
2337 Out << " non-virtual";
2338 if (Thunk.Return.VBaseOffsetOffset) {
2339 Out << ", " << Thunk.Return.VBaseOffsetOffset;
2340 Out << " vbase offset offset";
2341 }
2342
2343 if (!Thunk.This.isEmpty())
2344 Out << "\n ";
2345 }
2346
Anders Carlsson9135a842010-03-18 02:44:19 +00002347 // If this function pointer has a 'this' pointer adjustment, dump it.
2348 if (!Thunk.This.isEmpty()) {
Anders Carlsson09daa502010-03-22 16:10:59 +00002349 Out << "this adjustment: ";
2350 Out << Thunk.This.NonVirtual << " non-virtual";
Anders Carlsson9135a842010-03-18 02:44:19 +00002351
2352 if (Thunk.This.VCallOffsetOffset) {
2353 Out << ", " << Thunk.This.VCallOffsetOffset;
Anders Carlsson09daa502010-03-22 16:10:59 +00002354 Out << " vcall offset offset";
Anders Carlsson9135a842010-03-18 02:44:19 +00002355 }
2356 }
2357
2358 Out << '\n';
2359 }
Anders Carlssonbca5d372010-03-22 20:06:40 +00002360
2361 Out << '\n';
2362
Anders Carlsson9135a842010-03-18 02:44:19 +00002363 }
2364 }
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002365}
2366
2367}
2368
2369namespace {
2370class OldVtableBuilder {
Anders Carlssondbd920c2009-10-11 22:13:54 +00002371public:
2372 /// Index_t - Vtable index type.
2373 typedef uint64_t Index_t;
Eli Friedmanb455f0e2009-12-07 23:56:34 +00002374 typedef std::vector<std::pair<GlobalDecl,
2375 std::pair<GlobalDecl, ThunkAdjustment> > >
2376 SavedAdjustmentsVectorTy;
Anders Carlssonff143f82010-03-25 00:35:49 +00002377 typedef llvm::DenseMap<BaseSubobject, uint64_t> AddressPointsMapTy;
2378
Anders Carlssondbd920c2009-10-11 22:13:54 +00002379private:
Anders Carlsson15318f42009-12-04 16:19:30 +00002380
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00002381 // VtableComponents - The components of the vtable being built.
2382 typedef llvm::SmallVector<llvm::Constant *, 64> VtableComponentsVectorTy;
2383 VtableComponentsVectorTy VtableComponents;
2384
Eli Friedman152b5b12009-12-05 01:05:03 +00002385 const bool BuildVtable;
2386
Anders Carlssondbd920c2009-10-11 22:13:54 +00002387 llvm::Type *Ptr8Ty;
Anders Carlssonac3f7bd2009-12-04 18:36:22 +00002388
2389 /// MostDerivedClass - The most derived class that this vtable is being
2390 /// built for.
2391 const CXXRecordDecl *MostDerivedClass;
2392
Mike Stumpacfd1e52009-11-13 01:54:23 +00002393 /// LayoutClass - The most derived class used for virtual base layout
2394 /// information.
2395 const CXXRecordDecl *LayoutClass;
Mike Stump4cde6262009-11-13 02:13:54 +00002396 /// LayoutOffset - The offset for Class in LayoutClass.
2397 uint64_t LayoutOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002398 /// BLayout - Layout for the most derived class that this vtable is being
2399 /// built for.
2400 const ASTRecordLayout &BLayout;
2401 llvm::SmallSet<const CXXRecordDecl *, 32> IndirectPrimary;
2402 llvm::SmallSet<const CXXRecordDecl *, 32> SeenVBase;
2403 llvm::Constant *rtti;
2404 llvm::LLVMContext &VMContext;
2405 CodeGenModule &CGM; // Per-module state.
Anders Carlsson0e881162009-12-04 03:46:21 +00002406
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002407 llvm::DenseMap<const CXXMethodDecl *, Index_t> VCall;
Anders Carlssona0fdd912009-11-13 17:08:56 +00002408 llvm::DenseMap<GlobalDecl, Index_t> VCallOffset;
Mike Stumpd99a4d22010-01-26 03:42:22 +00002409 llvm::DenseMap<GlobalDecl, Index_t> VCallOffsetForVCall;
Mike Stump9e7e3c62009-11-06 23:27:42 +00002410 // This is the offset to the nearest virtual base
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002411 llvm::DenseMap<const CXXMethodDecl *, Index_t> NonVirtualOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002412 llvm::DenseMap<const CXXRecordDecl *, Index_t> VBIndex;
Mike Stump94aff932009-10-27 23:46:47 +00002413
Anders Carlsson6d4ccb72009-11-26 19:54:33 +00002414 /// PureVirtualFunction - Points to __cxa_pure_virtual.
2415 llvm::Constant *PureVirtualFn;
2416
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002417 /// VtableMethods - A data structure for keeping track of methods in a vtable.
2418 /// Can add methods, override methods and iterate in vtable order.
2419 class VtableMethods {
2420 // MethodToIndexMap - Maps from a global decl to the index it has in the
2421 // Methods vector.
2422 llvm::DenseMap<GlobalDecl, uint64_t> MethodToIndexMap;
2423
2424 /// Methods - The methods, in vtable order.
2425 typedef llvm::SmallVector<GlobalDecl, 16> MethodsVectorTy;
2426 MethodsVectorTy Methods;
Eli Friedman72649ed2009-12-06 22:01:30 +00002427 MethodsVectorTy OrigMethods;
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002428
2429 public:
2430 /// AddMethod - Add a method to the vtable methods.
2431 void AddMethod(GlobalDecl GD) {
2432 assert(!MethodToIndexMap.count(GD) &&
2433 "Method has already been added!");
2434
2435 MethodToIndexMap[GD] = Methods.size();
2436 Methods.push_back(GD);
Eli Friedman72649ed2009-12-06 22:01:30 +00002437 OrigMethods.push_back(GD);
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002438 }
2439
2440 /// OverrideMethod - Replace a method with another.
2441 void OverrideMethod(GlobalDecl OverriddenGD, GlobalDecl GD) {
2442 llvm::DenseMap<GlobalDecl, uint64_t>::iterator i
2443 = MethodToIndexMap.find(OverriddenGD);
2444 assert(i != MethodToIndexMap.end() && "Did not find entry!");
2445
2446 // Get the index of the old decl.
2447 uint64_t Index = i->second;
2448
2449 // Replace the old decl with the new decl.
2450 Methods[Index] = GD;
2451
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002452 // And add the new.
2453 MethodToIndexMap[GD] = Index;
2454 }
2455
Anders Carlsson77c23e52009-12-04 15:49:02 +00002456 /// getIndex - Gives the index of a passed in GlobalDecl. Returns false if
2457 /// the index couldn't be found.
Benjamin Kramercce9fde2009-12-04 22:45:27 +00002458 bool getIndex(GlobalDecl GD, uint64_t &Index) const {
Anders Carlsson77c23e52009-12-04 15:49:02 +00002459 llvm::DenseMap<GlobalDecl, uint64_t>::const_iterator i
2460 = MethodToIndexMap.find(GD);
Eli Friedman47145832009-12-04 08:34:14 +00002461
Anders Carlsson77c23e52009-12-04 15:49:02 +00002462 if (i == MethodToIndexMap.end())
2463 return false;
Anders Carlssonc0c49932009-12-04 03:41:37 +00002464
Anders Carlsson77c23e52009-12-04 15:49:02 +00002465 Index = i->second;
2466 return true;
Anders Carlssonc0c49932009-12-04 03:41:37 +00002467 }
2468
Eli Friedman72649ed2009-12-06 22:01:30 +00002469 GlobalDecl getOrigMethod(uint64_t Index) const {
2470 return OrigMethods[Index];
2471 }
2472
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002473 MethodsVectorTy::size_type size() const {
2474 return Methods.size();
2475 }
2476
2477 void clear() {
2478 MethodToIndexMap.clear();
2479 Methods.clear();
Eli Friedman72649ed2009-12-06 22:01:30 +00002480 OrigMethods.clear();
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002481 }
2482
Anders Carlssonc0c49932009-12-04 03:41:37 +00002483 GlobalDecl operator[](uint64_t Index) const {
Anders Carlssonc7ab1a82009-12-04 02:01:07 +00002484 return Methods[Index];
2485 }
2486 };
2487
2488 /// Methods - The vtable methods we're currently building.
2489 VtableMethods Methods;
2490
Anders Carlsson98fdb242009-12-04 02:26:15 +00002491 /// ThisAdjustments - For a given index in the vtable, contains the 'this'
2492 /// pointer adjustment needed for a method.
2493 typedef llvm::DenseMap<uint64_t, ThunkAdjustment> ThisAdjustmentsMapTy;
2494 ThisAdjustmentsMapTy ThisAdjustments;
Anders Carlsson5dd730a2009-11-26 19:32:45 +00002495
Eli Friedmanb455f0e2009-12-07 23:56:34 +00002496 SavedAdjustmentsVectorTy SavedAdjustments;
Eli Friedman72649ed2009-12-06 22:01:30 +00002497
Anders Carlssona8756702009-12-04 02:22:02 +00002498 /// BaseReturnTypes - Contains the base return types of methods who have been
2499 /// overridden with methods whose return types require adjustment. Used for
2500 /// generating covariant thunk information.
2501 typedef llvm::DenseMap<uint64_t, CanQualType> BaseReturnTypesMapTy;
2502 BaseReturnTypesMapTy BaseReturnTypes;
Anders Carlsson5dd730a2009-11-26 19:32:45 +00002503
Anders Carlssondbd920c2009-10-11 22:13:54 +00002504 std::vector<Index_t> VCalls;
Mike Stump9840c702009-11-12 20:47:57 +00002505
2506 typedef std::pair<const CXXRecordDecl *, uint64_t> CtorVtable_t;
Mike Stump23a35422009-11-19 20:52:19 +00002507 // subAddressPoints - Used to hold the AddressPoints (offsets) into the built
2508 // vtable for use in computing the initializers for the VTT.
2509 llvm::DenseMap<CtorVtable_t, int64_t> &subAddressPoints;
Mike Stump9840c702009-11-12 20:47:57 +00002510
Anders Carlsson1bb60992010-01-14 02:29:07 +00002511 /// AddressPoints - Address points for this vtable.
Anders Carlssonff143f82010-03-25 00:35:49 +00002512 AddressPointsMapTy& AddressPoints;
Anders Carlsson1bb60992010-01-14 02:29:07 +00002513
Anders Carlssondbd920c2009-10-11 22:13:54 +00002514 typedef CXXRecordDecl::method_iterator method_iter;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002515 const uint32_t LLVMPointerWidth;
2516 Index_t extra;
Mike Stump11dea942009-10-15 02:04:03 +00002517 typedef std::vector<std::pair<const CXXRecordDecl *, int64_t> > Path_t;
Mike Stump23a35422009-11-19 20:52:19 +00002518 static llvm::DenseMap<CtorVtable_t, int64_t>&
2519 AllocAddressPoint(CodeGenModule &cgm, const CXXRecordDecl *l,
2520 const CXXRecordDecl *c) {
Anders Carlsson66d567d2010-03-25 00:51:13 +00002521 CodeGenVTables::AddrMap_t *&oref = cgm.getVTables().OldAddressPoints[l];
Mike Stump23a35422009-11-19 20:52:19 +00002522 if (oref == 0)
Anders Carlssonaf440352010-03-23 04:11:45 +00002523 oref = new CodeGenVTables::AddrMap_t;
Mike Stump23a35422009-11-19 20:52:19 +00002524
2525 llvm::DenseMap<CtorVtable_t, int64_t> *&ref = (*oref)[c];
2526 if (ref == 0)
2527 ref = new llvm::DenseMap<CtorVtable_t, int64_t>;
2528 return *ref;
2529 }
Anders Carlsson6d4ccb72009-11-26 19:54:33 +00002530
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002531 bool DclIsSame(const FunctionDecl *New, const FunctionDecl *Old) {
2532 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
2533 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
2534
2535 // C++ [temp.fct]p2:
2536 // A function template can be overloaded with other function templates
2537 // and with normal (non-template) functions.
2538 if ((OldTemplate == 0) != (NewTemplate == 0))
2539 return false;
2540
2541 // Is the function New an overload of the function Old?
2542 QualType OldQType = CGM.getContext().getCanonicalType(Old->getType());
2543 QualType NewQType = CGM.getContext().getCanonicalType(New->getType());
2544
2545 // Compare the signatures (C++ 1.3.10) of the two functions to
2546 // determine whether they are overloads. If we find any mismatch
2547 // in the signature, they are overloads.
2548
2549 // If either of these functions is a K&R-style function (no
2550 // prototype), then we consider them to have matching signatures.
2551 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
2552 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
2553 return true;
2554
2555 FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType);
2556 FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType);
2557
2558 // The signature of a function includes the types of its
2559 // parameters (C++ 1.3.10), which includes the presence or absence
2560 // of the ellipsis; see C++ DR 357).
2561 if (OldQType != NewQType &&
2562 (OldType->getNumArgs() != NewType->getNumArgs() ||
2563 OldType->isVariadic() != NewType->isVariadic() ||
2564 !std::equal(OldType->arg_type_begin(), OldType->arg_type_end(),
2565 NewType->arg_type_begin())))
2566 return false;
2567
2568#if 0
2569 // C++ [temp.over.link]p4:
2570 // The signature of a function template consists of its function
2571 // signature, its return type and its template parameter list. The names
2572 // of the template parameters are significant only for establishing the
2573 // relationship between the template parameters and the rest of the
2574 // signature.
2575 //
2576 // We check the return type and template parameter lists for function
2577 // templates first; the remaining checks follow.
2578 if (NewTemplate &&
2579 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
2580 OldTemplate->getTemplateParameters(),
2581 TPL_TemplateMatch) ||
2582 OldType->getResultType() != NewType->getResultType()))
2583 return false;
2584#endif
2585
2586 // If the function is a class member, its signature includes the
2587 // cv-qualifiers (if any) on the function itself.
2588 //
2589 // As part of this, also check whether one of the member functions
2590 // is static, in which case they are not overloads (C++
2591 // 13.1p2). While not part of the definition of the signature,
2592 // this check is important to determine whether these functions
2593 // can be overloaded.
2594 const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
2595 const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
2596 if (OldMethod && NewMethod &&
2597 !OldMethod->isStatic() && !NewMethod->isStatic() &&
2598 OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers())
2599 return false;
2600
2601 // The signatures match; this is not an overload.
2602 return true;
2603 }
2604
2605 typedef llvm::DenseMap<const CXXMethodDecl *, const CXXMethodDecl*>
2606 ForwardUnique_t;
2607 ForwardUnique_t ForwardUnique;
2608 llvm::DenseMap<const CXXMethodDecl*, const CXXMethodDecl*> UniqueOverrider;
2609
2610 void BuildUniqueOverrider(const CXXMethodDecl *U, const CXXMethodDecl *MD) {
2611 const CXXMethodDecl *PrevU = UniqueOverrider[MD];
2612 assert(U && "no unique overrider");
2613 if (PrevU == U)
2614 return;
2615 if (PrevU != U && PrevU != 0) {
2616 // If already set, note the two sets as the same
2617 if (0)
2618 printf("%s::%s same as %s::%s\n",
Douglas Gregoraef605d2010-02-22 16:44:27 +00002619 PrevU->getParent()->getNameAsString().c_str(),
2620 PrevU->getNameAsString().c_str(),
2621 U->getParent()->getNameAsString().c_str(),
2622 U->getNameAsString().c_str());
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002623 ForwardUnique[PrevU] = U;
2624 return;
2625 }
2626
2627 // Not set, set it now
2628 if (0)
2629 printf("marking %s::%s %p override as %s::%s\n",
Douglas Gregoraef605d2010-02-22 16:44:27 +00002630 MD->getParent()->getNameAsString().c_str(),
2631 MD->getNameAsString().c_str(),
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002632 (void*)MD,
Douglas Gregoraef605d2010-02-22 16:44:27 +00002633 U->getParent()->getNameAsString().c_str(),
2634 U->getNameAsString().c_str());
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002635 UniqueOverrider[MD] = U;
2636
2637 for (CXXMethodDecl::method_iterator mi = MD->begin_overridden_methods(),
2638 me = MD->end_overridden_methods(); mi != me; ++mi) {
2639 BuildUniqueOverrider(U, *mi);
2640 }
2641 }
2642
2643 void BuildUniqueOverriders(const CXXRecordDecl *RD) {
2644 if (0) printf("walking %s\n", RD->getNameAsCString());
2645 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
2646 e = RD->method_end(); i != e; ++i) {
2647 const CXXMethodDecl *MD = *i;
2648 if (!MD->isVirtual())
2649 continue;
2650
2651 if (UniqueOverrider[MD] == 0) {
2652 // Only set this, if it hasn't been set yet.
2653 BuildUniqueOverrider(MD, MD);
2654 if (0)
2655 printf("top set is %s::%s %p\n",
Douglas Gregoraef605d2010-02-22 16:44:27 +00002656 MD->getParent()->getNameAsString().c_str(),
2657 MD->getNameAsString().c_str(),
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002658 (void*)MD);
2659 ForwardUnique[MD] = MD;
2660 }
2661 }
2662 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2663 e = RD->bases_end(); i != e; ++i) {
2664 const CXXRecordDecl *Base =
2665 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2666 BuildUniqueOverriders(Base);
2667 }
2668 }
2669
2670 static int DclCmp(const void *p1, const void *p2) {
John McCall7fe0b9e2010-02-13 01:04:05 +00002671 const CXXMethodDecl *MD1 = *(const CXXMethodDecl *const *)p1;
2672 const CXXMethodDecl *MD2 = *(const CXXMethodDecl *const *)p2;
2673
2674 return (DeclarationName::compare(MD1->getDeclName(), MD2->getDeclName()));
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002675 }
2676
2677 void MergeForwarding() {
2678 typedef llvm::SmallVector<const CXXMethodDecl *, 100> A_t;
2679 A_t A;
2680 for (ForwardUnique_t::iterator I = ForwardUnique.begin(),
2681 E = ForwardUnique.end(); I != E; ++I) {
2682 if (I->first == I->second)
2683 // Only add the roots of all trees
2684 A.push_back(I->first);
2685 }
2686 llvm::array_pod_sort(A.begin(), A.end(), DclCmp);
2687 for (A_t::iterator I = A.begin(),
2688 E = A.end(); I != E; ++I) {
2689 A_t::iterator J = I;
John McCall7fe0b9e2010-02-13 01:04:05 +00002690 while (++J != E && DclCmp(I, J) == 0)
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002691 if (DclIsSame(*I, *J)) {
Douglas Gregoraef605d2010-02-22 16:44:27 +00002692 if (0) printf("connecting %s\n", (*I)->getNameAsString().c_str());
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002693 ForwardUnique[*J] = *I;
2694 }
2695 }
2696 }
2697
2698 const CXXMethodDecl *getUnique(const CXXMethodDecl *MD) {
2699 const CXXMethodDecl *U = UniqueOverrider[MD];
2700 assert(U && "unique overrider not found");
2701 while (ForwardUnique.count(U)) {
2702 const CXXMethodDecl *NU = ForwardUnique[U];
2703 if (NU == U) break;
2704 U = NU;
2705 }
2706 return U;
2707 }
Anders Carlsson0f0bbbc2010-01-26 17:36:47 +00002708
2709 GlobalDecl getUnique(GlobalDecl GD) {
2710 const CXXMethodDecl *Unique = getUnique(cast<CXXMethodDecl>(GD.getDecl()));
2711
2712 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Unique))
2713 return GlobalDecl(CD, GD.getCtorType());
2714
2715 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Unique))
2716 return GlobalDecl(DD, GD.getDtorType());
2717
2718 return Unique;
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002719 }
2720
Anders Carlsson6d4ccb72009-11-26 19:54:33 +00002721 /// getPureVirtualFn - Return the __cxa_pure_virtual function.
2722 llvm::Constant* getPureVirtualFn() {
2723 if (!PureVirtualFn) {
2724 const llvm::FunctionType *Ty =
2725 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
2726 /*isVarArg=*/false);
2727 PureVirtualFn = wrap(CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual"));
2728 }
2729
2730 return PureVirtualFn;
2731 }
2732
Anders Carlssondbd920c2009-10-11 22:13:54 +00002733public:
Anders Carlsson824d7ea2010-02-11 08:02:13 +00002734 OldVtableBuilder(const CXXRecordDecl *MostDerivedClass,
Eli Friedman152b5b12009-12-05 01:05:03 +00002735 const CXXRecordDecl *l, uint64_t lo, CodeGenModule &cgm,
Anders Carlssonff143f82010-03-25 00:35:49 +00002736 bool build, AddressPointsMapTy& AddressPoints)
Eli Friedman152b5b12009-12-05 01:05:03 +00002737 : BuildVtable(build), MostDerivedClass(MostDerivedClass), LayoutClass(l),
2738 LayoutOffset(lo), BLayout(cgm.getContext().getASTRecordLayout(l)),
2739 rtti(0), VMContext(cgm.getModule().getContext()),CGM(cgm),
2740 PureVirtualFn(0),
Anders Carlssonac3f7bd2009-12-04 18:36:22 +00002741 subAddressPoints(AllocAddressPoint(cgm, l, MostDerivedClass)),
Anders Carlsson1bb60992010-01-14 02:29:07 +00002742 AddressPoints(AddressPoints),
2743 LLVMPointerWidth(cgm.getContext().Target.getPointerWidth(0))
2744 {
Anders Carlssondbd920c2009-10-11 22:13:54 +00002745 Ptr8Ty = llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext), 0);
Anders Carlsson1d7088d2009-12-17 07:09:17 +00002746 if (BuildVtable) {
2747 QualType ClassType = CGM.getContext().getTagDeclType(MostDerivedClass);
2748 rtti = CGM.GetAddrOfRTTIDescriptor(ClassType);
2749 }
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002750 BuildUniqueOverriders(MostDerivedClass);
2751 MergeForwarding();
Anders Carlssondbd920c2009-10-11 22:13:54 +00002752 }
2753
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00002754 // getVtableComponents - Returns a reference to the vtable components.
2755 const VtableComponentsVectorTy &getVtableComponents() const {
2756 return VtableComponents;
Anders Carlsson15318f42009-12-04 16:19:30 +00002757 }
2758
Anders Carlssonc997d422010-01-02 01:01:18 +00002759 llvm::DenseMap<const CXXRecordDecl *, uint64_t> &getVBIndex()
Anders Carlssondbd920c2009-10-11 22:13:54 +00002760 { return VBIndex; }
2761
Eli Friedmanb455f0e2009-12-07 23:56:34 +00002762 SavedAdjustmentsVectorTy &getSavedAdjustments()
2763 { return SavedAdjustments; }
Eli Friedman72649ed2009-12-06 22:01:30 +00002764
Anders Carlssondbd920c2009-10-11 22:13:54 +00002765 llvm::Constant *wrap(Index_t i) {
2766 llvm::Constant *m;
2767 m = llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext), i);
2768 return llvm::ConstantExpr::getIntToPtr(m, Ptr8Ty);
2769 }
2770
2771 llvm::Constant *wrap(llvm::Constant *m) {
2772 return llvm::ConstantExpr::getBitCast(m, Ptr8Ty);
2773 }
2774
Mike Stumpd6584902010-01-22 02:51:26 +00002775//#define D1(x)
Douglas Gregor12a91092010-02-22 16:48:26 +00002776#define D1(X) do { if (getenv("CLANG_VTABLE_DEBUG")) { X; } } while (0)
Mike Stump6a9612f2009-10-31 20:06:59 +00002777
2778 void GenerateVBaseOffsets(const CXXRecordDecl *RD, uint64_t Offset,
Mike Stumpab28c132009-10-13 22:54:56 +00002779 bool updateVBIndex, Index_t current_vbindex) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00002780 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2781 e = RD->bases_end(); i != e; ++i) {
2782 const CXXRecordDecl *Base =
2783 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stumpab28c132009-10-13 22:54:56 +00002784 Index_t next_vbindex = current_vbindex;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002785 if (i->isVirtual() && !SeenVBase.count(Base)) {
2786 SeenVBase.insert(Base);
Mike Stumpab28c132009-10-13 22:54:56 +00002787 if (updateVBIndex) {
Mike Stump6a9612f2009-10-31 20:06:59 +00002788 next_vbindex = (ssize_t)(-(VCalls.size()*LLVMPointerWidth/8)
Mike Stumpab28c132009-10-13 22:54:56 +00002789 - 3*LLVMPointerWidth/8);
2790 VBIndex[Base] = next_vbindex;
2791 }
Mike Stump6a9612f2009-10-31 20:06:59 +00002792 int64_t BaseOffset = -(Offset/8) + BLayout.getVBaseClassOffset(Base)/8;
2793 VCalls.push_back((0?700:0) + BaseOffset);
2794 D1(printf(" vbase for %s at %d delta %d most derived %s\n",
2795 Base->getNameAsCString(),
2796 (int)-VCalls.size()-3, (int)BaseOffset,
Mike Stumpd6584902010-01-22 02:51:26 +00002797 MostDerivedClass->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +00002798 }
Mike Stumpab28c132009-10-13 22:54:56 +00002799 // We also record offsets for non-virtual bases to closest enclosing
2800 // virtual base. We do this so that we don't have to search
2801 // for the nearst virtual base class when generating thunks.
2802 if (updateVBIndex && VBIndex.count(Base) == 0)
2803 VBIndex[Base] = next_vbindex;
Mike Stump6a9612f2009-10-31 20:06:59 +00002804 GenerateVBaseOffsets(Base, Offset, updateVBIndex, next_vbindex);
Anders Carlssondbd920c2009-10-11 22:13:54 +00002805 }
2806 }
2807
2808 void StartNewTable() {
2809 SeenVBase.clear();
2810 }
2811
Mike Stump3425b972009-10-15 09:30:16 +00002812 Index_t getNVOffset_1(const CXXRecordDecl *D, const CXXRecordDecl *B,
2813 Index_t Offset = 0) {
2814
2815 if (B == D)
2816 return Offset;
2817
2818 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(D);
2819 for (CXXRecordDecl::base_class_const_iterator i = D->bases_begin(),
2820 e = D->bases_end(); i != e; ++i) {
2821 const CXXRecordDecl *Base =
2822 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
2823 int64_t BaseOffset = 0;
2824 if (!i->isVirtual())
2825 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
2826 int64_t o = getNVOffset_1(Base, B, BaseOffset);
2827 if (o >= 0)
2828 return o;
2829 }
2830
2831 return -1;
2832 }
2833
2834 /// getNVOffset - Returns the non-virtual offset for the given (B) base of the
2835 /// derived class D.
2836 Index_t getNVOffset(QualType qB, QualType qD) {
Mike Stump9c212892009-11-03 19:03:17 +00002837 qD = qD->getPointeeType();
2838 qB = qB->getPointeeType();
Mike Stump3425b972009-10-15 09:30:16 +00002839 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
2840 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
2841 int64_t o = getNVOffset_1(D, B);
2842 if (o >= 0)
2843 return o;
2844
2845 assert(false && "FIXME: non-virtual base not found");
2846 return 0;
2847 }
2848
Anders Carlssondbd920c2009-10-11 22:13:54 +00002849 /// getVbaseOffset - Returns the index into the vtable for the virtual base
2850 /// offset for the given (B) virtual base of the derived class D.
2851 Index_t getVbaseOffset(QualType qB, QualType qD) {
Mike Stump9c212892009-11-03 19:03:17 +00002852 qD = qD->getPointeeType();
2853 qB = qB->getPointeeType();
Anders Carlssondbd920c2009-10-11 22:13:54 +00002854 CXXRecordDecl *D = cast<CXXRecordDecl>(qD->getAs<RecordType>()->getDecl());
2855 CXXRecordDecl *B = cast<CXXRecordDecl>(qB->getAs<RecordType>()->getDecl());
Anders Carlssonac3f7bd2009-12-04 18:36:22 +00002856 if (D != MostDerivedClass)
Anders Carlssonaf440352010-03-23 04:11:45 +00002857 return CGM.getVTables().getVirtualBaseOffsetOffset(D, B);
Anders Carlssondbd920c2009-10-11 22:13:54 +00002858 llvm::DenseMap<const CXXRecordDecl *, Index_t>::iterator i;
2859 i = VBIndex.find(B);
2860 if (i != VBIndex.end())
2861 return i->second;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002862
Mike Stumpab28c132009-10-13 22:54:56 +00002863 assert(false && "FIXME: Base not found");
Anders Carlssondbd920c2009-10-11 22:13:54 +00002864 return 0;
2865 }
2866
Eli Friedman367d1222009-12-04 08:40:51 +00002867 bool OverrideMethod(GlobalDecl GD, bool MorallyVirtual,
2868 Index_t OverrideOffset, Index_t Offset,
2869 int64_t CurrentVBaseOffset);
Anders Carlssondbd920c2009-10-11 22:13:54 +00002870
Anders Carlssonadfa2672009-12-04 02:39:04 +00002871 /// AppendMethods - Append the current methods to the vtable.
Anders Carlssonbf540272009-12-04 02:56:03 +00002872 void AppendMethodsToVtable();
Anders Carlssonadfa2672009-12-04 02:39:04 +00002873
Anders Carlssona0fdd912009-11-13 17:08:56 +00002874 llvm::Constant *WrapAddrOf(GlobalDecl GD) {
2875 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2876
Anders Carlssonecf282b2009-11-24 05:08:52 +00002877 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVtable(MD);
Mike Stump1ae31782009-10-27 23:36:26 +00002878
Mike Stumpc085a982009-12-03 16:55:20 +00002879 return wrap(CGM.GetAddrOfFunction(GD, Ty));
Mike Stump1ae31782009-10-27 23:36:26 +00002880 }
2881
Mike Stump9e7e3c62009-11-06 23:27:42 +00002882 void OverrideMethods(Path_t *Path, bool MorallyVirtual, int64_t Offset,
2883 int64_t CurrentVBaseOffset) {
Mike Stump11dea942009-10-15 02:04:03 +00002884 for (Path_t::reverse_iterator i = Path->rbegin(),
Anders Carlssondbd920c2009-10-11 22:13:54 +00002885 e = Path->rend(); i != e; ++i) {
2886 const CXXRecordDecl *RD = i->first;
Mike Stump3425b972009-10-15 09:30:16 +00002887 int64_t OverrideOffset = i->second;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002888 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
2889 ++mi) {
Anders Carlssona0fdd912009-11-13 17:08:56 +00002890 const CXXMethodDecl *MD = *mi;
2891
2892 if (!MD->isVirtual())
Anders Carlssondbd920c2009-10-11 22:13:54 +00002893 continue;
2894
Anders Carlssona0fdd912009-11-13 17:08:56 +00002895 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2896 // Override both the complete and the deleting destructor.
2897 GlobalDecl CompDtor(DD, Dtor_Complete);
Eli Friedman367d1222009-12-04 08:40:51 +00002898 OverrideMethod(CompDtor, MorallyVirtual, OverrideOffset, Offset,
2899 CurrentVBaseOffset);
2900
Anders Carlssona0fdd912009-11-13 17:08:56 +00002901 GlobalDecl DeletingDtor(DD, Dtor_Deleting);
Eli Friedman367d1222009-12-04 08:40:51 +00002902 OverrideMethod(DeletingDtor, MorallyVirtual, OverrideOffset, Offset,
2903 CurrentVBaseOffset);
Anders Carlssona0fdd912009-11-13 17:08:56 +00002904 } else {
Eli Friedman367d1222009-12-04 08:40:51 +00002905 OverrideMethod(MD, MorallyVirtual, OverrideOffset, Offset,
2906 CurrentVBaseOffset);
Anders Carlssona0fdd912009-11-13 17:08:56 +00002907 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00002908 }
2909 }
2910 }
2911
Anders Carlssona0fdd912009-11-13 17:08:56 +00002912 void AddMethod(const GlobalDecl GD, bool MorallyVirtual, Index_t Offset,
Eli Friedman76ed1f72009-11-30 01:19:33 +00002913 int64_t CurrentVBaseOffset) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00002914 // If we can find a previously allocated slot for this, reuse it.
Eli Friedman367d1222009-12-04 08:40:51 +00002915 if (OverrideMethod(GD, MorallyVirtual, Offset, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +00002916 CurrentVBaseOffset))
Anders Carlssondbd920c2009-10-11 22:13:54 +00002917 return;
2918
Mike Stump372ade22010-01-22 18:48:47 +00002919 D1(printf(" vfn for %s at %d\n",
Douglas Gregoraef605d2010-02-22 16:44:27 +00002920 dyn_cast<CXXMethodDecl>(GD.getDecl())->getNameAsString().c_str(),
Mike Stump372ade22010-01-22 18:48:47 +00002921 (int)Methods.size()));
2922
Anders Carlssona7f19112009-12-04 02:08:24 +00002923 // We didn't find an entry in the vtable that we could use, add a new
2924 // entry.
2925 Methods.AddMethod(GD);
2926
Mike Stump15189fb2010-01-26 21:35:27 +00002927 VCallOffset[GD] = Offset/8 - CurrentVBaseOffset/8;
2928
Anders Carlssondbd920c2009-10-11 22:13:54 +00002929 if (MorallyVirtual) {
Anders Carlsson0f0bbbc2010-01-26 17:36:47 +00002930 GlobalDecl UGD = getUnique(GD);
2931 const CXXMethodDecl *UMD = cast<CXXMethodDecl>(UGD.getDecl());
2932
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002933 assert(UMD && "final overrider not found");
2934
2935 Index_t &idx = VCall[UMD];
Anders Carlssondbd920c2009-10-11 22:13:54 +00002936 // Allocate the first one, after that, we reuse the previous one.
2937 if (idx == 0) {
Anders Carlsson0f0bbbc2010-01-26 17:36:47 +00002938 VCallOffsetForVCall[UGD] = Offset/8;
Mike Stump15189fb2010-01-26 21:35:27 +00002939 NonVirtualOffset[UMD] = Offset/8 - CurrentVBaseOffset/8;
Anders Carlssondbd920c2009-10-11 22:13:54 +00002940 idx = VCalls.size()+1;
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002941 VCalls.push_back(Offset/8 - CurrentVBaseOffset/8);
Mike Stump6a9612f2009-10-31 20:06:59 +00002942 D1(printf(" vcall for %s at %d with delta %d\n",
Douglas Gregoraef605d2010-02-22 16:44:27 +00002943 dyn_cast<CXXMethodDecl>(GD.getDecl())->getNameAsString().c_str(),
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00002944 (int)-VCalls.size()-3, (int)VCalls[idx-1]));
Anders Carlssondbd920c2009-10-11 22:13:54 +00002945 }
2946 }
2947 }
2948
2949 void AddMethods(const CXXRecordDecl *RD, bool MorallyVirtual,
Eli Friedman76ed1f72009-11-30 01:19:33 +00002950 Index_t Offset, int64_t CurrentVBaseOffset) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00002951 for (method_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
Anders Carlssona0fdd912009-11-13 17:08:56 +00002952 ++mi) {
2953 const CXXMethodDecl *MD = *mi;
2954 if (!MD->isVirtual())
2955 continue;
2956
2957 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2958 // For destructors, add both the complete and the deleting destructor
2959 // to the vtable.
2960 AddMethod(GlobalDecl(DD, Dtor_Complete), MorallyVirtual, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +00002961 CurrentVBaseOffset);
Eli Friedman76ed1f72009-11-30 01:19:33 +00002962 AddMethod(GlobalDecl(DD, Dtor_Deleting), MorallyVirtual, Offset,
2963 CurrentVBaseOffset);
2964 } else
2965 AddMethod(MD, MorallyVirtual, Offset, CurrentVBaseOffset);
Anders Carlssona0fdd912009-11-13 17:08:56 +00002966 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00002967 }
2968
2969 void NonVirtualBases(const CXXRecordDecl *RD, const ASTRecordLayout &Layout,
2970 const CXXRecordDecl *PrimaryBase,
2971 bool PrimaryBaseWasVirtual, bool MorallyVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +00002972 int64_t Offset, int64_t CurrentVBaseOffset,
2973 Path_t *Path) {
Mike Stump11dea942009-10-15 02:04:03 +00002974 Path->push_back(std::make_pair(RD, Offset));
Anders Carlssondbd920c2009-10-11 22:13:54 +00002975 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
2976 e = RD->bases_end(); i != e; ++i) {
2977 if (i->isVirtual())
2978 continue;
2979 const CXXRecordDecl *Base =
2980 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
Mike Stumpfc9f16c2010-01-22 06:45:05 +00002981 uint64_t o = Offset + Layout.getBaseClassOffset(Base);
2982 StartNewTable();
2983 GenerateVtableForBase(Base, o, MorallyVirtual, false,
2984 true, Base == PrimaryBase && !PrimaryBaseWasVirtual,
2985 CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +00002986 }
Mike Stump11dea942009-10-15 02:04:03 +00002987 Path->pop_back();
Anders Carlssondbd920c2009-10-11 22:13:54 +00002988 }
2989
Mike Stump0ca42792009-10-14 18:14:51 +00002990// #define D(X) do { X; } while (0)
2991#define D(X)
2992
2993 void insertVCalls(int InsertionPoint) {
Mike Stump6a9612f2009-10-31 20:06:59 +00002994 D1(printf("============= combining vbase/vcall\n"));
Mike Stump0ca42792009-10-14 18:14:51 +00002995 D(VCalls.insert(VCalls.begin(), 673));
2996 D(VCalls.push_back(672));
Eli Friedman152b5b12009-12-05 01:05:03 +00002997
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00002998 VtableComponents.insert(VtableComponents.begin() + InsertionPoint,
2999 VCalls.size(), 0);
Eli Friedman152b5b12009-12-05 01:05:03 +00003000 if (BuildVtable) {
3001 // The vcalls come first...
3002 for (std::vector<Index_t>::reverse_iterator i = VCalls.rbegin(),
3003 e = VCalls.rend();
3004 i != e; ++i)
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003005 VtableComponents[InsertionPoint++] = wrap((0?600:0) + *i);
Eli Friedman152b5b12009-12-05 01:05:03 +00003006 }
Mike Stump0ca42792009-10-14 18:14:51 +00003007 VCalls.clear();
Mike Stumpfbfb52d2009-11-10 02:30:51 +00003008 VCall.clear();
Mike Stump15189fb2010-01-26 21:35:27 +00003009 VCallOffsetForVCall.clear();
3010 VCallOffset.clear();
3011 NonVirtualOffset.clear();
Mike Stump0ca42792009-10-14 18:14:51 +00003012 }
3013
Mike Stump65d0e282009-11-13 23:13:20 +00003014 void AddAddressPoints(const CXXRecordDecl *RD, uint64_t Offset,
3015 Index_t AddressPoint) {
3016 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003017 RD->getNameAsCString(), MostDerivedClass->getNameAsCString(),
Mike Stump65d0e282009-11-13 23:13:20 +00003018 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump23a35422009-11-19 20:52:19 +00003019 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Anders Carlsson1bb60992010-01-14 02:29:07 +00003020 AddressPoints[BaseSubobject(RD, Offset)] = AddressPoint;
Mike Stump65d0e282009-11-13 23:13:20 +00003021
3022 // Now also add the address point for all our primary bases.
3023 while (1) {
3024 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3025 RD = Layout.getPrimaryBase();
3026 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
3027 // FIXME: Double check this.
3028 if (RD == 0)
3029 break;
3030 if (PrimaryBaseWasVirtual &&
3031 BLayout.getVBaseClassOffset(RD) != Offset)
3032 break;
3033 D1(printf("XXX address point for %s in %s layout %s at offset %d is %d\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003034 RD->getNameAsCString(), MostDerivedClass->getNameAsCString(),
Mike Stump65d0e282009-11-13 23:13:20 +00003035 LayoutClass->getNameAsCString(), (int)Offset, (int)AddressPoint));
Mike Stump23a35422009-11-19 20:52:19 +00003036 subAddressPoints[std::make_pair(RD, Offset)] = AddressPoint;
Anders Carlsson1bb60992010-01-14 02:29:07 +00003037 AddressPoints[BaseSubobject(RD, Offset)] = AddressPoint;
Mike Stump65d0e282009-11-13 23:13:20 +00003038 }
3039 }
3040
3041
Mike Stump8cc4f102009-12-24 07:29:41 +00003042 void FinishGenerateVtable(const CXXRecordDecl *RD,
3043 const ASTRecordLayout &Layout,
3044 const CXXRecordDecl *PrimaryBase,
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003045 bool ForNPNVBases, bool WasPrimaryBase,
Mike Stump8cc4f102009-12-24 07:29:41 +00003046 bool PrimaryBaseWasVirtual,
3047 bool MorallyVirtual, int64_t Offset,
3048 bool ForVirtualBase, int64_t CurrentVBaseOffset,
3049 Path_t *Path) {
Mike Stump11dea942009-10-15 02:04:03 +00003050 bool alloc = false;
3051 if (Path == 0) {
3052 alloc = true;
3053 Path = new Path_t;
3054 }
3055
Anders Carlssondbd920c2009-10-11 22:13:54 +00003056 StartNewTable();
3057 extra = 0;
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003058 Index_t AddressPoint = 0;
3059 int VCallInsertionPoint = 0;
3060 if (!ForNPNVBases || !WasPrimaryBase) {
3061 bool DeferVCalls = MorallyVirtual || ForVirtualBase;
3062 VCallInsertionPoint = VtableComponents.size();
3063 if (!DeferVCalls) {
3064 insertVCalls(VCallInsertionPoint);
3065 } else
3066 // FIXME: just for extra, or for all uses of VCalls.size post this?
3067 extra = -VCalls.size();
Anders Carlssondbd920c2009-10-11 22:13:54 +00003068
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003069 // Add the offset to top.
3070 VtableComponents.push_back(BuildVtable ? wrap(-((Offset-LayoutOffset)/8)) : 0);
Anders Carlsson15318f42009-12-04 16:19:30 +00003071
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003072 // Add the RTTI information.
3073 VtableComponents.push_back(rtti);
Anders Carlsson15318f42009-12-04 16:19:30 +00003074
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003075 AddressPoint = VtableComponents.size();
Anders Carlssondbd920c2009-10-11 22:13:54 +00003076
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003077 AppendMethodsToVtable();
3078 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00003079
3080 // and then the non-virtual bases.
3081 NonVirtualBases(RD, Layout, PrimaryBase, PrimaryBaseWasVirtual,
Mike Stump9e7e3c62009-11-06 23:27:42 +00003082 MorallyVirtual, Offset, CurrentVBaseOffset, Path);
Mike Stump0ca42792009-10-14 18:14:51 +00003083
3084 if (ForVirtualBase) {
Mike Stump9840c702009-11-12 20:47:57 +00003085 // FIXME: We're adding to VCalls in callers, we need to do the overrides
3086 // in the inner part, so that we know the complete set of vcalls during
3087 // the build and don't have to insert into methods. Saving out the
3088 // AddressPoint here, would need to be fixed, if we didn't do that. Also
3089 // retroactively adding vcalls for overrides later wind up in the wrong
3090 // place, the vcall slot has to be alloted during the walk of the base
3091 // when the function is first introduces.
Mike Stump0ca42792009-10-14 18:14:51 +00003092 AddressPoint += VCalls.size();
Mike Stump9840c702009-11-12 20:47:57 +00003093 insertVCalls(VCallInsertionPoint);
Mike Stump0ca42792009-10-14 18:14:51 +00003094 }
3095
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003096 if (!ForNPNVBases || !WasPrimaryBase)
3097 AddAddressPoints(RD, Offset, AddressPoint);
Mike Stump9840c702009-11-12 20:47:57 +00003098
Mike Stump11dea942009-10-15 02:04:03 +00003099 if (alloc) {
3100 delete Path;
3101 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00003102 }
3103
Mike Stump6a9612f2009-10-31 20:06:59 +00003104 void Primaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
3105 bool updateVBIndex, Index_t current_vbindex,
Eli Friedman76ed1f72009-11-30 01:19:33 +00003106 int64_t CurrentVBaseOffset) {
Mike Stump6a9612f2009-10-31 20:06:59 +00003107 if (!RD->isDynamicClass())
3108 return;
3109
3110 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3111 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
3112 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
3113
3114 // vtables are composed from the chain of primaries.
Eli Friedmandfe33bb2009-12-04 08:52:11 +00003115 if (PrimaryBase && !PrimaryBaseWasVirtual) {
Mike Stump6a9612f2009-10-31 20:06:59 +00003116 D1(printf(" doing primaries for %s most derived %s\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003117 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Eli Friedmandfe33bb2009-12-04 08:52:11 +00003118 Primaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
3119 updateVBIndex, current_vbindex, CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +00003120 }
3121
3122 D1(printf(" doing vcall entries for %s most derived %s\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003123 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump6a9612f2009-10-31 20:06:59 +00003124
3125 // And add the virtuals for the class to the primary vtable.
Eli Friedman76ed1f72009-11-30 01:19:33 +00003126 AddMethods(RD, MorallyVirtual, Offset, CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +00003127 }
3128
3129 void VBPrimaries(const CXXRecordDecl *RD, bool MorallyVirtual, int64_t Offset,
3130 bool updateVBIndex, Index_t current_vbindex,
Mike Stump9e7e3c62009-11-06 23:27:42 +00003131 bool RDisVirtualBase, int64_t CurrentVBaseOffset,
Eli Friedman76ed1f72009-11-30 01:19:33 +00003132 bool bottom) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003133 if (!RD->isDynamicClass())
3134 return;
3135
3136 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3137 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
3138 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
3139
3140 // vtables are composed from the chain of primaries.
3141 if (PrimaryBase) {
Mike Stump9e7e3c62009-11-06 23:27:42 +00003142 int BaseCurrentVBaseOffset = CurrentVBaseOffset;
3143 if (PrimaryBaseWasVirtual) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003144 IndirectPrimary.insert(PrimaryBase);
Mike Stump9e7e3c62009-11-06 23:27:42 +00003145 BaseCurrentVBaseOffset = BLayout.getVBaseClassOffset(PrimaryBase);
3146 }
Mike Stump6a9612f2009-10-31 20:06:59 +00003147
3148 D1(printf(" doing primaries for %s most derived %s\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003149 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump6a9612f2009-10-31 20:06:59 +00003150
3151 VBPrimaries(PrimaryBase, PrimaryBaseWasVirtual|MorallyVirtual, Offset,
Mike Stump9e7e3c62009-11-06 23:27:42 +00003152 updateVBIndex, current_vbindex, PrimaryBaseWasVirtual,
Eli Friedman76ed1f72009-11-30 01:19:33 +00003153 BaseCurrentVBaseOffset, false);
Anders Carlssondbd920c2009-10-11 22:13:54 +00003154 }
3155
Mike Stump6a9612f2009-10-31 20:06:59 +00003156 D1(printf(" doing vbase entries for %s most derived %s\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003157 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Mike Stump6a9612f2009-10-31 20:06:59 +00003158 GenerateVBaseOffsets(RD, Offset, updateVBIndex, current_vbindex);
3159
3160 if (RDisVirtualBase || bottom) {
3161 Primaries(RD, MorallyVirtual, Offset, updateVBIndex, current_vbindex,
Eli Friedman76ed1f72009-11-30 01:19:33 +00003162 CurrentVBaseOffset);
Mike Stump6a9612f2009-10-31 20:06:59 +00003163 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00003164 }
3165
Mike Stump8cc4f102009-12-24 07:29:41 +00003166 void GenerateVtableForBase(const CXXRecordDecl *RD, int64_t Offset = 0,
3167 bool MorallyVirtual = false,
3168 bool ForVirtualBase = false,
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003169 bool ForNPNVBases = false,
3170 bool WasPrimaryBase = true,
Mike Stump8cc4f102009-12-24 07:29:41 +00003171 int CurrentVBaseOffset = 0,
3172 Path_t *Path = 0) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003173 if (!RD->isDynamicClass())
Mike Stump8cc4f102009-12-24 07:29:41 +00003174 return;
Anders Carlssondbd920c2009-10-11 22:13:54 +00003175
Mike Stump92774d12009-11-13 02:35:38 +00003176 // Construction vtable don't need parts that have no virtual bases and
3177 // aren't morally virtual.
Anders Carlssonac3f7bd2009-12-04 18:36:22 +00003178 if ((LayoutClass != MostDerivedClass) &&
3179 RD->getNumVBases() == 0 && !MorallyVirtual)
Mike Stump8cc4f102009-12-24 07:29:41 +00003180 return;
Mike Stump92774d12009-11-13 02:35:38 +00003181
Anders Carlssondbd920c2009-10-11 22:13:54 +00003182 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3183 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
3184 const bool PrimaryBaseWasVirtual = Layout.getPrimaryBaseWasVirtual();
3185
Anders Carlssondbd920c2009-10-11 22:13:54 +00003186 extra = 0;
Mike Stump6a9612f2009-10-31 20:06:59 +00003187 D1(printf("building entries for base %s most derived %s\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003188 RD->getNameAsCString(), MostDerivedClass->getNameAsCString()));
Anders Carlssondbd920c2009-10-11 22:13:54 +00003189
Mike Stump6a9612f2009-10-31 20:06:59 +00003190 if (ForVirtualBase)
3191 extra = VCalls.size();
3192
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003193 if (!ForNPNVBases || !WasPrimaryBase) {
3194 VBPrimaries(RD, MorallyVirtual, Offset, !ForVirtualBase, 0,
3195 ForVirtualBase, CurrentVBaseOffset, true);
Anders Carlssondbd920c2009-10-11 22:13:54 +00003196
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003197 if (Path)
3198 OverrideMethods(Path, MorallyVirtual, Offset, CurrentVBaseOffset);
3199 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00003200
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003201 FinishGenerateVtable(RD, Layout, PrimaryBase, ForNPNVBases, WasPrimaryBase,
3202 PrimaryBaseWasVirtual, MorallyVirtual, Offset,
3203 ForVirtualBase, CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +00003204 }
3205
3206 void GenerateVtableForVBases(const CXXRecordDecl *RD,
3207 int64_t Offset = 0,
Mike Stump11dea942009-10-15 02:04:03 +00003208 Path_t *Path = 0) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003209 bool alloc = false;
3210 if (Path == 0) {
3211 alloc = true;
Mike Stump11dea942009-10-15 02:04:03 +00003212 Path = new Path_t;
Anders Carlssondbd920c2009-10-11 22:13:54 +00003213 }
3214 // FIXME: We also need to override using all paths to a virtual base,
3215 // right now, we just process the first path
3216 Path->push_back(std::make_pair(RD, Offset));
3217 for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
3218 e = RD->bases_end(); i != e; ++i) {
3219 const CXXRecordDecl *Base =
3220 cast<CXXRecordDecl>(i->getType()->getAs<RecordType>()->getDecl());
3221 if (i->isVirtual() && !IndirectPrimary.count(Base)) {
3222 // Mark it so we don't output it twice.
3223 IndirectPrimary.insert(Base);
3224 StartNewTable();
Mike Stump0ca42792009-10-14 18:14:51 +00003225 VCall.clear();
Anders Carlssondbd920c2009-10-11 22:13:54 +00003226 int64_t BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump9e7e3c62009-11-06 23:27:42 +00003227 int64_t CurrentVBaseOffset = BaseOffset;
Mike Stump6a9612f2009-10-31 20:06:59 +00003228 D1(printf("vtable %s virtual base %s\n",
Mike Stumpd6584902010-01-22 02:51:26 +00003229 MostDerivedClass->getNameAsCString(), Base->getNameAsCString()));
Mike Stumpfc9f16c2010-01-22 06:45:05 +00003230 GenerateVtableForBase(Base, BaseOffset, true, true, false,
3231 true, CurrentVBaseOffset, Path);
Anders Carlssondbd920c2009-10-11 22:13:54 +00003232 }
Mike Stump9840c702009-11-12 20:47:57 +00003233 int64_t BaseOffset;
Anders Carlssondbd920c2009-10-11 22:13:54 +00003234 if (i->isVirtual())
3235 BaseOffset = BLayout.getVBaseClassOffset(Base);
Mike Stump9840c702009-11-12 20:47:57 +00003236 else {
3237 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3238 BaseOffset = Offset + Layout.getBaseClassOffset(Base);
3239 }
3240
Mike Stump11dea942009-10-15 02:04:03 +00003241 if (Base->getNumVBases()) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003242 GenerateVtableForVBases(Base, BaseOffset, Path);
Mike Stump11dea942009-10-15 02:04:03 +00003243 }
Anders Carlssondbd920c2009-10-11 22:13:54 +00003244 }
3245 Path->pop_back();
3246 if (alloc)
3247 delete Path;
3248 }
3249};
Anders Carlsson27682a32009-12-03 01:54:02 +00003250} // end anonymous namespace
3251
Anders Carlsson824d7ea2010-02-11 08:02:13 +00003252bool OldVtableBuilder::OverrideMethod(GlobalDecl GD, bool MorallyVirtual,
Eli Friedman367d1222009-12-04 08:40:51 +00003253 Index_t OverrideOffset, Index_t Offset,
3254 int64_t CurrentVBaseOffset) {
Anders Carlsson27682a32009-12-03 01:54:02 +00003255 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3256
3257 const bool isPure = MD->isPure();
Anders Carlsson7ca46432009-12-05 17:04:47 +00003258
Anders Carlsson27682a32009-12-03 01:54:02 +00003259 // FIXME: Should OverrideOffset's be Offset?
3260
Anders Carlsson7ca46432009-12-05 17:04:47 +00003261 for (CXXMethodDecl::method_iterator mi = MD->begin_overridden_methods(),
3262 e = MD->end_overridden_methods(); mi != e; ++mi) {
Anders Carlsson27682a32009-12-03 01:54:02 +00003263 GlobalDecl OGD;
Mike Stump15189fb2010-01-26 21:35:27 +00003264 GlobalDecl OGD2;
Anders Carlsson27682a32009-12-03 01:54:02 +00003265
Anders Carlsson3aaf4862009-12-04 05:51:56 +00003266 const CXXMethodDecl *OMD = *mi;
Anders Carlsson27682a32009-12-03 01:54:02 +00003267 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(OMD))
3268 OGD = GlobalDecl(DD, GD.getDtorType());
3269 else
3270 OGD = OMD;
Eli Friedman47145832009-12-04 08:34:14 +00003271
Eli Friedman72649ed2009-12-06 22:01:30 +00003272 // Check whether this is the method being overridden in this section of
3273 // the vtable.
Anders Carlsson77c23e52009-12-04 15:49:02 +00003274 uint64_t Index;
3275 if (!Methods.getIndex(OGD, Index))
Eli Friedman47145832009-12-04 08:34:14 +00003276 continue;
3277
Mike Stump15189fb2010-01-26 21:35:27 +00003278 OGD2 = OGD;
3279
Eli Friedman72649ed2009-12-06 22:01:30 +00003280 // Get the original method, which we should be computing thunks, etc,
3281 // against.
3282 OGD = Methods.getOrigMethod(Index);
3283 OMD = cast<CXXMethodDecl>(OGD.getDecl());
3284
Eli Friedman47145832009-12-04 08:34:14 +00003285 QualType ReturnType =
3286 MD->getType()->getAs<FunctionType>()->getResultType();
3287 QualType OverriddenReturnType =
3288 OMD->getType()->getAs<FunctionType>()->getResultType();
Anders Carlsson27682a32009-12-03 01:54:02 +00003289
Eli Friedman47145832009-12-04 08:34:14 +00003290 // Check if we need a return type adjustment.
Anders Carlssondf31af12010-02-13 23:17:31 +00003291 if (!ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
3292 OMD).isEmpty()) {
Eli Friedman47145832009-12-04 08:34:14 +00003293 CanQualType &BaseReturnType = BaseReturnTypes[Index];
Anders Carlsson27682a32009-12-03 01:54:02 +00003294
Eli Friedman47145832009-12-04 08:34:14 +00003295 // Insert the base return type.
3296 if (BaseReturnType.isNull())
3297 BaseReturnType =
3298 CGM.getContext().getCanonicalType(OverriddenReturnType);
3299 }
Anders Carlssondd454be2009-12-04 03:52:52 +00003300
Eli Friedman47145832009-12-04 08:34:14 +00003301 Methods.OverrideMethod(OGD, GD);
3302
Anders Carlsson0f0bbbc2010-01-26 17:36:47 +00003303 GlobalDecl UGD = getUnique(GD);
3304 const CXXMethodDecl *UMD = cast<CXXMethodDecl>(UGD.getDecl());
3305 assert(UGD.getDecl() && "unique overrider not found");
3306 assert(UGD == getUnique(OGD) && "unique overrider not unique");
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00003307
Eli Friedman47145832009-12-04 08:34:14 +00003308 ThisAdjustments.erase(Index);
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00003309 if (MorallyVirtual || VCall.count(UMD)) {
Mike Stump15189fb2010-01-26 21:35:27 +00003310
Mike Stumpcf0b9cc2010-01-26 00:05:04 +00003311 Index_t &idx = VCall[UMD];
Eli Friedman47145832009-12-04 08:34:14 +00003312 if (idx == 0) {
Mike Stump15189fb2010-01-26 21:35:27 +00003313 VCallOffset[GD] = VCallOffset[OGD];
3314 // NonVirtualOffset[UMD] = CurrentVBaseOffset/8 - OverrideOffset/8;
3315 NonVirtualOffset[UMD] = VCallOffset[OGD];
Mike Stumpd99a4d22010-01-26 03:42:22 +00003316 VCallOffsetForVCall[UMD] = OverrideOffset/8;
Eli Friedman47145832009-12-04 08:34:14 +00003317 idx = VCalls.size()+1;
Mike Stumpd99a4d22010-01-26 03:42:22 +00003318 VCalls.push_back(OverrideOffset/8 - CurrentVBaseOffset/8);
Eli Friedman47145832009-12-04 08:34:14 +00003319 D1(printf(" vcall for %s at %d with delta %d most derived %s\n",
3320 MD->getNameAsString().c_str(), (int)-idx-3,
Mike Stumpd6584902010-01-22 02:51:26 +00003321 (int)VCalls[idx-1], MostDerivedClass->getNameAsCString()));
Eli Friedman47145832009-12-04 08:34:14 +00003322 } else {
Mike Stump15189fb2010-01-26 21:35:27 +00003323 VCallOffset[GD] = NonVirtualOffset[UMD];
Anders Carlsson0f0bbbc2010-01-26 17:36:47 +00003324 VCalls[idx-1] = -VCallOffsetForVCall[UGD] + OverrideOffset/8;
Eli Friedman47145832009-12-04 08:34:14 +00003325 D1(printf(" vcall patch for %s at %d with delta %d most derived %s\n",
3326 MD->getNameAsString().c_str(), (int)-idx-3,
Mike Stumpd6584902010-01-22 02:51:26 +00003327 (int)VCalls[idx-1], MostDerivedClass->getNameAsCString()));
Eli Friedman47145832009-12-04 08:34:14 +00003328 }
Mike Stump15189fb2010-01-26 21:35:27 +00003329 int64_t NonVirtualAdjustment = -VCallOffset[OGD];
Mike Stump852f5ce2010-01-26 22:44:01 +00003330 QualType DerivedType = MD->getThisType(CGM.getContext());
3331 QualType BaseType = cast<const CXXMethodDecl>(OGD.getDecl())->getThisType(CGM.getContext());
3332 int64_t NonVirtualAdjustment2 = -(getNVOffset(BaseType, DerivedType)/8);
3333 if (NonVirtualAdjustment2 != NonVirtualAdjustment) {
3334 NonVirtualAdjustment = NonVirtualAdjustment2;
3335 }
Eli Friedman47145832009-12-04 08:34:14 +00003336 int64_t VirtualAdjustment =
3337 -((idx + extra + 2) * LLVMPointerWidth / 8);
Anders Carlsson891bb4b2009-12-03 02:32:59 +00003338
Eli Friedman47145832009-12-04 08:34:14 +00003339 // Optimize out virtual adjustments of 0.
3340 if (VCalls[idx-1] == 0)
3341 VirtualAdjustment = 0;
Anders Carlsson891bb4b2009-12-03 02:32:59 +00003342
Eli Friedman47145832009-12-04 08:34:14 +00003343 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment,
3344 VirtualAdjustment);
Anders Carlssonbc0e3392009-12-03 02:22:59 +00003345
Eli Friedman72649ed2009-12-06 22:01:30 +00003346 if (!isPure && !ThisAdjustment.isEmpty()) {
Eli Friedman47145832009-12-04 08:34:14 +00003347 ThisAdjustments[Index] = ThisAdjustment;
Eli Friedmanb455f0e2009-12-07 23:56:34 +00003348 SavedAdjustments.push_back(
3349 std::make_pair(GD, std::make_pair(OGD, ThisAdjustment)));
Eli Friedman72649ed2009-12-06 22:01:30 +00003350 }
Anders Carlsson27682a32009-12-03 01:54:02 +00003351 return true;
3352 }
Eli Friedman47145832009-12-04 08:34:14 +00003353
Mike Stump15189fb2010-01-26 21:35:27 +00003354 VCallOffset[GD] = VCallOffset[OGD2] - OverrideOffset/8;
Eli Friedman47145832009-12-04 08:34:14 +00003355
Mike Stump15189fb2010-01-26 21:35:27 +00003356 int64_t NonVirtualAdjustment = -VCallOffset[GD];
3357 QualType DerivedType = MD->getThisType(CGM.getContext());
3358 QualType BaseType = cast<const CXXMethodDecl>(OGD.getDecl())->getThisType(CGM.getContext());
3359 int64_t NonVirtualAdjustment2 = -(getNVOffset(BaseType, DerivedType)/8);
3360 if (NonVirtualAdjustment2 != NonVirtualAdjustment) {
3361 NonVirtualAdjustment = NonVirtualAdjustment2;
3362 }
3363
Eli Friedman47145832009-12-04 08:34:14 +00003364 if (NonVirtualAdjustment) {
3365 ThunkAdjustment ThisAdjustment(NonVirtualAdjustment, 0);
3366
Eli Friedmanf062d9d2009-12-06 22:33:51 +00003367 if (!isPure) {
Eli Friedman47145832009-12-04 08:34:14 +00003368 ThisAdjustments[Index] = ThisAdjustment;
Eli Friedmanb455f0e2009-12-07 23:56:34 +00003369 SavedAdjustments.push_back(
3370 std::make_pair(GD, std::make_pair(OGD, ThisAdjustment)));
Eli Friedmanf062d9d2009-12-06 22:33:51 +00003371 }
Eli Friedman47145832009-12-04 08:34:14 +00003372 }
3373 return true;
Anders Carlsson27682a32009-12-03 01:54:02 +00003374 }
3375
3376 return false;
Anders Carlsson27f69d02009-11-27 22:21:51 +00003377}
3378
Anders Carlsson824d7ea2010-02-11 08:02:13 +00003379void OldVtableBuilder::AppendMethodsToVtable() {
Eli Friedman152b5b12009-12-05 01:05:03 +00003380 if (!BuildVtable) {
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003381 VtableComponents.insert(VtableComponents.end(), Methods.size(),
3382 (llvm::Constant *)0);
Eli Friedman152b5b12009-12-05 01:05:03 +00003383 ThisAdjustments.clear();
3384 BaseReturnTypes.clear();
3385 Methods.clear();
3386 return;
3387 }
3388
Anders Carlsson15318f42009-12-04 16:19:30 +00003389 // Reserve room in the vtable for our new methods.
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003390 VtableComponents.reserve(VtableComponents.size() + Methods.size());
Anders Carlsson29202d52009-12-04 03:07:26 +00003391
Anders Carlssonb73ba392009-12-04 02:43:50 +00003392 for (unsigned i = 0, e = Methods.size(); i != e; ++i) {
3393 GlobalDecl GD = Methods[i];
Anders Carlssonea357222009-12-04 02:52:22 +00003394 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3395
3396 // Get the 'this' pointer adjustment.
Anders Carlssonb73ba392009-12-04 02:43:50 +00003397 ThunkAdjustment ThisAdjustment = ThisAdjustments.lookup(i);
Anders Carlssonea357222009-12-04 02:52:22 +00003398
3399 // Construct the return type adjustment.
3400 ThunkAdjustment ReturnAdjustment;
3401
3402 QualType BaseReturnType = BaseReturnTypes.lookup(i);
3403 if (!BaseReturnType.isNull() && !MD->isPure()) {
3404 QualType DerivedType =
3405 MD->getType()->getAs<FunctionType>()->getResultType();
3406
3407 int64_t NonVirtualAdjustment =
3408 getNVOffset(BaseReturnType, DerivedType) / 8;
3409
3410 int64_t VirtualAdjustment =
3411 getVbaseOffset(BaseReturnType, DerivedType);
3412
3413 ReturnAdjustment = ThunkAdjustment(NonVirtualAdjustment,
3414 VirtualAdjustment);
3415 }
3416
Anders Carlsson2fce2162009-12-04 03:06:03 +00003417 llvm::Constant *Method = 0;
Anders Carlssonea357222009-12-04 02:52:22 +00003418 if (!ReturnAdjustment.isEmpty()) {
3419 // Build a covariant thunk.
3420 CovariantThunkAdjustment Adjustment(ThisAdjustment, ReturnAdjustment);
Eli Friedman72649ed2009-12-06 22:01:30 +00003421 Method = wrap(CGM.GetAddrOfCovariantThunk(GD, Adjustment));
Anders Carlssonea357222009-12-04 02:52:22 +00003422 } else if (!ThisAdjustment.isEmpty()) {
3423 // Build a "regular" thunk.
Eli Friedman72649ed2009-12-06 22:01:30 +00003424 Method = wrap(CGM.GetAddrOfThunk(GD, ThisAdjustment));
Anders Carlssonbf540272009-12-04 02:56:03 +00003425 } else if (MD->isPure()) {
3426 // We have a pure virtual method.
Anders Carlsson2fce2162009-12-04 03:06:03 +00003427 Method = getPureVirtualFn();
3428 } else {
3429 // We have a good old regular method.
3430 Method = WrapAddrOf(GD);
Anders Carlssonea357222009-12-04 02:52:22 +00003431 }
Anders Carlsson2fce2162009-12-04 03:06:03 +00003432
3433 // Add the method to the vtable.
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003434 VtableComponents.push_back(Method);
Anders Carlssonb73ba392009-12-04 02:43:50 +00003435 }
3436
Anders Carlsson2fce2162009-12-04 03:06:03 +00003437
Anders Carlssonb73ba392009-12-04 02:43:50 +00003438 ThisAdjustments.clear();
Anders Carlssonea357222009-12-04 02:52:22 +00003439 BaseReturnTypes.clear();
Anders Carlssonb73ba392009-12-04 02:43:50 +00003440
Anders Carlssonadfa2672009-12-04 02:39:04 +00003441 Methods.clear();
Anders Carlssonadfa2672009-12-04 02:39:04 +00003442}
3443
Anders Carlssonaf440352010-03-23 04:11:45 +00003444void CodeGenVTables::ComputeMethodVtableIndices(const CXXRecordDecl *RD) {
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003445
3446 // Itanium C++ ABI 2.5.2:
Anders Carlsson45147d02010-02-02 03:37:46 +00003447 // The order of the virtual function pointers in a virtual table is the
3448 // order of declaration of the corresponding member functions in the class.
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003449 //
Anders Carlsson45147d02010-02-02 03:37:46 +00003450 // There is an entry for any virtual function declared in a class,
3451 // whether it is a new function or overrides a base class function,
3452 // unless it overrides a function from the primary base, and conversion
3453 // between their return types does not require an adjustment.
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003454
3455 int64_t CurrentIndex = 0;
3456
3457 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
3458 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
3459
3460 if (PrimaryBase) {
Anders Carlsson0121fbd2009-11-30 19:43:26 +00003461 assert(PrimaryBase->isDefinition() &&
3462 "Should have the definition decl of the primary base!");
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003463
3464 // Since the record decl shares its vtable pointer with the primary base
3465 // we need to start counting at the end of the primary base's vtable.
3466 CurrentIndex = getNumVirtualFunctionPointers(PrimaryBase);
3467 }
Eli Friedmanea5ae312009-12-15 03:31:17 +00003468
3469 // Collect all the primary bases, so we can check whether methods override
3470 // a method from the base.
Anders Carlssonb9021e92010-02-27 16:18:19 +00003471 VtableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
Eli Friedmanea5ae312009-12-15 03:31:17 +00003472 for (ASTRecordLayout::primary_base_info_iterator
3473 I = Layout.primary_base_begin(), E = Layout.primary_base_end();
3474 I != E; ++I)
3475 PrimaryBases.insert((*I).getBase());
3476
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003477 const CXXDestructorDecl *ImplicitVirtualDtor = 0;
3478
3479 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
3480 e = RD->method_end(); i != e; ++i) {
3481 const CXXMethodDecl *MD = *i;
3482
3483 // We only want virtual methods.
3484 if (!MD->isVirtual())
3485 continue;
3486
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003487 // Check if this method overrides a method in the primary base.
Anders Carlsson57071e22010-02-12 05:25:12 +00003488 if (const CXXMethodDecl *OverriddenMD =
Anders Carlssonc784ba22010-02-27 06:38:03 +00003489 OverridesMethodInBases(MD, PrimaryBases)) {
Anders Carlsson57071e22010-02-12 05:25:12 +00003490 // Check if converting from the return type of the method to the
3491 // return type of the overridden method requires conversion.
Anders Carlssondf31af12010-02-13 23:17:31 +00003492 if (ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
3493 OverriddenMD).isEmpty()) {
Anders Carlsson57071e22010-02-12 05:25:12 +00003494 // This index is shared between the index in the vtable of the primary
3495 // base class.
3496 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3497 const CXXDestructorDecl *OverriddenDD =
3498 cast<CXXDestructorDecl>(OverriddenMD);
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003499
Anders Carlsson57071e22010-02-12 05:25:12 +00003500 // Add both the complete and deleting entries.
3501 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] =
3502 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Complete));
3503 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] =
3504 getMethodVtableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
3505 } else {
3506 MethodVtableIndices[MD] = getMethodVtableIndex(OverriddenMD);
3507 }
3508
3509 // We don't need to add an entry for this method.
Anders Carlssonc1eec892010-02-12 18:14:46 +00003510 continue;
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003511 }
3512 }
3513
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003514 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
3515 if (MD->isImplicit()) {
3516 assert(!ImplicitVirtualDtor &&
3517 "Did already see an implicit virtual dtor!");
3518 ImplicitVirtualDtor = DD;
3519 continue;
3520 }
3521
3522 // Add the complete dtor.
3523 MethodVtableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++;
3524
3525 // Add the deleting dtor.
3526 MethodVtableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
3527 } else {
3528 // Add the entry.
3529 MethodVtableIndices[MD] = CurrentIndex++;
3530 }
3531 }
3532
3533 if (ImplicitVirtualDtor) {
3534 // Itanium C++ ABI 2.5.2:
Anders Carlssona661a542010-02-16 04:49:44 +00003535 // If a class has an implicitly-defined virtual destructor,
3536 // its entries come after the declared virtual function pointers.
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003537
3538 // Add the complete dtor.
3539 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Complete)] =
3540 CurrentIndex++;
3541
3542 // Add the deleting dtor.
3543 MethodVtableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Deleting)] =
3544 CurrentIndex++;
3545 }
3546
3547 NumVirtualFunctionPointers[RD] = CurrentIndex;
3548}
3549
Anders Carlssonaf440352010-03-23 04:11:45 +00003550uint64_t CodeGenVTables::getNumVirtualFunctionPointers(const CXXRecordDecl *RD) {
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003551 llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
3552 NumVirtualFunctionPointers.find(RD);
3553 if (I != NumVirtualFunctionPointers.end())
3554 return I->second;
3555
3556 ComputeMethodVtableIndices(RD);
3557
3558 I = NumVirtualFunctionPointers.find(RD);
3559 assert(I != NumVirtualFunctionPointers.end() && "Did not find entry!");
3560 return I->second;
3561}
3562
Anders Carlssonaf440352010-03-23 04:11:45 +00003563uint64_t CodeGenVTables::getMethodVtableIndex(GlobalDecl GD) {
Anders Carlssona0fdd912009-11-13 17:08:56 +00003564 MethodVtableIndicesTy::iterator I = MethodVtableIndices.find(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +00003565 if (I != MethodVtableIndices.end())
3566 return I->second;
3567
Anders Carlssona0fdd912009-11-13 17:08:56 +00003568 const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
Anders Carlssond6b07fb2009-11-27 20:47:55 +00003569
3570 ComputeMethodVtableIndices(RD);
3571
Anders Carlssona0fdd912009-11-13 17:08:56 +00003572 I = MethodVtableIndices.find(GD);
Anders Carlssondbd920c2009-10-11 22:13:54 +00003573 assert(I != MethodVtableIndices.end() && "Did not find index!");
3574 return I->second;
3575}
3576
Anders Carlssonaf440352010-03-23 04:11:45 +00003577int64_t CodeGenVTables::getVirtualBaseOffsetOffset(const CXXRecordDecl *RD,
3578 const CXXRecordDecl *VBase) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003579 ClassPairTy ClassPair(RD, VBase);
3580
Anders Carlssonbba16072010-03-11 07:15:17 +00003581 VirtualBaseClassOffsetOffsetsMapTy::iterator I =
3582 VirtualBaseClassOffsetOffsets.find(ClassPair);
3583 if (I != VirtualBaseClassOffsetOffsets.end())
Anders Carlssondbd920c2009-10-11 22:13:54 +00003584 return I->second;
3585
Anders Carlssonc89a7cf2010-03-11 16:06:20 +00003586 VCallAndVBaseOffsetBuilder Builder(RD, RD, /*FinalOverriders=*/0,
3587 BaseSubobject(RD, 0),
3588 /*BaseIsVirtual=*/false,
3589 /*OffsetInLayoutClass=*/0);
Anders Carlssonc89a7cf2010-03-11 16:06:20 +00003590
3591 for (VCallAndVBaseOffsetBuilder::VBaseOffsetOffsetsMapTy::const_iterator I =
3592 Builder.getVBaseOffsetOffsets().begin(),
3593 E = Builder.getVBaseOffsetOffsets().end(); I != E; ++I) {
Anders Carlssondbd920c2009-10-11 22:13:54 +00003594 // Insert all types.
3595 ClassPairTy ClassPair(RD, I->first);
3596
Anders Carlssonbba16072010-03-11 07:15:17 +00003597 VirtualBaseClassOffsetOffsets.insert(std::make_pair(ClassPair, I->second));
Anders Carlssondbd920c2009-10-11 22:13:54 +00003598 }
3599
Anders Carlssonbba16072010-03-11 07:15:17 +00003600 I = VirtualBaseClassOffsetOffsets.find(ClassPair);
Anders Carlssonc89a7cf2010-03-11 16:06:20 +00003601
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00003602 // FIXME: The assertion below assertion currently fails with the old vtable
3603 /// layout code if there is a non-virtual thunk adjustment in a vtable.
3604 // Once the new layout is in place, this return should be removed.
Anders Carlssonbba16072010-03-11 07:15:17 +00003605 if (I == VirtualBaseClassOffsetOffsets.end())
Anders Carlsson7dbf47a2010-02-13 20:11:51 +00003606 return 0;
3607
Anders Carlssonbba16072010-03-11 07:15:17 +00003608 assert(I != VirtualBaseClassOffsetOffsets.end() && "Did not find index!");
Anders Carlssondbd920c2009-10-11 22:13:54 +00003609
3610 return I->second;
3611}
3612
Anders Carlsson64c9eca2010-03-29 02:08:26 +00003613uint64_t
3614CodeGenVTables::getAddressPoint(BaseSubobject Base, const CXXRecordDecl *RD) {
3615 const CodeGenVTables::AddrSubMap_t& AddressPoints = getAddressPoints(RD);
3616
3617 uint64_t AddressPoint =
3618 AddressPoints.lookup(std::make_pair(Base.getBase(),
3619 Base.getBaseOffset()));
3620
3621 assert(AddressPoint && "Address point must not be zero!");
3622
3623 return AddressPoint;
3624}
3625
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00003626const CodeGenVTables::AddrSubMap_t &
3627CodeGenVTables::getAddressPoints(const CXXRecordDecl *RD) {
Anders Carlsson66d567d2010-03-25 00:51:13 +00003628 if (!OldAddressPoints[RD]) {
Anders Carlssonff143f82010-03-25 00:35:49 +00003629 OldVtableBuilder::AddressPointsMapTy AddressPoints;
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00003630 OldVtableBuilder b(RD, RD, 0, CGM, false, AddressPoints);
3631
3632 b.GenerateVtableForBase(RD, 0);
3633 b.GenerateVtableForVBases(RD, 0);
3634 }
3635
Anders Carlsson66d567d2010-03-25 00:51:13 +00003636 return *(*OldAddressPoints[RD])[RD];
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00003637}
3638
Anders Carlsson8c2d36f2009-12-06 00:01:05 +00003639llvm::GlobalVariable *
Anders Carlssonaf440352010-03-23 04:11:45 +00003640CodeGenVTables::GenerateVtable(llvm::GlobalVariable::LinkageTypes Linkage,
3641 bool GenerateDefinition,
3642 const CXXRecordDecl *LayoutClass,
3643 const CXXRecordDecl *RD, uint64_t Offset,
3644 bool IsVirtual,
Anders Carlssonff143f82010-03-25 00:35:49 +00003645 llvm::DenseMap<BaseSubobject, uint64_t> &AddressPoints) {
Anders Carlssond03a3262010-02-27 20:39:05 +00003646 if (GenerateDefinition) {
3647 if (LayoutClass == RD) {
Anders Carlsson5d7af6b2010-02-28 00:36:23 +00003648 assert(!IsVirtual &&
Anders Carlssone02fc0a2010-03-11 05:48:21 +00003649 "Can only have a virtual base in construction vtables!");
3650 assert(!Offset &&
3651 "Can only have a base offset in construction vtables!");
Anders Carlssond03a3262010-02-27 20:39:05 +00003652 }
Anders Carlssone02fc0a2010-03-11 05:48:21 +00003653
3654 VtableBuilder Builder(*this, RD, Offset,
Anders Carlsson1ffd79b2010-03-11 06:10:52 +00003655 /*MostDerivedClassIsVirtual=*/IsVirtual,
Anders Carlssone02fc0a2010-03-11 05:48:21 +00003656 LayoutClass);
3657
3658 if (CGM.getLangOptions().DumpVtableLayouts)
3659 Builder.dumpLayout(llvm::errs());
Anders Carlsson0c0eeb22010-02-13 02:02:03 +00003660 }
3661
Anders Carlssondbd920c2009-10-11 22:13:54 +00003662 llvm::SmallString<256> OutName;
Mike Stump9840c702009-11-12 20:47:57 +00003663 if (LayoutClass != RD)
Anders Carlsson8c2d36f2009-12-06 00:01:05 +00003664 CGM.getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset / 8,
3665 RD, OutName);
Mike Stump8cfcb522009-11-11 20:26:26 +00003666 else
Anders Carlsson8c2d36f2009-12-06 00:01:05 +00003667 CGM.getMangleContext().mangleCXXVtable(RD, OutName);
Daniel Dunbar94fd26d2009-11-21 09:06:22 +00003668 llvm::StringRef Name = OutName.str();
Benjamin Kramer7a9474e2009-10-11 22:57:54 +00003669
Anders Carlsson8c2d36f2009-12-06 00:01:05 +00003670 llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00003671 if (GV == 0 || GV->isDeclaration()) {
Anders Carlsson824d7ea2010-02-11 08:02:13 +00003672 OldVtableBuilder b(RD, LayoutClass, Offset, CGM, GenerateDefinition,
3673 AddressPoints);
Eli Friedman152b5b12009-12-05 01:05:03 +00003674
3675 D1(printf("vtable %s\n", RD->getNameAsCString()));
3676 // First comes the vtables for all the non-virtual bases...
Mike Stump8cc4f102009-12-24 07:29:41 +00003677 b.GenerateVtableForBase(RD, Offset);
Eli Friedman152b5b12009-12-05 01:05:03 +00003678
3679 // then the vtables for all the virtual bases.
3680 b.GenerateVtableForVBases(RD, Offset);
3681
Anders Carlsson152d4dc2009-12-05 22:19:10 +00003682 llvm::Constant *Init = 0;
Anders Carlsson8c2d36f2009-12-06 00:01:05 +00003683 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
Anders Carlsson152d4dc2009-12-05 22:19:10 +00003684 llvm::ArrayType *ArrayType =
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003685 llvm::ArrayType::get(Int8PtrTy, b.getVtableComponents().size());
Anders Carlssone40477c2009-12-05 21:09:05 +00003686
Anders Carlsson5794c972009-12-06 00:53:22 +00003687 if (GenerateDefinition)
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003688 Init = llvm::ConstantArray::get(ArrayType, &b.getVtableComponents()[0],
3689 b.getVtableComponents().size());
Anders Carlsson5794c972009-12-06 00:53:22 +00003690
Mike Stump85615df2009-11-19 04:04:36 +00003691 llvm::GlobalVariable *OGV = GV;
Anders Carlsson5794c972009-12-06 00:53:22 +00003692
3693 GV = new llvm::GlobalVariable(CGM.getModule(), ArrayType,
3694 /*isConstant=*/true, Linkage, Init, Name);
Anders Carlssonc3a46ef2009-12-06 01:09:21 +00003695 CGM.setGlobalVisibility(GV, RD);
3696
Mike Stump85615df2009-11-19 04:04:36 +00003697 if (OGV) {
3698 GV->takeName(OGV);
Anders Carlsson152d4dc2009-12-05 22:19:10 +00003699 llvm::Constant *NewPtr =
3700 llvm::ConstantExpr::getBitCast(GV, OGV->getType());
Mike Stump85615df2009-11-19 04:04:36 +00003701 OGV->replaceAllUsesWith(NewPtr);
3702 OGV->eraseFromParent();
3703 }
Mike Stump85615df2009-11-19 04:04:36 +00003704 }
Anders Carlssonbb27d862009-12-05 21:28:12 +00003705
3706 return GV;
Anders Carlssondbd920c2009-10-11 22:13:54 +00003707}
Mike Stumpfbfb52d2009-11-10 02:30:51 +00003708
Anders Carlsson19879c92010-03-23 17:17:29 +00003709llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
3710 const ThunkInfo &Thunk) {
3711 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3712
3713 // Compute the mangled name.
3714 llvm::SmallString<256> Name;
3715 if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD))
3716 getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(), Thunk.This,
3717 Name);
3718 else
3719 getMangleContext().mangleThunk(MD, Thunk, Name);
3720
3721 const llvm::Type *Ty = getTypes().GetFunctionTypeForVtable(MD);
3722 return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl());
3723}
3724
Anders Carlsson519c3282010-03-24 00:39:18 +00003725static llvm::Value *PerformTypeAdjustment(CodeGenFunction &CGF,
3726 llvm::Value *Ptr,
3727 int64_t NonVirtualAdjustment,
3728 int64_t VirtualAdjustment) {
3729 if (!NonVirtualAdjustment && !VirtualAdjustment)
3730 return Ptr;
3731
3732 const llvm::Type *Int8PtrTy =
3733 llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
3734
3735 llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
3736
3737 if (NonVirtualAdjustment) {
3738 // Do the non-virtual adjustment.
3739 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
3740 }
3741
3742 if (VirtualAdjustment) {
3743 const llvm::Type *PtrDiffTy =
3744 CGF.ConvertType(CGF.getContext().getPointerDiffType());
3745
3746 // Do the virtual adjustment.
3747 llvm::Value *VTablePtrPtr =
3748 CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo());
3749
3750 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
3751
3752 llvm::Value *OffsetPtr =
3753 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
3754
3755 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
3756
3757 // Load the adjustment offset from the vtable.
3758 llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr);
3759
3760 // Adjust our pointer.
3761 V = CGF.Builder.CreateInBoundsGEP(V, Offset);
3762 }
3763
3764 // Cast back to the original type.
3765 return CGF.Builder.CreateBitCast(V, Ptr->getType());
3766}
3767
3768void CodeGenFunction::GenerateThunk(llvm::Function *Fn, GlobalDecl GD,
3769 const ThunkInfo &Thunk) {
3770 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
3771 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
3772 QualType ResultType = FPT->getResultType();
3773 QualType ThisType = MD->getThisType(getContext());
3774
3775 FunctionArgList FunctionArgs;
3776
3777 // FIXME: It would be nice if more of this code could be shared with
3778 // CodeGenFunction::GenerateCode.
3779
3780 // Create the implicit 'this' parameter declaration.
3781 CXXThisDecl = ImplicitParamDecl::Create(getContext(), 0,
3782 MD->getLocation(),
3783 &getContext().Idents.get("this"),
3784 ThisType);
3785
3786 // Add the 'this' parameter.
3787 FunctionArgs.push_back(std::make_pair(CXXThisDecl, CXXThisDecl->getType()));
3788
3789 // Add the rest of the parameters.
3790 for (FunctionDecl::param_const_iterator I = MD->param_begin(),
3791 E = MD->param_end(); I != E; ++I) {
3792 ParmVarDecl *Param = *I;
3793
3794 FunctionArgs.push_back(std::make_pair(Param, Param->getType()));
3795 }
3796
3797 StartFunction(GlobalDecl(), ResultType, Fn, FunctionArgs, SourceLocation());
3798
3799 // Adjust the 'this' pointer if necessary.
3800 llvm::Value *AdjustedThisPtr =
3801 PerformTypeAdjustment(*this, LoadCXXThis(),
3802 Thunk.This.NonVirtual,
3803 Thunk.This.VCallOffsetOffset);
3804
3805 CallArgList CallArgs;
3806
3807 // Add our adjusted 'this' pointer.
3808 CallArgs.push_back(std::make_pair(RValue::get(AdjustedThisPtr), ThisType));
3809
3810 // Add the rest of the parameters.
3811 for (FunctionDecl::param_const_iterator I = MD->param_begin(),
3812 E = MD->param_end(); I != E; ++I) {
3813 ParmVarDecl *Param = *I;
3814 QualType ArgType = Param->getType();
3815
3816 // FIXME: Declaring a DeclRefExpr on the stack is kinda icky.
3817 DeclRefExpr ArgExpr(Param, ArgType.getNonReferenceType(), SourceLocation());
3818 CallArgs.push_back(std::make_pair(EmitCallArg(&ArgExpr, ArgType), ArgType));
3819 }
3820
3821 // Get our callee.
3822 const llvm::Type *Ty =
3823 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(MD),
3824 FPT->isVariadic());
3825 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty);
3826
3827 const CGFunctionInfo &FnInfo =
3828 CGM.getTypes().getFunctionInfo(ResultType, CallArgs, FPT->getCallConv(),
3829 FPT->getNoReturnAttr());
3830
3831 // Now emit our call.
3832 RValue RV = EmitCall(FnInfo, Callee, ReturnValueSlot(), CallArgs, MD);
3833
3834 if (!Thunk.Return.isEmpty()) {
3835 // Emit the return adjustment.
3836 bool NullCheckValue = !ResultType->isReferenceType();
3837
3838 llvm::BasicBlock *AdjustNull = 0;
3839 llvm::BasicBlock *AdjustNotNull = 0;
3840 llvm::BasicBlock *AdjustEnd = 0;
3841
3842 llvm::Value *ReturnValue = RV.getScalarVal();
3843
3844 if (NullCheckValue) {
3845 AdjustNull = createBasicBlock("adjust.null");
3846 AdjustNotNull = createBasicBlock("adjust.notnull");
3847 AdjustEnd = createBasicBlock("adjust.end");
3848
3849 llvm::Value *IsNull = Builder.CreateIsNull(ReturnValue);
3850 Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
3851 EmitBlock(AdjustNotNull);
3852 }
3853
3854 ReturnValue = PerformTypeAdjustment(*this, ReturnValue,
3855 Thunk.Return.NonVirtual,
3856 Thunk.Return.VBaseOffsetOffset);
3857
3858 if (NullCheckValue) {
3859 Builder.CreateBr(AdjustEnd);
3860 EmitBlock(AdjustNull);
3861 Builder.CreateBr(AdjustEnd);
3862 EmitBlock(AdjustEnd);
3863
3864 llvm::PHINode *PHI = Builder.CreatePHI(ReturnValue->getType());
3865 PHI->reserveOperandSpace(2);
3866 PHI->addIncoming(ReturnValue, AdjustNotNull);
3867 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
3868 AdjustNull);
3869 ReturnValue = PHI;
3870 }
3871
3872 RV = RValue::get(ReturnValue);
3873 }
3874
3875 if (!ResultType->isVoidType())
3876 EmitReturnOfRValue(RV, ResultType);
3877
3878 FinishFunction();
3879
3880 // Destroy the 'this' declaration.
3881 CXXThisDecl->Destroy(getContext());
3882
3883 // Set the right linkage.
Anders Carlssonada087c2010-03-27 20:50:27 +00003884 Fn->setLinkage(CGM.getFunctionLinkage(MD));
Anders Carlsson519c3282010-03-24 00:39:18 +00003885
3886 // Set the right visibility.
3887 CGM.setGlobalVisibility(Fn, MD);
3888}
3889
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00003890void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk)
3891{
Anders Carlsson13d68982010-03-24 00:35:44 +00003892 llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk);
Anders Carlsson7986ad52010-03-23 18:18:41 +00003893 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
Anders Carlsson19879c92010-03-23 17:17:29 +00003894
Anders Carlsson7986ad52010-03-23 18:18:41 +00003895 // Strip off a bitcast if we got one back.
Anders Carlsson13d68982010-03-24 00:35:44 +00003896 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Anders Carlsson7986ad52010-03-23 18:18:41 +00003897 assert(CE->getOpcode() == llvm::Instruction::BitCast);
Anders Carlsson13d68982010-03-24 00:35:44 +00003898 Entry = CE->getOperand(0);
Anders Carlsson7986ad52010-03-23 18:18:41 +00003899 }
3900
Anders Carlsson7986ad52010-03-23 18:18:41 +00003901 // There's already a declaration with the same name, check if it has the same
3902 // type or if we need to replace it.
Anders Carlsson13d68982010-03-24 00:35:44 +00003903 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() !=
3904 CGM.getTypes().GetFunctionTypeForVtable(MD)) {
3905 llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry);
Anders Carlsson7986ad52010-03-23 18:18:41 +00003906
3907 // If the types mismatch then we have to rewrite the definition.
3908 assert(OldThunkFn->isDeclaration() &&
3909 "Shouldn't replace non-declaration");
3910
3911 // Remove the name from the old thunk function and get a new thunk.
3912 OldThunkFn->setName(llvm::StringRef());
Anders Carlsson13d68982010-03-24 00:35:44 +00003913 Entry = CGM.GetAddrOfThunk(GD, Thunk);
Anders Carlsson7986ad52010-03-23 18:18:41 +00003914
3915 // If needed, replace the old thunk with a bitcast.
3916 if (!OldThunkFn->use_empty()) {
3917 llvm::Constant *NewPtrForOldDecl =
Anders Carlsson13d68982010-03-24 00:35:44 +00003918 llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
Anders Carlsson7986ad52010-03-23 18:18:41 +00003919 OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
3920 }
3921
3922 // Remove the old thunk.
3923 OldThunkFn->eraseFromParent();
3924 }
Anders Carlsson519c3282010-03-24 00:39:18 +00003925
3926 // Actually generate the thunk body.
3927 llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
3928 CodeGenFunction(CGM).GenerateThunk(ThunkFn, GD, Thunk);
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00003929}
3930
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00003931void CodeGenVTables::EmitThunks(GlobalDecl GD)
3932{
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00003933 const CXXMethodDecl *MD =
3934 cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
3935
3936 // We don't need to generate thunks for the base destructor.
3937 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
3938 return;
3939
3940 const CXXRecordDecl *RD = MD->getParent();
3941
Anders Carlssonccd83d72010-03-24 16:42:11 +00003942 // Compute VTable related info for this class.
3943 ComputeVTableRelatedInformation(RD);
3944
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00003945 ThunksMapTy::const_iterator I = Thunks.find(MD);
3946 if (I == Thunks.end()) {
Anders Carlssonccd83d72010-03-24 16:42:11 +00003947 // We did not find a thunk for this method.
3948 return;
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00003949 }
Anders Carlssonccd83d72010-03-24 16:42:11 +00003950
Anders Carlssonfbf6ed42010-03-23 16:36:50 +00003951 const ThunkInfoVectorTy &ThunkInfoVector = I->second;
3952 for (unsigned I = 0, E = ThunkInfoVector.size(); I != E; ++I)
3953 EmitThunk(GD, ThunkInfoVector[I]);
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00003954}
3955
Anders Carlssonccd83d72010-03-24 16:42:11 +00003956void CodeGenVTables::ComputeVTableRelatedInformation(const CXXRecordDecl *RD) {
3957 uint64_t *&LayoutData = VTableLayoutMap[RD];
3958
3959 // Check if we've computed this information before.
3960 if (LayoutData)
3961 return;
3962
3963 VtableBuilder Builder(*this, RD, 0, /*MostDerivedClassIsVirtual=*/0, RD);
3964
3965 // Add the VTable layout.
3966 uint64_t NumVTableComponents = Builder.getNumVTableComponents();
3967 LayoutData = new uint64_t[NumVTableComponents + 1];
3968
3969 // Store the number of components.
3970 LayoutData[0] = NumVTableComponents;
3971
3972 // Store the components.
3973 std::copy(Builder.vtable_components_data_begin(),
3974 Builder.vtable_components_data_end(),
3975 &LayoutData[1]);
3976
3977 // Add the known thunks.
3978 Thunks.insert(Builder.thunks_begin(), Builder.thunks_end());
3979
Anders Carlsson276701f2010-03-29 01:38:05 +00003980 // Add the thunks needed in this vtable.
3981 assert(!VTableThunksMap.count(RD) &&
3982 "Thunks already exists for this vtable!");
3983
3984 VTableThunksTy &VTableThunks = VTableThunksMap[RD];
3985 VTableThunks.append(Builder.vtable_thunks_begin(),
3986 Builder.vtable_thunks_end());
3987
3988 // Sort them.
3989 std::sort(VTableThunks.begin(), VTableThunks.end());
3990
Anders Carlsson66d567d2010-03-25 00:51:13 +00003991 // Add the address points.
3992 for (VtableBuilder::AddressPointsMapTy::const_iterator I =
3993 Builder.address_points_begin(), E = Builder.address_points_end();
3994 I != E; ++I) {
3995
3996 uint64_t &AddressPoint = AddressPoints[std::make_pair(RD, I->first)];
3997
3998 // Check if we already have the address points for this base.
3999 assert(!AddressPoint && "Address point already exists for this base!");
4000
4001 AddressPoint = I->second;
4002 }
4003
Anders Carlssonccd83d72010-03-24 16:42:11 +00004004 // If we don't have the vbase information for this class, insert it.
4005 // getVirtualBaseOffsetOffset will compute it separately without computing
4006 // the rest of the vtable related information.
4007 if (!RD->getNumVBases())
4008 return;
4009
4010 const RecordType *VBaseRT =
4011 RD->vbases_begin()->getType()->getAs<RecordType>();
4012 const CXXRecordDecl *VBase = cast<CXXRecordDecl>(VBaseRT->getDecl());
4013
4014 if (VirtualBaseClassOffsetOffsets.count(std::make_pair(RD, VBase)))
4015 return;
4016
4017 for (VtableBuilder::VBaseOffsetOffsetsMapTy::const_iterator I =
4018 Builder.getVBaseOffsetOffsets().begin(),
4019 E = Builder.getVBaseOffsetOffsets().end(); I != E; ++I) {
4020 // Insert all types.
4021 ClassPairTy ClassPair(RD, I->first);
4022
4023 VirtualBaseClassOffsetOffsets.insert(std::make_pair(ClassPair, I->second));
4024 }
4025}
4026
Anders Carlssonaf440352010-03-23 04:11:45 +00004027void
4028CodeGenVTables::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage,
4029 const CXXRecordDecl *RD) {
Anders Carlssond58987c2009-12-07 07:59:52 +00004030 llvm::GlobalVariable *&Vtable = Vtables[RD];
4031 if (Vtable) {
4032 assert(Vtable->getInitializer() && "Vtable doesn't have a definition!");
4033 return;
4034 }
4035
Anders Carlssonff143f82010-03-25 00:35:49 +00004036 llvm::DenseMap<BaseSubobject, uint64_t> AddressPoints;
Anders Carlsson1bb60992010-01-14 02:29:07 +00004037 Vtable = GenerateVtable(Linkage, /*GenerateDefinition=*/true, RD, RD, 0,
Anders Carlsson5d7af6b2010-02-28 00:36:23 +00004038 /*IsVirtual=*/false,
Anders Carlsson1bb60992010-01-14 02:29:07 +00004039 AddressPoints);
Rafael Espindolabbf58bb2010-03-10 02:19:29 +00004040 GenerateVTT(Linkage, /*GenerateDefinition=*/true, RD);
Mike Stump58588942009-11-19 01:08:19 +00004041}
4042
Anders Carlsson0d1407e2010-03-25 15:26:28 +00004043llvm::Constant *
4044CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
4045 const uint64_t *Components,
4046 unsigned NumComponents,
4047 const VTableThunksTy &VTableThunks) {
4048 llvm::SmallVector<llvm::Constant *, 64> Inits;
4049
4050 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
4051
Anders Carlsson6a5ab5d2010-03-25 16:49:53 +00004052 const llvm::Type *PtrDiffTy =
4053 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
4054
4055 QualType ClassType = CGM.getContext().getTagDeclType(RD);
4056 llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
4057
4058 unsigned NextVTableThunkIndex = 0;
4059
Anders Carlsson0d1407e2010-03-25 15:26:28 +00004060 for (unsigned I = 0; I != NumComponents; ++I) {
Anders Carlsson6a5ab5d2010-03-25 16:49:53 +00004061 VtableComponent Component =
4062 VtableComponent::getFromOpaqueInteger(Components[I]);
4063
4064 llvm::Constant *Init = 0;
4065
4066 switch (Component.getKind()) {
4067 case VtableComponent::CK_VCallOffset:
4068 Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVCallOffset());
4069 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
4070 break;
4071 case VtableComponent::CK_VBaseOffset:
4072 Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVBaseOffset());
4073 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
4074 break;
4075 case VtableComponent::CK_OffsetToTop:
4076 Init = llvm::ConstantInt::get(PtrDiffTy, Component.getOffsetToTop());
4077 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
4078 break;
4079 case VtableComponent::CK_RTTI:
4080 Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
4081 break;
4082 case VtableComponent::CK_FunctionPointer:
4083 case VtableComponent::CK_CompleteDtorPointer:
4084 case VtableComponent::CK_DeletingDtorPointer: {
4085 GlobalDecl GD;
4086
4087 // Get the right global decl.
4088 switch (Component.getKind()) {
4089 default:
4090 llvm_unreachable("Unexpected vtable component kind");
4091 case VtableComponent::CK_FunctionPointer:
4092 GD = Component.getFunctionDecl();
4093 break;
4094 case VtableComponent::CK_CompleteDtorPointer:
4095 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
4096 break;
4097 case VtableComponent::CK_DeletingDtorPointer:
4098 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
4099 break;
4100 }
4101
4102 // Check if we should use a thunk.
4103 if (NextVTableThunkIndex < VTableThunks.size() &&
4104 VTableThunks[NextVTableThunkIndex].first == I) {
4105 const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
4106
4107 Init = CGM.GetAddrOfThunk(GD, Thunk);
Anders Carlssonf6da6a02010-03-29 01:04:16 +00004108
4109 NextVTableThunkIndex++;
Anders Carlsson6a5ab5d2010-03-25 16:49:53 +00004110 } else {
4111 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
4112 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVtable(MD);
4113
4114 Init = CGM.GetAddrOfFunction(GD, Ty);
4115 }
4116
4117 Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
4118 break;
4119 }
4120
4121 case VtableComponent::CK_UnusedFunctionPointer:
4122 Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
4123 break;
4124 };
Anders Carlsson0d1407e2010-03-25 15:26:28 +00004125
4126 Inits.push_back(Init);
4127 }
4128
4129 llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
4130 return llvm::ConstantArray::get(ArrayType, Inits.data(), Inits.size());
4131}
4132
4133/// GetGlobalVariable - Will return a global variable of the given type.
4134/// If a variable with a different type already exists then a new variable
4135/// with the right type will be created.
4136/// FIXME: We should move this to CodeGenModule and rename it to something
4137/// better and then use it in CGVTT and CGRTTI.
4138static llvm::GlobalVariable *
4139GetGlobalVariable(llvm::Module &Module, llvm::StringRef Name,
4140 const llvm::Type *Ty,
4141 llvm::GlobalValue::LinkageTypes Linkage) {
4142
4143 llvm::GlobalVariable *GV = Module.getNamedGlobal(Name);
4144 llvm::GlobalVariable *OldGV = 0;
4145
4146 if (GV) {
4147 // Check if the variable has the right type.
4148 if (GV->getType()->getElementType() == Ty) {
4149 // Set the correct linkage.
4150 GV->setLinkage(Linkage);
4151 return GV;
4152 }
4153
4154 assert(GV->isDeclaration() && "Declaration has wrong type!");
4155
4156 OldGV = GV;
4157 }
4158
4159 // Create a new variable.
4160 GV = new llvm::GlobalVariable(Module, Ty, /*isConstant=*/true,
4161 Linkage, 0, Name);
4162
4163 if (OldGV) {
4164 // Replace occurrences of the old variable if needed.
4165 GV->takeName(OldGV);
4166
4167 if (!OldGV->use_empty()) {
4168 llvm::Constant *NewPtrForOldDecl =
4169 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
4170 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
4171 }
4172
4173 OldGV->eraseFromParent();
4174 }
4175
4176 return GV;
4177}
4178
Anders Carlsson5eea8762010-03-24 05:32:05 +00004179llvm::Constant *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) {
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00004180 llvm::SmallString<256> OutName;
4181 CGM.getMangleContext().mangleCXXVtable(RD, OutName);
4182 llvm::StringRef Name = OutName.str();
Mike Stump85615df2009-11-19 04:04:36 +00004183
Anders Carlssonccd83d72010-03-24 16:42:11 +00004184 ComputeVTableRelatedInformation(RD);
4185
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00004186 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
Anders Carlssonccd83d72010-03-24 16:42:11 +00004187 llvm::ArrayType *ArrayType =
4188 llvm::ArrayType::get(Int8PtrTy, getNumVTableComponents(RD));
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00004189
Anders Carlsson5eea8762010-03-24 05:32:05 +00004190 llvm::GlobalVariable *GV = CGM.getModule().getNamedGlobal(Name);
Anders Carlsson5c6c1d92010-03-24 03:57:14 +00004191 if (GV) {
4192 if (!GV->isDeclaration() || GV->getType()->getElementType() == ArrayType)
4193 return GV;
4194
4195 return llvm::ConstantExpr::getBitCast(GV, ArrayType->getPointerTo());
4196 }
4197
4198 GV = new llvm::GlobalVariable(CGM.getModule(), ArrayType, /*isConstant=*/true,
4199 llvm::GlobalValue::ExternalLinkage, 0, Name);
4200
4201 return GV;
Mike Stump380dd752009-11-10 07:44:33 +00004202}
Mike Stump8cfcb522009-11-11 20:26:26 +00004203
Anders Carlssonff143f82010-03-25 00:35:49 +00004204llvm::GlobalVariable *
4205CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
Anders Carlsson2c822f12010-03-26 03:56:54 +00004206 const BaseSubobject &Base,
4207 bool BaseIsVirtual,
4208 VTableAddressPointsMapTy& AddressPoints) {
Anders Carlsson0d1407e2010-03-25 15:26:28 +00004209 VtableBuilder Builder(*this, Base.getBase(), Base.getBaseOffset(),
4210 /*MostDerivedClassIsVirtual=*/BaseIsVirtual, RD);
4211
Anders Carlsson6a5ab5d2010-03-25 16:49:53 +00004212 // Dump the vtable layout if necessary.
4213 if (CGM.getLangOptions().DumpVtableLayouts)
4214 Builder.dumpLayout(llvm::errs());
4215
4216 // Add the address points.
Anders Carlsson2c822f12010-03-26 03:56:54 +00004217 AddressPoints.insert(Builder.address_points_begin(),
4218 Builder.address_points_end());
Anders Carlsson0d1407e2010-03-25 15:26:28 +00004219
4220 // Get the mangled construction vtable name.
4221 llvm::SmallString<256> OutName;
4222 CGM.getMangleContext().mangleCXXCtorVtable(RD, Base.getBaseOffset() / 8,
4223 Base.getBase(), OutName);
4224 llvm::StringRef Name = OutName.str();
4225
4226 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
4227 llvm::ArrayType *ArrayType =
4228 llvm::ArrayType::get(Int8PtrTy, Builder.getNumVTableComponents());
4229
4230 // Create the variable that will hold the construction vtable.
4231 llvm::GlobalVariable *VTable =
4232 GetGlobalVariable(CGM.getModule(), Name, ArrayType,
4233 llvm::GlobalValue::InternalLinkage);
4234
4235 // Add the thunks.
4236 VTableThunksTy VTableThunks;
4237 VTableThunks.append(Builder.vtable_thunks_begin(),
4238 Builder.vtable_thunks_end());
4239
Anders Carlssonaed924e2010-03-29 01:28:05 +00004240 // Sort them.
4241 std::sort(VTableThunks.begin(), VTableThunks.end());
4242
Anders Carlsson0d1407e2010-03-25 15:26:28 +00004243 // Create and set the initializer.
4244 llvm::Constant *Init =
4245 CreateVTableInitializer(Base.getBase(),
4246 Builder.vtable_components_data_begin(),
4247 Builder.getNumVTableComponents(), VTableThunks);
4248 VTable->setInitializer(Init);
4249
Anders Carlssonff143f82010-03-25 00:35:49 +00004250 return VTable;
4251}
4252
Anders Carlsson13189d02010-03-23 04:15:00 +00004253void CodeGenVTables::EmitVTableRelatedData(GlobalDecl GD) {
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00004254 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
4255 const CXXRecordDecl *RD = MD->getParent();
4256
Anders Carlsson224c3122009-12-05 22:42:54 +00004257 // If the class doesn't have a vtable we don't need to emit one.
4258 if (!RD->isDynamicClass())
4259 return;
4260
Anders Carlsson7270ee42010-03-23 04:31:31 +00004261 // Check if we need to emit thunks for this function.
4262 if (MD->isVirtual())
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00004263 EmitThunks(GD);
Anders Carlsson7270ee42010-03-23 04:31:31 +00004264
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00004265 // Get the key function.
Anders Carlssonf53df232009-12-07 04:35:11 +00004266 const CXXMethodDecl *KeyFunction = CGM.getContext().getKeyFunction(RD);
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00004267
Anders Carlsson224c3122009-12-05 22:42:54 +00004268 if (KeyFunction) {
4269 // We don't have the right key function.
4270 if (KeyFunction->getCanonicalDecl() != MD->getCanonicalDecl())
4271 return;
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00004272 }
4273
Rafael Espindolabbf58bb2010-03-10 02:19:29 +00004274 if (Vtables.count(RD))
4275 return;
Eli Friedman72649ed2009-12-06 22:01:30 +00004276
Rafael Espindolabbf58bb2010-03-10 02:19:29 +00004277 TemplateSpecializationKind kind = RD->getTemplateSpecializationKind();
Rafael Espindolaf075b222010-03-23 19:55:22 +00004278 if (kind == TSK_ImplicitInstantiation)
Rafael Espindolabbf58bb2010-03-10 02:19:29 +00004279 CGM.DeferredVtables.push_back(RD);
4280 else
4281 GenerateClassData(CGM.getVtableLinkage(RD), RD);
Anders Carlsson1a5e0d72009-11-30 23:41:22 +00004282}
Anders Carlssonee5ab9f2010-03-23 04:59:02 +00004283