RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-03-02 17:29:03 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[ObjectYAML] Split CodeViewYAML into 3 pieces.

Browse Source 
The code was a mess and disorganized due to the sheer amount
of it being in one file.  So I'm splitting this into three files.
One for CodeView types, one for CodeView symbols, and one for
CodeView debug subsections.  NFC.

llvm-svn: 304278
This commit is contained in:
Zachary Turner 2017-05-31 04:17:13 +00:00
parent 7e016ab9a2
commit b1bdd69c7b
11 changed files with 728 additions and 608 deletions

47
include/llvm/ObjectYAML/CodeViewYAML.h → include/llvm/ObjectYAML/CodeViewYAMLDebugSections.h

@ -1,4 +1,4 @@
//===- CodeViewYAML.cpp - CodeView YAMLIO implementation ------------------===//
//===- CodeViewYAMLDebugSections.h - CodeView YAMLIO debug sections -------===//
//
// The LLVM Compiler Infrastructure
//
@ -12,33 +12,17 @@
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OBJECTYAML_CODEVIEWYAML_H
#define LLVM_OBJECTYAML_CODEVIEWYAML_H
#ifndef LLVM_OBJECTYAML_CODEVIEWYAMLDEBUGSECTIONS_H
#define LLVM_OBJECTYAML_CODEVIEWYAMLDEBUGSECTIONS_H
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/DebugSubsection.h"
#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
#include "llvm/DebugInfo/CodeView/TypeSerializer.h"
#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
#include "llvm/ObjectYAML/YAML.h"
namespace llvm {
namespace CodeViewYAML {
namespace detail {
struct C13FragmentBase;
struct LeafRecordBase;
struct MemberRecordBase;
struct SymbolRecordBase;
}
namespace detail {
struct MemberRecordBase;
struct LeafRecordBase;
struct SymbolRecordBase;
}
struct SourceLineEntry {
@ -96,37 +80,12 @@ struct SourceFileInfo {
std::vector<InlineeInfo> Inlinees;
};
struct MemberRecord {
std::shared_ptr<detail::MemberRecordBase> Member;
};
struct LeafRecord {
std::shared_ptr<detail::LeafRecordBase> Leaf;
codeview::CVType toCodeViewRecord(BumpPtrAllocator &Allocator) const;
static Expected<LeafRecord> fromCodeViewRecord(codeview::CVType Type);
};
struct SymbolRecord {
std::shared_ptr<detail::SymbolRecordBase> Symbol;
codeview::CVSymbol toCodeViewSymbol(BumpPtrAllocator &Allocator) const;
static Expected<SymbolRecord> fromCodeViewSymbol(codeview::CVSymbol Symbol);
};
struct C13DebugSection {
std::vector<detail::C13FragmentBase> Fragments;
};
} // namespace CodeViewYAML
} // namespace llvm
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::LeafRecord)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::MemberRecord)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SymbolRecord)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceFileInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::LeafRecord)
LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::MemberRecord)
LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::SymbolRecord)
#endif

41
include/llvm/ObjectYAML/CodeViewYAMLSymbols.h Normal file

@ -0,0 +1,41 @@
//===- CodeViewYAMLSymbols.h - CodeView YAMLIO Symbol implementation ------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of CodeView
// Debug Info.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OBJECTYAML_CODEVIEWYAMLSYMBOLS_H
#define LLVM_OBJECTYAML_CODEVIEWYAMLSYMBOLS_H
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
#include "llvm/ObjectYAML/YAML.h"
namespace llvm {
namespace CodeViewYAML {
namespace detail {
struct SymbolRecordBase;
}
struct SymbolRecord {
std::shared_ptr<detail::SymbolRecordBase> Symbol;
codeview::CVSymbol toCodeViewSymbol(BumpPtrAllocator &Allocator) const;
static Expected<SymbolRecord> fromCodeViewSymbol(codeview::CVSymbol Symbol);
};
} // namespace CodeViewYAML
} // namespace llvm
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SymbolRecord)
LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::SymbolRecord)
#endif

48
include/llvm/ObjectYAML/CodeViewYAMLTypes.h Normal file

@ -0,0 +1,48 @@
//===- CodeViewYAMLTypes.h - CodeView YAMLIO Type Record implementation ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of CodeView
// Debug Info.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OBJECTYAML_CODEVIEWYAMLTYPES_H
#define LLVM_OBJECTYAML_CODEVIEWYAMLTYPES_H
#include "llvm/DebugInfo/CodeView/CodeView.h"
#include "llvm/DebugInfo/CodeView/TypeRecord.h"
#include "llvm/ObjectYAML/YAML.h"
namespace llvm {
namespace CodeViewYAML {
namespace detail {
struct LeafRecordBase;
struct MemberRecordBase;
}
struct MemberRecord {
std::shared_ptr<detail::MemberRecordBase> Member;
};
struct LeafRecord {
std::shared_ptr<detail::LeafRecordBase> Leaf;
codeview::CVType toCodeViewRecord(BumpPtrAllocator &Allocator) const;
static Expected<LeafRecord> fromCodeViewRecord(codeview::CVType Type);
};
} // namespace CodeViewYAML
} // namespace llvm
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::LeafRecord)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::MemberRecord)
LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::LeafRecord)
LLVM_YAML_IS_SEQUENCE_VECTOR(CodeViewYAML::MemberRecord)
#endif

4
lib/ObjectYAML/CMakeLists.txt

@ -1,5 +1,7 @@
add_llvm_library(LLVMObjectYAML
CodeViewYAML.cpp
CodeViewYAMLTypes.cpp
CodeViewYAMLSymbols.cpp
CodeViewYAMLDebugSections.cpp
COFFYAML.cpp
DWARFEmitter.cpp
DWARFVisitor.cpp

127
lib/ObjectYAML/CodeViewYAMLDebugSections.cpp Normal file

@ -0,0 +1,127 @@
//===- CodeViewYAMLDebugSections.cpp - CodeView YAMLIO debug sections -----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of CodeView
// Debug Info.
//
//===----------------------------------------------------------------------===//
#include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/DebugInfo/CodeView/CodeViewError.h"
#include "llvm/DebugInfo/CodeView/EnumTables.h"
#include "llvm/DebugInfo/CodeView/SymbolRecord.h"
using namespace llvm;
using namespace llvm::codeview;
using namespace llvm::CodeViewYAML;
using namespace llvm::CodeViewYAML::detail;
using namespace llvm::yaml;
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceFileChecksumEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceColumnEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineBlock)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeSite)
LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
LLVM_YAML_DECLARE_SCALAR_TRAITS(HexFormattedString, false)
LLVM_YAML_DECLARE_ENUM_TRAITS(FileChecksumKind)
LLVM_YAML_DECLARE_BITSET_TRAITS(LineFlags)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceLineEntry)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceColumnEntry)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceFileChecksumEntry)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceLineInfo)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceLineBlock)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::InlineeInfo)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::InlineeSite)
void ScalarBitSetTraits<LineFlags>::bitset(IO &io, LineFlags &Flags) {
io.bitSetCase(Flags, "HasColumnInfo", LF_HaveColumns);
io.enumFallback<Hex16>(Flags);
}
void ScalarEnumerationTraits<FileChecksumKind>::enumeration(
IO &io, FileChecksumKind &Kind) {
io.enumCase(Kind, "None", FileChecksumKind::None);
io.enumCase(Kind, "MD5", FileChecksumKind::MD5);
io.enumCase(Kind, "SHA1", FileChecksumKind::SHA1);
io.enumCase(Kind, "SHA256", FileChecksumKind::SHA256);
}
void ScalarTraits<HexFormattedString>::output(const HexFormattedString &Value,
void *ctx, raw_ostream &Out) {
StringRef Bytes(reinterpret_cast<const char *>(Value.Bytes.data()),
Value.Bytes.size());
Out << toHex(Bytes);
}
StringRef ScalarTraits<HexFormattedString>::input(StringRef Scalar, void *ctxt,
HexFormattedString &Value) {
std::string H = fromHex(Scalar);
Value.Bytes.assign(H.begin(), H.end());
return StringRef();
}
void MappingTraits<SourceLineEntry>::mapping(IO &IO, SourceLineEntry &Obj) {
IO.mapRequired("Offset", Obj.Offset);
IO.mapRequired("LineStart", Obj.LineStart);
IO.mapRequired("IsStatement", Obj.IsStatement);
IO.mapRequired("EndDelta", Obj.EndDelta);
}
void MappingTraits<SourceColumnEntry>::mapping(IO &IO, SourceColumnEntry &Obj) {
IO.mapRequired("StartColumn", Obj.StartColumn);
IO.mapRequired("EndColumn", Obj.EndColumn);
}
void MappingTraits<SourceLineBlock>::mapping(IO &IO, SourceLineBlock &Obj) {
IO.mapRequired("FileName", Obj.FileName);
IO.mapRequired("Lines", Obj.Lines);
IO.mapRequired("Columns", Obj.Columns);
}
void MappingTraits<SourceFileChecksumEntry>::mapping(
IO &IO, SourceFileChecksumEntry &Obj) {
IO.mapRequired("FileName", Obj.FileName);
IO.mapRequired("Kind", Obj.Kind);
IO.mapRequired("Checksum", Obj.ChecksumBytes);
}
void MappingTraits<SourceLineInfo>::mapping(IO &IO, SourceLineInfo &Obj) {
IO.mapRequired("CodeSize", Obj.CodeSize);
IO.mapRequired("Flags", Obj.Flags);
IO.mapRequired("RelocOffset", Obj.RelocOffset);
IO.mapRequired("RelocSegment", Obj.RelocSegment);
IO.mapRequired("Blocks", Obj.Blocks);
}
void MappingTraits<SourceFileInfo>::mapping(IO &IO, SourceFileInfo &Obj) {
IO.mapOptional("Checksums", Obj.FileChecksums);
IO.mapOptional("Lines", Obj.LineFragments);
IO.mapOptional("InlineeLines", Obj.Inlinees);
}
void MappingTraits<InlineeSite>::mapping(IO &IO, InlineeSite &Obj) {
IO.mapRequired("FileName", Obj.FileName);
IO.mapRequired("LineNum", Obj.SourceLineNum);
IO.mapRequired("Inlinee", Obj.Inlinee);
IO.mapOptional("ExtraFiles", Obj.ExtraFiles);
}
void MappingTraits<InlineeInfo>::mapping(IO &IO, InlineeInfo &Obj) {
IO.mapRequired("HasExtraFiles", Obj.HasExtraFiles);
IO.mapRequired("Sites", Obj.Sites);
}

496
lib/ObjectYAML/CodeViewYAMLSymbols.cpp Normal file

@ -0,0 +1,496 @@
//===- CodeViewYAMLSymbols.cpp - CodeView YAMLIO Symbol implementation ----===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of CodeView
// Debug Info.
//
//===----------------------------------------------------------------------===//
#include "llvm/ObjectYAML/CodeViewYAMLSymbols.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
#include "llvm/DebugInfo/CodeView/CodeViewError.h"
#include "llvm/DebugInfo/CodeView/EnumTables.h"
#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
using namespace llvm;
using namespace llvm::codeview;
using namespace llvm::CodeViewYAML;
using namespace llvm::CodeViewYAML::detail;
using namespace llvm::yaml;
LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
// We only need to declare these, the definitions are in CodeViewYAMLTypes.cpp
LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, false)
LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, false)
LLVM_YAML_DECLARE_ENUM_TRAITS(SymbolKind)
LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym2Flags)
LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym3Flags)
LLVM_YAML_DECLARE_BITSET_TRAITS(ExportFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(LocalSymFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(ProcSymFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(FrameProcedureOptions)
LLVM_YAML_DECLARE_ENUM_TRAITS(CPUType)
LLVM_YAML_DECLARE_ENUM_TRAITS(RegisterId)
LLVM_YAML_DECLARE_ENUM_TRAITS(TrampolineType)
LLVM_YAML_DECLARE_ENUM_TRAITS(ThunkOrdinal)
void ScalarEnumerationTraits<SymbolKind>::enumeration(IO &io,
SymbolKind &Value) {
auto SymbolNames = getSymbolTypeNames();
for (const auto &E : SymbolNames)
io.enumCase(Value, E.Name.str().c_str(), E.Value);
}
void ScalarBitSetTraits<CompileSym2Flags>::bitset(IO &io,
CompileSym2Flags &Flags) {
auto FlagNames = getCompileSym2FlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<CompileSym2Flags>(E.Value));
}
}
void ScalarBitSetTraits<CompileSym3Flags>::bitset(IO &io,
CompileSym3Flags &Flags) {
auto FlagNames = getCompileSym3FlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<CompileSym3Flags>(E.Value));
}
}
void ScalarBitSetTraits<ExportFlags>::bitset(IO &io, ExportFlags &Flags) {
auto FlagNames = getExportSymFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<ExportFlags>(E.Value));
}
}
void ScalarBitSetTraits<LocalSymFlags>::bitset(IO &io, LocalSymFlags &Flags) {
auto FlagNames = getLocalFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<LocalSymFlags>(E.Value));
}
}
void ScalarBitSetTraits<ProcSymFlags>::bitset(IO &io, ProcSymFlags &Flags) {
auto FlagNames = getProcSymFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<ProcSymFlags>(E.Value));
}
}
void ScalarBitSetTraits<FrameProcedureOptions>::bitset(
IO &io, FrameProcedureOptions &Flags) {
auto FlagNames = getFrameProcSymFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<FrameProcedureOptions>(E.Value));
}
}
void ScalarEnumerationTraits<CPUType>::enumeration(IO &io, CPUType &Cpu) {
auto CpuNames = getCPUTypeNames();
for (const auto &E : CpuNames) {
io.enumCase(Cpu, E.Name.str().c_str(), static_cast<CPUType>(E.Value));
}
}
void ScalarEnumerationTraits<RegisterId>::enumeration(IO &io, RegisterId &Reg) {
auto RegNames = getRegisterNames();
for (const auto &E : RegNames) {
io.enumCase(Reg, E.Name.str().c_str(), static_cast<RegisterId>(E.Value));
}
io.enumFallback<Hex16>(Reg);
}
void ScalarEnumerationTraits<TrampolineType>::enumeration(
IO &io, TrampolineType &Tramp) {
auto TrampNames = getTrampolineNames();
for (const auto &E : TrampNames) {
io.enumCase(Tramp, E.Name.str().c_str(),
static_cast<TrampolineType>(E.Value));
}
}
void ScalarEnumerationTraits<ThunkOrdinal>::enumeration(IO &io,
ThunkOrdinal &Ord) {
auto ThunkNames = getThunkOrdinalNames();
for (const auto &E : ThunkNames) {
io.enumCase(Ord, E.Name.str().c_str(), static_cast<ThunkOrdinal>(E.Value));
}
}
namespace llvm {
namespace CodeViewYAML {
namespace detail {
struct SymbolRecordBase {
codeview::SymbolKind Kind;
explicit SymbolRecordBase(codeview::SymbolKind K) : Kind(K) {}
virtual ~SymbolRecordBase() {}
virtual void map(yaml::IO &io) = 0;
virtual codeview::CVSymbol
toCodeViewSymbol(BumpPtrAllocator &Allocator) const = 0;
virtual Error fromCodeViewSymbol(codeview::CVSymbol Type) = 0;
};
template <typename T> struct SymbolRecordImpl : public SymbolRecordBase {
explicit SymbolRecordImpl(codeview::SymbolKind K)
: SymbolRecordBase(K), Symbol(static_cast<SymbolRecordKind>(K)) {}
void map(yaml::IO &io) override;
codeview::CVSymbol
toCodeViewSymbol(BumpPtrAllocator &Allocator) const override {
return SymbolSerializer::writeOneSymbol(Symbol, Allocator);
}
Error fromCodeViewSymbol(codeview::CVSymbol CVS) override {
return SymbolDeserializer::deserializeAs<T>(CVS, Symbol);
}
mutable T Symbol;
};
template <> void SymbolRecordImpl<ScopeEndSym>::map(IO &IO) {}
template <> void SymbolRecordImpl<Thunk32Sym>::map(IO &IO) {
IO.mapRequired("Parent", Symbol.Parent);
IO.mapRequired("End", Symbol.End);
IO.mapRequired("Next", Symbol.Next);
IO.mapRequired("Off", Symbol.Offset);
IO.mapRequired("Seg", Symbol.Segment);
IO.mapRequired("Len", Symbol.Length);
IO.mapRequired("Ordinal", Symbol.Thunk);
}
template <> void SymbolRecordImpl<TrampolineSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Size", Symbol.Size);
IO.mapRequired("ThunkOff", Symbol.ThunkOffset);
IO.mapRequired("TargetOff", Symbol.TargetOffset);
IO.mapRequired("ThunkSection", Symbol.ThunkSection);
IO.mapRequired("TargetSection", Symbol.TargetSection);
}
template <> void SymbolRecordImpl<SectionSym>::map(IO &IO) {
IO.mapRequired("SectionNumber", Symbol.SectionNumber);
IO.mapRequired("Alignment", Symbol.Alignment);
IO.mapRequired("Rva", Symbol.Rva);
IO.mapRequired("Length", Symbol.Length);
IO.mapRequired("Characteristics", Symbol.Characteristics);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<CoffGroupSym>::map(IO &IO) {
IO.mapRequired("Size", Symbol.Size);
IO.mapRequired("Characteristics", Symbol.Characteristics);
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<ExportSym>::map(IO &IO) {
IO.mapRequired("Ordinal", Symbol.Ordinal);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<ProcSym>::map(IO &IO) {
// TODO: Print the linkage name
IO.mapRequired("PtrParent", Symbol.Parent);
IO.mapRequired("PtrEnd", Symbol.End);
IO.mapRequired("PtrNext", Symbol.Next);
IO.mapRequired("CodeSize", Symbol.CodeSize);
IO.mapRequired("DbgStart", Symbol.DbgStart);
IO.mapRequired("DbgEnd", Symbol.DbgEnd);
IO.mapRequired("FunctionType", Symbol.FunctionType);
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("DisplayName", Symbol.Name);
}
template <> void SymbolRecordImpl<RegisterSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Index);
IO.mapRequired("Seg", Symbol.Register);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<PublicSym32>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Index);
IO.mapRequired("Seg", Symbol.Segment);
IO.mapRequired("Off", Symbol.Offset);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<ProcRefSym>::map(IO &IO) {
IO.mapRequired("SumName", Symbol.SumName);
IO.mapRequired("SymOffset", Symbol.SymOffset);
IO.mapRequired("Mod", Symbol.Module);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<EnvBlockSym>::map(IO &IO) {
IO.mapRequired("Entries", Symbol.Fields);
}
template <> void SymbolRecordImpl<InlineSiteSym>::map(IO &IO) {
IO.mapRequired("PtrParent", Symbol.Parent);
IO.mapRequired("PtrEnd", Symbol.End);
IO.mapRequired("Inlinee", Symbol.Inlinee);
// TODO: The binary annotations
}
template <> void SymbolRecordImpl<LocalSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("VarName", Symbol.Name);
}
template <> void SymbolRecordImpl<DefRangeSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeSubfieldSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeRegisterSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeFramePointerRelSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeSubfieldRegisterSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <>
void SymbolRecordImpl<DefRangeFramePointerRelFullScopeSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeRegisterRelSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<BlockSym>::map(IO &IO) {
// TODO: Print the linkage name
IO.mapRequired("PtrParent", Symbol.Parent);
IO.mapRequired("PtrEnd", Symbol.End);
IO.mapRequired("CodeSize", Symbol.CodeSize);
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("BlockName", Symbol.Name);
}
template <> void SymbolRecordImpl<LabelSym>::map(IO &IO) {
// TODO: Print the linkage name
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("DisplayName", Symbol.Name);
}
template <> void SymbolRecordImpl<ObjNameSym>::map(IO &IO) {
IO.mapRequired("Signature", Symbol.Signature);
IO.mapRequired("ObjectName", Symbol.Name);
}
template <> void SymbolRecordImpl<Compile2Sym>::map(IO &IO) {
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Machine", Symbol.Machine);
IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor);
IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor);
IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild);
IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor);
IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor);
IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild);
IO.mapRequired("Version", Symbol.Version);
}
template <> void SymbolRecordImpl<Compile3Sym>::map(IO &IO) {
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Machine", Symbol.Machine);
IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor);
IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor);
IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild);
IO.mapRequired("FrontendQFE", Symbol.VersionFrontendQFE);
IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor);
IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor);
IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild);
IO.mapRequired("BackendQFE", Symbol.VersionBackendQFE);
IO.mapRequired("Version", Symbol.Version);
}
template <> void SymbolRecordImpl<FrameProcSym>::map(IO &IO) {
IO.mapRequired("TotalFrameBytes", Symbol.TotalFrameBytes);
IO.mapRequired("PaddingFrameBytes", Symbol.PaddingFrameBytes);
IO.mapRequired("OffsetToPadding", Symbol.OffsetToPadding);
IO.mapRequired("BytesOfCalleeSavedRegisters",
Symbol.BytesOfCalleeSavedRegisters);
IO.mapRequired("OffsetOfExceptionHandler", Symbol.OffsetOfExceptionHandler);
IO.mapRequired("SectionIdOfExceptionHandler",
Symbol.SectionIdOfExceptionHandler);
IO.mapRequired("Flags", Symbol.Flags);
}
template <> void SymbolRecordImpl<CallSiteInfoSym>::map(IO &IO) {
// TODO: Map Linkage Name
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Type", Symbol.Type);
}
template <> void SymbolRecordImpl<FileStaticSym>::map(IO &IO) {
IO.mapRequired("Index", Symbol.Index);
IO.mapRequired("ModFilenameOffset", Symbol.ModFilenameOffset);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<HeapAllocationSiteSym>::map(IO &IO) {
// TODO: Map Linkage Name
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("CallInstructionSize", Symbol.CallInstructionSize);
IO.mapRequired("Type", Symbol.Type);
}
template <> void SymbolRecordImpl<FrameCookieSym>::map(IO &IO) {
// TODO: Map Linkage Name
IO.mapRequired("Register", Symbol.Register);
IO.mapRequired("CookieKind", Symbol.CookieKind);
IO.mapRequired("Flags", Symbol.Flags);
}
template <> void SymbolRecordImpl<CallerSym>::map(IO &IO) {
IO.mapRequired("FuncID", Symbol.Indices);
}
template <> void SymbolRecordImpl<UDTSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("UDTName", Symbol.Name);
}
template <> void SymbolRecordImpl<BuildInfoSym>::map(IO &IO) {
IO.mapRequired("BuildId", Symbol.BuildId);
}
template <> void SymbolRecordImpl<BPRelativeSym>::map(IO &IO) {
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("VarName", Symbol.Name);
}
template <> void SymbolRecordImpl<RegRelativeSym>::map(IO &IO) {
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Register", Symbol.Register);
IO.mapRequired("VarName", Symbol.Name);
}
template <> void SymbolRecordImpl<ConstantSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Value", Symbol.Value);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<DataSym>::map(IO &IO) {
// TODO: Map linkage name
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("DisplayName", Symbol.Name);
}
template <> void SymbolRecordImpl<ThreadLocalDataSym>::map(IO &IO) {
// TODO: Map linkage name
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("DisplayName", Symbol.Name);
}
}
}
}
CVSymbol CodeViewYAML::SymbolRecord::toCodeViewSymbol(
BumpPtrAllocator &Allocator) const {
return Symbol->toCodeViewSymbol(Allocator);
}
namespace llvm {
namespace yaml {
template <> struct MappingTraits<SymbolRecordBase> {
static void mapping(IO &io, SymbolRecordBase &Record) { Record.map(io); }
};
}
}
template <typename SymbolType>
static inline Expected<CodeViewYAML::SymbolRecord>
fromCodeViewSymbolImpl(CVSymbol Symbol) {
CodeViewYAML::SymbolRecord Result;
auto Impl = std::make_shared<SymbolRecordImpl<SymbolType>>(Symbol.kind());
if (auto EC = Impl->fromCodeViewSymbol(Symbol))
return std::move(EC);
Result.Symbol = Impl;
return Result;
}
Expected<CodeViewYAML::SymbolRecord>
CodeViewYAML::SymbolRecord::fromCodeViewSymbol(CVSymbol Symbol) {
#define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \
case EnumName: \
return fromCodeViewSymbolImpl<ClassName>(Symbol);
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
SYMBOL_RECORD(EnumName, EnumVal, ClassName)
switch (Symbol.kind()) {
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
default: { llvm_unreachable("Unknown symbol kind!"); }
}
return make_error<CodeViewError>(cv_error_code::corrupt_record);
}
template <typename ConcreteType>
static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind,
CodeViewYAML::SymbolRecord &Obj) {
if (!IO.outputting())
Obj.Symbol = std::make_shared<SymbolRecordImpl<ConcreteType>>(Kind);
IO.mapRequired(Class, *Obj.Symbol);
}
void MappingTraits<CodeViewYAML::SymbolRecord>::mapping(
IO &IO, CodeViewYAML::SymbolRecord &Obj) {
SymbolKind Kind;
if (IO.outputting())
Kind = Obj.Symbol->Kind;
IO.mapRequired("Kind", Kind);
#define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \
case EnumName: \
mapSymbolRecordImpl<ClassName>(IO, #ClassName, Kind, Obj); \
break;
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
SYMBOL_RECORD(EnumName, EnumVal, ClassName)
switch (Kind) {
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
default: { llvm_unreachable("Unknown symbol kind!"); }
}
}

566
lib/ObjectYAML/CodeViewYAML.cpp → lib/ObjectYAML/CodeViewYAMLTypes.cpp

@ -1,4 +1,4 @@
//===- CodeViewYAML.cpp - CodeView YAMLIO implementation ------------------===//
//===- CodeViewYAMLTypes.cpp - CodeView YAMLIO types implementation -------===//
//
// The LLVM Compiler Infrastructure
//
@ -12,12 +12,14 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/ObjectYAML/CodeViewYAML.h"
#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
#include "llvm/DebugInfo/CodeView/CodeViewError.h"
#include "llvm/DebugInfo/CodeView/EnumTables.h"
#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
using namespace llvm;
using namespace llvm::codeview;
@ -25,32 +27,15 @@ using namespace llvm::CodeViewYAML;
using namespace llvm::CodeViewYAML::detail;
using namespace llvm::yaml;
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceFileChecksumEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceColumnEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineBlock)
LLVM_YAML_IS_SEQUENCE_VECTOR(SourceLineInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeSite)
LLVM_YAML_IS_SEQUENCE_VECTOR(InlineeInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(OneMethodRecord)
LLVM_YAML_IS_SEQUENCE_VECTOR(StringRef)
LLVM_YAML_IS_SEQUENCE_VECTOR(VFTableSlotKind)
LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(TypeIndex)
LLVM_YAML_DECLARE_SCALAR_TRAITS(TypeIndex, false)
LLVM_YAML_DECLARE_SCALAR_TRAITS(CodeViewYAML::HexFormattedString, false)
LLVM_YAML_DECLARE_SCALAR_TRAITS(APSInt, false)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceLineEntry)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceColumnEntry)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceFileChecksumEntry)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceLineInfo)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::SourceLineBlock)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::InlineeInfo)
LLVM_YAML_DECLARE_MAPPING_TRAITS(CodeViewYAML::InlineeSite)
LLVM_YAML_DECLARE_ENUM_TRAITS(TypeLeafKind)
LLVM_YAML_DECLARE_ENUM_TRAITS(SymbolKind)
LLVM_YAML_DECLARE_ENUM_TRAITS(PointerToMemberRepresentation)
LLVM_YAML_DECLARE_ENUM_TRAITS(VFTableSlotKind)
LLVM_YAML_DECLARE_ENUM_TRAITS(CallingConvention)
@ -61,28 +46,15 @@ LLVM_YAML_DECLARE_ENUM_TRAITS(MemberAccess)
LLVM_YAML_DECLARE_ENUM_TRAITS(MethodKind)
LLVM_YAML_DECLARE_ENUM_TRAITS(WindowsRTClassKind)
LLVM_YAML_DECLARE_ENUM_TRAITS(LabelType)
LLVM_YAML_DECLARE_ENUM_TRAITS(FileChecksumKind)
LLVM_YAML_DECLARE_BITSET_TRAITS(PointerOptions)
LLVM_YAML_DECLARE_BITSET_TRAITS(LineFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(ModifierOptions)
LLVM_YAML_DECLARE_BITSET_TRAITS(FunctionOptions)
LLVM_YAML_DECLARE_BITSET_TRAITS(ClassOptions)
LLVM_YAML_DECLARE_BITSET_TRAITS(MethodOptions)
LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::codeview::OneMethodRecord)
LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::codeview::MemberPointerInfo)
LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym2Flags)
LLVM_YAML_DECLARE_BITSET_TRAITS(CompileSym3Flags)
LLVM_YAML_DECLARE_BITSET_TRAITS(ExportFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(LocalSymFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(ProcSymFlags)
LLVM_YAML_DECLARE_BITSET_TRAITS(FrameProcedureOptions)
LLVM_YAML_DECLARE_ENUM_TRAITS(CPUType)
LLVM_YAML_DECLARE_ENUM_TRAITS(RegisterId)
LLVM_YAML_DECLARE_ENUM_TRAITS(TrampolineType)
LLVM_YAML_DECLARE_ENUM_TRAITS(ThunkOrdinal)
LLVM_YAML_DECLARE_MAPPING_TRAITS(OneMethodRecord)
LLVM_YAML_DECLARE_MAPPING_TRAITS(MemberPointerInfo)
namespace llvm {
namespace CodeViewYAML {
@ -147,34 +119,6 @@ template <typename T> struct MemberRecordImpl : public MemberRecordBase {
mutable T Record;
};
struct SymbolRecordBase {
codeview::SymbolKind Kind;
explicit SymbolRecordBase(codeview::SymbolKind K) : Kind(K) {}
virtual ~SymbolRecordBase() {}
virtual void map(yaml::IO &io) = 0;
virtual codeview::CVSymbol
toCodeViewSymbol(BumpPtrAllocator &Allocator) const = 0;
virtual Error fromCodeViewSymbol(codeview::CVSymbol Type) = 0;
};
template <typename T> struct SymbolRecordImpl : public SymbolRecordBase {
explicit SymbolRecordImpl(codeview::SymbolKind K)
: SymbolRecordBase(K), Symbol(static_cast<SymbolRecordKind>(K)) {}
void map(yaml::IO &io) override;
codeview::CVSymbol
toCodeViewSymbol(BumpPtrAllocator &Allocator) const override {
return SymbolSerializer::writeOneSymbol(Symbol, Allocator);
}
Error fromCodeViewSymbol(codeview::CVSymbol CVS) override {
return SymbolDeserializer::deserializeAs<T>(CVS, Symbol);
}
mutable T Symbol;
};
}
}
}
@ -394,175 +338,6 @@ void ScalarBitSetTraits<MethodOptions>::bitset(IO &IO, MethodOptions &Options) {
IO.bitSetCase(Options, "Sealed", MethodOptions::Sealed);
}
void ScalarEnumerationTraits<FileChecksumKind>::enumeration(
IO &io, FileChecksumKind &Kind) {
io.enumCase(Kind, "None", FileChecksumKind::None);
io.enumCase(Kind, "MD5", FileChecksumKind::MD5);
io.enumCase(Kind, "SHA1", FileChecksumKind::SHA1);
io.enumCase(Kind, "SHA256", FileChecksumKind::SHA256);
}
void ScalarBitSetTraits<LineFlags>::bitset(IO &io, LineFlags &Flags) {
io.bitSetCase(Flags, "HasColumnInfo", LF_HaveColumns);
io.enumFallback<Hex16>(Flags);
}
void ScalarEnumerationTraits<SymbolKind>::enumeration(IO &io,
SymbolKind &Value) {
auto SymbolNames = getSymbolTypeNames();
for (const auto &E : SymbolNames)
io.enumCase(Value, E.Name.str().c_str(), E.Value);
}
void ScalarBitSetTraits<CompileSym2Flags>::bitset(IO &io,
CompileSym2Flags &Flags) {
auto FlagNames = getCompileSym2FlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<CompileSym2Flags>(E.Value));
}
}
void ScalarBitSetTraits<CompileSym3Flags>::bitset(IO &io,
CompileSym3Flags &Flags) {
auto FlagNames = getCompileSym3FlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<CompileSym3Flags>(E.Value));
}
}
void ScalarBitSetTraits<ExportFlags>::bitset(IO &io, ExportFlags &Flags) {
auto FlagNames = getExportSymFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<ExportFlags>(E.Value));
}
}
void ScalarBitSetTraits<LocalSymFlags>::bitset(IO &io, LocalSymFlags &Flags) {
auto FlagNames = getLocalFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<LocalSymFlags>(E.Value));
}
}
void ScalarBitSetTraits<ProcSymFlags>::bitset(IO &io, ProcSymFlags &Flags) {
auto FlagNames = getProcSymFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<ProcSymFlags>(E.Value));
}
}
void ScalarBitSetTraits<FrameProcedureOptions>::bitset(
IO &io, FrameProcedureOptions &Flags) {
auto FlagNames = getFrameProcSymFlagNames();
for (const auto &E : FlagNames) {
io.bitSetCase(Flags, E.Name.str().c_str(),
static_cast<FrameProcedureOptions>(E.Value));
}
}
void ScalarEnumerationTraits<CPUType>::enumeration(IO &io, CPUType &Cpu) {
auto CpuNames = getCPUTypeNames();
for (const auto &E : CpuNames) {
io.enumCase(Cpu, E.Name.str().c_str(), static_cast<CPUType>(E.Value));
}
}
void ScalarEnumerationTraits<RegisterId>::enumeration(IO &io, RegisterId &Reg) {
auto RegNames = getRegisterNames();
for (const auto &E : RegNames) {
io.enumCase(Reg, E.Name.str().c_str(), static_cast<RegisterId>(E.Value));
}
io.enumFallback<Hex16>(Reg);
}
void ScalarEnumerationTraits<TrampolineType>::enumeration(
IO &io, TrampolineType &Tramp) {
auto TrampNames = getTrampolineNames();
for (const auto &E : TrampNames) {
io.enumCase(Tramp, E.Name.str().c_str(),
static_cast<TrampolineType>(E.Value));
}
}
void ScalarEnumerationTraits<ThunkOrdinal>::enumeration(IO &io,
ThunkOrdinal &Ord) {
auto ThunkNames = getThunkOrdinalNames();
for (const auto &E : ThunkNames) {
io.enumCase(Ord, E.Name.str().c_str(), static_cast<ThunkOrdinal>(E.Value));
}
}
void ScalarTraits<HexFormattedString>::output(const HexFormattedString &Value,
void *ctx, raw_ostream &Out) {
StringRef Bytes(reinterpret_cast<const char *>(Value.Bytes.data()),
Value.Bytes.size());
Out << toHex(Bytes);
}
StringRef ScalarTraits<HexFormattedString>::input(StringRef Scalar, void *ctxt,
HexFormattedString &Value) {
std::string H = fromHex(Scalar);
Value.Bytes.assign(H.begin(), H.end());
return StringRef();
}
void MappingTraits<SourceLineEntry>::mapping(IO &IO, SourceLineEntry &Obj) {
IO.mapRequired("Offset", Obj.Offset);
IO.mapRequired("LineStart", Obj.LineStart);
IO.mapRequired("IsStatement", Obj.IsStatement);
IO.mapRequired("EndDelta", Obj.EndDelta);
}
void MappingTraits<SourceColumnEntry>::mapping(IO &IO, SourceColumnEntry &Obj) {
IO.mapRequired("StartColumn", Obj.StartColumn);
IO.mapRequired("EndColumn", Obj.EndColumn);
}
void MappingTraits<SourceLineBlock>::mapping(IO &IO, SourceLineBlock &Obj) {
IO.mapRequired("FileName", Obj.FileName);
IO.mapRequired("Lines", Obj.Lines);
IO.mapRequired("Columns", Obj.Columns);
}
void MappingTraits<SourceFileChecksumEntry>::mapping(
IO &IO, SourceFileChecksumEntry &Obj) {
IO.mapRequired("FileName", Obj.FileName);
IO.mapRequired("Kind", Obj.Kind);
IO.mapRequired("Checksum", Obj.ChecksumBytes);
}
void MappingTraits<SourceLineInfo>::mapping(IO &IO, SourceLineInfo &Obj) {
IO.mapRequired("CodeSize", Obj.CodeSize);
IO.mapRequired("Flags", Obj.Flags);
IO.mapRequired("RelocOffset", Obj.RelocOffset);
IO.mapRequired("RelocSegment", Obj.RelocSegment);
IO.mapRequired("Blocks", Obj.Blocks);
}
void MappingTraits<SourceFileInfo>::mapping(IO &IO, SourceFileInfo &Obj) {
IO.mapOptional("Checksums", Obj.FileChecksums);
IO.mapOptional("Lines", Obj.LineFragments);
IO.mapOptional("InlineeLines", Obj.Inlinees);
}
void MappingTraits<InlineeSite>::mapping(IO &IO, InlineeSite &Obj) {
IO.mapRequired("FileName", Obj.FileName);
IO.mapRequired("LineNum", Obj.SourceLineNum);
IO.mapRequired("Inlinee", Obj.Inlinee);
IO.mapOptional("ExtraFiles", Obj.ExtraFiles);
}
void MappingTraits<InlineeInfo>::mapping(IO &IO, InlineeInfo &Obj) {
IO.mapRequired("HasExtraFiles", Obj.HasExtraFiles);
IO.mapRequired("Sites", Obj.Sites);
}
void MappingTraits<MemberPointerInfo>::mapping(IO &IO, MemberPointerInfo &MPI) {
IO.mapRequired("ContainingType", MPI.ContainingType);
IO.mapRequired("Representation", MPI.Representation);
@ -935,332 +710,3 @@ void MappingTraits<MemberRecord>::mapping(IO &IO, MemberRecord &Obj) {
default: { llvm_unreachable("Unknown member kind!"); }
}
}
namespace llvm {
namespace CodeViewYAML {
namespace detail {
template <> void SymbolRecordImpl<ScopeEndSym>::map(IO &IO) {}
template <> void SymbolRecordImpl<Thunk32Sym>::map(IO &IO) {
IO.mapRequired("Parent", Symbol.Parent);
IO.mapRequired("End", Symbol.End);
IO.mapRequired("Next", Symbol.Next);
IO.mapRequired("Off", Symbol.Offset);
IO.mapRequired("Seg", Symbol.Segment);
IO.mapRequired("Len", Symbol.Length);
IO.mapRequired("Ordinal", Symbol.Thunk);
}
template <> void SymbolRecordImpl<TrampolineSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Size", Symbol.Size);
IO.mapRequired("ThunkOff", Symbol.ThunkOffset);
IO.mapRequired("TargetOff", Symbol.TargetOffset);
IO.mapRequired("ThunkSection", Symbol.ThunkSection);
IO.mapRequired("TargetSection", Symbol.TargetSection);
}
template <> void SymbolRecordImpl<SectionSym>::map(IO &IO) {
IO.mapRequired("SectionNumber", Symbol.SectionNumber);
IO.mapRequired("Alignment", Symbol.Alignment);
IO.mapRequired("Rva", Symbol.Rva);
IO.mapRequired("Length", Symbol.Length);
IO.mapRequired("Characteristics", Symbol.Characteristics);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<CoffGroupSym>::map(IO &IO) {
IO.mapRequired("Size", Symbol.Size);
IO.mapRequired("Characteristics", Symbol.Characteristics);
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<ExportSym>::map(IO &IO) {
IO.mapRequired("Ordinal", Symbol.Ordinal);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<ProcSym>::map(IO &IO) {
// TODO: Print the linkage name
IO.mapRequired("PtrParent", Symbol.Parent);
IO.mapRequired("PtrEnd", Symbol.End);
IO.mapRequired("PtrNext", Symbol.Next);
IO.mapRequired("CodeSize", Symbol.CodeSize);
IO.mapRequired("DbgStart", Symbol.DbgStart);
IO.mapRequired("DbgEnd", Symbol.DbgEnd);
IO.mapRequired("FunctionType", Symbol.FunctionType);
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("DisplayName", Symbol.Name);
}
template <> void SymbolRecordImpl<RegisterSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Index);
IO.mapRequired("Seg", Symbol.Register);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<PublicSym32>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Index);
IO.mapRequired("Seg", Symbol.Segment);
IO.mapRequired("Off", Symbol.Offset);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<ProcRefSym>::map(IO &IO) {
IO.mapRequired("SumName", Symbol.SumName);
IO.mapRequired("SymOffset", Symbol.SymOffset);
IO.mapRequired("Mod", Symbol.Module);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<EnvBlockSym>::map(IO &IO) {
IO.mapRequired("Entries", Symbol.Fields);
}
template <> void SymbolRecordImpl<InlineSiteSym>::map(IO &IO) {
IO.mapRequired("PtrParent", Symbol.Parent);
IO.mapRequired("PtrEnd", Symbol.End);
IO.mapRequired("Inlinee", Symbol.Inlinee);
// TODO: The binary annotations
}
template <> void SymbolRecordImpl<LocalSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("VarName", Symbol.Name);
}
template <> void SymbolRecordImpl<DefRangeSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeSubfieldSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeRegisterSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeFramePointerRelSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeSubfieldRegisterSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <>
void SymbolRecordImpl<DefRangeFramePointerRelFullScopeSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<DefRangeRegisterRelSym>::map(IO &IO) {
// TODO: Print the subfields
}
template <> void SymbolRecordImpl<BlockSym>::map(IO &IO) {
// TODO: Print the linkage name
IO.mapRequired("PtrParent", Symbol.Parent);
IO.mapRequired("PtrEnd", Symbol.End);
IO.mapRequired("CodeSize", Symbol.CodeSize);
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("BlockName", Symbol.Name);
}
template <> void SymbolRecordImpl<LabelSym>::map(IO &IO) {
// TODO: Print the linkage name
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("DisplayName", Symbol.Name);
}
template <> void SymbolRecordImpl<ObjNameSym>::map(IO &IO) {
IO.mapRequired("Signature", Symbol.Signature);
IO.mapRequired("ObjectName", Symbol.Name);
}
template <> void SymbolRecordImpl<Compile2Sym>::map(IO &IO) {
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Machine", Symbol.Machine);
IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor);
IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor);
IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild);
IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor);
IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor);
IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild);
IO.mapRequired("Version", Symbol.Version);
}
template <> void SymbolRecordImpl<Compile3Sym>::map(IO &IO) {
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Machine", Symbol.Machine);
IO.mapRequired("FrontendMajor", Symbol.VersionFrontendMajor);
IO.mapRequired("FrontendMinor", Symbol.VersionFrontendMinor);
IO.mapRequired("FrontendBuild", Symbol.VersionFrontendBuild);
IO.mapRequired("FrontendQFE", Symbol.VersionFrontendQFE);
IO.mapRequired("BackendMajor", Symbol.VersionBackendMajor);
IO.mapRequired("BackendMinor", Symbol.VersionBackendMinor);
IO.mapRequired("BackendBuild", Symbol.VersionBackendBuild);
IO.mapRequired("BackendQFE", Symbol.VersionBackendQFE);
IO.mapRequired("Version", Symbol.Version);
}
template <> void SymbolRecordImpl<FrameProcSym>::map(IO &IO) {
IO.mapRequired("TotalFrameBytes", Symbol.TotalFrameBytes);
IO.mapRequired("PaddingFrameBytes", Symbol.PaddingFrameBytes);
IO.mapRequired("OffsetToPadding", Symbol.OffsetToPadding);
IO.mapRequired("BytesOfCalleeSavedRegisters",
Symbol.BytesOfCalleeSavedRegisters);
IO.mapRequired("OffsetOfExceptionHandler", Symbol.OffsetOfExceptionHandler);
IO.mapRequired("SectionIdOfExceptionHandler",
Symbol.SectionIdOfExceptionHandler);
IO.mapRequired("Flags", Symbol.Flags);
}
template <> void SymbolRecordImpl<CallSiteInfoSym>::map(IO &IO) {
// TODO: Map Linkage Name
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("Type", Symbol.Type);
}
template <> void SymbolRecordImpl<FileStaticSym>::map(IO &IO) {
IO.mapRequired("Index", Symbol.Index);
IO.mapRequired("ModFilenameOffset", Symbol.ModFilenameOffset);
IO.mapRequired("Flags", Symbol.Flags);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<HeapAllocationSiteSym>::map(IO &IO) {
// TODO: Map Linkage Name
IO.mapRequired("Segment", Symbol.Segment);
IO.mapRequired("CallInstructionSize", Symbol.CallInstructionSize);
IO.mapRequired("Type", Symbol.Type);
}
template <> void SymbolRecordImpl<FrameCookieSym>::map(IO &IO) {
// TODO: Map Linkage Name
IO.mapRequired("Register", Symbol.Register);
IO.mapRequired("CookieKind", Symbol.CookieKind);
IO.mapRequired("Flags", Symbol.Flags);
}
template <> void SymbolRecordImpl<CallerSym>::map(IO &IO) {
IO.mapRequired("FuncID", Symbol.Indices);
}
template <> void SymbolRecordImpl<UDTSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("UDTName", Symbol.Name);
}
template <> void SymbolRecordImpl<BuildInfoSym>::map(IO &IO) {
IO.mapRequired("BuildId", Symbol.BuildId);
}
template <> void SymbolRecordImpl<BPRelativeSym>::map(IO &IO) {
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("VarName", Symbol.Name);
}
template <> void SymbolRecordImpl<RegRelativeSym>::map(IO &IO) {
IO.mapRequired("Offset", Symbol.Offset);
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Register", Symbol.Register);
IO.mapRequired("VarName", Symbol.Name);
}
template <> void SymbolRecordImpl<ConstantSym>::map(IO &IO) {
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("Value", Symbol.Value);
IO.mapRequired("Name", Symbol.Name);
}
template <> void SymbolRecordImpl<DataSym>::map(IO &IO) {
// TODO: Map linkage name
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("DisplayName", Symbol.Name);
}
template <> void SymbolRecordImpl<ThreadLocalDataSym>::map(IO &IO) {
// TODO: Map linkage name
IO.mapRequired("Type", Symbol.Type);
IO.mapRequired("DisplayName", Symbol.Name);
}
}
}
}
CVSymbol CodeViewYAML::SymbolRecord::toCodeViewSymbol(
BumpPtrAllocator &Allocator) const {
return Symbol->toCodeViewSymbol(Allocator);
}
namespace llvm {
namespace yaml {
template <> struct MappingTraits<SymbolRecordBase> {
static void mapping(IO &io, SymbolRecordBase &Record) { Record.map(io); }
};
}
}
template <typename SymbolType>
static inline Expected<CodeViewYAML::SymbolRecord>
fromCodeViewSymbolImpl(CVSymbol Symbol) {
CodeViewYAML::SymbolRecord Result;
auto Impl = std::make_shared<SymbolRecordImpl<SymbolType>>(Symbol.kind());
if (auto EC = Impl->fromCodeViewSymbol(Symbol))
return std::move(EC);
Result.Symbol = Impl;
return Result;
}
Expected<CodeViewYAML::SymbolRecord>
CodeViewYAML::SymbolRecord::fromCodeViewSymbol(CVSymbol Symbol) {
#define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \
case EnumName: \
return fromCodeViewSymbolImpl<ClassName>(Symbol);
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
SYMBOL_RECORD(EnumName, EnumVal, ClassName)
switch (Symbol.kind()) {
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
default: { llvm_unreachable("Unknown symbol kind!"); }
}
return make_error<CodeViewError>(cv_error_code::corrupt_record);
}
template <typename ConcreteType>
static void mapSymbolRecordImpl(IO &IO, const char *Class, SymbolKind Kind,
CodeViewYAML::SymbolRecord &Obj) {
if (!IO.outputting())
Obj.Symbol = std::make_shared<SymbolRecordImpl<ConcreteType>>(Kind);
IO.mapRequired(Class, *Obj.Symbol);
}
void MappingTraits<CodeViewYAML::SymbolRecord>::mapping(
IO &IO, CodeViewYAML::SymbolRecord &Obj) {
SymbolKind Kind;
if (IO.outputting())
Kind = Obj.Symbol->Kind;
IO.mapRequired("Kind", Kind);
#define SYMBOL_RECORD(EnumName, EnumVal, ClassName) \
case EnumName: \
mapSymbolRecordImpl<ClassName>(IO, #ClassName, Kind, Obj); \
break;
#define SYMBOL_RECORD_ALIAS(EnumName, EnumVal, AliasName, ClassName) \
SYMBOL_RECORD(EnumName, EnumVal, ClassName)
switch (Kind) {
#include "llvm/DebugInfo/CodeView/CodeViewSymbols.def"
default: { llvm_unreachable("Unknown symbol kind!"); }
}
}

1
tools/llvm-pdbdump/PdbYaml.cpp

@ -21,6 +21,7 @@
#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
#include "llvm/DebugInfo/PDB/PDBExtras.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
using namespace llvm;
using namespace llvm::pdb;

4
tools/llvm-pdbdump/PdbYaml.h

@ -19,7 +19,9 @@
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
#include "llvm/DebugInfo/PDB/Native/RawConstants.h"
#include "llvm/DebugInfo/PDB/PDBTypes.h"
#include "llvm/ObjectYAML/CodeViewYAML.h"
#include "llvm/ObjectYAML/CodeViewYAMLDebugSections.h"
#include "llvm/ObjectYAML/CodeViewYAMLSymbols.h"
#include "llvm/ObjectYAML/CodeViewYAMLTypes.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/YAMLTraits.h"

1
tools/llvm-pdbdump/YAMLOutputStyle.cpp

@ -28,7 +28,6 @@
#include "llvm/DebugInfo/PDB/Native/RawConstants.h"
#include "llvm/DebugInfo/PDB/Native/RawError.h"
#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
#include "llvm/ObjectYAML/CodeViewYAML.h"
using namespace llvm;
using namespace llvm::codeview;

1
tools/llvm-pdbdump/llvm-pdbdump.cpp

@ -61,7 +61,6 @@
#include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
#include "llvm/DebugInfo/PDB/PDBSymbolFunc.h"
#include "llvm/DebugInfo/PDB/PDBSymbolThunk.h"
#include "llvm/ObjectYAML/CodeViewYAML.h"
#include "llvm/Support/BinaryByteStream.h"
#include "llvm/Support/COM.h"
#include "llvm/Support/CommandLine.h"