MinidumpYAML: add support for the ThreadList stream

[labath]

Summary

The implementation is a pretty straightforward extension of the pattern
used for (de)serializing the ModuleList stream. Since there are other
streams which use the same format (MemoryList and MemoryList64, at
least). I tried to generalize the code a bit so that adding future
streams of this type can be done with less code.

[clayborg]

lgtm

[jhenderson]

include/llvm/ObjectYAML/MinidumpYAML.h

57

with -> with a

58

KindV and TypeV aren't clear names to me. What does the V stand for?

64

explicit?

70–73

I'm not sure how much sense it makes to go into the detail of the minidump file format versus the memory view here. I also am not convinced by the repetition of this in the comments below.

lib/ObjectYAML/MinidumpYAML.cpp

481

Same comment as above re. names.

test/tools/obj2yaml/basic-minidump.yaml

47–49

It would be nice if these were padded so that they all line up. Ditto in the Stack block below.

51

I don't have a concrete suggestion, but it might be nice to have a shorter field name than "Start of Memory Range", but that's less of a concern if that's the actual minidump field name.

[labath]

include/llvm/ObjectYAML/MinidumpYAML.h

58

"variable" or "value" or something like that. :) Not a very good name, but I needed to differentiate that from the class member with the same name. However, just I've had an idea of how to organize this better and reduce the number of template parameters (by making these static members of the EntryT type). This also avoid the need for inventing names here.

70–73

I've removed the memory vs. file blurb.

test/tools/obj2yaml/basic-minidump.yaml

47–49

The microsoft structure definition calls this field just "teb" (for Thread Environment Block), but I've found that too opaque, so I expanded the acronym (sans "thread", because it is obvious we are talking about threads here). I could shorten this further to "environment" (the word "block" probably doesn't add that much value) , or even to "teb" for consistency with microsoft headers. Let me know what you think.

51

That's how the field is called in the official microsoft documentation (https://docs.microsoft.com/en-us/windows/desktop/api/minidumpapiset/ns-minidumpapiset-minidump_memory_descriptor), which is probably the closest thing to a "spec" for this thing. It's a bit verbose, and probably "Address" would just suffice here, but otoh it's nice for this to match the official name.

[labath]

Address review comments.

[jhenderson]

LGTM, with the suggested fixes.

test/tools/obj2yaml/basic-minidump.yaml

47–49

Environment Block is fine. I was actually referring to the number of spaces between the attribute name and value, i.e. I'd prefer this:

- Thread Id:         0x5C5D5E5F
  Priority Class:    0x60616263
  Environment Block: 0x6465666768696A6B

51

Let's leave it as is, since it matches the Microsoft document.

105

Similar comment here about whitespace. Make the values of attributes within a block line up.

106

Move this to be above the Stack block for readability.

[labath]

Thanks for the review.

test/tools/obj2yaml/basic-minidump.yaml

47–49

Ok, I see. I can do that manually here, but that won't prevent the actual output from obj2yaml from being misaligned (which is why i was trying to come up with a shorter name).

include/llvm/ObjectYAML/MinidumpYAML.h

 /// unrecognised stream Type will be handled via RawContentStream). The mapping
 /// from Types to Kinds is fixed and given by the static getKind function.
 struct Stream {
   enum class StreamKind {
     ModuleList,
     RawContent,
     SystemInfo,
     TextContent,
+    ThreadList,
   };
 
   Stream(StreamKind Kind, minidump::StreamType Type) : Kind(Kind), Type(Type) {}
   virtual ~Stream(); // anchor
 
   const StreamKind Kind;
   const minidump::StreamType Type;
 
   /// Get the stream Kind used for representing streams of a given Type.
   static StreamKind getKind(minidump::StreamType Type);
 
   /// Create an empty stream of the given Type.
   static std::unique_ptr<Stream> create(minidump::StreamType Type);
 
   /// Create a stream from the given stream directory entry.
   static Expected<std::unique_ptr<Stream>>
   create(const minidump::Directory &StreamDesc,
          const object::MinidumpFile &File);
 };
 
-/// A stream representing the list of modules loaded in the process. On disk, it
-/// is represented as a sequence of minidump::Module structures. These contain
-/// pointers to other data structures, like the module's name and CodeView
-/// record. In memory, we represent these as the ParsedModule struct, which
-/// groups minidump::Module with all of its dependant structures in a single
-/// entity.
-struct ModuleListStream : public Stream {
-  struct ParsedModule {
-    minidump::Module Module;
-    std::string Name;
-    yaml::BinaryRef CvRecord;
-    yaml::BinaryRef MiscRecord;
-  };
-  std::vector<ParsedModule> Modules;
+namespace detail {
+/// A stream representing a list of abstract entries in a minidump stream. Its
+/// instantiations can be used to represent the ModuleList stream and other
+/// streams with similar structure.
+template <typename EntryT, Stream::StreamKind KindV, minidump::StreamType TypeV>
+struct ListStream : public Stream {
+  using entry_type = EntryT;
+
+  std::vector<entry_type> Entries;
+
+  ListStream(std::vector<entry_type> Entries = {})
+      : Stream(KindV, TypeV), Entries(std::move(Entries)) {}
+
+  static bool classof(const Stream *S) { return S->Kind == KindV; }
+};
+
+/// A structure containing all data belonging to a single minidump module. On
+/// disk, these are placed at various places in the minidump file and
+/// cross-referenced via their offsets, but for ease of use, we group them
+/// together in the logical memory view.
+  minidump::Module Entry;
 
-  ModuleListStream(std::vector<ParsedModule> Modules = {})
-      : Stream(StreamKind::ModuleList, minidump::StreamType::ModuleList),
-        Modules(std::move(Modules)) {}
-
-  static bool classof(const Stream *S) {
-    return S->Kind == StreamKind::ModuleList;
-  }
-};
+/// A structure containing all data belonging to a single minidump thread. On
+/// disk, these are placed at various places in the minidump file and
+/// cross-referenced via their offsets, but for ease of use, we group them
+/// together in the logical memory view.
+struct ParsedThread {
+  minidump::Thread Entry;
+  yaml::BinaryRef Stack;
+  yaml::BinaryRef Context;
+};
+} // namespace detail
+
+using ModuleListStream =
+    detail::ListStream<detail::ParsedModule, Stream::StreamKind::ModuleList,
+                       minidump::StreamType::ModuleList>;
+
+using ThreadListStream =
+    detail::ListStream<detail::ParsedThread, Stream::StreamKind::ThreadList,
+                       minidump::StreamType::ThreadList>;
 
 /// A minidump stream represented as a sequence of hex bytes. This is used as a
 /// fallback when no other stream kind is suitable.
 struct RawContentStream : public Stream {
   yaml::BinaryRef Content;
   yaml::Hex32 Size;
 
   RawContentStream(minidump::StreamType Type, ArrayRef<uint8_t> Content = {})
template <> struct BlockScalarTraits<MinidumpYAML::BlockStringRef> {
   }
 };
 
 template <> struct MappingTraits<std::unique_ptr<MinidumpYAML::Stream>> {
   static void mapping(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
   static StringRef validate(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
 };
 
+template <> struct MappingContextTraits<minidump::MemoryDescriptor, BinaryRef> {
+  static void mapping(IO &IO, minidump::MemoryDescriptor &Memory,
+                      BinaryRef &Content);
+};
+
 } // namespace yaml
 
 } // namespace llvm
 
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::ProcessorArchitecture)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::OSPlatform)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::StreamType)
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::ArmInfo)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::OtherInfo)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::X86Info)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::VSFixedFileInfo)
+
+LLVM_YAML_DECLARE_MAPPING_TRAITS(
+    llvm::MinidumpYAML::ModuleListStream::entry_type)
 LLVM_YAML_DECLARE_MAPPING_TRAITS(
-    llvm::MinidumpYAML::ModuleListStream::ParsedModule)
+    llvm::MinidumpYAML::ThreadListStream::entry_type)
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::MinidumpYAML::Stream>)
-LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ModuleListStream::ParsedModule)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ModuleListStream::entry_type)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ThreadListStream::entry_type)
 
 LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::MinidumpYAML::Object)
 
 #endif // LLVM_OBJECTYAML_MINIDUMPYAML_H

lib/ObjectYAML/MinidumpYAML.cpp

Stream::StreamKind Stream::getKind(StreamType Type) {
   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::ModuleList:
     return llvm::make_unique<ModuleListStream>();
   case StreamKind::RawContent:
     return llvm::make_unique<RawContentStream>(Type);
   case StreamKind::SystemInfo:
     return llvm::make_unique<SystemInfoStream>();
   case StreamKind::TextContent:
     return llvm::make_unique<TextContentStream>(Type);
+  case StreamKind::ThreadList:
+    return llvm::make_unique<ThreadListStream>();
   }
   llvm_unreachable("Unhandled stream kind!");
 }
 
 void yaml::ScalarEnumerationTraits<ProcessorArchitecture>::enumeration(
     IO &IO, ProcessorArchitecture &Arch) {
 #define HANDLE_MDMP_ARCH(CODE, NAME)                                           \
   IO.enumCase(Arch, #NAME, ProcessorArchitecture::NAME);
void yaml::MappingTraits<VSFixedFileInfo>::mapping(IO &IO,
   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::ParsedModule>::mapping(
-    IO &IO, ModuleListStream::ParsedModule &M) {
-  mapRequiredHex(IO, "Base of Image", M.Module.BaseOfImage);
-  mapRequiredHex(IO, "Size of Image", M.Module.SizeOfImage);
-  mapOptionalHex(IO, "Checksum", M.Module.Checksum, 0);
-  IO.mapOptional("Time Date Stamp", M.Module.TimeDateStamp,
+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);
+  IO.mapOptional("Time Date Stamp", M.Entry.TimeDateStamp,
                  support::ulittle32_t(0));
   IO.mapRequired("Module Name", M.Name);
-  IO.mapOptional("Version Info", M.Module.VersionInfo, VSFixedFileInfo());
+  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.Module.Reserved0, 0);
-  mapOptionalHex(IO, "Reserved1", M.Module.Reserved1, 0);
+  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 StringRef streamValidate(RawContentStream &Stream) {
   if (Stream.Size.value < Stream.Content.binary_size())
     return "Stream size must be greater or equal to the content size";
   return "";
 }
 
 static void streamMapping(yaml::IO &IO, ModuleListStream &Stream) {
-  IO.mapRequired("Modules", Stream.Modules);
+  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);
default:
     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("Stack", T.Entry.Stack, T.Stack);
+  IO.mapRequired("Context", T.Context);
+}
+
+static void streamMapping(yaml::IO &IO, ThreadListStream &Stream) {
+  IO.mapRequired("Threads", Stream.Entries);
+}
+
 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::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;
   }
 }
 
 StringRef 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::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);
 }
 
+static LocationDescriptor layout(BlobAllocator &File, yaml::BinaryRef Data) {
+  return {support::ulittle32_t(Data.binary_size()),
+          support::ulittle32_t(File.allocateBytes(Data))};
+}
+
+static void layout(BlobAllocator &File, ModuleListStream::entry_type &M) {
+  M.Entry.ModuleNameRVA = File.allocateString(M.Name);
+
+  M.Entry.CvRecord = layout(File, M.CvRecord);
+  M.Entry.MiscRecord = layout(File, M.MiscRecord);
+}
+
+static void layout(BlobAllocator &File, ThreadListStream::entry_type &T) {
+  T.Entry.Stack.Memory = layout(File, T.Stack);
+  T.Entry.Context = layout(File, T.Context);
+}
+
+template <typename EntryT, Stream::StreamKind KindV, StreamType TypeV>
+static size_t
+layout(BlobAllocator &File,
+       MinidumpYAML::detail::ListStream<EntryT, KindV, TypeV> &S) {
+  using ListStream = MinidumpYAML::detail::ListStream<EntryT, KindV, TypeV>;
+
+  File.allocateNewObject<support::ulittle32_t>(S.Entries.size());
+  for (typename ListStream::entry_type &E : S.Entries)
+    File.allocateObject(E.Entry);
+
+  size_t DataEnd = File.tell();
+
+  // Lay out the auxiliary data, (which is not a part of the stream).
+  DataEnd = File.tell();
+  for (typename ListStream::entry_type &E : S.Entries)
+    layout(File, E);
+
+  return DataEnd;
+}
+
 static Directory layout(BlobAllocator &File, Stream &S) {
   Directory Result;
   Result.Type = S.Type;
   Result.Location.RVA = File.tell();
   Optional<size_t> DataEnd;
   switch (S.Kind) {
-  case Stream::StreamKind::ModuleList: {
-    ModuleListStream &List = cast<ModuleListStream>(S);
-
-    File.allocateNewObject<support::ulittle32_t>(List.Modules.size());
-    for (ModuleListStream::ParsedModule &M : List.Modules)
-      File.allocateObject(M.Module);
-
-    // Module names and CodeView/Misc records are not a part of the stream.
-    DataEnd = File.tell();
-    for (ModuleListStream::ParsedModule &M : List.Modules) {
-      M.Module.ModuleNameRVA = File.allocateString(M.Name);
-
-      M.Module.CvRecord.RVA = File.allocateBytes(M.CvRecord);
-      M.Module.CvRecord.DataSize = M.CvRecord.binary_size();
-
-      M.Module.MiscRecord.RVA = File.allocateBytes(M.MiscRecord);
-      M.Module.MiscRecord.DataSize = M.MiscRecord.binary_size();
-    }
+  case Stream::StreamKind::ModuleList:
+    DataEnd = layout(File, cast<ModuleListStream>(S));
     break;
-  }
   case Stream::StreamKind::RawContent: {
     RawContentStream &Raw = cast<RawContentStream>(S);
     File.allocateCallback(Raw.Size, [&Raw](raw_ostream &OS) {
       Raw.Content.writeAsBinary(OS);
       assert(Raw.Content.binary_size() <= Raw.Size);
       OS << std::string(Raw.Size - Raw.Content.binary_size(), '\0');
     });
     break;
   }
   case Stream::StreamKind::SystemInfo: {
     SystemInfoStream &SystemInfo = cast<SystemInfoStream>(S);
     File.allocateObject(SystemInfo.Info);
     // The CSD string is not a part of the stream.
     DataEnd = File.tell();
     SystemInfo.Info.CSDVersionRVA = File.allocateString(SystemInfo.CSDVersion);
     break;
   }
   case Stream::StreamKind::TextContent:
     File.allocateArray(arrayRefFromStringRef(cast<TextContentStream>(S).Text));
     break;
+  case Stream::StreamKind::ThreadList:
+    DataEnd = layout(File, cast<ThreadListStream>(S));
+    break;
   }
   // If DataEnd is not set, we assume everything we generated is a part of the
   // stream.
   Result.Location.DataSize =
       DataEnd.getValueOr(File.tell()) - Result.Location.RVA;
   return Result;
 }
 

 Expected<std::unique_ptr<Stream>>
 Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
   StreamKind Kind = getKind(StreamDesc.Type);
   switch (Kind) {
   case StreamKind::ModuleList: {
     auto ExpectedList = File.getModuleList();
     if (!ExpectedList)
       return ExpectedList.takeError();
-    std::vector<ModuleListStream::ParsedModule> Modules;
+    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);
case StreamKind::SystemInfo: {
     if (!ExpectedCSDVersion)
       return ExpectedInfo.takeError();
     return llvm::make_unique<SystemInfoStream>(*ExpectedInfo,
                                                std::move(*ExpectedCSDVersion));
   }
   case StreamKind::TextContent:
     return llvm::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 llvm::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));
 }

test/tools/obj2yaml/basic-minidump.yaml

Modules:
           File Date High:  0x3C3D3E3F
           File Date Low:   0x40414243
         CodeView Record: '44454647'
         Misc Record:     48494A4B
       - Base of Image:   0x4C4D4E4F50515253
         Size of Image:   0x54555657
         Module Name:     libb.so
         CodeView Record: 58595A5B
+  - Type:            ThreadList
+    Threads:         
+      - Thread Id:       0x5C5D5E5F
+        Priority Class:  0x60616263
+        Environment Block: 0x6465666768696A6B
+        Stack:           
+          Start of Memory Range: 0x6C6D6E6F70717273
+          Content:         7475767778797A7B
+        Context:         7C7D7E7F80818283
 ...
 
 # CHECK:      --- !minidump
 # CHECK-NEXT: Streams:         
 # CHECK-NEXT:   - Type:            SystemInfo
 # CHECK-NEXT:     Processor Arch:  ARM64
 # CHECK-NEXT:     Platform ID:     Linux
 # CHECK-NEXT:     CSD Version:     Linux 3.13.0-91-generic

 # CHECK-NEXT:           File Date High:  0x3C3D3E3F
 # CHECK-NEXT:           File Date Low:   0x40414243
 # CHECK-NEXT:         CodeView Record: '44454647'
 # CHECK-NEXT:         Misc Record:     48494A4B
 # CHECK-NEXT:       - Base of Image:   0x4C4D4E4F50515253
 # CHECK-NEXT:         Size of Image:   0x54555657
 # CHECK-NEXT:         Module Name:     libb.so
 # CHECK-NEXT:         CodeView Record: 58595A5B
+# CHECK-NEXT:   - Type:            ThreadList
+# CHECK-NEXT:     Threads:         
+# CHECK-NEXT:       - Thread Id:       0x5C5D5E5F
+# CHECK-NEXT:         Priority Class:  0x60616263
+# CHECK-NEXT:         Environment Block: 0x6465666768696A6B
+# CHECK-NEXT:         Stack:           
+# CHECK-NEXT:           Start of Memory Range: 0x6C6D6E6F70717273
+# CHECK-NEXT:           Content:         7475767778797A7B
+# CHECK-NEXT:         Context:         7C7D7E7F80818283
 # CHECK-NEXT: ...