clang  6.0.0svn
VTTBuilder.cpp
Go to the documentation of this file.
1 //===- VTTBuilder.cpp - C++ VTT layout builder ----------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code dealing with generation of the layout of virtual table
11 // tables (VTT).
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/VTTBuilder.h"
16 #include "clang/AST/ASTContext.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"
25 #include <cassert>
26 #include <cstdint>
27 
28 using namespace clang;
29 
30 #define DUMP_OVERRIDERS 0
31 
33  const CXXRecordDecl *MostDerivedClass,
34  bool GenerateDefinition)
35  : Ctx(Ctx), MostDerivedClass(MostDerivedClass),
36  MostDerivedClassLayout(Ctx.getASTRecordLayout(MostDerivedClass)),
37  GenerateDefinition(GenerateDefinition) {
38  // Lay out this VTT.
39  LayoutVTT(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
40  /*BaseIsVirtual=*/false);
41 }
42 
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();
50  }
51 
52  if (!GenerateDefinition) {
53  VTTComponents.push_back(VTTComponent());
54  return;
55  }
56 
57  VTTComponents.push_back(VTTComponent(VTableIndex, Base));
58 }
59 
60 void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) {
61  const CXXRecordDecl *RD = Base.getBase();
62 
63  for (const auto &I : RD->bases()) {
64  // Don't layout virtual bases.
65  if (I.isVirtual())
66  continue;
67 
68  const CXXRecordDecl *BaseDecl =
69  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
70 
71  const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
72  CharUnits BaseOffset = Base.getBaseOffset() +
73  Layout.getBaseClassOffset(BaseDecl);
74 
75  // Layout the VTT for this base.
76  LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/false);
77  }
78 }
79 
80 void
81 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
82  bool BaseIsMorallyVirtual,
83  uint64_t VTableIndex,
84  const CXXRecordDecl *VTableClass,
85  VisitedVirtualBasesSetTy &VBases) {
86  const CXXRecordDecl *RD = Base.getBase();
87 
88  // We're not interested in bases that don't have virtual bases, and not
89  // morally virtual bases.
90  if (!RD->getNumVBases() && !BaseIsMorallyVirtual)
91  return;
92 
93  for (const auto &I : RD->bases()) {
94  const CXXRecordDecl *BaseDecl =
95  cast<CXXRecordDecl>(I.getType()->getAs<RecordType>()->getDecl());
96 
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
100  // virtual path.
101  //
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())
105  continue;
106 
107  bool BaseDeclIsMorallyVirtual = BaseIsMorallyVirtual;
108  bool BaseDeclIsNonVirtualPrimaryBase = false;
109  CharUnits BaseOffset;
110  if (I.isVirtual()) {
111  // Ignore virtual bases that we've already visited.
112  if (!VBases.insert(BaseDecl).second)
113  continue;
114 
115  BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
116  BaseDeclIsMorallyVirtual = true;
117  } else {
118  const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD);
119 
120  BaseOffset = Base.getBaseOffset() +
121  Layout.getBaseClassOffset(BaseDecl);
122 
123  if (!Layout.isPrimaryBaseVirtual() &&
124  Layout.getPrimaryBase() == BaseDecl)
125  BaseDeclIsNonVirtualPrimaryBase = true;
126  }
127 
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,
137  VTableClass);
138  }
139 
140  // And lay out the secondary virtual pointers for the base class.
141  LayoutSecondaryVirtualPointers(BaseSubobject(BaseDecl, BaseOffset),
142  BaseDeclIsMorallyVirtual, VTableIndex,
143  VTableClass, VBases);
144  }
145 }
146 
147 void
148 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base,
149  uint64_t VTableIndex) {
150  VisitedVirtualBasesSetTy VBases;
151  LayoutSecondaryVirtualPointers(Base, /*BaseIsMorallyVirtual=*/false,
152  VTableIndex, Base.getBase(), VBases);
153 }
154 
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());
160 
161  // Check if this is a virtual base.
162  if (I.isVirtual()) {
163  // Check if we've seen this base before.
164  if (!VBases.insert(BaseDecl).second)
165  continue;
166 
167  CharUnits BaseOffset =
168  MostDerivedClassLayout.getVBaseClassOffset(BaseDecl);
169 
170  LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/true);
171  }
172 
173  // We only need to layout virtual VTTs for this base if it actually has
174  // virtual bases.
175  if (BaseDecl->getNumVBases())
176  LayoutVirtualVTTs(BaseDecl, VBases);
177  }
178 }
179 
180 void VTTBuilder::LayoutVTT(BaseSubobject Base, bool BaseIsVirtual) {
181  const CXXRecordDecl *RD = Base.getBase();
182 
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)
187  return;
188 
189  bool IsPrimaryVTT = Base.getBase() == MostDerivedClass;
190 
191  if (!IsPrimaryVTT) {
192  // Remember the sub-VTT index.
193  SubVTTIndicies[Base] = VTTComponents.size();
194  }
195 
196  uint64_t VTableIndex = VTTVTables.size();
197  VTTVTables.push_back(VTTVTable(Base, BaseIsVirtual));
198 
199  // Add the primary vtable pointer.
200  AddVTablePointer(Base, VTableIndex, RD);
201 
202  // Add the secondary VTTs.
203  LayoutSecondaryVTTs(Base);
204 
205  // Add the secondary virtual pointers.
206  LayoutSecondaryVirtualPointers(Base, VTableIndex);
207 
208  // If this is the primary VTT, we want to lay out virtual VTTs as well.
209  if (IsPrimaryVTT) {
210  VisitedVirtualBasesSetTy VBases;
211  LayoutVirtualVTTs(Base.getBase(), VBases);
212  }
213 }
Defines the clang::ASTContext interface.
bool isPrimaryBaseVirtual() const
isPrimaryBaseVirtual - Get whether the primary base for this record is virtual or not...
Definition: RecordLayout.h:216
base_class_range bases()
Definition: DeclCXX.h:773
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:223
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:788
C Language Family Type Representation.
CharUnits getBaseOffset() const
getBaseOffset - Returns the base class offset.
Definition: BaseSubobject.h:46
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const
getVBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:231
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
bool isDynamicClass() const
Definition: DeclCXX.h:751
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:39
const CXXRecordDecl * getPrimaryBase() const
getPrimaryBase - Get the primary base for this record.
Definition: RecordLayout.h:208
const CXXRecordDecl * getBase() const
getBase - Returns the base class declaration.
Definition: BaseSubobject.h:43
Dataflow Directional Tag Classes.
VTTBuilder(ASTContext &Ctx, const CXXRecordDecl *MostDerivedClass, bool GenerateDefinition)
Definition: VTTBuilder.cpp:32
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299