LLDB  mainline
DebuggerThread.h
Go to the documentation of this file.
1 //===-- DebuggerThread.h ----------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef liblldb_Plugins_Process_Windows_DebuggerThread_H_
10 #define liblldb_Plugins_Process_Windows_DebuggerThread_H_
11 
12 #include <atomic>
13 #include <memory>
14 
15 #include "ForwardDecl.h"
16 #include "lldb/Host/HostProcess.h"
17 #include "lldb/Host/HostThread.h"
19 #include "lldb/Utility/Predicate.h"
20 
21 namespace lldb_private {
22 
23 // DebuggerThread
24 //
25 // Debugs a single process, notifying listeners as appropriate when interesting
26 // things occur.
27 class DebuggerThread : public std::enable_shared_from_this<DebuggerThread> {
28 public:
29  DebuggerThread(DebugDelegateSP debug_delegate);
30  virtual ~DebuggerThread();
31 
32  Status DebugLaunch(const ProcessLaunchInfo &launch_info);
33  Status DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info);
34 
35  HostProcess GetProcess() const { return m_process; }
36  HostThread GetMainThread() const { return m_main_thread; }
37  std::weak_ptr<ExceptionRecord> GetActiveException() {
38  return m_active_exception;
39  }
40 
41  Status StopDebugging(bool terminate);
42 
44 
45 private:
46  void FreeProcessHandles();
47  void DebugLoop();
48  ExceptionResult HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
49  DWORD thread_id);
50  DWORD HandleCreateThreadEvent(const CREATE_THREAD_DEBUG_INFO &info,
51  DWORD thread_id);
52  DWORD HandleCreateProcessEvent(const CREATE_PROCESS_DEBUG_INFO &info,
53  DWORD thread_id);
54  DWORD HandleExitThreadEvent(const EXIT_THREAD_DEBUG_INFO &info,
55  DWORD thread_id);
56  DWORD HandleExitProcessEvent(const EXIT_PROCESS_DEBUG_INFO &info,
57  DWORD thread_id);
58  DWORD HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info, DWORD thread_id);
59  DWORD HandleUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO &info,
60  DWORD thread_id);
61  DWORD HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info, DWORD thread_id);
62  DWORD HandleRipEvent(const RIP_INFO &info, DWORD thread_id);
63 
64  DebugDelegateSP m_debug_delegate;
65 
66  HostProcess m_process; // The process being debugged.
67  HostThread m_main_thread; // The main thread of the inferior.
68 
69  // The image file of the process being debugged.
70  HANDLE m_image_file = nullptr;
71 
72  // The current exception waiting to be handled
73  ExceptionRecordSP m_active_exception;
74 
75  // A predicate which gets signalled when an exception is finished processing
76  // and the debug loop can be continued.
77  Predicate<ExceptionResult> m_exception_pred;
78 
79  // An event which gets signalled by the debugger thread when it exits the
80  // debugger loop and is detached from the inferior.
81  HANDLE m_debugging_ended_event = nullptr;
82 
83  // Signals the loop to detach from the process (specified by pid).
84  std::atomic<DWORD> m_pid_to_detach;
85 
86  // Signals the debug loop to stop processing certain types of events that
87  // block shutdown.
88  std::atomic<bool> m_is_shutting_down;
89 
90  // Indicates we've detached from the inferior process and the debug loop can
91  // exit.
92  bool m_detached = false;
93 
94  static lldb::thread_result_t DebuggerThreadLaunchRoutine(void *data);
96  DebuggerThreadLaunchRoutine(const ProcessLaunchInfo &launch_info);
97  static lldb::thread_result_t DebuggerThreadAttachRoutine(void *data);
99  DebuggerThreadAttachRoutine(lldb::pid_t pid,
100  const ProcessAttachInfo &launch_info);
101 };
102 }
103 #endif
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
DebuggerThread(DebugDelegateSP debug_delegate)
HostProcess GetProcess() const
Status DebugAttach(lldb::pid_t pid, const ProcessAttachInfo &attach_info)
Status StopDebugging(bool terminate)
std::shared_ptr< IDebugDelegate > DebugDelegateSP
Definition: ForwardDecl.h:33
std::weak_ptr< ExceptionRecord > GetActiveException()
ExceptionResult
Definition: ForwardDecl.h:16
void ContinueAsyncException(ExceptionResult result)
HostThread GetMainThread() const
Status DebugLaunch(const ProcessLaunchInfo &launch_info)
uint64_t pid_t
Definition: lldb-types.h:85
std::shared_ptr< ExceptionRecord > ExceptionRecordSP
Definition: ForwardDecl.h:37
An error handling class.
Definition: Status.h:44
void * thread_result_t
Definition: lldb-types.h:62