Adding a new Minidump post-mortem debugging plugin

[dvlahovski]

Summary

This plugin resembles the already existing Windows-only Minidump plugin.
The WinMinidumpPlugin uses the Windows API for parsing Minidumps
while this plugin is cross-platform because it includes a Minidump
parser (which is already commited)

It is able to produce a backtrace, to read the general puprose regiters,
inspect local variables, show image list, do memory reads, etc.

For now the only arch that this supports is x86 64 bit
This is because I have only written a register context for that arch.
Others will come in next CLs.

I copied the WinMinidump tests and adapted them a little bit for them to
work with the new plugin (and they pass)
I will add more tests, aiming for better code coverage.

There is still functionality to be added, see TODOs in code.

[dvlahovski]

So, there will be changes to the way I handle the case where there is no ExceptionStream - I will probably create a StopReason = None. But I have to investigate if in that case lldb still hangs because it's trying to resume a process (that does not exists). I will ask Jim Ingham about some insight about StopReasons

[labath]

I have a bunch of small comments. I'll have another look through this once they are done.

The high-level change we need is to avoid choosing the plugin to use at compile-time (your plugin should be host independent, so-lets use it everywhere). Since you still don't have full feature parity with the windows plugin, add a runtime check, which makes sure that your plugin does not kick in for windows minidump files. Once you have feature parity, we can remove that check and ask Zachary and Adrian to validate everything still works as they expect.

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

19 ↗

(On Diff #73296)

You can replace these with NO_DEBUG_INFO_TESTCASE = True at class level.

66 ↗

(On Diff #73296)

I don't think these are necessary.

source/Plugins/Process/minidump/MinidumpParser.cpp

228 ↗

(On Diff #73296)

Return llvm::Optional<range_out> ?

source/Plugins/Process/minidump/MinidumpParser.h

36 ↗

(On Diff #73296)

Make these two an ArrayRef ?

source/Plugins/Process/minidump/ProcessMinidump.cpp

47 ↗

(On Diff #73296)

Please rewrite this to use the early-return style:

if (!crash_file)
  return nullptr;

etc.

55 ↗

(On Diff #73296)

the check for non-nullness of data_sp is superfluous (or too late).

67 ↗

(On Diff #73296)

It already is return true.

Is that correct?

121 ↗

(On Diff #73296)

I think it is. You can remove the TODO.

source/Plugins/Process/minidump/ThreadMinidump.cpp

37 ↗

(On Diff #73296)

If you make the constructor take a ProcessMinidump & you can avoid this cast. (although, if we change the code below, you may not even need it).

39 ↗

(On Diff #73296)

This should be implemented inside the minidump parser. There's no reason for doing memory slicing at this level.

48 ↗

(On Diff #73296)

If you don't know whether this is necessary, prefer simplicity and don't do it

66 ↗

(On Diff #73296)

if (!m_reg_context_sp)

also use nullptr instead of NULL.

source/Plugins/Process/minidump/ThreadMinidump.h

1 ↗

(On Diff #73296)

typo (-h)

unittests/Process/minidump/MinidumpParserTest.cpp

142 ↗

(On Diff #73296)

Please do this now.

[amccarth]

I was hoping that, with your new mini dump parser, you'd be able to eliminate the need for the Windows-specific minidump process plugin.

When I wrote the Windows mini dump plugin, I tried to isolate the Windows API-specific bits using the pimpl idiom. Now that you've written a mini dump parser, we shouldn't need the Windows API calls, and nearly all the rest of the code should be shareable between Windows and Linux. Is there a plan to eliminate this redundancy and merge this new mini dump process plugin with the Windows-specific one?

[dvlahovski]

source/Plugins/Process/minidump/ProcessMinidump.cpp

67 ↗

(On Diff #73296)

What I meant here is: is there functionality that needs to be added here.
In the WinMinidump plugin, this method is only returning true (as mine) and has a TODO saying that it should have actual logic in it

[dvlahovski]

In D25196#559368, @amccarth wrote:

I was hoping that, with your new mini dump parser, you'd be able to eliminate the need for the Windows-specific minidump process plugin.

When I wrote the Windows mini dump plugin, I tried to isolate the Windows API-specific bits using the pimpl idiom. Now that you've written a mini dump parser, we shouldn't need the Windows API calls, and nearly all the rest of the code should be shareable between Windows and Linux. Is there a plan to eliminate this redundancy and merge this new mini dump process plugin with the Windows-specific one?

Yes, the plan is that my plugin will replace the Windows one. (and it has almost the same functionality)

What I have been doing so far is actually copying all of the methods from the WinMinidump plugin to mine and changing them to use the new Minidump parser.

Probably I could have fitted into you pimpl implementation pattern, but I chose just to start a 'new' plugin and copy everything from the WinMinidump, and then change it accordingly.

[dvlahovski]

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

19 ↗

(On Diff #73296)

But, should test_deeper_stack_in_mini_dump and test_local_variables_in_mini_dump not have this decorator ?

[labath]

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

19 ↗

(On Diff #73296)

They are not building any code, so the would behave the same way anyway. You would be just running the test 2--3 times for nothing.

[dvlahovski]

packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

19 ↗

(On Diff #73296)

Aah I understand now. Ok thanks :)

[dvlahovski]

Updated the CL with regard to Pavel's comments

[labath]

Just a couple more details and I think we're ready.

source/Plugins/Process/minidump/MinidumpParser.cpp

105 ↗

(On Diff #73504)

I think you have made it over-encapsulated now. :)
Either a Parser function which takes a thread or a Thread function which takes a parser as argument should be enough. Is there a reason you need both?

234 ↗

(On Diff #73504)

Not necessary.

255 ↗

(On Diff #73504)

return Range(...) is much cleaner and shorter.

Add an appropriate constructor if it is needed to make this work.

source/Plugins/Process/minidump/MinidumpTypes.cpp

94 ↗

(On Diff #73504)

This feels very unsafe. Is there anything guaranteeing that thread_context.rva does not point beyond the end of the file?

source/Plugins/Process/minidump/ProcessMinidump.cpp

69 ↗

(On Diff #73504)

This could also be an early-return.

[dvlahovski]

Second iteration over CL - regarded Pavel's comments and encapsulated m_data_sp more in MinidumpParser

[zturner]

source/Plugins/Process/minidump/MinidumpParser.cpp

81–82 ↗

(On Diff #73516)

Change this line to return GetData().slice(iter->second.rva, iter->second.data_size);

106–107 ↗

(On Diff #73516)

Same as above, use slice()

255 ↗

(On Diff #73516)

slice()

source/Plugins/Process/minidump/MinidumpParser.h

35–36 ↗

(On Diff #73516)

If the comment is long enough to wrap, maybe better to just put it on the line before. Looks awkward this way.

39–40 ↗

(On Diff #73516)

You don't need the underscores here. It might look awkward, but the usual LLVM pattern is to just call the constructor parameters and member variables the same name.

source/Plugins/Process/minidump/MinidumpTypes.cpp

188–190 ↗

(On Diff #73516)

you can write return llvm::makeArrayRef(reinterpret_cast<const MinidumpMemoryDescriptor*>(data.data()), *mem_ranges_count)); to avoid specifying the type name twice. It's a little shorter (admittedly not much though).

[dvlahovski]

Changes after Zachary's comments

[dvlahovski]

source/Plugins/Process/minidump/MinidumpParser.cpp

81–82 ↗

(On Diff #73516)

Nice! :)

source/Plugins/Process/minidump/MinidumpParser.h

35–36 ↗

(On Diff #73516)

This comment is for the ArrayrRef. Added a clarification

source/Plugins/Process/minidump/MinidumpTypes.cpp

188–190 ↗

(On Diff #73516)

I think it looks better with the makeArrayrRef :)

[labath]

Thanks for fixing all the comments. Unfortunately, on my last pass, I found one more case of unverified input (I think).

source/Plugins/Process/minidump/MinidumpParser.cpp

252 ↗

(On Diff #73526)

Is anything verifying that loc_desc points into the file ?

source/Plugins/Process/minidump/ProcessMinidump.cpp

187 ↗

(On Diff #73526)

typo: "in our"

[dvlahovski]

Added a sanity check for loc_descr

[labath]

lgtm

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
+

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

+"""
+Test basics of Minidump debugging.
+"""
+
+from __future__ import print_function
+from six import iteritems
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class MiniDumpNewTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_process_info_in_mini_dump(self):
+        """Test that lldb can read the process information from the Minidump."""
+        # target create -c linux-x86_64.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("linux-x86_64.dmp")
+        self.assertTrue(self.process, PROCESS_IS_VALID)
+        self.assertEqual(self.process.GetNumThreads(), 1)
+        self.assertEqual(self.process.GetProcessID(), 16001)
+
+    def test_thread_info_in_mini_dump(self):
+        """Test that lldb can read the thread information from the Minidump."""
+        # target create -c linux-x86_64.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("linux-x86_64.dmp")
+        # This process crashed due to a segmentation fault in its
+        # one and only thread.
+        self.assertEqual(self.process.GetNumThreads(), 1)
+        thread = self.process.GetThreadAtIndex(0)
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        stop_description = thread.GetStopDescription(256)
+        self.assertTrue("SIGSEGV" in stop_description)
+
+    def test_stack_info_in_mini_dump(self):
+        """Test that we can see a trivial stack in a breakpad-generated Minidump."""
+        # target create -c linux-x86_64.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("linux-x86_64.dmp")
+        self.assertEqual(self.process.GetNumThreads(), 1)
+        thread = self.process.GetThreadAtIndex(0)
+        # frame #0: a.out`crash()
+        # frame #1: a.out`main()
+        # frame #2: libc-2.19.so`__libc_start_main()
+        # frame #3: a.out`_start
+        self.assertEqual(thread.GetNumFrames(), 4)
+        frame = thread.GetFrameAtIndex(0)
+        self.assertTrue(frame.IsValid())
+        pc = frame.GetPC()
+        eip = frame.FindRegister("pc")
+        self.assertTrue(eip.IsValid())
+        self.assertEqual(pc, eip.GetValueAsUnsigned())
+
+    def test_snapshot_minidump(self):
+        """Test that if we load a snapshot minidump file (meaning the process did not crash) there is no stop reason."""
+        # target create -c linux-x86_64_not_crashed.dmp
+        self.dbg.CreateTarget("")
+        self.target = self.dbg.GetSelectedTarget()
+        self.process = self.target.LoadCore("linux-x86_64_not_crashed.dmp")
+        self.assertEqual(self.process.GetNumThreads(), 1)
+        thread = self.process.GetThreadAtIndex(0)
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+        stop_description = thread.GetStopDescription(256)
+        self.assertEqual(stop_description, None)
+
+    def test_deeper_stack_in_mini_dump(self):
+        """Test that we can examine a more interesting stack in a Minidump."""
+        # Launch with the Minidump, and inspect the stack.
+        target = self.dbg.CreateTarget(None)
+        process = target.LoadCore("linux-x86_64_not_crashed.dmp")
+        thread = process.GetThreadAtIndex(0)
+
+        expected_stack = {1: 'bar', 2: 'foo', 3: 'main'}
+        self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
+        for index, name in iteritems(expected_stack):
+            frame = thread.GetFrameAtIndex(index)
+            self.assertTrue(frame.IsValid())
+            function_name = frame.GetFunctionName()
+            self.assertTrue(name in function_name)
+
+    def test_local_variables_in_mini_dump(self):
+        """Test that we can examine local variables in a Minidump."""
+        # Launch with the Minidump, and inspect a local variable.
+        target = self.dbg.CreateTarget(None)
+        process = target.LoadCore("linux-x86_64_not_crashed.dmp")
+        thread = process.GetThreadAtIndex(0)
+        frame = thread.GetFrameAtIndex(1)
+        value = frame.EvaluateExpression('x')
+        self.assertEqual(value.GetValueAsSigned(), 3)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/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/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp

+#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;
+}
+
+int global = 42;
+
+int
+bar(int x, google_breakpad::ExceptionHandler &eh)
+{
+    eh.WriteMinidump();
+    int y = 4*x + global;
+    return y;
+}
+
+int
+foo(int x, google_breakpad::ExceptionHandler &eh)
+{
+    int y = 2*bar(3*x, eh);
+      return y;
+}
+
+
+int main(int argc, char* argv[]) {
+    google_breakpad::MinidumpDescriptor descriptor("/tmp");
+    google_breakpad::ExceptionHandler eh(descriptor, NULL, dumpCallback, NULL, true, -1);
+    foo(1, eh);
+    return 0;
+}

lldb/trunk/source/API/SystemInitializerFull.cpp

 #include "Plugins/Platform/Linux/PlatformLinux.h"
 #include "Plugins/Platform/MacOSX/PlatformMacOSX.h"
 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h"
 #include "Plugins/Platform/NetBSD/PlatformNetBSD.h"
 #include "Plugins/Platform/Windows/PlatformWindows.h"
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 #include "Plugins/Process/elf-core/ProcessElfCore.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+#include "Plugins/Process/minidump/ProcessMinidump.h"
 #include "Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
 #include "Plugins/SymbolFile/PDB/SymbolFilePDB.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
 #include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
 #include "Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h"
 #include "Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h"
#endif
   ABISysV_s390x::Initialize();
   DisassemblerLLVMC::Initialize();
 
   JITLoaderGDB::Initialize();
   ProcessElfCore::Initialize();
 #if defined(_MSC_VER)
   ProcessWinMiniDump::Initialize();
 #endif
+  minidump::ProcessMinidump::Initialize();
   MemoryHistoryASan::Initialize();
   AddressSanitizerRuntime::Initialize();
   ThreadSanitizerRuntime::Initialize();
 
   SymbolVendorELF::Initialize();
   SymbolFileDWARF::Initialize();
   SymbolFilePDB::Initialize();
   SymbolFileSymtab::Initialize();
void SystemInitializerFull::Terminate() {
   ABISysV_ppc64::Terminate();
   ABISysV_mips::Terminate();
   ABISysV_mips64::Terminate();
   ABISysV_s390x::Terminate();
   DisassemblerLLVMC::Terminate();
 
   JITLoaderGDB::Terminate();
   ProcessElfCore::Terminate();
+
 #if defined(_MSC_VER)
   ProcessWinMiniDump::Terminate();
 #endif
+  minidump::ProcessMinidump::Terminate();
   MemoryHistoryASan::Terminate();
   AddressSanitizerRuntime::Terminate();
   ThreadSanitizerRuntime::Terminate();
   SymbolVendorELF::Terminate();
   SymbolFileDWARF::Terminate();
   SymbolFilePDB::Terminate();
   SymbolFileSymtab::Terminate();
   UnwindAssembly_x86::Terminate();

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

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

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

-//===-- MinidumpParser.h -----------------------------------------*- C++
-//-*-===//
+//===-- 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"
 #include "llvm/ADT/StringRef.h"
 
 // C includes
-
 // C++ includes
-#include <cstring>
-#include <unordered_map>
 
 namespace lldb_private {
 
 namespace minidump {
 
+// Describes a range of memory captured in the Minidump
+struct Range {
+  lldb::addr_t start; // virtual address of the beginning of the range
+  // range_ref - absolute pointer to the first byte of the range and size
+  llvm::ArrayRef<uint8_t> range_ref;
+
+  Range(lldb::addr_t start, llvm::ArrayRef<uint8_t> range_ref)
+      : start(start), range_ref(range_ref) {}
+};
+
 class MinidumpParser {
 public:
   static llvm::Optional<MinidumpParser>
   Create(const lldb::DataBufferSP &data_buf_sp);
 
   llvm::ArrayRef<uint8_t> GetData();
 
   llvm::ArrayRef<uint8_t> GetStream(MinidumpStreamType stream_type);
 
   llvm::Optional<std::string> GetMinidumpString(uint32_t rva);
 
   llvm::ArrayRef<MinidumpThread> GetThreads();
 
+  llvm::ArrayRef<uint8_t> GetThreadContext(const MinidumpThread &td);
+
   const MinidumpSystemInfo *GetSystemInfo();
 
   ArchSpec GetArchitecture();
 
   const MinidumpMiscInfo *GetMiscInfo();
 
   llvm::Optional<LinuxProcStatus> GetLinuxProcStatus();
 
   llvm::Optional<lldb::pid_t> GetPid();
 
   llvm::ArrayRef<MinidumpModule> GetModuleList();
 
   const MinidumpExceptionStream *GetExceptionStream();
 
+  llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr);
+
 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,
       llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> &&directory_map);
 };
 
 } // end namespace minidump
 } // end namespace lldb_private
 #endif // liblldb_MinidumpParser_h_

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

-//===-- MinidumpParser.cpp ---------------------------------------*- C++ -*-===//
+//===-- 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
 

 
 MinidumpParser::MinidumpParser(
     const lldb::DataBufferSP &data_buf_sp, const MinidumpHeader *header,
     llvm::DenseMap<uint32_t, MinidumpLocationDescriptor> &&directory_map)
     : m_data_sp(data_buf_sp), m_header(header), m_directory_map(directory_map) {
 }
 
 llvm::ArrayRef<uint8_t> MinidumpParser::GetData() {
-  return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(),
-                                 m_data_sp->GetByteSize());
+  return m_data_sp->GetData();
 }
 
 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 {};
 
   // check if there is enough data
-  if (iter->second.rva + iter->second.data_size > m_data_sp->GetByteSize())
+  if (iter->second.rva + iter->second.data_size > GetData().size())
     return {};
 
-  return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes() + iter->second.rva,
-                                 iter->second.data_size);
+  return GetData().slice(iter->second.rva, iter->second.data_size);
 }
 
 llvm::Optional<std::string> MinidumpParser::GetMinidumpString(uint32_t rva) {
-  auto arr_ref = m_data_sp->GetData();
+  auto arr_ref = GetData();
   if (rva > arr_ref.size())
     return llvm::None;
   arr_ref = arr_ref.drop_front(rva);
   return parseMinidumpString(arr_ref);
 }
 
 llvm::ArrayRef<MinidumpThread> MinidumpParser::GetThreads() {
   llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::ThreadList);
 
   if (data.size() == 0)
     return llvm::None;
 
   return MinidumpThread::ParseThreadList(data);
 }
 
+llvm::ArrayRef<uint8_t>
+MinidumpParser::GetThreadContext(const MinidumpThread &td) {
+  if (td.thread_context.rva + td.thread_context.data_size > GetData().size())
+    return llvm::None;
+
+  return GetData().slice(td.thread_context.rva, td.thread_context.data_size);
+}
+
 const MinidumpSystemInfo *MinidumpParser::GetSystemInfo() {
   llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::SystemInfo);
 
   if (data.size() == 0)
     return nullptr;
 
   return MinidumpSystemInfo::Parse(data);
 }

 const MinidumpExceptionStream *MinidumpParser::GetExceptionStream() {
   llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::Exception);
 
   if (data.size() == 0)
     return nullptr;
 
   return MinidumpExceptionStream::Parse(data);
 }
+
+llvm::Optional<Range> MinidumpParser::FindMemoryRange(lldb::addr_t addr) {
+  llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::MemoryList);
+
+  if (data.size() == 0)
+    return llvm::None;
+
+  llvm::ArrayRef<MinidumpMemoryDescriptor> memory_list =
+      MinidumpMemoryDescriptor::ParseMemoryList(data);
+
+  if (memory_list.size() == 0)
+    return llvm::None;
+
+  for (auto memory_desc : memory_list) {
+    const MinidumpLocationDescriptor &loc_desc = memory_desc.memory;
+    const lldb::addr_t range_start = memory_desc.start_of_memory_range;
+    const size_t range_size = loc_desc.data_size;
+
+    if (loc_desc.rva + loc_desc.data_size > GetData().size())
+      return llvm::None;
+
+    if (range_start <= addr && addr < range_start + range_size) {
+      return Range(range_start, GetData().slice(loc_desc.rva, range_size));
+    }
+  }
+
+  // TODO parse Memory64List which is present in full-memory Minidumps
+
+  return llvm::None;
+}

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

 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 llvm::ArrayRef<MinidumpMemoryDescriptor>
+  ParseMemoryList(llvm::ArrayRef<uint8_t> &data);
 };
 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;
struct MinidumpModule {
   ParseModuleList(llvm::ArrayRef<uint8_t> &data);
 };
 static_assert(sizeof(MinidumpModule) == 108,
               "sizeof MinidumpVSFixedFileInfo is not correct!");
 
 // Exception stuff
 struct MinidumpException {
   enum {
-    MaxParams = 15,
+    ExceptonInfoMaxParams = 15,
+    DumpRequested = 0xFFFFFFFF,
   };
 
   llvm::support::ulittle32_t exception_code;
   llvm::support::ulittle32_t exception_flags;
   llvm::support::ulittle64_t exception_record;
   llvm::support::ulittle64_t exception_address;
   llvm::support::ulittle32_t number_parameters;
   llvm::support::ulittle32_t unused_alignment;
-  llvm::support::ulittle64_t exception_information[MaxParams];
+  llvm::support::ulittle64_t exception_information[ExceptonInfoMaxParams];
 };
 static_assert(sizeof(MinidumpException) == 152,
               "sizeof MinidumpException is not correct!");
 
 struct MinidumpExceptionStream {
   llvm::support::ulittle32_t thread_id;
   llvm::support::ulittle32_t alignment;
   MinidumpException exception_record;

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

 
 llvm::ArrayRef<MinidumpThread>
 MinidumpThread::ParseThreadList(llvm::ArrayRef<uint8_t> &data) {
   const llvm::support::ulittle32_t *thread_count;
   Error error = consumeObject(data, thread_count);
   if (error.Fail() || *thread_count * sizeof(MinidumpThread) > data.size())
     return {};
 
-  return llvm::ArrayRef<MinidumpThread>(
+  return llvm::makeArrayRef(
       reinterpret_cast<const MinidumpThread *>(data.data()), *thread_count);
 }
 
 // MinidumpSystemInfo
 const MinidumpSystemInfo *
 MinidumpSystemInfo::Parse(llvm::ArrayRef<uint8_t> &data) {
   const MinidumpSystemInfo *system_info;
   Error error = consumeObject(data, system_info);

 llvm::ArrayRef<MinidumpModule>
 MinidumpModule::ParseModuleList(llvm::ArrayRef<uint8_t> &data) {
 
   const llvm::support::ulittle32_t *modules_count;
   Error error = consumeObject(data, modules_count);
   if (error.Fail() || *modules_count * sizeof(MinidumpModule) > data.size())
     return {};
 
-  return llvm::ArrayRef<MinidumpModule>(
+  return llvm::makeArrayRef(
       reinterpret_cast<const MinidumpModule *>(data.data()), *modules_count);
 }
 
 // Exception stuff
 const MinidumpExceptionStream *
 MinidumpExceptionStream::Parse(llvm::ArrayRef<uint8_t> &data) {
   const MinidumpExceptionStream *exception_stream = nullptr;
   Error error = consumeObject(data, exception_stream);
   if (error.Fail())
     return nullptr;
 
   return exception_stream;
 }
+
+llvm::ArrayRef<MinidumpMemoryDescriptor>
+MinidumpMemoryDescriptor::ParseMemoryList(llvm::ArrayRef<uint8_t> &data) {
+  const llvm::support::ulittle32_t *mem_ranges_count;
+  Error error = consumeObject(data, mem_ranges_count);
+  if (error.Fail() ||
+      *mem_ranges_count * sizeof(MinidumpMemoryDescriptor) > data.size())
+    return {};
+
+  return llvm::makeArrayRef(
+      reinterpret_cast<const MinidumpMemoryDescriptor *>(data.data()),
+      *mem_ranges_count);
+}

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

+//===-- ProcessMinidump.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_ProcessMinidump_h_
+#define liblldb_ProcessMinidump_h_
+
+// Project includes
+#include "MinidumpParser.h"
+#include "MinidumpTypes.h"
+
+// Other libraries and framework includes
+#include "lldb/Core/ConstString.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+
+#include "llvm/Support/Format.h"
+#include "llvm/Support/raw_ostream.h"
+
+// C Includes
+// C++ Includes
+
+namespace lldb_private {
+
+namespace minidump {
+
+class ProcessMinidump : public Process {
+public:
+  static lldb::ProcessSP CreateInstance(lldb::TargetSP target_sp,
+                                        lldb::ListenerSP listener_sp,
+                                        const FileSpec *crash_file_path);
+
+  static void Initialize();
+
+  static void Terminate();
+
+  static ConstString GetPluginNameStatic();
+
+  static const char *GetPluginDescriptionStatic();
+
+  ProcessMinidump(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
+                  const lldb_private::FileSpec &core_file,
+                  MinidumpParser minidump_parser);
+
+  ~ProcessMinidump() override;
+
+  bool CanDebug(lldb::TargetSP target_sp,
+                bool plugin_specified_by_name) override;
+
+  Error DoLoadCore() override;
+
+  DynamicLoader *GetDynamicLoader() override;
+
+  ConstString GetPluginName() override;
+
+  uint32_t GetPluginVersion() override;
+
+  Error DoDestroy() override;
+
+  void RefreshStateAfterStop() override;
+
+  bool IsAlive() override;
+
+  bool WarnBeforeDetach() const override;
+
+  size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                    Error &error) override;
+
+  size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                      Error &error) override;
+
+  ArchSpec GetArchitecture();
+
+  Error GetMemoryRegionInfo(lldb::addr_t load_addr,
+                            MemoryRegionInfo &range_info) override;
+
+  MinidumpParser m_minidump_parser;
+
+protected:
+  void Clear();
+
+  bool UpdateThreadList(ThreadList &old_thread_list,
+                        ThreadList &new_thread_list) override;
+
+  void ReadModuleList();
+
+private:
+  FileSpec m_core_file;
+  llvm::ArrayRef<MinidumpThread> m_thread_list;
+  const MinidumpExceptionStream *m_active_exception;
+};
+
+} // namespace minidump
+} // namespace lldb_private
+
+#endif // liblldb_ProcessMinidump_h_

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

+//===-- ProcessMinidump.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 "ProcessMinidump.h"
+#include "ThreadMinidump.h"
+
+// Other libraries and framework includes
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/State.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/LLDBAssert.h"
+
+// C includes
+// C++ includes
+
+using namespace lldb_private;
+using namespace minidump;
+
+ConstString ProcessMinidump::GetPluginNameStatic() {
+  static ConstString g_name("minidump");
+  return g_name;
+}
+
+const char *ProcessMinidump::GetPluginDescriptionStatic() {
+  return "Minidump plug-in.";
+}
+
+lldb::ProcessSP ProcessMinidump::CreateInstance(lldb::TargetSP target_sp,
+                                                lldb::ListenerSP listener_sp,
+                                                const FileSpec *crash_file) {
+  if (!crash_file)
+    return nullptr;
+
+  lldb::ProcessSP process_sp;
+  // Read enough data for the Minidump header
+  const size_t header_size = sizeof(MinidumpHeader);
+  lldb::DataBufferSP data_sp(crash_file->MemoryMapFileContents(0, header_size));
+  // The memory map can fail
+  if (!data_sp)
+    return nullptr;
+
+  // first, only try to parse the header, beacuse we need to be fast
+  llvm::ArrayRef<uint8_t> header_data(data_sp->GetBytes(), header_size);
+  const MinidumpHeader *header = MinidumpHeader::Parse(header_data);
+
+  if (data_sp->GetByteSize() != header_size || header == nullptr)
+    return nullptr;
+
+  lldb::DataBufferSP all_data_sp(crash_file->MemoryMapFileContents());
+  auto minidump_parser = MinidumpParser::Create(all_data_sp);
+  // check if the parser object is valid
+  // skip if the Minidump file is Windows generated, because we are still
+  // work-in-progress
+  if (!minidump_parser ||
+      minidump_parser->GetArchitecture().GetTriple().getOS() ==
+          llvm::Triple::OSType::Win32)
+    return nullptr;
+
+  return lldb::ProcessSP(new ProcessMinidump(
+      target_sp, listener_sp, *crash_file, minidump_parser.getValue()));
+}
+
+// TODO leave it to be only "return true" ?
+bool ProcessMinidump::CanDebug(lldb::TargetSP target_sp,
+                               bool plugin_specified_by_name) {
+  return true;
+}
+
+ProcessMinidump::ProcessMinidump(lldb::TargetSP target_sp,
+                                 lldb::ListenerSP listener_sp,
+                                 const FileSpec &core_file,
+                                 MinidumpParser minidump_parser)
+    : Process(target_sp, listener_sp), m_minidump_parser(minidump_parser),
+      m_core_file(core_file) {}
+
+ProcessMinidump::~ProcessMinidump() {
+  Clear();
+  // We need to call finalize on the process before destroying ourselves
+  // to make sure all of the broadcaster cleanup goes as planned. If we
+  // destruct this class, then Process::~Process() might have problems
+  // trying to fully destroy the broadcaster.
+  Finalize();
+}
+
+void ProcessMinidump::Initialize() {
+  static std::once_flag g_once_flag;
+
+  std::call_once(g_once_flag, []() {
+    PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                  GetPluginDescriptionStatic(),
+                                  ProcessMinidump::CreateInstance);
+  });
+}
+
+void ProcessMinidump::Terminate() {
+  PluginManager::UnregisterPlugin(ProcessMinidump::CreateInstance);
+}
+
+Error ProcessMinidump::DoLoadCore() {
+  Error error;
+
+  m_thread_list = m_minidump_parser.GetThreads();
+  m_active_exception = m_minidump_parser.GetExceptionStream();
+  GetTarget().SetArchitecture(GetArchitecture());
+  ReadModuleList();
+
+  llvm::Optional<lldb::pid_t> pid = m_minidump_parser.GetPid();
+  if (!pid) {
+    error.SetErrorString("failed to parse PID");
+    return error;
+  }
+  SetID(pid.getValue());
+
+  return error;
+}
+
+DynamicLoader *ProcessMinidump::GetDynamicLoader() {
+  if (m_dyld_ap.get() == nullptr)
+    m_dyld_ap.reset(DynamicLoader::FindPlugin(this, nullptr));
+  return m_dyld_ap.get();
+}
+
+ConstString ProcessMinidump::GetPluginName() { return GetPluginNameStatic(); }
+
+uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
+
+Error ProcessMinidump::DoDestroy() { return Error(); }
+
+void ProcessMinidump::RefreshStateAfterStop() {
+  if (!m_active_exception)
+    return;
+
+  if (m_active_exception->exception_record.exception_code ==
+      MinidumpException::DumpRequested) {
+    return;
+  }
+
+  lldb::StopInfoSP stop_info;
+  lldb::ThreadSP stop_thread;
+
+  Process::m_thread_list.SetSelectedThreadByID(m_active_exception->thread_id);
+  stop_thread = Process::m_thread_list.GetSelectedThread();
+  ArchSpec arch = GetArchitecture();
+
+  if (arch.GetTriple().getOS() == llvm::Triple::Linux) {
+    stop_info = StopInfo::CreateStopReasonWithSignal(
+        *stop_thread, m_active_exception->exception_record.exception_code);
+  } else {
+    std::string desc;
+    llvm::raw_string_ostream desc_stream(desc);
+    desc_stream << "Exception "
+                << llvm::format_hex(
+                       m_active_exception->exception_record.exception_code, 8)
+                << " encountered at address "
+                << llvm::format_hex(
+                       m_active_exception->exception_record.exception_address,
+                       8);
+    stop_info = StopInfo::CreateStopReasonWithException(
+        *stop_thread, desc_stream.str().c_str());
+  }
+
+  stop_thread->SetStopInfo(stop_info);
+}
+
+bool ProcessMinidump::IsAlive() { return true; }
+
+bool ProcessMinidump::WarnBeforeDetach() const { return false; }
+
+size_t ProcessMinidump::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                   lldb_private::Error &error) {
+  // Don't allow the caching that lldb_private::Process::ReadMemory does
+  // since we have it all cached in our dump file anyway.
+  return DoReadMemory(addr, buf, size, error);
+}
+
+size_t ProcessMinidump::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
+                                     lldb_private::Error &error) {
+  // I don't have a sense of how frequently this is called or how many memory
+  // ranges a Minidump typically has, so I'm not sure if searching for the
+  // appropriate range linearly each time is stupid.  Perhaps we should build
+  // an index for faster lookups.
+  llvm::Optional<Range> range = m_minidump_parser.FindMemoryRange(addr);
+  if (!range)
+    return 0;
+
+  // There's at least some overlap between the beginning of the desired range
+  // (addr) and the current range.  Figure out where the overlap begins and
+  // how much overlap there is, then copy it to the destination buffer.
+  lldbassert(range->start <= addr);
+  const size_t offset = addr - range->start;
+  lldbassert(offset < range->range_ref.size());
+  const size_t overlap = std::min(size, range->range_ref.size() - offset);
+  std::memcpy(buf, range->range_ref.data() + offset, overlap);
+  return overlap;
+}
+
+ArchSpec ProcessMinidump::GetArchitecture() {
+  return m_minidump_parser.GetArchitecture();
+}
+
+// TODO - parse the MemoryInfoListStream and implement this method
+Error ProcessMinidump::GetMemoryRegionInfo(
+    lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &range_info) {
+  return {};
+}
+
+void ProcessMinidump::Clear() { Process::m_thread_list.Clear(); }
+
+bool ProcessMinidump::UpdateThreadList(
+    lldb_private::ThreadList &old_thread_list,
+    lldb_private::ThreadList &new_thread_list) {
+  uint32_t num_threads = 0;
+  if (m_thread_list.size() > 0)
+    num_threads = m_thread_list.size();
+
+  for (lldb::tid_t tid = 0; tid < num_threads; ++tid) {
+    lldb::ThreadSP thread_sp(new ThreadMinidump(
+        *this, m_thread_list[tid],
+        m_minidump_parser.GetThreadContext(m_thread_list[tid])));
+    new_thread_list.AddThread(thread_sp);
+  }
+  return new_thread_list.GetSize(false) > 0;
+}
+
+void ProcessMinidump::ReadModuleList() {
+  llvm::ArrayRef<MinidumpModule> modules = m_minidump_parser.GetModuleList();
+
+  for (auto module : modules) {
+    llvm::Optional<std::string> name =
+        m_minidump_parser.GetMinidumpString(module.module_name_rva);
+
+    if (!name)
+      continue;
+
+    const auto file_spec = FileSpec(name.getValue(), true);
+    ModuleSpec module_spec = file_spec;
+    Error error;
+    lldb::ModuleSP module_sp =
+        this->GetTarget().GetSharedModule(module_spec, &error);
+    if (!module_sp || error.Fail()) {
+      continue;
+    }
+
+    bool load_addr_changed = false;
+    module_sp->SetLoadAddress(this->GetTarget(), module.base_of_image, false,
+                              load_addr_changed);
+  }
+}

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

+//===-- ThreadMinidump.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_ThreadMinidump_h_
+#define liblldb_ThreadMinidump_h_
+
+// Project includes
+#include "MinidumpTypes.h"
+
+// Other libraries and framework includes
+#include "lldb/Target/Thread.h"
+
+// C Includes
+// C++ Includes
+
+namespace lldb_private {
+
+namespace minidump {
+
+class ThreadMinidump : public Thread {
+public:
+  ThreadMinidump(Process &process, const MinidumpThread &td,
+                 llvm::ArrayRef<uint8_t> gpregset_data);
+
+  ~ThreadMinidump() override;
+
+  void RefreshStateAfterStop() override;
+
+  lldb::RegisterContextSP GetRegisterContext() override;
+
+  lldb::RegisterContextSP
+  CreateRegisterContextForFrame(StackFrame *frame) override;
+
+  void ClearStackFrames() override;
+
+protected:
+  lldb::RegisterContextSP m_thread_reg_ctx_sp;
+  llvm::ArrayRef<uint8_t> m_gpregset_data;
+
+  bool CalculateStopInfo() override;
+};
+
+} // namespace minidump
+} // namespace lldb_private
+
+#endif // liblldb_ThreadMinidump_h_

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

+//===-- ThreadMinidump.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 "ThreadMinidump.h"
+#include "ProcessMinidump.h"
+
+#include "RegisterContextMinidump_x86_64.h"
+
+// Other libraries and framework includes
+#include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
+
+#include "Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.h"
+
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Unwind.h"
+
+// C Includes
+// C++ Includes
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace minidump;
+
+ThreadMinidump::ThreadMinidump(Process &process, const MinidumpThread &td,
+                               llvm::ArrayRef<uint8_t> gpregset_data)
+    : Thread(process, td.thread_id), m_thread_reg_ctx_sp(),
+      m_gpregset_data(gpregset_data) {}
+
+ThreadMinidump::~ThreadMinidump() {}
+
+void ThreadMinidump::RefreshStateAfterStop() {}
+
+void ThreadMinidump::ClearStackFrames() {}
+
+RegisterContextSP ThreadMinidump::GetRegisterContext() {
+  if (!m_reg_context_sp) {
+    m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
+  }
+  return m_reg_context_sp;
+}
+
+RegisterContextSP
+ThreadMinidump::CreateRegisterContextForFrame(StackFrame *frame) {
+  RegisterContextSP reg_ctx_sp;
+  uint32_t concrete_frame_idx = 0;
+  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_THREAD));
+
+  if (frame)
+    concrete_frame_idx = frame->GetConcreteFrameIndex();
+
+  if (concrete_frame_idx == 0) {
+    if (m_thread_reg_ctx_sp)
+      return m_thread_reg_ctx_sp;
+
+    ProcessMinidump *process =
+        static_cast<ProcessMinidump *>(GetProcess().get());
+    ArchSpec arch = process->GetArchitecture();
+    RegisterInfoInterface *reg_interface = nullptr;
+
+    // TODO write other register contexts and add them here
+    switch (arch.GetMachine()) {
+    case llvm::Triple::x86_64: {
+      reg_interface = new RegisterContextLinux_x86_64(arch);
+      lldb::DataBufferSP buf =
+          ConvertMinidumpContextToRegIface(m_gpregset_data, reg_interface);
+      DataExtractor gpregs(buf, lldb::eByteOrderLittle, 8);
+      DataExtractor fpregs;
+      m_thread_reg_ctx_sp.reset(new RegisterContextCorePOSIX_x86_64(
+          *this, reg_interface, gpregs, fpregs));
+      break;
+    }
+    default:
+      break;
+    }
+
+    if (!reg_interface) {
+      if (log)
+        log->Printf("elf-core::%s:: Architecture(%d) not supported",
+                    __FUNCTION__, arch.GetMachine());
+      assert(false && "Architecture not supported");
+    }
+
+    reg_ctx_sp = m_thread_reg_ctx_sp;
+  } else if (m_unwinder_ap) {
+    reg_ctx_sp = m_unwinder_ap->CreateRegisterContextForFrame(frame);
+  }
+
+  return reg_ctx_sp;
+}
+
+bool ThreadMinidump::CalculateStopInfo() { return false; }

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

void SetUpData(const char *minidump_filename, size_t load_size = SIZE_MAX) {
     parser.reset(new MinidumpParser(optional_parser.getValue()));
     ASSERT_GT(parser->GetData().size(), 0UL);
   }
 
   llvm::SmallString<128> inputs_folder;
   std::unique_ptr<MinidumpParser> parser;
 };
 
-TEST_F(MinidumpParserTest, GetThreads) {
+TEST_F(MinidumpParserTest, GetThreadsAndGetThreadContext) {
   SetUpData("linux-x86_64.dmp");
   llvm::ArrayRef<MinidumpThread> thread_list;
 
   thread_list = parser->GetThreads();
   ASSERT_EQ(1UL, thread_list.size());
 
   const MinidumpThread thread = thread_list[0];
-  ASSERT_EQ(16001UL, thread.thread_id);
+  EXPECT_EQ(16001UL, thread.thread_id);
+
+  llvm::ArrayRef<uint8_t> context = parser->GetThreadContext(thread);
+  EXPECT_EQ(1232, context.size());
 }
 
 TEST_F(MinidumpParserTest, GetThreadsTruncatedFile) {
   SetUpData("linux-x86_64.dmp", 200);
   llvm::ArrayRef<MinidumpThread> thread_list;
 
   thread_list = parser->GetThreads();
   ASSERT_EQ(0UL, thread_list.size());

 TEST_F(MinidumpParserTest, GetExceptionStream) {
   SetUpData("linux-x86_64.dmp");
   const MinidumpExceptionStream *exception_stream =
       parser->GetExceptionStream();
   ASSERT_NE(nullptr, exception_stream);
   ASSERT_EQ(11UL, exception_stream->exception_record.exception_code);
 }
 
+TEST_F(MinidumpParserTest, GetMemoryRange) {
+  SetUpData("linux-x86_64.dmp");
+  // There are two memory ranges in the file (size is in bytes, decimal):
+  // 1) 0x7ffceb34a000 12288
+  // 2) 0x401d46 256
+  EXPECT_TRUE(parser->FindMemoryRange(0x7ffceb34a000).hasValue());
+  EXPECT_TRUE(parser->FindMemoryRange(0x7ffceb34a000 + 12288 / 2).hasValue());
+  EXPECT_TRUE(parser->FindMemoryRange(0x7ffceb34a000 + 12288 - 1).hasValue());
+  EXPECT_FALSE(parser->FindMemoryRange(0x7ffceb34a000 + 12288).hasValue());
+
+  EXPECT_TRUE(parser->FindMemoryRange(0x401d46).hasValue());
+  EXPECT_TRUE(parser->FindMemoryRange(0x401d46 + 256 / 2).hasValue());
+  EXPECT_TRUE(parser->FindMemoryRange(0x401d46 + 256 - 1).hasValue());
+  EXPECT_FALSE(parser->FindMemoryRange(0x401d46 + 256).hasValue());
+
+  EXPECT_FALSE(parser->FindMemoryRange(0x2a).hasValue());
+}
+
 // Windows Minidump tests
 // fizzbuzz_no_heap.dmp is copied from the WinMiniDump tests
 TEST_F(MinidumpParserTest, GetArchitectureWindows) {
   SetUpData("fizzbuzz_no_heap.dmp");
   ASSERT_EQ(llvm::Triple::ArchType::x86,
             parser->GetArchitecture().GetMachine());
   ASSERT_EQ(llvm::Triple::OSType::Win32,
             parser->GetArchitecture().GetTriple().getOS());

 TEST_F(MinidumpParserTest, GetPidWindows) {
   SetUpData("fizzbuzz_no_heap.dmp");
   llvm::Optional<lldb::pid_t> pid = parser->GetPid();
   ASSERT_TRUE(pid.hasValue());
   ASSERT_EQ(4440UL, pid.getValue());
 }
 
 // Register stuff
-// TODO probably split register stuff tests into different file?
 #define REG_VAL(x) *(reinterpret_cast<uint64_t *>(x))
 
 TEST_F(MinidumpParserTest, ConvertRegisterContext) {
   SetUpData("linux-x86_64.dmp");
   llvm::ArrayRef<MinidumpThread> thread_list = parser->GetThreads();
   const MinidumpThread thread = thread_list[0];
   llvm::ArrayRef<uint8_t> registers(parser->GetData().data() +
                                         thread.thread_context.rva,