This is an archive of the discontinued LLVM Phabricator instance.

Differential D26697

Remove Windows-specific minidump plugin
ClosedPublic

Authored by amccarth on Nov 15 2016, 1:38 PM.

Details

Reviewers
zturner
labath
Commits
rG1ca677f4c49c: Remove Windows-specific minidump plugin
rLLDB287113: Remove Windows-specific minidump plugin
rL287113: Remove Windows-specific minidump plugin
Summary

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.

Diff Detail

Repository
rL LLVM

Event Timeline

amccarth updated this revision to Diff 78065.Nov 15 2016, 1:38 PM
amccarth retitled this revision from to Remove Windows-specific minidump plugin.
amccarth updated this object.
amccarth added reviewers: labath, zturner.
amccarth added a subscriber: lldb-commits.
Herald added subscribers: modocache, mgorny. · View Herald TranscriptNov 15 2016, 1:38 PM
labath accepted this revision.Nov 16 2016, 2:25 AM
labath edited edge metadata.

Cool.

This revision is now accepted and ready to land.Nov 16 2016, 2:25 AM
Closed by commit rL287113: Remove Windows-specific minidump plugin (authored by amccarth). · Explain WhyNov 16 2016, 8:14 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 78194

lldb/trunk/cmake/LLDBDependencies.cmake

Show All 15 Linesset( LLDB_USED_LIBS
lldbPluginDisassemblerLLVM lldbPluginDisassemblerLLVM
lldbPluginSymbolFileDWARF lldbPluginSymbolFileDWARF
lldbPluginSymbolFilePDB lldbPluginSymbolFilePDB
lldbPluginSymbolFileSymtab lldbPluginSymbolFileSymtab
lldbPluginDynamicLoaderStatic lldbPluginDynamicLoaderStatic
lldbPluginDynamicLoaderPosixDYLD lldbPluginDynamicLoaderPosixDYLD
lldbPluginDynamicLoaderHexagonDYLD lldbPluginDynamicLoaderHexagonDYLD
lldbPluginDynamicLoaderWindowsDYLD lldbPluginDynamicLoaderWindowsDYLD
lldbPluginCPlusPlusLanguage lldbPluginCPlusPlusLanguage
lldbPluginGoLanguage lldbPluginGoLanguage
lldbPluginJavaLanguage lldbPluginJavaLanguage
lldbPluginObjCLanguage lldbPluginObjCLanguage
lldbPluginObjCPlusPlusLanguage lldbPluginObjCPlusPlusLanguage
lldbPluginOCamlLanguage lldbPluginOCamlLanguage
lldbPluginObjectFileELF lldbPluginObjectFileELF
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Linesset( LLDB_USED_LIBS
lldbPluginExpressionParserClang lldbPluginExpressionParserClang
lldbPluginExpressionParserGo lldbPluginExpressionParserGo
) )
# Windows-only libraries # Windows-only libraries
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
) )
endif () endif ()
# Linux-only libraries # Linux-only libraries
if ( CMAKE_SYSTEM_NAME MATCHES "Linux" ) if ( CMAKE_SYSTEM_NAME MATCHES "Linux" )
▲ Show 20 Lines • Show All 119 Lines • Show Last 20 Lines

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

if (CMAKE_SYSTEM_NAME MATCHES "Linux") if (CMAKE_SYSTEM_NAME MATCHES "Linux")
add_subdirectory(Linux) add_subdirectory(Linux)
add_subdirectory(POSIX) add_subdirectory(POSIX)
elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD") elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
add_subdirectory(FreeBSD) add_subdirectory(FreeBSD)
add_subdirectory(POSIX) add_subdirectory(POSIX)
elseif (CMAKE_SYSTEM_NAME MATCHES "NetBSD") 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)
endif() endif()
add_subdirectory(gdb-remote) add_subdirectory(gdb-remote)
add_subdirectory(Utility) add_subdirectory(Utility)
add_subdirectory(mach-core) add_subdirectory(mach-core)
add_subdirectory(elf-core) add_subdirectory(elf-core)
add_subdirectory(minidump) add_subdirectory(minidump)

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

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}
)

lldb/trunk/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h

//===-- 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_

lldb/trunk/source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

//===-- 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();
}

lldb/trunk/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.h

//===-- 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

lldb/trunk/source/Plugins/Process/Windows/MiniDump/ThreadWinMiniDump.cpp

//===-- 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; }

lldb/trunk/source/Plugins/Process/Windows/MiniDump/x64/RegisterContextWindowsMiniDump_x64.h

//===-- 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 &reg_value) override;
protected:
bool CacheAllRegisterValues() override;
};
}
#endif // #ifndef liblldb_RegisterContextWindowsMiniDump_x64_H_

lldb/trunk/source/Plugins/Process/Windows/MiniDump/x64/RegisterContextWindowsMiniDump_x64.cpp

//===-- 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

lldb/trunk/source/Plugins/Process/Windows/MiniDump/x86/RegisterContextWindowsMiniDump_x86.h

//===-- 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 &reg_value) override;
protected:
bool CacheAllRegisterValues() override;
};
}
#endif // #ifndef liblldb_RegisterContextWindowsMiniDump_x86_H_

lldb/trunk/source/Plugins/Process/Windows/MiniDump/x86/RegisterContextWindowsMiniDump_x86.cpp

//===-- 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
lldb/trunk/source/Plugins/Process/Windows/MiniDump/x64/RegisterContextWindowsMiniDump_x64.h