4ad5def9b0
The Windows process plugin was broken up into multiple pieces a while back in order to share code between debugging live processes and minidumps (postmortem) debugging. The minidump portion was replaced by a cross-platform solution. This left the plugin split into a formerly "common" base classes and the derived classes for live debugging. This extra layer made the code harder to understand and work with. This patch simplifies these class hierarchies by rolling the live debugging concrete classes up to the base classes. Last week I posted my intent to make this change to lldb-dev, and I didn't hear any objections. This involved moving code and changing references to classes like ProcessWindowsLive to ProcessWindows. It still builds for both 32- and 64-bit, and the tests still pass on 32-bit. (Tests on 64-bit weren't passing before this refactor for unrelated reasons.) llvm-svn: 287770
107 lines
3.9 KiB
C++
107 lines
3.9 KiB
C++
//===-- DebuggerThread.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_DebuggerThread_H_
|
|
#define liblldb_Plugins_Process_Windows_DebuggerThread_H_
|
|
|
|
#include <atomic>
|
|
#include <memory>
|
|
|
|
#include "ForwardDecl.h"
|
|
#include "lldb/Host/HostProcess.h"
|
|
#include "lldb/Host/HostThread.h"
|
|
#include "lldb/Host/Predicate.h"
|
|
#include "lldb/Host/windows/windows.h"
|
|
|
|
namespace lldb_private {
|
|
|
|
//----------------------------------------------------------------------
|
|
// DebuggerThread
|
|
//
|
|
// Debugs a single process, notifying listeners as appropriate when interesting
|
|
// things occur.
|
|
//----------------------------------------------------------------------
|
|
class DebuggerThread : public std::enable_shared_from_this<DebuggerThread> {
|
|
public:
|
|
DebuggerThread(DebugDelegateSP debug_delegate);
|
|
virtual ~DebuggerThread();
|
|
|
|
Error DebugLaunch(const ProcessLaunchInfo &launch_info);
|
|
Error DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info);
|
|
|
|
HostProcess GetProcess() const { return m_process; }
|
|
HostThread GetMainThread() const { return m_main_thread; }
|
|
std::weak_ptr<ExceptionRecord> GetActiveException() {
|
|
return m_active_exception;
|
|
}
|
|
|
|
Error StopDebugging(bool terminate);
|
|
|
|
void ContinueAsyncException(ExceptionResult result);
|
|
|
|
private:
|
|
void FreeProcessHandles();
|
|
void DebugLoop();
|
|
ExceptionResult HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
|
|
DWORD thread_id);
|
|
DWORD HandleCreateThreadEvent(const CREATE_THREAD_DEBUG_INFO &info,
|
|
DWORD thread_id);
|
|
DWORD HandleCreateProcessEvent(const CREATE_PROCESS_DEBUG_INFO &info,
|
|
DWORD thread_id);
|
|
DWORD HandleExitThreadEvent(const EXIT_THREAD_DEBUG_INFO &info,
|
|
DWORD thread_id);
|
|
DWORD HandleExitProcessEvent(const EXIT_PROCESS_DEBUG_INFO &info,
|
|
DWORD thread_id);
|
|
DWORD HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info, DWORD thread_id);
|
|
DWORD HandleUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO &info,
|
|
DWORD thread_id);
|
|
DWORD HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info, DWORD thread_id);
|
|
DWORD HandleRipEvent(const RIP_INFO &info, DWORD thread_id);
|
|
|
|
DebugDelegateSP m_debug_delegate;
|
|
|
|
HostProcess m_process; // The process being debugged.
|
|
HostThread m_main_thread; // The main thread of the inferior.
|
|
|
|
// The image file of the process being debugged.
|
|
HANDLE m_image_file = nullptr;
|
|
|
|
// The current exception waiting to be handled
|
|
ExceptionRecordSP m_active_exception;
|
|
|
|
// A predicate which gets signalled when an exception is finished processing
|
|
// and the debug loop can be continued.
|
|
Predicate<ExceptionResult> m_exception_pred;
|
|
|
|
// An event which gets signalled by the debugger thread when it exits the
|
|
// debugger loop and is detached from the inferior.
|
|
HANDLE m_debugging_ended_event = nullptr;
|
|
|
|
// Signals the loop to detach from the process (specified by pid).
|
|
std::atomic<DWORD> m_pid_to_detach;
|
|
|
|
// Signals the debug loop to stop processing certain types of events that
|
|
// block shutdown.
|
|
std::atomic<bool> m_is_shutting_down;
|
|
|
|
// Indicates we've detached from the inferior process and the debug loop can
|
|
// exit.
|
|
bool m_detached = false;
|
|
|
|
static lldb::thread_result_t DebuggerThreadLaunchRoutine(void *data);
|
|
lldb::thread_result_t
|
|
DebuggerThreadLaunchRoutine(const ProcessLaunchInfo &launch_info);
|
|
static lldb::thread_result_t DebuggerThreadAttachRoutine(void *data);
|
|
lldb::thread_result_t
|
|
DebuggerThreadAttachRoutine(lldb::pid_t pid,
|
|
const ProcessAttachInfo &launch_info);
|
|
};
|
|
}
|
|
#endif
|