blob: 0e7a477b4f165bd825495a80597babeb544577b2 [file] [log] [blame]
Anders Carlsson11e51402010-04-17 20:15:18 +00001//===--- CGVTables.cpp - Emit LLVM Code for C++ vtables -------------------===//
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002//
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"
John McCall5d865c322010-08-31 07:33:07 +000016#include "CGCXXABI.h"
Anders Carlssonf942ee02009-11-27 20:47:55 +000017#include "clang/AST/CXXInheritance.h"
Anders Carlsson2bb27f52009-10-11 22:13:54 +000018#include "clang/AST/RecordLayout.h"
John McCall5513fce92010-08-05 20:39:18 +000019#include "clang/Frontend/CodeGenOptions.h"
Anders Carlssond420a312009-11-26 19:32:45 +000020#include "llvm/ADT/DenseSet.h"
Anders Carlssond46ed892010-02-27 16:18:19 +000021#include "llvm/ADT/SetVector.h"
Chandler Carruth94eab4a2010-02-13 10:38:52 +000022#include "llvm/Support/Compiler.h"
Anders Carlsson5d40c6f2010-02-11 08:02:13 +000023#include "llvm/Support/Format.h"
Anders Carlsson56446142010-03-17 20:06:32 +000024#include <algorithm>
Zhongxing Xu1721ef72009-11-13 05:46:16 +000025#include <cstdio>
Anders Carlsson2bb27f52009-10-11 22:13:54 +000026
27using namespace clang;
28using namespace CodeGen;
29
Anders Carlssond59885022009-11-27 22:21:51 +000030namespace {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +000031
Anders Carlsson075056a2010-02-23 01:34:28 +000032/// BaseOffset - Represents an offset from a derived class to a direct or
33/// indirect base class.
34struct BaseOffset {
35 /// DerivedClass - The derived class.
36 const CXXRecordDecl *DerivedClass;
37
38 /// VirtualBase - If the path from the derived class to the base class
39 /// involves a virtual base class, this holds its declaration.
40 const CXXRecordDecl *VirtualBase;
41
42 /// NonVirtualOffset - The offset from the derived class to the base class.
43 /// (Or the offset from the virtual base class to the base class, if the
44 /// path from the derived class to the base class involves a virtual base
45 /// class.
46 int64_t NonVirtualOffset;
47
48 BaseOffset() : DerivedClass(0), VirtualBase(0), NonVirtualOffset(0) { }
49 BaseOffset(const CXXRecordDecl *DerivedClass,
50 const CXXRecordDecl *VirtualBase, int64_t NonVirtualOffset)
51 : DerivedClass(DerivedClass), VirtualBase(VirtualBase),
52 NonVirtualOffset(NonVirtualOffset) { }
53
54 bool isEmpty() const { return !NonVirtualOffset && !VirtualBase; }
55};
56
Anders Carlssone8ac42a2010-02-11 21:24:32 +000057/// FinalOverriders - Contains the final overrider member functions for all
58/// member functions in the base subobjects of a class.
59class FinalOverriders {
Anders Carlsson136bd192010-02-12 16:55:34 +000060public:
61 /// OverriderInfo - Information about a final overrider.
62 struct OverriderInfo {
63 /// Method - The method decl of the overrider.
64 const CXXMethodDecl *Method;
Anders Carlsson5a7654a2010-02-18 16:29:24 +000065
Anders Carlssonca82a4f2010-03-10 02:33:41 +000066 /// Offset - the base offset of the overrider in the layout class.
Ken Dyck785cbdb2011-03-26 01:29:16 +000067 CharUnits Offset;
Anders Carlsson136bd192010-02-12 16:55:34 +000068
Ken Dyck785cbdb2011-03-26 01:29:16 +000069 OverriderInfo() : Method(0), Offset(CharUnits::Zero()) { }
Anders Carlsson136bd192010-02-12 16:55:34 +000070 };
71
72private:
Anders Carlssone8ac42a2010-02-11 21:24:32 +000073 /// MostDerivedClass - The most derived class for which the final overriders
74 /// are stored.
75 const CXXRecordDecl *MostDerivedClass;
76
Anders Carlssonca82a4f2010-03-10 02:33:41 +000077 /// MostDerivedClassOffset - If we're building final overriders for a
78 /// construction vtable, this holds the offset from the layout class to the
79 /// most derived class.
80 const uint64_t MostDerivedClassOffset;
81
82 /// LayoutClass - The class we're using for layout information. Will be
83 /// different than the most derived class if the final overriders are for a
84 /// construction vtable.
85 const CXXRecordDecl *LayoutClass;
86
Anders Carlssone8ac42a2010-02-11 21:24:32 +000087 ASTContext &Context;
88
89 /// MostDerivedClassLayout - the AST record layout of the most derived class.
90 const ASTRecordLayout &MostDerivedClassLayout;
91
Anders Carlsson04e51cc2010-06-01 23:52:26 +000092 /// MethodBaseOffsetPairTy - Uniquely identifies a member function
Anders Carlssoneee53d92010-02-13 02:02:03 +000093 /// in a base subobject.
Ken Dyck808457c2011-03-26 01:18:17 +000094 typedef std::pair<const CXXMethodDecl *, CharUnits> MethodBaseOffsetPairTy;
Anders Carlsson04e51cc2010-06-01 23:52:26 +000095
96 typedef llvm::DenseMap<MethodBaseOffsetPairTy,
Anders Carlsson136bd192010-02-12 16:55:34 +000097 OverriderInfo> OverridersMapTy;
Anders Carlssone8ac42a2010-02-11 21:24:32 +000098
99 /// OverridersMap - The final overriders for all virtual member functions of
100 /// all the base subobjects of the most derived class.
101 OverridersMapTy OverridersMap;
102
Anders Carlsson27860db2010-06-04 00:54:04 +0000103 /// SubobjectsToOffsetsMapTy - A mapping from a base subobject (represented
104 /// as a record decl and a subobject number) and its offsets in the most
105 /// derived class as well as the layout class.
106 typedef llvm::DenseMap<std::pair<const CXXRecordDecl *, unsigned>,
Ken Dyck70b47e02011-03-26 01:09:13 +0000107 CharUnits> SubobjectOffsetMapTy;
Anders Carlsson27860db2010-06-04 00:54:04 +0000108
109 typedef llvm::DenseMap<const CXXRecordDecl *, unsigned> SubobjectCountMapTy;
110
111 /// ComputeBaseOffsets - Compute the offsets for all base subobjects of the
112 /// given base.
113 void ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual,
Ken Dyck58863dc2011-03-26 01:36:26 +0000114 CharUnits OffsetInLayoutClass,
Anders Carlsson27860db2010-06-04 00:54:04 +0000115 SubobjectOffsetMapTy &SubobjectOffsets,
116 SubobjectOffsetMapTy &SubobjectLayoutClassOffsets,
117 SubobjectCountMapTy &SubobjectCounts);
118
Anders Carlssonfd788402010-06-04 00:59:37 +0000119 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
120
121 /// dump - dump the final overriders for a base subobject, and all its direct
122 /// and indirect base subobjects.
123 void dump(llvm::raw_ostream &Out, BaseSubobject Base,
124 VisitedVirtualBasesSetTy& VisitedVirtualBases);
125
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000126public:
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000127 FinalOverriders(const CXXRecordDecl *MostDerivedClass,
128 uint64_t MostDerivedClassOffset,
129 const CXXRecordDecl *LayoutClass);
Anders Carlsson8025e7b2010-02-24 22:18:01 +0000130
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000131 /// getOverrider - Get the final overrider for the given method declaration in
Anders Carlsson79547c32010-06-01 23:17:37 +0000132 /// the subobject with the given base offset.
133 OverriderInfo getOverrider(const CXXMethodDecl *MD,
Ken Dyck808457c2011-03-26 01:18:17 +0000134 CharUnits BaseOffset) const {
Anders Carlsson04e51cc2010-06-01 23:52:26 +0000135 assert(OverridersMap.count(std::make_pair(MD, BaseOffset)) &&
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000136 "Did not find overrider!");
137
Anders Carlsson04e51cc2010-06-01 23:52:26 +0000138 return OverridersMap.lookup(std::make_pair(MD, BaseOffset));
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000139 }
140
141 /// dump - dump the final overriders.
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000142 void dump() {
Anders Carlssonfd788402010-06-04 00:59:37 +0000143 VisitedVirtualBasesSetTy VisitedVirtualBases;
Ken Dyck16ffcac2011-03-24 01:21:01 +0000144 dump(llvm::errs(), BaseSubobject(MostDerivedClass, CharUnits::Zero()),
145 VisitedVirtualBases);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000146 }
147
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000148};
Anders Carlssoneee53d92010-02-13 02:02:03 +0000149
Anders Carlsson603d7d12010-02-27 20:02:53 +0000150#define DUMP_OVERRIDERS 0
151
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000152FinalOverriders::FinalOverriders(const CXXRecordDecl *MostDerivedClass,
153 uint64_t MostDerivedClassOffset,
154 const CXXRecordDecl *LayoutClass)
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000155 : MostDerivedClass(MostDerivedClass),
Anders Carlssonca82a4f2010-03-10 02:33:41 +0000156 MostDerivedClassOffset(MostDerivedClassOffset), LayoutClass(LayoutClass),
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000157 Context(MostDerivedClass->getASTContext()),
158 MostDerivedClassLayout(Context.getASTRecordLayout(MostDerivedClass)) {
Anders Carlssonfd788402010-06-04 00:59:37 +0000159
Anders Carlsson27860db2010-06-04 00:54:04 +0000160 // Compute base offsets.
161 SubobjectOffsetMapTy SubobjectOffsets;
162 SubobjectOffsetMapTy SubobjectLayoutClassOffsets;
163 SubobjectCountMapTy SubobjectCounts;
Ken Dyck16ffcac2011-03-24 01:21:01 +0000164 ComputeBaseOffsets(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
165 /*IsVirtual=*/false,
Ken Dyck58863dc2011-03-26 01:36:26 +0000166 Context.toCharUnitsFromBits(MostDerivedClassOffset),
167 SubobjectOffsets, SubobjectLayoutClassOffsets,
168 SubobjectCounts);
Anders Carlsson27860db2010-06-04 00:54:04 +0000169
170 // Get the the final overriders.
171 CXXFinalOverriderMap FinalOverriders;
172 MostDerivedClass->getFinalOverriders(FinalOverriders);
173
174 for (CXXFinalOverriderMap::const_iterator I = FinalOverriders.begin(),
175 E = FinalOverriders.end(); I != E; ++I) {
176 const CXXMethodDecl *MD = I->first;
177 const OverridingMethods& Methods = I->second;
178
179 for (OverridingMethods::const_iterator I = Methods.begin(),
180 E = Methods.end(); I != E; ++I) {
181 unsigned SubobjectNumber = I->first;
182 assert(SubobjectOffsets.count(std::make_pair(MD->getParent(),
183 SubobjectNumber)) &&
184 "Did not find subobject offset!");
185
Ken Dyck70b47e02011-03-26 01:09:13 +0000186 CharUnits BaseOffset = SubobjectOffsets[std::make_pair(MD->getParent(),
Anders Carlsson27860db2010-06-04 00:54:04 +0000187 SubobjectNumber)];
188
189 assert(I->second.size() == 1 && "Final overrider is not unique!");
190 const UniqueVirtualMethod &Method = I->second.front();
191
192 const CXXRecordDecl *OverriderRD = Method.Method->getParent();
193 assert(SubobjectLayoutClassOffsets.count(
194 std::make_pair(OverriderRD, Method.Subobject))
195 && "Did not find subobject offset!");
Ken Dyck70b47e02011-03-26 01:09:13 +0000196 CharUnits OverriderOffset =
Anders Carlsson27860db2010-06-04 00:54:04 +0000197 SubobjectLayoutClassOffsets[std::make_pair(OverriderRD,
198 Method.Subobject)];
199
Ken Dyck808457c2011-03-26 01:18:17 +0000200 OverriderInfo& Overrider = OverridersMap[std::make_pair(MD, BaseOffset)];
Anders Carlsson27860db2010-06-04 00:54:04 +0000201 assert(!Overrider.Method && "Overrider should not exist yet!");
202
Ken Dyck785cbdb2011-03-26 01:29:16 +0000203 Overrider.Offset = OverriderOffset;
Anders Carlsson27860db2010-06-04 00:54:04 +0000204 Overrider.Method = Method.Method;
205 }
206 }
Anders Carlsson603d7d12010-02-27 20:02:53 +0000207
208#if DUMP_OVERRIDERS
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000209 // And dump them (for now).
210 dump();
Anders Carlsson603d7d12010-02-27 20:02:53 +0000211#endif
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000212}
213
Anders Carlsson075056a2010-02-23 01:34:28 +0000214static BaseOffset ComputeBaseOffset(ASTContext &Context,
215 const CXXRecordDecl *DerivedRD,
216 const CXXBasePath &Path) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000217 int64_t NonVirtualOffset = 0;
Anders Carlssoneee53d92010-02-13 02:02:03 +0000218
Anders Carlssonf3f67842010-02-13 20:41:15 +0000219 unsigned NonVirtualStart = 0;
220 const CXXRecordDecl *VirtualBase = 0;
221
222 // First, look for the virtual base class.
223 for (unsigned I = 0, E = Path.size(); I != E; ++I) {
224 const CXXBasePathElement &Element = Path[I];
225
226 if (Element.Base->isVirtual()) {
227 // FIXME: Can we break when we find the first virtual base?
228 // (If we can't, can't we just iterate over the path in reverse order?)
229 NonVirtualStart = I + 1;
230 QualType VBaseType = Element.Base->getType();
231 VirtualBase =
232 cast<CXXRecordDecl>(VBaseType->getAs<RecordType>()->getDecl());
233 }
234 }
235
236 // Now compute the non-virtual offset.
237 for (unsigned I = NonVirtualStart, E = Path.size(); I != E; ++I) {
238 const CXXBasePathElement &Element = Path[I];
Anders Carlssoneee53d92010-02-13 02:02:03 +0000239
240 // Check the base class offset.
241 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Element.Class);
Anders Carlssoned7d0e82010-02-25 22:18:35 +0000242
Anders Carlssoneee53d92010-02-13 02:02:03 +0000243 const RecordType *BaseType = Element.Base->getType()->getAs<RecordType>();
244 const CXXRecordDecl *Base = cast<CXXRecordDecl>(BaseType->getDecl());
Anders Carlssoned7d0e82010-02-25 22:18:35 +0000245
Anders Carlssonfd88a612010-10-31 23:22:37 +0000246 NonVirtualOffset += Layout.getBaseClassOffsetInBits(Base);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000247 }
248
249 // FIXME: This should probably use CharUnits or something. Maybe we should
250 // even change the base offsets in ASTRecordLayout to be specified in
251 // CharUnits.
Anders Carlsson075056a2010-02-23 01:34:28 +0000252 return BaseOffset(DerivedRD, VirtualBase, NonVirtualOffset / 8);
Anders Carlsson258a1e32010-02-14 00:16:19 +0000253
254}
255
Anders Carlsson075056a2010-02-23 01:34:28 +0000256static BaseOffset ComputeBaseOffset(ASTContext &Context,
257 const CXXRecordDecl *BaseRD,
258 const CXXRecordDecl *DerivedRD) {
Anders Carlsson258a1e32010-02-14 00:16:19 +0000259 CXXBasePaths Paths(/*FindAmbiguities=*/false,
260 /*RecordPaths=*/true, /*DetectVirtual=*/false);
261
262 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
263 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
264 assert(false && "Class must be derived from the passed in base class!");
Anders Carlsson075056a2010-02-23 01:34:28 +0000265 return BaseOffset();
Anders Carlsson258a1e32010-02-14 00:16:19 +0000266 }
267
268 return ComputeBaseOffset(Context, DerivedRD, Paths.front());
Anders Carlssoneee53d92010-02-13 02:02:03 +0000269}
270
Anders Carlsson075056a2010-02-23 01:34:28 +0000271static BaseOffset
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000272ComputeReturnAdjustmentBaseOffset(ASTContext &Context,
273 const CXXMethodDecl *DerivedMD,
274 const CXXMethodDecl *BaseMD) {
Anders Carlssoneee53d92010-02-13 02:02:03 +0000275 const FunctionType *BaseFT = BaseMD->getType()->getAs<FunctionType>();
276 const FunctionType *DerivedFT = DerivedMD->getType()->getAs<FunctionType>();
277
278 // Canonicalize the return types.
279 CanQualType CanDerivedReturnType =
280 Context.getCanonicalType(DerivedFT->getResultType());
281 CanQualType CanBaseReturnType =
282 Context.getCanonicalType(BaseFT->getResultType());
283
284 assert(CanDerivedReturnType->getTypeClass() ==
285 CanBaseReturnType->getTypeClass() &&
286 "Types must have same type class!");
287
288 if (CanDerivedReturnType == CanBaseReturnType) {
289 // No adjustment needed.
Anders Carlsson075056a2010-02-23 01:34:28 +0000290 return BaseOffset();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000291 }
292
293 if (isa<ReferenceType>(CanDerivedReturnType)) {
294 CanDerivedReturnType =
295 CanDerivedReturnType->getAs<ReferenceType>()->getPointeeType();
296 CanBaseReturnType =
297 CanBaseReturnType->getAs<ReferenceType>()->getPointeeType();
298 } else if (isa<PointerType>(CanDerivedReturnType)) {
299 CanDerivedReturnType =
300 CanDerivedReturnType->getAs<PointerType>()->getPointeeType();
301 CanBaseReturnType =
302 CanBaseReturnType->getAs<PointerType>()->getPointeeType();
303 } else {
304 assert(false && "Unexpected return type!");
305 }
306
307 // We need to compare unqualified types here; consider
308 // const T *Base::foo();
309 // T *Derived::foo();
310 if (CanDerivedReturnType.getUnqualifiedType() ==
311 CanBaseReturnType.getUnqualifiedType()) {
312 // No adjustment needed.
Anders Carlsson075056a2010-02-23 01:34:28 +0000313 return BaseOffset();
Anders Carlssoneee53d92010-02-13 02:02:03 +0000314 }
315
316 const CXXRecordDecl *DerivedRD =
317 cast<CXXRecordDecl>(cast<RecordType>(CanDerivedReturnType)->getDecl());
318
319 const CXXRecordDecl *BaseRD =
320 cast<CXXRecordDecl>(cast<RecordType>(CanBaseReturnType)->getDecl());
321
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000322 return ComputeBaseOffset(Context, BaseRD, DerivedRD);
Anders Carlssoneee53d92010-02-13 02:02:03 +0000323}
324
Anders Carlsson27860db2010-06-04 00:54:04 +0000325void
326FinalOverriders::ComputeBaseOffsets(BaseSubobject Base, bool IsVirtual,
Ken Dyck58863dc2011-03-26 01:36:26 +0000327 CharUnits OffsetInLayoutClass,
Anders Carlsson27860db2010-06-04 00:54:04 +0000328 SubobjectOffsetMapTy &SubobjectOffsets,
329 SubobjectOffsetMapTy &SubobjectLayoutClassOffsets,
330 SubobjectCountMapTy &SubobjectCounts) {
331 const CXXRecordDecl *RD = Base.getBase();
332
333 unsigned SubobjectNumber = 0;
334 if (!IsVirtual)
335 SubobjectNumber = ++SubobjectCounts[RD];
336
337 // Set up the subobject to offset mapping.
338 assert(!SubobjectOffsets.count(std::make_pair(RD, SubobjectNumber))
339 && "Subobject offset already exists!");
340 assert(!SubobjectLayoutClassOffsets.count(std::make_pair(RD, SubobjectNumber))
341 && "Subobject offset already exists!");
342
Ken Dyck70b47e02011-03-26 01:09:13 +0000343 SubobjectOffsets[std::make_pair(RD, SubobjectNumber)] = Base.getBaseOffset();
Anders Carlsson27860db2010-06-04 00:54:04 +0000344 SubobjectLayoutClassOffsets[std::make_pair(RD, SubobjectNumber)] =
Ken Dyck58863dc2011-03-26 01:36:26 +0000345 OffsetInLayoutClass;
Anders Carlsson27860db2010-06-04 00:54:04 +0000346
347 // Traverse our bases.
348 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
349 E = RD->bases_end(); I != E; ++I) {
350 const CXXRecordDecl *BaseDecl =
351 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
352
Ken Dyckce812032011-03-26 00:51:24 +0000353 CharUnits BaseOffset;
354 CharUnits BaseOffsetInLayoutClass;
Anders Carlsson27860db2010-06-04 00:54:04 +0000355 if (I->isVirtual()) {
356 // Check if we've visited this virtual base before.
357 if (SubobjectOffsets.count(std::make_pair(BaseDecl, 0)))
358 continue;
359
360 const ASTRecordLayout &LayoutClassLayout =
361 Context.getASTRecordLayout(LayoutClass);
362
Ken Dyckce812032011-03-26 00:51:24 +0000363 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlsson27860db2010-06-04 00:54:04 +0000364 BaseOffsetInLayoutClass =
Ken Dyckce812032011-03-26 00:51:24 +0000365 LayoutClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlsson27860db2010-06-04 00:54:04 +0000366 } else {
367 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
Ken Dyckce812032011-03-26 00:51:24 +0000368 CharUnits Offset = Layout.getBaseClassOffset(BaseDecl);
Anders Carlsson27860db2010-06-04 00:54:04 +0000369
Ken Dyckce812032011-03-26 00:51:24 +0000370 BaseOffset = Base.getBaseOffset() + Offset;
Ken Dyck58863dc2011-03-26 01:36:26 +0000371 BaseOffsetInLayoutClass = OffsetInLayoutClass + Offset;
Anders Carlsson27860db2010-06-04 00:54:04 +0000372 }
373
Ken Dyckce812032011-03-26 00:51:24 +0000374 ComputeBaseOffsets(BaseSubobject(BaseDecl, BaseOffset),
Ken Dyck58863dc2011-03-26 01:36:26 +0000375 I->isVirtual(), BaseOffsetInLayoutClass,
Ken Dyck16ffcac2011-03-24 01:21:01 +0000376 SubobjectOffsets, SubobjectLayoutClassOffsets,
377 SubobjectCounts);
Anders Carlsson27860db2010-06-04 00:54:04 +0000378 }
379}
380
Anders Carlssonfd788402010-06-04 00:59:37 +0000381void FinalOverriders::dump(llvm::raw_ostream &Out, BaseSubobject Base,
382 VisitedVirtualBasesSetTy &VisitedVirtualBases) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000383 const CXXRecordDecl *RD = Base.getBase();
384 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
385
386 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
387 E = RD->bases_end(); I != E; ++I) {
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000388 const CXXRecordDecl *BaseDecl =
389 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
390
Anders Carlsson033d4862010-02-14 17:05:59 +0000391 // Ignore bases that don't have any virtual member functions.
392 if (!BaseDecl->isPolymorphic())
393 continue;
394
Ken Dyck16ffcac2011-03-24 01:21:01 +0000395 CharUnits BaseOffset;
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000396 if (I->isVirtual()) {
397 if (!VisitedVirtualBases.insert(BaseDecl)) {
398 // We've visited this base before.
399 continue;
400 }
401
Ken Dyck16ffcac2011-03-24 01:21:01 +0000402 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000403 } else {
Ken Dyck16ffcac2011-03-24 01:21:01 +0000404 BaseOffset = Layout.getBaseClassOffset(BaseDecl) + Base.getBaseOffset();
Anders Carlsson6a7e6a42010-02-14 00:37:35 +0000405 }
406
Anders Carlssonfd788402010-06-04 00:59:37 +0000407 dump(Out, BaseSubobject(BaseDecl, BaseOffset), VisitedVirtualBases);
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000408 }
409
410 Out << "Final overriders for (" << RD->getQualifiedNameAsString() << ", ";
Ken Dyck16ffcac2011-03-24 01:21:01 +0000411 Out << Base.getBaseOffset().getQuantity() << ")\n";
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000412
413 // Now dump the overriders for this base subobject.
414 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
415 E = RD->method_end(); I != E; ++I) {
416 const CXXMethodDecl *MD = *I;
417
418 if (!MD->isVirtual())
419 continue;
420
Ken Dyck808457c2011-03-26 01:18:17 +0000421 OverriderInfo Overrider = getOverrider(MD, Base.getBaseOffset());
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000422
Anders Carlsson6f1f0022010-03-02 03:44:06 +0000423 Out << " " << MD->getQualifiedNameAsString() << " - (";
Anders Carlsson8e661e12010-02-12 17:13:23 +0000424 Out << Overrider.Method->getQualifiedNameAsString();
Ken Dyck785cbdb2011-03-26 01:29:16 +0000425 Out << ", " << ", " << Overrider.Offset.getQuantity() << ')';
Anders Carlsson6f1f0022010-03-02 03:44:06 +0000426
Anders Carlsson042ce2d82010-06-01 23:47:05 +0000427 BaseOffset Offset;
428 if (!Overrider.Method->isPure())
429 Offset = ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method, MD);
Anders Carlssonf3f67842010-02-13 20:41:15 +0000430
Anders Carlsson042ce2d82010-06-01 23:47:05 +0000431 if (!Offset.isEmpty()) {
Anders Carlssonf3f67842010-02-13 20:41:15 +0000432 Out << " [ret-adj: ";
433 if (Offset.VirtualBase)
434 Out << Offset.VirtualBase->getQualifiedNameAsString() << " vbase, ";
Anders Carlssoneee53d92010-02-13 02:02:03 +0000435
Anders Carlssonf3f67842010-02-13 20:41:15 +0000436 Out << Offset.NonVirtualOffset << " nv]";
Anders Carlssoneee53d92010-02-13 02:02:03 +0000437 }
Anders Carlssoncce9ee82010-02-13 23:17:31 +0000438
Anders Carlsson8e661e12010-02-12 17:13:23 +0000439 Out << "\n";
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000440 }
441}
442
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000443/// VTableComponent - Represents a single component in a vtable.
444class VTableComponent {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000445public:
446 enum Kind {
447 CK_VCallOffset,
448 CK_VBaseOffset,
449 CK_OffsetToTop,
450 CK_RTTI,
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000451 CK_FunctionPointer,
452
453 /// CK_CompleteDtorPointer - A pointer to the complete destructor.
454 CK_CompleteDtorPointer,
455
456 /// CK_DeletingDtorPointer - A pointer to the deleting destructor.
Anders Carlsson350b56e2010-02-19 20:08:13 +0000457 CK_DeletingDtorPointer,
458
459 /// CK_UnusedFunctionPointer - In some cases, a vtable function pointer
460 /// will end up never being called. Such vtable function pointers are
461 /// represented as a CK_UnusedFunctionPointer.
462 CK_UnusedFunctionPointer
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000463 };
464
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000465 static VTableComponent MakeVCallOffset(int64_t Offset) {
466 return VTableComponent(CK_VCallOffset, Offset);
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000467 }
468
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000469 static VTableComponent MakeVBaseOffset(int64_t Offset) {
470 return VTableComponent(CK_VBaseOffset, Offset);
Anders Carlssondc2dba32010-02-16 04:49:44 +0000471 }
472
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000473 static VTableComponent MakeOffsetToTop(int64_t Offset) {
474 return VTableComponent(CK_OffsetToTop, Offset);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000475 }
476
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000477 static VTableComponent MakeRTTI(const CXXRecordDecl *RD) {
478 return VTableComponent(CK_RTTI, reinterpret_cast<uintptr_t>(RD));
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000479 }
480
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000481 static VTableComponent MakeFunction(const CXXMethodDecl *MD) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000482 assert(!isa<CXXDestructorDecl>(MD) &&
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000483 "Don't use MakeFunction with destructors!");
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000484
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000485 return VTableComponent(CK_FunctionPointer,
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000486 reinterpret_cast<uintptr_t>(MD));
487 }
488
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000489 static VTableComponent MakeCompleteDtor(const CXXDestructorDecl *DD) {
490 return VTableComponent(CK_CompleteDtorPointer,
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000491 reinterpret_cast<uintptr_t>(DD));
492 }
493
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000494 static VTableComponent MakeDeletingDtor(const CXXDestructorDecl *DD) {
495 return VTableComponent(CK_DeletingDtorPointer,
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000496 reinterpret_cast<uintptr_t>(DD));
497 }
498
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000499 static VTableComponent MakeUnusedFunction(const CXXMethodDecl *MD) {
Anders Carlsson350b56e2010-02-19 20:08:13 +0000500 assert(!isa<CXXDestructorDecl>(MD) &&
501 "Don't use MakeUnusedFunction with destructors!");
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000502 return VTableComponent(CK_UnusedFunctionPointer,
Anders Carlsson350b56e2010-02-19 20:08:13 +0000503 reinterpret_cast<uintptr_t>(MD));
504 }
505
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000506 static VTableComponent getFromOpaqueInteger(uint64_t I) {
507 return VTableComponent(I);
Anders Carlssona5736bd2010-03-25 16:49:53 +0000508 }
509
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000510 /// getKind - Get the kind of this vtable component.
511 Kind getKind() const {
512 return (Kind)(Value & 0x7);
513 }
514
Anders Carlssonb0a588f2010-02-17 06:07:19 +0000515 int64_t getVCallOffset() const {
516 assert(getKind() == CK_VCallOffset && "Invalid component kind!");
517
518 return getOffset();
519 }
520
Anders Carlssondc2dba32010-02-16 04:49:44 +0000521 int64_t getVBaseOffset() const {
522 assert(getKind() == CK_VBaseOffset && "Invalid component kind!");
523
524 return getOffset();
525 }
526
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000527 int64_t getOffsetToTop() const {
528 assert(getKind() == CK_OffsetToTop && "Invalid component kind!");
529
530 return getOffset();
531 }
532
533 const CXXRecordDecl *getRTTIDecl() const {
534 assert(getKind() == CK_RTTI && "Invalid component kind!");
535
536 return reinterpret_cast<CXXRecordDecl *>(getPointer());
537 }
538
539 const CXXMethodDecl *getFunctionDecl() const {
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000540 assert(getKind() == CK_FunctionPointer);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000541
542 return reinterpret_cast<CXXMethodDecl *>(getPointer());
543 }
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000544
545 const CXXDestructorDecl *getDestructorDecl() const {
546 assert((getKind() == CK_CompleteDtorPointer ||
547 getKind() == CK_DeletingDtorPointer) && "Invalid component kind!");
548
549 return reinterpret_cast<CXXDestructorDecl *>(getPointer());
550 }
551
Anders Carlsson350b56e2010-02-19 20:08:13 +0000552 const CXXMethodDecl *getUnusedFunctionDecl() const {
553 assert(getKind() == CK_UnusedFunctionPointer);
554
555 return reinterpret_cast<CXXMethodDecl *>(getPointer());
556 }
557
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000558private:
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000559 VTableComponent(Kind ComponentKind, int64_t Offset) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000560 assert((ComponentKind == CK_VCallOffset ||
561 ComponentKind == CK_VBaseOffset ||
562 ComponentKind == CK_OffsetToTop) && "Invalid component kind!");
563 assert(Offset <= ((1LL << 56) - 1) && "Offset is too big!");
564
565 Value = ((Offset << 3) | ComponentKind);
566 }
567
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000568 VTableComponent(Kind ComponentKind, uintptr_t Ptr) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000569 assert((ComponentKind == CK_RTTI ||
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000570 ComponentKind == CK_FunctionPointer ||
571 ComponentKind == CK_CompleteDtorPointer ||
Anders Carlsson350b56e2010-02-19 20:08:13 +0000572 ComponentKind == CK_DeletingDtorPointer ||
573 ComponentKind == CK_UnusedFunctionPointer) &&
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000574 "Invalid component kind!");
575
576 assert((Ptr & 7) == 0 && "Pointer not sufficiently aligned!");
577
578 Value = Ptr | ComponentKind;
579 }
580
581 int64_t getOffset() const {
582 assert((getKind() == CK_VCallOffset || getKind() == CK_VBaseOffset ||
583 getKind() == CK_OffsetToTop) && "Invalid component kind!");
584
585 return Value >> 3;
586 }
587
588 uintptr_t getPointer() const {
Anders Carlsson5bd8d192010-02-11 18:20:28 +0000589 assert((getKind() == CK_RTTI ||
590 getKind() == CK_FunctionPointer ||
591 getKind() == CK_CompleteDtorPointer ||
Anders Carlsson350b56e2010-02-19 20:08:13 +0000592 getKind() == CK_DeletingDtorPointer ||
593 getKind() == CK_UnusedFunctionPointer) &&
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000594 "Invalid component kind!");
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000595
596 return static_cast<uintptr_t>(Value & ~7ULL);
597 }
598
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000599 explicit VTableComponent(uint64_t Value)
Anders Carlssona5736bd2010-03-25 16:49:53 +0000600 : Value(Value) { }
601
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000602 /// The kind is stored in the lower 3 bits of the value. For offsets, we
603 /// make use of the facts that classes can't be larger than 2^55 bytes,
604 /// so we store the offset in the lower part of the 61 bytes that remain.
605 /// (The reason that we're not simply using a PointerIntPair here is that we
606 /// need the offsets to be 64-bit, even when on a 32-bit machine).
607 int64_t Value;
608};
609
Anders Carlsson78277c72010-02-18 17:00:09 +0000610/// VCallOffsetMap - Keeps track of vcall offsets when building a vtable.
611struct VCallOffsetMap {
612
613 typedef std::pair<const CXXMethodDecl *, int64_t> MethodAndOffsetPairTy;
614
615 /// Offsets - Keeps track of methods and their offsets.
616 // FIXME: This should be a real map and not a vector.
617 llvm::SmallVector<MethodAndOffsetPairTy, 16> Offsets;
618
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000619 /// MethodsCanShareVCallOffset - Returns whether two virtual member functions
620 /// can share the same vcall offset.
621 static bool MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
622 const CXXMethodDecl *RHS);
623
Anders Carlsson78277c72010-02-18 17:00:09 +0000624public:
625 /// AddVCallOffset - Adds a vcall offset to the map. Returns true if the
626 /// add was successful, or false if there was already a member function with
627 /// the same signature in the map.
628 bool AddVCallOffset(const CXXMethodDecl *MD, int64_t OffsetOffset);
629
630 /// getVCallOffsetOffset - Returns the vcall offset offset (relative to the
631 /// vtable address point) for the given virtual member function.
632 int64_t getVCallOffsetOffset(const CXXMethodDecl *MD);
633
Anders Carlsson9e3b3a32010-02-25 22:23:13 +0000634 // empty - Return whether the offset map is empty or not.
635 bool empty() const { return Offsets.empty(); }
Anders Carlsson78277c72010-02-18 17:00:09 +0000636};
637
John McCall43c6ffb2010-02-26 20:22:44 +0000638static bool HasSameVirtualSignature(const CXXMethodDecl *LHS,
639 const CXXMethodDecl *RHS) {
640 ASTContext &C = LHS->getASTContext(); // TODO: thread this down
641 CanQual<FunctionProtoType>
642 LT = C.getCanonicalType(LHS->getType()).getAs<FunctionProtoType>(),
643 RT = C.getCanonicalType(RHS->getType()).getAs<FunctionProtoType>();
644
645 // Fast-path matches in the canonical types.
646 if (LT == RT) return true;
647
648 // Force the signatures to match. We can't rely on the overrides
649 // list here because there isn't necessarily an inheritance
650 // relationship between the two methods.
651 if (LT.getQualifiers() != RT.getQualifiers() ||
652 LT->getNumArgs() != RT->getNumArgs())
653 return false;
654 for (unsigned I = 0, E = LT->getNumArgs(); I != E; ++I)
655 if (LT->getArgType(I) != RT->getArgType(I))
656 return false;
657 return true;
658}
659
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000660bool VCallOffsetMap::MethodsCanShareVCallOffset(const CXXMethodDecl *LHS,
661 const CXXMethodDecl *RHS) {
662 assert(LHS->isVirtual() && "LHS must be virtual!");
663 assert(RHS->isVirtual() && "LHS must be virtual!");
664
Anders Carlssond69b2f92010-02-27 04:12:52 +0000665 // A destructor can share a vcall offset with another destructor.
666 if (isa<CXXDestructorDecl>(LHS))
667 return isa<CXXDestructorDecl>(RHS);
668
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000669 // FIXME: We need to check more things here.
670
Anders Carlssond69b2f92010-02-27 04:12:52 +0000671 // The methods must have the same name.
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000672 DeclarationName LHSName = LHS->getDeclName();
673 DeclarationName RHSName = RHS->getDeclName();
John McCall43c6ffb2010-02-26 20:22:44 +0000674 if (LHSName != RHSName)
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000675 return false;
John McCall43c6ffb2010-02-26 20:22:44 +0000676
Anders Carlssond69b2f92010-02-27 04:12:52 +0000677 // And the same signatures.
678 return HasSameVirtualSignature(LHS, RHS);
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000679}
680
Anders Carlsson78277c72010-02-18 17:00:09 +0000681bool VCallOffsetMap::AddVCallOffset(const CXXMethodDecl *MD,
682 int64_t OffsetOffset) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000683 // Check if we can reuse an offset.
684 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
685 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
686 return false;
687 }
688
689 // Add the offset.
690 Offsets.push_back(MethodAndOffsetPairTy(MD, OffsetOffset));
Anders Carlsson78277c72010-02-18 17:00:09 +0000691 return true;
692}
693
694int64_t VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
Anders Carlsson8847d9e2010-02-18 17:26:40 +0000695 // Look for an offset.
696 for (unsigned I = 0, E = Offsets.size(); I != E; ++I) {
697 if (MethodsCanShareVCallOffset(Offsets[I].first, MD))
698 return Offsets[I].second;
699 }
700
701 assert(false && "Should always find a vcall offset offset!");
Anders Carlsson78277c72010-02-18 17:00:09 +0000702 return 0;
703}
704
Anders Carlsson422f7782010-02-25 03:45:56 +0000705/// VCallAndVBaseOffsetBuilder - Class for building vcall and vbase offsets.
706class VCallAndVBaseOffsetBuilder {
Anders Carlssondd819c92010-03-11 16:06:20 +0000707public:
708 typedef llvm::DenseMap<const CXXRecordDecl *, int64_t>
709 VBaseOffsetOffsetsMapTy;
710
711private:
Anders Carlssone3385f52010-02-28 01:43:58 +0000712 /// MostDerivedClass - The most derived class for which we're building vcall
713 /// and vbase offsets.
Anders Carlsson422f7782010-02-25 03:45:56 +0000714 const CXXRecordDecl *MostDerivedClass;
715
Anders Carlssonc3f92a12010-02-27 21:09:00 +0000716 /// LayoutClass - The class we're using for layout information. Will be
717 /// different than the most derived class if we're building a construction
718 /// vtable.
719 const CXXRecordDecl *LayoutClass;
720
Anders Carlsson422f7782010-02-25 03:45:56 +0000721 /// Context - The ASTContext which we will use for layout information.
722 ASTContext &Context;
723
724 /// Components - vcall and vbase offset components
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000725 typedef llvm::SmallVector<VTableComponent, 64> VTableComponentVectorTy;
726 VTableComponentVectorTy Components;
Anders Carlsson422f7782010-02-25 03:45:56 +0000727
728 /// VisitedVirtualBases - Visited virtual bases.
729 llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBases;
730
731 /// VCallOffsets - Keeps track of vcall offsets.
732 VCallOffsetMap VCallOffsets;
733
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000734
735 /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets,
736 /// relative to the address point.
737 VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
738
Anders Carlsson422f7782010-02-25 03:45:56 +0000739 /// FinalOverriders - The final overriders of the most derived class.
740 /// (Can be null when we're not building a vtable of the most derived class).
741 const FinalOverriders *Overriders;
742
743 /// AddVCallAndVBaseOffsets - Add vcall offsets and vbase offsets for the
744 /// given base subobject.
745 void AddVCallAndVBaseOffsets(BaseSubobject Base, bool BaseIsVirtual,
746 uint64_t RealBaseOffset);
747
748 /// AddVCallOffsets - Add vcall offsets for the given base subobject.
749 void AddVCallOffsets(BaseSubobject Base, uint64_t VBaseOffset);
750
751 /// AddVBaseOffsets - Add vbase offsets for the given class.
Anders Carlsson93b1b492010-03-02 05:40:45 +0000752 void AddVBaseOffsets(const CXXRecordDecl *Base, uint64_t OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +0000753
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000754 /// getCurrentOffsetOffset - Get the current vcall or vbase offset offset in
755 /// bytes, relative to the vtable address point.
756 int64_t getCurrentOffsetOffset() const;
757
Anders Carlsson422f7782010-02-25 03:45:56 +0000758public:
759 VCallAndVBaseOffsetBuilder(const CXXRecordDecl *MostDerivedClass,
Anders Carlssonc3f92a12010-02-27 21:09:00 +0000760 const CXXRecordDecl *LayoutClass,
Anders Carlsson422f7782010-02-25 03:45:56 +0000761 const FinalOverriders *Overriders,
Anders Carlssone3385f52010-02-28 01:43:58 +0000762 BaseSubobject Base, bool BaseIsVirtual,
763 uint64_t OffsetInLayoutClass)
764 : MostDerivedClass(MostDerivedClass), LayoutClass(LayoutClass),
Anders Carlsson422f7782010-02-25 03:45:56 +0000765 Context(MostDerivedClass->getASTContext()), Overriders(Overriders) {
766
767 // Add vcall and vbase offsets.
Anders Carlssone3385f52010-02-28 01:43:58 +0000768 AddVCallAndVBaseOffsets(Base, BaseIsVirtual, OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +0000769 }
770
771 /// Methods for iterating over the components.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000772 typedef VTableComponentVectorTy::const_reverse_iterator const_iterator;
Anders Carlsson422f7782010-02-25 03:45:56 +0000773 const_iterator components_begin() const { return Components.rbegin(); }
774 const_iterator components_end() const { return Components.rend(); }
775
Anders Carlssondd819c92010-03-11 16:06:20 +0000776 const VCallOffsetMap &getVCallOffsets() const { return VCallOffsets; }
777 const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000778 return VBaseOffsetOffsets;
779 }
Anders Carlsson422f7782010-02-25 03:45:56 +0000780};
781
782void
783VCallAndVBaseOffsetBuilder::AddVCallAndVBaseOffsets(BaseSubobject Base,
784 bool BaseIsVirtual,
785 uint64_t RealBaseOffset) {
786 const ASTRecordLayout &Layout = Context.getASTRecordLayout(Base.getBase());
787
788 // Itanium C++ ABI 2.5.2:
789 // ..in classes sharing a virtual table with a primary base class, the vcall
790 // and vbase offsets added by the derived class all come before the vcall
791 // and vbase offsets required by the base class, so that the latter may be
792 // laid out as required by the base class without regard to additions from
793 // the derived class(es).
794
795 // (Since we're emitting the vcall and vbase offsets in reverse order, we'll
796 // emit them for the primary base first).
797 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson7f95cd12010-11-24 23:12:57 +0000798 bool PrimaryBaseIsVirtual = Layout.isPrimaryBaseVirtual();
Anders Carlsson422f7782010-02-25 03:45:56 +0000799
Ken Dyckce812032011-03-26 00:51:24 +0000800 CharUnits PrimaryBaseOffset;
Anders Carlsson422f7782010-02-25 03:45:56 +0000801
802 // Get the base offset of the primary base.
803 if (PrimaryBaseIsVirtual) {
Anders Carlssonfd88a612010-10-31 23:22:37 +0000804 assert(Layout.getVBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson422f7782010-02-25 03:45:56 +0000805 "Primary vbase should have a zero offset!");
806
807 const ASTRecordLayout &MostDerivedClassLayout =
808 Context.getASTRecordLayout(MostDerivedClass);
809
810 PrimaryBaseOffset =
Ken Dyckce812032011-03-26 00:51:24 +0000811 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
Anders Carlsson422f7782010-02-25 03:45:56 +0000812 } else {
Anders Carlssonfd88a612010-10-31 23:22:37 +0000813 assert(Layout.getBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson422f7782010-02-25 03:45:56 +0000814 "Primary base should have a zero offset!");
815
Ken Dyckce812032011-03-26 00:51:24 +0000816 PrimaryBaseOffset = Base.getBaseOffset();
Anders Carlsson422f7782010-02-25 03:45:56 +0000817 }
818
Ken Dyck16ffcac2011-03-24 01:21:01 +0000819 AddVCallAndVBaseOffsets(
Ken Dyckce812032011-03-26 00:51:24 +0000820 BaseSubobject(PrimaryBase,PrimaryBaseOffset),
Ken Dyck16ffcac2011-03-24 01:21:01 +0000821 PrimaryBaseIsVirtual, RealBaseOffset);
Anders Carlsson422f7782010-02-25 03:45:56 +0000822 }
823
Anders Carlsson93b1b492010-03-02 05:40:45 +0000824 AddVBaseOffsets(Base.getBase(), RealBaseOffset);
Anders Carlsson422f7782010-02-25 03:45:56 +0000825
826 // We only want to add vcall offsets for virtual bases.
827 if (BaseIsVirtual)
828 AddVCallOffsets(Base, RealBaseOffset);
829}
830
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000831int64_t VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const {
832 // OffsetIndex is the index of this vcall or vbase offset, relative to the
833 // vtable address point. (We subtract 3 to account for the information just
834 // above the address point, the RTTI info, the offset to top, and the
835 // vcall offset itself).
836 int64_t OffsetIndex = -(int64_t)(3 + Components.size());
837
838 // FIXME: We shouldn't use / 8 here.
839 int64_t OffsetOffset = OffsetIndex *
840 (int64_t)Context.Target.getPointerWidth(0) / 8;
841
842 return OffsetOffset;
843}
844
Anders Carlsson422f7782010-02-25 03:45:56 +0000845void VCallAndVBaseOffsetBuilder::AddVCallOffsets(BaseSubobject Base,
846 uint64_t VBaseOffset) {
847 const CXXRecordDecl *RD = Base.getBase();
848 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
849
John McCall43c6ffb2010-02-26 20:22:44 +0000850 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
851
Anders Carlsson422f7782010-02-25 03:45:56 +0000852 // Handle the primary base first.
Anders Carlsson343a26b2010-04-11 20:04:11 +0000853 // We only want to add vcall offsets if the base is non-virtual; a virtual
854 // primary base will have its vcall and vbase offsets emitted already.
Anders Carlsson7f95cd12010-11-24 23:12:57 +0000855 if (PrimaryBase && !Layout.isPrimaryBaseVirtual()) {
Anders Carlsson422f7782010-02-25 03:45:56 +0000856 // Get the base offset of the primary base.
Anders Carlssonfd88a612010-10-31 23:22:37 +0000857 assert(Layout.getBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson343a26b2010-04-11 20:04:11 +0000858 "Primary base should have a zero offset!");
Anders Carlsson422f7782010-02-25 03:45:56 +0000859
Anders Carlsson343a26b2010-04-11 20:04:11 +0000860 AddVCallOffsets(BaseSubobject(PrimaryBase, Base.getBaseOffset()),
Anders Carlsson422f7782010-02-25 03:45:56 +0000861 VBaseOffset);
862 }
Anders Carlsson343a26b2010-04-11 20:04:11 +0000863
Anders Carlsson422f7782010-02-25 03:45:56 +0000864 // Add the vcall offsets.
865 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
866 E = RD->method_end(); I != E; ++I) {
867 const CXXMethodDecl *MD = *I;
868
869 if (!MD->isVirtual())
870 continue;
871
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000872 int64_t OffsetOffset = getCurrentOffsetOffset();
Anders Carlsson422f7782010-02-25 03:45:56 +0000873
874 // Don't add a vcall offset if we already have one for this member function
875 // signature.
876 if (!VCallOffsets.AddVCallOffset(MD, OffsetOffset))
877 continue;
878
879 int64_t Offset = 0;
880
881 if (Overriders) {
882 // Get the final overrider.
883 FinalOverriders::OverriderInfo Overrider =
Ken Dyck808457c2011-03-26 01:18:17 +0000884 Overriders->getOverrider(MD, Base.getBaseOffset());
Anders Carlsson422f7782010-02-25 03:45:56 +0000885
Anders Carlsson31f595f2010-02-28 00:10:58 +0000886 /// The vcall offset is the offset from the virtual base to the object
887 /// where the function was overridden.
Anders Carlsson422f7782010-02-25 03:45:56 +0000888 // FIXME: We should not use / 8 here.
Ken Dyck785cbdb2011-03-26 01:29:16 +0000889 Offset = (int64_t)(Context.toBits(Overrider.Offset) - VBaseOffset) / 8;
Anders Carlsson422f7782010-02-25 03:45:56 +0000890 }
891
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000892 Components.push_back(VTableComponent::MakeVCallOffset(Offset));
Anders Carlsson422f7782010-02-25 03:45:56 +0000893 }
894
895 // And iterate over all non-virtual bases (ignoring the primary base).
896 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
897 E = RD->bases_end(); I != E; ++I) {
898
899 if (I->isVirtual())
900 continue;
901
902 const CXXRecordDecl *BaseDecl =
903 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
John McCall43c6ffb2010-02-26 20:22:44 +0000904 if (BaseDecl == PrimaryBase)
905 continue;
Anders Carlsson422f7782010-02-25 03:45:56 +0000906
907 // Get the base offset of this base.
Ken Dyckce812032011-03-26 00:51:24 +0000908 CharUnits BaseOffset = Base.getBaseOffset() +
909 Layout.getBaseClassOffset(BaseDecl);
Anders Carlsson422f7782010-02-25 03:45:56 +0000910
Ken Dyckce812032011-03-26 00:51:24 +0000911 AddVCallOffsets(BaseSubobject(BaseDecl, BaseOffset),
912 VBaseOffset);
Anders Carlsson422f7782010-02-25 03:45:56 +0000913 }
914}
915
Anders Carlsson422f7782010-02-25 03:45:56 +0000916void VCallAndVBaseOffsetBuilder::AddVBaseOffsets(const CXXRecordDecl *RD,
Anders Carlsson93b1b492010-03-02 05:40:45 +0000917 uint64_t OffsetInLayoutClass) {
Anders Carlssonc3f92a12010-02-27 21:09:00 +0000918 const ASTRecordLayout &LayoutClassLayout =
919 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +0000920
921 // Add vbase offsets.
922 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
923 E = RD->bases_end(); I != E; ++I) {
924 const CXXRecordDecl *BaseDecl =
925 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
926
927 // Check if this is a virtual base that we haven't visited before.
928 if (I->isVirtual() && VisitedVirtualBases.insert(BaseDecl)) {
929 // FIXME: We shouldn't use / 8 here.
Anders Carlsson93b1b492010-03-02 05:40:45 +0000930 int64_t Offset =
Anders Carlssonfd88a612010-10-31 23:22:37 +0000931 (int64_t)(LayoutClassLayout.getVBaseClassOffsetInBits(BaseDecl) -
Anders Carlsson93b1b492010-03-02 05:40:45 +0000932 OffsetInLayoutClass) / 8;
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000933
934 // Add the vbase offset offset.
935 assert(!VBaseOffsetOffsets.count(BaseDecl) &&
936 "vbase offset offset already exists!");
937
938 int64_t VBaseOffsetOffset = getCurrentOffsetOffset();
939 VBaseOffsetOffsets.insert(std::make_pair(BaseDecl, VBaseOffsetOffset));
940
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000941 Components.push_back(VTableComponent::MakeVBaseOffset(Offset));
Anders Carlsson422f7782010-02-25 03:45:56 +0000942 }
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000943
Anders Carlsson422f7782010-02-25 03:45:56 +0000944 // Check the base class looking for more vbase offsets.
Anders Carlsson93b1b492010-03-02 05:40:45 +0000945 AddVBaseOffsets(BaseDecl, OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +0000946 }
947}
948
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000949/// VTableBuilder - Class for building vtable layout information.
950class VTableBuilder {
Anders Carlsson65b49782010-02-12 05:25:12 +0000951public:
Anders Carlssond46ed892010-02-27 16:18:19 +0000952 /// PrimaryBasesSetVectorTy - A set vector of direct and indirect
953 /// primary bases.
954 typedef llvm::SmallSetVector<const CXXRecordDecl *, 8>
955 PrimaryBasesSetVectorTy;
956
Anders Carlssone90954d2010-03-24 16:42:11 +0000957 typedef llvm::DenseMap<const CXXRecordDecl *, int64_t>
958 VBaseOffsetOffsetsMapTy;
Anders Carlssond03325c2010-03-25 00:51:13 +0000959
960 typedef llvm::DenseMap<BaseSubobject, uint64_t>
961 AddressPointsMapTy;
Anders Carlssone90954d2010-03-24 16:42:11 +0000962
Anders Carlsson65b49782010-02-12 05:25:12 +0000963private:
Anders Carlssona864caf2010-03-23 04:11:45 +0000964 /// VTables - Global vtable information.
965 CodeGenVTables &VTables;
Anders Carlssoncf5a8822010-02-13 21:07:32 +0000966
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000967 /// MostDerivedClass - The most derived class for which we're building this
968 /// vtable.
969 const CXXRecordDecl *MostDerivedClass;
970
Anders Carlsson93913752010-02-27 20:39:05 +0000971 /// MostDerivedClassOffset - If we're building a construction vtable, this
972 /// holds the offset from the layout class to the most derived class.
973 const uint64_t MostDerivedClassOffset;
974
Anders Carlsson62c6c722010-02-28 00:36:23 +0000975 /// MostDerivedClassIsVirtual - Whether the most derived class is a virtual
976 /// base. (This only makes sense when building a construction vtable).
977 bool MostDerivedClassIsVirtual;
978
Anders Carlsson93913752010-02-27 20:39:05 +0000979 /// LayoutClass - The class we're using for layout information. Will be
980 /// different than the most derived class if we're building a construction
981 /// vtable.
982 const CXXRecordDecl *LayoutClass;
983
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000984 /// Context - The ASTContext which we will use for layout information.
Anders Carlsson65b49782010-02-12 05:25:12 +0000985 ASTContext &Context;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000986
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000987 /// FinalOverriders - The final overriders of the most derived class.
Anders Carlsson422f7782010-02-25 03:45:56 +0000988 const FinalOverriders Overriders;
Anders Carlssone8ac42a2010-02-11 21:24:32 +0000989
Anders Carlsson9e3b3a32010-02-25 22:23:13 +0000990 /// VCallOffsetsForVBases - Keeps track of vcall offsets for the virtual
991 /// bases in this vtable.
992 llvm::DenseMap<const CXXRecordDecl *, VCallOffsetMap> VCallOffsetsForVBases;
Anders Carlsson78277c72010-02-18 17:00:09 +0000993
Anders Carlsson7f6b71e2010-03-11 06:43:12 +0000994 /// VBaseOffsetOffsets - Contains the offsets of the virtual base offsets for
995 /// the most derived class.
996 VBaseOffsetOffsetsMapTy VBaseOffsetOffsets;
997
Anders Carlsson5d40c6f2010-02-11 08:02:13 +0000998 /// Components - The components of the vtable being built.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +0000999 llvm::SmallVector<VTableComponent, 64> Components;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001000
Anders Carlsson932c2f22010-02-11 17:18:51 +00001001 /// AddressPoints - Address points for the vtable being built.
Anders Carlsson0534b022010-03-25 00:35:49 +00001002 AddressPointsMapTy AddressPoints;
Anders Carlsson932c2f22010-02-11 17:18:51 +00001003
Anders Carlssond46ed892010-02-27 16:18:19 +00001004 /// MethodInfo - Contains information about a method in a vtable.
1005 /// (Used for computing 'this' pointer adjustment thunks.
1006 struct MethodInfo {
1007 /// BaseOffset - The base offset of this method.
Ken Dyck7d876f32011-03-27 18:57:53 +00001008 const CharUnits BaseOffset;
Anders Carlssond46ed892010-02-27 16:18:19 +00001009
Anders Carlsson423406f32010-03-10 21:25:37 +00001010 /// BaseOffsetInLayoutClass - The base offset in the layout class of this
1011 /// method.
Ken Dyck7d876f32011-03-27 18:57:53 +00001012 const CharUnits BaseOffsetInLayoutClass;
Anders Carlsson423406f32010-03-10 21:25:37 +00001013
Anders Carlssond78b2242010-04-11 22:07:06 +00001014 /// VTableIndex - The index in the vtable that this method has.
Anders Carlssond46ed892010-02-27 16:18:19 +00001015 /// (For destructors, this is the index of the complete destructor).
Anders Carlssond78b2242010-04-11 22:07:06 +00001016 const uint64_t VTableIndex;
Anders Carlssond46ed892010-02-27 16:18:19 +00001017
Ken Dyck7d876f32011-03-27 18:57:53 +00001018 MethodInfo(CharUnits BaseOffset, CharUnits BaseOffsetInLayoutClass,
Anders Carlssond78b2242010-04-11 22:07:06 +00001019 uint64_t VTableIndex)
Anders Carlsson423406f32010-03-10 21:25:37 +00001020 : BaseOffset(BaseOffset),
1021 BaseOffsetInLayoutClass(BaseOffsetInLayoutClass),
Anders Carlssond78b2242010-04-11 22:07:06 +00001022 VTableIndex(VTableIndex) { }
Anders Carlsson40687982010-02-27 16:52:49 +00001023
Ken Dyck7d876f32011-03-27 18:57:53 +00001024 MethodInfo()
1025 : BaseOffset(CharUnits::Zero()),
1026 BaseOffsetInLayoutClass(CharUnits::Zero()),
1027 VTableIndex(0) { }
Anders Carlssond46ed892010-02-27 16:18:19 +00001028 };
1029
1030 typedef llvm::DenseMap<const CXXMethodDecl *, MethodInfo> MethodInfoMapTy;
1031
1032 /// MethodInfoMap - The information for all methods in the vtable we're
1033 /// currently building.
1034 MethodInfoMapTy MethodInfoMap;
1035
Anders Carlssond78b2242010-04-11 22:07:06 +00001036 typedef llvm::DenseMap<uint64_t, ThunkInfo> VTableThunksMapTy;
Anders Carlsson8a240292010-03-12 04:54:20 +00001037
Anders Carlsson7cea12f2010-03-23 04:44:10 +00001038 /// VTableThunks - The thunks by vtable index in the vtable currently being
1039 /// built.
Anders Carlssond78b2242010-04-11 22:07:06 +00001040 VTableThunksMapTy VTableThunks;
Anders Carlssond46ed892010-02-27 16:18:19 +00001041
Anders Carlsson917229c2010-03-23 04:59:02 +00001042 typedef llvm::SmallVector<ThunkInfo, 1> ThunkInfoVectorTy;
1043 typedef llvm::DenseMap<const CXXMethodDecl *, ThunkInfoVectorTy> ThunksMapTy;
Anders Carlsson56446142010-03-17 20:06:32 +00001044
Anders Carlsson7cea12f2010-03-23 04:44:10 +00001045 /// Thunks - A map that contains all the thunks needed for all methods in the
1046 /// most derived class for which the vtable is currently being built.
Anders Carlsson917229c2010-03-23 04:59:02 +00001047 ThunksMapTy Thunks;
Anders Carlsson56446142010-03-17 20:06:32 +00001048
1049 /// AddThunk - Add a thunk for the given method.
Anders Carlsson4b2411e2010-03-21 20:27:14 +00001050 void AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk);
Anders Carlsson56446142010-03-17 20:06:32 +00001051
Anders Carlsson40687982010-02-27 16:52:49 +00001052 /// ComputeThisAdjustments - Compute the 'this' pointer adjustments for the
1053 /// part of the vtable we're currently building.
1054 void ComputeThisAdjustments();
1055
Anders Carlssondc2dba32010-02-16 04:49:44 +00001056 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy;
1057
Anders Carlssond46ed892010-02-27 16:18:19 +00001058 /// PrimaryVirtualBases - All known virtual bases who are a primary base of
Anders Carlsson0570f712010-02-23 03:48:14 +00001059 /// some other base.
1060 VisitedVirtualBasesSetTy PrimaryVirtualBases;
1061
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001062 /// ComputeReturnAdjustment - Compute the return adjustment given a return
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001063 /// adjustment base offset.
Anders Carlsson075056a2010-02-23 01:34:28 +00001064 ReturnAdjustment ComputeReturnAdjustment(BaseOffset Offset);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001065
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001066 /// ComputeThisAdjustmentBaseOffset - Compute the base offset for adjusting
1067 /// the 'this' pointer from the base subobject to the derived subobject.
1068 BaseOffset ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
1069 BaseSubobject Derived) const;
1070
Anders Carlsson78277c72010-02-18 17:00:09 +00001071 /// ComputeThisAdjustment - Compute the 'this' pointer adjustment for the
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001072 /// given virtual member function, its offset in the layout class and its
1073 /// final overrider.
1074 ThisAdjustment
1075 ComputeThisAdjustment(const CXXMethodDecl *MD,
1076 uint64_t BaseOffsetInLayoutClass,
1077 FinalOverriders::OverriderInfo Overrider);
1078
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001079 /// AddMethod - Add a single virtual member function to the vtable
1080 /// components vector.
Anders Carlsson40687982010-02-27 16:52:49 +00001081 void AddMethod(const CXXMethodDecl *MD, ReturnAdjustment ReturnAdjustment);
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001082
Anders Carlssona8796c62010-02-23 04:26:39 +00001083 /// IsOverriderUsed - Returns whether the overrider will ever be used in this
1084 /// part of the vtable.
1085 ///
1086 /// Itanium C++ ABI 2.5.2:
1087 ///
1088 /// struct A { virtual void f(); };
1089 /// struct B : virtual public A { int i; };
1090 /// struct C : virtual public A { int j; };
1091 /// struct D : public B, public C {};
1092 ///
1093 /// When B and C are declared, A is a primary base in each case, so although
1094 /// vcall offsets are allocated in the A-in-B and A-in-C vtables, no this
1095 /// adjustment is required and no thunk is generated. However, inside D
1096 /// objects, A is no longer a primary base of C, so if we allowed calls to
1097 /// C::f() to use the copy of A's vtable in the C subobject, we would need
1098 /// to adjust this from C* to B::A*, which would require a third-party
1099 /// thunk. Since we require that a call to C::f() first convert to A*,
1100 /// C-in-D's copy of A's vtable is never referenced, so this is not
1101 /// necessary.
Anders Carlsson804cf512010-03-10 06:51:42 +00001102 bool IsOverriderUsed(const CXXMethodDecl *Overrider,
1103 uint64_t BaseOffsetInLayoutClass,
1104 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1105 uint64_t FirstBaseOffsetInLayoutClass) const;
1106
Anders Carlssona8796c62010-02-23 04:26:39 +00001107
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001108 /// AddMethods - Add the methods of this base subobject and all its
1109 /// primary bases to the vtable components vector.
Anders Carlsson804cf512010-03-10 06:51:42 +00001110 void AddMethods(BaseSubobject Base, uint64_t BaseOffsetInLayoutClass,
1111 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1112 uint64_t FirstBaseOffsetInLayoutClass,
Anders Carlssond46ed892010-02-27 16:18:19 +00001113 PrimaryBasesSetVectorTy &PrimaryBases);
Anders Carlssonb716a542010-02-16 16:26:28 +00001114
Anders Carlssond78b2242010-04-11 22:07:06 +00001115 // LayoutVTable - Layout the vtable for the given base class, including its
Anders Carlssonb716a542010-02-16 16:26:28 +00001116 // secondary vtables and any vtables for virtual bases.
Anders Carlssond78b2242010-04-11 22:07:06 +00001117 void LayoutVTable();
Anders Carlssonb716a542010-02-16 16:26:28 +00001118
Anders Carlssond78b2242010-04-11 22:07:06 +00001119 /// LayoutPrimaryAndSecondaryVTables - Layout the primary vtable for the
Anders Carlssonb716a542010-02-16 16:26:28 +00001120 /// given base subobject, as well as all its secondary vtables.
Anders Carlssonb41c6332010-04-11 22:03:57 +00001121 ///
Anders Carlsson3383e2a2010-04-11 22:20:36 +00001122 /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
1123 /// or a direct or indirect base of a virtual base.
1124 ///
Anders Carlssonb41c6332010-04-11 22:03:57 +00001125 /// \param BaseIsVirtualInLayoutClass - Whether the base subobject is virtual
1126 /// in the layout class.
Anders Carlssond78b2242010-04-11 22:07:06 +00001127 void LayoutPrimaryAndSecondaryVTables(BaseSubobject Base,
Anders Carlsson3383e2a2010-04-11 22:20:36 +00001128 bool BaseIsMorallyVirtual,
Anders Carlssonb41c6332010-04-11 22:03:57 +00001129 bool BaseIsVirtualInLayoutClass,
Anders Carlssone3385f52010-02-28 01:43:58 +00001130 uint64_t OffsetInLayoutClass);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001131
Anders Carlssond78b2242010-04-11 22:07:06 +00001132 /// LayoutSecondaryVTables - Layout the secondary vtables for the given base
Anders Carlsson14157932010-02-16 16:02:57 +00001133 /// subobject.
Anders Carlsson115b4752010-03-10 19:39:11 +00001134 ///
1135 /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base
1136 /// or a direct or indirect base of a virtual base.
Anders Carlssond78b2242010-04-11 22:07:06 +00001137 void LayoutSecondaryVTables(BaseSubobject Base, bool BaseIsMorallyVirtual,
Anders Carlsson115b4752010-03-10 19:39:11 +00001138 uint64_t OffsetInLayoutClass);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001139
1140 /// DeterminePrimaryVirtualBases - Determine the primary virtual bases in this
1141 /// class hierarchy.
1142 void DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
Anders Carlsson02b99d62010-03-10 03:02:01 +00001143 uint64_t OffsetInLayoutClass,
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001144 VisitedVirtualBasesSetTy &VBases);
1145
Anders Carlssond78b2242010-04-11 22:07:06 +00001146 /// LayoutVTablesForVirtualBases - Layout vtables for all virtual bases of the
Anders Carlsson13f0f662010-02-16 16:49:35 +00001147 /// given base (excluding any primary bases).
Anders Carlssond78b2242010-04-11 22:07:06 +00001148 void LayoutVTablesForVirtualBases(const CXXRecordDecl *RD,
Anders Carlsson13f0f662010-02-16 16:49:35 +00001149 VisitedVirtualBasesSetTy &VBases);
1150
Anders Carlssond78b2242010-04-11 22:07:06 +00001151 /// isBuildingConstructionVTable - Return whether this vtable builder is
Anders Carlsson31f595f2010-02-28 00:10:58 +00001152 /// building a construction vtable.
Anders Carlssond78b2242010-04-11 22:07:06 +00001153 bool isBuildingConstructorVTable() const {
Anders Carlsson31f595f2010-02-28 00:10:58 +00001154 return MostDerivedClass != LayoutClass;
1155 }
1156
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001157public:
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001158 VTableBuilder(CodeGenVTables &VTables, const CXXRecordDecl *MostDerivedClass,
Anders Carlsson62c6c722010-02-28 00:36:23 +00001159 uint64_t MostDerivedClassOffset, bool MostDerivedClassIsVirtual,
Anders Carlsson93913752010-02-27 20:39:05 +00001160 const CXXRecordDecl *LayoutClass)
Anders Carlssona864caf2010-03-23 04:11:45 +00001161 : VTables(VTables), MostDerivedClass(MostDerivedClass),
Anders Carlsson62c6c722010-02-28 00:36:23 +00001162 MostDerivedClassOffset(MostDerivedClassOffset),
1163 MostDerivedClassIsVirtual(MostDerivedClassIsVirtual),
1164 LayoutClass(LayoutClass), Context(MostDerivedClass->getASTContext()),
Anders Carlssonca82a4f2010-03-10 02:33:41 +00001165 Overriders(MostDerivedClass, MostDerivedClassOffset, LayoutClass) {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001166
Anders Carlssond78b2242010-04-11 22:07:06 +00001167 LayoutVTable();
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001168 }
1169
Anders Carlsson5c5abad2010-03-23 16:36:50 +00001170 ThunksMapTy::const_iterator thunks_begin() const {
1171 return Thunks.begin();
1172 }
1173
1174 ThunksMapTy::const_iterator thunks_end() const {
1175 return Thunks.end();
1176 }
1177
Anders Carlssone90954d2010-03-24 16:42:11 +00001178 const VBaseOffsetOffsetsMapTy &getVBaseOffsetOffsets() const {
1179 return VBaseOffsetOffsets;
1180 }
1181
1182 /// getNumVTableComponents - Return the number of components in the vtable
1183 /// currently built.
1184 uint64_t getNumVTableComponents() const {
1185 return Components.size();
1186 }
1187
Anders Carlssond03325c2010-03-25 00:51:13 +00001188 const uint64_t *vtable_components_data_begin() const {
Anders Carlssone90954d2010-03-24 16:42:11 +00001189 return reinterpret_cast<const uint64_t *>(Components.begin());
1190 }
1191
Anders Carlssond03325c2010-03-25 00:51:13 +00001192 const uint64_t *vtable_components_data_end() const {
Anders Carlssone90954d2010-03-24 16:42:11 +00001193 return reinterpret_cast<const uint64_t *>(Components.end());
1194 }
1195
Anders Carlssond03325c2010-03-25 00:51:13 +00001196 AddressPointsMapTy::const_iterator address_points_begin() const {
1197 return AddressPoints.begin();
1198 }
1199
1200 AddressPointsMapTy::const_iterator address_points_end() const {
1201 return AddressPoints.end();
1202 }
1203
Anders Carlssond78b2242010-04-11 22:07:06 +00001204 VTableThunksMapTy::const_iterator vtable_thunks_begin() const {
Anders Carlssona4147142010-03-25 15:26:28 +00001205 return VTableThunks.begin();
1206 }
1207
Anders Carlssond78b2242010-04-11 22:07:06 +00001208 VTableThunksMapTy::const_iterator vtable_thunks_end() const {
Anders Carlssona4147142010-03-25 15:26:28 +00001209 return VTableThunks.end();
1210 }
1211
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001212 /// dumpLayout - Dump the vtable layout.
1213 void dumpLayout(llvm::raw_ostream&);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001214};
1215
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001216void VTableBuilder::AddThunk(const CXXMethodDecl *MD, const ThunkInfo &Thunk) {
Anders Carlssond78b2242010-04-11 22:07:06 +00001217 assert(!isBuildingConstructorVTable() &&
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001218 "Can't add thunks for construction vtable");
Anders Carlsson18c582d2010-03-18 02:44:19 +00001219
Anders Carlsson7cea12f2010-03-23 04:44:10 +00001220 llvm::SmallVector<ThunkInfo, 1> &ThunksVector = Thunks[MD];
Anders Carlsson56446142010-03-17 20:06:32 +00001221
1222 // Check if we have this thunk already.
1223 if (std::find(ThunksVector.begin(), ThunksVector.end(), Thunk) !=
1224 ThunksVector.end())
1225 return;
1226
1227 ThunksVector.push_back(Thunk);
1228}
1229
Anders Carlsson88cf34f2010-04-10 20:39:29 +00001230typedef llvm::SmallPtrSet<const CXXMethodDecl *, 8> OverriddenMethodsSetTy;
1231
1232/// ComputeAllOverriddenMethods - Given a method decl, will return a set of all
1233/// the overridden methods that the function decl overrides.
1234static void
1235ComputeAllOverriddenMethods(const CXXMethodDecl *MD,
1236 OverriddenMethodsSetTy& OverriddenMethods) {
1237 assert(MD->isVirtual() && "Method is not virtual!");
1238
Anders Carlsson65b49782010-02-12 05:25:12 +00001239 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1240 E = MD->end_overridden_methods(); I != E; ++I) {
1241 const CXXMethodDecl *OverriddenMD = *I;
Anders Carlsson65b49782010-02-12 05:25:12 +00001242
Anders Carlsson88cf34f2010-04-10 20:39:29 +00001243 OverriddenMethods.insert(OverriddenMD);
1244
1245 ComputeAllOverriddenMethods(OverriddenMD, OverriddenMethods);
Anders Carlsson65b49782010-02-12 05:25:12 +00001246 }
Anders Carlsson65b49782010-02-12 05:25:12 +00001247}
1248
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001249void VTableBuilder::ComputeThisAdjustments() {
Anders Carlsson40687982010-02-27 16:52:49 +00001250 // Now go through the method info map and see if any of the methods need
1251 // 'this' pointer adjustments.
1252 for (MethodInfoMapTy::const_iterator I = MethodInfoMap.begin(),
1253 E = MethodInfoMap.end(); I != E; ++I) {
1254 const CXXMethodDecl *MD = I->first;
1255 const MethodInfo &MethodInfo = I->second;
1256
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001257 // Ignore adjustments for unused function pointers.
Anders Carlssond78b2242010-04-11 22:07:06 +00001258 uint64_t VTableIndex = MethodInfo.VTableIndex;
1259 if (Components[VTableIndex].getKind() ==
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001260 VTableComponent::CK_UnusedFunctionPointer)
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001261 continue;
1262
Anders Carlsson40687982010-02-27 16:52:49 +00001263 // Get the final overrider for this method.
1264 FinalOverriders::OverriderInfo Overrider =
Ken Dyck7d876f32011-03-27 18:57:53 +00001265 Overriders.getOverrider(MD, MethodInfo.BaseOffset);
Anders Carlsson40687982010-02-27 16:52:49 +00001266
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001267 // Check if we need an adjustment at all.
Ken Dyck7d876f32011-03-27 18:57:53 +00001268 if (MethodInfo.BaseOffsetInLayoutClass == Overrider.Offset) {
Anders Carlssoneba1a602010-03-29 15:08:41 +00001269 // When a return thunk is needed by a derived class that overrides a
1270 // virtual base, gcc uses a virtual 'this' adjustment as well.
1271 // While the thunk itself might be needed by vtables in subclasses or
1272 // in construction vtables, there doesn't seem to be a reason for using
1273 // the thunk in this vtable. Still, we do so to match gcc.
Anders Carlssond78b2242010-04-11 22:07:06 +00001274 if (VTableThunks.lookup(VTableIndex).Return.isEmpty())
Anders Carlssoneba1a602010-03-29 15:08:41 +00001275 continue;
1276 }
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001277
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001278 ThisAdjustment ThisAdjustment =
Ken Dyck7d876f32011-03-27 18:57:53 +00001279 ComputeThisAdjustment(MD,
1280 Context.toBits(MethodInfo.BaseOffsetInLayoutClass), Overrider);
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001281
1282 if (ThisAdjustment.isEmpty())
Anders Carlsson40687982010-02-27 16:52:49 +00001283 continue;
Anders Carlsson40687982010-02-27 16:52:49 +00001284
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001285 // Add it.
Anders Carlssond78b2242010-04-11 22:07:06 +00001286 VTableThunks[VTableIndex].This = ThisAdjustment;
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001287
Anders Carlsson40687982010-02-27 16:52:49 +00001288 if (isa<CXXDestructorDecl>(MD)) {
1289 // Add an adjustment for the deleting destructor as well.
Anders Carlssond78b2242010-04-11 22:07:06 +00001290 VTableThunks[VTableIndex + 1].This = ThisAdjustment;
Anders Carlsson40687982010-02-27 16:52:49 +00001291 }
1292 }
1293
1294 /// Clear the method info map.
1295 MethodInfoMap.clear();
Anders Carlsson64decd32010-03-22 15:47:01 +00001296
Anders Carlssond78b2242010-04-11 22:07:06 +00001297 if (isBuildingConstructorVTable()) {
Anders Carlsson64decd32010-03-22 15:47:01 +00001298 // We don't need to store thunk information for construction vtables.
1299 return;
1300 }
1301
Anders Carlssond78b2242010-04-11 22:07:06 +00001302 for (VTableThunksMapTy::const_iterator I = VTableThunks.begin(),
Anders Carlsson7cea12f2010-03-23 04:44:10 +00001303 E = VTableThunks.end(); I != E; ++I) {
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001304 const VTableComponent &Component = Components[I->first];
Anders Carlsson64decd32010-03-22 15:47:01 +00001305 const ThunkInfo &Thunk = I->second;
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001306 const CXXMethodDecl *MD;
Anders Carlsson64decd32010-03-22 15:47:01 +00001307
1308 switch (Component.getKind()) {
1309 default:
1310 llvm_unreachable("Unexpected vtable component kind!");
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001311 case VTableComponent::CK_FunctionPointer:
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001312 MD = Component.getFunctionDecl();
Anders Carlsson64decd32010-03-22 15:47:01 +00001313 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001314 case VTableComponent::CK_CompleteDtorPointer:
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001315 MD = Component.getDestructorDecl();
Anders Carlsson64decd32010-03-22 15:47:01 +00001316 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001317 case VTableComponent::CK_DeletingDtorPointer:
Anders Carlsson64decd32010-03-22 15:47:01 +00001318 // We've already added the thunk when we saw the complete dtor pointer.
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001319 continue;
Anders Carlsson64decd32010-03-22 15:47:01 +00001320 }
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001321
1322 if (MD->getParent() == MostDerivedClass)
1323 AddThunk(MD, Thunk);
Anders Carlsson64decd32010-03-22 15:47:01 +00001324 }
Anders Carlsson40687982010-02-27 16:52:49 +00001325}
1326
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001327ReturnAdjustment VTableBuilder::ComputeReturnAdjustment(BaseOffset Offset) {
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001328 ReturnAdjustment Adjustment;
1329
1330 if (!Offset.isEmpty()) {
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001331 if (Offset.VirtualBase) {
1332 // Get the virtual base offset offset.
Anders Carlssone4424882010-03-11 07:00:45 +00001333 if (Offset.DerivedClass == MostDerivedClass) {
1334 // We can get the offset offset directly from our map.
1335 Adjustment.VBaseOffsetOffset =
1336 VBaseOffsetOffsets.lookup(Offset.VirtualBase);
1337 } else {
1338 Adjustment.VBaseOffsetOffset =
Anders Carlssona864caf2010-03-23 04:11:45 +00001339 VTables.getVirtualBaseOffsetOffset(Offset.DerivedClass,
1340 Offset.VirtualBase);
Anders Carlssone4424882010-03-11 07:00:45 +00001341 }
Anders Carlssoncf5a8822010-02-13 21:07:32 +00001342 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001343
1344 Adjustment.NonVirtual = Offset.NonVirtualOffset;
1345 }
1346
1347 return Adjustment;
1348}
1349
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001350BaseOffset
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001351VTableBuilder::ComputeThisAdjustmentBaseOffset(BaseSubobject Base,
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001352 BaseSubobject Derived) const {
1353 const CXXRecordDecl *BaseRD = Base.getBase();
1354 const CXXRecordDecl *DerivedRD = Derived.getBase();
1355
1356 CXXBasePaths Paths(/*FindAmbiguities=*/true,
1357 /*RecordPaths=*/true, /*DetectVirtual=*/true);
1358
1359 if (!const_cast<CXXRecordDecl *>(DerivedRD)->
1360 isDerivedFrom(const_cast<CXXRecordDecl *>(BaseRD), Paths)) {
1361 assert(false && "Class must be derived from the passed in base class!");
1362 return BaseOffset();
1363 }
1364
1365 // We have to go through all the paths, and see which one leads us to the
1366 // right base subobject.
1367 for (CXXBasePaths::const_paths_iterator I = Paths.begin(), E = Paths.end();
1368 I != E; ++I) {
1369 BaseOffset Offset = ComputeBaseOffset(Context, DerivedRD, *I);
1370
Ken Dyckce812032011-03-26 00:51:24 +00001371 CharUnits OffsetToBaseSubobject =
1372 CharUnits::fromQuantity(Offset.NonVirtualOffset);
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001373
1374 if (Offset.VirtualBase) {
1375 // If we have a virtual base class, the non-virtual offset is relative
1376 // to the virtual base class offset.
Anders Carlsson423406f32010-03-10 21:25:37 +00001377 const ASTRecordLayout &LayoutClassLayout =
1378 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001379
1380 /// Get the virtual base offset, relative to the most derived class
1381 /// layout.
1382 OffsetToBaseSubobject +=
Ken Dyckce812032011-03-26 00:51:24 +00001383 LayoutClassLayout.getVBaseClassOffset(Offset.VirtualBase);
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001384 } else {
1385 // Otherwise, the non-virtual offset is relative to the derived class
1386 // offset.
Ken Dyckce812032011-03-26 00:51:24 +00001387 OffsetToBaseSubobject += Derived.getBaseOffset();
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001388 }
1389
1390 // Check if this path gives us the right base subobject.
Ken Dyckce812032011-03-26 00:51:24 +00001391 if (OffsetToBaseSubobject == Base.getBaseOffset()) {
Anders Carlsson9f19aaaa2010-02-27 19:57:44 +00001392 // Since we're going from the base class _to_ the derived class, we'll
1393 // invert the non-virtual offset here.
1394 Offset.NonVirtualOffset = -Offset.NonVirtualOffset;
1395 return Offset;
1396 }
1397 }
1398
1399 return BaseOffset();
1400}
1401
Anders Carlsson67fd3a50d2010-03-23 15:13:06 +00001402ThisAdjustment
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001403VTableBuilder::ComputeThisAdjustment(const CXXMethodDecl *MD,
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001404 uint64_t BaseOffsetInLayoutClass,
1405 FinalOverriders::OverriderInfo Overrider) {
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001406 // Ignore adjustments for pure virtual member functions.
1407 if (Overrider.Method->isPure())
1408 return ThisAdjustment();
1409
1410 BaseSubobject OverriddenBaseSubobject(MD->getParent(),
Ken Dyck16ffcac2011-03-24 01:21:01 +00001411 Context.toCharUnitsFromBits(
1412 BaseOffsetInLayoutClass));
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001413
1414 BaseSubobject OverriderBaseSubobject(Overrider.Method->getParent(),
Ken Dyck785cbdb2011-03-26 01:29:16 +00001415 Overrider.Offset);
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001416
1417 // Compute the adjustment offset.
1418 BaseOffset Offset = ComputeThisAdjustmentBaseOffset(OverriddenBaseSubobject,
1419 OverriderBaseSubobject);
1420 if (Offset.isEmpty())
1421 return ThisAdjustment();
1422
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001423 ThisAdjustment Adjustment;
1424
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001425 if (Offset.VirtualBase) {
1426 // Get the vcall offset map for this virtual base.
1427 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Offset.VirtualBase];
Anders Carlsson8847d9e2010-02-18 17:26:40 +00001428
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001429 if (VCallOffsets.empty()) {
1430 // We don't have vcall offsets for this virtual base, go ahead and
1431 // build them.
1432 VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, MostDerivedClass,
1433 /*FinalOverriders=*/0,
Ken Dyck16ffcac2011-03-24 01:21:01 +00001434 BaseSubobject(Offset.VirtualBase,
1435 CharUnits::Zero()),
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001436 /*BaseIsVirtual=*/true,
1437 /*OffsetInLayoutClass=*/0);
1438
1439 VCallOffsets = Builder.getVCallOffsets();
1440 }
1441
1442 Adjustment.VCallOffsetOffset = VCallOffsets.getVCallOffsetOffset(MD);
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001443 }
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001444
1445 // Set the non-virtual part of the adjustment.
1446 Adjustment.NonVirtual = Offset.NonVirtualOffset;
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001447
1448 return Adjustment;
1449}
Anders Carlsson5d3b9012010-03-12 05:28:07 +00001450
Anders Carlsson65b49782010-02-12 05:25:12 +00001451void
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001452VTableBuilder::AddMethod(const CXXMethodDecl *MD,
Anders Carlsson40687982010-02-27 16:52:49 +00001453 ReturnAdjustment ReturnAdjustment) {
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001454 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
1455 assert(ReturnAdjustment.isEmpty() &&
1456 "Destructor can't have return adjustment!");
Anders Carlssond3adb0c2010-02-13 23:40:17 +00001457
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001458 // Add both the complete destructor and the deleting destructor.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001459 Components.push_back(VTableComponent::MakeCompleteDtor(DD));
1460 Components.push_back(VTableComponent::MakeDeletingDtor(DD));
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001461 } else {
1462 // Add the return adjustment if necessary.
1463 if (!ReturnAdjustment.isEmpty())
Anders Carlsson7cea12f2010-03-23 04:44:10 +00001464 VTableThunks[Components.size()].Return = ReturnAdjustment;
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001465
1466 // Add the function.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001467 Components.push_back(VTableComponent::MakeFunction(MD));
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001468 }
1469}
1470
Anders Carlssond2025412010-02-27 06:38:03 +00001471/// OverridesIndirectMethodInBase - Return whether the given member function
1472/// overrides any methods in the set of given bases.
1473/// Unlike OverridesMethodInBase, this checks "overriders of overriders".
1474/// For example, if we have:
1475///
1476/// struct A { virtual void f(); }
1477/// struct B : A { virtual void f(); }
1478/// struct C : B { virtual void f(); }
1479///
1480/// OverridesIndirectMethodInBase will return true if given C::f as the method
Anders Carlsson88cf34f2010-04-10 20:39:29 +00001481/// and { A } as the set of bases.
Anders Carlssond2025412010-02-27 06:38:03 +00001482static bool
1483OverridesIndirectMethodInBases(const CXXMethodDecl *MD,
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001484 VTableBuilder::PrimaryBasesSetVectorTy &Bases) {
Anders Carlssonc6db5ab2010-04-17 17:24:33 +00001485 if (Bases.count(MD->getParent()))
1486 return true;
1487
Anders Carlssond2025412010-02-27 06:38:03 +00001488 for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
1489 E = MD->end_overridden_methods(); I != E; ++I) {
1490 const CXXMethodDecl *OverriddenMD = *I;
Anders Carlssond2025412010-02-27 06:38:03 +00001491
1492 // Check "indirect overriders".
1493 if (OverridesIndirectMethodInBases(OverriddenMD, Bases))
1494 return true;
1495 }
1496
1497 return false;
1498}
1499
Anders Carlssona8796c62010-02-23 04:26:39 +00001500bool
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001501VTableBuilder::IsOverriderUsed(const CXXMethodDecl *Overrider,
Anders Carlsson804cf512010-03-10 06:51:42 +00001502 uint64_t BaseOffsetInLayoutClass,
1503 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1504 uint64_t FirstBaseOffsetInLayoutClass) const {
Anders Carlssona8796c62010-02-23 04:26:39 +00001505 // If the base and the first base in the primary base chain have the same
1506 // offsets, then this overrider will be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001507 if (BaseOffsetInLayoutClass == FirstBaseOffsetInLayoutClass)
Anders Carlsson8939e402010-02-23 06:34:44 +00001508 return true;
1509
1510 // We know now that Base (or a direct or indirect base of it) is a primary
1511 // base in part of the class hierarchy, but not a primary base in the most
1512 // derived class.
1513
1514 // If the overrider is the first base in the primary base chain, we know
1515 // that the overrider will be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001516 if (Overrider->getParent() == FirstBaseInPrimaryBaseChain)
Anders Carlssona8796c62010-02-23 04:26:39 +00001517 return true;
1518
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001519 VTableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlsson8939e402010-02-23 06:34:44 +00001520
Anders Carlsson804cf512010-03-10 06:51:42 +00001521 const CXXRecordDecl *RD = FirstBaseInPrimaryBaseChain;
Anders Carlsson8939e402010-02-23 06:34:44 +00001522 PrimaryBases.insert(RD);
1523
1524 // Now traverse the base chain, starting with the first base, until we find
1525 // the base that is no longer a primary base.
1526 while (true) {
1527 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1528 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
1529
1530 if (!PrimaryBase)
1531 break;
1532
Anders Carlsson7f95cd12010-11-24 23:12:57 +00001533 if (Layout.isPrimaryBaseVirtual()) {
Anders Carlssonfd88a612010-10-31 23:22:37 +00001534 assert(Layout.getVBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson8939e402010-02-23 06:34:44 +00001535 "Primary base should always be at offset 0!");
1536
Anders Carlsson7162ab92010-02-28 18:37:33 +00001537 const ASTRecordLayout &LayoutClassLayout =
1538 Context.getASTRecordLayout(LayoutClass);
Anders Carlsson8939e402010-02-23 06:34:44 +00001539
1540 // Now check if this is the primary base that is not a primary base in the
1541 // most derived class.
Anders Carlssonfd88a612010-10-31 23:22:37 +00001542 if (LayoutClassLayout.getVBaseClassOffsetInBits(PrimaryBase) !=
Anders Carlsson804cf512010-03-10 06:51:42 +00001543 FirstBaseOffsetInLayoutClass) {
Anders Carlsson8939e402010-02-23 06:34:44 +00001544 // We found it, stop walking the chain.
1545 break;
1546 }
1547 } else {
Anders Carlssonfd88a612010-10-31 23:22:37 +00001548 assert(Layout.getBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson8939e402010-02-23 06:34:44 +00001549 "Primary base should always be at offset 0!");
1550 }
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001551
Anders Carlssonb26c2ab2010-02-27 19:51:04 +00001552 if (!PrimaryBases.insert(PrimaryBase))
1553 assert(false && "Found a duplicate primary base!");
1554
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001555 RD = PrimaryBase;
Anders Carlsson8939e402010-02-23 06:34:44 +00001556 }
1557
1558 // If the final overrider is an override of one of the primary bases,
1559 // then we know that it will be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001560 return OverridesIndirectMethodInBases(Overrider, PrimaryBases);
Anders Carlssona8796c62010-02-23 04:26:39 +00001561}
1562
Anders Carlsson40687982010-02-27 16:52:49 +00001563/// FindNearestOverriddenMethod - Given a method, returns the overridden method
1564/// from the nearest base. Returns null if no method was found.
1565static const CXXMethodDecl *
1566FindNearestOverriddenMethod(const CXXMethodDecl *MD,
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001567 VTableBuilder::PrimaryBasesSetVectorTy &Bases) {
Anders Carlsson88cf34f2010-04-10 20:39:29 +00001568 OverriddenMethodsSetTy OverriddenMethods;
1569 ComputeAllOverriddenMethods(MD, OverriddenMethods);
1570
Anders Carlsson40687982010-02-27 16:52:49 +00001571 for (int I = Bases.size(), E = 0; I != E; --I) {
1572 const CXXRecordDecl *PrimaryBase = Bases[I - 1];
1573
1574 // Now check the overriden methods.
Anders Carlsson88cf34f2010-04-10 20:39:29 +00001575 for (OverriddenMethodsSetTy::const_iterator I = OverriddenMethods.begin(),
1576 E = OverriddenMethods.end(); I != E; ++I) {
Anders Carlsson40687982010-02-27 16:52:49 +00001577 const CXXMethodDecl *OverriddenMD = *I;
Anders Carlsson88cf34f2010-04-10 20:39:29 +00001578
Anders Carlsson40687982010-02-27 16:52:49 +00001579 // We found our overridden method.
1580 if (OverriddenMD->getParent() == PrimaryBase)
1581 return OverriddenMD;
1582 }
1583 }
1584
1585 return 0;
1586}
1587
Anders Carlsson804cf512010-03-10 06:51:42 +00001588void
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001589VTableBuilder::AddMethods(BaseSubobject Base, uint64_t BaseOffsetInLayoutClass,
Anders Carlsson804cf512010-03-10 06:51:42 +00001590 const CXXRecordDecl *FirstBaseInPrimaryBaseChain,
1591 uint64_t FirstBaseOffsetInLayoutClass,
Anders Carlssond46ed892010-02-27 16:18:19 +00001592 PrimaryBasesSetVectorTy &PrimaryBases) {
Anders Carlsson65b49782010-02-12 05:25:12 +00001593 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson65b49782010-02-12 05:25:12 +00001594 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1595
1596 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Ken Dyckce812032011-03-26 00:51:24 +00001597 CharUnits PrimaryBaseOffset;
Anders Carlsson804cf512010-03-10 06:51:42 +00001598 uint64_t PrimaryBaseOffsetInLayoutClass;
Anders Carlsson7f95cd12010-11-24 23:12:57 +00001599 if (Layout.isPrimaryBaseVirtual()) {
Anders Carlssonfd88a612010-10-31 23:22:37 +00001600 assert(Layout.getVBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson0570f712010-02-23 03:48:14 +00001601 "Primary vbase should have a zero offset!");
1602
1603 const ASTRecordLayout &MostDerivedClassLayout =
1604 Context.getASTRecordLayout(MostDerivedClass);
1605
Anders Carlsson804cf512010-03-10 06:51:42 +00001606 PrimaryBaseOffset =
Ken Dyckce812032011-03-26 00:51:24 +00001607 MostDerivedClassLayout.getVBaseClassOffset(PrimaryBase);
Anders Carlsson804cf512010-03-10 06:51:42 +00001608
1609 const ASTRecordLayout &LayoutClassLayout =
1610 Context.getASTRecordLayout(LayoutClass);
1611
1612 PrimaryBaseOffsetInLayoutClass =
Anders Carlssonfd88a612010-10-31 23:22:37 +00001613 LayoutClassLayout.getVBaseClassOffsetInBits(PrimaryBase);
Anders Carlsson0570f712010-02-23 03:48:14 +00001614 } else {
Anders Carlssonfd88a612010-10-31 23:22:37 +00001615 assert(Layout.getBaseClassOffsetInBits(PrimaryBase) == 0 &&
Anders Carlsson65b49782010-02-12 05:25:12 +00001616 "Primary base should have a zero offset!");
Anders Carlsson0570f712010-02-23 03:48:14 +00001617
Ken Dyckce812032011-03-26 00:51:24 +00001618 PrimaryBaseOffset = Base.getBaseOffset();
Anders Carlsson804cf512010-03-10 06:51:42 +00001619 PrimaryBaseOffsetInLayoutClass = BaseOffsetInLayoutClass;
Anders Carlsson0570f712010-02-23 03:48:14 +00001620 }
Anders Carlsson7162ab92010-02-28 18:37:33 +00001621
Ken Dyckce812032011-03-26 00:51:24 +00001622 AddMethods(BaseSubobject(PrimaryBase, PrimaryBaseOffset),
Anders Carlsson804cf512010-03-10 06:51:42 +00001623 PrimaryBaseOffsetInLayoutClass, FirstBaseInPrimaryBaseChain,
1624 FirstBaseOffsetInLayoutClass, PrimaryBases);
Anders Carlsson65b49782010-02-12 05:25:12 +00001625
1626 if (!PrimaryBases.insert(PrimaryBase))
1627 assert(false && "Found a duplicate primary base!");
1628 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00001629
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001630 // Now go through all virtual member functions and add them.
1631 for (CXXRecordDecl::method_iterator I = RD->method_begin(),
1632 E = RD->method_end(); I != E; ++I) {
1633 const CXXMethodDecl *MD = *I;
Anders Carlsson65b49782010-02-12 05:25:12 +00001634
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001635 if (!MD->isVirtual())
1636 continue;
Anders Carlsson65b49782010-02-12 05:25:12 +00001637
1638 // Get the final overrider.
Anders Carlsson136bd192010-02-12 16:55:34 +00001639 FinalOverriders::OverriderInfo Overrider =
Ken Dyck808457c2011-03-26 01:18:17 +00001640 Overriders.getOverrider(MD, Base.getBaseOffset());
Anders Carlsson65b49782010-02-12 05:25:12 +00001641
1642 // Check if this virtual member function overrides a method in a primary
1643 // base. If this is the case, and the return type doesn't require adjustment
1644 // then we can just use the member function from the primary base.
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001645 if (const CXXMethodDecl *OverriddenMD =
Anders Carlsson40687982010-02-27 16:52:49 +00001646 FindNearestOverriddenMethod(MD, PrimaryBases)) {
Anders Carlssoncce9ee82010-02-13 23:17:31 +00001647 if (ComputeReturnAdjustmentBaseOffset(Context, MD,
Anders Carlsson40687982010-02-27 16:52:49 +00001648 OverriddenMD).isEmpty()) {
1649 // Replace the method info of the overridden method with our own
1650 // method.
1651 assert(MethodInfoMap.count(OverriddenMD) &&
1652 "Did not find the overridden method!");
1653 MethodInfo &OverriddenMethodInfo = MethodInfoMap[OverriddenMD];
1654
Ken Dyck7d876f32011-03-27 18:57:53 +00001655 MethodInfo MethodInfo(Base.getBaseOffset(),
1656 Context.toCharUnitsFromBits(BaseOffsetInLayoutClass),
1657 OverriddenMethodInfo.VTableIndex);
Anders Carlsson40687982010-02-27 16:52:49 +00001658
1659 assert(!MethodInfoMap.count(MD) &&
1660 "Should not have method info for this method yet!");
1661
1662 MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
1663 MethodInfoMap.erase(OverriddenMD);
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001664
1665 // If the overridden method exists in a virtual base class or a direct
1666 // or indirect base class of a virtual base class, we need to emit a
1667 // thunk if we ever have a class hierarchy where the base class is not
1668 // a primary base in the complete object.
Anders Carlssond78b2242010-04-11 22:07:06 +00001669 if (!isBuildingConstructorVTable() && OverriddenMD != MD) {
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001670 // Compute the this adjustment.
1671 ThisAdjustment ThisAdjustment =
1672 ComputeThisAdjustment(OverriddenMD, BaseOffsetInLayoutClass,
1673 Overrider);
1674
Anders Carlsson800ded62010-03-29 02:53:58 +00001675 if (ThisAdjustment.VCallOffsetOffset &&
1676 Overrider.Method->getParent() == MostDerivedClass) {
John McCall47838252010-11-09 01:18:05 +00001677
1678 // There's no return adjustment from OverriddenMD and MD,
1679 // but that doesn't mean there isn't one between MD and
1680 // the final overrider.
1681 BaseOffset ReturnAdjustmentOffset =
1682 ComputeReturnAdjustmentBaseOffset(Context, Overrider.Method, MD);
1683 ReturnAdjustment ReturnAdjustment =
1684 ComputeReturnAdjustment(ReturnAdjustmentOffset);
1685
Anders Carlsson800ded62010-03-29 02:53:58 +00001686 // This is a virtual thunk for the most derived class, add it.
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001687 AddThunk(Overrider.Method,
John McCall47838252010-11-09 01:18:05 +00001688 ThunkInfo(ThisAdjustment, ReturnAdjustment));
Anders Carlsson290c6ed2010-03-22 20:06:40 +00001689 }
1690 }
1691
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001692 continue;
Anders Carlsson40687982010-02-27 16:52:49 +00001693 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001694 }
Anders Carlssoneee53d92010-02-13 02:02:03 +00001695
Anders Carlsson40687982010-02-27 16:52:49 +00001696 // Insert the method info for this method.
Ken Dyck7d876f32011-03-27 18:57:53 +00001697 MethodInfo MethodInfo(Base.getBaseOffset(),
1698 Context.toCharUnitsFromBits(BaseOffsetInLayoutClass),
1699 Components.size());
Anders Carlsson40687982010-02-27 16:52:49 +00001700
1701 assert(!MethodInfoMap.count(MD) &&
1702 "Should not have method info for this method yet!");
1703 MethodInfoMap.insert(std::make_pair(MD, MethodInfo));
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001704
1705 // Check if this overrider is going to be used.
Anders Carlsson804cf512010-03-10 06:51:42 +00001706 const CXXMethodDecl *OverriderMD = Overrider.Method;
1707 if (!IsOverriderUsed(OverriderMD, BaseOffsetInLayoutClass,
1708 FirstBaseInPrimaryBaseChain,
1709 FirstBaseOffsetInLayoutClass)) {
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001710 Components.push_back(VTableComponent::MakeUnusedFunction(OverriderMD));
Anders Carlsson01d3c7d2010-02-27 18:09:40 +00001711 continue;
1712 }
Anders Carlssona8796c62010-02-23 04:26:39 +00001713
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001714 // Check if this overrider needs a return adjustment.
Anders Carlsson042ce2d82010-06-01 23:47:05 +00001715 // We don't want to do this for pure virtual member functions.
1716 BaseOffset ReturnAdjustmentOffset;
1717 if (!OverriderMD->isPure()) {
1718 ReturnAdjustmentOffset =
1719 ComputeReturnAdjustmentBaseOffset(Context, OverriderMD, MD);
1720 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00001721
1722 ReturnAdjustment ReturnAdjustment =
1723 ComputeReturnAdjustment(ReturnAdjustmentOffset);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001724
Anders Carlsson40687982010-02-27 16:52:49 +00001725 AddMethod(Overrider.Method, ReturnAdjustment);
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001726 }
1727}
1728
Anders Carlssond78b2242010-04-11 22:07:06 +00001729void VTableBuilder::LayoutVTable() {
Ken Dyck16ffcac2011-03-24 01:21:01 +00001730 LayoutPrimaryAndSecondaryVTables(BaseSubobject(MostDerivedClass,
1731 CharUnits::Zero()),
Anders Carlsson3383e2a2010-04-11 22:20:36 +00001732 /*BaseIsMorallyVirtual=*/false,
Anders Carlssone3385f52010-02-28 01:43:58 +00001733 MostDerivedClassIsVirtual,
1734 MostDerivedClassOffset);
Anders Carlssonb716a542010-02-16 16:26:28 +00001735
Anders Carlsson13f0f662010-02-16 16:49:35 +00001736 VisitedVirtualBasesSetTy VBases;
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001737
1738 // Determine the primary virtual bases.
Anders Carlsson02b99d62010-03-10 03:02:01 +00001739 DeterminePrimaryVirtualBases(MostDerivedClass, MostDerivedClassOffset,
1740 VBases);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001741 VBases.clear();
1742
Anders Carlssond78b2242010-04-11 22:07:06 +00001743 LayoutVTablesForVirtualBases(MostDerivedClass, VBases);
Anders Carlssonb716a542010-02-16 16:26:28 +00001744}
1745
Anders Carlssone3385f52010-02-28 01:43:58 +00001746void
Anders Carlssond78b2242010-04-11 22:07:06 +00001747VTableBuilder::LayoutPrimaryAndSecondaryVTables(BaseSubobject Base,
Anders Carlsson3383e2a2010-04-11 22:20:36 +00001748 bool BaseIsMorallyVirtual,
Anders Carlssonb41c6332010-04-11 22:03:57 +00001749 bool BaseIsVirtualInLayoutClass,
Anders Carlssone3385f52010-02-28 01:43:58 +00001750 uint64_t OffsetInLayoutClass) {
Chris Lattnerd2408f72010-02-17 21:42:34 +00001751 assert(Base.getBase()->isDynamicClass() && "class does not have a vtable!");
Anders Carlsson033d4862010-02-14 17:05:59 +00001752
Anders Carlsson77904f12010-02-16 04:59:55 +00001753 // Add vcall and vbase offsets for this vtable.
Anders Carlssone3385f52010-02-28 01:43:58 +00001754 VCallAndVBaseOffsetBuilder Builder(MostDerivedClass, LayoutClass, &Overriders,
Anders Carlssonb41c6332010-04-11 22:03:57 +00001755 Base, BaseIsVirtualInLayoutClass,
1756 OffsetInLayoutClass);
Anders Carlsson422f7782010-02-25 03:45:56 +00001757 Components.append(Builder.components_begin(), Builder.components_end());
1758
Anders Carlsson9e3b3a32010-02-25 22:23:13 +00001759 // Check if we need to add these vcall offsets.
Anders Carlssonb41c6332010-04-11 22:03:57 +00001760 if (BaseIsVirtualInLayoutClass && !Builder.getVCallOffsets().empty()) {
Anders Carlsson9e3b3a32010-02-25 22:23:13 +00001761 VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Base.getBase()];
1762
1763 if (VCallOffsets.empty())
1764 VCallOffsets = Builder.getVCallOffsets();
1765 }
1766
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001767 // If we're laying out the most derived class we want to keep track of the
1768 // virtual base class offset offsets.
1769 if (Base.getBase() == MostDerivedClass)
1770 VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets();
1771
Anders Carlsson77904f12010-02-16 04:59:55 +00001772 // Add the offset to top.
Anders Carlsson258a1e32010-02-14 00:16:19 +00001773 // FIXME: We should not use / 8 here.
Anders Carlssone3385f52010-02-28 01:43:58 +00001774 int64_t OffsetToTop = -(int64_t)(OffsetInLayoutClass -
1775 MostDerivedClassOffset) / 8;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001776 Components.push_back(VTableComponent::MakeOffsetToTop(OffsetToTop));
Anders Carlsson65b49782010-02-12 05:25:12 +00001777
1778 // Next, add the RTTI.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001779 Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass));
Anders Carlsson65b49782010-02-12 05:25:12 +00001780
Anders Carlssone8a97562010-02-12 07:43:48 +00001781 uint64_t AddressPoint = Components.size();
Anders Carlsson65b49782010-02-12 05:25:12 +00001782
1783 // Now go through all virtual member functions and add them.
Anders Carlssond46ed892010-02-27 16:18:19 +00001784 PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlsson804cf512010-03-10 06:51:42 +00001785 AddMethods(Base, OffsetInLayoutClass, Base.getBase(), OffsetInLayoutClass,
1786 PrimaryBases);
Anders Carlsson65b49782010-02-12 05:25:12 +00001787
Anders Carlsson40687982010-02-27 16:52:49 +00001788 // Compute 'this' pointer adjustments.
1789 ComputeThisAdjustments();
1790
Anders Carlsson151b0622010-03-25 21:45:14 +00001791 // Add all address points.
1792 const CXXRecordDecl *RD = Base.getBase();
1793 while (true) {
Ken Dyck16ffcac2011-03-24 01:21:01 +00001794 AddressPoints.insert(std::make_pair(
1795 BaseSubobject(RD, Context.toCharUnitsFromBits(OffsetInLayoutClass)),
1796 AddressPoint));
Anders Carlsson151b0622010-03-25 21:45:14 +00001797
1798 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1799 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
Anders Carlssone8a97562010-02-12 07:43:48 +00001800
Anders Carlsson151b0622010-03-25 21:45:14 +00001801 if (!PrimaryBase)
1802 break;
1803
Anders Carlsson7f95cd12010-11-24 23:12:57 +00001804 if (Layout.isPrimaryBaseVirtual()) {
Anders Carlsson151b0622010-03-25 21:45:14 +00001805 // Check if this virtual primary base is a primary base in the layout
1806 // class. If it's not, we don't want to add it.
1807 const ASTRecordLayout &LayoutClassLayout =
1808 Context.getASTRecordLayout(LayoutClass);
1809
Anders Carlssonfd88a612010-10-31 23:22:37 +00001810 if (LayoutClassLayout.getVBaseClassOffsetInBits(PrimaryBase) !=
Anders Carlsson151b0622010-03-25 21:45:14 +00001811 OffsetInLayoutClass) {
1812 // We don't want to add this class (or any of its primary bases).
1813 break;
1814 }
1815 }
1816
1817 RD = PrimaryBase;
Anders Carlssone8a97562010-02-12 07:43:48 +00001818 }
1819
Anders Carlssona9f633b2010-02-24 16:43:12 +00001820 // Layout secondary vtables.
Anders Carlssond78b2242010-04-11 22:07:06 +00001821 LayoutSecondaryVTables(Base, BaseIsMorallyVirtual, OffsetInLayoutClass);
Anders Carlsson14157932010-02-16 16:02:57 +00001822}
1823
Anders Carlssond78b2242010-04-11 22:07:06 +00001824void VTableBuilder::LayoutSecondaryVTables(BaseSubobject Base,
Anders Carlsson115b4752010-03-10 19:39:11 +00001825 bool BaseIsMorallyVirtual,
Anders Carlssone3385f52010-02-28 01:43:58 +00001826 uint64_t OffsetInLayoutClass) {
Anders Carlsson14157932010-02-16 16:02:57 +00001827 // Itanium C++ ABI 2.5.2:
1828 // Following the primary virtual table of a derived class are secondary
1829 // virtual tables for each of its proper base classes, except any primary
1830 // base(s) with which it shares its primary virtual table.
1831
1832 const CXXRecordDecl *RD = Base.getBase();
Anders Carlsson65b49782010-02-12 05:25:12 +00001833 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1834 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
Anders Carlsson14157932010-02-16 16:02:57 +00001835
Anders Carlsson65b49782010-02-12 05:25:12 +00001836 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1837 E = RD->bases_end(); I != E; ++I) {
Anders Carlsson14157932010-02-16 16:02:57 +00001838 // Ignore virtual bases, we'll emit them later.
1839 if (I->isVirtual())
1840 continue;
1841
Anders Carlsson65b49782010-02-12 05:25:12 +00001842 const CXXRecordDecl *BaseDecl =
1843 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
Anders Carlsson033d4862010-02-14 17:05:59 +00001844
Anders Carlssondc2dba32010-02-16 04:49:44 +00001845 // Ignore bases that don't have a vtable.
1846 if (!BaseDecl->isDynamicClass())
1847 continue;
Anders Carlsson033d4862010-02-14 17:05:59 +00001848
Anders Carlssond78b2242010-04-11 22:07:06 +00001849 if (isBuildingConstructorVTable()) {
Anders Carlsson703a0862010-03-10 19:15:26 +00001850 // Itanium C++ ABI 2.6.4:
1851 // Some of the base class subobjects may not need construction virtual
1852 // tables, which will therefore not be present in the construction
1853 // virtual table group, even though the subobject virtual tables are
1854 // present in the main virtual table group for the complete object.
Anders Carlsson115b4752010-03-10 19:39:11 +00001855 if (!BaseIsMorallyVirtual && !BaseDecl->getNumVBases())
Anders Carlsson703a0862010-03-10 19:15:26 +00001856 continue;
Anders Carlsson703a0862010-03-10 19:15:26 +00001857 }
1858
Anders Carlssone75aaa92010-02-13 22:05:23 +00001859 // Get the base offset of this base.
Ken Dyckce812032011-03-26 00:51:24 +00001860 CharUnits RelativeBaseOffset = Layout.getBaseClassOffset(BaseDecl);
1861 CharUnits BaseOffset = Base.getBaseOffset() + RelativeBaseOffset;
Anders Carlssone3385f52010-02-28 01:43:58 +00001862
Ken Dyckce812032011-03-26 00:51:24 +00001863 CharUnits BaseOffsetInLayoutClass =
1864 Context.toCharUnitsFromBits(OffsetInLayoutClass) + RelativeBaseOffset;
Anders Carlsson14157932010-02-16 16:02:57 +00001865
1866 // Don't emit a secondary vtable for a primary base. We might however want
1867 // to emit secondary vtables for other bases of this base.
1868 if (BaseDecl == PrimaryBase) {
Ken Dyck16ffcac2011-03-24 01:21:01 +00001869 LayoutSecondaryVTables(
Ken Dyckce812032011-03-26 00:51:24 +00001870 BaseSubobject(BaseDecl, BaseOffset),
1871 BaseIsMorallyVirtual, Context.toBits(BaseOffsetInLayoutClass));
Anders Carlsson14157932010-02-16 16:02:57 +00001872 continue;
1873 }
Anders Carlssone75aaa92010-02-13 22:05:23 +00001874
Anders Carlssonb716a542010-02-16 16:26:28 +00001875 // Layout the primary vtable (and any secondary vtables) for this base.
Ken Dyck16ffcac2011-03-24 01:21:01 +00001876 LayoutPrimaryAndSecondaryVTables(
Ken Dyckce812032011-03-26 00:51:24 +00001877 BaseSubobject(BaseDecl, BaseOffset),
Ken Dyck16ffcac2011-03-24 01:21:01 +00001878 BaseIsMorallyVirtual,
1879 /*BaseIsVirtualInLayoutClass=*/false,
Ken Dyckce812032011-03-26 00:51:24 +00001880 Context.toBits(BaseOffsetInLayoutClass));
Anders Carlsson65b49782010-02-12 05:25:12 +00001881 }
1882}
1883
Anders Carlsson13f0f662010-02-16 16:49:35 +00001884void
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001885VTableBuilder::DeterminePrimaryVirtualBases(const CXXRecordDecl *RD,
Anders Carlsson02b99d62010-03-10 03:02:01 +00001886 uint64_t OffsetInLayoutClass,
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001887 VisitedVirtualBasesSetTy &VBases) {
1888 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
1889
1890 // Check if this base has a primary base.
1891 if (const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase()) {
Anders Carlsson8b37bb72010-02-28 18:08:38 +00001892
1893 // Check if it's virtual.
Anders Carlsson7f95cd12010-11-24 23:12:57 +00001894 if (Layout.isPrimaryBaseVirtual()) {
Anders Carlsson8b37bb72010-02-28 18:08:38 +00001895 bool IsPrimaryVirtualBase = true;
1896
Anders Carlssond78b2242010-04-11 22:07:06 +00001897 if (isBuildingConstructorVTable()) {
Anders Carlsson8b37bb72010-02-28 18:08:38 +00001898 // Check if the base is actually a primary base in the class we use for
1899 // layout.
Anders Carlsson02b99d62010-03-10 03:02:01 +00001900 const ASTRecordLayout &LayoutClassLayout =
1901 Context.getASTRecordLayout(LayoutClass);
1902
1903 uint64_t PrimaryBaseOffsetInLayoutClass =
Anders Carlssonfd88a612010-10-31 23:22:37 +00001904 LayoutClassLayout.getVBaseClassOffsetInBits(PrimaryBase);
Anders Carlsson02b99d62010-03-10 03:02:01 +00001905
1906 // We know that the base is not a primary base in the layout class if
1907 // the base offsets are different.
1908 if (PrimaryBaseOffsetInLayoutClass != OffsetInLayoutClass)
Anders Carlsson8b37bb72010-02-28 18:08:38 +00001909 IsPrimaryVirtualBase = false;
1910 }
1911
1912 if (IsPrimaryVirtualBase)
1913 PrimaryVirtualBases.insert(PrimaryBase);
1914 }
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001915 }
1916
1917 // Traverse bases, looking for more primary virtual bases.
1918 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1919 E = RD->bases_end(); I != E; ++I) {
1920 const CXXRecordDecl *BaseDecl =
1921 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1922
Anders Carlsson02b99d62010-03-10 03:02:01 +00001923 uint64_t BaseOffsetInLayoutClass;
1924
1925 if (I->isVirtual()) {
1926 if (!VBases.insert(BaseDecl))
1927 continue;
1928
1929 const ASTRecordLayout &LayoutClassLayout =
1930 Context.getASTRecordLayout(LayoutClass);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001931
Anders Carlssonfd88a612010-10-31 23:22:37 +00001932 BaseOffsetInLayoutClass =
1933 LayoutClassLayout.getVBaseClassOffsetInBits(BaseDecl);
Anders Carlsson02b99d62010-03-10 03:02:01 +00001934 } else {
1935 BaseOffsetInLayoutClass =
Anders Carlssonfd88a612010-10-31 23:22:37 +00001936 OffsetInLayoutClass + Layout.getBaseClassOffsetInBits(BaseDecl);
Anders Carlsson02b99d62010-03-10 03:02:01 +00001937 }
1938
1939 DeterminePrimaryVirtualBases(BaseDecl, BaseOffsetInLayoutClass, VBases);
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001940 }
1941}
1942
1943void
Anders Carlssond78b2242010-04-11 22:07:06 +00001944VTableBuilder::LayoutVTablesForVirtualBases(const CXXRecordDecl *RD,
Anders Carlsson13f0f662010-02-16 16:49:35 +00001945 VisitedVirtualBasesSetTy &VBases) {
1946 // Itanium C++ ABI 2.5.2:
1947 // Then come the virtual base virtual tables, also in inheritance graph
1948 // order, and again excluding primary bases (which share virtual tables with
1949 // the classes for which they are primary).
Anders Carlsson13f0f662010-02-16 16:49:35 +00001950 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1951 E = RD->bases_end(); I != E; ++I) {
1952 const CXXRecordDecl *BaseDecl =
1953 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1954
Anders Carlsson0570f712010-02-23 03:48:14 +00001955 // Check if this base needs a vtable. (If it's virtual, not a primary base
1956 // of some other class, and we haven't visited it before).
Anders Carlsson13f0f662010-02-16 16:49:35 +00001957 if (I->isVirtual() && BaseDecl->isDynamicClass() &&
Anders Carlssonb08aaa32010-02-27 04:05:52 +00001958 !PrimaryVirtualBases.count(BaseDecl) && VBases.insert(BaseDecl)) {
Anders Carlsson13f0f662010-02-16 16:49:35 +00001959 const ASTRecordLayout &MostDerivedClassLayout =
1960 Context.getASTRecordLayout(MostDerivedClass);
1961 uint64_t BaseOffset =
Anders Carlssonfd88a612010-10-31 23:22:37 +00001962 MostDerivedClassLayout.getVBaseClassOffsetInBits(BaseDecl);
Anders Carlsson13f0f662010-02-16 16:49:35 +00001963
Anders Carlssone3385f52010-02-28 01:43:58 +00001964 const ASTRecordLayout &LayoutClassLayout =
1965 Context.getASTRecordLayout(LayoutClass);
1966 uint64_t BaseOffsetInLayoutClass =
Anders Carlssonfd88a612010-10-31 23:22:37 +00001967 LayoutClassLayout.getVBaseClassOffsetInBits(BaseDecl);
Anders Carlssone3385f52010-02-28 01:43:58 +00001968
Ken Dyck16ffcac2011-03-24 01:21:01 +00001969 LayoutPrimaryAndSecondaryVTables(
1970 BaseSubobject(BaseDecl, Context.toCharUnitsFromBits(BaseOffset)),
1971 /*BaseIsMorallyVirtual=*/true,
1972 /*BaseIsVirtualInLayoutClass=*/true,
1973 BaseOffsetInLayoutClass);
Anders Carlsson13f0f662010-02-16 16:49:35 +00001974 }
1975
1976 // We only need to check the base for virtual base vtables if it actually
1977 // has virtual bases.
1978 if (BaseDecl->getNumVBases())
Anders Carlssond78b2242010-04-11 22:07:06 +00001979 LayoutVTablesForVirtualBases(BaseDecl, VBases);
Anders Carlsson13f0f662010-02-16 16:49:35 +00001980 }
1981}
1982
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001983/// dumpLayout - Dump the vtable layout.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00001984void VTableBuilder::dumpLayout(llvm::raw_ostream& Out) {
Anders Carlsson93913752010-02-27 20:39:05 +00001985
Anders Carlssond78b2242010-04-11 22:07:06 +00001986 if (isBuildingConstructorVTable()) {
Anders Carlsson93913752010-02-27 20:39:05 +00001987 Out << "Construction vtable for ('";
1988 Out << MostDerivedClass->getQualifiedNameAsString() << "', ";
1989 // FIXME: Don't use / 8 .
1990 Out << MostDerivedClassOffset / 8 << ") in '";
1991 Out << LayoutClass->getQualifiedNameAsString();
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00001992 } else {
1993 Out << "Vtable for '";
1994 Out << MostDerivedClass->getQualifiedNameAsString();
Anders Carlsson93913752010-02-27 20:39:05 +00001995 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001996 Out << "' (" << Components.size() << " entries).\n";
1997
Anders Carlsson932c2f22010-02-11 17:18:51 +00001998 // Iterate through the address points and insert them into a new map where
1999 // they are keyed by the index and not the base object.
2000 // Since an address point can be shared by multiple subobjects, we use an
2001 // STL multimap.
2002 std::multimap<uint64_t, BaseSubobject> AddressPointsByIndex;
Anders Carlsson0534b022010-03-25 00:35:49 +00002003 for (AddressPointsMapTy::const_iterator I = AddressPoints.begin(),
2004 E = AddressPoints.end(); I != E; ++I) {
Anders Carlsson932c2f22010-02-11 17:18:51 +00002005 const BaseSubobject& Base = I->first;
2006 uint64_t Index = I->second;
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002007
Anders Carlsson932c2f22010-02-11 17:18:51 +00002008 AddressPointsByIndex.insert(std::make_pair(Index, Base));
2009 }
2010
2011 for (unsigned I = 0, E = Components.size(); I != E; ++I) {
Anders Carlssone8a97562010-02-12 07:43:48 +00002012 uint64_t Index = I;
Anders Carlsson932c2f22010-02-11 17:18:51 +00002013
2014 Out << llvm::format("%4d | ", I);
2015
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002016 const VTableComponent &Component = Components[I];
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002017
2018 // Dump the component.
2019 switch (Component.getKind()) {
Anders Carlssonb0a588f2010-02-17 06:07:19 +00002020
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002021 case VTableComponent::CK_VCallOffset:
Anders Carlssonb0a588f2010-02-17 06:07:19 +00002022 Out << "vcall_offset (" << Component.getVCallOffset() << ")";
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002023 break;
Anders Carlsson77904f12010-02-16 04:59:55 +00002024
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002025 case VTableComponent::CK_VBaseOffset:
Anders Carlsson77904f12010-02-16 04:59:55 +00002026 Out << "vbase_offset (" << Component.getVBaseOffset() << ")";
2027 break;
2028
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002029 case VTableComponent::CK_OffsetToTop:
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002030 Out << "offset_to_top (" << Component.getOffsetToTop() << ")";
2031 break;
2032
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002033 case VTableComponent::CK_RTTI:
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002034 Out << Component.getRTTIDecl()->getQualifiedNameAsString() << " RTTI";
2035 break;
2036
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002037 case VTableComponent::CK_FunctionPointer: {
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002038 const CXXMethodDecl *MD = Component.getFunctionDecl();
2039
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002040 std::string Str =
2041 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2042 MD);
2043 Out << Str;
Anders Carlsson09da3372010-02-12 02:38:13 +00002044 if (MD->isPure())
2045 Out << " [pure]";
2046
Anders Carlsson7cea12f2010-03-23 04:44:10 +00002047 ThunkInfo Thunk = VTableThunks.lookup(I);
Anders Carlsson8a240292010-03-12 04:54:20 +00002048 if (!Thunk.isEmpty()) {
2049 // If this function pointer has a return adjustment, dump it.
2050 if (!Thunk.Return.isEmpty()) {
2051 Out << "\n [return adjustment: ";
2052 Out << Thunk.Return.NonVirtual << " non-virtual";
2053
2054 if (Thunk.Return.VBaseOffsetOffset) {
2055 Out << ", " << Thunk.Return.VBaseOffsetOffset;
2056 Out << " vbase offset offset";
2057 }
Anders Carlsson78277c72010-02-18 17:00:09 +00002058
Anders Carlsson8a240292010-03-12 04:54:20 +00002059 Out << ']';
2060 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00002061
Anders Carlsson8a240292010-03-12 04:54:20 +00002062 // If this function pointer has a 'this' pointer adjustment, dump it.
2063 if (!Thunk.This.isEmpty()) {
2064 Out << "\n [this adjustment: ";
2065 Out << Thunk.This.NonVirtual << " non-virtual";
2066
2067 if (Thunk.This.VCallOffsetOffset) {
2068 Out << ", " << Thunk.This.VCallOffsetOffset;
2069 Out << " vcall offset offset";
2070 }
Anders Carlsson78277c72010-02-18 17:00:09 +00002071
Anders Carlsson8a240292010-03-12 04:54:20 +00002072 Out << ']';
2073 }
Anders Carlssond3adb0c2010-02-13 23:40:17 +00002074 }
Anders Carlsson6a6cbfc2010-02-13 20:11:51 +00002075
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002076 break;
2077 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002078
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002079 case VTableComponent::CK_CompleteDtorPointer:
2080 case VTableComponent::CK_DeletingDtorPointer: {
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002081 bool IsComplete =
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002082 Component.getKind() == VTableComponent::CK_CompleteDtorPointer;
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002083
Anders Carlsson5bd8d192010-02-11 18:20:28 +00002084 const CXXDestructorDecl *DD = Component.getDestructorDecl();
2085
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002086 Out << DD->getQualifiedNameAsString();
2087 if (IsComplete)
2088 Out << "() [complete]";
2089 else
2090 Out << "() [deleting]";
2091
Anders Carlsson09da3372010-02-12 02:38:13 +00002092 if (DD->isPure())
2093 Out << " [pure]";
2094
Anders Carlsson7cea12f2010-03-23 04:44:10 +00002095 ThunkInfo Thunk = VTableThunks.lookup(I);
Anders Carlsson8a240292010-03-12 04:54:20 +00002096 if (!Thunk.isEmpty()) {
2097 // If this destructor has a 'this' pointer adjustment, dump it.
2098 if (!Thunk.This.isEmpty()) {
2099 Out << "\n [this adjustment: ";
2100 Out << Thunk.This.NonVirtual << " non-virtual";
2101
2102 if (Thunk.This.VCallOffsetOffset) {
2103 Out << ", " << Thunk.This.VCallOffsetOffset;
2104 Out << " vcall offset offset";
2105 }
2106
2107 Out << ']';
2108 }
2109 }
Anders Carlsson2d3d9032010-02-19 06:03:53 +00002110
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002111 break;
2112 }
2113
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002114 case VTableComponent::CK_UnusedFunctionPointer: {
Anders Carlsson350b56e2010-02-19 20:08:13 +00002115 const CXXMethodDecl *MD = Component.getUnusedFunctionDecl();
2116
2117 std::string Str =
2118 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2119 MD);
2120 Out << "[unused] " << Str;
2121 if (MD->isPure())
2122 Out << " [pure]";
2123 }
2124
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002125 }
Anders Carlsson932c2f22010-02-11 17:18:51 +00002126
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002127 Out << '\n';
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002128
2129 // Dump the next address point.
2130 uint64_t NextIndex = Index + 1;
2131 if (AddressPointsByIndex.count(NextIndex)) {
2132 if (AddressPointsByIndex.count(NextIndex) == 1) {
2133 const BaseSubobject &Base =
2134 AddressPointsByIndex.find(NextIndex)->second;
2135
2136 // FIXME: Instead of dividing by 8, we should be using CharUnits.
2137 Out << " -- (" << Base.getBase()->getQualifiedNameAsString();
Ken Dyck16ffcac2011-03-24 01:21:01 +00002138 Out << ", " << Base.getBaseOffset().getQuantity();
2139 Out << ") vtable address --\n";
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002140 } else {
Ken Dyckce812032011-03-26 00:51:24 +00002141 CharUnits BaseOffset =
2142 AddressPointsByIndex.lower_bound(NextIndex)->second.getBaseOffset();
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002143
2144 // We store the class names in a set to get a stable order.
2145 std::set<std::string> ClassNames;
2146 for (std::multimap<uint64_t, BaseSubobject>::const_iterator I =
2147 AddressPointsByIndex.lower_bound(NextIndex), E =
2148 AddressPointsByIndex.upper_bound(NextIndex); I != E; ++I) {
Ken Dyckce812032011-03-26 00:51:24 +00002149 assert(I->second.getBaseOffset() == BaseOffset &&
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002150 "Invalid base offset!");
2151 const CXXRecordDecl *RD = I->second.getBase();
2152 ClassNames.insert(RD->getQualifiedNameAsString());
2153 }
2154
2155 for (std::set<std::string>::const_iterator I = ClassNames.begin(),
2156 E = ClassNames.end(); I != E; ++I) {
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002157 Out << " -- (" << *I;
Ken Dyckce812032011-03-26 00:51:24 +00002158 Out << ", " << BaseOffset.getQuantity() << ") vtable address --\n";
Anders Carlssonf98b47d32010-02-27 23:58:01 +00002159 }
2160 }
2161 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002162 }
Anders Carlsson93913752010-02-27 20:39:05 +00002163
2164 Out << '\n';
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002165
Anders Carlssond78b2242010-04-11 22:07:06 +00002166 if (isBuildingConstructorVTable())
Anders Carlsson18c582d2010-03-18 02:44:19 +00002167 return;
2168
2169 if (MostDerivedClass->getNumVBases()) {
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002170 // We store the virtual base class names and their offsets in a map to get
2171 // a stable order.
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002172
Anders Carlsson18c582d2010-03-18 02:44:19 +00002173 std::map<std::string, int64_t> ClassNamesAndOffsets;
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002174 for (VBaseOffsetOffsetsMapTy::const_iterator I = VBaseOffsetOffsets.begin(),
2175 E = VBaseOffsetOffsets.end(); I != E; ++I) {
2176 std::string ClassName = I->first->getQualifiedNameAsString();
2177 int64_t OffsetOffset = I->second;
2178 ClassNamesAndOffsets.insert(std::make_pair(ClassName, OffsetOffset));
2179 }
Anders Carlsson18c582d2010-03-18 02:44:19 +00002180
2181 Out << "Virtual base offset offsets for '";
2182 Out << MostDerivedClass->getQualifiedNameAsString() << "' (";
2183 Out << ClassNamesAndOffsets.size();
2184 Out << (ClassNamesAndOffsets.size() == 1 ? " entry" : " entries") << ").\n";
Anders Carlsson7f6b71e2010-03-11 06:43:12 +00002185
2186 for (std::map<std::string, int64_t>::const_iterator I =
2187 ClassNamesAndOffsets.begin(), E = ClassNamesAndOffsets.end();
2188 I != E; ++I)
2189 Out << " " << I->first << " | " << I->second << '\n';
2190
2191 Out << "\n";
2192 }
Anders Carlsson18c582d2010-03-18 02:44:19 +00002193
Anders Carlsson7cea12f2010-03-23 04:44:10 +00002194 if (!Thunks.empty()) {
Anders Carlsson18c582d2010-03-18 02:44:19 +00002195 // We store the method names in a map to get a stable order.
2196 std::map<std::string, const CXXMethodDecl *> MethodNamesAndDecls;
2197
Anders Carlsson917229c2010-03-23 04:59:02 +00002198 for (ThunksMapTy::const_iterator I = Thunks.begin(), E = Thunks.end();
Anders Carlsson7cea12f2010-03-23 04:44:10 +00002199 I != E; ++I) {
Anders Carlsson18c582d2010-03-18 02:44:19 +00002200 const CXXMethodDecl *MD = I->first;
2201 std::string MethodName =
2202 PredefinedExpr::ComputeName(PredefinedExpr::PrettyFunctionNoVirtual,
2203 MD);
2204
2205 MethodNamesAndDecls.insert(std::make_pair(MethodName, MD));
2206 }
2207
2208 for (std::map<std::string, const CXXMethodDecl *>::const_iterator I =
2209 MethodNamesAndDecls.begin(), E = MethodNamesAndDecls.end();
2210 I != E; ++I) {
2211 const std::string &MethodName = I->first;
2212 const CXXMethodDecl *MD = I->second;
Anders Carlsson7eb99a62010-03-22 16:30:44 +00002213
Anders Carlsson917229c2010-03-23 04:59:02 +00002214 ThunkInfoVectorTy ThunksVector = Thunks[MD];
Anders Carlsson7eb99a62010-03-22 16:30:44 +00002215 std::sort(ThunksVector.begin(), ThunksVector.end());
Anders Carlsson18c582d2010-03-18 02:44:19 +00002216
2217 Out << "Thunks for '" << MethodName << "' (" << ThunksVector.size();
2218 Out << (ThunksVector.size() == 1 ? " entry" : " entries") << ").\n";
2219
2220 for (unsigned I = 0, E = ThunksVector.size(); I != E; ++I) {
2221 const ThunkInfo &Thunk = ThunksVector[I];
2222
2223 Out << llvm::format("%4d | ", I);
2224
Anders Carlsson53a47bf2010-03-22 16:10:59 +00002225 // If this function pointer has a return pointer adjustment, dump it.
2226 if (!Thunk.Return.isEmpty()) {
2227 Out << "return adjustment: " << Thunk.This.NonVirtual;
2228 Out << " non-virtual";
2229 if (Thunk.Return.VBaseOffsetOffset) {
2230 Out << ", " << Thunk.Return.VBaseOffsetOffset;
2231 Out << " vbase offset offset";
2232 }
2233
2234 if (!Thunk.This.isEmpty())
2235 Out << "\n ";
2236 }
2237
Anders Carlsson18c582d2010-03-18 02:44:19 +00002238 // If this function pointer has a 'this' pointer adjustment, dump it.
2239 if (!Thunk.This.isEmpty()) {
Anders Carlsson53a47bf2010-03-22 16:10:59 +00002240 Out << "this adjustment: ";
2241 Out << Thunk.This.NonVirtual << " non-virtual";
Anders Carlsson18c582d2010-03-18 02:44:19 +00002242
2243 if (Thunk.This.VCallOffsetOffset) {
2244 Out << ", " << Thunk.This.VCallOffsetOffset;
Anders Carlsson53a47bf2010-03-22 16:10:59 +00002245 Out << " vcall offset offset";
Anders Carlsson18c582d2010-03-18 02:44:19 +00002246 }
2247 }
2248
2249 Out << '\n';
2250 }
Anders Carlsson290c6ed2010-03-22 20:06:40 +00002251
2252 Out << '\n';
2253
Anders Carlsson18c582d2010-03-18 02:44:19 +00002254 }
2255 }
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00002256}
2257
2258}
2259
Anders Carlssoncadbc462010-11-24 23:04:03 +00002260static void
2261CollectPrimaryBases(const CXXRecordDecl *RD, ASTContext &Context,
2262 VTableBuilder::PrimaryBasesSetVectorTy &PrimaryBases) {
2263 while (RD) {
2264 const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
2265 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2266 if (PrimaryBase)
2267 PrimaryBases.insert(PrimaryBase);
2268
2269 RD = PrimaryBase;
2270 }
2271}
2272
Anders Carlsson11e51402010-04-17 20:15:18 +00002273void CodeGenVTables::ComputeMethodVTableIndices(const CXXRecordDecl *RD) {
Anders Carlssonf942ee02009-11-27 20:47:55 +00002274
2275 // Itanium C++ ABI 2.5.2:
Anders Carlsson259688c2010-02-02 03:37:46 +00002276 // The order of the virtual function pointers in a virtual table is the
2277 // order of declaration of the corresponding member functions in the class.
Anders Carlssonf942ee02009-11-27 20:47:55 +00002278 //
Anders Carlsson259688c2010-02-02 03:37:46 +00002279 // There is an entry for any virtual function declared in a class,
2280 // whether it is a new function or overrides a base class function,
2281 // unless it overrides a function from the primary base, and conversion
2282 // between their return types does not require an adjustment.
Anders Carlssonf942ee02009-11-27 20:47:55 +00002283
2284 int64_t CurrentIndex = 0;
2285
2286 const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
2287 const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
2288
2289 if (PrimaryBase) {
Anders Carlssonc920fa22009-11-30 19:43:26 +00002290 assert(PrimaryBase->isDefinition() &&
2291 "Should have the definition decl of the primary base!");
Anders Carlssonf942ee02009-11-27 20:47:55 +00002292
2293 // Since the record decl shares its vtable pointer with the primary base
2294 // we need to start counting at the end of the primary base's vtable.
2295 CurrentIndex = getNumVirtualFunctionPointers(PrimaryBase);
2296 }
Eli Friedman21517252009-12-15 03:31:17 +00002297
2298 // Collect all the primary bases, so we can check whether methods override
2299 // a method from the base.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002300 VTableBuilder::PrimaryBasesSetVectorTy PrimaryBases;
Anders Carlssoncadbc462010-11-24 23:04:03 +00002301 CollectPrimaryBases(RD, CGM.getContext(), PrimaryBases);
Eli Friedman21517252009-12-15 03:31:17 +00002302
Anders Carlssonf942ee02009-11-27 20:47:55 +00002303 const CXXDestructorDecl *ImplicitVirtualDtor = 0;
2304
2305 for (CXXRecordDecl::method_iterator i = RD->method_begin(),
2306 e = RD->method_end(); i != e; ++i) {
2307 const CXXMethodDecl *MD = *i;
2308
2309 // We only want virtual methods.
2310 if (!MD->isVirtual())
2311 continue;
2312
Anders Carlssonf942ee02009-11-27 20:47:55 +00002313 // Check if this method overrides a method in the primary base.
Anders Carlsson65b49782010-02-12 05:25:12 +00002314 if (const CXXMethodDecl *OverriddenMD =
Anders Carlsson88cf34f2010-04-10 20:39:29 +00002315 FindNearestOverriddenMethod(MD, PrimaryBases)) {
Anders Carlsson65b49782010-02-12 05:25:12 +00002316 // Check if converting from the return type of the method to the
2317 // return type of the overridden method requires conversion.
Anders Carlssoncce9ee82010-02-13 23:17:31 +00002318 if (ComputeReturnAdjustmentBaseOffset(CGM.getContext(), MD,
2319 OverriddenMD).isEmpty()) {
Anders Carlsson65b49782010-02-12 05:25:12 +00002320 // This index is shared between the index in the vtable of the primary
2321 // base class.
2322 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2323 const CXXDestructorDecl *OverriddenDD =
2324 cast<CXXDestructorDecl>(OverriddenMD);
Anders Carlssonf942ee02009-11-27 20:47:55 +00002325
Anders Carlsson65b49782010-02-12 05:25:12 +00002326 // Add both the complete and deleting entries.
Anders Carlsson11e51402010-04-17 20:15:18 +00002327 MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] =
2328 getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Complete));
2329 MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] =
2330 getMethodVTableIndex(GlobalDecl(OverriddenDD, Dtor_Deleting));
Anders Carlsson65b49782010-02-12 05:25:12 +00002331 } else {
Anders Carlsson11e51402010-04-17 20:15:18 +00002332 MethodVTableIndices[MD] = getMethodVTableIndex(OverriddenMD);
Anders Carlsson65b49782010-02-12 05:25:12 +00002333 }
2334
2335 // We don't need to add an entry for this method.
Anders Carlsson07604812010-02-12 18:14:46 +00002336 continue;
Anders Carlssonf942ee02009-11-27 20:47:55 +00002337 }
2338 }
2339
Anders Carlssonf942ee02009-11-27 20:47:55 +00002340 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
2341 if (MD->isImplicit()) {
2342 assert(!ImplicitVirtualDtor &&
2343 "Did already see an implicit virtual dtor!");
2344 ImplicitVirtualDtor = DD;
2345 continue;
2346 }
Tilmann Schellere60baf72011-03-02 20:40:50 +00002347
Anders Carlssonf942ee02009-11-27 20:47:55 +00002348 // Add the complete dtor.
Anders Carlsson11e51402010-04-17 20:15:18 +00002349 MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)] = CurrentIndex++;
Anders Carlssonf942ee02009-11-27 20:47:55 +00002350
2351 // Add the deleting dtor.
Anders Carlsson11e51402010-04-17 20:15:18 +00002352 MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)] = CurrentIndex++;
Anders Carlssonf942ee02009-11-27 20:47:55 +00002353 } else {
2354 // Add the entry.
Tilmann Schellere60baf72011-03-02 20:40:50 +00002355 MethodVTableIndices[MD] = CurrentIndex++;
Anders Carlssonf942ee02009-11-27 20:47:55 +00002356 }
2357 }
2358
2359 if (ImplicitVirtualDtor) {
2360 // Itanium C++ ABI 2.5.2:
Anders Carlssondc2dba32010-02-16 04:49:44 +00002361 // If a class has an implicitly-defined virtual destructor,
2362 // its entries come after the declared virtual function pointers.
Anders Carlssonf942ee02009-11-27 20:47:55 +00002363
2364 // Add the complete dtor.
Anders Carlsson11e51402010-04-17 20:15:18 +00002365 MethodVTableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Complete)] =
Anders Carlssonf942ee02009-11-27 20:47:55 +00002366 CurrentIndex++;
2367
2368 // Add the deleting dtor.
Anders Carlsson11e51402010-04-17 20:15:18 +00002369 MethodVTableIndices[GlobalDecl(ImplicitVirtualDtor, Dtor_Deleting)] =
Anders Carlssonf942ee02009-11-27 20:47:55 +00002370 CurrentIndex++;
2371 }
2372
2373 NumVirtualFunctionPointers[RD] = CurrentIndex;
2374}
2375
Argyrios Kyrtzidis0c34b132010-10-11 03:25:57 +00002376bool CodeGenVTables::ShouldEmitVTableInThisTU(const CXXRecordDecl *RD) {
2377 assert(RD->isDynamicClass() && "Non dynamic classes have no VTable.");
2378
2379 TemplateSpecializationKind TSK = RD->getTemplateSpecializationKind();
2380 if (TSK == TSK_ExplicitInstantiationDeclaration)
2381 return false;
2382
2383 const CXXMethodDecl *KeyFunction = CGM.getContext().getKeyFunction(RD);
2384 if (!KeyFunction)
2385 return true;
2386
2387 // Itanium C++ ABI, 5.2.6 Instantiated Templates:
2388 // An instantiation of a class template requires:
2389 // - In the object where instantiated, the virtual table...
2390 if (TSK == TSK_ImplicitInstantiation ||
2391 TSK == TSK_ExplicitInstantiationDefinition)
2392 return true;
2393
Anders Carlssona03f3a82011-01-30 20:45:54 +00002394 // If we're building with optimization, we always emit VTables since that
2395 // allows for virtual function calls to be devirtualized.
2396 // (We don't want to do this in -fapple-kext mode however).
2397 if (CGM.getCodeGenOpts().OptimizationLevel && !CGM.getLangOptions().AppleKext)
2398 return true;
2399
Argyrios Kyrtzidis0c34b132010-10-11 03:25:57 +00002400 return KeyFunction->hasBody();
2401}
2402
Anders Carlssona864caf2010-03-23 04:11:45 +00002403uint64_t CodeGenVTables::getNumVirtualFunctionPointers(const CXXRecordDecl *RD) {
Anders Carlssonf942ee02009-11-27 20:47:55 +00002404 llvm::DenseMap<const CXXRecordDecl *, uint64_t>::iterator I =
2405 NumVirtualFunctionPointers.find(RD);
2406 if (I != NumVirtualFunctionPointers.end())
2407 return I->second;
2408
Anders Carlsson11e51402010-04-17 20:15:18 +00002409 ComputeMethodVTableIndices(RD);
Anders Carlssonf942ee02009-11-27 20:47:55 +00002410
2411 I = NumVirtualFunctionPointers.find(RD);
2412 assert(I != NumVirtualFunctionPointers.end() && "Did not find entry!");
2413 return I->second;
2414}
2415
Anders Carlsson11e51402010-04-17 20:15:18 +00002416uint64_t CodeGenVTables::getMethodVTableIndex(GlobalDecl GD) {
2417 MethodVTableIndicesTy::iterator I = MethodVTableIndices.find(GD);
2418 if (I != MethodVTableIndices.end())
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002419 return I->second;
2420
Anders Carlssonfb4dda42009-11-13 17:08:56 +00002421 const CXXRecordDecl *RD = cast<CXXMethodDecl>(GD.getDecl())->getParent();
Anders Carlssonf942ee02009-11-27 20:47:55 +00002422
Anders Carlsson11e51402010-04-17 20:15:18 +00002423 ComputeMethodVTableIndices(RD);
Anders Carlssonf942ee02009-11-27 20:47:55 +00002424
Anders Carlsson11e51402010-04-17 20:15:18 +00002425 I = MethodVTableIndices.find(GD);
2426 assert(I != MethodVTableIndices.end() && "Did not find index!");
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002427 return I->second;
2428}
2429
Anders Carlssona864caf2010-03-23 04:11:45 +00002430int64_t CodeGenVTables::getVirtualBaseOffsetOffset(const CXXRecordDecl *RD,
2431 const CXXRecordDecl *VBase) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002432 ClassPairTy ClassPair(RD, VBase);
2433
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00002434 VirtualBaseClassOffsetOffsetsMapTy::iterator I =
2435 VirtualBaseClassOffsetOffsets.find(ClassPair);
2436 if (I != VirtualBaseClassOffsetOffsets.end())
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002437 return I->second;
2438
Anders Carlssondd819c92010-03-11 16:06:20 +00002439 VCallAndVBaseOffsetBuilder Builder(RD, RD, /*FinalOverriders=*/0,
Ken Dyck16ffcac2011-03-24 01:21:01 +00002440 BaseSubobject(RD, CharUnits::Zero()),
Anders Carlssondd819c92010-03-11 16:06:20 +00002441 /*BaseIsVirtual=*/false,
2442 /*OffsetInLayoutClass=*/0);
Anders Carlssondd819c92010-03-11 16:06:20 +00002443
2444 for (VCallAndVBaseOffsetBuilder::VBaseOffsetOffsetsMapTy::const_iterator I =
2445 Builder.getVBaseOffsetOffsets().begin(),
2446 E = Builder.getVBaseOffsetOffsets().end(); I != E; ++I) {
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002447 // Insert all types.
2448 ClassPairTy ClassPair(RD, I->first);
2449
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00002450 VirtualBaseClassOffsetOffsets.insert(std::make_pair(ClassPair, I->second));
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002451 }
2452
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00002453 I = VirtualBaseClassOffsetOffsets.find(ClassPair);
Anders Carlsson4cbe83c2010-03-11 07:15:17 +00002454 assert(I != VirtualBaseClassOffsetOffsets.end() && "Did not find index!");
Anders Carlsson2bb27f52009-10-11 22:13:54 +00002455
2456 return I->second;
2457}
2458
Anders Carlssonf6f24c62010-03-29 02:08:26 +00002459uint64_t
2460CodeGenVTables::getAddressPoint(BaseSubobject Base, const CXXRecordDecl *RD) {
Anders Carlssonae9e9a62010-04-08 16:18:36 +00002461 assert(AddressPoints.count(std::make_pair(RD, Base)) &&
2462 "Did not find address point!");
2463
Anders Carlssona627ac7e2010-03-29 03:38:52 +00002464 uint64_t AddressPoint = AddressPoints.lookup(std::make_pair(RD, Base));
Anders Carlssonf6f24c62010-03-29 02:08:26 +00002465 assert(AddressPoint && "Address point must not be zero!");
Anders Carlssona627ac7e2010-03-29 03:38:52 +00002466
Anders Carlssonf6f24c62010-03-29 02:08:26 +00002467 return AddressPoint;
2468}
2469
Anders Carlssoncd836f02010-03-23 17:17:29 +00002470llvm::Constant *CodeGenModule::GetAddrOfThunk(GlobalDecl GD,
Anders Carlssonfe8a9932011-02-06 17:15:43 +00002471 const ThunkInfo &Thunk) {
Anders Carlssoncd836f02010-03-23 17:17:29 +00002472 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2473
2474 // Compute the mangled name.
2475 llvm::SmallString<256> Name;
Rafael Espindola3968cd02011-02-11 02:52:17 +00002476 llvm::raw_svector_ostream Out(Name);
Anders Carlssoncd836f02010-03-23 17:17:29 +00002477 if (const CXXDestructorDecl* DD = dyn_cast<CXXDestructorDecl>(MD))
John McCall5d865c322010-08-31 07:33:07 +00002478 getCXXABI().getMangleContext().mangleCXXDtorThunk(DD, GD.getDtorType(),
Rafael Espindola3968cd02011-02-11 02:52:17 +00002479 Thunk.This, Out);
Anders Carlssoncd836f02010-03-23 17:17:29 +00002480 else
Rafael Espindola3968cd02011-02-11 02:52:17 +00002481 getCXXABI().getMangleContext().mangleThunk(MD, Thunk, Out);
2482 Out.flush();
2483
John McCall5d865c322010-08-31 07:33:07 +00002484 const llvm::Type *Ty = getTypes().GetFunctionTypeForVTable(GD);
Anders Carlssonfe8a9932011-02-06 17:15:43 +00002485 return GetOrCreateLLVMFunction(Name, Ty, GD, /*ForVTable=*/true);
Anders Carlssoncd836f02010-03-23 17:17:29 +00002486}
2487
Anders Carlssonbad991d2010-03-24 00:39:18 +00002488static llvm::Value *PerformTypeAdjustment(CodeGenFunction &CGF,
2489 llvm::Value *Ptr,
2490 int64_t NonVirtualAdjustment,
2491 int64_t VirtualAdjustment) {
2492 if (!NonVirtualAdjustment && !VirtualAdjustment)
2493 return Ptr;
2494
2495 const llvm::Type *Int8PtrTy =
2496 llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
2497
2498 llvm::Value *V = CGF.Builder.CreateBitCast(Ptr, Int8PtrTy);
2499
2500 if (NonVirtualAdjustment) {
2501 // Do the non-virtual adjustment.
2502 V = CGF.Builder.CreateConstInBoundsGEP1_64(V, NonVirtualAdjustment);
2503 }
2504
2505 if (VirtualAdjustment) {
2506 const llvm::Type *PtrDiffTy =
2507 CGF.ConvertType(CGF.getContext().getPointerDiffType());
2508
2509 // Do the virtual adjustment.
2510 llvm::Value *VTablePtrPtr =
2511 CGF.Builder.CreateBitCast(V, Int8PtrTy->getPointerTo());
2512
2513 llvm::Value *VTablePtr = CGF.Builder.CreateLoad(VTablePtrPtr);
2514
2515 llvm::Value *OffsetPtr =
2516 CGF.Builder.CreateConstInBoundsGEP1_64(VTablePtr, VirtualAdjustment);
2517
2518 OffsetPtr = CGF.Builder.CreateBitCast(OffsetPtr, PtrDiffTy->getPointerTo());
2519
2520 // Load the adjustment offset from the vtable.
2521 llvm::Value *Offset = CGF.Builder.CreateLoad(OffsetPtr);
2522
2523 // Adjust our pointer.
2524 V = CGF.Builder.CreateInBoundsGEP(V, Offset);
2525 }
2526
2527 // Cast back to the original type.
2528 return CGF.Builder.CreateBitCast(V, Ptr->getType());
2529}
2530
John McCallc8bd9c22010-08-04 23:46:35 +00002531static void setThunkVisibility(CodeGenModule &CGM, const CXXMethodDecl *MD,
2532 const ThunkInfo &Thunk, llvm::Function *Fn) {
Anders Carlssonc6a47892011-01-29 19:39:23 +00002533 CGM.setGlobalVisibility(Fn, MD);
John McCallc8bd9c22010-08-04 23:46:35 +00002534
John McCallb3732bb2010-08-12 23:36:15 +00002535 if (!CGM.getCodeGenOpts().HiddenWeakVTables)
2536 return;
2537
John McCallc8bd9c22010-08-04 23:46:35 +00002538 // If the thunk has weak/linkonce linkage, but the function must be
2539 // emitted in every translation unit that references it, then we can
2540 // emit its thunks with hidden visibility, since its thunks must be
2541 // emitted when the function is.
2542
John McCall5513fce92010-08-05 20:39:18 +00002543 // This follows CodeGenModule::setTypeVisibility; see the comments
2544 // there for explanation.
John McCallc8bd9c22010-08-04 23:46:35 +00002545
2546 if ((Fn->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage &&
2547 Fn->getLinkage() != llvm::GlobalVariable::WeakODRLinkage) ||
2548 Fn->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
2549 return;
2550
Douglas Gregor1baf38f2011-03-26 12:10:19 +00002551 if (MD->getExplicitVisibility())
John McCallc8bd9c22010-08-04 23:46:35 +00002552 return;
2553
2554 switch (MD->getTemplateSpecializationKind()) {
John McCallc8bd9c22010-08-04 23:46:35 +00002555 case TSK_ExplicitInstantiationDefinition:
2556 case TSK_ExplicitInstantiationDeclaration:
2557 return;
2558
John McCallc8bd9c22010-08-04 23:46:35 +00002559 case TSK_Undeclared:
2560 break;
2561
John McCall5513fce92010-08-05 20:39:18 +00002562 case TSK_ExplicitSpecialization:
John McCallc8bd9c22010-08-04 23:46:35 +00002563 case TSK_ImplicitInstantiation:
John McCallb3732bb2010-08-12 23:36:15 +00002564 if (!CGM.getCodeGenOpts().HiddenWeakTemplateVTables)
John McCall5513fce92010-08-05 20:39:18 +00002565 return;
John McCallc8bd9c22010-08-04 23:46:35 +00002566 break;
2567 }
2568
2569 // If there's an explicit definition, and that definition is
2570 // out-of-line, then we can't assume that all users will have a
2571 // definition to emit.
2572 const FunctionDecl *Def = 0;
2573 if (MD->hasBody(Def) && Def->isOutOfLine())
2574 return;
2575
2576 Fn->setVisibility(llvm::GlobalValue::HiddenVisibility);
2577}
2578
John McCall5fe00962011-03-09 07:12:35 +00002579#ifndef NDEBUG
2580static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
2581 const ABIArgInfo &infoR, CanQualType typeR) {
2582 return (infoL.getKind() == infoR.getKind() &&
2583 (typeL == typeR ||
2584 (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
2585 (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
2586}
2587#endif
2588
John McCalla738c252011-03-09 04:27:21 +00002589void CodeGenFunction::GenerateThunk(llvm::Function *Fn,
2590 const CGFunctionInfo &FnInfo,
2591 GlobalDecl GD, const ThunkInfo &Thunk) {
Anders Carlssonbad991d2010-03-24 00:39:18 +00002592 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2593 const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
2594 QualType ResultType = FPT->getResultType();
2595 QualType ThisType = MD->getThisType(getContext());
2596
2597 FunctionArgList FunctionArgs;
2598
2599 // FIXME: It would be nice if more of this code could be shared with
2600 // CodeGenFunction::GenerateCode.
2601
2602 // Create the implicit 'this' parameter declaration.
John McCall5d865c322010-08-31 07:33:07 +00002603 CurGD = GD;
2604 CGM.getCXXABI().BuildInstanceFunctionParams(*this, ResultType, FunctionArgs);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002605
2606 // Add the rest of the parameters.
2607 for (FunctionDecl::param_const_iterator I = MD->param_begin(),
2608 E = MD->param_end(); I != E; ++I) {
2609 ParmVarDecl *Param = *I;
2610
John McCalla738c252011-03-09 04:27:21 +00002611 FunctionArgs.push_back(Param);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002612 }
Tilmann Scheller99cc30c2011-03-02 21:36:49 +00002613
John McCalla738c252011-03-09 04:27:21 +00002614 StartFunction(GlobalDecl(), ResultType, Fn, FnInfo, FunctionArgs,
2615 SourceLocation());
Anders Carlssonbad991d2010-03-24 00:39:18 +00002616
John McCall5d865c322010-08-31 07:33:07 +00002617 CGM.getCXXABI().EmitInstanceFunctionProlog(*this);
2618
Anders Carlssonbad991d2010-03-24 00:39:18 +00002619 // Adjust the 'this' pointer if necessary.
2620 llvm::Value *AdjustedThisPtr =
2621 PerformTypeAdjustment(*this, LoadCXXThis(),
2622 Thunk.This.NonVirtual,
2623 Thunk.This.VCallOffsetOffset);
2624
2625 CallArgList CallArgs;
2626
2627 // Add our adjusted 'this' pointer.
2628 CallArgs.push_back(std::make_pair(RValue::get(AdjustedThisPtr), ThisType));
2629
2630 // Add the rest of the parameters.
2631 for (FunctionDecl::param_const_iterator I = MD->param_begin(),
2632 E = MD->param_end(); I != E; ++I) {
John McCall32ea9692011-03-11 20:59:21 +00002633 ParmVarDecl *param = *I;
2634 EmitDelegateCallArg(CallArgs, param);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002635 }
2636
2637 // Get our callee.
2638 const llvm::Type *Ty =
John McCall5d865c322010-08-31 07:33:07 +00002639 CGM.getTypes().GetFunctionType(CGM.getTypes().getFunctionInfo(GD),
Anders Carlssonbad991d2010-03-24 00:39:18 +00002640 FPT->isVariadic());
Anders Carlssonfe8a9932011-02-06 17:15:43 +00002641 llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002642
John McCalla738c252011-03-09 04:27:21 +00002643#ifndef NDEBUG
2644 const CGFunctionInfo &CallFnInfo =
2645 CGM.getTypes().getFunctionInfo(ResultType, CallArgs, FPT->getExtInfo());
John McCall5fe00962011-03-09 07:12:35 +00002646 assert(CallFnInfo.getRegParm() == FnInfo.getRegParm() &&
2647 CallFnInfo.isNoReturn() == FnInfo.isNoReturn() &&
2648 CallFnInfo.getCallingConvention() == FnInfo.getCallingConvention());
2649 assert(similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
2650 FnInfo.getReturnInfo(), FnInfo.getReturnType()));
2651 assert(CallFnInfo.arg_size() == FnInfo.arg_size());
2652 for (unsigned i = 0, e = FnInfo.arg_size(); i != e; ++i)
2653 assert(similar(CallFnInfo.arg_begin()[i].info,
2654 CallFnInfo.arg_begin()[i].type,
2655 FnInfo.arg_begin()[i].info, FnInfo.arg_begin()[i].type));
John McCalla738c252011-03-09 04:27:21 +00002656#endif
Anders Carlssonbad991d2010-03-24 00:39:18 +00002657
Douglas Gregoraa2ac802010-05-20 05:54:35 +00002658 // Determine whether we have a return value slot to use.
2659 ReturnValueSlot Slot;
2660 if (!ResultType->isVoidType() &&
2661 FnInfo.getReturnInfo().getKind() == ABIArgInfo::Indirect &&
2662 hasAggregateLLVMType(CurFnInfo->getReturnType()))
2663 Slot = ReturnValueSlot(ReturnValue, ResultType.isVolatileQualified());
2664
Anders Carlssonbad991d2010-03-24 00:39:18 +00002665 // Now emit our call.
Douglas Gregoraa2ac802010-05-20 05:54:35 +00002666 RValue RV = EmitCall(FnInfo, Callee, Slot, CallArgs, MD);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002667
2668 if (!Thunk.Return.isEmpty()) {
2669 // Emit the return adjustment.
2670 bool NullCheckValue = !ResultType->isReferenceType();
2671
2672 llvm::BasicBlock *AdjustNull = 0;
2673 llvm::BasicBlock *AdjustNotNull = 0;
2674 llvm::BasicBlock *AdjustEnd = 0;
2675
2676 llvm::Value *ReturnValue = RV.getScalarVal();
2677
2678 if (NullCheckValue) {
2679 AdjustNull = createBasicBlock("adjust.null");
2680 AdjustNotNull = createBasicBlock("adjust.notnull");
2681 AdjustEnd = createBasicBlock("adjust.end");
2682
2683 llvm::Value *IsNull = Builder.CreateIsNull(ReturnValue);
2684 Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);
2685 EmitBlock(AdjustNotNull);
2686 }
2687
2688 ReturnValue = PerformTypeAdjustment(*this, ReturnValue,
2689 Thunk.Return.NonVirtual,
2690 Thunk.Return.VBaseOffsetOffset);
2691
2692 if (NullCheckValue) {
2693 Builder.CreateBr(AdjustEnd);
2694 EmitBlock(AdjustNull);
2695 Builder.CreateBr(AdjustEnd);
2696 EmitBlock(AdjustEnd);
2697
2698 llvm::PHINode *PHI = Builder.CreatePHI(ReturnValue->getType());
2699 PHI->reserveOperandSpace(2);
2700 PHI->addIncoming(ReturnValue, AdjustNotNull);
2701 PHI->addIncoming(llvm::Constant::getNullValue(ReturnValue->getType()),
2702 AdjustNull);
2703 ReturnValue = PHI;
2704 }
2705
2706 RV = RValue::get(ReturnValue);
2707 }
2708
Douglas Gregoraa2ac802010-05-20 05:54:35 +00002709 if (!ResultType->isVoidType() && Slot.isNull())
John McCallad7c5c12011-02-08 08:22:06 +00002710 CGM.getCXXABI().EmitReturnFromThunk(*this, RV, ResultType);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002711
2712 FinishFunction();
2713
Anders Carlssonbad991d2010-03-24 00:39:18 +00002714 // Set the right linkage.
John McCall7cb02202010-05-25 04:30:21 +00002715 CGM.setFunctionLinkage(MD, Fn);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002716
2717 // Set the right visibility.
John McCallc8bd9c22010-08-04 23:46:35 +00002718 setThunkVisibility(CGM, MD, Thunk, Fn);
Anders Carlssonbad991d2010-03-24 00:39:18 +00002719}
2720
Anders Carlsson8b021832011-02-06 18:31:40 +00002721void CodeGenVTables::EmitThunk(GlobalDecl GD, const ThunkInfo &Thunk,
2722 bool UseAvailableExternallyLinkage)
Anders Carlsson5c5abad2010-03-23 16:36:50 +00002723{
John McCalla738c252011-03-09 04:27:21 +00002724 const CGFunctionInfo &FnInfo = CGM.getTypes().getFunctionInfo(GD);
2725
2726 // FIXME: re-use FnInfo in this computation.
Anders Carlssonfe8a9932011-02-06 17:15:43 +00002727 llvm::Constant *Entry = CGM.GetAddrOfThunk(GD, Thunk);
Anders Carlssoncd836f02010-03-23 17:17:29 +00002728
Anders Carlsson55e89f82010-03-23 18:18:41 +00002729 // Strip off a bitcast if we got one back.
Anders Carlsson4a3cdf52010-03-24 00:35:44 +00002730 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Anders Carlsson55e89f82010-03-23 18:18:41 +00002731 assert(CE->getOpcode() == llvm::Instruction::BitCast);
Anders Carlsson4a3cdf52010-03-24 00:35:44 +00002732 Entry = CE->getOperand(0);
Anders Carlsson55e89f82010-03-23 18:18:41 +00002733 }
2734
Anders Carlsson55e89f82010-03-23 18:18:41 +00002735 // There's already a declaration with the same name, check if it has the same
2736 // type or if we need to replace it.
Anders Carlsson4a3cdf52010-03-24 00:35:44 +00002737 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() !=
John McCall5d865c322010-08-31 07:33:07 +00002738 CGM.getTypes().GetFunctionTypeForVTable(GD)) {
Anders Carlsson4a3cdf52010-03-24 00:35:44 +00002739 llvm::GlobalValue *OldThunkFn = cast<llvm::GlobalValue>(Entry);
Anders Carlsson55e89f82010-03-23 18:18:41 +00002740
2741 // If the types mismatch then we have to rewrite the definition.
2742 assert(OldThunkFn->isDeclaration() &&
2743 "Shouldn't replace non-declaration");
2744
2745 // Remove the name from the old thunk function and get a new thunk.
2746 OldThunkFn->setName(llvm::StringRef());
Anders Carlssonfe8a9932011-02-06 17:15:43 +00002747 Entry = CGM.GetAddrOfThunk(GD, Thunk);
Anders Carlsson55e89f82010-03-23 18:18:41 +00002748
2749 // If needed, replace the old thunk with a bitcast.
2750 if (!OldThunkFn->use_empty()) {
2751 llvm::Constant *NewPtrForOldDecl =
Anders Carlsson4a3cdf52010-03-24 00:35:44 +00002752 llvm::ConstantExpr::getBitCast(Entry, OldThunkFn->getType());
Anders Carlsson55e89f82010-03-23 18:18:41 +00002753 OldThunkFn->replaceAllUsesWith(NewPtrForOldDecl);
2754 }
2755
2756 // Remove the old thunk.
2757 OldThunkFn->eraseFromParent();
2758 }
Anders Carlssonbad991d2010-03-24 00:39:18 +00002759
Anders Carlssonbad991d2010-03-24 00:39:18 +00002760 llvm::Function *ThunkFn = cast<llvm::Function>(Entry);
Anders Carlsson8b021832011-02-06 18:31:40 +00002761
2762 if (!ThunkFn->isDeclaration()) {
2763 if (UseAvailableExternallyLinkage) {
2764 // There is already a thunk emitted for this function, do nothing.
2765 return;
2766 }
2767
Anders Carlssone866d442011-02-06 20:09:44 +00002768 // If a function has a body, it should have available_externally linkage.
2769 assert(ThunkFn->hasAvailableExternallyLinkage() &&
2770 "Function should have available_externally linkage!");
2771
2772 // Change the linkage.
2773 CGM.setFunctionLinkage(cast<CXXMethodDecl>(GD.getDecl()), ThunkFn);
2774 return;
Anders Carlsson8b021832011-02-06 18:31:40 +00002775 }
2776
2777 // Actually generate the thunk body.
John McCalla738c252011-03-09 04:27:21 +00002778 CodeGenFunction(CGM).GenerateThunk(ThunkFn, FnInfo, GD, Thunk);
Anders Carlsson8b021832011-02-06 18:31:40 +00002779
2780 if (UseAvailableExternallyLinkage)
2781 ThunkFn->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
2782}
2783
2784void CodeGenVTables::MaybeEmitThunkAvailableExternally(GlobalDecl GD,
2785 const ThunkInfo &Thunk) {
2786 // We only want to do this when building with optimizations.
2787 if (!CGM.getCodeGenOpts().OptimizationLevel)
2788 return;
2789
2790 // We can't emit thunks for member functions with incomplete types.
2791 const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
2792 if (CGM.getTypes().VerifyFuncTypeComplete(MD->getType().getTypePtr()))
2793 return;
2794
2795 EmitThunk(GD, Thunk, /*UseAvailableExternallyLinkage=*/true);
Anders Carlsson5c5abad2010-03-23 16:36:50 +00002796}
2797
Anders Carlsson917229c2010-03-23 04:59:02 +00002798void CodeGenVTables::EmitThunks(GlobalDecl GD)
2799{
Anders Carlsson5c5abad2010-03-23 16:36:50 +00002800 const CXXMethodDecl *MD =
2801 cast<CXXMethodDecl>(GD.getDecl())->getCanonicalDecl();
2802
2803 // We don't need to generate thunks for the base destructor.
2804 if (isa<CXXDestructorDecl>(MD) && GD.getDtorType() == Dtor_Base)
2805 return;
2806
2807 const CXXRecordDecl *RD = MD->getParent();
2808
Anders Carlssone90954d2010-03-24 16:42:11 +00002809 // Compute VTable related info for this class.
John McCall6a7f9f52010-06-02 21:22:02 +00002810 ComputeVTableRelatedInformation(RD, false);
Anders Carlssone90954d2010-03-24 16:42:11 +00002811
Anders Carlsson5c5abad2010-03-23 16:36:50 +00002812 ThunksMapTy::const_iterator I = Thunks.find(MD);
2813 if (I == Thunks.end()) {
Anders Carlssone90954d2010-03-24 16:42:11 +00002814 // We did not find a thunk for this method.
2815 return;
Anders Carlsson5c5abad2010-03-23 16:36:50 +00002816 }
Anders Carlssone90954d2010-03-24 16:42:11 +00002817
Anders Carlsson5c5abad2010-03-23 16:36:50 +00002818 const ThunkInfoVectorTy &ThunkInfoVector = I->second;
2819 for (unsigned I = 0, E = ThunkInfoVector.size(); I != E; ++I)
Anders Carlsson8b021832011-02-06 18:31:40 +00002820 EmitThunk(GD, ThunkInfoVector[I], /*UseAvailableExternallyLinkage=*/false);
Anders Carlsson917229c2010-03-23 04:59:02 +00002821}
2822
John McCall6a7f9f52010-06-02 21:22:02 +00002823void CodeGenVTables::ComputeVTableRelatedInformation(const CXXRecordDecl *RD,
2824 bool RequireVTable) {
2825 VTableLayoutData &Entry = VTableLayoutMap[RD];
Douglas Gregor88d292c2010-05-13 16:44:06 +00002826
2827 // We may need to generate a definition for this vtable.
John McCall6a7f9f52010-06-02 21:22:02 +00002828 if (RequireVTable && !Entry.getInt()) {
Argyrios Kyrtzidis0c34b132010-10-11 03:25:57 +00002829 if (ShouldEmitVTableInThisTU(RD))
John McCall6a7f9f52010-06-02 21:22:02 +00002830 CGM.DeferredVTables.push_back(RD);
2831
2832 Entry.setInt(true);
2833 }
2834
2835 // Check if we've computed this information before.
2836 if (Entry.getPointer())
2837 return;
Douglas Gregor88d292c2010-05-13 16:44:06 +00002838
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002839 VTableBuilder Builder(*this, RD, 0, /*MostDerivedClassIsVirtual=*/0, RD);
Anders Carlssone90954d2010-03-24 16:42:11 +00002840
2841 // Add the VTable layout.
2842 uint64_t NumVTableComponents = Builder.getNumVTableComponents();
Fariborz Jahanian9f9438b2011-01-28 23:42:29 +00002843 // -fapple-kext adds an extra entry at end of vtbl.
2844 bool IsAppleKext = CGM.getContext().getLangOptions().AppleKext;
2845 if (IsAppleKext)
2846 NumVTableComponents += 1;
2847
John McCall6a7f9f52010-06-02 21:22:02 +00002848 uint64_t *LayoutData = new uint64_t[NumVTableComponents + 1];
Fariborz Jahanian9f9438b2011-01-28 23:42:29 +00002849 if (IsAppleKext)
2850 LayoutData[NumVTableComponents] = 0;
John McCall6a7f9f52010-06-02 21:22:02 +00002851 Entry.setPointer(LayoutData);
Anders Carlssone90954d2010-03-24 16:42:11 +00002852
2853 // Store the number of components.
2854 LayoutData[0] = NumVTableComponents;
2855
2856 // Store the components.
2857 std::copy(Builder.vtable_components_data_begin(),
2858 Builder.vtable_components_data_end(),
2859 &LayoutData[1]);
2860
2861 // Add the known thunks.
2862 Thunks.insert(Builder.thunks_begin(), Builder.thunks_end());
2863
Anders Carlsson9a97e2e2010-03-29 01:38:05 +00002864 // Add the thunks needed in this vtable.
2865 assert(!VTableThunksMap.count(RD) &&
2866 "Thunks already exists for this vtable!");
2867
2868 VTableThunksTy &VTableThunks = VTableThunksMap[RD];
2869 VTableThunks.append(Builder.vtable_thunks_begin(),
2870 Builder.vtable_thunks_end());
2871
2872 // Sort them.
2873 std::sort(VTableThunks.begin(), VTableThunks.end());
2874
Anders Carlssond03325c2010-03-25 00:51:13 +00002875 // Add the address points.
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002876 for (VTableBuilder::AddressPointsMapTy::const_iterator I =
Anders Carlssond03325c2010-03-25 00:51:13 +00002877 Builder.address_points_begin(), E = Builder.address_points_end();
2878 I != E; ++I) {
2879
2880 uint64_t &AddressPoint = AddressPoints[std::make_pair(RD, I->first)];
2881
2882 // Check if we already have the address points for this base.
2883 assert(!AddressPoint && "Address point already exists for this base!");
2884
2885 AddressPoint = I->second;
2886 }
2887
Anders Carlssone90954d2010-03-24 16:42:11 +00002888 // If we don't have the vbase information for this class, insert it.
2889 // getVirtualBaseOffsetOffset will compute it separately without computing
2890 // the rest of the vtable related information.
2891 if (!RD->getNumVBases())
2892 return;
2893
2894 const RecordType *VBaseRT =
2895 RD->vbases_begin()->getType()->getAs<RecordType>();
2896 const CXXRecordDecl *VBase = cast<CXXRecordDecl>(VBaseRT->getDecl());
2897
2898 if (VirtualBaseClassOffsetOffsets.count(std::make_pair(RD, VBase)))
2899 return;
2900
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002901 for (VTableBuilder::VBaseOffsetOffsetsMapTy::const_iterator I =
Anders Carlssone90954d2010-03-24 16:42:11 +00002902 Builder.getVBaseOffsetOffsets().begin(),
2903 E = Builder.getVBaseOffsetOffsets().end(); I != E; ++I) {
2904 // Insert all types.
2905 ClassPairTy ClassPair(RD, I->first);
2906
2907 VirtualBaseClassOffsetOffsets.insert(std::make_pair(ClassPair, I->second));
2908 }
2909}
2910
Anders Carlssona4147142010-03-25 15:26:28 +00002911llvm::Constant *
2912CodeGenVTables::CreateVTableInitializer(const CXXRecordDecl *RD,
2913 const uint64_t *Components,
2914 unsigned NumComponents,
2915 const VTableThunksTy &VTableThunks) {
2916 llvm::SmallVector<llvm::Constant *, 64> Inits;
2917
2918 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
2919
Anders Carlssona5736bd2010-03-25 16:49:53 +00002920 const llvm::Type *PtrDiffTy =
2921 CGM.getTypes().ConvertType(CGM.getContext().getPointerDiffType());
2922
2923 QualType ClassType = CGM.getContext().getTagDeclType(RD);
2924 llvm::Constant *RTTI = CGM.GetAddrOfRTTIDescriptor(ClassType);
2925
2926 unsigned NextVTableThunkIndex = 0;
2927
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002928 llvm::Constant* PureVirtualFn = 0;
2929
Anders Carlssona4147142010-03-25 15:26:28 +00002930 for (unsigned I = 0; I != NumComponents; ++I) {
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002931 VTableComponent Component =
2932 VTableComponent::getFromOpaqueInteger(Components[I]);
Anders Carlssona5736bd2010-03-25 16:49:53 +00002933
2934 llvm::Constant *Init = 0;
2935
2936 switch (Component.getKind()) {
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002937 case VTableComponent::CK_VCallOffset:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002938 Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVCallOffset());
2939 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
2940 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002941 case VTableComponent::CK_VBaseOffset:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002942 Init = llvm::ConstantInt::get(PtrDiffTy, Component.getVBaseOffset());
2943 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
2944 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002945 case VTableComponent::CK_OffsetToTop:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002946 Init = llvm::ConstantInt::get(PtrDiffTy, Component.getOffsetToTop());
2947 Init = llvm::ConstantExpr::getIntToPtr(Init, Int8PtrTy);
2948 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002949 case VTableComponent::CK_RTTI:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002950 Init = llvm::ConstantExpr::getBitCast(RTTI, Int8PtrTy);
2951 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002952 case VTableComponent::CK_FunctionPointer:
2953 case VTableComponent::CK_CompleteDtorPointer:
2954 case VTableComponent::CK_DeletingDtorPointer: {
Anders Carlssona5736bd2010-03-25 16:49:53 +00002955 GlobalDecl GD;
2956
2957 // Get the right global decl.
2958 switch (Component.getKind()) {
2959 default:
2960 llvm_unreachable("Unexpected vtable component kind");
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002961 case VTableComponent::CK_FunctionPointer:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002962 GD = Component.getFunctionDecl();
2963 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002964 case VTableComponent::CK_CompleteDtorPointer:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002965 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Complete);
2966 break;
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00002967 case VTableComponent::CK_DeletingDtorPointer:
Anders Carlssona5736bd2010-03-25 16:49:53 +00002968 GD = GlobalDecl(Component.getDestructorDecl(), Dtor_Deleting);
2969 break;
2970 }
2971
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002972 if (cast<CXXMethodDecl>(GD.getDecl())->isPure()) {
2973 // We have a pure virtual member function.
2974 if (!PureVirtualFn) {
2975 const llvm::FunctionType *Ty =
2976 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2977 /*isVarArg=*/false);
2978 PureVirtualFn =
2979 CGM.CreateRuntimeFunction(Ty, "__cxa_pure_virtual");
2980 PureVirtualFn = llvm::ConstantExpr::getBitCast(PureVirtualFn,
2981 Int8PtrTy);
2982 }
Anders Carlssona5736bd2010-03-25 16:49:53 +00002983
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002984 Init = PureVirtualFn;
Anders Carlssona5736bd2010-03-25 16:49:53 +00002985 } else {
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002986 // Check if we should use a thunk.
2987 if (NextVTableThunkIndex < VTableThunks.size() &&
2988 VTableThunks[NextVTableThunkIndex].first == I) {
2989 const ThunkInfo &Thunk = VTableThunks[NextVTableThunkIndex].second;
Anders Carlssona5736bd2010-03-25 16:49:53 +00002990
Anders Carlssonfe8a9932011-02-06 17:15:43 +00002991 Init = CGM.GetAddrOfThunk(GD, Thunk);
Anders Carlsson8b021832011-02-06 18:31:40 +00002992 MaybeEmitThunkAvailableExternally(GD, Thunk);
2993
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002994 NextVTableThunkIndex++;
2995 } else {
John McCall5d865c322010-08-31 07:33:07 +00002996 const llvm::Type *Ty = CGM.getTypes().GetFunctionTypeForVTable(GD);
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002997
Anders Carlsson3c239482011-02-05 04:35:53 +00002998 Init = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true);
Anders Carlssoncb6207f2010-03-29 05:40:50 +00002999 }
3000
3001 Init = llvm::ConstantExpr::getBitCast(Init, Int8PtrTy);
Anders Carlssona5736bd2010-03-25 16:49:53 +00003002 }
Anders Carlssona5736bd2010-03-25 16:49:53 +00003003 break;
3004 }
3005
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00003006 case VTableComponent::CK_UnusedFunctionPointer:
Anders Carlssona5736bd2010-03-25 16:49:53 +00003007 Init = llvm::ConstantExpr::getNullValue(Int8PtrTy);
3008 break;
3009 };
Anders Carlssona4147142010-03-25 15:26:28 +00003010
3011 Inits.push_back(Init);
3012 }
3013
3014 llvm::ArrayType *ArrayType = llvm::ArrayType::get(Int8PtrTy, NumComponents);
3015 return llvm::ConstantArray::get(ArrayType, Inits.data(), Inits.size());
3016}
3017
Anders Carlssona086edc2010-03-30 03:35:35 +00003018llvm::GlobalVariable *CodeGenVTables::GetAddrOfVTable(const CXXRecordDecl *RD) {
Anders Carlssonb35ea552010-03-24 03:57:14 +00003019 llvm::SmallString<256> OutName;
Rafael Espindola3968cd02011-02-11 02:52:17 +00003020 llvm::raw_svector_ostream Out(OutName);
3021 CGM.getCXXABI().getMangleContext().mangleCXXVTable(RD, Out);
3022 Out.flush();
Anders Carlssonb35ea552010-03-24 03:57:14 +00003023 llvm::StringRef Name = OutName.str();
Mike Stumpaa51ad62009-11-19 04:04:36 +00003024
John McCall6a7f9f52010-06-02 21:22:02 +00003025 ComputeVTableRelatedInformation(RD, true);
Anders Carlssone90954d2010-03-24 16:42:11 +00003026
Anders Carlssonb35ea552010-03-24 03:57:14 +00003027 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
Anders Carlssone90954d2010-03-24 16:42:11 +00003028 llvm::ArrayType *ArrayType =
3029 llvm::ArrayType::get(Int8PtrTy, getNumVTableComponents(RD));
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003030
Rafael Espindola5674c642011-01-11 21:10:26 +00003031 llvm::GlobalVariable *GV =
Anders Carlsson93be9a92011-01-29 18:25:07 +00003032 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType,
3033 llvm::GlobalValue::ExternalLinkage);
Rafael Espindolafacb7d02011-01-15 08:23:14 +00003034 GV->setUnnamedAddr(true);
Rafael Espindola5674c642011-01-11 21:10:26 +00003035 return GV;
Mike Stumpd846d082009-11-10 07:44:33 +00003036}
Mike Stumpeac45592009-11-11 20:26:26 +00003037
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003038void
3039CodeGenVTables::EmitVTableDefinition(llvm::GlobalVariable *VTable,
3040 llvm::GlobalVariable::LinkageTypes Linkage,
3041 const CXXRecordDecl *RD) {
3042 // Dump the vtable layout if necessary.
Anders Carlsson11e51402010-04-17 20:15:18 +00003043 if (CGM.getLangOptions().DumpVTableLayouts) {
Anders Carlssonbe1b9cb2010-04-10 19:13:06 +00003044 VTableBuilder Builder(*this, RD, 0, /*MostDerivedClassIsVirtual=*/0, RD);
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003045
3046 Builder.dumpLayout(llvm::errs());
3047 }
3048
3049 assert(VTableThunksMap.count(RD) &&
3050 "No thunk status for this record decl!");
3051
3052 const VTableThunksTy& Thunks = VTableThunksMap[RD];
3053
3054 // Create and set the initializer.
3055 llvm::Constant *Init =
3056 CreateVTableInitializer(RD, getVTableComponentsData(RD),
3057 getNumVTableComponents(RD), Thunks);
3058 VTable->setInitializer(Init);
Anders Carlssoncb6207f2010-03-29 05:40:50 +00003059
3060 // Set the correct linkage.
3061 VTable->setLinkage(Linkage);
Douglas Gregor4f6e8de2010-06-14 23:41:45 +00003062
3063 // Set the right visibility.
Anders Carlsson265aa7c2011-01-29 20:24:48 +00003064 CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForVTable);
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003065}
3066
Anders Carlsson0534b022010-03-25 00:35:49 +00003067llvm::GlobalVariable *
3068CodeGenVTables::GenerateConstructionVTable(const CXXRecordDecl *RD,
Anders Carlssona208b392010-03-26 03:56:54 +00003069 const BaseSubobject &Base,
3070 bool BaseIsVirtual,
John McCall358d0562011-03-27 09:00:25 +00003071 llvm::GlobalVariable::LinkageTypes Linkage,
Anders Carlssona208b392010-03-26 03:56:54 +00003072 VTableAddressPointsMapTy& AddressPoints) {
Ken Dyck16ffcac2011-03-24 01:21:01 +00003073 VTableBuilder Builder(*this, Base.getBase(),
3074 CGM.getContext().toBits(Base.getBaseOffset()),
Anders Carlssona4147142010-03-25 15:26:28 +00003075 /*MostDerivedClassIsVirtual=*/BaseIsVirtual, RD);
3076
Anders Carlssona5736bd2010-03-25 16:49:53 +00003077 // Dump the vtable layout if necessary.
Anders Carlsson11e51402010-04-17 20:15:18 +00003078 if (CGM.getLangOptions().DumpVTableLayouts)
Anders Carlssona5736bd2010-03-25 16:49:53 +00003079 Builder.dumpLayout(llvm::errs());
3080
3081 // Add the address points.
Anders Carlssona208b392010-03-26 03:56:54 +00003082 AddressPoints.insert(Builder.address_points_begin(),
3083 Builder.address_points_end());
Anders Carlssona4147142010-03-25 15:26:28 +00003084
3085 // Get the mangled construction vtable name.
3086 llvm::SmallString<256> OutName;
Rafael Espindola3968cd02011-02-11 02:52:17 +00003087 llvm::raw_svector_ostream Out(OutName);
John McCall5d865c322010-08-31 07:33:07 +00003088 CGM.getCXXABI().getMangleContext().
Ken Dyck16ffcac2011-03-24 01:21:01 +00003089 mangleCXXCtorVTable(RD, Base.getBaseOffset().getQuantity(), Base.getBase(),
3090 Out);
Rafael Espindola3968cd02011-02-11 02:52:17 +00003091 Out.flush();
Anders Carlssona4147142010-03-25 15:26:28 +00003092 llvm::StringRef Name = OutName.str();
3093
3094 const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
3095 llvm::ArrayType *ArrayType =
3096 llvm::ArrayType::get(Int8PtrTy, Builder.getNumVTableComponents());
3097
3098 // Create the variable that will hold the construction vtable.
3099 llvm::GlobalVariable *VTable =
John McCall358d0562011-03-27 09:00:25 +00003100 CGM.CreateOrReplaceCXXRuntimeVariable(Name, ArrayType, Linkage);
3101 CGM.setTypeVisibility(VTable, RD, CodeGenModule::TVK_ForConstructionVTable);
3102
3103 // V-tables are always unnamed_addr.
3104 VTable->setUnnamedAddr(true);
Anders Carlssona4147142010-03-25 15:26:28 +00003105
3106 // Add the thunks.
3107 VTableThunksTy VTableThunks;
3108 VTableThunks.append(Builder.vtable_thunks_begin(),
3109 Builder.vtable_thunks_end());
3110
Anders Carlsson848d86e2010-03-29 01:28:05 +00003111 // Sort them.
3112 std::sort(VTableThunks.begin(), VTableThunks.end());
3113
Anders Carlssona4147142010-03-25 15:26:28 +00003114 // Create and set the initializer.
3115 llvm::Constant *Init =
3116 CreateVTableInitializer(Base.getBase(),
3117 Builder.vtable_components_data_begin(),
3118 Builder.getNumVTableComponents(), VTableThunks);
3119 VTable->setInitializer(Init);
3120
Anders Carlsson0534b022010-03-25 00:35:49 +00003121 return VTable;
3122}
3123
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003124void
3125CodeGenVTables::GenerateClassData(llvm::GlobalVariable::LinkageTypes Linkage,
3126 const CXXRecordDecl *RD) {
Anders Carlsson11e51402010-04-17 20:15:18 +00003127 llvm::GlobalVariable *&VTable = VTables[RD];
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003128 if (VTable) {
Anders Carlsson11e51402010-04-17 20:15:18 +00003129 assert(VTable->getInitializer() && "VTable doesn't have a definition!");
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003130 return;
3131 }
3132
Anders Carlssona086edc2010-03-30 03:35:35 +00003133 VTable = GetAddrOfVTable(RD);
3134 EmitVTableDefinition(VTable, Linkage, RD);
3135
Anders Carlsson883fc722011-01-29 19:16:51 +00003136 if (RD->getNumVBases()) {
3137 llvm::GlobalVariable *VTT = GetAddrOfVTT(RD);
3138 EmitVTTDefinition(VTT, Linkage, RD);
3139 }
Douglas Gregoreadd3ca2010-04-08 15:52:03 +00003140
3141 // If this is the magic class __cxxabiv1::__fundamental_type_info,
3142 // we will emit the typeinfo for the fundamental types. This is the
3143 // same behaviour as GCC.
3144 const DeclContext *DC = RD->getDeclContext();
3145 if (RD->getIdentifier() &&
3146 RD->getIdentifier()->isStr("__fundamental_type_info") &&
3147 isa<NamespaceDecl>(DC) &&
3148 cast<NamespaceDecl>(DC)->getIdentifier() &&
3149 cast<NamespaceDecl>(DC)->getIdentifier()->isStr("__cxxabiv1") &&
3150 DC->getParent()->isTranslationUnit())
3151 CGM.EmitFundamentalRTTIDescriptors();
Anders Carlssona627ac7e2010-03-29 03:38:52 +00003152}