dvlahovski created this revision.
dvlahovski added reviewers: labath, zturner.
dvlahovski added subscribers: lldb-commits, amccarth.
Herald added subscribers: modocache, mgorny, beanz.
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.
https://reviews.llvm.org/D25196
Files:
packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile
packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py
packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp
packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.dmp
packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp
packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.dmp
source/API/SystemInitializerFull.cpp
source/Plugins/Process/minidump/CMakeLists.txt
source/Plugins/Process/minidump/MinidumpParser.cpp
source/Plugins/Process/minidump/MinidumpParser.h
source/Plugins/Process/minidump/MinidumpTypes.cpp
source/Plugins/Process/minidump/MinidumpTypes.h
source/Plugins/Process/minidump/ProcessMinidump.cpp
source/Plugins/Process/minidump/ProcessMinidump.h
source/Plugins/Process/minidump/ThreadMinidump.cpp
source/Plugins/Process/minidump/ThreadMinidump.h
unittests/Process/minidump/MinidumpParserTest.cpp
Index: unittests/Process/minidump/MinidumpParserTest.cpp
===================================================================
--- unittests/Process/minidump/MinidumpParserTest.cpp
+++ unittests/Process/minidump/MinidumpParserTest.cpp
@@ -139,6 +139,8 @@
ASSERT_EQ(11UL, exception_stream->exception_record.exception_code);
}
+//TODO add tests for MemoryList parsing
+
// Windows Minidump tests
// fizzbuzz_no_heap.dmp is copied from the WinMiniDump tests
TEST_F(MinidumpParserTest, GetArchitectureWindows) {
@@ -172,7 +174,6 @@
}
// Register stuff
-// TODO probably split register stuff tests into different file?
#define REG_VAL(x) *(reinterpret_cast<uint64_t *>(x))
TEST_F(MinidumpParserTest, ConvertRegisterContext) {
Index: source/Plugins/Process/minidump/ThreadMinidump.h
===================================================================
--- /dev/null
+++ source/Plugins/Process/minidump/ThreadMinidump.h
@@ -0,0 +1,51 @@
+//===-- 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);
+
+ ~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_
Index: source/Plugins/Process/minidump/ThreadMinidump.cpp
===================================================================
--- /dev/null
+++ source/Plugins/Process/minidump/ThreadMinidump.cpp
@@ -0,0 +1,121 @@
+//===-- 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)
+ : Thread(process, td.thread_id), m_thread_reg_ctx_sp(), m_gpregset_data() {
+ ProcessMinidump *process_ =
+ static_cast<ProcessMinidump *>(GetProcess().get());
+ llvm::ArrayRef<uint8_t> arr_ref(process_->m_minidump_parser.GetData().data() +
+ td.thread_context.rva,
+ td.thread_context.data_size);
+ // TODO wow64 context in the TEB
+
+ m_gpregset_data = arr_ref;
+}
+
+ThreadMinidump::~ThreadMinidump() {
+ // TODO should we use this? WinMinidump doesn't use it but elf-core does
+ DestroyThread();
+}
+
+void ThreadMinidump::RefreshStateAfterStop() {
+ // TODO should we use this? WinMinidump doesn't use it but elf-core does
+ GetRegisterContext()->InvalidateIfNeeded(false);
+}
+
+void ThreadMinidump::ClearStackFrames() {
+ // TODO should we use this? WinMinidump doesn't use it but elf-core does
+ Unwind *unwinder = GetUnwinder();
+ if (unwinder)
+ unwinder->Clear();
+ Thread::ClearStackFrames();
+}
+
+RegisterContextSP ThreadMinidump::GetRegisterContext() {
+ if (m_reg_context_sp.get() == NULL) {
+ m_reg_context_sp = CreateRegisterContextForFrame(NULL);
+ }
+ 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 = NULL;
+
+ // 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; }
Index: source/Plugins/Process/minidump/ProcessMinidump.h
===================================================================
--- /dev/null
+++ source/Plugins/Process/minidump/ProcessMinidump.h
@@ -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_
Index: source/Plugins/Process/minidump/ProcessMinidump.cpp
===================================================================
--- /dev/null
+++ source/Plugins/Process/minidump/ProcessMinidump.cpp
@@ -0,0 +1,256 @@
+//===-- 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) {
+ lldb::ProcessSP process_sp;
+ if (crash_file) {
+ // Read enough data for the Minidump header
+ const size_t header_size = sizeof(MinidumpHeader);
+ lldb::DataBufferSP data_sp(
+ crash_file->MemoryMapFileContents(0, header_size));
+ llvm::ArrayRef<uint8_t> header_data(data_sp->GetBytes(), header_size);
+ const MinidumpHeader *header = MinidumpHeader::Parse(header_data);
+
+ if (data_sp && data_sp->GetByteSize() == header_size && header != nullptr) {
+ lldb::DataBufferSP all_data_sp(crash_file->MemoryMapFileContents());
+ auto minidump_parser = MinidumpParser::Create(all_data_sp);
+ // check if the parser object is valid
+ if (minidump_parser)
+ process_sp.reset(new ProcessMinidump(
+ target_sp, listener_sp, *crash_file, minidump_parser.getValue()));
+ }
+ }
+ return process_sp;
+}
+
+// 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;
+}
+
+// TODO is this ok? copied from gdb-remote
+DynamicLoader *ProcessMinidump::GetDynamicLoader() {
+ if (m_dyld_ap.get() == NULL)
+ m_dyld_ap.reset(DynamicLoader::FindPlugin(this, NULL));
+ return m_dyld_ap.get();
+}
+
+ConstString ProcessMinidump::GetPluginName() { return GetPluginNameStatic(); }
+
+uint32_t ProcessMinidump::GetPluginVersion() { return 1; }
+
+Error ProcessMinidump::DoDestroy() { return Error(); }
+
+void ProcessMinidump::RefreshStateAfterStop() {
+ bool stopped = false;
+ lldb::StopInfoSP stop_info;
+ lldb::ThreadSP stop_thread;
+
+ if (m_active_exception == nullptr) {
+ stop_thread = Process::m_thread_list.GetSelectedThread();
+ stop_info = StopInfo::CreateStopReasonWithException(
+ *stop_thread, "No ExceptionStream found in file!");
+ stop_thread->SetStopInfo(stop_info);
+ return;
+ }
+
+ 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);
+ stopped = stop_info->ShouldStopSynchronous(nullptr);
+ }
+
+ if (!stopped) {
+ 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 our 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.
+ Range range = {0, 0, nullptr};
+ if (!m_minidump_parser.FindMemoryRange(addr, &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.size);
+ const size_t overlap = std::min(size, range.size - offset);
+ std::memcpy(buf, range.ptr + 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]));
+ 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.hasValue())
+ 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);
+ }
+}
Index: source/Plugins/Process/minidump/MinidumpTypes.h
===================================================================
--- source/Plugins/Process/minidump/MinidumpTypes.h
+++ source/Plugins/Process/minidump/MinidumpTypes.h
@@ -207,6 +207,9 @@
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!");
Index: source/Plugins/Process/minidump/MinidumpTypes.cpp
===================================================================
--- source/Plugins/Process/minidump/MinidumpTypes.cpp
+++ source/Plugins/Process/minidump/MinidumpTypes.cpp
@@ -176,3 +176,16 @@
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::ArrayRef<MinidumpMemoryDescriptor>(
+ reinterpret_cast<const MinidumpMemoryDescriptor *>(data.data()),
+ *mem_ranges_count);
+}
Index: source/Plugins/Process/minidump/MinidumpParser.h
===================================================================
--- source/Plugins/Process/minidump/MinidumpParser.h
+++ source/Plugins/Process/minidump/MinidumpParser.h
@@ -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,19 @@
#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
+ size_t size; // size of the range in bytes
+ const uint8_t *ptr; // absolute pointer to the first byte of the range
+};
+
class MinidumpParser {
public:
static llvm::Optional<MinidumpParser>
@@ -61,6 +64,8 @@
const MinidumpExceptionStream *GetExceptionStream();
+ bool FindMemoryRange(lldb::addr_t addr, Range *range_out);
+
private:
lldb::DataBufferSP m_data_sp;
const MinidumpHeader *m_header;
Index: source/Plugins/Process/minidump/MinidumpParser.cpp
===================================================================
--- source/Plugins/Process/minidump/MinidumpParser.cpp
+++ source/Plugins/Process/minidump/MinidumpParser.cpp
@@ -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"
@@ -224,3 +224,33 @@
return MinidumpExceptionStream::Parse(data);
}
+
+bool MinidumpParser::FindMemoryRange(lldb::addr_t addr, Range *range_out) {
+ llvm::ArrayRef<uint8_t> data = GetStream(MinidumpStreamType::MemoryList);
+
+ if (data.size() == 0)
+ return false;
+
+ llvm::ArrayRef<MinidumpMemoryDescriptor> memory_list =
+ MinidumpMemoryDescriptor::ParseMemoryList(data);
+
+ if (memory_list.size() == 0)
+ return false;
+
+ 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 (range_start <= addr && addr < range_start + range_size) {
+ range_out->start = range_start;
+ range_out->size = range_size;
+ range_out->ptr = GetData().data() + loc_desc.rva;
+ return true;
+ }
+ }
+
+ // TODO parse Memory64List which is present in full-memory Minidumps
+
+ return false;
+}
Index: source/Plugins/Process/minidump/CMakeLists.txt
===================================================================
--- source/Plugins/Process/minidump/CMakeLists.txt
+++ source/Plugins/Process/minidump/CMakeLists.txt
@@ -4,4 +4,6 @@
MinidumpTypes.cpp
MinidumpParser.cpp
RegisterContextMinidump_x86_64.cpp
+ ThreadMinidump.cpp
+ ProcessMinidump.cpp
)
Index: source/API/SystemInitializerFull.cpp
===================================================================
--- source/API/SystemInitializerFull.cpp
+++ source/API/SystemInitializerFull.cpp
@@ -78,6 +78,11 @@
#include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
#include "Plugins/Process/elf-core/ProcessElfCore.h"
#include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+
+#if !defined(_MSC_VER)
+#include "Plugins/Process/minidump/ProcessMinidump.h"
+#endif
+
#include "Plugins/ScriptInterpreter/None/ScriptInterpreterNone.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
@@ -306,6 +311,8 @@
ProcessElfCore::Initialize();
#if defined(_MSC_VER)
ProcessWinMiniDump::Initialize();
+#else
+ minidump::ProcessMinidump::Initialize();
#endif
MemoryHistoryASan::Initialize();
AddressSanitizerRuntime::Initialize();
@@ -429,8 +436,11 @@
JITLoaderGDB::Terminate();
ProcessElfCore::Terminate();
+
#if defined(_MSC_VER)
ProcessWinMiniDump::Terminate();
+#else
+ minidump::ProcessMinidump::Terminate();
#endif
MemoryHistoryASan::Terminate();
AddressSanitizerRuntime::Terminate();
Index: packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp
===================================================================
--- /dev/null
+++ packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64_not_crashed.cpp
@@ -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;
+}
Index: packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp
===================================================================
--- /dev/null
+++ packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/linux-x86_64.cpp
@@ -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;
+}
Index: packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py
===================================================================
--- /dev/null
+++ packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/TestMiniDumpNew.py
@@ -0,0 +1,91 @@
+"""
+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_test
+ 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)
+
+ @no_debug_info_test
+ 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)
+
+ @no_debug_info_test
+ 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())
+
+ @not_remote_testsuite_ready
+ 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)
+
+ @not_remote_testsuite_ready
+ 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)
Index: packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile
===================================================================
--- /dev/null
+++ packages/Python/lldbsuite/test/functionalities/postmortem/minidump-new/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules
+
_______________________________________________
lldb-commits mailing list
[email protected]
http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
