1 //===- UDTLayout.h - UDT layout info ----------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_DEBUGINFO_PDB_UDTLAYOUT_H 10 #define LLVM_DEBUGINFO_PDB_UDTLAYOUT_H 11 12 #include "llvm/ADT/ArrayRef.h" 13 #include "llvm/ADT/BitVector.h" 14 #include "llvm/ADT/StringRef.h" 15 #include "llvm/DebugInfo/PDB/PDBSymbol.h" 16 #include "llvm/DebugInfo/PDB/PDBSymbolData.h" 17 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h" 18 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h" 19 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h" 20 #include "llvm/DebugInfo/PDB/PDBSymbolTypeVTable.h" 21 #include <cstdint> 22 #include <memory> 23 #include <string> 24 #include <vector> 25 26 namespace llvm { 27 namespace pdb { 28 29 class BaseClassLayout; 30 class ClassLayout; 31 class UDTLayoutBase; 32 33 class LayoutItemBase { 34 public: 35 LayoutItemBase(const UDTLayoutBase *Parent, const PDBSymbol *Symbol, 36 const std::string &Name, uint32_t OffsetInParent, 37 uint32_t Size, bool IsElided); 38 virtual ~LayoutItemBase() = default; 39 40 uint32_t deepPaddingSize() const; 41 virtual uint32_t immediatePadding() const { return 0; } 42 virtual uint32_t tailPadding() const; 43 44 const UDTLayoutBase *getParent() const { return Parent; } 45 StringRef getName() const { return Name; } 46 uint32_t getOffsetInParent() const { return OffsetInParent; } 47 uint32_t getSize() const { return SizeOf; } 48 uint32_t getLayoutSize() const { return LayoutSize; } 49 const PDBSymbol *getSymbol() const { return Symbol; } 50 const BitVector &usedBytes() const { return UsedBytes; } 51 bool isElided() const { return IsElided; } 52 virtual bool isVBPtr() const { return false; } 53 54 uint32_t containsOffset(uint32_t Off) const { 55 uint32_t Begin = getOffsetInParent(); 56 uint32_t End = Begin + getSize(); 57 return (Off >= Begin && Off < End); 58 } 59 60 protected: 61 const PDBSymbol *Symbol = nullptr; 62 const UDTLayoutBase *Parent = nullptr; 63 BitVector UsedBytes; 64 std::string Name; 65 uint32_t OffsetInParent = 0; 66 uint32_t SizeOf = 0; 67 uint32_t LayoutSize = 0; 68 bool IsElided = false; 69 }; 70 71 class VBPtrLayoutItem : public LayoutItemBase { 72 public: 73 VBPtrLayoutItem(const UDTLayoutBase &Parent, 74 std::unique_ptr<PDBSymbolTypeBuiltin> Sym, uint32_t Offset, 75 uint32_t Size); 76 77 bool isVBPtr() const override { return true; } 78 79 private: 80 std::unique_ptr<PDBSymbolTypeBuiltin> Type; 81 }; 82 83 class DataMemberLayoutItem : public LayoutItemBase { 84 public: 85 DataMemberLayoutItem(const UDTLayoutBase &Parent, 86 std::unique_ptr<PDBSymbolData> DataMember); 87 88 const PDBSymbolData &getDataMember(); 89 bool hasUDTLayout() const; 90 const ClassLayout &getUDTLayout() const; 91 92 private: 93 std::unique_ptr<PDBSymbolData> DataMember; 94 std::unique_ptr<ClassLayout> UdtLayout; 95 }; 96 97 class VTableLayoutItem : public LayoutItemBase { 98 public: 99 VTableLayoutItem(const UDTLayoutBase &Parent, 100 std::unique_ptr<PDBSymbolTypeVTable> VTable); 101 102 uint32_t getElementSize() const { return ElementSize; } 103 104 private: 105 uint32_t ElementSize = 0; 106 std::unique_ptr<PDBSymbolTypeVTable> VTable; 107 }; 108 109 class UDTLayoutBase : public LayoutItemBase { 110 template <typename T> using UniquePtrVector = std::vector<std::unique_ptr<T>>; 111 112 public: 113 UDTLayoutBase(const UDTLayoutBase *Parent, const PDBSymbol &Sym, 114 const std::string &Name, uint32_t OffsetInParent, uint32_t Size, 115 bool IsElided); 116 117 uint32_t tailPadding() const override; 118 ArrayRef<LayoutItemBase *> layout_items() const { return LayoutItems; } 119 ArrayRef<BaseClassLayout *> bases() const { return AllBases; } 120 ArrayRef<BaseClassLayout *> regular_bases() const { return NonVirtualBases; } 121 ArrayRef<BaseClassLayout *> virtual_bases() const { return VirtualBases; } 122 uint32_t directVirtualBaseCount() const { return DirectVBaseCount; } 123 ArrayRef<std::unique_ptr<PDBSymbolFunc>> funcs() const { return Funcs; } 124 ArrayRef<std::unique_ptr<PDBSymbol>> other_items() const { return Other; } 125 126 protected: 127 bool hasVBPtrAtOffset(uint32_t Off) const; 128 void initializeChildren(const PDBSymbol &Sym); 129 130 void addChildToLayout(std::unique_ptr<LayoutItemBase> Child); 131 132 uint32_t DirectVBaseCount = 0; 133 134 UniquePtrVector<PDBSymbol> Other; 135 UniquePtrVector<PDBSymbolFunc> Funcs; 136 UniquePtrVector<LayoutItemBase> ChildStorage; 137 std::vector<LayoutItemBase *> LayoutItems; 138 139 std::vector<BaseClassLayout *> AllBases; 140 ArrayRef<BaseClassLayout *> NonVirtualBases; 141 ArrayRef<BaseClassLayout *> VirtualBases; 142 143 VTableLayoutItem *VTable = nullptr; 144 VBPtrLayoutItem *VBPtr = nullptr; 145 }; 146 147 class BaseClassLayout : public UDTLayoutBase { 148 public: 149 BaseClassLayout(const UDTLayoutBase &Parent, uint32_t OffsetInParent, 150 bool Elide, std::unique_ptr<PDBSymbolTypeBaseClass> Base); 151 152 const PDBSymbolTypeBaseClass &getBase() const { return *Base; } 153 bool isVirtualBase() const { return IsVirtualBase; } 154 bool isEmptyBase() { return SizeOf == 1 && LayoutSize == 0; } 155 156 private: 157 std::unique_ptr<PDBSymbolTypeBaseClass> Base; 158 bool IsVirtualBase; 159 }; 160 161 class ClassLayout : public UDTLayoutBase { 162 public: 163 explicit ClassLayout(const PDBSymbolTypeUDT &UDT); 164 explicit ClassLayout(std::unique_ptr<PDBSymbolTypeUDT> UDT); 165 166 ClassLayout(ClassLayout &&Other) = default; 167 168 const PDBSymbolTypeUDT &getClass() const { return UDT; } 169 uint32_t immediatePadding() const override; 170 171 private: 172 BitVector ImmediateUsedBytes; 173 std::unique_ptr<PDBSymbolTypeUDT> OwnedStorage; 174 const PDBSymbolTypeUDT &UDT; 175 }; 176 177 } // end namespace pdb 178 } // end namespace llvm 179 180 #endif // LLVM_DEBUGINFO_PDB_UDTLAYOUT_H 181