1 //===- VTTBuilder.cpp - C++ VTT layout builder ----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code dealing with generation of the layout of virtual table
13 //===----------------------------------------------------------------------===//
15 #include "clang/AST/VTTBuilder.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/BaseSubobject.h"
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/RecordLayout.h"
22 #include "clang/AST/Type.h"
23 #include "clang/Basic/LLVM.h"
24 #include "llvm/Support/Casting.h"
28 using namespace clang;
30 #define DUMP_OVERRIDERS 0
32 VTTBuilder::VTTBuilder(ASTContext &Ctx,
33 const CXXRecordDecl *MostDerivedClass,
34 bool GenerateDefinition)
35 : Ctx(Ctx), MostDerivedClass(MostDerivedClass),
36 MostDerivedClassLayout(Ctx.getASTRecordLayout(MostDerivedClass)),
37 GenerateDefinition(GenerateDefinition) {
39 LayoutVTT(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
40 /*BaseIsVirtual=*/false);
43 void VTTBuilder::AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex,
44 const CXXRecordDecl *VTableClass) {
45 // Store the vtable pointer index if we're generating the primary VTT.
46 if (VTableClass == MostDerivedClass) {
47 assert(!SecondaryVirtualPointerIndices.count(Base) &&
48 "A virtual pointer index already exists for this base subobject!");
49 SecondaryVirtualPointerIndices[Base] = VTTComponents.size();
52 if (!GenerateDefinition) {
53 VTTComponents.push_back(VTTComponent());
57 VTTComponents.push_back(VTTComponent(VTableIndex, Base));
60 void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) {
61 const CXXRecordDecl *RD = Base.getBase();
63 for (const auto &I : RD->bases()) {
64 // Don't layout virtual bases.
68 const CXXRecordDecl *BaseDecl =
69 cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
71 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
72 CharUnits BaseOffset = Base.getBaseOffset() +
73 Layout.getBaseClassOffset(BaseDecl);
75 // Layout the VTT for this base.
76 LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/false);
81 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
82 bool BaseIsMorallyVirtual,
84 const CXXRecordDecl *VTableClass,
85 VisitedVirtualBasesSetTy &VBases) {
86 const CXXRecordDecl *RD = Base.getBase();
88 // We're not interested in bases that don't have virtual bases, and not
89 // morally virtual bases.
90 if (!RD->getNumVBases() && !BaseIsMorallyVirtual)
93 for (const auto &I : RD->bases()) {
94 const CXXRecordDecl *BaseDecl =
95 cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
97 // Itanium C++ ABI 2.6.2:
98 // Secondary virtual pointers are present for all bases with either
99 // virtual bases or virtual function declarations overridden along a
102 // If the base class is not dynamic, we don't want to add it, nor any
103 // of its base classes.
104 if (!BaseDecl->isDynamicClass())
107 bool BaseDeclIsMorallyVirtual = BaseIsMorallyVirtual;
108 bool BaseDeclIsNonVirtualPrimaryBase = false;
109 CharUnits BaseOffset;
111 // Ignore virtual bases that we've already visited.
112 if (!VBases.insert(BaseDecl).second)
115 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
116 BaseDeclIsMorallyVirtual = true;
118 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
120 BaseOffset = Base.getBaseOffset() +
121 Layout.getBaseClassOffset(BaseDecl);
123 if (!Layout.isPrimaryBaseVirtual() &&
124 Layout.getPrimaryBase() == BaseDecl)
125 BaseDeclIsNonVirtualPrimaryBase = true;
128 // Itanium C++ ABI 2.6.2:
129 // Secondary virtual pointers: for each base class X which (a) has virtual
130 // bases or is reachable along a virtual path from D, and (b) is not a
131 // non-virtual primary base, the address of the virtual table for X-in-D
132 // or an appropriate construction virtual table.
133 if (!BaseDeclIsNonVirtualPrimaryBase &&
134 (BaseDecl->getNumVBases() || BaseDeclIsMorallyVirtual)) {
135 // Add the vtable pointer.
136 AddVTablePointer(BaseSubobject(BaseDecl, BaseOffset), VTableIndex,
140 // And lay out the secondary virtual pointers for the base class.
141 LayoutSecondaryVirtualPointers(BaseSubobject(BaseDecl, BaseOffset),
142 BaseDeclIsMorallyVirtual, VTableIndex,
143 VTableClass, VBases);
148 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
149 uint64_t VTableIndex) {
150 VisitedVirtualBasesSetTy VBases;
151 LayoutSecondaryVirtualPointers(Base, /*BaseIsMorallyVirtual=*/false,
152 VTableIndex, Base.getBase(), VBases);
155 void VTTBuilder::LayoutVirtualVTTs(const CXXRecordDecl *RD,
156 VisitedVirtualBasesSetTy &VBases) {
157 for (const auto &I : RD->bases()) {
158 const CXXRecordDecl *BaseDecl =
159 cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
161 // Check if this is a virtual base.
163 // Check if we've seen this base before.
164 if (!VBases.insert(BaseDecl).second)
167 CharUnits BaseOffset =
168 MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
170 LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/true);
173 // We only need to layout virtual VTTs for this base if it actually has
175 if (BaseDecl->getNumVBases())
176 LayoutVirtualVTTs(BaseDecl, VBases);
180 void VTTBuilder::LayoutVTT(BaseSubobject Base, bool BaseIsVirtual) {
181 const CXXRecordDecl *RD = Base.getBase();
183 // Itanium C++ ABI 2.6.2:
184 // An array of virtual table addresses, called the VTT, is declared for
185 // each class type that has indirect or direct virtual base classes.
186 if (RD->getNumVBases() == 0)
189 bool IsPrimaryVTT = Base.getBase() == MostDerivedClass;
192 // Remember the sub-VTT index.
193 SubVTTIndicies[Base] = VTTComponents.size();
196 uint64_t VTableIndex = VTTVTables.size();
197 VTTVTables.push_back(VTTVTable(Base, BaseIsVirtual));
199 // Add the primary vtable pointer.
200 AddVTablePointer(Base, VTableIndex, RD);
202 // Add the secondary VTTs.
203 LayoutSecondaryVTTs(Base);
205 // Add the secondary virtual pointers.
206 LayoutSecondaryVirtualPointers(Base, VTableIndex);
208 // If this is the primary VTT, we want to lay out virtual VTTs as well.
210 VisitedVirtualBasesSetTy VBases;
211 LayoutVirtualVTTs(Base.getBase(), VBases);