summaryrefslogtreecommitdiffstats
path: root/llvm/lib/DebugInfo/PDB
diff options
context:
space:
mode:
Diffstat (limited to 'llvm/lib/DebugInfo/PDB')
-rw-r--r--llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp86
-rw-r--r--llvm/lib/DebugInfo/PDB/PDBExtras.cpp97
-rw-r--r--llvm/lib/DebugInfo/PDB/PDBSymbolData.cpp59
-rw-r--r--llvm/lib/DebugInfo/PDB/PDBSymbolExe.cpp11
-rw-r--r--llvm/lib/DebugInfo/PDB/PDBSymbolFunc.cpp37
5 files changed, 250 insertions, 40 deletions
diff --git a/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp b/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp
index 530d3b5deb5..e9e5ce2fc7b 100644
--- a/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp
+++ b/llvm/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp
@@ -18,6 +18,60 @@
using namespace llvm;
namespace {
+Variant VariantFromVARIANT(const VARIANT &V) {
+ Variant Result;
+ switch (V.vt) {
+ case VT_I1:
+ Result.Int8 = V.cVal;
+ Result.Type = PDB_VariantType::Int8;
+ break;
+ case VT_I2:
+ Result.Int16 = V.iVal;
+ Result.Type = PDB_VariantType::Int16;
+ break;
+ case VT_I4:
+ Result.Int32 = V.intVal;
+ Result.Type = PDB_VariantType::Int32;
+ break;
+ case VT_I8:
+ Result.Int64 = V.llVal;
+ Result.Type = PDB_VariantType::Int64;
+ break;
+ case VT_UI1:
+ Result.UInt8 = V.bVal;
+ Result.Type = PDB_VariantType::UInt8;
+ break;
+ case VT_UI2:
+ Result.UInt16 = V.uiVal;
+ Result.Type = PDB_VariantType::UInt16;
+ break;
+ case VT_UI4:
+ Result.UInt32 = V.uintVal;
+ Result.Type = PDB_VariantType::UInt32;
+ break;
+ case VT_UI8:
+ Result.UInt64 = V.ullVal;
+ Result.Type = PDB_VariantType::UInt64;
+ break;
+ case VT_BOOL:
+ Result.Bool = (V.boolVal == VARIANT_TRUE) ? true : false;
+ Result.Type = PDB_VariantType::Bool;
+ break;
+ case VT_R4:
+ Result.Single = V.fltVal;
+ Result.Type = PDB_VariantType::Single;
+ break;
+ case VT_R8:
+ Result.Double = V.dblVal;
+ Result.Type = PDB_VariantType::Double;
+ break;
+ default:
+ Result.Type = PDB_VariantType::Unknown;
+ break;
+ }
+ return Result;
+}
+
template <typename ArgType>
ArgType PrivateGetDIAValue(IDiaSymbol *Symbol,
HRESULT (__stdcall IDiaSymbol::*Method)(ArgType *)) {
@@ -93,6 +147,18 @@ void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,
}
::SysFreeString(Value);
}
+
+void DumpDIAValue(llvm::raw_ostream &OS, int Indent, StringRef Name,
+ IDiaSymbol *Symbol,
+ HRESULT (__stdcall IDiaSymbol::*Method)(VARIANT *)) {
+ VARIANT Value;
+ Value.vt = VT_EMPTY;
+ if (S_OK != (Symbol->*Method)(&Value))
+ return;
+ Variant V = VariantFromVARIANT(Value);
+ OS.indent(Indent);
+ OS << V;
+}
}
namespace llvm {
@@ -276,6 +342,9 @@ void DIARawSymbol::dump(raw_ostream &OS, int Indent,
RAW_METHOD_DUMP(OS, get_virtualBaseClass)
RAW_METHOD_DUMP(OS, get_isVirtualInheritance)
RAW_METHOD_DUMP(OS, get_volatileType)
+ RAW_METHOD_DUMP(OS, get_wasInlined)
+ RAW_METHOD_DUMP(OS, get_unused)
+ RAW_METHOD_DUMP(OS, get_value)
}
std::unique_ptr<IPDBEnumSymbols>
@@ -611,6 +680,15 @@ uint32_t DIARawSymbol::getUpperBoundId() const {
return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_upperBoundId);
}
+Variant DIARawSymbol::getValue() const {
+ VARIANT Value;
+ Value.vt = VT_EMPTY;
+ if (S_OK != Symbol->get_value(&Value))
+ return Variant();
+
+ return VariantFromVARIANT(Value);
+}
+
uint32_t DIARawSymbol::getVirtualBaseDispIndex() const {
return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_virtualBaseDispIndex);
}
@@ -1006,3 +1084,11 @@ bool DIARawSymbol::isVirtualInheritance() const {
bool DIARawSymbol::isVolatileType() const {
return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_volatileType);
}
+
+bool DIARawSymbol::wasInlined() const {
+ return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_wasInlined);
+}
+
+std::string DIARawSymbol::getUnused() const {
+ return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_unused);
+}
diff --git a/llvm/lib/DebugInfo/PDB/PDBExtras.cpp b/llvm/lib/DebugInfo/PDB/PDBExtras.cpp
index 28870870de5..9ead764ae76 100644
--- a/llvm/lib/DebugInfo/PDB/PDBExtras.cpp
+++ b/llvm/lib/DebugInfo/PDB/PDBExtras.cpp
@@ -25,6 +25,41 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const stream_indent &Indent) {
return OS;
}
+raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_VariantType &Type) {
+ switch (Type) {
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Bool, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Single, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Double, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Int8, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Int16, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Int32, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, Int64, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, UInt8, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, UInt16, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, UInt32, OS)
+ CASE_OUTPUT_ENUM_CLASS_NAME(PDB_VariantType, UInt64, OS)
+ default:
+ OS << "Unknown";
+ }
+ return OS;
+}
+
+raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_DataKind &Data) {
+ switch (Data) {
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Unknown, "unknown", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Local, "local", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, StaticLocal, "static local", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Param, "param", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, ObjectPtr, "this ptr", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, FileStatic, "static global", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Global, "global", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Member, "member", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, StaticMember, "static member", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_DataKind, Constant, "const", OS)
+ }
+ return OS;
+}
+
raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_RegisterId &Reg) {
switch (Reg) {
CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AL, OS)
@@ -82,16 +117,16 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_RegisterId &Reg) {
raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_LocType &Loc) {
switch (Loc) {
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, Static, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, TLS, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, RegRel, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, ThisRel, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, Enregistered, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, BitField, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, Slot, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, IlRel, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, MetaData, OS)
- CASE_OUTPUT_ENUM_CLASS_NAME(PDB_LocType, Constant, OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, Static, "static", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, TLS, "tls", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, RegRel, "regrel", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, ThisRel, "thisrel", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, Enregistered, "register", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, BitField, "bitfield", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, Slot, "slot", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, IlRel, "IL rel", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, MetaData, "metadata", OS)
+ CASE_OUTPUT_ENUM_CLASS_STR(PDB_LocType, Constant, "constant", OS)
default:
OS << "Unknown";
}
@@ -200,6 +235,48 @@ raw_ostream &llvm::operator<<(raw_ostream &OS, const PDB_UniqueId &Id) {
return OS;
}
+raw_ostream &llvm::operator<<(raw_ostream &OS, const Variant &Value) {
+ switch (Value.Type) {
+ case PDB_VariantType::Bool:
+ OS << (Value.Bool ? "true" : "false");
+ break;
+ case PDB_VariantType::Double:
+ OS << Value.Double;
+ break;
+ case PDB_VariantType::Int16:
+ OS << Value.Int16;
+ break;
+ case PDB_VariantType::Int32:
+ OS << Value.Int32;
+ break;
+ case PDB_VariantType::Int64:
+ OS << Value.Int64;
+ break;
+ case PDB_VariantType::Int8:
+ OS << Value.Int8;
+ break;
+ case PDB_VariantType::Single:
+ OS << Value.Single;
+ break;
+ case PDB_VariantType::UInt16:
+ OS << Value.Double;
+ break;
+ case PDB_VariantType::UInt32:
+ OS << Value.UInt32;
+ break;
+ case PDB_VariantType::UInt64:
+ OS << Value.UInt64;
+ break;
+ case PDB_VariantType::UInt8:
+ OS << Value.UInt8;
+ break;
+ default:
+ OS << Value.Type;
+ }
+ OS << " {" << Value.Type << "}";
+ return OS;
+}
+
raw_ostream &llvm::operator<<(raw_ostream &OS, const VersionInfo &Version) {
OS << Version.Major << "." << Version.Minor << "." << Version.Build;
return OS;
diff --git a/llvm/lib/DebugInfo/PDB/PDBSymbolData.cpp b/llvm/lib/DebugInfo/PDB/PDBSymbolData.cpp
index bffad8af751..3c4be3ad2d0 100644
--- a/llvm/lib/DebugInfo/PDB/PDBSymbolData.cpp
+++ b/llvm/lib/DebugInfo/PDB/PDBSymbolData.cpp
@@ -8,8 +8,10 @@
//===----------------------------------------------------------------------===//
#include <utility>
+#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/PDBExtras.h"
#include "llvm/DebugInfo/PDB/PDBSymbolData.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
#include "llvm/Support/Format.h"
@@ -21,48 +23,69 @@ PDBSymbolData::PDBSymbolData(const IPDBSession &PDBSession,
void PDBSymbolData::dump(raw_ostream &OS, int Indent,
PDB_DumpLevel Level) const {
- OS.indent(Indent);
+ OS << stream_indent(Indent);
+ PDB_LocType Loc = getLocationType();
+ PDB_DataKind Kind = getDataKind();
if (Level == PDB_DumpLevel::Compact) {
- PDB_LocType Loc = getLocationType();
- OS << Loc << " data [";
- int Length;
switch (Loc) {
- case PDB_LocType::Static:
- OS << format_hex(getRelativeVirtualAddress(), 10);
- Length = getLength();
+ case PDB_LocType::Static: {
+ uint32_t RVA = getRelativeVirtualAddress();
+ OS << Kind << " data[";
+ if (RVA != 0)
+ OS << format_hex(RVA, 10);
+ else
+ OS << "???";
break;
+ }
case PDB_LocType::TLS:
+ OS << "threadlocal " << Kind << " data[";
OS << getAddressSection() << ":" << format_hex(getAddressOffset(), 10);
break;
case PDB_LocType::RegRel:
- OS << getRegisterId() << " + " << getOffset() << "]";
+ OS << "regrel " << Kind << " data[";
+ OS << getRegisterId() << " + " << getOffset();
break;
- case PDB_LocType::ThisRel:
- OS << "this + " << getOffset() << "]";
+ case PDB_LocType::ThisRel: {
+ uint32_t Offset = getOffset();
+ OS << Kind << " data[this + " << format_hex(Offset, 4);
break;
+ }
case PDB_LocType::Enregistered:
- OS << getRegisterId() << "]";
+ OS << "register " << Kind << " data[" << getRegisterId();
break;
case PDB_LocType::BitField: {
+ OS << "bitfield data[this + ";
uint32_t Offset = getOffset();
uint32_t BitPos = getBitPosition();
uint32_t Length = getLength();
- uint32_t StartBits = 8 - BitPos;
- uint32_t MiddleBytes = (Length - StartBits) / 8;
- uint32_t EndBits = Length - StartBits - MiddleBytes * 8;
- OS << format_hex(Offset, 10) << ":" << BitPos;
- OS << " - " << format_hex(Offset + MiddleBytes, 10) << ":" << EndBits;
+ OS << format_hex(Offset, 4) << ":" << BitPos << "," << Length;
break;
}
case PDB_LocType::Slot:
OS << getSlot();
+ break;
+ case PDB_LocType::Constant: {
+ OS << "constant data[";
+ OS << getValue();
+ break;
+ }
case PDB_LocType::IlRel:
case PDB_LocType::MetaData:
- case PDB_LocType::Constant:
default:
OS << "???";
}
- OS << "] ";
+ }
+ OS << "] ";
+ if (Kind == PDB_DataKind::Member || Kind == PDB_DataKind::StaticMember) {
+ uint32_t ClassId = getClassParentId();
+ if (auto Class = Session.getSymbolById(ClassId)) {
+ if (auto UDT = dyn_cast<PDBSymbolTypeUDT>(Class.get()))
+ OS << UDT->getName();
+ else
+ OS << "{class " << Class->getSymTag() << "}";
+ OS << "::";
+ }
}
OS << getName() << "\n";
+ OS.flush();
} \ No newline at end of file
diff --git a/llvm/lib/DebugInfo/PDB/PDBSymbolExe.cpp b/llvm/lib/DebugInfo/PDB/PDBSymbolExe.cpp
index c058949991b..4f999d9138e 100644
--- a/llvm/lib/DebugInfo/PDB/PDBSymbolExe.cpp
+++ b/llvm/lib/DebugInfo/PDB/PDBSymbolExe.cpp
@@ -29,10 +29,6 @@ void PDBSymbolExe::dump(raw_ostream &OS, int Indent,
OS << "Summary for " << FileName << "\n";
- TagStats Stats;
- auto ChildrenEnum = getChildStats(Stats);
- OS << stream_indent(Indent + 2) << "Children: " << Stats << "\n";
-
uint64_t FileSize = 0;
if (!llvm::sys::fs::file_size(FileName, FileSize))
OS << " Size: " << FileSize << " bytes\n";
@@ -47,4 +43,11 @@ void PDBSymbolExe::dump(raw_ostream &OS, int Indent,
if (hasPrivateSymbols())
OS << "HasPrivateSymbols ";
OS << "\n";
+
+ TagStats Stats;
+ auto ChildrenEnum = getChildStats(Stats);
+ OS << stream_indent(Indent + 2) << "Children: " << Stats << "\n";
+ while (auto Child = ChildrenEnum->getNext()) {
+ Child->dump(OS, Indent+2, PDB_DumpLevel::Compact);
+ }
}
diff --git a/llvm/lib/DebugInfo/PDB/PDBSymbolFunc.cpp b/llvm/lib/DebugInfo/PDB/PDBSymbolFunc.cpp
index 17473c17a45..4bd96080c7f 100644
--- a/llvm/lib/DebugInfo/PDB/PDBSymbolFunc.cpp
+++ b/llvm/lib/DebugInfo/PDB/PDBSymbolFunc.cpp
@@ -10,10 +10,12 @@
#include <utility>
#include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/IPDBSession.h"
#include "llvm/DebugInfo/PDB/PDBSymbol.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
+#include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
#include "llvm/Support/Format.h"
@@ -25,16 +27,23 @@ PDBSymbolFunc::PDBSymbolFunc(const IPDBSession &PDBSession,
void PDBSymbolFunc::dump(raw_ostream &OS, int Indent,
PDB_DumpLevel Level) const {
if (Level == PDB_DumpLevel::Compact) {
+ OS << stream_indent(Indent);
+
uint32_t FuncStart = getRelativeVirtualAddress();
uint32_t FuncEnd = FuncStart + getLength();
- OS << stream_indent(Indent);
- OS << "[" << format_hex(FuncStart, 8);
- if (auto DebugStart = findOneChild<PDBSymbolFuncDebugStart>())
- OS << "+" << DebugStart->getRelativeVirtualAddress() - FuncStart;
- OS << " - " << format_hex(FuncEnd, 8);
- if (auto DebugEnd = findOneChild<PDBSymbolFuncDebugEnd>())
+ if (FuncStart == 0 && FuncEnd == 0) {
+ OS << "func [???]";
+ } else {
+ OS << "func ";
+ OS << "[" << format_hex(FuncStart, 8);
+ if (auto DebugStart = findOneChild<PDBSymbolFuncDebugStart>())
+ OS << "+" << DebugStart->getRelativeVirtualAddress() - FuncStart;
+ OS << " - " << format_hex(FuncEnd, 8);
+ if (auto DebugEnd = findOneChild<PDBSymbolFuncDebugEnd>())
OS << "-" << FuncEnd - DebugEnd->getRelativeVirtualAddress();
- OS << "] ";
+ OS << "] ";
+ }
+
PDB_RegisterId Reg = getLocalBasePointerRegisterId();
if (Reg == PDB_RegisterId::VFrame)
OS << "(VFrame)";
@@ -42,6 +51,18 @@ void PDBSymbolFunc::dump(raw_ostream &OS, int Indent,
OS << "(" << Reg << ")";
else
OS << "(FPO)";
- OS << " " << getName() << "\n";
+
+ OS << " ";
+ uint32_t ClassId = getClassParentId();
+ if (ClassId != 0) {
+ if (auto Class = Session.getSymbolById(ClassId)) {
+ if (auto UDT = dyn_cast<PDBSymbolTypeUDT>(Class.get()))
+ OS << UDT->getName() << "::";
+ else
+ OS << "{class " << Class->getSymTag() << "}::";
+ }
+ }
+ OS << getName();
+ OS << "\n";
}
}
OpenPOWER on IntegriCloud