Allow resetting an empty inferior-tty

[deliverable/binutils-gdb.git] / gdb / remote-sim.c

diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c
index b3890b842693fb86730eb828d3eda570df94aa71..11d36eb6591db3476ff470033f0c4eb86c88c743 100644 (file)
--- a/gdb/remote-sim.c
+++ b/gdb/remote-sim.c
@@ -1,6 +1,6 @@
 /* Generic remote debugging interface for simulators.
 
 /* Generic remote debugging interface for simulators.
 

-   Copyright (C) 1993-2002, 2004-2012 Free Software Foundation, Inc.
+   Copyright (C) 1993-2016 Free Software Foundation, Inc.

 
    Contributed by Cygnus Support.
    Steve Chamberlain (sac@cygnus.com).
 
    Contributed by Cygnus Support.
    Steve Chamberlain (sac@cygnus.com).


@@ -21,14 +21,14 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"

+#include "gdb_bfd.h"

 #include "inferior.h"
 #include "inferior.h"

+#include "infrun.h"

 #include "value.h"
 #include "value.h"

-#include "gdb_string.h"

 #include <ctype.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <setjmp.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <setjmp.h>

-#include <errno.h>

 #include "terminal.h"
 #include "target.h"
 #include "gdbcore.h"
 #include "terminal.h"
 #include "target.h"
 #include "gdbcore.h"


@@ -36,7 +36,6 @@
 #include "gdb/remote-sim.h"
 #include "command.h"
 #include "regcache.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 "sim-regno.h"
 #include "arch-utils.h"
 #include "readline/readline.h"


@@ -46,8 +45,6 @@
 
 extern void _initialize_remote_sim (void);
 
 
 extern void _initialize_remote_sim (void);
 

-static void dump_mem (char *buf, int len);
-

 static void init_callbacks (void);
 
 static void end_callbacks (void);
 static void init_callbacks (void);
 
 static void end_callbacks (void);


@@ -74,21 +71,24 @@ static void gdb_os_error (host_callback *, const char *, ...)
 
 static void gdbsim_kill (struct target_ops *);
 
 
 static void gdbsim_kill (struct target_ops *);
 

-static void gdbsim_load (char *prog, int fromtty);
+static void gdbsim_load (struct target_ops *self, const char *prog,
+                        int fromtty);

 
 

-static void gdbsim_open (char *args, int from_tty);
+static void gdbsim_open (const char *args, int from_tty);

 
 

-static void gdbsim_close (int quitting);
+static void gdbsim_close (struct target_ops *self);

 
 

-static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
+static void gdbsim_detach (struct target_ops *ops, const char *args,
+                          int from_tty);

 
 

-static void gdbsim_prepare_to_store (struct regcache *regcache);
+static void gdbsim_prepare_to_store (struct target_ops *self,
+                                    struct regcache *regcache);

 
 static void gdbsim_files_info (struct target_ops *target);
 
 static void gdbsim_mourn_inferior (struct target_ops *target);
 
 
 static void gdbsim_files_info (struct target_ops *target);
 
 static void gdbsim_mourn_inferior (struct target_ops *target);
 

-static void gdbsim_stop (ptid_t ptid);
+static void gdbsim_interrupt (struct target_ops *self, ptid_t ptid);

 
 void simulator_command (char *args, int from_tty);
 
 
 void simulator_command (char *args, int from_tty);
 


@@ -152,9 +152,10 @@ static int
 check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
 {
   struct sim_inferior_data *sim_data;
 check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
 {
   struct sim_inferior_data *sim_data;

-  SIM_DESC new_sim_desc = arg;
+  SIM_DESC new_sim_desc = (SIM_DESC) arg;

 
 

-  sim_data = inferior_data (inf, sim_inferior_data_key);
+  sim_data = ((struct sim_inferior_data *)
+             inferior_data (inf, sim_inferior_data_key));

 
   return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
 }
 
   return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
 }


@@ -172,13 +173,13 @@ get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
 {
   SIM_DESC sim_desc = NULL;
   struct sim_inferior_data *sim_data
 {
   SIM_DESC sim_desc = NULL;
   struct sim_inferior_data *sim_data

-    = inferior_data (inf, sim_inferior_data_key);
+    = (struct sim_inferior_data *) inferior_data (inf, sim_inferior_data_key);

 
   /* Try to allocate a new sim instance, if needed.  We do this ahead of
      a potential allocation of a sim_inferior_data struct in order to
      avoid needlessly allocating that struct in the event that the sim
      instance allocation fails.  */
 
   /* Try to allocate a new sim instance, if needed.  We do this ahead of
      a potential allocation of a sim_inferior_data struct in order to
      avoid needlessly allocating that struct in the event that the sim
      instance allocation fails.  */

-  if (sim_instance_needed == SIM_INSTANCE_NEEDED 
+  if (sim_instance_needed == SIM_INSTANCE_NEEDED

       && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
     {
       struct inferior *idup;
       && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
     {
       struct inferior *idup;


@@ -188,7 +189,7 @@ get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
               inf->num);
 
       idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
               inf->num);
 
       idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,

-                                     sim_desc);
+                                    sim_desc);

       if (idup != NULL)
        {
          /* We don't close the descriptor due to the fact that it's
       if (idup != NULL)
        {
          /* We don't close the descriptor due to the fact that it's


@@ -201,13 +202,13 @@ get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
          error (
  _("Inferior %d and inferior %d would have identical simulator state.\n"
    "(This simulator does not support the running of more than one inferior.)"),
          error (
  _("Inferior %d and inferior %d would have identical simulator state.\n"
    "(This simulator does not support the running of more than one inferior.)"),

-                inf->num, idup->num); 
-        }
+                inf->num, idup->num);
+       }

     }
 
   if (sim_data == NULL)
     {
     }
 
   if (sim_data == NULL)
     {

-      sim_data = XZALLOC(struct sim_inferior_data);
+      sim_data = XCNEW(struct sim_inferior_data);

       set_inferior_data (inf, sim_inferior_data_key, sim_data);
 
       /* Allocate a ptid for this inferior.  */
       set_inferior_data (inf, sim_inferior_data_key, sim_data);
 
       /* Allocate a ptid for this inferior.  */


@@ -223,7 +224,7 @@ get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
   else if (sim_desc)
     {
       /* This handles the case where sim_data was allocated prior to
   else if (sim_desc)
     {
       /* This handles the case where sim_data was allocated prior to

-         needing a sim instance.  */
+        needing a sim instance.  */

       sim_data->gdbsim_desc = sim_desc;
     }
 
       sim_data->gdbsim_desc = sim_desc;
     }
 


@@ -243,7 +244,7 @@ get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
 
   if (pid <= 0)
     return NULL;
 
   if (pid <= 0)
     return NULL;

-  
+

   inf = find_inferior_pid (pid);
 
   if (inf)
   inf = find_inferior_pid (pid);
 
   if (inf)


@@ -257,7 +258,7 @@ get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
 static void
 sim_inferior_data_cleanup (struct inferior *inf, void *data)
 {
 static void
 sim_inferior_data_cleanup (struct inferior *inf, void *data)
 {

-  struct sim_inferior_data *sim_data = data;
+  struct sim_inferior_data *sim_data = (struct sim_inferior_data *) data;

 
   if (sim_data != NULL)
     {
 
   if (sim_data != NULL)
     {


@@ -271,30 +272,28 @@ sim_inferior_data_cleanup (struct inferior *inf, void *data)
 }
 
 static void
 }
 
 static void

-dump_mem (char *buf, int len)
+dump_mem (const gdb_byte *buf, int len)

 {
 {

-  if (len <= 8)
+  fputs_unfiltered ("\t", gdb_stdlog);
+
+  if (len == 8 || len == 4)

     {
     {

-      if (len == 8 || len == 4)
-       {
-         long l[2];
+      uint32_t l[2];

 
 

-         memcpy (l, buf, len);
-         printf_filtered ("\t0x%lx", l[0]);
-         if (len == 8)
-           printf_filtered (" 0x%lx", l[1]);
-         printf_filtered ("\n");
-       }
-      else
-       {
-         int i;
+      memcpy (l, buf, len);
+      fprintf_unfiltered (gdb_stdlog, "0x%08x", l[0]);
+      if (len == 8)
+       fprintf_unfiltered (gdb_stdlog, " 0x%08x", l[1]);
+    }
+  else
+    {
+      int i;

 
 

-         printf_filtered ("\t");
-         for (i = 0; i < len; i++)
-           printf_filtered ("0x%x ", buf[i]);
-         printf_filtered ("\n");
-       }
+      for (i = 0; i < len; i++)
+       fprintf_unfiltered (gdb_stdlog, "0x%02x ", buf[i]);

     }
     }

+
+  fputs_unfiltered ("\n", gdb_stdlog);

 }
 
 /* Initialize gdb_callback.  */
 }
 
 /* Initialize gdb_callback.  */


@@ -447,19 +446,19 @@ gdbsim_fetch_register (struct target_ops *ops,
     case SIM_REGNO_DOES_NOT_EXIST:
       {
        /* For moment treat a `does not exist' register the same way
     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];
+          as an ``unavailable'' register.  */
+       gdb_byte buf[MAX_REGISTER_SIZE];

        int nr_bytes;
 
        memset (buf, 0, MAX_REGISTER_SIZE);
        regcache_raw_supply (regcache, regno, buf);
        break;
       }
        int nr_bytes;
 
        memset (buf, 0, MAX_REGISTER_SIZE);
        regcache_raw_supply (regcache, regno, buf);
        break;
       }

-      
+

     default:
       {
        static int warn_user = 1;
     default:
       {
        static int warn_user = 1;

-       char buf[MAX_REGISTER_SIZE];
+       gdb_byte buf[MAX_REGISTER_SIZE];

        int nr_bytes;
 
        gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
        int nr_bytes;
 
        gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));


@@ -490,7 +489,8 @@ gdbsim_fetch_register (struct target_ops *ops,
        regcache_raw_supply (regcache, regno, buf);
        if (remote_debug)
          {
        regcache_raw_supply (regcache, regno, buf);
        if (remote_debug)
          {

-           printf_filtered ("gdbsim_fetch_register: %d", regno);
+           fprintf_unfiltered (gdb_stdlog,
+                               "gdbsim_fetch_register: %d", regno);

            /* FIXME: We could print something more intelligible.  */
            dump_mem (buf, register_size (gdbarch, regno));
          }
            /* FIXME: We could print something more intelligible.  */
            dump_mem (buf, register_size (gdbarch, regno));
          }


@@ -516,7 +516,7 @@ gdbsim_store_register (struct target_ops *ops,
     }
   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
     {
     }
   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
     {

-      char tmp[MAX_REGISTER_SIZE];
+      gdb_byte tmp[MAX_REGISTER_SIZE];

       int nr_bytes;
 
       regcache_cooked_read (regcache, regno, tmp);
       int nr_bytes;
 
       regcache_cooked_read (regcache, regno, tmp);


@@ -528,15 +528,15 @@ gdbsim_store_register (struct target_ops *ops,
        internal_error (__FILE__, __LINE__,
                        _("Register size different to expected"));
       if (nr_bytes < 0)
        internal_error (__FILE__, __LINE__,
                        _("Register size different to expected"));
       if (nr_bytes < 0)

-        internal_error (__FILE__, __LINE__,
-                       _("Register %d not updated"), regno);
+       internal_error (__FILE__, __LINE__,
+                       _("Register %d not updated"), regno);

       if (nr_bytes == 0)
       if (nr_bytes == 0)

-        warning (_("Register %s not updated"),
-                 gdbarch_register_name (gdbarch, regno));
+       warning (_("Register %s not updated"),
+                gdbarch_register_name (gdbarch, regno));

 
       if (remote_debug)
        {
 
       if (remote_debug)
        {

-         printf_filtered ("gdbsim_store_register: %d", regno);
+         fprintf_unfiltered (gdb_stdlog, "gdbsim_store_register: %d", regno);

          /* FIXME: We could print something more intelligible.  */
          dump_mem (tmp, register_size (gdbarch, regno));
        }
          /* FIXME: We could print something more intelligible.  */
          dump_mem (tmp, register_size (gdbarch, regno));
        }


@@ -550,7 +550,7 @@ static void
 gdbsim_kill (struct target_ops *ops)
 {
   if (remote_debug)
 gdbsim_kill (struct target_ops *ops)
 {
   if (remote_debug)

-    printf_filtered ("gdbsim_kill\n");
+    fprintf_unfiltered (gdb_stdlog, "gdbsim_kill\n");

 
   /* There is no need to `kill' running simulator - the simulator is
      not running.  Mourning it is enough.  */
 
   /* There is no need to `kill' running simulator - the simulator is
      not running.  Mourning it is enough.  */


@@ -562,10 +562,10 @@ gdbsim_kill (struct target_ops *ops)
    GDB's symbol tables to match.  */
 
 static void
    GDB's symbol tables to match.  */
 
 static void

-gdbsim_load (char *args, int fromtty)
+gdbsim_load (struct target_ops *self, const char *args, int fromtty)

 {
   char **argv;
 {
   char **argv;

-  char *prog;
+  const char *prog;

   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
 


@@ -581,7 +581,7 @@ gdbsim_load (char *args, int fromtty)
     error (_("GDB sim does not yet support a load offset."));
 
   if (remote_debug)
     error (_("GDB sim does not yet support a load offset."));
 
   if (remote_debug)

-    printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
+    fprintf_unfiltered (gdb_stdlog, "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
 
   /* FIXME: We will print two messages on error.
      Need error to either not print anything if passed NULL or need


@@ -619,9 +619,10 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
     warning (_("No program loaded."));
 
   if (remote_debug)
     warning (_("No program loaded."));
 
   if (remote_debug)

-    printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
-                    (exec_file ? exec_file : "(NULL)"),
-                    args);
+    fprintf_unfiltered (gdb_stdlog,
+                       "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
+                       (exec_file ? exec_file : "(NULL)"),
+                       args);

 
   if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
     gdbsim_kill (target);
 
   if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
     gdbsim_kill (target);


@@ -642,6 +643,9 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
   else
     argv = NULL;
 
   else
     argv = NULL;
 

+  if (!have_inferiors ())
+    init_thread_list ();
+

   if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
       != SIM_RC_OK)
     error (_("Unable to create sim inferior."));
   if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
       != SIM_RC_OK)
     error (_("Unable to create sim inferior."));


@@ -653,7 +657,7 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
   insert_breakpoints ();       /* Needed to get correct instruction
                                   in cache.  */
 
   insert_breakpoints ();       /* Needed to get correct instruction
                                   in cache.  */
 

-  clear_proceed_status ();
+  clear_proceed_status (0);

 }
 
 /* The open routine takes the rest of the parameters from the command,
 }
 
 /* The open routine takes the rest of the parameters from the command,


@@ -662,15 +666,21 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
 
 static void
 /* Called when selecting the simulator.  E.g. (gdb) target sim name.  */
 
 static void

-gdbsim_open (char *args, int from_tty)
+gdbsim_open (const char *args, int from_tty)

 {
   int len;
   char *arg_buf;
   struct sim_inferior_data *sim_data;
 {
   int len;
   char *arg_buf;
   struct sim_inferior_data *sim_data;

+  const char *sysroot;

   SIM_DESC gdbsim_desc;
 
   SIM_DESC gdbsim_desc;
 

+  sysroot = gdb_sysroot;
+  if (is_target_filename (sysroot))
+    sysroot += strlen (TARGET_SYSROOT_PREFIX);
+

   if (remote_debug)
   if (remote_debug)

-    printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
+    fprintf_unfiltered (gdb_stdlog,
+                       "gdbsim_open: args \"%s\"\n", args ? args : "(null)");

 
   /* Ensure that the sim target is not on the target stack.  This is
      necessary, because if it is on the target stack, the call to
 
   /* Ensure that the sim target is not on the target stack.  This is
      necessary, because if it is on the target stack, the call to


@@ -685,7 +695,7 @@ gdbsim_open (char *args, int from_tty)
   len = (7 + 1                 /* gdbsim */
         + strlen (" -E little")
         + strlen (" --architecture=xxxxxxxxxx")
   len = (7 + 1                 /* gdbsim */
         + strlen (" -E little")
         + strlen (" --architecture=xxxxxxxxxx")

-        + strlen (" --sysroot=") + strlen (gdb_sysroot) +
+        + strlen (" --sysroot=") + strlen (sysroot) +

         + (args ? strlen (args) : 0)
         + 50) /* slack */ ;
   arg_buf = (char *) alloca (len);
         + (args ? strlen (args) : 0)
         + 50) /* slack */ ;
   arg_buf = (char *) alloca (len);


@@ -712,7 +722,7 @@ gdbsim_open (char *args, int from_tty)
     }
   /* Pass along gdb's concept of the sysroot.  */
   strcat (arg_buf, " --sysroot=");
     }
   /* Pass along gdb's concept of the sysroot.  */
   strcat (arg_buf, " --sysroot=");

-  strcat (arg_buf, gdb_sysroot);
+  strcat (arg_buf, sysroot);

   /* finally, any explicit args */
   if (args)
     {
   /* finally, any explicit args */
   if (args)
     {


@@ -757,8 +767,8 @@ gdbsim_open (char *args, int from_tty)
 static int
 gdbsim_close_inferior (struct inferior *inf, void *arg)
 {
 static int
 gdbsim_close_inferior (struct inferior *inf, void *arg)
 {

-  struct sim_inferior_data *sim_data = inferior_data (inf,
-                                                      sim_inferior_data_key);
+  struct sim_inferior_data *sim_data
+    = (struct sim_inferior_data *) inferior_data (inf, sim_inferior_data_key);

   if (sim_data != NULL)
     {
       ptid_t ptid = sim_data->remote_sim_ptid;
   if (sim_data != NULL)
     {
       ptid_t ptid = sim_data->remote_sim_ptid;


@@ -771,7 +781,7 @@ gdbsim_close_inferior (struct inferior *inf, void *arg)
         Thus we need to verify the existence of an inferior using the
         pid in question before setting inferior_ptid via
         switch_to_thread() or mourning the inferior.  */
         Thus we need to verify the existence of an inferior using the
         pid in question before setting inferior_ptid via
         switch_to_thread() or mourning the inferior.  */

-      if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
+      if (find_inferior_ptid (ptid) != NULL)

        {
          switch_to_thread (ptid);
          generic_mourn_inferior ();
        {
          switch_to_thread (ptid);
          generic_mourn_inferior ();


@@ -781,23 +791,16 @@ gdbsim_close_inferior (struct inferior *inf, void *arg)
   return 0;
 }
 
   return 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
-   should not get hung in case of errors, or whether we want a clean
-   termination even if it takes a while.  This routine is automatically
-   always called just before a routine is popped off the target stack.
-   Closing file descriptors and freeing memory are typical things it should
-   do.  */

 /* Close out all files and local state before this target loses control.  */
 
 static void
 /* Close out all files and local state before this target loses control.  */
 
 static void

-gdbsim_close (int quitting)
+gdbsim_close (struct target_ops *self)

 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 
   if (remote_debug)
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 
   if (remote_debug)

-    printf_filtered ("gdbsim_close: quitting %d\n", quitting);
+    fprintf_unfiltered (gdb_stdlog, "gdbsim_close\n");

 
   iterate_over_inferiors (gdbsim_close_inferior, NULL);
 
 
   iterate_over_inferiors (gdbsim_close_inferior, NULL);
 


@@ -822,12 +825,12 @@ gdbsim_close (int quitting)
    Use this when you want to detach and do something else with your gdb.  */
 
 static void
    Use this when you want to detach and do something else with your gdb.  */
 
 static void

-gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
+gdbsim_detach (struct target_ops *ops, const char *args, int from_tty)

 {
   if (remote_debug)
 {
   if (remote_debug)

-    printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
+    fprintf_unfiltered (gdb_stdlog, "gdbsim_detach: args \"%s\"\n", args);

 
 

-  pop_target ();               /* calls gdbsim_close to do the real work */
+  unpush_target (ops);         /* calls gdbsim_close to do the real work */

   if (from_tty)
     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 }
   if (from_tty)
     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 }


@@ -847,7 +850,7 @@ gdbsim_resume_inferior (struct inferior *inf, void *arg)
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);

-  struct resume_data *rd = arg;
+  struct resume_data *rd = (struct resume_data *) arg;

 
   if (sim_data)
     {
 
   if (sim_data)
     {


@@ -855,8 +858,9 @@ gdbsim_resume_inferior (struct inferior *inf, void *arg)
       sim_data->resume_step = rd->step;
 
       if (remote_debug)
       sim_data->resume_step = rd->step;
 
       if (remote_debug)

-       printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
-                        inf->pid, rd->step, rd->siggnal);
+       fprintf_unfiltered (gdb_stdlog,
+                           _("gdbsim_resume: pid %d, step %d, signal %d\n"),
+                           inf->pid, rd->step, rd->siggnal);

     }
 
   /* When called from iterate_over_inferiors, a zero return causes the
     }
 
   /* When called from iterate_over_inferiors, a zero return causes the


@@ -884,24 +888,24 @@ gdbsim_resume (struct target_ops *ops,
      either have multiple inferiors to resume or an error condition.  */
 
   if (sim_data)
      either have multiple inferiors to resume or an error condition.  */
 
   if (sim_data)

-    gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
+    gdbsim_resume_inferior (find_inferior_ptid (ptid), &rd);

   else if (ptid_equal (ptid, minus_one_ptid))
     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
   else
     error (_("The program is not being run."));
 }
 
   else if (ptid_equal (ptid, minus_one_ptid))
     iterate_over_inferiors (gdbsim_resume_inferior, &rd);
   else
     error (_("The program is not being run."));
 }
 

-/* Notify the simulator of an asynchronous request to stop.
+/* Notify the simulator of an asynchronous request to interrupt.

 
 

-   The simulator shall ensure that the stop request is eventually
+   The simulator shall ensure that the interrupt request is eventually

    delivered to the simulator.  If the call is made while the
    delivered to the simulator.  If the call is made while the

-   simulator is not running then the stop request is processed when
+   simulator is not running then the interrupt request is processed when

    the simulator is next resumed.
 
    For simulators that do not support this operation, just abort.  */
 
 static int
    the simulator is next resumed.
 
    For simulators that do not support this operation, just abort.  */
 
 static int

-gdbsim_stop_inferior (struct inferior *inf, void *arg)
+gdbsim_interrupt_inferior (struct inferior *inf, void *arg)

 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);


@@ -921,23 +925,23 @@ gdbsim_stop_inferior (struct inferior *inf, void *arg)
 }
 
 static void
 }
 
 static void

-gdbsim_stop (ptid_t ptid)
+gdbsim_interrupt (struct target_ops *self, ptid_t ptid)

 {
   struct sim_inferior_data *sim_data;
 
   if (ptid_equal (ptid, minus_one_ptid))
     {
 {
   struct sim_inferior_data *sim_data;
 
   if (ptid_equal (ptid, minus_one_ptid))
     {

-      iterate_over_inferiors (gdbsim_stop_inferior, NULL);
+      iterate_over_inferiors (gdbsim_interrupt_inferior, NULL);

     }
   else
     {
     }
   else
     {

-      struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
+      struct inferior *inf = find_inferior_ptid (ptid);

 
       if (inf == NULL)
        error (_("Can't stop pid %d.  No inferior found."),
               ptid_get_pid (ptid));
 
 
       if (inf == NULL)
        error (_("Can't stop pid %d.  No inferior found."),
               ptid_get_pid (ptid));
 

-      gdbsim_stop_inferior (inf, NULL);
+      gdbsim_interrupt_inferior (inf, NULL);

     }
 }
 
     }
 }
 


@@ -950,11 +954,8 @@ gdb_os_poll_quit (host_callback *p)
   if (deprecated_ui_loop_hook != NULL)
     deprecated_ui_loop_hook (0);
 
   if (deprecated_ui_loop_hook != NULL)
     deprecated_ui_loop_hook (0);
 

-  if (quit_flag)               /* gdb's idea of quit */
-    {
-      quit_flag = 0;           /* we've stolen it */
-      return 1;
-    }
+  if (check_quit_flag ())      /* gdb's idea of quit */
+    return 1;

   return 0;
 }
 
   return 0;
 }
 


@@ -965,7 +966,7 @@ gdb_os_poll_quit (host_callback *p)
 static void
 gdbsim_cntrl_c (int signo)
 {
 static void
 gdbsim_cntrl_c (int signo)
 {

-  gdbsim_stop (minus_one_ptid);
+  gdbsim_interrupt (NULL, minus_one_ptid);

 }
 
 static ptid_t
 }
 
 static ptid_t


@@ -973,7 +974,7 @@ gdbsim_wait (struct target_ops *ops,
             ptid_t ptid, struct target_waitstatus *status, int options)
 {
   struct sim_inferior_data *sim_data;
             ptid_t ptid, struct target_waitstatus *status, int options)
 {
   struct sim_inferior_data *sim_data;

-  static RETSIGTYPE (*prev_sigint) ();
+  static sighandler_t prev_sigint;

   int sigrc = 0;
   enum sim_stop reason = sim_running;
 
   int sigrc = 0;
   enum sim_stop reason = sim_running;
 


@@ -993,7 +994,7 @@ gdbsim_wait (struct target_ops *ops,
     }
 
   if (remote_debug)
     }
 
   if (remote_debug)

-    printf_filtered ("gdbsim_wait\n");
+    fprintf_unfiltered (gdb_stdlog, "gdbsim_wait\n");

 
 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
   {
 
 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
   {


@@ -1008,7 +1009,7 @@ gdbsim_wait (struct target_ops *ops,
   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 #endif
   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
 #endif
   sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,

-              sim_data->resume_siggnal);
+             sim_data->resume_siggnal);

 
   signal (SIGINT, prev_sigint);
   sim_data->resume_step = 0;
 
   signal (SIGINT, prev_sigint);
   sim_data->resume_step = 0;


@@ -1031,13 +1032,13 @@ gdbsim_wait (struct target_ops *ops,
        case GDB_SIGNAL_TRAP:
        default:
          status->kind = TARGET_WAITKIND_STOPPED;
        case GDB_SIGNAL_TRAP:
        default:
          status->kind = TARGET_WAITKIND_STOPPED;

-         status->value.sig = sigrc;
+         status->value.sig = (enum gdb_signal) sigrc;

          break;
        }
       break;
     case sim_signalled:
       status->kind = TARGET_WAITKIND_SIGNALLED;
          break;
        }
       break;
     case sim_signalled:
       status->kind = TARGET_WAITKIND_SIGNALLED;

-      status->value.sig = sigrc;
+      status->value.sig = (enum gdb_signal) sigrc;

       break;
     case sim_running:
     case sim_polling:
       break;
     case sim_running:
     case sim_polling:


@@ -1055,30 +1056,28 @@ gdbsim_wait (struct target_ops *ops,
    debugged.  */
 
 static void
    debugged.  */
 
 static void

-gdbsim_prepare_to_store (struct regcache *regcache)
+gdbsim_prepare_to_store (struct target_ops *self, struct regcache *regcache)

 {
   /* Do nothing, since we can store individual regs.  */
 }
 
 {
   /* 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.  */
+/* Helper for gdbsim_xfer_partial that handles memory transfers.
+   Arguments are like target_xfer_partial.  */

 
 

-static int
-gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
-                            int write, struct mem_attrib *attrib,
-                            struct target_ops *target)
+static enum target_xfer_status
+gdbsim_xfer_memory (struct target_ops *target,
+                   gdb_byte *readbuf, const gdb_byte *writebuf,
+                   ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)

 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);

+  int l;

 
   /* If this target doesn't have memory yet, return 0 causing the
      request to be passed to a lower target, hopefully an exec
      file.  */
   if (!target->to_has_memory (target))
 
   /* If this target doesn't have memory yet, return 0 causing the
      request to be passed to a lower target, hopefully an exec
      file.  */
   if (!target->to_has_memory (target))

-    return 0;
+    return TARGET_XFER_EOF;

 
   if (!sim_data->program_loaded)
     error (_("No program loaded."));
 
   if (!sim_data->program_loaded)
     error (_("No program loaded."));


@@ -1092,27 +1091,54 @@ gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
   gdb_assert (sim_data->gdbsim_desc != NULL);
 
   if (remote_debug)
   gdb_assert (sim_data->gdbsim_desc != NULL);
 
   if (remote_debug)

+    fprintf_unfiltered (gdb_stdlog,
+                       "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
+                       "memaddr %s, len %s\n",
+                       host_address_to_string (readbuf),
+                       host_address_to_string (writebuf),
+                       paddress (target_gdbarch (), memaddr),
+                       pulongest (len));
+
+  if (writebuf)

     {
     {

-      /* 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 %s, len %d, write %d\n",
-                      paddress (target_gdbarch, memaddr), len, write);
-      if (remote_debug && write)
-       dump_mem (myaddr, len);
+      if (remote_debug && len > 0)
+       dump_mem (writebuf, len);
+      l = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);

     }
     }

-
-  if (write)
+  else
+    {
+      l = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
+      if (remote_debug && len > 0)
+       dump_mem (readbuf, len);
+    }
+  if (l > 0)

     {
     {

-      len = sim_write (sim_data->gdbsim_desc, memaddr, myaddr, len);
+      *xfered_len = (ULONGEST) l;
+      return TARGET_XFER_OK;

     }
     }

+  else if (l == 0)
+    return TARGET_XFER_EOF;

   else
   else

+    return TARGET_XFER_E_IO;
+}
+
+/* Target to_xfer_partial implementation.  */
+
+static enum target_xfer_status
+gdbsim_xfer_partial (struct target_ops *ops, enum target_object object,
+                    const char *annex, gdb_byte *readbuf,
+                    const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
+                    ULONGEST *xfered_len)
+{
+  switch (object)

     {
     {

-      len = sim_read (sim_data->gdbsim_desc, memaddr, myaddr, len);
-      if (remote_debug && len > 0)
-       dump_mem (myaddr, len);
+    case TARGET_OBJECT_MEMORY:
+      return gdbsim_xfer_memory (ops, readbuf, writebuf, offset, len,
+                                xfered_len);
+
+    default:
+      return TARGET_XFER_E_IO;

     }
     }

-  return len;

 }
 
 static void
 }
 
 static void


@@ -1126,12 +1152,12 @@ gdbsim_files_info (struct target_ops *target)
     file = bfd_get_filename (exec_bfd);
 
   if (remote_debug)
     file = bfd_get_filename (exec_bfd);
 
   if (remote_debug)

-    printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
+    fprintf_unfiltered (gdb_stdlog, "gdbsim_files_info: file \"%s\"\n", file);

 
   if (exec_bfd)
     {
 
   if (exec_bfd)
     {

-      printf_filtered ("\tAttached to %s running program %s\n",
-                      target_shortname, file);
+      fprintf_unfiltered (gdb_stdlog, "\tAttached to %s running program %s\n",
+                         target_shortname, file);

       sim_info (sim_data->gdbsim_desc, 0);
     }
 }
       sim_info (sim_data->gdbsim_desc, 0);
     }
 }


@@ -1145,7 +1171,7 @@ gdbsim_mourn_inferior (struct target_ops *target)
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 
   if (remote_debug)
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 
   if (remote_debug)

-    printf_filtered ("gdbsim_mourn_inferior:\n");
+    fprintf_unfiltered (gdb_stdlog, "gdbsim_mourn_inferior:\n");

 
   remove_breakpoints ();
   generic_mourn_inferior ();
 
   remove_breakpoints ();
   generic_mourn_inferior ();


@@ -1170,19 +1196,20 @@ simulator_command (char *args, int from_tty)
      thus allocating memory that would not be garbage collected until
      the ultimate destruction of the associated inferior.  */
 
      thus allocating memory that would not be garbage collected until
      the ultimate destruction of the associated inferior.  */
 

-  sim_data  = inferior_data (current_inferior (), sim_inferior_data_key);
+  sim_data  = ((struct sim_inferior_data *)
+              inferior_data (current_inferior (), sim_inferior_data_key));

   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
     {
 
       /* PREVIOUSLY: The user may give a command before the simulator
   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
     {
 
       /* PREVIOUSLY: The user may give a command before the simulator

-         is opened. [...] (??? assuming of course one wishes to
-         continue to allow commands to be sent to unopened simulators,
-         which isn't entirely unreasonable).  */
+        is opened. [...] (??? assuming of course one wishes to
+        continue to allow commands to be sent to unopened simulators,
+        which isn't entirely unreasonable).  */

 
       /* The simulator is a builtin abstraction of a remote target.
 
       /* The simulator is a builtin abstraction of a remote target.

-         Consistent with that model, access to the simulator, via sim
-         commands, is restricted to the period when the channel to the
-         simulator is open.  */
+        Consistent with that model, access to the simulator, via sim
+        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"));
     }


@@ -1195,14 +1222,16 @@ simulator_command (char *args, int from_tty)
 }
 
 static VEC (char_ptr) *
 }
 
 static VEC (char_ptr) *

-sim_command_completer (struct cmd_list_element *ignore, char *text, char *word)
+sim_command_completer (struct cmd_list_element *ignore, const char *text,
+                      const char *word)

 {
   struct sim_inferior_data *sim_data;
   char **tmp;
   int i;
   VEC (char_ptr) *result = NULL;
 
 {
   struct sim_inferior_data *sim_data;
   char **tmp;
   int i;
   VEC (char_ptr) *result = NULL;
 

-  sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
+  sim_data = ((struct sim_inferior_data *)
+             inferior_data (current_inferior (), sim_inferior_data_key));

   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
     return NULL;
 
   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
     return NULL;
 


@@ -1289,7 +1318,7 @@ init_gdbsim_ops (void)
   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_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.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
+  gdbsim_ops.to_xfer_partial = gdbsim_xfer_partial;

   gdbsim_ops.to_files_info = gdbsim_files_info;
   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
   gdbsim_ops.to_files_info = gdbsim_files_info;
   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;


@@ -1297,7 +1326,7 @@ init_gdbsim_ops (void)
   gdbsim_ops.to_load = gdbsim_load;
   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
   gdbsim_ops.to_load = gdbsim_load;
   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;

-  gdbsim_ops.to_stop = gdbsim_stop;
+  gdbsim_ops.to_interrupt = gdbsim_interrupt;

   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.to_thread_alive = gdbsim_thread_alive;
   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
   gdbsim_ops.to_stratum = process_stratum;


@@ -1322,5 +1351,5 @@ _initialize_remote_sim (void)
   set_cmd_completer (c, sim_command_completer);
 
   sim_inferior_data_key
   set_cmd_completer (c, sim_command_completer);
 
   sim_inferior_data_key

-    = register_inferior_data_with_cleanup (sim_inferior_data_cleanup);
+    = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);

 }
 }