Object/Minidump: Add support for the ThreadList stream

[labath]

Summary

The stream contains the list of threads belonging to the process
described by the minidump. Its structure is the same as the ModuleList
stream, and in fact, I have generalized the ModuleList reading code to
handle this stream too.

[clayborg]

LGTM, but since in llvm someone else should ok too.

[jhenderson]

Aside from a couple of nits, LGTM.

lib/Object/Minidump.cpp

69 ↗

(On Diff #196435)

Nit (was there before): to 8-byte -> to an 8-byte

unittests/Object/MinidumpTest.cpp

446 ↗

(On Diff #196435)

I missed this in the other tests, but this could be an ArrayRef<uint8_t> instead of a const std::vector<uint8_t> &. Feel free to leave it as is or to update it in an NFC throughout this test afterwards, if you would prefer to leave it to another patch.

[labath]

Thanks for the review.

unittests/Object/MinidumpTest.cpp

446 ↗

(On Diff #196435)

There's just one more test besides this one, so I'll update everything in this patch.

llvm/trunk/include/llvm/BinaryFormat/Minidump.h

 /// Specifies the location (and size) of various objects in the minidump file.
 /// The location is relative to the start of the file.
 struct LocationDescriptor {
   support::ulittle32_t DataSize;
   support::ulittle32_t RVA;
 };
 static_assert(sizeof(LocationDescriptor) == 8, "");
 
+/// Describes a single memory range (both its VM address and where to find it in
+/// the file) of the process from which this minidump file was generated.
+struct MemoryDescriptor {
+  support::ulittle64_t StartOfMemoryRange;
+  LocationDescriptor Memory;
+};
+static_assert(sizeof(MemoryDescriptor) == 16, "");
+
 /// Specifies the location and type of a single stream in the minidump file. The
 /// minidump stream directory is an array of entries of this type, with its size
 /// given by Header.NumberOfStreams.
 struct Directory {
   support::little_t<StreamType> Type;
   LocationDescriptor Location;
 };
 static_assert(sizeof(Directory) == 12, "");
struct Module {
   VSFixedFileInfo VersionInfo;
   LocationDescriptor CvRecord;
   LocationDescriptor MiscRecord;
   support::ulittle64_t Reserved0;
   support::ulittle64_t Reserved1;
 };
 static_assert(sizeof(Module) == 108, "");
 
+/// Describes a single thread in the minidump file. Part of the ThreadList
+/// stream.
+struct Thread {
+  support::ulittle32_t ThreadId;
+  support::ulittle32_t SuspendCount;
+  support::ulittle32_t PriorityClass;
+  support::ulittle32_t Priority;
+  support::ulittle64_t EnvironmentBlock;
+  MemoryDescriptor Stack;
+  LocationDescriptor Context;
+};
+static_assert(sizeof(Thread) == 48, "");
+
 } // namespace minidump
 
 template <> struct DenseMapInfo<minidump::StreamType> {
   static minidump::StreamType getEmptyKey() { return minidump::StreamType(-1); }
 
   static minidump::StreamType getTombstoneKey() {
     return minidump::StreamType(-2);
   }

llvm/trunk/include/llvm/Object/Minidump.h

Expected<const minidump::SystemInfo &> getSystemInfo() const {
     return getStream<minidump::SystemInfo>(minidump::StreamType::SystemInfo);
   }
 
   /// Returns the module list embedded in the ModuleList stream. An error is
   /// returned if the file does not contain this stream, or if the stream is
   /// not large enough to contain the number of modules declared in the stream
   /// header. The consistency of the Module entries themselves is not checked in
   /// any way.
-  Expected<ArrayRef<minidump::Module>> getModuleList() const;
+  Expected<ArrayRef<minidump::Module>> getModuleList() const {
+    return getListStream<minidump::Module>(minidump::StreamType::ModuleList);
+  }
+
+  /// Returns the thread list embedded in the ThreadList stream. An error is
+  /// returned if the file does not contain this stream, or if the stream is
+  /// not large enough to contain the number of threads declared in the stream
+  /// header. The consistency of the Thread entries themselves is not checked in
+  /// any way.
+  Expected<ArrayRef<minidump::Thread>> getThreadList() const {
+    return getListStream<minidump::Thread>(minidump::StreamType::ThreadList);
+  }
 
 private:
   static Error createError(StringRef Str) {
     return make_error<GenericBinaryError>(Str, object_error::parse_failed);
   }
 
   static Error createEOFError() {
     return make_error<GenericBinaryError>("Unexpected EOF",
ArrayRef<uint8_t> getData() const {
     return arrayRefFromStringRef(Data.getBuffer());
   }
 
   /// Return the stream of the given type, cast to the appropriate type. Checks
   /// that the stream is large enough to hold an object of this type.
   template <typename T>
   Expected<const T &> getStream(minidump::StreamType Stream) const;
 
+  /// Return the contents of a stream which contains a list of fixed-size items,
+  /// prefixed by the list size.
+  template <typename T>
+  Expected<ArrayRef<T>> getListStream(minidump::StreamType Stream) const;
+
   const minidump::Header &Header;
   ArrayRef<minidump::Directory> Streams;
   DenseMap<minidump::StreamType, std::size_t> StreamMap;
 };
 
 template <typename T>
 Expected<const T &> MinidumpFile::getStream(minidump::StreamType Stream) const {
   if (auto OptionalStream = getRawStream(Stream)) {

llvm/trunk/lib/Object/Minidump.cpp

Expected<std::string> MinidumpFile::getString(size_t Offset) const {
 
   std::string Result;
   if (!convertUTF16ToUTF8String(WStr, Result))
     return createError("String decoding failed");
 
   return Result;
 }
 
-Expected<ArrayRef<Module>> MinidumpFile::getModuleList() const {
-  auto OptionalStream = getRawStream(StreamType::ModuleList);
+template <typename T>
+Expected<ArrayRef<T>> MinidumpFile::getListStream(StreamType Stream) const {
+  auto OptionalStream = getRawStream(Stream);
   if (!OptionalStream)
     return createError("No such stream");
   auto ExpectedSize =
       getDataSliceAs<support::ulittle32_t>(*OptionalStream, 0, 1);
   if (!ExpectedSize)
     return ExpectedSize.takeError();
 
   size_t ListSize = ExpectedSize.get()[0];
 
   size_t ListOffset = 4;
-  // Some producers insert additional padding bytes to align the module list to
-  // 8-byte boundary. Check for that by comparing the module list size with the
-  // overall stream size.
-  if (ListOffset + sizeof(Module) * ListSize < OptionalStream->size())
+  // Some producers insert additional padding bytes to align the list to an
+  // 8-byte boundary. Check for that by comparing the list size with the overall
+  // stream size.
+  if (ListOffset + sizeof(T) * ListSize < OptionalStream->size())
     ListOffset = 8;
 
-  return getDataSliceAs<Module>(*OptionalStream, ListOffset, ListSize);
+  return getDataSliceAs<T>(*OptionalStream, ListOffset, ListSize);
 }
+template Expected<ArrayRef<Module>>
+    MinidumpFile::getListStream(StreamType) const;
+template Expected<ArrayRef<Thread>>
+    MinidumpFile::getListStream(StreamType) const;
 
 Expected<ArrayRef<uint8_t>>
 MinidumpFile::getDataSlice(ArrayRef<uint8_t> Data, size_t Offset, size_t Size) {
   // Check for overflow.
   if (Offset + Size < Offset || Offset + Size < Size ||
       Offset + Size > Data.size())
     return createEOFError();
   return Data.slice(Offset, Size);

llvm/trunk/unittests/Object/MinidumpTest.cpp

std::vector<uint8_t> PaddedModule{
       0, 0, 0, 0, 0, 0, 0, 0, // FileType, FileSubType
       0, 0, 0, 0, 0, 0, 0, 0, // FileDate
       1, 2, 3, 4, 5, 6, 7, 8, // CvRecord
       9, 0, 1, 2, 3, 4, 5, 6, // MiscRecord
       7, 8, 9, 0, 1, 2, 3, 4, // Reserved0
       5, 6, 7, 8, 9, 0, 1, 2, // Reserved1
   };
 
-  for (const std::vector<uint8_t> &Data : {OneModule, PaddedModule}) {
+  for (ArrayRef<uint8_t> Data : {OneModule, PaddedModule}) {
     auto ExpectedFile = create(Data);
     ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
     const MinidumpFile &File = **ExpectedFile;
     Expected<ArrayRef<Module>> ExpectedModule = File.getModuleList();
     ASSERT_THAT_EXPECTED(ExpectedModule, Succeeded());
     ASSERT_EQ(1u, ExpectedModule->size());
     const Module &M = ExpectedModule.get()[0];
     EXPECT_EQ(0x0807060504030201u, M.BaseOfImage);
std::vector<uint8_t> StreamTooShort{
       7, 8, 9, 0, 1, 2, 3, 4, // Reserved0
       5, 6, 7, 8, 9, 0, 1, 2, // Reserved1
   };
   auto ExpectedFile = create(StreamTooShort);
   ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
   const MinidumpFile &File = **ExpectedFile;
   EXPECT_THAT_EXPECTED(File.getModuleList(), Failed<BinaryError>());
 }
+
+TEST(MinidumpFile, getThreadList) {
+  std::vector<uint8_t> OneThread{
+      // Header
+      'M', 'D', 'M', 'P', 0x93, 0xa7, 0, 0, // Signature, Version
+      1, 0, 0, 0,                           // NumberOfStreams,
+      32, 0, 0, 0,                          // StreamDirectoryRVA
+      0, 1, 2, 3, 4, 5, 6, 7,               // Checksum, TimeDateStamp
+      0, 0, 0, 0, 0, 0, 0, 0,               // Flags
+                                            // Stream Directory
+      3, 0, 0, 0, 52, 0, 0, 0,              // Type, DataSize,
+      44, 0, 0, 0,                          // RVA
+      // ThreadList
+      1, 0, 0, 0,             // NumberOfThreads
+      1, 2, 3, 4, 5, 6, 7, 8, // ThreadId, SuspendCount
+      9, 0, 1, 2, 3, 4, 5, 6, // PriorityClass, Priority
+      7, 8, 9, 0, 1, 2, 3, 4, // EnvironmentBlock
+      // Stack
+      5, 6, 7, 8, 9, 0, 1, 2, // StartOfMemoryRange
+      3, 4, 5, 6, 7, 8, 9, 0, // DataSize, RVA
+      // Context
+      1, 2, 3, 4, 5, 6, 7, 8, // DataSize, RVA
+  };
+  // Same as before, but with a padded thread list.
+  std::vector<uint8_t> PaddedThread{
+      // Header
+      'M', 'D', 'M', 'P', 0x93, 0xa7, 0, 0, // Signature, Version
+      1, 0, 0, 0,                           // NumberOfStreams,
+      32, 0, 0, 0,                          // StreamDirectoryRVA
+      0, 1, 2, 3, 4, 5, 6, 7,               // Checksum, TimeDateStamp
+      0, 0, 0, 0, 0, 0, 0, 0,               // Flags
+                                            // Stream Directory
+      3, 0, 0, 0, 56, 0, 0, 0,              // Type, DataSize,
+      44, 0, 0, 0,                          // RVA
+      // ThreadList
+      1, 0, 0, 0,             // NumberOfThreads
+      0, 0, 0, 0,             // Padding
+      1, 2, 3, 4, 5, 6, 7, 8, // ThreadId, SuspendCount
+      9, 0, 1, 2, 3, 4, 5, 6, // PriorityClass, Priority
+      7, 8, 9, 0, 1, 2, 3, 4, // EnvironmentBlock
+      // Stack
+      5, 6, 7, 8, 9, 0, 1, 2, // StartOfMemoryRange
+      3, 4, 5, 6, 7, 8, 9, 0, // DataSize, RVA
+      // Context
+      1, 2, 3, 4, 5, 6, 7, 8, // DataSize, RVA
+  };
+
+  for (ArrayRef<uint8_t> Data : {OneThread, PaddedThread}) {
+    auto ExpectedFile = create(Data);
+    ASSERT_THAT_EXPECTED(ExpectedFile, Succeeded());
+    const MinidumpFile &File = **ExpectedFile;
+    Expected<ArrayRef<Thread>> ExpectedThread = File.getThreadList();
+    ASSERT_THAT_EXPECTED(ExpectedThread, Succeeded());
+    ASSERT_EQ(1u, ExpectedThread->size());
+    const Thread &T = ExpectedThread.get()[0];
+    EXPECT_EQ(0x04030201u, T.ThreadId);
+    EXPECT_EQ(0x08070605u, T.SuspendCount);
+    EXPECT_EQ(0x02010009u, T.PriorityClass);
+    EXPECT_EQ(0x06050403u, T.Priority);
+    EXPECT_EQ(0x0403020100090807u, T.EnvironmentBlock);
+    EXPECT_EQ(0x0201000908070605u, T.Stack.StartOfMemoryRange);
+    EXPECT_EQ(0x06050403u, T.Stack.Memory.DataSize);
+    EXPECT_EQ(0x00090807u, T.Stack.Memory.RVA);
+    EXPECT_EQ(0x04030201u, T.Context.DataSize);
+    EXPECT_EQ(0x08070605u, T.Context.RVA);
+  }
+}