1//===- PrettyVariableDumper.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 "PrettyVariableDumper.h"
10
11#include "LinePrinter.h"
12#include "PrettyBuiltinDumper.h"
13#include "PrettyFunctionDumper.h"
14#include "llvm-pdbutil.h"
15
16#include "llvm/DebugInfo/PDB/IPDBSession.h"
17#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
18#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
19#include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
20#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
21#include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.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/DebugInfo/PDB/PDBTypes.h"
27
28#include "llvm/Support/Format.h"
29
30using namespace llvm;
31using namespace llvm::codeview;
32using namespace llvm::pdb;
33
34VariableDumper::VariableDumper(LinePrinter &P)
35    : PDBSymDumper(true), Printer(P) {}
36
37void VariableDumper::start(const PDBSymbolData &Var, uint32_t Offset) {
38  if (Var.isCompilerGenerated() && opts::pretty::ExcludeCompilerGenerated)
39    return;
40  if (Printer.IsSymbolExcluded(Var.getName()))
41    return;
42
43  auto VarType = Var.getType();
44
45  uint64_t Length = VarType->getRawSymbol().getLength();
46
47  switch (auto LocType = Var.getLocationType()) {
48  case PDB_LocType::Static:
49    Printer.NewLine();
50    Printer << "data [";
51    WithColor(Printer, PDB_ColorItem::Address).get()
52        << format_hex(Var.getVirtualAddress(), 10);
53    Printer << ", sizeof=" << Length << "] ";
54    WithColor(Printer, PDB_ColorItem::Keyword).get() << "static ";
55    dumpSymbolTypeAndName(*VarType, Var.getName());
56    break;
57  case PDB_LocType::Constant:
58    if (isa<PDBSymbolTypeEnum>(*VarType))
59      break;
60    Printer.NewLine();
61    Printer << "data [sizeof=" << Length << "] ";
62    dumpSymbolTypeAndName(*VarType, Var.getName());
63    Printer << " = ";
64    WithColor(Printer, PDB_ColorItem::LiteralValue).get() << Var.getValue();
65    break;
66  case PDB_LocType::ThisRel:
67    Printer.NewLine();
68    Printer << "data ";
69    WithColor(Printer, PDB_ColorItem::Offset).get()
70        << "+" << format_hex(Offset + Var.getOffset(), 4)
71        << " [sizeof=" << Length << "] ";
72    dumpSymbolTypeAndName(*VarType, Var.getName());
73    break;
74  case PDB_LocType::BitField:
75    Printer.NewLine();
76    Printer << "data ";
77    WithColor(Printer, PDB_ColorItem::Offset).get()
78        << "+" << format_hex(Offset + Var.getOffset(), 4)
79        << " [sizeof=" << Length << "] ";
80    dumpSymbolTypeAndName(*VarType, Var.getName());
81    Printer << " : ";
82    WithColor(Printer, PDB_ColorItem::LiteralValue).get() << Var.getLength();
83    break;
84  default:
85    Printer.NewLine();
86    Printer << "data [sizeof=" << Length << "] ";
87    Printer << "unknown(" << LocType << ") ";
88    WithColor(Printer, PDB_ColorItem::Identifier).get() << Var.getName();
89    break;
90  }
91}
92
93void VariableDumper::startVbptr(uint32_t Offset, uint32_t Size) {
94  Printer.NewLine();
95  Printer << "vbptr ";
96
97  WithColor(Printer, PDB_ColorItem::Offset).get()
98      << "+" << format_hex(Offset, 4) << " [sizeof=" << Size << "] ";
99}
100
101void VariableDumper::start(const PDBSymbolTypeVTable &Var, uint32_t Offset) {
102  Printer.NewLine();
103  Printer << "vfptr ";
104  auto VTableType = cast<PDBSymbolTypePointer>(Var.getType());
105  uint32_t PointerSize = VTableType->getLength();
106
107  WithColor(Printer, PDB_ColorItem::Offset).get()
108      << "+" << format_hex(Offset + Var.getOffset(), 4)
109      << " [sizeof=" << PointerSize << "] ";
110}
111
112void VariableDumper::dump(const PDBSymbolTypeArray &Symbol) {
113  auto ElementType = Symbol.getElementType();
114  assert(ElementType);
115  if (!ElementType)
116    return;
117  ElementType->dump(*this);
118}
119
120void VariableDumper::dumpRight(const PDBSymbolTypeArray &Symbol) {
121  auto ElementType = Symbol.getElementType();
122  assert(ElementType);
123  if (!ElementType)
124    return;
125  Printer << '[' << Symbol.getCount() << ']';
126  ElementType->dumpRight(*this);
127}
128
129void VariableDumper::dump(const PDBSymbolTypeBuiltin &Symbol) {
130  BuiltinDumper Dumper(Printer);
131  Dumper.start(Symbol);
132}
133
134void VariableDumper::dump(const PDBSymbolTypeEnum &Symbol) {
135  WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
136}
137
138void VariableDumper::dump(const PDBSymbolTypeFunctionSig &Symbol) {
139  auto ReturnType = Symbol.getReturnType();
140  ReturnType->dump(*this);
141  Printer << " ";
142
143  uint32_t ClassParentId = Symbol.getClassParentId();
144  auto ClassParent =
145      Symbol.getSession().getConcreteSymbolById<PDBSymbolTypeUDT>(
146          ClassParentId);
147
148  if (ClassParent) {
149    WithColor(Printer, PDB_ColorItem::Identifier).get()
150      << ClassParent->getName();
151    Printer << "::";
152  }
153}
154
155void VariableDumper::dumpRight(const PDBSymbolTypeFunctionSig &Symbol) {
156  Printer << "(";
157  if (auto Arguments = Symbol.getArguments()) {
158    uint32_t Index = 0;
159    while (auto Arg = Arguments->getNext()) {
160      Arg->dump(*this);
161      if (++Index < Arguments->getChildCount())
162        Printer << ", ";
163    }
164  }
165  Printer << ")";
166
167  if (Symbol.isConstType())
168    WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
169  if (Symbol.isVolatileType())
170    WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
171
172  if (Symbol.getRawSymbol().isRestrictedType())
173    WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
174}
175
176void VariableDumper::dump(const PDBSymbolTypePointer &Symbol) {
177  auto PointeeType = Symbol.getPointeeType();
178  if (!PointeeType)
179    return;
180  PointeeType->dump(*this);
181  if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
182    // A hack to get the calling convention in the right spot.
183    Printer << " (";
184    PDB_CallingConv CC = FuncSig->getCallingConvention();
185    WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
186  } else if (isa<PDBSymbolTypeArray>(PointeeType)) {
187    Printer << " (";
188  }
189  Printer << (Symbol.isReference() ? "&" : "*");
190  if (Symbol.isConstType())
191    WithColor(Printer, PDB_ColorItem::Keyword).get() << " const ";
192  if (Symbol.isVolatileType())
193    WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile ";
194
195  if (Symbol.getRawSymbol().isRestrictedType())
196    WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict ";
197}
198
199void VariableDumper::dumpRight(const PDBSymbolTypePointer &Symbol) {
200  auto PointeeType = Symbol.getPointeeType();
201  assert(PointeeType);
202  if (!PointeeType)
203    return;
204  if (isa<PDBSymbolTypeFunctionSig>(PointeeType) ||
205      isa<PDBSymbolTypeArray>(PointeeType)) {
206    Printer << ")";
207  }
208  PointeeType->dumpRight(*this);
209}
210
211void VariableDumper::dump(const PDBSymbolTypeTypedef &Symbol) {
212  WithColor(Printer, PDB_ColorItem::Keyword).get() << "typedef ";
213  WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
214}
215
216void VariableDumper::dump(const PDBSymbolTypeUDT &Symbol) {
217  WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
218}
219
220void VariableDumper::dumpSymbolTypeAndName(const PDBSymbol &Type,
221                                           StringRef Name) {
222  Type.dump(*this);
223  WithColor(Printer, PDB_ColorItem::Identifier).get() << " " << Name;
224  Type.dumpRight(*this);
225}
226