contrib/llvm/include/llvm/DebugInfo/PDB/UDTLayout.h

   1 //===- UDTLayout.h - UDT layout info ----------------------------*- 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 #ifndef LLVM_DEBUGINFO_PDB_UDTLAYOUT_H
  11 #define LLVM_DEBUGINFO_PDB_UDTLAYOUT_H
  12
  13 #include "PDBSymbol.h"
  14 #include "PDBTypes.h"
  15
  16 #include "llvm/ADT/ArrayRef.h"
  17 #include "llvm/ADT/BitVector.h"
  18
  19 #include <list>
  20 #include <memory>
  21
  22 namespace llvm {
  23
  24 class raw_ostream;
  25
  26 namespace pdb {
  27
  28 class PDBSymTypeBaseClass;
  29 class PDBSymbolData;
  30 class PDBSymbolTypeUDT;
  31 class PDBSymbolTypeVTable;
  32
  33 class ClassLayout;
  34 class BaseClassLayout;
  35 class StorageItemBase;
  36 class UDTLayoutBase;
  37
  38 class StorageItemBase {
  39 public:
  40   StorageItemBase(const UDTLayoutBase &Parent, const PDBSymbol &Symbol,
  41                   const std::string &Name, uint32_t OffsetInParent,
  42                   uint32_t Size);
  43   virtual ~StorageItemBase() {}
  44
  45   virtual uint32_t deepPaddingSize() const;
  46
  47   const UDTLayoutBase &getParent() const { return Parent; }
  48   StringRef getName() const { return Name; }
  49   uint32_t getOffsetInParent() const { return OffsetInParent; }
  50   uint32_t getSize() const { return SizeOf; }
  51   const PDBSymbol &getSymbol() const { return Symbol; }
  52
  53 protected:
  54   const UDTLayoutBase &Parent;
  55   const PDBSymbol &Symbol;
  56   BitVector UsedBytes;
  57   std::string Name;
  58   uint32_t OffsetInParent = 0;
  59   uint32_t SizeOf = 0;
  60 };
  61
  62 class DataMemberLayoutItem : public StorageItemBase {
  63 public:
  64   DataMemberLayoutItem(const UDTLayoutBase &Parent,
  65                        std::unique_ptr<PDBSymbolData> DataMember);
  66
  67   virtual uint32_t deepPaddingSize() const;
  68
  69   const PDBSymbolData &getDataMember();
  70   bool hasUDTLayout() const;
  71   const ClassLayout &getUDTLayout() const;
  72
  73 private:
  74   std::unique_ptr<PDBSymbolData> DataMember;
  75   std::unique_ptr<ClassLayout> UdtLayout;
  76 };
  77
  78 class VTableLayoutItem : public StorageItemBase {
  79 public:
  80   VTableLayoutItem(const UDTLayoutBase &Parent,
  81                    std::unique_ptr<PDBSymbolTypeVTable> VTable);
  82   ArrayRef<PDBSymbolFunc *> funcs() const { return VTableFuncs; }
  83
  84   uint32_t getElementSize() const { return ElementSize; }
  85
  86   void setFunction(uint32_t Index, PDBSymbolFunc &Func) {
  87     VTableFuncs[Index] = &Func;
  88   }
  89
  90 private:
  91   uint32_t ElementSize = 0;
  92   std::unique_ptr<PDBSymbolTypeVTableShape> Shape;
  93   std::unique_ptr<PDBSymbolTypeVTable> VTable;
  94   std::vector<PDBSymbolFunc *> VTableFuncs;
  95 };
  96
  97 class UDTLayoutBase {
  98   template <typename T> using UniquePtrVector = std::vector<std::unique_ptr<T>>;
  99
 100 public:
 101   UDTLayoutBase(const PDBSymbol &Symbol, const std::string &Name,
 102                 uint32_t Size);
 103
 104   uint32_t shallowPaddingSize() const;
 105   uint32_t deepPaddingSize() const;
 106
 107   const BitVector &usedBytes() const { return UsedBytes; }
 108
 109   uint32_t getClassSize() const { return SizeOf; }
 110
 111   ArrayRef<std::unique_ptr<StorageItemBase>> layout_items() const {
 112     return ChildStorage;
 113   }
 114
 115   VTableLayoutItem *findVTableAtOffset(uint32_t RelativeOffset);
 116
 117   StringRef getUDTName() const { return Name; }
 118
 119   ArrayRef<BaseClassLayout *> bases() const { return BaseClasses; }
 120   ArrayRef<std::unique_ptr<PDBSymbolTypeBaseClass>> vbases() const {
 121     return VirtualBases;
 122   }
 123
 124   ArrayRef<std::unique_ptr<PDBSymbolFunc>> funcs() const { return Funcs; }
 125
 126   ArrayRef<std::unique_ptr<PDBSymbol>> other_items() const { return Other; }
 127
 128   const PDBSymbol &getSymbolBase() const { return SymbolBase; }
 129
 130 protected:
 131   void initializeChildren(const PDBSymbol &Sym);
 132
 133   void addChildToLayout(std::unique_ptr<StorageItemBase> Child);
 134   void addVirtualOverride(PDBSymbolFunc &Func);
 135   void addVirtualIntro(PDBSymbolFunc &Func);
 136
 137   const PDBSymbol &SymbolBase;
 138   std::string Name;
 139   uint32_t SizeOf = 0;
 140
 141   BitVector UsedBytes;
 142   UniquePtrVector<PDBSymbol> Other;
 143   UniquePtrVector<PDBSymbolFunc> Funcs;
 144   UniquePtrVector<PDBSymbolTypeBaseClass> VirtualBases;
 145   UniquePtrVector<StorageItemBase> ChildStorage;
 146   std::vector<std::list<StorageItemBase *>> ChildrenPerByte;
 147   std::vector<BaseClassLayout *> BaseClasses;
 148   VTableLayoutItem *VTable = nullptr;
 149 };
 150
 151 class ClassLayout : public UDTLayoutBase {
 152 public:
 153   explicit ClassLayout(const PDBSymbolTypeUDT &UDT);
 154   explicit ClassLayout(std::unique_ptr<PDBSymbolTypeUDT> UDT);
 155
 156   ClassLayout(ClassLayout &&Other) = default;
 157
 158   const PDBSymbolTypeUDT &getClass() const { return UDT; }
 159
 160 private:
 161   std::unique_ptr<PDBSymbolTypeUDT> OwnedStorage;
 162   const PDBSymbolTypeUDT &UDT;
 163 };
 164
 165 class BaseClassLayout : public UDTLayoutBase, public StorageItemBase {
 166 public:
 167   BaseClassLayout(const UDTLayoutBase &Parent,
 168                   std::unique_ptr<PDBSymbolTypeBaseClass> Base);
 169
 170   const PDBSymbolTypeBaseClass &getBase() const { return *Base; }
 171   bool isVirtualBase() const { return IsVirtualBase; }
 172
 173 private:
 174   std::unique_ptr<PDBSymbolTypeBaseClass> Base;
 175   bool IsVirtualBase;
 176 };
 177 }
 178 } // namespace llvm
 179
 180 #endif // LLVM_DEBUGINFO_PDB_UDTLAYOUT_H