Minidump parsing

[dvlahovski]

Summary

This is a work-in-progress minidump parsing code.
There are still some more structures/data streams that need to be added.
The aim ot this is to be used in the implementation of
a minidump debugging plugin that works on all platforms/architectures.
Currently we have a windows-only plugin that uses the WinAPI to parse
the dump files.
Also added unittests for the current functionality.

[labath]

The implementation looks nice and clean. I have only some stylistic comments giving it finishing touches..

source/Plugins/Process/minidump/CMakeLists.txt

6 ↗

(On Diff #68152)

Just remove the commented lines.

source/Plugins/Process/minidump/MinidumpParser.cpp

28 ↗

(On Diff #68152)

What's the anticipated usage of this function? I am wondering whether it shouldn't clear the cached data (m_header, m_directory_map) as well. Or maybe, since you already have a matching contructor, just remove the function and have the user construct a new object if he needs to (?)

33 ↗

(On Diff #68152)

This kind of comment should go into the header, as it speaks about the interface.

source/Plugins/Process/minidump/MinidumpParser.h

14 ↗

(On Diff #68152)

(nit) if you include <cstring>, it's not a C include :)
I'd put that under C++

45 ↗

(On Diff #68152)

Does the user need to know that you are returning an iterator? The map sounds like an implementation detail. If you don't have any usages for that in mind, it would be just cleaner to return the MinidumpLocationDescriptor (or maybe a reference to it) directly. Then you could remove the typedef above as well...

source/Plugins/Process/minidump/MinidumpTypes.cpp

83 ↗

(On Diff #68152)

Should we abort upon encountering the first invalid thread?

I am thinking of a situation where a corrupt file claims to have UINT32_MAX threads, and we end up spinning here for quite a long time...

source/Plugins/Process/minidump/MinidumpTypes.h

35 ↗

(On Diff #68152)

Let's change these into (anonymous) enums as well. We should avoid macros when possible.

120 ↗

(On Diff #68152)

This declares a variable. I assume you did not want that.

unittests/Process/minidump/MinidumpParserTest.cpp

10 ↗

(On Diff #68152)

I think this is only necessary when you are actually using threads.

51 ↗

(On Diff #68152)

Since it's the parser who handles setting the byte order and such, maybe we should just pass the data buffer to it, and let it construct the data extractor internally. Would that work?

[dvlahovski]

Resolving Pavel's remarks

[dvlahovski]

Fixing a little bug - should get the byteorder

after calling SignatureMatchAndSetByteOrder

[zturner]

source/Plugins/Process/minidump/MinidumpTypes.cpp

31–35 ↗

(On Diff #68180)

Why would this be true? Is there a minidump specification somewhere that says that both big endian and little endian are valid byte orderings? I would expect that being a Microsoft created format, it should always be little endian, and if there is a file in big endian we can consider it corrupt.

[dvlahovski]

source/Plugins/Process/minidump/MinidumpTypes.cpp

31–35 ↗

(On Diff #68180)

I didn't find anything in the MS documentation about the minidump's endianess.
I am doing this because breakpad does this too: https://chromium.googlesource.com/breakpad/breakpad/+/master/src/processor/minidump.cc#4384

[amccarth]

Are we putting this code in the right place? I wouldn't expect minidump parsing to fall under Plugins/Process.

I assume the eventual intent is to turn the Windows-specific code into a user of your new code? I look forward to seeing that happen.

source/Plugins/Process/minidump/MinidumpTypes.cpp

13 ↗

(On Diff #68180)

Include MinidumpTypes.h first in MinidumpTypes.cpp. This helps ensure that headers can stand alone.

source/Plugins/Process/minidump/MinidumpTypes.h

14 ↗

(On Diff #68180)

Maybe I'm missing it, but it doesn't seem like this header is using anything from <cstring> (which should be under C++ includes).

40 ↗

(On Diff #68180)

// Reference:  https://msdn.microsoft.com/en-us/library/windows/desktop/ms680394.aspx

257 ↗

(On Diff #68180)

Why do the arithmetic and static_assert? Why not use sizeof(MinidumpSystemInfo)?

[zturner]

LLVM does have something similar to DataExtractor, but unfortunately it's not present in the correct library for you to easily be able to reuse it. I actually own the code in question, so I'm willing to fix that for you if you're interested, but at the same time the code is very simple. LLVM has some endian-aware data types that are very convenient to work with and mostly eliminate the need to worry about endianness while parsing, which is what DataExtractor mostly does for you. To use LLVM's types, for example, you would change this:

struct MinidumpHeader
{
    uint32_t signature;
    uint32_t version;
    uint32_t streams_count;
    RVA stream_directory_rva; // offset of the stream directory
    uint32_t checksum;
    uint32_t time_date_stamp; // time_t format
    uint64_t flags;

    static bool
    SignatureMatchAndSetByteOrder(DataExtractor &data, lldb::offset_t *offset);

    static llvm::Optional<MinidumpHeader>
    Parse(const DataExtractor &data, lldb::offset_t *offset);
};

to this:

struct MinidumpHeader
{
    support::ulittle32_t signature;
    support::ulittle32_t version;
    support::ulittle32_t streams_count;
    support::ulittle32_t stream_directory_rva; // offset of the stream directory
    support::ulittle32_t checksum;
    support::ulittle32_t time_date_stamp; // time_t format
    support::ulittle64_t flags;
};

All you have to do now is reinterpret_cast the buffer to a MiniDumpHeader* and you're good to go. So pretty much the entirety of the DataExtractor class boils down to a single template function:

template<typename T>
Error consumeObject(ArrayRef<uint8_t> &Buffer, const T *&Object) {
  if (Buffer.size() < sizeof(T))
    return make_error<StringError>("Insufficient buffer!");
  Object = reinterpret_cast<const T*>(Buffer.data());
  Buffer = Buffer.drop_front(sizeof(T));
  return Error::success();
}

For starters, this is nice because it means you're not copying memory around unnecessarily. You're just pointing to the memory that's already there. With DataExtractor you are always copying bytes around. Dump files can be large (even minidumps!) and copying all this memory around is inefficient.

It also makes the syntax cleaner. You have to call different functions on DataExtractor depending on what you want to extract. GetU8 or GetU16 for example. This one function works with almost everything. A few simple template specializations and overloads can make it even more powerful. For example:

Error consumeObject(ArrayRef<uint8_t> &Buffer, StringRef &ZeroString) {
   ZeroString = StringRef(reinterpret_cast<const char *>(Buffer.front()));
   Buffer = Buffer.drop_front(ZeroString.size() + 1);
   return Error::success();
}

I have some more comments on the CL, but I have to run to a meeting, so I will be back later.

[zturner]

source/Plugins/Process/minidump/MinidumpParser.cpp

29 ↗

(On Diff #68180)

I asked some people familiar with breakpad and windows history, and the answer I got was that while minidump may have support big endian prior to windows 2000 when it supported PPC and MIPS, but probably not anymore.

At this point we have full control over the minidump pipeline. If we want to generate them from within LLDB, we can write them using little endian. And if we want to read them, we can assume they are not from a file prior to windows 2000. I think it's safe to assume little endian unless we have strong evidence that we need to parse a big endian minidump.

35 ↗

(On Diff #68180)

Note that this will make a copy of the data. Based on my previous email, this could be written as follows:

const MiniDumpDirectory *directory = nullptr;

for (uint32_t i=0; i < m_header->streams_count; ++i) {
  if (auto EC = consumeObject(data, directory))
    return EC;
  m_directory_map[directory.stream_type = directory->location;
}

No copying is involved here. You would need to make a few changes to do this but I think it is worth it. Same concept applies throughout the rest of this file, so I won't mention it again.

source/Plugins/Process/minidump/MinidumpParser.h

13–25 ↗

(On Diff #68180)

Please include files in the following order:

1. Files in the same directory

2. LLDB includes

3. LLVM includes

4. C and C++ system includes

Although this isn't consistent with the rest of the codebase, it was recently agreed that this is what we want to move towards, so all new code should follow this pattern.

61 ↗

(On Diff #68180)

Please use llvm::DenseMap. std::unordered_map should probably not be used for anything ever.

67 ↗

(On Diff #68180)

Newline here.

source/Plugins/Process/minidump/MinidumpTypes.h

40 ↗

(On Diff #68180)

In LLVM where we parse PDB and CodeView debug info types, we have adopted the convention that these are all enum classes, and we continue to use LLVM naming style instead of using Microsoft all caps style. So I would write this as:

enum class MiniDumpStreamType : uint32_t {
  Unused = 0,
  Reserved0 = 1,
  Reserved1 = 2,
  ThreadList = 3,
  ...
};

The : uint32_t is important since enums are signed by default on Microsoft compilers.

85 ↗

(On Diff #68180)

Same goes for these, as well as a few more enums later on. I would make these all enum classes and name them using the LLVM naming conventions.

147 ↗

(On Diff #68180)

Enum classes don't play nicely with flags, but LLVM has a file called llvm/ADT/BitmaskEnum.h which improves this significantly. So these can also be an enum class, just use the proper macro from that file so that bitwise operations become possible.

151 ↗

(On Diff #68180)

As mentioned in my previous response, all these could be come LLVM endian aware types from llvm/Support/Endian.h' which would allow you to reinterpret_cast` straight from the underlying buffer.

165–166 ↗

(On Diff #68180)

The computation here seems unnecessary to me. How about just static_assert(sizeof(MinidumpHeader) == 32);

[dvlahovski]

Update of the code, regarding the remarks

of zturner and amccarth.

[dvlahovski]

source/Plugins/Process/minidump/MinidumpTypes.h

258 ↗

(On Diff #68557)

The idea of this is to be sure that the compiler didn't align stuff wrongly/not in the way we expect.

[dvlahovski]

In D23545#516808, @amccarth wrote:

Are we putting this code in the right place? I wouldn't expect minidump parsing to fall under Plugins/Process.

I assume the eventual intent is to turn the Windows-specific code into a user of your new code? I look forward to seeing that happen.

My idea was that the new plugin will live in Plugins/Process/minidump.
Do you have a suggestion where the parsing code to be, if not in the same directory?

[zturner]

source/Plugins/Process/minidump/MinidumpParser.h

67 ↗

(On Diff #68557)

Can this be llvm::DenseMap<MinidumpStreamType, MinidumpLocationDescriptor>?

No point erasing the type information of the enum.

source/Plugins/Process/minidump/MinidumpTypes.cpp

21 ↗

(On Diff #68557)

I think these can all just return the pointer instead of llvm::Optional<>. return nullptr to indicate failure. Optionally, make the signature be something like Error MinidumpHeader::Parse(llvm::ArrayRef<uint8_t> &data, const MinidumpHeader *&Header) which would allow you to propagate the error up (if you wanted to).

At the very least though, there's no point using llvm::Optional<> if nullptr can be used to indicate failure.

30 ↗

(On Diff #68557)

Where does the 0xFFFF come from?

source/Plugins/Process/minidump/MinidumpTypes.h

133 ↗

(On Diff #68557)

Should this be enum class?

[zturner]

source/Plugins/Process/minidump/MinidumpTypes.h

259 ↗

(On Diff #68180)

I think the static_assert is a good idea. Since this corresponds to an on disk format where the size of the structure is fixed and known, the static assert is a good idea. But the calculation is unnecessary I think. It's more readable if someone can just look at it and say "ok it has to be 32 bytes" or whatever, rather than doing this math in their head.

[dvlahovski]

source/Plugins/Process/minidump/MinidumpParser.h

67 ↗

(On Diff #68557)

If I use MinidumpStreamType as the keys type then I think I have to specify the getEmptyKey() and getTombstoneKey() functions via DenseMapInfo.
And in the "unsigned" template specialisation of DenseMapInfo:

// Provide DenseMapInfo for unsigned ints.
template<> struct DenseMapInfo<unsigned> {
  static inline unsigned getEmptyKey() { return ~0U; }
  static inline unsigned getTombstoneKey() { return ~0U - 1; }
  static unsigned getHashValue(const unsigned& Val) { return Val * 37U; }
  static bool isEqual(const unsigned& LHS, const unsigned& RHS) {
    return LHS == RHS;
  }
};

So I should probably add there "special" values in the enum as well in order for it to work?

source/Plugins/Process/minidump/MinidumpTypes.h

133 ↗

(On Diff #68557)

Yes, forgot to change it ...

[dvlahovski]

source/Plugins/Process/minidump/MinidumpTypes.cpp

21 ↗

(On Diff #68557)

Yes, fair point. Now that I'm returning pointers, nullptr is better for indicating failure.

30 ↗

(On Diff #68557)

There is a comment in the header, but probably it should be here. The higher 16 bit of the version field are implementation specific.
The lower 16 bits are the version number (which is always the same constant number)

[zturner]

source/Plugins/Process/minidump/MinidumpParser.h

67 ↗

(On Diff #68557)

That's unfortunate, but it looks like you're right. It's probably not worth going to that much effort. It could probably be done by partially specializing DenseMapInfo for all enums, but I don't think it's worth it. So I suppose it's fine to leave as a uint32_t.

[dvlahovski]

Also FYI I copied the implementation of consumeObject to my header.

[amccarth]

In D23545#519675, @dvlahovski wrote:

In D23545#516808, @amccarth wrote:

Are we putting this code in the right place? I wouldn't expect minidump parsing to fall under Plugins/Process.

I assume the eventual intent is to turn the Windows-specific code into a user of your new code? I look forward to seeing that happen.

My idea was that the new plugin will live in Plugins/Process/minidump.
Do you have a suggestion where the parsing code to be, if not in the same directory?

The parsing code will end up being used by multiple plugins--the new one you're building for Linux and the existing one that's Windows-specific.

What I thought would happen would be that you'd write the parsing code first, hook up the Windows-minidump plugin to use it (since the Windows-minidump plugin tests would help validate that your parsing is correct/complete) and then either add a new plugin for non-Windows. That would argue for the minidump parsing to be in a common location that could be used by both plugins. I don't have a good idea of where that would go.

Another approach is to make the Windows plugin platform agnostic once you replace the limited use of the minidump APIs with your own parsing code.

Food for thought. No need to hold up this patch for that. The code can be moved later if appropriate.

source/Plugins/Process/minidump/MinidumpTypes.cpp

22 ↗

(On Diff #68557)

I find it amusing that all these Parse methods are in MinidumpTypes.cpp rather than MinidumpParser.cpp. Just an observation--not a request to change it.

source/Plugins/Process/minidump/MinidumpTypes.h

133 ↗

(On Diff #68557)

These look like individual bits that will be bitwise-ORed together, which is trickier to do with an enum class.

But you may still want to specify the underlying type, like uint32_t.

258 ↗

(On Diff #68557)

OK.

260 ↗

(On Diff #68557)

I'll concede that the static_assert is useful. Given that, showing the arithmetic explicitly will be helpful when one of these assertions trips, because you'll be able to see how it's supposed to correspond to the struct.

[zturner]

source/Plugins/Process/minidump/MinidumpTypes.h

133 ↗

(On Diff #68557)

Yea, see my earlier comment. This enum uses LLVM_MARK_AS_BITMASK_ENUM() which makes this possible.

[dvlahovski]

source/Plugins/Process/minidump/MinidumpTypes.h

260 ↗

(On Diff #68557)

Yes that was my inital insentive to write explicitly the arithmetic

[labath]

Do you have a suggestion where the parsing code to be, if not in the same directory?

The parsing code will end up being used by multiple plugins--the new one you're building for Linux and the existing one that's Windows-specific.

I was hoping that we could avoid having a separate plugin for each OS. ProcessElfCore already handles linux and freebsd core files. It should be even simpler for minidumps, as the format there should be more similar. If that does not play out then we will need to move the generic code to a separate place, but I am hoping we can keep it in one plugin (maybe we can have a small class inside the plugin which abstracts any os-specific details we encounter).

What I thought would happen would be that you'd write the parsing code first, hook up the Windows-minidump plugin to use it (since the Windows-minidump plugin tests would help validate that your parsing is correct/complete) and then either add a new plugin for non-Windows. That would argue for the minidump parsing to be in a common location that could be used by both plugins. I don't have a good idea of where that would go.

Another approach is to make the Windows plugin platform agnostic once you replace the limited use of the minidump APIs with your own parsing code.

Food for thought. No need to hold up this patch for that. The code can be moved later if appropriate.

We'll see how it goes...

source/Plugins/Process/minidump/MinidumpParser.cpp

22 ↗

(On Diff #68557)

You should check whether the data buffer contains more than sizeof(MinidumpHeader) bytes. Or you can just use m_data_sp->GetByteSize() for size, and let the parse function deal with that.

31 ↗

(On Diff #68557)

Same thing. How do you know this memory exists? Is that checked somewhere?

60 ↗

(On Diff #68557)

Suggestion: auto iter = ?

source/Plugins/Process/minidump/MinidumpTypes.h

260 ↗

(On Diff #68557)

What I did not like about the original approach is that it declared a new global variable (in a header, so it is visible to everyone), just to store the temporary result. I think we should avoid that. I don't really care whether you write sizeof(FOO) = 47 or sizeof(FOO) = 4*10+4+3

[dvlahovski]

Adding sanity checks whether the data buffer

contains the amound of bytes that we want to read.
All of the functions that were returning llvm::Optional<const something *>
now return just const something *
and indicate for failure with the return of nullptr.

[dvlahovski]

I'm thinking of doing the following approach regarding the plugin implementation:
Start writing a new plugin "from scratch", which will be inspired strongly by ProcessWinMiniDump and also borrowing stuff from ProcessElfCore.
Also my plan is to make a single cross-platform Minidump plugin. At least for now I think that there aren't so many differences between Minidumps
generated on different platforms. (If the code gets messy probably a separate plugin for each platform is better.)
Also I think that I could reuse the Windows Minidump tests by pointing them to the new plugin and see if we
have at least the same (working) functionality.

[labath]

Looks good as far as I am concerned. You might want to add a test or two that makes sure we handle invalid data reasonably. E.g., load only the first X kb of the minidump (so that the thread list is not present in the loaded block), and make sure getting a thread list fails (and does not crash).

source/Plugins/Process/minidump/MinidumpParser.cpp

40 ↗

(On Diff #68670)

Please put this before the construction of the ArrayRef - so we don't create a dangling object for no reason.

[dvlahovski]

Move creation of ArrayRef after sanity check

Add a test that checks that the thread list is not present in a
truncated minidump file

[zturner]

Were you still going to change all the Optionals to raw pointers (or even better, llvm::Errors)

source/Plugins/Process/minidump/MinidumpParser.cpp

21 ↗

(On Diff #68690)

I'm not crazy about the idea of allowing the constructor to fail and then checking IsValidData() after you construct it. One way LLVM solves this is by having a static function that returns Expected<T>. You would use it like this:

Expected<MinidumpParser> MinidumpParser::create(const lldb::DataBufferSP &data_buf_sp) {
  if (data_buf_sp->GetByteSize() < sizeof(MinidumpHeader))
    return make_error<StringError>("Insufficient buffer!");

  MinidumpHeader *header = nullptr;
  if (auto EC = MinidumpHeader::Parse(header_data, header))
    return std::move(EC);

   ...

   return MinidumpParser(header, directory_map);
}

auto Parser = MinidumpParser::create(buffer);
if (!Parser) {
  // Handle the error
}

This way it's impossible to create a MinidumpParser that is invalid.

Up to you whether you want to do this, but I think it is a very good (and safe) pattern that I'd love to see LLDB start adopting more often.

[dvlahovski]

Changed the constructing pattern of MinidumpParser

Now there is a static Create method that returns
and llvm::Optional MinidumpParser.

[dvlahovski]

I changed all of the llvm::Optional<const type *> returning functions to return only const type *
and signalize for 'failure' by returning a nullptr. In the cases where I return objects (e.g. vector of threads)
I'm still using the llvm::Optional pattern.
I also think that using llvm::Error is a good idea, but I think that it'll be difficult, because of
collisions with the lldb::Error, and also at some point I have to convert objects from one type to the other.

So that's why I stick to the llvm::Optional.
I also used it on the creation of MinidumpParser (following somewhat the pattern that you proposed)

[labath]

Looks fine to me. Adrian, Zachary, any more thoughts here?

source/Plugins/Process/minidump/MinidumpParser.h

42 ↗

(On Diff #69254)

If you have a Create function, the constructor should probably be private (also, explicit is not necessary anymore).

[dvlahovski]

Making MinidumpParser constuctor private

[zturner]

source/Plugins/Process/minidump/MinidumpParser.cpp

60 ↗

(On Diff #69340)

You can just write return parser here. It's implicitly convertible to an llvm::Optional<>.

65 ↗

(On Diff #69340)

This isn't really a performance critical class, so it doesn't matter too much, but you could std::move(directory_map) to avoid the copy.

[amccarth]

LGTM.

[labath]

lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp

146

You have a "enumeration not handled in a switch" warning here. Could you do something about that?

[dvlahovski]

lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp

146

Yes, I fixed it locally. Will submit it with the next CL. :)

lldb/trunk/cmake/LLDBDependencies.cmake

set( LLDB_USED_LIBS
   lldbPluginObjectFilePECOFF
   lldbPluginOSGo
   lldbPluginOSPython
   lldbPluginMemoryHistoryASan
   lldbPluginInstrumentationRuntimeAddressSanitizer
   lldbPluginInstrumentationRuntimeThreadSanitizer
   lldbPluginSystemRuntimeMacOSX
   lldbPluginProcessElfCore
+  lldbPluginProcessMinidump
   lldbPluginJITLoaderGDB
   lldbPluginExpressionParserClang
   lldbPluginExpressionParserGo
   )
 
 # Windows-only libraries
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   list(APPEND LLDB_USED_LIBS

lldb/trunk/source/Plugins/Process/CMakeLists.txt

elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_subdirectory(Windows/Common)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()
 add_subdirectory(gdb-remote)
 add_subdirectory(Utility)
 add_subdirectory(mach-core)
 add_subdirectory(elf-core)
+add_subdirectory(minidump)

lldb/trunk/source/Plugins/Process/minidump/CMakeLists.txt

+include_directories(../Utility)
+
+add_lldb_library(lldbPluginProcessMinidump
+  MinidumpTypes.cpp
+  MinidumpParser.cpp
+  )

lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.h

+//===-- MinidumpParser.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_MinidumpParser_h_
+#define liblldb_MinidumpParser_h_
+
+// Project includes
+#include "MinidumpTypes.h"
+
+// Other libraries and framework includes
+#include "lldb/Core/ArchSpec.h"
+#include "lldb/Core/DataBuffer.h"
+#include "lldb/Core/Error.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
+
+// C includes
+
+// C++ includes
+#include <cstring>
+#include <unordered_map>
+
+
+namespace lldb_private
+{
+
+namespace minidump
+{
+
+class MinidumpParser
+{
+public:
+    static llvm::Optional<MinidumpParser>
+    Create(const lldb::DataBufferSP &data_buf_sp);
+
+    lldb::offset_t
+    GetByteSize();
+
+    llvm::Optional<llvm::ArrayRef<uint8_t>>
+    GetStream(MinidumpStreamType stream_type);
+
+    llvm::Optional<std::vector<const MinidumpThread *>>
+    GetThreads();
+
+    const MinidumpSystemInfo *
+    GetSystemInfo();
+
+    ArchSpec
+    GetArchitecture();
+
+    const MinidumpMiscInfo *
+    GetMiscInfo();
+
+private:
+    lldb::DataBufferSP m_data_sp;
+    const MinidumpHeader *m_header;
+    llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> m_directory_map;
+
+    MinidumpParser(const lldb::DataBufferSP &data_buf_sp, const MinidumpHeader *header,
+                   const llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> &directory_map);
+};
+
+} // namespace minidump
+} // namespace lldb_private
+#endif // liblldb_MinidumpParser_h_

lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp

+//===-- MinidumpParser.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Project includes
+#include "MinidumpParser.h"
+
+// Other libraries and framework includes
+// C includes
+// C++ includes
+
+using namespace lldb_private;
+using namespace minidump;
+
+llvm::Optional<MinidumpParser>
+MinidumpParser::Create(const lldb::DataBufferSP &data_buf_sp)
+{
+    if (data_buf_sp->GetByteSize() < sizeof(MinidumpHeader))
+    {
+        return llvm::None;
+    }
+
+    llvm::ArrayRef<uint8_t> header_data(data_buf_sp->GetBytes(), sizeof(MinidumpHeader));
+    const MinidumpHeader *header = MinidumpHeader::Parse(header_data);
+
+    if (header == nullptr)
+    {
+        return llvm::None;
+    }
+
+    lldb::offset_t directory_list_offset = header->stream_directory_rva;
+    // check if there is enough data for the parsing of the directory list
+    if ((directory_list_offset + sizeof(MinidumpDirectory) * header->streams_count) > data_buf_sp->GetByteSize())
+    {
+        return llvm::None;
+    }
+
+    const MinidumpDirectory *directory = nullptr;
+    Error error;
+    llvm::ArrayRef<uint8_t> directory_data(data_buf_sp->GetBytes() + directory_list_offset,
+                                           sizeof(MinidumpDirectory) * header->streams_count);
+    llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> directory_map;
+
+    for (uint32_t i = 0; i < header->streams_count; ++i)
+    {
+        error = consumeObject(directory_data, directory);
+        if (error.Fail())
+        {
+            return llvm::None;
+        }
+        directory_map[static_cast<const uint32_t>(directory->stream_type)] = directory->location;
+    }
+
+    MinidumpParser parser(data_buf_sp, header, directory_map);
+    return llvm::Optional<MinidumpParser>(parser);
+}
+
+MinidumpParser::MinidumpParser(const lldb::DataBufferSP &data_buf_sp, const MinidumpHeader *header,
+                               const llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> &directory_map)
+    : m_data_sp(data_buf_sp), m_header(header), m_directory_map(directory_map)
+{
+}
+
+lldb::offset_t
+MinidumpParser::GetByteSize()
+{
+    return m_data_sp->GetByteSize();
+}
+
+llvm::Optional<llvm::ArrayRef<uint8_t>>
+MinidumpParser::GetStream(MinidumpStreamType stream_type)
+{
+    auto iter = m_directory_map.find(static_cast<uint32_t>(stream_type));
+    if (iter == m_directory_map.end())
+        return llvm::None;
+
+    // check if there is enough data
+    if (iter->second.rva + iter->second.data_size > m_data_sp->GetByteSize())
+        return llvm::None;
+
+    llvm::ArrayRef<uint8_t> arr_ref(m_data_sp->GetBytes() + iter->second.rva, iter->second.data_size);
+    return llvm::Optional<llvm::ArrayRef<uint8_t>>(arr_ref);
+}
+
+llvm::Optional<std::vector<const MinidumpThread *>>
+MinidumpParser::GetThreads()
+{
+    llvm::Optional<llvm::ArrayRef<uint8_t>> data = GetStream(MinidumpStreamType::ThreadList);
+
+    if (!data)
+        return llvm::None;
+
+    return MinidumpThread::ParseThreadList(data.getValue());
+}
+
+const MinidumpSystemInfo *
+MinidumpParser::GetSystemInfo()
+{
+    llvm::Optional<llvm::ArrayRef<uint8_t>> data = GetStream(MinidumpStreamType::SystemInfo);
+
+    if (!data)
+        return nullptr;
+
+    return MinidumpSystemInfo::Parse(data.getValue());
+}
+
+ArchSpec
+MinidumpParser::GetArchitecture()
+{
+    ArchSpec arch_spec;
+    arch_spec.GetTriple().setOS(llvm::Triple::OSType::UnknownOS);
+    arch_spec.GetTriple().setVendor(llvm::Triple::VendorType::UnknownVendor);
+    arch_spec.GetTriple().setArch(llvm::Triple::ArchType::UnknownArch);
+
+    // TODO should we add the OS type here, or somewhere else ?
+
+    const MinidumpSystemInfo *system_info = GetSystemInfo();
+
+    if (!system_info)
+        return arch_spec;
+
+    // TODO what to do about big endiand flavors of arm ?
+    // TODO set the arm subarch stuff if the minidump has info about it
+
+    const MinidumpCPUArchitecture arch =
+        static_cast<const MinidumpCPUArchitecture>(static_cast<const uint32_t>(system_info->processor_arch));
+    switch (arch)
+    {
+        case MinidumpCPUArchitecture::X86:
+            arch_spec.GetTriple().setArch(llvm::Triple::ArchType::x86);
+            break;
+        case MinidumpCPUArchitecture::AMD64:
+            arch_spec.GetTriple().setArch(llvm::Triple::ArchType::x86_64);
+            break;
+        case MinidumpCPUArchitecture::ARM:
+            arch_spec.GetTriple().setArch(llvm::Triple::ArchType::arm);
+            break;
+        case MinidumpCPUArchitecture::ARM64:
+            arch_spec.GetTriple().setArch(llvm::Triple::ArchType::aarch64);
+            break;
+    }
+
+    return arch_spec;
+}
+
+const MinidumpMiscInfo *
+MinidumpParser::GetMiscInfo()
+{
+    llvm::Optional<llvm::ArrayRef<uint8_t>> data = GetStream(MinidumpStreamType::MiscInfo);
+
+    if (!data)
+        return nullptr;
+
+    return MinidumpMiscInfo::Parse(data.getValue());
+}

lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.h

+//===-- MinidumpTypes.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_MinidumpTypes_h_
+#define liblldb_MinidumpTypes_h_
+
+// Project includes
+
+// Other libraries and framework includes
+#include "lldb/Core/Error.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/Endian.h"
+
+// C includes
+// C++ includes
+
+// Reference:
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms679293(v=vs.85).aspx
+// https://chromium.googlesource.com/breakpad/breakpad/
+
+namespace lldb_private
+{
+
+namespace minidump
+{
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+enum class MinidumpHeaderConstants : uint32_t
+{
+    Signature = 0x504d444d, // 'PMDM'
+    Version = 0x0000a793,   // 42899
+    LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ Signature)
+
+};
+
+// Reference:  https://msdn.microsoft.com/en-us/library/windows/desktop/ms680394.aspx
+enum class MinidumpStreamType : uint32_t
+{
+    Unused = 0,
+    Reserved0 = 1,
+    Reserved1 = 2,
+    ThreadList = 3,
+    ModuleList = 4,
+    MemoryList = 5,
+    Exception = 6,
+    SystemInfo = 7,
+    ThreadExList = 8,
+    Memory64List = 9,
+    CommentA = 10,
+    CommentW = 11,
+    HandleData = 12,
+    FunctionTable = 13,
+    UnloadedModuleList = 14,
+    MiscInfo = 15,
+    MemoryInfoList = 16,
+    ThreadInfoList = 17,
+    HandleOperationList = 18,
+    Token = 19,
+    JavascriptData = 20,
+    SystemMemoryInfo = 21,
+    ProcessVMCounters = 22,
+    LastReserved = 0x0000ffff,
+
+    /* Breakpad extension types.  0x4767 = "Gg" */
+    BreakpadInfo = 0x47670001,
+    AssertionInfo = 0x47670002,
+    /* These are additional minidump stream values which are specific to
+     * the linux breakpad implementation.   */
+    LinuxCPUInfo = 0x47670003,    /* /proc/cpuinfo      */
+    LinuxProcStatus = 0x47670004, /* /proc/$x/status    */
+    LinuxLSBRelease = 0x47670005, /* /etc/lsb-release   */
+    LinuxCMDLine = 0x47670006,    /* /proc/$x/cmdline   */
+    LinuxEnviron = 0x47670007,    /* /proc/$x/environ   */
+    LinuxAuxv = 0x47670008,       /* /proc/$x/auxv      */
+    LinuxMaps = 0x47670009,       /* /proc/$x/maps      */
+    LinuxDSODebug = 0x4767000A
+};
+
+// for MinidumpSystemInfo.processor_arch
+enum class MinidumpCPUArchitecture : uint16_t
+{
+    X86 = 0,         /* PROCESSOR_ARCHITECTURE_INTEL */
+    MIPS = 1,        /* PROCESSOR_ARCHITECTURE_MIPS */
+    Alpha = 2,       /* PROCESSOR_ARCHITECTURE_ALPHA */
+    PPC = 3,         /* PROCESSOR_ARCHITECTURE_PPC */
+    SHX = 4,         /* PROCESSOR_ARCHITECTURE_SHX (Super-H) */
+    ARM = 5,         /* PROCESSOR_ARCHITECTURE_ARM */
+    IA64 = 6,        /* PROCESSOR_ARCHITECTURE_IA64 */
+    Alpha64 = 7,     /* PROCESSOR_ARCHITECTURE_ALPHA64 */
+    MSIL = 8,        /* PROCESSOR_ARCHITECTURE_MSIL
+                                                * (Microsoft Intermediate Language) */
+    AMD64 = 9,       /* PROCESSOR_ARCHITECTURE_AMD64 */
+    X86Win64 = 10,   /* PROCESSOR_ARCHITECTURE_IA32_ON_WIN64 (WoW64) */
+    SPARC = 0x8001,  /* Breakpad-defined value for SPARC */
+    PPC64 = 0x8002,  /* Breakpad-defined value for PPC64 */
+    ARM64 = 0x8003,  /* Breakpad-defined value for ARM64 */
+    MIPS64 = 0x8004, /* Breakpad-defined value for MIPS64 */
+    Unknown = 0xffff /* PROCESSOR_ARCHITECTURE_UNKNOWN */
+};
+
+// for MinidumpSystemInfo.platform_id
+enum class MinidumpOSPlatform : uint32_t
+{
+    Win32S = 0,       /* VER_PLATFORM_WIN32s (Windows 3.1) */
+    Win32Windows = 1, /* VER_PLATFORM_WIN32_WINDOWS (Windows 95-98-Me) */
+    Win32NT = 2,      /* VER_PLATFORM_WIN32_NT (Windows NT, 2000+) */
+    Win32CE = 3,      /* VER_PLATFORM_WIN32_CE, VER_PLATFORM_WIN32_HH
+                                    * (Windows CE, Windows Mobile, "Handheld") */
+
+    /* The following values are Breakpad-defined. */
+    Unix = 0x8000,    /* Generic Unix-ish */
+    MacOSX = 0x8101,  /* Mac OS X/Darwin */
+    IOS = 0x8102,     /* iOS */
+    Linux = 0x8201,   /* Linux */
+    Solaris = 0x8202, /* Solaris */
+    Android = 0x8203, /* Android */
+    PS3 = 0x8204,     /* PS3 */
+    NaCl = 0x8205     /* Native Client (NaCl) */
+};
+
+// For MinidumpCPUInfo.arm_cpu_info.elf_hwcaps.
+// This matches the Linux kernel definitions from <asm/hwcaps.h>
+enum class MinidumpPCPUInformationARMElfHwCaps : uint32_t
+{
+    SWP = (1 << 0),
+    Half = (1 << 1),
+    Thumb = (1 << 2),
+    _26BIT = (1 << 3),
+    FastMult = (1 << 4),
+    FPA = (1 << 5),
+    VFP = (1 << 6),
+    EDSP = (1 << 7),
+    Java = (1 << 8),
+    IWMMXT = (1 << 9),
+    Crunch = (1 << 10),
+    ThumbEE = (1 << 11),
+    Neon = (1 << 12),
+    VFPv3 = (1 << 13),
+    VFPv3D16 = (1 << 14),
+    TLS = (1 << 15),
+    VFPv4 = (1 << 16),
+    IDIVA = (1 << 17),
+    IDIVT = (1 << 18),
+    LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ IDIVT)
+};
+
+template <typename T>
+Error
+consumeObject(llvm::ArrayRef<uint8_t> &Buffer, const T *&Object)
+{
+    Error error;
+    if (Buffer.size() < sizeof(T))
+    {
+        error.SetErrorString("Insufficient buffer!");
+        return error;
+    }
+
+    Object = reinterpret_cast<const T *>(Buffer.data());
+    Buffer = Buffer.drop_front(sizeof(T));
+    return error;
+}
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680378(v=vs.85).aspx
+struct MinidumpHeader
+{
+    llvm::support::ulittle32_t signature;
+    llvm::support::ulittle32_t version; // The high 16 bits of version field are implementation specific
+    llvm::support::ulittle32_t streams_count;
+    llvm::support::ulittle32_t stream_directory_rva; // offset of the stream directory
+    llvm::support::ulittle32_t checksum;
+    llvm::support::ulittle32_t time_date_stamp; // time_t format
+    llvm::support::ulittle64_t flags;
+
+    static const MinidumpHeader *
+    Parse(llvm::ArrayRef<uint8_t> &data);
+};
+static_assert(sizeof(MinidumpHeader) == 32, "sizeof MinidumpHeader is not correct!");
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680383.aspx
+struct MinidumpLocationDescriptor
+{
+    llvm::support::ulittle32_t data_size;
+    llvm::support::ulittle32_t rva;
+};
+static_assert(sizeof(MinidumpLocationDescriptor) == 8, "sizeof MinidumpLocationDescriptor is not correct!");
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680384(v=vs.85).aspx
+struct MinidumpMemoryDescriptor
+{
+    llvm::support::ulittle64_t start_of_memory_range;
+    MinidumpLocationDescriptor memory;
+};
+static_assert(sizeof(MinidumpMemoryDescriptor) == 16, "sizeof MinidumpMemoryDescriptor is not correct!");
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680365.aspx
+struct MinidumpDirectory
+{
+    llvm::support::ulittle32_t stream_type;
+    MinidumpLocationDescriptor location;
+};
+static_assert(sizeof(MinidumpDirectory) == 12, "sizeof MinidumpDirectory is not correct!");
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680517(v=vs.85).aspx
+struct MinidumpThread
+{
+    llvm::support::ulittle32_t thread_id;
+    llvm::support::ulittle32_t suspend_count;
+    llvm::support::ulittle32_t priority_class;
+    llvm::support::ulittle32_t priority;
+    llvm::support::ulittle64_t teb;
+    MinidumpMemoryDescriptor stack;
+    MinidumpLocationDescriptor thread_context;
+
+    static const MinidumpThread *
+    Parse(llvm::ArrayRef<uint8_t> &data);
+
+    static llvm::Optional<std::vector<const MinidumpThread *>>
+    ParseThreadList(llvm::ArrayRef<uint8_t> &data);
+};
+static_assert(sizeof(MinidumpThread) == 48, "sizeof MinidumpThread is not correct!");
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680396(v=vs.85).aspx
+union MinidumpCPUInfo {
+    struct
+    {
+        llvm::support::ulittle32_t vendor_id[3];              /* cpuid 0: ebx, edx, ecx */
+        llvm::support::ulittle32_t version_information;       /* cpuid 1: eax */
+        llvm::support::ulittle32_t feature_information;       /* cpuid 1: edx */
+        llvm::support::ulittle32_t amd_extended_cpu_features; /* cpuid 0x80000001, ebx */
+    } x86_cpu_info;
+    struct
+    {
+        llvm::support::ulittle32_t cpuid;
+        llvm::support::ulittle32_t elf_hwcaps; /* linux specific, 0 otherwise */
+    } arm_cpu_info;
+    struct
+    {
+        llvm::support::ulittle64_t processor_features[2];
+    } other_cpu_info;
+};
+static_assert(sizeof(MinidumpCPUInfo) == 24, "sizeof MinidumpCPUInfo is not correct!");
+
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680396(v=vs.85).aspx
+struct MinidumpSystemInfo
+{
+    llvm::support::ulittle16_t processor_arch;
+    llvm::support::ulittle16_t processor_level;
+    llvm::support::ulittle16_t processor_revision;
+
+    uint8_t number_of_processors;
+    uint8_t product_type;
+
+    llvm::support::ulittle32_t major_version;
+    llvm::support::ulittle32_t minor_version;
+    llvm::support::ulittle32_t build_number;
+    llvm::support::ulittle32_t platform_id;
+    llvm::support::ulittle32_t csd_version_rva;
+
+    llvm::support::ulittle16_t suit_mask;
+    llvm::support::ulittle16_t reserved2;
+
+    MinidumpCPUInfo cpu;
+
+    static const MinidumpSystemInfo *
+    Parse(llvm::ArrayRef<uint8_t> &data);
+};
+static_assert(sizeof(MinidumpSystemInfo) == 56, "sizeof MinidumpSystemInfo is not correct!");
+
+// TODO check flags to see what's valid
+// TODO misc2, misc3 ?
+// Reference: https://msdn.microsoft.com/en-us/library/windows/desktop/ms680389(v=vs.85).aspx
+struct MinidumpMiscInfo
+{
+    llvm::support::ulittle32_t size;
+    llvm::support::ulittle32_t flags1;
+    llvm::support::ulittle32_t process_id;
+    llvm::support::ulittle32_t process_create_time;
+    llvm::support::ulittle32_t process_user_time;
+    llvm::support::ulittle32_t process_kernel_time;
+
+    static const MinidumpMiscInfo *
+    Parse(llvm::ArrayRef<uint8_t> &data);
+};
+static_assert(sizeof(MinidumpMiscInfo) == 24, "sizeof MinidumpMiscInfo is not correct!");
+
+} // namespace minidump
+} // namespace lldb_private
+#endif // liblldb_MinidumpTypes_h_

lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.cpp

+//===-- MinidumpTypes.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Project includes
+#include "MinidumpTypes.h"
+#include "MinidumpParser.h"
+
+// Other libraries and framework includes
+// C includes
+// C++ includes
+
+using namespace lldb_private;
+using namespace minidump;
+
+const MinidumpHeader *
+MinidumpHeader::Parse(llvm::ArrayRef<uint8_t> &data)
+{
+    const MinidumpHeader *header = nullptr;
+    Error error = consumeObject(data, header);
+
+    const MinidumpHeaderConstants signature =
+        static_cast<const MinidumpHeaderConstants>(static_cast<const uint32_t>(header->signature));
+    const MinidumpHeaderConstants version =
+        static_cast<const MinidumpHeaderConstants>(static_cast<const uint32_t>(header->version) & 0x0000ffff);
+    // the high 16 bits of the version field are implementation specific
+
+    if (error.Fail() || signature != MinidumpHeaderConstants::Signature || version != MinidumpHeaderConstants::Version)
+        return nullptr;
+
+    // TODO check for max number of streams ?
+    // TODO more sanity checks ?
+
+    return header;
+}
+
+// MinidumpThread
+const MinidumpThread *
+MinidumpThread::Parse(llvm::ArrayRef<uint8_t> &data)
+{
+    const MinidumpThread *thread = nullptr;
+    Error error = consumeObject(data, thread);
+    if (error.Fail())
+        return nullptr;
+
+    return thread;
+}
+
+llvm::Optional<std::vector<const MinidumpThread *>>
+MinidumpThread::ParseThreadList(llvm::ArrayRef<uint8_t> &data)
+{
+    std::vector<const MinidumpThread *> thread_list;
+
+    const llvm::support::ulittle32_t *thread_count;
+    Error error = consumeObject(data, thread_count);
+    if (error.Fail())
+        return llvm::None;
+
+    const MinidumpThread *thread;
+    for (uint32_t i = 0; i < *thread_count; ++i)
+    {
+        thread = MinidumpThread::Parse(data);
+        if (thread == nullptr)
+            return llvm::None;
+        thread_list.push_back(thread);
+    }
+
+    return llvm::Optional<std::vector<const MinidumpThread *>>(thread_list);
+}
+
+// MinidumpSystemInfo
+const MinidumpSystemInfo *
+MinidumpSystemInfo::Parse(llvm::ArrayRef<uint8_t> &data)
+{
+    const MinidumpSystemInfo *system_info;
+    Error error = consumeObject(data, system_info);
+    if (error.Fail())
+        return nullptr;
+
+    return system_info;
+}
+
+// MinidumpMiscInfo
+const MinidumpMiscInfo *
+MinidumpMiscInfo::Parse(llvm::ArrayRef<uint8_t> &data)
+{
+    const MinidumpMiscInfo *misc_info;
+    Error error = consumeObject(data, misc_info);
+    if (error.Fail())
+        return nullptr;
+
+    return misc_info;
+}

lldb/trunk/unittests/Process/CMakeLists.txt

 add_subdirectory(gdb-remote)
+add_subdirectory(minidump)

lldb/trunk/unittests/Process/minidump/CMakeLists.txt

+add_lldb_unittest(LLDBMinidumpTests
+  MinidumpParserTest.cpp
+  )
+
+set(test_inputs
+   linux-x86_64.dmp)
+
+add_unittest_inputs(LLDBMinidumpTests "${test_inputs}")

lldb/trunk/unittests/Process/minidump/Inputs/linux-x86_64.cpp

+// Example source from breakpad's linux tutorial
+// https://chromium.googlesource.com/breakpad/breakpad/+/master/docs/linux_starter_guide.md
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "client/linux/handler/exception_handler.h"
+
+
+static bool dumpCallback(const google_breakpad::MinidumpDescriptor& descriptor,
+void* context, bool succeeded) {
+    printf("Dump path: %s\n", descriptor.path());
+    return succeeded;
+}
+
+void crash() { volatile int* a = (int*)(NULL); *a = 1; }
+
+int main(int argc, char* argv[]) {
+    google_breakpad::MinidumpDescriptor descriptor("/tmp");
+    google_breakpad::ExceptionHandler eh(descriptor, NULL, dumpCallback, NULL, true, -1);
+    printf("pid: %d\n", getpid());
+    crash();
+    return 0;
+}

lldb/trunk/unittests/Process/minidump/MinidumpParserTest.cpp

+//===-- MinidumpTypesTest.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Project includes
+#include "Plugins/Process/minidump/MinidumpParser.h"
+#include "Plugins/Process/minidump/MinidumpTypes.h"
+
+// Other libraries and framework includes
+#include "gtest/gtest.h"
+
+#include "lldb/Core/ArchSpec.h"
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Host/FileSpec.h"
+
+#include "llvm/ADT/Optional.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+
+// C includes
+
+// C++ includes
+#include <memory>
+
+extern const char *TestMainArgv0;
+
+using namespace lldb_private;
+using namespace minidump;
+
+class MinidumpParserTest : public testing::Test
+{
+public:
+    void
+    SetUp() override
+    {
+        llvm::StringRef dmp_folder = llvm::sys::path::parent_path(TestMainArgv0);
+        inputs_folder = dmp_folder;
+        llvm::sys::path::append(inputs_folder, "Inputs");
+    }
+
+    void
+    SetUpData(const char *minidump_filename, size_t load_size = SIZE_MAX)
+    {
+        llvm::SmallString<128> filename = inputs_folder;
+        llvm::sys::path::append(filename, minidump_filename);
+        FileSpec minidump_file(filename.c_str(), false);
+        lldb::DataBufferSP data_sp(minidump_file.MemoryMapFileContents(0, load_size));
+        llvm::Optional<MinidumpParser> optional_parser = MinidumpParser::Create(data_sp);
+        ASSERT_TRUE(optional_parser.hasValue());
+        parser.reset(new MinidumpParser(optional_parser.getValue()));
+        ASSERT_GT(parser->GetByteSize(), 0UL);
+    }
+
+    llvm::SmallString<128> inputs_folder;
+    std::unique_ptr<MinidumpParser> parser;
+};
+
+TEST_F(MinidumpParserTest, GetThreads)
+{
+    SetUpData("linux-x86_64.dmp");
+    llvm::Optional<std::vector<const MinidumpThread *>> thread_list;
+
+    thread_list = parser->GetThreads();
+    ASSERT_TRUE(thread_list.hasValue());
+    ASSERT_EQ(1UL, thread_list->size());
+
+    const MinidumpThread *thread = thread_list.getValue()[0];
+    ASSERT_EQ(16001UL, thread->thread_id);
+}
+
+TEST_F(MinidumpParserTest, GetThreadsTruncatedFile)
+{
+    SetUpData("linux-x86_64.dmp", 200);
+    llvm::Optional<std::vector<const MinidumpThread *>> thread_list;
+
+    thread_list = parser->GetThreads();
+    ASSERT_FALSE(thread_list.hasValue());
+}
+
+TEST_F(MinidumpParserTest, GetArchitecture)
+{
+    SetUpData("linux-x86_64.dmp");
+    ASSERT_EQ(llvm::Triple::ArchType::x86_64, parser->GetArchitecture().GetTriple().getArch());
+}
+
+TEST_F(MinidumpParserTest, GetMiscInfo)
+{
+    SetUpData("linux-x86_64.dmp");
+    const MinidumpMiscInfo *misc_info = parser->GetMiscInfo();
+    ASSERT_EQ(nullptr, misc_info);
+    // linux breakpad generated minidump files don't have misc info stream
+}