mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 10:03:47 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove some globals from nat/windows-nat.c

Browse Source 
nat/windows-nat.c has a number of globals that it uses to communicate
with its clients (gdb and gdbserver).  However, if we ever want the
Windows ports to be multi-inferior, globals won't work.

This patch takes a step toward that by moving most nat/windows-nat.c
globals into a new struct windows_process_info.  Many functions are
converted to be methods on this object.

A couple of globals remain, as they are needed to truly be global due
to the way that the Windows debugging APIs work.

The clients still have a global for the current process.  That is,
this patch is a step toward the end goal, but doesn't implement the
goal itself.
This commit is contained in:
Tom Tromey 2022-03-31 13:41:02 -06:00
parent fc0b013e44
commit 0578e87f93
4 changed files with 472 additions and 420 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
gdb/nat/windows-nat.c
View File

@ -23,12 +23,6 @@
namespace windows_nat
{
HANDLE current_process_handle;
DWORD current_process_id;
DWORD main_thread_id;
enum gdb_signal last_sig = GDB_SIGNAL_0;
DEBUG_EVENT current_event;
/* The most recent event from WaitForDebugEvent. Unlike
current_event, this is guaranteed never to come from a pending
stop. This is important because only data from the most recent
@ -36,15 +30,6 @@ DEBUG_EVENT current_event;
ContinueDebugEvent. */
static DEBUG_EVENT last_wait_event;
DWORD desired_stop_thread_id = -1;
std::vector<pending_stop> pending_stops;
EXCEPTION_RECORD siginfo_er;
#ifdef __x86_64__
bool wow64_process = false;
bool ignore_first_breakpoint = false;
#endif
AdjustTokenPrivileges_ftype *AdjustTokenPrivileges;
DebugActiveProcessStop_ftype *DebugActiveProcessStop;
DebugBreakProcess_ftype *DebugBreakProcess;
@ -180,7 +165,8 @@ get_image_name (HANDLE h, void *address, int unicode)
#define MS_VC_EXCEPTION 0x406d1388
handle_exception_result
handle_exception (struct target_waitstatus *ourstatus, bool debug_exceptions)
windows_process_info::handle_exception (struct target_waitstatus *ourstatus,
bool debug_exceptions)
{
#define DEBUG_EXCEPTION_SIMPLE(x) if (debug_exceptions) \
debug_printf ("gdb: Target exception %s at %s\n", x, \
@ -335,15 +321,10 @@ handle_exception (struct target_waitstatus *ourstatus, bool debug_exceptions)
#undef DEBUG_EXCEPTION_SIMPLE
}
/* Iterate over all DLLs currently mapped by our inferior, looking for
a DLL which is loaded at LOAD_ADDR. If found, add the DLL to our
list of solibs; otherwise do nothing. LOAD_ADDR NULL means add all
DLLs to the list of solibs; this is used when the inferior finishes
its initialization, and all the DLLs it statically depends on are
presumed loaded. */
/* See nat/windows-nat.h. */
static void
windows_add_dll (LPVOID load_addr)
void
windows_process_info::add_dll (LPVOID load_addr)
{
HMODULE dummy_hmodule;
DWORD cb_needed;
@ -353,7 +334,7 @@ windows_add_dll (LPVOID load_addr)
#ifdef __x86_64__
if (wow64_process)
{
if (EnumProcessModulesEx (current_process_handle, &dummy_hmodule,
if (EnumProcessModulesEx (handle, &dummy_hmodule,
sizeof (HMODULE), &cb_needed,
LIST_MODULES_32BIT) == 0)
return;
@ -361,7 +342,7 @@ windows_add_dll (LPVOID load_addr)
else
#endif
{
if (EnumProcessModules (current_process_handle, &dummy_hmodule,
if (EnumProcessModules (handle, &dummy_hmodule,
sizeof (HMODULE), &cb_needed) == 0)
return;
}
@ -373,7 +354,7 @@ windows_add_dll (LPVOID load_addr)
#ifdef __x86_64__
if (wow64_process)
{
if (EnumProcessModulesEx (current_process_handle, hmodules,
if (EnumProcessModulesEx (handle, hmodules,
cb_needed, &cb_needed,
LIST_MODULES_32BIT) == 0)
return;
@ -381,7 +362,7 @@ windows_add_dll (LPVOID load_addr)
else
#endif
{
if (EnumProcessModules (current_process_handle, hmodules,
if (EnumProcessModules (handle, hmodules,
cb_needed, &cb_needed) == 0)
return;
}
@ -426,11 +407,11 @@ windows_add_dll (LPVOID load_addr)
char dll_name[MAX_PATH];
#endif
const char *name;
if (GetModuleInformation (current_process_handle, hmodules[i],
if (GetModuleInformation (handle, hmodules[i],
&mi, sizeof (mi)) == 0)
continue;
if (GetModuleFileNameEx (current_process_handle, hmodules[i],
if (GetModuleFileNameEx (handle, hmodules[i],
dll_name, sizeof (dll_name)) == 0)
continue;
#ifdef __USEWIDE
@ -466,7 +447,7 @@ windows_add_dll (LPVOID load_addr)
/* See nat/windows-nat.h. */
void
dll_loaded_event ()
windows_process_info::dll_loaded_event ()
{
gdb_assert (current_event.dwDebugEventCode == LOAD_DLL_DEBUG_EVENT);
@ -478,29 +459,28 @@ dll_loaded_event ()
in the sense that it might be NULL. And the first DLL event in
particular is explicitly documented as "likely not pass[ed]"
(source: MSDN LOAD_DLL_DEBUG_INFO structure). */
dll_name = get_image_name (current_process_handle,
event->lpImageName, event->fUnicode);
dll_name = get_image_name (handle, event->lpImageName, event->fUnicode);
/* If the DLL name could not be gleaned via lpImageName, try harder
by enumerating all the DLLs loaded into the inferior, looking for
one that is loaded at base address = lpBaseOfDll. */
if (dll_name != nullptr)
handle_load_dll (dll_name, event->lpBaseOfDll);
else if (event->lpBaseOfDll != nullptr)
windows_add_dll (event->lpBaseOfDll);
add_dll (event->lpBaseOfDll);
}
/* See nat/windows-nat.h. */
void
windows_add_all_dlls ()
windows_process_info::add_all_dlls ()
{
windows_add_dll (nullptr);
add_dll (nullptr);
}
/* See nat/windows-nat.h. */
bool
matching_pending_stop (bool debug_events)
windows_process_info::matching_pending_stop (bool debug_events)
{
/* If there are pending stops, and we might plausibly hit one of
them, we don't want to actually continue the inferior -- we just
@ -524,7 +504,7 @@ matching_pending_stop (bool debug_events)
/* See nat/windows-nat.h. */
gdb::optional<pending_stop>
fetch_pending_stop (bool debug_events)
windows_process_info::fetch_pending_stop (bool debug_events)
{
gdb::optional<pending_stop> result;
for (auto iter = pending_stops.begin ();

235
gdb/nat/windows-nat.h
View File

@ -109,79 +109,6 @@ enum thread_disposition_type
INVALIDATE_CONTEXT
};
/* Find a thread record given a thread id. THREAD_DISPOSITION
controls whether the thread is suspended, and whether the context
is invalidated.
This function must be supplied by the embedding application. */
extern windows_thread_info *thread_rec (ptid_t ptid,
thread_disposition_type disposition);
/* Handle OUTPUT_DEBUG_STRING_EVENT from child process. Updates
OURSTATUS and returns the thread id if this represents a thread
change (this is specific to Cygwin), otherwise 0.
Cygwin prepends its messages with a "cygwin:". Interpret this as
a Cygwin signal. Otherwise just print the string as a warning.
This function must be supplied by the embedding application. */
extern int handle_output_debug_string (struct target_waitstatus *ourstatus);
/* Handle a DLL load event.
This function assumes that the current event did not occur during
inferior initialization.
DLL_NAME is the name of the library. BASE is the base load
address.
This function must be supplied by the embedding application. */
extern void handle_load_dll (const char *dll_name, LPVOID base);
/* Handle a DLL unload event.
This function assumes that this event did not occur during inferior
initialization.
This function must be supplied by the embedding application. */
extern void handle_unload_dll ();
/* Handle MS_VC_EXCEPTION when processing a stop. MS_VC_EXCEPTION is
somewhat undocumented but is used to tell the debugger the name of
a thread.
Return true if the exception was handled; return false otherwise.
This function must be supplied by the embedding application. */
extern bool handle_ms_vc_exception (const EXCEPTION_RECORD *rec);
/* When EXCEPTION_ACCESS_VIOLATION is processed, we give the embedding
application a chance to change it to be considered "unhandled".
This function must be supplied by the embedding application. If it
returns true, then the exception is "unhandled". */
extern bool handle_access_violation (const EXCEPTION_RECORD *rec);
/* Currently executing process */
extern HANDLE current_process_handle;
extern DWORD current_process_id;
extern DWORD main_thread_id;
extern enum gdb_signal last_sig;
/* The current debug event from WaitForDebugEvent or from a pending
stop. */
extern DEBUG_EVENT current_event;
/* The ID of the thread for which we anticipate a stop event.
Normally this is -1, meaning we'll accept an event in any
thread. */
extern DWORD desired_stop_thread_id;
/* A single pending stop. See "pending_stops" for more
information. */
struct pending_stop
@ -197,27 +124,6 @@ struct pending_stop
DEBUG_EVENT event;
};
/* A vector of pending stops. Sometimes, Windows will report a stop
on a thread that has been ostensibly suspended. We believe what
happens here is that two threads hit a breakpoint simultaneously,
and the Windows kernel queues the stop events. However, this can
result in the strange effect of trying to single step thread A --
leaving all other threads suspended -- and then seeing a stop in
thread B. To handle this scenario, we queue all such "pending"
stops here, and then process them once the step has completed. See
PR gdb/22992. */
extern std::vector<pending_stop> pending_stops;
/* Contents of $_siginfo */
extern EXCEPTION_RECORD siginfo_er;
#ifdef __x86_64__
/* The target is a WOW64 process */
extern bool wow64_process;
/* Ignore first breakpoint exception of WOW64 process */
extern bool ignore_first_breakpoint;
#endif
typedef enum
{
HANDLE_EXCEPTION_UNHANDLED = 0,
@ -225,29 +131,140 @@ typedef enum
HANDLE_EXCEPTION_IGNORED
} handle_exception_result;
extern handle_exception_result handle_exception
(struct target_waitstatus *ourstatus, bool debug_exceptions);
/* A single Windows process. An object of this type (or subclass) is
created by the client. Some methods must be provided by the client
as well. */
/* Call to indicate that a DLL was loaded. */
struct windows_process_info
{
/* The process handle */
HANDLE handle = 0;
DWORD id = 0;
DWORD main_thread_id = 0;
enum gdb_signal last_sig = GDB_SIGNAL_0;
extern void dll_loaded_event ();
/* The current debug event from WaitForDebugEvent or from a pending
stop. */
DEBUG_EVENT current_event {};
/* Iterate over all DLLs currently mapped by our inferior, and
add them to our list of solibs. */
/* The ID of the thread for which we anticipate a stop event.
Normally this is -1, meaning we'll accept an event in any
thread. */
DWORD desired_stop_thread_id = -1;
extern void windows_add_all_dlls ();
/* A vector of pending stops. Sometimes, Windows will report a stop
on a thread that has been ostensibly suspended. We believe what
happens here is that two threads hit a breakpoint simultaneously,
and the Windows kernel queues the stop events. However, this can
result in the strange effect of trying to single step thread A --
leaving all other threads suspended -- and then seeing a stop in
thread B. To handle this scenario, we queue all such "pending"
stops here, and then process them once the step has completed. See
PR gdb/22992. */
std::vector<pending_stop> pending_stops;
/* Return true if there is a pending stop matching
desired_stop_thread_id. If DEBUG_EVENTS is true, logging will be
enabled. */
/* Contents of $_siginfo */
EXCEPTION_RECORD siginfo_er {};
extern bool matching_pending_stop (bool debug_events);
#ifdef __x86_64__
/* The target is a WOW64 process */
bool wow64_process = false;
/* Ignore first breakpoint exception of WOW64 process */
bool ignore_first_breakpoint = false;
#endif
/* See if a pending stop matches DESIRED_STOP_THREAD_ID. If so,
remove it from the list of pending stops, set 'current_event', and
return it. Otherwise, return an empty optional. */
extern gdb::optional<pending_stop> fetch_pending_stop (bool debug_events);
/* Find a thread record given a thread id. THREAD_DISPOSITION
controls whether the thread is suspended, and whether the context
is invalidated.
This function must be supplied by the embedding application. */
windows_thread_info *thread_rec (ptid_t ptid,
thread_disposition_type disposition);
/* Handle OUTPUT_DEBUG_STRING_EVENT from child process. Updates
OURSTATUS and returns the thread id if this represents a thread
change (this is specific to Cygwin), otherwise 0.
Cygwin prepends its messages with a "cygwin:". Interpret this as
a Cygwin signal. Otherwise just print the string as a warning.
This function must be supplied by the embedding application. */
int handle_output_debug_string (struct target_waitstatus *ourstatus);
/* Handle a DLL load event.
This function assumes that the current event did not occur during
inferior initialization.
DLL_NAME is the name of the library. BASE is the base load
address.
This function must be supplied by the embedding application. */
void handle_load_dll (const char *dll_name, LPVOID base);
/* Handle a DLL unload event.
This function assumes that this event did not occur during inferior
initialization.
This function must be supplied by the embedding application. */
void handle_unload_dll ();
/* Handle MS_VC_EXCEPTION when processing a stop. MS_VC_EXCEPTION is
somewhat undocumented but is used to tell the debugger the name of
a thread.
Return true if the exception was handled; return false otherwise.
This function must be supplied by the embedding application. */
bool handle_ms_vc_exception (const EXCEPTION_RECORD *rec);
/* When EXCEPTION_ACCESS_VIOLATION is processed, we give the embedding
application a chance to change it to be considered "unhandled".
This function must be supplied by the embedding application. If it
returns true, then the exception is "unhandled". */
bool handle_access_violation (const EXCEPTION_RECORD *rec);
handle_exception_result handle_exception
(struct target_waitstatus *ourstatus, bool debug_exceptions);
/* Call to indicate that a DLL was loaded. */
void dll_loaded_event ();
/* Iterate over all DLLs currently mapped by our inferior, and
add them to our list of solibs. */
void add_all_dlls ();
/* Return true if there is a pending stop matching
desired_stop_thread_id. If DEBUG_EVENTS is true, logging will be
enabled. */
bool matching_pending_stop (bool debug_events);
/* See if a pending stop matches DESIRED_STOP_THREAD_ID. If so,
remove it from the list of pending stops, set 'current_event', and
return it. Otherwise, return an empty optional. */
gdb::optional<pending_stop> fetch_pending_stop (bool debug_events);
private:
/* Iterate over all DLLs currently mapped by our inferior, looking for
a DLL which is loaded at LOAD_ADDR. If found, add the DLL to our
list of solibs; otherwise do nothing. LOAD_ADDR NULL means add all
DLLs to the list of solibs; this is used when the inferior finishes
its initialization, and all the DLLs it statically depends on are
presumed loaded. */
void add_dll (LPVOID load_addr);
};
/* A simple wrapper for ContinueDebugEvent that continues the last
waited-for event. If DEBUG_EVENTS is true, logging will be

356
gdb/windows-nat.c
View File

@ -74,6 +74,9 @@
using namespace windows_nat;
/* The current process. */
static windows_process_info windows_process;
#undef STARTUPINFO
#undef CreateProcess
#undef GetModuleFileNameEx
@ -242,7 +245,7 @@ struct windows_nat_target final : public x86_nat_target<inf_child_target>
bool stopped_by_sw_breakpoint () override
{
windows_thread_info *th
= thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
= windows_process.thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
return th->stopped_at_software_breakpoint;
}
@ -317,7 +320,8 @@ check (BOOL ok, const char *file, int line)
/* See nat/windows-nat.h. */
windows_thread_info *
windows_nat::thread_rec (ptid_t ptid, thread_disposition_type disposition)
windows_nat::windows_process_info::thread_rec
(ptid_t ptid, thread_disposition_type disposition)
{
for (auto &th : thread_list)
if (th->tid == ptid.lwp ())
@ -361,14 +365,14 @@ windows_add_thread (ptid_t ptid, HANDLE h, void *tlb, bool main_thread_p)
gdb_assert (ptid.lwp () != 0);
if ((th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
if ((th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
return th;
CORE_ADDR base = (CORE_ADDR) (uintptr_t) tlb;
#ifdef __x86_64__
/* For WOW64 processes, this is actually the pointer to the 64bit TIB,
and the 32bit TIB is exactly 2 pages after it. */
if (wow64_process)
if (windows_process.wow64_process)
base += 0x2000;
#endif
th = new windows_thread_info (ptid.lwp (), h, base);
@ -462,7 +466,7 @@ windows_fetch_one_register (struct regcache *regcache,
char *context_ptr = (char *) &th->context;
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
context_ptr = (char *) &th->wow64_context;
#endif
@ -524,7 +528,8 @@ windows_fetch_one_register (struct regcache *regcache,
void
windows_nat_target::fetch_registers (struct regcache *regcache, int r)
{
windows_thread_info *th = thread_rec (regcache->ptid (), INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (regcache->ptid (), INVALIDATE_CONTEXT);
/* Check if TH exists. Windows sometimes uses a non-existent
thread id in its events. */
@ -547,7 +552,7 @@ windows_nat_target::fetch_registers (struct regcache *regcache, int r)
else
#endif
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
{
th->wow64_context.ContextFlags = CONTEXT_DEBUGGER_DR;
CHECK (Wow64GetThreadContext (th->h, &th->wow64_context));
@ -606,7 +611,7 @@ windows_store_one_register (const struct regcache *regcache,
char *context_ptr = (char *) &th->context;
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
context_ptr = (char *) &th->wow64_context;
#endif
@ -619,7 +624,8 @@ windows_store_one_register (const struct regcache *regcache,
void
windows_nat_target::store_registers (struct regcache *regcache, int r)
{
windows_thread_info *th = thread_rec (regcache->ptid (), INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (regcache->ptid (), INVALIDATE_CONTEXT);
/* Check if TH exists. Windows sometimes uses a non-existent
thread id in its events. */
@ -762,7 +768,8 @@ windows_make_so (const char *name, LPVOID load_addr)
/* See nat/windows-nat.h. */
void
windows_nat::handle_load_dll (const char *dll_name, LPVOID base)
windows_nat::windows_process_info::handle_load_dll (const char *dll_name,
LPVOID base)
{
windows_solib *solib = windows_make_so (dll_name, base);
DEBUG_EVENTS ("Loading dll \"%s\" at %s.", solib->name.c_str (),
@ -772,7 +779,7 @@ windows_nat::handle_load_dll (const char *dll_name, LPVOID base)
/* See nat/windows-nat.h. */
void
windows_nat::handle_unload_dll ()
windows_nat::windows_process_info::handle_unload_dll ()
{
LPVOID lpBaseOfDll = current_event.u.UnloadDll.lpBaseOfDll;
@ -804,22 +811,6 @@ windows_nat::handle_unload_dll ()
host_address_to_string (lpBaseOfDll));
}
/* Call FUNC wrapped in a TRY/CATCH that swallows all GDB
exceptions. */
static void
catch_errors (void (*func) ())
{
try
{
func ();
}
catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
}
/* Clear list of loaded DLLs. */
static void
windows_clear_solib (void)
@ -849,7 +840,8 @@ signal_event_command (const char *args, int from_tty)
/* See nat/windows-nat.h. */
int
windows_nat::handle_output_debug_string (struct target_waitstatus *ourstatus)
windows_nat::windows_process_info::handle_output_debug_string
(struct target_waitstatus *ourstatus)
{
int retval = 0;
@ -914,7 +906,7 @@ display_selector (HANDLE thread, DWORD sel)
LDT_ENTRY info;
BOOL ret;
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
ret = Wow64GetThreadSelectorEntry (thread, sel, &info);
else
#endif
@ -1003,12 +995,12 @@ display_selectors (const char * args, int from_tty)
}
windows_thread_info *current_windows_thread
= thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
= windows_process.thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
if (!args)
{
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
{
gdb_puts ("Selector $cs\n");
display_selector (current_windows_thread->h,
@ -1064,7 +1056,8 @@ display_selectors (const char * args, int from_tty)
/* See nat/windows-nat.h. */
bool
windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec)
windows_nat::windows_process_info::handle_ms_vc_exception
(const EXCEPTION_RECORD *rec)
{
if (rec->NumberParameters >= 3
&& (rec->ExceptionInformation[0] & 0xffffffff) == 0x1000)
@ -1103,7 +1096,8 @@ windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec)
/* See nat/windows-nat.h. */
bool
windows_nat::handle_access_violation (const EXCEPTION_RECORD *rec)
windows_nat::windows_process_info::handle_access_violation
(const EXCEPTION_RECORD *rec)
{
#ifdef __CYGWIN__
/* See if the access violation happened within the cygwin DLL
@ -1134,16 +1128,16 @@ windows_continue (DWORD continue_status, int id, int killed)
{
BOOL res;
desired_stop_thread_id = id;
windows_process.desired_stop_thread_id = id;
if (matching_pending_stop (debug_events))
if (windows_process.matching_pending_stop (debug_events))
return TRUE;
for (auto &th : thread_list)
if (id == -1 || id == (int) th->tid)
{
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
{
if (th->debug_registers_changed)
{
@ -1225,9 +1219,10 @@ windows_continue (DWORD continue_status, int id, int killed)
static DWORD
fake_create_process (void)
{
current_process_handle = OpenProcess (PROCESS_ALL_ACCESS, FALSE,
current_event.dwProcessId);
if (current_process_handle != NULL)
windows_process.handle
= OpenProcess (PROCESS_ALL_ACCESS, FALSE,
windows_process.current_event.dwProcessId);
if (windows_process.handle != NULL)
open_process_used = 1;
else
{
@ -1235,12 +1230,12 @@ fake_create_process (void)
(unsigned) GetLastError ());
/* We can not debug anything in that case. */
}
windows_add_thread (ptid_t (current_event.dwProcessId, 0,
current_event.dwThreadId),
current_event.u.CreateThread.hThread,
current_event.u.CreateThread.lpThreadLocalBase,
windows_add_thread (ptid_t (windows_process.current_event.dwProcessId, 0,
windows_process.current_event.dwThreadId),
windows_process.current_event.u.CreateThread.hThread,
windows_process.current_event.u.CreateThread.lpThreadLocalBase,
true /* main_thread_p */);
return current_event.dwThreadId;
return windows_process.current_event.dwThreadId;
}
void
@ -1259,11 +1254,12 @@ windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
if (sig != GDB_SIGNAL_0)
{
if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
if (windows_process.current_event.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT)
{
DEBUG_EXCEPT ("Cannot continue with signal %d here.", sig);
}
else if (sig == last_sig)
else if (sig == windows_process.last_sig)
continue_status = DBG_EXCEPTION_NOT_HANDLED;
else
#if 0
@ -1287,20 +1283,20 @@ windows_nat_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
}
#endif
DEBUG_EXCEPT ("Can only continue with received signal %d.",
last_sig);
windows_process.last_sig);
}
last_sig = GDB_SIGNAL_0;
windows_process.last_sig = GDB_SIGNAL_0;
DEBUG_EXEC ("pid=%d, tid=0x%x, step=%d, sig=%d",
ptid.pid (), (unsigned) ptid.lwp (), step, sig);
/* Get context for currently selected thread. */
th = thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
th = windows_process.thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
if (th)
{
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
{
if (step)
{
@ -1385,7 +1381,7 @@ ctrl_c_handler (DWORD event_type)
return TRUE;
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
{
/* Call DbgUiRemoteBreakin of the 32bit ntdll.dll in the target process.
DebugBreakProcess would call the one of the 64bit ntdll.dll, which
@ -1400,7 +1396,7 @@ ctrl_c_handler (DWORD event_type)
if (wow64_dbgbreak != nullptr)
{
HANDLE thread = CreateRemoteThread (current_process_handle, NULL,
HANDLE thread = CreateRemoteThread (windows_process.handle, NULL,
0, (LPTHREAD_START_ROUTINE)
wow64_dbgbreak, NULL, 0, NULL);
if (thread)
@ -1410,7 +1406,7 @@ ctrl_c_handler (DWORD event_type)
else
#endif
{
if (!DebugBreakProcess (current_process_handle))
if (!DebugBreakProcess (windows_process.handle))
warning (_("Could not interrupt program. "
"Press Ctrl-c in the program console."));
}
@ -1433,27 +1429,31 @@ windows_nat_target::get_windows_debug_event (int pid,
/* If there is a relevant pending stop, report it now. See the
comment by the definition of "pending_stops" for details on why
this is needed. */
gdb::optional<pending_stop> stop = fetch_pending_stop (debug_events);
gdb::optional<pending_stop> stop
= windows_process.fetch_pending_stop (debug_events);
if (stop.has_value ())
{
thread_id = stop->thread_id;
*ourstatus = stop->status;
ptid_t ptid (current_event.dwProcessId, thread_id);
windows_thread_info *th = thread_rec (ptid, INVALIDATE_CONTEXT);
ptid_t ptid (windows_process.current_event.dwProcessId, thread_id);
windows_thread_info *th
= windows_process.thread_rec (ptid, INVALIDATE_CONTEXT);
th->reload_context = true;
return thread_id;
}
last_sig = GDB_SIGNAL_0;
windows_process.last_sig = GDB_SIGNAL_0;
DEBUG_EVENT *current_event = &windows_process.current_event;
if (!(debug_event = wait_for_debug_event (&current_event, 1000)))
if (!(debug_event = wait_for_debug_event (&windows_process.current_event,
1000)))
goto out;
continue_status = DBG_CONTINUE;
event_code = current_event.dwDebugEventCode;
event_code = windows_process.current_event.dwDebugEventCode;
ourstatus->set_spurious ();
have_saved_context = 0;
@ -1461,12 +1461,12 @@ windows_nat_target::get_windows_debug_event (int pid,
{
case CREATE_THREAD_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"CREATE_THREAD_DEBUG_EVENT");
if (saw_create != 1)
{
inferior *inf = find_inferior_pid (this, current_event.dwProcessId);
inferior *inf = find_inferior_pid (this, current_event->dwProcessId);
if (!saw_create && inf->attach_flag)
{
/* Kludge around a Windows bug where first event is a create
@ -1479,64 +1479,64 @@ windows_nat_target::get_windows_debug_event (int pid,
break;
}
/* Record the existence of this thread. */
thread_id = current_event.dwThreadId;
thread_id = current_event->dwThreadId;
windows_add_thread
(ptid_t (current_event.dwProcessId, current_event.dwThreadId, 0),
current_event.u.CreateThread.hThread,
current_event.u.CreateThread.lpThreadLocalBase,
(ptid_t (current_event->dwProcessId, current_event->dwThreadId, 0),
current_event->u.CreateThread.hThread,
current_event->u.CreateThread.lpThreadLocalBase,
false /* main_thread_p */);
break;
case EXIT_THREAD_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"EXIT_THREAD_DEBUG_EVENT");
windows_delete_thread (ptid_t (current_event.dwProcessId,
current_event.dwThreadId, 0),
current_event.u.ExitThread.dwExitCode,
windows_delete_thread (ptid_t (current_event->dwProcessId,
current_event->dwThreadId, 0),
current_event->u.ExitThread.dwExitCode,
false /* main_thread_p */);
break;
case CREATE_PROCESS_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"CREATE_PROCESS_DEBUG_EVENT");
CloseHandle (current_event.u.CreateProcessInfo.hFile);
CloseHandle (current_event->u.CreateProcessInfo.hFile);
if (++saw_create != 1)
break;
current_process_handle = current_event.u.CreateProcessInfo.hProcess;
windows_process.handle = current_event->u.CreateProcessInfo.hProcess;
/* Add the main thread. */
windows_add_thread
(ptid_t (current_event.dwProcessId,
current_event.dwThreadId, 0),
current_event.u.CreateProcessInfo.hThread,
current_event.u.CreateProcessInfo.lpThreadLocalBase,
(ptid_t (current_event->dwProcessId,
current_event->dwThreadId, 0),
current_event->u.CreateProcessInfo.hThread,
current_event->u.CreateProcessInfo.lpThreadLocalBase,
true /* main_thread_p */);
thread_id = current_event.dwThreadId;
thread_id = current_event->dwThreadId;
break;
case EXIT_PROCESS_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"EXIT_PROCESS_DEBUG_EVENT");
if (!windows_initialization_done)
{
target_terminal::ours ();
target_mourn_inferior (inferior_ptid);
error (_("During startup program exited with code 0x%x."),
(unsigned int) current_event.u.ExitProcess.dwExitCode);
(unsigned int) current_event->u.ExitProcess.dwExitCode);
}
else if (saw_create == 1)
{
windows_delete_thread (ptid_t (current_event.dwProcessId,
current_event.dwThreadId, 0),
windows_delete_thread (ptid_t (current_event->dwProcessId,
current_event->dwThreadId, 0),
0, true /* main_thread_p */);
DWORD exit_status = current_event.u.ExitProcess.dwExitCode;
DWORD exit_status = current_event->u.ExitProcess.dwExitCode;
/* If the exit status looks like a fatal exception, but we
don't recognize the exception's code, make the original
exit status value available, to avoid losing
@ -1548,50 +1548,64 @@ windows_nat_target::get_windows_debug_event (int pid,
else
ourstatus->set_signalled (gdb_signal_from_host (exit_signal));
thread_id = current_event.dwThreadId;
thread_id = current_event->dwThreadId;
}
break;
case LOAD_DLL_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"LOAD_DLL_DEBUG_EVENT");
CloseHandle (current_event.u.LoadDll.hFile);
CloseHandle (current_event->u.LoadDll.hFile);
if (saw_create != 1 || ! windows_initialization_done)
break;
catch_errors (dll_loaded_event);
try
{
windows_process.dll_loaded_event ();
}
catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
ourstatus->set_loaded ();
thread_id = current_event.dwThreadId;
thread_id = current_event->dwThreadId;
break;
case UNLOAD_DLL_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"UNLOAD_DLL_DEBUG_EVENT");
if (saw_create != 1 || ! windows_initialization_done)
break;
catch_errors (handle_unload_dll);
try
{
windows_process.handle_unload_dll ();
}
catch (const gdb_exception &ex)
{
exception_print (gdb_stderr, ex);
}
ourstatus->set_loaded ();
thread_id = current_event.dwThreadId;
thread_id = current_event->dwThreadId;
break;
case EXCEPTION_DEBUG_EVENT:
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"EXCEPTION_DEBUG_EVENT");
if (saw_create != 1)
break;
switch (handle_exception (ourstatus, debug_exceptions))
switch (windows_process.handle_exception (ourstatus, debug_exceptions))
{
case HANDLE_EXCEPTION_UNHANDLED:
default:
continue_status = DBG_EXCEPTION_NOT_HANDLED;
break;
case HANDLE_EXCEPTION_HANDLED:
thread_id = current_event.dwThreadId;
thread_id = current_event->dwThreadId;
break;
case HANDLE_EXCEPTION_IGNORED:
continue_status = DBG_CONTINUE;
@ -1601,52 +1615,57 @@ windows_nat_target::get_windows_debug_event (int pid,
case OUTPUT_DEBUG_STRING_EVENT: /* Message from the kernel. */
DEBUG_EVENTS ("kernel event for pid=%u tid=0x%x code=%s",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
"OUTPUT_DEBUG_STRING_EVENT");
if (saw_create != 1)
break;
thread_id = handle_output_debug_string (ourstatus);
thread_id = windows_process.handle_output_debug_string (ourstatus);
break;
default:
if (saw_create != 1)
break;
gdb_printf ("gdb: kernel event for pid=%u tid=0x%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId);
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId);
gdb_printf (" unknown event code %u\n",
(unsigned) current_event.dwDebugEventCode);
(unsigned) current_event->dwDebugEventCode);
break;
}
if (!thread_id || saw_create != 1)
{
CHECK (windows_continue (continue_status, desired_stop_thread_id, 0));
CHECK (windows_continue (continue_status,
windows_process.desired_stop_thread_id, 0));
}
else if (desired_stop_thread_id != -1 && desired_stop_thread_id != thread_id)
else if (windows_process.desired_stop_thread_id != -1
&& windows_process.desired_stop_thread_id != thread_id)
{
/* Pending stop. See the comment by the definition of
"pending_stops" for details on why this is needed. */
DEBUG_EVENTS ("get_windows_debug_event - "
"unexpected stop in 0x%x (expecting 0x%x)",
thread_id, desired_stop_thread_id);
thread_id, windows_process.desired_stop_thread_id);
if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
&& ((current_event.u.Exception.ExceptionRecord.ExceptionCode
if (current_event->dwDebugEventCode == EXCEPTION_DEBUG_EVENT
&& ((current_event->u.Exception.ExceptionRecord.ExceptionCode
== EXCEPTION_BREAKPOINT)
|| (current_event.u.Exception.ExceptionRecord.ExceptionCode
|| (current_event->u.Exception.ExceptionRecord.ExceptionCode
== STATUS_WX86_BREAKPOINT))
&& windows_initialization_done)
{
ptid_t ptid = ptid_t (current_event.dwProcessId, thread_id, 0);
windows_thread_info *th = thread_rec (ptid, INVALIDATE_CONTEXT);
ptid_t ptid = ptid_t (current_event->dwProcessId, thread_id, 0);
windows_thread_info *th
= windows_process.thread_rec (ptid, INVALIDATE_CONTEXT);
th->stopped_at_software_breakpoint = true;
th->pc_adjusted = false;
}
pending_stops.push_back ({thread_id, *ourstatus, current_event});
windows_process.pending_stops.push_back
({thread_id, *ourstatus, windows_process.current_event});
thread_id = 0;
CHECK (windows_continue (continue_status, desired_stop_thread_id, 0));
CHECK (windows_continue (continue_status,
windows_process.desired_stop_thread_id, 0));
}
out:
@ -1702,20 +1721,23 @@ windows_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
if (retval)
{
ptid_t result = ptid_t (current_event.dwProcessId, retval, 0);
ptid_t result = ptid_t (windows_process.current_event.dwProcessId,
retval, 0);
if (ourstatus->kind () != TARGET_WAITKIND_EXITED
&& ourstatus->kind () != TARGET_WAITKIND_SIGNALLED)
{
windows_thread_info *th = thread_rec (result, INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (result, INVALIDATE_CONTEXT);
if (th != nullptr)
{
th->stopped_at_software_breakpoint = false;
if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
&& ((current_event.u.Exception.ExceptionRecord.ExceptionCode
if (windows_process.current_event.dwDebugEventCode
== EXCEPTION_DEBUG_EVENT
&& ((windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
== EXCEPTION_BREAKPOINT)
|| (current_event.u.Exception.ExceptionRecord.ExceptionCode
|| (windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
== STATUS_WX86_BREAKPOINT))
&& windows_initialization_done)
{
@ -1746,15 +1768,16 @@ windows_nat_target::do_initial_windows_stuff (DWORD pid, bool attaching)
int i;
struct inferior *inf;
last_sig = GDB_SIGNAL_0;
windows_process.last_sig = GDB_SIGNAL_0;
open_process_used = 0;
for (i = 0; i < sizeof (dr) / sizeof (dr[0]); i++)
dr[i] = 0;
#ifdef __CYGWIN__
cygwin_load_start = cygwin_load_end = 0;
#endif
current_event.dwProcessId = pid;
memset (&current_event, 0, sizeof (current_event));
windows_process.current_event.dwProcessId = pid;
memset (&windows_process.current_event, 0,
sizeof (windows_process.current_event));
inf = current_inferior ();
if (!inf->target_is_pushed (this))
inf->push_target (this);
@ -1764,9 +1787,10 @@ windows_nat_target::do_initial_windows_stuff (DWORD pid, bool attaching)
init_wait_for_inferior ();
#ifdef __x86_64__
ignore_first_breakpoint = !attaching && wow64_process;
windows_process.ignore_first_breakpoint
= !attaching && windows_process.wow64_process;
if (!wow64_process)
if (!windows_process.wow64_process)
{
windows_set_context_register_offsets (amd64_mappings);
windows_set_segment_register_p (amd64_windows_segment_register_p);
@ -1820,7 +1844,7 @@ windows_nat_target::do_initial_windows_stuff (DWORD pid, bool attaching)
Rather than try to work around this sort of issue, it is much
simpler to just ignore DLL load/unload events during the startup
phase, and then process them all in one batch now. */
windows_add_all_dlls ();
windows_process.add_all_dlls ();
windows_initialization_done = 1;
return;
@ -1918,7 +1942,7 @@ windows_nat_target::attach (const char *args, int from_tty)
{
BOOL wow64;
if (IsWow64Process (h, &wow64))
wow64_process = wow64;
windows_process.wow64_process = wow64;
CloseHandle (h);
}
#endif
@ -1935,10 +1959,11 @@ windows_nat_target::detach (inferior *inf, int from_tty)
ptid_t ptid = minus_one_ptid;
resume (ptid, 0, GDB_SIGNAL_0);
if (!DebugActiveProcessStop (current_event.dwProcessId))
if (!DebugActiveProcessStop (windows_process.current_event.dwProcessId))
{
error (_("Can't detach process %u (error %u)"),
(unsigned) current_event.dwProcessId, (unsigned) GetLastError ());
(unsigned) windows_process.current_event.dwProcessId,
(unsigned) GetLastError ());
detached = 0;
}
DebugSetProcessKillOnExit (FALSE);
@ -1972,18 +1997,20 @@ windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
cbNeeded = 0;
#ifdef __x86_64__
if (wow64_process)
if (windows_process.wow64_process)
{
if (!EnumProcessModulesEx (current_process_handle, &dh_buf,
sizeof (HMODULE), &cbNeeded,
LIST_MODULES_32BIT) || !cbNeeded)
if (!EnumProcessModulesEx (windows_process.handle,
&dh_buf, sizeof (HMODULE), &cbNeeded,
LIST_MODULES_32BIT)
|| !cbNeeded)
return 0;
}
else
#endif
{
if (!EnumProcessModules (current_process_handle, &dh_buf,
sizeof (HMODULE), &cbNeeded) || !cbNeeded)
if (!EnumProcessModules (windows_process.handle,
&dh_buf, sizeof (HMODULE), &cbNeeded)
|| !cbNeeded)
return 0;
}
@ -2007,7 +2034,7 @@ windows_get_exec_module_filename (char *exe_name_ret, size_t exe_name_max_len)
error (_("Error converting executable filename to POSIX: %d."), errno);
}
#else
len = GetModuleFileNameEx (current_process_handle,
len = GetModuleFileNameEx (windows_process.handle,
dh_buf, exe_name_ret, exe_name_max_len);
if (len == 0)
error (_("Error getting executable filename: %u."),
@ -2748,7 +2775,7 @@ windows_nat_target::create_inferior (const char *exec_file,
#ifdef __x86_64__
BOOL wow64;
if (IsWow64Process (pi.hProcess, &wow64))
wow64_process = wow64;
windows_process.wow64_process = wow64;
#endif
CloseHandle (pi.hThread);
@ -2771,10 +2798,10 @@ windows_nat_target::mourn_inferior ()
x86_cleanup_dregs();
if (open_process_used)
{
CHECK (CloseHandle (current_process_handle));
CHECK (CloseHandle (windows_process.handle));
open_process_used = 0;
}
siginfo_er.ExceptionCode = 0;
windows_process.siginfo_er.ExceptionCode = 0;
inf_child_target::mourn_inferior ();
}
@ -2785,7 +2812,8 @@ void
windows_nat_target::interrupt ()
{
DEBUG_EVENTS ("GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)");
CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT,
windows_process.current_event.dwProcessId));
registers_changed (); /* refresh register state */
}
@ -2804,19 +2832,19 @@ windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
{
DEBUG_MEM ("write target memory, %s bytes at %s",
pulongest (len), core_addr_to_string (memaddr));
success = WriteProcessMemory (current_process_handle,
success = WriteProcessMemory (windows_process.handle,
(LPVOID) (uintptr_t) memaddr, writebuf,
len, &done);
if (!success)
lasterror = GetLastError ();
FlushInstructionCache (current_process_handle,
FlushInstructionCache (windows_process.handle,
(LPCVOID) (uintptr_t) memaddr, len);
}
else
{
DEBUG_MEM ("read target memory, %s bytes at %s",
pulongest (len), core_addr_to_string (memaddr));
success = ReadProcessMemory (current_process_handle,
success = ReadProcessMemory (windows_process.handle,
(LPCVOID) (uintptr_t) memaddr, readbuf,
len, &done);
if (!success)
@ -2832,15 +2860,16 @@ windows_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
void
windows_nat_target::kill ()
{
CHECK (TerminateProcess (current_process_handle, 0));
CHECK (TerminateProcess (windows_process.handle, 0));
for (;;)
{
if (!windows_continue (DBG_CONTINUE, -1, 1))
break;
if (!wait_for_debug_event (&current_event, INFINITE))
if (!wait_for_debug_event (&windows_process.current_event, INFINITE))
break;
if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
if (windows_process.current_event.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT)
break;
}
@ -2906,28 +2935,31 @@ static enum target_xfer_status
windows_xfer_siginfo (gdb_byte *readbuf, ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len)
{
char *buf = (char *) &siginfo_er;
size_t bufsize = sizeof (siginfo_er);
char *buf = (char *) &windows_process.siginfo_er;
size_t bufsize = sizeof (windows_process.siginfo_er);
#ifdef __x86_64__
EXCEPTION_RECORD32 er32;
if (wow64_process)
if (windows_process.wow64_process)
{
buf = (char *) &er32;
bufsize = sizeof (er32);
er32.ExceptionCode = siginfo_er.ExceptionCode;
er32.ExceptionFlags = siginfo_er.ExceptionFlags;
er32.ExceptionRecord = (uintptr_t) siginfo_er.ExceptionRecord;
er32.ExceptionAddress = (uintptr_t) siginfo_er.ExceptionAddress;
er32.NumberParameters = siginfo_er.NumberParameters;
er32.ExceptionCode = windows_process.siginfo_er.ExceptionCode;
er32.ExceptionFlags = windows_process.siginfo_er.ExceptionFlags;
er32.ExceptionRecord
= (uintptr_t) windows_process.siginfo_er.ExceptionRecord;
er32.ExceptionAddress
= (uintptr_t) windows_process.siginfo_er.ExceptionAddress;
er32.NumberParameters = windows_process.siginfo_er.NumberParameters;
int i;
for (i = 0; i < EXCEPTION_MAXIMUM_PARAMETERS; i++)
er32.ExceptionInformation[i] = siginfo_er.ExceptionInformation[i];
er32.ExceptionInformation[i]
= windows_process.siginfo_er.ExceptionInformation[i];
}
#endif
if (siginfo_er.ExceptionCode == 0)
if (windows_process.siginfo_er.ExceptionCode == 0)
return TARGET_XFER_E_IO;
if (readbuf == nullptr)
@ -2985,7 +3017,7 @@ windows_nat_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
{
windows_thread_info *th;
th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
if (th == NULL)
return false;
@ -3006,7 +3038,8 @@ windows_nat_target::get_ada_task_ptid (long lwp, ULONGEST thread)
const char *
windows_nat_target::thread_name (struct thread_info *thr)
{
return thread_rec (thr->ptid, DONT_INVALIDATE_CONTEXT)->name.get ();
return windows_process.thread_rec (thr->ptid,
DONT_INVALIDATE_CONTEXT)->name.get ();
}
@ -3178,8 +3211,9 @@ windows_nat_target::thread_alive (ptid_t ptid)
{
gdb_assert (ptid.lwp () != 0);
return (WaitForSingleObject (thread_rec (ptid, DONT_INVALIDATE_CONTEXT)->h, 0)
!= WAIT_OBJECT_0);
windows_thread_info *th
= windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
return WaitForSingleObject (th->h, 0) != WAIT_OBJECT_0;
}
void _initialize_check_for_gdb_ini ();

245
gdbserver/win32-low.cc
View File

@ -38,6 +38,8 @@
using namespace windows_nat;
static windows_process_info windows_process;
#ifndef USE_WIN32API
#include <sys/cygwin.h>
#endif
@ -163,7 +165,8 @@ win32_require_context (windows_thread_info *th)
/* See nat/windows-nat.h. */
windows_thread_info *
windows_nat::thread_rec (ptid_t ptid, thread_disposition_type disposition)
windows_nat::windows_process_info::thread_rec
(ptid_t ptid, thread_disposition_type disposition)
{
thread_info *thread = find_thread_ptid (ptid);
if (thread == NULL)
@ -182,7 +185,7 @@ child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb)
windows_thread_info *th;
ptid_t ptid = ptid_t (pid, tid, 0);
if ((th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
if ((th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
return th;
CORE_ADDR base = (CORE_ADDR) (uintptr_t) tlb;
@ -295,15 +298,15 @@ child_xfer_memory (CORE_ADDR memaddr, char *our, int len,
if (write)
{
success = WriteProcessMemory (current_process_handle, (LPVOID) addr,
success = WriteProcessMemory (windows_process.handle, (LPVOID) addr,
(LPCVOID) our, len, &done);
if (!success)
lasterror = GetLastError ();
FlushInstructionCache (current_process_handle, (LPCVOID) addr, len);
FlushInstructionCache (windows_process.handle, (LPCVOID) addr, len);
}
else
{
success = ReadProcessMemory (current_process_handle, (LPCVOID) addr,
success = ReadProcessMemory (windows_process.handle, (LPCVOID) addr,
(LPVOID) our, len, &done);
if (!success)
lasterror = GetLastError ();
@ -331,17 +334,17 @@ do_initial_child_stuff (HANDLE proch, DWORD pid, int attached)
{
struct process_info *proc;
last_sig = GDB_SIGNAL_0;
current_process_handle = proch;
current_process_id = pid;
main_thread_id = 0;
windows_process.last_sig = GDB_SIGNAL_0;
windows_process.handle = proch;
windows_process.id = pid;
windows_process.main_thread_id = 0;
soft_interrupt_requested = 0;
faked_breakpoint = 0;
open_process_used = true;
memset (&current_event, 0, sizeof (current_event));
memset (&windows_process.current_event, 0,
sizeof (windows_process.current_event));
#ifdef __x86_64__
BOOL wow64;
@ -417,7 +420,7 @@ do_initial_child_stuff (HANDLE proch, DWORD pid, int attached)
Rather than try to work around this sort of issue, it is much
simpler to just ignore DLL load/unload events during the startup
phase, and then process them all in one batch now. */
windows_add_all_dlls ();
windows_process.add_all_dlls ();
child_initialization_done = 1;
}
@ -456,8 +459,8 @@ continue_one_thread (thread_info *thread, int thread_id)
static BOOL
child_continue (DWORD continue_status, int thread_id)
{
desired_stop_thread_id = thread_id;
if (matching_pending_stop (debug_threads))
windows_process.desired_stop_thread_id = thread_id;
if (windows_process.matching_pending_stop (debug_threads))
return TRUE;
/* The inferior will only continue after the ContinueDebugEvent
@ -476,8 +479,9 @@ static void
child_fetch_inferior_registers (struct regcache *regcache, int r)
{
int regno;
windows_thread_info *th = thread_rec (current_thread_ptid (),
INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (current_thread_ptid (),
INVALIDATE_CONTEXT);
if (r == -1 || r > NUM_REGS)
child_fetch_inferior_registers (regcache, NUM_REGS);
else
@ -491,8 +495,9 @@ static void
child_store_inferior_registers (struct regcache *regcache, int r)
{
int regno;
windows_thread_info *th = thread_rec (current_thread_ptid (),
INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (current_thread_ptid (),
INVALIDATE_CONTEXT);
if (r == -1 || r == 0 || r > NUM_REGS)
child_store_inferior_registers (regcache, NUM_REGS);
else
@ -671,12 +676,12 @@ win32_process_target::create_inferior (const char *program,
/* Wait till we are at 1st instruction in program, return new pid
(assuming success). */
cs.last_ptid = wait (ptid_t (current_process_id), &cs.last_status, 0);
cs.last_ptid = wait (ptid_t (windows_process.id), &cs.last_status, 0);
/* Necessary for handle_v_kill. */
signal_pid = current_process_id;
signal_pid = windows_process.id;
return current_process_id;
return windows_process.id;
}
/* Attach to a running process.
@ -712,7 +717,8 @@ win32_process_target::attach (unsigned long pid)
/* See nat/windows-nat.h. */
int
windows_nat::handle_output_debug_string (struct target_waitstatus *ourstatus)
windows_nat::windows_process_info::handle_output_debug_string
(struct target_waitstatus *ourstatus)
{
#define READ_BUFFER_LEN 1024
CORE_ADDR addr;
@ -762,12 +768,12 @@ win32_clear_inferiors (void)
{
if (open_process_used)
{
CloseHandle (current_process_handle);
CloseHandle (windows_process.handle);
open_process_used = false;
}
for_each_thread (delete_thread_info);
siginfo_er.ExceptionCode = 0;
windows_process.siginfo_er.ExceptionCode = 0;
clear_inferiors ();
}
@ -776,17 +782,19 @@ win32_clear_inferiors (void)
int
win32_process_target::kill (process_info *process)
{
TerminateProcess (current_process_handle, 0);
TerminateProcess (windows_process.handle, 0);
for (;;)
{
if (!child_continue (DBG_CONTINUE, -1))
break;
if (!wait_for_debug_event (&current_event, INFINITE))
if (!wait_for_debug_event (&windows_process.current_event, INFINITE))
break;
if (current_event.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
if (windows_process.current_event.dwDebugEventCode
== EXIT_PROCESS_DEBUG_EVENT)
break;
else if (current_event.dwDebugEventCode == OUTPUT_DEBUG_STRING_EVENT)
handle_output_debug_string (nullptr);
else if (windows_process.current_event.dwDebugEventCode
== OUTPUT_DEBUG_STRING_EVENT)
windows_process.handle_output_debug_string (nullptr);
}
win32_clear_inferiors ();
@ -806,7 +814,7 @@ win32_process_target::detach (process_info *process)
resume.sig = 0;
this->resume (&resume, 1);
if (!DebugActiveProcessStop (current_process_id))
if (!DebugActiveProcessStop (windows_process.id))
return -1;
DebugSetProcessKillOnExit (FALSE);
@ -866,7 +874,7 @@ win32_process_target::resume (thread_resume *resume_info, size_t n)
else
/* Yes, we're ignoring resume_info[0].thread. It'd be tricky to make
the Windows resume code do the right thing for thread switching. */
tid = current_event.dwThreadId;
tid = windows_process.current_event.dwThreadId;
if (resume_info[0].thread != minus_one_ptid)
{
@ -881,23 +889,24 @@ win32_process_target::resume (thread_resume *resume_info, size_t n)
if (sig != GDB_SIGNAL_0)
{
if (current_event.dwDebugEventCode != EXCEPTION_DEBUG_EVENT)
if (windows_process.current_event.dwDebugEventCode
!= EXCEPTION_DEBUG_EVENT)
{
OUTMSG (("Cannot continue with signal %s here.\n",
gdb_signal_to_string (sig)));
}
else if (sig == last_sig)
else if (sig == windows_process.last_sig)
continue_status = DBG_EXCEPTION_NOT_HANDLED;
else
OUTMSG (("Can only continue with received signal %s.\n",
gdb_signal_to_string (last_sig)));
gdb_signal_to_string (windows_process.last_sig)));
}
last_sig = GDB_SIGNAL_0;
windows_process.last_sig = GDB_SIGNAL_0;
/* Get context for the currently selected thread. */
ptid = debug_event_ptid (&current_event);
th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
ptid = debug_event_ptid (&windows_process.current_event);
th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
if (th)
{
win32_prepare_to_resume (th);
@ -938,7 +947,8 @@ win32_process_target::resume (thread_resume *resume_info, size_t n)
/* See nat/windows-nat.h. */
void
windows_nat::handle_load_dll (const char *name, LPVOID base)
windows_nat::windows_process_info::handle_load_dll (const char *name,
LPVOID base)
{
CORE_ADDR load_addr = (CORE_ADDR) (uintptr_t) base;
@ -992,7 +1002,7 @@ windows_nat::handle_load_dll (const char *name, LPVOID base)
/* See nat/windows-nat.h. */
void
windows_nat::handle_unload_dll ()
windows_nat::windows_process_info::handle_unload_dll ()
{
CORE_ADDR load_addr =
(CORE_ADDR) (uintptr_t) current_event.u.UnloadDll.lpBaseOfDll;
@ -1019,10 +1029,11 @@ fake_breakpoint_event (void)
faked_breakpoint = 1;
memset (&current_event, 0, sizeof (current_event));
current_event.dwThreadId = main_thread_id;
current_event.dwDebugEventCode = EXCEPTION_DEBUG_EVENT;
current_event.u.Exception.ExceptionRecord.ExceptionCode
memset (&windows_process.current_event, 0,
sizeof (windows_process.current_event));
windows_process.current_event.dwThreadId = windows_process.main_thread_id;
windows_process.current_event.dwDebugEventCode = EXCEPTION_DEBUG_EVENT;
windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
= EXCEPTION_BREAKPOINT;
for_each_thread (suspend_one_thread);
@ -1031,7 +1042,8 @@ fake_breakpoint_event (void)
/* See nat/windows-nat.h. */
bool
windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec)
windows_nat::windows_process_info::handle_ms_vc_exception
(const EXCEPTION_RECORD *rec)
{
return false;
}
@ -1039,7 +1051,8 @@ windows_nat::handle_ms_vc_exception (const EXCEPTION_RECORD *rec)
/* See nat/windows-nat.h. */
bool
windows_nat::handle_access_violation (const EXCEPTION_RECORD *rec)
windows_nat::windows_process_info::handle_access_violation
(const EXCEPTION_RECORD *rec)
{
return false;
}
@ -1054,14 +1067,15 @@ maybe_adjust_pc ()
struct regcache *regcache = get_thread_regcache (current_thread, 1);
child_fetch_inferior_registers (regcache, -1);
windows_thread_info *th = thread_rec (current_thread_ptid (),
DONT_INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (current_thread_ptid (),
DONT_INVALIDATE_CONTEXT);
th->stopped_at_software_breakpoint = false;
if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
&& ((current_event.u.Exception.ExceptionRecord.ExceptionCode
if (windows_process.current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
&& ((windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
== EXCEPTION_BREAKPOINT)
|| (current_event.u.Exception.ExceptionRecord.ExceptionCode
|| (windows_process.current_event.u.Exception.ExceptionRecord.ExceptionCode
== STATUS_WX86_BREAKPOINT))
&& child_initialization_done)
{
@ -1080,13 +1094,15 @@ get_child_debug_event (DWORD *continue_status,
{
ptid_t ptid;
last_sig = GDB_SIGNAL_0;
windows_process.last_sig = GDB_SIGNAL_0;
ourstatus->set_spurious ();
*continue_status = DBG_CONTINUE;
/* Check if GDB sent us an interrupt request. */
check_remote_input_interrupt_request ();
DEBUG_EVENT *current_event = &windows_process.current_event;
if (soft_interrupt_requested)
{
soft_interrupt_requested = 0;
@ -1096,12 +1112,13 @@ get_child_debug_event (DWORD *continue_status,
attaching = 0;
{
gdb::optional<pending_stop> stop = fetch_pending_stop (debug_threads);
gdb::optional<pending_stop> stop
= windows_process.fetch_pending_stop (debug_threads);
if (stop.has_value ())
{
*ourstatus = stop->status;
current_event = stop->event;
ptid = debug_event_ptid (&current_event);
windows_process.current_event = stop->event;
ptid = debug_event_ptid (&windows_process.current_event);
switch_to_thread (find_thread_ptid (ptid));
return 1;
}
@ -1109,7 +1126,7 @@ get_child_debug_event (DWORD *continue_status,
/* Keep the wait time low enough for comfortable remote
interruption, but high enough so gdbserver doesn't become a
bottleneck. */
if (!wait_for_debug_event (&current_event, 250))
if (!wait_for_debug_event (&windows_process.current_event, 250))
{
DWORD e = GetLastError();
@ -1129,28 +1146,28 @@ get_child_debug_event (DWORD *continue_status,
gotevent:
switch (current_event.dwDebugEventCode)
switch (current_event->dwDebugEventCode)
{
case CREATE_THREAD_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event CREATE_THREAD_DEBUG_EVENT "
"for pid=%u tid=%x)\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
/* Record the existence of this thread. */
child_add_thread (current_event.dwProcessId,
current_event.dwThreadId,
current_event.u.CreateThread.hThread,
current_event.u.CreateThread.lpThreadLocalBase);
child_add_thread (current_event->dwProcessId,
current_event->dwThreadId,
current_event->u.CreateThread.hThread,
current_event->u.CreateThread.lpThreadLocalBase);
break;
case EXIT_THREAD_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event EXIT_THREAD_DEBUG_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
child_delete_thread (current_event.dwProcessId,
current_event.dwThreadId);
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
child_delete_thread (current_event->dwProcessId,
current_event->dwThreadId);
switch_to_thread (get_first_thread ());
return 1;
@ -1158,33 +1175,33 @@ get_child_debug_event (DWORD *continue_status,
case CREATE_PROCESS_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event CREATE_PROCESS_DEBUG_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
CloseHandle (current_event.u.CreateProcessInfo.hFile);
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
CloseHandle (current_event->u.CreateProcessInfo.hFile);
if (open_process_used)
{
CloseHandle (current_process_handle);
CloseHandle (windows_process.handle);
open_process_used = false;
}
current_process_handle = current_event.u.CreateProcessInfo.hProcess;
main_thread_id = current_event.dwThreadId;
windows_process.handle = current_event->u.CreateProcessInfo.hProcess;
windows_process.main_thread_id = current_event->dwThreadId;
/* Add the main thread. */
child_add_thread (current_event.dwProcessId,
main_thread_id,
current_event.u.CreateProcessInfo.hThread,
current_event.u.CreateProcessInfo.lpThreadLocalBase);
child_add_thread (current_event->dwProcessId,
windows_process.main_thread_id,
current_event->u.CreateProcessInfo.hThread,
current_event->u.CreateProcessInfo.lpThreadLocalBase);
break;
case EXIT_PROCESS_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event EXIT_PROCESS_DEBUG_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
{
DWORD exit_status = current_event.u.ExitProcess.dwExitCode;
DWORD exit_status = current_event->u.ExitProcess.dwExitCode;
/* If the exit status looks like a fatal exception, but we
don't recognize the exception's code, make the original
exit status value available, to avoid losing information. */
@ -1195,18 +1212,18 @@ get_child_debug_event (DWORD *continue_status,
else
ourstatus->set_signalled (gdb_signal_from_host (exit_signal));
}
child_continue (DBG_CONTINUE, desired_stop_thread_id);
child_continue (DBG_CONTINUE, windows_process.desired_stop_thread_id);
break;
case LOAD_DLL_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event LOAD_DLL_DEBUG_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
CloseHandle (current_event.u.LoadDll.hFile);
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
CloseHandle (current_event->u.LoadDll.hFile);
if (! child_initialization_done)
break;
dll_loaded_event ();
windows_process.dll_loaded_event ();
ourstatus->set_loaded ();
break;
@ -1214,20 +1231,20 @@ get_child_debug_event (DWORD *continue_status,
case UNLOAD_DLL_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event UNLOAD_DLL_DEBUG_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
if (! child_initialization_done)
break;
handle_unload_dll ();
windows_process.handle_unload_dll ();
ourstatus->set_loaded ();
break;
case EXCEPTION_DEBUG_EVENT:
OUTMSG2 (("gdbserver: kernel event EXCEPTION_DEBUG_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
if (handle_exception (ourstatus, debug_threads)
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
if (windows_process.handle_exception (ourstatus, debug_threads)
== HANDLE_EXCEPTION_UNHANDLED)
*continue_status = DBG_EXCEPTION_NOT_HANDLED;
break;
@ -1236,31 +1253,33 @@ get_child_debug_event (DWORD *continue_status,
/* A message from the kernel (or Cygwin). */
OUTMSG2 (("gdbserver: kernel event OUTPUT_DEBUG_STRING_EVENT "
"for pid=%u tid=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId));
handle_output_debug_string (nullptr);
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId));
windows_process.handle_output_debug_string (nullptr);
break;
default:
OUTMSG2 (("gdbserver: kernel event unknown "
"for pid=%u tid=%x code=%x\n",
(unsigned) current_event.dwProcessId,
(unsigned) current_event.dwThreadId,
(unsigned) current_event.dwDebugEventCode));
(unsigned) current_event->dwProcessId,
(unsigned) current_event->dwThreadId,
(unsigned) current_event->dwDebugEventCode));
break;
}
ptid = debug_event_ptid (&current_event);
ptid = debug_event_ptid (&windows_process.current_event);
if (desired_stop_thread_id != -1 && desired_stop_thread_id != ptid.lwp ())
if (windows_process.desired_stop_thread_id != -1
&& windows_process.desired_stop_thread_id != ptid.lwp ())
{
/* Pending stop. See the comment by the definition of
"pending_stops" for details on why this is needed. */
OUTMSG2 (("get_windows_debug_event - "
"unexpected stop in 0x%lx (expecting 0x%x)\n",
ptid.lwp (), desired_stop_thread_id));
ptid.lwp (), windows_process.desired_stop_thread_id));
maybe_adjust_pc ();
pending_stops.push_back ({(DWORD) ptid.lwp (), *ourstatus, current_event});
windows_process.pending_stops.push_back
({(DWORD) ptid.lwp (), *ourstatus, *current_event});
ourstatus->set_spurious ();
}
else
@ -1284,7 +1303,7 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
fails). Report it now. */
*ourstatus = cached_status;
cached_status.set_ignore ();
return debug_event_ptid (&current_event);
return debug_event_ptid (&windows_process.current_event);
}
while (1)
@ -1299,7 +1318,7 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
OUTMSG2 (("Child exited with retcode = %x\n",
ourstatus->exit_status ()));
win32_clear_inferiors ();
return ptid_t (current_event.dwProcessId);
return ptid_t (windows_process.current_event.dwProcessId);
case TARGET_WAITKIND_STOPPED:
case TARGET_WAITKIND_SIGNALLED:
case TARGET_WAITKIND_LOADED:
@ -1307,7 +1326,7 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
OUTMSG2 (("Child Stopped with signal = %d \n",
ourstatus->sig ()));
maybe_adjust_pc ();
return debug_event_ptid (&current_event);
return debug_event_ptid (&windows_process.current_event);
}
default:
OUTMSG (("Ignoring unknown internal event, %d\n",
@ -1315,7 +1334,8 @@ win32_process_target::wait (ptid_t ptid, target_waitstatus *ourstatus,
/* fall-through */
case TARGET_WAITKIND_SPURIOUS:
/* do nothing, just continue */
child_continue (continue_status, desired_stop_thread_id);
child_continue (continue_status,
windows_process.desired_stop_thread_id);
break;
}
}
@ -1362,7 +1382,7 @@ win32_process_target::write_memory (CORE_ADDR memaddr,
void
win32_process_target::request_interrupt ()
{
if (GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, current_process_id))
if (GenerateConsoleCtrlEvent (CTRL_BREAK_EVENT, windows_process.id))
return;
/* GenerateConsoleCtrlEvent can fail if process id being debugged is
@ -1370,7 +1390,7 @@ win32_process_target::request_interrupt ()
Fallback to XP/Vista 'DebugBreakProcess', which generates a
breakpoint exception in the interior process. */
if (DebugBreakProcess (current_process_handle))
if (DebugBreakProcess (windows_process.handle))
return;
/* Last resort, suspend all threads manually. */
@ -1397,14 +1417,14 @@ win32_process_target::qxfer_siginfo (const char *annex,
unsigned const char *writebuf,
CORE_ADDR offset, int len)
{
if (siginfo_er.ExceptionCode == 0)
if (windows_process.siginfo_er.ExceptionCode == 0)
return -1;
if (readbuf == nullptr)
return -1;
char *buf = (char *) &siginfo_er;
size_t bufsize = sizeof (siginfo_er);
char *buf = (char *) &windows_process.siginfo_er;
size_t bufsize = sizeof (windows_process.siginfo_er);
#ifdef __x86_64__
EXCEPTION_RECORD32 er32;
@ -1447,7 +1467,7 @@ int
win32_process_target::get_tib_address (ptid_t ptid, CORE_ADDR *addr)
{
windows_thread_info *th;
th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
th = windows_process.thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
if (th == NULL)
return 0;
if (addr != NULL)
@ -1467,8 +1487,9 @@ win32_process_target::sw_breakpoint_from_kind (int kind, int *size)
bool
win32_process_target::stopped_by_sw_breakpoint ()
{
windows_thread_info *th = thread_rec (current_thread_ptid (),
DONT_INVALIDATE_CONTEXT);
windows_thread_info *th
= windows_process.thread_rec (current_thread_ptid (),
DONT_INVALIDATE_CONTEXT);
return th == nullptr ? false : th->stopped_at_software_breakpoint;
}