[Lldb-commits] [lldb] r283259 - Adding a new Minidump post-mortem debugging plugin
Dimitar Vlahovski via lldb-commits
lldb-commits at lists.llvm.org
Tue Oct 4 14:02:14 PDT 2016
Author: dvlahovski
Date: Tue Oct 4 16:02:13 2016
New Revision: 283259
URL: http://llvm.org/viewvc/llvm-project?rev=283259&view=rev
Log:
Adding a new Minidump post-mortem debugging plugin
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.
Reviewers: labath, zturner
Subscribers: beanz, mgorny, amccarth, lldb-commits, modocache
Differential Revision: https://reviews.llvm.org/D25196
Added:
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.dmp
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp
lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.dmp
lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp
lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.h
lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.cpp
lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.h
Modified:
lldb/trunk/source/API/SystemInitializerFull.cpp
lldb/trunk/source/Plugins/Process/minidump/CMakeLists.txt
lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp
lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.h
lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.cpp
lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.h
lldb/trunk/unittests/Process/minidump/MinidumpParserTest.cpp
Added: lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile?rev=283259&view=auto
==============================================================================
--- lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile (added)
+++ lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile Tue Oct 4 16:02:13 2016
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
+
Added: lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py?rev=283259&view=auto
==============================================================================
--- lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py (added)
+++ lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py Tue Oct 4 16:02:13 2016
@@ -0,0 +1,100 @@
+"""
+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)
Added: lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp?rev=283259&view=auto
==============================================================================
--- lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp (added)
+++ lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp Tue Oct 4 16:02:13 2016
@@ -0,0 +1,28 @@
+// 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;
+}
Added: lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.dmp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.dmp?rev=283259&view=auto
==============================================================================
Binary files lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.dmp (added) and lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.dmp Tue Oct 4 16:02:13 2016 differ
Added: lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp?rev=283259&view=auto
==============================================================================
--- lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp (added)
+++ lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp Tue Oct 4 16:02:13 2016
@@ -0,0 +1,36 @@
+#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;
+}
Added: lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.dmp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.dmp?rev=283259&view=auto
==============================================================================
Binary files lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.dmp (added) and lldb/trunk/packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.dmp Tue Oct 4 16:02:13 2016 differ
Modified: lldb/trunk/source/API/SystemInitializerFull.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/API/SystemInitializerFull.cpp?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/source/API/SystemInitializerFull.cpp (original)
+++ lldb/trunk/source/API/SystemInitializerFull.cpp Tue Oct 4 16:02:13 2016
@@ -78,6 +78,7 @@
#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"
@@ -307,6 +308,7 @@ void SystemInitializerFull::Initialize()
#if defined(_MSC_VER)
ProcessWinMiniDump::Initialize();
#endif
+ minidump::ProcessMinidump::Initialize();
MemoryHistoryASan::Initialize();
AddressSanitizerRuntime::Initialize();
ThreadSanitizerRuntime::Initialize();
@@ -429,9 +431,11 @@ void SystemInitializerFull::Terminate()
JITLoaderGDB::Terminate();
ProcessElfCore::Terminate();
+
#if defined(_MSC_VER)
ProcessWinMiniDump::Terminate();
#endif
+ minidump::ProcessMinidump::Terminate();
MemoryHistoryASan::Terminate();
AddressSanitizerRuntime::Terminate();
ThreadSanitizerRuntime::Terminate();
Modified: lldb/trunk/source/Plugins/Process/minidump/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/CMakeLists.txt?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/CMakeLists.txt (original)
+++ lldb/trunk/source/Plugins/Process/minidump/CMakeLists.txt Tue Oct 4 16:02:13 2016
@@ -4,4 +4,6 @@ add_lldb_library(lldbPluginProcessMinidu
MinidumpTypes.cpp
MinidumpParser.cpp
RegisterContextMinidump_x86_64.cpp
+ ThreadMinidump.cpp
+ ProcessMinidump.cpp
)
Modified: lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp (original)
+++ lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.cpp Tue Oct 4 16:02:13 2016
@@ -1,11 +1,11 @@
-//===-- 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"
@@ -65,8 +65,7 @@ MinidumpParser::MinidumpParser(
}
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>
@@ -76,15 +75,14 @@ MinidumpParser::GetStream(MinidumpStream
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);
@@ -100,6 +98,14 @@ llvm::ArrayRef<MinidumpThread> MinidumpP
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);
@@ -224,3 +230,33 @@ const MinidumpExceptionStream *MinidumpP
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;
+}
Modified: lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.h?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.h (original)
+++ lldb/trunk/source/Plugins/Process/minidump/MinidumpParser.h Tue Oct 4 16:02:13 2016
@@ -1,12 +1,11 @@
-//===-- 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_
@@ -25,15 +24,22 @@
#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>
@@ -47,6 +53,8 @@ public:
llvm::ArrayRef<MinidumpThread> GetThreads();
+ llvm::ArrayRef<uint8_t> GetThreadContext(const MinidumpThread &td);
+
const MinidumpSystemInfo *GetSystemInfo();
ArchSpec GetArchitecture();
@@ -61,6 +69,8 @@ public:
const MinidumpExceptionStream *GetExceptionStream();
+ llvm::Optional<Range> FindMemoryRange(lldb::addr_t addr);
+
private:
lldb::DataBufferSP m_data_sp;
const MinidumpHeader *m_header;
Modified: lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.cpp?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.cpp (original)
+++ lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.cpp Tue Oct 4 16:02:13 2016
@@ -85,7 +85,7 @@ MinidumpThread::ParseThreadList(llvm::Ar
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);
}
@@ -162,7 +162,7 @@ MinidumpModule::ParseModuleList(llvm::Ar
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);
}
@@ -176,3 +176,16 @@ MinidumpExceptionStream::Parse(llvm::Arr
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);
+}
Modified: lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.h?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.h (original)
+++ lldb/trunk/source/Plugins/Process/minidump/MinidumpTypes.h Tue Oct 4 16:02:13 2016
@@ -207,6 +207,9 @@ static_assert(sizeof(MinidumpLocationDes
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!");
@@ -362,7 +365,8 @@ static_assert(sizeof(MinidumpModule) ==
// Exception stuff
struct MinidumpException {
enum {
- MaxParams = 15,
+ ExceptonInfoMaxParams = 15,
+ DumpRequested = 0xFFFFFFFF,
};
llvm::support::ulittle32_t exception_code;
@@ -371,7 +375,7 @@ struct MinidumpException {
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!");
Added: lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp?rev=283259&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp (added)
+++ lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.cpp Tue Oct 4 16:02:13 2016
@@ -0,0 +1,263 @@
+//===-- 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);
+ }
+}
Added: lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.h?rev=283259&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.h (added)
+++ lldb/trunk/source/Plugins/Process/minidump/ProcessMinidump.h Tue Oct 4 16:02:13 2016
@@ -0,0 +1,103 @@
+//===-- 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_
Added: lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.cpp?rev=283259&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.cpp (added)
+++ lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.cpp Tue Oct 4 16:02:13 2016
@@ -0,0 +1,102 @@
+//===-- 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; }
Added: lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.h
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.h?rev=283259&view=auto
==============================================================================
--- lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.h (added)
+++ lldb/trunk/source/Plugins/Process/minidump/ThreadMinidump.h Tue Oct 4 16:02:13 2016
@@ -0,0 +1,52 @@
+//===-- 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_
Modified: lldb/trunk/unittests/Process/minidump/MinidumpParserTest.cpp
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/unittests/Process/minidump/MinidumpParserTest.cpp?rev=283259&r1=283258&r2=283259&view=diff
==============================================================================
--- lldb/trunk/unittests/Process/minidump/MinidumpParserTest.cpp (original)
+++ lldb/trunk/unittests/Process/minidump/MinidumpParserTest.cpp Tue Oct 4 16:02:13 2016
@@ -60,7 +60,7 @@ public:
std::unique_ptr<MinidumpParser> parser;
};
-TEST_F(MinidumpParserTest, GetThreads) {
+TEST_F(MinidumpParserTest, GetThreadsAndGetThreadContext) {
SetUpData("linux-x86_64.dmp");
llvm::ArrayRef<MinidumpThread> thread_list;
@@ -68,7 +68,10 @@ TEST_F(MinidumpParserTest, 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) {
@@ -139,6 +142,24 @@ TEST_F(MinidumpParserTest, GetExceptionS
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) {
@@ -172,7 +193,6 @@ TEST_F(MinidumpParserTest, GetPidWindows
}
// Register stuff
-// TODO probably split register stuff tests into different file?
#define REG_VAL(x) *(reinterpret_cast<uint64_t *>(x))
TEST_F(MinidumpParserTest, ConvertRegisterContext) {
More information about the lldb-commits
mailing list