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 
12 using namespace llvm;
13 using namespace llvm::MinidumpYAML;
14 using 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;
19 template <typename EndianType>
20 static 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.
26 template <typename MapType, typename EndianType>
27 static 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.
36 template <typename MapType, typename EndianType>
37 static 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 
44 namespace {
45 /// Return the appropriate yaml Hex type for a given endian-aware type.
46 template <typename EndianType> struct HexType;
47 template <> struct HexType<support::ulittle16_t> { using type = yaml::Hex16; };
48 template <> struct HexType<support::ulittle32_t> { using type = yaml::Hex32; };
49 template <> 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.
53 template <typename EndianType>
54 static 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.
61 template <typename EndianType>
62 static 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 
68 Stream::~Stream() = default;
69 
70 Stream::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 
97 std::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 
120 void 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 
127 void 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 
133 void 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 
139 void 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 
147 void 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 
155 void 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 
163 void 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 
169 namespace {
170 template <std::size_t N> struct FixedSizeHex {
171   FixedSizeHex(uint8_t (&Storage)[N]) : Storage(Storage) {}
172 
173   uint8_t (&Storage)[N];
174 };
175 } // namespace
176 
177 namespace llvm {
178 namespace yaml {
179 template <std::size_t N> struct ScalarTraits<FixedSizeHex<N>> {
180   static void output(const FixedSizeHex<N> &Fixed, void *, raw_ostream &OS) {
181     OS << toHex(makeArrayRef(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
199 void 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 
205 namespace {
206 /// A type which only accepts strings of a fixed size for yaml conversion.
207 template <std::size_t N> struct FixedSizeString {
208   FixedSizeString(char (&Storage)[N]) : Storage(Storage) {}
209 
210   char (&Storage)[N];
211 };
212 } // namespace
213 
214 namespace llvm {
215 namespace yaml {
216 template <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 
235 void 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 
245 void 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 
259 void 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 
276 void 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 
290 static 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 
295 static StringRef 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 
301 void 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 
307 static void streamMapping(yaml::IO &IO, MemoryInfoListStream &Stream) {
308   IO.mapRequired("Memory Ranges", Stream.Infos);
309 }
310 
311 static void streamMapping(yaml::IO &IO, MemoryListStream &Stream) {
312   IO.mapRequired("Memory Ranges", Stream.Entries);
313 }
314 
315 static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) {
316   IO.mapRequired("Modules", Stream.Entries);
317 }
318 
319 static 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 
349 static void streamMapping(yaml::IO &IO, TextContentStream &Stream) {
350   IO.mapOptional("Text", Stream.Text);
351 }
352 
353 void 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 
359 void 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 
370 static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) {
371   IO.mapRequired("Threads", Stream.Entries);
372 }
373 
374 static 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 
380 void 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 
400 void 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 
437 StringRef 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 
454 void 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 
462 Expected<std::unique_ptr<Stream>>
463 Stream::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 
553 Expected<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