1 //===- PrettyFunctionDumper.cpp --------------------------------- *- 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 "PrettyFunctionDumper.h"
10 #include "LinePrinter.h"
11 #include "PrettyBuiltinDumper.h"
12 
13 #include "llvm/DebugInfo/PDB/IPDBSession.h"
14 #include "llvm/DebugInfo/PDB/PDBExtras.h"
15 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
16 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
17 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
18 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
19 #include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
20 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
21 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
22 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
23 #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
24 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
25 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
26 #include "llvm/Support/Format.h"
27 #include "llvm/Support/FormatVariadic.h"
28 
29 using namespace llvm;
30 using namespace llvm::codeview;
31 using namespace llvm::pdb;
32 
33 namespace {
34 template <class T>
dumpClassParentWithScopeOperator(const T & Symbol,LinePrinter & Printer,FunctionDumper & Dumper)35 void dumpClassParentWithScopeOperator(const T &Symbol, LinePrinter &Printer,
36                                       FunctionDumper &Dumper) {
37   uint32_t ClassParentId = Symbol.getClassParentId();
38   auto ClassParent =
39       Symbol.getSession().template getConcreteSymbolById<PDBSymbolTypeUDT>(
40           ClassParentId);
41   if (!ClassParent)
42     return;
43 
44   WithColor(Printer, PDB_ColorItem::Type).get() << ClassParent->getName();
45   Printer << "::";
46 }
47 }
48 
FunctionDumper(LinePrinter & P)49 FunctionDumper::FunctionDumper(LinePrinter &P)
50     : PDBSymDumper(true), Printer(P) {}
51 
start(const PDBSymbolTypeFunctionSig & Symbol,const char * Name,PointerType Pointer)52 void FunctionDumper::start(const PDBSymbolTypeFunctionSig &Symbol,
53                            const char *Name, PointerType Pointer) {
54   auto ReturnType = Symbol.getReturnType();
55   if (!ReturnType)
56     Printer << "<unknown-type>";
57   else
58     ReturnType->dump(*this);
59   Printer << " ";
60   uint32_t ClassParentId = Symbol.getClassParentId();
61   auto ClassParent =
62       Symbol.getSession().getConcreteSymbolById<PDBSymbolTypeUDT>(
63           ClassParentId);
64 
65   PDB_CallingConv CC = Symbol.getCallingConvention();
66   bool ShouldDumpCallingConvention = true;
67   if ((ClassParent && CC == CallingConvention::ThisCall) ||
68       (!ClassParent && CC == CallingConvention::NearStdCall)) {
69     ShouldDumpCallingConvention = false;
70   }
71 
72   if (Pointer == PointerType::None) {
73     if (ShouldDumpCallingConvention)
74       WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
75     if (ClassParent) {
76       Printer << "(";
77       WithColor(Printer, PDB_ColorItem::Identifier).get()
78           << ClassParent->getName();
79       Printer << "::)";
80     }
81   } else {
82     Printer << "(";
83     if (ShouldDumpCallingConvention)
84       WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
85     if (ClassParent) {
86       WithColor(Printer, PDB_ColorItem::Identifier).get()
87           << ClassParent->getName();
88       Printer << "::";
89     }
90     if (Pointer == PointerType::Reference)
91       Printer << "&";
92     else
93       Printer << "*";
94     if (Name)
95       WithColor(Printer, PDB_ColorItem::Identifier).get() << Name;
96     Printer << ")";
97   }
98 
99   Printer << "(";
100   if (auto ChildEnum = Symbol.getArguments()) {
101     uint32_t Index = 0;
102     while (auto Arg = ChildEnum->getNext()) {
103       Arg->dump(*this);
104       if (++Index < ChildEnum->getChildCount())
105         Printer << ", ";
106     }
107   }
108   Printer << ")";
109 
110   if (Symbol.isConstType())
111     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
112   if (Symbol.isVolatileType())
113     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
114 }
115 
start(const PDBSymbolFunc & Symbol,PointerType Pointer)116 void FunctionDumper::start(const PDBSymbolFunc &Symbol, PointerType Pointer) {
117   uint64_t FuncStart = Symbol.getVirtualAddress();
118   uint64_t FuncEnd = FuncStart + Symbol.getLength();
119 
120   Printer << "func [";
121   WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(FuncStart, 10);
122   if (auto DebugStart = Symbol.findOneChild<PDBSymbolFuncDebugStart>()) {
123     uint64_t Prologue = DebugStart->getVirtualAddress() - FuncStart;
124     WithColor(Printer, PDB_ColorItem::Offset).get()
125         << formatv("+{0,2}", Prologue);
126   }
127   Printer << " - ";
128   WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(FuncEnd, 10);
129   if (auto DebugEnd = Symbol.findOneChild<PDBSymbolFuncDebugEnd>()) {
130     uint64_t Epilogue = FuncEnd - DebugEnd->getVirtualAddress();
131     WithColor(Printer, PDB_ColorItem::Offset).get()
132         << formatv("-{0,2}", Epilogue);
133   }
134 
135   WithColor(Printer, PDB_ColorItem::Comment).get()
136       << formatv(" | sizeof={0,3}", Symbol.getLength());
137   Printer << "] (";
138 
139   if (Symbol.hasFramePointer()) {
140     WithColor(Printer, PDB_ColorItem::Register).get()
141         << CPURegister{Symbol.getRawSymbol().getPlatform(),
142                        Symbol.getLocalBasePointerRegisterId()};
143   } else {
144     WithColor(Printer, PDB_ColorItem::Register).get() << "FPO";
145   }
146   Printer << ") ";
147 
148   if (Symbol.isVirtual() || Symbol.isPureVirtual())
149     WithColor(Printer, PDB_ColorItem::Keyword).get() << "virtual ";
150 
151   auto Signature = Symbol.getSignature();
152   if (!Signature) {
153     WithColor(Printer, PDB_ColorItem::Identifier).get() << Symbol.getName();
154     if (Pointer == PointerType::Pointer)
155       Printer << "*";
156     else if (Pointer == FunctionDumper::PointerType::Reference)
157       Printer << "&";
158     return;
159   }
160 
161   auto ReturnType = Signature->getReturnType();
162   ReturnType->dump(*this);
163   Printer << " ";
164 
165   auto ClassParent = Symbol.getClassParent();
166   CallingConvention CC = Signature->getCallingConvention();
167   if (Pointer != FunctionDumper::PointerType::None)
168     Printer << "(";
169 
170   if ((ClassParent && CC != CallingConvention::ThisCall) ||
171       (!ClassParent && CC != CallingConvention::NearStdCall)) {
172     WithColor(Printer, PDB_ColorItem::Keyword).get()
173         << Signature->getCallingConvention() << " ";
174   }
175   WithColor(Printer, PDB_ColorItem::Identifier).get() << Symbol.getName();
176   if (Pointer != FunctionDumper::PointerType::None) {
177     if (Pointer == PointerType::Pointer)
178       Printer << "*";
179     else if (Pointer == FunctionDumper::PointerType::Reference)
180       Printer << "&";
181     Printer << ")";
182   }
183 
184   Printer << "(";
185   if (auto Arguments = Symbol.getArguments()) {
186     uint32_t Index = 0;
187     while (auto Arg = Arguments->getNext()) {
188       auto ArgType = Arg->getType();
189       ArgType->dump(*this);
190       WithColor(Printer, PDB_ColorItem::Identifier).get() << " "
191                                                           << Arg->getName();
192       if (++Index < Arguments->getChildCount())
193         Printer << ", ";
194     }
195     if (Signature->isCVarArgs())
196       Printer << ", ...";
197   }
198   Printer << ")";
199   if (Symbol.isConstType())
200     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
201   if (Symbol.isVolatileType())
202     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
203   if (Symbol.isPureVirtual())
204     Printer << " = 0";
205 }
206 
dump(const PDBSymbolTypeArray & Symbol)207 void FunctionDumper::dump(const PDBSymbolTypeArray &Symbol) {
208   auto ElementType = Symbol.getElementType();
209 
210   ElementType->dump(*this);
211   Printer << "[";
212   WithColor(Printer, PDB_ColorItem::LiteralValue).get() << Symbol.getLength();
213   Printer << "]";
214 }
215 
dump(const PDBSymbolTypeBuiltin & Symbol)216 void FunctionDumper::dump(const PDBSymbolTypeBuiltin &Symbol) {
217   BuiltinDumper Dumper(Printer);
218   Dumper.start(Symbol);
219 }
220 
dump(const PDBSymbolTypeEnum & Symbol)221 void FunctionDumper::dump(const PDBSymbolTypeEnum &Symbol) {
222   dumpClassParentWithScopeOperator(Symbol, Printer, *this);
223   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
224 }
225 
dump(const PDBSymbolTypeFunctionArg & Symbol)226 void FunctionDumper::dump(const PDBSymbolTypeFunctionArg &Symbol) {
227   // PDBSymbolTypeFunctionArg is just a shim over the real argument.  Just drill
228   // through to the real thing and dump it.
229   uint32_t TypeId = Symbol.getTypeId();
230   auto Type = Symbol.getSession().getSymbolById(TypeId);
231   if (Type)
232     Type->dump(*this);
233   else
234     Printer << "<unknown-type>";
235 }
236 
dump(const PDBSymbolTypeTypedef & Symbol)237 void FunctionDumper::dump(const PDBSymbolTypeTypedef &Symbol) {
238   dumpClassParentWithScopeOperator(Symbol, Printer, *this);
239   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
240 }
241 
dump(const PDBSymbolTypePointer & Symbol)242 void FunctionDumper::dump(const PDBSymbolTypePointer &Symbol) {
243   auto PointeeType = Symbol.getPointeeType();
244   if (!PointeeType)
245     return;
246 
247   if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
248     FunctionDumper NestedDumper(Printer);
249     PointerType Pointer =
250         Symbol.isReference() ? PointerType::Reference : PointerType::Pointer;
251     NestedDumper.start(*FuncSig, nullptr, Pointer);
252   } else {
253     if (Symbol.isConstType())
254       WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
255     if (Symbol.isVolatileType())
256       WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
257     PointeeType->dump(*this);
258     Printer << (Symbol.isReference() ? "&" : "*");
259 
260     if (Symbol.getRawSymbol().isRestrictedType())
261       WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
262   }
263 }
264 
dump(const PDBSymbolTypeUDT & Symbol)265 void FunctionDumper::dump(const PDBSymbolTypeUDT &Symbol) {
266   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
267 }
268