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" 17 #include "clang/AST/CXXInheritance.h" 18 #include "clang/AST/RecordLayout.h" 19 #include "clang/Basic/TargetInfo.h" 20 #include "llvm/Support/Format.h" 21 #include <algorithm> 22 #include <cstdio> 23 24 using namespace clang; 25 26 #define DUMP_OVERRIDERS 0 27 28 VTTBuilder::VTTBuilder(ASTContext &Ctx, 29 const CXXRecordDecl *MostDerivedClass, 30 bool GenerateDefinition) 31 : Ctx(Ctx), MostDerivedClass(MostDerivedClass), 32 MostDerivedClassLayout(Ctx.getASTRecordLayout(MostDerivedClass)), 33 GenerateDefinition(GenerateDefinition) { 34 // Lay out this VTT. 35 LayoutVTT(BaseSubobject(MostDerivedClass, CharUnits::Zero()), 36 /*BaseIsVirtual=*/false); 37 } 38 39 void VTTBuilder::AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex, 40 const CXXRecordDecl *VTableClass) { 41 // Store the vtable pointer index if we're generating the primary VTT. 42 if (VTableClass == MostDerivedClass) { 43 assert(!SecondaryVirtualPointerIndices.count(Base) && 44 "A virtual pointer index already exists for this base subobject!"); 45 SecondaryVirtualPointerIndices[Base] = VTTComponents.size(); 46 } 47 48 if (!GenerateDefinition) { 49 VTTComponents.push_back(VTTComponent()); 50 return; 51 } 52 53 VTTComponents.push_back(VTTComponent(VTableIndex, Base)); 54 } 55 56 void VTTBuilder::LayoutSecondaryVTTs(BaseSubobject Base) { 57 const CXXRecordDecl *RD = Base.getBase(); 58 59 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 60 E = RD->bases_end(); I != E; ++I) { 61 62 // Don't layout virtual bases. 63 if (I->isVirtual()) 64 continue; 65 66 const CXXRecordDecl *BaseDecl = 67 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 68 69 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD); 70 CharUnits BaseOffset = Base.getBaseOffset() + 71 Layout.getBaseClassOffset(BaseDecl); 72 73 // Layout the VTT for this base. 74 LayoutVTT(BaseSubobject(BaseDecl, BaseOffset), /*BaseIsVirtual=*/false); 75 } 76 } 77 78 void 79 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base, 80 bool BaseIsMorallyVirtual, 81 uint64_t VTableIndex, 82 const CXXRecordDecl *VTableClass, 83 VisitedVirtualBasesSetTy &VBases) { 84 const CXXRecordDecl *RD = Base.getBase(); 85 86 // We're not interested in bases that don't have virtual bases, and not 87 // morally virtual bases. 88 if (!RD->getNumVBases() && !BaseIsMorallyVirtual) 89 return; 90 91 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 92 E = RD->bases_end(); I != E; ++I) { 93 const CXXRecordDecl *BaseDecl = 94 cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl()); 95 96 // Itanium C++ ABI 2.6.2: 97 // Secondary virtual pointers are present for all bases with either 98 // virtual bases or virtual function declarations overridden along a 99 // virtual path. 100 // 101 // If the base class is not dynamic, we don't want to add it, nor any 102 // of its base classes. 103 if (!BaseDecl->isDynamicClass()) 104 continue; 105 106 bool BaseDeclIsMorallyVirtual = BaseIsMorallyVirtual; 107 bool BaseDeclIsNonVirtualPrimaryBase = false; 108 CharUnits BaseOffset; 109 if (I->isVirtual()) { 110 // Ignore virtual bases that we've already visited. 111 if (!VBases.insert(BaseDecl)) 112 continue; 113 114 BaseOffset = MostDerivedClassLayout.getVBaseClassOffset(BaseDecl); 115 BaseDeclIsMorallyVirtual = true; 116 } else { 117 const ASTRecordLayout &Layout = Ctx.getASTRecordLayout(RD); 118 119 BaseOffset = Base.getBaseOffset() + 120 Layout.getBaseClassOffset(BaseDecl); 121 122 if (!Layout.isPrimaryBaseVirtual() && 123 Layout.getPrimaryBase() == BaseDecl) 124 BaseDeclIsNonVirtualPrimaryBase = true; 125 } 126 127 // Itanium C++ ABI 2.6.2: 128 // Secondary virtual pointers: for each base class X which (a) has virtual 129 // bases or is reachable along a virtual path from D, and (b) is not a 130 // non-virtual primary base, the address of the virtual table for X-in-D 131 // or an appropriate construction virtual table. 132 if (!BaseDeclIsNonVirtualPrimaryBase && 133 (BaseDecl->getNumVBases() || BaseDeclIsMorallyVirtual)) { 134 // Add the vtable pointer. 135 AddVTablePointer(BaseSubobject(BaseDecl, BaseOffset), VTableIndex, 136 VTableClass); 137 } 138 139 // And lay out the secondary virtual pointers for the base class. 140 LayoutSecondaryVirtualPointers(BaseSubobject(BaseDecl, BaseOffset), 141 BaseDeclIsMorallyVirtual, VTableIndex, 142 VTableClass, VBases); 143 } 144 } 145 146 void 147 VTTBuilder::LayoutSecondaryVirtualPointers(BaseSubobject Base, 148 uint64_t VTableIndex) { 149 VisitedVirtualBasesSetTy VBases; 150 LayoutSecondaryVirtualPointers(Base, /*BaseIsMorallyVirtual=*/false, 151 VTableIndex, Base.getBase(), VBases); 152 } 153 154 void VTTBuilder::LayoutVirtualVTTs(const CXXRecordDecl *RD, 155 VisitedVirtualBasesSetTy &VBases) { 156 for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(), 157 E = RD->bases_end(); I != E; ++I) { 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)) 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 } 214
