forked from OSchip/llvm-project
Remove Windows-specific minidump plugin
With the cross-platform minidump plugin working, the Windows-specific one is no longer needed. This eliminates the unnecessary code. This does not eliminate the Windows-specific tests, as they hit a few cases the general tests don't. (The Windows-specific tests are currently passing.) I'll look into a separate patch to make sure we're not doing too much duplicate testing. After that I might do a little re-org in the Windows plugin, as there was some factoring there (Common & Live) that probably isn't necessary anymore. Differential Revision: https://reviews.llvm.org/D26697 llvm-svn: 287113
This commit is contained in:
Adrian McCarthy
parent
6735448751
commit
1ca677f4c4
|
|
@ -21,7 +21,7 @@ set( LLDB_USED_LIBS
|
||||||
lldbPluginDynamicLoaderPosixDYLD
|
lldbPluginDynamicLoaderPosixDYLD
|
||||||
lldbPluginDynamicLoaderHexagonDYLD
|
lldbPluginDynamicLoaderHexagonDYLD
|
||||||
lldbPluginDynamicLoaderWindowsDYLD
|
lldbPluginDynamicLoaderWindowsDYLD
|
||||||
|
|
||||||
lldbPluginCPlusPlusLanguage
|
lldbPluginCPlusPlusLanguage
|
||||||
lldbPluginGoLanguage
|
lldbPluginGoLanguage
|
||||||
lldbPluginJavaLanguage
|
lldbPluginJavaLanguage
|
||||||
|
|
@ -91,7 +91,6 @@ set( LLDB_USED_LIBS
|
||||||
if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
|
if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
|
||||||
list(APPEND LLDB_USED_LIBS
|
list(APPEND LLDB_USED_LIBS
|
||||||
lldbPluginProcessWindows
|
lldbPluginProcessWindows
|
||||||
lldbPluginProcessWinMiniDump
|
|
||||||
lldbPluginProcessWindowsCommon
|
lldbPluginProcessWindowsCommon
|
||||||
Ws2_32
|
Ws2_32
|
||||||
Rpcrt4
|
Rpcrt4
|
||||||
|
|
|
||||||
|
|
@ -8,7 +8,6 @@ elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD")
|
||||||
add_subdirectory(POSIX)
|
add_subdirectory(POSIX)
|
||||||
elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
|
elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
|
||||||
add_subdirectory(Windows/Live)
|
add_subdirectory(Windows/Live)
|
||||||
add_subdirectory(Windows/MiniDump)
|
|
||||||
add_subdirectory(Windows/Common)
|
add_subdirectory(Windows/Common)
|
||||||
elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
|
elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
|
||||||
add_subdirectory(MacOSX-Kernel)
|
add_subdirectory(MacOSX-Kernel)
|
||||||
|
|
|
||||||
|
|
@ -1,21 +0,0 @@
|
||||||
include_directories(../../Utility)
|
|
||||||
include_directories(../Common)
|
|
||||||
|
|
||||||
set(PROC_WINDOWS_MINIDUMP_SOURCES
|
|
||||||
ProcessWinMiniDump.cpp
|
|
||||||
ThreadWinMiniDump.cpp
|
|
||||||
)
|
|
||||||
|
|
||||||
if (CMAKE_SIZEOF_VOID_P EQUAL 4)
|
|
||||||
set(PROC_WINDOWS_MINIDUMP_SOURCES ${PROC_WINDOWS_MINIDUMP_SOURCES}
|
|
||||||
x86/RegisterContextWindowsMiniDump_x86.cpp
|
|
||||||
)
|
|
||||||
elseif (CMAKE_SIZEOF_VOID_P EQUAL 8)
|
|
||||||
set(PROC_WINDOWS_MINIDUMP_SOURCES ${PROC_WINDOWS_MINIDUMP_SOURCES}
|
|
||||||
x64/RegisterContextWindowsMiniDump_x64.cpp
|
|
||||||
)
|
|
||||||
endif()
|
|
||||||
|
|
||||||
add_lldb_library(lldbPluginProcessWinMiniDump
|
|
||||||
${PROC_WINDOWS_MINIDUMP_SOURCES}
|
|
||||||
)
|
|
||||||
|
|
@ -1,631 +0,0 @@
|
||||||
//===-- ProcessWinMiniDump.cpp ----------------------------------*- C++ -*-===//
|
|
||||||
//
|
|
||||||
// The LLVM Compiler Infrastructure
|
|
||||||
//
|
|
||||||
// This file is distributed under the University of Illinois Open Source
|
|
||||||
// License. See LICENSE.TXT for details.
|
|
||||||
//
|
|
||||||
//===----------------------------------------------------------------------===//
|
|
||||||
|
|
||||||
#include "ProcessWinMiniDump.h"
|
|
||||||
|
|
||||||
#include "lldb/Host/windows/windows.h"
|
|
||||||
#include <DbgHelp.h>
|
|
||||||
|
|
||||||
#include <assert.h>
|
|
||||||
#include <memory>
|
|
||||||
#include <mutex>
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
|
|
||||||
#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/StopInfo.h"
|
|
||||||
#include "lldb/Target/Target.h"
|
|
||||||
#include "lldb/Target/UnixSignals.h"
|
|
||||||
#include "lldb/Utility/LLDBAssert.h"
|
|
||||||
#include "llvm/Support/ConvertUTF.h"
|
|
||||||
#include "llvm/Support/Format.h"
|
|
||||||
#include "llvm/Support/raw_ostream.h"
|
|
||||||
|
|
||||||
#include "Plugins/Process/Windows/Common/NtStructures.h"
|
|
||||||
#include "Plugins/Process/Windows/Common/ProcessWindowsLog.h"
|
|
||||||
|
|
||||||
#include "ExceptionRecord.h"
|
|
||||||
#include "ThreadWinMiniDump.h"
|
|
||||||
|
|
||||||
using namespace lldb_private;
|
|
||||||
|
|
||||||
// Implementation class for ProcessWinMiniDump encapsulates the Windows-specific
|
|
||||||
// code, keeping non-portable types out of the header files.
|
|
||||||
// TODO(amccarth): Determine if we need a mutex for access. Given that this is
|
|
||||||
// postmortem debugging, I don't think so.
|
|
||||||
class ProcessWinMiniDump::Impl {
|
|
||||||
public:
|
|
||||||
Impl(const FileSpec &core_file, ProcessWinMiniDump *self);
|
|
||||||
~Impl();
|
|
||||||
|
|
||||||
Error DoLoadCore();
|
|
||||||
|
|
||||||
bool UpdateThreadList(ThreadList &old_thread_list,
|
|
||||||
ThreadList &new_thread_list);
|
|
||||||
|
|
||||||
void RefreshStateAfterStop();
|
|
||||||
|
|
||||||
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Error &error);
|
|
||||||
|
|
||||||
Error GetMemoryRegionInfo(lldb::addr_t load_addr,
|
|
||||||
lldb_private::MemoryRegionInfo &info);
|
|
||||||
|
|
||||||
private:
|
|
||||||
// Describes a range of memory captured in the mini dump.
|
|
||||||
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
|
|
||||||
};
|
|
||||||
|
|
||||||
// If the mini dump has a memory range that contains the desired address, it
|
|
||||||
// returns true with the details of the range in *range_out. Otherwise, it
|
|
||||||
// returns false.
|
|
||||||
bool FindMemoryRange(lldb::addr_t addr, Range *range_out) const;
|
|
||||||
|
|
||||||
lldb_private::Error MapMiniDumpIntoMemory();
|
|
||||||
|
|
||||||
lldb_private::ArchSpec DetermineArchitecture();
|
|
||||||
|
|
||||||
void ReadExceptionRecord();
|
|
||||||
|
|
||||||
void ReadMiscInfo();
|
|
||||||
|
|
||||||
void ReadModuleList();
|
|
||||||
|
|
||||||
// A thin wrapper around WinAPI's MiniDumpReadDumpStream to avoid redundant
|
|
||||||
// checks. If there's a failure (e.g., if the requested stream doesn't
|
|
||||||
// exist),
|
|
||||||
// the function returns nullptr and sets *size_out to 0.
|
|
||||||
void *FindDumpStream(unsigned stream_number, size_t *size_out) const;
|
|
||||||
|
|
||||||
// Getting a string out of a mini dump is a chore. You're usually given a
|
|
||||||
// relative virtual address (RVA), which points to a counted string that's in
|
|
||||||
// Windows Unicode (UTF-16). This wrapper handles all the redirection and
|
|
||||||
// returns a UTF-8 copy of the string.
|
|
||||||
std::string GetMiniDumpString(RVA rva) const;
|
|
||||||
|
|
||||||
ProcessWinMiniDump *m_self; // non-owning back pointer
|
|
||||||
FileSpec m_core_file;
|
|
||||||
HANDLE m_dump_file; // handle to the open minidump file
|
|
||||||
HANDLE m_mapping; // handle to the file mapping for the minidump file
|
|
||||||
void *m_base_addr; // base memory address of the minidump
|
|
||||||
std::shared_ptr<ExceptionRecord> m_exception_sp;
|
|
||||||
bool m_is_wow64; // minidump is of a 32-bit process captured with a 64-bit
|
|
||||||
// debugger
|
|
||||||
};
|
|
||||||
|
|
||||||
ProcessWinMiniDump::Impl::Impl(const FileSpec &core_file,
|
|
||||||
ProcessWinMiniDump *self)
|
|
||||||
: m_self(self), m_core_file(core_file), m_dump_file(INVALID_HANDLE_VALUE),
|
|
||||||
m_mapping(NULL), m_base_addr(nullptr), m_exception_sp(),
|
|
||||||
m_is_wow64(false) {}
|
|
||||||
|
|
||||||
ProcessWinMiniDump::Impl::~Impl() {
|
|
||||||
if (m_base_addr) {
|
|
||||||
::UnmapViewOfFile(m_base_addr);
|
|
||||||
m_base_addr = nullptr;
|
|
||||||
}
|
|
||||||
if (m_mapping) {
|
|
||||||
::CloseHandle(m_mapping);
|
|
||||||
m_mapping = NULL;
|
|
||||||
}
|
|
||||||
if (m_dump_file != INVALID_HANDLE_VALUE) {
|
|
||||||
::CloseHandle(m_dump_file);
|
|
||||||
m_dump_file = INVALID_HANDLE_VALUE;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
Error ProcessWinMiniDump::Impl::DoLoadCore() {
|
|
||||||
Error error = MapMiniDumpIntoMemory();
|
|
||||||
if (error.Fail()) {
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
m_self->GetTarget().SetArchitecture(DetermineArchitecture());
|
|
||||||
ReadMiscInfo(); // notably for process ID
|
|
||||||
ReadModuleList();
|
|
||||||
ReadExceptionRecord();
|
|
||||||
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ProcessWinMiniDump::Impl::UpdateThreadList(ThreadList &old_thread_list,
|
|
||||||
ThreadList &new_thread_list) {
|
|
||||||
size_t size = 0;
|
|
||||||
auto thread_list_ptr = static_cast<const MINIDUMP_THREAD_LIST *>(
|
|
||||||
FindDumpStream(ThreadListStream, &size));
|
|
||||||
if (thread_list_ptr) {
|
|
||||||
const ULONG32 thread_count = thread_list_ptr->NumberOfThreads;
|
|
||||||
for (ULONG32 i = 0; i < thread_count; ++i) {
|
|
||||||
const auto &mini_dump_thread = thread_list_ptr->Threads[i];
|
|
||||||
auto thread_sp = std::make_shared<ThreadWinMiniDump>(
|
|
||||||
*m_self, mini_dump_thread.ThreadId);
|
|
||||||
if (mini_dump_thread.ThreadContext.DataSize >= sizeof(CONTEXT)) {
|
|
||||||
const CONTEXT *context = reinterpret_cast<const CONTEXT *>(
|
|
||||||
static_cast<const char *>(m_base_addr) +
|
|
||||||
mini_dump_thread.ThreadContext.Rva);
|
|
||||||
|
|
||||||
if (m_is_wow64) {
|
|
||||||
// On Windows, a 32-bit process can run on a 64-bit machine under
|
|
||||||
// WOW64. If the minidump was captured with a 64-bit debugger, then
|
|
||||||
// the CONTEXT we just grabbed from the mini_dump_thread is the one
|
|
||||||
// for the 64-bit "native" process rather than the 32-bit "guest"
|
|
||||||
// process we care about. In this case, we can get the 32-bit CONTEXT
|
|
||||||
// from the TEB (Thread Environment Block) of the 64-bit process.
|
|
||||||
Error error;
|
|
||||||
TEB64 wow64teb = {};
|
|
||||||
m_self->ReadMemory(mini_dump_thread.Teb, &wow64teb, sizeof(wow64teb),
|
|
||||||
error);
|
|
||||||
if (error.Success()) {
|
|
||||||
// Slot 1 of the thread-local storage in the 64-bit TEB points to a
|
|
||||||
// structure that includes the 32-bit CONTEXT (after a ULONG).
|
|
||||||
// See: https://msdn.microsoft.com/en-us/library/ms681670.aspx
|
|
||||||
const lldb::addr_t addr = wow64teb.TlsSlots[1];
|
|
||||||
Range range = {};
|
|
||||||
if (FindMemoryRange(addr, &range)) {
|
|
||||||
lldbassert(range.start <= addr);
|
|
||||||
const size_t offset = addr - range.start + sizeof(ULONG);
|
|
||||||
if (offset < range.size) {
|
|
||||||
const size_t overlap = range.size - offset;
|
|
||||||
if (overlap >= sizeof(CONTEXT)) {
|
|
||||||
context =
|
|
||||||
reinterpret_cast<const CONTEXT *>(range.ptr + offset);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// NOTE: We don't currently use the TEB for anything else. If we
|
|
||||||
// need it in
|
|
||||||
// the future, the 32-bit TEB is located according to the address
|
|
||||||
// stored in the
|
|
||||||
// first slot of the 64-bit TEB (wow64teb.Reserved1[0]).
|
|
||||||
}
|
|
||||||
|
|
||||||
thread_sp->SetContext(context);
|
|
||||||
}
|
|
||||||
new_thread_list.AddThread(thread_sp);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return new_thread_list.GetSize(false) > 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Impl::RefreshStateAfterStop() {
|
|
||||||
if (!m_exception_sp)
|
|
||||||
return;
|
|
||||||
|
|
||||||
auto active_exception = m_exception_sp;
|
|
||||||
std::string desc;
|
|
||||||
llvm::raw_string_ostream desc_stream(desc);
|
|
||||||
desc_stream << "Exception "
|
|
||||||
<< llvm::format_hex(active_exception->GetExceptionCode(), 8)
|
|
||||||
<< " encountered at address "
|
|
||||||
<< llvm::format_hex(active_exception->GetExceptionAddress(), 8);
|
|
||||||
m_self->m_thread_list.SetSelectedThreadByID(active_exception->GetThreadID());
|
|
||||||
auto stop_thread = m_self->m_thread_list.GetSelectedThread();
|
|
||||||
auto stop_info = StopInfo::CreateStopReasonWithException(
|
|
||||||
*stop_thread, desc_stream.str().c_str());
|
|
||||||
stop_thread->SetStopInfo(stop_info);
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t ProcessWinMiniDump::Impl::DoReadMemory(lldb::addr_t addr, void *buf,
|
|
||||||
size_t size, Error &error) {
|
|
||||||
// I don't have a sense of how frequently this is called or how many memory
|
|
||||||
// ranges a mini dump 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 = {};
|
|
||||||
if (!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;
|
|
||||||
}
|
|
||||||
|
|
||||||
Error ProcessWinMiniDump::Impl::GetMemoryRegionInfo(
|
|
||||||
lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &info) {
|
|
||||||
Error error;
|
|
||||||
size_t size;
|
|
||||||
info.Clear();
|
|
||||||
const auto list = reinterpret_cast<const MINIDUMP_MEMORY_INFO_LIST *>(
|
|
||||||
FindDumpStream(MemoryInfoListStream, &size));
|
|
||||||
if (list == nullptr || size < sizeof(MINIDUMP_MEMORY_INFO_LIST)) {
|
|
||||||
error.SetErrorString("the mini dump contains no memory range information");
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (list->SizeOfEntry < sizeof(MINIDUMP_MEMORY_INFO)) {
|
|
||||||
error.SetErrorString("the entries in the mini dump memory info list are "
|
|
||||||
"smaller than expected");
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (size < list->SizeOfHeader + list->SizeOfEntry * list->NumberOfEntries) {
|
|
||||||
error.SetErrorString("the mini dump memory info list is incomplete");
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
const MINIDUMP_MEMORY_INFO *next_entry = nullptr;
|
|
||||||
|
|
||||||
for (uint64_t i = 0; i < list->NumberOfEntries; ++i) {
|
|
||||||
const auto entry = reinterpret_cast<const MINIDUMP_MEMORY_INFO *>(
|
|
||||||
reinterpret_cast<const char *>(list) + list->SizeOfHeader +
|
|
||||||
i * list->SizeOfEntry);
|
|
||||||
const auto head = entry->BaseAddress;
|
|
||||||
const auto tail = head + entry->RegionSize;
|
|
||||||
if (head <= load_addr && load_addr < tail) {
|
|
||||||
info.GetRange().SetRangeBase((entry->State != MEM_FREE) ? head
|
|
||||||
: load_addr);
|
|
||||||
info.GetRange().SetRangeEnd(tail);
|
|
||||||
info.SetReadable(IsPageReadable(entry->Protect) ? MemoryRegionInfo::eYes
|
|
||||||
: MemoryRegionInfo::eNo);
|
|
||||||
info.SetWritable(IsPageWritable(entry->Protect) ? MemoryRegionInfo::eYes
|
|
||||||
: MemoryRegionInfo::eNo);
|
|
||||||
info.SetExecutable(IsPageExecutable(entry->Protect)
|
|
||||||
? MemoryRegionInfo::eYes
|
|
||||||
: MemoryRegionInfo::eNo);
|
|
||||||
info.SetMapped((entry->State != MEM_FREE) ? MemoryRegionInfo::eYes
|
|
||||||
: MemoryRegionInfo::eNo);
|
|
||||||
return error;
|
|
||||||
} else if (head > load_addr &&
|
|
||||||
(next_entry == nullptr || head < next_entry->BaseAddress)) {
|
|
||||||
// In case there is no region containing load_addr keep track of the
|
|
||||||
// nearest region
|
|
||||||
// after load_addr so we can return the distance to it.
|
|
||||||
next_entry = entry;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// No containing region found. Create an unmapped region that extends to the
|
|
||||||
// next region
|
|
||||||
// or LLDB_INVALID_ADDRESS
|
|
||||||
info.GetRange().SetRangeBase(load_addr);
|
|
||||||
info.GetRange().SetRangeEnd((next_entry != nullptr) ? next_entry->BaseAddress
|
|
||||||
: LLDB_INVALID_ADDRESS);
|
|
||||||
info.SetReadable(MemoryRegionInfo::eNo);
|
|
||||||
info.SetWritable(MemoryRegionInfo::eNo);
|
|
||||||
info.SetExecutable(MemoryRegionInfo::eNo);
|
|
||||||
info.SetMapped(MemoryRegionInfo::eNo);
|
|
||||||
|
|
||||||
// Note that the memory info list doesn't seem to contain ranges in kernel
|
|
||||||
// space,
|
|
||||||
// so if you're walking a stack that has kernel frames, the stack may appear
|
|
||||||
// truncated.
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ProcessWinMiniDump::Impl::FindMemoryRange(lldb::addr_t addr,
|
|
||||||
Range *range_out) const {
|
|
||||||
size_t stream_size = 0;
|
|
||||||
auto mem_list_stream = static_cast<const MINIDUMP_MEMORY_LIST *>(
|
|
||||||
FindDumpStream(MemoryListStream, &stream_size));
|
|
||||||
if (mem_list_stream) {
|
|
||||||
for (ULONG32 i = 0; i < mem_list_stream->NumberOfMemoryRanges; ++i) {
|
|
||||||
const MINIDUMP_MEMORY_DESCRIPTOR &mem_desc =
|
|
||||||
mem_list_stream->MemoryRanges[i];
|
|
||||||
const MINIDUMP_LOCATION_DESCRIPTOR &loc_desc = mem_desc.Memory;
|
|
||||||
const lldb::addr_t range_start = mem_desc.StartOfMemoryRange;
|
|
||||||
const size_t range_size = loc_desc.DataSize;
|
|
||||||
if (range_start <= addr && addr < range_start + range_size) {
|
|
||||||
range_out->start = range_start;
|
|
||||||
range_out->size = range_size;
|
|
||||||
range_out->ptr =
|
|
||||||
reinterpret_cast<const uint8_t *>(m_base_addr) + loc_desc.Rva;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Some mini dumps have a Memory64ListStream that captures all the heap
|
|
||||||
// memory. We can't exactly use the same loop as above, because the mini
|
|
||||||
// dump uses slightly different data structures to describe those.
|
|
||||||
auto mem_list64_stream = static_cast<const MINIDUMP_MEMORY64_LIST *>(
|
|
||||||
FindDumpStream(Memory64ListStream, &stream_size));
|
|
||||||
if (mem_list64_stream) {
|
|
||||||
size_t base_rva = mem_list64_stream->BaseRva;
|
|
||||||
for (ULONG32 i = 0; i < mem_list64_stream->NumberOfMemoryRanges; ++i) {
|
|
||||||
const MINIDUMP_MEMORY_DESCRIPTOR64 &mem_desc =
|
|
||||||
mem_list64_stream->MemoryRanges[i];
|
|
||||||
const lldb::addr_t range_start = mem_desc.StartOfMemoryRange;
|
|
||||||
const size_t range_size = mem_desc.DataSize;
|
|
||||||
if (range_start <= addr && addr < range_start + range_size) {
|
|
||||||
range_out->start = range_start;
|
|
||||||
range_out->size = range_size;
|
|
||||||
range_out->ptr =
|
|
||||||
reinterpret_cast<const uint8_t *>(m_base_addr) + base_rva;
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
base_rva += range_size;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
Error ProcessWinMiniDump::Impl::MapMiniDumpIntoMemory() {
|
|
||||||
Error error;
|
|
||||||
const char *file = m_core_file.GetCString();
|
|
||||||
std::wstring wfile;
|
|
||||||
if (!llvm::ConvertUTF8toWide(file, wfile)) {
|
|
||||||
error.SetErrorString("Error converting path to UTF-16");
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
m_dump_file = ::CreateFileW(wfile.c_str(), GENERIC_READ, FILE_SHARE_READ,
|
|
||||||
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
||||||
if (m_dump_file == INVALID_HANDLE_VALUE) {
|
|
||||||
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
m_mapping =
|
|
||||||
::CreateFileMappingW(m_dump_file, NULL, PAGE_READONLY, 0, 0, NULL);
|
|
||||||
if (m_mapping == NULL) {
|
|
||||||
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
m_base_addr = ::MapViewOfFile(m_mapping, FILE_MAP_READ, 0, 0, 0);
|
|
||||||
if (m_base_addr == nullptr) {
|
|
||||||
error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
return error;
|
|
||||||
}
|
|
||||||
|
|
||||||
ArchSpec ProcessWinMiniDump::Impl::DetermineArchitecture() {
|
|
||||||
size_t size = 0;
|
|
||||||
auto system_info_ptr = static_cast<const MINIDUMP_SYSTEM_INFO *>(
|
|
||||||
FindDumpStream(SystemInfoStream, &size));
|
|
||||||
if (system_info_ptr) {
|
|
||||||
switch (system_info_ptr->ProcessorArchitecture) {
|
|
||||||
case PROCESSOR_ARCHITECTURE_INTEL:
|
|
||||||
if (system_info_ptr->ProcessorLevel == 6) {
|
|
||||||
return ArchSpec("i686-pc-windows");
|
|
||||||
} else {
|
|
||||||
return ArchSpec("i386-pc-windows");
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
case PROCESSOR_ARCHITECTURE_AMD64:
|
|
||||||
return ArchSpec("x86_64-pc-windows");
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return ArchSpec(); // invalid or unknown
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Impl::ReadExceptionRecord() {
|
|
||||||
size_t size = 0;
|
|
||||||
auto exception_stream_ptr = static_cast<MINIDUMP_EXCEPTION_STREAM *>(
|
|
||||||
FindDumpStream(ExceptionStream, &size));
|
|
||||||
if (exception_stream_ptr) {
|
|
||||||
m_exception_sp.reset(new ExceptionRecord(
|
|
||||||
exception_stream_ptr->ExceptionRecord, exception_stream_ptr->ThreadId));
|
|
||||||
} else {
|
|
||||||
WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Minidump has no exception record.");
|
|
||||||
// TODO: See if we can recover the exception from the TEB.
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Impl::ReadMiscInfo() {
|
|
||||||
size_t size = 0;
|
|
||||||
const auto misc_info_ptr =
|
|
||||||
static_cast<MINIDUMP_MISC_INFO *>(FindDumpStream(MiscInfoStream, &size));
|
|
||||||
if (!misc_info_ptr || size < sizeof(MINIDUMP_MISC_INFO)) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
if ((misc_info_ptr->Flags1 & MINIDUMP_MISC1_PROCESS_ID) != 0) {
|
|
||||||
// This misc info record has the process ID.
|
|
||||||
m_self->SetID(misc_info_ptr->ProcessId);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Impl::ReadModuleList() {
|
|
||||||
size_t size = 0;
|
|
||||||
auto module_list_ptr = static_cast<MINIDUMP_MODULE_LIST *>(
|
|
||||||
FindDumpStream(ModuleListStream, &size));
|
|
||||||
if (!module_list_ptr || module_list_ptr->NumberOfModules == 0) {
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (ULONG32 i = 0; i < module_list_ptr->NumberOfModules; ++i) {
|
|
||||||
const auto &module = module_list_ptr->Modules[i];
|
|
||||||
const auto file_name = GetMiniDumpString(module.ModuleNameRva);
|
|
||||||
const auto file_spec = FileSpec(file_name, true);
|
|
||||||
if (FileSpec::Compare(file_spec, FileSpec("wow64.dll", false), false) ==
|
|
||||||
0) {
|
|
||||||
WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Minidump is for a WOW64 process.");
|
|
||||||
m_is_wow64 = true;
|
|
||||||
}
|
|
||||||
ModuleSpec module_spec = file_spec;
|
|
||||||
|
|
||||||
lldb::ModuleSP module_sp = m_self->GetTarget().GetSharedModule(module_spec);
|
|
||||||
if (!module_sp) {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
bool load_addr_changed = false;
|
|
||||||
module_sp->SetLoadAddress(m_self->GetTarget(), module.BaseOfImage, false,
|
|
||||||
load_addr_changed);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void *ProcessWinMiniDump::Impl::FindDumpStream(unsigned stream_number,
|
|
||||||
size_t *size_out) const {
|
|
||||||
void *stream = nullptr;
|
|
||||||
*size_out = 0;
|
|
||||||
|
|
||||||
MINIDUMP_DIRECTORY *dir = nullptr;
|
|
||||||
if (::MiniDumpReadDumpStream(m_base_addr, stream_number, &dir, nullptr,
|
|
||||||
nullptr) &&
|
|
||||||
dir != nullptr && dir->Location.DataSize > 0) {
|
|
||||||
assert(dir->StreamType == stream_number);
|
|
||||||
*size_out = dir->Location.DataSize;
|
|
||||||
stream = static_cast<void *>(static_cast<char *>(m_base_addr) +
|
|
||||||
dir->Location.Rva);
|
|
||||||
}
|
|
||||||
|
|
||||||
return stream;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string ProcessWinMiniDump::Impl::GetMiniDumpString(RVA rva) const {
|
|
||||||
std::string result;
|
|
||||||
if (!m_base_addr) {
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
auto md_string = reinterpret_cast<const MINIDUMP_STRING *>(
|
|
||||||
static_cast<const char *>(m_base_addr) + rva);
|
|
||||||
auto source_start = reinterpret_cast<const llvm::UTF16 *>(md_string->Buffer);
|
|
||||||
const auto source_length = ::wcslen(md_string->Buffer);
|
|
||||||
const auto source_end = source_start + source_length;
|
|
||||||
result.resize(UNI_MAX_UTF8_BYTES_PER_CODE_POINT *
|
|
||||||
source_length); // worst case length
|
|
||||||
auto result_start = reinterpret_cast<llvm::UTF8 *>(&result[0]);
|
|
||||||
const auto result_end = result_start + result.size();
|
|
||||||
llvm::ConvertUTF16toUTF8(&source_start, source_end, &result_start, result_end,
|
|
||||||
llvm::ConversionFlags::strictConversion);
|
|
||||||
const auto result_size =
|
|
||||||
std::distance(reinterpret_cast<llvm::UTF8 *>(&result[0]), result_start);
|
|
||||||
result.resize(result_size); // shrink to actual length
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
ConstString ProcessWinMiniDump::GetPluginNameStatic() {
|
|
||||||
static ConstString g_name("win-minidump");
|
|
||||||
return g_name;
|
|
||||||
}
|
|
||||||
|
|
||||||
const char *ProcessWinMiniDump::GetPluginDescriptionStatic() {
|
|
||||||
return "Windows minidump plug-in.";
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Terminate() {
|
|
||||||
PluginManager::UnregisterPlugin(ProcessWinMiniDump::CreateInstance);
|
|
||||||
}
|
|
||||||
|
|
||||||
lldb::ProcessSP ProcessWinMiniDump::CreateInstance(lldb::TargetSP target_sp,
|
|
||||||
lldb::ListenerSP listener_sp,
|
|
||||||
const FileSpec *crash_file) {
|
|
||||||
lldb::ProcessSP process_sp;
|
|
||||||
if (crash_file) {
|
|
||||||
process_sp.reset(
|
|
||||||
new ProcessWinMiniDump(target_sp, listener_sp, *crash_file));
|
|
||||||
}
|
|
||||||
return process_sp;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ProcessWinMiniDump::CanDebug(lldb::TargetSP target_sp,
|
|
||||||
bool plugin_specified_by_name) {
|
|
||||||
// TODO(amccarth): Eventually, this needs some actual logic.
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
ProcessWinMiniDump::ProcessWinMiniDump(lldb::TargetSP target_sp,
|
|
||||||
lldb::ListenerSP listener_sp,
|
|
||||||
const FileSpec &core_file)
|
|
||||||
: ProcessWindows(target_sp, listener_sp),
|
|
||||||
m_impl_up(new Impl(core_file, this)) {}
|
|
||||||
|
|
||||||
ProcessWinMiniDump::~ProcessWinMiniDump() {
|
|
||||||
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();
|
|
||||||
}
|
|
||||||
|
|
||||||
ConstString ProcessWinMiniDump::GetPluginName() {
|
|
||||||
return GetPluginNameStatic();
|
|
||||||
}
|
|
||||||
|
|
||||||
uint32_t ProcessWinMiniDump::GetPluginVersion() { return 1; }
|
|
||||||
|
|
||||||
Error ProcessWinMiniDump::DoLoadCore() { return m_impl_up->DoLoadCore(); }
|
|
||||||
|
|
||||||
DynamicLoader *ProcessWinMiniDump::GetDynamicLoader() {
|
|
||||||
if (m_dyld_ap.get() == NULL)
|
|
||||||
m_dyld_ap.reset(DynamicLoader::FindPlugin(
|
|
||||||
this, DynamicLoaderWindowsDYLD::GetPluginNameStatic().GetCString()));
|
|
||||||
return m_dyld_ap.get();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ProcessWinMiniDump::UpdateThreadList(ThreadList &old_thread_list,
|
|
||||||
ThreadList &new_thread_list) {
|
|
||||||
return m_impl_up->UpdateThreadList(old_thread_list, new_thread_list);
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::RefreshStateAfterStop() {
|
|
||||||
if (!m_impl_up)
|
|
||||||
return;
|
|
||||||
return m_impl_up->RefreshStateAfterStop();
|
|
||||||
}
|
|
||||||
|
|
||||||
Error ProcessWinMiniDump::DoDestroy() { return Error(); }
|
|
||||||
|
|
||||||
bool ProcessWinMiniDump::IsAlive() { return true; }
|
|
||||||
|
|
||||||
bool ProcessWinMiniDump::WarnBeforeDetach() const {
|
|
||||||
// Since this is post-mortem debugging, there's no need to warn the user
|
|
||||||
// that quitting the debugger will terminate the process.
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_t ProcessWinMiniDump::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
|
|
||||||
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 ProcessWinMiniDump::DoReadMemory(lldb::addr_t addr, void *buf,
|
|
||||||
size_t size, Error &error) {
|
|
||||||
return m_impl_up->DoReadMemory(addr, buf, size, error);
|
|
||||||
}
|
|
||||||
|
|
||||||
Error ProcessWinMiniDump::GetMemoryRegionInfo(
|
|
||||||
lldb::addr_t load_addr, lldb_private::MemoryRegionInfo &info) {
|
|
||||||
return m_impl_up->GetMemoryRegionInfo(load_addr, info);
|
|
||||||
}
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Clear() { m_thread_list.Clear(); }
|
|
||||||
|
|
||||||
void ProcessWinMiniDump::Initialize() {
|
|
||||||
static std::once_flag g_once_flag;
|
|
||||||
|
|
||||||
std::call_once(g_once_flag, []() {
|
|
||||||
PluginManager::RegisterPlugin(GetPluginNameStatic(),
|
|
||||||
GetPluginDescriptionStatic(), CreateInstance);
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
ArchSpec ProcessWinMiniDump::GetArchitecture() {
|
|
||||||
// TODO
|
|
||||||
return ArchSpec();
|
|
||||||
}
|
|
||||||
|
|
@ -1,86 +0,0 @@
|
||||||
//===-- ProcessWinMiniDump.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_ProcessWinMiniDump_h_
|
|
||||||
#define liblldb_ProcessWinMiniDump_h_
|
|
||||||
|
|
||||||
#include <list>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
#include "lldb/Core/ConstString.h"
|
|
||||||
#include "lldb/Core/Error.h"
|
|
||||||
#include "lldb/Target/Process.h"
|
|
||||||
|
|
||||||
#include "Plugins/Process/Windows/Common/ProcessWindows.h"
|
|
||||||
|
|
||||||
struct ThreadData;
|
|
||||||
|
|
||||||
class ProcessWinMiniDump : public lldb_private::ProcessWindows {
|
|
||||||
public:
|
|
||||||
static lldb::ProcessSP
|
|
||||||
CreateInstance(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
|
|
||||||
const lldb_private::FileSpec *crash_file_path);
|
|
||||||
|
|
||||||
static void Initialize();
|
|
||||||
|
|
||||||
static void Terminate();
|
|
||||||
|
|
||||||
static lldb_private::ConstString GetPluginNameStatic();
|
|
||||||
|
|
||||||
static const char *GetPluginDescriptionStatic();
|
|
||||||
|
|
||||||
ProcessWinMiniDump(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
|
|
||||||
const lldb_private::FileSpec &core_file);
|
|
||||||
|
|
||||||
virtual ~ProcessWinMiniDump();
|
|
||||||
|
|
||||||
bool CanDebug(lldb::TargetSP target_sp,
|
|
||||||
bool plugin_specified_by_name) override;
|
|
||||||
|
|
||||||
lldb_private::Error DoLoadCore() override;
|
|
||||||
|
|
||||||
lldb_private::DynamicLoader *GetDynamicLoader() override;
|
|
||||||
|
|
||||||
lldb_private::ConstString GetPluginName() override;
|
|
||||||
|
|
||||||
uint32_t GetPluginVersion() override;
|
|
||||||
|
|
||||||
lldb_private::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,
|
|
||||||
lldb_private::Error &error) override;
|
|
||||||
|
|
||||||
size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
|
|
||||||
lldb_private::Error &error) override;
|
|
||||||
|
|
||||||
lldb_private::ArchSpec GetArchitecture();
|
|
||||||
|
|
||||||
lldb_private::Error
|
|
||||||
GetMemoryRegionInfo(lldb::addr_t load_addr,
|
|
||||||
lldb_private::MemoryRegionInfo &range_info) override;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
void Clear();
|
|
||||||
|
|
||||||
bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
|
|
||||||
lldb_private::ThreadList &new_thread_list) override;
|
|
||||||
|
|
||||||
private:
|
|
||||||
// Keep Windows-specific types out of this header.
|
|
||||||
class Impl;
|
|
||||||
std::unique_ptr<Impl> m_impl_up;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif // liblldb_ProcessWinMiniDump_h_
|
|
||||||
|
|
@ -1,87 +0,0 @@
|
||||||
//===-- ThreadWinMiniDump.cpp -----------------------------------*- C++ -*-===//
|
|
||||||
//
|
|
||||||
// The LLVM Compiler Infrastructure
|
|
||||||
//
|
|
||||||
// This file is distributed under the University of Illinois Open Source
|
|
||||||
// License. See LICENSE.TXT for details.
|
|
||||||
//
|
|
||||||
//===----------------------------------------------------------------------===//
|
|
||||||
|
|
||||||
#include "ThreadWinMiniDump.h"
|
|
||||||
|
|
||||||
#include "lldb/Host/HostInfo.h"
|
|
||||||
#include "lldb/Host/windows/windows.h"
|
|
||||||
#include <DbgHelp.h>
|
|
||||||
|
|
||||||
#include "ProcessWinMiniDump.h"
|
|
||||||
#if defined(_WIN64)
|
|
||||||
#include "x64/RegisterContextWindowsMiniDump_x64.h"
|
|
||||||
#else
|
|
||||||
#include "x86/RegisterContextWindowsMiniDump_x86.h"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
using namespace lldb;
|
|
||||||
using namespace lldb_private;
|
|
||||||
|
|
||||||
// This is a minimal implementation in order to get something running. It will
|
|
||||||
// be fleshed out as more mini-dump functionality is added.
|
|
||||||
|
|
||||||
class ThreadWinMiniDump::Data {
|
|
||||||
public:
|
|
||||||
Data() : m_context(nullptr) {}
|
|
||||||
const CONTEXT *m_context;
|
|
||||||
};
|
|
||||||
|
|
||||||
ThreadWinMiniDump::ThreadWinMiniDump(lldb_private::Process &process,
|
|
||||||
lldb::tid_t tid)
|
|
||||||
: Thread(process, tid), m_data(new Data) {}
|
|
||||||
|
|
||||||
ThreadWinMiniDump::~ThreadWinMiniDump() {}
|
|
||||||
|
|
||||||
void ThreadWinMiniDump::RefreshStateAfterStop() {}
|
|
||||||
|
|
||||||
lldb::RegisterContextSP ThreadWinMiniDump::GetRegisterContext() {
|
|
||||||
if (m_reg_context_sp.get() == NULL) {
|
|
||||||
m_reg_context_sp = CreateRegisterContextForFrame(NULL);
|
|
||||||
}
|
|
||||||
return m_reg_context_sp;
|
|
||||||
}
|
|
||||||
|
|
||||||
lldb::RegisterContextSP ThreadWinMiniDump::CreateRegisterContextForFrame(
|
|
||||||
lldb_private::StackFrame *frame) {
|
|
||||||
const uint32_t concrete_frame_idx =
|
|
||||||
(frame) ? frame->GetConcreteFrameIndex() : 0;
|
|
||||||
RegisterContextSP reg_ctx_sp;
|
|
||||||
ArchSpec arch = HostInfo::GetArchitecture();
|
|
||||||
switch (arch.GetMachine()) {
|
|
||||||
case llvm::Triple::x86:
|
|
||||||
#if defined(_WIN64)
|
|
||||||
// FIXME: This is a Wow64 process, create a RegisterContextWindows_Wow64
|
|
||||||
#else
|
|
||||||
reg_ctx_sp.reset(new RegisterContextWindowsMiniDump_x86(
|
|
||||||
*this, concrete_frame_idx, m_data->m_context));
|
|
||||||
#endif
|
|
||||||
break;
|
|
||||||
case llvm::Triple::x86_64:
|
|
||||||
#if defined(_WIN64)
|
|
||||||
reg_ctx_sp.reset(new RegisterContextWindowsMiniDump_x64(
|
|
||||||
*this, concrete_frame_idx, m_data->m_context));
|
|
||||||
#else
|
|
||||||
// LLDB is 32-bit, but the target process is 64-bit. We probably can't debug
|
|
||||||
// this.
|
|
||||||
#endif
|
|
||||||
default:
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
return reg_ctx_sp;
|
|
||||||
}
|
|
||||||
|
|
||||||
void ThreadWinMiniDump::ClearStackFrames() {}
|
|
||||||
|
|
||||||
void ThreadWinMiniDump::SetContext(const void *context) {
|
|
||||||
if (m_data) {
|
|
||||||
m_data->m_context = static_cast<const CONTEXT *>(context);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool ThreadWinMiniDump::CalculateStopInfo() { return false; }
|
|
||||||
|
|
@ -1,43 +0,0 @@
|
||||||
//===-- ThreadWinMiniDump.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_ThreadWinMiniDump_h_
|
|
||||||
#define liblldb_ThreadWinMiniDump_h_
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#include "lldb/Core/DataExtractor.h"
|
|
||||||
#include "lldb/Target/Thread.h"
|
|
||||||
|
|
||||||
class ThreadWinMiniDump : public lldb_private::Thread {
|
|
||||||
public:
|
|
||||||
ThreadWinMiniDump(lldb_private::Process &process, lldb::tid_t tid);
|
|
||||||
|
|
||||||
virtual ~ThreadWinMiniDump();
|
|
||||||
|
|
||||||
void RefreshStateAfterStop() override;
|
|
||||||
|
|
||||||
lldb::RegisterContextSP GetRegisterContext() override;
|
|
||||||
|
|
||||||
lldb::RegisterContextSP
|
|
||||||
CreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
|
|
||||||
|
|
||||||
void ClearStackFrames() override;
|
|
||||||
|
|
||||||
void SetContext(const void *context);
|
|
||||||
|
|
||||||
protected:
|
|
||||||
lldb::RegisterContextSP m_reg_context_sp;
|
|
||||||
class Data;
|
|
||||||
std::unique_ptr<Data> m_data; // for WinAPI-specific data
|
|
||||||
|
|
||||||
bool CalculateStopInfo() override;
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
//===-- RegisterContextWindowsMiniDump_x64.cpp ------------------*- C++ -*-===//
|
|
||||||
//
|
|
||||||
// The LLVM Compiler Infrastructure
|
|
||||||
//
|
|
||||||
// This file is distributed under the University of Illinois Open Source
|
|
||||||
// License. See LICENSE.TXT for details.
|
|
||||||
//
|
|
||||||
//===----------------------------------------------------------------------===//
|
|
||||||
|
|
||||||
#include "lldb/Host/windows/windows.h"
|
|
||||||
#include "lldb/lldb-private-types.h"
|
|
||||||
|
|
||||||
#include "RegisterContextWindowsMiniDump_x64.h"
|
|
||||||
|
|
||||||
using namespace lldb;
|
|
||||||
|
|
||||||
namespace lldb_private {
|
|
||||||
|
|
||||||
RegisterContextWindowsMiniDump_x64::RegisterContextWindowsMiniDump_x64(
|
|
||||||
Thread &thread, uint32_t concrete_frame_idx, const CONTEXT *context)
|
|
||||||
: RegisterContextWindows_x64(thread, concrete_frame_idx) {
|
|
||||||
if (context) {
|
|
||||||
m_context = *context;
|
|
||||||
m_context_stale = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
RegisterContextWindowsMiniDump_x64::~RegisterContextWindowsMiniDump_x64() {}
|
|
||||||
|
|
||||||
bool RegisterContextWindowsMiniDump_x64::WriteRegister(
|
|
||||||
const RegisterInfo * /* reg_info */,
|
|
||||||
const RegisterValue & /* reg_value */) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool RegisterContextWindowsMiniDump_x64::CacheAllRegisterValues() {
|
|
||||||
// Since this is post-mortem debugging, we either have the context or we
|
|
||||||
// don't.
|
|
||||||
return !m_context_stale;
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace lldb_private
|
|
||||||
|
|
@ -1,36 +0,0 @@
|
||||||
//===-- RegisterContextWindowsMiniDump_x64.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_RegisterContextWindowsMiniDump_x64_H_
|
|
||||||
#define liblldb_RegisterContextWindowsMiniDump_x64_H_
|
|
||||||
|
|
||||||
#include "Plugins/Process/Windows/Common/x64/RegisterContextWindows_x64.h"
|
|
||||||
#include "lldb/lldb-forward.h"
|
|
||||||
|
|
||||||
namespace lldb_private {
|
|
||||||
|
|
||||||
class Thread;
|
|
||||||
|
|
||||||
class RegisterContextWindowsMiniDump_x64 : public RegisterContextWindows_x64 {
|
|
||||||
public:
|
|
||||||
RegisterContextWindowsMiniDump_x64(Thread &thread,
|
|
||||||
uint32_t concrete_frame_idx,
|
|
||||||
const CONTEXT *context);
|
|
||||||
|
|
||||||
virtual ~RegisterContextWindowsMiniDump_x64();
|
|
||||||
|
|
||||||
bool WriteRegister(const RegisterInfo *reg_info,
|
|
||||||
const RegisterValue ®_value) override;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
bool CacheAllRegisterValues() override;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // #ifndef liblldb_RegisterContextWindowsMiniDump_x64_H_
|
|
||||||
|
|
@ -1,42 +0,0 @@
|
||||||
//===-- RegisterContextWindowsMiniDump_x86.cpp ------------------*- C++ -*-===//
|
|
||||||
//
|
|
||||||
// The LLVM Compiler Infrastructure
|
|
||||||
//
|
|
||||||
// This file is distributed under the University of Illinois Open Source
|
|
||||||
// License. See LICENSE.TXT for details.
|
|
||||||
//
|
|
||||||
//===----------------------------------------------------------------------===//
|
|
||||||
|
|
||||||
#include "lldb/Host/windows/windows.h"
|
|
||||||
#include "lldb/lldb-private-types.h"
|
|
||||||
|
|
||||||
#include "RegisterContextWindowsMiniDump_x86.h"
|
|
||||||
|
|
||||||
using namespace lldb;
|
|
||||||
|
|
||||||
namespace lldb_private {
|
|
||||||
|
|
||||||
RegisterContextWindowsMiniDump_x86::RegisterContextWindowsMiniDump_x86(
|
|
||||||
Thread &thread, uint32_t concrete_frame_idx, const CONTEXT *context)
|
|
||||||
: RegisterContextWindows_x86(thread, concrete_frame_idx) {
|
|
||||||
if (context) {
|
|
||||||
m_context = *context;
|
|
||||||
m_context_stale = false;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
RegisterContextWindowsMiniDump_x86::~RegisterContextWindowsMiniDump_x86() {}
|
|
||||||
|
|
||||||
bool RegisterContextWindowsMiniDump_x86::WriteRegister(
|
|
||||||
const RegisterInfo * /* reg_info */,
|
|
||||||
const RegisterValue & /* reg_value */) {
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool RegisterContextWindowsMiniDump_x86::CacheAllRegisterValues() {
|
|
||||||
// Since this is post-mortem debugging, we either have the context or we
|
|
||||||
// don't.
|
|
||||||
return !m_context_stale;
|
|
||||||
}
|
|
||||||
|
|
||||||
} // namespace lldb_private
|
|
||||||
|
|
@ -1,37 +0,0 @@
|
||||||
//===-- RegisterContextWindowsMiniDump_x86.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_RegisterContextWindowsMiniDump_x86_H_
|
|
||||||
#define liblldb_RegisterContextWindowsMiniDump_x86_H_
|
|
||||||
|
|
||||||
#include "Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.h"
|
|
||||||
#include "lldb/lldb-forward.h"
|
|
||||||
|
|
||||||
namespace lldb_private {
|
|
||||||
|
|
||||||
class Thread;
|
|
||||||
|
|
||||||
class RegisterContextWindowsMiniDump_x86 : public RegisterContextWindows_x86 {
|
|
||||||
public:
|
|
||||||
RegisterContextWindowsMiniDump_x86(Thread &thread,
|
|
||||||
uint32_t concrete_frame_idx,
|
|
||||||
const CONTEXT *context);
|
|
||||||
|
|
||||||
virtual ~RegisterContextWindowsMiniDump_x86();
|
|
||||||
|
|
||||||
bool WriteRegister(const RegisterInfo *reg_info,
|
|
||||||
const RegisterValue ®_value) override;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
bool CacheAllRegisterValues() override;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // #ifndef liblldb_RegisterContextWindowsMiniDump_x86_H_
|
|
||||||
Loading…
Reference in New Issue