forked from OSchip/llvm-project
Reorg code to allow Windows Process Plugins to share some common code.
Differential Revision: http://reviews.llvm.org/D12252 llvm-svn: 245850
This commit is contained in:
Adrian McCarthy
parent
550dfe79ca
commit
27785dd530
|
|
@ -70,8 +70,8 @@
|
|||
|
||||
#if defined(_MSC_VER)
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
#include "Plugins/Process/Windows/ProcessWindows.h"
|
||||
#include "Plugins/Process/win-minidump/ProcessWinMiniDump.h"
|
||||
#include "Plugins/Process/Windows/Live/ProcessWindows.h"
|
||||
#include "Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.h"
|
||||
#endif
|
||||
|
||||
#include "llvm/Support/TargetSelect.h"
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@
|
|||
|
||||
#if defined(_MSC_VER)
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
#include "Plugins/Process/Windows/ProcessWindowsLog.h"
|
||||
#include "Plugins/Process/Windows/Live/ProcessWindowsLog.h"
|
||||
#endif
|
||||
|
||||
#include "llvm/Support/TargetSelect.h"
|
||||
|
|
|
|||
|
|
@ -5,8 +5,8 @@ elseif (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
|
|||
add_subdirectory(FreeBSD)
|
||||
add_subdirectory(POSIX)
|
||||
elseif (CMAKE_SYSTEM_NAME MATCHES "Windows")
|
||||
add_subdirectory(Windows)
|
||||
add_subdirectory(win-minidump)
|
||||
add_subdirectory(Windows/Live)
|
||||
add_subdirectory(Windows/MiniDump)
|
||||
elseif (CMAKE_SYSTEM_NAME MATCHES "Darwin")
|
||||
add_subdirectory(MacOSX-Kernel)
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -10,8 +10,6 @@
|
|||
#ifndef liblldb_Plugins_Process_Windows_ExceptionRecord_H_
|
||||
#define liblldb_Plugins_Process_Windows_ExceptionRecord_H_
|
||||
|
||||
#include "ForwardDecl.h"
|
||||
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
#include <DbgHelp.h>
|
||||
|
|
@ -1,7 +1,8 @@
|
|||
set(LLVM_NO_RTTI 1)
|
||||
|
||||
include_directories(.)
|
||||
include_directories(../Utility)
|
||||
include_directories(../../Utility)
|
||||
include_directories(../Common)
|
||||
|
||||
set(PROC_WINDOWS_SOURCES
|
||||
DebuggerThread.cpp
|
||||
|
|
@ -24,7 +24,7 @@
|
|||
#include "lldb/Target/ProcessLaunchInfo.h"
|
||||
#include "lldb/Target/Process.h"
|
||||
|
||||
#include "Plugins/Process/Windows/ProcessWindowsLog.h"
|
||||
#include "Plugins/Process/Windows/Live/ProcessWindowsLog.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
|
|
@ -1,41 +1,41 @@
|
|||
//===-- ForwardDecl.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_Plugins_Process_Windows_ForwardDecl_H_
|
||||
#define liblldb_Plugins_Process_Windows_ForwardDecl_H_
|
||||
|
||||
class ProcessWindows;
|
||||
|
||||
#include <memory>
|
||||
|
||||
// ExceptionResult is returned by the debug delegate to specify how it processed
|
||||
// the exception.
|
||||
enum class ExceptionResult
|
||||
{
|
||||
BreakInDebugger, // Break in the debugger and give the user a chance to interact with
|
||||
// the program before continuing.
|
||||
MaskException, // Eat the exception and don't let the application know it occurred.
|
||||
SendToApplication // Send the exception to the application to be handled as if there were
|
||||
// no debugger attached.
|
||||
};
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class IDebugDelegate;
|
||||
class DebuggerThread;
|
||||
class ExceptionRecord;
|
||||
|
||||
typedef std::shared_ptr<IDebugDelegate> DebugDelegateSP;
|
||||
typedef std::shared_ptr<DebuggerThread> DebuggerThreadSP;
|
||||
typedef std::shared_ptr<ExceptionRecord> ExceptionRecordSP;
|
||||
typedef std::unique_ptr<ExceptionRecord> ExceptionRecordUP;
|
||||
}
|
||||
|
||||
//===-- ForwardDecl.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_Plugins_Process_Windows_ForwardDecl_H_
|
||||
#define liblldb_Plugins_Process_Windows_ForwardDecl_H_
|
||||
|
||||
class ProcessWindows;
|
||||
|
||||
#include <memory>
|
||||
|
||||
// ExceptionResult is returned by the debug delegate to specify how it processed
|
||||
// the exception.
|
||||
enum class ExceptionResult
|
||||
{
|
||||
BreakInDebugger, // Break in the debugger and give the user a chance to interact with
|
||||
// the program before continuing.
|
||||
MaskException, // Eat the exception and don't let the application know it occurred.
|
||||
SendToApplication // Send the exception to the application to be handled as if there were
|
||||
// no debugger attached.
|
||||
};
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class IDebugDelegate;
|
||||
class DebuggerThread;
|
||||
class ExceptionRecord;
|
||||
|
||||
typedef std::shared_ptr<IDebugDelegate> DebugDelegateSP;
|
||||
typedef std::shared_ptr<DebuggerThread> DebuggerThreadSP;
|
||||
typedef std::shared_ptr<ExceptionRecord> ExceptionRecordSP;
|
||||
typedef std::unique_ptr<ExceptionRecord> ExceptionRecordUP;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,46 +1,46 @@
|
|||
//===-- IDebugDelegate.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_Plugins_Process_Windows_IDebugDelegate_H_
|
||||
#define liblldb_Plugins_Process_Windows_IDebugDelegate_H_
|
||||
|
||||
#include "ForwardDecl.h"
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/lldb-types.h"
|
||||
#include <string>
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
class Error;
|
||||
class HostThread;
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// IDebugDelegate
|
||||
//
|
||||
// IDebugDelegate defines an interface which allows implementors to receive
|
||||
// notification of events that happen in a debugged process.
|
||||
//----------------------------------------------------------------------
|
||||
class IDebugDelegate
|
||||
{
|
||||
public:
|
||||
virtual ~IDebugDelegate() {}
|
||||
|
||||
virtual void OnExitProcess(uint32_t exit_code) = 0;
|
||||
virtual void OnDebuggerConnected(lldb::addr_t image_base) = 0;
|
||||
virtual ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) = 0;
|
||||
virtual void OnCreateThread(const HostThread &thread) = 0;
|
||||
virtual void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) = 0;
|
||||
virtual void OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr) = 0;
|
||||
virtual void OnUnloadDll(lldb::addr_t module_addr) = 0;
|
||||
virtual void OnDebugString(const std::string &string) = 0;
|
||||
virtual void OnDebuggerError(const Error &error, uint32_t type) = 0;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
//===-- IDebugDelegate.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_Plugins_Process_Windows_IDebugDelegate_H_
|
||||
#define liblldb_Plugins_Process_Windows_IDebugDelegate_H_
|
||||
|
||||
#include "ForwardDecl.h"
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/lldb-types.h"
|
||||
#include <string>
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
class Error;
|
||||
class HostThread;
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
// IDebugDelegate
|
||||
//
|
||||
// IDebugDelegate defines an interface which allows implementors to receive
|
||||
// notification of events that happen in a debugged process.
|
||||
//----------------------------------------------------------------------
|
||||
class IDebugDelegate
|
||||
{
|
||||
public:
|
||||
virtual ~IDebugDelegate() {}
|
||||
|
||||
virtual void OnExitProcess(uint32_t exit_code) = 0;
|
||||
virtual void OnDebuggerConnected(lldb::addr_t image_base) = 0;
|
||||
virtual ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) = 0;
|
||||
virtual void OnCreateThread(const HostThread &thread) = 0;
|
||||
virtual void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) = 0;
|
||||
virtual void OnLoadDll(const ModuleSpec &module_spec, lldb::addr_t module_addr) = 0;
|
||||
virtual void OnUnloadDll(lldb::addr_t module_addr) = 0;
|
||||
virtual void OnDebugString(const std::string &string) = 0;
|
||||
virtual void OnDebuggerError(const Error &error, uint32_t type) = 0;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,73 +1,73 @@
|
|||
//===-- LocalDebugDelegate.cpp ----------------------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "LocalDebugDelegate.h"
|
||||
#include "ProcessWindows.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
LocalDebugDelegate::LocalDebugDelegate(ProcessSP process)
|
||||
: m_process(process)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnExitProcess(uint32_t exit_code)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnExitProcess(exit_code);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnDebuggerConnected(lldb::addr_t image_base)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnDebuggerConnected(image_base);
|
||||
}
|
||||
|
||||
ExceptionResult
|
||||
LocalDebugDelegate::OnDebugException(bool first_chance, const ExceptionRecord &record)
|
||||
{
|
||||
return ((ProcessWindows &)*m_process).OnDebugException(first_chance, record);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnCreateThread(const HostThread &thread)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnCreateThread(thread);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnExitThread(thread_id, exit_code);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnLoadDll(module_spec, module_addr);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnUnloadDll(lldb::addr_t module_addr)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnUnloadDll(module_addr);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnDebugString(const std::string &string)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnDebugString(string);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnDebuggerError(const Error &error, uint32_t type)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnDebuggerError(error, type);
|
||||
}
|
||||
//===-- LocalDebugDelegate.cpp ----------------------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "LocalDebugDelegate.h"
|
||||
#include "ProcessWindows.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
LocalDebugDelegate::LocalDebugDelegate(ProcessSP process)
|
||||
: m_process(process)
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnExitProcess(uint32_t exit_code)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnExitProcess(exit_code);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnDebuggerConnected(lldb::addr_t image_base)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnDebuggerConnected(image_base);
|
||||
}
|
||||
|
||||
ExceptionResult
|
||||
LocalDebugDelegate::OnDebugException(bool first_chance, const ExceptionRecord &record)
|
||||
{
|
||||
return ((ProcessWindows &)*m_process).OnDebugException(first_chance, record);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnCreateThread(const HostThread &thread)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnCreateThread(thread);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnExitThread(lldb::tid_t thread_id, uint32_t exit_code)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnExitThread(thread_id, exit_code);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnLoadDll(module_spec, module_addr);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnUnloadDll(lldb::addr_t module_addr)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnUnloadDll(module_addr);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnDebugString(const std::string &string)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnDebugString(string);
|
||||
}
|
||||
|
||||
void
|
||||
LocalDebugDelegate::OnDebuggerError(const Error &error, uint32_t type)
|
||||
{
|
||||
((ProcessWindows &)*m_process).OnDebuggerError(error, type);
|
||||
}
|
||||
|
|
@ -1,60 +1,60 @@
|
|||
//===-- LocalDebugDelegate.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_Plugins_Process_Windows_LocalDebugDelegate_H_
|
||||
#define liblldb_Plugins_Process_Windows_LocalDebugDelegate_H_
|
||||
|
||||
#include "IDebugDelegate.h"
|
||||
#include "lldb/lldb-forward.h"
|
||||
|
||||
class ProcessWindows;
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
//----------------------------------------------------------------------
|
||||
// LocalDebugDelegate
|
||||
//
|
||||
// LocalDebugDelegate creates a connection between a ProcessWindows and the
|
||||
// debug driver. This serves to decouple ProcessWindows from the debug driver.
|
||||
// It would be possible to get a similar decoupling by just having
|
||||
// ProcessWindows implement this interface directly. There are two reasons why
|
||||
// we don't do this:
|
||||
//
|
||||
// 1) In the future when we add support for local debugging through LLGS, and we
|
||||
// go through the Native*Protocol interface, it is likely we will need the
|
||||
// additional flexibility provided by this sort of adapter pattern.
|
||||
// 2) LLDB holds a shared_ptr to the ProcessWindows, and our driver thread also
|
||||
// also needs access to it as well. To avoid a race condition, we want to
|
||||
// make sure that we're also holding onto a shared_ptr.
|
||||
// lldb_private::Process supports enable_shared_from_this, but that gives us
|
||||
// a ProcessSP (which is exactly what we are trying to decouple from the
|
||||
// driver), so this adapter serves as a way to transparently hold the
|
||||
// ProcessSP while still keeping it decoupled from the driver.
|
||||
//----------------------------------------------------------------------
|
||||
class LocalDebugDelegate : public IDebugDelegate
|
||||
{
|
||||
public:
|
||||
explicit LocalDebugDelegate(lldb::ProcessSP process);
|
||||
|
||||
void OnExitProcess(uint32_t exit_code) override;
|
||||
void OnDebuggerConnected(lldb::addr_t image_base) override;
|
||||
ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) override;
|
||||
void OnCreateThread(const HostThread &thread) override;
|
||||
void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;
|
||||
void OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr) override;
|
||||
void OnUnloadDll(lldb::addr_t module_addr) override;
|
||||
void OnDebugString(const std::string &message) override;
|
||||
void OnDebuggerError(const Error &error, uint32_t type) override;
|
||||
|
||||
private:
|
||||
lldb::ProcessSP m_process;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
//===-- LocalDebugDelegate.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_Plugins_Process_Windows_LocalDebugDelegate_H_
|
||||
#define liblldb_Plugins_Process_Windows_LocalDebugDelegate_H_
|
||||
|
||||
#include "IDebugDelegate.h"
|
||||
#include "lldb/lldb-forward.h"
|
||||
|
||||
class ProcessWindows;
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
//----------------------------------------------------------------------
|
||||
// LocalDebugDelegate
|
||||
//
|
||||
// LocalDebugDelegate creates a connection between a ProcessWindows and the
|
||||
// debug driver. This serves to decouple ProcessWindows from the debug driver.
|
||||
// It would be possible to get a similar decoupling by just having
|
||||
// ProcessWindows implement this interface directly. There are two reasons why
|
||||
// we don't do this:
|
||||
//
|
||||
// 1) In the future when we add support for local debugging through LLGS, and we
|
||||
// go through the Native*Protocol interface, it is likely we will need the
|
||||
// additional flexibility provided by this sort of adapter pattern.
|
||||
// 2) LLDB holds a shared_ptr to the ProcessWindows, and our driver thread also
|
||||
// also needs access to it as well. To avoid a race condition, we want to
|
||||
// make sure that we're also holding onto a shared_ptr.
|
||||
// lldb_private::Process supports enable_shared_from_this, but that gives us
|
||||
// a ProcessSP (which is exactly what we are trying to decouple from the
|
||||
// driver), so this adapter serves as a way to transparently hold the
|
||||
// ProcessSP while still keeping it decoupled from the driver.
|
||||
//----------------------------------------------------------------------
|
||||
class LocalDebugDelegate : public IDebugDelegate
|
||||
{
|
||||
public:
|
||||
explicit LocalDebugDelegate(lldb::ProcessSP process);
|
||||
|
||||
void OnExitProcess(uint32_t exit_code) override;
|
||||
void OnDebuggerConnected(lldb::addr_t image_base) override;
|
||||
ExceptionResult OnDebugException(bool first_chance, const ExceptionRecord &record) override;
|
||||
void OnCreateThread(const HostThread &thread) override;
|
||||
void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;
|
||||
void OnLoadDll(const lldb_private::ModuleSpec &module_spec, lldb::addr_t module_addr) override;
|
||||
void OnUnloadDll(lldb::addr_t module_addr) override;
|
||||
void OnDebugString(const std::string &message) override;
|
||||
void OnDebuggerError(const Error &error, uint32_t type) override;
|
||||
|
||||
private:
|
||||
lldb::ProcessSP m_process;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -39,7 +39,7 @@
|
|||
#include "lldb/Target/StopInfo.h"
|
||||
#include "lldb/Target/Target.h"
|
||||
|
||||
#include "Plugins/Process/Windows/ProcessWindowsLog.h"
|
||||
#include "Plugins/Process/Windows/live/ProcessWindowsLog.h"
|
||||
|
||||
#include "DebuggerThread.h"
|
||||
#include "ExceptionRecord.h"
|
||||
|
|
@ -1,190 +1,190 @@
|
|||
//===-- ProcessWindowsLog.cpp -----------------------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "ProcessWindowsLog.h"
|
||||
|
||||
#include <mutex>
|
||||
|
||||
#include "lldb/Core/StreamFile.h"
|
||||
#include "lldb/Interpreter/Args.h"
|
||||
#include "llvm/Support/ManagedStatic.h"
|
||||
|
||||
#include "ProcessWindows.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
|
||||
// We want to avoid global constructors where code needs to be run so here we
|
||||
// control access to our static g_log_sp by hiding it in a singleton function
|
||||
// that will construct the static g_log_sp the first time this function is
|
||||
// called.
|
||||
static bool g_log_enabled = false;
|
||||
static Log * g_log = nullptr;
|
||||
|
||||
static llvm::ManagedStatic<std::once_flag> g_once_flag;
|
||||
|
||||
void
|
||||
ProcessWindowsLog::Initialize()
|
||||
{
|
||||
static ConstString g_name("windows");
|
||||
|
||||
std::call_once(*g_once_flag, [](){
|
||||
Log::Callbacks log_callbacks = {
|
||||
DisableLog,
|
||||
EnableLog,
|
||||
ListLogCategories
|
||||
};
|
||||
|
||||
Log::RegisterLogChannel(g_name, log_callbacks);
|
||||
RegisterPluginName(g_name);
|
||||
});
|
||||
}
|
||||
|
||||
void
|
||||
ProcessWindowsLog::Terminate()
|
||||
{
|
||||
}
|
||||
|
||||
Log *
|
||||
ProcessWindowsLog::GetLog()
|
||||
{
|
||||
return (g_log_enabled) ? g_log : nullptr;
|
||||
}
|
||||
|
||||
bool
|
||||
ProcessWindowsLog::TestLogFlags(uint32_t mask, LogMaskReq req)
|
||||
{
|
||||
Log *log = GetLog();
|
||||
if (!log)
|
||||
return false;
|
||||
|
||||
uint32_t log_mask = log->GetMask().Get();
|
||||
if (req == LogMaskReq::All)
|
||||
return ((log_mask & mask) == mask);
|
||||
else
|
||||
return (log_mask & mask);
|
||||
}
|
||||
|
||||
static uint32_t
|
||||
GetFlagBits(const char *arg)
|
||||
{
|
||||
if (::strcasecmp(arg, "all") == 0 ) return WINDOWS_LOG_ALL;
|
||||
else if (::strcasecmp(arg, "break") == 0 ) return WINDOWS_LOG_BREAKPOINTS;
|
||||
else if (::strcasecmp(arg, "event") == 0 ) return WINDOWS_LOG_EVENT;
|
||||
else if (::strcasecmp(arg, "exception") == 0 ) return WINDOWS_LOG_EXCEPTION;
|
||||
else if (::strcasecmp(arg, "memory") == 0 ) return WINDOWS_LOG_MEMORY;
|
||||
else if (::strcasecmp(arg, "process") == 0 ) return WINDOWS_LOG_PROCESS;
|
||||
else if (::strcasecmp(arg, "registers") == 0 ) return WINDOWS_LOG_REGISTERS;
|
||||
else if (::strcasecmp(arg, "step") == 0 ) return WINDOWS_LOG_STEP;
|
||||
else if (::strcasecmp(arg, "thread") == 0 ) return WINDOWS_LOG_THREAD;
|
||||
else if (::strcasecmp(arg, "verbose") == 0 ) return WINDOWS_LOG_VERBOSE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
ProcessWindowsLog::DisableLog(const char **args, Stream *feedback_strm)
|
||||
{
|
||||
Log *log (GetLog());
|
||||
if (log)
|
||||
{
|
||||
uint32_t flag_bits = 0;
|
||||
|
||||
flag_bits = log->GetMask().Get();
|
||||
for (; args[0]; args++)
|
||||
{
|
||||
const char *arg = args[0];
|
||||
uint32_t bits = GetFlagBits(arg);
|
||||
|
||||
if (bits)
|
||||
{
|
||||
flag_bits &= ~bits;
|
||||
}
|
||||
else
|
||||
{
|
||||
feedback_strm->Printf("error: unrecognized log category '%s'\n", arg);
|
||||
ListLogCategories(feedback_strm);
|
||||
}
|
||||
}
|
||||
|
||||
log->GetMask().Reset(flag_bits);
|
||||
if (flag_bits == 0)
|
||||
g_log_enabled = false;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
Log *
|
||||
ProcessWindowsLog::EnableLog(StreamSP &log_stream_sp, uint32_t log_options, const char **args, Stream *feedback_strm)
|
||||
{
|
||||
// Try see if there already is a log - that way we can reuse its settings.
|
||||
// We could reuse the log in toto, but we don't know that the stream is the same.
|
||||
uint32_t flag_bits = 0;
|
||||
if (g_log)
|
||||
flag_bits = g_log->GetMask().Get();
|
||||
|
||||
// Now make a new log with this stream if one was provided
|
||||
if (log_stream_sp)
|
||||
{
|
||||
if (g_log)
|
||||
g_log->SetStream(log_stream_sp);
|
||||
else
|
||||
g_log = new Log(log_stream_sp);
|
||||
}
|
||||
|
||||
if (g_log)
|
||||
{
|
||||
bool got_unknown_category = false;
|
||||
for (; args[0]; args++)
|
||||
{
|
||||
const char *arg = args[0];
|
||||
uint32_t bits = GetFlagBits(arg);
|
||||
|
||||
if (bits)
|
||||
{
|
||||
flag_bits |= bits;
|
||||
}
|
||||
else
|
||||
{
|
||||
feedback_strm->Printf("error: unrecognized log category '%s'\n", arg);
|
||||
if (got_unknown_category == false)
|
||||
{
|
||||
got_unknown_category = true;
|
||||
ListLogCategories (feedback_strm);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag_bits == 0)
|
||||
flag_bits = WINDOWS_LOG_ALL;
|
||||
g_log->GetMask().Reset(flag_bits);
|
||||
g_log->GetOptions().Reset(log_options);
|
||||
g_log_enabled = true;
|
||||
}
|
||||
return g_log;
|
||||
}
|
||||
|
||||
void
|
||||
ProcessWindowsLog::ListLogCategories(Stream *strm)
|
||||
{
|
||||
strm->Printf("Logging categories for '%s':\n"
|
||||
" all - turn on all available logging categories\n"
|
||||
" break - log breakpoints\n"
|
||||
" event - log low level debugger events\n"
|
||||
" exception - log exception information\n"
|
||||
" memory - log memory reads and writes\n"
|
||||
" process - log process events and activities\n"
|
||||
" registers - log register read/writes\n"
|
||||
" thread - log thread events and activities\n"
|
||||
" step - log step related activities\n"
|
||||
" verbose - enable verbose logging\n",
|
||||
ProcessWindowsLog::m_pluginname);
|
||||
}
|
||||
|
||||
const char *ProcessWindowsLog::m_pluginname = "";
|
||||
//===-- ProcessWindowsLog.cpp -----------------------------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "ProcessWindowsLog.h"
|
||||
|
||||
#include <mutex>
|
||||
|
||||
#include "lldb/Core/StreamFile.h"
|
||||
#include "lldb/Interpreter/Args.h"
|
||||
#include "llvm/Support/ManagedStatic.h"
|
||||
|
||||
#include "ProcessWindows.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
|
||||
// We want to avoid global constructors where code needs to be run so here we
|
||||
// control access to our static g_log_sp by hiding it in a singleton function
|
||||
// that will construct the static g_log_sp the first time this function is
|
||||
// called.
|
||||
static bool g_log_enabled = false;
|
||||
static Log * g_log = nullptr;
|
||||
|
||||
static llvm::ManagedStatic<std::once_flag> g_once_flag;
|
||||
|
||||
void
|
||||
ProcessWindowsLog::Initialize()
|
||||
{
|
||||
static ConstString g_name("windows");
|
||||
|
||||
std::call_once(*g_once_flag, [](){
|
||||
Log::Callbacks log_callbacks = {
|
||||
DisableLog,
|
||||
EnableLog,
|
||||
ListLogCategories
|
||||
};
|
||||
|
||||
Log::RegisterLogChannel(g_name, log_callbacks);
|
||||
RegisterPluginName(g_name);
|
||||
});
|
||||
}
|
||||
|
||||
void
|
||||
ProcessWindowsLog::Terminate()
|
||||
{
|
||||
}
|
||||
|
||||
Log *
|
||||
ProcessWindowsLog::GetLog()
|
||||
{
|
||||
return (g_log_enabled) ? g_log : nullptr;
|
||||
}
|
||||
|
||||
bool
|
||||
ProcessWindowsLog::TestLogFlags(uint32_t mask, LogMaskReq req)
|
||||
{
|
||||
Log *log = GetLog();
|
||||
if (!log)
|
||||
return false;
|
||||
|
||||
uint32_t log_mask = log->GetMask().Get();
|
||||
if (req == LogMaskReq::All)
|
||||
return ((log_mask & mask) == mask);
|
||||
else
|
||||
return (log_mask & mask);
|
||||
}
|
||||
|
||||
static uint32_t
|
||||
GetFlagBits(const char *arg)
|
||||
{
|
||||
if (::strcasecmp(arg, "all") == 0 ) return WINDOWS_LOG_ALL;
|
||||
else if (::strcasecmp(arg, "break") == 0 ) return WINDOWS_LOG_BREAKPOINTS;
|
||||
else if (::strcasecmp(arg, "event") == 0 ) return WINDOWS_LOG_EVENT;
|
||||
else if (::strcasecmp(arg, "exception") == 0 ) return WINDOWS_LOG_EXCEPTION;
|
||||
else if (::strcasecmp(arg, "memory") == 0 ) return WINDOWS_LOG_MEMORY;
|
||||
else if (::strcasecmp(arg, "process") == 0 ) return WINDOWS_LOG_PROCESS;
|
||||
else if (::strcasecmp(arg, "registers") == 0 ) return WINDOWS_LOG_REGISTERS;
|
||||
else if (::strcasecmp(arg, "step") == 0 ) return WINDOWS_LOG_STEP;
|
||||
else if (::strcasecmp(arg, "thread") == 0 ) return WINDOWS_LOG_THREAD;
|
||||
else if (::strcasecmp(arg, "verbose") == 0 ) return WINDOWS_LOG_VERBOSE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
ProcessWindowsLog::DisableLog(const char **args, Stream *feedback_strm)
|
||||
{
|
||||
Log *log (GetLog());
|
||||
if (log)
|
||||
{
|
||||
uint32_t flag_bits = 0;
|
||||
|
||||
flag_bits = log->GetMask().Get();
|
||||
for (; args[0]; args++)
|
||||
{
|
||||
const char *arg = args[0];
|
||||
uint32_t bits = GetFlagBits(arg);
|
||||
|
||||
if (bits)
|
||||
{
|
||||
flag_bits &= ~bits;
|
||||
}
|
||||
else
|
||||
{
|
||||
feedback_strm->Printf("error: unrecognized log category '%s'\n", arg);
|
||||
ListLogCategories(feedback_strm);
|
||||
}
|
||||
}
|
||||
|
||||
log->GetMask().Reset(flag_bits);
|
||||
if (flag_bits == 0)
|
||||
g_log_enabled = false;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
Log *
|
||||
ProcessWindowsLog::EnableLog(StreamSP &log_stream_sp, uint32_t log_options, const char **args, Stream *feedback_strm)
|
||||
{
|
||||
// Try see if there already is a log - that way we can reuse its settings.
|
||||
// We could reuse the log in toto, but we don't know that the stream is the same.
|
||||
uint32_t flag_bits = 0;
|
||||
if (g_log)
|
||||
flag_bits = g_log->GetMask().Get();
|
||||
|
||||
// Now make a new log with this stream if one was provided
|
||||
if (log_stream_sp)
|
||||
{
|
||||
if (g_log)
|
||||
g_log->SetStream(log_stream_sp);
|
||||
else
|
||||
g_log = new Log(log_stream_sp);
|
||||
}
|
||||
|
||||
if (g_log)
|
||||
{
|
||||
bool got_unknown_category = false;
|
||||
for (; args[0]; args++)
|
||||
{
|
||||
const char *arg = args[0];
|
||||
uint32_t bits = GetFlagBits(arg);
|
||||
|
||||
if (bits)
|
||||
{
|
||||
flag_bits |= bits;
|
||||
}
|
||||
else
|
||||
{
|
||||
feedback_strm->Printf("error: unrecognized log category '%s'\n", arg);
|
||||
if (got_unknown_category == false)
|
||||
{
|
||||
got_unknown_category = true;
|
||||
ListLogCategories (feedback_strm);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag_bits == 0)
|
||||
flag_bits = WINDOWS_LOG_ALL;
|
||||
g_log->GetMask().Reset(flag_bits);
|
||||
g_log->GetOptions().Reset(log_options);
|
||||
g_log_enabled = true;
|
||||
}
|
||||
return g_log;
|
||||
}
|
||||
|
||||
void
|
||||
ProcessWindowsLog::ListLogCategories(Stream *strm)
|
||||
{
|
||||
strm->Printf("Logging categories for '%s':\n"
|
||||
" all - turn on all available logging categories\n"
|
||||
" break - log breakpoints\n"
|
||||
" event - log low level debugger events\n"
|
||||
" exception - log exception information\n"
|
||||
" memory - log memory reads and writes\n"
|
||||
" process - log process events and activities\n"
|
||||
" registers - log register read/writes\n"
|
||||
" thread - log thread events and activities\n"
|
||||
" step - log step related activities\n"
|
||||
" verbose - enable verbose logging\n",
|
||||
ProcessWindowsLog::m_pluginname);
|
||||
}
|
||||
|
||||
const char *ProcessWindowsLog::m_pluginname = "";
|
||||
|
|
@ -1,96 +1,96 @@
|
|||
//===-- ProcessWindowsLog.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_ProcessWindowsLog_h_
|
||||
#define liblldb_ProcessWindowsLog_h_
|
||||
|
||||
#include "lldb/Core/Log.h"
|
||||
|
||||
#define WINDOWS_LOG_VERBOSE (1u << 0)
|
||||
#define WINDOWS_LOG_PROCESS (1u << 1) // Log process operations
|
||||
#define WINDOWS_LOG_EXCEPTION (1u << 1) // Log exceptions
|
||||
#define WINDOWS_LOG_THREAD (1u << 2) // Log thread operations
|
||||
#define WINDOWS_LOG_MEMORY (1u << 3) // Log memory reads/writes calls
|
||||
#define WINDOWS_LOG_BREAKPOINTS (1u << 4) // Log breakpoint operations
|
||||
#define WINDOWS_LOG_STEP (1u << 5) // Log step operations
|
||||
#define WINDOWS_LOG_REGISTERS (1u << 6) // Log register operations
|
||||
#define WINDOWS_LOG_EVENT (1u << 7) // Low level debug events
|
||||
#define WINDOWS_LOG_ALL (UINT32_MAX)
|
||||
|
||||
enum class LogMaskReq
|
||||
{
|
||||
All,
|
||||
Any
|
||||
};
|
||||
|
||||
class ProcessWindowsLog
|
||||
{
|
||||
static const char *m_pluginname;
|
||||
|
||||
public:
|
||||
// ---------------------------------------------------------------------
|
||||
// Public Static Methods
|
||||
// ---------------------------------------------------------------------
|
||||
static void
|
||||
Initialize();
|
||||
|
||||
static void
|
||||
Terminate();
|
||||
|
||||
static void
|
||||
RegisterPluginName(const char *pluginName)
|
||||
{
|
||||
m_pluginname = pluginName;
|
||||
}
|
||||
|
||||
static void
|
||||
RegisterPluginName(lldb_private::ConstString pluginName)
|
||||
{
|
||||
m_pluginname = pluginName.GetCString();
|
||||
}
|
||||
|
||||
static bool
|
||||
TestLogFlags(uint32_t mask, LogMaskReq req);
|
||||
|
||||
static lldb_private::Log *
|
||||
GetLog();
|
||||
|
||||
static void
|
||||
DisableLog(const char **args, lldb_private::Stream *feedback_strm);
|
||||
|
||||
static lldb_private::Log *
|
||||
EnableLog(lldb::StreamSP &log_stream_sp, uint32_t log_options,
|
||||
const char **args, lldb_private::Stream *feedback_strm);
|
||||
|
||||
static void
|
||||
ListLogCategories(lldb_private::Stream *strm);
|
||||
};
|
||||
|
||||
#define WINLOGF_IF(Flags, Req, Method, ...) \
|
||||
{ \
|
||||
if (ProcessWindowsLog::TestLogFlags(Flags, Req)) \
|
||||
{ \
|
||||
Log *log = ProcessWindowsLog::GetLog(); \
|
||||
if (log) \
|
||||
log->Method(__VA_ARGS__); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define WINLOG_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Printf, __VA_ARGS__)
|
||||
#define WINLOG_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Printf, __VA_ARGS__)
|
||||
#define WINLOGV_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Verbose, __VA_ARGS__)
|
||||
#define WINLOGV_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Verbose, __VA_ARGS__)
|
||||
#define WINLOGD_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Debug, __VA_ARGS__)
|
||||
#define WINLOGD_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Debug, __VA_ARGS__)
|
||||
#define WINERR_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Error, __VA_ARGS__)
|
||||
#define WINERR_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Error, __VA_ARGS__)
|
||||
#define WINWARN_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Warning, __VA_ARGS__)
|
||||
#define WINWARN_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Warning, __VA_ARGS__)
|
||||
|
||||
#endif // liblldb_ProcessWindowsLog_h_
|
||||
//===-- ProcessWindowsLog.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_ProcessWindowsLog_h_
|
||||
#define liblldb_ProcessWindowsLog_h_
|
||||
|
||||
#include "lldb/Core/Log.h"
|
||||
|
||||
#define WINDOWS_LOG_VERBOSE (1u << 0)
|
||||
#define WINDOWS_LOG_PROCESS (1u << 1) // Log process operations
|
||||
#define WINDOWS_LOG_EXCEPTION (1u << 1) // Log exceptions
|
||||
#define WINDOWS_LOG_THREAD (1u << 2) // Log thread operations
|
||||
#define WINDOWS_LOG_MEMORY (1u << 3) // Log memory reads/writes calls
|
||||
#define WINDOWS_LOG_BREAKPOINTS (1u << 4) // Log breakpoint operations
|
||||
#define WINDOWS_LOG_STEP (1u << 5) // Log step operations
|
||||
#define WINDOWS_LOG_REGISTERS (1u << 6) // Log register operations
|
||||
#define WINDOWS_LOG_EVENT (1u << 7) // Low level debug events
|
||||
#define WINDOWS_LOG_ALL (UINT32_MAX)
|
||||
|
||||
enum class LogMaskReq
|
||||
{
|
||||
All,
|
||||
Any
|
||||
};
|
||||
|
||||
class ProcessWindowsLog
|
||||
{
|
||||
static const char *m_pluginname;
|
||||
|
||||
public:
|
||||
// ---------------------------------------------------------------------
|
||||
// Public Static Methods
|
||||
// ---------------------------------------------------------------------
|
||||
static void
|
||||
Initialize();
|
||||
|
||||
static void
|
||||
Terminate();
|
||||
|
||||
static void
|
||||
RegisterPluginName(const char *pluginName)
|
||||
{
|
||||
m_pluginname = pluginName;
|
||||
}
|
||||
|
||||
static void
|
||||
RegisterPluginName(lldb_private::ConstString pluginName)
|
||||
{
|
||||
m_pluginname = pluginName.GetCString();
|
||||
}
|
||||
|
||||
static bool
|
||||
TestLogFlags(uint32_t mask, LogMaskReq req);
|
||||
|
||||
static lldb_private::Log *
|
||||
GetLog();
|
||||
|
||||
static void
|
||||
DisableLog(const char **args, lldb_private::Stream *feedback_strm);
|
||||
|
||||
static lldb_private::Log *
|
||||
EnableLog(lldb::StreamSP &log_stream_sp, uint32_t log_options,
|
||||
const char **args, lldb_private::Stream *feedback_strm);
|
||||
|
||||
static void
|
||||
ListLogCategories(lldb_private::Stream *strm);
|
||||
};
|
||||
|
||||
#define WINLOGF_IF(Flags, Req, Method, ...) \
|
||||
{ \
|
||||
if (ProcessWindowsLog::TestLogFlags(Flags, Req)) \
|
||||
{ \
|
||||
Log *log = ProcessWindowsLog::GetLog(); \
|
||||
if (log) \
|
||||
log->Method(__VA_ARGS__); \
|
||||
} \
|
||||
}
|
||||
|
||||
#define WINLOG_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Printf, __VA_ARGS__)
|
||||
#define WINLOG_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Printf, __VA_ARGS__)
|
||||
#define WINLOGV_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Verbose, __VA_ARGS__)
|
||||
#define WINLOGV_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Verbose, __VA_ARGS__)
|
||||
#define WINLOGD_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Debug, __VA_ARGS__)
|
||||
#define WINLOGD_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Debug, __VA_ARGS__)
|
||||
#define WINERR_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Error, __VA_ARGS__)
|
||||
#define WINERR_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Error, __VA_ARGS__)
|
||||
#define WINWARN_IFANY(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::Any, Warning, __VA_ARGS__)
|
||||
#define WINWARN_IFALL(Flags, ...) WINLOGF_IF(Flags, LogMaskReq::All, Warning, __VA_ARGS__)
|
||||
|
||||
#endif // liblldb_ProcessWindowsLog_h_
|
||||
|
|
@ -1,155 +1,155 @@
|
|||
//===-- RegisterContextWindows.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 "ProcessWindowsLog.h"
|
||||
#include "RegisterContextWindows.h"
|
||||
#include "TargetThreadWindows.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows::RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx)
|
||||
: RegisterContext(thread, concrete_frame_idx)
|
||||
, m_context()
|
||||
, m_context_stale(true)
|
||||
{
|
||||
}
|
||||
|
||||
RegisterContextWindows::~RegisterContextWindows()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
RegisterContextWindows::InvalidateAllRegisters()
|
||||
{
|
||||
m_context_stale = true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
|
||||
{
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
if (data_sp->GetByteSize() < sizeof(m_context))
|
||||
{
|
||||
data_sp.reset(new DataBufferHeap(sizeof(CONTEXT), 0));
|
||||
}
|
||||
memcpy(data_sp->GetBytes(), &m_context, sizeof(m_context));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
|
||||
{
|
||||
assert(data_sp->GetByteSize() >= sizeof(m_context));
|
||||
memcpy(&m_context, data_sp->GetBytes(), sizeof(m_context));
|
||||
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::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;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses can these functions if desired
|
||||
//------------------------------------------------------------------
|
||||
uint32_t
|
||||
RegisterContextWindows::NumSupportedHardwareBreakpoints()
|
||||
{
|
||||
// Support for hardware breakpoints not yet implemented.
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::ClearHardwareBreakpoint(uint32_t hw_idx)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::NumSupportedHardwareWatchpoints()
|
||||
{
|
||||
// Support for hardware watchpoints not yet implemented.
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::ClearHardwareWatchpoint(uint32_t hw_index)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::HardwareSingleStep(bool enable)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::CacheAllRegisterValues()
|
||||
{
|
||||
if (!m_context_stale)
|
||||
return true;
|
||||
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
memset(&m_context, 0, sizeof(m_context));
|
||||
m_context.ContextFlags = kWinContextFlags;
|
||||
if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
|
||||
{
|
||||
WINERR_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext failed with error %u while caching register values.",
|
||||
::GetLastError());
|
||||
return false;
|
||||
}
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext successfully updated the register values.", ::GetLastError());
|
||||
m_context_stale = false;
|
||||
return true;
|
||||
}
|
||||
//===-- RegisterContextWindows.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 "ProcessWindowsLog.h"
|
||||
#include "RegisterContextWindows.h"
|
||||
#include "TargetThreadWindows.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
const DWORD kWinContextFlags = CONTEXT_CONTROL | CONTEXT_INTEGER;
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows::RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx)
|
||||
: RegisterContext(thread, concrete_frame_idx)
|
||||
, m_context()
|
||||
, m_context_stale(true)
|
||||
{
|
||||
}
|
||||
|
||||
RegisterContextWindows::~RegisterContextWindows()
|
||||
{
|
||||
}
|
||||
|
||||
void
|
||||
RegisterContextWindows::InvalidateAllRegisters()
|
||||
{
|
||||
m_context_stale = true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::ReadAllRegisterValues(lldb::DataBufferSP &data_sp)
|
||||
{
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
if (data_sp->GetByteSize() < sizeof(m_context))
|
||||
{
|
||||
data_sp.reset(new DataBufferHeap(sizeof(CONTEXT), 0));
|
||||
}
|
||||
memcpy(data_sp->GetBytes(), &m_context, sizeof(m_context));
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::WriteAllRegisterValues(const lldb::DataBufferSP &data_sp)
|
||||
{
|
||||
assert(data_sp->GetByteSize() >= sizeof(m_context));
|
||||
memcpy(&m_context, data_sp->GetBytes(), sizeof(m_context));
|
||||
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
if (!::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::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;
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses can these functions if desired
|
||||
//------------------------------------------------------------------
|
||||
uint32_t
|
||||
RegisterContextWindows::NumSupportedHardwareBreakpoints()
|
||||
{
|
||||
// Support for hardware breakpoints not yet implemented.
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::SetHardwareBreakpoint(lldb::addr_t addr, size_t size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::ClearHardwareBreakpoint(uint32_t hw_idx)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::NumSupportedHardwareWatchpoints()
|
||||
{
|
||||
// Support for hardware watchpoints not yet implemented.
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t
|
||||
RegisterContextWindows::SetHardwareWatchpoint(lldb::addr_t addr, size_t size, bool read, bool write)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::ClearHardwareWatchpoint(uint32_t hw_index)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::HardwareSingleStep(bool enable)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows::CacheAllRegisterValues()
|
||||
{
|
||||
if (!m_context_stale)
|
||||
return true;
|
||||
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
memset(&m_context, 0, sizeof(m_context));
|
||||
m_context.ContextFlags = kWinContextFlags;
|
||||
if (!::GetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context))
|
||||
{
|
||||
WINERR_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext failed with error %u while caching register values.",
|
||||
::GetLastError());
|
||||
return false;
|
||||
}
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "GetThreadContext successfully updated the register values.", ::GetLastError());
|
||||
m_context_stale = false;
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1,69 +1,69 @@
|
|||
//===-- RegisterContextWindows.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_RegisterContextWindows_H_
|
||||
#define liblldb_RegisterContextWindows_H_
|
||||
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/Target/RegisterContext.h"
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class Thread;
|
||||
|
||||
class RegisterContextWindows : public lldb_private::RegisterContext
|
||||
{
|
||||
public:
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx);
|
||||
|
||||
virtual ~RegisterContextWindows();
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses must override these functions
|
||||
//------------------------------------------------------------------
|
||||
void InvalidateAllRegisters() 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;
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses can override these functions if desired
|
||||
//------------------------------------------------------------------
|
||||
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;
|
||||
|
||||
protected:
|
||||
bool CacheAllRegisterValues();
|
||||
|
||||
CONTEXT m_context;
|
||||
|
||||
private:
|
||||
bool m_context_stale;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_
|
||||
//===-- RegisterContextWindows.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_RegisterContextWindows_H_
|
||||
#define liblldb_RegisterContextWindows_H_
|
||||
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/Target/RegisterContext.h"
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class Thread;
|
||||
|
||||
class RegisterContextWindows : public lldb_private::RegisterContext
|
||||
{
|
||||
public:
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows(Thread &thread, uint32_t concrete_frame_idx);
|
||||
|
||||
virtual ~RegisterContextWindows();
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses must override these functions
|
||||
//------------------------------------------------------------------
|
||||
void InvalidateAllRegisters() 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;
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses can override these functions if desired
|
||||
//------------------------------------------------------------------
|
||||
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;
|
||||
|
||||
protected:
|
||||
bool CacheAllRegisterValues();
|
||||
|
||||
CONTEXT m_context;
|
||||
|
||||
private:
|
||||
bool m_context_stale;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // #ifndef liblldb_RegisterContextPOSIX_x86_H_
|
||||
|
|
@ -1,57 +1,57 @@
|
|||
//===-- TargetThreadWindows.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_Plugins_Process_Windows_TargetThreadWindows_H_
|
||||
#define liblldb_Plugins_Process_Windows_TargetThreadWindows_H_
|
||||
|
||||
#include "ForwardDecl.h"
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/Host/HostThread.h"
|
||||
#include "lldb/Target/Thread.h"
|
||||
class ProcessWindows;
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class HostThread;
|
||||
class StackFrame;
|
||||
|
||||
class TargetThreadWindows : public lldb_private::Thread
|
||||
{
|
||||
public:
|
||||
TargetThreadWindows(ProcessWindows &process, const HostThread &thread);
|
||||
virtual ~TargetThreadWindows();
|
||||
|
||||
// lldb_private::Thread overrides
|
||||
void RefreshStateAfterStop() override;
|
||||
void WillResume(lldb::StateType resume_state) override;
|
||||
void DidStop() override;
|
||||
lldb::RegisterContextSP GetRegisterContext() override;
|
||||
lldb::RegisterContextSP CreateRegisterContextForFrame(StackFrame *frame) override;
|
||||
bool CalculateStopInfo() override;
|
||||
Unwind *GetUnwinder() override;
|
||||
|
||||
bool DoResume();
|
||||
|
||||
HostThread
|
||||
GetHostThread() const
|
||||
{
|
||||
return m_host_thread;
|
||||
}
|
||||
|
||||
private:
|
||||
lldb::RegisterContextSP CreateRegisterContextForFrameIndex(uint32_t idx);
|
||||
|
||||
lldb::StackFrameUP m_stack_frame;
|
||||
|
||||
HostThread m_host_thread;
|
||||
};
|
||||
}
|
||||
|
||||
//===-- TargetThreadWindows.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_Plugins_Process_Windows_TargetThreadWindows_H_
|
||||
#define liblldb_Plugins_Process_Windows_TargetThreadWindows_H_
|
||||
|
||||
#include "ForwardDecl.h"
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "lldb/Host/HostThread.h"
|
||||
#include "lldb/Target/Thread.h"
|
||||
class ProcessWindows;
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class HostThread;
|
||||
class StackFrame;
|
||||
|
||||
class TargetThreadWindows : public lldb_private::Thread
|
||||
{
|
||||
public:
|
||||
TargetThreadWindows(ProcessWindows &process, const HostThread &thread);
|
||||
virtual ~TargetThreadWindows();
|
||||
|
||||
// lldb_private::Thread overrides
|
||||
void RefreshStateAfterStop() override;
|
||||
void WillResume(lldb::StateType resume_state) override;
|
||||
void DidStop() override;
|
||||
lldb::RegisterContextSP GetRegisterContext() override;
|
||||
lldb::RegisterContextSP CreateRegisterContextForFrame(StackFrame *frame) override;
|
||||
bool CalculateStopInfo() override;
|
||||
Unwind *GetUnwinder() override;
|
||||
|
||||
bool DoResume();
|
||||
|
||||
HostThread
|
||||
GetHostThread() const
|
||||
{
|
||||
return m_host_thread;
|
||||
}
|
||||
|
||||
private:
|
||||
lldb::RegisterContextSP CreateRegisterContextForFrameIndex(uint32_t idx);
|
||||
|
||||
lldb::StackFrameUP m_stack_frame;
|
||||
|
||||
HostThread m_host_thread;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,323 +1,323 @@
|
|||
//===-- RegisterContextWindows_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/lldb-private-types.h"
|
||||
#include "lldb/Core/Error.h"
|
||||
#include "lldb/Core/RegisterValue.h"
|
||||
#include "lldb/Host/windows/HostThreadWindows.h"
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
|
||||
#include "lldb-x86-register-enums.h"
|
||||
#include "RegisterContext_x86.h"
|
||||
#include "RegisterContextWindows_x64.h"
|
||||
#include "TargetThreadWindows.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
#define DEFINE_GPR(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatHexUppercase
|
||||
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatBinary
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
// This enum defines the layout of the global RegisterInfo array. This is necessary because
|
||||
// lldb register sets are defined in terms of indices into the register array. As such, the
|
||||
// order of RegisterInfos defined in global registers array must match the order defined here.
|
||||
// When defining the register set layouts, these values can appear in an arbitrary order, and that
|
||||
// determines the order that register values are displayed in a dump.
|
||||
enum RegisterIndex
|
||||
{
|
||||
eRegisterIndexRax,
|
||||
eRegisterIndexRbx,
|
||||
eRegisterIndexRcx,
|
||||
eRegisterIndexRdx,
|
||||
eRegisterIndexRdi,
|
||||
eRegisterIndexRsi,
|
||||
eRegisterIndexR8,
|
||||
eRegisterIndexR9,
|
||||
eRegisterIndexR10,
|
||||
eRegisterIndexR11,
|
||||
eRegisterIndexR12,
|
||||
eRegisterIndexR13,
|
||||
eRegisterIndexR14,
|
||||
eRegisterIndexR15,
|
||||
eRegisterIndexRbp,
|
||||
eRegisterIndexRsp,
|
||||
eRegisterIndexRip,
|
||||
eRegisterIndexRflags
|
||||
};
|
||||
|
||||
// Array of all register information supported by Windows x86
|
||||
RegisterInfo g_register_infos[] = {
|
||||
// Macro auto defines most stuff GCC DWARF GENERIC
|
||||
// GDB LLDB VALUE REGS INVALIDATE REGS
|
||||
// ================================ ========================= ====================== =========================
|
||||
// =================== ================= ========== ===============
|
||||
{DEFINE_GPR(rax, nullptr),
|
||||
{gcc_dwarf_rax_x86_64, gcc_dwarf_rax_x86_64, LLDB_INVALID_REGNUM, gdb_rax_x86_64, lldb_rax_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rbx, nullptr),
|
||||
{gcc_dwarf_rbx_x86_64, gcc_dwarf_rbx_x86_64, LLDB_INVALID_REGNUM, gdb_rbx_x86_64, lldb_rbx_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rcx, nullptr),
|
||||
{gcc_dwarf_rcx_x86_64, gcc_dwarf_rcx_x86_64, LLDB_INVALID_REGNUM, gdb_rcx_x86_64, lldb_rcx_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rdx, nullptr),
|
||||
{gcc_dwarf_rdx_x86_64, gcc_dwarf_rdx_x86_64, LLDB_INVALID_REGNUM, gdb_rdx_x86_64, lldb_rdx_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rdi, nullptr),
|
||||
{gcc_dwarf_rdi_x86_64, gcc_dwarf_rdi_x86_64, LLDB_INVALID_REGNUM, gdb_rdi_x86_64, lldb_rdi_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rsi, nullptr),
|
||||
{gcc_dwarf_rsi_x86_64, gcc_dwarf_rsi_x86_64, LLDB_INVALID_REGNUM, gdb_rsi_x86_64, lldb_rsi_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r8, nullptr),
|
||||
{gcc_dwarf_r8_x86_64, gcc_dwarf_r8_x86_64, LLDB_INVALID_REGNUM, gdb_r8_x86_64, lldb_r8_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r9, nullptr),
|
||||
{gcc_dwarf_r9_x86_64, gcc_dwarf_r9_x86_64, LLDB_INVALID_REGNUM, gdb_r9_x86_64, lldb_r9_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r10, nullptr),
|
||||
{gcc_dwarf_r10_x86_64, gcc_dwarf_r10_x86_64, LLDB_INVALID_REGNUM, gdb_r10_x86_64, lldb_r10_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r11, nullptr),
|
||||
{gcc_dwarf_r11_x86_64, gcc_dwarf_r11_x86_64, LLDB_INVALID_REGNUM, gdb_r11_x86_64, lldb_r11_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r12, nullptr),
|
||||
{gcc_dwarf_r12_x86_64, gcc_dwarf_r12_x86_64, LLDB_INVALID_REGNUM, gdb_r12_x86_64, lldb_r12_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r13, nullptr),
|
||||
{gcc_dwarf_r13_x86_64, gcc_dwarf_r13_x86_64, LLDB_INVALID_REGNUM, gdb_r13_x86_64, lldb_r13_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r14, nullptr),
|
||||
{gcc_dwarf_r14_x86_64, gcc_dwarf_r14_x86_64, LLDB_INVALID_REGNUM, gdb_r14_x86_64, lldb_r14_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r15, nullptr),
|
||||
{gcc_dwarf_r15_x86_64, gcc_dwarf_r15_x86_64, LLDB_INVALID_REGNUM, gdb_r15_x86_64, lldb_r15_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rbp, "fp"),
|
||||
{gcc_dwarf_rbp_x86_64, gcc_dwarf_rbp_x86_64, LLDB_REGNUM_GENERIC_FP, gdb_rbp_x86_64, lldb_rbp_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rsp, "sp"),
|
||||
{gcc_dwarf_rsp_x86_64, gcc_dwarf_rsp_x86_64, LLDB_REGNUM_GENERIC_SP, gdb_rsp_x86_64, lldb_rsp_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rip, "pc"),
|
||||
{gcc_dwarf_rip_x86_64, gcc_dwarf_rip_x86_64, LLDB_REGNUM_GENERIC_PC, gdb_rip_x86_64, lldb_rip_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR_BIN(eflags, "flags"),
|
||||
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS, gdb_rflags_x86_64, lldb_rflags_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
};
|
||||
|
||||
// Array of lldb register numbers used to define the set of all General Purpose Registers
|
||||
uint32_t g_gpr_reg_indices[] = {eRegisterIndexRax, eRegisterIndexRbx, eRegisterIndexRcx, eRegisterIndexRdx,
|
||||
eRegisterIndexRdi, eRegisterIndexRsi, eRegisterIndexR8, eRegisterIndexR9,
|
||||
eRegisterIndexR10, eRegisterIndexR11, eRegisterIndexR12, eRegisterIndexR13,
|
||||
eRegisterIndexR14, eRegisterIndexR15, eRegisterIndexRbp, eRegisterIndexRsp,
|
||||
eRegisterIndexRip, eRegisterIndexRflags};
|
||||
|
||||
RegisterSet g_register_sets[] = {
|
||||
{"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
|
||||
};
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows_x64::RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx)
|
||||
: RegisterContextWindows(thread, concrete_frame_idx)
|
||||
{
|
||||
}
|
||||
|
||||
RegisterContextWindows_x64::~RegisterContextWindows_x64()
|
||||
{
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x64::GetRegisterCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_infos);
|
||||
}
|
||||
|
||||
const RegisterInfo *
|
||||
RegisterContextWindows_x64::GetRegisterInfoAtIndex(size_t reg)
|
||||
{
|
||||
return &g_register_infos[reg];
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x64::GetRegisterSetCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_sets);
|
||||
}
|
||||
|
||||
const RegisterSet *
|
||||
RegisterContextWindows_x64::GetRegisterSet(size_t reg_set)
|
||||
{
|
||||
return &g_register_sets[reg_set];
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)
|
||||
{
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
switch (reg_info->kinds[eRegisterKindLLDB])
|
||||
{
|
||||
case lldb_rax_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rax);
|
||||
break;
|
||||
case lldb_rbx_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rbx);
|
||||
break;
|
||||
case lldb_rcx_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rcx);
|
||||
break;
|
||||
case lldb_rdx_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rdx);
|
||||
break;
|
||||
case lldb_rdi_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rdi);
|
||||
break;
|
||||
case lldb_rsi_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rsi);
|
||||
break;
|
||||
case lldb_r8_x86_64:
|
||||
reg_value.SetUInt64(m_context.R8);
|
||||
break;
|
||||
case lldb_r9_x86_64:
|
||||
reg_value.SetUInt64(m_context.R9);
|
||||
break;
|
||||
case lldb_r10_x86_64:
|
||||
reg_value.SetUInt64(m_context.R10);
|
||||
break;
|
||||
case lldb_r11_x86_64:
|
||||
reg_value.SetUInt64(m_context.R11);
|
||||
break;
|
||||
case lldb_r12_x86_64:
|
||||
reg_value.SetUInt64(m_context.R12);
|
||||
break;
|
||||
case lldb_r13_x86_64:
|
||||
reg_value.SetUInt64(m_context.R13);
|
||||
break;
|
||||
case lldb_r14_x86_64:
|
||||
reg_value.SetUInt64(m_context.R14);
|
||||
break;
|
||||
case lldb_r15_x86_64:
|
||||
reg_value.SetUInt64(m_context.R15);
|
||||
break;
|
||||
case lldb_rbp_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rbp);
|
||||
break;
|
||||
case lldb_rsp_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rsp);
|
||||
break;
|
||||
case lldb_rip_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rip);
|
||||
break;
|
||||
case lldb_rflags_x86_64:
|
||||
reg_value.SetUInt64(m_context.EFlags);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x64::WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value)
|
||||
{
|
||||
// Since we cannot only write a single register value to the inferior, we need to make sure
|
||||
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
|
||||
// we may also overwrite some other register with a stale value.
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
switch (reg_info->kinds[eRegisterKindLLDB])
|
||||
{
|
||||
case lldb_rax_x86_64:
|
||||
m_context.Rax = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rbx_x86_64:
|
||||
m_context.Rbx = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rcx_x86_64:
|
||||
m_context.Rcx = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rdx_x86_64:
|
||||
m_context.Rdx = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rdi_x86_64:
|
||||
m_context.Rdi = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rsi_x86_64:
|
||||
m_context.Rsi = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r8_x86_64:
|
||||
m_context.R8 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r9_x86_64:
|
||||
m_context.R9 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r10_x86_64:
|
||||
m_context.R10 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r11_x86_64:
|
||||
m_context.R11 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r12_x86_64:
|
||||
m_context.R12 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r13_x86_64:
|
||||
m_context.R13 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r14_x86_64:
|
||||
m_context.R14 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r15_x86_64:
|
||||
m_context.R15 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rbp_x86_64:
|
||||
m_context.Rbp = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rsp_x86_64:
|
||||
m_context.Rsp = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rip_x86_64:
|
||||
m_context.Rip = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rflags_x86_64:
|
||||
m_context.EFlags = reg_value.GetAsUInt64();
|
||||
break;
|
||||
}
|
||||
|
||||
// Physically update the registers in the target process.
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
|
||||
}
|
||||
//===-- RegisterContextWindows_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/lldb-private-types.h"
|
||||
#include "lldb/Core/Error.h"
|
||||
#include "lldb/Core/RegisterValue.h"
|
||||
#include "lldb/Host/windows/HostThreadWindows.h"
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
|
||||
#include "lldb-x86-register-enums.h"
|
||||
#include "RegisterContext_x86.h"
|
||||
#include "RegisterContextWindows_x64.h"
|
||||
#include "TargetThreadWindows.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
#define DEFINE_GPR(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatHexUppercase
|
||||
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 8, 0, eEncodingUint, eFormatBinary
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
// This enum defines the layout of the global RegisterInfo array. This is necessary because
|
||||
// lldb register sets are defined in terms of indices into the register array. As such, the
|
||||
// order of RegisterInfos defined in global registers array must match the order defined here.
|
||||
// When defining the register set layouts, these values can appear in an arbitrary order, and that
|
||||
// determines the order that register values are displayed in a dump.
|
||||
enum RegisterIndex
|
||||
{
|
||||
eRegisterIndexRax,
|
||||
eRegisterIndexRbx,
|
||||
eRegisterIndexRcx,
|
||||
eRegisterIndexRdx,
|
||||
eRegisterIndexRdi,
|
||||
eRegisterIndexRsi,
|
||||
eRegisterIndexR8,
|
||||
eRegisterIndexR9,
|
||||
eRegisterIndexR10,
|
||||
eRegisterIndexR11,
|
||||
eRegisterIndexR12,
|
||||
eRegisterIndexR13,
|
||||
eRegisterIndexR14,
|
||||
eRegisterIndexR15,
|
||||
eRegisterIndexRbp,
|
||||
eRegisterIndexRsp,
|
||||
eRegisterIndexRip,
|
||||
eRegisterIndexRflags
|
||||
};
|
||||
|
||||
// Array of all register information supported by Windows x86
|
||||
RegisterInfo g_register_infos[] = {
|
||||
// Macro auto defines most stuff GCC DWARF GENERIC
|
||||
// GDB LLDB VALUE REGS INVALIDATE REGS
|
||||
// ================================ ========================= ====================== =========================
|
||||
// =================== ================= ========== ===============
|
||||
{DEFINE_GPR(rax, nullptr),
|
||||
{gcc_dwarf_rax_x86_64, gcc_dwarf_rax_x86_64, LLDB_INVALID_REGNUM, gdb_rax_x86_64, lldb_rax_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rbx, nullptr),
|
||||
{gcc_dwarf_rbx_x86_64, gcc_dwarf_rbx_x86_64, LLDB_INVALID_REGNUM, gdb_rbx_x86_64, lldb_rbx_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rcx, nullptr),
|
||||
{gcc_dwarf_rcx_x86_64, gcc_dwarf_rcx_x86_64, LLDB_INVALID_REGNUM, gdb_rcx_x86_64, lldb_rcx_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rdx, nullptr),
|
||||
{gcc_dwarf_rdx_x86_64, gcc_dwarf_rdx_x86_64, LLDB_INVALID_REGNUM, gdb_rdx_x86_64, lldb_rdx_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rdi, nullptr),
|
||||
{gcc_dwarf_rdi_x86_64, gcc_dwarf_rdi_x86_64, LLDB_INVALID_REGNUM, gdb_rdi_x86_64, lldb_rdi_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rsi, nullptr),
|
||||
{gcc_dwarf_rsi_x86_64, gcc_dwarf_rsi_x86_64, LLDB_INVALID_REGNUM, gdb_rsi_x86_64, lldb_rsi_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r8, nullptr),
|
||||
{gcc_dwarf_r8_x86_64, gcc_dwarf_r8_x86_64, LLDB_INVALID_REGNUM, gdb_r8_x86_64, lldb_r8_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r9, nullptr),
|
||||
{gcc_dwarf_r9_x86_64, gcc_dwarf_r9_x86_64, LLDB_INVALID_REGNUM, gdb_r9_x86_64, lldb_r9_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r10, nullptr),
|
||||
{gcc_dwarf_r10_x86_64, gcc_dwarf_r10_x86_64, LLDB_INVALID_REGNUM, gdb_r10_x86_64, lldb_r10_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r11, nullptr),
|
||||
{gcc_dwarf_r11_x86_64, gcc_dwarf_r11_x86_64, LLDB_INVALID_REGNUM, gdb_r11_x86_64, lldb_r11_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r12, nullptr),
|
||||
{gcc_dwarf_r12_x86_64, gcc_dwarf_r12_x86_64, LLDB_INVALID_REGNUM, gdb_r12_x86_64, lldb_r12_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r13, nullptr),
|
||||
{gcc_dwarf_r13_x86_64, gcc_dwarf_r13_x86_64, LLDB_INVALID_REGNUM, gdb_r13_x86_64, lldb_r13_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r14, nullptr),
|
||||
{gcc_dwarf_r14_x86_64, gcc_dwarf_r14_x86_64, LLDB_INVALID_REGNUM, gdb_r14_x86_64, lldb_r14_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(r15, nullptr),
|
||||
{gcc_dwarf_r15_x86_64, gcc_dwarf_r15_x86_64, LLDB_INVALID_REGNUM, gdb_r15_x86_64, lldb_r15_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rbp, "fp"),
|
||||
{gcc_dwarf_rbp_x86_64, gcc_dwarf_rbp_x86_64, LLDB_REGNUM_GENERIC_FP, gdb_rbp_x86_64, lldb_rbp_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rsp, "sp"),
|
||||
{gcc_dwarf_rsp_x86_64, gcc_dwarf_rsp_x86_64, LLDB_REGNUM_GENERIC_SP, gdb_rsp_x86_64, lldb_rsp_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR(rip, "pc"),
|
||||
{gcc_dwarf_rip_x86_64, gcc_dwarf_rip_x86_64, LLDB_REGNUM_GENERIC_PC, gdb_rip_x86_64, lldb_rip_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
{DEFINE_GPR_BIN(eflags, "flags"),
|
||||
{LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_REGNUM_GENERIC_FLAGS, gdb_rflags_x86_64, lldb_rflags_x86_64},
|
||||
nullptr,
|
||||
nullptr},
|
||||
};
|
||||
|
||||
// Array of lldb register numbers used to define the set of all General Purpose Registers
|
||||
uint32_t g_gpr_reg_indices[] = {eRegisterIndexRax, eRegisterIndexRbx, eRegisterIndexRcx, eRegisterIndexRdx,
|
||||
eRegisterIndexRdi, eRegisterIndexRsi, eRegisterIndexR8, eRegisterIndexR9,
|
||||
eRegisterIndexR10, eRegisterIndexR11, eRegisterIndexR12, eRegisterIndexR13,
|
||||
eRegisterIndexR14, eRegisterIndexR15, eRegisterIndexRbp, eRegisterIndexRsp,
|
||||
eRegisterIndexRip, eRegisterIndexRflags};
|
||||
|
||||
RegisterSet g_register_sets[] = {
|
||||
{"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
|
||||
};
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows_x64::RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx)
|
||||
: RegisterContextWindows(thread, concrete_frame_idx)
|
||||
{
|
||||
}
|
||||
|
||||
RegisterContextWindows_x64::~RegisterContextWindows_x64()
|
||||
{
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x64::GetRegisterCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_infos);
|
||||
}
|
||||
|
||||
const RegisterInfo *
|
||||
RegisterContextWindows_x64::GetRegisterInfoAtIndex(size_t reg)
|
||||
{
|
||||
return &g_register_infos[reg];
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x64::GetRegisterSetCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_sets);
|
||||
}
|
||||
|
||||
const RegisterSet *
|
||||
RegisterContextWindows_x64::GetRegisterSet(size_t reg_set)
|
||||
{
|
||||
return &g_register_sets[reg_set];
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x64::ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)
|
||||
{
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
switch (reg_info->kinds[eRegisterKindLLDB])
|
||||
{
|
||||
case lldb_rax_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rax);
|
||||
break;
|
||||
case lldb_rbx_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rbx);
|
||||
break;
|
||||
case lldb_rcx_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rcx);
|
||||
break;
|
||||
case lldb_rdx_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rdx);
|
||||
break;
|
||||
case lldb_rdi_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rdi);
|
||||
break;
|
||||
case lldb_rsi_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rsi);
|
||||
break;
|
||||
case lldb_r8_x86_64:
|
||||
reg_value.SetUInt64(m_context.R8);
|
||||
break;
|
||||
case lldb_r9_x86_64:
|
||||
reg_value.SetUInt64(m_context.R9);
|
||||
break;
|
||||
case lldb_r10_x86_64:
|
||||
reg_value.SetUInt64(m_context.R10);
|
||||
break;
|
||||
case lldb_r11_x86_64:
|
||||
reg_value.SetUInt64(m_context.R11);
|
||||
break;
|
||||
case lldb_r12_x86_64:
|
||||
reg_value.SetUInt64(m_context.R12);
|
||||
break;
|
||||
case lldb_r13_x86_64:
|
||||
reg_value.SetUInt64(m_context.R13);
|
||||
break;
|
||||
case lldb_r14_x86_64:
|
||||
reg_value.SetUInt64(m_context.R14);
|
||||
break;
|
||||
case lldb_r15_x86_64:
|
||||
reg_value.SetUInt64(m_context.R15);
|
||||
break;
|
||||
case lldb_rbp_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rbp);
|
||||
break;
|
||||
case lldb_rsp_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rsp);
|
||||
break;
|
||||
case lldb_rip_x86_64:
|
||||
reg_value.SetUInt64(m_context.Rip);
|
||||
break;
|
||||
case lldb_rflags_x86_64:
|
||||
reg_value.SetUInt64(m_context.EFlags);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x64::WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value)
|
||||
{
|
||||
// Since we cannot only write a single register value to the inferior, we need to make sure
|
||||
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
|
||||
// we may also overwrite some other register with a stale value.
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
switch (reg_info->kinds[eRegisterKindLLDB])
|
||||
{
|
||||
case lldb_rax_x86_64:
|
||||
m_context.Rax = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rbx_x86_64:
|
||||
m_context.Rbx = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rcx_x86_64:
|
||||
m_context.Rcx = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rdx_x86_64:
|
||||
m_context.Rdx = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rdi_x86_64:
|
||||
m_context.Rdi = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rsi_x86_64:
|
||||
m_context.Rsi = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r8_x86_64:
|
||||
m_context.R8 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r9_x86_64:
|
||||
m_context.R9 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r10_x86_64:
|
||||
m_context.R10 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r11_x86_64:
|
||||
m_context.R11 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r12_x86_64:
|
||||
m_context.R12 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r13_x86_64:
|
||||
m_context.R13 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r14_x86_64:
|
||||
m_context.R14 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_r15_x86_64:
|
||||
m_context.R15 = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rbp_x86_64:
|
||||
m_context.Rbp = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rsp_x86_64:
|
||||
m_context.Rsp = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rip_x86_64:
|
||||
m_context.Rip = reg_value.GetAsUInt64();
|
||||
break;
|
||||
case lldb_rflags_x86_64:
|
||||
m_context.EFlags = reg_value.GetAsUInt64();
|
||||
break;
|
||||
}
|
||||
|
||||
// Physically update the registers in the target process.
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
|
||||
}
|
||||
|
|
@ -1,48 +1,48 @@
|
|||
//===-- RegisterContextWindows_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_RegisterContextWindows_x64_H_
|
||||
#define liblldb_RegisterContextWindows_x64_H_
|
||||
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "RegisterContextWindows.h"
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class Thread;
|
||||
|
||||
class RegisterContextWindows_x64 : public RegisterContextWindows
|
||||
{
|
||||
public:
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx);
|
||||
|
||||
virtual ~RegisterContextWindows_x64();
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses must override these functions
|
||||
//------------------------------------------------------------------
|
||||
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 ®_value) override;
|
||||
|
||||
bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value) override;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // #ifndef liblldb_RegisterContextPOSIX_x64_H_
|
||||
//===-- RegisterContextWindows_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_RegisterContextWindows_x64_H_
|
||||
#define liblldb_RegisterContextWindows_x64_H_
|
||||
|
||||
#include "lldb/lldb-forward.h"
|
||||
#include "RegisterContextWindows.h"
|
||||
|
||||
namespace lldb_private
|
||||
{
|
||||
|
||||
class Thread;
|
||||
|
||||
class RegisterContextWindows_x64 : public RegisterContextWindows
|
||||
{
|
||||
public:
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows_x64(Thread &thread, uint32_t concrete_frame_idx);
|
||||
|
||||
virtual ~RegisterContextWindows_x64();
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Subclasses must override these functions
|
||||
//------------------------------------------------------------------
|
||||
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 ®_value) override;
|
||||
|
||||
bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value) override;
|
||||
};
|
||||
}
|
||||
|
||||
#endif // #ifndef liblldb_RegisterContextPOSIX_x64_H_
|
||||
|
|
@ -1,241 +1,241 @@
|
|||
//===-- RegisterContextWindows_x86.h ----------------------------*- 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/Error.h"
|
||||
#include "lldb/Core/RegisterValue.h"
|
||||
#include "lldb/Host/windows/HostThreadWindows.h"
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
|
||||
#include "lldb-x86-register-enums.h"
|
||||
#include "ProcessWindowsLog.h"
|
||||
#include "RegisterContext_x86.h"
|
||||
#include "RegisterContextWindows_x86.h"
|
||||
#include "TargetThreadWindows.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
#define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase
|
||||
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
// This enum defines the layout of the global RegisterInfo array. This is necessary because
|
||||
// lldb register sets are defined in terms of indices into the register array. As such, the
|
||||
// order of RegisterInfos defined in global registers array must match the order defined here.
|
||||
// When defining the register set layouts, these values can appear in an arbitrary order, and that
|
||||
// determines the order that register values are displayed in a dump.
|
||||
enum RegisterIndex
|
||||
{
|
||||
eRegisterIndexEax,
|
||||
eRegisterIndexEbx,
|
||||
eRegisterIndexEcx,
|
||||
eRegisterIndexEdx,
|
||||
eRegisterIndexEdi,
|
||||
eRegisterIndexEsi,
|
||||
eRegisterIndexEbp,
|
||||
eRegisterIndexEsp,
|
||||
eRegisterIndexEip,
|
||||
eRegisterIndexEflags
|
||||
};
|
||||
|
||||
// Array of all register information supported by Windows x86
|
||||
RegisterInfo g_register_infos[] =
|
||||
{
|
||||
// Macro auto defines most stuff GCC DWARF GENERIC GDB LLDB VALUE REGS INVALIDATE REGS
|
||||
// ============================== ======================= =================== ========================= =================== ================= ========== ===============
|
||||
{ DEFINE_GPR(eax, nullptr), { gcc_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_eax_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(ebx, nullptr), { gcc_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ebx_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(ecx, nullptr), { gcc_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ecx_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(edx, nullptr), { gcc_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edx_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(edi, nullptr), { gcc_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edi_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(esi, nullptr), { gcc_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_esi_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(ebp, "fp"), { gcc_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM, lldb_ebp_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(esp, "sp"), { gcc_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM, lldb_esp_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(eip, "pc"), { gcc_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM, lldb_eip_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR_BIN(eflags, "flags"), { gcc_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM, lldb_eflags_i386}, nullptr, nullptr},
|
||||
};
|
||||
|
||||
// Array of lldb register numbers used to define the set of all General Purpose Registers
|
||||
uint32_t g_gpr_reg_indices[] =
|
||||
{
|
||||
eRegisterIndexEax,
|
||||
eRegisterIndexEbx,
|
||||
eRegisterIndexEcx,
|
||||
eRegisterIndexEdx,
|
||||
eRegisterIndexEdi,
|
||||
eRegisterIndexEsi,
|
||||
eRegisterIndexEbp,
|
||||
eRegisterIndexEsp,
|
||||
eRegisterIndexEip,
|
||||
eRegisterIndexEflags
|
||||
};
|
||||
|
||||
RegisterSet g_register_sets[] = {
|
||||
{"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
|
||||
};
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)
|
||||
: RegisterContextWindows(thread, concrete_frame_idx)
|
||||
{
|
||||
}
|
||||
|
||||
RegisterContextWindows_x86::~RegisterContextWindows_x86()
|
||||
{
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x86::GetRegisterCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_infos);
|
||||
}
|
||||
|
||||
const RegisterInfo *
|
||||
RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)
|
||||
{
|
||||
return &g_register_infos[reg];
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x86::GetRegisterSetCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_sets);
|
||||
}
|
||||
|
||||
const RegisterSet *
|
||||
RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)
|
||||
{
|
||||
return &g_register_sets[reg_set];
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)
|
||||
{
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
|
||||
switch (reg)
|
||||
{
|
||||
case lldb_eax_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EAX", m_context.Eax);
|
||||
reg_value.SetUInt32(m_context.Eax);
|
||||
break;
|
||||
case lldb_ebx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBX", m_context.Ebx);
|
||||
reg_value.SetUInt32(m_context.Ebx);
|
||||
break;
|
||||
case lldb_ecx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ECX", m_context.Ecx);
|
||||
reg_value.SetUInt32(m_context.Ecx);
|
||||
break;
|
||||
case lldb_edx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDX", m_context.Edx);
|
||||
reg_value.SetUInt32(m_context.Edx);
|
||||
break;
|
||||
case lldb_edi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDI", m_context.Edi);
|
||||
reg_value.SetUInt32(m_context.Edi);
|
||||
break;
|
||||
case lldb_esi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESI", m_context.Esi);
|
||||
reg_value.SetUInt32(m_context.Esi);
|
||||
break;
|
||||
case lldb_ebp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBP", m_context.Ebp);
|
||||
reg_value.SetUInt32(m_context.Ebp);
|
||||
break;
|
||||
case lldb_esp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESP", m_context.Esp);
|
||||
reg_value.SetUInt32(m_context.Esp);
|
||||
break;
|
||||
case lldb_eip_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EIP", m_context.Eip);
|
||||
reg_value.SetUInt32(m_context.Eip);
|
||||
break;
|
||||
case lldb_eflags_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EFLAGS", m_context.EFlags);
|
||||
reg_value.SetUInt32(m_context.EFlags);
|
||||
break;
|
||||
default:
|
||||
WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Requested unknown register %u", reg);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value)
|
||||
{
|
||||
// Since we cannot only write a single register value to the inferior, we need to make sure
|
||||
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
|
||||
// we may also overwrite some other register with a stale value.
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
|
||||
switch (reg)
|
||||
{
|
||||
case lldb_eax_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EAX", reg_value.GetAsUInt32());
|
||||
m_context.Eax = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_ebx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBX", reg_value.GetAsUInt32());
|
||||
m_context.Ebx = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_ecx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ECX", reg_value.GetAsUInt32());
|
||||
m_context.Ecx = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_edx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDX", reg_value.GetAsUInt32());
|
||||
m_context.Edx = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_edi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDI", reg_value.GetAsUInt32());
|
||||
m_context.Edi = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_esi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESI", reg_value.GetAsUInt32());
|
||||
m_context.Esi = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_ebp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBP", reg_value.GetAsUInt32());
|
||||
m_context.Ebp = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_esp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESP", reg_value.GetAsUInt32());
|
||||
m_context.Esp = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_eip_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EIP", reg_value.GetAsUInt32());
|
||||
m_context.Eip = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_eflags_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EFLAGS", reg_value.GetAsUInt32());
|
||||
m_context.EFlags = reg_value.GetAsUInt32();
|
||||
break;
|
||||
default:
|
||||
WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to unknown register %u", reg_value.GetAsUInt32(),
|
||||
reg);
|
||||
}
|
||||
|
||||
// Physically update the registers in the target process.
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
|
||||
}
|
||||
//===-- RegisterContextWindows_x86.h ----------------------------*- 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/Error.h"
|
||||
#include "lldb/Core/RegisterValue.h"
|
||||
#include "lldb/Host/windows/HostThreadWindows.h"
|
||||
#include "lldb/Host/windows/windows.h"
|
||||
|
||||
#include "lldb-x86-register-enums.h"
|
||||
#include "ProcessWindowsLog.h"
|
||||
#include "RegisterContext_x86.h"
|
||||
#include "RegisterContextWindows_x86.h"
|
||||
#include "TargetThreadWindows.h"
|
||||
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
|
||||
using namespace lldb;
|
||||
using namespace lldb_private;
|
||||
|
||||
#define DEFINE_GPR(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatHexUppercase
|
||||
#define DEFINE_GPR_BIN(reg, alt) #reg, alt, 4, 0, eEncodingUint, eFormatBinary
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
// This enum defines the layout of the global RegisterInfo array. This is necessary because
|
||||
// lldb register sets are defined in terms of indices into the register array. As such, the
|
||||
// order of RegisterInfos defined in global registers array must match the order defined here.
|
||||
// When defining the register set layouts, these values can appear in an arbitrary order, and that
|
||||
// determines the order that register values are displayed in a dump.
|
||||
enum RegisterIndex
|
||||
{
|
||||
eRegisterIndexEax,
|
||||
eRegisterIndexEbx,
|
||||
eRegisterIndexEcx,
|
||||
eRegisterIndexEdx,
|
||||
eRegisterIndexEdi,
|
||||
eRegisterIndexEsi,
|
||||
eRegisterIndexEbp,
|
||||
eRegisterIndexEsp,
|
||||
eRegisterIndexEip,
|
||||
eRegisterIndexEflags
|
||||
};
|
||||
|
||||
// Array of all register information supported by Windows x86
|
||||
RegisterInfo g_register_infos[] =
|
||||
{
|
||||
// Macro auto defines most stuff GCC DWARF GENERIC GDB LLDB VALUE REGS INVALIDATE REGS
|
||||
// ============================== ======================= =================== ========================= =================== ================= ========== ===============
|
||||
{ DEFINE_GPR(eax, nullptr), { gcc_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_eax_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(ebx, nullptr), { gcc_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ebx_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(ecx, nullptr), { gcc_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_ecx_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(edx, nullptr), { gcc_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edx_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(edi, nullptr), { gcc_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_edi_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(esi, nullptr), { gcc_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_esi_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(ebp, "fp"), { gcc_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM, lldb_ebp_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(esp, "sp"), { gcc_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM, lldb_esp_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR(eip, "pc"), { gcc_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM, lldb_eip_i386 }, nullptr, nullptr},
|
||||
{ DEFINE_GPR_BIN(eflags, "flags"), { gcc_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM, lldb_eflags_i386}, nullptr, nullptr},
|
||||
};
|
||||
|
||||
// Array of lldb register numbers used to define the set of all General Purpose Registers
|
||||
uint32_t g_gpr_reg_indices[] =
|
||||
{
|
||||
eRegisterIndexEax,
|
||||
eRegisterIndexEbx,
|
||||
eRegisterIndexEcx,
|
||||
eRegisterIndexEdx,
|
||||
eRegisterIndexEdi,
|
||||
eRegisterIndexEsi,
|
||||
eRegisterIndexEbp,
|
||||
eRegisterIndexEsp,
|
||||
eRegisterIndexEip,
|
||||
eRegisterIndexEflags
|
||||
};
|
||||
|
||||
RegisterSet g_register_sets[] = {
|
||||
{"General Purpose Registers", "gpr", llvm::array_lengthof(g_gpr_reg_indices), g_gpr_reg_indices},
|
||||
};
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------
|
||||
// Constructors and Destructors
|
||||
//------------------------------------------------------------------
|
||||
RegisterContextWindows_x86::RegisterContextWindows_x86(Thread &thread, uint32_t concrete_frame_idx)
|
||||
: RegisterContextWindows(thread, concrete_frame_idx)
|
||||
{
|
||||
}
|
||||
|
||||
RegisterContextWindows_x86::~RegisterContextWindows_x86()
|
||||
{
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x86::GetRegisterCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_infos);
|
||||
}
|
||||
|
||||
const RegisterInfo *
|
||||
RegisterContextWindows_x86::GetRegisterInfoAtIndex(size_t reg)
|
||||
{
|
||||
return &g_register_infos[reg];
|
||||
}
|
||||
|
||||
size_t
|
||||
RegisterContextWindows_x86::GetRegisterSetCount()
|
||||
{
|
||||
return llvm::array_lengthof(g_register_sets);
|
||||
}
|
||||
|
||||
const RegisterSet *
|
||||
RegisterContextWindows_x86::GetRegisterSet(size_t reg_set)
|
||||
{
|
||||
return &g_register_sets[reg_set];
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x86::ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)
|
||||
{
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
|
||||
switch (reg)
|
||||
{
|
||||
case lldb_eax_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EAX", m_context.Eax);
|
||||
reg_value.SetUInt32(m_context.Eax);
|
||||
break;
|
||||
case lldb_ebx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBX", m_context.Ebx);
|
||||
reg_value.SetUInt32(m_context.Ebx);
|
||||
break;
|
||||
case lldb_ecx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ECX", m_context.Ecx);
|
||||
reg_value.SetUInt32(m_context.Ecx);
|
||||
break;
|
||||
case lldb_edx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDX", m_context.Edx);
|
||||
reg_value.SetUInt32(m_context.Edx);
|
||||
break;
|
||||
case lldb_edi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EDI", m_context.Edi);
|
||||
reg_value.SetUInt32(m_context.Edi);
|
||||
break;
|
||||
case lldb_esi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESI", m_context.Esi);
|
||||
reg_value.SetUInt32(m_context.Esi);
|
||||
break;
|
||||
case lldb_ebp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EBP", m_context.Ebp);
|
||||
reg_value.SetUInt32(m_context.Ebp);
|
||||
break;
|
||||
case lldb_esp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from ESP", m_context.Esp);
|
||||
reg_value.SetUInt32(m_context.Esp);
|
||||
break;
|
||||
case lldb_eip_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EIP", m_context.Eip);
|
||||
reg_value.SetUInt32(m_context.Eip);
|
||||
break;
|
||||
case lldb_eflags_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from EFLAGS", m_context.EFlags);
|
||||
reg_value.SetUInt32(m_context.EFlags);
|
||||
break;
|
||||
default:
|
||||
WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Requested unknown register %u", reg);
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
RegisterContextWindows_x86::WriteRegister(const RegisterInfo *reg_info, const RegisterValue ®_value)
|
||||
{
|
||||
// Since we cannot only write a single register value to the inferior, we need to make sure
|
||||
// our cached copy of the register values are fresh. Otherwise when writing EAX, for example,
|
||||
// we may also overwrite some other register with a stale value.
|
||||
if (!CacheAllRegisterValues())
|
||||
return false;
|
||||
|
||||
uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
|
||||
switch (reg)
|
||||
{
|
||||
case lldb_eax_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EAX", reg_value.GetAsUInt32());
|
||||
m_context.Eax = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_ebx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBX", reg_value.GetAsUInt32());
|
||||
m_context.Ebx = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_ecx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ECX", reg_value.GetAsUInt32());
|
||||
m_context.Ecx = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_edx_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDX", reg_value.GetAsUInt32());
|
||||
m_context.Edx = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_edi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EDI", reg_value.GetAsUInt32());
|
||||
m_context.Edi = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_esi_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESI", reg_value.GetAsUInt32());
|
||||
m_context.Esi = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_ebp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EBP", reg_value.GetAsUInt32());
|
||||
m_context.Ebp = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_esp_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to ESP", reg_value.GetAsUInt32());
|
||||
m_context.Esp = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_eip_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EIP", reg_value.GetAsUInt32());
|
||||
m_context.Eip = reg_value.GetAsUInt32();
|
||||
break;
|
||||
case lldb_eflags_i386:
|
||||
WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to EFLAGS", reg_value.GetAsUInt32());
|
||||
m_context.EFlags = reg_value.GetAsUInt32();
|
||||
break;
|
||||
default:
|
||||
WINWARN_IFALL(WINDOWS_LOG_REGISTERS, "Write value 0x%x to unknown register %u", reg_value.GetAsUInt32(),
|
||||
reg);
|
||||
}
|
||||
|
||||
// Physically update the registers in the target process.
|
||||
TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
|
||||
return ::SetThreadContext(wthread.GetHostThread().GetNativeThread().GetSystemHandle(), &m_context);
|
||||
}
|
||||
|
|
@ -1,4 +1,5 @@
|
|||
include_directories(../Utility)
|
||||
include_directories(../../Utility)
|
||||
include_directories(../Common)
|
||||
|
||||
add_lldb_library(lldbPluginProcessWinMiniDump
|
||||
ProcessWinMiniDump.cpp
|
||||
|
|
@ -32,7 +32,7 @@
|
|||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.h"
|
||||
|
||||
#include "../windows/ExceptionRecord.h" // TODO(amccarth): move this file to a common location
|
||||
#include "ExceptionRecord.h"
|
||||
#include "ThreadWinMiniDump.h"
|
||||
|
||||
using namespace lldb_private;
|
||||
Loading…
Reference in New Issue