From 4aa4d6e21a2c31bb47c6bbce528f94c61457e149 Mon Sep 17 00:00:00 2001 From: Zachary Turner Date: Tue, 24 May 2016 22:58:46 +0000 Subject: [PATCH] [codeview] Add support for new type records. This adds support for parsing and dumping the following symbol types: S_LPROCREF S_ENVBLOCK S_COMPILE2 S_REGISTER S_COFFGROUP S_SECTION S_THUNK32 S_TRAMPOLINE As of this patch, the test PDB files no longer have any unknown symbol types. llvm-svn: 270628 --- .../llvm/DebugInfo/CodeView/CVSymbolTypes.def | 22 +- include/llvm/DebugInfo/CodeView/CodeView.h | 81 +++++- .../DebugInfo/CodeView/RecordSerialization.h | 34 +++ .../llvm/DebugInfo/CodeView/SymbolRecord.h | 260 +++++++++++++++++- include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h | 6 +- include/llvm/DebugInfo/PDB/IPDBRawSymbol.h | 7 +- include/llvm/DebugInfo/PDB/PDBExtras.h | 5 +- include/llvm/DebugInfo/PDB/PDBTypes.h | 64 ----- lib/DebugInfo/CodeView/SymbolDumper.cpp | 183 +++++++++++- lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp | 14 +- lib/DebugInfo/PDB/PDBExtras.cpp | 113 ++++---- test/DebugInfo/PDB/pdbdump-headers.test | 116 +++++--- tools/llvm-pdbdump/CompilandDumper.cpp | 4 +- 13 files changed, 723 insertions(+), 186 deletions(-) diff --git a/include/llvm/DebugInfo/CodeView/CVSymbolTypes.def b/include/llvm/DebugInfo/CodeView/CVSymbolTypes.def index 991644d102c..556d0b85bde 100644 --- a/include/llvm/DebugInfo/CodeView/CVSymbolTypes.def +++ b/include/llvm/DebugInfo/CodeView/CVSymbolTypes.def @@ -126,13 +126,10 @@ CV_SYMBOL(S_UNAMESPACE_ST , 0x1029) CV_SYMBOL(S_ST_MAX , 0x1100) -CV_SYMBOL(S_THUNK32 , 0x1102) CV_SYMBOL(S_WITH32 , 0x1104) -CV_SYMBOL(S_REGISTER , 0x1106) CV_SYMBOL(S_MANYREG , 0x110a) CV_SYMBOL(S_LPROCMIPS , 0x1114) CV_SYMBOL(S_GPROCMIPS , 0x1115) -CV_SYMBOL(S_COMPILE2 , 0x1116) CV_SYMBOL(S_MANYREG2 , 0x1117) CV_SYMBOL(S_LPROCIA64 , 0x1118) CV_SYMBOL(S_GPROCIA64 , 0x1119) @@ -148,12 +145,10 @@ CV_SYMBOL(S_MANREGREL , 0x1122) CV_SYMBOL(S_MANMANYREG2 , 0x1123) CV_SYMBOL(S_UNAMESPACE , 0x1124) CV_SYMBOL(S_DATAREF , 0x1126) -CV_SYMBOL(S_LPROCREF , 0x1127) CV_SYMBOL(S_ANNOTATIONREF , 0x1128) CV_SYMBOL(S_TOKENREF , 0x1129) CV_SYMBOL(S_GMANPROC , 0x112a) CV_SYMBOL(S_LMANPROC , 0x112b) -CV_SYMBOL(S_TRAMPOLINE , 0x112c) CV_SYMBOL(S_ATTR_FRAMEREL , 0x112e) CV_SYMBOL(S_ATTR_REGISTER , 0x112f) CV_SYMBOL(S_ATTR_REGREL , 0x1130) @@ -164,11 +159,8 @@ CV_SYMBOL(S_SEPCODE , 0x1132) CV_SYMBOL(S_LOCAL_2005 , 0x1133) CV_SYMBOL(S_DEFRANGE_2005 , 0x1134) CV_SYMBOL(S_DEFRANGE2_2005, 0x1135) -CV_SYMBOL(S_SECTION , 0x1136) -CV_SYMBOL(S_COFFGROUP , 0x1137) CV_SYMBOL(S_EXPORT , 0x1138) CV_SYMBOL(S_DISCARDED , 0x113b) -CV_SYMBOL(S_ENVBLOCK , 0x113d) // Current symbol types for most procedures as of this writing. CV_SYMBOL(S_LPROCMIPS_ID , 0x1148) @@ -179,7 +171,6 @@ CV_SYMBOL(S_GPROCIA64_ID , 0x114b) CV_SYMBOL(S_DEFRANGE_HLSL , 0x1150) CV_SYMBOL(S_GDATA_HLSL , 0x1151) CV_SYMBOL(S_LDATA_HLSL , 0x1152) -CV_SYMBOL(S_FILESTATIC , 0x1153) CV_SYMBOL(S_LOCAL_DPC_GROUPSHARED, 0x1154) CV_SYMBOL(S_DEFRANGE_DPC_PTR_TAG, 0x1157) CV_SYMBOL(S_DPC_SYM_TAG_MAP, 0x1158) @@ -199,6 +190,11 @@ SYMBOL_RECORD(S_END , 0x0006, ScopeEndSym) SYMBOL_RECORD_ALIAS(S_INLINESITE_END , 0x114e, InlineSiteEnd, ScopeEndSym) SYMBOL_RECORD_ALIAS(S_PROC_ID_END , 0x114f, ProcEnd, ScopeEndSym) +SYMBOL_RECORD(S_THUNK32 , 0x1102, Thunk32Sym) +SYMBOL_RECORD(S_TRAMPOLINE , 0x112c, TrampolineSym) +SYMBOL_RECORD(S_SECTION , 0x1136, SectionSym) +SYMBOL_RECORD(S_COFFGROUP , 0x1137, CoffGroupSym) + SYMBOL_RECORD(S_LPROC32 , 0x110f, ProcSym) SYMBOL_RECORD_ALIAS(S_GPROC32 , 0x1110, GlobalProcSym, ProcSym) SYMBOL_RECORD_ALIAS(S_LPROC32_ID , 0x1146, ProcIdSym, ProcSym) @@ -206,8 +202,14 @@ SYMBOL_RECORD_ALIAS(S_GPROC32_ID , 0x1147, GlobalProcIdSym, ProcSym) SYMBOL_RECORD_ALIAS(S_LPROC32_DPC , 0x1155, DPCProcSym, ProcSym) SYMBOL_RECORD_ALIAS(S_LPROC32_DPC_ID , 0x1156, DPCProcIdSym, ProcSym) +SYMBOL_RECORD(S_REGISTER , 0x1106, RegisterSym) SYMBOL_RECORD(S_PUB32 , 0x110e, PublicSym32) + SYMBOL_RECORD(S_PROCREF , 0x1125, ProcRefSym) +SYMBOL_RECORD_ALIAS(S_LPROCREF, 0x1127, LocalProcRef, ProcRefSym) + + +SYMBOL_RECORD(S_ENVBLOCK , 0x113d, EnvBlockSym) SYMBOL_RECORD(S_INLINESITE , 0x114d, InlineSiteSym) SYMBOL_RECORD(S_LOCAL , 0x113e, LocalSym) @@ -221,9 +223,11 @@ SYMBOL_RECORD(S_DEFRANGE_REGISTER_REL, 0x1145, DefRangeRegisterRelSym) SYMBOL_RECORD(S_BLOCK32 , 0x1103, BlockSym) SYMBOL_RECORD(S_LABEL32 , 0x1105, LabelSym) SYMBOL_RECORD(S_OBJNAME , 0x1101, ObjNameSym) +SYMBOL_RECORD(S_COMPILE2 , 0x1116, Compile2Sym) SYMBOL_RECORD(S_COMPILE3 , 0x113c, Compile3Sym) SYMBOL_RECORD(S_FRAMEPROC , 0x1012, FrameProcSym) SYMBOL_RECORD(S_CALLSITEINFO , 0x1139, CallSiteInfoSym) +SYMBOL_RECORD(S_FILESTATIC , 0x1153, FileStaticSym) SYMBOL_RECORD(S_HEAPALLOCSITE , 0x115e, HeapAllocationSiteSym) SYMBOL_RECORD(S_FRAMECOOKIE , 0x113a, FrameCookieSym) diff --git a/include/llvm/DebugInfo/CodeView/CodeView.h b/include/llvm/DebugInfo/CodeView/CodeView.h index 4cc67407ded..399461b3545 100644 --- a/include/llvm/DebugInfo/CodeView/CodeView.h +++ b/include/llvm/DebugInfo/CodeView/CodeView.h @@ -405,8 +405,21 @@ enum class ProcSymFlags : uint8_t { }; CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ProcSymFlags) +/// Corresponds to COMPILESYM2::Flags bitfield. +enum class CompileSym2Flags : uint32_t { + EC = 1 << 8, + NoDbgInfo = 1 << 9, + LTCG = 1 << 10, + NoDataAlign = 1 << 11, + ManagedPresent = 1 << 12, + SecurityChecks = 1 << 13, + HotPatch = 1 << 14, + CVTCIL = 1 << 15, + MSILModule = 1 << 16, +}; + /// Corresponds to COMPILESYM3::Flags bitfield. -enum CompileSym3Flags : uint32_t { +enum class CompileSym3Flags : uint32_t { EC = 1 << 8, NoDbgInfo = 1 << 9, LTCG = 1 << 10, @@ -446,6 +459,72 @@ enum class FrameCookieKind : uint32_t { XorFramePointer, XorR13, }; + +// Corresponds to CV_HREG_e enum. +enum class RegisterId : uint16_t { + Unknown = 0, + VFrame = 30006, + AL = 1, + CL = 2, + DL = 3, + BL = 4, + AH = 5, + CH = 6, + DH = 7, + BH = 8, + AX = 9, + CX = 10, + DX = 11, + BX = 12, + SP = 13, + BP = 14, + SI = 15, + DI = 16, + EAX = 17, + ECX = 18, + EDX = 19, + EBX = 20, + ESP = 21, + EBP = 22, + ESI = 23, + EDI = 24, + ES = 25, + CS = 26, + SS = 27, + DS = 28, + FS = 29, + GS = 30, + IP = 31, + RAX = 328, + RBX = 329, + RCX = 330, + RDX = 331, + RSI = 332, + RDI = 333, + RBP = 334, + RSP = 335, + R8 = 336, + R9 = 337, + R10 = 338, + R11 = 339, + R12 = 340, + R13 = 341, + R14 = 342, + R15 = 343, +}; + +/// These values correspond to the THUNK_ORDINAL enumeration. +enum class ThunkOrdinal { + Standard, + ThisAdjustor, + Vcall, + Pcode, + UnknownLoad, + TrampIncremental, + BranchIsland +}; + +enum class TrampolineType { TrampIncremental, BranchIsland }; } } diff --git a/include/llvm/DebugInfo/CodeView/RecordSerialization.h b/include/llvm/DebugInfo/CodeView/RecordSerialization.h index d4eb5754bad..c93e5ad46e9 100644 --- a/include/llvm/DebugInfo/CodeView/RecordSerialization.h +++ b/include/llvm/DebugInfo/CodeView/RecordSerialization.h @@ -131,6 +131,25 @@ template struct serialize_vector_tail_impl { std::vector &Item; }; +struct serialize_null_term_string_array_impl { + serialize_null_term_string_array_impl(std::vector &Item) + : Item(Item) {} + + std::error_code deserialize(ArrayRef &Data) const { + StringRef Field; + // Stop when we run out of bytes or we hit record padding bytes. + while (Data.front() != 0) { + if (auto EC = consume(Data, Field)) + return EC; + Item.push_back(Field); + } + Data = Data.drop_front(1); + return std::error_code(); + } + + std::vector &Item; +}; + template struct serialize_arrayref_tail_impl { serialize_arrayref_tail_impl(ArrayRef &Item) : Item(Item) {} @@ -158,6 +177,11 @@ serialize_array_impl serialize_array(ArrayRef &Item, U Func) { return serialize_array_impl(Item, Func); } +inline serialize_null_term_string_array_impl +serialize_null_term_string_array(std::vector &Item) { + return serialize_null_term_string_array_impl(Item); +} + template serialize_vector_tail_impl serialize_array_tail(std::vector &Item) { return serialize_vector_tail_impl(Item); @@ -186,6 +210,10 @@ template serialize_numeric_impl serialize_numeric(T &Item) { // This is an array that exhausts the remainder of the input buffer. #define CV_ARRAY_FIELD_TAIL(I) serialize_array_tail(I) +// This is an array that consumes null terminated strings until a double null +// is encountered. +#define CV_STRING_ARRAY_NULL_TERM(I) serialize_null_term_string_array(I) + #define CV_NUMERIC_FIELD(I) serialize_numeric(I) template @@ -200,6 +228,12 @@ std::error_code consume(ArrayRef &Data, return Item.deserialize(Data); } +inline std::error_code +consume(ArrayRef &Data, + const serialize_null_term_string_array_impl &Item) { + return Item.deserialize(Data); +} + template std::error_code consume(ArrayRef &Data, const serialize_vector_tail_impl &Item) { diff --git a/include/llvm/DebugInfo/CodeView/SymbolRecord.h b/include/llvm/DebugInfo/CodeView/SymbolRecord.h index f0ff7335111..1b1caa849d9 100644 --- a/include/llvm/DebugInfo/CodeView/SymbolRecord.h +++ b/include/llvm/DebugInfo/CodeView/SymbolRecord.h @@ -79,6 +79,139 @@ public: StringRef Name; }; +// S_THUNK32 +class Thunk32Sym : public SymbolRecord { +public: + struct Hdr { + ulittle32_t Parent; + ulittle32_t End; + ulittle32_t Next; + ulittle32_t Off; + ulittle16_t Seg; + ulittle16_t Len; + uint8_t Ord; // ThunkOrdinal enumeration + // Name: The null-terminated name follows. + // Variant portion of thunk + }; + + Thunk32Sym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H, + StringRef Name, ArrayRef VariantData) + : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name), + VariantData(VariantData) {} + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + StringRef Name; + ArrayRef VariantData; + + CV_DESERIALIZE(Data, H, Name, CV_ARRAY_FIELD_TAIL(VariantData)); + + return Thunk32Sym(Kind, RecordOffset, H, Name, VariantData); + } + + uint32_t RecordOffset; + Hdr Header; + StringRef Name; + ArrayRef VariantData; +}; + +// S_TRAMPOLINE +class TrampolineSym : public SymbolRecord { +public: + struct Hdr { + ulittle16_t Type; // TrampolineType enum + ulittle16_t Size; + ulittle32_t ThunkOff; + ulittle32_t TargetOff; + ulittle16_t ThunkSection; + ulittle16_t TargetSection; + }; + + TrampolineSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H) + : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H) {} + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + + CV_DESERIALIZE(Data, H); + + return TrampolineSym(Kind, RecordOffset, H); + } + + uint32_t RecordOffset; + Hdr Header; +}; + +// S_SECTION +class SectionSym : public SymbolRecord { +public: + struct Hdr { + ulittle16_t SectionNumber; + uint8_t Alignment; + uint8_t Reserved; // Must be 0 + ulittle32_t Rva; + ulittle32_t Length; + ulittle32_t Characteristics; + // Name: The null-terminated name follows. + }; + + SectionSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H, + StringRef Name) + : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name) { + } + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + StringRef Name; + + CV_DESERIALIZE(Data, H, Name); + + return SectionSym(Kind, RecordOffset, H, Name); + } + + uint32_t RecordOffset; + Hdr Header; + StringRef Name; +}; + +// S_COFFGROUP +class CoffGroupSym : public SymbolRecord { +public: + struct Hdr { + ulittle32_t Size; + ulittle32_t Characteristics; + ulittle32_t Offset; + ulittle16_t Segment; + // Name: The null-terminated name follows. + }; + + CoffGroupSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *H, + StringRef Name) + : SymbolRecord(Kind), RecordOffset(RecordOffset), Header(*H), Name(Name) { + } + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + StringRef Name; + + CV_DESERIALIZE(Data, H, Name); + + return CoffGroupSym(Kind, RecordOffset, H, Name); + } + + uint32_t RecordOffset; + Hdr Header; + StringRef Name; +}; + class ScopeEndSym : public SymbolRecord { public: ScopeEndSym(SymbolRecordKind Kind, uint32_t RecordOffset) @@ -95,7 +228,7 @@ public: class CallerSym : public SymbolRecord { public: struct Hdr { - uint32_t Count; + ulittle32_t Count; }; CallerSym(SymbolRecordKind Kind, uint32_t RecordOffset, const Hdr *Header, @@ -363,7 +496,35 @@ public: StringRef Name; }; -// S_PROCREF +// S_REGISTER +class RegisterSym : public SymbolRecord { +public: + struct Hdr { + ulittle32_t Index; // Type index or Metadata token + ulittle16_t Register; // RegisterId enumeration + // Name: The null-terminated name follows. + }; + + RegisterSym(uint32_t RecordOffset, const Hdr *H, StringRef Name) + : SymbolRecord(SymbolRecordKind::RegisterSym), RecordOffset(RecordOffset), + Header(*H), Name(Name) {} + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + StringRef Name; + CV_DESERIALIZE(Data, H, Name); + + return RegisterSym(RecordOffset, H, Name); + } + + uint32_t RecordOffset; + Hdr Header; + StringRef Name; +}; + +// S_PROCREF, S_LPROCREF class ProcRefSym : public SymbolRecord { public: struct Hdr { @@ -794,13 +955,106 @@ public: StringRef Name; }; +// S_ENVBLOCK +class EnvBlockSym : public SymbolRecord { +public: + struct Hdr { + uint8_t Reserved; + // Sequence of zero terminated strings. + }; + + EnvBlockSym(uint32_t RecordOffset, const Hdr *H, + const std::vector &Fields) + : SymbolRecord(SymbolRecordKind::EnvBlockSym), RecordOffset(RecordOffset), + Header(*H), Fields(Fields) {} + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + std::vector Fields; + CV_DESERIALIZE(Data, H, CV_STRING_ARRAY_NULL_TERM(Fields)); + + return EnvBlockSym(RecordOffset, H, Fields); + } + + uint32_t RecordOffset; + Hdr Header; + std::vector Fields; +}; + +// S_FILESTATIC +class FileStaticSym : public SymbolRecord { +public: + struct Hdr { + ulittle32_t Index; // Type Index + ulittle32_t ModFilenameOffset; // Index of mod filename in string table + ulittle16_t Flags; // LocalSymFlags enum + // Name: The null-terminated name follows. + }; + + FileStaticSym(uint32_t RecordOffset, const Hdr *H, StringRef Name) + : SymbolRecord(SymbolRecordKind::FileStaticSym), + RecordOffset(RecordOffset), Header(*H), Name(Name) {} + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + StringRef Name; + CV_DESERIALIZE(Data, H, Name); + + return FileStaticSym(RecordOffset, H, Name); + } + + uint32_t RecordOffset; + Hdr Header; + StringRef Name; +}; + +// S_COMPILE2 +class Compile2Sym : public SymbolRecord { +public: + struct Hdr { + ulittle32_t flags; // CompileSym2Flags enum + uint8_t getLanguage() const { return flags & 0xFF; } + unsigned short Machine; // CPUType enum + unsigned short VersionFrontendMajor; + unsigned short VersionFrontendMinor; + unsigned short VersionFrontendBuild; + unsigned short VersionBackendMajor; + unsigned short VersionBackendMinor; + unsigned short VersionBackendBuild; + // Version: The null-terminated version string follows. + // Optional block of zero terminated strings terminated with a double zero. + }; + + Compile2Sym(uint32_t RecordOffset, const Hdr *H, StringRef Version) + : SymbolRecord(SymbolRecordKind::Compile2Sym), RecordOffset(RecordOffset), + Header(*H), Version(Version) {} + + static ErrorOr deserialize(SymbolRecordKind Kind, + uint32_t RecordOffset, + ArrayRef &Data) { + const Hdr *H = nullptr; + StringRef Version; + CV_DESERIALIZE(Data, H, Version); + + return Compile2Sym(RecordOffset, H, Version); + } + + uint32_t RecordOffset; + Hdr Header; + StringRef Version; +}; + // S_COMPILE3 class Compile3Sym : public SymbolRecord { public: struct Hdr { ulittle32_t flags; // CompileSym3Flags enum uint8_t getLanguage() const { return flags & 0xff; } - ulittle16_t Machine; // CPUType + ulittle16_t Machine; // CPUType enum ulittle16_t VersionFrontendMajor; ulittle16_t VersionFrontendMinor; ulittle16_t VersionFrontendBuild; diff --git a/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h b/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h index 63bfb3794f7..1e40c46f8a2 100644 --- a/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h +++ b/include/llvm/DebugInfo/PDB/DIA/DIARawSymbol.h @@ -59,7 +59,7 @@ public: uint32_t getLiveRangeStartAddressOffset() const override; uint32_t getLiveRangeStartAddressSection() const override; uint32_t getLiveRangeStartRelativeVirtualAddress() const override; - PDB_RegisterId getLocalBasePointerRegisterId() const override; + codeview::RegisterId getLocalBasePointerRegisterId() const override; uint32_t getLowerBoundId() const override; uint32_t getMemorySpaceKind() const override; std::string getName() const override; @@ -74,7 +74,7 @@ public: uint32_t getOffsetInUdt() const override; PDB_Cpu getPlatform() const override; uint32_t getRank() const override; - PDB_RegisterId getRegisterId() const override; + codeview::RegisterId getRegisterId() const override; uint32_t getRegisterType() const override; uint32_t getRelativeVirtualAddress() const override; uint32_t getSamplerSlot() const override; @@ -110,7 +110,7 @@ public: int32_t getVirtualBasePointerOffset() const override; PDB_LocType getLocationType() const override; PDB_Machine getMachineType() const override; - PDB_ThunkOrdinal getThunkOrdinal() const override; + codeview::ThunkOrdinal getThunkOrdinal() const override; uint64_t getLength() const override; uint64_t getLiveRangeLength() const override; uint64_t getVirtualAddress() const override; diff --git a/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h b/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h index b91317f7a10..49866b8bb2f 100644 --- a/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h +++ b/include/llvm/DebugInfo/PDB/IPDBRawSymbol.h @@ -13,6 +13,7 @@ #include "PDBTypes.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" +#include "llvm/DebugInfo/CodeView/CodeView.h" #include namespace llvm { @@ -67,7 +68,7 @@ public: virtual uint32_t getLiveRangeStartAddressOffset() const = 0; virtual uint32_t getLiveRangeStartAddressSection() const = 0; virtual uint32_t getLiveRangeStartRelativeVirtualAddress() const = 0; - virtual PDB_RegisterId getLocalBasePointerRegisterId() const = 0; + virtual codeview::RegisterId getLocalBasePointerRegisterId() const = 0; virtual uint32_t getLowerBoundId() const = 0; virtual uint32_t getMemorySpaceKind() const = 0; virtual std::string getName() const = 0; @@ -82,7 +83,7 @@ public: virtual uint32_t getOffsetInUdt() const = 0; virtual PDB_Cpu getPlatform() const = 0; virtual uint32_t getRank() const = 0; - virtual PDB_RegisterId getRegisterId() const = 0; + virtual codeview::RegisterId getRegisterId() const = 0; virtual uint32_t getRegisterType() const = 0; virtual uint32_t getRelativeVirtualAddress() const = 0; virtual uint32_t getSamplerSlot() const = 0; @@ -118,7 +119,7 @@ public: virtual int32_t getVirtualBasePointerOffset() const = 0; virtual PDB_LocType getLocationType() const = 0; virtual PDB_Machine getMachineType() const = 0; - virtual PDB_ThunkOrdinal getThunkOrdinal() const = 0; + virtual codeview::ThunkOrdinal getThunkOrdinal() const = 0; virtual uint64_t getLength() const = 0; virtual uint64_t getLiveRangeLength() const = 0; virtual uint64_t getVirtualAddress() const = 0; diff --git a/include/llvm/DebugInfo/PDB/PDBExtras.h b/include/llvm/DebugInfo/PDB/PDBExtras.h index d9c8a703192..5a7422d9e9e 100644 --- a/include/llvm/DebugInfo/PDB/PDBExtras.h +++ b/include/llvm/DebugInfo/PDB/PDBExtras.h @@ -11,6 +11,7 @@ #define LLVM_DEBUGINFO_PDB_PDBEXTRAS_H #include "PDBTypes.h" +#include "llvm/DebugInfo/CodeView/CodeView.h" #include "llvm/Support/raw_ostream.h" #include @@ -22,9 +23,9 @@ typedef std::unordered_map TagStats; raw_ostream &operator<<(raw_ostream &OS, const PDB_VariantType &Value); raw_ostream &operator<<(raw_ostream &OS, const PDB_CallingConv &Conv); 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 codeview::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 codeview::ThunkOrdinal &Thunk); raw_ostream &operator<<(raw_ostream &OS, const PDB_Checksum &Checksum); raw_ostream &operator<<(raw_ostream &OS, const PDB_Lang &Lang); raw_ostream &operator<<(raw_ostream &OS, const PDB_SymType &Tag); diff --git a/include/llvm/DebugInfo/PDB/PDBTypes.h b/include/llvm/DebugInfo/PDB/PDBTypes.h index cc52760b6f1..a9325a43436 100644 --- a/include/llvm/DebugInfo/PDB/PDBTypes.h +++ b/include/llvm/DebugInfo/PDB/PDBTypes.h @@ -217,18 +217,6 @@ enum class PDB_LocType { Max }; -/// These values correspond to the THUNK_ORDINAL enumeration, and are documented -/// here: https://msdn.microsoft.com/en-us/library/dh0k8hft.aspx -enum class PDB_ThunkOrdinal { - Standard, - ThisAdjustor, - Vcall, - Pcode, - UnknownLoad, - TrampIncremental, - BranchIsland -}; - /// These values correspond to the UdtKind enumeration, and are documented /// here: https://msdn.microsoft.com/en-us/library/wcstk66t.aspx enum class PDB_UdtType { Struct, Class, Union, Interface }; @@ -264,58 +252,6 @@ enum class PDB_BuiltinType { HResult = 31 }; -enum class PDB_RegisterId { - Unknown = 0, - VFrame = 30006, - AL = 1, - CL = 2, - DL = 3, - BL = 4, - AH = 5, - CH = 6, - DH = 7, - BH = 8, - AX = 9, - CX = 10, - DX = 11, - BX = 12, - SP = 13, - BP = 14, - SI = 15, - DI = 16, - EAX = 17, - ECX = 18, - EDX = 19, - EBX = 20, - ESP = 21, - EBP = 22, - ESI = 23, - EDI = 24, - ES = 25, - CS = 26, - SS = 27, - DS = 28, - FS = 29, - GS = 30, - IP = 31, - RAX = 328, - RBX = 329, - RCX = 330, - RDX = 331, - RSI = 332, - RDI = 333, - RBP = 334, - RSP = 335, - R8 = 336, - R9 = 337, - R10 = 338, - R11 = 339, - R12 = 340, - R13 = 341, - R14 = 342, - R15 = 343, -}; - enum class PDB_MemberAccess { Private = 1, Protected = 2, Public = 3 }; struct VersionInfo { diff --git a/lib/DebugInfo/CodeView/SymbolDumper.cpp b/lib/DebugInfo/CodeView/SymbolDumper.cpp index 60a3b8156b6..989772b8fb2 100644 --- a/lib/DebugInfo/CodeView/SymbolDumper.cpp +++ b/lib/DebugInfo/CodeView/SymbolDumper.cpp @@ -34,6 +34,58 @@ namespace { #define CV_ENUM_ENT(ns, enum) \ { #enum, ns::enum } +static const EnumEntry RegisterNames[] = { + CV_ENUM_CLASS_ENT(RegisterId, Unknown), + CV_ENUM_CLASS_ENT(RegisterId, VFrame), + CV_ENUM_CLASS_ENT(RegisterId, AL), + CV_ENUM_CLASS_ENT(RegisterId, CL), + CV_ENUM_CLASS_ENT(RegisterId, DL), + CV_ENUM_CLASS_ENT(RegisterId, BL), + CV_ENUM_CLASS_ENT(RegisterId, AH), + CV_ENUM_CLASS_ENT(RegisterId, CH), + CV_ENUM_CLASS_ENT(RegisterId, DH), + CV_ENUM_CLASS_ENT(RegisterId, BH), + CV_ENUM_CLASS_ENT(RegisterId, AX), + CV_ENUM_CLASS_ENT(RegisterId, CX), + CV_ENUM_CLASS_ENT(RegisterId, DX), + CV_ENUM_CLASS_ENT(RegisterId, BX), + CV_ENUM_CLASS_ENT(RegisterId, SP), + CV_ENUM_CLASS_ENT(RegisterId, BP), + CV_ENUM_CLASS_ENT(RegisterId, SI), + CV_ENUM_CLASS_ENT(RegisterId, DI), + CV_ENUM_CLASS_ENT(RegisterId, EAX), + CV_ENUM_CLASS_ENT(RegisterId, ECX), + CV_ENUM_CLASS_ENT(RegisterId, EDX), + CV_ENUM_CLASS_ENT(RegisterId, EBX), + CV_ENUM_CLASS_ENT(RegisterId, ESP), + CV_ENUM_CLASS_ENT(RegisterId, EBP), + CV_ENUM_CLASS_ENT(RegisterId, ESI), + CV_ENUM_CLASS_ENT(RegisterId, EDI), + CV_ENUM_CLASS_ENT(RegisterId, ES), + CV_ENUM_CLASS_ENT(RegisterId, CS), + CV_ENUM_CLASS_ENT(RegisterId, SS), + CV_ENUM_CLASS_ENT(RegisterId, DS), + CV_ENUM_CLASS_ENT(RegisterId, FS), + CV_ENUM_CLASS_ENT(RegisterId, GS), + CV_ENUM_CLASS_ENT(RegisterId, IP), + CV_ENUM_CLASS_ENT(RegisterId, RAX), + CV_ENUM_CLASS_ENT(RegisterId, RBX), + CV_ENUM_CLASS_ENT(RegisterId, RCX), + CV_ENUM_CLASS_ENT(RegisterId, RDX), + CV_ENUM_CLASS_ENT(RegisterId, RSI), + CV_ENUM_CLASS_ENT(RegisterId, RDI), + CV_ENUM_CLASS_ENT(RegisterId, RBP), + CV_ENUM_CLASS_ENT(RegisterId, RSP), + CV_ENUM_CLASS_ENT(RegisterId, R8), + CV_ENUM_CLASS_ENT(RegisterId, R9), + CV_ENUM_CLASS_ENT(RegisterId, R10), + CV_ENUM_CLASS_ENT(RegisterId, R11), + CV_ENUM_CLASS_ENT(RegisterId, R12), + CV_ENUM_CLASS_ENT(RegisterId, R13), + CV_ENUM_CLASS_ENT(RegisterId, R14), + CV_ENUM_CLASS_ENT(RegisterId, R15), +}; + static const EnumEntry ProcSymFlagNames[] = { CV_ENUM_CLASS_ENT(ProcSymFlags, HasFP), CV_ENUM_CLASS_ENT(ProcSymFlags, HasIRET), @@ -78,6 +130,18 @@ static const EnumEntry SourceLanguages[] = { CV_ENUM_ENT(SourceLanguage, HLSL), }; +static const EnumEntry CompileSym2FlagNames[] = { + CV_ENUM_CLASS_ENT(CompileSym2Flags, EC), + CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDbgInfo), + CV_ENUM_CLASS_ENT(CompileSym2Flags, LTCG), + CV_ENUM_CLASS_ENT(CompileSym2Flags, NoDataAlign), + CV_ENUM_CLASS_ENT(CompileSym2Flags, ManagedPresent), + CV_ENUM_CLASS_ENT(CompileSym2Flags, SecurityChecks), + CV_ENUM_CLASS_ENT(CompileSym2Flags, HotPatch), + CV_ENUM_CLASS_ENT(CompileSym2Flags, CVTCIL), + CV_ENUM_CLASS_ENT(CompileSym2Flags, MSILModule), +}; + static const EnumEntry CompileSym3FlagNames[] = { CV_ENUM_CLASS_ENT(CompileSym3Flags, EC), CV_ENUM_CLASS_ENT(CompileSym3Flags, NoDbgInfo), @@ -177,6 +241,21 @@ static const EnumEntry FrameProcSymFlags[] = { CV_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw), }; +static const EnumEntry ThunkOrdinalNames[] = { + CV_ENUM_CLASS_ENT(ThunkOrdinal, Standard), + CV_ENUM_CLASS_ENT(ThunkOrdinal, ThisAdjustor), + CV_ENUM_CLASS_ENT(ThunkOrdinal, Vcall), + CV_ENUM_CLASS_ENT(ThunkOrdinal, Pcode), + CV_ENUM_CLASS_ENT(ThunkOrdinal, UnknownLoad), + CV_ENUM_CLASS_ENT(ThunkOrdinal, TrampIncremental), + CV_ENUM_CLASS_ENT(ThunkOrdinal, BranchIsland), +}; + +static const EnumEntry TrampolineNames[] = { + CV_ENUM_CLASS_ENT(TrampolineType, TrampIncremental), + CV_ENUM_CLASS_ENT(TrampolineType, BranchIsland), +}; + /// Use this private dumper implementation to keep implementation details about /// the visitor out of SymbolDumper.h. class CVSymbolDumperImpl : public CVSymbolVisitor { @@ -254,6 +333,49 @@ void CVSymbolDumperImpl::visitBlockSym(SymbolKind Kind, BlockSym &Block) { W.printString("LinkageName", LinkageName); } +void CVSymbolDumperImpl::visitThunk32Sym(SymbolKind Kind, Thunk32Sym &Thunk) { + DictScope S(W, "Thunk32"); + W.printNumber("Parent", Thunk.Header.Parent); + W.printNumber("End", Thunk.Header.End); + W.printNumber("Next", Thunk.Header.Next); + W.printNumber("Off", Thunk.Header.Off); + W.printNumber("Seg", Thunk.Header.Seg); + W.printNumber("Len", Thunk.Header.Len); + W.printEnum("Ordinal", Thunk.Header.Ord, makeArrayRef(ThunkOrdinalNames)); +} + +void CVSymbolDumperImpl::visitTrampolineSym(SymbolKind Kind, + TrampolineSym &Tramp) { + DictScope S(W, "Trampoline"); + W.printEnum("Type", Tramp.Header.Type, makeArrayRef(TrampolineNames)); + W.printNumber("Size", Tramp.Header.Size); + W.printNumber("ThunkOff", Tramp.Header.ThunkOff); + W.printNumber("TargetOff", Tramp.Header.TargetOff); + W.printNumber("ThunkSection", Tramp.Header.ThunkSection); + W.printNumber("TargetSection", Tramp.Header.TargetSection); +} + +void CVSymbolDumperImpl::visitSectionSym(SymbolKind Kind, SectionSym &Section) { + DictScope S(W, "Section"); + W.printNumber("SectionNumber", Section.Header.SectionNumber); + W.printNumber("Alignment", Section.Header.Alignment); + W.printNumber("Reserved", Section.Header.Reserved); + W.printNumber("Rva", Section.Header.Rva); + W.printNumber("Length", Section.Header.Length); + W.printHex("Characteristics", Section.Header.Characteristics); + W.printString("Name", Section.Name); +} + +void CVSymbolDumperImpl::visitCoffGroupSym(SymbolKind Kind, + CoffGroupSym &CoffGroup) { + DictScope S(W, "COFF Group"); + W.printNumber("Size", CoffGroup.Header.Size); + W.printHex("Characteristics", CoffGroup.Header.Characteristics); + W.printNumber("Offset", CoffGroup.Header.Offset); + W.printNumber("Segment", CoffGroup.Header.Segment); + W.printString("Name", CoffGroup.Name); +} + void CVSymbolDumperImpl::visitBPRelativeSym(SymbolKind Kind, BPRelativeSym &BPRel) { DictScope S(W, "BPRelativeSym"); @@ -287,9 +409,59 @@ void CVSymbolDumperImpl::visitCallSiteInfoSym(SymbolKind Kind, W.printString("LinkageName", LinkageName); } +void CVSymbolDumperImpl::visitEnvBlockSym(SymbolKind Kind, + EnvBlockSym &EnvBlock) { + DictScope S(W, "EnvBlock"); + + W.printNumber("Reserved", EnvBlock.Header.Reserved); + ListScope L(W, "Entries"); + for (auto Entry : EnvBlock.Fields) { + W.printString(Entry); + } +} + +void CVSymbolDumperImpl::visitFileStaticSym(SymbolKind Kind, + FileStaticSym &FileStatic) { + DictScope S(W, "FileStatic"); + W.printNumber("Index", FileStatic.Header.Index); + W.printNumber("ModFilenameOffset", FileStatic.Header.ModFilenameOffset); + W.printFlags("Flags", uint16_t(FileStatic.Header.Flags), + makeArrayRef(LocalFlags)); + W.printString("Name", FileStatic.Name); +} + +void CVSymbolDumperImpl::visitCompile2Sym(SymbolKind Kind, + Compile2Sym &Compile2) { + DictScope S(W, "CompilerFlags2"); + + W.printEnum("Language", Compile2.Header.getLanguage(), + makeArrayRef(SourceLanguages)); + W.printFlags("Flags", Compile2.Header.flags & ~0xff, + makeArrayRef(CompileSym2FlagNames)); + W.printEnum("Machine", unsigned(Compile2.Header.Machine), + makeArrayRef(CPUTypeNames)); + std::string FrontendVersion; + { + raw_string_ostream Out(FrontendVersion); + Out << Compile2.Header.VersionFrontendMajor << '.' + << Compile2.Header.VersionFrontendMinor << '.' + << Compile2.Header.VersionFrontendBuild; + } + std::string BackendVersion; + { + raw_string_ostream Out(BackendVersion); + Out << Compile2.Header.VersionBackendMajor << '.' + << Compile2.Header.VersionBackendMinor << '.' + << Compile2.Header.VersionBackendBuild; + } + W.printString("FrontendVersion", FrontendVersion); + W.printString("BackendVersion", BackendVersion); + W.printString("VersionName", Compile2.Version); +} + void CVSymbolDumperImpl::visitCompile3Sym(SymbolKind Kind, Compile3Sym &Compile3) { - DictScope S(W, "CompilerFlags"); + DictScope S(W, "CompilerFlags3"); W.printEnum("Language", Compile3.Header.getLanguage(), makeArrayRef(SourceLanguages)); @@ -537,6 +709,15 @@ void CVSymbolDumperImpl::visitInlineSiteSym(SymbolKind Kind, } } +void CVSymbolDumperImpl::visitRegisterSym(SymbolKind Kind, + RegisterSym &Register) { + DictScope S(W, "RegisterSym"); + W.printNumber("Type", Register.Header.Index); + W.printEnum("Seg", uint16_t(Register.Header.Register), + makeArrayRef(RegisterNames)); + W.printString("Name", Register.Name); +} + void CVSymbolDumperImpl::visitPublicSym32(SymbolKind Kind, PublicSym32 &Public) { DictScope S(W, "PublicSym"); diff --git a/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp b/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp index 1bc81d82c95..bba5b0f94dc 100644 --- a/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp +++ b/lib/DebugInfo/PDB/DIA/DIARawSymbol.cpp @@ -534,8 +534,8 @@ uint32_t DIARawSymbol::getLiveRangeStartRelativeVirtualAddress() const { Symbol, &IDiaSymbol::get_liveRangeStartRelativeVirtualAddress); } -PDB_RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const { - return PrivateGetDIAValue( +codeview::RegisterId DIARawSymbol::getLocalBasePointerRegisterId() const { + return PrivateGetDIAValue( Symbol, &IDiaSymbol::get_localBasePointerRegisterId); } @@ -596,9 +596,9 @@ uint32_t DIARawSymbol::getRank() const { return PrivateGetDIAValue(Symbol, &IDiaSymbol::get_rank); } -PDB_RegisterId DIARawSymbol::getRegisterId() const { - return PrivateGetDIAValue(Symbol, - &IDiaSymbol::get_registerId); +codeview::RegisterId DIARawSymbol::getRegisterId() const { + return PrivateGetDIAValue( + Symbol, &IDiaSymbol::get_registerId); } uint32_t DIARawSymbol::getRegisterType() const { @@ -751,8 +751,8 @@ PDB_Machine DIARawSymbol::getMachineType() const { &IDiaSymbol::get_machineType); } -PDB_ThunkOrdinal DIARawSymbol::getThunkOrdinal() const { - return PrivateGetDIAValue( +codeview::ThunkOrdinal DIARawSymbol::getThunkOrdinal() const { + return PrivateGetDIAValue( Symbol, &IDiaSymbol::get_thunkOrdinal); } diff --git a/lib/DebugInfo/PDB/PDBExtras.cpp b/lib/DebugInfo/PDB/PDBExtras.cpp index ebad9a072a5..b7eee6e5394 100644 --- a/lib/DebugInfo/PDB/PDBExtras.cpp +++ b/lib/DebugInfo/PDB/PDBExtras.cpp @@ -90,55 +90,56 @@ raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_DataKind &Data) { return OS; } -raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_RegisterId &Reg) { +raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, + const codeview::RegisterId &Reg) { switch (Reg) { - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AL, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CL, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DL, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BL, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AH, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CH, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DH, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BH, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, AX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, SP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, BP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, SI, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DI, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EAX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ECX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EDX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EBX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ESP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EBP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ESI, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, EDI, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, ES, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, CS, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, SS, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, DS, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, FS, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, GS, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, IP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RAX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RBX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RCX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RDX, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RSI, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RDI, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RBP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, RSP, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R8, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R9, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R10, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R11, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R12, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R13, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R14, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_RegisterId, R15, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, AL, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CL, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DL, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BL, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, AH, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CH, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DH, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BH, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, AX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, SP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, BP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, SI, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DI, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EAX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ECX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EDX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EBX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ESP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EBP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ESI, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, EDI, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, ES, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, CS, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, SS, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, DS, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, FS, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, GS, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, IP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RAX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RBX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RCX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RDX, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RSI, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RDI, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RBP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, RSP, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R8, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R9, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R10, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R11, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R12, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R13, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R14, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::RegisterId, R15, OS) default: OS << static_cast(Reg); } @@ -164,15 +165,15 @@ raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, const PDB_LocType &Loc) { } raw_ostream &llvm::pdb::operator<<(raw_ostream &OS, - const PDB_ThunkOrdinal &Thunk) { + const codeview::ThunkOrdinal &Thunk) { switch (Thunk) { - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, BranchIsland, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Pcode, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Standard, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, ThisAdjustor, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, TrampIncremental, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, UnknownLoad, OS) - CASE_OUTPUT_ENUM_CLASS_NAME(PDB_ThunkOrdinal, Vcall, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, BranchIsland, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, Pcode, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, Standard, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, ThisAdjustor, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, TrampIncremental, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, UnknownLoad, OS) + CASE_OUTPUT_ENUM_CLASS_NAME(codeview::ThunkOrdinal, Vcall, OS) } return OS; } diff --git a/test/DebugInfo/PDB/pdbdump-headers.test b/test/DebugInfo/PDB/pdbdump-headers.test index 8f1ff2de8b7..18681acefdd 100644 --- a/test/DebugInfo/PDB/pdbdump-headers.test +++ b/test/DebugInfo/PDB/pdbdump-headers.test @@ -141,7 +141,7 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: CompilerFlags { +; EMPTY-NEXT: CompilerFlags3 { ; EMPTY-NEXT: Language: Cpp (0x1) ; EMPTY-NEXT: Flags [ (0x2000) ; EMPTY-NEXT: SecurityChecks (0x2000) @@ -238,7 +238,7 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: CompilerFlags { +; EMPTY-NEXT: CompilerFlags3 { ; EMPTY-NEXT: Language: Link (0x7) ; EMPTY-NEXT: Flags [ (0x0) ; EMPTY-NEXT: ] @@ -254,9 +254,16 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_ENVBLOCK (0x113D) -; EMPTY-NEXT: Length: 168 +; EMPTY-NEXT: EnvBlock { +; EMPTY-NEXT: Reserved: 0 +; EMPTY-NEXT: Entries [ +; EMPTY-NEXT: cwd +; EMPTY-NEXT: d:\src\llvm\test\DebugInfo\PDB\Inputs +; EMPTY-NEXT: exe +; EMPTY-NEXT: C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\BIN\link.exe +; EMPTY-NEXT: pdb +; EMPTY-NEXT: d:\src\llvm\test\DebugInfo\PDB\Inputs\empty.pdb +; EMPTY-NEXT: ] ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 00637764 00643A5C 7372635C 6C6C766D |.cwd.d:\src\llvm| @@ -273,18 +280,27 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_TRAMPOLINE (0x112C) -; EMPTY-NEXT: Length: 16 +; EMPTY-NEXT: Trampoline { +; EMPTY-NEXT: Type: TrampIncremental (0x0) +; EMPTY-NEXT: Size: 5 +; EMPTY-NEXT: ThunkOff: 5 +; EMPTY-NEXT: TargetOff: 16 +; EMPTY-NEXT: ThunkSection: 1 +; EMPTY-NEXT: TargetSection: 1 ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 00000500 05000000 10000000 01000100 |................| ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_SECTION (0x1136) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: Section { +; EMPTY-NEXT: SectionNumber: 1 +; EMPTY-NEXT: Alignment: 12 +; EMPTY-NEXT: Reserved: 0 +; EMPTY-NEXT: Rva: 4096 +; EMPTY-NEXT: Length: 4122 +; EMPTY-NEXT: Characteristics: 0x60000020 +; EMPTY-NEXT: Name: .text ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 01000C00 00100000 1A100000 20000060 |............ ..`| @@ -292,9 +308,12 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_COFFGROUP (0x1137) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: COFF Group { +; EMPTY-NEXT: Size: 4122 +; EMPTY-NEXT: Characteristics: 0x60000020 +; EMPTY-NEXT: Offset: 0 +; EMPTY-NEXT: Segment: 1 +; EMPTY-NEXT: Name: .text$mn ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 1A100000 20000060 00000000 01002E74 |.... ..`.......t| @@ -302,9 +321,14 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_SECTION (0x1136) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: Section { +; EMPTY-NEXT: SectionNumber: 2 +; EMPTY-NEXT: Alignment: 12 +; EMPTY-NEXT: Reserved: 0 +; EMPTY-NEXT: Rva: 12288 +; EMPTY-NEXT: Length: 690 +; EMPTY-NEXT: Characteristics: 0x40000040 +; EMPTY-NEXT: Name: .rdata ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 02000C00 00300000 B2020000 40000040 |.....0......@..@| @@ -312,9 +336,12 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_COFFGROUP (0x1137) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: COFF Group { +; EMPTY-NEXT: Size: 323 +; EMPTY-NEXT: Characteristics: 0x40000040 +; EMPTY-NEXT: Offset: 0 +; EMPTY-NEXT: Segment: 2 +; EMPTY-NEXT: Name: .rdata ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 43010000 40000040 00000000 02002E72 |C...@..@.......r| @@ -322,9 +349,12 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_COFFGROUP (0x1137) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: COFF Group { +; EMPTY-NEXT: Size: 0 +; EMPTY-NEXT: Characteristics: 0x40000040 +; EMPTY-NEXT: Offset: 323 +; EMPTY-NEXT: Segment: 2 +; EMPTY-NEXT: Name: .edata ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 00000000 40000040 43010000 02002E65 |....@..@C......e| @@ -332,9 +362,12 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_COFFGROUP (0x1137) -; EMPTY-NEXT: Length: 28 +; EMPTY-NEXT: COFF Group { +; EMPTY-NEXT: Size: 366 +; EMPTY-NEXT: Characteristics: 0x40000040 +; EMPTY-NEXT: Offset: 324 +; EMPTY-NEXT: Segment: 2 +; EMPTY-NEXT: Name: .rdata$debug ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 6E010000 40000040 44010000 02002E72 |n...@..@D......r| @@ -342,9 +375,14 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_SECTION (0x1136) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: Section { +; EMPTY-NEXT: SectionNumber: 3 +; EMPTY-NEXT: Alignment: 12 +; EMPTY-NEXT: Reserved: 0 +; EMPTY-NEXT: Rva: 16384 +; EMPTY-NEXT: Length: 4 +; EMPTY-NEXT: Characteristics: 0xC0000040 +; EMPTY-NEXT: Name: .data ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 03000C00 00400000 04000000 400000C0 |.....@......@...| @@ -352,9 +390,12 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_COFFGROUP (0x1137) -; EMPTY-NEXT: Length: 20 +; EMPTY-NEXT: COFF Group { +; EMPTY-NEXT: Size: 4 +; EMPTY-NEXT: Characteristics: 0xC0000080 +; EMPTY-NEXT: Offset: 0 +; EMPTY-NEXT: Segment: 3 +; EMPTY-NEXT: Name: .bss ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 04000000 800000C0 00000000 03002E62 |...............b| @@ -362,9 +403,14 @@ ; EMPTY-NEXT: ) ; EMPTY-NEXT: } ; EMPTY-NEXT: { -; EMPTY-NEXT: UnknownSym { -; EMPTY-NEXT: Kind: S_SECTION (0x1136) -; EMPTY-NEXT: Length: 24 +; EMPTY-NEXT: Section { +; EMPTY-NEXT: SectionNumber: 4 +; EMPTY-NEXT: Alignment: 12 +; EMPTY-NEXT: Reserved: 0 +; EMPTY-NEXT: Rva: 20480 +; EMPTY-NEXT: Length: 8 +; EMPTY-NEXT: Characteristics: 0x42000040 +; EMPTY-NEXT: Name: .reloc ; EMPTY-NEXT: } ; EMPTY-NEXT: Bytes ( ; EMPTY-NEXT: 0000: 04000C00 00500000 08000000 40000042 |.....P......@..B| diff --git a/tools/llvm-pdbdump/CompilandDumper.cpp b/tools/llvm-pdbdump/CompilandDumper.cpp index b7de0f2534e..5ec37cbbb5a 100644 --- a/tools/llvm-pdbdump/CompilandDumper.cpp +++ b/tools/llvm-pdbdump/CompilandDumper.cpp @@ -158,9 +158,9 @@ void CompilandDumper::dump(const PDBSymbolThunk &Symbol) { Printer.NewLine(); Printer << "thunk "; - PDB_ThunkOrdinal Ordinal = Symbol.getThunkOrdinal(); + codeview::ThunkOrdinal Ordinal = Symbol.getThunkOrdinal(); uint64_t VA = Symbol.getVirtualAddress(); - if (Ordinal == PDB_ThunkOrdinal::TrampIncremental) { + if (Ordinal == codeview::ThunkOrdinal::TrampIncremental) { uint64_t Target = Symbol.getTargetVirtualAddress(); WithColor(Printer, PDB_ColorItem::Address).get() << format_hex(VA, 10); Printer << " -> ";