Remove all_lwps global.

	* inferiors.h (ptid_of): Move here from linux-low.h.
	(pid_of, lwpid_of): Ditto.
	* linux-aarch64-low.c (debug_reg_change_callback): Update, "entry"
	parameter is a struct thread_info * now.
	(aarch64_notify_debug_reg_change): Fetch pid from current_inferior
	directly.  Pass &all_threads to find_inferior instead of &all_lwps.
	(aarch64_stopped_data_address): Fetch lwpid from current_inferior
	directly.
	(aarch64_linux_prepare_to_resume): Fetch ptid from thread.
	(aarch64_arch_setup): Fetch lwpid from current_inferior directly.
	* linux-arm-low.c (update_registers_callback): Update, "entry"
	parameter is a struct thread_info * now.
	Fetch lwpid from current_inferior directly.
	(arm_insert_point): Pass &all_threads to find_inferior instead of
	&all_lwps.
	(arm_remove_point): Ditto.
	(arm_stopped_by_watchpoint): Fetch lwp from current_inferior.
	(arm_prepare_to_resume): Fetch pid from thread.
	(arm_read_description): Fetch lwpid from current_inferior directly.
	* linux-low.c (all_lwps): Delete.
	(delete_lwp): Delete call to remove_inferior.
	(handle_extended_wait): Fetch lwpid from thread.
	(add_lwp): Don't set lwp->entry.id.  Remove call to
	add_inferior_to_list.
	(linux_attach_lwp_1): Fetch pid from current_inferior directly.
	(linux_kill_one_lwp): Fetch ptid,lwpid from thread.
	(kill_one_lwp_callback): Ditto.
	(linux_kill): Don't dereference NULL pointer.
	Fetch ptid,lwpid from thread.
	(get_detach_signal): Fetch ptid from thread.
	(linux_detach_one_lwp): Fetch ptid,lwpid from thread.
	Simplify call to regcache_invalidate_thread.
	(delete_lwp_callback): Update, "entry" parameter is a
	struct thread_info * now.  Fetch pid from thread.
	(linux_mourn): Pass &all_threads to find_inferior instead of &all_lwps.
	(status_pending_p_callback): Update, "entry" parameter is a
	struct thread_info * now.  Fetch ptid from thread.
	(find_lwp_pid): Update, "entry" parameter is a
	struct thread_info * now.
	(linux_wait_for_lwp): Fetch pid from thread.
	(linux_fast_tracepoint_collecting): Fetch lwpid from thread.
	(maybe_move_out_of_jump_pad): Fetch lwpid from current_inferior.
	(enqueue_one_deferred_signal): Fetch lwpid from thread.
	(dequeue_one_deferred_signal): Ditto.
	(cancel_breakpoint): Fetch ptid from current_inferior.
	(linux_wait_for_event): Pass &all_threads to find_inferior,
	not &all_lwps.  Fetch ptid, lwpid from thread.
	(count_events_callback): Update, "entry" parameter is a
	struct thread_info * now.
	(select_singlestep_lwp_callback): Ditto.
	(select_event_lwp_callback): Ditto.
	(cancel_breakpoints_callback): Ditto.
	(linux_cancel_breakpoints): Pass &all_threads to find_inferior,
	not &all_lwps.
	(select_event_lwp): Ditto.  Fetch ptid from event_thread.
	(unsuspend_one_lwp): Update, "entry" parameter is a
	struct thread_info * now.
	(unsuspend_all_lwps): Pass &all_threads to find_inferior,
	not &all_lwps.
	(linux_stabilize_threads): Ditto.  And for for_each_inferior.
	Fetch lwpid from thread, not lwp.
	(linux_wait_1): Fetch ptid, lwpid from current_inferior.
	Pass &all_threads to find_inferior, not &all_lwps.
	(send_sigstop): Fetch lwpid from thread, not lwp.
	(send_sigstop_callback): Update, "entry" parameter is a
	struct thread_info * now.
	(suspend_and_send_sigstop_callback): Ditto.
	(wait_for_sigstop): Ditto.  Fetch ptid, lwpid from thread, lwp.
	(stuck_in_jump_pad_callback): Update, "entry" parameter is a
	struct thread_info * now.
	(move_out_of_jump_pad_callback): Ditto.  Fetch ptid, lwpid
	from thread, lwp.
	(lwp_running): Update, "entry" parameter is a
	struct thread_info * now.
	(stop_all_lwps): Fetch ptid from thread.
	Pass &all_threads to find_inferior, for_each_inferior, not &all_lwps.
	(linux_resume_one_lwp): Fetch lwpid from thread.
	(linux_set_resume_request): Update, "entry" parameter is a
	struct thread_info * now.  Fetch pid, lwpid from thread.
	(resume_status_pending_p): Update, "entry" parameter is a
	struct thread_info * now.
	(need_step_over_p): Ditto.  Fetch lwpid from thread.
	(start_step_over): Fetch lwpid from thread.
	(linux_resume_one_thread): Update, "entry" parameter is a
	struct thread_info * now.  Fetch lwpid from thread.
	(linux_resume): Pass &all_threads to find_inferior, not &all_lwps.
	(proceed_one_lwp): Update, "entry" parameter is a
	struct thread_info * now.  Fetch lwpid from thread.
	(unsuspend_and_proceed_one_lwp): Update, "entry" parameter is a
	struct thread_info * now.
	(proceed_all_lwps): Pass &all_threads to find_inferior, not &all_lwps.
	(unstop_all_lwps): Ditto.  Fetch lwpid from thread.
	(regsets_fetch_inferior_registers): Fetch lwpid from current_inferior
	directly.
	(regsets_store_inferior_registers): Ditto.
	(fetch_register, store_register): Ditto.
	(linux_read_memory, linux_write_memory): Ditto.
	(linux_request_interrupt): Ditto.
	(linux_read_auxv): Ditto.
	(linux_xfer_siginfo): Ditto.
	(linux_qxfer_spu): Ditto.
	(linux_qxfer_libraries_svr4): Ditto.
	* linux-low.h (ptid_of, pid_of, lwpid_of): Delete,
	moved to inferiors.h.
	(get_lwp): Delete.
	(get_thread_lwp): Update.
	(struct lwp_info): Delete member "entry".  Simplify comment for
	member "thread".
	(all_lwps): Delete.
	* linux-mips-low.c (mips_read_description): Fetch lwpid from
	current_inferior directly.
	(update_watch_registers_callback): Update, "entry" parameter is a
	struct thread_info * now.  Fetch pid from thread.
	(mips_linux_prepare_to_resume): Fetch ptid from thread.
	(mips_insert_point): Fetch lwpid from current_inferior.
	Pass &all_threads to find_inferior, not &all_lwps.
	(mips_remove_point): Pass &all_threads to find_inferior, not &all_lwps.
	(mips_stopped_by_watchpoint): Fetch lwpid from current_inferior
	directly.
	(mips_stopped_data_address): Ditto.
	* linux-s390-low.c (s390_arch_setup): Fetch pid from current_inferior
	directly.
	* linux-tile-low.c (tile_arch_setup): Ditto.
	* linux-x86-low.c (x86_get_thread_area): Fetch lwpid from thread.
	(update_debug_registers_callback): Update, "entry" parameter is a
	struct thread_info * now.  Fetch pid from thread.
	(i386_dr_low_set_addr): Fetch pid from current_inferior directly.
	Pass &all_threads to find_inferior, not &all_lwps.
	(i386_dr_low_get_addr): Fetch ptid from current_inferior directly.
	(i386_dr_low_set_control): Fetch pid from current_inferior directly.
	Pass &all_threads to find_inferior, not &all_lwps.
	(i386_dr_low_get_control): Fetch ptid from current_inferior directly.
	(i386_dr_low_get_status): Ditto.
	(x86_linux_prepare_to_resume): Fetch ptid from thread.
	(x86_siginfo_fixup): Fetch lwpid from current_inferior directly.
	(x86_linux_read_description): Ditto.
	* proc-service.c (ps_getpid): Fetch pid from current_inferior directly.

11 files changed, 459 insertions, 292 deletions

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