diff options
Diffstat (limited to 'lib/DebugInfo/CodeView/SymbolDumper.cpp')
| -rw-r--r-- | lib/DebugInfo/CodeView/SymbolDumper.cpp | 642 |
1 files changed, 642 insertions, 0 deletions
diff --git a/lib/DebugInfo/CodeView/SymbolDumper.cpp b/lib/DebugInfo/CodeView/SymbolDumper.cpp new file mode 100644 index 000000000000..6763c3d562d7 --- /dev/null +++ b/lib/DebugInfo/CodeView/SymbolDumper.cpp @@ -0,0 +1,642 @@ +//===-- SymbolDumper.cpp - CodeView symbol info dumper ----------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/DebugInfo/CodeView/SymbolDumper.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/DebugInfo/CodeView/CVSymbolVisitor.h" +#include "llvm/DebugInfo/CodeView/EnumTables.h" +#include "llvm/DebugInfo/CodeView/SymbolDumpDelegate.h" +#include "llvm/DebugInfo/CodeView/SymbolRecord.h" +#include "llvm/DebugInfo/CodeView/TypeDumper.h" +#include "llvm/DebugInfo/CodeView/TypeIndex.h" +#include "llvm/Support/ScopedPrinter.h" + +#include <system_error> + +using namespace llvm; +using namespace llvm::codeview; + +namespace { +/// Use this private dumper implementation to keep implementation details about +/// the visitor out of SymbolDumper.h. +class CVSymbolDumperImpl : public CVSymbolVisitor<CVSymbolDumperImpl> { +public: + CVSymbolDumperImpl(CVTypeDumper &CVTD, SymbolDumpDelegate *ObjDelegate, + ScopedPrinter &W, bool PrintRecordBytes) + : CVSymbolVisitor(ObjDelegate), CVTD(CVTD), ObjDelegate(ObjDelegate), + W(W), PrintRecordBytes(PrintRecordBytes), InFunctionScope(false) {} + +/// CVSymbolVisitor overrides. +#define SYMBOL_RECORD(EnumName, EnumVal, Name) \ + void visit##Name(SymbolKind Kind, Name &Record); +#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName) +#include "llvm/DebugInfo/CodeView/CVSymbolTypes.def" + + void visitSymbolBegin(SymbolKind Kind, ArrayRef<uint8_t> Data); + void visitSymbolEnd(SymbolKind Kind, ArrayRef<uint8_t> OriginalSymData); + void visitUnknownSymbol(SymbolKind Kind, ArrayRef<uint8_t> Data); + +private: + void printLocalVariableAddrRange(const LocalVariableAddrRange &Range, + uint32_t RelocationOffset); + void printLocalVariableAddrGap(ArrayRef<LocalVariableAddrGap> Gaps); + + CVTypeDumper &CVTD; + SymbolDumpDelegate *ObjDelegate; + ScopedPrinter &W; + + bool PrintRecordBytes; + bool InFunctionScope; +}; +} + +void CVSymbolDumperImpl::printLocalVariableAddrRange( + const LocalVariableAddrRange &Range, uint32_t RelocationOffset) { + DictScope S(W, "LocalVariableAddrRange"); + if (ObjDelegate) + ObjDelegate->printRelocatedField("OffsetStart", RelocationOffset, + Range.OffsetStart); + W.printHex("ISectStart", Range.ISectStart); + W.printHex("Range", Range.Range); +} + +void CVSymbolDumperImpl::printLocalVariableAddrGap( + ArrayRef<LocalVariableAddrGap> Gaps) { + for (auto &Gap : Gaps) { + ListScope S(W, "LocalVariableAddrGap"); + W.printHex("GapStartOffset", Gap.GapStartOffset); + W.printHex("Range", Gap.Range); + } +} + +void CVSymbolDumperImpl::visitSymbolBegin(SymbolKind Kind, + ArrayRef<uint8_t> Data) {} + +void CVSymbolDumperImpl::visitSymbolEnd(SymbolKind Kind, + ArrayRef<uint8_t> OriginalSymData) { + if (PrintRecordBytes && ObjDelegate) + ObjDelegate->printBinaryBlockWithRelocs("SymData", OriginalSymData); +} + +void CVSymbolDumperImpl::visitBlockSym(SymbolKind Kind, BlockSym &Block) { + DictScope S(W, "BlockStart"); + + StringRef LinkageName; + W.printHex("PtrParent", Block.Header.PtrParent); + W.printHex("PtrEnd", Block.Header.PtrEnd); + W.printHex("CodeSize", Block.Header.CodeSize); + if (ObjDelegate) { + ObjDelegate->printRelocatedField("CodeOffset", Block.getRelocationOffset(), + Block.Header.CodeOffset, &LinkageName); + } + W.printHex("Segment", Block.Header.Segment); + W.printString("BlockName", Block.Name); + 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, getThunkOrdinalNames()); +} + +void CVSymbolDumperImpl::visitTrampolineSym(SymbolKind Kind, + TrampolineSym &Tramp) { + DictScope S(W, "Trampoline"); + W.printEnum("Type", Tramp.Header.Type, getTrampolineNames()); + 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.printFlags("Characteristics", Section.Header.Characteristics, + getImageSectionCharacteristicNames(), + COFF::SectionCharacteristics(0x00F00000)); + + W.printString("Name", Section.Name); +} + +void CVSymbolDumperImpl::visitCoffGroupSym(SymbolKind Kind, + CoffGroupSym &CoffGroup) { + DictScope S(W, "COFF Group"); + W.printNumber("Size", CoffGroup.Header.Size); + W.printFlags("Characteristics", CoffGroup.Header.Characteristics, + getImageSectionCharacteristicNames(), + COFF::SectionCharacteristics(0x00F00000)); + 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"); + + W.printNumber("Offset", BPRel.Header.Offset); + CVTD.printTypeIndex("Type", BPRel.Header.Type); + W.printString("VarName", BPRel.Name); +} + +void CVSymbolDumperImpl::visitBuildInfoSym(SymbolKind Kind, + BuildInfoSym &BuildInfo) { + DictScope S(W, "BuildInfo"); + + W.printNumber("BuildId", BuildInfo.Header.BuildId); +} + +void CVSymbolDumperImpl::visitCallSiteInfoSym(SymbolKind Kind, + CallSiteInfoSym &CallSiteInfo) { + DictScope S(W, "CallSiteInfo"); + + StringRef LinkageName; + if (ObjDelegate) { + ObjDelegate->printRelocatedField( + "CodeOffset", CallSiteInfo.getRelocationOffset(), + CallSiteInfo.Header.CodeOffset, &LinkageName); + } + W.printHex("Segment", CallSiteInfo.Header.Segment); + W.printHex("Reserved", CallSiteInfo.Header.Reserved); + CVTD.printTypeIndex("Type", CallSiteInfo.Header.Type); + if (!LinkageName.empty()) + 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), getLocalFlagNames()); + W.printString("Name", FileStatic.Name); +} + +void CVSymbolDumperImpl::visitExportSym(SymbolKind Kind, ExportSym &Export) { + DictScope S(W, "Export"); + W.printNumber("Ordinal", Export.Header.Ordinal); + W.printFlags("Flags", Export.Header.Flags, getExportSymFlagNames()); + W.printString("Name", Export.Name); +} + +void CVSymbolDumperImpl::visitCompile2Sym(SymbolKind Kind, + Compile2Sym &Compile2) { + DictScope S(W, "CompilerFlags2"); + + W.printEnum("Language", Compile2.Header.getLanguage(), + getSourceLanguageNames()); + W.printFlags("Flags", Compile2.Header.flags & ~0xff, + getCompileSym2FlagNames()); + W.printEnum("Machine", unsigned(Compile2.Header.Machine), getCPUTypeNames()); + 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, "CompilerFlags3"); + + W.printEnum("Language", Compile3.Header.getLanguage(), + getSourceLanguageNames()); + W.printFlags("Flags", Compile3.Header.flags & ~0xff, + getCompileSym3FlagNames()); + W.printEnum("Machine", unsigned(Compile3.Header.Machine), getCPUTypeNames()); + std::string FrontendVersion; + { + raw_string_ostream Out(FrontendVersion); + Out << Compile3.Header.VersionFrontendMajor << '.' + << Compile3.Header.VersionFrontendMinor << '.' + << Compile3.Header.VersionFrontendBuild << '.' + << Compile3.Header.VersionFrontendQFE; + } + std::string BackendVersion; + { + raw_string_ostream Out(BackendVersion); + Out << Compile3.Header.VersionBackendMajor << '.' + << Compile3.Header.VersionBackendMinor << '.' + << Compile3.Header.VersionBackendBuild << '.' + << Compile3.Header.VersionBackendQFE; + } + W.printString("FrontendVersion", FrontendVersion); + W.printString("BackendVersion", BackendVersion); + W.printString("VersionName", Compile3.Version); +} + +void CVSymbolDumperImpl::visitConstantSym(SymbolKind Kind, + ConstantSym &Constant) { + DictScope S(W, "Constant"); + + CVTD.printTypeIndex("Type", Constant.Header.Type); + W.printNumber("Value", Constant.Value); + W.printString("Name", Constant.Name); +} + +void CVSymbolDumperImpl::visitDataSym(SymbolKind Kind, DataSym &Data) { + DictScope S(W, "DataSym"); + + W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames()); + StringRef LinkageName; + if (ObjDelegate) { + ObjDelegate->printRelocatedField("DataOffset", Data.getRelocationOffset(), + Data.Header.DataOffset, &LinkageName); + } + CVTD.printTypeIndex("Type", Data.Header.Type); + W.printString("DisplayName", Data.Name); + if (!LinkageName.empty()) + W.printString("LinkageName", LinkageName); +} + +void CVSymbolDumperImpl::visitDefRangeFramePointerRelFullScopeSym( + SymbolKind Kind, + DefRangeFramePointerRelFullScopeSym &DefRangeFramePointerRelFullScope) { + DictScope S(W, "DefRangeFramePointerRelFullScope"); + W.printNumber("Offset", DefRangeFramePointerRelFullScope.Header.Offset); +} + +void CVSymbolDumperImpl::visitDefRangeFramePointerRelSym( + SymbolKind Kind, DefRangeFramePointerRelSym &DefRangeFramePointerRel) { + DictScope S(W, "DefRangeFramePointerRel"); + + W.printNumber("Offset", DefRangeFramePointerRel.Header.Offset); + printLocalVariableAddrRange(DefRangeFramePointerRel.Header.Range, + DefRangeFramePointerRel.getRelocationOffset()); + printLocalVariableAddrGap(DefRangeFramePointerRel.Gaps); +} + +void CVSymbolDumperImpl::visitDefRangeRegisterRelSym( + SymbolKind Kind, DefRangeRegisterRelSym &DefRangeRegisterRel) { + DictScope S(W, "DefRangeRegisterRel"); + + W.printNumber("BaseRegister", DefRangeRegisterRel.Header.BaseRegister); + W.printBoolean("HasSpilledUDTMember", + DefRangeRegisterRel.hasSpilledUDTMember()); + W.printNumber("OffsetInParent", DefRangeRegisterRel.offsetInParent()); + W.printNumber("BasePointerOffset", + DefRangeRegisterRel.Header.BasePointerOffset); + printLocalVariableAddrRange(DefRangeRegisterRel.Header.Range, + DefRangeRegisterRel.getRelocationOffset()); + printLocalVariableAddrGap(DefRangeRegisterRel.Gaps); +} + +void CVSymbolDumperImpl::visitDefRangeRegisterSym( + SymbolKind Kind, DefRangeRegisterSym &DefRangeRegister) { + DictScope S(W, "DefRangeRegister"); + + W.printNumber("Register", DefRangeRegister.Header.Register); + W.printNumber("MayHaveNoName", DefRangeRegister.Header.MayHaveNoName); + printLocalVariableAddrRange(DefRangeRegister.Header.Range, + DefRangeRegister.getRelocationOffset()); + printLocalVariableAddrGap(DefRangeRegister.Gaps); +} + +void CVSymbolDumperImpl::visitDefRangeSubfieldRegisterSym( + SymbolKind Kind, DefRangeSubfieldRegisterSym &DefRangeSubfieldRegister) { + DictScope S(W, "DefRangeSubfieldRegister"); + + W.printNumber("Register", DefRangeSubfieldRegister.Header.Register); + W.printNumber("MayHaveNoName", DefRangeSubfieldRegister.Header.MayHaveNoName); + W.printNumber("OffsetInParent", + DefRangeSubfieldRegister.Header.OffsetInParent); + printLocalVariableAddrRange(DefRangeSubfieldRegister.Header.Range, + DefRangeSubfieldRegister.getRelocationOffset()); + printLocalVariableAddrGap(DefRangeSubfieldRegister.Gaps); +} + +void CVSymbolDumperImpl::visitDefRangeSubfieldSym( + SymbolKind Kind, DefRangeSubfieldSym &DefRangeSubfield) { + DictScope S(W, "DefRangeSubfield"); + + if (ObjDelegate) { + StringRef StringTable = ObjDelegate->getStringTable(); + auto ProgramStringTableOffset = DefRangeSubfield.Header.Program; + if (ProgramStringTableOffset >= StringTable.size()) + return parseError(); + StringRef Program = + StringTable.drop_front(ProgramStringTableOffset).split('\0').first; + W.printString("Program", Program); + } + W.printNumber("OffsetInParent", DefRangeSubfield.Header.OffsetInParent); + printLocalVariableAddrRange(DefRangeSubfield.Header.Range, + DefRangeSubfield.getRelocationOffset()); + printLocalVariableAddrGap(DefRangeSubfield.Gaps); +} + +void CVSymbolDumperImpl::visitDefRangeSym(SymbolKind Kind, + DefRangeSym &DefRange) { + DictScope S(W, "DefRange"); + + if (ObjDelegate) { + StringRef StringTable = ObjDelegate->getStringTable(); + auto ProgramStringTableOffset = DefRange.Header.Program; + if (ProgramStringTableOffset >= StringTable.size()) + return parseError(); + StringRef Program = + StringTable.drop_front(ProgramStringTableOffset).split('\0').first; + W.printString("Program", Program); + } + printLocalVariableAddrRange(DefRange.Header.Range, + DefRange.getRelocationOffset()); + printLocalVariableAddrGap(DefRange.Gaps); +} + +void CVSymbolDumperImpl::visitFrameCookieSym(SymbolKind Kind, + FrameCookieSym &FrameCookie) { + DictScope S(W, "FrameCookie"); + + StringRef LinkageName; + if (ObjDelegate) { + ObjDelegate->printRelocatedField( + "CodeOffset", FrameCookie.getRelocationOffset(), + FrameCookie.Header.CodeOffset, &LinkageName); + } + W.printHex("Register", FrameCookie.Header.Register); + W.printEnum("CookieKind", uint16_t(FrameCookie.Header.CookieKind), + getFrameCookieKindNames()); + W.printHex("Flags", FrameCookie.Header.Flags); +} + +void CVSymbolDumperImpl::visitFrameProcSym(SymbolKind Kind, + FrameProcSym &FrameProc) { + DictScope S(W, "FrameProc"); + + W.printHex("TotalFrameBytes", FrameProc.Header.TotalFrameBytes); + W.printHex("PaddingFrameBytes", FrameProc.Header.PaddingFrameBytes); + W.printHex("OffsetToPadding", FrameProc.Header.OffsetToPadding); + W.printHex("BytesOfCalleeSavedRegisters", + FrameProc.Header.BytesOfCalleeSavedRegisters); + W.printHex("OffsetOfExceptionHandler", + FrameProc.Header.OffsetOfExceptionHandler); + W.printHex("SectionIdOfExceptionHandler", + FrameProc.Header.SectionIdOfExceptionHandler); + W.printFlags("Flags", FrameProc.Header.Flags, getFrameProcSymFlagNames()); +} + +void CVSymbolDumperImpl::visitHeapAllocationSiteSym( + SymbolKind Kind, HeapAllocationSiteSym &HeapAllocSite) { + DictScope S(W, "HeapAllocationSite"); + + StringRef LinkageName; + if (ObjDelegate) { + ObjDelegate->printRelocatedField( + "CodeOffset", HeapAllocSite.getRelocationOffset(), + HeapAllocSite.Header.CodeOffset, &LinkageName); + } + W.printHex("Segment", HeapAllocSite.Header.Segment); + W.printHex("CallInstructionSize", HeapAllocSite.Header.CallInstructionSize); + CVTD.printTypeIndex("Type", HeapAllocSite.Header.Type); + if (!LinkageName.empty()) + W.printString("LinkageName", LinkageName); +} + +void CVSymbolDumperImpl::visitInlineSiteSym(SymbolKind Kind, + InlineSiteSym &InlineSite) { + DictScope S(W, "InlineSite"); + + W.printHex("PtrParent", InlineSite.Header.PtrParent); + W.printHex("PtrEnd", InlineSite.Header.PtrEnd); + CVTD.printTypeIndex("Inlinee", InlineSite.Header.Inlinee); + + ListScope BinaryAnnotations(W, "BinaryAnnotations"); + for (auto &Annotation : InlineSite.annotations()) { + switch (Annotation.OpCode) { + case BinaryAnnotationsOpCode::Invalid: + return parseError(); + case BinaryAnnotationsOpCode::CodeOffset: + case BinaryAnnotationsOpCode::ChangeCodeOffset: + case BinaryAnnotationsOpCode::ChangeCodeLength: + W.printHex(Annotation.Name, Annotation.U1); + break; + case BinaryAnnotationsOpCode::ChangeCodeOffsetBase: + case BinaryAnnotationsOpCode::ChangeLineEndDelta: + case BinaryAnnotationsOpCode::ChangeRangeKind: + case BinaryAnnotationsOpCode::ChangeColumnStart: + case BinaryAnnotationsOpCode::ChangeColumnEnd: + W.printNumber(Annotation.Name, Annotation.U1); + break; + case BinaryAnnotationsOpCode::ChangeLineOffset: + case BinaryAnnotationsOpCode::ChangeColumnEndDelta: + W.printNumber(Annotation.Name, Annotation.S1); + break; + case BinaryAnnotationsOpCode::ChangeFile: + if (ObjDelegate) { + W.printHex("ChangeFile", + ObjDelegate->getFileNameForFileOffset(Annotation.U1), + Annotation.U1); + } else { + W.printHex("ChangeFile", Annotation.U1); + } + + break; + case BinaryAnnotationsOpCode::ChangeCodeOffsetAndLineOffset: { + W.startLine() << "ChangeCodeOffsetAndLineOffset: {CodeOffset: " + << W.hex(Annotation.U1) << ", LineOffset: " << Annotation.S1 + << "}\n"; + break; + } + case BinaryAnnotationsOpCode::ChangeCodeLengthAndCodeOffset: { + W.startLine() << "ChangeCodeLengthAndCodeOffset: {CodeOffset: " + << W.hex(Annotation.U2) + << ", Length: " << W.hex(Annotation.U1) << "}\n"; + break; + } + } + } +} + +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), getRegisterNames()); + W.printString("Name", Register.Name); +} + +void CVSymbolDumperImpl::visitPublicSym32(SymbolKind Kind, + PublicSym32 &Public) { + DictScope S(W, "PublicSym"); + W.printNumber("Type", Public.Header.Index); + W.printNumber("Seg", Public.Header.Seg); + W.printNumber("Off", Public.Header.Off); + W.printString("Name", Public.Name); +} + +void CVSymbolDumperImpl::visitProcRefSym(SymbolKind Kind, ProcRefSym &ProcRef) { + DictScope S(W, "ProcRef"); + W.printNumber("SumName", ProcRef.Header.SumName); + W.printNumber("SymOffset", ProcRef.Header.SymOffset); + W.printNumber("Mod", ProcRef.Header.Mod); + W.printString("Name", ProcRef.Name); +} + +void CVSymbolDumperImpl::visitLabelSym(SymbolKind Kind, LabelSym &Label) { + DictScope S(W, "Label"); + + StringRef LinkageName; + if (ObjDelegate) { + ObjDelegate->printRelocatedField("CodeOffset", Label.getRelocationOffset(), + Label.Header.CodeOffset, &LinkageName); + } + W.printHex("Segment", Label.Header.Segment); + W.printHex("Flags", Label.Header.Flags); + W.printFlags("Flags", Label.Header.Flags, getProcSymFlagNames()); + W.printString("DisplayName", Label.Name); + if (!LinkageName.empty()) + W.printString("LinkageName", LinkageName); +} + +void CVSymbolDumperImpl::visitLocalSym(SymbolKind Kind, LocalSym &Local) { + DictScope S(W, "Local"); + + CVTD.printTypeIndex("Type", Local.Header.Type); + W.printFlags("Flags", uint16_t(Local.Header.Flags), getLocalFlagNames()); + W.printString("VarName", Local.Name); +} + +void CVSymbolDumperImpl::visitObjNameSym(SymbolKind Kind, ObjNameSym &ObjName) { + DictScope S(W, "ObjectName"); + + W.printHex("Signature", ObjName.Header.Signature); + W.printString("ObjectName", ObjName.Name); +} + +void CVSymbolDumperImpl::visitProcSym(SymbolKind Kind, ProcSym &Proc) { + DictScope S(W, "ProcStart"); + + if (InFunctionScope) + return parseError(); + + InFunctionScope = true; + + StringRef LinkageName; + W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames()); + W.printHex("PtrParent", Proc.Header.PtrParent); + W.printHex("PtrEnd", Proc.Header.PtrEnd); + W.printHex("PtrNext", Proc.Header.PtrNext); + W.printHex("CodeSize", Proc.Header.CodeSize); + W.printHex("DbgStart", Proc.Header.DbgStart); + W.printHex("DbgEnd", Proc.Header.DbgEnd); + CVTD.printTypeIndex("FunctionType", Proc.Header.FunctionType); + if (ObjDelegate) { + ObjDelegate->printRelocatedField("CodeOffset", Proc.getRelocationOffset(), + Proc.Header.CodeOffset, &LinkageName); + } + W.printHex("Segment", Proc.Header.Segment); + W.printFlags("Flags", static_cast<uint8_t>(Proc.Header.Flags), + getProcSymFlagNames()); + W.printString("DisplayName", Proc.Name); + if (!LinkageName.empty()) + W.printString("LinkageName", LinkageName); +} + +void CVSymbolDumperImpl::visitScopeEndSym(SymbolKind Kind, + ScopeEndSym &ScopeEnd) { + if (Kind == SymbolKind::S_END) + DictScope S(W, "BlockEnd"); + else if (Kind == SymbolKind::S_PROC_ID_END) + DictScope S(W, "ProcEnd"); + else if (Kind == SymbolKind::S_INLINESITE_END) + DictScope S(W, "InlineSiteEnd"); + + InFunctionScope = false; +} + +void CVSymbolDumperImpl::visitCallerSym(SymbolKind Kind, CallerSym &Caller) { + ListScope S(W, Kind == S_CALLEES ? "Callees" : "Callers"); + for (auto FuncID : Caller.Indices) + CVTD.printTypeIndex("FuncID", FuncID); +} + +void CVSymbolDumperImpl::visitRegRelativeSym(SymbolKind Kind, + RegRelativeSym &RegRel) { + DictScope S(W, "RegRelativeSym"); + + W.printHex("Offset", RegRel.Header.Offset); + CVTD.printTypeIndex("Type", RegRel.Header.Type); + W.printHex("Register", RegRel.Header.Register); + W.printString("VarName", RegRel.Name); +} + +void CVSymbolDumperImpl::visitThreadLocalDataSym(SymbolKind Kind, + ThreadLocalDataSym &Data) { + DictScope S(W, "ThreadLocalDataSym"); + + StringRef LinkageName; + if (ObjDelegate) { + ObjDelegate->printRelocatedField("DataOffset", Data.getRelocationOffset(), + Data.Header.DataOffset, &LinkageName); + } + CVTD.printTypeIndex("Type", Data.Header.Type); + W.printString("DisplayName", Data.Name); + if (!LinkageName.empty()) + W.printString("LinkageName", LinkageName); +} + +void CVSymbolDumperImpl::visitUDTSym(SymbolKind Kind, UDTSym &UDT) { + DictScope S(W, "UDT"); + CVTD.printTypeIndex("Type", UDT.Header.Type); + W.printString("UDTName", UDT.Name); +} + +void CVSymbolDumperImpl::visitUnknownSymbol(SymbolKind Kind, + ArrayRef<uint8_t> Data) { + DictScope S(W, "UnknownSym"); + W.printEnum("Kind", uint16_t(Kind), getSymbolTypeNames()); + W.printNumber("Length", uint32_t(Data.size())); +} + +bool CVSymbolDumper::dump(const CVRecord<SymbolKind> &Record) { + CVSymbolDumperImpl Dumper(CVTD, ObjDelegate.get(), W, PrintRecordBytes); + Dumper.visitSymbolRecord(Record); + return !Dumper.hadError(); +} + +bool CVSymbolDumper::dump(const CVSymbolArray &Symbols) { + CVSymbolDumperImpl Dumper(CVTD, ObjDelegate.get(), W, PrintRecordBytes); + Dumper.visitSymbolStream(Symbols); + return !Dumper.hadError(); +} |