1//===- MinidumpYAML.cpp - Minidump YAMLIO implementation ------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/ObjectYAML/MinidumpYAML.h"
10#include "llvm/Support/Allocator.h"
11
12using namespace llvm;
13using namespace llvm::MinidumpYAML;
14using namespace llvm::minidump;
15
16/// Perform an optional yaml-mapping of an endian-aware type EndianType. The
17/// only purpose of this function is to avoid casting the Default value to the
18/// endian type;
19template <typename EndianType>
20static inline void mapOptional(yaml::IO &IO, const char *Key, EndianType &Val,
21                               typename EndianType::value_type Default) {
22  IO.mapOptional(Key, Val, EndianType(Default));
23}
24
25/// Yaml-map an endian-aware type EndianType as some other type MapType.
26template <typename MapType, typename EndianType>
27static inline void mapRequiredAs(yaml::IO &IO, const char *Key,
28                                 EndianType &Val) {
29  MapType Mapped = static_cast<typename EndianType::value_type>(Val);
30  IO.mapRequired(Key, Mapped);
31  Val = static_cast<typename EndianType::value_type>(Mapped);
32}
33
34/// Perform an optional yaml-mapping of an endian-aware type EndianType as some
35/// other type MapType.
36template <typename MapType, typename EndianType>
37static inline void mapOptionalAs(yaml::IO &IO, const char *Key, EndianType &Val,
38                                 MapType Default) {
39  MapType Mapped = static_cast<typename EndianType::value_type>(Val);
40  IO.mapOptional(Key, Mapped, Default);
41  Val = static_cast<typename EndianType::value_type>(Mapped);
42}
43
44namespace {
45/// Return the appropriate yaml Hex type for a given endian-aware type.
46template <typename EndianType> struct HexType;
47template <> struct HexType<support::ulittle16_t> { using type = yaml::Hex16; };
48template <> struct HexType<support::ulittle32_t> { using type = yaml::Hex32; };
49template <> struct HexType<support::ulittle64_t> { using type = yaml::Hex64; };
50} // namespace
51
52/// Yaml-map an endian-aware type as an appropriately-sized hex value.
53template <typename EndianType>
54static inline void mapRequiredHex(yaml::IO &IO, const char *Key,
55                                  EndianType &Val) {
56  mapRequiredAs<typename HexType<EndianType>::type>(IO, Key, Val);
57}
58
59/// Perform an optional yaml-mapping of an endian-aware type as an
60/// appropriately-sized hex value.
61template <typename EndianType>
62static inline void mapOptionalHex(yaml::IO &IO, const char *Key,
63                                  EndianType &Val,
64                                  typename EndianType::value_type Default) {
65  mapOptionalAs<typename HexType<EndianType>::type>(IO, Key, Val, Default);
66}
67
68Stream::~Stream() = default;
69
70Stream::StreamKind Stream::getKind(StreamType Type) {
71  switch (Type) {
72  case StreamType::Exception:
73    return StreamKind::Exception;
74  case StreamType::MemoryInfoList:
75    return StreamKind::MemoryInfoList;
76  case StreamType::MemoryList:
77    return StreamKind::MemoryList;
78  case StreamType::ModuleList:
79    return StreamKind::ModuleList;
80  case StreamType::SystemInfo:
81    return StreamKind::SystemInfo;
82  case StreamType::LinuxCPUInfo:
83  case StreamType::LinuxProcStatus:
84  case StreamType::LinuxLSBRelease:
85  case StreamType::LinuxCMDLine:
86  case StreamType::LinuxMaps:
87  case StreamType::LinuxProcStat:
88  case StreamType::LinuxProcUptime:
89    return StreamKind::TextContent;
90  case StreamType::ThreadList:
91    return StreamKind::ThreadList;
92  default:
93    return StreamKind::RawContent;
94  }
95}
96
97std::unique_ptr<Stream> Stream::create(StreamType Type) {
98  StreamKind Kind = getKind(Type);
99  switch (Kind) {
100  case StreamKind::Exception:
101    return std::make_unique<ExceptionStream>();
102  case StreamKind::MemoryInfoList:
103    return std::make_unique<MemoryInfoListStream>();
104  case StreamKind::MemoryList:
105    return std::make_unique<MemoryListStream>();
106  case StreamKind::ModuleList:
107    return std::make_unique<ModuleListStream>();
108  case StreamKind::RawContent:
109    return std::make_unique<RawContentStream>(Type);
110  case StreamKind::SystemInfo:
111    return std::make_unique<SystemInfoStream>();
112  case StreamKind::TextContent:
113    return std::make_unique<TextContentStream>(Type);
114  case StreamKind::ThreadList:
115    return std::make_unique<ThreadListStream>();
116  }
117  llvm_unreachable("Unhandled stream kind!");
118}
119
120void yaml::ScalarBitSetTraits<MemoryProtection>::bitset(
121    IO &IO, MemoryProtection &Protect) {
122#define HANDLE_MDMP_PROTECT(CODE, NAME, NATIVENAME)                            \
123  IO.bitSetCase(Protect, #NATIVENAME, MemoryProtection::NAME);
124#include "llvm/BinaryFormat/MinidumpConstants.def"
125}
126
127void yaml::ScalarBitSetTraits<MemoryState>::bitset(IO &IO, MemoryState &State) {
128#define HANDLE_MDMP_MEMSTATE(CODE, NAME, NATIVENAME)                           \
129  IO.bitSetCase(State, #NATIVENAME, MemoryState::NAME);
130#include "llvm/BinaryFormat/MinidumpConstants.def"
131}
132
133void yaml::ScalarBitSetTraits<MemoryType>::bitset(IO &IO, MemoryType &Type) {
134#define HANDLE_MDMP_MEMTYPE(CODE, NAME, NATIVENAME)                            \
135  IO.bitSetCase(Type, #NATIVENAME, MemoryType::NAME);
136#include "llvm/BinaryFormat/MinidumpConstants.def"
137}
138
139void yaml::ScalarEnumerationTraits<ProcessorArchitecture>::enumeration(
140    IO &IO, ProcessorArchitecture &Arch) {
141#define HANDLE_MDMP_ARCH(CODE, NAME)                                           \
142  IO.enumCase(Arch, #NAME, ProcessorArchitecture::NAME);
143#include "llvm/BinaryFormat/MinidumpConstants.def"
144  IO.enumFallback<Hex16>(Arch);
145}
146
147void yaml::ScalarEnumerationTraits<OSPlatform>::enumeration(IO &IO,
148                                                            OSPlatform &Plat) {
149#define HANDLE_MDMP_PLATFORM(CODE, NAME)                                       \
150  IO.enumCase(Plat, #NAME, OSPlatform::NAME);
151#include "llvm/BinaryFormat/MinidumpConstants.def"
152  IO.enumFallback<Hex32>(Plat);
153}
154
155void yaml::ScalarEnumerationTraits<StreamType>::enumeration(IO &IO,
156                                                            StreamType &Type) {
157#define HANDLE_MDMP_STREAM_TYPE(CODE, NAME)                                    \
158  IO.enumCase(Type, #NAME, StreamType::NAME);
159#include "llvm/BinaryFormat/MinidumpConstants.def"
160  IO.enumFallback<Hex32>(Type);
161}
162
163void yaml::MappingTraits<CPUInfo::ArmInfo>::mapping(IO &IO,
164                                                    CPUInfo::ArmInfo &Info) {
165  mapRequiredHex(IO, "CPUID", Info.CPUID);
166  mapOptionalHex(IO, "ELF hwcaps", Info.ElfHWCaps, 0);
167}
168
169namespace {
170template <std::size_t N> struct FixedSizeHex {
171  FixedSizeHex(uint8_t (&Storage)[N]) : Storage(Storage) {}
172
173  uint8_t (&Storage)[N];
174};
175} // namespace
176
177namespace llvm {
178namespace yaml {
179template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> {
180  static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) {
181    OS << toHex(ArrayRef(Fixed.Storage));
182  }
183
184  static StringRef input(StringRef Scalar, void *, FixedSizeHex<N> &Fixed) {
185    if (!all_of(Scalar, isHexDigit))
186      return "Invalid hex digit in input";
187    if (Scalar.size() < 2 * N)
188      return "String too short";
189    if (Scalar.size() > 2 * N)
190      return "String too long";
191    copy(fromHex(Scalar), Fixed.Storage);
192    return "";
193  }
194
195  static QuotingType mustQuote(StringRef S) { return QuotingType::None; }
196};
197} // namespace yaml
198} // namespace llvm
199void yaml::MappingTraits<CPUInfo::OtherInfo>::mapping(
200    IO &IO, CPUInfo::OtherInfo &Info) {
201  FixedSizeHex<sizeof(Info.ProcessorFeatures)> Features(Info.ProcessorFeatures);
202  IO.mapRequired("Features", Features);
203}
204
205namespace {
206/// A type which only accepts strings of a fixed size for yaml conversion.
207template <std::size_t N> struct FixedSizeString {
208  FixedSizeString(char (&Storage)[N]) : Storage(Storage) {}
209
210  char (&Storage)[N];
211};
212} // namespace
213
214namespace llvm {
215namespace yaml {
216template <std::size_t N> struct ScalarTraits<FixedSizeString<N>> {
217  static void output(const FixedSizeString<N> &Fixed, void *, raw_ostream &OS) {
218    OS << StringRef(Fixed.Storage, N);
219  }
220
221  static StringRef input(StringRef Scalar, void *, FixedSizeString<N> &Fixed) {
222    if (Scalar.size() < N)
223      return "String too short";
224    if (Scalar.size() > N)
225      return "String too long";
226    copy(Scalar, Fixed.Storage);
227    return "";
228  }
229
230  static QuotingType mustQuote(StringRef S) { return needsQuotes(S); }
231};
232} // namespace yaml
233} // namespace llvm
234
235void yaml::MappingTraits<CPUInfo::X86Info>::mapping(IO &IO,
236                                                    CPUInfo::X86Info &Info) {
237  FixedSizeString<sizeof(Info.VendorID)> VendorID(Info.VendorID);
238  IO.mapRequired("Vendor ID", VendorID);
239
240  mapRequiredHex(IO, "Version Info", Info.VersionInfo);
241  mapRequiredHex(IO, "Feature Info", Info.FeatureInfo);
242  mapOptionalHex(IO, "AMD Extended Features", Info.AMDExtendedFeatures, 0);
243}
244
245void yaml::MappingTraits<MemoryInfo>::mapping(IO &IO, MemoryInfo &Info) {
246  mapRequiredHex(IO, "Base Address", Info.BaseAddress);
247  mapOptionalHex(IO, "Allocation Base", Info.AllocationBase, Info.BaseAddress);
248  mapRequiredAs<MemoryProtection>(IO, "Allocation Protect",
249                                  Info.AllocationProtect);
250  mapOptionalHex(IO, "Reserved0", Info.Reserved0, 0);
251  mapRequiredHex(IO, "Region Size", Info.RegionSize);
252  mapRequiredAs<MemoryState>(IO, "State", Info.State);
253  mapOptionalAs<MemoryProtection>(IO, "Protect", Info.Protect,
254                                  Info.AllocationProtect);
255  mapRequiredAs<MemoryType>(IO, "Type", Info.Type);
256  mapOptionalHex(IO, "Reserved1", Info.Reserved1, 0);
257}
258
259void yaml::MappingTraits<VSFixedFileInfo>::mapping(IO &IO,
260                                                   VSFixedFileInfo &Info) {
261  mapOptionalHex(IO, "Signature", Info.Signature, 0);
262  mapOptionalHex(IO, "Struct Version", Info.StructVersion, 0);
263  mapOptionalHex(IO, "File Version High", Info.FileVersionHigh, 0);
264  mapOptionalHex(IO, "File Version Low", Info.FileVersionLow, 0);
265  mapOptionalHex(IO, "Product Version High", Info.ProductVersionHigh, 0);
266  mapOptionalHex(IO, "Product Version Low", Info.ProductVersionLow, 0);
267  mapOptionalHex(IO, "File Flags Mask", Info.FileFlagsMask, 0);
268  mapOptionalHex(IO, "File Flags", Info.FileFlags, 0);
269  mapOptionalHex(IO, "File OS", Info.FileOS, 0);
270  mapOptionalHex(IO, "File Type", Info.FileType, 0);
271  mapOptionalHex(IO, "File Subtype", Info.FileSubtype, 0);
272  mapOptionalHex(IO, "File Date High", Info.FileDateHigh, 0);
273  mapOptionalHex(IO, "File Date Low", Info.FileDateLow, 0);
274}
275
276void yaml::MappingTraits<ModuleListStream::entry_type>::mapping(
277    IO &IO, ModuleListStream::entry_type &M) {
278  mapRequiredHex(IO, "Base of Image", M.Entry.BaseOfImage);
279  mapRequiredHex(IO, "Size of Image", M.Entry.SizeOfImage);
280  mapOptionalHex(IO, "Checksum", M.Entry.Checksum, 0);
281  mapOptional(IO, "Time Date Stamp", M.Entry.TimeDateStamp, 0);
282  IO.mapRequired("Module Name", M.Name);
283  IO.mapOptional("Version Info", M.Entry.VersionInfo, VSFixedFileInfo());
284  IO.mapRequired("CodeView Record", M.CvRecord);
285  IO.mapOptional("Misc Record", M.MiscRecord, yaml::BinaryRef());
286  mapOptionalHex(IO, "Reserved0", M.Entry.Reserved0, 0);
287  mapOptionalHex(IO, "Reserved1", M.Entry.Reserved1, 0);
288}
289
290static void streamMapping(yaml::IO &IO, RawContentStream &Stream) {
291  IO.mapOptional("Content", Stream.Content);
292  IO.mapOptional("Size", Stream.Size, Stream.Content.binary_size());
293}
294
295static std::string streamValidate(RawContentStream &Stream) {
296  if (Stream.Size.value < Stream.Content.binary_size())
297    return "Stream size must be greater or equal to the content size";
298  return "";
299}
300
301void yaml::MappingTraits<MemoryListStream::entry_type>::mapping(
302    IO &IO, MemoryListStream::entry_type &Range) {
303  MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
304      IO, Range.Entry, Range.Content);
305}
306
307static void streamMapping(yaml::IO &IO, MemoryInfoListStream &Stream) {
308  IO.mapRequired("Memory Ranges", Stream.Infos);
309}
310
311static void streamMapping(yaml::IO &IO, MemoryListStream &Stream) {
312  IO.mapRequired("Memory Ranges", Stream.Entries);
313}
314
315static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) {
316  IO.mapRequired("Modules", Stream.Entries);
317}
318
319static void streamMapping(yaml::IO &IO, SystemInfoStream &Stream) {
320  SystemInfo &Info = Stream.Info;
321  IO.mapRequired("Processor Arch", Info.ProcessorArch);
322  mapOptional(IO, "Processor Level", Info.ProcessorLevel, 0);
323  mapOptional(IO, "Processor Revision", Info.ProcessorRevision, 0);
324  IO.mapOptional("Number of Processors", Info.NumberOfProcessors, 0);
325  IO.mapOptional("Product type", Info.ProductType, 0);
326  mapOptional(IO, "Major Version", Info.MajorVersion, 0);
327  mapOptional(IO, "Minor Version", Info.MinorVersion, 0);
328  mapOptional(IO, "Build Number", Info.BuildNumber, 0);
329  IO.mapRequired("Platform ID", Info.PlatformId);
330  IO.mapOptional("CSD Version", Stream.CSDVersion, "");
331  mapOptionalHex(IO, "Suite Mask", Info.SuiteMask, 0);
332  mapOptionalHex(IO, "Reserved", Info.Reserved, 0);
333  switch (static_cast<ProcessorArchitecture>(Info.ProcessorArch)) {
334  case ProcessorArchitecture::X86:
335  case ProcessorArchitecture::AMD64:
336    IO.mapOptional("CPU", Info.CPU.X86);
337    break;
338  case ProcessorArchitecture::ARM:
339  case ProcessorArchitecture::ARM64:
340  case ProcessorArchitecture::BP_ARM64:
341    IO.mapOptional("CPU", Info.CPU.Arm);
342    break;
343  default:
344    IO.mapOptional("CPU", Info.CPU.Other);
345    break;
346  }
347}
348
349static void streamMapping(yaml::IO &IO, TextContentStream &Stream) {
350  IO.mapOptional("Text", Stream.Text);
351}
352
353void yaml::MappingContextTraits<MemoryDescriptor, yaml::BinaryRef>::mapping(
354    IO &IO, MemoryDescriptor &Memory, BinaryRef &Content) {
355  mapRequiredHex(IO, "Start of Memory Range", Memory.StartOfMemoryRange);
356  IO.mapRequired("Content", Content);
357}
358
359void yaml::MappingTraits<ThreadListStream::entry_type>::mapping(
360    IO &IO, ThreadListStream::entry_type &T) {
361  mapRequiredHex(IO, "Thread Id", T.Entry.ThreadId);
362  mapOptionalHex(IO, "Suspend Count", T.Entry.SuspendCount, 0);
363  mapOptionalHex(IO, "Priority Class", T.Entry.PriorityClass, 0);
364  mapOptionalHex(IO, "Priority", T.Entry.Priority, 0);
365  mapOptionalHex(IO, "Environment Block", T.Entry.EnvironmentBlock, 0);
366  IO.mapRequired("Context", T.Context);
367  IO.mapRequired("Stack", T.Entry.Stack, T.Stack);
368}
369
370static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) {
371  IO.mapRequired("Threads", Stream.Entries);
372}
373
374static void streamMapping(yaml::IO &IO, MinidumpYAML::ExceptionStream &Stream) {
375  mapRequiredHex(IO, "Thread ID", Stream.MDExceptionStream.ThreadId);
376  IO.mapRequired("Exception Record", Stream.MDExceptionStream.ExceptionRecord);
377  IO.mapRequired("Thread Context", Stream.ThreadContext);
378}
379
380void yaml::MappingTraits<minidump::Exception>::mapping(
381    yaml::IO &IO, minidump::Exception &Exception) {
382  mapRequiredHex(IO, "Exception Code", Exception.ExceptionCode);
383  mapOptionalHex(IO, "Exception Flags", Exception.ExceptionFlags, 0);
384  mapOptionalHex(IO, "Exception Record", Exception.ExceptionRecord, 0);
385  mapOptionalHex(IO, "Exception Address", Exception.ExceptionAddress, 0);
386  mapOptional(IO, "Number of Parameters", Exception.NumberParameters, 0);
387
388  for (size_t Index = 0; Index < Exception.MaxParameters; ++Index) {
389    SmallString<16> Name("Parameter ");
390    Twine(Index).toVector(Name);
391    support::ulittle64_t &Field = Exception.ExceptionInformation[Index];
392
393    if (Index < Exception.NumberParameters)
394      mapRequiredHex(IO, Name.c_str(), Field);
395    else
396      mapOptionalHex(IO, Name.c_str(), Field, 0);
397  }
398}
399
400void yaml::MappingTraits<std::unique_ptr<Stream>>::mapping(
401    yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
402  StreamType Type;
403  if (IO.outputting())
404    Type = S->Type;
405  IO.mapRequired("Type", Type);
406
407  if (!IO.outputting())
408    S = MinidumpYAML::Stream::create(Type);
409  switch (S->Kind) {
410  case MinidumpYAML::Stream::StreamKind::Exception:
411    streamMapping(IO, llvm::cast<MinidumpYAML::ExceptionStream>(*S));
412    break;
413  case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
414    streamMapping(IO, llvm::cast<MemoryInfoListStream>(*S));
415    break;
416  case MinidumpYAML::Stream::StreamKind::MemoryList:
417    streamMapping(IO, llvm::cast<MemoryListStream>(*S));
418    break;
419  case MinidumpYAML::Stream::StreamKind::ModuleList:
420    streamMapping(IO, llvm::cast<ModuleListStream>(*S));
421    break;
422  case MinidumpYAML::Stream::StreamKind::RawContent:
423    streamMapping(IO, llvm::cast<RawContentStream>(*S));
424    break;
425  case MinidumpYAML::Stream::StreamKind::SystemInfo:
426    streamMapping(IO, llvm::cast<SystemInfoStream>(*S));
427    break;
428  case MinidumpYAML::Stream::StreamKind::TextContent:
429    streamMapping(IO, llvm::cast<TextContentStream>(*S));
430    break;
431  case MinidumpYAML::Stream::StreamKind::ThreadList:
432    streamMapping(IO, llvm::cast<ThreadListStream>(*S));
433    break;
434  }
435}
436
437std::string yaml::MappingTraits<std::unique_ptr<Stream>>::validate(
438    yaml::IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S) {
439  switch (S->Kind) {
440  case MinidumpYAML::Stream::StreamKind::RawContent:
441    return streamValidate(cast<RawContentStream>(*S));
442  case MinidumpYAML::Stream::StreamKind::Exception:
443  case MinidumpYAML::Stream::StreamKind::MemoryInfoList:
444  case MinidumpYAML::Stream::StreamKind::MemoryList:
445  case MinidumpYAML::Stream::StreamKind::ModuleList:
446  case MinidumpYAML::Stream::StreamKind::SystemInfo:
447  case MinidumpYAML::Stream::StreamKind::TextContent:
448  case MinidumpYAML::Stream::StreamKind::ThreadList:
449    return "";
450  }
451  llvm_unreachable("Fully covered switch above!");
452}
453
454void yaml::MappingTraits<Object>::mapping(IO &IO, Object &O) {
455  IO.mapTag("!minidump", true);
456  mapOptionalHex(IO, "Signature", O.Header.Signature, Header::MagicSignature);
457  mapOptionalHex(IO, "Version", O.Header.Version, Header::MagicVersion);
458  mapOptionalHex(IO, "Flags", O.Header.Flags, 0);
459  IO.mapRequired("Streams", O.Streams);
460}
461
462Expected<std::unique_ptr<Stream>>
463Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
464  StreamKind Kind = getKind(StreamDesc.Type);
465  switch (Kind) {
466  case StreamKind::Exception: {
467    Expected<const minidump::ExceptionStream &> ExpectedExceptionStream =
468        File.getExceptionStream();
469    if (!ExpectedExceptionStream)
470      return ExpectedExceptionStream.takeError();
471    Expected<ArrayRef<uint8_t>> ExpectedThreadContext =
472        File.getRawData(ExpectedExceptionStream->ThreadContext);
473    if (!ExpectedThreadContext)
474      return ExpectedThreadContext.takeError();
475    return std::make_unique<ExceptionStream>(*ExpectedExceptionStream,
476                                             *ExpectedThreadContext);
477  }
478  case StreamKind::MemoryInfoList: {
479    if (auto ExpectedList = File.getMemoryInfoList())
480      return std::make_unique<MemoryInfoListStream>(*ExpectedList);
481    else
482      return ExpectedList.takeError();
483  }
484  case StreamKind::MemoryList: {
485    auto ExpectedList = File.getMemoryList();
486    if (!ExpectedList)
487      return ExpectedList.takeError();
488    std::vector<MemoryListStream::entry_type> Ranges;
489    for (const MemoryDescriptor &MD : *ExpectedList) {
490      auto ExpectedContent = File.getRawData(MD.Memory);
491      if (!ExpectedContent)
492        return ExpectedContent.takeError();
493      Ranges.push_back({MD, *ExpectedContent});
494    }
495    return std::make_unique<MemoryListStream>(std::move(Ranges));
496  }
497  case StreamKind::ModuleList: {
498    auto ExpectedList = File.getModuleList();
499    if (!ExpectedList)
500      return ExpectedList.takeError();
501    std::vector<ModuleListStream::entry_type> Modules;
502    for (const Module &M : *ExpectedList) {
503      auto ExpectedName = File.getString(M.ModuleNameRVA);
504      if (!ExpectedName)
505        return ExpectedName.takeError();
506      auto ExpectedCv = File.getRawData(M.CvRecord);
507      if (!ExpectedCv)
508        return ExpectedCv.takeError();
509      auto ExpectedMisc = File.getRawData(M.MiscRecord);
510      if (!ExpectedMisc)
511        return ExpectedMisc.takeError();
512      Modules.push_back(
513          {M, std::move(*ExpectedName), *ExpectedCv, *ExpectedMisc});
514    }
515    return std::make_unique<ModuleListStream>(std::move(Modules));
516  }
517  case StreamKind::RawContent:
518    return std::make_unique<RawContentStream>(StreamDesc.Type,
519                                               File.getRawStream(StreamDesc));
520  case StreamKind::SystemInfo: {
521    auto ExpectedInfo = File.getSystemInfo();
522    if (!ExpectedInfo)
523      return ExpectedInfo.takeError();
524    auto ExpectedCSDVersion = File.getString(ExpectedInfo->CSDVersionRVA);
525    if (!ExpectedCSDVersion)
526      return ExpectedInfo.takeError();
527    return std::make_unique<SystemInfoStream>(*ExpectedInfo,
528                                               std::move(*ExpectedCSDVersion));
529  }
530  case StreamKind::TextContent:
531    return std::make_unique<TextContentStream>(
532        StreamDesc.Type, toStringRef(File.getRawStream(StreamDesc)));
533  case StreamKind::ThreadList: {
534    auto ExpectedList = File.getThreadList();
535    if (!ExpectedList)
536      return ExpectedList.takeError();
537    std::vector<ThreadListStream::entry_type> Threads;
538    for (const Thread &T : *ExpectedList) {
539      auto ExpectedStack = File.getRawData(T.Stack.Memory);
540      if (!ExpectedStack)
541        return ExpectedStack.takeError();
542      auto ExpectedContext = File.getRawData(T.Context);
543      if (!ExpectedContext)
544        return ExpectedContext.takeError();
545      Threads.push_back({T, *ExpectedStack, *ExpectedContext});
546    }
547    return std::make_unique<ThreadListStream>(std::move(Threads));
548  }
549  }
550  llvm_unreachable("Unhandled stream kind!");
551}
552
553Expected<Object> Object::create(const object::MinidumpFile &File) {
554  std::vector<std::unique_ptr<Stream>> Streams;
555  Streams.reserve(File.streams().size());
556  for (const Directory &StreamDesc : File.streams()) {
557    auto ExpectedStream = Stream::create(StreamDesc, File);
558    if (!ExpectedStream)
559      return ExpectedStream.takeError();
560    Streams.push_back(std::move(*ExpectedStream));
561  }
562  return Object(File.header(), std::move(Streams));
563}
564