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