X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fremote-sim.c;h=7875f77076c48c67332217ffd2a242e18fdec422;hb=91158a569dc571a9916dfad98c6c95ce789ad18d;hp=c992e9ac2e80599cfe7251ae3c3112f4c5a3ceb8;hpb=fba45db2faf619e71856ee38ec63949c0ef6903e;p=binutils-gdb.git

diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index c992e9ac2e8..7875f77076c 100644
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -1,5 +1,8 @@
 /* Generic remote debugging interface for simulators.
-   Copyright 1993, 1994, 1996, 1997, 2000 Free Software Foundation, Inc.
+
+   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+   2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+
    Contributed by Cygnus Support.
    Steve Chamberlain (sac@cygnus.com).
 
@@ -7,7 +10,7 @@
 
    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
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
@@ -16,13 +19,10 @@
    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.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "inferior.h"
-#include "gdb_wait.h"
 #include "value.h"
 #include "gdb_string.h"
 #include <ctype.h>
@@ -33,17 +33,20 @@
 #include "terminal.h"
 #include "target.h"
 #include "gdbcore.h"
-#include "callback.h"
-#include "remote-sim.h"
-#include "remote-utils.h"
+#include "gdb/callback.h"
+#include "gdb/remote-sim.h"
 #include "command.h"
+#include "regcache.h"
+#include "gdb_assert.h"
+#include "sim-regno.h"
+#include "arch-utils.h"
+#include "readline/readline.h"
+#include "gdbthread.h"
 
 /* Prototypes */
 
 extern void _initialize_remote_sim (void);
 
-extern int (*ui_loop_hook) (int signo);
-
 static void dump_mem (char *buf, int len);
 
 static void init_callbacks (void);
@@ -67,39 +70,26 @@ static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
 
 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
 
-static void gdb_os_error (host_callback *, const char *, ...);
-
-static void gdbsim_fetch_register (int regno);
+static void gdb_os_error (host_callback *, const char *, ...)
+     ATTRIBUTE_NORETURN;
 
-static void gdbsim_store_register (int regno);
-
-static void gdbsim_kill (void);
+static void gdbsim_kill (struct target_ops *);
 
 static void gdbsim_load (char *prog, int fromtty);
 
-static void gdbsim_create_inferior (char *exec_file, char *args, char **env);
-
 static void gdbsim_open (char *args, int from_tty);
 
 static void gdbsim_close (int quitting);
 
-static void gdbsim_detach (char *args, int from_tty);
-
-static void gdbsim_resume (int pid, int step, enum target_signal siggnal);
+static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
 
-static int gdbsim_wait (int pid, struct target_waitstatus *status);
-
-static void gdbsim_prepare_to_store (void);
-
-static int gdbsim_xfer_inferior_memory (CORE_ADDR memaddr,
-					char *myaddr, int len,
-					int write, struct target_ops *target);
+static void gdbsim_prepare_to_store (struct regcache *regcache);
 
 static void gdbsim_files_info (struct target_ops *target);
 
-static void gdbsim_mourn_inferior (void);
+static void gdbsim_mourn_inferior (struct target_ops *target);
 
-static void gdbsim_stop (void);
+static void gdbsim_stop (ptid_t ptid);
 
 void simulator_command (char *args, int from_tty);
 
@@ -119,6 +109,12 @@ static int program_loaded = 0;
    back to the other sim_foo routines.  */
 static SIM_DESC gdbsim_desc = 0;
 
+/* This is the ptid we use while we're connected to the simulator.
+   Its value is arbitrary, as the simulator target don't have a notion
+   or processes or threads, but we need something non-null to place in
+   inferior_ptid.  */
+static ptid_t remote_sim_ptid;
+
 static void
 dump_mem (char *buf, int len)
 {
@@ -127,13 +123,17 @@ dump_mem (char *buf, int len)
       if (len == 8 || len == 4)
 	{
 	  long l[2];
+
 	  memcpy (l, buf, len);
 	  printf_filtered ("\t0x%lx", l[0]);
-	  printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
+	  if (len == 8)
+	    printf_filtered (" 0x%lx", l[1]);
+	  printf_filtered ("\n");
 	}
       else
 	{
 	  int i;
+
 	  printf_filtered ("\t");
 	  for (i = 0; i < len; i++)
 	    printf_filtered ("0x%x ", buf[i]);
@@ -212,7 +212,7 @@ gdb_os_write_stderr (host_callback *p, const char *buf, int len)
     {
       b[0] = buf[i];
       b[1] = 0;
-      fputs_unfiltered (b, gdb_stdtarg);
+      fputs_unfiltered (b, gdb_stdtargerr);
     }
   return len;
 }
@@ -222,7 +222,7 @@ gdb_os_write_stderr (host_callback *p, const char *buf, int len)
 static void
 gdb_os_flush_stderr (host_callback *p)
 {
-  gdb_flush (gdb_stderr);
+  gdb_flush (gdb_stdtargerr);
 }
 
 /* GDB version of printf_filtered callback.  */
@@ -231,10 +231,9 @@ static void
 gdb_os_printf_filtered (host_callback * p, const char *format,...)
 {
   va_list args;
-  va_start (args, format);
 
+  va_start (args, format);
   vfprintf_filtered (gdb_stdout, format, args);
-
   va_end (args);
 }
 
@@ -257,92 +256,127 @@ gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
 /* GDB version of error callback.  */
 
 static void
-gdb_os_error (host_callback * p, const char *format,...)
+gdb_os_error (host_callback * p, const char *format, ...)
 {
-  if (error_hook)
-    (*error_hook) ();
-  else
-    {
-      va_list args;
-      va_start (args, format);
-      verror (format, args);
-      va_end (args);
-    }
+  va_list args;
+
+  va_start (args, format);
+  verror (format, args);
+  va_end (args);
 }
 
-#ifndef REGISTER_SIM_REGNO
-#define REGISTER_SIM_REGNO(N) (N)
-#endif
+int
+one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
+{
+  /* Only makes sense to supply raw registers.  */
+  gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
+  return regnum;
+}
 
 static void
-gdbsim_fetch_register (int regno)
+gdbsim_fetch_register (struct target_ops *ops,
+		       struct regcache *regcache, int regno)
 {
-  static int warn_user = 1;
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
+
   if (regno == -1)
     {
-      for (regno = 0; regno < NUM_REGS; regno++)
-	gdbsim_fetch_register (regno);
+      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
+	gdbsim_fetch_register (ops, regcache, regno);
+      return;
     }
-  else if (REGISTER_NAME (regno) != NULL
-	   && *REGISTER_NAME (regno) != '\0')
+
+  switch (gdbarch_register_sim_regno (gdbarch, regno))
     {
-      char buf[MAX_REGISTER_RAW_SIZE];
-      int nr_bytes;
-      if (REGISTER_SIM_REGNO (regno) >= 0)
+    case LEGACY_SIM_REGNO_IGNORE:
+      break;
+    case SIM_REGNO_DOES_NOT_EXIST:
+      {
+	/* For moment treat a `does not exist' register the same way
+           as an ``unavailable'' register.  */
+	char buf[MAX_REGISTER_SIZE];
+	int nr_bytes;
+
+	memset (buf, 0, MAX_REGISTER_SIZE);
+	regcache_raw_supply (regcache, regno, buf);
+	break;
+      }
+      
+    default:
+      {
+	static int warn_user = 1;
+	char buf[MAX_REGISTER_SIZE];
+	int nr_bytes;
+
+	gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
+	memset (buf, 0, MAX_REGISTER_SIZE);
 	nr_bytes = sim_fetch_register (gdbsim_desc,
-				       REGISTER_SIM_REGNO (regno),
-				       buf, REGISTER_RAW_SIZE (regno));
-      else
-	nr_bytes = 0;
-      if (nr_bytes == 0)
-	/* register not applicable, supply zero's */
-	memset (buf, 0, MAX_REGISTER_RAW_SIZE);
-      else if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno)
-	       && warn_user)
-	{
-	  fprintf_unfiltered (gdb_stderr,
-			      "Size of register %s (%d/%d) incorrect (%d instead of %d))",
-			      REGISTER_NAME (regno),
-			      regno, REGISTER_SIM_REGNO (regno),
-			      nr_bytes, REGISTER_RAW_SIZE (regno));
-	  warn_user = 0;
-	}
-      supply_register (regno, buf);
-      if (sr_get_debug ())
-	{
-	  printf_filtered ("gdbsim_fetch_register: %d", regno);
-	  /* FIXME: We could print something more intelligible.  */
-	  dump_mem (buf, REGISTER_RAW_SIZE (regno));
-	}
+				       gdbarch_register_sim_regno
+					 (gdbarch, regno),
+				       buf,
+				       register_size (gdbarch, regno));
+	if (nr_bytes > 0
+	    && nr_bytes != register_size (gdbarch, regno) && warn_user)
+	  {
+	    fprintf_unfiltered (gdb_stderr,
+				"Size of register %s (%d/%d) incorrect (%d instead of %d))",
+				gdbarch_register_name (gdbarch, regno),
+				regno,
+				gdbarch_register_sim_regno
+				  (gdbarch, regno),
+				nr_bytes, register_size (gdbarch, regno));
+	    warn_user = 0;
+	  }
+	/* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
+	   indicating that GDB and the SIM have different ideas about
+	   which registers are fetchable.  */
+	/* Else if (nr_bytes < 0): an old simulator, that doesn't
+	   think to return the register size.  Just assume all is ok.  */
+	regcache_raw_supply (regcache, regno, buf);
+	if (remote_debug)
+	  {
+	    printf_filtered ("gdbsim_fetch_register: %d", regno);
+	    /* FIXME: We could print something more intelligible.  */
+	    dump_mem (buf, register_size (gdbarch, regno));
+	  }
+	break;
+      }
     }
 }
 
 
 static void
-gdbsim_store_register (int regno)
+gdbsim_store_register (struct target_ops *ops,
+		       struct regcache *regcache, int regno)
 {
+  struct gdbarch *gdbarch = get_regcache_arch (regcache);
   if (regno == -1)
     {
-      for (regno = 0; regno < NUM_REGS; regno++)
-	gdbsim_store_register (regno);
+      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
+	gdbsim_store_register (ops, regcache, regno);
+      return;
     }
-  else if (REGISTER_NAME (regno) != NULL
-	   && *REGISTER_NAME (regno) != '\0'
-	   && REGISTER_SIM_REGNO (regno) >= 0)
+  else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
     {
-      char tmp[MAX_REGISTER_RAW_SIZE];
+      char tmp[MAX_REGISTER_SIZE];
       int nr_bytes;
-      read_register_gen (regno, tmp);
+
+      regcache_cooked_read (regcache, regno, tmp);
       nr_bytes = sim_store_register (gdbsim_desc,
-				     REGISTER_SIM_REGNO (regno),
-				     tmp, REGISTER_RAW_SIZE (regno));
-      if (nr_bytes > 0 && nr_bytes != REGISTER_RAW_SIZE (regno))
-	internal_error ("Register size different to expected");
-      if (sr_get_debug ())
+				     gdbarch_register_sim_regno
+				       (gdbarch, regno),
+				     tmp, register_size (gdbarch, regno));
+      if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
+	internal_error (__FILE__, __LINE__,
+			_("Register size different to expected"));
+      /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
+	 indicating that GDB and the SIM have different ideas about
+	 which registers are fetchable.  */
+      if (remote_debug)
 	{
 	  printf_filtered ("gdbsim_store_register: %d", regno);
 	  /* FIXME: We could print something more intelligible.  */
-	  dump_mem (tmp, REGISTER_RAW_SIZE (regno));
+	  dump_mem (tmp, register_size (gdbarch, regno));
 	}
     }
 }
@@ -351,14 +385,14 @@ gdbsim_store_register (int regno)
    and releasing other resources acquired by the simulated program.  */
 
 static void
-gdbsim_kill (void)
+gdbsim_kill (struct target_ops *ops)
 {
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_kill\n");
 
   /* There is no need to `kill' running simulator - the simulator is
-     not running */
-  inferior_pid = 0;
+     not running.  Mourning it is enough.  */
+  target_mourn_inferior ();
 }
 
 /* Load an executable file into the target process.  This is expected to
@@ -366,18 +400,30 @@ gdbsim_kill (void)
    GDB's symbol tables to match.  */
 
 static void
-gdbsim_load (char *prog, int fromtty)
+gdbsim_load (char *args, int fromtty)
 {
-  if (sr_get_debug ())
-    printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
+  char **argv;
+  char *prog;
+
+  if (args == NULL)
+      error_no_arg (_("program to load"));
+
+  argv = gdb_buildargv (args);
+  make_cleanup_freeargv (argv);
+
+  prog = tilde_expand (argv[0]);
 
-  inferior_pid = 0;
+  if (argv[1] != NULL)
+    error (_("GDB sim does not yet support a load offset."));
+
+  if (remote_debug)
+    printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
 
   /* FIXME: We will print two messages on error.
      Need error to either not print anything if passed NULL or need
      another routine that doesn't take any arguments.  */
   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
-    error ("unable to load program");
+    error (_("unable to load program"));
 
   /* FIXME: If a load command should reset the targets registers then
      a call to sim_create_inferior() should go here. */
@@ -386,7 +432,7 @@ gdbsim_load (char *prog, int fromtty)
 }
 
 
-/* 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.
    ARGS is a string containing the arguments to the program.
    ENV is the environment vector to pass.  Errors reported with error().
@@ -395,22 +441,24 @@ gdbsim_load (char *prog, int fromtty)
    user types "run" after having attached.  */
 
 static void
-gdbsim_create_inferior (char *exec_file, char *args, char **env)
+gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
+			char **env, int from_tty)
 {
   int len;
   char *arg_buf, **argv;
 
   if (exec_file == 0 || exec_bfd == 0)
-    warning ("No executable file specified.");
+    warning (_("No executable file specified."));
   if (!program_loaded)
-    warning ("No program loaded.");
+    warning (_("No program loaded."));
 
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
 		     (exec_file ? exec_file : "(NULL)"),
 		     args);
 
-  gdbsim_kill ();
+  if (ptid_equal (inferior_ptid, remote_sim_ptid))
+    gdbsim_kill (target);
   remove_breakpoints ();
   init_wait_for_inferior ();
 
@@ -422,20 +470,20 @@ gdbsim_create_inferior (char *exec_file, char *args, char **env)
       strcat (arg_buf, exec_file);
       strcat (arg_buf, " ");
       strcat (arg_buf, args);
-      argv = buildargv (arg_buf);
+      argv = gdb_buildargv (arg_buf);
       make_cleanup_freeargv (argv);
     }
   else
     argv = NULL;
   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
 
-  inferior_pid = 42;
+  inferior_ptid = remote_sim_ptid;
+  inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
+  add_thread_silent (inferior_ptid);
+
   insert_breakpoints ();	/* Needed to get correct instruction in cache */
 
   clear_proceed_status ();
-
-  /* NB: Entry point already set by sim_create_inferior. */
-  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
 }
 
 /* The open routine takes the rest of the parameters from the command,
@@ -450,7 +498,7 @@ gdbsim_open (char *args, int from_tty)
   char *arg_buf;
   char **argv;
 
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
 
   /* Remove current simulator if one exists.  Only do this if the simulator
@@ -469,29 +517,25 @@ gdbsim_open (char *args, int from_tty)
 	 + 50) /* slack */ ;
   arg_buf = (char *) alloca (len);
   strcpy (arg_buf, "gdbsim");	/* 7 */
-  /* Specify the byte order for the target when it is both selectable
-     and explicitly specified by the user (not auto detected). */
-  if (TARGET_BYTE_ORDER_SELECTABLE_P
-      && !TARGET_BYTE_ORDER_AUTO)
+  /* Specify the byte order for the target when it is explicitly
+     specified by the user (not auto detected). */
+  switch (selected_byte_order ())
     {
-      switch (TARGET_BYTE_ORDER)
-	{
-	case BIG_ENDIAN:
-	  strcat (arg_buf, " -E big");
-	  break;
-	case LITTLE_ENDIAN:
-	  strcat (arg_buf, " -E little");
-	  break;
-	default:
-	  internal_error ("Value of TARGET_BYTE_ORDER unknown");
-	}
+    case BFD_ENDIAN_BIG:
+      strcat (arg_buf, " -E big");
+      break;
+    case BFD_ENDIAN_LITTLE:
+      strcat (arg_buf, " -E little");
+      break;
+    case BFD_ENDIAN_UNKNOWN:
+      break;
     }
   /* Specify the architecture of the target when it has been
      explicitly specified */
-  if (!TARGET_ARCHITECTURE_AUTO)
+  if (selected_architecture_name () != NULL)
     {
       strcat (arg_buf, " --architecture=");
-      strcat (arg_buf, TARGET_ARCHITECTURE->printable_name);
+      strcat (arg_buf, selected_architecture_name ());
     }
   /* finally, any explicit args */
   if (args)
@@ -499,20 +543,21 @@ gdbsim_open (char *args, int from_tty)
       strcat (arg_buf, " ");	/* 1 */
       strcat (arg_buf, args);
     }
-  argv = buildargv (arg_buf);
-  if (argv == NULL)
-    error ("Insufficient memory available to allocate simulator arg list.");
+  argv = gdb_buildargv (arg_buf);
   make_cleanup_freeargv (argv);
 
   init_callbacks ();
   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
 
   if (gdbsim_desc == 0)
-    error ("unable to create simulator instance");
+    error (_("unable to create simulator instance"));
 
   push_target (&gdbsim_ops);
-  target_fetch_registers (-1);
   printf_filtered ("Connected to the simulator.\n");
+
+  /* There's nothing running after "target sim" or "load"; not until
+     "run".  */
+  inferior_ptid = null_ptid;
 }
 
 /* Does whatever cleanup is required for a target that we are no longer
@@ -527,7 +572,7 @@ gdbsim_open (char *args, int from_tty)
 static void
 gdbsim_close (int quitting)
 {
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
 
   program_loaded = 0;
@@ -540,6 +585,8 @@ gdbsim_close (int quitting)
 
   end_callbacks ();
   generic_mourn_inferior ();
+  delete_thread_silent (remote_sim_ptid);
+  delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
 }
 
 /* Takes a program previously attached to and detaches it.
@@ -552,9 +599,9 @@ gdbsim_close (int quitting)
    Use this when you want to detach and do something else with your gdb.  */
 
 static void
-gdbsim_detach (char *args, int from_tty)
+gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
 {
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
 
   pop_target ();		/* calls gdbsim_close to do the real work */
@@ -570,12 +617,13 @@ static enum target_signal resume_siggnal;
 static int resume_step;
 
 static void
-gdbsim_resume (int pid, int step, enum target_signal siggnal)
+gdbsim_resume (struct target_ops *ops,
+	       ptid_t ptid, int step, enum target_signal siggnal)
 {
-  if (inferior_pid != 42)
-    error ("The program is not being run.");
+  if (!ptid_equal (inferior_ptid, remote_sim_ptid))
+    error (_("The program is not being run."));
 
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
 
   resume_siggnal = siggnal;
@@ -592,7 +640,7 @@ gdbsim_resume (int pid, int step, enum target_signal siggnal)
    For simulators that do not support this operation, just abort */
 
 static void
-gdbsim_stop (void)
+gdbsim_stop (ptid_t ptid)
 {
   if (!sim_stop (gdbsim_desc))
     {
@@ -601,15 +649,14 @@ gdbsim_stop (void)
 }
 
 /* GDB version of os_poll_quit callback.
-   Taken from gdb/util.c - should be in a library */
+   Taken from gdb/util.c - should be in a library.  */
 
 static int
 gdb_os_poll_quit (host_callback *p)
 {
-  if (ui_loop_hook != NULL)
-    ui_loop_hook (0);
+  if (deprecated_ui_loop_hook != NULL)
+    deprecated_ui_loop_hook (0);
 
-  notice_quit ();
   if (quit_flag)		/* gdb's idea of quit */
     {
       quit_flag = 0;		/* we've stolen it */
@@ -629,17 +676,18 @@ gdb_os_poll_quit (host_callback *p)
 static void
 gdbsim_cntrl_c (int signo)
 {
-  gdbsim_stop ();
+  gdbsim_stop (remote_sim_ptid);
 }
 
-static int
-gdbsim_wait (int pid, struct target_waitstatus *status)
+static ptid_t
+gdbsim_wait (struct target_ops *ops,
+	     ptid_t ptid, struct target_waitstatus *status, int options)
 {
   static RETSIGTYPE (*prev_sigint) ();
   int sigrc = 0;
   enum sim_stop reason = sim_running;
 
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_wait\n");
 
 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
@@ -654,8 +702,7 @@ gdbsim_wait (int pid, struct target_waitstatus *status)
 #else
   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 #endif
-  sim_resume (gdbsim_desc, resume_step,
-	      target_signal_to_host (resume_siggnal));
+  sim_resume (gdbsim_desc, resume_step, resume_siggnal);
   signal (SIGINT, prev_sigint);
   resume_step = 0;
 
@@ -670,24 +717,20 @@ gdbsim_wait (int pid, struct target_waitstatus *status)
     case sim_stopped:
       switch (sigrc)
 	{
-	case SIGABRT:
+	case TARGET_SIGNAL_ABRT:
 	  quit ();
 	  break;
-	case SIGINT:
-	case SIGTRAP:
+	case TARGET_SIGNAL_INT:
+	case TARGET_SIGNAL_TRAP:
 	default:
 	  status->kind = TARGET_WAITKIND_STOPPED;
-	  /* The signal in sigrc is a host signal.  That probably
-	     should be fixed.  */
-	  status->value.sig = target_signal_from_host (sigrc);
+	  status->value.sig = sigrc;
 	  break;
 	}
       break;
     case sim_signalled:
       status->kind = TARGET_WAITKIND_SIGNALLED;
-      /* The signal in sigrc is a host signal.  That probably
-         should be fixed.  */
-      status->value.sig = target_signal_from_host (sigrc);
+      status->value.sig = sigrc;
       break;
     case sim_running:
     case sim_polling:
@@ -695,7 +738,7 @@ gdbsim_wait (int pid, struct target_waitstatus *status)
       break;
     }
 
-  return inferior_pid;
+  return inferior_ptid;
 }
 
 /* Get ready to modify the registers array.  On machines which store
@@ -705,30 +748,39 @@ gdbsim_wait (int pid, struct target_waitstatus *status)
    debugged.  */
 
 static void
-gdbsim_prepare_to_store (void)
+gdbsim_prepare_to_store (struct regcache *regcache)
 {
   /* Do nothing, since we can store individual regs */
 }
 
+/* Transfer LEN bytes between GDB address MYADDR and target address
+   MEMADDR.  If WRITE is non-zero, transfer them to the target,
+   otherwise transfer them from the target.  TARGET is unused.
+
+   Returns the number of bytes transferred. */
+
 static int
-gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
-     CORE_ADDR memaddr;
-     char *myaddr;
-     int len;
-     int write;
-     struct target_ops *target;	/* ignored */
+gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+			     int write, struct mem_attrib *attrib,
+			     struct target_ops *target)
 {
+  /* If no program is running yet, then ignore the simulator for
+     memory.  Pass the request down to the next target, hopefully
+     an exec file.  */
+  if (!target_has_execution)
+    return 0;
+
   if (!program_loaded)
-    error ("No program loaded.");
+    error (_("No program loaded."));
 
-  if (sr_get_debug ())
+  if (remote_debug)
     {
       /* FIXME: Send to something other than STDOUT? */
       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
       gdb_print_host_address (myaddr, gdb_stdout);
-      printf_filtered (", memaddr 0x%s, len %d, write %d\n",
-		       paddr_nz (memaddr), len, write);
-      if (sr_get_debug () && write)
+      printf_filtered (", memaddr %s, len %d, write %d\n",
+		       paddress (target_gdbarch, memaddr), len, write);
+      if (remote_debug && write)
 	dump_mem (myaddr, len);
     }
 
@@ -739,7 +791,7 @@ gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
   else
     {
       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
-      if (sr_get_debug () && len > 0)
+      if (remote_debug && len > 0)
 	dump_mem (myaddr, len);
     }
   return len;
@@ -748,12 +800,12 @@ gdbsim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 static void
 gdbsim_files_info (struct target_ops *target)
 {
-  char *file = "nothing";
+  const char *file = "nothing";
 
   if (exec_bfd)
     file = bfd_get_filename (exec_bfd);
 
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
 
   if (exec_bfd)
@@ -767,58 +819,14 @@ gdbsim_files_info (struct target_ops *target)
 /* Clear the simulator's notion of what the break points are.  */
 
 static void
-gdbsim_mourn_inferior (void)
+gdbsim_mourn_inferior (struct target_ops *target)
 {
-  if (sr_get_debug ())
+  if (remote_debug)
     printf_filtered ("gdbsim_mourn_inferior:\n");
 
   remove_breakpoints ();
   generic_mourn_inferior ();
-}
-
-static int
-gdbsim_insert_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-#ifdef SIM_HAS_BREAKPOINTS
-  SIM_RC retcode;
-
-  retcode = sim_set_breakpoint (gdbsim_desc, addr);
-
-  switch (retcode)
-    {
-    case SIM_RC_OK:
-      return 0;
-    case SIM_RC_INSUFFICIENT_RESOURCES:
-      return ENOMEM;
-    default:
-      return EIO;
-    }
-#else
-  return memory_insert_breakpoint (addr, contents_cache);
-#endif
-}
-
-static int
-gdbsim_remove_breakpoint (CORE_ADDR addr, char *contents_cache)
-{
-#ifdef SIM_HAS_BREAKPOINTS
-  SIM_RC retcode;
-
-  retcode = sim_clear_breakpoint (gdbsim_desc, addr);
-
-  switch (retcode)
-    {
-    case SIM_RC_OK:
-    case SIM_RC_UNKNOWN_BREAKPOINT:
-      return 0;
-    case SIM_RC_INSUFFICIENT_RESOURCES:
-      return ENOMEM;
-    default:
-      return EIO;
-    }
-#else
-  return memory_remove_breakpoint (addr, contents_cache);
-#endif
+  delete_thread_silent (remote_sim_ptid);
 }
 
 /* Pass the command argument through to the simulator verbatim.  The
@@ -840,7 +848,7 @@ simulator_command (char *args, int from_tty)
          commands, is restricted to the period when the channel to the
          simulator is open. */
 
-      error ("Not connected to the simulator target");
+      error (_("Not connected to the simulator target"));
     }
 
   sim_do_command (gdbsim_desc, args);
@@ -850,6 +858,35 @@ simulator_command (char *args, int from_tty)
   registers_changed ();
 }
 
+/* Check to see if a thread is still alive.  */
+
+static int
+gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
+{
+  if (ptid_equal (ptid, remote_sim_ptid))
+    /* The simulators' task is always alive.  */
+    return 1;
+
+  return 0;
+}
+
+/* Convert a thread ID to a string.  Returns the string in a static
+   buffer.  */
+
+static char *
+gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
+{
+  static char buf[64];
+
+  if (ptid_equal (remote_sim_ptid, ptid))
+    {
+      xsnprintf (buf, sizeof buf, "Thread <main>");
+      return buf;
+    }
+
+  return normal_pid_to_str (ptid);
+}
+
 /* Define the target subroutine names */
 
 struct target_ops gdbsim_ops;
@@ -862,68 +899,30 @@ init_gdbsim_ops (void)
   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
   gdbsim_ops.to_open = gdbsim_open;
   gdbsim_ops.to_close = gdbsim_close;
-  gdbsim_ops.to_attach = NULL;
-  gdbsim_ops.to_post_attach = NULL;
-  gdbsim_ops.to_require_attach = NULL;
   gdbsim_ops.to_detach = gdbsim_detach;
-  gdbsim_ops.to_require_detach = NULL;
   gdbsim_ops.to_resume = gdbsim_resume;
   gdbsim_ops.to_wait = gdbsim_wait;
-  gdbsim_ops.to_post_wait = NULL;
   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
   gdbsim_ops.to_store_registers = gdbsim_store_register;
   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
-  gdbsim_ops.to_xfer_memory = gdbsim_xfer_inferior_memory;
+  gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
   gdbsim_ops.to_files_info = gdbsim_files_info;
-  gdbsim_ops.to_insert_breakpoint = gdbsim_insert_breakpoint;
-  gdbsim_ops.to_remove_breakpoint = gdbsim_remove_breakpoint;
-  gdbsim_ops.to_terminal_init = NULL;
-  gdbsim_ops.to_terminal_inferior = NULL;
-  gdbsim_ops.to_terminal_ours_for_output = NULL;
-  gdbsim_ops.to_terminal_ours = NULL;
-  gdbsim_ops.to_terminal_info = NULL;
+  gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
+  gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
   gdbsim_ops.to_kill = gdbsim_kill;
   gdbsim_ops.to_load = gdbsim_load;
-  gdbsim_ops.to_lookup_symbol = NULL;
   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
-  gdbsim_ops.to_post_startup_inferior = NULL;
-  gdbsim_ops.to_acknowledge_created_inferior = NULL;
-  gdbsim_ops.to_clone_and_follow_inferior = NULL;
-  gdbsim_ops.to_post_follow_inferior_by_clone = NULL;
-  gdbsim_ops.to_insert_fork_catchpoint = NULL;
-  gdbsim_ops.to_remove_fork_catchpoint = NULL;
-  gdbsim_ops.to_insert_vfork_catchpoint = NULL;
-  gdbsim_ops.to_remove_vfork_catchpoint = NULL;
-  gdbsim_ops.to_has_forked = NULL;
-  gdbsim_ops.to_has_vforked = NULL;
-  gdbsim_ops.to_can_follow_vfork_prior_to_exec = NULL;
-  gdbsim_ops.to_post_follow_vfork = NULL;
-  gdbsim_ops.to_insert_exec_catchpoint = NULL;
-  gdbsim_ops.to_remove_exec_catchpoint = NULL;
-  gdbsim_ops.to_has_execd = NULL;
-  gdbsim_ops.to_reported_exec_events_per_exec_call = NULL;
-  gdbsim_ops.to_has_exited = NULL;
   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
-  gdbsim_ops.to_can_run = 0;
-  gdbsim_ops.to_notice_signals = 0;
-  gdbsim_ops.to_thread_alive = 0;
   gdbsim_ops.to_stop = gdbsim_stop;
-  gdbsim_ops.to_pid_to_exec_file = NULL;
-  gdbsim_ops.to_core_file_to_sym_file = NULL;
+  gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
+  gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
   gdbsim_ops.to_stratum = process_stratum;
-  gdbsim_ops.DONT_USE = NULL;
-  gdbsim_ops.to_has_all_memory = 1;
-  gdbsim_ops.to_has_memory = 1;
-  gdbsim_ops.to_has_stack = 1;
-  gdbsim_ops.to_has_registers = 1;
-  gdbsim_ops.to_has_execution = 1;
-  gdbsim_ops.to_sections = NULL;
-  gdbsim_ops.to_sections_end = NULL;
+  gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
+  gdbsim_ops.to_has_memory = default_child_has_memory;
+  gdbsim_ops.to_has_stack = default_child_has_stack;
+  gdbsim_ops.to_has_registers = default_child_has_registers;
+  gdbsim_ops.to_has_execution = default_child_has_execution;
   gdbsim_ops.to_magic = OPS_MAGIC;
-
-#ifdef TARGET_REDEFINE_DEFAULT_OPS
-  TARGET_REDEFINE_DEFAULT_OPS (&gdbsim_ops);
-#endif
 }
 
 void
@@ -932,6 +931,10 @@ _initialize_remote_sim (void)
   init_gdbsim_ops ();
   add_target (&gdbsim_ops);
 
-  add_com ("sim <command>", class_obscure, simulator_command,
-	   "Send a command to the simulator.");
+  add_com ("sim", class_obscure, simulator_command,
+	   _("Send a command to the simulator."));
+
+  /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
+     isn't 0.  */
+  remote_sim_ptid = ptid_build (42000, 0, 42000);
 }