diff options
Diffstat (limited to 'gdb/gdbserver/linux-low.c')
| -rw-r--r-- | gdb/gdbserver/linux-low.c | 483 |
1 files changed, 251 insertions, 232 deletions
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; |