contrib/llvm/tools/llvm-pdbutil/PrettyFunctionDumper.cpp

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