- kernel core debugging for i386 (Mark Peek)

- thread debugging for i386 (Mark Peek) and alpha (Doug Rabson)

Submitted by:	mp,dfr

3 files changed, 1642 insertions, 1900 deletions

diff --git a/contrib/gdb/gdb/config/i386/tm-fbsd.h b/contrib/gdb/gdb/config/i386/tm-fbsd.h
index 61f5de5..dc82d0e 100644
--- a/contrib/gdb/gdb/config/i386/tm-fbsd.h
+++ b/contrib/gdb/gdb/config/i386/tm-fbsd.h
@@ -18,12 +18,18 @@
    Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
+/* $FreeBSD$ */
+
 #ifndef TM_FBSD_H
 #define TM_FBSD_H
 
 #define HAVE_I387_REGS
 #include "i386/tm-i386.h"
 
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
 /* FreeBSD/ELF uses stabs-in-ELF with the DWARF register numbering
    scheme by default, so we must redefine STAB_REG_TO_REGNUM.  This
    messes up the floating-point registers for a.out, but there is not
@@ -41,38 +47,42 @@
 /* Support for longjmp.  */
 
 /* Details about jmp_buf.  It's supposed to be an array of integers.  */
-
-#define JB_ELEMENT_SIZE 4	/* Size of elements in jmp_buf.  */
-#define JB_PC		0	/* Array index of saved PC.  */
-
-/* Figure out where the longjmp will land.  Store the address that
-   longjmp will jump to in *ADDR, and return non-zero if successful.  */
-
 #define GET_LONGJMP_TARGET(addr) get_longjmp_target (addr)
-extern int get_longjmp_target (CORE_ADDR *addr);
 
 
-/* Support for signal handlers.  */
-
-#define IN_SIGTRAMP(pc, name) i386bsd_in_sigtramp (pc, name)
-extern int i386bsd_in_sigtramp (CORE_ADDR pc, char *name);
-
-/* These defines allow the recognition of sigtramps as a function name
-   <sigtramp>.
+/* On FreeBSD, sigtramp has size 0x18 and is immediately below the
+   ps_strings struct which has size 0x10 and is at the top of the
+   user stack.  */
 
-   FIXME: kettenis/2001-07-13: These should be added to the target
-   vector and turned into functions when we go "multi-arch".  */
+#undef SIGTRAMP_START
+#undef SIGTRAMP_END
+#define SIGTRAMP_START(pc)    0xbfbfdfd8
+#define SIGTRAMP_END(pc)      0xbfbfdff0
 
-#define SIGTRAMP_START(pc) i386bsd_sigtramp_start
-#define SIGTRAMP_END(pc) i386bsd_sigtramp_end
 extern CORE_ADDR i386bsd_sigtramp_start;
 extern CORE_ADDR i386bsd_sigtramp_end;
+extern CORE_ADDR fbsd_kern_frame_saved_pc(struct frame_info *fr);
 
 /* Override FRAME_SAVED_PC to enable the recognition of signal handlers.  */
 
 #undef FRAME_SAVED_PC
-#define FRAME_SAVED_PC(frame) i386bsd_frame_saved_pc (frame)
-extern CORE_ADDR i386bsd_frame_saved_pc (struct frame_info *frame);
+#if __FreeBSD_version >= 500032
+#define FRAME_SAVED_PC(FRAME) \
+  (kernel_debugging ? fbsd_kern_frame_saved_pc(FRAME) : \
+  (((FRAME)->signal_handler_caller \
+    ? sigtramp_saved_pc (FRAME) \
+    : read_memory_integer ((FRAME)->frame + 4, 4)) \
+   ))
+#else
+#define FRAME_SAVED_PC(FRAME) \
+  (((FRAME)->signal_handler_caller \
+    ? sigtramp_saved_pc (FRAME) \
+    : read_memory_integer ((FRAME)->frame + 4, 4)) \
+   )
+#endif
+
+/* Offset to saved PC in sigcontext, from <sys/signal.h>.  */
+#define SIGCONTEXT_PC_OFFSET 20
 
 
 /* Shared library support.  */
diff --git a/contrib/gdb/gdb/target.c b/contrib/gdb/gdb/target.c
index 2eea4ac..631ebda 100644
--- a/contrib/gdb/gdb/target.c
+++ b/contrib/gdb/gdb/target.c
@@ -1,26 +1,30 @@
 /* Select target systems and architectures at runtime for GDB.
-   Copyright 1990, 1992-1995, 1998, 1999 Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001, 2002
+   Free Software Foundation, Inc.
    Contributed by Cygnus Support.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* $FreeBSD$ */
 
 #include "defs.h"
 #include <errno.h>
-#include <ctype.h>
 #include "gdb_string.h"
 #include "target.h"
 #include "gdbcmd.h"
@@ -29,152 +33,117 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "bfd.h"
 #include "symfile.h"
 #include "objfiles.h"
-#include "wait.h"
+#include "gdb_wait.h"
+#include "dcache.h"
 #include <signal.h>
+#include "regcache.h"
 
 extern int errno;
 
-static void
-target_info PARAMS ((char *, int));
+static void target_info (char *, int);
 
-static void
-cleanup_target PARAMS ((struct target_ops *));
+static void cleanup_target (struct target_ops *);
 
-static void
-maybe_kill_then_create_inferior PARAMS ((char *, char *, char **));
+static void maybe_kill_then_create_inferior (char *, char *, char **);
 
-static void
-default_clone_and_follow_inferior PARAMS ((int, int *));
+static void default_clone_and_follow_inferior (int, int *);
 
-static void
-maybe_kill_then_attach PARAMS ((char *, int));
+static void maybe_kill_then_attach (char *, int);
 
-static void
-kill_or_be_killed PARAMS ((int));
+static void kill_or_be_killed (int);
 
-static void
-default_terminal_info PARAMS ((char *, int));
+static void default_terminal_info (char *, int);
 
-static int
-nosymbol PARAMS ((char *, CORE_ADDR *));
+static int nosymbol (char *, CORE_ADDR *);
 
-static void
-tcomplain PARAMS ((void));
+static void tcomplain (void);
 
-static int
-nomemory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
 
-static int
-return_zero PARAMS ((void));
+static int return_zero (void);
 
-static int
-return_one PARAMS ((void));
+static int return_one (void);
 
-void
-target_ignore PARAMS ((void));
+void target_ignore (void);
 
-static void
-target_command PARAMS ((char *, int));
+static void target_command (char *, int);
 
-static struct target_ops *
-find_default_run_target PARAMS ((char *));
+static struct target_ops *find_default_run_target (char *);
 
-static void
-update_current_target PARAMS ((void));
+static void update_current_target (void);
+
+static void nosupport_runtime (void);
+
+static void normal_target_post_startup_inferior (ptid_t ptid);
 
-/* Transfer LEN bytes between target address MEMADDR and GDB address MYADDR.
-   Returns 0 for success, errno code for failure (which includes partial
-   transfers--if you want a more useful response to partial transfers, try
-   target_read_memory_partial).  */
+/* Transfer LEN bytes between target address MEMADDR and GDB address
+   MYADDR.  Returns 0 for success, errno code for failure (which
+   includes partial transfers -- if you want a more useful response to
+   partial transfers, try either target_read_memory_partial or
+   target_write_memory_partial).  */
 
 static int
-target_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
-			    int write, asection *bfd_section));
+target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write);
 
-static void init_dummy_target PARAMS ((void));
+static void init_dummy_target (void);
 
-static void
-debug_to_open PARAMS ((char *, int));
+static void debug_to_open (char *, int);
 
-static void
-debug_to_close PARAMS ((int));
+static void debug_to_close (int);
 
-static void
-debug_to_attach PARAMS ((char *, int));
+static void debug_to_attach (char *, int);
 
-static void
-debug_to_detach PARAMS ((char *, int));
+static void debug_to_detach (char *, int);
 
-static void
-debug_to_resume PARAMS ((int, int, enum target_signal));
+static void debug_to_resume (ptid_t, int, enum target_signal);
 
-static int
-debug_to_wait PARAMS ((int, struct target_waitstatus *));
+static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
 
-static void
-debug_to_fetch_registers PARAMS ((int));
+static void debug_to_fetch_registers (int);
 
-static void
-debug_to_store_registers PARAMS ((int));
+static void debug_to_store_registers (int);
 
-static void
-debug_to_prepare_to_store PARAMS ((void));
+static void debug_to_prepare_to_store (void);
 
 static int
-debug_to_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+debug_to_xfer_memory (CORE_ADDR, char *, int, int, struct mem_attrib *, 
+		      struct target_ops *);
 
-static void
-debug_to_files_info PARAMS ((struct target_ops *));
+static void debug_to_files_info (struct target_ops *);
 
-static int
-debug_to_insert_breakpoint PARAMS ((CORE_ADDR, char *));
+static int debug_to_insert_breakpoint (CORE_ADDR, char *);
 
-static int
-debug_to_remove_breakpoint PARAMS ((CORE_ADDR, char *));
+static int debug_to_remove_breakpoint (CORE_ADDR, char *);
 
-static void
-debug_to_terminal_init PARAMS ((void));
+static void debug_to_terminal_init (void);
 
-static void
-debug_to_terminal_inferior PARAMS ((void));
+static void debug_to_terminal_inferior (void);
 
-static void
-debug_to_terminal_ours_for_output PARAMS ((void));
+static void debug_to_terminal_ours_for_output (void);
 
-static void
-debug_to_terminal_ours PARAMS ((void));
+static void debug_to_terminal_ours (void);
 
-static void
-debug_to_terminal_info PARAMS ((char *, int));
+static void debug_to_terminal_info (char *, int);
 
-static void
-debug_to_kill PARAMS ((void));
+static void debug_to_kill (void);
 
-static void
-debug_to_load PARAMS ((char *, int));
+static void debug_to_load (char *, int);
 
-static int
-debug_to_lookup_symbol PARAMS ((char *, CORE_ADDR *));
+static int debug_to_lookup_symbol (char *, CORE_ADDR *);
 
-static void
-debug_to_create_inferior PARAMS ((char *, char *, char **));
+static void debug_to_create_inferior (char *, char *, char **);
 
-static void
-debug_to_mourn_inferior PARAMS ((void));
+static void debug_to_mourn_inferior (void);
 
-static int
-debug_to_can_run PARAMS ((void));
+static int debug_to_can_run (void);
 
-static void
-debug_to_notice_signals PARAMS ((int));
+static void debug_to_notice_signals (ptid_t);
 
-static int
-debug_to_thread_alive PARAMS ((int));
+static int debug_to_thread_alive (ptid_t);
 
-static void
-debug_to_stop PARAMS ((void));
+static void debug_to_stop (void);
 
-static int debug_to_query PARAMS ((int/*char*/, char *, char *, int *));
+static int debug_to_query (int /*char */ , char *, char *, int *);
 
 /* Pointer to array of target architecture structures; the size of the
    array; the current index into the array; the allocated size of the 
@@ -208,22 +177,19 @@ static struct cmd_list_element *targetlist = NULL;
 
 int attach_flag;
 
-#ifdef MAINTENANCE_CMDS
 /* Non-zero if we want to see trace of target level stuff.  */
 
 static int targetdebug = 0;
 
-static void setup_target_debug PARAMS ((void));
+static void setup_target_debug (void);
 
-#endif
+DCACHE *target_dcache;
 
 /* The user just typed 'target' without the name of a target.  */
 
 /* ARGSUSED */
 static void
-target_command (arg, from_tty)
-     char *arg;
-     int from_tty;
+target_command (char *arg, int from_tty)
 {
   fputs_filtered ("Argument required (target name).  Try `help target'\n",
 		  gdb_stdout);
@@ -232,8 +198,7 @@ target_command (arg, from_tty)
 /* Add a possible target architecture to the list.  */
 
 void
-add_target (t)
-     struct target_ops *t;
+add_target (struct target_ops *t)
 {
   if (!target_structs)
     {
@@ -245,11 +210,11 @@ add_target (t)
     {
       target_struct_allocsize *= 2;
       target_structs = (struct target_ops **)
-	  xrealloc ((char *) target_structs, 
-		    target_struct_allocsize * sizeof (*target_structs));
+	xrealloc ((char *) target_structs,
+		  target_struct_allocsize * sizeof (*target_structs));
     }
   target_structs[target_struct_size++] = t;
-/*  cleanup_target (t);*/
+/*  cleanup_target (t); */
 
   if (targetlist == NULL)
     add_prefix_cmd ("target", class_run, target_command,
@@ -265,50 +230,51 @@ information on the arguments for a particular protocol, type\n\
 /* Stub functions */
 
 void
-target_ignore ()
+target_ignore (void)
 {
 }
 
+void
+target_load (char *arg, int from_tty)
+{
+  dcache_invalidate (target_dcache);
+  (*current_target.to_load) (arg, from_tty);
+}
+
 /* ARGSUSED */
 static int
-nomemory (memaddr, myaddr, len, write, t)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     struct target_ops *t;
+nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+	  struct target_ops *t)
 {
-  errno = EIO;		/* Can't read/write this location */
-  return 0;		/* No bytes handled */
+  errno = EIO;			/* Can't read/write this location */
+  return 0;			/* No bytes handled */
 }
 
 static void
-tcomplain ()
+tcomplain (void)
 {
   error ("You can't do that when your target is `%s'",
 	 current_target.to_shortname);
 }
 
 void
-noprocess ()
+noprocess (void)
 {
   error ("You can't do that without a process to debug.");
 }
 
 /* ARGSUSED */
 static int
-nosymbol (name, addrp)
-     char *name;
-     CORE_ADDR *addrp;
+nosymbol (char *name, CORE_ADDR *addrp)
 {
-  return 1;		/* Symbol does not exist in target env */
+  return 1;			/* Symbol does not exist in target env */
 }
 
 /* ARGSUSED */
-void
-nosupport_runtime ()
+static void
+nosupport_runtime (void)
 {
-  if (!inferior_pid)
+  if (ptid_equal (inferior_ptid, null_ptid))
     noprocess ();
   else
     error ("No run-time support for this");
@@ -317,11 +283,9 @@ nosupport_runtime ()
 
 /* ARGSUSED */
 static void
-default_terminal_info (args, from_tty)
-     char *args;
-     int from_tty;
+default_terminal_info (char *args, int from_tty)
 {
-  printf_unfiltered("No saved terminal information.\n");
+  printf_unfiltered ("No saved terminal information.\n");
 }
 
 /* This is the default target_create_inferior and target_attach function.
@@ -330,48 +294,43 @@ default_terminal_info (args, from_tty)
    the target, and the operation should be attempted.  */
 
 static void
-kill_or_be_killed (from_tty)
-     int from_tty;
+kill_or_be_killed (int from_tty)
 {
   if (target_has_execution)
     {
       printf_unfiltered ("You are already running a program:\n");
       target_files_info ();
-      if (query ("Kill it? ")) {
-	target_kill ();
-	if (target_has_execution)
-	  error ("Killing the program did not help.");
-	return;
-      } else {
-	error ("Program not killed.");
-      }
+      if (query ("Kill it? "))
+	{
+	  target_kill ();
+	  if (target_has_execution)
+	    error ("Killing the program did not help.");
+	  return;
+	}
+      else
+	{
+	  error ("Program not killed.");
+	}
     }
-  tcomplain();
+  tcomplain ();
 }
 
 static void
-maybe_kill_then_attach (args, from_tty)
-     char *args;
-     int from_tty;
+maybe_kill_then_attach (char *args, int from_tty)
 {
   kill_or_be_killed (from_tty);
   target_attach (args, from_tty);
 }
 
 static void
-maybe_kill_then_create_inferior (exec, args, env)
-     char *exec;
-     char *args;
-     char **env;
+maybe_kill_then_create_inferior (char *exec, char *args, char **env)
 {
   kill_or_be_killed (0);
   target_create_inferior (exec, args, env);
 }
 
 static void
-default_clone_and_follow_inferior (child_pid, followed_child)
-  int  child_pid;
-  int  *followed_child;
+default_clone_and_follow_inferior (int child_pid, int *followed_child)
 {
   target_clone_and_follow_inferior (child_pid, followed_child);
 }
@@ -380,70 +339,179 @@ default_clone_and_follow_inferior (child_pid, followed_child)
    We default entries, at least to stubs that print error messages.  */
 
 static void
-cleanup_target (t)
-     struct target_ops *t;
+cleanup_target (struct target_ops *t)
 {
 
 #define de_fault(field, value) \
-  if (!t->field)	t->field = value
-
-  /*        FIELD			DEFAULT VALUE        */
-
-  de_fault (to_open, 			(void (*) PARAMS((char *, int))) tcomplain);
-  de_fault (to_close, 			(void (*) PARAMS((int))) target_ignore);
-  de_fault (to_attach, 			maybe_kill_then_attach);
-  de_fault (to_post_attach,             (void (*) PARAMS ((int))) target_ignore);
-  de_fault (to_require_attach,          maybe_kill_then_attach);
-  de_fault (to_detach, 			(void (*) PARAMS((char *, int))) target_ignore);
-  de_fault (to_require_detach,          (void (*) PARAMS((int, char *, int))) target_ignore);
-  de_fault (to_resume, 			(void (*) PARAMS((int, int, enum target_signal))) noprocess);
-  de_fault (to_wait, 			(int (*) PARAMS((int, struct target_waitstatus *))) noprocess);
-  de_fault (to_post_wait,               (void (*) PARAMS ((int, int))) target_ignore);
-  de_fault (to_fetch_registers, 	(void (*) PARAMS((int))) target_ignore);
-  de_fault (to_store_registers,		(void (*) PARAMS((int))) noprocess);
-  de_fault (to_prepare_to_store,	(void (*) PARAMS((void))) noprocess);
-  de_fault (to_xfer_memory,		(int (*) PARAMS((CORE_ADDR, char *, int, int, struct target_ops *))) nomemory);
-  de_fault (to_files_info,		(void (*) PARAMS((struct target_ops *))) target_ignore);
-  de_fault (to_insert_breakpoint,	memory_insert_breakpoint);
-  de_fault (to_remove_breakpoint,	memory_remove_breakpoint);
-  de_fault (to_terminal_init,		(void (*) PARAMS((void))) target_ignore);
-  de_fault (to_terminal_inferior,	(void (*) PARAMS ((void))) target_ignore);
-  de_fault (to_terminal_ours_for_output,(void (*) PARAMS ((void))) target_ignore);
-  de_fault (to_terminal_ours,		(void (*) PARAMS ((void))) target_ignore);
-  de_fault (to_terminal_info,		default_terminal_info);
-  de_fault (to_kill,			(void (*) PARAMS((void))) noprocess);
-  de_fault (to_load,			(void (*) PARAMS((char *, int))) tcomplain);
-  de_fault (to_lookup_symbol,		(int (*) PARAMS ((char *, CORE_ADDR *))) nosymbol);
-  de_fault (to_create_inferior,		maybe_kill_then_create_inferior);
-  de_fault (to_post_startup_inferior,   (void (*) PARAMS ((int))) target_ignore);
-  de_fault (to_acknowledge_created_inferior,            (void (*) PARAMS((int))) target_ignore);
-  de_fault (to_clone_and_follow_inferior,               default_clone_and_follow_inferior);
-  de_fault (to_post_follow_inferior_by_clone,           (void (*) PARAMS ((void))) target_ignore);
-  de_fault (to_insert_fork_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
-  de_fault (to_remove_fork_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
-  de_fault (to_insert_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
-  de_fault (to_remove_vfork_catchpoint, (int (*) PARAMS ((int))) tcomplain);
-  de_fault (to_has_forked,              (int (*) PARAMS ((int, int *))) return_zero);
-  de_fault (to_has_vforked,             (int (*) PARAMS ((int, int *))) return_zero);
-  de_fault (to_can_follow_vfork_prior_to_exec, (int (*) PARAMS ((void ))) return_zero);
-  de_fault (to_post_follow_vfork,       (void (*) PARAMS ((int, int, int, int))) target_ignore);
-  de_fault (to_insert_exec_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
-  de_fault (to_remove_exec_catchpoint,  (int (*) PARAMS ((int))) tcomplain);
-  de_fault (to_has_execd,               (int (*) PARAMS ((int, char **))) return_zero);
-  de_fault (to_reported_exec_events_per_exec_call, (int (*) PARAMS ((void))) return_one);
-  de_fault (to_has_syscall_event,       (int (*) PARAMS ((int, enum target_waitkind *, int *))) return_zero);
-  de_fault (to_has_exited,              (int (*) PARAMS ((int, int, int *))) return_zero);
-  de_fault (to_mourn_inferior,		(void (*) PARAMS ((void))) noprocess);
-  de_fault (to_can_run,			return_zero);
-  de_fault (to_notice_signals,		(void (*) PARAMS((int))) target_ignore);
-  de_fault (to_thread_alive,		(int (*) PARAMS((int))) target_ignore);
-  de_fault (to_stop,			(void (*) PARAMS((void))) target_ignore);
-  de_fault (to_query,			(int (*) PARAMS((int/*char*/, char*, char *, int *))) target_ignore);
-  de_fault (to_enable_exception_callback,	(struct symtab_and_line * (*) PARAMS((enum exception_event_kind, int))) nosupport_runtime);
-  de_fault (to_get_current_exception_event,	(struct exception_event_record * (*) PARAMS((void))) nosupport_runtime);
-
-  de_fault (to_pid_to_exec_file,        (char* (*) PARAMS((int))) return_zero);
-  de_fault (to_core_file_to_sym_file,   (char* (*) PARAMS ((char *))) return_zero);
+  if (!t->field)               \
+    t->field = value
+
+  de_fault (to_open, 
+	    (void (*) (char *, int)) 
+	    tcomplain);
+  de_fault (to_close, 
+	    (void (*) (int)) 
+	    target_ignore);
+  de_fault (to_attach, 
+	    maybe_kill_then_attach);
+  de_fault (to_post_attach, 
+	    (void (*) (int)) 
+	    target_ignore);
+  de_fault (to_require_attach, 
+	    maybe_kill_then_attach);
+  de_fault (to_detach, 
+	    (void (*) (char *, int)) 
+	    target_ignore);
+  de_fault (to_require_detach, 
+	    (void (*) (int, char *, int)) 
+	    target_ignore);
+  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_post_wait, 
+	    (void (*) (ptid_t, int)) 
+	    target_ignore);
+  de_fault (to_fetch_registers, 
+	    (void (*) (int)) 
+	    target_ignore);
+  de_fault (to_store_registers, 
+	    (void (*) (int)) 
+	    noprocess);
+  de_fault (to_prepare_to_store, 
+	    (void (*) (void)) 
+	    noprocess);
+  de_fault (to_xfer_memory, 
+	    (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *)) 
+	    nomemory);
+  de_fault (to_files_info, 
+	    (void (*) (struct target_ops *)) 
+	    target_ignore);
+  de_fault (to_insert_breakpoint, 
+	    memory_insert_breakpoint);
+  de_fault (to_remove_breakpoint, 
+	    memory_remove_breakpoint);
+  de_fault (to_terminal_init, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_terminal_inferior, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_terminal_ours_for_output, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_terminal_ours, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_terminal_info, 
+	    default_terminal_info);
+  de_fault (to_kill, 
+	    (void (*) (void)) 
+	    noprocess);
+  de_fault (to_load, 
+	    (void (*) (char *, int)) 
+	    tcomplain);
+  de_fault (to_lookup_symbol, 
+	    (int (*) (char *, CORE_ADDR *)) 
+	    nosymbol);
+  de_fault (to_create_inferior, 
+	    maybe_kill_then_create_inferior);
+  de_fault (to_post_startup_inferior, 
+	    (void (*) (ptid_t)) 
+	    target_ignore);
+  de_fault (to_acknowledge_created_inferior, 
+	    (void (*) (int)) 
+	    target_ignore);
+  de_fault (to_clone_and_follow_inferior, 
+	    default_clone_and_follow_inferior);
+  de_fault (to_post_follow_inferior_by_clone, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_insert_fork_catchpoint, 
+	    (int (*) (int)) 
+	    tcomplain);
+  de_fault (to_remove_fork_catchpoint, 
+	    (int (*) (int)) 
+	    tcomplain);
+  de_fault (to_insert_vfork_catchpoint, 
+	    (int (*) (int)) 
+	    tcomplain);
+  de_fault (to_remove_vfork_catchpoint, 
+	    (int (*) (int)) 
+	    tcomplain);
+  de_fault (to_has_forked, 
+	    (int (*) (int, int *)) 
+	    return_zero);
+  de_fault (to_has_vforked, 
+	    (int (*) (int, int *)) 
+	    return_zero);
+  de_fault (to_can_follow_vfork_prior_to_exec, 
+	    (int (*) (void)) 
+	    return_zero);
+  de_fault (to_post_follow_vfork, 
+	    (void (*) (int, int, int, int)) 
+	    target_ignore);
+  de_fault (to_insert_exec_catchpoint, 
+	    (int (*) (int)) 
+	    tcomplain);
+  de_fault (to_remove_exec_catchpoint, 
+	    (int (*) (int)) 
+	    tcomplain);
+  de_fault (to_has_execd, 
+	    (int (*) (int, char **)) 
+	    return_zero);
+  de_fault (to_reported_exec_events_per_exec_call, 
+	    (int (*) (void)) 
+	    return_one);
+  de_fault (to_has_syscall_event, 
+	    (int (*) (int, enum target_waitkind *, int *)) 
+	    return_zero);
+  de_fault (to_has_exited, 
+	    (int (*) (int, int, int *)) 
+	    return_zero);
+  de_fault (to_mourn_inferior, 
+	    (void (*) (void)) 
+	    noprocess);
+  de_fault (to_can_run, 
+	    return_zero);
+  de_fault (to_notice_signals, 
+	    (void (*) (ptid_t)) 
+	    target_ignore);
+  de_fault (to_thread_alive, 
+	    (int (*) (ptid_t)) 
+	    return_zero);
+  de_fault (to_find_new_threads, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_extra_thread_info, 
+	    (char *(*) (struct thread_info *)) 
+	    return_zero);
+  de_fault (to_stop, 
+	    (void (*) (void)) 
+	    target_ignore);
+  de_fault (to_rcmd, 
+	    (void (*) (char *, struct ui_file *)) 
+	    tcomplain);
+  de_fault (to_enable_exception_callback, 
+	    (struct symtab_and_line * (*) (enum exception_event_kind, int)) 
+	    nosupport_runtime);
+  de_fault (to_get_current_exception_event, 
+	    (struct exception_event_record * (*) (void)) 
+	    nosupport_runtime);
+  de_fault (to_pid_to_exec_file, 
+	    (char *(*) (int)) 
+	    return_zero);
+  de_fault (to_can_async_p, 
+	    (int (*) (void)) 
+	    return_zero);
+  de_fault (to_is_async_p, 
+	    (int (*) (void)) 
+	    return_zero);
+  de_fault (to_async, 
+	    (void (*) (void (*) (enum inferior_event_type, void*), void*)) 
+	    tcomplain);
 #undef de_fault
 }
 
@@ -452,7 +520,7 @@ cleanup_target (t)
    pushed target vectors.  */
 
 static void
-update_current_target ()
+update_current_target (void)
 {
   struct target_stack_item *item;
   struct target_ops *t;
@@ -519,12 +587,15 @@ update_current_target ()
       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);
+      INHERIT (to_extra_thread_info, t);
       INHERIT (to_stop, t);
       INHERIT (to_query, t);
+      INHERIT (to_rcmd, t);
       INHERIT (to_enable_exception_callback, t);
       INHERIT (to_get_current_exception_event, t);
       INHERIT (to_pid_to_exec_file, t);
-      INHERIT (to_core_file_to_sym_file, t);
       INHERIT (to_stratum, t);
       INHERIT (DONT_USE, t);
       INHERIT (to_has_all_memory, t);
@@ -535,6 +606,12 @@ update_current_target ()
       INHERIT (to_has_thread_control, t);
       INHERIT (to_sections, t);
       INHERIT (to_sections_end, t);
+      INHERIT (to_can_async_p, t);
+      INHERIT (to_is_async_p, t);
+      INHERIT (to_async, t);
+      INHERIT (to_async_mask_value, t);
+      INHERIT (to_find_memory_regions, t);
+      INHERIT (to_make_corefile_notes, t);
       INHERIT (to_magic, t);
 
 #undef INHERIT
@@ -552,8 +629,7 @@ update_current_target ()
    checking them.  */
 
 int
-push_target (t)
-     struct target_ops *t;
+push_target (struct target_ops *t)
 {
   struct target_stack_item *cur, *prev, *tmp;
 
@@ -561,17 +637,17 @@ push_target (t)
      the struct definition, but not all the places that initialize one.  */
   if (t->to_magic != OPS_MAGIC)
     {
-      fprintf_unfiltered(gdb_stderr,
-			 "Magic number of %s target struct wrong\n", 
-			 t->to_shortname);
-      abort();
+      fprintf_unfiltered (gdb_stderr,
+			  "Magic number of %s target struct wrong\n",
+			  t->to_shortname);
+      internal_error (__FILE__, __LINE__, "failed internal consistency check");
     }
 
   /* Find the proper stratum to install this target in. */
 
   for (prev = NULL, cur = target_stack; cur; prev = cur, cur = cur->next)
     {
-      if ((int)(t->to_stratum) >= (int)(cur->target_ops->to_stratum))
+      if ((int) (t->to_stratum) >= (int) (cur->target_ops->to_stratum))
 	break;
     }
 
@@ -584,11 +660,11 @@ push_target (t)
 	if (cur->target_ops->to_close)
 	  (cur->target_ops->to_close) (0);
 	if (prev)
-	  prev->next = cur->next; /* Unchain old target_ops */
+	  prev->next = cur->next;	/* Unchain old target_ops */
 	else
-	  target_stack = cur->next; /* Unchain first on list */
+	  target_stack = cur->next;	/* Unchain first on list */
 	tmp = cur->next;
-	free (cur);
+	xfree (cur);
 	cur = tmp;
       }
 
@@ -606,12 +682,10 @@ push_target (t)
 
   update_current_target ();
 
-  cleanup_target (&current_target); /* Fill in the gaps */
+  cleanup_target (&current_target);	/* Fill in the gaps */
 
-#ifdef MAINTENANCE_CMDS
   if (targetdebug)
     setup_target_debug ();
-#endif
 
   return prev != 0;
 }
@@ -620,8 +694,7 @@ push_target (t)
    Return how many times it was removed (0 or 1).  */
 
 int
-unpush_target (t)
-     struct target_ops *t;
+unpush_target (struct target_ops *t)
 {
   struct target_stack_item *cur, *prev;
 
@@ -645,7 +718,7 @@ unpush_target (t)
   else
     prev->next = cur->next;
 
-  free (cur);			/* Release the target_stack_item */
+  xfree (cur);			/* Release the target_stack_item */
 
   update_current_target ();
   cleanup_target (&current_target);
@@ -654,16 +727,16 @@ unpush_target (t)
 }
 
 void
-pop_target ()
+pop_target (void)
 {
-  (current_target.to_close)(0);	/* Let it clean up */
+  (current_target.to_close) (0);	/* Let it clean up */
   if (unpush_target (target_stack->target_ops) == 1)
     return;
 
-  fprintf_unfiltered(gdb_stderr,
-		     "pop_target couldn't find target %s\n", 
-		     current_target.to_shortname);
-  abort();
+  fprintf_unfiltered (gdb_stderr,
+		      "pop_target couldn't find target %s\n",
+		      current_target.to_shortname);
+  internal_error (__FILE__, __LINE__, "failed internal consistency check");
 }
 
 #undef	MIN
@@ -676,11 +749,7 @@ pop_target ()
    read.  */
 
 int
-target_read_string (memaddr, string, len, errnop)
-     CORE_ADDR memaddr;
-     char **string;
-     int len;
-     int *errnop;
+target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
 {
   int tlen, origlen, offset, i;
   char buf[4];
@@ -702,7 +771,7 @@ target_read_string (memaddr, string, len, errnop)
       tlen = MIN (len, 4 - (memaddr & 3));
       offset = memaddr & 3;
 
-      errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0, NULL);
+      errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
       if (errcode != 0)
 	{
 	  /* The transfer request might have crossed the boundary to an
@@ -710,7 +779,7 @@ target_read_string (memaddr, string, len, errnop)
 	     a single byte.  */
 	  tlen = 1;
 	  offset = 0;
-	  errcode = target_xfer_memory (memaddr, buf, 1, 0, NULL);
+	  errcode = target_xfer_memory (memaddr, buf, 1, 0);
 	  if (errcode != 0)
 	    goto done;
 	}
@@ -738,7 +807,7 @@ target_read_string (memaddr, string, len, errnop)
       len -= tlen;
       nbytes_read += tlen;
     }
- done:
+done:
   if (errnop != NULL)
     *errnop = errcode;
   if (string != NULL)
@@ -757,101 +826,30 @@ target_read_string (memaddr, string, len, errnop)
    deal with partial reads should call target_read_memory_partial. */
 
 int
-target_read_memory (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
 {
-  return target_xfer_memory (memaddr, myaddr, len, 0, NULL);
+  return target_xfer_memory (memaddr, myaddr, len, 0);
 }
 
 int
-target_read_memory_section (memaddr, myaddr, len, bfd_section)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     asection *bfd_section;
+target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
 {
-  return target_xfer_memory (memaddr, myaddr, len, 0, bfd_section);
+  return target_xfer_memory (memaddr, myaddr, len, 1);
 }
 
-/* Read LEN bytes of target memory at address MEMADDR, placing the results
-   in GDB's memory at MYADDR.  Returns a count of the bytes actually read,
-   and optionally an errno value in the location pointed to by ERRNOPTR
-   if ERRNOPTR is non-null. */
+static int trust_readonly = 0;
 
-int
-target_read_memory_partial (memaddr, myaddr, len, errnoptr)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int *errnoptr;
-{
-  int nread;	/* Number of bytes actually read. */
-  int errcode;	/* Error from last read. */
-
-  /* First try a complete read. */
-  errcode = target_xfer_memory (memaddr, myaddr, len, 0, NULL);
-  if (errcode == 0)
-    {
-      /* Got it all. */
-      nread = len;
-    }
-  else
-    {
-      /* Loop, reading one byte at a time until we get as much as we can. */
-      for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
-	{
-	  errcode = target_xfer_memory (memaddr++, myaddr++, 1, 0, NULL);
-	}
-      /* If an error, the last read was unsuccessful, so adjust count. */
-      if (errcode != 0)
-	{
-	  nread--;
-	}
-    }
-  if (errnoptr != NULL)
-    {
-      *errnoptr = errcode;
-    }
-  return (nread);
-}
+/* Move memory to or from the targets.  The top target gets priority;
+   if it cannot handle it, it is offered to the next one down, etc.
+
+   Result is -1 on error, or the number of bytes transfered.  */
 
 int
-target_write_memory (memaddr, myaddr, len)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
+do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+		struct mem_attrib *attrib)
 {
-  return target_xfer_memory (memaddr, myaddr, len, 1, NULL);
-}
- 
-/* This variable is used to pass section information down to targets.  This
-   *should* be done by adding an argument to the target_xfer_memory function
-   of all the targets, but I didn't feel like changing 50+ files.  */
-
-asection *target_memory_bfd_section = NULL;
-
-/* Move memory to or from the targets.  Iterate until all of it has
-   been moved, if necessary.  The top target gets priority; anything
-   it doesn't want, is offered to the next one down, etc.  Note the
-   business with curlen:  if an early target says "no, but I have a
-   boundary overlapping this xfer" then we shorten what we offer to
-   the subsequent targets so the early guy will get a chance at the
-   tail before the subsequent ones do. 
-
-   Result is 0 or errno value.  */
-
-static int
-target_xfer_memory (memaddr, myaddr, len, write, bfd_section)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     asection *bfd_section;
-{
-  int curlen;
   int res;
+  int done = 0;
   struct target_ops *t;
   struct target_stack_item *item;
 
@@ -859,32 +857,44 @@ target_xfer_memory (memaddr, myaddr, len, write, bfd_section)
   if (len == 0)
     return 0;
 
-  target_memory_bfd_section = bfd_section;
-
   /* to_xfer_memory is not guaranteed to set errno, even when it returns
      0.  */
   errno = 0;
 
-  /* The quick case is that the top target does it all.  */
-  res = current_target.to_xfer_memory
-			(memaddr, myaddr, len, write, &current_target);
-  if (res == len)
-    return 0;
+  if (!write && trust_readonly)
+    {
+      /* User-settable option, "trust-readonly".  If true, then
+	 memory from any SEC_READONLY bfd section may be read
+	 directly from the bfd file. */
+
+      struct section_table *secp;
+
+      for (secp = current_target.to_sections;
+	   secp < current_target.to_sections_end;
+	   secp++)
+	{
+	  if (bfd_get_section_flags (secp->bfd, secp->the_bfd_section) 
+	      & SEC_READONLY)
+	    if (memaddr >= secp->addr && memaddr < secp->endaddr)
+	      return xfer_memory (memaddr, myaddr, len, 0, 
+				  attrib, &current_target);
+	}
+    }
 
-  if (res > 0)
-    goto bump;
-  /* If res <= 0 then we call it again in the loop.  Ah well.  */
+  /* The quick case is that the top target can handle the transfer.  */
+  res = current_target.to_xfer_memory
+    (memaddr, myaddr, len, write, attrib, &current_target);
 
-  for (; len > 0;)
+  /* If res <= 0 then we call it again in the loop.  Ah well. */
+  if (res <= 0)
     {
-      curlen = len;		/* Want to do it all */
       for (item = target_stack; item; item = item->next)
 	{
 	  t = item->target_ops;
 	  if (!t->to_has_memory)
 	    continue;
 
-	  res = t->to_xfer_memory (memaddr, myaddr, curlen, write, t);
+	  res = t->to_xfer_memory (memaddr, myaddr, len, write, attrib, t);
 	  if (res > 0)
 	    break;		/* Handled all or part of xfer */
 	  if (t->to_has_all_memory)
@@ -892,35 +902,170 @@ target_xfer_memory (memaddr, myaddr, len, write, bfd_section)
 	}
 
       if (res <= 0)
+	return -1;
+    }
+
+  return res;
+}
+
+
+/* Perform a memory transfer.  Iterate until the entire region has
+   been transfered.
+
+   Result is 0 or errno value.  */
+
+static int
+target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
+{
+  int res;
+  int reg_len;
+  struct mem_region *region;
+
+  /* Zero length requests are ok and require no work.  */
+  if (len == 0)
+    {
+      return 0;
+    }
+
+  while (len > 0)
+    {
+      region = lookup_mem_region(memaddr);
+      if (memaddr + len < region->hi)
+	reg_len = len;
+      else
+	reg_len = region->hi - memaddr;
+
+      switch (region->attrib.mode)
 	{
-	  /* If this address is for nonexistent memory,
-	     read zeros if reading, or do nothing if writing.  Return error. */
+	case MEM_RO:
+	  if (write)
+	    return EIO;
+	  break;
+	  
+	case MEM_WO:
 	  if (!write)
-	    memset (myaddr, 0, len);
-	  if (errno == 0)
 	    return EIO;
+	  break;
+	}
+
+      while (reg_len > 0)
+	{
+	  if (region->attrib.cache)
+	    res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
+				     reg_len, write);
 	  else
-	    return errno;
+	    res = do_xfer_memory (memaddr, myaddr, reg_len, write,
+				 &region->attrib);
+	      
+	  if (res <= 0)
+	    {
+	      /* If this address is for nonexistent memory, read zeros
+		 if reading, or do nothing if writing.  Return
+		 error. */
+	      if (!write)
+		memset (myaddr, 0, len);
+	      if (errno == 0)
+		return EIO;
+	      else
+		return errno;
+	    }
+
+	  memaddr += res;
+	  myaddr  += res;
+	  len     -= res;
+	  reg_len -= res;
 	}
-bump:
-      memaddr += res;
-      myaddr  += res;
-      len     -= res;
     }
+  
   return 0;			/* We managed to cover it all somehow. */
 }
 
 
+/* Perform a partial memory transfer.
+
+   Result is -1 on error, or the number of bytes transfered.  */
+
+static int
+target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
+			    int write_p, int *err)
+{
+  int res;
+  int reg_len;
+  struct mem_region *region;
+
+  /* Zero length requests are ok and require no work.  */
+  if (len == 0)
+    {
+      *err = 0;
+      return 0;
+    }
+
+  region = lookup_mem_region(memaddr);
+  if (memaddr + len < region->hi)
+    reg_len = len;
+  else
+    reg_len = region->hi - memaddr;
+
+  switch (region->attrib.mode)
+    {
+    case MEM_RO:
+      if (write_p)
+	{
+	  *err = EIO;
+	  return -1;
+	}
+      break;
+
+    case MEM_WO:
+      if (write_p)
+	{
+	  *err = EIO;
+	  return -1;
+	}
+      break;
+    }
+
+  if (region->attrib.cache)
+    res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
+			      reg_len, write_p);
+  else
+    res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
+			  &region->attrib);
+      
+  if (res <= 0)
+    {
+      if (errno != 0)
+	*err = errno;
+      else
+	*err = EIO;
+
+        return -1;
+    }
+
+  *err = 0;
+  return res;
+}
+
+int
+target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
+{
+  return target_xfer_memory_partial (memaddr, buf, len, 0, err);
+}
+
+int
+target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
+{
+  return target_xfer_memory_partial (memaddr, buf, len, 1, err);
+}
+
 /* ARGSUSED */
 static void
-target_info (args, from_tty)
-     char *args;
-     int from_tty;
+target_info (char *args, int from_tty)
 {
   struct target_ops *t;
   struct target_stack_item *item;
   int has_all_mem = 0;
-  
+
   if (symfile_objfile != NULL)
     printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
 
@@ -936,12 +1081,12 @@ target_info (args, from_tty)
       if (!t->to_has_memory)
 	continue;
 
-      if ((int)(t->to_stratum) <= (int)dummy_stratum)
+      if ((int) (t->to_stratum) <= (int) dummy_stratum)
 	continue;
       if (has_all_mem)
-	printf_unfiltered("\tWhile running this, GDB does not access memory from...\n");
-      printf_unfiltered("%s:\n", t->to_longname);
-      (t->to_files_info)(t);
+	printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
+      printf_unfiltered ("%s:\n", t->to_longname);
+      (t->to_files_info) (t);
       has_all_mem = t->to_has_all_memory;
     }
 }
@@ -950,17 +1095,17 @@ target_info (args, from_tty)
    anything.  */
 
 void
-target_preopen (from_tty)
-     int from_tty;
+target_preopen (int from_tty)
 {
-  dont_repeat();
+  dont_repeat ();
 
   if (target_has_execution)
-    {   
-      if (query ("A program is being debugged already.  Kill it? "))
-        target_kill ();
+    {
+      if (!from_tty
+          || query ("A program is being debugged already.  Kill it? "))
+	target_kill ();
       else
-        error ("Program not killed.");
+	error ("Program not killed.");
     }
 
   /* Calling target_kill may remove the target from the stack.  But if
@@ -973,9 +1118,7 @@ target_preopen (from_tty)
 /* Detach a target after doing deferred register stores.  */
 
 void
-target_detach (args, from_tty)
-     char *args;
-     int from_tty;
+target_detach (char *args, int from_tty)
 {
   /* Handle any optimized stores to the inferior.  */
 #ifdef DO_DEFERRED_STORES
@@ -985,18 +1128,24 @@ target_detach (args, from_tty)
 }
 
 void
-target_link (modname, t_reloc)
-     char *modname;
-     CORE_ADDR *t_reloc;
+target_link (char *modname, CORE_ADDR *t_reloc)
 {
-  if (STREQ(current_target.to_shortname, "rombug"))
+  if (STREQ (current_target.to_shortname, "rombug"))
     {
       (current_target.to_lookup_symbol) (modname, t_reloc);
       if (*t_reloc == 0)
-      error("Unable to link to %s and get relocation in rombug", modname);
+	error ("Unable to link to %s and get relocation in rombug", modname);
     }
   else
-    *t_reloc = (CORE_ADDR)-1;
+    *t_reloc = (CORE_ADDR) -1;
+}
+
+int
+target_async_mask (int mask)
+{
+  int saved_async_masked_status = target_async_mask_value;
+  target_async_mask_value = mask;
+  return saved_async_masked_status;
 }
 
 /* Look through the list of possible targets for a target that can
@@ -1006,8 +1155,7 @@ target_link (modname, t_reloc)
    Result is always valid (error() is called for errors).  */
 
 static struct target_ops *
-find_default_run_target (do_mesg)
-     char *do_mesg;
+find_default_run_target (char *do_mesg)
 {
   struct target_ops **t;
   struct target_ops *runable = NULL;
@@ -1018,7 +1166,7 @@ find_default_run_target (do_mesg)
   for (t = target_structs; t < target_structs + target_struct_size;
        ++t)
     {
-      if ((*t)->to_can_run && target_can_run(*t))
+      if ((*t)->to_can_run && target_can_run (*t))
 	{
 	  runable = *t;
 	  ++count;
@@ -1032,109 +1180,231 @@ find_default_run_target (do_mesg)
 }
 
 void
-find_default_attach (args, from_tty)
-     char *args;
-     int from_tty;
+find_default_attach (char *args, int from_tty)
 {
   struct target_ops *t;
 
-  t = find_default_run_target("attach");
+  t = find_default_run_target ("attach");
   (t->to_attach) (args, from_tty);
   return;
 }
 
 void
-find_default_require_attach (args, from_tty)
-     char *args;
-     int from_tty;
+find_default_require_attach (char *args, int from_tty)
 {
   struct target_ops *t;
 
-  t = find_default_run_target("require_attach");
+  t = find_default_run_target ("require_attach");
   (t->to_require_attach) (args, from_tty);
   return;
 }
 
 void
-find_default_require_detach (pid, args, from_tty)
-  int  pid;
-  char *  args;
-  int  from_tty;
+find_default_require_detach (int pid, char *args, int from_tty)
 {
   struct target_ops *t;
 
-  t = find_default_run_target("require_detach");
+  t = find_default_run_target ("require_detach");
   (t->to_require_detach) (pid, args, from_tty);
   return;
 }
 
 void
-find_default_create_inferior (exec_file, allargs, env)
-     char *exec_file;
-     char *allargs;
-     char **env;
+find_default_create_inferior (char *exec_file, char *allargs, char **env)
 {
   struct target_ops *t;
 
-  t = find_default_run_target("run");
+  t = find_default_run_target ("run");
   (t->to_create_inferior) (exec_file, allargs, env);
   return;
 }
 
 void
-find_default_clone_and_follow_inferior (child_pid, followed_child)
-  int  child_pid;
-  int  *followed_child;
+find_default_clone_and_follow_inferior (int child_pid, int *followed_child)
 {
   struct target_ops *t;
 
-  t = find_default_run_target("run");
+  t = find_default_run_target ("run");
   (t->to_clone_and_follow_inferior) (child_pid, followed_child);
   return;
 }
 
 static int
-return_zero ()
+return_zero (void)
 {
   return 0;
 }
 
 static int
-return_one ()
+return_one (void)
 {
   return 1;
 }
 
+/*
+ * Resize the to_sections pointer.  Also make sure that anyone that
+ * was holding on to an old value of it gets updated.
+ * Returns the old size.
+ */
+
+int
+target_resize_to_sections (struct target_ops *target, int num_added)
+{
+  struct target_ops **t;
+  struct section_table *old_value;
+  int old_count;
+
+  old_value = target->to_sections;
+
+  if (target->to_sections)
+    {
+      old_count = target->to_sections_end - target->to_sections;
+      target->to_sections = (struct section_table *)
+	xrealloc ((char *) target->to_sections,
+		  (sizeof (struct section_table)) * (num_added + old_count));
+    }
+  else
+    {
+      old_count = 0;
+      target->to_sections = (struct section_table *)
+	xmalloc ((sizeof (struct section_table)) * num_added);
+    }
+  target->to_sections_end = target->to_sections + (num_added + old_count);
+
+  /* Check to see if anyone else was pointing to this structure.
+     If old_value was null, then no one was. */
+     
+  if (old_value)
+    {
+      for (t = target_structs; t < target_structs + target_struct_size;
+	   ++t)
+	{
+	  if ((*t)->to_sections == old_value)
+	    {
+	      (*t)->to_sections = target->to_sections;
+	      (*t)->to_sections_end = target->to_sections_end;
+	    }
+	}
+    }
+  
+  return old_count;
+
+}
+
+/* Remove all target sections taken from ABFD.
+
+   Scan the current target stack for targets whose section tables
+   refer to sections from BFD, and remove those sections.  We use this
+   when we notice that the inferior has unloaded a shared object, for
+   example.  */
+void
+remove_target_sections (bfd *abfd)
+{
+  struct target_ops **t;
+
+  for (t = target_structs; t < target_structs + target_struct_size; t++)
+    {
+      struct section_table *src, *dest;
+
+      dest = (*t)->to_sections;
+      for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
+	if (src->bfd != abfd)
+	  {
+	    /* Keep this section.  */
+	    if (dest < src) *dest = *src;
+	    dest++;
+	  }
+
+      /* If we've dropped any sections, resize the section table.  */
+      if (dest < src)
+	target_resize_to_sections (*t, dest - src);
+    }
+}
+
+
+
+
+/* Find a single runnable target in the stack and return it.  If for
+   some reason there is more than one, return NULL.  */
+
 struct target_ops *
-find_core_target ()
+find_run_target (void)
 {
   struct target_ops **t;
   struct target_ops *runable = NULL;
   int count;
-  
+
   count = 0;
-  
+
+  for (t = target_structs; t < target_structs + target_struct_size; ++t)
+    {
+      if ((*t)->to_can_run && target_can_run (*t))
+	{
+	  runable = *t;
+	  ++count;
+	}
+    }
+
+  return (count == 1 ? runable : NULL);
+}
+
+/* Find a single core_stratum target in the list of targets and return it.
+   If for some reason there is more than one, return NULL.  */
+
+struct target_ops *
+find_core_target (void)
+{
+  struct target_ops **t;
+  struct target_ops *runable = NULL;
+  int count;
+
+  count = 0;
+
   for (t = target_structs; t < target_structs + target_struct_size;
        ++t)
     {
+#if defined(__FreeBSD__)
       if ((*t)->to_stratum == (kernel_debugging ? kcore_stratum : core_stratum))
+#else
+      if ((*t)->to_stratum == core_stratum)
+#endif
 	{
 	  runable = *t;
 	  ++count;
 	}
     }
-  
-  return(count == 1 ? runable : NULL);
+
+  return (count == 1 ? runable : NULL);
 }
+
+/*
+ * Find the next target down the stack from the specified target.
+ */
+
+struct target_ops *
+find_target_beneath (struct target_ops *t)
+{
+  struct target_stack_item *cur;
+
+  for (cur = target_stack; cur; cur = cur->next)
+    if (cur->target_ops == t)
+      break;
+
+  if (cur == NULL || cur->next == NULL)
+    return NULL;
+  else
+    return cur->next->target_ops;
+}
+
 
 /* The inferior process has died.  Long live the inferior!  */
 
 void
-generic_mourn_inferior ()
+generic_mourn_inferior (void)
 {
   extern int show_breakpoint_hit_counts;
 
-  inferior_pid = 0;
+  inferior_ptid = null_ptid;
   attach_flag = 0;
   breakpoint_init_inferior (inf_exited);
   registers_changed ();
@@ -1153,519 +1423,16 @@ generic_mourn_inferior ()
      using hit counts.  So don't clear them if we're counting hits.  */
   if (!show_breakpoint_hit_counts)
     breakpoint_clear_ignore_counts ();
-}
-
-/* This table must match in order and size the signals in enum target_signal
-   in target.h.  */
-static struct {
-  char *name;
-  char *string;
-  } signals [] =
-{
-  {"0", "Signal 0"},
-  {"SIGHUP", "Hangup"},
-  {"SIGINT", "Interrupt"},
-  {"SIGQUIT", "Quit"},
-  {"SIGILL", "Illegal instruction"},
-  {"SIGTRAP", "Trace/breakpoint trap"},
-  {"SIGABRT", "Aborted"},
-  {"SIGEMT", "Emulation trap"},
-  {"SIGFPE", "Arithmetic exception"},
-  {"SIGKILL", "Killed"},
-  {"SIGBUS", "Bus error"},
-  {"SIGSEGV", "Segmentation fault"},
-  {"SIGSYS", "Bad system call"},
-  {"SIGPIPE", "Broken pipe"},
-  {"SIGALRM", "Alarm clock"},
-  {"SIGTERM", "Terminated"},
-  {"SIGURG", "Urgent I/O condition"},
-  {"SIGSTOP", "Stopped (signal)"},
-  {"SIGTSTP", "Stopped (user)"},
-  {"SIGCONT", "Continued"},
-  {"SIGCHLD", "Child status changed"},
-  {"SIGTTIN", "Stopped (tty input)"},
-  {"SIGTTOU", "Stopped (tty output)"},
-  {"SIGIO", "I/O possible"},
-  {"SIGXCPU", "CPU time limit exceeded"},
-  {"SIGXFSZ", "File size limit exceeded"},
-  {"SIGVTALRM", "Virtual timer expired"},
-  {"SIGPROF", "Profiling timer expired"},
-  {"SIGWINCH", "Window size changed"},
-  {"SIGLOST", "Resource lost"},
-  {"SIGUSR1", "User defined signal 1"},
-  {"SIGUSR2", "User defined signal 2"},
-  {"SIGPWR", "Power fail/restart"},
-  {"SIGPOLL", "Pollable event occurred"},
-  {"SIGWIND", "SIGWIND"},
-  {"SIGPHONE", "SIGPHONE"},
-  {"SIGWAITING", "Process's LWPs are blocked"},
-  {"SIGLWP", "Signal LWP"},
-  {"SIGDANGER", "Swap space dangerously low"},
-  {"SIGGRANT", "Monitor mode granted"},
-  {"SIGRETRACT", "Need to relinquish monitor mode"},
-  {"SIGMSG", "Monitor mode data available"},
-  {"SIGSOUND", "Sound completed"},
-  {"SIGSAK", "Secure attention"},
-  {"SIGPRIO", "SIGPRIO"},
-  {"SIG33", "Real-time event 33"},
-  {"SIG34", "Real-time event 34"},
-  {"SIG35", "Real-time event 35"},
-  {"SIG36", "Real-time event 36"},
-  {"SIG37", "Real-time event 37"},
-  {"SIG38", "Real-time event 38"},
-  {"SIG39", "Real-time event 39"},
-  {"SIG40", "Real-time event 40"},
-  {"SIG41", "Real-time event 41"},
-  {"SIG42", "Real-time event 42"},
-  {"SIG43", "Real-time event 43"},
-  {"SIG44", "Real-time event 44"},
-  {"SIG45", "Real-time event 45"},
-  {"SIG46", "Real-time event 46"},
-  {"SIG47", "Real-time event 47"},
-  {"SIG48", "Real-time event 48"},
-  {"SIG49", "Real-time event 49"},
-  {"SIG50", "Real-time event 50"},
-  {"SIG51", "Real-time event 51"},
-  {"SIG52", "Real-time event 52"},
-  {"SIG53", "Real-time event 53"},
-  {"SIG54", "Real-time event 54"},
-  {"SIG55", "Real-time event 55"},
-  {"SIG56", "Real-time event 56"},
-  {"SIG57", "Real-time event 57"},
-  {"SIG58", "Real-time event 58"},
-  {"SIG59", "Real-time event 59"},
-  {"SIG60", "Real-time event 60"},
-  {"SIG61", "Real-time event 61"},
-  {"SIG62", "Real-time event 62"},
-  {"SIG63", "Real-time event 63"},
-
-#if defined(MACH) || defined(__MACH__)
-  /* Mach exceptions */
-  {"EXC_BAD_ACCESS", "Could not access memory"},
-  {"EXC_BAD_INSTRUCTION", "Illegal instruction/operand"},
-  {"EXC_ARITHMETIC", "Arithmetic exception"},
-  {"EXC_EMULATION", "Emulation instruction"},
-  {"EXC_SOFTWARE", "Software generated exception"},
-  {"EXC_BREAKPOINT", "Breakpoint"},
-#endif
-  {NULL, "Unknown signal"},
-  {NULL, "Internal error: printing TARGET_SIGNAL_DEFAULT"},
-
-  /* Last entry, used to check whether the table is the right size.  */
-  {NULL, "TARGET_SIGNAL_MAGIC"}
-};
-
-/* Return the string for a signal.  */
-char *
-target_signal_to_string (sig)
-     enum target_signal sig;
-{
-  return signals[sig].string;
-}
-
-/* Return the name for a signal.  */
-char *
-target_signal_to_name (sig)
-     enum target_signal sig;
-{
-  if (sig == TARGET_SIGNAL_UNKNOWN)
-    /* I think the code which prints this will always print it along with
-       the string, so no need to be verbose.  */
-    return "?";
-  return signals[sig].name;
-}
-
-/* Given a name, return its signal.  */
-enum target_signal
-target_signal_from_name (name)
-     char *name;
-{
-  enum target_signal sig;
-
-  /* It's possible we also should allow "SIGCLD" as well as "SIGCHLD"
-     for TARGET_SIGNAL_SIGCHLD.  SIGIOT, on the other hand, is more
-     questionable; seems like by now people should call it SIGABRT
-     instead.  */
 
-  /* This ugly cast brought to you by the native VAX compiler.  */
-  for (sig = TARGET_SIGNAL_HUP;
-       signals[sig].name != NULL;
-       sig = (enum target_signal)((int)sig + 1))
-    if (STREQ (name, signals[sig].name))
-      return sig;
-  return TARGET_SIGNAL_UNKNOWN;
+  if (detach_hook)
+    detach_hook ();
 }
 
-/* The following functions are to help certain targets deal
-   with the signal/waitstatus stuff.  They could just as well be in
-   a file called native-utils.c or unixwaitstatus-utils.c or whatever.  */
-
-/* Convert host signal to our signals.  */
-enum target_signal
-target_signal_from_host (hostsig)
-     int hostsig;
-{
-  /* A switch statement would make sense but would require special kludges
-     to deal with the cases where more than one signal has the same number.  */
-
-  if (hostsig == 0) return TARGET_SIGNAL_0;
-
-#if defined (SIGHUP)
-  if (hostsig == SIGHUP) return TARGET_SIGNAL_HUP;
-#endif
-#if defined (SIGINT)
-  if (hostsig == SIGINT) return TARGET_SIGNAL_INT;
-#endif
-#if defined (SIGQUIT)
-  if (hostsig == SIGQUIT) return TARGET_SIGNAL_QUIT;
-#endif
-#if defined (SIGILL)
-  if (hostsig == SIGILL) return TARGET_SIGNAL_ILL;
-#endif
-#if defined (SIGTRAP)
-  if (hostsig == SIGTRAP) return TARGET_SIGNAL_TRAP;
-#endif
-#if defined (SIGABRT)
-  if (hostsig == SIGABRT) return TARGET_SIGNAL_ABRT;
-#endif
-#if defined (SIGEMT)
-  if (hostsig == SIGEMT) return TARGET_SIGNAL_EMT;
-#endif
-#if defined (SIGFPE)
-  if (hostsig == SIGFPE) return TARGET_SIGNAL_FPE;
-#endif
-#if defined (SIGKILL)
-  if (hostsig == SIGKILL) return TARGET_SIGNAL_KILL;
-#endif
-#if defined (SIGBUS)
-  if (hostsig == SIGBUS) return TARGET_SIGNAL_BUS;
-#endif
-#if defined (SIGSEGV)
-  if (hostsig == SIGSEGV) return TARGET_SIGNAL_SEGV;
-#endif
-#if defined (SIGSYS)
-  if (hostsig == SIGSYS) return TARGET_SIGNAL_SYS;
-#endif
-#if defined (SIGPIPE)
-  if (hostsig == SIGPIPE) return TARGET_SIGNAL_PIPE;
-#endif
-#if defined (SIGALRM)
-  if (hostsig == SIGALRM) return TARGET_SIGNAL_ALRM;
-#endif
-#if defined (SIGTERM)
-  if (hostsig == SIGTERM) return TARGET_SIGNAL_TERM;
-#endif
-#if defined (SIGUSR1)
-  if (hostsig == SIGUSR1) return TARGET_SIGNAL_USR1;
-#endif
-#if defined (SIGUSR2)
-  if (hostsig == SIGUSR2) return TARGET_SIGNAL_USR2;
-#endif
-#if defined (SIGCLD)
-  if (hostsig == SIGCLD) return TARGET_SIGNAL_CHLD;
-#endif
-#if defined (SIGCHLD)
-  if (hostsig == SIGCHLD) return TARGET_SIGNAL_CHLD;
-#endif
-#if defined (SIGPWR)
-  if (hostsig == SIGPWR) return TARGET_SIGNAL_PWR;
-#endif
-#if defined (SIGWINCH)
-  if (hostsig == SIGWINCH) return TARGET_SIGNAL_WINCH;
-#endif
-#if defined (SIGURG)
-  if (hostsig == SIGURG) return TARGET_SIGNAL_URG;
-#endif
-#if defined (SIGIO)
-  if (hostsig == SIGIO) return TARGET_SIGNAL_IO;
-#endif
-#if defined (SIGPOLL)
-  if (hostsig == SIGPOLL) return TARGET_SIGNAL_POLL;
-#endif
-#if defined (SIGSTOP)
-  if (hostsig == SIGSTOP) return TARGET_SIGNAL_STOP;
-#endif
-#if defined (SIGTSTP)
-  if (hostsig == SIGTSTP) return TARGET_SIGNAL_TSTP;
-#endif
-#if defined (SIGCONT)
-  if (hostsig == SIGCONT) return TARGET_SIGNAL_CONT;
-#endif
-#if defined (SIGTTIN)
-  if (hostsig == SIGTTIN) return TARGET_SIGNAL_TTIN;
-#endif
-#if defined (SIGTTOU)
-  if (hostsig == SIGTTOU) return TARGET_SIGNAL_TTOU;
-#endif
-#if defined (SIGVTALRM)
-  if (hostsig == SIGVTALRM) return TARGET_SIGNAL_VTALRM;
-#endif
-#if defined (SIGPROF)
-  if (hostsig == SIGPROF) return TARGET_SIGNAL_PROF;
-#endif
-#if defined (SIGXCPU)
-  if (hostsig == SIGXCPU) return TARGET_SIGNAL_XCPU;
-#endif
-#if defined (SIGXFSZ)
-  if (hostsig == SIGXFSZ) return TARGET_SIGNAL_XFSZ;
-#endif
-#if defined (SIGWIND)
-  if (hostsig == SIGWIND) return TARGET_SIGNAL_WIND;
-#endif
-#if defined (SIGPHONE)
-  if (hostsig == SIGPHONE) return TARGET_SIGNAL_PHONE;
-#endif
-#if defined (SIGLOST)
-  if (hostsig == SIGLOST) return TARGET_SIGNAL_LOST;
-#endif
-#if defined (SIGWAITING)
-  if (hostsig == SIGWAITING) return TARGET_SIGNAL_WAITING;
-#endif
-#if defined (SIGLWP)
-  if (hostsig == SIGLWP) return TARGET_SIGNAL_LWP;
-#endif
-#if defined (SIGDANGER)
-  if (hostsig == SIGDANGER) return TARGET_SIGNAL_DANGER;
-#endif
-#if defined (SIGGRANT)
-  if (hostsig == SIGGRANT) return TARGET_SIGNAL_GRANT;
-#endif
-#if defined (SIGRETRACT)
-  if (hostsig == SIGRETRACT) return TARGET_SIGNAL_RETRACT;
-#endif
-#if defined (SIGMSG)
-  if (hostsig == SIGMSG) return TARGET_SIGNAL_MSG;
-#endif
-#if defined (SIGSOUND)
-  if (hostsig == SIGSOUND) return TARGET_SIGNAL_SOUND;
-#endif
-#if defined (SIGSAK)
-  if (hostsig == SIGSAK) return TARGET_SIGNAL_SAK;
-#endif
-#if defined (SIGPRIO)
-  if (hostsig == SIGPRIO) return TARGET_SIGNAL_PRIO;
-#endif
-
-  /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
-#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
-  if (hostsig == _NSIG + EXC_BAD_ACCESS) return TARGET_EXC_BAD_ACCESS;
-#endif
-#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
-  if (hostsig == _NSIG + EXC_BAD_INSTRUCTION) return TARGET_EXC_BAD_INSTRUCTION;
-#endif
-#if defined (EXC_ARITHMETIC) && defined (_NSIG)
-  if (hostsig == _NSIG + EXC_ARITHMETIC) return TARGET_EXC_ARITHMETIC;
-#endif
-#if defined (EXC_EMULATION) && defined (_NSIG)
-  if (hostsig == _NSIG + EXC_EMULATION) return TARGET_EXC_EMULATION;
-#endif
-#if defined (EXC_SOFTWARE) && defined (_NSIG)
-  if (hostsig == _NSIG + EXC_SOFTWARE) return TARGET_EXC_SOFTWARE;
-#endif
-#if defined (EXC_BREAKPOINT) && defined (_NSIG)
-  if (hostsig == _NSIG + EXC_BREAKPOINT) return TARGET_EXC_BREAKPOINT;
-#endif
-
-#if defined (REALTIME_LO)
-  if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
-    return (enum target_signal)
-      (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
-#endif
-  return TARGET_SIGNAL_UNKNOWN;
-}
-
-int
-target_signal_to_host (oursig)
-     enum target_signal oursig;
-{
-  switch (oursig)
-    {
-    case TARGET_SIGNAL_0: return 0;
-
-#if defined (SIGHUP)
-    case TARGET_SIGNAL_HUP: return SIGHUP;
-#endif
-#if defined (SIGINT)
-    case TARGET_SIGNAL_INT: return SIGINT;
-#endif
-#if defined (SIGQUIT)
-    case TARGET_SIGNAL_QUIT: return SIGQUIT;
-#endif
-#if defined (SIGILL)
-    case TARGET_SIGNAL_ILL: return SIGILL;
-#endif
-#if defined (SIGTRAP)
-    case TARGET_SIGNAL_TRAP: return SIGTRAP;
-#endif
-#if defined (SIGABRT)
-    case TARGET_SIGNAL_ABRT: return SIGABRT;
-#endif
-#if defined (SIGEMT)
-    case TARGET_SIGNAL_EMT: return SIGEMT;
-#endif
-#if defined (SIGFPE)
-    case TARGET_SIGNAL_FPE: return SIGFPE;
-#endif
-#if defined (SIGKILL)
-    case TARGET_SIGNAL_KILL: return SIGKILL;
-#endif
-#if defined (SIGBUS)
-    case TARGET_SIGNAL_BUS: return SIGBUS;
-#endif
-#if defined (SIGSEGV)
-    case TARGET_SIGNAL_SEGV: return SIGSEGV;
-#endif
-#if defined (SIGSYS)
-    case TARGET_SIGNAL_SYS: return SIGSYS;
-#endif
-#if defined (SIGPIPE)
-    case TARGET_SIGNAL_PIPE: return SIGPIPE;
-#endif
-#if defined (SIGALRM)
-    case TARGET_SIGNAL_ALRM: return SIGALRM;
-#endif
-#if defined (SIGTERM)
-    case TARGET_SIGNAL_TERM: return SIGTERM;
-#endif
-#if defined (SIGUSR1)
-    case TARGET_SIGNAL_USR1: return SIGUSR1;
-#endif
-#if defined (SIGUSR2)
-    case TARGET_SIGNAL_USR2: return SIGUSR2;
-#endif
-#if defined (SIGCHLD) || defined (SIGCLD)
-    case TARGET_SIGNAL_CHLD: 
-#if defined (SIGCHLD)
-      return SIGCHLD;
-#else
-      return SIGCLD;
-#endif
-#endif /* SIGCLD or SIGCHLD */
-#if defined (SIGPWR)
-    case TARGET_SIGNAL_PWR: return SIGPWR;
-#endif
-#if defined (SIGWINCH)
-    case TARGET_SIGNAL_WINCH: return SIGWINCH;
-#endif
-#if defined (SIGURG)
-    case TARGET_SIGNAL_URG: return SIGURG;
-#endif
-#if defined (SIGIO)
-    case TARGET_SIGNAL_IO: return SIGIO;
-#endif
-#if defined (SIGPOLL)
-    case TARGET_SIGNAL_POLL: return SIGPOLL;
-#endif
-#if defined (SIGSTOP)
-    case TARGET_SIGNAL_STOP: return SIGSTOP;
-#endif
-#if defined (SIGTSTP)
-    case TARGET_SIGNAL_TSTP: return SIGTSTP;
-#endif
-#if defined (SIGCONT)
-    case TARGET_SIGNAL_CONT: return SIGCONT;
-#endif
-#if defined (SIGTTIN)
-    case TARGET_SIGNAL_TTIN: return SIGTTIN;
-#endif
-#if defined (SIGTTOU)
-    case TARGET_SIGNAL_TTOU: return SIGTTOU;
-#endif
-#if defined (SIGVTALRM)
-    case TARGET_SIGNAL_VTALRM: return SIGVTALRM;
-#endif
-#if defined (SIGPROF)
-    case TARGET_SIGNAL_PROF: return SIGPROF;
-#endif
-#if defined (SIGXCPU)
-    case TARGET_SIGNAL_XCPU: return SIGXCPU;
-#endif
-#if defined (SIGXFSZ)
-    case TARGET_SIGNAL_XFSZ: return SIGXFSZ;
-#endif
-#if defined (SIGWIND)
-    case TARGET_SIGNAL_WIND: return SIGWIND;
-#endif
-#if defined (SIGPHONE)
-    case TARGET_SIGNAL_PHONE: return SIGPHONE;
-#endif
-#if defined (SIGLOST)
-    case TARGET_SIGNAL_LOST: return SIGLOST;
-#endif
-#if defined (SIGWAITING)
-    case TARGET_SIGNAL_WAITING: return SIGWAITING;
-#endif
-#if defined (SIGLWP)
-    case TARGET_SIGNAL_LWP: return SIGLWP;
-#endif
-#if defined (SIGDANGER)
-    case TARGET_SIGNAL_DANGER: return SIGDANGER;
-#endif
-#if defined (SIGGRANT)
-    case TARGET_SIGNAL_GRANT: return SIGGRANT;
-#endif
-#if defined (SIGRETRACT)
-    case TARGET_SIGNAL_RETRACT: return SIGRETRACT;
-#endif
-#if defined (SIGMSG)
-    case TARGET_SIGNAL_MSG: return SIGMSG;
-#endif
-#if defined (SIGSOUND)
-    case TARGET_SIGNAL_SOUND: return SIGSOUND;
-#endif
-#if defined (SIGSAK)
-    case TARGET_SIGNAL_SAK: return SIGSAK;
-#endif
-#if defined (SIGPRIO)
-    case TARGET_SIGNAL_PRIO: return SIGPRIO;
-#endif
-
-      /* Mach exceptions.  Assumes that the values for EXC_ are positive! */
-#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
-    case TARGET_EXC_BAD_ACCESS: return _NSIG + EXC_BAD_ACCESS;
-#endif
-#if defined (EXC_BAD_INSTRUCTION) && defined (_NSIG)
-    case TARGET_EXC_BAD_INSTRUCTION: return _NSIG + EXC_BAD_INSTRUCTION;
-#endif
-#if defined (EXC_ARITHMETIC) && defined (_NSIG)
-    case TARGET_EXC_ARITHMETIC: return _NSIG + EXC_ARITHMETIC;
-#endif
-#if defined (EXC_EMULATION) && defined (_NSIG)
-    case TARGET_EXC_EMULATION: return _NSIG + EXC_EMULATION;
-#endif
-#if defined (EXC_SOFTWARE) && defined (_NSIG)
-    case TARGET_EXC_SOFTWARE: return _NSIG + EXC_SOFTWARE;
-#endif
-#if defined (EXC_BREAKPOINT) && defined (_NSIG)
-    case TARGET_EXC_BREAKPOINT: return _NSIG + EXC_BREAKPOINT;
-#endif
-
-    default:
-#if defined (REALTIME_LO)
-      if (oursig >= TARGET_SIGNAL_REALTIME_33
-	  && oursig <= TARGET_SIGNAL_REALTIME_63)
-	{
-	  int retsig =
-	    (int)oursig - (int)TARGET_SIGNAL_REALTIME_33 + REALTIME_LO;
-	  if (retsig < REALTIME_HI)
-	    return retsig;
-	}
-#endif
-      /* The user might be trying to do "signal SIGSAK" where this system
-	 doesn't have SIGSAK.  */
-      warning ("Signal %s does not exist on this system.\n",
-	       target_signal_to_name (oursig));
-      return 0;
-    }
-}
-
 /* Helper function for child_wait and the Lynx derivatives of child_wait.
    HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
    translation of that in OURSTATUS.  */
 void
-store_waitstatus (ourstatus, hoststatus)
-     struct target_waitstatus *ourstatus;
-     int hoststatus;
+store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
 {
 #ifdef CHILD_SPECIAL_WAITSTATUS
   /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
@@ -1691,42 +1458,19 @@ store_waitstatus (ourstatus, hoststatus)
     }
 }
 
-/* In some circumstances we allow a command to specify a numeric
-   signal.  The idea is to keep these circumstances limited so that
-   users (and scripts) develop portable habits.  For comparison,
-   POSIX.2 `kill' requires that 1,2,3,6,9,14, and 15 work (and using a
-   numeric signal at all is obscelescent.  We are slightly more
-   lenient and allow 1-15 which should match host signal numbers on
-   most systems.  Use of symbolic signal names is strongly encouraged.  */
-
-enum target_signal
-target_signal_from_command (num)
-     int num;
-{
-  if (num >= 1 && num <= 15)
-    return (enum target_signal)num;
-  error ("Only signals 1-15 are valid as numeric signals.\n\
-Use \"info signals\" for a list of symbolic signals.");
-}
-
 /* Returns zero to leave the inferior alone, one to interrupt it.  */
-int (*target_activity_function) PARAMS ((void));
+int (*target_activity_function) (void);
 int target_activity_fd;
 
 /* Convert a normal process ID to a string.  Returns the string in a static
    buffer.  */
 
 char *
-normal_pid_to_str (pid)
-     int pid;
+normal_pid_to_str (ptid_t ptid)
 {
   static char buf[30];
 
-  if (STREQ (current_target.to_shortname, "remote"))
-    sprintf (buf, "thread %d\0", pid);
-  else
-    sprintf (buf, "process %d\0", pid);
-
+  sprintf (buf, "process %d", PIDGET (ptid));
   return buf;
 }
 
@@ -1737,23 +1481,38 @@ normal_pid_to_str (pid)
    if the shell init file has commands in it, the shell will fork and
    exec for each of those commands, and we will see each such fork
    event.  Very bad.)
-   
+
    This function is used by all targets that allow us to request
    notification of forks, etc at inferior creation time; e.g., in
    target_acknowledge_forked_child.
-   */
-void
-normal_target_post_startup_inferior (pid)
-  int  pid;
+ */
+static void
+normal_target_post_startup_inferior (ptid_t ptid)
 {
   /* This space intentionally left blank. */
 }
 
+/* Error-catcher for target_find_memory_regions */
+/* ARGSUSED */
+static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
+{
+  error ("No target.");
+  return 0;
+}
+
+/* Error-catcher for target_make_corefile_notes */
+/* ARGSUSED */
+static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
+{
+  error ("No target.");
+  return NULL;
+}
+
 /* Set up the handful of non-empty slots needed by the dummy target
    vector.  */
 
 static void
-init_dummy_target ()
+init_dummy_target (void)
 {
   dummy_target.to_shortname = "None";
   dummy_target.to_longname = "None";
@@ -1763,142 +1522,127 @@ init_dummy_target ()
   dummy_target.to_require_detach = find_default_require_detach;
   dummy_target.to_create_inferior = find_default_create_inferior;
   dummy_target.to_clone_and_follow_inferior = find_default_clone_and_follow_inferior;
+  dummy_target.to_pid_to_str = normal_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;
   dummy_target.to_magic = OPS_MAGIC;
 }
-
 
-#ifdef MAINTENANCE_CMDS
+
 static struct target_ops debug_target;
 
 static void
-debug_to_open (args, from_tty)
-     char *args;
-     int from_tty;
+debug_to_open (char *args, int from_tty)
 {
   debug_target.to_open (args, from_tty);
 
-  fprintf_unfiltered (gdb_stderr, "target_open (%s, %d)\n", args, from_tty);
+  fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
 }
 
 static void
-debug_to_close (quitting)
-     int quitting;
+debug_to_close (int quitting)
 {
   debug_target.to_close (quitting);
 
-  fprintf_unfiltered (gdb_stderr, "target_close (%d)\n", quitting);
+  fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
 }
 
 static void
-debug_to_attach (args, from_tty)
-     char *args;
-     int from_tty;
+debug_to_attach (char *args, int from_tty)
 {
   debug_target.to_attach (args, from_tty);
 
-  fprintf_unfiltered (gdb_stderr, "target_attach (%s, %d)\n", args, from_tty);
+  fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
 }
 
 
 static void
-debug_to_post_attach (pid)
-  int  pid;
+debug_to_post_attach (int pid)
 {
   debug_target.to_post_attach (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_post_attach (%d)\n", pid);
+  fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
 }
 
 static void
-debug_to_require_attach (args, from_tty)
-     char *args;
-     int from_tty;
+debug_to_require_attach (char *args, int from_tty)
 {
   debug_target.to_require_attach (args, from_tty);
 
-  fprintf_unfiltered (gdb_stderr,
+  fprintf_unfiltered (gdb_stdlog,
 		      "target_require_attach (%s, %d)\n", args, from_tty);
 }
 
 static void
-debug_to_detach (args, from_tty)
-     char *args;
-     int from_tty;
+debug_to_detach (char *args, int from_tty)
 {
   debug_target.to_detach (args, from_tty);
 
-  fprintf_unfiltered (gdb_stderr, "target_detach (%s, %d)\n", args, from_tty);
+  fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
 }
 
 static void
-debug_to_require_detach (pid, args, from_tty)
-  int  pid;
-  char *  args;
-  int  from_tty;
+debug_to_require_detach (int pid, char *args, int from_tty)
 {
   debug_target.to_require_detach (pid, args, from_tty);
 
-  fprintf_unfiltered (gdb_stderr,
-		      "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
+  fprintf_unfiltered (gdb_stdlog,
+	       "target_require_detach (%d, %s, %d)\n", pid, args, from_tty);
 }
 
 static void
-debug_to_resume (pid, step, siggnal)
-     int pid;
-     int step;
-     enum target_signal siggnal;
+debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
 {
-  debug_target.to_resume (pid, step, siggnal);
+  debug_target.to_resume (ptid, step, siggnal);
 
-  fprintf_unfiltered (gdb_stderr, "target_resume (%d, %s, %s)\n", pid,
+  fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
 		      step ? "step" : "continue",
 		      target_signal_to_name (siggnal));
 }
 
-static int
-debug_to_wait (pid, status)
-     int pid;
-     struct target_waitstatus *status;
+static ptid_t
+debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
 {
-  int retval;
+  ptid_t retval;
 
-  retval = debug_target.to_wait (pid, status);
+  retval = debug_target.to_wait (ptid, status);
 
-  fprintf_unfiltered (gdb_stderr,
-		      "target_wait (%d, status) = %d,   ", pid, retval);
-  fprintf_unfiltered (gdb_stderr, "status->kind = ");
+  fprintf_unfiltered (gdb_stdlog,
+		      "target_wait (%d, status) = %d,   ", PIDGET (ptid),
+		      PIDGET (retval));
+  fprintf_unfiltered (gdb_stdlog, "status->kind = ");
   switch (status->kind)
     {
     case TARGET_WAITKIND_EXITED:
-      fprintf_unfiltered (gdb_stderr, "exited, status = %d\n",
+      fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
 			  status->value.integer);
       break;
     case TARGET_WAITKIND_STOPPED:
-      fprintf_unfiltered (gdb_stderr, "stopped, signal = %s\n",
+      fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
 			  target_signal_to_name (status->value.sig));
       break;
     case TARGET_WAITKIND_SIGNALLED:
-      fprintf_unfiltered (gdb_stderr, "signalled, signal = %s\n",
+      fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
 			  target_signal_to_name (status->value.sig));
       break;
     case TARGET_WAITKIND_LOADED:
-      fprintf_unfiltered (gdb_stderr, "loaded\n");
+      fprintf_unfiltered (gdb_stdlog, "loaded\n");
       break;
     case TARGET_WAITKIND_FORKED:
-      fprintf_unfiltered (gdb_stderr, "forked\n");
+      fprintf_unfiltered (gdb_stdlog, "forked\n");
       break;
     case TARGET_WAITKIND_VFORKED:
-      fprintf_unfiltered (gdb_stderr, "vforked\n");
+      fprintf_unfiltered (gdb_stdlog, "vforked\n");
       break;
     case TARGET_WAITKIND_EXECD:
-      fprintf_unfiltered (gdb_stderr, "execd\n");
+      fprintf_unfiltered (gdb_stdlog, "execd\n");
       break;
     case TARGET_WAITKIND_SPURIOUS:
-      fprintf_unfiltered (gdb_stderr, "spurious\n");
+      fprintf_unfiltered (gdb_stdlog, "spurious\n");
       break;
     default:
-      fprintf_unfiltered (gdb_stderr, "unknown???\n");
+      fprintf_unfiltered (gdb_stdlog, "unknown???\n");
       break;
     }
 
@@ -1906,592 +1650,547 @@ debug_to_wait (pid, status)
 }
 
 static void
-debug_to_post_wait (pid, status)
-  int  pid;
-  int  status;
+debug_to_post_wait (ptid_t ptid, int status)
 {
-  debug_target.to_post_wait (pid, status);
+  debug_target.to_post_wait (ptid, status);
 
-  fprintf_unfiltered (gdb_stderr, "target_post_wait (%d, %d)\n",
-		      pid, status);
+  fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
+		      PIDGET (ptid), status);
 }
 
 static void
-debug_to_fetch_registers (regno)
-     int regno;
+debug_to_fetch_registers (int regno)
 {
   debug_target.to_fetch_registers (regno);
 
-  fprintf_unfiltered (gdb_stderr, "target_fetch_registers (%s)",
+  fprintf_unfiltered (gdb_stdlog, "target_fetch_registers (%s)",
 		      regno != -1 ? REGISTER_NAME (regno) : "-1");
   if (regno != -1)
-    fprintf_unfiltered (gdb_stderr, " = 0x%x %d",
+    fprintf_unfiltered (gdb_stdlog, " = 0x%lx %ld",
 			(unsigned long) read_register (regno),
-			read_register (regno));
-  fprintf_unfiltered (gdb_stderr, "\n");
+			(unsigned long) read_register (regno));
+  fprintf_unfiltered (gdb_stdlog, "\n");
 }
 
 static void
-debug_to_store_registers (regno)
-     int regno;
+debug_to_store_registers (int regno)
 {
   debug_target.to_store_registers (regno);
 
   if (regno >= 0 && regno < NUM_REGS)
-    fprintf_unfiltered (gdb_stderr, "target_store_registers (%s) = 0x%x %d\n",
+    fprintf_unfiltered (gdb_stdlog, "target_store_registers (%s) = 0x%lx %ld\n",
 			REGISTER_NAME (regno),
 			(unsigned long) read_register (regno),
 			(unsigned long) read_register (regno));
   else
-    fprintf_unfiltered (gdb_stderr, "target_store_registers (%d)\n", regno);
+    fprintf_unfiltered (gdb_stdlog, "target_store_registers (%d)\n", regno);
 }
 
 static void
-debug_to_prepare_to_store ()
+debug_to_prepare_to_store (void)
 {
   debug_target.to_prepare_to_store ();
 
-  fprintf_unfiltered (gdb_stderr, "target_prepare_to_store ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
 }
 
 static int
-debug_to_xfer_memory (memaddr, myaddr, len, write, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     struct target_ops *target;
+debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+		      struct mem_attrib *attrib,
+		      struct target_ops *target)
 {
   int retval;
 
-  retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write, target);
+  retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write,
+					attrib, target);
 
-  fprintf_unfiltered (gdb_stderr,
+  fprintf_unfiltered (gdb_stdlog,
 		      "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
-		      (unsigned int) memaddr, /* possable truncate long long */
+		      (unsigned int) memaddr,	/* possable truncate long long */
 		      len, write ? "write" : "read", retval);
 
-  
+
 
   if (retval > 0)
     {
       int i;
 
-      fputs_unfiltered (", bytes =", gdb_stderr);
+      fputs_unfiltered (", bytes =", gdb_stdlog);
       for (i = 0; i < retval; i++)
 	{
 	  if ((((long) &(myaddr[i])) & 0xf) == 0)
-	    fprintf_unfiltered (gdb_stderr, "\n");
-	  fprintf_unfiltered (gdb_stderr, " %02x", myaddr[i] & 0xff);
+	    fprintf_unfiltered (gdb_stdlog, "\n");
+	  fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
 	}
     }
 
-  fputc_unfiltered ('\n', gdb_stderr);
+  fputc_unfiltered ('\n', gdb_stdlog);
 
   return retval;
 }
 
 static void
-debug_to_files_info (target)
-     struct target_ops *target;
+debug_to_files_info (struct target_ops *target)
 {
   debug_target.to_files_info (target);
 
-  fprintf_unfiltered (gdb_stderr, "target_files_info (xxx)\n");
+  fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
 }
 
 static int
-debug_to_insert_breakpoint (addr, save)
-     CORE_ADDR addr;
-     char *save;
+debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
 {
   int retval;
 
   retval = debug_target.to_insert_breakpoint (addr, save);
 
-  fprintf_unfiltered (gdb_stderr,
-		      "target_insert_breakpoint (0x%x, xxx) = %d\n",
-		      (unsigned long) addr, retval);
+  fprintf_unfiltered (gdb_stdlog,
+		      "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
+		      (unsigned long) addr,
+		      (unsigned long) retval);
   return retval;
 }
 
 static int
-debug_to_remove_breakpoint (addr, save)
-     CORE_ADDR addr;
-     char *save;
+debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
 {
   int retval;
 
   retval = debug_target.to_remove_breakpoint (addr, save);
 
-  fprintf_unfiltered (gdb_stderr,
-		      "target_remove_breakpoint (0x%x, xxx) = %d\n",
-		      (unsigned long)addr, retval);
+  fprintf_unfiltered (gdb_stdlog,
+		      "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
+		      (unsigned long) addr,
+		      (unsigned long) retval);
   return retval;
 }
 
 static void
-debug_to_terminal_init ()
+debug_to_terminal_init (void)
 {
   debug_target.to_terminal_init ();
 
-  fprintf_unfiltered (gdb_stderr, "target_terminal_init ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
 }
 
 static void
-debug_to_terminal_inferior ()
+debug_to_terminal_inferior (void)
 {
   debug_target.to_terminal_inferior ();
 
-  fprintf_unfiltered (gdb_stderr, "target_terminal_inferior ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
 }
 
 static void
-debug_to_terminal_ours_for_output ()
+debug_to_terminal_ours_for_output (void)
 {
   debug_target.to_terminal_ours_for_output ();
 
-  fprintf_unfiltered (gdb_stderr, "target_terminal_ours_for_output ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
 }
 
 static void
-debug_to_terminal_ours ()
+debug_to_terminal_ours (void)
 {
   debug_target.to_terminal_ours ();
 
-  fprintf_unfiltered (gdb_stderr, "target_terminal_ours ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
 }
 
 static void
-debug_to_terminal_info (arg, from_tty)
-     char *arg;
-     int from_tty;
+debug_to_terminal_info (char *arg, int from_tty)
 {
   debug_target.to_terminal_info (arg, from_tty);
 
-  fprintf_unfiltered (gdb_stderr, "target_terminal_info (%s, %d)\n", arg,
+  fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
 		      from_tty);
 }
 
 static void
-debug_to_kill ()
+debug_to_kill (void)
 {
   debug_target.to_kill ();
 
-  fprintf_unfiltered (gdb_stderr, "target_kill ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
 }
 
 static void
-debug_to_load (args, from_tty)
-     char *args;
-     int from_tty;
+debug_to_load (char *args, int from_tty)
 {
   debug_target.to_load (args, from_tty);
 
-  fprintf_unfiltered (gdb_stderr, "target_load (%s, %d)\n", args, from_tty);
+  fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
 }
 
 static int
-debug_to_lookup_symbol (name, addrp)
-     char *name;
-     CORE_ADDR *addrp;
+debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
 {
   int retval;
 
   retval = debug_target.to_lookup_symbol (name, addrp);
 
-  fprintf_unfiltered (gdb_stderr, "target_lookup_symbol (%s, xxx)\n", name);
+  fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
 
   return retval;
 }
 
 static void
-debug_to_create_inferior (exec_file, args, env)
-     char *exec_file;
-     char *args;
-     char **env;
+debug_to_create_inferior (char *exec_file, char *args, char **env)
 {
   debug_target.to_create_inferior (exec_file, args, env);
 
-  fprintf_unfiltered (gdb_stderr, "target_create_inferior (%s, %s, xxx)\n",
+  fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx)\n",
 		      exec_file, args);
 }
 
 static void
-debug_to_post_startup_inferior (pid)
-  int  pid;
+debug_to_post_startup_inferior (ptid_t ptid)
 {
-  debug_target.to_post_startup_inferior (pid);
+  debug_target.to_post_startup_inferior (ptid);
 
-  fprintf_unfiltered (gdb_stderr, "target_post_startup_inferior (%d)\n",
-		      pid);
+  fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
+		      PIDGET (ptid));
 }
 
 static void
-debug_to_acknowledge_created_inferior (pid)
-  int  pid;
+debug_to_acknowledge_created_inferior (int pid)
 {
   debug_target.to_acknowledge_created_inferior (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_acknowledge_created_inferior (%d)\n",
+  fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
 		      pid);
 }
 
 static void
-debug_to_clone_and_follow_inferior (child_pid, followed_child)
-  int  child_pid;
-  int  *followed_child;
+debug_to_clone_and_follow_inferior (int child_pid, int *followed_child)
 {
   debug_target.to_clone_and_follow_inferior (child_pid, followed_child);
 
-  fprintf_unfiltered (gdb_stderr,
+  fprintf_unfiltered (gdb_stdlog,
 		      "target_clone_and_follow_inferior (%d, %d)\n",
 		      child_pid, *followed_child);
 }
 
 static void
-debug_to_post_follow_inferior_by_clone ()
+debug_to_post_follow_inferior_by_clone (void)
 {
   debug_target.to_post_follow_inferior_by_clone ();
 
-  fprintf_unfiltered (gdb_stderr, "target_post_follow_inferior_by_clone ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_post_follow_inferior_by_clone ()\n");
 }
 
 static int
-debug_to_insert_fork_catchpoint (pid)
-  int  pid;
+debug_to_insert_fork_catchpoint (int pid)
 {
-  int  retval;
+  int retval;
 
   retval = debug_target.to_insert_fork_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_insert_fork_catchpoint (%d) = %d\n",
-                      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
+		      pid, retval);
 
   return retval;
 }
 
 static int
-debug_to_remove_fork_catchpoint (pid)
-  int  pid;
+debug_to_remove_fork_catchpoint (int pid)
 {
-  int  retval;
+  int retval;
 
   retval = debug_target.to_remove_fork_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_remove_fork_catchpoint (%d) = %d\n",
-                      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
+		      pid, retval);
 
   return retval;
 }
 
 static int
-debug_to_insert_vfork_catchpoint (pid)
-  int  pid;
+debug_to_insert_vfork_catchpoint (int pid)
 {
-  int  retval;
+  int retval;
 
   retval = debug_target.to_insert_vfork_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_insert_vfork_catchpoint (%d)= %d\n",
-                      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
+		      pid, retval);
 
   return retval;
 }
 
 static int
-debug_to_remove_vfork_catchpoint (pid)
-  int  pid;
+debug_to_remove_vfork_catchpoint (int pid)
 {
-  int  retval;
+  int retval;
 
   retval = debug_target.to_remove_vfork_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_remove_vfork_catchpoint (%d) = %d\n",
-                      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
+		      pid, retval);
 
   return retval;
 }
 
 static int
-debug_to_has_forked (pid, child_pid)
-  int  pid;
-  int *  child_pid;
+debug_to_has_forked (int pid, int *child_pid)
 {
-  int  has_forked;
+  int has_forked;
 
   has_forked = debug_target.to_has_forked (pid, child_pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_has_forked (%d, %d) = %d\n",
-                      pid, *child_pid, has_forked);
+  fprintf_unfiltered (gdb_stdlog, "target_has_forked (%d, %d) = %d\n",
+		      pid, *child_pid, has_forked);
 
   return has_forked;
 }
 
 static int
-debug_to_has_vforked (pid, child_pid)
-  int  pid;
-  int *  child_pid;
+debug_to_has_vforked (int pid, int *child_pid)
 {
-  int  has_vforked;
+  int has_vforked;
 
   has_vforked = debug_target.to_has_vforked (pid, child_pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_has_vforked (%d, %d) = %d\n",
-                      pid, *child_pid, has_vforked);
+  fprintf_unfiltered (gdb_stdlog, "target_has_vforked (%d, %d) = %d\n",
+		      pid, *child_pid, has_vforked);
 
   return has_vforked;
 }
 
 static int
-debug_to_can_follow_vfork_prior_to_exec ()
+debug_to_can_follow_vfork_prior_to_exec (void)
 {
-  int  can_immediately_follow_vfork;
+  int can_immediately_follow_vfork;
 
   can_immediately_follow_vfork = debug_target.to_can_follow_vfork_prior_to_exec ();
 
-  fprintf_unfiltered (gdb_stderr, "target_can_follow_vfork_prior_to_exec () = %d\n",
-                      can_immediately_follow_vfork);
+  fprintf_unfiltered (gdb_stdlog, "target_can_follow_vfork_prior_to_exec () = %d\n",
+		      can_immediately_follow_vfork);
 
   return can_immediately_follow_vfork;
 }
 
 static void
-debug_to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
-  int  parent_pid;
-  int  followed_parent;
-  int  child_pid;
-  int  followed_child;
+debug_to_post_follow_vfork (int parent_pid, int followed_parent, int child_pid,
+			    int followed_child)
 {
   debug_target.to_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child);
 
-  fprintf_unfiltered (gdb_stderr,
+  fprintf_unfiltered (gdb_stdlog,
 		      "target_post_follow_vfork (%d, %d, %d, %d)\n",
-                      parent_pid, followed_parent, child_pid, followed_child);
+		    parent_pid, followed_parent, child_pid, followed_child);
 }
 
 static int
-debug_to_insert_exec_catchpoint (pid)
-  int  pid;
+debug_to_insert_exec_catchpoint (int pid)
 {
-  int  retval;
+  int retval;
 
   retval = debug_target.to_insert_exec_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_insert_exec_catchpoint (%d) = %d\n",
-                      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
+		      pid, retval);
 
   return retval;
 }
 
 static int
-debug_to_remove_exec_catchpoint (pid)
-  int  pid;
+debug_to_remove_exec_catchpoint (int pid)
 {
-  int  retval;
+  int retval;
 
   retval = debug_target.to_remove_exec_catchpoint (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_remove_exec_catchpoint (%d) = %d\n",
-                      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
+		      pid, retval);
 
   return retval;
 }
 
 static int
-debug_to_has_execd (pid, execd_pathname)
-  int  pid;
-  char **  execd_pathname;
+debug_to_has_execd (int pid, char **execd_pathname)
 {
-  int  has_execd;
+  int has_execd;
 
   has_execd = debug_target.to_has_execd (pid, execd_pathname);
 
-  fprintf_unfiltered (gdb_stderr, "target_has_execd (%d, %s) = %d\n",
-                      pid, *execd_pathname, has_execd);
+  fprintf_unfiltered (gdb_stdlog, "target_has_execd (%d, %s) = %d\n",
+		      pid, (*execd_pathname ? *execd_pathname : "<NULL>"),
+		      has_execd);
 
   return has_execd;
 }
 
 static int
-debug_to_reported_exec_events_per_exec_call ()
+debug_to_reported_exec_events_per_exec_call (void)
 {
-  int  reported_exec_events;
+  int reported_exec_events;
 
   reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
 
-  fprintf_unfiltered (gdb_stderr,
+  fprintf_unfiltered (gdb_stdlog,
 		      "target_reported_exec_events_per_exec_call () = %d\n",
-                      reported_exec_events);
+		      reported_exec_events);
 
   return reported_exec_events;
 }
 
 static int
-debug_to_has_syscall_event (pid, kind, syscall_id)
-  int  pid;
-  enum target_waitkind *  kind;
-  int *  syscall_id;
+debug_to_has_syscall_event (int pid, enum target_waitkind *kind,
+			    int *syscall_id)
 {
-  int  has_syscall_event;
-  char *  kind_spelling = "??";
+  int has_syscall_event;
+  char *kind_spelling = "??";
 
   has_syscall_event = debug_target.to_has_syscall_event (pid, kind, syscall_id);
   if (has_syscall_event)
     {
       switch (*kind)
-        {
-          case TARGET_WAITKIND_SYSCALL_ENTRY:
-            kind_spelling = "SYSCALL_ENTRY";
-            break;
-          case TARGET_WAITKIND_SYSCALL_RETURN:
-            kind_spelling = "SYSCALL_RETURN";
-            break;
-          default:
-            break;
-        }
+	{
+	case TARGET_WAITKIND_SYSCALL_ENTRY:
+	  kind_spelling = "SYSCALL_ENTRY";
+	  break;
+	case TARGET_WAITKIND_SYSCALL_RETURN:
+	  kind_spelling = "SYSCALL_RETURN";
+	  break;
+	default:
+	  break;
+	}
     }
 
-  fprintf_unfiltered (gdb_stderr,
+  fprintf_unfiltered (gdb_stdlog,
 		      "target_has_syscall_event (%d, %s, %d) = %d\n",
-                      pid, kind_spelling, *syscall_id, has_syscall_event);
+		      pid, kind_spelling, *syscall_id, has_syscall_event);
 
   return has_syscall_event;
 }
 
 static int
-debug_to_has_exited (pid, wait_status, exit_status)
-  int  pid;
-  int  wait_status;
-  int *  exit_status;
+debug_to_has_exited (int pid, int wait_status, int *exit_status)
 {
-  int  has_exited;
+  int has_exited;
 
   has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
 
-  fprintf_unfiltered (gdb_stderr, "target_has_exited (%d, %d, %d) = %d\n",
-                      pid, wait_status, *exit_status, has_exited);
+  fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
+		      pid, wait_status, *exit_status, has_exited);
 
   return has_exited;
 }
 
 static void
-debug_to_mourn_inferior ()
+debug_to_mourn_inferior (void)
 {
   debug_target.to_mourn_inferior ();
 
-  fprintf_unfiltered (gdb_stderr, "target_mourn_inferior ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
 }
 
 static int
-debug_to_can_run ()
+debug_to_can_run (void)
 {
   int retval;
 
   retval = debug_target.to_can_run ();
 
-  fprintf_unfiltered (gdb_stderr, "target_can_run () = %d\n", retval);
+  fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
 
   return retval;
 }
 
 static void
-debug_to_notice_signals (pid)
-     int pid;
+debug_to_notice_signals (ptid_t ptid)
 {
-  debug_target.to_notice_signals (pid);
+  debug_target.to_notice_signals (ptid);
 
-  fprintf_unfiltered (gdb_stderr, "target_notice_signals (%d)\n", pid);
+  fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
+                      PIDGET (ptid));
 }
 
 static int
-debug_to_thread_alive (pid)
-     int pid;
+debug_to_thread_alive (ptid_t ptid)
 {
   int retval;
 
-  retval = debug_target.to_thread_alive (pid);
+  retval = debug_target.to_thread_alive (ptid);
 
-  fprintf_unfiltered (gdb_stderr, "target_thread_alive (%d) = %d\n",
-		      pid, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
+		      PIDGET (ptid), retval);
 
   return retval;
 }
 
 static void
-debug_to_stop ()
+debug_to_find_new_threads (void)
+{
+  debug_target.to_find_new_threads ();
+
+  fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
+}
+
+static void
+debug_to_stop (void)
 {
   debug_target.to_stop ();
 
-  fprintf_unfiltered (gdb_stderr, "target_stop ()\n");
+  fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
 }
 
 static int
-debug_to_query (type, req, resp, siz)
-  int type;
-  char *req;
-  char *resp;
-  int *siz;
+debug_to_query (int type, char *req, char *resp, int *siz)
 {
   int retval;
 
   retval = debug_target.to_query (type, req, resp, siz);
 
-  fprintf_unfiltered (gdb_stderr, "target_query (%c, %s, %s,  %d) = %d\n", type, req, resp, *siz, retval);
+  fprintf_unfiltered (gdb_stdlog, "target_query (%c, %s, %s,  %d) = %d\n", type, req, resp, *siz, retval);
 
   return retval;
 }
 
-static struct symtab_and_line *
-debug_to_enable_exception_callback (kind, enable)
-  enum exception_event_kind kind;
-  int enable;
+static void
+debug_to_rcmd (char *command,
+	       struct ui_file *outbuf)
 {
-  debug_target.to_enable_exception_callback (kind, enable);
+  debug_target.to_rcmd (command, outbuf);
+  fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
+}
 
-  fprintf_unfiltered (gdb_stderr,
+static struct symtab_and_line *
+debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
+{
+  struct symtab_and_line *result;
+  result = debug_target.to_enable_exception_callback (kind, enable);
+  fprintf_unfiltered (gdb_stdlog,
 		      "target get_exception_callback_sal (%d, %d)\n",
 		      kind, enable);
+  return result;
 }
 
 static struct exception_event_record *
-debug_to_get_current_exception_event ()
+debug_to_get_current_exception_event (void)
 {
-  debug_target.to_get_current_exception_event();
-
-  fprintf_unfiltered (gdb_stderr, "target get_current_exception_event ()\n");
+  struct exception_event_record *result;
+  result = debug_target.to_get_current_exception_event ();
+  fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
+  return result;
 }
 
 static char *
-debug_to_pid_to_exec_file (pid)
-  int  pid;
+debug_to_pid_to_exec_file (int pid)
 {
-  char *  exec_file;
+  char *exec_file;
 
   exec_file = debug_target.to_pid_to_exec_file (pid);
 
-  fprintf_unfiltered (gdb_stderr, "target_pid_to_exec_file (%d) = %s\n",
-                      pid, exec_file);
+  fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
+		      pid, exec_file);
 
   return exec_file;
 }
 
-static char *
-debug_to_core_file_to_sym_file (core)
-  char *  core;
-{
-  char *  sym_file;
-
-  sym_file = debug_target.to_core_file_to_sym_file (core);
-
-  fprintf_unfiltered (gdb_stderr, "target_core_file_to_sym_file (%s) = %s\n",
-                      core, sym_file);
-
-  return sym_file;
-}
-
 static void
-setup_target_debug ()
+setup_target_debug (void)
 {
   memcpy (&debug_target, &current_target, sizeof debug_target);
 
@@ -2543,23 +2242,39 @@ setup_target_debug ()
   current_target.to_can_run = debug_to_can_run;
   current_target.to_notice_signals = debug_to_notice_signals;
   current_target.to_thread_alive = debug_to_thread_alive;
+  current_target.to_find_new_threads = debug_to_find_new_threads;
   current_target.to_stop = debug_to_stop;
   current_target.to_query = debug_to_query;
+  current_target.to_rcmd = debug_to_rcmd;
   current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
   current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
   current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
-  current_target.to_core_file_to_sym_file = debug_to_core_file_to_sym_file;
 
 }
-#endif /* MAINTENANCE_CMDS */
 
-static char targ_desc[] = 
-    "Names of targets and files being debugged.\n\
+
+static char targ_desc[] =
+"Names of targets and files being debugged.\n\
 Shows the entire stack of targets currently in use (including the exec-file,\n\
 core-file, and process, if any), as well as the symbol file name.";
 
+static void
+do_monitor_command (char *cmd,
+		 int from_tty)
+{
+  if ((current_target.to_rcmd
+       == (void (*) (char *, struct ui_file *)) tcomplain)
+      || (current_target.to_rcmd == debug_to_rcmd
+	  && (debug_target.to_rcmd
+	      == (void (*) (char *, struct ui_file *)) tcomplain)))
+    {
+      error ("\"monitor\" command not supported by this target.\n");
+    }
+  target_rcmd (cmd, gdb_stdtarg);
+}
+
 void
-initialize_targets ()
+initialize_targets (void)
 {
   init_dummy_target ();
   push_target (&dummy_target);
@@ -2567,15 +2282,26 @@ initialize_targets ()
   add_info ("target", target_info, targ_desc);
   add_info ("files", target_info, targ_desc);
 
-#ifdef MAINTENANCE_CMDS
-  add_show_from_set (
-     add_set_cmd ("targetdebug", class_maintenance, var_zinteger,
-		  (char *)&targetdebug,
-		 "Set target debugging.\n\
-When non-zero, target debugging is enabled.", &setlist),
-		     &showlist);
-#endif
-
-  if (!STREQ (signals[TARGET_SIGNAL_LAST].string, "TARGET_SIGNAL_MAGIC"))
-    abort ();
+  add_show_from_set 
+    (add_set_cmd ("target", class_maintenance, var_zinteger,
+		  (char *) &targetdebug,
+		  "Set target debugging.\n\
+When non-zero, target debugging is enabled.", &setdebuglist),
+     &showdebuglist);
+
+  add_show_from_set 
+    (add_set_boolean_cmd 
+     ("trust-readonly-sections", class_support, 
+      &trust_readonly, 
+      "Set mode for reading from readonly sections.\n\
+When this mode is on, memory reads from readonly sections (such as .text)\n\
+will be read from the object file instead of from the target.  This will\n\
+result in significant performance improvement for remote targets.",
+      &setlist),
+     &showlist);
+
+  add_com ("monitor", class_obscure, do_monitor_command,
+	   "Send a command to the remote monitor (remote targets only).");
+
+  target_dcache = dcache_init ();
 }
diff --git a/contrib/gdb/gdb/target.h b/contrib/gdb/gdb/target.h
index d070f16..41b4a90 100644
--- a/contrib/gdb/gdb/target.h
+++ b/contrib/gdb/gdb/target.h
@@ -1,22 +1,26 @@
 /* Interface between GDB and target environments, including files and processes
-   Copyright 1990, 91, 92, 93, 94, 1999 Free Software Foundation, Inc.
+   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
+   2000, 2001, 2002 Free Software Foundation, Inc.
    Contributed by Cygnus Support.  Written by John Gilmore.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* $FreeBSD$ */
 
 #if !defined (TARGET_H)
 #define TARGET_H
@@ -42,341 +46,286 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "bfd.h"
 #include "symtab.h"
+#include "dcache.h"
+#include "memattr.h"
+
+enum strata
+  {
+    dummy_stratum,		/* The lowest of the low */
+    file_stratum,		/* Executable files, etc */
+    core_stratum,		/* Core dump files */
+    kcore_stratum,		/* Kernel core files */
+    download_stratum,		/* Downloading of remote targets */
+    process_stratum,		/* Executing processes */
+    thread_stratum		/* Executing threads */
+  };
 
-enum strata {
-	dummy_stratum,		/* The lowest of the low */
-	file_stratum,		/* Executable files, etc */
-	core_stratum,		/* Core dump files */
-	kcore_stratum,		/* Kernel core files */
-	download_stratum,	/* Downloading of remote targets */
-	process_stratum		/* Executing processes */
-};
-
-enum thread_control_capabilities {
-	tc_none = 0, 		/* Default: can't control thread execution. */
-	tc_schedlock = 1,	/* Can lock the thread scheduler. */
-	tc_switch = 2 		/* Can switch the running thread on demand. */
-};
+enum thread_control_capabilities
+  {
+    tc_none = 0,		/* Default: can't control thread execution.  */
+    tc_schedlock = 1,		/* Can lock the thread scheduler.  */
+    tc_switch = 2		/* Can switch the running thread on demand.  */
+  };
 
 /* Stuff for target_wait.  */
 
 /* Generally, what has the program done?  */
-enum target_waitkind {
-  /* The program has exited.  The exit status is in value.integer.  */
-  TARGET_WAITKIND_EXITED,
+enum target_waitkind
+  {
+    /* The program has exited.  The exit status is in value.integer.  */
+    TARGET_WAITKIND_EXITED,
 
-  /* The program has stopped with a signal.  Which signal is in value.sig.  */
-  TARGET_WAITKIND_STOPPED,
+    /* The program has stopped with a signal.  Which signal is in
+       value.sig.  */
+    TARGET_WAITKIND_STOPPED,
 
-  /* The program has terminated with a signal.  Which signal is in
-     value.sig.  */
-  TARGET_WAITKIND_SIGNALLED,
+    /* The program has terminated with a signal.  Which signal is in
+       value.sig.  */
+    TARGET_WAITKIND_SIGNALLED,
 
-  /* The program is letting us know that it dynamically loaded something
-     (e.g. it called load(2) on AIX).  */
-  TARGET_WAITKIND_LOADED,
+    /* The program is letting us know that it dynamically loaded something
+       (e.g. it called load(2) on AIX).  */
+    TARGET_WAITKIND_LOADED,
 
-  /* The program has forked.  A "related" process' ID is in value.related_pid.
-     I.e., if the child forks, value.related_pid is the parent's ID.
-     */
-  TARGET_WAITKIND_FORKED,
+    /* The program has forked.  A "related" process' ID is in
+       value.related_pid.  I.e., if the child forks, value.related_pid
+       is the parent's ID.  */
 
-  /* The program has vforked.  A "related" process's ID is in value.related_pid.
-     */
-  TARGET_WAITKIND_VFORKED,
+    TARGET_WAITKIND_FORKED,
 
-  /* The program has exec'ed a new executable file.  The new file's pathname
-     is pointed to by value.execd_pathname.
-     */
-  TARGET_WAITKIND_EXECD,
+    /* The program has vforked.  A "related" process's ID is in
+       value.related_pid.  */
 
-  /* The program has entered or returned from a system call.  On HP-UX, this
-     is used in the hardware watchpoint implementation.  The syscall's unique
-     integer ID number is in value.syscall_id;
-     */
-  TARGET_WAITKIND_SYSCALL_ENTRY,
-  TARGET_WAITKIND_SYSCALL_RETURN,
+    TARGET_WAITKIND_VFORKED,
 
-  /* Nothing happened, but we stopped anyway.  This perhaps should be handled
-     within target_wait, but I'm not sure target_wait should be resuming the
-     inferior.  */
-  TARGET_WAITKIND_SPURIOUS
+    /* The program has exec'ed a new executable file.  The new file's
+       pathname is pointed to by value.execd_pathname.  */
+
+    TARGET_WAITKIND_EXECD,
+
+    /* The program has entered or returned from a system call.  On
+       HP-UX, this is used in the hardware watchpoint implementation.
+       The syscall's unique integer ID number is in value.syscall_id */
+
+    TARGET_WAITKIND_SYSCALL_ENTRY,
+    TARGET_WAITKIND_SYSCALL_RETURN,
+
+    /* Nothing happened, but we stopped anyway.  This perhaps should be handled
+       within target_wait, but I'm not sure target_wait should be resuming the
+       inferior.  */
+    TARGET_WAITKIND_SPURIOUS,
+
+    /* This is used for target async and extended-async
+       only. Remote_async_wait() returns this when there is an event
+       on the inferior, but the rest of the world is not interested in
+       it. The inferior has not stopped, but has just sent some output
+       to the console, for instance. In this case, we want to go back
+       to the event loop and wait there for another event from the
+       inferior, rather than being stuck in the remote_async_wait()
+       function. This way the event loop is responsive to other events,
+       like for instance the user typing.  */
+    TARGET_WAITKIND_IGNORE
   };
 
-/* The numbering of these signals is chosen to match traditional unix
-   signals (insofar as various unices use the same numbers, anyway).
-   It is also the numbering of the GDB remote protocol.  Other remote
-   protocols, if they use a different numbering, should make sure to
-   translate appropriately.  */
-
-/* This is based strongly on Unix/POSIX signals for several reasons:
-   (1) This set of signals represents a widely-accepted attempt to
-   represent events of this sort in a portable fashion, (2) we want a
-   signal to make it from wait to child_wait to the user intact, (3) many
-   remote protocols use a similar encoding.  However, it is
-   recognized that this set of signals has limitations (such as not
-   distinguishing between various kinds of SIGSEGV, or not
-   distinguishing hitting a breakpoint from finishing a single step).
-   So in the future we may get around this either by adding additional
-   signals for breakpoint, single-step, etc., or by adding signal
-   codes; the latter seems more in the spirit of what BSD, System V,
-   etc. are doing to address these issues.  */
-
-/* For an explanation of what each signal means, see
-   target_signal_to_string.  */
-
-enum target_signal {
-  /* Used some places (e.g. stop_signal) to record the concept that
-     there is no signal.  */
-  TARGET_SIGNAL_0 = 0,
-  TARGET_SIGNAL_FIRST = 0,
-  TARGET_SIGNAL_HUP = 1,
-  TARGET_SIGNAL_INT = 2,
-  TARGET_SIGNAL_QUIT = 3,
-  TARGET_SIGNAL_ILL = 4,
-  TARGET_SIGNAL_TRAP = 5,
-  TARGET_SIGNAL_ABRT = 6,
-  TARGET_SIGNAL_EMT = 7,
-  TARGET_SIGNAL_FPE = 8,
-  TARGET_SIGNAL_KILL = 9,
-  TARGET_SIGNAL_BUS = 10,
-  TARGET_SIGNAL_SEGV = 11,
-  TARGET_SIGNAL_SYS = 12,
-  TARGET_SIGNAL_PIPE = 13,
-  TARGET_SIGNAL_ALRM = 14,
-  TARGET_SIGNAL_TERM = 15,
-  TARGET_SIGNAL_URG = 16,
-  TARGET_SIGNAL_STOP = 17,
-  TARGET_SIGNAL_TSTP = 18,
-  TARGET_SIGNAL_CONT = 19,
-  TARGET_SIGNAL_CHLD = 20,
-  TARGET_SIGNAL_TTIN = 21,
-  TARGET_SIGNAL_TTOU = 22,
-  TARGET_SIGNAL_IO = 23,
-  TARGET_SIGNAL_XCPU = 24,
-  TARGET_SIGNAL_XFSZ = 25,
-  TARGET_SIGNAL_VTALRM = 26,
-  TARGET_SIGNAL_PROF = 27,
-  TARGET_SIGNAL_WINCH = 28,
-  TARGET_SIGNAL_LOST = 29,
-  TARGET_SIGNAL_USR1 = 30,
-  TARGET_SIGNAL_USR2 = 31,
-  TARGET_SIGNAL_PWR = 32,
-  /* Similar to SIGIO.  Perhaps they should have the same number.  */
-  TARGET_SIGNAL_POLL = 33,
-  TARGET_SIGNAL_WIND = 34,
-  TARGET_SIGNAL_PHONE = 35,
-  TARGET_SIGNAL_WAITING = 36,
-  TARGET_SIGNAL_LWP = 37,
-  TARGET_SIGNAL_DANGER = 38,
-  TARGET_SIGNAL_GRANT = 39,
-  TARGET_SIGNAL_RETRACT = 40,
-  TARGET_SIGNAL_MSG = 41,
-  TARGET_SIGNAL_SOUND = 42,
-  TARGET_SIGNAL_SAK = 43,
-  TARGET_SIGNAL_PRIO = 44,
-  TARGET_SIGNAL_REALTIME_33 = 45,
-  TARGET_SIGNAL_REALTIME_34 = 46,
-  TARGET_SIGNAL_REALTIME_35 = 47,
-  TARGET_SIGNAL_REALTIME_36 = 48,
-  TARGET_SIGNAL_REALTIME_37 = 49,
-  TARGET_SIGNAL_REALTIME_38 = 50,
-  TARGET_SIGNAL_REALTIME_39 = 51,
-  TARGET_SIGNAL_REALTIME_40 = 52,
-  TARGET_SIGNAL_REALTIME_41 = 53,
-  TARGET_SIGNAL_REALTIME_42 = 54,
-  TARGET_SIGNAL_REALTIME_43 = 55,
-  TARGET_SIGNAL_REALTIME_44 = 56,
-  TARGET_SIGNAL_REALTIME_45 = 57,
-  TARGET_SIGNAL_REALTIME_46 = 58,
-  TARGET_SIGNAL_REALTIME_47 = 59,
-  TARGET_SIGNAL_REALTIME_48 = 60,
-  TARGET_SIGNAL_REALTIME_49 = 61,
-  TARGET_SIGNAL_REALTIME_50 = 62,
-  TARGET_SIGNAL_REALTIME_51 = 63,
-  TARGET_SIGNAL_REALTIME_52 = 64,
-  TARGET_SIGNAL_REALTIME_53 = 65,
-  TARGET_SIGNAL_REALTIME_54 = 66,
-  TARGET_SIGNAL_REALTIME_55 = 67,
-  TARGET_SIGNAL_REALTIME_56 = 68,
-  TARGET_SIGNAL_REALTIME_57 = 69,
-  TARGET_SIGNAL_REALTIME_58 = 70,
-  TARGET_SIGNAL_REALTIME_59 = 71,
-  TARGET_SIGNAL_REALTIME_60 = 72,
-  TARGET_SIGNAL_REALTIME_61 = 73,
-  TARGET_SIGNAL_REALTIME_62 = 74,
-  TARGET_SIGNAL_REALTIME_63 = 75,
-#if defined(MACH) || defined(__MACH__)
-  /* Mach exceptions */
-  TARGET_EXC_BAD_ACCESS = 76,
-  TARGET_EXC_BAD_INSTRUCTION = 77,
-  TARGET_EXC_ARITHMETIC = 78,
-  TARGET_EXC_EMULATION = 79,
-  TARGET_EXC_SOFTWARE = 80,
-  TARGET_EXC_BREAKPOINT = 81,
-#endif
-  /* Some signal we don't know about.  */
-  TARGET_SIGNAL_UNKNOWN,
-
-  /* Use whatever signal we use when one is not specifically specified
-     (for passing to proceed and so on).  */
-  TARGET_SIGNAL_DEFAULT,
-
-  /* Last and unused enum value, for sizing arrays, etc.  */
-  TARGET_SIGNAL_LAST
-};
-
-struct target_waitstatus {
-  enum target_waitkind kind;
-
-  /* Forked child pid, execd pathname, exit status or signal number.  */
-  union {
-    int integer;
-    enum target_signal sig;
-    int  related_pid;
-    char *  execd_pathname;
-    int  syscall_id;
-  } value;
-};
+struct target_waitstatus
+  {
+    enum target_waitkind kind;
+
+    /* Forked child pid, execd pathname, exit status or signal number.  */
+    union
+      {
+	int integer;
+	enum target_signal sig;
+	int related_pid;
+	char *execd_pathname;
+	int syscall_id;
+      }
+    value;
+  };
+
+/* Possible types of events that the inferior handler will have to
+   deal with.  */
+enum inferior_event_type
+  {
+    /* There is a request to quit the inferior, abandon it.  */
+    INF_QUIT_REQ,
+    /* Process a normal inferior event which will result in target_wait
+       being called.  */
+    INF_REG_EVENT, 
+    /* Deal with an error on the inferior.  */
+    INF_ERROR,
+    /* We are called because a timer went off.  */
+    INF_TIMER,
+    /* We are called to do stuff after the inferior stops.  */
+    INF_EXEC_COMPLETE,
+    /* We are called to do some stuff after the inferior stops, but we
+       are expected to reenter the proceed() and
+       handle_inferior_event() functions. This is used only in case of
+       'step n' like commands.  */
+    INF_EXEC_CONTINUE
+  };
 
 /* Return the string for a signal.  */
-extern char *target_signal_to_string PARAMS ((enum target_signal));
+extern char *target_signal_to_string (enum target_signal);
 
 /* Return the name (SIGHUP, etc.) for a signal.  */
-extern char *target_signal_to_name PARAMS ((enum target_signal));
+extern char *target_signal_to_name (enum target_signal);
 
 /* Given a name (SIGHUP, etc.), return its signal.  */
-enum target_signal target_signal_from_name PARAMS ((char *));
-
+enum target_signal target_signal_from_name (char *);
 
+
 /* If certain kinds of activity happen, target_wait should perform
    callbacks.  */
 /* Right now we just call (*TARGET_ACTIVITY_FUNCTION) if I/O is possible
-   on TARGET_ACTIVITY_FD.   */
+   on TARGET_ACTIVITY_FD.  */
 extern int target_activity_fd;
 /* Returns zero to leave the inferior alone, one to interrupt it.  */
-extern int (*target_activity_function) PARAMS ((void));
+extern int (*target_activity_function) (void);
 
+struct thread_info;		/* fwd decl for parameter list below: */
+
 struct target_ops
-{
-  char	       *to_shortname;	/* Name this target type */
-  char	       *to_longname;	/* Name for printing */
-  char 	       *to_doc;	        /* Documentation.  Does not include trailing
+  {
+    char *to_shortname;		/* Name this target type */
+    char *to_longname;		/* Name for printing */
+    char *to_doc;		/* Documentation.  Does not include trailing
 				   newline, and starts with a one-line descrip-
-				   tion (probably similar to to_longname). */
-  void 	      (*to_open) PARAMS ((char *, int));
-  void 	      (*to_close) PARAMS ((int));
-  void 	      (*to_attach) PARAMS ((char *, int));
-  void        (*to_post_attach) PARAMS ((int));
-  void 	      (*to_require_attach) PARAMS ((char *, int));
-  void 	      (*to_detach) PARAMS ((char *, int));
-  void 	      (*to_require_detach) PARAMS ((int, char *, int));
-  void 	      (*to_resume) PARAMS ((int, int, enum target_signal));
-  int  	      (*to_wait) PARAMS ((int, struct target_waitstatus *));
-  void        (*to_post_wait) PARAMS ((int, int));
-  void 	      (*to_fetch_registers) PARAMS ((int));
-  void 	      (*to_store_registers) PARAMS ((int));
-  void 	      (*to_prepare_to_store) PARAMS ((void));
-
-  /* Transfer LEN bytes of memory between GDB address MYADDR and
-     target address MEMADDR.  If WRITE, transfer them to the target, else
-     transfer them from the target.  TARGET is the target from which we
-     get this function.
-
-     Return value, N, is one of the following:
-
-     0 means that we can't handle this.  If errno has been set, it is the
-     error which prevented us from doing it (FIXME: What about bfd_error?).
-
-     positive (call it N) means that we have transferred N bytes
-     starting at MEMADDR.  We might be able to handle more bytes
-     beyond this length, but no promises.
-
-     negative (call its absolute value N) means that we cannot
-     transfer right at MEMADDR, but we could transfer at least
-     something at MEMADDR + N.  */
-
-  int  	      (*to_xfer_memory) PARAMS ((CORE_ADDR memaddr, char *myaddr,
-					 int len, int write,
-					 struct target_ops * target));
+				   tion (probably similar to to_longname).  */
+    void (*to_open) (char *, int);
+    void (*to_close) (int);
+    void (*to_attach) (char *, int);
+    void (*to_post_attach) (int);
+    void (*to_require_attach) (char *, int);
+    void (*to_detach) (char *, int);
+    void (*to_require_detach) (int, char *, int);
+    void (*to_resume) (ptid_t, int, enum target_signal);
+    ptid_t (*to_wait) (ptid_t, struct target_waitstatus *);
+    void (*to_post_wait) (ptid_t, int);
+    void (*to_fetch_registers) (int);
+    void (*to_store_registers) (int);
+    void (*to_prepare_to_store) (void);
+
+    /* Transfer LEN bytes of memory between GDB address MYADDR and
+       target address MEMADDR.  If WRITE, transfer them to the target, else
+       transfer them from the target.  TARGET is the target from which we
+       get this function.
+
+       Return value, N, is one of the following:
+
+       0 means that we can't handle this.  If errno has been set, it is the
+       error which prevented us from doing it (FIXME: What about bfd_error?).
+
+       positive (call it N) means that we have transferred N bytes
+       starting at MEMADDR.  We might be able to handle more bytes
+       beyond this length, but no promises.
+
+       negative (call its absolute value N) means that we cannot
+       transfer right at MEMADDR, but we could transfer at least
+       something at MEMADDR + N.  */
+
+    int (*to_xfer_memory) (CORE_ADDR memaddr, char *myaddr,
+			   int len, int write, 
+			   struct mem_attrib *attrib,
+			   struct target_ops *target);
 
 #if 0
-  /* Enable this after 4.12.  */
+    /* Enable this after 4.12.  */
+
+    /* Search target memory.  Start at STARTADDR and take LEN bytes of
+       target memory, and them with MASK, and compare to DATA.  If they
+       match, set *ADDR_FOUND to the address we found it at, store the data
+       we found at LEN bytes starting at DATA_FOUND, and return.  If
+       not, add INCREMENT to the search address and keep trying until
+       the search address is outside of the range [LORANGE,HIRANGE).
 
-  /* Search target memory.  Start at STARTADDR and take LEN bytes of
-     target memory, and them with MASK, and compare to DATA.  If they
-     match, set *ADDR_FOUND to the address we found it at, store the data
-     we found at LEN bytes starting at DATA_FOUND, and return.  If
-     not, add INCREMENT to the search address and keep trying until
-     the search address is outside of the range [LORANGE,HIRANGE).
+       If we don't find anything, set *ADDR_FOUND to (CORE_ADDR)0 and
+       return.  */
 
-     If we don't find anything, set *ADDR_FOUND to (CORE_ADDR)0 and return.  */
-  void (*to_search) PARAMS ((int len, char *data, char *mask,
-			     CORE_ADDR startaddr, int increment,
-			     CORE_ADDR lorange, CORE_ADDR hirange,
-			     CORE_ADDR *addr_found, char *data_found));
+    void (*to_search) (int len, char *data, char *mask,
+		       CORE_ADDR startaddr, int increment,
+		       CORE_ADDR lorange, CORE_ADDR hirange,
+		       CORE_ADDR * addr_found, char *data_found);
 
 #define	target_search(len, data, mask, startaddr, increment, lorange, hirange, addr_found, data_found)	\
-  (*current_target.to_search) (len, data, mask, startaddr, increment, \
-				lorange, hirange, addr_found, data_found)
-#endif /* 0 */
-
-  void 	      (*to_files_info) PARAMS ((struct target_ops *));
-  int  	      (*to_insert_breakpoint) PARAMS ((CORE_ADDR, char *));
-  int 	      (*to_remove_breakpoint) PARAMS ((CORE_ADDR, char *));
-  void 	      (*to_terminal_init) PARAMS ((void));
-  void 	      (*to_terminal_inferior) PARAMS ((void));
-  void 	      (*to_terminal_ours_for_output) PARAMS ((void));
-  void 	      (*to_terminal_ours) PARAMS ((void));
-  void 	      (*to_terminal_info) PARAMS ((char *, int));
-  void 	      (*to_kill) PARAMS ((void));
-  void 	      (*to_load) PARAMS ((char *, int));
-  int 	      (*to_lookup_symbol) PARAMS ((char *, CORE_ADDR *));
-  void 	      (*to_create_inferior) PARAMS ((char *, char *, char **));
-  void        (*to_post_startup_inferior) PARAMS ((int));
-  void        (*to_acknowledge_created_inferior) PARAMS ((int));
-  void        (*to_clone_and_follow_inferior) PARAMS ((int, int *));
-  void        (*to_post_follow_inferior_by_clone) PARAMS ((void));
-  int         (*to_insert_fork_catchpoint) PARAMS ((int));
-  int         (*to_remove_fork_catchpoint) PARAMS ((int));
-  int         (*to_insert_vfork_catchpoint) PARAMS ((int));
-  int         (*to_remove_vfork_catchpoint) PARAMS ((int));
-  int         (*to_has_forked) PARAMS ((int, int *));
-  int         (*to_has_vforked) PARAMS ((int, int *));
-  int         (*to_can_follow_vfork_prior_to_exec) PARAMS ((void));
-  void        (*to_post_follow_vfork) PARAMS ((int, int, int, int));
-  int         (*to_insert_exec_catchpoint) PARAMS ((int));
-  int         (*to_remove_exec_catchpoint) PARAMS ((int));
-  int         (*to_has_execd) PARAMS ((int, char **));
-  int         (*to_reported_exec_events_per_exec_call) PARAMS ((void));
-  int         (*to_has_syscall_event) PARAMS ((int, enum target_waitkind *, int *));
-  int         (*to_has_exited) PARAMS ((int, int, int *));
-  void 	      (*to_mourn_inferior) PARAMS ((void));
-  int	      (*to_can_run) PARAMS ((void));
-  void	      (*to_notice_signals) PARAMS ((int pid));
-  int	      (*to_thread_alive) PARAMS ((int pid));
-  void	      (*to_stop) PARAMS ((void));
-  int 	      (*to_query) PARAMS ((int/*char*/, char *, char *, int *));
-  struct symtab_and_line * (*to_enable_exception_callback) PARAMS ((enum exception_event_kind, int));
-  struct exception_event_record * (*to_get_current_exception_event) PARAMS ((void));
-  char *      (*to_pid_to_exec_file) PARAMS ((int pid));
-  char *      (*to_core_file_to_sym_file) PARAMS ((char *));
-  enum strata   to_stratum;
-  struct target_ops
-		*DONT_USE;	/* formerly to_next */
-  int		to_has_all_memory;
-  int		to_has_memory;
-  int		to_has_stack;
-  int		to_has_registers;
-  int		to_has_execution;
-  int		to_has_thread_control;	/* control thread execution */
-  struct section_table
-    	       *to_sections;
-  struct section_table
-	       *to_sections_end;
-  int		to_magic;
-  /* Need sub-structure for target machine related rather than comm related? */
-};
+    (*current_target.to_search) (len, data, mask, startaddr, increment, \
+				 lorange, hirange, addr_found, data_found)
+#endif				/* 0 */
+
+    void (*to_files_info) (struct target_ops *);
+    int (*to_insert_breakpoint) (CORE_ADDR, char *);
+    int (*to_remove_breakpoint) (CORE_ADDR, char *);
+    void (*to_terminal_init) (void);
+    void (*to_terminal_inferior) (void);
+    void (*to_terminal_ours_for_output) (void);
+    void (*to_terminal_ours) (void);
+    void (*to_terminal_info) (char *, int);
+    void (*to_kill) (void);
+    void (*to_load) (char *, int);
+    int (*to_lookup_symbol) (char *, CORE_ADDR *);
+    void (*to_create_inferior) (char *, char *, char **);
+    void (*to_post_startup_inferior) (ptid_t);
+    void (*to_acknowledge_created_inferior) (int);
+    void (*to_clone_and_follow_inferior) (int, int *);
+    void (*to_post_follow_inferior_by_clone) (void);
+    int (*to_insert_fork_catchpoint) (int);
+    int (*to_remove_fork_catchpoint) (int);
+    int (*to_insert_vfork_catchpoint) (int);
+    int (*to_remove_vfork_catchpoint) (int);
+    int (*to_has_forked) (int, int *);
+    int (*to_has_vforked) (int, int *);
+    int (*to_can_follow_vfork_prior_to_exec) (void);
+    void (*to_post_follow_vfork) (int, int, int, int);
+    int (*to_insert_exec_catchpoint) (int);
+    int (*to_remove_exec_catchpoint) (int);
+    int (*to_has_execd) (int, char **);
+    int (*to_reported_exec_events_per_exec_call) (void);
+    int (*to_has_syscall_event) (int, enum target_waitkind *, int *);
+    int (*to_has_exited) (int, int, int *);
+    void (*to_mourn_inferior) (void);
+    int (*to_can_run) (void);
+    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_extra_thread_info) (struct thread_info *);
+    void (*to_stop) (void);
+    int (*to_query) (int /*char */ , char *, char *, int *);
+    void (*to_rcmd) (char *command, struct ui_file *output);
+    struct symtab_and_line *(*to_enable_exception_callback) (enum
+							     exception_event_kind,
+							     int);
+    struct exception_event_record *(*to_get_current_exception_event) (void);
+    char *(*to_pid_to_exec_file) (int pid);
+    enum strata to_stratum;
+    struct target_ops
+     *DONT_USE;			/* formerly to_next */
+    int to_has_all_memory;
+    int to_has_memory;
+    int to_has_stack;
+    int to_has_registers;
+    int to_has_execution;
+    int to_has_thread_control;	/* control thread execution */
+    struct section_table
+     *to_sections;
+    struct section_table
+     *to_sections_end;
+    /* ASYNC target controls */
+    int (*to_can_async_p) (void);
+    int (*to_is_async_p) (void);
+    void (*to_async) (void (*cb) (enum inferior_event_type, void *context),
+		      void *context);
+    int to_async_mask_value;
+    int (*to_find_memory_regions) (int (*) (CORE_ADDR, 
+					    unsigned long, 
+					    int, int, int, 
+					    void *), 
+				   void *);
+    char * (*to_make_corefile_notes) (bfd *, int *);
+    int to_magic;
+    /* Need sub-structure for target machine related rather than comm related?
+     */
+  };
 
 /* Magic number for checking ops size.  If a struct doesn't end with this
    number, somebody changed the declaration but didn't change all the
@@ -387,15 +336,15 @@ struct target_ops
 /* The ops structure for our "current" target process.  This should
    never be NULL.  If there is no target, it points to the dummy_target.  */
 
-extern struct target_ops	current_target;
+extern struct target_ops current_target;
 
 /* An item on the target stack.  */
 
 struct target_stack_item
-{
-  struct target_stack_item *next;
-  struct target_ops *target_ops;
-};
+  {
+    struct target_stack_item *next;
+    struct target_ops *target_ops;
+  };
 
 /* The target stack.  */
 
@@ -409,8 +358,12 @@ extern struct target_stack_item *target_stack;
 /* The open routine takes the rest of the parameters from the command,
    and (if successful) pushes a new target onto the stack.
    Targets should supply this routine, if only to provide an error message.  */
-#define	target_open(name, from_tty)	\
-	(*current_target.to_open) (name, from_tty)
+
+#define	target_open(name, from_tty)					\
+  do {									\
+    dcache_invalidate (target_dcache);					\
+    (*current_target.to_open) (name, from_tty);				\
+  } while (0)
 
 /* Does whatever cleanup is required for a target that we are no longer
    going to be calling.  Argument says whether we are quitting gdb and
@@ -421,7 +374,7 @@ extern struct target_stack_item *target_stack;
    do.  */
 
 #define	target_close(quitting)	\
-	(*current_target.to_close) (quitting)
+     (*current_target.to_close) (quitting)
 
 /* Attaches to a process on the target side.  Arguments are as passed
    to the `attach' command by the user.  This routine can be called
@@ -432,16 +385,15 @@ extern struct target_stack_item *target_stack;
    (without waiting) to an upcoming target_wait call.  */
 
 #define	target_attach(args, from_tty)	\
-	(*current_target.to_attach) (args, from_tty)
+     (*current_target.to_attach) (args, from_tty)
 
 /* The target_attach operation places a process under debugger control,
    and stops the process.
 
    This operation provides a target-specific hook that allows the
-   necessary bookkeeping to be performed after an attach completes.
-   */
+   necessary bookkeeping to be performed after an attach completes.  */
 #define target_post_attach(pid) \
-        (*current_target.to_post_attach) (pid)
+     (*current_target.to_post_attach) (pid)
 
 /* Attaches to a process on the target side, if not already attached.
    (If already attached, takes no action.)
@@ -452,7 +404,7 @@ extern struct target_stack_item *target_stack;
    actual attach operation.  */
 
 #define	target_require_attach(args, from_tty)	\
-	(*current_target.to_require_attach) (args, from_tty)
+     (*current_target.to_require_attach) (args, from_tty)
 
 /* Takes a program previously attached to and detaches it.
    The program may resume execution (some targets do, some don't) and will
@@ -461,8 +413,7 @@ extern struct target_stack_item *target_stack;
    typed by the user (e.g. a signal to send the process).  FROM_TTY
    says whether to be verbose or not.  */
 
-extern void
-target_detach PARAMS ((char *, int));
+extern void target_detach (char *, int);
 
 /* Detaches from a process on the target side, if not already dettached.
    (If already detached, takes no action.)
@@ -476,27 +427,30 @@ target_detach PARAMS ((char *, int));
    ARGS is arguments typed by the user (e.g. a signal to send the process).
    FROM_TTY says whether to be verbose or not.  */
 
-#define target_require_detach(pid, args, from_tty) \
-	(*current_target.to_require_detach) (pid, args, from_tty)
+#define target_require_detach(pid, args, from_tty)	\
+     (*current_target.to_require_detach) (pid, args, from_tty)
 
-/* Resume execution of the target process PID.  STEP says whether to
+/* Resume execution of the target process PTID.  STEP says whether to
    single-step or to run free; SIGGNAL is the signal to be given to
    the target, or TARGET_SIGNAL_0 for no signal.  The caller may not
    pass TARGET_SIGNAL_DEFAULT.  */
 
-#define	target_resume(pid, step, siggnal)	\
-	(*current_target.to_resume) (pid, step, siggnal)
+#define	target_resume(ptid, step, siggnal)				\
+  do {									\
+    dcache_invalidate(target_dcache);					\
+    (*current_target.to_resume) (ptid, step, siggnal);			\
+  } while (0)
 
-/* Wait for process pid to do something.  Pid = -1 to wait for any pid
-   to do something.  Return pid of child, or -1 in case of error;
+/* Wait for process pid to do something.  PTID = -1 to wait for any
+   pid to do something.  Return pid of child, or -1 in case of error;
    store status through argument pointer STATUS.  Note that it is
-   *not* OK to return_to_top_level out of target_wait without popping
+   _NOT_ OK to throw_exception() out of target_wait() without popping
    the debugging target from the stack; GDB isn't prepared to get back
    to the prompt with a debugging target but without the frame cache,
    stop_pc, etc., set up.  */
 
-#define	target_wait(pid, status)		\
-	(*current_target.to_wait) (pid, status)
+#define	target_wait(ptid, status)		\
+     (*current_target.to_wait) (ptid, status)
 
 /* The target_wait operation waits for a process event to occur, and
    thereby stop the process.
@@ -506,23 +460,22 @@ target_detach PARAMS ((char *, int));
    knowledge of what earlier events in the sequence have been seen.
 
    This operation provides a target-specific hook that allows the
-   necessary bookkeeping to be performed to track such sequences.
-   */
+   necessary bookkeeping to be performed to track such sequences.  */
 
-#define target_post_wait(pid, status) \
-        (*current_target.to_post_wait) (pid, status)
+#define target_post_wait(ptid, status) \
+     (*current_target.to_post_wait) (ptid, status)
 
-/* Fetch register REGNO, or all regs if regno == -1.  No result.  */
+/* Fetch at least register REGNO, or all regs if regno == -1.  No result.  */
 
 #define	target_fetch_registers(regno)	\
-	(*current_target.to_fetch_registers) (regno)
+     (*current_target.to_fetch_registers) (regno)
 
 /* Store at least register REGNO, or all regs if REGNO == -1.
    It can store as many registers as it wants to, so target_prepare_to_store
    must have been previously called.  Calls error() if there are problems.  */
 
 #define	target_store_registers(regs)	\
-	(*current_target.to_store_registers) (regs)
+     (*current_target.to_store_registers) (regs)
 
 /* Get ready to modify the registers array.  On machines which store
    individual registers, this doesn't need to do anything.  On machines
@@ -531,112 +484,95 @@ target_detach PARAMS ((char *, int));
    debugged.  */
 
 #define	target_prepare_to_store()	\
-	(*current_target.to_prepare_to_store) ()
+     (*current_target.to_prepare_to_store) ()
 
-extern int target_read_string PARAMS ((CORE_ADDR, char **, int, int *));
+extern DCACHE *target_dcache;
 
-extern int
-target_read_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
+extern int do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
+			   struct mem_attrib *attrib);
 
-extern int
-target_read_memory_section PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
-				    asection *bfd_section));
+extern int target_read_string (CORE_ADDR, char **, int, int *);
 
-extern int
-target_read_memory_partial PARAMS ((CORE_ADDR, char *, int, int *));
+extern int target_read_memory (CORE_ADDR memaddr, char *myaddr, int len);
 
-extern int
-target_write_memory PARAMS ((CORE_ADDR, char *, int));
+extern int target_write_memory (CORE_ADDR memaddr, char *myaddr, int len);
 
-extern int
-xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+extern int xfer_memory (CORE_ADDR, char *, int, int, 
+			struct mem_attrib *, struct target_ops *);
 
-extern int
-child_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+extern int child_xfer_memory (CORE_ADDR, char *, int, int, 
+			      struct mem_attrib *, struct target_ops *);
+
+/* Make a single attempt at transfering LEN bytes.  On a successful
+   transfer, the number of bytes actually transfered is returned and
+   ERR is set to 0.  When a transfer fails, -1 is returned (the number
+   of bytes actually transfered is not defined) and ERR is set to a
+   non-zero error indication.  */
 
-extern char *
-child_pid_to_exec_file PARAMS ((int));
+extern int 
+target_read_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
 
-extern char *
-child_core_file_to_sym_file PARAMS ((char *));
+extern int 
+target_write_memory_partial (CORE_ADDR addr, char *buf, int len, int *err);
+
+extern char *child_pid_to_exec_file (int);
+
+extern char *child_core_file_to_sym_file (char *);
 
 #if defined(CHILD_POST_ATTACH)
-extern void
-child_post_attach PARAMS ((int));
+extern void child_post_attach (int);
 #endif
 
-extern void
-child_post_wait PARAMS ((int, int));
+extern void child_post_wait (ptid_t, int);
 
-extern void
-child_post_startup_inferior PARAMS ((int));
+extern void child_post_startup_inferior (ptid_t);
 
-extern void
-child_acknowledge_created_inferior PARAMS ((int));
+extern void child_acknowledge_created_inferior (int);
 
-extern void
-child_clone_and_follow_inferior PARAMS ((int, int *));
+extern void child_clone_and_follow_inferior (int, int *);
 
-extern void
-child_post_follow_inferior_by_clone PARAMS ((void));
+extern void child_post_follow_inferior_by_clone (void);
 
-extern int
-child_insert_fork_catchpoint PARAMS ((int));
+extern int child_insert_fork_catchpoint (int);
 
-extern int
-child_remove_fork_catchpoint PARAMS ((int));
+extern int child_remove_fork_catchpoint (int);
 
-extern int
-child_insert_vfork_catchpoint PARAMS ((int));
+extern int child_insert_vfork_catchpoint (int);
 
-extern int
-child_remove_vfork_catchpoint PARAMS ((int));
+extern int child_remove_vfork_catchpoint (int);
 
-extern int
-child_has_forked PARAMS ((int, int *));
+extern int child_has_forked (int, int *);
 
-extern int
-child_has_vforked PARAMS ((int, int *));
+extern int child_has_vforked (int, int *);
 
-extern void
-child_acknowledge_created_inferior PARAMS ((int));
+extern void child_acknowledge_created_inferior (int);
 
-extern int
-child_can_follow_vfork_prior_to_exec PARAMS ((void));
+extern int child_can_follow_vfork_prior_to_exec (void);
 
-extern void
-child_post_follow_vfork PARAMS ((int, int, int, int));
+extern void child_post_follow_vfork (int, int, int, int);
 
-extern int
-child_insert_exec_catchpoint PARAMS ((int));
+extern int child_insert_exec_catchpoint (int);
 
-extern int
-child_remove_exec_catchpoint PARAMS ((int));
+extern int child_remove_exec_catchpoint (int);
 
-extern int
-child_has_execd PARAMS ((int, char **));
+extern int child_has_execd (int, char **);
 
-extern int
-child_reported_exec_events_per_exec_call PARAMS ((void));
+extern int child_reported_exec_events_per_exec_call (void);
 
-extern int
-child_has_syscall_event PARAMS ((int, enum target_waitkind *, int *));
+extern int child_has_syscall_event (int, enum target_waitkind *, int *);
 
-extern int
-child_has_exited PARAMS ((int, int, int *));
+extern int child_has_exited (int, int, int *);
 
-extern int
-child_thread_alive PARAMS ((int));
+extern int child_thread_alive (ptid_t);
 
 /* From exec.c */
 
-extern void
-print_section_info PARAMS ((struct target_ops *, bfd *));
+extern void print_section_info (struct target_ops *, bfd *);
 
 /* Print a line about the current target.  */
 
 #define	target_files_info()	\
-	(*current_target.to_files_info) (&current_target)
+     (*current_target.to_files_info) (&current_target)
 
 /* Insert a breakpoint at address ADDR in the target machine.
    SAVE is a pointer to memory allocated for saving the
@@ -645,7 +581,7 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    an errno value.  */
 
 #define	target_insert_breakpoint(addr, save)	\
-	(*current_target.to_insert_breakpoint) (addr, save)
+     (*current_target.to_insert_breakpoint) (addr, save)
 
 /* Remove a breakpoint at address ADDR in the target machine.
    SAVE is a pointer to the same save area 
@@ -653,19 +589,19 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    Result is 0 for success, or an errno value.  */
 
 #define	target_remove_breakpoint(addr, save)	\
-	(*current_target.to_remove_breakpoint) (addr, save)
+     (*current_target.to_remove_breakpoint) (addr, save)
 
 /* Initialize the terminal settings we record for the inferior,
    before we actually run the inferior.  */
 
 #define target_terminal_init() \
-	(*current_target.to_terminal_init) ()
+     (*current_target.to_terminal_init) ()
 
 /* Put the inferior's terminal settings into effect.
    This is preparation for starting or resuming the inferior.  */
 
 #define target_terminal_inferior() \
-	(*current_target.to_terminal_inferior) ()
+     (*current_target.to_terminal_inferior) ()
 
 /* Put some of our terminal settings into effect,
    enough to get proper results from our output,
@@ -676,52 +612,51 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    should be called to get back to a normal state of affairs.  */
 
 #define target_terminal_ours_for_output() \
-	(*current_target.to_terminal_ours_for_output) ()
+     (*current_target.to_terminal_ours_for_output) ()
 
 /* Put our terminal settings into effect.
    First record the inferior's terminal settings
    so they can be restored properly later.  */
 
 #define target_terminal_ours() \
-	(*current_target.to_terminal_ours) ()
+     (*current_target.to_terminal_ours) ()
 
 /* Print useful information about our terminal status, if such a thing
    exists.  */
 
 #define target_terminal_info(arg, from_tty) \
-	(*current_target.to_terminal_info) (arg, from_tty)
+     (*current_target.to_terminal_info) (arg, from_tty)
 
 /* Kill the inferior process.   Make it go away.  */
 
 #define target_kill() \
-	(*current_target.to_kill) ()
+     (*current_target.to_kill) ()
 
-/* Load an executable file into the target process.  This is expected to
-   not only bring new code into the target process, but also to update
-   GDB's symbol tables to match.  */
+/* Load an executable file into the target process.  This is expected
+   to not only bring new code into the target process, but also to
+   update GDB's symbol tables to match.  */
 
-#define target_load(arg, from_tty) \
-	(*current_target.to_load) (arg, from_tty)
+extern void target_load (char *arg, int from_tty);
 
 /* Look up a symbol in the target's symbol table.  NAME is the symbol
-   name.  ADDRP is a CORE_ADDR * pointing to where the value of the symbol
-   should be returned.  The result is 0 if successful, nonzero if the
-   symbol does not exist in the target environment.  This function should
-   not call error() if communication with the target is interrupted, since
-   it is called from symbol reading, but should return nonzero, possibly
-   doing a complain().  */
+   name.  ADDRP is a CORE_ADDR * pointing to where the value of the
+   symbol should be returned.  The result is 0 if successful, nonzero
+   if the symbol does not exist in the target environment.  This
+   function should not call error() if communication with the target
+   is interrupted, since it is called from symbol reading, but should
+   return nonzero, possibly doing a complain().  */
 
-#define target_lookup_symbol(name, addrp) 	\
-  (*current_target.to_lookup_symbol) (name, addrp)
+#define target_lookup_symbol(name, addrp) \
+     (*current_target.to_lookup_symbol) (name, addrp)
 
-/* Start an inferior process and set inferior_pid to its pid.
+/* Start an inferior process and set inferior_ptid to its pid.
    EXEC_FILE is the file to run.
    ALLARGS is a string containing the arguments to the program.
    ENV is the environment vector to pass.  Errors reported with error().
    On VxWorks and various standalone systems, we ignore exec_file.  */
- 
+
 #define	target_create_inferior(exec_file, args, env)	\
-	(*current_target.to_create_inferior) (exec_file, args, env)
+     (*current_target.to_create_inferior) (exec_file, args, env)
 
 
 /* Some targets (such as ttrace-based HPUX) don't allow us to request
@@ -731,17 +666,17 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    if the shell init file has commands in it, the shell will fork and
    exec for each of those commands, and we will see each such fork
    event.  Very bad.)
-   
-   Such targets will supply an appropriate definition for this function.
-   */
-#define target_post_startup_inferior(pid) \
-        (*current_target.to_post_startup_inferior) (pid)
+
+   Such targets will supply an appropriate definition for this function.  */
+
+#define target_post_startup_inferior(ptid) \
+     (*current_target.to_post_startup_inferior) (ptid)
 
 /* On some targets, the sequence of starting up an inferior requires
-   some synchronization between gdb and the new inferior process, PID.
-   */
+   some synchronization between gdb and the new inferior process, PID.  */
+
 #define target_acknowledge_created_inferior(pid) \
-        (*current_target.to_acknowledge_created_inferior) (pid)
+     (*current_target.to_acknowledge_created_inferior) (pid)
 
 /* An inferior process has been created via a fork() or similar
    system call.  This function will clone the debugger, then ensure
@@ -752,10 +687,10 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    to determine which they are, if need be.)
 
    (This is not a terribly useful feature without a GUI to prevent
-   the two debuggers from competing for shell input.)
-   */
+   the two debuggers from competing for shell input.)  */
+
 #define target_clone_and_follow_inferior(child_pid,followed_child) \
-        (*current_target.to_clone_and_follow_inferior) (child_pid, followed_child)
+     (*current_target.to_clone_and_follow_inferior) (child_pid, followed_child)
 
 /* This operation is intended to be used as the last in a sequence of
    steps taken when following both parent and child of a fork.  This
@@ -765,40 +700,40 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    clone has attached to it.
 
    On some targets, this requires a bit of cleanup to make it work
-   correctly.
-   */
+   correctly.  */
+
 #define target_post_follow_inferior_by_clone() \
-        (*current_target.to_post_follow_inferior_by_clone) ()
+     (*current_target.to_post_follow_inferior_by_clone) ()
+
+/* On some targets, we can catch an inferior fork or vfork event when
+   it occurs.  These functions insert/remove an already-created
+   catchpoint for such events.  */
 
-/* On some targets, we can catch an inferior fork or vfork event when it
-   occurs.  These functions insert/remove an already-created catchpoint for
-   such events.
-   */
 #define target_insert_fork_catchpoint(pid) \
-        (*current_target.to_insert_fork_catchpoint) (pid)
+     (*current_target.to_insert_fork_catchpoint) (pid)
 
 #define target_remove_fork_catchpoint(pid) \
-        (*current_target.to_remove_fork_catchpoint) (pid)
+     (*current_target.to_remove_fork_catchpoint) (pid)
 
 #define target_insert_vfork_catchpoint(pid) \
-        (*current_target.to_insert_vfork_catchpoint) (pid)
+     (*current_target.to_insert_vfork_catchpoint) (pid)
 
 #define target_remove_vfork_catchpoint(pid) \
-        (*current_target.to_remove_vfork_catchpoint) (pid)
+     (*current_target.to_remove_vfork_catchpoint) (pid)
 
 /* Returns TRUE if PID has invoked the fork() system call.  And,
    also sets CHILD_PID to the process id of the other ("child")
-   inferior process that was created by that call.
-   */
+   inferior process that was created by that call.  */
+
 #define target_has_forked(pid,child_pid) \
-        (*current_target.to_has_forked) (pid,child_pid)
+     (*current_target.to_has_forked) (pid,child_pid)
+
+/* Returns TRUE if PID has invoked the vfork() system call.  And, 
+   also sets CHILD_PID to the process id of the other ("child") 
+   inferior process that was created by that call.  */
 
-/* Returns TRUE if PID has invoked the vfork() system call.  And,
-   also sets CHILD_PID to the process id of the other ("child")
-   inferior process that was created by that call.
-   */
 #define target_has_vforked(pid,child_pid) \
-        (*current_target.to_has_vforked) (pid,child_pid)
+     (*current_target.to_has_vforked) (pid,child_pid)
 
 /* Some platforms (such as pre-10.20 HP-UX) don't allow us to do
    anything to a vforked child before it subsequently calls exec().
@@ -807,10 +742,10 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
 
    This function should be defined to return 1 by those targets
    which can allow the debugger to immediately follow a vforked
-   child, and 0 if they cannot.
-   */
+   child, and 0 if they cannot.  */
+
 #define target_can_follow_vfork_prior_to_exec() \
-        (*current_target.to_can_follow_vfork_prior_to_exec) ()
+     (*current_target.to_can_follow_vfork_prior_to_exec) ()
 
 /* An inferior process has been created via a vfork() system call.
    The debugger has followed the parent, the child, or both.  The
@@ -818,77 +753,81 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    target-specific trickery to track the sequence of reported events.
    If so, this function should be defined by those targets that
    require the debugger to perform cleanup or initialization after
-   the vfork follow.
-   */
+   the vfork follow.  */
+
 #define target_post_follow_vfork(parent_pid,followed_parent,child_pid,followed_child) \
-        (*current_target.to_post_follow_vfork) (parent_pid,followed_parent,child_pid,followed_child)
+     (*current_target.to_post_follow_vfork) (parent_pid,followed_parent,child_pid,followed_child)
 
 /* On some targets, we can catch an inferior exec event when it
-   occurs.  These functions insert/remove an already-created catchpoint
-   for such events.
-   */
+   occurs.  These functions insert/remove an already-created
+   catchpoint for such events.  */
+
 #define target_insert_exec_catchpoint(pid) \
-        (*current_target.to_insert_exec_catchpoint) (pid)
- 
+     (*current_target.to_insert_exec_catchpoint) (pid)
+
 #define target_remove_exec_catchpoint(pid) \
-        (*current_target.to_remove_exec_catchpoint) (pid)
+     (*current_target.to_remove_exec_catchpoint) (pid)
 
 /* Returns TRUE if PID has invoked a flavor of the exec() system call.
-   And, also sets EXECD_PATHNAME to the pathname of the executable file
-   that was passed to exec(), and is now being executed.
-   */
+   And, also sets EXECD_PATHNAME to the pathname of the executable
+   file that was passed to exec(), and is now being executed.  */
+
 #define target_has_execd(pid,execd_pathname) \
-        (*current_target.to_has_execd) (pid,execd_pathname)
+     (*current_target.to_has_execd) (pid,execd_pathname)
 
 /* Returns the number of exec events that are reported when a process
    invokes a flavor of the exec() system call on this target, if exec
-   events are being reported.
-   */
+   events are being reported.  */
+
 #define target_reported_exec_events_per_exec_call() \
-        (*current_target.to_reported_exec_events_per_exec_call) ()
+     (*current_target.to_reported_exec_events_per_exec_call) ()
 
 /* Returns TRUE if PID has reported a syscall event.  And, also sets
    KIND to the appropriate TARGET_WAITKIND_, and sets SYSCALL_ID to
-   the unique integer ID of the syscall.
-   */
+   the unique integer ID of the syscall.  */
+
 #define target_has_syscall_event(pid,kind,syscall_id) \
-  (*current_target.to_has_syscall_event) (pid,kind,syscall_id)
+     (*current_target.to_has_syscall_event) (pid,kind,syscall_id)
 
 /* Returns TRUE if PID has exited.  And, also sets EXIT_STATUS to the
-   exit code of PID, if any.
-   */
+   exit code of PID, if any.  */
+
 #define target_has_exited(pid,wait_status,exit_status) \
-        (*current_target.to_has_exited) (pid,wait_status,exit_status)
+     (*current_target.to_has_exited) (pid,wait_status,exit_status)
 
 /* The debugger has completed a blocking wait() call.  There is now
-   some process event that must be processed.  This function should
+   some process event that must be processed.  This function should 
    be defined by those targets that require the debugger to perform
-   cleanup or internal state changes in response to the process event.
-   */
+   cleanup or internal state changes in response to the process event.  */
 
 /* The inferior process has died.  Do what is right.  */
 
 #define	target_mourn_inferior()	\
-	(*current_target.to_mourn_inferior) ()
+     (*current_target.to_mourn_inferior) ()
 
 /* Does target have enough data to do a run or attach command? */
 
 #define target_can_run(t) \
-  	((t)->to_can_run) ()
+     ((t)->to_can_run) ()
 
 /* post process changes to signal handling in the inferior.  */
 
-#define target_notice_signals(pid) \
-  	(*current_target.to_notice_signals) (pid)
+#define target_notice_signals(ptid) \
+     (*current_target.to_notice_signals) (ptid)
 
 /* Check to see if a thread is still alive.  */
 
-#define target_thread_alive(pid) \
-	(*current_target.to_thread_alive) (pid)
+#define target_thread_alive(ptid) \
+     (*current_target.to_thread_alive) (ptid)
 
-/* Make target stop in a continuable fashion.  (For instance, under Unix, this
-   should act like SIGSTOP).  This function is normally used by GUIs to
-   implement a stop button.  */
+/* Query for new threads and add them to the thread list.  */
+
+#define target_find_new_threads() \
+     (*current_target.to_find_new_threads) (); \
+
+/* Make target stop in a continuable fashion.  (For instance, under
+   Unix, this should act like SIGSTOP).  This function is normally
+   used by GUIs to implement a stop button.  */
 
 #define target_stop current_target.to_stop
 
@@ -897,53 +836,61 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    should process it.  The second argument is a string that specifies which 
    information is desired and the third is a buffer that carries back the 
    response from the target side. The fourth parameter is the size of the
-   output buffer supplied. */
- 
+   output buffer supplied.  */
+
 #define	target_query(query_type, query, resp_buffer, bufffer_size)	\
-	(*current_target.to_query) (query_type, query, resp_buffer, bufffer_size)
+     (*current_target.to_query) (query_type, query, resp_buffer, bufffer_size)
+
+/* Send the specified COMMAND to the target's monitor
+   (shell,interpreter) for execution.  The result of the query is
+   placed in OUTBUF.  */
+
+#define target_rcmd(command, outbuf) \
+     (*current_target.to_rcmd) (command, outbuf)
+
 
 /* Get the symbol information for a breakpointable routine called when
    an exception event occurs. 
    Intended mainly for C++, and for those
    platforms/implementations where such a callback mechanism is available,
    e.g. HP-UX with ANSI C++ (aCC).  Some compilers (e.g. g++) support
-   different mechanisms for debugging exceptions. */
+   different mechanisms for debugging exceptions.  */
 
 #define target_enable_exception_callback(kind, enable) \
-        (*current_target.to_enable_exception_callback) (kind, enable)
+     (*current_target.to_enable_exception_callback) (kind, enable)
+
+/* Get the current exception event kind -- throw or catch, etc.  */
 
-/* Get the current exception event kind -- throw or catch, etc. */
-   
 #define target_get_current_exception_event() \
-        (*current_target.to_get_current_exception_event) ()
+     (*current_target.to_get_current_exception_event) ()
 
 /* Pointer to next target in the chain, e.g. a core file and an exec file.  */
 
 #define	target_next \
-	(current_target.to_next)
+     (current_target.to_next)
 
 /* Does the target include all of memory, or only part of it?  This
    determines whether we look up the target chain for other parts of
    memory if this target can't satisfy a request.  */
 
 #define	target_has_all_memory	\
-	(current_target.to_has_all_memory)
+     (current_target.to_has_all_memory)
 
 /* Does the target include memory?  (Dummy targets don't.)  */
 
 #define	target_has_memory	\
-	(current_target.to_has_memory)
+     (current_target.to_has_memory)
 
 /* Does the target have a stack?  (Exec files don't, VxWorks doesn't, until
    we start a process.)  */
-   
+
 #define	target_has_stack	\
-	(current_target.to_has_stack)
+     (current_target.to_has_stack)
 
 /* Does the target have registers?  (Exec files don't.)  */
 
 #define	target_has_registers	\
-	(current_target.to_has_registers)
+     (current_target.to_has_registers)
 
 /* Does the target have execution?  Can we make it jump (through
    hoops), or pop its stack a few times?  FIXME: If this is to work that
@@ -953,69 +900,138 @@ print_section_info PARAMS ((struct target_ops *, bfd *));
    this just tells us whether this target is *capable* of execution.  */
 
 #define	target_has_execution	\
-	(current_target.to_has_execution)
+     (current_target.to_has_execution)
 
 /* Can the target support the debugger control of thread execution?
    a) Can it lock the thread scheduler?
    b) Can it switch the currently running thread?  */
 
 #define target_can_lock_scheduler \
- 	(current_target.to_has_thread_control & tc_schedlock)
+     (current_target.to_has_thread_control & tc_schedlock)
 
 #define target_can_switch_threads \
- 	(current_target.to_has_thread_control & tc_switch)
+     (current_target.to_has_thread_control & tc_switch)
+
+/* Can the target support asynchronous execution? */
+#define target_can_async_p() (current_target.to_can_async_p ())
+
+/* Is the target in asynchronous execution mode? */
+#define target_is_async_p() (current_target.to_is_async_p())
 
-extern void target_link PARAMS ((char *, CORE_ADDR *));
+/* Put the target in async mode with the specified callback function. */
+#define target_async(CALLBACK,CONTEXT) \
+     (current_target.to_async((CALLBACK), (CONTEXT)))
+
+/* This is to be used ONLY within run_stack_dummy(). It
+   provides a workaround, to have inferior function calls done in
+   sychronous mode, even though the target is asynchronous. After
+   target_async_mask(0) is called, calls to target_can_async_p() will
+   return FALSE , so that target_resume() will not try to start the
+   target asynchronously. After the inferior stops, we IMMEDIATELY
+   restore the previous nature of the target, by calling
+   target_async_mask(1). After that, target_can_async_p() will return
+   TRUE. ANY OTHER USE OF THIS FEATURE IS DEPRECATED. 
+
+   FIXME ezannoni 1999-12-13: we won't need this once we move
+   the turning async on and off to the single execution commands,
+   from where it is done currently, in remote_resume().  */
+
+#define	target_async_mask_value	\
+     (current_target.to_async_mask_value)
+
+extern int target_async_mask (int mask);     
+
+extern void target_link (char *, CORE_ADDR *);
 
 /* Converts a process id to a string.  Usually, the string just contains
    `process xyz', but on some systems it may contain
    `process xyz thread abc'.  */
 
-#ifndef target_pid_to_str
-#define target_pid_to_str(PID) \
-	normal_pid_to_str (PID)
-extern char *normal_pid_to_str PARAMS ((int pid));
-#endif
+#undef target_pid_to_str
+#define target_pid_to_str(PID) current_target.to_pid_to_str (PID)
 
 #ifndef target_tid_to_str
 #define target_tid_to_str(PID) \
-        normal_pid_to_str (PID)
-extern char *normal_pid_to_str PARAMS ((int pid));
+     target_pid_to_str (PID)
+extern char *normal_pid_to_str (ptid_t ptid);
 #endif
- 
 
-#ifndef target_new_objfile
-#define target_new_objfile(OBJFILE)
-#endif
+/* Return a short string describing extra information about PID,
+   e.g. "sleeping", "runnable", "running on LWP 3".  Null return value
+   is okay.  */
+
+#define target_extra_thread_info(TP) \
+     (current_target.to_extra_thread_info (TP))
+
+/*
+ * New Objfile Event Hook:
+ *
+ * Sometimes a GDB component wants to get notified whenever a new
+ * objfile is loaded.  Mainly this is used by thread-debugging 
+ * implementations that need to know when symbols for the target
+ * thread implemenation are available.
+ *
+ * The old way of doing this is to define a macro 'target_new_objfile'
+ * that points to the function that you want to be called on every
+ * objfile/shlib load.
+ *
+ * The new way is to grab the function pointer, 'target_new_objfile_hook',
+ * and point it to the function that you want to be called on every
+ * objfile/shlib load.
+ *
+ * If multiple clients are willing to be cooperative, they can each
+ * save a pointer to the previous value of target_new_objfile_hook
+ * before modifying it, and arrange for their function to call the
+ * previous function in the chain.  In that way, multiple clients
+ * can receive this notification (something like with signal handlers).
+ */
+
+extern void (*target_new_objfile_hook) (struct objfile *);
 
 #ifndef target_pid_or_tid_to_str
 #define target_pid_or_tid_to_str(ID) \
-	normal_pid_to_str (ID)
+     target_pid_to_str (ID)
 #endif
 
 /* Attempts to find the pathname of the executable file
    that was run to create a specified process.
 
    The process PID must be stopped when this operation is used.
-   
+
    If the executable file cannot be determined, NULL is returned.
 
    Else, a pointer to a character string containing the pathname
    is returned.  This string should be copied into a buffer by
    the client if the string will not be immediately used, or if
-   it must persist.
-   */
+   it must persist.  */
 
 #define target_pid_to_exec_file(pid) \
-	(current_target.to_pid_to_exec_file) (pid)
+     (current_target.to_pid_to_exec_file) (pid)
+
+/*
+ * Iterator function for target memory regions.
+ * Calls a callback function once for each memory region 'mapped'
+ * in the child process.  Defined as a simple macro rather than
+ * as a function macro so that it can be tested for nullity.  
+ */
+
+#define target_find_memory_regions(FUNC, DATA) \
+     (current_target.to_find_memory_regions) (FUNC, DATA)
 
-/* Hook to call target-dependant code after reading in a new symbol table. */
+/*
+ * Compose corefile .note section.
+ */
+
+#define target_make_corefile_notes(BFD, SIZE_P) \
+     (current_target.to_make_corefile_notes) (BFD, SIZE_P)
+
+/* Hook to call target-dependent code after reading in a new symbol table.  */
 
 #ifndef TARGET_SYMFILE_POSTREAD
 #define TARGET_SYMFILE_POSTREAD(OBJFILE)
 #endif
 
-/* Hook to call target dependant code just after inferior target process has
+/* Hook to call target dependent code just after inferior target process has
    started.  */
 
 #ifndef TARGET_CREATE_INFERIOR_HOOK
@@ -1033,8 +1049,8 @@ extern char *normal_pid_to_str PARAMS ((int pid));
 
 /* HP-UX supplies these operations, which respectively disable and enable
    the memory page-protections that are used to implement hardware watchpoints
-   on that platform.  See wait_for_inferior's use of these.
-   */
+   on that platform.  See wait_for_inferior's use of these.  */
+
 #if !defined(TARGET_DISABLE_HW_WATCHPOINTS)
 #define TARGET_DISABLE_HW_WATCHPOINTS(pid)
 #endif
@@ -1043,7 +1059,7 @@ extern char *normal_pid_to_str PARAMS ((int pid));
 #define TARGET_ENABLE_HW_WATCHPOINTS(pid)
 #endif
 
-/* Provide defaults for systems that don't support hardware watchpoints. */
+/* Provide defaults for systems that don't support hardware watchpoints.  */
 
 #ifndef TARGET_HAS_HARDWARE_WATCHPOINTS
 
@@ -1056,18 +1072,7 @@ extern char *normal_pid_to_str PARAMS ((int pid));
 
 #if !defined(TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT)
 #define TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT(byte_count) \
-        (LONGEST)(byte_count) <= REGISTER_SIZE
-#endif
-
-/* However, some addresses may not be profitable to use hardware to watch,
-   or may be difficult to understand when the addressed object is out of
-   scope, and hence should be unwatched.  On some targets, this may have
-   severe performance penalties, such that we might as well use regular
-   watchpoints, and save (possibly precious) hardware watchpoints for other
-   locations.
-   */
-#if !defined(TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT)
-#define TARGET_RANGE_PROFITABLE_FOR_HW_WATCHPOINT(pid,start,len) 0
+     ((LONGEST)(byte_count) <= REGISTER_SIZE)
 #endif
 
 
@@ -1099,8 +1104,8 @@ extern char *normal_pid_to_str PARAMS ((int pid));
 /* Sometimes gdb may pick up what appears to be a valid target address
    from a minimal symbol, but the value really means, essentially,
    "This is an index into a table which is populated when the inferior
-   is run.  Therefore, do not attempt to use this as a PC."
-   */
+   is run.  Therefore, do not attempt to use this as a PC."  */
+
 #if !defined(PC_REQUIRES_RUN_BEFORE_USE)
 #define PC_REQUIRES_RUN_BEFORE_USE(pc) (0)
 #endif
@@ -1111,8 +1116,7 @@ extern char *normal_pid_to_str PARAMS ((int pid));
    On some targets (such as HP-UX 10.20 and earlier), resuming a newly vforked
    child process after it has exec'd, causes the parent process to resume as
    well.  To prevent the parent from running spontaneously, such targets should
-   define this to a function that prevents that from happening.
-   */
+   define this to a function that prevents that from happening.  */
 #if !defined(ENSURE_VFORKING_PARENT_REMAINS_STOPPED)
 #define ENSURE_VFORKING_PARENT_REMAINS_STOPPED(PID) (0)
 #endif
@@ -1122,8 +1126,8 @@ extern char *normal_pid_to_str PARAMS ((int pid));
 
    On some targets (such as HP-UX 10.20 and earlier), a newly vforked child
    process must be resumed when it delivers its exec event, before the parent
-   vfork event will be delivered to us.
-   */
+   vfork event will be delivered to us.  */
+
 #if !defined(RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK)
 #define RESUME_EXECD_VFORKING_CHILD_TO_GET_PARENT_VFORK() (0)
 #endif
@@ -1133,88 +1137,86 @@ extern char *normal_pid_to_str PARAMS ((int pid));
    add_target:   Add a target to the list of all possible targets.
 
    push_target:  Make this target the top of the stack of currently used
-		 targets, within its particular stratum of the stack.  Result
-		 is 0 if now atop the stack, nonzero if not on top (maybe
-		 should warn user).
+   targets, within its particular stratum of the stack.  Result
+   is 0 if now atop the stack, nonzero if not on top (maybe
+   should warn user).
 
    unpush_target: Remove this from the stack of currently used targets,
-		 no matter where it is on the list.  Returns 0 if no
-		 change, 1 if removed from stack.
+   no matter where it is on the list.  Returns 0 if no
+   change, 1 if removed from stack.
 
-   pop_target:	 Remove the top thing on the stack of current targets.  */
+   pop_target:   Remove the top thing on the stack of current targets.  */
 
-extern void
-add_target PARAMS ((struct target_ops *));
+extern void add_target (struct target_ops *);
 
-extern int
-push_target PARAMS ((struct target_ops *));
+extern int push_target (struct target_ops *);
 
-extern int
-unpush_target PARAMS ((struct target_ops *));
+extern int unpush_target (struct target_ops *);
 
-extern void
-target_preopen PARAMS ((int));
+extern void target_preopen (int);
 
-extern void
-pop_target PARAMS ((void));
+extern void pop_target (void);
 
 /* Struct section_table maps address ranges to file sections.  It is
    mostly used with BFD files, but can be used without (e.g. for handling
    raw disks, or files not in formats handled by BFD).  */
 
-struct section_table {
-  CORE_ADDR addr;		/* Lowest address in section */
-  CORE_ADDR endaddr;		/* 1+highest address in section */
+struct section_table
+  {
+    CORE_ADDR addr;		/* Lowest address in section */
+    CORE_ADDR endaddr;		/* 1+highest address in section */
 
-  sec_ptr the_bfd_section;
+    sec_ptr the_bfd_section;
 
-  bfd	   *bfd;		/* BFD file pointer */
-};
+    bfd *bfd;			/* BFD file pointer */
+  };
 
 /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
    Returns 0 if OK, 1 on error.  */
 
 extern int
-build_section_table PARAMS ((bfd *, struct section_table **,
-			     struct section_table **));
+build_section_table (bfd *, struct section_table **, struct section_table **);
 
 /* From mem-break.c */
 
-extern int memory_remove_breakpoint PARAMS ((CORE_ADDR, char *));
+extern int memory_remove_breakpoint (CORE_ADDR, char *);
+
+extern int memory_insert_breakpoint (CORE_ADDR, char *);
 
-extern int memory_insert_breakpoint PARAMS ((CORE_ADDR, char *));
+extern int default_memory_remove_breakpoint (CORE_ADDR, char *);
+
+extern int default_memory_insert_breakpoint (CORE_ADDR, char *);
 
 extern breakpoint_from_pc_fn memory_breakpoint_from_pc;
-#ifndef BREAKPOINT_FROM_PC
-#define BREAKPOINT_FROM_PC(pcptr, lenptr) memory_breakpoint_from_pc (pcptr, lenptr)
-#endif
 
 
 /* From target.c */
 
-extern void
-initialize_targets PARAMS ((void));
+extern void initialize_targets (void);
+
+extern void noprocess (void);
+
+extern void find_default_attach (char *, int);
+
+extern void find_default_require_attach (char *, int);
 
-extern void
-noprocess PARAMS ((void));
+extern void find_default_require_detach (int, char *, int);
 
-extern void
-find_default_attach PARAMS ((char *, int));
+extern void find_default_create_inferior (char *, char *, char **);
 
-void
-find_default_require_attach PARAMS ((char *, int));
+extern void find_default_clone_and_follow_inferior (int, int *);
 
-void
-find_default_require_detach PARAMS ((int, char *, int));
+extern struct target_ops *find_run_target (void);
 
-extern void
-find_default_create_inferior PARAMS ((char *, char *, char **));
+extern struct target_ops *find_core_target (void);
 
-void
-find_default_clone_and_follow_inferior PARAMS ((int, int *));
+extern struct target_ops *find_target_beneath (struct target_ops *);
+
+extern int
+target_resize_to_sections (struct target_ops *target, int num_added);
+
+extern void remove_target_sections (bfd *abfd);
 
-extern struct target_ops *
-find_core_target PARAMS ((void));
 
 /* Stuff that should be shared among the various remote targets.  */
 
@@ -1227,39 +1229,43 @@ extern int baud_rate;
 /* Timeout limit for response from target. */
 extern int remote_timeout;
 
-extern asection *target_memory_bfd_section;
 
 /* Functions for helping to write a native target.  */
 
 /* This is for native targets which use a unix/POSIX-style waitstatus.  */
-extern void store_waitstatus PARAMS ((struct target_waitstatus *, int));
-
-/* Convert between host signal numbers and enum target_signal's.  */
-extern enum target_signal target_signal_from_host PARAMS ((int));
-extern int target_signal_to_host PARAMS ((enum target_signal));
+extern void store_waitstatus (struct target_waitstatus *, int);
+
+/* Predicate to target_signal_to_host(). Return non-zero if the enum
+   targ_signal SIGNO has an equivalent ``host'' representation.  */
+/* FIXME: cagney/1999-11-22: The name below was chosen in preference
+   to the shorter target_signal_p() because it is far less ambigious.
+   In this context ``target_signal'' refers to GDB's internal
+   representation of the target's set of signals while ``host signal''
+   refers to the target operating system's signal.  Confused?  */
+
+extern int target_signal_to_host_p (enum target_signal signo);
+
+/* Convert between host signal numbers and enum target_signal's.
+   target_signal_to_host() returns 0 and prints a warning() on GDB's
+   console if SIGNO has no equivalent host representation.  */
+/* FIXME: cagney/1999-11-22: Here ``host'' is used incorrectly, it is
+   refering to the target operating system's signal numbering.
+   Similarly, ``enum target_signal'' is named incorrectly, ``enum
+   gdb_signal'' would probably be better as it is refering to GDB's
+   internal representation of a target operating system's signal.  */
+
+extern enum target_signal target_signal_from_host (int);
+extern int target_signal_to_host (enum target_signal);
 
 /* Convert from a number used in a GDB command to an enum target_signal.  */
-extern enum target_signal target_signal_from_command PARAMS ((int));
+extern enum target_signal target_signal_from_command (int);
 
 /* Any target can call this to switch to remote protocol (in remote.c). */
-extern void push_remote_target PARAMS ((char *name, int from_tty));
+extern void push_remote_target (char *name, int from_tty);
 
 /* Imported from machine dependent code */
 
-#ifndef SOFTWARE_SINGLE_STEP_P
-#define SOFTWARE_SINGLE_STEP_P 0
-#define SOFTWARE_SINGLE_STEP(sig,bp_p) abort ()
-#endif /* SOFTWARE_SINGLE_STEP_P */
-
 /* Blank target vector entries are initialized to target_ignore. */
-void target_ignore PARAMS ((void));
-
-/* Macro for getting target's idea of a frame pointer.
-   FIXME: GDB's whole scheme for dealing with "frames" and
-   "frame pointers" needs a serious shakedown.  */
-#ifndef TARGET_VIRTUAL_FRAME_POINTER
-#define TARGET_VIRTUAL_FRAME_POINTER(ADDR, REGP, OFFP) \
-   do { *(REGP) = FP_REGNUM; *(OFFP) =  0; } while (0)
-#endif /* TARGET_VIRTUAL_FRAME_POINTER */
+void target_ignore (void);
 
-#endif	/* !defined (TARGET_H) */
+#endif /* !defined (TARGET_H) */