1 //===--- VTTBuilder.h - C++ VTT layout builder --------------------*- C++ -*-=// 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 #ifndef LLVM_CLANG_AST_VTTBUILDER_H 16 #define LLVM_CLANG_AST_VTTBUILDER_H 17 18 #include "clang/AST/BaseSubobject.h" 19 #include "clang/AST/CXXInheritance.h" 20 #include "clang/AST/GlobalDecl.h" 21 #include "clang/AST/RecordLayout.h" 22 #include "clang/Basic/ABI.h" 23 #include "llvm/ADT/SetVector.h" 24 #include <utility> 25 26 namespace clang { 27 28 class VTTVTable { 29 llvm::PointerIntPair<const CXXRecordDecl *, 1, bool> BaseAndIsVirtual; 30 CharUnits BaseOffset; 31 32 public: 33 VTTVTable() {} 34 VTTVTable(const CXXRecordDecl *Base, CharUnits BaseOffset, bool BaseIsVirtual) 35 : BaseAndIsVirtual(Base, BaseIsVirtual), BaseOffset(BaseOffset) {} 36 VTTVTable(BaseSubobject Base, bool BaseIsVirtual) 37 : BaseAndIsVirtual(Base.getBase(), BaseIsVirtual), 38 BaseOffset(Base.getBaseOffset()) {} 39 40 const CXXRecordDecl *getBase() const { 41 return BaseAndIsVirtual.getPointer(); 42 } 43 44 CharUnits getBaseOffset() const { 45 return BaseOffset; 46 } 47 48 bool isVirtual() const { 49 return BaseAndIsVirtual.getInt(); 50 } 51 52 BaseSubobject getBaseSubobject() const { 53 return BaseSubobject(getBase(), getBaseOffset()); 54 } 55 }; 56 57 struct VTTComponent { 58 uint64_t VTableIndex; 59 BaseSubobject VTableBase; 60 61 VTTComponent() {} 62 VTTComponent(uint64_t VTableIndex, BaseSubobject VTableBase) 63 : VTableIndex(VTableIndex), VTableBase(VTableBase) {} 64 }; 65 66 /// VTT builder - Class for building VTT layout information. 67 class VTTBuilder { 68 69 ASTContext &Ctx; 70 71 /// MostDerivedClass - The most derived class for which we're building this 72 /// vtable. 73 const CXXRecordDecl *MostDerivedClass; 74 75 typedef SmallVector<VTTVTable, 64> VTTVTablesVectorTy; 76 77 /// VTTVTables - The VTT vtables. 78 VTTVTablesVectorTy VTTVTables; 79 80 typedef SmallVector<VTTComponent, 64> VTTComponentsVectorTy; 81 82 /// VTTComponents - The VTT components. 83 VTTComponentsVectorTy VTTComponents; 84 85 /// MostDerivedClassLayout - the AST record layout of the most derived class. 86 const ASTRecordLayout &MostDerivedClassLayout; 87 88 typedef llvm::SmallPtrSet<const CXXRecordDecl *, 4> VisitedVirtualBasesSetTy; 89 90 typedef llvm::DenseMap<BaseSubobject, uint64_t> AddressPointsMapTy; 91 92 /// SubVTTIndicies - The sub-VTT indices for the bases of the most derived 93 /// class. 94 llvm::DenseMap<BaseSubobject, uint64_t> SubVTTIndicies; 95 96 /// SecondaryVirtualPointerIndices - The secondary virtual pointer indices of 97 /// all subobjects of the most derived class. 98 llvm::DenseMap<BaseSubobject, uint64_t> SecondaryVirtualPointerIndices; 99 100 /// GenerateDefinition - Whether the VTT builder should generate LLVM IR for 101 /// the VTT. 102 bool GenerateDefinition; 103 104 /// AddVTablePointer - Add a vtable pointer to the VTT currently being built. 105 void AddVTablePointer(BaseSubobject Base, uint64_t VTableIndex, 106 const CXXRecordDecl *VTableClass); 107 108 /// LayoutSecondaryVTTs - Lay out the secondary VTTs of the given base 109 /// subobject. 110 void LayoutSecondaryVTTs(BaseSubobject Base); 111 112 /// LayoutSecondaryVirtualPointers - Lay out the secondary virtual pointers 113 /// for the given base subobject. 114 /// 115 /// \param BaseIsMorallyVirtual whether the base subobject is a virtual base 116 /// or a direct or indirect base of a virtual base. 117 void LayoutSecondaryVirtualPointers(BaseSubobject Base, 118 bool BaseIsMorallyVirtual, 119 uint64_t VTableIndex, 120 const CXXRecordDecl *VTableClass, 121 VisitedVirtualBasesSetTy &VBases); 122 123 /// LayoutSecondaryVirtualPointers - Lay out the secondary virtual pointers 124 /// for the given base subobject. 125 void LayoutSecondaryVirtualPointers(BaseSubobject Base, 126 uint64_t VTableIndex); 127 128 /// LayoutVirtualVTTs - Lay out the VTTs for the virtual base classes of the 129 /// given record decl. 130 void LayoutVirtualVTTs(const CXXRecordDecl *RD, 131 VisitedVirtualBasesSetTy &VBases); 132 133 /// LayoutVTT - Will lay out the VTT for the given subobject, including any 134 /// secondary VTTs, secondary virtual pointers and virtual VTTs. 135 void LayoutVTT(BaseSubobject Base, bool BaseIsVirtual); 136 137 public: 138 VTTBuilder(ASTContext &Ctx, const CXXRecordDecl *MostDerivedClass, 139 bool GenerateDefinition); 140 141 // getVTTComponents - Returns a reference to the VTT components. 142 const VTTComponentsVectorTy &getVTTComponents() const { 143 return VTTComponents; 144 } 145 146 // getVTTVTables - Returns a reference to the VTT vtables. 147 const VTTVTablesVectorTy &getVTTVTables() const { 148 return VTTVTables; 149 } 150 151 /// getSubVTTIndicies - Returns a reference to the sub-VTT indices. 152 const llvm::DenseMap<BaseSubobject, uint64_t> &getSubVTTIndicies() const { 153 return SubVTTIndicies; 154 } 155 156 /// getSecondaryVirtualPointerIndices - Returns a reference to the secondary 157 /// virtual pointer indices. 158 const llvm::DenseMap<BaseSubobject, uint64_t> & 159 getSecondaryVirtualPointerIndices() const { 160 return SecondaryVirtualPointerIndices; 161 } 162 163 }; 164 165 } 166 167 #endif 168