564 lines
22 KiB
C++
564 lines
22 KiB
C++
|
//===- MinidumpYAML.cpp - Minidump YAMLIO implementation ------------------===//
|
||
|
|
//
|
||
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
||
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#include "llvm/ObjectYAML/MinidumpYAML.h"
|
||
|
|
#include "llvm/Support/Allocator.h"
|
||
|
|
|
||
|
|
using namespace llvm;
|
||
|
|
using namespace llvm::MinidumpYAML;
|
||
|
|
using namespace llvm::minidump;
|
||
|
|
|
||
|
|
/// Perform an optional yaml-mapping of an endian-aware type EndianType. The
|
||
|
|
/// only purpose of this function is to avoid casting the Default value to the
|
||
|
|
/// endian type;
|
||
|
|
template <typename EndianType>
|
||
|
|
static inline void mapOptional(yaml::IO &IO, const char *Key, EndianType &Val,
|
||
|
|
typename EndianType::value_type Default) {
|
||
|
|
IO.mapOptional(Key, Val, EndianType(Default));
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Yaml-map an endian-aware type EndianType as some other type MapType.
|
||
|
|
template <typename MapType, typename EndianType>
|
||
|
|
static inline void mapRequiredAs(yaml::IO &IO, const char *Key,
|
||
|
|
EndianType &Val) {
|
||
|
|
MapType Mapped = static_cast<typename EndianType::value_type>(Val);
|
||
|
|
IO.mapRequired(Key, Mapped);
|
||
|
|
Val = static_cast<typename EndianType::value_type>(Mapped);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Perform an optional yaml-mapping of an endian-aware type EndianType as some
|
||
|
|
/// other type MapType.
|
||
|
|
template <typename MapType, typename EndianType>
|
||
|
|
static inline void mapOptionalAs(yaml::IO &IO, const char *Key, EndianType &Val,
|
||
|
|
MapType Default) {
|
||
|
|
MapType Mapped = static_cast<typename EndianType::value_type>(Val);
|
||
|
|
IO.mapOptional(Key, Mapped, Default);
|
||
|
|
Val = static_cast<typename EndianType::value_type>(Mapped);
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
/// Return the appropriate yaml Hex type for a given endian-aware type.
|
||
|
|
template <typename EndianType> struct HexType;
|
||
|
|
template <> struct HexType<support::ulittle16_t> { using type = yaml::Hex16; };
|
||
|
|
template <> struct HexType<support::ulittle32_t> { using type = yaml::Hex32; };
|
||
|
|
template <> struct HexType<support::ulittle64_t> { using type = yaml::Hex64; };
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
/// Yaml-map an endian-aware type as an appropriately-sized hex value.
|
||
|
|
template <typename EndianType>
|
||
|
|
static inline void mapRequiredHex(yaml::IO &IO, const char *Key,
|
||
|
|
EndianType &Val) {
|
||
|
|
mapRequiredAs<typename HexType<EndianType>::type>(IO, Key, Val);
|
||
|
|
}
|
||
|
|
|
||
|
|
/// Perform an optional yaml-mapping of an endian-aware type as an
|
||
|
|
/// appropriately-sized hex value.
|
||
|
|
template <typename EndianType>
|
||
|
|
static inline void mapOptionalHex(yaml::IO &IO, const char *Key,
|
||
|
|
EndianType &Val,
|
||
|
|
typename EndianType::value_type Default) {
|
||
|
|
mapOptionalAs<typename HexType<EndianType>::type>(IO, Key, Val, Default);
|
||
|
|
}
|
||
|
|
|
||
|
|
Stream::~Stream() = default;
|
||
|
|
|
||
|
|
Stream::StreamKind Stream::getKind(StreamType Type) {
|
||
|
|
switch (Type) {
|
||
|
|
case StreamType::Exception:
|
||
|
|
return StreamKind::Exception;
|
||
|
|
case StreamType::MemoryInfoList:
|
||
|
|
return StreamKind::MemoryInfoList;
|
||
|
|
case StreamType::MemoryList:
|
||
|
|
return StreamKind::MemoryList;
|
||
|
|
case StreamType::ModuleList:
|
||
|
|
return StreamKind::ModuleList;
|
||
|
|
case StreamType::SystemInfo:
|
||
|
|
return StreamKind::SystemInfo;
|
||
|
|
case StreamType::LinuxCPUInfo:
|
||
|
|
case StreamType::LinuxProcStatus:
|
||
|
|
case StreamType::LinuxLSBRelease:
|
||
|
|
case StreamType::LinuxCMDLine:
|
||
|
|
case StreamType::LinuxMaps:
|
||
|
|
case StreamType::LinuxProcStat:
|
||
|
|
case StreamType::LinuxProcUptime:
|
||
|
|
return StreamKind::TextContent;
|
||
|
|
case StreamType::ThreadList:
|
||
|
|
return StreamKind::ThreadList;
|
||
|
|
default:
|
||
|
|
return StreamKind::RawContent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::unique_ptr<Stream> Stream::create(StreamType Type) {
|
||
|
|
StreamKind Kind = getKind(Type);
|
||
|
|
switch (Kind) {
|
||
|
|
case StreamKind::Exception:
|
||
|
|
return std::make_unique<ExceptionStream>();
|
||
|
|
case StreamKind::MemoryInfoList:
|
||
|
|
return std::make_unique<MemoryInfoListStream>();
|
||
|
|
case StreamKind::MemoryList:
|
||
|
|
return std::make_unique<MemoryListStream>();
|
||
|
|
case StreamKind::ModuleList:
|
||
|
|
return std::make_unique<ModuleListStream>();
|
||
|
|
case StreamKind::RawContent:
|
||
|
|
return std::make_unique<RawContentStream>(Type);
|
||
|
|
case StreamKind::SystemInfo:
|
||
|
|
return std::make_unique<SystemInfoStream>();
|
||
|
|
case StreamKind::TextContent:
|
||
|
|
return std::make_unique<TextContentStream>(Type);
|
||
|
|
case StreamKind::ThreadList:
|
||
|
|
return std::make_unique<ThreadListStream>();
|
||
|
|
}
|
||
|
|
llvm_unreachable("Unhandled stream kind!");
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::ScalarBitSetTraits<MemoryProtection>::bitset(
|
||
|
|
IO &IO, MemoryProtection &Protect) {
|
||
|
|
#define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME) \
|
||
|
|
IO.bitSetCase(Protect, #NATIVENAME, MemoryProtection::NAME);
|
||
|
|
#include "llvm/BinaryFormat/MinidumpConstants.def"
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::ScalarBitSetTraits<MemoryState>::bitset(IO &IO, MemoryState &State) {
|
||
|
|
#define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME) \
|
||
|
|
IO.bitSetCase(State, #NATIVENAME, MemoryState::NAME);
|
||
|
|
#include "llvm/BinaryFormat/MinidumpConstants.def"
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::ScalarBitSetTraits<MemoryType>::bitset(IO &IO, MemoryType &Type) {
|
||
|
|
#define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME) \
|
||
|
|
IO.bitSetCase(Type, #NATIVENAME, MemoryType::NAME);
|
||
|
|
#include "llvm/BinaryFormat/MinidumpConstants.def"
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::ScalarEnumerationTraits<ProcessorArchitecture>::enumeration(
|
||
|
|
IO &IO, ProcessorArchitecture &Arch) {
|
||
|
|
#define HANDLE_MDMP_ARCH(CODE, NAME) \
|
||
|
|
IO.enumCase(Arch, #NAME, ProcessorArchitecture::NAME);
|
||
|
|
#include "llvm/BinaryFormat/MinidumpConstants.def"
|
||
|
|
IO.enumFallback<Hex16>(Arch);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::ScalarEnumerationTraits<OSPlatform>::enumeration(IO &IO,
|
||
|
|
OSPlatform &Plat) {
|
||
|
|
#define HANDLE_MDMP_PLATFORM(CODE, NAME) \
|
||
|
|
IO.enumCase(Plat, #NAME, OSPlatform::NAME);
|
||
|
|
#include "llvm/BinaryFormat/MinidumpConstants.def"
|
||
|
|
IO.enumFallback<Hex32>(Plat);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::ScalarEnumerationTraits<StreamType>::enumeration(IO &IO,
|
||
|
|
StreamType &Type) {
|
||
|
|
#define HANDLE_MDMP_STREAM_TYPE(CODE, NAME) \
|
||
|
|
IO.enumCase(Type, #NAME, StreamType::NAME);
|
||
|
|
#include "llvm/BinaryFormat/MinidumpConstants.def"
|
||
|
|
IO.enumFallback<Hex32>(Type);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<CPUInfo::ArmInfo>::mapping(IO &IO,
|
||
|
|
CPUInfo::ArmInfo &Info) {
|
||
|
|
mapRequiredHex(IO, "CPUID", Info.CPUID);
|
||
|
|
mapOptionalHex(IO, "ELF hwcaps", Info.ElfHWCaps, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
template <std::size_t N> struct FixedSizeHex {
|
||
|
|
FixedSizeHex(uint8_t (&Storage)[N]) : Storage(Storage) {}
|
||
|
|
|
||
|
|
uint8_t (&Storage)[N];
|
||
|
|
};
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
namespace llvm {
|
||
|
|
namespace yaml {
|
||
|
|
template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> {
|
||
|
|
static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) {
|
||
|
|
OS << toHex(makeArrayRef(Fixed.Storage));
|
||
|
|
}
|
||
|
|
|
||
|
|
static StringRef input(StringRef Scalar, void *, FixedSizeHex<N> &Fixed) {
|
||
|
|
if (!all_of(Scalar, isHexDigit))
|
||
|
|
return "Invalid hex digit in input";
|
||
|
|
if (Scalar.size() < 2 * N)
|
||
|
|
return "String too short";
|
||
|
|
if (Scalar.size() > 2 * N)
|
||
|
|
return "String too long";
|
||
|
|
copy(fromHex(Scalar), Fixed.Storage);
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
|
||
|
|
static QuotingType mustQuote(StringRef S) { return QuotingType::None; }
|
||
|
|
};
|
||
|
|
} // namespace yaml
|
||
|
|
} // namespace llvm
|
||
|
|
void yaml::MappingTraits<CPUInfo::OtherInfo>::mapping(
|
||
|
|
IO &IO, CPUInfo::OtherInfo &Info) {
|
||
|
|
FixedSizeHex<sizeof(Info.ProcessorFeatures)> Features(Info.ProcessorFeatures);
|
||
|
|
IO.mapRequired("Features", Features);
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
/// A type which only accepts strings of a fixed size for yaml conversion.
|
||
|
|
template <std::size_t N> struct FixedSizeString {
|
||
|
|
FixedSizeString(char (&Storage)[N]) : Storage(Storage) {}
|
||
|
|
|
||
|
|
char (&Storage)[N];
|
||
|
|
};
|
||
|
|
} // namespace
|
||
|
|
|
||
|
|
namespace llvm {
|
||
|
|
namespace yaml {
|
||
|
|
template <std::size_t N> struct ScalarTraits<FixedSizeString<N>> {
|
||
|
|
static void output(const FixedSizeString<N> &Fixed, void *, raw_ostream &OS) {
|
||
|
|
OS << StringRef(Fixed.Storage, N);
|
||
|
|
}
|
||
|
|
|
||
|
|
static StringRef input(StringRef Scalar, void *, FixedSizeString<N> &Fixed) {
|
||
|
|
if (Scalar.size() < N)
|
||
|
|
return "String too short";
|
||
|
|
if (Scalar.size() > N)
|
||
|
|
return "String too long";
|
||
|
|
copy(Scalar, Fixed.Storage);
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
|
||
|
|
static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
|
||
|
|
};
|
||
|
|
} // namespace yaml
|
||
|
|
} // namespace llvm
|
||
|
|
|
||
|
|
void yaml::MappingTraits<CPUInfo::X86Info>::mapping(IO &IO,
|
||
|
|
CPUInfo::X86Info &Info) {
|
||
|
|
FixedSizeString<sizeof(Info.VendorID)> VendorID(Info.VendorID);
|
||
|
|
IO.mapRequired("Vendor ID", VendorID);
|
||
|
|
|
||
|
|
mapRequiredHex(IO, "Version Info", Info.VersionInfo);
|
||
|
|
mapRequiredHex(IO, "Feature Info", Info.FeatureInfo);
|
||
|
|
mapOptionalHex(IO, "AMD Extended Features", Info.AMDExtendedFeatures, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<MemoryInfo>::mapping(IO &IO, MemoryInfo &Info) {
|
||
|
|
mapRequiredHex(IO, "Base Address", Info.BaseAddress);
|
||
|
|
mapOptionalHex(IO, "Allocation Base", Info.AllocationBase, Info.BaseAddress);
|
||
|
|
mapRequiredAs<MemoryProtection>(IO, "Allocation Protect",
|
||
|
|
Info.AllocationProtect);
|
||
|
|
mapOptionalHex(IO, "Reserved0", Info.Reserved0, 0);
|
||
|
|
mapRequiredHex(IO, "Region Size", Info.RegionSize);
|
||
|
|
mapRequiredAs<MemoryState>(IO, "State", Info.State);
|
||
|
|
mapOptionalAs<MemoryProtection>(IO, "Protect", Info.Protect,
|
||
|
|
Info.AllocationProtect);
|
||
|
|
mapRequiredAs<MemoryType>(IO, "Type", Info.Type);
|
||
|
|
mapOptionalHex(IO, "Reserved1", Info.Reserved1, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<VSFixedFileInfo>::mapping(IO &IO,
|
||
|
|
VSFixedFileInfo &Info) {
|
||
|
|
mapOptionalHex(IO, "Signature", Info.Signature, 0);
|
||
|
|
mapOptionalHex(IO, "Struct Version", Info.StructVersion, 0);
|
||
|
|
mapOptionalHex(IO, "File Version High", Info.FileVersionHigh, 0);
|
||
|
|
mapOptionalHex(IO, "File Version Low", Info.FileVersionLow, 0);
|
||
|
|
mapOptionalHex(IO, "Product Version High", Info.ProductVersionHigh, 0);
|
||
|
|
mapOptionalHex(IO, "Product Version Low", Info.ProductVersionLow, 0);
|
||
|
|
mapOptionalHex(IO, "File Flags Mask", Info.FileFlagsMask, 0);
|
||
|
|
mapOptionalHex(IO, "File Flags", Info.FileFlags, 0);
|
||
|
|
mapOptionalHex(IO, "File OS", Info.FileOS, 0);
|
||
|
|
mapOptionalHex(IO, "File Type", Info.FileType, 0);
|
||
|
|
mapOptionalHex(IO, "File Subtype", Info.FileSubtype, 0);
|
||
|
|
mapOptionalHex(IO, "File Date High", Info.FileDateHigh, 0);
|
||
|
|
mapOptionalHex(IO, "File Date Low", Info.FileDateLow, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<ModuleListStream::entry_type>::mapping(
|
||
|
|
IO &IO, ModuleListStream::entry_type &M) {
|
||
|
|
mapRequiredHex(IO, "Base of Image", M.Entry.BaseOfImage);
|
||
|
|
mapRequiredHex(IO, "Size of Image", M.Entry.SizeOfImage);
|
||
|
|
mapOptionalHex(IO, "Checksum", M.Entry.Checksum, 0);
|
||
|
|
mapOptional(IO, "Time Date Stamp", M.Entry.TimeDateStamp, 0);
|
||
|
|
IO.mapRequired("Module Name", M.Name);
|
||
|
|
IO.mapOptional("Version Info", M.Entry.VersionInfo, VSFixedFileInfo());
|
||
|
|
IO.mapRequired("CodeView Record", M.CvRecord);
|
||
|
|
IO.mapOptional("Misc Record", M.MiscRecord, yaml::BinaryRef());
|
||
|
|
mapOptionalHex(IO, "Reserved0", M.Entry.Reserved0, 0);
|
||
|
|
mapOptionalHex(IO, "Reserved1", M.Entry.Reserved1, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, RawContentStream &Stream) {
|
||
|
|
IO.mapOptional("Content", Stream.Content);
|
||
|
|
IO.mapOptional("Size", Stream.Size, Stream.Content.binary_size());
|
||
|
|
}
|
||
|
|
|
||
|
|
static std::string streamValidate(RawContentStream &Stream) {
|
||
|
|
if (Stream.Size.value < Stream.Content.binary_size())
|
||
|
|
return "Stream size must be greater or equal to the content size";
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<MemoryListStream::entry_type>::mapping(
|
||
|
|
IO &IO, MemoryListStream::entry_type &Range) {
|
||
|
|
MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
|
||
|
|
IO, Range.Entry, Range.Content);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, MemoryInfoListStream &Stream) {
|
||
|
|
IO.mapRequired("Memory Ranges", Stream.Infos);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, MemoryListStream &Stream) {
|
||
|
|
IO.mapRequired("Memory Ranges", Stream.Entries);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) {
|
||
|
|
IO.mapRequired("Modules", Stream.Entries);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, SystemInfoStream &Stream) {
|
||
|
|
SystemInfo &Info = Stream.Info;
|
||
|
|
IO.mapRequired("Processor Arch", Info.ProcessorArch);
|
||
|
|
mapOptional(IO, "Processor Level", Info.ProcessorLevel, 0);
|
||
|
|
mapOptional(IO, "Processor Revision", Info.ProcessorRevision, 0);
|
||
|
|
IO.mapOptional("Number of Processors", Info.NumberOfProcessors, 0);
|
||
|
|
IO.mapOptional("Product type", Info.ProductType, 0);
|
||
|
|
mapOptional(IO, "Major Version", Info.MajorVersion, 0);
|
||
|
|
mapOptional(IO, "Minor Version", Info.MinorVersion, 0);
|
||
|
|
mapOptional(IO, "Build Number", Info.BuildNumber, 0);
|
||
|
|
IO.mapRequired("Platform ID", Info.PlatformId);
|
||
|
|
IO.mapOptional("CSD Version", Stream.CSDVersion, "");
|
||
|
|
mapOptionalHex(IO, "Suite Mask", Info.SuiteMask, 0);
|
||
|
|
mapOptionalHex(IO, "Reserved", Info.Reserved, 0);
|
||
|
|
switch (static_cast<ProcessorArchitecture>(Info.ProcessorArch)) {
|
||
|
|
case ProcessorArchitecture::X86:
|
||
|
|
case ProcessorArchitecture::AMD64:
|
||
|
|
IO.mapOptional("CPU", Info.CPU.X86);
|
||
|
|
break;
|
||
|
|
case ProcessorArchitecture::ARM:
|
||
|
|
case ProcessorArchitecture::ARM64:
|
||
|
|
case ProcessorArchitecture::BP_ARM64:
|
||
|
|
IO.mapOptional("CPU", Info.CPU.Arm);
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
IO.mapOptional("CPU", Info.CPU.Other);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, TextContentStream &Stream) {
|
||
|
|
IO.mapOptional("Text", Stream.Text);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
|
||
|
|
IO &IO, MemoryDescriptor &Memory, BinaryRef &Content) {
|
||
|
|
mapRequiredHex(IO, "Start of Memory Range", Memory.StartOfMemoryRange);
|
||
|
|
IO.mapRequired("Content", Content);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<ThreadListStream::entry_type>::mapping(
|
||
|
|
IO &IO, ThreadListStream::entry_type &T) {
|
||
|
|
mapRequiredHex(IO, "Thread Id", T.Entry.ThreadId);
|
||
|
|
mapOptionalHex(IO, "Suspend Count", T.Entry.SuspendCount, 0);
|
||
|
|
mapOptionalHex(IO, "Priority Class", T.Entry.PriorityClass, 0);
|
||
|
|
mapOptionalHex(IO, "Priority", T.Entry.Priority, 0);
|
||
|
|
mapOptionalHex(IO, "Environment Block", T.Entry.EnvironmentBlock, 0);
|
||
|
|
IO.mapRequired("Context", T.Context);
|
||
|
|
IO.mapRequired("Stack", T.Entry.Stack, T.Stack);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) {
|
||
|
|
IO.mapRequired("Threads", Stream.Entries);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void streamMapping(yaml::IO &IO, MinidumpYAML::ExceptionStream &Stream) {
|
||
|
|
mapRequiredHex(IO, "Thread ID", Stream.MDExceptionStream.ThreadId);
|
||
|
|
IO.mapRequired("Exception Record", Stream.MDExceptionStream.ExceptionRecord);
|
||
|
|
IO.mapRequired("Thread Context", Stream.ThreadContext);
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<minidump::Exception>::mapping(
|
||
|
|
yaml::IO &IO, minidump::Exception &Exception) {
|
||
|
|
mapRequiredHex(IO, "Exception Code", Exception.ExceptionCode);
|
||
|
|
mapOptionalHex(IO, "Exception Flags", Exception.ExceptionFlags, 0);
|
||
|
|
mapOptionalHex(IO, "Exception Record", Exception.ExceptionRecord, 0);
|
||
|
|
mapOptionalHex(IO, "Exception Address", Exception.ExceptionAddress, 0);
|
||
|
|
mapOptional(IO, "Number of Parameters", Exception.NumberParameters, 0);
|
||
|
|
|
||
|
|
for (size_t Index = 0; Index < Exception.MaxParameters; ++Index) {
|
||
|
|
SmallString<16> Name("Parameter ");
|
||
|
|
Twine(Index).toVector(Name);
|
||
|
|
support::ulittle64_t &Field = Exception.ExceptionInformation[Index];
|
||
|
|
|
||
|
|
if (Index < Exception.NumberParameters)
|
||
|
|
mapRequiredHex(IO, Name.c_str(), Field);
|
||
|
|
else
|
||
|
|
mapOptionalHex(IO, Name.c_str(), Field, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<std::unique_ptr<Stream>>::mapping(
|
||
|
|
yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
|
||
|
|
StreamType Type;
|
||
|
|
if (IO.outputting())
|
||
|
|
Type = S->Type;
|
||
|
|
IO.mapRequired("Type", Type);
|
||
|
|
|
||
|
|
if (!IO.outputting())
|
||
|
|
S = MinidumpYAML::Stream::create(Type);
|
||
|
|
switch (S->Kind) {
|
||
|
|
case MinidumpYAML::Stream::StreamKind::Exception:
|
||
|
|
streamMapping(IO, llvm::cast<MinidumpYAML::ExceptionStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
|
||
|
|
streamMapping(IO, llvm::cast<MemoryInfoListStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::MemoryList:
|
||
|
|
streamMapping(IO, llvm::cast<MemoryListStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::ModuleList:
|
||
|
|
streamMapping(IO, llvm::cast<ModuleListStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::RawContent:
|
||
|
|
streamMapping(IO, llvm::cast<RawContentStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::SystemInfo:
|
||
|
|
streamMapping(IO, llvm::cast<SystemInfoStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::TextContent:
|
||
|
|
streamMapping(IO, llvm::cast<TextContentStream>(*S));
|
||
|
|
break;
|
||
|
|
case MinidumpYAML::Stream::StreamKind::ThreadList:
|
||
|
|
streamMapping(IO, llvm::cast<ThreadListStream>(*S));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
std::string yaml::MappingTraits<std::unique_ptr<Stream>>::validate(
|
||
|
|
yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
|
||
|
|
switch (S->Kind) {
|
||
|
|
case MinidumpYAML::Stream::StreamKind::RawContent:
|
||
|
|
return streamValidate(cast<RawContentStream>(*S));
|
||
|
|
case MinidumpYAML::Stream::StreamKind::Exception:
|
||
|
|
case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
|
||
|
|
case MinidumpYAML::Stream::StreamKind::MemoryList:
|
||
|
|
case MinidumpYAML::Stream::StreamKind::ModuleList:
|
||
|
|
case MinidumpYAML::Stream::StreamKind::SystemInfo:
|
||
|
|
case MinidumpYAML::Stream::StreamKind::TextContent:
|
||
|
|
case MinidumpYAML::Stream::StreamKind::ThreadList:
|
||
|
|
return "";
|
||
|
|
}
|
||
|
|
llvm_unreachable("Fully covered switch above!");
|
||
|
|
}
|
||
|
|
|
||
|
|
void yaml::MappingTraits<Object>::mapping(IO &IO, Object &O) {
|
||
|
|
IO.mapTag("!minidump", true);
|
||
|
|
mapOptionalHex(IO, "Signature", O.Header.Signature, Header::MagicSignature);
|
||
|
|
mapOptionalHex(IO, "Version", O.Header.Version, Header::MagicVersion);
|
||
|
|
mapOptionalHex(IO, "Flags", O.Header.Flags, 0);
|
||
|
|
IO.mapRequired("Streams", O.Streams);
|
||
|
|
}
|
||
|
|
|
||
|
|
Expected<std::unique_ptr<Stream>>
|
||
|
|
Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
|
||
|
|
StreamKind Kind = getKind(StreamDesc.Type);
|
||
|
|
switch (Kind) {
|
||
|
|
case StreamKind::Exception: {
|
||
|
|
Expected<const minidump::ExceptionStream &> ExpectedExceptionStream =
|
||
|
|
File.getExceptionStream();
|
||
|
|
if (!ExpectedExceptionStream)
|
||
|
|
return ExpectedExceptionStream.takeError();
|
||
|
|
Expected<ArrayRef<uint8_t>> ExpectedThreadContext =
|
||
|
|
File.getRawData(ExpectedExceptionStream->ThreadContext);
|
||
|
|
if (!ExpectedThreadContext)
|
||
|
|
return ExpectedThreadContext.takeError();
|
||
|
|
return std::make_unique<ExceptionStream>(*ExpectedExceptionStream,
|
||
|
|
*ExpectedThreadContext);
|
||
|
|
}
|
||
|
|
case StreamKind::MemoryInfoList: {
|
||
|
|
if (auto ExpectedList = File.getMemoryInfoList())
|
||
|
|
return std::make_unique<MemoryInfoListStream>(*ExpectedList);
|
||
|
|
else
|
||
|
|
return ExpectedList.takeError();
|
||
|
|
}
|
||
|
|
case StreamKind::MemoryList: {
|
||
|
|
auto ExpectedList = File.getMemoryList();
|
||
|
|
if (!ExpectedList)
|
||
|
|
return ExpectedList.takeError();
|
||
|
|
std::vector<MemoryListStream::entry_type> Ranges;
|
||
|
|
for (const MemoryDescriptor &MD : *ExpectedList) {
|
||
|
|
auto ExpectedContent = File.getRawData(MD.Memory);
|
||
|
|
if (!ExpectedContent)
|
||
|
|
return ExpectedContent.takeError();
|
||
|
|
Ranges.push_back({MD, *ExpectedContent});
|
||
|
|
}
|
||
|
|
return std::make_unique<MemoryListStream>(std::move(Ranges));
|
||
|
|
}
|
||
|
|
case StreamKind::ModuleList: {
|
||
|
|
auto ExpectedList = File.getModuleList();
|
||
|
|
if (!ExpectedList)
|
||
|
|
return ExpectedList.takeError();
|
||
|
|
std::vector<ModuleListStream::entry_type> Modules;
|
||
|
|
for (const Module &M : *ExpectedList) {
|
||
|
|
auto ExpectedName = File.getString(M.ModuleNameRVA);
|
||
|
|
if (!ExpectedName)
|
||
|
|
return ExpectedName.takeError();
|
||
|
|
auto ExpectedCv = File.getRawData(M.CvRecord);
|
||
|
|
if (!ExpectedCv)
|
||
|
|
return ExpectedCv.takeError();
|
||
|
|
auto ExpectedMisc = File.getRawData(M.MiscRecord);
|
||
|
|
if (!ExpectedMisc)
|
||
|
|
return ExpectedMisc.takeError();
|
||
|
|
Modules.push_back(
|
||
|
|
{M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
|
||
|
|
}
|
||
|
|
return std::make_unique<ModuleListStream>(std::move(Modules));
|
||
|
|
}
|
||
|
|
case StreamKind::RawContent:
|
||
|
|
return std::make_unique<RawContentStream>(StreamDesc.Type,
|
||
|
|
File.getRawStream(StreamDesc));
|
||
|
|
case StreamKind::SystemInfo: {
|
||
|
|
auto ExpectedInfo = File.getSystemInfo();
|
||
|
|
if (!ExpectedInfo)
|
||
|
|
return ExpectedInfo.takeError();
|
||
|
|
auto ExpectedCSDVersion = File.getString(ExpectedInfo->CSDVersionRVA);
|
||
|
|
if (!ExpectedCSDVersion)
|
||
|
|
return ExpectedInfo.takeError();
|
||
|
|
return std::make_unique<SystemInfoStream>(*ExpectedInfo,
|
||
|
|
std::move(*ExpectedCSDVersion));
|
||
|
|
}
|
||
|
|
case StreamKind::TextContent:
|
||
|
|
return std::make_unique<TextContentStream>(
|
||
|
|
StreamDesc.Type, toStringRef(File.getRawStream(StreamDesc)));
|
||
|
|
case StreamKind::ThreadList: {
|
||
|
|
auto ExpectedList = File.getThreadList();
|
||
|
|
if (!ExpectedList)
|
||
|
|
return ExpectedList.takeError();
|
||
|
|
std::vector<ThreadListStream::entry_type> Threads;
|
||
|
|
for (const Thread &T : *ExpectedList) {
|
||
|
|
auto ExpectedStack = File.getRawData(T.Stack.Memory);
|
||
|
|
if (!ExpectedStack)
|
||
|
|
return ExpectedStack.takeError();
|
||
|
|
auto ExpectedContext = File.getRawData(T.Context);
|
||
|
|
if (!ExpectedContext)
|
||
|
|
return ExpectedContext.takeError();
|
||
|
|
Threads.push_back({T, *ExpectedStack, *ExpectedContext});
|
||
|
|
}
|
||
|
|
return std::make_unique<ThreadListStream>(std::move(Threads));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
llvm_unreachable("Unhandled stream kind!");
|
||
|
|
}
|
||
|
|
|
||
|
|
Expected<Object> Object::create(const object::MinidumpFile &File) {
|
||
|
|
std::vector<std::unique_ptr<Stream>> Streams;
|
||
|
|
Streams.reserve(File.streams().size());
|
||
|
|
for (const Directory &StreamDesc : File.streams()) {
|
||
|
|
auto ExpectedStream = Stream::create(StreamDesc, File);
|
||
|
|
if (!ExpectedStream)
|
||
|
|
return ExpectedStream.takeError();
|
||
|
|
Streams.push_back(std::move(*ExpectedStream));
|
||
|
|
}
|
||
|
|
return Object(File.header(), std::move(Streams));
|
||
|
|
}
|