This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[PATCH v2 3/3] remove all_lwps from gdbserver: remove all_lwps
- From: Doug Evans <dje at google dot com>
- To: gdb-patches at sourceware dot org
- Date: Wed, 29 Jan 2014 10:31:01 -0800
- Subject: [PATCH v2 3/3] remove all_lwps from gdbserver: remove all_lwps
- Authentication-results: sourceware.org; auth=none
Hi.
This is the main patch.
The concept is very simple: remove all_lwps.
I think it's the right thing to do, I can't think of a good reason
to maintain two separate lists of threads, each containing a subset
of the data needed.
Alas implementing this involves a lot of work.
Regression tested on amd64-linux.
I think I caught all the places that need updating in the other ports,
but I can't test them. Can anyone else?
The speedup I get from this is at least as good as what I was
seeing with my hashtable implementation.
The changelog entry is massive, but I'm just "going with the flow" here,
or at least as I understand what the community requires.
I can see simplifying it a lot.
There's a couple of cleanups that I can see doing after this:
1) Use the ptid accessor macros more.
Some code accesses the ptid directly instead of using
ptid_of, pid_of, lwpid_of.
Sometimes such accessor macros bother me, this one I'm ambivalent on
so I've left this for another pass.
2) With the removal of all_lwps the "this" pointer of a thread is now
unambiguously the struct thread_info pointer. However, some code
still takes a struct lwp_info pointer as a pseudo "this". These
functions could be changed, but it's not clear to me the win is
that great.
Another issue is:
Several functions have a struct thread_info pointer and a struct
lwp_info pointer. That's because lwp_info is recorded in the
target_data field of thread_info. thread_info "has a" lwp_info,
as opposed to lwp_info "is a" thread_info.
This problem already existed. This patch makes it a bit worse
because previously the ptid was recorded in both thread_info and
lwp_info and the code didn't need a thread_info pointer to get the ptid.
I could have left ptid in lwp_info but that would have meant
recording the same data in two different places, also not good.
The benefit of the current approach is clarity: there is only one place
to get the ptid of a thread.
2014-01-28 Doug Evans <dje@google.com>
* gdbthread.h (add_thread): Change result type to struct thread_info *.
* inferiors.c (add_thread): Change result type to struct thread_info *.
All callers updated.
* 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): Change result type to struct lwp_info *.
Call add_thread here instead of in callers. All callers updated.
(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, now 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, now 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, for_each_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.
(get_lwp_thread): Rewrite.
(struct lwp_info): Delete member "entry".
New 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.
(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.
diff --git a/gdb/gdbserver/gdbthread.h b/gdb/gdbserver/gdbthread.h
index 0eac5a4..9785d67 100644
--- a/gdb/gdbserver/gdbthread.h
+++ b/gdb/gdbserver/gdbthread.h
@@ -74,7 +74,7 @@ struct thread_info
extern struct inferior_list all_threads;
void remove_thread (struct thread_info *thread);
-void add_thread (ptid_t ptid, void *target_data);
+struct thread_info *add_thread (ptid_t ptid, void *target_data);
struct thread_info *get_first_thread (void);
diff --git a/gdb/gdbserver/inferiors.c b/gdb/gdbserver/inferiors.c
index a090386..4786dc8 100644
--- a/gdb/gdbserver/inferiors.c
+++ b/gdb/gdbserver/inferiors.c
@@ -104,7 +104,7 @@ remove_inferior (struct inferior_list *list,
list->tail = *cur;
}
-void
+struct thread_info *
add_thread (ptid_t thread_id, void *target_data)
{
struct thread_info *new_thread = xmalloc (sizeof (*new_thread));
@@ -115,12 +115,14 @@ add_thread (ptid_t thread_id, void *target_data)
new_thread->last_resume_kind = resume_continue;
new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
- add_inferior_to_list (&all_threads, & new_thread->entry);
+ add_inferior_to_list (&all_threads, &new_thread->entry);
if (current_inferior == NULL)
current_inferior = new_thread;
new_thread->target_data = target_data;
+
+ return new_thread;
}
ptid_t
diff --git a/gdb/gdbserver/inferiors.h b/gdb/gdbserver/inferiors.h
index a503be6..b810939 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 011ee58..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. */
@@ -226,7 +215,7 @@ static void linux_resume (struct thread_resume *resume_info, size_t n);
static void stop_all_lwps (int suspend, struct lwp_info *except);
static void unstop_all_lwps (int unsuspend, struct lwp_info *except);
static int linux_wait_for_event (ptid_t ptid, int *wstat, int options);
-static void *add_lwp (ptid_t ptid);
+static struct lwp_info *add_lwp (ptid_t ptid);
static int linux_stopped_by_watchpoint (void);
static void mark_lwp_dead (struct lwp_info *lwp, int wstat);
static void proceed_all_lwps (void);
@@ -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;
f 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,9 +396,8 @@ 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);
- new_lwp = (struct lwp_info *) add_lwp (ptid);
- add_thread (ptid, new_lwp);
+ 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
or leave it stopped. linux_resume_one_lwp is a nop if it
@@ -525,7 +513,7 @@ get_stop_pc (struct lwp_info *lwp)
return stop_pc;
}
-static void *
+static struct lwp_info *
add_lwp (ptid_t ptid)
{
struct lwp_info *lwp;
@@ -533,12 +521,10 @@ 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;
}
@@ -632,7 +618,6 @@ linux_create_inferior (char *program, char **allargs)
ptid = ptid_build (pid, pid, 0);
new_lwp = add_lwp (ptid);
- add_thread (ptid, new_lwp);
new_lwp->must_set_ptrace_flags = 1;
return pid;
@@ -678,12 +663,11 @@ 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);
}
- new_lwp = (struct lwp_info *) add_lwp (ptid);
- add_thread (ptid, new_lwp);
+ new_lwp = add_lwp (ptid);
/* We need to wait for SIGSTOP before being able to make the next
ptrace call on this LWP. */
@@ -878,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
@@ -898,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");
}
@@ -928,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",
@@ -941,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;
@@ -972,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));
}
@@ -1029,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;
}
@@ -1039,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;
}
@@ -1049,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;
}
@@ -1063,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;
}
@@ -1071,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);
@@ -1094,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);
@@ -1109,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);
@@ -1156,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;
@@ -1174,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;
@@ -1216,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
@@ -1257,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 *
@@ -1265,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));
@@ -1292,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.
@@ -1317,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 ();
@@ -1457,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;
@@ -1465,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);
@@ -1495,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);
@@ -1521,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;
@@ -1551,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;
@@ -1593,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;
@@ -1606,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)
{
@@ -1641,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;
}
}
@@ -1651,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;
@@ -1663,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;
@@ -1673,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)
{
@@ -1723,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)
@@ -1741,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;
@@ -1761,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;
@@ -1771,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
{
@@ -1796,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))
@@ -1840,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);
@@ -1853,29 +1864,29 @@ 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)
{
- current_inferior = (struct thread_info *) all_threads.head;
+ 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
{
@@ -1888,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. */
@@ -1906,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;
}
@@ -1938,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 */
@@ -1950,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);
@@ -1974,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
@@ -1991,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);
@@ -2013,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. */
@@ -2049,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. */
@@ -2059,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
{
@@ -2077,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)
@@ -2087,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;
}
@@ -2104,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)
@@ -2122,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);
@@ -2167,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;
}
@@ -2185,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;
@@ -2215,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;
@@ -2223,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));
}
}
@@ -2341,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 ();
}
@@ -2355,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
@@ -2441,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
@@ -2451,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;
@@ -2463,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;
@@ -2525,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);
}
}
}
@@ -2563,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
@@ -2627,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);
}
@@ -2692,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
@@ -2743,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. */
@@ -2840,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. */
@@ -2862,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)
@@ -2881,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)
@@ -2912,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;
@@ -2923,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;
}
@@ -2933,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");
@@ -2947,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;
@@ -3008,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);
@@ -3026,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);
@@ -3043,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)
{
@@ -3053,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);
@@ -3065,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;
@@ -3090,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");
}
@@ -3099,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)
@@ -3121,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;
@@ -3137,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
@@ -3165,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
@@ -3217,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;
@@ -3227,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;
@@ -3247,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;
}
@@ -3278,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);
@@ -3288,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. */
@@ -3334,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++)
@@ -3350,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)))
{
@@ -3363,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;
}
@@ -3386,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;
@@ -3405,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. */
@@ -3426,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;
@@ -3438,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;
}
@@ -3459,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)
@@ -3474,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;
}
@@ -3492,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;
@@ -3514,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;
@@ -3524,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. */
@@ -3541,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;
}
@@ -3567,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);
@@ -3588,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);
@@ -3610,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;
}
@@ -3664,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. */
@@ -3694,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
@@ -3736,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);
@@ -3744,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)
@@ -3761,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;
@@ -3777,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;
@@ -3797,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
@@ -3807,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);
@@ -3828,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)
{
@@ -3849,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;
}
@@ -3881,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;
}
@@ -3890,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;
}
@@ -3911,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);
}
@@ -3924,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;
@@ -3942,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
@@ -3952,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)
{
@@ -3962,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;
}
}
@@ -3970,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
@@ -3985,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)
{
@@ -4040,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;
@@ -4111,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;
@@ -4256,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;
@@ -4306,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;
@@ -4446,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;
@@ -4547,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)
{
@@ -4640,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
@@ -4659,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);
@@ -4806,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",
@@ -5020,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;
@@ -5570,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 3b7ec21..7459710 100644
--- a/gdb/gdbserver/linux-low.h
+++ b/gdb/gdbserver/linux-low.h
@@ -223,19 +223,23 @@ 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_thread_lwp(thr) ((struct lwp_info *) (inferior_target_data (thr)))
+#define get_lwp_thread(lwp) ((lwp)->thread)
-#define get_lwp(inf) ((struct lwp_info *)(inf))
-#define get_thread_lwp(thr) (get_lwp (inferior_target_data (thr)))
-#define get_lwp_thread(proc) ((struct thread_info *) \
- find_inferior_id (&all_threads, \
- get_lwp (proc)->entry.id))
+/* 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 parent object. */
+ struct thread_info *thread;
/* If this flag is set, the next SIGSTOP will be ignored (the
process will be immediately resumed). This means that either we
@@ -337,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);
}