#define DEBUG_MEM(x) if (debug_memory) printf_unfiltered x
#define DEBUG_EXCEPT(x) if (debug_exceptions) printf_unfiltered x
-static void win32_stop (void);
+static void win32_stop (ptid_t);
static int win32_win32_thread_alive (ptid_t);
static void win32_kill_inferior (void);
return NULL;
}
-/* Add a thread to the thread list */
+/* Add a thread to the thread list. */
static thread_info *
-win32_add_thread (DWORD id, HANDLE h)
+win32_add_thread (ptid_t ptid, HANDLE h)
{
thread_info *th;
+ DWORD id;
+
+ gdb_assert (ptid_get_tid (ptid) != 0);
+
+ id = ptid_get_tid (ptid);
if ((th = thread_rec (id, FALSE)))
return th;
th->h = h;
th->next = thread_head.next;
thread_head.next = th;
- add_thread (pid_to_ptid (id));
- /* Set the debug registers for the new thread in they are used. */
+ add_thread (ptid);
+ /* Set the debug registers for the new thread if they are used. */
if (debug_registers_used)
{
/* Only change the value of the debug registers. */
/* Delete a thread from the list of threads */
static void
-win32_delete_thread (DWORD id)
+win32_delete_thread (ptid_t ptid)
{
thread_info *th;
+ DWORD id;
+
+ gdb_assert (ptid_get_tid (ptid) != 0);
+
+ id = ptid_get_tid (ptid);
if (info_verbose)
- printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (pid_to_ptid (id)));
- delete_thread (pid_to_ptid (id));
+ printf_unfiltered ("[Deleting %s]\n", target_pid_to_str (ptid));
+ delete_thread (ptid);
for (th = &thread_head;
th->next != NULL && th->next->id != id;
static void
win32_fetch_inferior_registers (struct regcache *regcache, int r)
{
- current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
+ current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events */
if (current_thread)
static void
win32_store_inferior_registers (struct regcache *regcache, int r)
{
- current_thread = thread_rec (PIDGET (inferior_ptid), TRUE);
+ current_thread = thread_rec (ptid_get_tid (inferior_ptid), TRUE);
/* Check if current_thread exists. Windows sometimes uses a non-existent
thread id in its events */
if (current_thread)
/* We can not debug anything in that case. */
}
main_thread_id = current_event.dwThreadId;
- current_thread = win32_add_thread (main_thread_id,
+ current_thread = win32_add_thread (ptid_build (current_event.dwProcessId, 0,
+ current_event.dwThreadId),
current_event.u.CreateThread.hThread);
return main_thread_id;
}
thread_info *th;
DWORD continue_status = DBG_CONTINUE;
- int pid = PIDGET (ptid);
+ /* A specific PTID means `step only this thread id'. */
+ int resume_all = ptid_equal (ptid, minus_one_ptid);
+
+ /* If we're continuing all threads, it's the current inferior that
+ should be handled specially. */
+ if (resume_all)
+ ptid = inferior_ptid;
if (sig != TARGET_SIGNAL_0)
{
last_sig = TARGET_SIGNAL_0;
- DEBUG_EXEC (("gdb: win32_resume (pid=%d, step=%d, sig=%d);\n",
- pid, step, sig));
+ DEBUG_EXEC (("gdb: win32_resume (pid=%d, tid=%ld, step=%d, sig=%d);\n",
+ ptid_get_pid (ptid), ptid_get_tid (ptid), step, sig));
/* Get context for currently selected thread */
- th = thread_rec (PIDGET (inferior_ptid), FALSE);
+ th = thread_rec (ptid_get_tid (inferior_ptid), FALSE);
if (th)
{
if (step)
/* Allow continuing with the same signal that interrupted us.
Otherwise complain. */
- win32_continue (continue_status, pid);
+ if (resume_all)
+ win32_continue (continue_status, -1);
+ else
+ win32_continue (continue_status, ptid_get_tid (ptid));
}
/* Get the next event from the child. Return 1 if the event requires
thread_info *th;
static thread_info dummy_thread_info;
int retval = 0;
- ptid_t ptid = {-1};
last_sig = TARGET_SIGNAL_0;
/* Kludge around a Windows bug where first event is a create
thread event. Caused when attached process does not have
a main thread. */
- retval = ourstatus->value.related_pid = fake_create_process ();
+ retval = fake_create_process ();
if (retval)
saw_create++;
}
break;
}
/* Record the existence of this thread */
- th = win32_add_thread (current_event.dwThreadId,
- current_event.u.CreateThread.hThread);
retval = current_event.dwThreadId;
+ th = win32_add_thread (ptid_build (current_event.dwProcessId, 0,
+ current_event.dwThreadId),
+ current_event.u.CreateThread.hThread);
break;
case EXIT_THREAD_DEBUG_EVENT:
"EXIT_THREAD_DEBUG_EVENT"));
if (current_event.dwThreadId != main_thread_id)
{
- win32_delete_thread (current_event.dwThreadId);
+ win32_delete_thread (ptid_build (current_event.dwProcessId, 0,
+ current_event.dwThreadId));
th = &dummy_thread_info;
}
break;
current_process_handle = current_event.u.CreateProcessInfo.hProcess;
if (main_thread_id)
- win32_delete_thread (main_thread_id);
+ win32_delete_thread (ptid_build (current_event.dwProcessId, 0,
+ main_thread_id));
main_thread_id = current_event.dwThreadId;
/* Add the main thread */
- th = win32_add_thread (main_thread_id,
+ th = win32_add_thread (ptid_build (current_event.dwProcessId, 0,
+ current_event.dwThreadId),
current_event.u.CreateProcessInfo.hThread);
- retval = ourstatus->value.related_pid = current_event.dwThreadId;
+ retval = current_event.dwThreadId;
break;
case EXIT_PROCESS_DEBUG_EVENT:
if (!retval || saw_create != 1)
{
if (continue_status == -1)
- win32_resume (ptid, 0, 1);
+ win32_resume (minus_one_ptid, 0, 1);
else
CHECK (win32_continue (continue_status, -1));
}
else
{
- inferior_ptid = pid_to_ptid (retval);
+ inferior_ptid = ptid_build (current_event.dwProcessId, 0,
+ retval);
current_thread = th ?: thread_rec (current_event.dwThreadId, TRUE);
}
return retval;
}
-/* Wait for interesting events to occur in the target process. */
+/* Wait for interesting events to occur in the target process. */
static ptid_t
win32_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
{
- int pid = PIDGET (ptid);
+ int pid = -1;
target_terminal_ours ();
SetConsoleCtrlHandler (NULL, FALSE);
if (retval)
- return pid_to_ptid (retval);
+ return ptid_build (current_event.dwProcessId, 0, retval);
else
{
int detach = 0;
{
extern int stop_after_trap;
int i;
+ struct thread_info *tp;
last_sig = TARGET_SIGNAL_0;
event_count = 0;
{
stop_after_trap = 1;
wait_for_inferior (0);
- if (stop_signal != TARGET_SIGNAL_TRAP)
- resume (0, stop_signal);
+ tp = inferior_thread ();
+ if (tp->stop_signal != TARGET_SIGNAL_TRAP)
+ resume (0, tp->stop_signal);
else
break;
}
/* Try to find exe name as symlink target of /proc/<pid>/exe */
int nchars;
char procexe[sizeof ("/proc/4294967295/exe")];
- sprintf (procexe, "/proc/%lu/exe", current_event.dwProcessId);
+ sprintf (procexe, "/proc/%u/exe", pid);
nchars = readlink (procexe, path, sizeof(path));
if (nchars > 0 && nchars < sizeof (path))
{
^C on the controlling terminal. */
static void
-win32_stop (void)
+win32_stop (ptid_t ptid)
{
DEBUG_EVENTS (("gdb: GenerateConsoleCtrlEvent (CTRLC_EVENT, 0)\n"));
CHECK (GenerateConsoleCtrlEvent (CTRL_C_EVENT, current_event.dwProcessId));
win32_pid_to_str (ptid_t ptid)
{
static char buf[80];
- int pid = PIDGET (ptid);
- if ((DWORD) pid == current_event.dwProcessId)
- sprintf (buf, "process %d", pid);
- else
- sprintf (buf, "Thread %ld.0x%x", current_event.dwProcessId, pid);
- return buf;
+ if (ptid_get_tid (ptid) != 0)
+ {
+ snprintf (buf, sizeof (buf), "Thread %d.0x%lx",
+ ptid_get_pid (ptid), ptid_get_tid (ptid));
+ return buf;
+ }
+
+ return normal_pid_to_str (ptid);
}
static LONGEST
win32_ops.to_open = win32_open;
win32_ops.to_close = win32_close;
win32_ops.to_attach = win32_attach;
+ win32_ops.to_attach_no_wait = 1;
win32_ops.to_detach = win32_detach;
win32_ops.to_resume = win32_resume;
win32_ops.to_wait = win32_wait;
win32_ops.to_has_stack = 1;
win32_ops.to_has_registers = 1;
win32_ops.to_has_execution = 1;
- win32_ops.to_magic = OPS_MAGIC;
win32_ops.to_pid_to_exec_file = win32_pid_to_exec_file;
+ win32_ops.to_magic = OPS_MAGIC;
}
static void
return dr[6];
}
-/* Determine if the thread referenced by "pid" is alive
+/* Determine if the thread referenced by "ptid" is alive
by "polling" it. If WaitForSingleObject returns WAIT_OBJECT_0
- it means that the pid has died. Otherwise it is assumed to be alive. */
+ it means that the thread has died. Otherwise it is assumed to be alive. */
static int
win32_win32_thread_alive (ptid_t ptid)
{
- int pid = PIDGET (ptid);
+ int tid;
+
+ gdb_assert (ptid_get_tid (ptid) != 0);
+ tid = ptid_get_tid (ptid);
- return WaitForSingleObject (thread_rec (pid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
+ return WaitForSingleObject (thread_rec (tid, FALSE)->h, 0) == WAIT_OBJECT_0 ?
FALSE : TRUE;
}