static unsigned long cygwin_get_dr6 (void);
static unsigned long cygwin_get_dr7 (void);
-static enum gdb_signal last_sig = GDB_SIGNAL_0;
-/* Set if a signal was received from the debugged process. */
-
static std::vector<windows_thread_info *> thread_list;
-/* The process and thread handles for the above context. */
-
-/* The current debug event from WaitForDebugEvent or from a pending
- stop. */
-static 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
- event from WaitForDebugEvent can be used when calling
- ContinueDebugEvent. */
-static DEBUG_EVENT last_wait_event;
-
-static HANDLE current_process_handle; /* Currently executing process */
-static windows_thread_info *current_thread; /* Info on currently selected thread */
-static EXCEPTION_RECORD siginfo_er; /* Contents of $_siginfo */
-
/* Counts of things. */
static int exception_count = 0;
static int event_count = 0;
#endif /* 0 */
-/* 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. */
-static DWORD desired_stop_thread_id = -1;
-
-/* A single pending stop. See "pending_stops" for more
- information. */
-struct pending_stop
-{
- /* The thread id. */
- DWORD thread_id;
-
- /* The target waitstatus we computed. */
- target_waitstatus status;
-
- /* The event. A few fields of this can be referenced after a stop,
- and it seemed simplest to store the entire event. */
- 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. */
-static std::vector<pending_stop> pending_stops;
-
struct windows_nat_target final : public x86_nat_target<inf_child_target>
{
void close () override;
bool stopped_by_sw_breakpoint () override
{
- return current_thread->stopped_at_software_breakpoint;
+ return current_windows_thread->stopped_at_software_breakpoint;
}
bool supports_stopped_by_sw_breakpoint () override
(unsigned) GetLastError ());
}
-/* Possible values to pass to 'thread_rec'. */
-enum thread_disposition_type
-{
- /* Do not invalidate the thread's context, and do not suspend the
- thread. */
- DONT_INVALIDATE_CONTEXT,
- /* Invalidate the context, but do not suspend the thread. */
- DONT_SUSPEND,
- /* Invalidate the context and suspend the thread. */
- INVALIDATE_CONTEXT
-};
+/* See nat/windows-nat.h. */
-/* Find a thread record given a thread id. THREAD_DISPOSITION
- controls whether the thread is suspended, and whether the context
- is invalidated. */
-static windows_thread_info *
-thread_rec (DWORD id, enum thread_disposition_type disposition)
+windows_thread_info *
+windows_nat::thread_rec (ptid_t ptid, thread_disposition_type disposition)
{
for (windows_thread_info *th : thread_list)
- if (th->tid == id)
+ if (th->tid == ptid.lwp ())
{
if (!th->suspended)
{
/* Nothing. */
break;
case INVALIDATE_CONTEXT:
- if (id != current_event.dwThreadId)
+ if (ptid.lwp () != current_event.dwThreadId)
th->suspend ();
th->reload_context = true;
break;
windows_add_thread (ptid_t ptid, HANDLE h, void *tlb, bool main_thread_p)
{
windows_thread_info *th;
- DWORD id;
gdb_assert (ptid.lwp () != 0);
- id = ptid.lwp ();
-
- if ((th = thread_rec (id, DONT_INVALIDATE_CONTEXT)))
+ if ((th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT)))
return th;
CORE_ADDR base = (CORE_ADDR) (uintptr_t) tlb;
if (wow64_process)
base += 0x2000;
#endif
- th = new windows_thread_info (id, h, base);
+ th = new windows_thread_info (ptid.lwp (), h, base);
thread_list.push_back (th);
/* Add this new thread to the list of threads.
void
windows_nat_target::fetch_registers (struct regcache *regcache, int r)
{
- DWORD tid = regcache->ptid ().lwp ();
- windows_thread_info *th = thread_rec (tid, INVALIDATE_CONTEXT);
+ windows_thread_info *th = thread_rec (regcache->ptid (), INVALIDATE_CONTEXT);
/* Check if TH exists. Windows sometimes uses a non-existent
thread id in its events. */
void
windows_nat_target::store_registers (struct regcache *regcache, int r)
{
- DWORD tid = regcache->ptid ().lwp ();
- windows_thread_info *th = thread_rec (tid, INVALIDATE_CONTEXT);
+ windows_thread_info *th = thread_rec (regcache->ptid (), INVALIDATE_CONTEXT);
/* Check if TH exists. Windows sometimes uses a non-existent
thread id in its events. */
return so;
}
-static char *
-get_image_name (HANDLE h, void *address, int unicode)
-{
-#ifdef __CYGWIN__
- static char buf[__PMAX];
-#else
- static char buf[(2 * __PMAX) + 1];
-#endif
- DWORD size = unicode ? sizeof (WCHAR) : sizeof (char);
- char *address_ptr;
- int len = 0;
- char b[2];
- SIZE_T done;
-
- /* Attempt to read the name of the dll that was detected.
- This is documented to work only when actively debugging
- a program. It will not work for attached processes. */
- if (address == NULL)
- return NULL;
-
- /* See if we could read the address of a string, and that the
- address isn't null. */
- if (!ReadProcessMemory (h, address, &address_ptr,
- sizeof (address_ptr), &done)
- || done != sizeof (address_ptr) || !address_ptr)
- return NULL;
-
- /* Find the length of the string. */
- while (ReadProcessMemory (h, address_ptr + len++ * size, &b, size, &done)
- && (b[0] != 0 || b[size - 1] != 0) && done == size)
- continue;
-
- if (!unicode)
- ReadProcessMemory (h, address_ptr, buf, len, &done);
- else
- {
- WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
- ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
- &done);
-#ifdef __CYGWIN__
- wcstombs (buf, unicode_address, __PMAX);
-#else
- WideCharToMultiByte (CP_ACP, 0, unicode_address, len, buf, sizeof buf,
- 0, 0);
-#endif
- }
-
- return buf;
-}
-
/* Handle a DLL load event, and return 1.
This function assumes that this event did not occur during inferior
handle_load_dll ()
{
LOAD_DLL_DEBUG_INFO *event = ¤t_event.u.LoadDll;
- char *dll_name;
+ const char *dll_name;
/* Try getting the DLL name via the lpImageName field of the event.
Note that Microsoft documents this fields as strictly optional,
CloseHandle ((HANDLE) event_id);
}
-/* Handle DEBUG_STRING output from child process.
- Cygwin prepends its messages with a "cygwin:". Interpret this as
- a Cygwin signal. Otherwise just print the string as a warning. */
-static int
-handle_output_debug_string (struct target_waitstatus *ourstatus)
+/* See nat/windows-nat.h. */
+
+int
+windows_nat::handle_output_debug_string (struct target_waitstatus *ourstatus)
{
gdb::unique_xmalloc_ptr<char> s;
int retval = 0;
static void
display_selectors (const char * args, int from_tty)
{
- if (!current_thread)
+ if (!current_windows_thread)
{
puts_filtered ("Impossible to display selectors now.\n");
return;
if (wow64_process)
{
puts_filtered ("Selector $cs\n");
- display_selector (current_thread->h,
- current_thread->wow64_context.SegCs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->wow64_context.SegCs);
puts_filtered ("Selector $ds\n");
- display_selector (current_thread->h,
- current_thread->wow64_context.SegDs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->wow64_context.SegDs);
puts_filtered ("Selector $es\n");
- display_selector (current_thread->h,
- current_thread->wow64_context.SegEs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->wow64_context.SegEs);
puts_filtered ("Selector $ss\n");
- display_selector (current_thread->h,
- current_thread->wow64_context.SegSs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->wow64_context.SegSs);
puts_filtered ("Selector $fs\n");
- display_selector (current_thread->h,
- current_thread->wow64_context.SegFs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->wow64_context.SegFs);
puts_filtered ("Selector $gs\n");
- display_selector (current_thread->h,
- current_thread->wow64_context.SegGs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->wow64_context.SegGs);
}
else
#endif
{
puts_filtered ("Selector $cs\n");
- display_selector (current_thread->h,
- current_thread->context.SegCs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->context.SegCs);
puts_filtered ("Selector $ds\n");
- display_selector (current_thread->h,
- current_thread->context.SegDs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->context.SegDs);
puts_filtered ("Selector $es\n");
- display_selector (current_thread->h,
- current_thread->context.SegEs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->context.SegEs);
puts_filtered ("Selector $ss\n");
- display_selector (current_thread->h,
- current_thread->context.SegSs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->context.SegSs);
puts_filtered ("Selector $fs\n");
- display_selector (current_thread->h,
- current_thread->context.SegFs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->context.SegFs);
puts_filtered ("Selector $gs\n");
- display_selector (current_thread->h,
- current_thread->context.SegGs);
+ display_selector (current_windows_thread->h,
+ current_windows_thread->context.SegGs);
}
}
else
int sel;
sel = parse_and_eval_long (args);
printf_filtered ("Selector \"%s\"\n",args);
- display_selector (current_thread->h, sel);
+ display_selector (current_windows_thread->h, sel);
}
}
ourstatus->kind = TARGET_WAITKIND_STOPPED;
/* Record the context of the current thread. */
- thread_rec (current_event.dwThreadId, DONT_SUSPEND);
+ thread_rec (ptid_t (current_event.dwProcessId, current_event.dwThreadId, 0),
+ DONT_SUSPEND);
switch (code)
{
if (named_thread_id == (DWORD) -1)
named_thread_id = current_event.dwThreadId;
- named_thread = thread_rec (named_thread_id, DONT_INVALIDATE_CONTEXT);
+ named_thread = thread_rec (ptid_t (current_event.dwProcessId,
+ named_thread_id, 0),
+ DONT_INVALIDATE_CONTEXT);
if (named_thread != NULL)
{
int thread_name_len;
(unsigned) GetLastError ());
/* We can not debug anything in that case. */
}
- current_thread
+ current_windows_thread
= windows_add_thread (ptid_t (current_event.dwProcessId,
current_event.dwThreadId, 0),
current_event.u.CreateThread.hThread,
ptid.pid (), (unsigned) ptid.lwp (), step, sig));
/* Get context for currently selected thread. */
- th = thread_rec (inferior_ptid.lwp (), DONT_INVALIDATE_CONTEXT);
+ th = thread_rec (inferior_ptid, DONT_INVALIDATE_CONTEXT);
if (th)
{
#ifdef __x86_64__
current_event = iter->event;
inferior_ptid = ptid_t (current_event.dwProcessId, thread_id, 0);
- current_thread = thread_rec (thread_id, INVALIDATE_CONTEXT);
- current_thread->reload_context = 1;
+ current_windows_thread = thread_rec (inferior_ptid,
+ INVALIDATE_CONTEXT);
+ current_windows_thread->reload_context = 1;
DEBUG_EVENTS (("get_windows_debug_event - "
"pending stop found in 0x%x (desired=0x%x)\n",
== EXCEPTION_BREAKPOINT)
&& windows_initialization_done)
{
- th = thread_rec (thread_id, INVALIDATE_CONTEXT);
+ ptid_t ptid = ptid_t (current_event.dwProcessId, thread_id, 0);
+ th = thread_rec (ptid, INVALIDATE_CONTEXT);
th->stopped_at_software_breakpoint = true;
}
pending_stops.push_back ({thread_id, *ourstatus, current_event});
else
{
inferior_ptid = ptid_t (current_event.dwProcessId, thread_id, 0);
- current_thread = th;
- if (!current_thread)
- current_thread = thread_rec (thread_id, INVALIDATE_CONTEXT);
+ current_windows_thread = th;
+ if (!current_windows_thread)
+ current_windows_thread = thread_rec (inferior_ptid,
+ INVALIDATE_CONTEXT);
}
out:
{
ptid_t result = ptid_t (current_event.dwProcessId, retval, 0);
- if (current_thread != nullptr)
+ if (current_windows_thread != nullptr)
{
- current_thread->stopped_at_software_breakpoint = false;
+ current_windows_thread->stopped_at_software_breakpoint = false;
if (current_event.dwDebugEventCode == EXCEPTION_DEBUG_EVENT
&& (current_event.u.Exception.ExceptionRecord.ExceptionCode
== EXCEPTION_BREAKPOINT)
&& windows_initialization_done)
- current_thread->stopped_at_software_breakpoint = true;
+ current_windows_thread->stopped_at_software_breakpoint = true;
}
return result;
{
windows_thread_info *th;
- th = thread_rec (ptid.lwp (), DONT_INVALIDATE_CONTEXT);
+ th = thread_rec (ptid, DONT_INVALIDATE_CONTEXT);
if (th == NULL)
return false;
const char *
windows_nat_target::thread_name (struct thread_info *thr)
{
- return thread_rec (thr->ptid.lwp (), DONT_INVALIDATE_CONTEXT)->name.get ();
+ return thread_rec (thr->ptid, DONT_INVALIDATE_CONTEXT)->name.get ();
}
bool
windows_nat_target::thread_alive (ptid_t ptid)
{
- int tid;
-
gdb_assert (ptid.lwp () != 0);
- tid = ptid.lwp ();
- return (WaitForSingleObject (thread_rec (tid, DONT_INVALIDATE_CONTEXT)->h, 0)
+ return (WaitForSingleObject (thread_rec (ptid, DONT_INVALIDATE_CONTEXT)->h, 0)
!= WAIT_OBJECT_0);
}
projects / deliverable / binutils-gdb.git / blobdiff