Create a Windows mini-dump target

[amccarth]

Summary

This is the first (of many) steps to add support for Windows mini dumps as targets.

Like loading an ELF core file, this patch allows lldb to open a mini dump with a command like this:

(lldb) target create -c foo.dmp

All you can do now is see the thread list. I'm planning to add functionality in bite-sized chunks.

I'm still thinking about how to write tests for this functionality. I haven't found any ELF core tests to pattern after. If you have suggestions, let me know.

[zturner]

Will review in more detail later, but to answer your question about test. A good first start would be to create a minidump of a test program which is stopped at the first line of main. Check in the minidump as well as the test program. Then just write a test that verifies the stack frame is correct.

[zturner]

cmake/LLDBDependencies.cmake

69

This needs to be removed. The reason you see ElfCore and other MacOSX ones is because they don't use any Posix-specific APIs, but instead just read/write the core file directly and parse it. This allows you to debug an ELF core on Windows, for example. We use Windows Minidump API, so we can't allow someone not on Windows to try and link it, which this will cause to happen. If someone ever decides to write a minidump plugin that works on non-Windows, we could add that plugin here, and leave the existing one under the windows-only check

source/API/SystemInitializerFull.cpp

41

All the changes to this file need to be inside of #if defined(_MSC_VER) checks

source/Plugins/Process/win-minidump/CMakeLists.txt

3

Some CMake files still have this line, but I think it's unnecessary. Feel free to remove

source/Plugins/Process/win-minidump/Makefile

1

I think you can delete this file, nobody on Windows is using the autoconf build, and I don't care to support it since the autoconf build is going away anyway.

source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp

237–238

We already have a DetermineArchitecture() function. Is there any reason we can't just return it right here? Does this function have slightly different semantics or something?

source/Plugins/Process/win-minidump/ProcessWinMiniDump.h

49

Need to reformat these declarations to put return value on separate line.

86

I'd rather remove the TODO and either put it in Data or leave it here. Either way, be decisive :)

[amccarth]

By the way, I also made the capitalization of WinMiniDump/WinMinidump consistent, going with the former because it's consistent with more Windows APIs (even though the latter is probably more "natural").

source/Plugins/Process/win-minidump/ProcessWinMiniDump.cpp

237–238

DetermineArchitecture can be called only after the core file has been opened. In practice, it seems the GetArchitecture is called at least once before that happens. In those cases, GetArchitecture returns a default that seems mostly right.

The ELF core handling works similarly, providing a default until the actual value is determined from the core file.

source/Plugins/Process/win-minidump/ProcessWinMiniDump.h

86

Sorry, I meant to take care of that before sending it out for review, but I searched for TODO(amccarth) instead of just TODO. :-(

Moved to the private ProcessWinMap::Data class.

[amccarth]

Addresses earlier comments.

cmake/LLDBDependencies.cmake

set( LLDB_USED_LIBS
   lldbPluginInstructionMIPS
   lldbPluginInstructionMIPS64
   lldbPluginObjectFilePECOFF
   lldbPluginOSPython
   lldbPluginMemoryHistoryASan
   lldbPluginInstrumentationRuntimeAddressSanitizer
   lldbPluginSystemRuntimeMacOSX
   lldbPluginProcessElfCore
+  lldbPluginProcessWinMinidump
   lldbPluginJITLoaderGDB
   )
 
 # Windows-only libraries
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   list(APPEND LLDB_USED_LIBS
     lldbPluginProcessWindows
-    lldbPluginProcessElfCore
+    lldbPluginProcessWinMinidump
     lldbPluginJITLoaderGDB
     Ws2_32
     Rpcrt4
     )
 endif ()
 
 # Linux-only libraries
 if ( CMAKE_SYSTEM_NAME MATCHES "Linux" )

source/API/SystemInitializerFull.cpp

 #include "Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.h"
 #include "Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h"
 #include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"
 #include "Plugins/MemoryHistory/asan/MemoryHistoryASan.h"
 #include "Plugins/Platform/gdb-server/PlatformRemoteGDBServer.h"
 #include "Plugins/Process/elf-core/ProcessElfCore.h"
 #include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+#include "Plugins/Process/win-minidump/ProcessWinMiniDump.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h"
 #include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
 #include "Plugins/SymbolVendor/ELF/SymbolVendorELF.h"
 #include "Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h"
 #include "Plugins/UnwindAssembly/x86/UnwindAssembly-x86.h"
 #include "Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.h"
 
SystemInitializerFull::Initialize()
     ABISysV_ppc::Initialize();
     ABISysV_ppc64::Initialize();
     ABISysV_mips::Initialize();
     ABISysV_mips64::Initialize();
     DisassemblerLLVMC::Initialize();
 
     JITLoaderGDB::Initialize();
     ProcessElfCore::Initialize();
+    ProcessWinMiniDump::Initialize();
     MemoryHistoryASan::Initialize();
     AddressSanitizerRuntime::Initialize();
 
     SymbolVendorELF::Initialize();
     SymbolFileDWARF::Initialize();
     SymbolFileSymtab::Initialize();
     UnwindAssemblyInstEmulation::Initialize();
     UnwindAssembly_x86::Initialize();
SystemInitializerFull::Terminate()
     ABISysV_ppc::Terminate();
     ABISysV_ppc64::Terminate();
     ABISysV_mips::Terminate();
     ABISysV_mips64::Terminate();
     DisassemblerLLVMC::Terminate();
 
     JITLoaderGDB::Terminate();
     ProcessElfCore::Terminate();
+    ProcessWinMiniDump::Terminate();
     MemoryHistoryASan::Terminate();
     AddressSanitizerRuntime::Terminate();
     SymbolVendorELF::Terminate();
     SymbolFileDWARF::Terminate();
     SymbolFileSymtab::Terminate();
     UnwindAssembly_x86::Terminate();
     UnwindAssemblyInstEmulation::Terminate();
     EmulateInstructionARM64::Terminate();

source/Plugins/Process/CMakeLists.txt

 if (CMAKE_SYSTEM_NAME MATCHES "Linux")
   add_subdirectory(Linux)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
   add_subdirectory(FreeBSD)
   add_subdirectory(POSIX)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
   add_subdirectory(Windows)
 elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   add_subdirectory(MacOSX-Kernel)
 endif()
 add_subdirectory(gdb-remote)
 add_subdirectory(Utility)
 add_subdirectory(mach-core)
 add_subdirectory(elf-core)
+add_subdirectory(win-minidump)

source/Plugins/Process/win-minidump/CMakeLists.txt

+include_directories(../Utility)
+
+set(LLVM_NO_RTTI 1)
+
+add_lldb_library(lldbPluginProcessWinMinidump
+  ProcessWinMiniDump.cpp
+  RegisterContextWindowsMiniDump.cpp
+  ThreadWinMiniDump.cpp
+  )

source/Plugins/Process/win-minidump/Makefile

+##===- source/Plugins/Process/elf-core/Makefile -----------*- Makefile -*-===##
+#
+#                     The LLVM Compiler Infrastructure
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+
+LLDB_LEVEL := ../../../..
+LIBRARYNAME := lldbPluginProcessWinMiniDump
+BUILD_ARCHIVE = 1
+
+include $(LLDB_LEVEL)/Makefile

source/Plugins/Process/win-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"
+
+struct ThreadData;
+
+class ProcessWinMiniDump : public lldb_private::Process
+{
+public:
+    static lldb::ProcessSP
+    CreateInstance (lldb_private::Target& target,
+                    lldb_private::Listener &listener,
+                    const lldb_private::FileSpec *crash_file_path);
+
+    static void
+    Initialize();
+
+    static void
+    Terminate();
+
+    static lldb_private::ConstString
+    GetPluginNameStatic();
+
+    static const char *
+    GetPluginDescriptionStatic();
+
+    ProcessWinMiniDump(lldb_private::Target& target,
+                       lldb_private::Listener &listener,
+                       const lldb_private::FileSpec &core_file);
+
+    virtual
+    ~ProcessWinMiniDump();
+
+    bool CanDebug(lldb_private::Target &target, 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;
+
+    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::addr_t GetImageInfoAddress() override;
+
+    lldb_private::ArchSpec
+    GetArchitecture();
+
+protected:
+    void
+    Clear ( );
+
+    bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
+                          lldb_private::ThreadList &new_thread_list) override;
+
+private:
+    lldb_private::Error MapMiniDumpIntoMemory(const char *file);
+    lldb_private::ArchSpec DetermineArchitecture();
+
+
+    lldb_private::FileSpec m_core_file;  // TODO:  IS THIS NEEDED?  SHOULD IT BE IN struct Data?
+
+    // Isolate the data to keep Windows-specific types out of this header.  Can't
+    // use the typical pimpl idiom because the implementation of this class also
+    // needs access to public and protected members of the base class.
+    class Data;
+    std::unique_ptr<Data> m_data_up;
+};
+
+#endif  // liblldb_ProcessWinMinidump_h_

source/Plugins/Process/win-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 <stdlib.h>
+
+#include <mutex>
+
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/State.h"
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/DynamicLoader.h"
+#include "lldb/Target/UnixSignals.h"
+#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
+
+#include "ThreadWinMiniDump.h"
+
+using namespace lldb_private;
+
+// Encapsulates the private data for ProcessWinMiniDump.
+// TODO(amccarth):  Determine if we need a mutex for access.
+class ProcessWinMiniDump::Data
+{
+public:
+    Data();
+    ~Data();
+
+    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
+};
+
+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(Target &target, Listener &listener, const FileSpec *crash_file)
+{
+    lldb::ProcessSP process_sp;
+    if (crash_file)
+    {
+       process_sp.reset(new ProcessWinMiniDump(target, listener, *crash_file));
+    }
+    return process_sp;
+}
+
+bool
+ProcessWinMiniDump::CanDebug(Target &target, bool plugin_specified_by_name)
+{
+    // TODO(amccarth):  Eventually, this needs some actual logic.
+    return true;
+}
+
+ProcessWinMiniDump::ProcessWinMiniDump(Target& target, Listener &listener,
+                                       const FileSpec &core_file) :
+    Process(target, listener),
+    m_core_file(core_file),
+    m_data_up(new Data)
+{
+}
+
+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()
+{
+    Error error;
+
+    error = MapMiniDumpIntoMemory(m_core_file.GetCString());
+    if (error.Fail())
+    {
+        return error;
+    }
+
+    m_target.SetArchitecture(DetermineArchitecture());
+    // TODO(amccarth):  Build the module list.
+    // TODO(amccarth):  Read the exeception record.
+
+    return error;
+
+}
+
+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)
+{
+    assert(m_data_up != nullptr);
+    assert(m_data_up->m_base_addr != 0);
+
+    MINIDUMP_DIRECTORY *dir = nullptr;
+    void *ptr = nullptr;
+    ULONG size = 0;
+    if (::MiniDumpReadDumpStream(m_data_up->m_base_addr, ThreadListStream, &dir, &ptr, &size))
+    {
+        assert(dir->StreamType == ThreadListStream);
+        assert(size == dir->Location.DataSize);
+        assert(ptr == static_cast<void*>(static_cast<char*>(m_data_up->m_base_addr) + dir->Location.Rva));
+        auto thread_list_ptr = static_cast<const MINIDUMP_THREAD_LIST *>(ptr);
+        const ULONG32 thread_count = thread_list_ptr->NumberOfThreads;
+        assert(thread_count < std::numeric_limits<int>::max());
+        for (int i = 0; i < thread_count; ++i) {
+            std::shared_ptr<ThreadWinMiniDump> thread_sp(new ThreadWinMiniDump(*this, thread_list_ptr->Threads[i].ThreadId));
+            new_thread_list.AddThread(thread_sp);
+        }
+    }
+
+    return new_thread_list.GetSize(false) > 0;
+}
+
+void
+ProcessWinMiniDump::RefreshStateAfterStop()
+{
+}
+
+Error
+ProcessWinMiniDump::DoDestroy()
+{
+    return Error();
+}
+
+bool
+ProcessWinMiniDump::IsAlive()
+{
+    return true;
+}
+
+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 in core files we have it all cached our our core file anyway.
+    return DoReadMemory(addr, buf, size, error);
+}
+
+size_t
+ProcessWinMiniDump::DoReadMemory(lldb::addr_t addr, void *buf, size_t size, Error &error)
+{
+    // TODO
+    return 0;
+}
+
+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);
+    });
+}
+
+lldb::addr_t
+ProcessWinMiniDump::GetImageInfoAddress()
+{
+    Target *target = &GetTarget();
+    ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
+    Address addr = obj_file->GetImageInfoAddress(target);
+
+    if (addr.IsValid())
+        return addr.GetLoadAddress(target);
+    return LLDB_INVALID_ADDRESS;
+}
+
+ArchSpec
+ProcessWinMiniDump::GetArchitecture()
+{
+    // TODO
+    return ArchSpec();
+}
+
+
+ProcessWinMiniDump::Data::Data() :
+    m_dump_file(INVALID_HANDLE_VALUE),
+    m_mapping(NULL),
+    m_base_addr(nullptr)
+{
+}
+
+ProcessWinMiniDump::Data::~Data()
+{
+    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::MapMiniDumpIntoMemory(const char *file)
+{
+    Error error;
+
+    m_data_up->m_dump_file = ::CreateFile(file, GENERIC_READ, FILE_SHARE_READ,
+                                          NULL, OPEN_EXISTING,
+                                          FILE_ATTRIBUTE_NORMAL, NULL);
+    if (m_data_up->m_dump_file == INVALID_HANDLE_VALUE)
+    {
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+        return error;
+    }
+
+    m_data_up->m_mapping = ::CreateFileMapping(m_data_up->m_dump_file, NULL,
+                                               PAGE_READONLY, 0, 0, NULL);
+    if (m_data_up->m_mapping == NULL)
+    {
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+        return error;
+    }
+
+    m_data_up->m_base_addr = ::MapViewOfFile(m_data_up->m_mapping, FILE_MAP_READ, 0, 0, 0);
+    if (m_data_up->m_base_addr == NULL)
+    {
+        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
+        return error;
+    }
+
+    return error;
+}
+
+
+ArchSpec
+ProcessWinMiniDump::DetermineArchitecture()
+{
+    assert(m_data_up != nullptr);
+    assert(m_data_up->m_base_addr != 0);
+
+    MINIDUMP_DIRECTORY *dir = nullptr;
+    void *ptr = nullptr;
+    ULONG size = 0;
+    if (::MiniDumpReadDumpStream(m_data_up->m_base_addr, SystemInfoStream, &dir, &ptr, &size))
+    {
+        assert(dir->StreamType == SystemInfoStream);
+        assert(size == dir->Location.DataSize);
+        assert(ptr == static_cast<void*>(static_cast<char*>(m_data_up->m_base_addr) + dir->Location.Rva));
+        auto system_info_ptr = static_cast<const MINIDUMP_SYSTEM_INFO *>(ptr);
+        switch (system_info_ptr->ProcessorArchitecture)
+        {
+        case PROCESSOR_ARCHITECTURE_INTEL:
+            return ArchSpec(eArchTypeCOFF, IMAGE_FILE_MACHINE_I386, LLDB_INVALID_CPUTYPE);
+        case PROCESSOR_ARCHITECTURE_AMD64:
+            return ArchSpec(eArchTypeCOFF, IMAGE_FILE_MACHINE_AMD64, LLDB_INVALID_CPUTYPE);
+        default:
+            break;
+        }
+    }
+
+    return ArchSpec();  // invalid or unknown
+}

source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.h

+//===-- RegisterContextWindowsMiniDump.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_H_
+#define liblldb_RegisterContextWindowsMiniDump_H_
+
+#include "lldb/lldb-forward.h"
+#include "lldb/Target/RegisterContext.h"
+
+
+namespace lldb_private
+{
+
+class Thread;
+
+class RegisterContextWindowsMiniDump : public lldb_private::RegisterContext
+{
+  public:
+    RegisterContextWindowsMiniDump(Thread &thread, uint32_t concrete_frame_idx);
+
+    virtual ~RegisterContextWindowsMiniDump();
+
+    void
+    InvalidateAllRegisters() override;
+
+    size_t
+    GetRegisterCount() override;
+
+    const RegisterInfo *
+    GetRegisterInfoAtIndex(size_t reg) override;
+
+    size_t
+    GetRegisterSetCount() override;
+
+    const RegisterSet *
+    GetRegisterSet(size_t reg_set) override;
+
+    bool
+    ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value) override;
+
+    bool
+    WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value) override;
+
+    bool ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
+
+    bool WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
+
+    uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num) override;
+
+    uint32_t NumSupportedHardwareBreakpoints() override;
+
+    uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
+
+    bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
+
+    uint32_t NumSupportedHardwareWatchpoints() override;
+
+    uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write) override;
+
+    bool ClearHardwareWatchpoint(uint32_t hw_index) override;
+
+    bool HardwareSingleStep(bool enable) override;
+};
+
+}
+
+#endif // #ifndef liblldb_RegisterContextWindowsMiniDump_H_

source/Plugins/Process/win-minidump/RegisterContextWindowsMiniDump.cpp

+//===-- RegisterContextWindowsMiniDump.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/lldb-private-types.h"
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Host/windows/HostThreadWindows.h"
+#include "lldb/Host/windows/windows.h"
+
+#include "RegisterContextWindowsMiniDump.h"
+
+#include "llvm/ADT/STLExtras.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+// This is a do-nothing stub implementation for now.
+
+RegisterContextWindowsMiniDump::RegisterContextWindowsMiniDump(Thread &thread, uint32_t concrete_frame_idx)
+    : RegisterContext(thread, concrete_frame_idx)
+{
+}
+
+RegisterContextWindowsMiniDump::~RegisterContextWindowsMiniDump()
+{
+}
+
+void
+RegisterContextWindowsMiniDump::InvalidateAllRegisters()
+{
+}
+
+size_t
+RegisterContextWindowsMiniDump::GetRegisterCount()
+{
+    return 0;
+}
+
+const RegisterInfo *
+RegisterContextWindowsMiniDump::GetRegisterInfoAtIndex(size_t reg)
+{
+    return nullptr;
+}
+
+size_t
+RegisterContextWindowsMiniDump::GetRegisterSetCount()
+{
+    return 0;
+}
+
+const RegisterSet *
+RegisterContextWindowsMiniDump::GetRegisterSet(size_t reg_set)
+{
+    return nullptr;
+}
+
+bool
+RegisterContextWindowsMiniDump::ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)
+{
+    return false;
+}
+
+bool
+RegisterContextWindowsMiniDump::WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value)
+{
+    return false;
+}
+
+bool
+RegisterContextWindowsMiniDump::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
+{
+    return false;
+}
+
+bool
+RegisterContextWindowsMiniDump::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
+{
+    return false;
+}
+
+uint32_t
+RegisterContextWindowsMiniDump::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num)
+{
+    const uint32_t num_regs = GetRegisterCount();
+
+    assert(kind < kNumRegisterKinds);
+    for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
+    {
+        const RegisterInfo *reg_info = GetRegisterInfoAtIndex(reg_idx);
+
+        if (reg_info->kinds[kind] == num)
+            return reg_idx;
+    }
+
+    return LLDB_INVALID_REGNUM;
+}
+
+uint32_t
+RegisterContextWindowsMiniDump::NumSupportedHardwareBreakpoints()
+{
+    // Support for hardware breakpoints not yet implemented.
+    return 0;
+}
+
+uint32_t
+RegisterContextWindowsMiniDump::SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
+{
+    return 0;
+}
+
+bool
+RegisterContextWindowsMiniDump::ClearHardwareBreakpoint(uint32_t hw_idx)
+{
+    return false;
+}
+
+uint32_t
+RegisterContextWindowsMiniDump::NumSupportedHardwareWatchpoints()
+{
+    // Support for hardware watchpoints not yet implemented.
+    return 0;
+}
+
+uint32_t
+RegisterContextWindowsMiniDump::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write)
+{
+    return 0;
+}
+
+bool
+RegisterContextWindowsMiniDump::ClearHardwareWatchpoint(uint32_t hw_index)
+{
+    return false;
+}
+
+bool
+RegisterContextWindowsMiniDump::HardwareSingleStep(bool enable)
+{
+    return false;
+}

source/Plugins/Process/win-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;
+
+    const char *
+    GetName() override;
+
+    void
+    SetName(const char *name);
+
+protected:
+    std::string m_thread_name;
+    lldb::RegisterContextSP m_reg_context_sp;
+
+    bool CalculateStopInfo() override;
+};
+
+#endif

source/Plugins/Process/win-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"
+
+// Windows includes
+#include "lldb/Host/windows/windows.h"
+#include <DbgHelp.h>
+
+#include "ProcessWinMiniDump.h"
+#include "RegisterContextWindowsMiniDump.h"
+
+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.
+
+ThreadWinMiniDump::ThreadWinMiniDump(lldb_private::Process &process, lldb::tid_t tid) :
+    Thread(process, tid),
+    m_thread_name()
+{
+}
+
+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(new RegisterContextWindowsMiniDump(*this, concrete_frame_idx));
+    return reg_ctx_sp;
+}
+
+void
+ThreadWinMiniDump::ClearStackFrames()
+{
+}
+
+const char *
+ThreadWinMiniDump::GetName()
+{
+    return m_thread_name.empty() ? nullptr : m_thread_name.c_str();
+}
+
+void
+ThreadWinMiniDump::SetName(const char *name)
+{
+    if (name && name[0])
+        m_thread_name.assign(name);
+    else
+        m_thread_name.clear();
+}
+
+bool ThreadWinMiniDump::CalculateStopInfo()
+{
+    return false;
+}