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
27using namespace llvm;
28using namespace llvm::pdb;
29
30PrettyClassLayoutGraphicalDumper::PrettyClassLayoutGraphicalDumper(
31 LinePrinter &P, uint32_t RecurseLevel, uint32_t InitialOffset)
32 : PDBSymDumper(true), Printer(P), RecursionLevel(RecurseLevel),
33 ClassOffsetZero(InitialOffset), CurrentAbsoluteOffset(InitialOffset) {}
34
35bool PrettyClassLayoutGraphicalDumper::start(const UDTLayoutBase &Layout) {
36
37 if (RecursionLevel == 1 &&
38 opts::pretty::ClassFormat == opts::pretty::ClassDefinitionFormat::All) {
39 for (const auto &Other : Layout.other_items())
40 Other->dump(Dumper&: *this);
41 for (const auto &Func : Layout.funcs())
42 Func->dump(Dumper&: *this);
43 }
44
45 const BitVector &UseMap = Layout.usedBytes();
46 int NextPaddingByte = UseMap.find_first_unset();
47
48 for (const 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(Amount: RelativeOffset - NextPaddingByte);
63 NextPaddingByte = UseMap.find_next_unset(Prev: 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(Offset: CurrentAbsoluteOffset, Size: Layout.getSize());
73 } else {
74 if (auto Sym = Item->getSymbol())
75 Sym->dump(Dumper&: *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
98void 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
108void 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(p: Label.begin(), c: 'v');
118 if (Layout.getBase().isIndirectVirtualBaseClass())
119 Label.insert(p: Label.begin(), c: '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(N: CurrentAbsoluteOffset, Width: 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
143bool PrettyClassLayoutGraphicalDumper::shouldRecurse() const {
144 uint32_t Limit = opts::pretty::ClassRecursionDepth;
145 if (Limit == 0)
146 return true;
147 return RecursionLevel < Limit;
148}
149
150void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolData &Symbol) {
151 VariableDumper VarDumper(Printer);
152 VarDumper.start(Var: Symbol, Offset: 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: Layout.getUDTLayout());
164 Printer.Unindent();
165 }
166 }
167
168 DumpedAnything = true;
169}
170
171void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolTypeVTable &Symbol) {
172 assert(CurrentItem != nullptr);
173
174 VariableDumper VarDumper(Printer);
175 VarDumper.start(Var: Symbol, Offset: ClassOffsetZero);
176
177 DumpedAnything = true;
178}
179
180void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolTypeEnum &Symbol) {
181 DumpedAnything = true;
182 Printer.NewLine();
183 EnumDumper Dumper(Printer);
184 Dumper.start(Symbol);
185}
186
187void PrettyClassLayoutGraphicalDumper::dump(
188 const PDBSymbolTypeTypedef &Symbol) {
189 DumpedAnything = true;
190 Printer.NewLine();
191 TypedefDumper Dumper(Printer);
192 Dumper.start(Symbol);
193}
194
195void PrettyClassLayoutGraphicalDumper::dump(
196 const PDBSymbolTypeBuiltin &Symbol) {}
197
198void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolTypeUDT &Symbol) {}
199
200void PrettyClassLayoutGraphicalDumper::dump(const PDBSymbolFunc &Symbol) {
201 if (Printer.IsSymbolExcluded(SymbolName: 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, Pointer: FunctionDumper::PointerType::None);
213}
214