1 //===- PrettyClassLayoutGraphicalDumper.h -----------------------*- 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 #include "PrettyClassLayoutGraphicalDumper.h" 10 11 #include "PrettyClassDefinitionDumper.h" 12 #include "PrettyEnumDumper.h" 13 #include "PrettyFunctionDumper.h" 14 #include "PrettyTypedefDumper.h" 15 #include "PrettyVariableDumper.h" 16 #include "PrettyVariableDumper.h" 17 #include "llvm-pdbutil.h" 18 19 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h" 20 #include "llvm/DebugInfo/PDB/PDBSymbolData.h" 21 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBaseClass.h" 22 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h" 23 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h" 24 #include "llvm/DebugInfo/PDB/UDTLayout.h" 25 #include "llvm/Support/Format.h" 26 27 using namespace llvm; 28 using namespace llvm::pdb; 29 30 PrettyClassLayoutGraphicalDumper::PrettyClassLayoutGraphicalDumper( 31 LinePrinter &P, uint32_t RecurseLevel, uint32_t InitialOffset) 32 : PDBSymDumper(true), Printer(P), RecursionLevel(RecurseLevel), 33 ClassOffsetZero(InitialOffset), CurrentAbsoluteOffset(InitialOffset) {} 34 35 bool PrettyClassLayoutGraphicalDumper::start(const UDTLayoutBase &Layout) { 36 37 if (RecursionLevel == 1 && 38 opts::pretty::ClassFormat == opts::pretty::ClassDefinitionFormat::All) { 39 for (auto &Other : Layout.other_items()) 40 Other->dump(*this); 41 for (auto &Func : Layout.funcs()) 42 Func->dump(*this); 43 } 44 45 const BitVector &UseMap = Layout.usedBytes(); 46 int NextPaddingByte = UseMap.find_first_unset(); 47 48 for (auto &Item : Layout.layout_items()) { 49 // Calculate the absolute offset of the first byte of the next field. 50 uint32_t RelativeOffset = Item->getOffsetInParent(); 51 CurrentAbsoluteOffset = ClassOffsetZero + RelativeOffset; 52 53 // This might be an empty base, in which case it could extend outside the 54 // bounds of the parent class. 55 if (RelativeOffset < UseMap.size() && (Item->getSize() > 0)) { 56 // If there is any remaining padding in this class, and the offset of the 57 // new item is after the padding, then we must have just jumped over some 58 // padding. Print a padding row and then look for where the next block 59 // of padding begins. 60 if ((NextPaddingByte >= 0) && 61 (RelativeOffset > uint32_t(NextPaddingByte))) { 62 printPaddingRow(RelativeOffset - NextPaddingByte); 63 NextPaddingByte = UseMap.find_next_unset(RelativeOffset); 64 } 65 } 66 67 CurrentItem = Item; 68 if (Item->isVBPtr()) { 69 VTableLayoutItem &Layout = static_cast<VTableLayoutItem &>(*CurrentItem); 70 71 VariableDumper VarDumper(Printer); 72 VarDumper.startVbptr(CurrentAbsoluteOffset, Layout.getSize()); 73 } else { 74 if (auto Sym = Item->getSymbol()) 75 Sym->dump(*this); 76 } 77 78 if (Item->getLayoutSize() > 0) { 79 uint32_t Prev = RelativeOffset + Item->getLayoutSize() - 1; 80 if (Prev < UseMap.size()) 81 NextPaddingByte = UseMap.find_next_unset(Prev); 82 } 83 } 84 85 auto TailPadding = Layout.tailPadding(); 86 if (TailPadding > 0) { 87 if (TailPadding != 1 || Layout.getSize() != 1) { 88 Printer.NewLine(); 89 WithColor(Printer, PDB_ColorItem::Padding).get() 90 << "<padding> (" << TailPadding << " bytes)"; 91 DumpedAnything = true; 92 } 93 } 94 95 return DumpedAnything; 96 } 97 98 void PrettyClassLayoutGraphicalDumper::printPaddingRow(uint32_t Amount) { 99 if (Amount == 0) 100 return; 101 102 Printer.NewLine(); 103 WithColor(Printer, PDB_ColorItem::Padding).get() << "<padding> (" << Amount 104 << " bytes)"; 105 DumpedAnything = true; 106 } 107 108 void PrettyClassLayoutGraphicalDumper::dump( 109 const PDBSymbolTypeBaseClass &Symbol) { 110 assert(CurrentItem != nullptr); 111 112 Printer.NewLine(); 113 BaseClassLayout &Layout = static_cast<BaseClassLayout &>(*CurrentItem); 114 115 std::string Label = "base"; 116 if (Layout.isVirtualBase()) { 117 Label.insert(Label.begin(), 'v'); 118 if (Layout.getBase().isIndirectVirtualBaseClass()) 119 Label.insert(Label.begin(), 'i'); 120 } 121 Printer << Label << " "; 122 123 uint32_t Size = Layout.isEmptyBase() ? 1 : Layout.getLayoutSize(); 124 125 WithColor(Printer, PDB_ColorItem::Offset).get() 126 << "+" << format_hex(CurrentAbsoluteOffset, 4) << " [sizeof=" << Size 127 << "] "; 128 129 WithColor(Printer, PDB_ColorItem::Identifier).get() << Layout.getName(); 130 131 if (shouldRecurse()) { 132 Printer.Indent(); 133 uint32_t ChildOffsetZero = ClassOffsetZero + Layout.getOffsetInParent(); 134 PrettyClassLayoutGraphicalDumper BaseDumper(Printer, RecursionLevel + 1, 135 ChildOffsetZero); 136 DumpedAnything |= BaseDumper.start(Layout); 137 Printer.Unindent(); 138 } 139 140 DumpedAnything = true; 141 } 142 143 bool PrettyClassLayoutGraphicalDumper::shouldRecurse() const { 144 uint32_t Limit = opts::pretty::ClassRecursionDepth; 145 if (Limit == 0) 146 return true; 147 return RecursionLevel < Limit; 148 } 149 150 void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolData &Symbol) { 151 VariableDumper VarDumper(Printer); 152 VarDumper.start(Symbol, ClassOffsetZero); 153 154 if (CurrentItem != nullptr) { 155 DataMemberLayoutItem &Layout = 156 static_cast<DataMemberLayoutItem &>(*CurrentItem); 157 158 if (Layout.hasUDTLayout() && shouldRecurse()) { 159 uint32_t ChildOffsetZero = ClassOffsetZero + Layout.getOffsetInParent(); 160 Printer.Indent(); 161 PrettyClassLayoutGraphicalDumper TypeDumper(Printer, RecursionLevel + 1, 162 ChildOffsetZero); 163 TypeDumper.start(Layout.getUDTLayout()); 164 Printer.Unindent(); 165 } 166 } 167 168 DumpedAnything = true; 169 } 170 171 void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolTypeVTable &Symbol) { 172 assert(CurrentItem != nullptr); 173 174 VariableDumper VarDumper(Printer); 175 VarDumper.start(Symbol, ClassOffsetZero); 176 177 DumpedAnything = true; 178 } 179 180 void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolTypeEnum &Symbol) { 181 DumpedAnything = true; 182 Printer.NewLine(); 183 EnumDumper Dumper(Printer); 184 Dumper.start(Symbol); 185 } 186 187 void PrettyClassLayoutGraphicalDumper::dump( 188 const PDBSymbolTypeTypedef &Symbol) { 189 DumpedAnything = true; 190 Printer.NewLine(); 191 TypedefDumper Dumper(Printer); 192 Dumper.start(Symbol); 193 } 194 195 void PrettyClassLayoutGraphicalDumper::dump( 196 const PDBSymbolTypeBuiltin &Symbol) {} 197 198 void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolTypeUDT &Symbol) {} 199 200 void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolFunc &Symbol) { 201 if (Printer.IsSymbolExcluded(Symbol.getName())) 202 return; 203 if (Symbol.isCompilerGenerated() && opts::pretty::ExcludeCompilerGenerated) 204 return; 205 if (Symbol.getLength() == 0 && !Symbol.isPureVirtual() && 206 !Symbol.isIntroVirtualFunction()) 207 return; 208 209 DumpedAnything = true; 210 Printer.NewLine(); 211 FunctionDumper Dumper(Printer); 212 Dumper.start(Symbol, FunctionDumper::PointerType::None); 213 } 214