std::string getUndecoratedName() const override;
uint32_t getUnmodifiedTypeId() const override;
uint32_t getUpperBoundId() const override;
+ Variant getValue() const override;
uint32_t getVirtualBaseDispIndex() const override;
uint32_t getVirtualBaseOffset() const override;
uint32_t getVirtualTableShapeId() const override;
bool isVirtualBaseClass() const override;
bool isVirtualInheritance() const override;
bool isVolatileType() const override;
+ bool wasInlined() const override;
+ std::string getUnused() const override;
private:
const DIASession &Session;
virtual std::string getUndecoratedName() const = 0;
virtual uint32_t getUnmodifiedTypeId() const = 0;
virtual uint32_t getUpperBoundId() const = 0;
+ virtual Variant getValue() const = 0;
virtual uint32_t getVirtualBaseDispIndex() const = 0;
virtual uint32_t getVirtualBaseOffset() const = 0;
virtual uint32_t getVirtualTableShapeId() const = 0;
virtual bool isVirtualBaseClass() const = 0;
virtual bool isVirtualInheritance() const = 0;
virtual bool isVolatileType() const = 0;
+ virtual bool wasInlined() const = 0;
+ virtual std::string getUnused() const = 0;
};
} // namespace llvm
};
raw_ostream &operator<<(raw_ostream &OS, const stream_indent &Indent);
+raw_ostream &operator<<(raw_ostream &OS, const PDB_VariantType &Value);
+raw_ostream &operator<<(raw_ostream &OS, const PDB_DataKind &Data);
raw_ostream &operator<<(raw_ostream &OS, const PDB_RegisterId &Reg);
raw_ostream &operator<<(raw_ostream &OS, const PDB_LocType &Loc);
raw_ostream &operator<<(raw_ostream &OS, const PDB_ThunkOrdinal &Thunk);
raw_ostream &operator<<(raw_ostream &OS, const PDB_Lang &Lang);
raw_ostream &operator<<(raw_ostream &OS, const PDB_SymType &Tag);
raw_ostream &operator<<(raw_ostream &OS, const PDB_UniqueId &Id);
+
+raw_ostream &operator<<(raw_ostream &OS, const Variant &Value);
raw_ostream &operator<<(raw_ostream &OS, const VersionInfo &Version);
raw_ostream &operator<<(raw_ostream &OS, const TagStats &Stats);
}
FORWARD_SYMBOL_METHOD(getToken)
FORWARD_SYMBOL_METHOD(getTypeId)
FORWARD_SYMBOL_METHOD(isUnalignedType)
- // FORWARD_SYMBOL_METHOD(getValue)
+ FORWARD_SYMBOL_METHOD(getValue)
FORWARD_SYMBOL_METHOD(getVirtualAddress)
FORWARD_SYMBOL_METHOD(isVolatileType)
};
uint32_t QFE;
};
+enum PDB_VariantType {
+ Empty,
+ Unknown,
+ Int8,
+ Int16,
+ Int32,
+ Int64,
+ Single,
+ Double,
+ UInt8,
+ UInt16,
+ UInt32,
+ UInt64,
+ Bool,
+};
+
+struct Variant {
+ Variant()
+ : Type(PDB_VariantType::Empty) {
+ }
+
+ PDB_VariantType Type;
+ union {
+ bool Bool;
+ int8_t Int8;
+ int16_t Int16;
+ int32_t Int32;
+ int64_t Int64;
+ float Single;
+ double Double;
+ uint8_t UInt8;
+ uint16_t UInt16;
+ uint32_t UInt32;
+ uint64_t UInt64;
+ void* Pointer;
+ };
+};
+
} // namespace llvm
namespace std {
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 *)) {
}
::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 {
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>
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);
}
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);
+}
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)
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";
}
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;
//===----------------------------------------------------------------------===//
#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"
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
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";
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);
+ }
}
#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"
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)";
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";
}
}