* linux-nat.c (linux_nat_wait): Adjust.

	(linux_nat_pid_to_str): Adjust.  Remove call to thread_db_init.
	* linux-nat.h (thread_db_init): Delete declaration.
	* linux-thread-db.c (target_beneath): Delete.
	(thread_db_init): Delete.
	(thread_db_detach): Use find_target_beneath.
	(thread_db_wait): Adjust interface.  Use find_target_beneath.
	(thread_db_mourn_inferior): Use find_target_beneath.
	(thread_db_can_async_p, thread_db_is_async_p, thread_db_async)
	(thread_db_async_mask): Delete.
	(thread_db_pid_to_str): Adjust interface.  Use
	find_target_beneath.
	(thread_db_get_thread_local_address): Adjust interface.  Use
	find_target_beneath.
	(init_thread_db_ops): Delete references to delete functions.
	* target.c (update_current_target): Don't inherit or default
	to_wait.  Don't inherit to_pid_to_str and
	to_get_thread_local_address.
	(target_translate_tls_address): Look for a pushed target that
	implements to_get_thread_local_address, and use it instead of
	checking for target_get_thread_local_address_p.
	(target_wait, target_pid_to_str): Reimplement as functions.
	(dummy_pid_to_str): New.
	(init_dummy_target): Register it.
	(debug_to_wait): Delete.
	* target.h (struct target_ops): Make to_wait, to_pid_to_str and
	to_get_thread_local_address accept a pointer to struct target_ops.
	(target_wait): Delete macro, and declare as function.
	(target_pid_to_str): Likewise.
	(target_get_thread_local_address)
	(target_get_thread_local_address_p): Delete.
	(noprocess): Add NORETURN and ATTR_NORETURN tags.
	* inf-ptrace.c (inf_ptrace_wait): Adjust.
	(inf_ptrace_pid_to_str): New.
	(inf_ptrace_target): Use inf_ptrace_pid_to_str.
	* aix-thread.c (aix_thread_wait, aix_thread_pid_to_str): Adjust.
	* bsd-kvm.c (bsd_kvm_pid_to_str): Adjust.
	* bsd-uthread.c (bsd_uthread_wait, bsd_uthread_pid_to_str):
	Adjust.
	* corelow.c (core_pid_to_str): Adjust.
	* darwin-nat.c (darwin_wait, darwin_pid_to_str): Adjust.
	* dec-thread.c (dec_thread_wait, dec_thread_pid_to_str): Adjust.
	* gnu-nat.c (gnu_wait, gnu_pid_to_str): Adjust.
	* go32-nat.c (go32_wait, go32_pid_to_str): Adjust.
	* hpux-thread.c (hpux_thread_wait): Adjust.
	* inf-ttrace.c (inf_ttrace_wait, inf_ttrace_pid_to_str): Adjust.
	* monitor.c (monitor_wait, monitor_pid_to_str): Adjust.
	* nto-procfs.c (procfs_wait, procfs_pid_to_str): Adjust.
	* procfs.c (procfs_pid_to_str): Adjust.
	* remote-m32r-sdi.c (m32r_wait, m32r_pid_to_str): Adjust.
	* remote-mips.c (mips_wait): Adjust.
	* remote-sim.c (gdbsim_wait, gdbsim_pid_to_str): Adjust.
	* remote.c (remote_wait, remote_pid_to_str)
	(remote_get_thread_local_address): Adjust.
	* rs6000-nat.c (rs6000_wait): Adjust.
	* sol-thread.c (procfs_pid_to_str): Adjust declaration.
	(sol_thread_wait, solaris_pid_to_str): Adjust.
	* spu-linux-nat.c (spu_child_wait): Adjust.
	* windows-nat.c (windows_wait, windows_pid_to_str): Adjust.

28 files changed, 239 insertions, 168 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0f28a82..aab098d 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,65 @@
+2009-02-06  Pedro Alves  <pedro@codesourcery.com>
+
+	* linux-nat.c (linux_nat_wait): Adjust.
+	(linux_nat_pid_to_str): Adjust.  Remove call to thread_db_init.
+	* linux-nat.h (thread_db_init): Delete declaration.
+	* linux-thread-db.c (target_beneath): Delete.
+	(thread_db_init): Delete.
+	(thread_db_detach): Use find_target_beneath.
+	(thread_db_wait): Adjust interface.  Use find_target_beneath.
+	(thread_db_mourn_inferior): Use find_target_beneath.
+	(thread_db_can_async_p, thread_db_is_async_p, thread_db_async)
+	(thread_db_async_mask): Delete.
+	(thread_db_pid_to_str): Adjust interface.  Use
+	find_target_beneath.
+	(thread_db_get_thread_local_address): Adjust interface.  Use
+	find_target_beneath.
+	(init_thread_db_ops): Delete references to delete functions.
+	* target.c (update_current_target): Don't inherit or default
+	to_wait.  Don't inherit to_pid_to_str and
+	to_get_thread_local_address.
+	(target_translate_tls_address): Look for a pushed target that
+	implements to_get_thread_local_address, and use it instead of
+	checking for target_get_thread_local_address_p.
+	(target_wait, target_pid_to_str): Reimplement as functions.
+	(dummy_pid_to_str): New.
+	(init_dummy_target): Register it.
+	(debug_to_wait): Delete.
+	* target.h (struct target_ops): Make to_wait, to_pid_to_str and
+	to_get_thread_local_address accept a pointer to struct target_ops.
+	(target_wait): Delete macro, and declare as function.
+	(target_pid_to_str): Likewise.
+	(target_get_thread_local_address)
+	(target_get_thread_local_address_p): Delete.
+	(noprocess): Add NORETURN and ATTR_NORETURN tags.
+	* inf-ptrace.c (inf_ptrace_wait): Adjust.
+	(inf_ptrace_pid_to_str): New.
+	(inf_ptrace_target): Use inf_ptrace_pid_to_str.
+	* aix-thread.c (aix_thread_wait, aix_thread_pid_to_str): Adjust.
+	* bsd-kvm.c (bsd_kvm_pid_to_str): Adjust.
+	* bsd-uthread.c (bsd_uthread_wait, bsd_uthread_pid_to_str):
+	Adjust.
+	* corelow.c (core_pid_to_str): Adjust.
+	* darwin-nat.c (darwin_wait, darwin_pid_to_str): Adjust.
+	* dec-thread.c (dec_thread_wait, dec_thread_pid_to_str): Adjust.
+	* gnu-nat.c (gnu_wait, gnu_pid_to_str): Adjust.
+	* go32-nat.c (go32_wait, go32_pid_to_str): Adjust.
+	* hpux-thread.c (hpux_thread_wait): Adjust.
+	* inf-ttrace.c (inf_ttrace_wait, inf_ttrace_pid_to_str): Adjust.
+	* monitor.c (monitor_wait, monitor_pid_to_str): Adjust.
+	* nto-procfs.c (procfs_wait, procfs_pid_to_str): Adjust.
+	* procfs.c (procfs_pid_to_str): Adjust.
+	* remote-m32r-sdi.c (m32r_wait, m32r_pid_to_str): Adjust.
+	* remote-mips.c (mips_wait): Adjust.
+	* remote-sim.c (gdbsim_wait, gdbsim_pid_to_str): Adjust.
+	* remote.c (remote_wait, remote_pid_to_str)
+	(remote_get_thread_local_address): Adjust.
+	* rs6000-nat.c (rs6000_wait): Adjust.
+	* sol-thread.c (procfs_pid_to_str): Adjust declaration.
+	(sol_thread_wait, solaris_pid_to_str): Adjust.
+	* spu-linux-nat.c (spu_child_wait): Adjust.
+	* windows-nat.c (windows_wait, windows_pid_to_str): Adjust.
+
 2009-02-06  Tom Tromey  <tromey@redhat.com>
 
 	* Makefile.in (SUBDIR_PYTHON_OBS): Add python-cmd.o.
diff --git a/gdb/aix-thread.c b/gdb/aix-thread.c
index 04570c6..051de07 100644
--- a/gdb/aix-thread.c
+++ b/gdb/aix-thread.c
@@ -997,14 +997,15 @@ aix_thread_resume (ptid_t ptid, int step, enum target_signal sig)
    thread.  */
 
 static ptid_t
-aix_thread_wait (ptid_t ptid, struct target_waitstatus *status)
+aix_thread_wait (struct target_ops *ops,
+		 ptid_t ptid, struct target_waitstatus *status)
 {
   struct cleanup *cleanup = save_inferior_ptid ();
 
   pid_to_prc (&ptid);
 
   inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid));
-  ptid = base_target.to_wait (ptid, status);
+  ptid = base_target.to_wait (&base_target, ptid, status);
   do_cleanups (cleanup);
 
   if (PIDGET (ptid) == -1)
@@ -1691,12 +1692,12 @@ aix_thread_thread_alive (ptid_t ptid)
    "info threads" output.  */
 
 static char *
-aix_thread_pid_to_str (ptid_t ptid)
+aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char *ret = NULL;
 
   if (!PD_TID (ptid))
-    return base_target.to_pid_to_str (ptid);
+    return base_target.to_pid_to_str (&base_target, ptid);
 
   /* Free previous return value; a new one will be allocated by
      xstrprintf().  */
diff --git a/gdb/bsd-kvm.c b/gdb/bsd-kvm.c
index 46d6b6b..84ca680 100644
--- a/gdb/bsd-kvm.c
+++ b/gdb/bsd-kvm.c
@@ -316,7 +316,7 @@ bsd_kvm_thread_alive (ptid_t ptid)
 }
 
 static char *
-bsd_kvm_pid_to_str (ptid_t ptid)
+bsd_kvm_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
   xsnprintf (buf, sizeof buf, "<kvm>");
diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index 24b2e2e..ecbad76 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -340,12 +340,14 @@ bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
 }
 
 static ptid_t
-bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
+bsd_uthread_wait (struct target_ops *ops,
+		  ptid_t ptid, struct target_waitstatus *status)
 {
   CORE_ADDR addr;
+  struct target_ops *beneath = find_target_beneath (bsd_uthread_ops_hack);
 
   /* Pass the request to the layer beneath.  */
-  ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
+  ptid = beneath->to_wait (beneath, ptid, status);
 
   /* If the process is no longer alive, there's no point in figuring
      out the thread ID.  It will fail anyway.  */
@@ -487,7 +489,7 @@ bsd_uthread_extra_thread_info (struct thread_info *info)
 }
 
 static char *
-bsd_uthread_pid_to_str (ptid_t ptid)
+bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   if (ptid_get_tid (ptid) != 0)
     {
diff --git a/gdb/corelow.c b/gdb/corelow.c
index d814831..2d159b4 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -680,7 +680,7 @@ core_read_description (struct target_ops *target)
 }
 
 static char *
-core_pid_to_str (ptid_t ptid)
+core_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
 
diff --git a/gdb/darwin-nat.c b/gdb/darwin-nat.c
index eac05ba..340ef35 100644
--- a/gdb/darwin-nat.c
+++ b/gdb/darwin-nat.c
@@ -89,8 +89,6 @@ static void darwin_stop (ptid_t);
 static void darwin_resume (ptid_t ptid, int step,
 			   enum target_signal signal);
 
-static ptid_t darwin_wait (ptid_t ptid, struct target_waitstatus *status);
-
 static void darwin_mourn_inferior (struct target_ops *ops);
 
 static int darwin_lookup_task (char *args, task_t * ptask, int *ppid);
@@ -106,8 +104,6 @@ static void darwin_create_inferior (struct target_ops *ops, char *exec_file,
 
 static void darwin_files_info (struct target_ops *ops);
 
-static char *darwin_pid_to_str (ptid_t tpid);
-
 static int darwin_thread_alive (ptid_t tpid);
 
 /* Current inferior.  */
@@ -483,7 +479,8 @@ catch_exception_raise (mach_port_t port,
 }
 
 static ptid_t
-darwin_wait (ptid_t ptid, struct target_waitstatus *status)
+darwin_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *status)
 {
   kern_return_t kret;
   mach_msg_header_t *hdr = &msgin.hdr;
@@ -1049,7 +1046,7 @@ darwin_files_info (struct target_ops *ops)
 }
 
 static char *
-darwin_pid_to_str (ptid_t ptid)
+darwin_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[128];
 
diff --git a/gdb/dec-thread.c b/gdb/dec-thread.c
index 02eb56d..8398e8d 100644
--- a/gdb/dec-thread.c
+++ b/gdb/dec-thread.c
@@ -453,13 +453,14 @@ get_active_ptid (void)
 /* The "to_wait" method of the dec_thread_ops.  */
 
 static ptid_t
-dec_thread_wait (ptid_t ptid, struct target_waitstatus *status)
+dec_thread_wait (struct target_ops *ops,
+		 ptid_t ptid, struct target_waitstatus *status)
 {
   ptid_t active_ptid;
 
   debug ("dec_thread_wait");
 
-  ptid = base_target.to_wait (ptid, status);
+  ptid = base_target.to_wait (&base_target, ptid, status);
 
   /* The ptid returned by the base_target is the ptid of the process.
      We need to find which thread is currently active and return its
@@ -622,12 +623,12 @@ dec_thread_thread_alive (ptid_t ptid)
 /* The "to_pid_to_str" method of the dec_thread_ops.  */
 
 static char *
-dec_thread_pid_to_str (ptid_t ptid)
+dec_thread_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char *ret = NULL;
 
   if (ptid_get_tid (ptid) == 0)
-    return base_target.to_pid_to_str (ptid);
+    return base_target.to_pid_to_str (&base_target, ptid);
 
   /* Free previous return value; a new one will be allocated by
      xstrprintf().  */
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index 08971cf..af04047 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1433,7 +1433,8 @@ struct inf *waiting_inf;
 
 /* Wait for something to happen in the inferior, returning what in STATUS. */
 static ptid_t
-gnu_wait (ptid_t ptid, struct target_waitstatus *status)
+gnu_wait (struct target_ops *ops,
+	  ptid_t ptid, struct target_waitstatus *status)
 {
   struct msg
     {
@@ -2594,7 +2595,7 @@ proc_string (struct proc *proc)
 }
 
 static char *
-gnu_pid_to_str (ptid_t ptid)
+gnu_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   struct inf *inf = gnu_current_inf;
   int tid = ptid_get_tid (ptid);
diff --git a/gdb/go32-nat.c b/gdb/go32-nat.c
index 230c7b7..be0de4a 100644
--- a/gdb/go32-nat.c
+++ b/gdb/go32-nat.c
@@ -171,8 +171,6 @@ static void go32_attach (char *args, int from_tty);
 static void go32_detach (char *args, int from_tty);
 static void go32_resume (ptid_t ptid, int step,
                          enum target_signal siggnal);
-static ptid_t go32_wait (ptid_t ptid,
-                               struct target_waitstatus *status);
 static void go32_fetch_registers (struct regcache *, int regno);
 static void store_register (const struct regcache *, int regno);
 static void go32_store_registers (struct regcache *, int regno);
@@ -347,7 +345,8 @@ go32_resume (ptid_t ptid, int step, enum target_signal siggnal)
 static char child_cwd[FILENAME_MAX];
 
 static ptid_t
-go32_wait (ptid_t ptid, struct target_waitstatus *status)
+go32_wait (struct target_ops *ops,
+	   ptid_t ptid, struct target_waitstatus *status)
 {
   int i;
   unsigned char saved_opcode;
@@ -866,7 +865,7 @@ go32_thread_alive (ptid_t ptid)
 }
 
 static char *
-go32_pid_to_str (ptid_t ptid)
+go32_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
   xsnprintf (buf, sizeof buf, "Thread <main>");
diff --git a/gdb/hpux-thread.c b/gdb/hpux-thread.c
index 9184bf1..1c2daa0 100644
--- a/gdb/hpux-thread.c
+++ b/gdb/hpux-thread.c
@@ -191,7 +191,8 @@ hpux_thread_resume (ptid_t ptid, int step, enum target_signal signo)
    to a LWP id, and vice versa on the way out.  */
 
 static ptid_t
-hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+hpux_thread_wait (struct target_ops *ops,
+		  ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   ptid_t rtnval;
   struct cleanup *old_chain;
@@ -203,7 +204,8 @@ hpux_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
   if (!ptid_equal (ptid, minus_one_ptid))
     ptid = main_ptid;
 
-  rtnval = deprecated_child_ops.to_wait (ptid, ourstatus);
+  rtnval = deprecated_child_ops.to_wait (&deprecated_child_ops,
+					 ptid, ourstatus);
 
   rtnval = find_active_thread ();
 
diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c
index 76cbecc..0679200 100644
--- a/gdb/inf-ptrace.c
+++ b/gdb/inf-ptrace.c
@@ -385,7 +385,8 @@ inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal)
    the status in *OURSTATUS.  */
 
 static ptid_t
-inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+inf_ptrace_wait (struct target_ops *ops,
+		 ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   pid_t pid;
   int status, save_errno;
@@ -615,6 +616,12 @@ inf_ptrace_files_info (struct target_ops *ignore)
 		   target_pid_to_str (inferior_ptid));
 }
 
+static char *
+inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+  return normal_pid_to_str (ptid);
+}
+
 /* Create a prototype ptrace target.  The client can override it with
    local methods.  */
 
@@ -637,7 +644,7 @@ inf_ptrace_target (void)
 #endif
   t->to_mourn_inferior = inf_ptrace_mourn_inferior;
   t->to_thread_alive = inf_ptrace_thread_alive;
-  t->to_pid_to_str = normal_pid_to_str;
+  t->to_pid_to_str = inf_ptrace_pid_to_str;
   t->to_stop = inf_ptrace_stop;
   t->to_xfer_partial = inf_ptrace_xfer_partial;
 
diff --git a/gdb/inf-ttrace.c b/gdb/inf-ttrace.c
index 5255828..f128440 100644
--- a/gdb/inf-ttrace.c
+++ b/gdb/inf-ttrace.c
@@ -915,7 +915,8 @@ inf_ttrace_resume (ptid_t ptid, int step, enum target_signal signal)
 }
 
 static ptid_t
-inf_ttrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+inf_ttrace_wait (struct target_ops *ops,
+		 ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   pid_t pid = ptid_get_pid (ptid);
   lwpid_t lwpid = ptid_get_lwp (ptid);
@@ -1252,7 +1253,7 @@ inf_ttrace_extra_thread_info (struct thread_info *info)
 }
 
 static char *
-inf_ttrace_pid_to_str (ptid_t ptid)
+inf_ttrace_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   pid_t pid = ptid_get_pid (ptid);
   lwpid_t lwpid = ptid_get_lwp (ptid);
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 20f1ea5..33b05fa 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -2776,7 +2776,8 @@ local_event_queue_to_pipe (void)
 }
 
 static ptid_t
-linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+linux_nat_wait (struct target_ops *ops,
+		ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   struct lwp_info *lp = NULL;
   int options = 0;
@@ -3266,7 +3267,7 @@ linux_nat_thread_alive (ptid_t ptid)
 }
 
 static char *
-linux_nat_pid_to_str (ptid_t ptid)
+linux_nat_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
 
@@ -4659,10 +4660,6 @@ linux_nat_add_target (struct target_ops *t)
      also want to be used for single-threaded processes.  */
 
   add_target (t);
-
-  /* TODO: Eliminate this and have libthread_db use
-     find_target_beneath.  */
-  thread_db_init (t);
 }
 
 /* Register a method to call whenever a new thread is attached.  */
diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h
index 13a1088..0985e84 100644
--- a/gdb/linux-nat.h
+++ b/gdb/linux-nat.h
@@ -94,9 +94,6 @@ extern struct lwp_info *lwp_list;
 /* Attempt to initialize libthread_db.  */
 void check_for_thread_db (void);
 
-/* Tell the thread_db layer what native target operations to use.  */
-void thread_db_init (struct target_ops *);
-
 int thread_db_attach_lwp (ptid_t ptid);
 
 /* Find process PID's pending signal set from /proc/pid/status.  */
diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index eced854..d3371d0 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -80,9 +80,6 @@
 /* This module's target vector.  */
 static struct target_ops thread_db_ops;
 
-/* The target vector that we call for things this module can't handle.  */
-static struct target_ops *target_beneath;
-
 /* Non-zero if we're using this module's target vector.  */
 static int using_thread_db;
 
@@ -379,12 +376,6 @@ thread_db_attach_lwp (ptid_t ptid)
   return 1;
 }
 
-void
-thread_db_init (struct target_ops *target)
-{
-  target_beneath = target;
-}
-
 static void *
 verbose_dlsym (void *handle, const char *name)
 {
@@ -782,6 +773,8 @@ detach_thread (ptid_t ptid)
 static void
 thread_db_detach (struct target_ops *ops, char *args, int from_tty)
 {
+  struct target_ops *target_beneath = find_target_beneath (ops);
+
   disable_thread_event_reporting ();
 
   /* Forget about the child's process ID.  We shouldn't need it
@@ -885,9 +878,12 @@ check_event (ptid_t ptid)
 }
 
 static ptid_t
-thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+thread_db_wait (struct target_ops *ops,
+		ptid_t ptid, struct target_waitstatus *ourstatus)
 {
-  ptid = target_beneath->to_wait (ptid, ourstatus);
+  struct target_ops *beneath = find_target_beneath (ops);
+
+  ptid = beneath->to_wait (beneath, ptid, ourstatus);
 
   if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
     return ptid;
@@ -934,6 +930,8 @@ thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 static void
 thread_db_mourn_inferior (struct target_ops *ops)
 {
+  struct target_ops *target_beneath = find_target_beneath (ops);
+
   /* Forget about the child's process ID.  We shouldn't need it
      anymore.  */
   proc_handle.pid = 0;
@@ -950,31 +948,6 @@ thread_db_mourn_inferior (struct target_ops *ops)
 }
 
 static int
-thread_db_can_async_p (void)
-{
-  return target_beneath->to_can_async_p ();
-}
-
-static int
-thread_db_is_async_p (void)
-{
-  return target_beneath->to_is_async_p ();
-}
-
-static void
-thread_db_async (void (*callback) (enum inferior_event_type event_type,
-				   void *context), void *context)
-{
-  return target_beneath->to_async (callback, context);
-}
-
-static int
-thread_db_async_mask (int mask)
-{
-  return target_beneath->to_async_mask (mask);
-}
-
-static int
 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 {
   td_thrinfo_t ti;
@@ -1045,9 +1018,10 @@ thread_db_find_new_threads (void)
 }
 
 static char *
-thread_db_pid_to_str (ptid_t ptid)
+thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   struct thread_info *thread_info = find_thread_pid (ptid);
+  struct target_ops *beneath;
 
   if (thread_info != NULL && thread_info->private != NULL)
     {
@@ -1062,8 +1036,9 @@ thread_db_pid_to_str (ptid_t ptid)
       return buf;
     }
 
-  if (target_beneath->to_pid_to_str (ptid))
-    return target_beneath->to_pid_to_str (ptid);
+  beneath = find_target_beneath (ops);
+  if (beneath->to_pid_to_str (beneath, ptid))
+    return beneath->to_pid_to_str (beneath, ptid);
 
   return normal_pid_to_str (ptid);
 }
@@ -1087,11 +1062,13 @@ thread_db_extra_thread_info (struct thread_info *info)
    is stored at OFFSET within the thread local storage for thread PTID.  */
 
 static CORE_ADDR
-thread_db_get_thread_local_address (ptid_t ptid,
+thread_db_get_thread_local_address (struct target_ops *ops,
+				    ptid_t ptid,
 				    CORE_ADDR lm,
 				    CORE_ADDR offset)
 {
   struct thread_info *thread_info;
+  struct target_ops *beneath;
 
   /* If we have not discovered any threads yet, check now.  */
   if (!have_threads ())
@@ -1141,8 +1118,9 @@ thread_db_get_thread_local_address (ptid_t ptid,
 	      : (CORE_ADDR) (uintptr_t) address);
     }
 
-  if (target_beneath->to_get_thread_local_address)
-    return target_beneath->to_get_thread_local_address (ptid, lm, offset);
+  beneath = find_target_beneath (ops);
+  if (beneath->to_get_thread_local_address)
+    return beneath->to_get_thread_local_address (beneath, ptid, lm, offset);
   else
     throw_error (TLS_GENERIC_ERROR,
 	         _("TLS not supported on this target"));
@@ -1193,10 +1171,6 @@ init_thread_db_ops (void)
   thread_db_ops.to_get_thread_local_address
     = thread_db_get_thread_local_address;
   thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
-  thread_db_ops.to_can_async_p = thread_db_can_async_p;
-  thread_db_ops.to_is_async_p = thread_db_is_async_p;
-  thread_db_ops.to_async = thread_db_async;
-  thread_db_ops.to_async_mask = thread_db_async_mask;
   thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid;
   thread_db_ops.to_magic = OPS_MAGIC;
 }
diff --git a/gdb/monitor.c b/gdb/monitor.c
index 2812e43..9a38dbc 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -1063,7 +1063,8 @@ monitor_wait_filter (char *buf,
    status just as `wait' would.  */
 
 static ptid_t
-monitor_wait (ptid_t ptid, struct target_waitstatus *status)
+monitor_wait (struct target_ops *ops,
+	      ptid_t ptid, struct target_waitstatus *status)
 {
   int old_timeout = timeout;
   char buf[TARGET_BUF_SIZE];
@@ -2244,7 +2245,7 @@ monitor_thread_alive (ptid_t ptid)
    buffer.  */
 
 static char *
-monitor_pid_to_str (ptid_t ptid)
+monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
 
diff --git a/gdb/nto-procfs.c b/gdb/nto-procfs.c
index 40fbee0..b8bfcbe 100644
--- a/gdb/nto-procfs.c
+++ b/gdb/nto-procfs.c
@@ -59,8 +59,6 @@ static void procfs_open (char *, int);
 
 static int procfs_can_run (void);
 
-static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);
-
 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
 			       struct mem_attrib *attrib,
 			       struct target_ops *);
@@ -626,7 +624,8 @@ nto_interrupt (int signo)
 }
 
 static ptid_t
-procfs_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+procfs_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   sigset_t set;
   siginfo_t info;
@@ -1265,7 +1264,7 @@ procfs_thread_info (pid_t pid, short tid)
 }
 
 char *
-procfs_pid_to_str (ptid_t ptid)
+procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[1024];
   int pid, tid, n;
diff --git a/gdb/procfs.c b/gdb/procfs.c
index 4587fdd..bc49ffe 100644
--- a/gdb/procfs.c
+++ b/gdb/procfs.c
@@ -126,7 +126,8 @@ static void procfs_kill_inferior (void);
 static void procfs_mourn_inferior (struct target_ops *ops);
 static void procfs_create_inferior (struct target_ops *, char *, 
 				    char *, char **, int);
-static ptid_t procfs_wait (ptid_t, struct target_waitstatus *);
+static ptid_t procfs_wait (struct target_ops *,
+			   ptid_t, struct target_waitstatus *);
 static int procfs_xfer_memory (CORE_ADDR, gdb_byte *, int, int,
 			       struct mem_attrib *attrib,
 			       struct target_ops *);
@@ -139,7 +140,7 @@ static LONGEST procfs_xfer_partial (struct target_ops *ops,
 static int procfs_thread_alive (ptid_t);
 
 void procfs_find_new_threads (void);
-char *procfs_pid_to_str (ptid_t);
+char *procfs_pid_to_str (struct target_ops *, ptid_t);
 
 static int proc_find_memory_regions (int (*) (CORE_ADDR,
 					      unsigned long,
@@ -3969,7 +3970,8 @@ syscall_is_lwp_create (procinfo *pi, int scall)
  */
 
 static ptid_t
-procfs_wait (ptid_t ptid, struct target_waitstatus *status)
+procfs_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *status)
 {
   /* First cut: loosely based on original version 2.1 */
   procinfo *pi;
@@ -5270,7 +5272,7 @@ procfs_thread_alive (ptid_t ptid)
 /* Convert PTID to a string.  Returns the string in a static buffer.  */
 
 char *
-procfs_pid_to_str (ptid_t ptid)
+procfs_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[80];
 
diff --git a/gdb/remote-m32r-sdi.c b/gdb/remote-m32r-sdi.c
index ab97cbb..357b330 100644
--- a/gdb/remote-m32r-sdi.c
+++ b/gdb/remote-m32r-sdi.c
@@ -693,7 +693,8 @@ gdb_cntrl_c (int signo)
 }
 
 static ptid_t
-m32r_wait (ptid_t ptid, struct target_waitstatus *status)
+m32r_wait (struct target_ops *ops,
+	   ptid_t ptid, struct target_waitstatus *status)
 {
   static RETSIGTYPE (*prev_sigint) ();
   unsigned long bp_addr, pc_addr;
@@ -1507,7 +1508,7 @@ m32r_thread_alive (ptid_t ptid)
    buffer.  */
 
 static char *
-m32r_pid_to_str (ptid_t ptid)
+m32r_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
 
diff --git a/gdb/remote-mips.c b/gdb/remote-mips.c
index 5c174ed..26cda1a 100644
--- a/gdb/remote-mips.c
+++ b/gdb/remote-mips.c
@@ -89,9 +89,6 @@ static void mips_detach (struct target_ops *ops, char *args, int from_tty);
 static void mips_resume (ptid_t ptid, int step,
                          enum target_signal siggnal);
 
-static ptid_t mips_wait (ptid_t ptid,
-                               struct target_waitstatus *status);
-
 static int mips_map_regno (struct gdbarch *, int);
 
 static void mips_fetch_registers (struct regcache *regcache, int regno);
@@ -1703,7 +1700,8 @@ mips_signal_from_protocol (int sig)
 /* Wait until the remote stops, and return a wait status.  */
 
 static ptid_t
-mips_wait (ptid_t ptid, struct target_waitstatus *status)
+mips_wait (struct target_ops *ops,
+	   ptid_t ptid, struct target_waitstatus *status)
 {
   int rstatus;
   int err;
diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index 5b9d2d3..3ad87fa 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -88,8 +88,6 @@ static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
 
 static void gdbsim_resume (ptid_t ptid, int step, enum target_signal siggnal);
 
-static ptid_t gdbsim_wait (ptid_t ptid, struct target_waitstatus *status);
-
 static void gdbsim_prepare_to_store (struct regcache *regcache);
 
 static void gdbsim_files_info (struct target_ops *target);
@@ -680,7 +678,8 @@ gdbsim_cntrl_c (int signo)
 }
 
 static ptid_t
-gdbsim_wait (ptid_t ptid, struct target_waitstatus *status)
+gdbsim_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *status)
 {
   static RETSIGTYPE (*prev_sigint) ();
   int sigrc = 0;
@@ -874,7 +873,7 @@ gdbsim_thread_alive (ptid_t ptid)
    buffer.  */
 
 static char *
-gdbsim_pid_to_str (ptid_t ptid)
+gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
 
diff --git a/gdb/remote.c b/gdb/remote.c
index 8cb37fa..aeeb8b8 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -117,9 +117,6 @@ static void remote_send (char **buf, long *sizeof_buf_p);
 
 static int readchar (int timeout);
 
-static ptid_t remote_wait (ptid_t ptid,
-			   struct target_waitstatus *status);
-
 static void remote_kill (void);
 
 static int tohex (int nib);
@@ -4733,7 +4730,8 @@ remote_wait_as (ptid_t ptid, struct target_waitstatus *status)
    STATUS just as `wait' would.  */
 
 static ptid_t
-remote_wait (ptid_t ptid, struct target_waitstatus *status)
+remote_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *status)
 {
   ptid_t event_ptid;
 
@@ -7769,7 +7767,7 @@ Fetch and print the remote list of thread identifiers, one pkt only"));
    buffer.  */
 
 static char *
-remote_pid_to_str (ptid_t ptid)
+remote_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[64];
   struct remote_state *rs = get_remote_state ();
@@ -7800,7 +7798,8 @@ remote_pid_to_str (ptid_t ptid)
    stored at OFFSET within the thread local storage for thread PTID.  */
 
 static CORE_ADDR
-remote_get_thread_local_address (ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
+remote_get_thread_local_address (struct target_ops *ops,
+				 ptid_t ptid, CORE_ADDR lm, CORE_ADDR offset)
 {
   if (remote_protocol_packets[PACKET_qGetTLSAddr].support != PACKET_DISABLE)
     {
diff --git a/gdb/rs6000-nat.c b/gdb/rs6000-nat.c
index c8279dd..6aaeba9 100644
--- a/gdb/rs6000-nat.c
+++ b/gdb/rs6000-nat.c
@@ -517,7 +517,8 @@ rs6000_xfer_partial (struct target_ops *ops, enum target_object object,
    the status in *OURSTATUS.  */
 
 static ptid_t
-rs6000_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+rs6000_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   pid_t pid;
   int status, save_errno;
diff --git a/gdb/sol-thread.c b/gdb/sol-thread.c
index 3ce5a56..ade49f0 100644
--- a/gdb/sol-thread.c
+++ b/gdb/sol-thread.c
@@ -80,7 +80,7 @@ struct target_ops sol_core_ops;
 extern int procfs_suppress_run;
 extern struct target_ops procfs_ops;	/* target vector for procfs.c */
 extern struct target_ops core_ops;	/* target vector for corelow.c */
-extern char *procfs_pid_to_str (ptid_t ptid);
+extern char *procfs_pid_to_str (struct target_ops *ops, ptid_t ptid);
 
 /* Prototypes for supply_gregset etc. */
 #include "gregset.h"
@@ -424,7 +424,8 @@ sol_thread_resume (ptid_t ptid, int step, enum target_signal signo)
    thread ID to an LWP ID, and vice versa on the way out.  */
 
 static ptid_t
-sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+sol_thread_wait (struct target_ops *ops,
+		 ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   ptid_t rtnval;
   ptid_t save_ptid;
@@ -449,7 +450,7 @@ sol_thread_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 		 GET_THREAD (save_ptid));
     }
 
-  rtnval = procfs_ops.to_wait (ptid, ourstatus);
+  rtnval = procfs_ops.to_wait (&procfs_ops, ptid, ourstatus);
 
   if (ourstatus->kind != TARGET_WAITKIND_EXITED)
     {
@@ -1323,13 +1324,13 @@ ps_lgetLDT (gdb_ps_prochandle_t ph, lwpid_t lwpid,
 /* Convert PTID to printable form.  */
 
 char *
-solaris_pid_to_str (ptid_t ptid)
+solaris_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[100];
 
   /* In case init failed to resolve the libthread_db library.  */
   if (!procfs_suppress_run)
-    return procfs_pid_to_str (ptid);
+    return procfs_pid_to_str (&procfs_ops, ptid);
 
   if (is_thread (ptid))
     {
diff --git a/gdb/spu-linux-nat.c b/gdb/spu-linux-nat.c
index 0786083..8f903fe 100644
--- a/gdb/spu-linux-nat.c
+++ b/gdb/spu-linux-nat.c
@@ -404,7 +404,8 @@ spu_child_post_attach (int pid)
 /* Wait for child PTID to do something.  Return id of the child,
    minus_one_ptid in case of error; store status into *OURSTATUS.  */
 static ptid_t
-spu_child_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+spu_child_wait (struct target_ops *ops,
+		ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   int save_errno;
   int status;
diff --git a/gdb/target.c b/gdb/target.c
index 1752ddc..937b26a 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -99,8 +99,6 @@ static void debug_to_open (char *, int);
 
 static void debug_to_resume (ptid_t, int, enum target_signal);
 
-static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
-
 static void debug_to_fetch_registers (struct regcache *, int);
 
 static void debug_to_store_registers (struct regcache *, int);
@@ -415,7 +413,7 @@ update_current_target (void)
       /* Do not inherit to_detach.  */
       /* Do not inherit to_disconnect.  */
       INHERIT (to_resume, t);
-      INHERIT (to_wait, t);
+      /* Do not inherit to_wait.  */
       INHERIT (to_fetch_registers, t);
       INHERIT (to_store_registers, t);
       INHERIT (to_prepare_to_store, t);
@@ -454,12 +452,12 @@ update_current_target (void)
       INHERIT (to_insert_exec_catchpoint, t);
       INHERIT (to_remove_exec_catchpoint, t);
       INHERIT (to_has_exited, t);
-      /* Do no inherit to_mourn_inferiour.  */
+      /* Do not inherit to_mourn_inferiour.  */
       INHERIT (to_can_run, t);
       INHERIT (to_notice_signals, t);
       INHERIT (to_thread_alive, t);
       INHERIT (to_find_new_threads, t);
-      INHERIT (to_pid_to_str, t);
+      /* Do not inherit to_pid_to_str.  */
       INHERIT (to_extra_thread_info, t);
       INHERIT (to_stop, t);
       /* Do not inherit to_xfer_partial.  */
@@ -481,7 +479,7 @@ update_current_target (void)
       INHERIT (to_async_mask, t);
       INHERIT (to_find_memory_regions, t);
       INHERIT (to_make_corefile_notes, t);
-      INHERIT (to_get_thread_local_address, t);
+      /* Do not inherit to_get_thread_local_address.  */
       INHERIT (to_can_execute_reverse, t);
       /* Do not inherit to_read_description.  */
       INHERIT (to_get_ada_task_ptid, t);
@@ -514,9 +512,6 @@ update_current_target (void)
   de_fault (to_resume,
 	    (void (*) (ptid_t, int, enum target_signal))
 	    noprocess);
-  de_fault (to_wait,
-	    (ptid_t (*) (ptid_t, struct target_waitstatus *))
-	    noprocess);
   de_fault (to_fetch_registers,
 	    (void (*) (struct regcache *, int))
 	    target_ignore);
@@ -853,8 +848,17 @@ CORE_ADDR
 target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
 {
   volatile CORE_ADDR addr = 0;
+  struct target_ops *target;
+
+  for (target = current_target.beneath;
+       target != NULL;
+       target = target->beneath)
+    {
+      if (target->to_get_thread_local_address != NULL)
+	break;
+    }
 
-  if (target_get_thread_local_address_p ()
+  if (target != NULL
       && gdbarch_fetch_tls_load_module_address_p (target_gdbarch))
     {
       ptid_t ptid = inferior_ptid;
@@ -872,7 +876,7 @@ target_translate_tls_address (struct objfile *objfile, CORE_ADDR offset)
 	    throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
 			 _("TLS load module not found"));
 
-	  addr = target_get_thread_local_address (ptid, lm_addr, offset);
+	  addr = target->to_get_thread_local_address (target, ptid, lm_addr, offset);
 	}
       /* If an error occurred, print TLS related messages here.  Otherwise,
          throw the error to some higher catcher.  */
@@ -1841,6 +1845,50 @@ target_disconnect (char *args, int from_tty)
   tcomplain ();
 }
 
+ptid_t
+target_wait (ptid_t ptid, struct target_waitstatus *status)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    {
+      if (t->to_wait != NULL)
+	{
+	  ptid_t retval = (*t->to_wait) (t, ptid, status);
+
+	  if (targetdebug)
+	    {
+	      char *status_string;
+
+	      status_string = target_waitstatus_to_string (status);
+	      fprintf_unfiltered (gdb_stdlog,
+				  "target_wait (%d, status) = %d,   %s\n",
+				  PIDGET (ptid), PIDGET (retval),
+				  status_string);
+	      xfree (status_string);
+	    }
+
+	  return retval;
+	}
+    }
+
+  noprocess ();
+}
+
+char *
+target_pid_to_str (ptid_t ptid)
+{
+  struct target_ops *t;
+
+  for (t = current_target.beneath; t != NULL; t = t->beneath)
+    {
+      if (t->to_pid_to_str != NULL)
+	return (*t->to_pid_to_str) (t, ptid);
+    }
+
+  return normal_pid_to_str (ptid);
+}
+
 void
 target_resume (ptid_t ptid, int step, enum target_signal signal)
 {
@@ -2475,6 +2523,12 @@ normal_pid_to_str (ptid_t ptid)
   return buf;
 }
 
+char *
+dummy_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+  return normal_pid_to_str (ptid);
+}
+
 /* Error-catcher for target_find_memory_regions */
 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
 {
@@ -2505,7 +2559,7 @@ init_dummy_target (void)
   dummy_target.to_can_async_p = find_default_can_async_p;
   dummy_target.to_is_async_p = find_default_is_async_p;
   dummy_target.to_supports_non_stop = find_default_supports_non_stop;
-  dummy_target.to_pid_to_str = normal_pid_to_str;
+  dummy_target.to_pid_to_str = dummy_pid_to_str;
   dummy_target.to_stratum = dummy_stratum;
   dummy_target.to_find_memory_regions = dummy_find_memory_regions;
   dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
@@ -2613,25 +2667,6 @@ target_waitstatus_to_string (const struct target_waitstatus *ws)
     }
 }
 
-static ptid_t
-debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
-{
-  ptid_t retval;
-  char *status_string;
-
-  retval = debug_target.to_wait (ptid, status);
-
-  fprintf_unfiltered (gdb_stdlog,
-		      "target_wait (%d, status) = %d,   ", PIDGET (ptid),
-		      PIDGET (retval));
-
-  status_string = target_waitstatus_to_string (status);
-  fprintf_unfiltered (gdb_stdlog, "%s\n", status_string);
-  xfree (status_string);
-
-  return retval;
-}
-
 static void
 debug_print_register (const char * func,
 		      struct regcache *regcache, int regno)
@@ -3148,7 +3183,6 @@ setup_target_debug (void)
   current_target.to_open = debug_to_open;
   current_target.to_post_attach = debug_to_post_attach;
   current_target.to_resume = debug_to_resume;
-  current_target.to_wait = debug_to_wait;
   current_target.to_fetch_registers = debug_to_fetch_registers;
   current_target.to_store_registers = debug_to_store_registers;
   current_target.to_prepare_to_store = debug_to_prepare_to_store;
diff --git a/gdb/target.h b/gdb/target.h
index 8e0f6c5..cb70646 100644
--- a/gdb/target.h
+++ b/gdb/target.h
@@ -330,7 +330,8 @@ struct target_ops
     void (*to_detach) (struct target_ops *ops, char *, int);
     void (*to_disconnect) (struct target_ops *, char *, int);
     void (*to_resume) (ptid_t, int, enum target_signal);
-    ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
+    ptid_t (*to_wait) (struct target_ops *,
+		      ptid_t, struct target_waitstatus *);
     void (*to_fetch_registers) (struct regcache *, int);
     void (*to_store_registers) (struct regcache *, int);
     void (*to_prepare_to_store) (struct regcache *);
@@ -402,7 +403,7 @@ struct target_ops
     void (*to_notice_signals) (ptid_t ptid);
     int (*to_thread_alive) (ptid_t ptid);
     void (*to_find_new_threads) (void);
-    char *(*to_pid_to_str) (ptid_t);
+    char *(*to_pid_to_str) (struct target_ops *, ptid_t);
     char *(*to_extra_thread_info) (struct thread_info *);
     void (*to_stop) (ptid_t);
     void (*to_rcmd) (char *command, struct ui_file *output);
@@ -438,7 +439,8 @@ struct target_ops
        or executable file given by OBJFILE.  If that block of
        thread-local storage hasn't been allocated yet, this function
        may return an error.  */
-    CORE_ADDR (*to_get_thread_local_address) (ptid_t ptid,
+    CORE_ADDR (*to_get_thread_local_address) (struct target_ops *ops,
+					      ptid_t ptid,
 					      CORE_ADDR load_module_addr,
 					      CORE_ADDR offset);
 
@@ -625,8 +627,7 @@ extern void target_resume (ptid_t ptid, int step, enum target_signal signal);
    to the prompt with a debugging target but without the frame cache,
    stop_pc, etc., set up.  */
 
-#define	target_wait(ptid, status)		\
-     (*current_target.to_wait) (ptid, status)
+extern ptid_t target_wait (ptid_t ptid, struct target_waitstatus *status);
 
 /* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
 
@@ -1013,8 +1014,7 @@ int target_supports_non_stop (void);
    `process xyz', but on some systems it may contain
    `process xyz thread abc'.  */
 
-#undef target_pid_to_str
-#define target_pid_to_str(PID) current_target.to_pid_to_str (PID)
+extern char *target_pid_to_str (ptid_t ptid);
 
 extern char *normal_pid_to_str (ptid_t ptid);
 
@@ -1057,13 +1057,6 @@ extern char *normal_pid_to_str (ptid_t ptid);
 #define target_make_corefile_notes(BFD, SIZE_P) \
      (current_target.to_make_corefile_notes) (BFD, SIZE_P)
 
-/* Thread-local values.  */
-#define target_get_thread_local_address \
-    (current_target.to_get_thread_local_address)
-#define target_get_thread_local_address_p() \
-    (target_get_thread_local_address != NULL)
-
-
 /* Hardware watchpoint interfaces.  */
 
 /* Returns non-zero if we were stopped by a hardware watchpoint (memory read or
@@ -1252,7 +1245,7 @@ extern int default_memory_insert_breakpoint (struct gdbarch *, struct bp_target_
 
 extern void initialize_targets (void);
 
-extern void noprocess (void);
+extern NORETURN void noprocess (void) ATTR_NORETURN;
 
 extern void target_require_runnable (void);
 
diff --git a/gdb/windows-nat.c b/gdb/windows-nat.c
index 7e43f87..7398d6a 100644
--- a/gdb/windows-nat.c
+++ b/gdb/windows-nat.c
@@ -1444,7 +1444,8 @@ out:
 
 /* Wait for interesting events to occur in the target process.  */
 static ptid_t
-windows_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
+windows_wait (struct target_ops *ops,
+	      ptid_t ptid, struct target_waitstatus *ourstatus)
 {
   int pid = -1;
 
@@ -2017,7 +2018,7 @@ windows_close (int x)
 
 /* Convert pid to printable format. */
 static char *
-windows_pid_to_str (ptid_t ptid)
+windows_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   static char buf[80];