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
  14 #include "llvm/DebugInfo/PDB/IPDBSession.h"
  15 #include "llvm/DebugInfo/PDB/PDBExtras.h"
  16 #include "llvm/DebugInfo/PDB/PDBSymbolData.h"
  17 #include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
  18 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
  19 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
  20 #include "llvm/DebugInfo/PDB/PDBSymbolTypeArray.h"
  21 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
  22 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
  23 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
  24 #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
  25 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
  26 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
  27 #include "llvm/Support/Format.h"
  28 #include "llvm/Support/FormatVariadic.h"
  29
  30 using namespace llvm;
  31 using namespace llvm::codeview;
  32 using namespace llvm::pdb;
  33
  34 namespace {
  35 template <class T>
  36 void dumpClassParentWithScopeOperator(const T &Symbol, LinePrinter &Printer,
  37                                       FunctionDumper &Dumper) {
  38   uint32_t ClassParentId = Symbol.getClassParentId();
  39   auto ClassParent =
  40       Symbol.getSession().template getConcreteSymbolById<PDBSymbolTypeUDT>(
  41           ClassParentId);
  42   if (!ClassParent)
  43     return;
  44
  45   WithColor(Printer, PDB_ColorItem::Type).get() << ClassParent->getName();
  46   Printer << "::";
  47 }
  48 }
  49
  50 FunctionDumper::FunctionDumper(LinePrinter &P)
  51     : PDBSymDumper(true), Printer(P) {}
  52
  53 void FunctionDumper::start(const PDBSymbolTypeFunctionSig &Symbol,
  54                            const char *Name, PointerType Pointer) {
  55   auto ReturnType = Symbol.getReturnType();
  56   if (!ReturnType)
  57     Printer << "<unknown-type>";
  58   else
  59     ReturnType->dump(*this);
  60   Printer << " ";
  61   uint32_t ClassParentId = Symbol.getClassParentId();
  62   auto ClassParent =
  63       Symbol.getSession().getConcreteSymbolById<PDBSymbolTypeUDT>(
  64           ClassParentId);
  65
  66   PDB_CallingConv CC = Symbol.getCallingConvention();
  67   bool ShouldDumpCallingConvention = true;
  68   if ((ClassParent && CC == CallingConvention::ThisCall) ||
  69       (!ClassParent && CC == CallingConvention::NearStdCall)) {
  70     ShouldDumpCallingConvention = false;
  71   }
  72
  73   if (Pointer == PointerType::None) {
  74     if (ShouldDumpCallingConvention)
  75       WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
  76     if (ClassParent) {
  77       Printer << "(";
  78       WithColor(Printer, PDB_ColorItem::Identifier).get()
  79           << ClassParent->getName();
  80       Printer << "::)";
  81     }
  82   } else {
  83     Printer << "(";
  84     if (ShouldDumpCallingConvention)
  85       WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
  86     if (ClassParent) {
  87       WithColor(Printer, PDB_ColorItem::Identifier).get()
  88           << ClassParent->getName();
  89       Printer << "::";
  90     }
  91     if (Pointer == PointerType::Reference)
  92       Printer << "&";
  93     else
  94       Printer << "*";
  95     if (Name)
  96       WithColor(Printer, PDB_ColorItem::Identifier).get() << Name;
  97     Printer << ")";
  98   }
  99
 100   Printer << "(";
 101   if (auto ChildEnum = Symbol.getArguments()) {
 102     uint32_t Index = 0;
 103     while (auto Arg = ChildEnum->getNext()) {
 104       Arg->dump(*this);
 105       if (++Index < ChildEnum->getChildCount())
 106         Printer << ", ";
 107     }
 108   }
 109   Printer << ")";
 110
 111   if (Symbol.isConstType())
 112     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
 113   if (Symbol.isVolatileType())
 114     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
 115 }
 116
 117 void FunctionDumper::start(const PDBSymbolFunc &Symbol, PointerType Pointer) {
 118   uint64_t FuncStart = Symbol.getVirtualAddress();
 119   uint64_t FuncEnd = FuncStart + Symbol.getLength();
 120
 121   Printer << "func [";
 122   WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(FuncStart, 10);
 123   if (auto DebugStart = Symbol.findOneChild<PDBSymbolFuncDebugStart>()) {
 124     uint64_t Prologue = DebugStart->getVirtualAddress() - FuncStart;
 125     WithColor(Printer, PDB_ColorItem::Offset).get()
 126         << formatv("+{0,2}", Prologue);
 127   }
 128   Printer << " - ";
 129   WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(FuncEnd, 10);
 130   if (auto DebugEnd = Symbol.findOneChild<PDBSymbolFuncDebugEnd>()) {
 131     uint64_t Epilogue = FuncEnd - DebugEnd->getVirtualAddress();
 132     WithColor(Printer, PDB_ColorItem::Offset).get()
 133         << formatv("-{0,2}", Epilogue);
 134   }
 135
 136   WithColor(Printer, PDB_ColorItem::Comment).get()
 137       << formatv(" | sizeof={0,3}", Symbol.getLength());
 138   Printer << "] (";
 139
 140   if (Symbol.hasFramePointer()) {
 141     WithColor(Printer, PDB_ColorItem::Register).get()
 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
 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
 216 void FunctionDumper::dump(const PDBSymbolTypeBuiltin &Symbol) {
 217   BuiltinDumper Dumper(Printer);
 218   Dumper.start(Symbol);
 219 }
 220
 221 void FunctionDumper::dump(const PDBSymbolTypeEnum &Symbol) {
 222   dumpClassParentWithScopeOperator(Symbol, Printer, *this);
 223   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
 224 }
 225
 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     Printer << "<unknown-type>";
 233   else
 234     Type->dump(*this);
 235 }
 236
 237 void FunctionDumper::dump(const PDBSymbolTypeTypedef &Symbol) {
 238   dumpClassParentWithScopeOperator(Symbol, Printer, *this);
 239   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
 240 }
 241
 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
 265 void FunctionDumper::dump(const PDBSymbolTypeUDT &Symbol) {
 266   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
 267 }