diff options
Diffstat (limited to 'gdb/gdbserver')
| -rw-r--r-- | gdb/gdbserver/ChangeLog | 140 | ||||
| -rw-r--r-- | gdb/gdbserver/inferiors.h | 4 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-aarch64-low.c | 23 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-arm-low.c | 18 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-low.c | 483 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-low.h | 25 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-mips-low.c | 19 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-s390-low.c | 2 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-tile-low.c | 2 | ||||
| -rw-r--r-- | gdb/gdbserver/linux-x86-low.c | 33 | ||||
| -rw-r--r-- | gdb/gdbserver/proc-service.c | 2 |
11 files changed, 459 insertions, 292 deletions
diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog index e80edd2..b256dbf 100644 --- a/gdb/gdbserver/ChangeLog +++ b/gdb/gdbserver/ChangeLog @@ -1,5 +1,145 @@ 2014-02-20 Doug Evans <dje@google.com> + * inferiors.h (ptid_of): Move here from linux-low.h. + (pid_of, lwpid_of): Ditto. + * linux-aarch64-low.c (debug_reg_change_callback): Update, "entry" + parameter is a struct thread_info * now. + (aarch64_notify_debug_reg_change): Fetch pid from current_inferior + directly. Pass &all_threads to find_inferior instead of &all_lwps. + (aarch64_stopped_data_address): Fetch lwpid from current_inferior + directly. + (aarch64_linux_prepare_to_resume): Fetch ptid from thread. + (aarch64_arch_setup): Fetch lwpid from current_inferior directly. + * linux-arm-low.c (update_registers_callback): Update, "entry" + parameter is a struct thread_info * now. + Fetch lwpid from current_inferior directly. + (arm_insert_point): Pass &all_threads to find_inferior instead of + &all_lwps. + (arm_remove_point): Ditto. + (arm_stopped_by_watchpoint): Fetch lwp from current_inferior. + (arm_prepare_to_resume): Fetch pid from thread. + (arm_read_description): Fetch lwpid from current_inferior directly. + * linux-low.c (all_lwps): Delete. + (delete_lwp): Delete call to remove_inferior. + (handle_extended_wait): Fetch lwpid from thread. + (add_lwp): Don't set lwp->entry.id. Remove call to + add_inferior_to_list. + (linux_attach_lwp_1): Fetch pid from current_inferior directly. + (linux_kill_one_lwp): Fetch ptid,lwpid from thread. + (kill_one_lwp_callback): Ditto. + (linux_kill): Don't dereference NULL pointer. + Fetch ptid,lwpid from thread. + (get_detach_signal): Fetch ptid from thread. + (linux_detach_one_lwp): Fetch ptid,lwpid from thread. + Simplify call to regcache_invalidate_thread. + (delete_lwp_callback): Update, "entry" parameter is a + struct thread_info * now. Fetch pid from thread. + (linux_mourn): Pass &all_threads to find_inferior instead of &all_lwps. + (status_pending_p_callback): Update, "entry" parameter is a + struct thread_info * now. Fetch ptid from thread. + (find_lwp_pid): Update, "entry" parameter is a + struct thread_info * now. + (linux_wait_for_lwp): Fetch pid from thread. + (linux_fast_tracepoint_collecting): Fetch lwpid from thread. + (maybe_move_out_of_jump_pad): Fetch lwpid from current_inferior. + (enqueue_one_deferred_signal): Fetch lwpid from thread. + (dequeue_one_deferred_signal): Ditto. + (cancel_breakpoint): Fetch ptid from current_inferior. + (linux_wait_for_event): Pass &all_threads to find_inferior, + not &all_lwps. Fetch ptid, lwpid from thread. + (count_events_callback): Update, "entry" parameter is a + struct thread_info * now. + (select_singlestep_lwp_callback): Ditto. + (select_event_lwp_callback): Ditto. + (cancel_breakpoints_callback): Ditto. + (linux_cancel_breakpoints): Pass &all_threads to find_inferior, + not &all_lwps. + (select_event_lwp): Ditto. Fetch ptid from event_thread. + (unsuspend_one_lwp): Update, "entry" parameter is a + struct thread_info * now. + (unsuspend_all_lwps): Pass &all_threads to find_inferior, + not &all_lwps. + (linux_stabilize_threads): Ditto. And for for_each_inferior. + Fetch lwpid from thread, not lwp. + (linux_wait_1): Fetch ptid, lwpid from current_inferior. + Pass &all_threads to find_inferior, not &all_lwps. + (send_sigstop): Fetch lwpid from thread, not lwp. + (send_sigstop_callback): Update, "entry" parameter is a + struct thread_info * now. + (suspend_and_send_sigstop_callback): Ditto. + (wait_for_sigstop): Ditto. Fetch ptid, lwpid from thread, lwp. + (stuck_in_jump_pad_callback): Update, "entry" parameter is a + struct thread_info * now. + (move_out_of_jump_pad_callback): Ditto. Fetch ptid, lwpid + from thread, lwp. + (lwp_running): Update, "entry" parameter is a + struct thread_info * now. + (stop_all_lwps): Fetch ptid from thread. + Pass &all_threads to find_inferior, for_each_inferior, not &all_lwps. + (linux_resume_one_lwp): Fetch lwpid from thread. + (linux_set_resume_request): Update, "entry" parameter is a + struct thread_info * now. Fetch pid, lwpid from thread. + (resume_status_pending_p): Update, "entry" parameter is a + struct thread_info * now. + (need_step_over_p): Ditto. Fetch lwpid from thread. + (start_step_over): Fetch lwpid from thread. + (linux_resume_one_thread): Update, "entry" parameter is a + struct thread_info * now. Fetch lwpid from thread. + (linux_resume): Pass &all_threads to find_inferior, not &all_lwps. + (proceed_one_lwp): Update, "entry" parameter is a + struct thread_info * now. Fetch lwpid from thread. + (unsuspend_and_proceed_one_lwp): Update, "entry" parameter is a + struct thread_info * now. + (proceed_all_lwps): Pass &all_threads to find_inferior, not &all_lwps. + (unstop_all_lwps): Ditto. Fetch lwpid from thread. + (regsets_fetch_inferior_registers): Fetch lwpid from current_inferior + directly. + (regsets_store_inferior_registers): Ditto. + (fetch_register, store_register): Ditto. + (linux_read_memory, linux_write_memory): Ditto. + (linux_request_interrupt): Ditto. + (linux_read_auxv): Ditto. + (linux_xfer_siginfo): Ditto. + (linux_qxfer_spu): Ditto. + (linux_qxfer_libraries_svr4): Ditto. + * linux-low.h (ptid_of, pid_of, lwpid_of): Delete, + moved to inferiors.h. + (get_lwp): Delete. + (get_thread_lwp): Update. + (struct lwp_info): Delete member "entry". Simplify comment for + member "thread". + (all_lwps): Delete. + * linux-mips-low.c (mips_read_description): Fetch lwpid from + current_inferior directly. + (update_watch_registers_callback): Update, "entry" parameter is a + struct thread_info * now. Fetch pid from thread. + (mips_linux_prepare_to_resume): Fetch ptid from thread. + (mips_insert_point): Fetch lwpid from current_inferior. + Pass &all_threads to find_inferior, not &all_lwps. + (mips_remove_point): Pass &all_threads to find_inferior, not &all_lwps. + (mips_stopped_by_watchpoint): Fetch lwpid from current_inferior + directly. + (mips_stopped_data_address): Ditto. + * linux-s390-low.c (s390_arch_setup): Fetch pid from current_inferior + directly. + * linux-tile-low.c (tile_arch_setup): Ditto. + * linux-x86-low.c (x86_get_thread_area): Fetch lwpid from thread. + (update_debug_registers_callback): Update, "entry" parameter is a + struct thread_info * now. Fetch pid from thread. + (i386_dr_low_set_addr): Fetch pid from current_inferior directly. + Pass &all_threads to find_inferior, not &all_lwps. + (i386_dr_low_get_addr): Fetch ptid from current_inferior directly. + (i386_dr_low_set_control): Fetch pid from current_inferior directly. + Pass &all_threads to find_inferior, not &all_lwps. + (i386_dr_low_get_control): Fetch ptid from current_inferior directly. + (i386_dr_low_get_status): Ditto. + (x86_linux_prepare_to_resume): Fetch ptid from thread. + (x86_siginfo_fixup): Fetch lwpid from current_inferior directly. + (x86_linux_read_description): Ditto. + * proc-service.c (ps_getpid): Fetch pid from current_inferior directly. + +2014-02-20 Doug Evans <dje@google.com> + * inferiors.c (get_first_inferior): Fix buglet. 2014-02-19 Doug Evans <dje@google.com> diff --git a/gdb/gdbserver/inferiors.h b/gdb/gdbserver/inferiors.h index 8601b7e..9ea55df 100644 --- a/gdb/gdbserver/inferiors.h +++ b/gdb/gdbserver/inferiors.h @@ -72,6 +72,10 @@ struct process_info struct process_info_private *private; }; +#define ptid_of(inf) ((inf)->entry.id) +#define pid_of(inf) ptid_get_pid ((inf)->entry.id) +#define lwpid_of(inf) ptid_get_lwp ((inf)->entry.id) + /* Return a pointer to the process that corresponds to the current thread (current_inferior). It is an error to call this if there is no current thread selected. */ diff --git a/gdb/gdbserver/linux-aarch64-low.c b/gdb/gdbserver/linux-aarch64-low.c index e7d3e4f..627ade3 100644 --- a/gdb/gdbserver/linux-aarch64-low.c +++ b/gdb/gdbserver/linux-aarch64-low.c @@ -638,7 +638,8 @@ struct aarch64_dr_update_callback_param static int debug_reg_change_callback (struct inferior_list_entry *entry, void *ptr) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); struct aarch64_dr_update_callback_param *param_p = (struct aarch64_dr_update_callback_param *) ptr; int pid = param_p->pid; @@ -653,7 +654,7 @@ debug_reg_change_callback (struct inferior_list_entry *entry, void *ptr) fprintf (stderr, "debug_reg_change_callback: \n\tOn entry:\n"); fprintf (stderr, "\tpid%d, tid: %ld, dr_changed_bp=0x%llx, " "dr_changed_wp=0x%llx\n", - pid, lwpid_of (lwp), info->dr_changed_bp, + pid, lwpid_of (thread), info->dr_changed_bp, info->dr_changed_wp); } @@ -662,7 +663,7 @@ debug_reg_change_callback (struct inferior_list_entry *entry, void *ptr) dr_changed = *dr_changed_ptr; /* Only update the threads of this process. */ - if (pid_of (lwp) == pid) + if (pid_of (thread) == pid) { gdb_assert (idx >= 0 && (idx <= (is_watchpoint ? aarch64_num_wp_regs @@ -703,7 +704,8 @@ debug_reg_change_callback (struct inferior_list_entry *entry, void *ptr) { fprintf (stderr, "\tOn exit:\n\tpid%d, tid: %ld, dr_changed_bp=0x%llx, " "dr_changed_wp=0x%llx\n", - pid, lwpid_of (lwp), info->dr_changed_bp, info->dr_changed_wp); + pid, lwpid_of (thread), info->dr_changed_bp, + info->dr_changed_wp); } return 0; @@ -721,12 +723,12 @@ aarch64_notify_debug_reg_change (const struct aarch64_debug_reg_state *state, struct aarch64_dr_update_callback_param param; /* Only update the threads of this process. */ - param.pid = pid_of (get_thread_lwp (current_inferior)); + param.pid = pid_of (current_inferior); param.is_watchpoint = is_watchpoint; param.idx = idx; - find_inferior (&all_lwps, debug_reg_change_callback, (void *) ¶m); + find_inferior (&all_threads, debug_reg_change_callback, (void *) ¶m); } @@ -1048,7 +1050,7 @@ aarch64_stopped_data_address (void) int pid, i; struct aarch64_debug_reg_state *state; - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); /* Get the siginfo. */ if (ptrace (PTRACE_GETSIGINFO, pid, NULL, &siginfo) != 0) @@ -1145,7 +1147,8 @@ aarch64_linux_new_thread (void) static void aarch64_linux_prepare_to_resume (struct lwp_info *lwp) { - ptid_t ptid = ptid_of (lwp); + struct thread_info *thread = get_lwp_thread (lwp); + ptid_t ptid = ptid_of (thread); struct arch_lwp_info *info = lwp->arch_private; if (DR_HAS_CHANGED (info->dr_changed_bp) @@ -1157,7 +1160,7 @@ aarch64_linux_prepare_to_resume (struct lwp_info *lwp) = &proc->private->arch_private->debug_reg_state; if (debug_hw_points) - fprintf (stderr, "prepare_to_resume thread %ld\n", lwpid_of (lwp)); + fprintf (stderr, "prepare_to_resume thread %ld\n", lwpid_of (thread)); /* Watchpoints. */ if (DR_HAS_CHANGED (info->dr_changed_wp)) @@ -1195,7 +1198,7 @@ aarch64_arch_setup (void) current_process ()->tdesc = tdesc_aarch64; - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); iov.iov_base = &dreg_state; iov.iov_len = sizeof (dreg_state); diff --git a/gdb/gdbserver/linux-arm-low.c b/gdb/gdbserver/linux-arm-low.c index fb6ff68..d7813ab 100644 --- a/gdb/gdbserver/linux-arm-low.c +++ b/gdb/gdbserver/linux-arm-low.c @@ -536,11 +536,12 @@ struct update_registers_data static int update_registers_callback (struct inferior_list_entry *entry, void *arg) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); struct update_registers_data *data = (struct update_registers_data *) arg; /* Only update the threads of the current process. */ - if (pid_of (lwp) == pid_of (get_thread_lwp (current_inferior))) + if (pid_of (thread) == pid_of (current_inferior)) { /* The actual update is done later just before resuming the lwp, we just mark that the registers need updating. */ @@ -589,7 +590,7 @@ arm_insert_point (char type, CORE_ADDR addr, int len) { struct update_registers_data data = { watch, i }; pts[i] = p; - find_inferior (&all_lwps, update_registers_callback, &data); + find_inferior (&all_threads, update_registers_callback, &data); return 0; } @@ -628,7 +629,7 @@ arm_remove_point (char type, CORE_ADDR addr, int len) { struct update_registers_data data = { watch, i }; pts[i].control = arm_hwbp_control_disable (pts[i].control); - find_inferior (&all_lwps, update_registers_callback, &data); + find_inferior (&all_threads, update_registers_callback, &data); return 0; } @@ -649,7 +650,7 @@ arm_stopped_by_watchpoint (void) /* Retrieve siginfo. */ errno = 0; - ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), 0, &siginfo); + ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior), 0, &siginfo); if (errno != 0) return 0; @@ -707,8 +708,9 @@ arm_new_thread (void) static void arm_prepare_to_resume (struct lwp_info *lwp) { - int pid = lwpid_of (lwp); - struct process_info *proc = find_process_pid (pid_of (lwp)); + struct thread_info *thread = get_lwp_thread (lwp); + int pid = lwpid_of (thread); + struct process_info *proc = find_process_pid (pid_of (thread)); struct arch_process_info *proc_info = proc->private->arch_private; struct arch_lwp_info *lwp_info = lwp->arch_private; int i; @@ -780,7 +782,7 @@ arm_get_hwcap (unsigned long *valp) static const struct target_desc * arm_read_description (void) { - int pid = lwpid_of (get_thread_lwp (current_inferior)); + int pid = lwpid_of (current_inferior); /* Query hardware watchpoint/breakpoint capabilities. */ arm_linux_init_hwbp_cap (pid); diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c index d4c113a..923ee14 100644 --- a/gdb/gdbserver/linux-low.c +++ b/gdb/gdbserver/linux-low.c @@ -138,17 +138,6 @@ typedef struct } Elf64_auxv_t; #endif -/* ``all_threads'' is keyed by the LWP ID, which we use as the GDB protocol - representation of the thread ID. - - ``all_lwps'' is keyed by the process ID - which on Linux is (presently) - the same as the LWP ID. - - ``all_processes'' is keyed by the "overall process ID", which - GNU/Linux calls tgid, "thread group ID". */ - -struct inferior_list all_lwps; - /* A list of all unknown processes which receive stop signals. Some other process will presumably claim each of these as forked children momentarily. */ @@ -347,7 +336,6 @@ static void delete_lwp (struct lwp_info *lwp) { remove_thread (get_lwp_thread (lwp)); - remove_inferior (&all_lwps, &lwp->entry); free (lwp->arch_private); free (lwp); } @@ -380,6 +368,7 @@ static void handle_extended_wait (struct lwp_info *event_child, int wstat) { int event = wstat >> 16; + struct thread_info *event_thr = get_lwp_thread (event_child); struct lwp_info *new_lwp; if (event == PTRACE_EVENT_CLONE) @@ -388,7 +377,7 @@ handle_extended_wait (struct lwp_info *event_child, int wstat) unsigned long new_pid; int ret, status; - ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_child), (PTRACE_TYPE_ARG3) 0, + ptrace (PTRACE_GETEVENTMSG, lwpid_of (event_thr), (PTRACE_TYPE_ARG3) 0, &new_pid); /* If we haven't already seen the new PID stop, wait for it now. */ @@ -407,7 +396,7 @@ handle_extended_wait (struct lwp_info *event_child, int wstat) warning ("wait returned unexpected status 0x%x", status); } - ptid = ptid_build (pid_of (event_child), new_pid, 0); + ptid = ptid_build (pid_of (event_thr), new_pid, 0); new_lwp = add_lwp (ptid); /* Either we're going to immediately resume the new thread @@ -532,12 +521,9 @@ add_lwp (ptid_t ptid) lwp = (struct lwp_info *) xmalloc (sizeof (*lwp)); memset (lwp, 0, sizeof (*lwp)); - lwp->entry.id = ptid; - if (the_low_target.new_thread != NULL) lwp->arch_private = the_low_target.new_thread (); - add_inferior_to_list (&all_lwps, &lwp->entry); lwp->thread = add_thread (ptid, lwp); return lwp; @@ -677,7 +663,7 @@ linux_attach_lwp_1 (unsigned long lwpid, int initial) /* Note that extracting the pid from the current inferior is safe, since we're always called in the context of the same process as this new thread. */ - int pid = pid_of (get_thread_lwp (current_inferior)); + int pid = pid_of (current_inferior); ptid = ptid_build (pid, lwpid, 0); } @@ -876,7 +862,8 @@ last_thread_of_process_p (struct thread_info *thread) static void linux_kill_one_lwp (struct lwp_info *lwp) { - int pid = lwpid_of (lwp); + struct thread_info *thr = get_lwp_thread (lwp); + int pid = lwpid_of (thr); /* PTRACE_KILL is unreliable. After stepping into a signal handler, there is no signal context, and ptrace(PTRACE_KILL) (or @@ -896,14 +883,14 @@ linux_kill_one_lwp (struct lwp_info *lwp) kill (pid, SIGKILL); if (debug_threads) debug_printf ("LKL: kill (SIGKILL) %s, 0, 0 (%s)\n", - target_pid_to_str (ptid_of (lwp)), + target_pid_to_str (ptid_of (thr)), errno ? strerror (errno) : "OK"); errno = 0; ptrace (PTRACE_KILL, pid, (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) 0); if (debug_threads) debug_printf ("LKL: PTRACE_KILL %s, 0, 0 (%s)\n", - target_pid_to_str (ptid_of (lwp)), + target_pid_to_str (ptid_of (thr)), errno ? strerror (errno) : "OK"); } @@ -926,7 +913,7 @@ kill_one_lwp_callback (struct inferior_list_entry *entry, void *args) the children get a chance to be reaped, it will remain a zombie forever. */ - if (lwpid_of (lwp) == pid) + if (lwpid_of (thread) == pid) { if (debug_threads) debug_printf ("lkop: is last of process %s\n", @@ -939,7 +926,7 @@ kill_one_lwp_callback (struct inferior_list_entry *entry, void *args) linux_kill_one_lwp (lwp); /* Make sure it died. The loop is most likely unnecessary. */ - pid = linux_wait_for_event (lwp->entry.id, &wstat, __WALL); + pid = linux_wait_for_event (thread->entry.id, &wstat, __WALL); } while (pid > 0 && WIFSTOPPED (wstat)); return 0; @@ -970,21 +957,23 @@ linux_kill (int pid) if (lwp == NULL) { if (debug_threads) - debug_printf ("lk_1: cannot find lwp %ld, for pid: %d\n", - lwpid_of (lwp), pid); + debug_printf ("lk_1: cannot find lwp for pid: %d\n", + pid); } else { + struct thread_info *thr = get_lwp_thread (lwp); + if (debug_threads) debug_printf ("lk_1: killing lwp %ld, for pid: %d\n", - lwpid_of (lwp), pid); + lwpid_of (thr), pid); do { linux_kill_one_lwp (lwp); /* Make sure it died. The loop is most likely unnecessary. */ - lwpid = linux_wait_for_event (lwp->entry.id, &wstat, __WALL); + lwpid = linux_wait_for_event (thr->entry.id, &wstat, __WALL); } while (lwpid > 0 && WIFSTOPPED (wstat)); } @@ -1027,7 +1016,7 @@ get_detach_signal (struct thread_info *thread) { if (debug_threads) debug_printf ("GPS: lwp %s hasn't stopped: no pending signal\n", - target_pid_to_str (ptid_of (lp))); + target_pid_to_str (ptid_of (thread))); return 0; } @@ -1037,7 +1026,7 @@ get_detach_signal (struct thread_info *thread) if (debug_threads) debug_printf ("GPS: lwp %s had stopped with extended " "status: no pending signal\n", - target_pid_to_str (ptid_of (lp))); + target_pid_to_str (ptid_of (thread))); return 0; } @@ -1047,7 +1036,7 @@ get_detach_signal (struct thread_info *thread) { if (debug_threads) debug_printf ("GPS: lwp %s had signal %s, but it is in nopass state\n", - target_pid_to_str (ptid_of (lp)), + target_pid_to_str (ptid_of (thread)), gdb_signal_to_string (signo)); return 0; } @@ -1061,7 +1050,7 @@ get_detach_signal (struct thread_info *thread) debug_printf ("GPS: lwp %s had signal %s, " "but we don't know if we should pass it. " "Default to not.\n", - target_pid_to_str (ptid_of (lp)), + target_pid_to_str (ptid_of (thread)), gdb_signal_to_string (signo)); return 0; } @@ -1069,7 +1058,7 @@ get_detach_signal (struct thread_info *thread) { if (debug_threads) debug_printf ("GPS: lwp %s has pending signal %s: delivering it.\n", - target_pid_to_str (ptid_of (lp)), + target_pid_to_str (ptid_of (thread)), gdb_signal_to_string (signo)); return WSTOPSIG (status); @@ -1092,14 +1081,14 @@ linux_detach_one_lwp (struct inferior_list_entry *entry, void *args) { if (debug_threads) debug_printf ("Sending SIGCONT to %s\n", - target_pid_to_str (ptid_of (lwp))); + target_pid_to_str (ptid_of (thread))); - kill_lwp (lwpid_of (lwp), SIGCONT); + kill_lwp (lwpid_of (thread), SIGCONT); lwp->stop_expected = 0; } /* Flush any pending changes to the process's registers. */ - regcache_invalidate_thread (get_lwp_thread (lwp)); + regcache_invalidate_thread (thread); /* Pass on any pending signal for this thread. */ sig = get_detach_signal (thread); @@ -1107,10 +1096,10 @@ linux_detach_one_lwp (struct inferior_list_entry *entry, void *args) /* Finally, let it resume. */ if (the_low_target.prepare_to_resume != NULL) the_low_target.prepare_to_resume (lwp); - if (ptrace (PTRACE_DETACH, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0, + if (ptrace (PTRACE_DETACH, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, (PTRACE_TYPE_ARG4) (long) sig) < 0) error (_("Can't detach %s: %s"), - target_pid_to_str (ptid_of (lwp)), + target_pid_to_str (ptid_of (thread)), strerror (errno)); delete_lwp (lwp); @@ -1154,10 +1143,11 @@ linux_detach (int pid) static int delete_lwp_callback (struct inferior_list_entry *entry, void *proc) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); struct process_info *process = proc; - if (pid_of (lwp) == pid_of (process)) + if (pid_of (thread) == pid_of (process)) delete_lwp (lwp); return 0; @@ -1172,7 +1162,7 @@ linux_mourn (struct process_info *process) thread_db_mourn (process); #endif - find_inferior (&all_lwps, delete_lwp_callback, process); + find_inferior (&all_threads, delete_lwp_callback, process); /* Freeing all private data. */ priv = process->private; @@ -1214,18 +1204,16 @@ linux_thread_alive (ptid_t ptid) static int status_pending_p_callback (struct inferior_list_entry *entry, void *arg) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); ptid_t ptid = * (ptid_t *) arg; - struct thread_info *thread; /* Check if we're only interested in events from a specific process or its lwps. */ if (!ptid_equal (minus_one_ptid, ptid) - && ptid_get_pid (ptid) != ptid_get_pid (lwp->entry.id)) + && ptid_get_pid (ptid) != ptid_get_pid (thread->entry.id)) return 0; - thread = get_lwp_thread (lwp); - /* If we got a `vCont;t', but we haven't reported a stop yet, do report any status pending the LWP may have. */ if (thread->last_resume_kind == resume_stop @@ -1255,7 +1243,13 @@ same_lwp (struct inferior_list_entry *entry, void *data) struct lwp_info * find_lwp_pid (ptid_t ptid) { - return (struct lwp_info*) find_inferior (&all_lwps, same_lwp, &ptid); + struct inferior_list_entry *thread + = find_inferior (&all_threads, same_lwp, &ptid); + + if (thread == NULL) + return NULL; + + return get_thread_lwp ((struct thread_info *) thread); } static struct lwp_info * @@ -1263,7 +1257,8 @@ linux_wait_for_lwp (ptid_t ptid, int *wstatp, int options) { int ret; int to_wait_for = -1; - struct lwp_info *child = NULL; + struct lwp_info *child; + struct thread_info *thread; if (debug_threads) debug_printf ("linux_wait_for_lwp: %s\n", target_pid_to_str (ptid)); @@ -1290,6 +1285,10 @@ retry: debug_printf ("Got an event from %d (%x)\n", ret, *wstatp); child = find_lwp_pid (pid_to_ptid (ret)); + if (child != NULL) + thread = get_lwp_thread (child); + else + thread = NULL; /* If we didn't find a process, one of two things presumably happened: - A process we started and then detached from has exited. Ignore it. @@ -1315,13 +1314,13 @@ retry: needs to happen after we have attached to the inferior and it is stopped for the first time, but before we access any inferior registers. */ - proc = find_process_pid (pid_of (child)); + proc = find_process_pid (pid_of (thread)); if (proc->private->new_inferior) { struct thread_info *saved_inferior; saved_inferior = current_inferior; - current_inferior = get_lwp_thread (child); + current_inferior = thread; the_low_target.arch_setup (); @@ -1455,6 +1454,7 @@ linux_fast_tracepoint_collecting (struct lwp_info *lwp, struct fast_tpoint_collect_status *status) { CORE_ADDR thread_area; + struct thread_info *thread = get_lwp_thread (lwp); if (the_low_target.get_thread_area == NULL) return 0; @@ -1463,7 +1463,7 @@ linux_fast_tracepoint_collecting (struct lwp_info *lwp, thread is which when tracing with the in-process agent library. We don't read anything from the address, and treat it as opaque; it's the address itself that we assume is unique per-thread. */ - if ((*the_low_target.get_thread_area) (lwpid_of (lwp), &thread_area) == -1) + if ((*the_low_target.get_thread_area) (lwpid_of (thread), &thread_area) == -1) return 0; return fast_tracepoint_collecting (thread_area, lwp->stop_pc, status); @@ -1493,7 +1493,7 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat) if (debug_threads) debug_printf ("Checking whether LWP %ld needs to move out of the " "jump pad.\n", - lwpid_of (lwp)); + lwpid_of (current_inferior)); r = linux_fast_tracepoint_collecting (lwp, &status); @@ -1519,7 +1519,7 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat) if (debug_threads) debug_printf ("Checking whether LWP %ld needs to move out of " "the jump pad...it does\n", - lwpid_of (lwp)); + lwpid_of (current_inferior)); current_inferior = saved_inferior; return 1; @@ -1549,18 +1549,18 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat) || WSTOPSIG (*wstat) == SIGFPE || WSTOPSIG (*wstat) == SIGBUS || WSTOPSIG (*wstat) == SIGSEGV) - && ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), + && ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior), (PTRACE_TYPE_ARG3) 0, &info) == 0 /* Final check just to make sure we don't clobber the siginfo of non-kernel-sent signals. */ && (uintptr_t) info.si_addr == lwp->stop_pc) { info.si_addr = (void *) (uintptr_t) status.tpoint_addr; - ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), + ptrace (PTRACE_SETSIGINFO, lwpid_of (current_inferior), (PTRACE_TYPE_ARG3) 0, &info); } - regcache = get_thread_regcache (get_lwp_thread (lwp), 1); + regcache = get_thread_regcache (current_inferior, 1); (*the_low_target.set_pc) (regcache, status.tpoint_addr); lwp->stop_pc = status.tpoint_addr; @@ -1591,7 +1591,7 @@ maybe_move_out_of_jump_pad (struct lwp_info *lwp, int *wstat) if (debug_threads) debug_printf ("Checking whether LWP %ld needs to move out of the " "jump pad...no\n", - lwpid_of (lwp)); + lwpid_of (current_inferior)); current_inferior = saved_inferior; return 0; @@ -1604,10 +1604,11 @@ static void enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat) { struct pending_signals *p_sig; + struct thread_info *thread = get_lwp_thread (lwp); if (debug_threads) debug_printf ("Deferring signal %d for LWP %ld.\n", - WSTOPSIG (*wstat), lwpid_of (lwp)); + WSTOPSIG (*wstat), lwpid_of (thread)); if (debug_threads) { @@ -1639,7 +1640,7 @@ enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat) debug_printf ("Not requeuing already queued non-RT signal %d" " for LWP %ld\n", sig->signal, - lwpid_of (lwp)); + lwpid_of (thread)); return; } } @@ -1649,7 +1650,7 @@ enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat) p_sig->prev = lwp->pending_signals_to_report; p_sig->signal = WSTOPSIG (*wstat); memset (&p_sig->info, 0, sizeof (siginfo_t)); - ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0, + ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, &p_sig->info); lwp->pending_signals_to_report = p_sig; @@ -1661,6 +1662,8 @@ enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat) static int dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat) { + struct thread_info *thread = get_lwp_thread (lwp); + if (lwp->pending_signals_to_report != NULL) { struct pending_signals **p_sig; @@ -1671,14 +1674,14 @@ dequeue_one_deferred_signal (struct lwp_info *lwp, int *wstat) *wstat = W_STOPCODE ((*p_sig)->signal); if ((*p_sig)->info.si_signo != 0) - ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0, + ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, &(*p_sig)->info); free (*p_sig); *p_sig = NULL; if (debug_threads) debug_printf ("Reporting deferred signal %d for LWP %ld.\n", - WSTOPSIG (*wstat), lwpid_of (lwp)); + WSTOPSIG (*wstat), lwpid_of (thread)); if (debug_threads) { @@ -1721,7 +1724,7 @@ cancel_breakpoint (struct lwp_info *lwp) { if (debug_threads) debug_printf ("CB: Push back breakpoint for %s\n", - target_pid_to_str (ptid_of (lwp))); + target_pid_to_str (ptid_of (current_inferior))); /* Back up the PC if necessary. */ if (the_low_target.decr_pc_after_break) @@ -1739,7 +1742,7 @@ cancel_breakpoint (struct lwp_info *lwp) if (debug_threads) debug_printf ("CB: No breakpoint found at %s for [%s]\n", paddress (lwp->stop_pc), - target_pid_to_str (ptid_of (lwp))); + target_pid_to_str (ptid_of (current_inferior))); } current_inferior = saved_inferior; @@ -1759,9 +1762,13 @@ ptid_t step_over_bkpt; static int linux_wait_for_event (ptid_t ptid, int *wstat, int options) { + struct thread_info *event_thread; struct lwp_info *event_child, *requested_child; ptid_t wait_ptid; + /* N.B. event_thread points to the thread_info struct that contains + event_child. Keep them in sync. */ + event_thread = NULL; event_child = NULL; requested_child = NULL; @@ -1769,10 +1776,12 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid)) { - event_child = (struct lwp_info *) - find_inferior (&all_lwps, status_pending_p_callback, &ptid); - if (debug_threads && event_child) - debug_printf ("Got a pending child %ld\n", lwpid_of (event_child)); + event_thread = (struct thread_info *) + find_inferior (&all_threads, status_pending_p_callback, &ptid); + if (event_thread != NULL) + event_child = get_thread_lwp (event_thread); + if (debug_threads && event_thread) + debug_printf ("Got a pending child %ld\n", lwpid_of (event_thread)); } else { @@ -1794,19 +1803,22 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) fatal ("requesting an event out of a suspended child?"); if (requested_child->status_pending_p) - event_child = requested_child; + { + event_child = requested_child; + event_thread = get_lwp_thread (event_child); + } } if (event_child != NULL) { if (debug_threads) debug_printf ("Got an event from pending child %ld (%04x)\n", - lwpid_of (event_child), event_child->status_pending); + lwpid_of (event_thread), event_child->status_pending); *wstat = event_child->status_pending; event_child->status_pending_p = 0; event_child->status_pending = 0; - current_inferior = get_lwp_thread (event_child); - return lwpid_of (event_child); + current_inferior = event_thread; + return lwpid_of (event_thread); } if (ptid_is_pid (ptid)) @@ -1838,8 +1850,9 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) if (event_child == NULL) error ("event from unknown child"); + event_thread = get_lwp_thread (event_child); if (ptid_is_pid (ptid) - && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_child))) + && ptid_get_pid (ptid) != ptid_get_pid (ptid_of (event_thread))) { if (! WIFSTOPPED (*wstat)) mark_lwp_dead (event_child, *wstat); @@ -1851,21 +1864,21 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) continue; } - current_inferior = get_lwp_thread (event_child); + current_inferior = event_thread; /* Check for thread exit. */ if (! WIFSTOPPED (*wstat)) { if (debug_threads) - debug_printf ("LWP %ld exiting\n", lwpid_of (event_child)); + debug_printf ("LWP %ld exiting\n", lwpid_of (event_thread)); /* If the last thread is exiting, just return. */ if (last_thread_of_process_p (current_inferior)) { if (debug_threads) debug_printf ("LWP %ld is last lwp of process\n", - lwpid_of (event_child)); - return lwpid_of (event_child); + lwpid_of (event_thread)); + return lwpid_of (event_thread); } if (!non_stop) @@ -1873,7 +1886,7 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) current_inferior = get_first_thread (); if (debug_threads) debug_printf ("Current inferior is now %ld\n", - lwpid_of (get_thread_lwp (current_inferior))); + lwpid_of (current_inferior)); } else { @@ -1886,7 +1899,7 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) well, it did something. */ if (requested_child != NULL) { - int lwpid = lwpid_of (event_child); + int lwpid = lwpid_of (event_thread); /* Cancel the step-over operation --- the thread that started it is gone. */ @@ -1904,7 +1917,7 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) if (event_child->must_set_ptrace_flags) { - linux_enable_event_reporting (lwpid_of (event_child)); + linux_enable_event_reporting (lwpid_of (event_thread)); event_child->must_set_ptrace_flags = 0; } @@ -1936,7 +1949,7 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) } } - return lwpid_of (event_child); + return lwpid_of (event_thread); } /* NOTREACHED */ @@ -1948,8 +1961,8 @@ linux_wait_for_event (ptid_t ptid, int *wstat, int options) static int count_events_callback (struct inferior_list_entry *entry, void *data) { - struct lwp_info *lp = (struct lwp_info *) entry; - struct thread_info *thread = get_lwp_thread (lp); + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lp = get_thread_lwp (thread); int *count = data; gdb_assert (count != NULL); @@ -1972,8 +1985,8 @@ count_events_callback (struct inferior_list_entry *entry, void *data) static int select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data) { - struct lwp_info *lp = (struct lwp_info *) entry; - struct thread_info *thread = get_lwp_thread (lp); + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lp = get_thread_lwp (thread); if (thread->last_status.kind == TARGET_WAITKIND_IGNORE && thread->last_resume_kind == resume_step @@ -1989,8 +2002,8 @@ select_singlestep_lwp_callback (struct inferior_list_entry *entry, void *data) static int select_event_lwp_callback (struct inferior_list_entry *entry, void *data) { - struct lwp_info *lp = (struct lwp_info *) entry; - struct thread_info *thread = get_lwp_thread (lp); + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lp = get_thread_lwp (thread); int *selector = data; gdb_assert (selector != NULL); @@ -2011,8 +2024,8 @@ select_event_lwp_callback (struct inferior_list_entry *entry, void *data) static int cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data) { - struct lwp_info *lp = (struct lwp_info *) entry; - struct thread_info *thread = get_lwp_thread (lp); + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lp = get_thread_lwp (thread); struct lwp_info *event_lp = data; /* Leave the LWP that has been elected to receive a SIGTRAP alone. */ @@ -2047,7 +2060,7 @@ cancel_breakpoints_callback (struct inferior_list_entry *entry, void *data) static void linux_cancel_breakpoints (void) { - find_inferior (&all_lwps, cancel_breakpoints_callback, NULL); + find_inferior (&all_threads, cancel_breakpoints_callback, NULL); } /* Select one LWP out of those that have events pending. */ @@ -2057,17 +2070,18 @@ select_event_lwp (struct lwp_info **orig_lp) { int num_events = 0; int random_selector; - struct lwp_info *event_lp; + struct thread_info *event_thread; /* Give preference to any LWP that is being single-stepped. */ - event_lp - = (struct lwp_info *) find_inferior (&all_lwps, - select_singlestep_lwp_callback, NULL); - if (event_lp != NULL) + event_thread + = (struct thread_info *) find_inferior (&all_threads, + select_singlestep_lwp_callback, + NULL); + if (event_thread != NULL) { if (debug_threads) debug_printf ("SEL: Select single-step %s\n", - target_pid_to_str (ptid_of (event_lp))); + target_pid_to_str (ptid_of (event_thread))); } else { @@ -2075,7 +2089,7 @@ select_event_lwp (struct lwp_info **orig_lp) which have had SIGTRAP events. */ /* First see how many SIGTRAP events we have. */ - find_inferior (&all_lwps, count_events_callback, &num_events); + find_inferior (&all_threads, count_events_callback, &num_events); /* Now randomly pick a LWP out of those that have had a SIGTRAP. */ random_selector = (int) @@ -2085,13 +2099,16 @@ select_event_lwp (struct lwp_info **orig_lp) debug_printf ("SEL: Found %d SIGTRAP events, selecting #%d\n", num_events, random_selector); - event_lp = (struct lwp_info *) find_inferior (&all_lwps, - select_event_lwp_callback, - &random_selector); + event_thread + = (struct thread_info *) find_inferior (&all_threads, + select_event_lwp_callback, + &random_selector); } - if (event_lp != NULL) + if (event_thread != NULL) { + struct lwp_info *event_lp = get_thread_lwp (event_thread); + /* Switch the event LWP. */ *orig_lp = event_lp; } @@ -2102,7 +2119,8 @@ select_event_lwp (struct lwp_info **orig_lp) static int unsuspend_one_lwp (struct inferior_list_entry *entry, void *except) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); /* Ignore EXCEPT. */ if (lwp == except) @@ -2120,7 +2138,7 @@ unsuspend_one_lwp (struct inferior_list_entry *entry, void *except) static void unsuspend_all_lwps (struct lwp_info *except) { - find_inferior (&all_lwps, unsuspend_one_lwp, except); + find_inferior (&all_threads, unsuspend_one_lwp, except); } static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry); @@ -2165,16 +2183,17 @@ static void linux_stabilize_threads (void) { struct thread_info *save_inferior; - struct lwp_info *lwp_stuck; + struct thread_info *thread_stuck; - lwp_stuck - = (struct lwp_info *) find_inferior (&all_lwps, - stuck_in_jump_pad_callback, NULL); - if (lwp_stuck != NULL) + thread_stuck + = (struct thread_info *) find_inferior (&all_threads, + stuck_in_jump_pad_callback, + NULL); + if (thread_stuck != NULL) { if (debug_threads) debug_printf ("can't stabilize, LWP %ld is stuck in jump pad\n", - lwpid_of (lwp_stuck)); + lwpid_of (thread_stuck)); return; } @@ -2183,10 +2202,10 @@ linux_stabilize_threads (void) stabilizing_threads = 1; /* Kick 'em all. */ - for_each_inferior (&all_lwps, move_out_of_jump_pad_callback); + for_each_inferior (&all_threads, move_out_of_jump_pad_callback); /* Loop until all are stopped out of the jump pads. */ - while (find_inferior (&all_lwps, lwp_running, NULL) != NULL) + while (find_inferior (&all_threads, lwp_running, NULL) != NULL) { struct target_waitstatus ourstatus; struct lwp_info *lwp; @@ -2213,7 +2232,7 @@ linux_stabilize_threads (void) } } - find_inferior (&all_lwps, unsuspend_one_lwp, NULL); + find_inferior (&all_threads, unsuspend_one_lwp, NULL); stabilizing_threads = 0; @@ -2221,12 +2240,13 @@ linux_stabilize_threads (void) if (debug_threads) { - lwp_stuck - = (struct lwp_info *) find_inferior (&all_lwps, - stuck_in_jump_pad_callback, NULL); - if (lwp_stuck != NULL) + thread_stuck + = (struct thread_info *) find_inferior (&all_threads, + stuck_in_jump_pad_callback, + NULL); + if (thread_stuck != NULL) debug_printf ("couldn't stabilize, LWP %ld got stuck in jump pad\n", - lwpid_of (lwp_stuck)); + lwpid_of (thread_stuck)); } } @@ -2339,7 +2359,7 @@ retry: { debug_printf ("linux_wait_1 ret = %s, exited with " "retcode %d\n", - target_pid_to_str (ptid_of (event_child)), + target_pid_to_str (ptid_of (current_inferior)), WEXITSTATUS (w)); debug_exit (); } @@ -2353,13 +2373,13 @@ retry: { debug_printf ("linux_wait_1 ret = %s, terminated with " "signal %d\n", - target_pid_to_str (ptid_of (event_child)), + target_pid_to_str (ptid_of (current_inferior)), WTERMSIG (w)); debug_exit (); } } - return ptid_of (event_child); + return ptid_of (current_inferior); } } else @@ -2439,7 +2459,7 @@ retry: if (debug_threads) debug_printf ("Got signal %d for LWP %ld. Check if we need " "to defer or adjust it.\n", - WSTOPSIG (w), lwpid_of (event_child)); + WSTOPSIG (w), lwpid_of (current_inferior)); /* Allow debugging the jump pad itself. */ if (current_inferior->last_resume_kind != resume_step @@ -2449,7 +2469,7 @@ retry: if (debug_threads) debug_printf ("Signal %d for LWP %ld deferred (in jump pad)\n", - WSTOPSIG (w), lwpid_of (event_child)); + WSTOPSIG (w), lwpid_of (current_inferior)); linux_resume_one_lwp (event_child, 0, 0, NULL); goto retry; @@ -2461,7 +2481,7 @@ retry: if (debug_threads) debug_printf ("LWP %ld was trying to move out of the jump pad (%d). " "Check if we're already there.\n", - lwpid_of (event_child), + lwpid_of (current_inferior), event_child->collecting_fast_tracepoint); trace_event = 1; @@ -2523,11 +2543,11 @@ retry: { debug_printf ("linux_wait_1 ret = %s, stopped " "while stabilizing threads\n", - target_pid_to_str (ptid_of (event_child))); + target_pid_to_str (ptid_of (current_inferior))); debug_exit (); } - return ptid_of (event_child); + return ptid_of (current_inferior); } } } @@ -2561,9 +2581,9 @@ retry: if (debug_threads) debug_printf ("Ignored signal %d for LWP %ld.\n", - WSTOPSIG (w), lwpid_of (event_child)); + WSTOPSIG (w), lwpid_of (current_inferior)); - if (ptrace (PTRACE_GETSIGINFO, lwpid_of (event_child), + if (ptrace (PTRACE_GETSIGINFO, lwpid_of (current_inferior), (PTRACE_TYPE_ARG3) 0, &info) == 0) info_p = &info; else @@ -2625,7 +2645,7 @@ retry: if (the_low_target.set_pc != NULL) { struct regcache *regcache - = get_thread_regcache (get_lwp_thread (event_child), 1); + = get_thread_regcache (current_inferior, 1); (*the_low_target.set_pc) (regcache, event_child->stop_pc); } @@ -2690,7 +2710,7 @@ retry: breakpoints in other LWPs that have hit a GDB breakpoint. See the comment in cancel_breakpoints_callback to find out why. */ - find_inferior (&all_lwps, cancel_breakpoints_callback, event_child); + find_inferior (&all_threads, cancel_breakpoints_callback, event_child); /* If we were going a step-over, all other threads but the stepping one had been paused in start_step_over, with their suspend counts @@ -2741,12 +2761,12 @@ retry: if (debug_threads) { debug_printf ("linux_wait_1 ret = %s, %d, %d\n", - target_pid_to_str (ptid_of (event_child)), + target_pid_to_str (ptid_of (current_inferior)), ourstatus->kind, ourstatus->value.sig); debug_exit (); } - return ptid_of (event_child); + return ptid_of (current_inferior); } /* Get rid of any pending event in the pipe. */ @@ -2838,7 +2858,7 @@ send_sigstop (struct lwp_info *lwp) { int pid; - pid = lwpid_of (lwp); + pid = lwpid_of (get_lwp_thread (lwp)); /* If we already have a pending stop signal for this process, don't send another. */ @@ -2860,7 +2880,8 @@ send_sigstop (struct lwp_info *lwp) static int send_sigstop_callback (struct inferior_list_entry *entry, void *except) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); /* Ignore EXCEPT. */ if (lwp == except) @@ -2879,7 +2900,8 @@ static int suspend_and_send_sigstop_callback (struct inferior_list_entry *entry, void *except) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); /* Ignore EXCEPT. */ if (lwp == except) @@ -2910,7 +2932,8 @@ mark_lwp_dead (struct lwp_info *lwp, int wstat) static void wait_for_sigstop (struct inferior_list_entry *entry) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); struct thread_info *saved_inferior; int wstat; ptid_t saved_tid; @@ -2921,7 +2944,7 @@ wait_for_sigstop (struct inferior_list_entry *entry) { if (debug_threads) debug_printf ("wait_for_sigstop: LWP %ld already stopped\n", - lwpid_of (lwp)); + lwpid_of (thread)); return; } @@ -2931,7 +2954,7 @@ wait_for_sigstop (struct inferior_list_entry *entry) else saved_tid = null_ptid; /* avoid bogus unused warning */ - ptid = lwp->entry.id; + ptid = thread->entry.id; if (debug_threads) debug_printf ("wait_for_sigstop: pulling one event\n"); @@ -2945,13 +2968,13 @@ wait_for_sigstop (struct inferior_list_entry *entry) { if (debug_threads) debug_printf ("LWP %ld stopped with signal %d\n", - lwpid_of (lwp), WSTOPSIG (wstat)); + lwpid_of (thread), WSTOPSIG (wstat)); if (WSTOPSIG (wstat) != SIGSTOP) { if (debug_threads) debug_printf ("LWP %ld stopped with non-sigstop status %06x\n", - lwpid_of (lwp), wstat); + lwpid_of (thread), wstat); lwp->status_pending_p = 1; lwp->status_pending = wstat; @@ -3006,8 +3029,8 @@ wait_for_sigstop (struct inferior_list_entry *entry) static int stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data) { - struct lwp_info *lwp = (struct lwp_info *) entry; - struct thread_info *thread = get_lwp_thread (lwp); + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); gdb_assert (lwp->suspended == 0); gdb_assert (lwp->stopped); @@ -3024,8 +3047,8 @@ stuck_in_jump_pad_callback (struct inferior_list_entry *entry, void *data) static void move_out_of_jump_pad_callback (struct inferior_list_entry *entry) { - struct lwp_info *lwp = (struct lwp_info *) entry; - struct thread_info *thread = get_lwp_thread (lwp); + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); int *wstat; gdb_assert (lwp->suspended == 0); @@ -3041,7 +3064,7 @@ move_out_of_jump_pad_callback (struct inferior_list_entry *entry) { if (debug_threads) debug_printf ("LWP %ld needs stabilizing (in jump pad)\n", - lwpid_of (lwp)); + lwpid_of (thread)); if (wstat) { @@ -3051,7 +3074,7 @@ move_out_of_jump_pad_callback (struct inferior_list_entry *entry) if (debug_threads) debug_printf ("Signal %d for LWP %ld deferred " "(in jump pad)\n", - WSTOPSIG (*wstat), lwpid_of (lwp)); + WSTOPSIG (*wstat), lwpid_of (thread)); } linux_resume_one_lwp (lwp, 0, 0, NULL); @@ -3063,7 +3086,8 @@ move_out_of_jump_pad_callback (struct inferior_list_entry *entry) static int lwp_running (struct inferior_list_entry *entry, void *data) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); if (lwp->dead) return 0; @@ -3088,7 +3112,7 @@ stop_all_lwps (int suspend, struct lwp_info *except) debug_printf ("stop_all_lwps (%s, except=%s)\n", suspend ? "stop-and-suspend" : "stop", except != NULL - ? target_pid_to_str (ptid_of (except)) + ? target_pid_to_str (ptid_of (get_lwp_thread (except))) : "none"); } @@ -3097,10 +3121,10 @@ stop_all_lwps (int suspend, struct lwp_info *except) : STOPPING_THREADS); if (suspend) - find_inferior (&all_lwps, suspend_and_send_sigstop_callback, except); + find_inferior (&all_threads, suspend_and_send_sigstop_callback, except); else - find_inferior (&all_lwps, send_sigstop_callback, except); - for_each_inferior (&all_lwps, wait_for_sigstop); + find_inferior (&all_threads, send_sigstop_callback, except); + for_each_inferior (&all_threads, wait_for_sigstop); stopping_threads = NOT_STOPPING_THREADS; if (debug_threads) @@ -3119,6 +3143,7 @@ static void linux_resume_one_lwp (struct lwp_info *lwp, int step, int signal, siginfo_t *info) { + struct thread_info *thread = get_lwp_thread (lwp); struct thread_info *saved_inferior; int fast_tp_collecting; @@ -3135,7 +3160,7 @@ linux_resume_one_lwp (struct lwp_info *lwp, { /* Collecting 'while-stepping' actions doesn't make sense anymore. */ - release_while_stepping_state_list (get_lwp_thread (lwp)); + release_while_stepping_state_list (thread); } /* If we have pending signals or status, and a new signal, enqueue the @@ -3163,17 +3188,17 @@ linux_resume_one_lwp (struct lwp_info *lwp, if (debug_threads) debug_printf ("Not resuming lwp %ld (%s, signal %d, stop %s);" " has pending status\n", - lwpid_of (lwp), step ? "step" : "continue", signal, + lwpid_of (thread), step ? "step" : "continue", signal, lwp->stop_expected ? "expected" : "not expected"); return; } saved_inferior = current_inferior; - current_inferior = get_lwp_thread (lwp); + current_inferior = thread; if (debug_threads) debug_printf ("Resuming lwp %ld (%s, signal %d, stop %s)\n", - lwpid_of (lwp), step ? "step" : "continue", signal, + lwpid_of (thread), step ? "step" : "continue", signal, lwp->stop_expected ? "expected" : "not expected"); /* This bit needs some thinking about. If we get a signal that @@ -3215,7 +3240,7 @@ linux_resume_one_lwp (struct lwp_info *lwp, if (debug_threads) debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad" " (exit-jump-pad-bkpt)\n", - lwpid_of (lwp)); + lwpid_of (thread)); /* Postpone any pending signal. It was enqueued above. */ signal = 0; @@ -3225,7 +3250,7 @@ linux_resume_one_lwp (struct lwp_info *lwp, if (debug_threads) debug_printf ("lwp %ld wants to get out of fast tracepoint jump pad" " single-stepping\n", - lwpid_of (lwp)); + lwpid_of (thread)); if (can_hardware_single_step ()) step = 1; @@ -3245,12 +3270,12 @@ linux_resume_one_lwp (struct lwp_info *lwp, address, continue, and carry on catching this while-stepping action only when that breakpoint is hit. A future enhancement. */ - if (get_lwp_thread (lwp)->while_stepping != NULL + if (thread->while_stepping != NULL && can_hardware_single_step ()) { if (debug_threads) debug_printf ("lwp %ld has a while-stepping action -> forcing step.\n", - lwpid_of (lwp)); + lwpid_of (thread)); step = 1; } @@ -3276,7 +3301,7 @@ linux_resume_one_lwp (struct lwp_info *lwp, signal = (*p_sig)->signal; if ((*p_sig)->info.si_signo != 0) - ptrace (PTRACE_SETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0, + ptrace (PTRACE_SETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, &(*p_sig)->info); free (*p_sig); @@ -3286,12 +3311,12 @@ linux_resume_one_lwp (struct lwp_info *lwp, if (the_low_target.prepare_to_resume != NULL) the_low_target.prepare_to_resume (lwp); - regcache_invalidate_thread (get_lwp_thread (lwp)); + regcache_invalidate_thread (thread); errno = 0; lwp->stopped = 0; lwp->stopped_by_watchpoint = 0; lwp->stepping = step; - ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (lwp), + ptrace (step ? PTRACE_SINGLESTEP : PTRACE_CONT, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, /* Coerce to a uintptr_t first to avoid potential gcc warning of coercing an 8 byte integer to a 4 byte pointer. */ @@ -3332,13 +3357,11 @@ struct thread_resume_array static int linux_set_resume_request (struct inferior_list_entry *entry, void *arg) { - struct lwp_info *lwp; - struct thread_info *thread; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); int ndx; struct thread_resume_array *r; - thread = (struct thread_info *) entry; - lwp = get_thread_lwp (thread); r = arg; for (ndx = 0; ndx < r->n; ndx++) @@ -3348,7 +3371,7 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg) || ptid_equal (ptid, entry->id) /* Handle both 'pPID' and 'pPID.-1' as meaning 'all threads of PID'. */ - || (ptid_get_pid (ptid) == pid_of (lwp) + || (ptid_get_pid (ptid) == pid_of (thread) && (ptid_is_pid (ptid) || ptid_get_lwp (ptid) == -1))) { @@ -3361,7 +3384,7 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg) == TARGET_WAITKIND_STOPPED) ? "stopped" : "stopping", - lwpid_of (lwp)); + lwpid_of (thread)); continue; } @@ -3384,7 +3407,8 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg) if (debug_threads) debug_printf ("Dequeueing deferred signal %d for LWP %ld, " "leaving status pending.\n", - WSTOPSIG (lwp->status_pending), lwpid_of (lwp)); + WSTOPSIG (lwp->status_pending), + lwpid_of (thread)); } return 0; @@ -3403,7 +3427,8 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg) static int resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); /* LWPs which will not be resumed are not interesting, because we might not wait for them next time through linux_wait. */ @@ -3424,8 +3449,8 @@ resume_status_pending_p (struct inferior_list_entry *entry, void *flag_p) static int need_step_over_p (struct inferior_list_entry *entry, void *dummy) { - struct lwp_info *lwp = (struct lwp_info *) entry; - struct thread_info *thread; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); struct thread_info *saved_inferior; CORE_ADDR pc; @@ -3436,18 +3461,16 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) { if (debug_threads) debug_printf ("Need step over [LWP %ld]? Ignoring, not stopped\n", - lwpid_of (lwp)); + lwpid_of (thread)); return 0; } - thread = get_lwp_thread (lwp); - if (thread->last_resume_kind == resume_stop) { if (debug_threads) debug_printf ("Need step over [LWP %ld]? Ignoring, should remain" " stopped\n", - lwpid_of (lwp)); + lwpid_of (thread)); return 0; } @@ -3457,14 +3480,14 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) { if (debug_threads) debug_printf ("Need step over [LWP %ld]? Ignoring, suspended\n", - lwpid_of (lwp)); + lwpid_of (thread)); return 0; } if (!lwp->need_step_over) { if (debug_threads) - debug_printf ("Need step over [LWP %ld]? No\n", lwpid_of (lwp)); + debug_printf ("Need step over [LWP %ld]? No\n", lwpid_of (thread)); } if (lwp->status_pending_p) @@ -3472,7 +3495,7 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) if (debug_threads) debug_printf ("Need step over [LWP %ld]? Ignoring, has pending" " status.\n", - lwpid_of (lwp)); + lwpid_of (thread)); return 0; } @@ -3490,7 +3513,8 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) if (debug_threads) debug_printf ("Need step over [LWP %ld]? Cancelling, PC was changed. " "Old stop_pc was 0x%s, PC is now 0x%s\n", - lwpid_of (lwp), paddress (lwp->stop_pc), paddress (pc)); + lwpid_of (thread), + paddress (lwp->stop_pc), paddress (pc)); lwp->need_step_over = 0; return 0; @@ -3512,7 +3536,7 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) if (debug_threads) debug_printf ("Need step over [LWP %ld]? yes, but found" " GDB breakpoint at 0x%s; skipping step over\n", - lwpid_of (lwp), paddress (pc)); + lwpid_of (thread), paddress (pc)); current_inferior = saved_inferior; return 0; @@ -3522,7 +3546,7 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) if (debug_threads) debug_printf ("Need step over [LWP %ld]? yes, " "found breakpoint at 0x%s\n", - lwpid_of (lwp), paddress (pc)); + lwpid_of (thread), paddress (pc)); /* We've found an lwp that needs stepping over --- return 1 so that find_inferior stops looking. */ @@ -3539,7 +3563,7 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) if (debug_threads) debug_printf ("Need step over [LWP %ld]? No, no breakpoint found" " at 0x%s\n", - lwpid_of (lwp), paddress (pc)); + lwpid_of (thread), paddress (pc)); return 0; } @@ -3565,13 +3589,14 @@ need_step_over_p (struct inferior_list_entry *entry, void *dummy) static int start_step_over (struct lwp_info *lwp) { + struct thread_info *thread = get_lwp_thread (lwp); struct thread_info *saved_inferior; CORE_ADDR pc; int step; if (debug_threads) debug_printf ("Starting step-over on LWP %ld. Stopping all threads\n", - lwpid_of (lwp)); + lwpid_of (thread)); stop_all_lwps (1, lwp); gdb_assert (lwp->suspended == 0); @@ -3586,7 +3611,7 @@ start_step_over (struct lwp_info *lwp) pc = get_pc (lwp); saved_inferior = current_inferior; - current_inferior = get_lwp_thread (lwp); + current_inferior = thread; lwp->bp_reinsert = pc; uninsert_breakpoints_at (pc); @@ -3608,7 +3633,7 @@ start_step_over (struct lwp_info *lwp) linux_resume_one_lwp (lwp, step, 0, NULL); /* Require next event from this LWP. */ - step_over_bkpt = lwp->entry.id; + step_over_bkpt = thread->entry.id; return 1; } @@ -3662,27 +3687,24 @@ finish_step_over (struct lwp_info *lwp) static int linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) { - struct lwp_info *lwp; - struct thread_info *thread; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); int step; int leave_all_stopped = * (int *) arg; int leave_pending; - thread = (struct thread_info *) entry; - lwp = get_thread_lwp (thread); - if (lwp->resume == NULL) return 0; if (lwp->resume->kind == resume_stop) { if (debug_threads) - debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (lwp)); + debug_printf ("resume_stop request for LWP %ld\n", lwpid_of (thread)); if (!lwp->stopped) { if (debug_threads) - debug_printf ("stopping LWP %ld\n", lwpid_of (lwp)); + debug_printf ("stopping LWP %ld\n", lwpid_of (thread)); /* Stop the thread, and wait for the event asynchronously, through the event loop. */ @@ -3692,7 +3714,7 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) { if (debug_threads) debug_printf ("already stopped LWP %ld\n", - lwpid_of (lwp)); + lwpid_of (thread)); /* The LWP may have been stopped in an internal event that was not meant to be notified back to GDB (e.g., gdbserver @@ -3734,7 +3756,7 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) if (!leave_pending) { if (debug_threads) - debug_printf ("resuming LWP %ld\n", lwpid_of (lwp)); + debug_printf ("resuming LWP %ld\n", lwpid_of (thread)); step = (lwp->resume->kind == resume_step); linux_resume_one_lwp (lwp, step, lwp->resume->sig, NULL); @@ -3742,7 +3764,7 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) else { if (debug_threads) - debug_printf ("leaving LWP %ld stopped\n", lwpid_of (lwp)); + debug_printf ("leaving LWP %ld stopped\n", lwpid_of (thread)); /* If we have a new signal, enqueue the signal. */ if (lwp->resume->sig != 0) @@ -3759,7 +3781,7 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg) PTRACE_SETSIGINFO. */ if (WIFSTOPPED (lwp->last_status) && WSTOPSIG (lwp->last_status) == lwp->resume->sig) - ptrace (PTRACE_GETSIGINFO, lwpid_of (lwp), (PTRACE_TYPE_ARG3) 0, + ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0, &p_sig->info); lwp->pending_signals = p_sig; @@ -3775,7 +3797,7 @@ static void linux_resume (struct thread_resume *resume_info, size_t n) { struct thread_resume_array array = { resume_info, n }; - struct lwp_info *need_step_over = NULL; + struct thread_info *need_step_over = NULL; int any_pending; int leave_all_stopped; @@ -3795,7 +3817,7 @@ linux_resume (struct thread_resume *resume_info, size_t n) before considering to start a step-over (in all-stop). */ any_pending = 0; if (!non_stop) - find_inferior (&all_lwps, resume_status_pending_p, &any_pending); + find_inferior (&all_threads, resume_status_pending_p, &any_pending); /* If there is a thread which would otherwise be resumed, which is stopped at a breakpoint that needs stepping over, then don't @@ -3805,8 +3827,8 @@ linux_resume (struct thread_resume *resume_info, size_t n) queued. */ if (!any_pending && supports_breakpoints ()) need_step_over - = (struct lwp_info *) find_inferior (&all_lwps, - need_step_over_p, NULL); + = (struct thread_info *) find_inferior (&all_threads, + need_step_over_p, NULL); leave_all_stopped = (need_step_over != NULL || any_pending); @@ -3826,7 +3848,7 @@ linux_resume (struct thread_resume *resume_info, size_t n) find_inferior (&all_threads, linux_resume_one_thread, &leave_all_stopped); if (need_step_over) - start_step_over (need_step_over); + start_step_over (get_thread_lwp (need_step_over)); if (debug_threads) { @@ -3847,31 +3869,29 @@ linux_resume (struct thread_resume *resume_info, size_t n) static int proceed_one_lwp (struct inferior_list_entry *entry, void *except) { - struct lwp_info *lwp = (struct lwp_info *) entry; - struct thread_info *thread; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); int step; if (lwp == except) return 0; if (debug_threads) - debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (lwp)); + debug_printf ("proceed_one_lwp: lwp %ld\n", lwpid_of (thread)); if (!lwp->stopped) { if (debug_threads) - debug_printf (" LWP %ld already running\n", lwpid_of (lwp)); + debug_printf (" LWP %ld already running\n", lwpid_of (thread)); return 0; } - thread = get_lwp_thread (lwp); - if (thread->last_resume_kind == resume_stop && thread->last_status.kind != TARGET_WAITKIND_IGNORE) { if (debug_threads) debug_printf (" client wants LWP to remain %ld stopped\n", - lwpid_of (lwp)); + lwpid_of (thread)); return 0; } @@ -3879,7 +3899,7 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except) { if (debug_threads) debug_printf (" LWP %ld has pending status, leaving stopped\n", - lwpid_of (lwp)); + lwpid_of (thread)); return 0; } @@ -3888,7 +3908,7 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except) if (lwp->suspended) { if (debug_threads) - debug_printf (" LWP %ld is suspended\n", lwpid_of (lwp)); + debug_printf (" LWP %ld is suspended\n", lwpid_of (thread)); return 0; } @@ -3909,7 +3929,7 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except) if (debug_threads) debug_printf ("Client wants LWP %ld to stop. " "Making sure it has a SIGSTOP pending\n", - lwpid_of (lwp)); + lwpid_of (thread)); send_sigstop (lwp); } @@ -3922,7 +3942,8 @@ proceed_one_lwp (struct inferior_list_entry *entry, void *except) static int unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); if (lwp == except) return 0; @@ -3940,7 +3961,7 @@ unsuspend_and_proceed_one_lwp (struct inferior_list_entry *entry, void *except) static void proceed_all_lwps (void) { - struct lwp_info *need_step_over; + struct thread_info *need_step_over; /* If there is a thread which would otherwise be resumed, which is stopped at a breakpoint that needs stepping over, then don't @@ -3950,8 +3971,8 @@ proceed_all_lwps (void) if (supports_breakpoints ()) { need_step_over - = (struct lwp_info *) find_inferior (&all_lwps, - need_step_over_p, NULL); + = (struct thread_info *) find_inferior (&all_threads, + need_step_over_p, NULL); if (need_step_over != NULL) { @@ -3960,7 +3981,7 @@ proceed_all_lwps (void) "thread %ld needing a step-over\n", lwpid_of (need_step_over)); - start_step_over (need_step_over); + start_step_over (get_thread_lwp (need_step_over)); return; } } @@ -3968,7 +3989,7 @@ proceed_all_lwps (void) if (debug_threads) debug_printf ("Proceeding, no step-over needed\n"); - find_inferior (&all_lwps, proceed_one_lwp, NULL); + find_inferior (&all_threads, proceed_one_lwp, NULL); } /* Stopped LWPs that the client wanted to be running, that don't have @@ -3983,15 +4004,15 @@ unstop_all_lwps (int unsuspend, struct lwp_info *except) debug_enter (); if (except) debug_printf ("unstopping all lwps, except=(LWP %ld)\n", - lwpid_of (except)); + lwpid_of (get_lwp_thread (except))); else debug_printf ("unstopping all lwps\n"); } if (unsuspend) - find_inferior (&all_lwps, unsuspend_and_proceed_one_lwp, except); + find_inferior (&all_threads, unsuspend_and_proceed_one_lwp, except); else - find_inferior (&all_lwps, proceed_one_lwp, except); + find_inferior (&all_threads, proceed_one_lwp, except); if (debug_threads) { @@ -4038,7 +4059,7 @@ regsets_fetch_inferior_registers (struct regsets_info *regsets_info, regset = regsets_info->regsets; - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); while (regset->size >= 0) { void *buf, *data; @@ -4109,7 +4130,7 @@ regsets_store_inferior_registers (struct regsets_info *regsets_info, regset = regsets_info->regsets; - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); while (regset->size >= 0) { void *buf, *data; @@ -4254,7 +4275,7 @@ fetch_register (const struct usrregs_info *usrregs, & -sizeof (PTRACE_XFER_TYPE)); buf = alloca (size); - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; @@ -4304,7 +4325,7 @@ store_register (const struct usrregs_info *usrregs, else collect_register (regcache, regno, buf); - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); for (i = 0; i < size; i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; @@ -4444,7 +4465,7 @@ linux_store_registers (struct regcache *regcache, int regno) static int linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) { - int pid = lwpid_of (get_thread_lwp (current_inferior)); + int pid = lwpid_of (current_inferior); register PTRACE_XFER_TYPE *buffer; register CORE_ADDR addr; register int count; @@ -4545,7 +4566,7 @@ linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len) register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE)); - int pid = lwpid_of (get_thread_lwp (current_inferior)); + int pid = lwpid_of (current_inferior); if (len == 0) { @@ -4638,11 +4659,9 @@ linux_request_interrupt (void) if (!ptid_equal (cont_thread, null_ptid) && !ptid_equal (cont_thread, minus_one_ptid)) { - struct lwp_info *lwp; int lwpid; - lwp = get_thread_lwp (current_inferior); - lwpid = lwpid_of (lwp); + lwpid = lwpid_of (current_inferior); kill_lwp (lwpid, SIGINT); } else @@ -4657,7 +4676,7 @@ linux_read_auxv (CORE_ADDR offset, unsigned char *myaddr, unsigned int len) { char filename[PATH_MAX]; int fd, n; - int pid = lwpid_of (get_thread_lwp (current_inferior)); + int pid = lwpid_of (current_inferior); xsnprintf (filename, sizeof filename, "/proc/%d/auxv", pid); @@ -4804,7 +4823,7 @@ linux_xfer_siginfo (const char *annex, unsigned char *readbuf, if (current_inferior == NULL) return -1; - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); if (debug_threads) debug_printf ("%s siginfo for lwp %d.\n", @@ -5018,7 +5037,7 @@ linux_qxfer_spu (const char *annex, unsigned char *readbuf, unsigned const char *writebuf, CORE_ADDR offset, int len) { - long pid = lwpid_of (get_thread_lwp (current_inferior)); + long pid = lwpid_of (current_inferior); char buf[128]; int fd = 0; int ret = 0; @@ -5568,7 +5587,7 @@ linux_qxfer_libraries_svr4 (const char *annex, unsigned char *readbuf, if (readbuf == NULL) return -1; - pid = lwpid_of (get_thread_lwp (current_inferior)); + pid = lwpid_of (current_inferior); xsnprintf (filename, sizeof filename, "/proc/%d/exe", pid); is_elf64 = elf_64_file_p (filename, &machine); lmo = is_elf64 ? &lmo_64bit_offsets : &lmo_32bit_offsets; diff --git a/gdb/gdbserver/linux-low.h b/gdb/gdbserver/linux-low.h index b3e75db..7459710 100644 --- a/gdb/gdbserver/linux-low.h +++ b/gdb/gdbserver/linux-low.h @@ -223,21 +223,22 @@ struct linux_target_ops extern struct linux_target_ops the_low_target; -#define ptid_of(proc) ((proc)->entry.id) -#define pid_of(proc) ptid_get_pid ((proc)->entry.id) -#define lwpid_of(proc) ptid_get_lwp ((proc)->entry.id) - -#define get_lwp(inf) ((struct lwp_info *)(inf)) -#define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr))) +#define get_thread_lwp(thr) ((struct lwp_info *) (inferior_target_data (thr))) #define get_lwp_thread(lwp) ((lwp)->thread) +/* This struct is recorded in the target_data field of struct thread_info. + + On linux ``all_threads'' is keyed by the LWP ID, which we use as the + GDB protocol representation of the thread ID. Threads also have + a "process ID" (poorly named) which is (presently) the same as the + LWP ID. + + There is also ``all_processes'' is keyed by the "overall process ID", + which GNU/Linux calls tgid, "thread group ID". */ + struct lwp_info { - struct inferior_list_entry entry; - - /* Backlink to the thread_info object. - It is the "main" representation of the thread, we just contain - linux-specific subordinate data. */ + /* Backlink to the parent object. */ struct thread_info *thread; /* If this flag is set, the next SIGSTOP will be ignored (the @@ -340,8 +341,6 @@ struct lwp_info struct arch_lwp_info *arch_private; }; -extern struct inferior_list all_lwps; - int linux_pid_exe_is_elf_64_file (int pid, unsigned int *machine); void linux_attach_lwp (unsigned long pid); diff --git a/gdb/gdbserver/linux-mips-low.c b/gdb/gdbserver/linux-mips-low.c index 70917fd..5a24bfe 100644 --- a/gdb/gdbserver/linux-mips-low.c +++ b/gdb/gdbserver/linux-mips-low.c @@ -126,7 +126,7 @@ mips_read_description (void) { if (have_dsp < 0) { - int pid = lwpid_of (get_thread_lwp (current_inferior)); + int pid = lwpid_of (current_inferior); ptrace (PTRACE_PEEKUSER, pid, DSP_CONTROL, 0); switch (errno) @@ -298,11 +298,12 @@ static int update_watch_registers_callback (struct inferior_list_entry *entry, void *pid_p) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thread = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thread); int pid = *(int *) pid_p; /* Only update the threads of this process. */ - if (pid_of (lwp) == pid) + if (pid_of (thread) == pid) { /* The actual update is done later just before resuming the lwp, we just mark that the registers need updating. */ @@ -349,7 +350,7 @@ mips_linux_new_thread (void) static void mips_linux_prepare_to_resume (struct lwp_info *lwp) { - ptid_t ptid = ptid_of (lwp); + ptid_t ptid = ptid_of (get_lwp_thread (lwp)); struct process_info *proc = find_process_pid (ptid_get_pid (ptid)); struct arch_process_info *private = proc->private->arch_private; @@ -418,7 +419,7 @@ mips_insert_point (char type, CORE_ADDR addr, int len) return 1; } - lwpid = lwpid_of (get_thread_lwp (current_inferior)); + lwpid = lwpid_of (current_inferior); if (!mips_linux_read_watch_registers (lwpid, &private->watch_readback, &private->watch_readback_valid, @@ -454,7 +455,7 @@ mips_insert_point (char type, CORE_ADDR addr, int len) /* Only update the threads of this process. */ pid = pid_of (proc); - find_inferior (&all_lwps, update_watch_registers_callback, &pid); + find_inferior (&all_threads, update_watch_registers_callback, &pid); return 0; } @@ -517,7 +518,7 @@ mips_remove_point (char type, CORE_ADDR addr, int len) /* Only update the threads of this process. */ pid = pid_of (proc); - find_inferior (&all_lwps, update_watch_registers_callback, &pid); + find_inferior (&all_threads, update_watch_registers_callback, &pid); return 0; } @@ -532,7 +533,7 @@ mips_stopped_by_watchpoint (void) struct arch_process_info *private = proc->private->arch_private; int n; int num_valid; - long lwpid = lwpid_of (get_thread_lwp (current_inferior)); + long lwpid = lwpid_of (current_inferior); if (!mips_linux_read_watch_registers (lwpid, &private->watch_readback, @@ -560,7 +561,7 @@ mips_stopped_data_address (void) struct arch_process_info *private = proc->private->arch_private; int n; int num_valid; - long lwpid = lwpid_of (get_thread_lwp (current_inferior)); + long lwpid = lwpid_of (current_inferior); /* On MIPS we don't know the low order 3 bits of the data address. GDB does not support remote targets that can't report the diff --git a/gdb/gdbserver/linux-s390-low.c b/gdb/gdbserver/linux-s390-low.c index cd464ff..fd1b0c9 100644 --- a/gdb/gdbserver/linux-s390-low.c +++ b/gdb/gdbserver/linux-s390-low.c @@ -422,7 +422,7 @@ s390_arch_setup (void) struct regset_info *regset; /* Check whether the kernel supports extra register sets. */ - int pid = pid_of (get_thread_lwp (current_inferior)); + int pid = pid_of (current_inferior); int have_regset_last_break = s390_check_regset (pid, NT_S390_LAST_BREAK, 8); int have_regset_system_call diff --git a/gdb/gdbserver/linux-tile-low.c b/gdb/gdbserver/linux-tile-low.c index 2a84ace..c292c27 100644 --- a/gdb/gdbserver/linux-tile-low.c +++ b/gdb/gdbserver/linux-tile-low.c @@ -158,7 +158,7 @@ tile_regs_info (void) static void tile_arch_setup (void) { - int pid = pid_of (get_thread_lwp (current_inferior)); + int pid = pid_of (current_inferior); unsigned int machine; int is_elf64 = linux_pid_exe_is_elf_64_file (pid, &machine); diff --git a/gdb/gdbserver/linux-x86-low.c b/gdb/gdbserver/linux-x86-low.c index 1e590e8..33b5f26 100644 --- a/gdb/gdbserver/linux-x86-low.c +++ b/gdb/gdbserver/linux-x86-low.c @@ -285,7 +285,8 @@ x86_get_thread_area (int lwpid, CORE_ADDR *addr) { struct lwp_info *lwp = find_lwp_pid (pid_to_ptid (lwpid)); - struct regcache *regcache = get_thread_regcache (get_lwp_thread (lwp), 1); + struct thread_info *thr = get_lwp_thread (lwp); + struct regcache *regcache = get_thread_regcache (thr, 1); unsigned int desc[4]; ULONGEST gs = 0; const int reg_thread_area = 3; /* bits to scale down register value. */ @@ -296,7 +297,7 @@ x86_get_thread_area (int lwpid, CORE_ADDR *addr) idx = gs >> reg_thread_area; if (ptrace (PTRACE_GET_THREAD_AREA, - lwpid_of (lwp), + lwpid_of (thr), (void *) (long) idx, (unsigned long) &desc) < 0) return -1; @@ -538,11 +539,12 @@ static int update_debug_registers_callback (struct inferior_list_entry *entry, void *pid_p) { - struct lwp_info *lwp = (struct lwp_info *) entry; + struct thread_info *thr = (struct thread_info *) entry; + struct lwp_info *lwp = get_thread_lwp (thr); int pid = *(int *) pid_p; /* Only update the threads of this process. */ - if (pid_of (lwp) == pid) + if (pid_of (thr) == pid) { /* The actual update is done later just before resuming the lwp, we just mark that the registers need updating. */ @@ -563,12 +565,12 @@ void i386_dr_low_set_addr (const struct i386_debug_reg_state *state, int regnum) { /* Only update the threads of this process. */ - int pid = pid_of (get_thread_lwp (current_inferior)); + int pid = pid_of (current_inferior); if (! (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR)) fatal ("Invalid debug register %d", regnum); - find_inferior (&all_lwps, update_debug_registers_callback, &pid); + find_inferior (&all_threads, update_debug_registers_callback, &pid); } /* Return the inferior's debug register REGNUM. */ @@ -576,8 +578,7 @@ i386_dr_low_set_addr (const struct i386_debug_reg_state *state, int regnum) CORE_ADDR i386_dr_low_get_addr (int regnum) { - struct lwp_info *lwp = get_thread_lwp (current_inferior); - ptid_t ptid = ptid_of (lwp); + ptid_t ptid = ptid_of (current_inferior); /* DR6 and DR7 are retrieved with some other way. */ gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR); @@ -591,9 +592,9 @@ void i386_dr_low_set_control (const struct i386_debug_reg_state *state) { /* Only update the threads of this process. */ - int pid = pid_of (get_thread_lwp (current_inferior)); + int pid = pid_of (current_inferior); - find_inferior (&all_lwps, update_debug_registers_callback, &pid); + find_inferior (&all_threads, update_debug_registers_callback, &pid); } /* Return the inferior's DR7 debug control register. */ @@ -601,8 +602,7 @@ i386_dr_low_set_control (const struct i386_debug_reg_state *state) unsigned i386_dr_low_get_control (void) { - struct lwp_info *lwp = get_thread_lwp (current_inferior); - ptid_t ptid = ptid_of (lwp); + ptid_t ptid = ptid_of (current_inferior); return x86_linux_dr_get (ptid, DR_CONTROL); } @@ -613,8 +613,7 @@ i386_dr_low_get_control (void) unsigned i386_dr_low_get_status (void) { - struct lwp_info *lwp = get_thread_lwp (current_inferior); - ptid_t ptid = ptid_of (lwp); + ptid_t ptid = ptid_of (current_inferior); return x86_linux_dr_get (ptid, DR_STATUS); } @@ -728,7 +727,7 @@ x86_linux_new_thread (void) static void x86_linux_prepare_to_resume (struct lwp_info *lwp) { - ptid_t ptid = ptid_of (lwp); + ptid_t ptid = ptid_of (get_lwp_thread (lwp)); int clear_status = 0; if (lwp->arch_private->debug_registers_changed) @@ -1170,7 +1169,7 @@ x86_siginfo_fixup (siginfo_t *native, void *inf, int direction) { #ifdef __x86_64__ unsigned int machine; - int tid = lwpid_of (get_thread_lwp (current_inferior)); + int tid = lwpid_of (current_inferior); int is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine); /* Is the inferior 32-bit? If so, then fixup the siginfo object. */ @@ -1255,7 +1254,7 @@ x86_linux_read_description (void) static uint64_t xcr0; struct regset_info *regset; - tid = lwpid_of (get_thread_lwp (current_inferior)); + tid = lwpid_of (current_inferior); is_elf64 = linux_pid_exe_is_elf_64_file (tid, &machine); diff --git a/gdb/gdbserver/proc-service.c b/gdb/gdbserver/proc-service.c index 85d28ad..5a6dc4e 100644 --- a/gdb/gdbserver/proc-service.c +++ b/gdb/gdbserver/proc-service.c @@ -157,5 +157,5 @@ ps_lsetfpregs (gdb_ps_prochandle_t ph, lwpid_t lwpid, void *fpregset) pid_t ps_getpid (gdb_ps_prochandle_t ph) { - return pid_of (get_thread_lwp (current_inferior)); + return pid_of (current_inferior); } |