Restore function naming scheme (sim_xxx vs simif_xxx).

Make more generic (remove any reference to sparc64).
Document simif_xxx fns.

1 files changed, 177 insertions, 126 deletions

diff --git a/gdb/remote-sp64sim.c b/gdb/remote-sp64sim.c
index 2c15272..7c222d7 100644
--- a/gdb/remote-sp64sim.c
+++ b/gdb/remote-sp64sim.c
@@ -1,5 +1,5 @@
-/* Remote debugging interface for SPARC64 Simulator.
-   Copyright 1992 Free Software Foundation, Inc.
+/* Generic remote debugging interface for simulators.
+   Copyright 1993 Free Software Foundation, Inc.
    Contributed by Cygnus Support.  Hacked from Steve Chamberlain's Z8000 work
    by Doug Evans. (dje@cygnus.com).
 
@@ -32,125 +32,177 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "terminal.h"
 #include "target.h"
 #include "gdbcore.h"
-#include "sp64sim.h"
+#include "simif.h"
 
 /* Naming conventions:
 
-   simif_xxx are internal objects that describe top level interfaces to the
-   simulator (simif for SIMulator InterFace).
+   sim_xxx are internal objects that describe top level interfaces to the
+   simulator.
 
-   sim_xxx are external counterparts to the simif_xxx objects that must be
-   provided by the simulator.  */
+   simif_xxx are external counterparts to the sim_xxx objects that must be
+   provided by the simulator (simif for SIMulator InterFace, duh...).
+
+   A complete list of them is:
+
+   --- Fetch one register and store the raw value in BUF.
+
+int simif_fetch_register (int regno, char *buf);
+
+   --- Store VAL in one register.
+
+int simif_store_register (int regno, char *val);
+
+   --- Complete terminate the simulator.  This includes freeing all memory,
+   closing all open files, and releasing all mmap'd memory.
+
+int simif_kill (void);
+
+   --- Load program PROG into the simulator.
+
+int simif_load (bfd *abfd, char *prog);
+
+   --- Set the arguments and environment for the program loaded into the
+   simulator.  ARGV and ENV are NULL terminated lists of pointers.
+
+int simif_set_args (char **argv, char **env);
+
+   --- Initialize the simulator.  This function is called when the simulator
+   is selected from the command line. ARGS is passed from the command line
+   and can be used to select whatever run time options the simulator provides.
+   ARGS is the raw character string and must be parsed by the simulator.
+
+int simif_open (char *args);
+
+   --- Start running the program, or resume it after a breakpoint.
+   FIXME: What are A and B?
+
+int simif_resume (int a, int b);
+
+   --- Fetch the reason why the program stopped running (breakpoint, signal,
+   etc.)
+
+WAITTYPE simif_stop_signal (void);
+
+   --- Write some data into the program's memory.
+   Result is 0 for success, nonzero for failure.
+
+int simif_write (CORE_ADDR memaddr, char *myaddr, int len);
+
+   --- Read some data from the program's memory.
+   Result is 0 for success, nonzero for failure.
+
+int simif_read (CORE_ADDR memaddr, char *myaddr, int len);
+*/
 
 /* Forward data declarations */
-extern struct target_ops simif_ops;
+extern struct target_ops sim_ops;
 
-int simif_verbose = 0;	/* available to the simulator to use */
+int sim_verbose = 0;	/* available to the simulator to use */
 
 static int program_loaded = 0;
 
 static void dump_mem ();
 
 static void
-simif_fetch_register (regno)
+sim_fetch_register (regno)
 int regno;
 {
   if (regno == -1) 
     {
-      if (simif_verbose)
-	printf_filtered ("simif_fetch_register: %d\n", regno);
+      if (sim_verbose)
+	printf_filtered ("sim_fetch_register: %d\n", regno);
+      /* FIXME: Where did the 16 come from and what does it need to be? */
       for (regno = 0; regno < 16; regno++)
-	simif_fetch_register (regno);
+	sim_fetch_register (regno);
     }
   else
     {
       char buf[MAX_REGISTER_RAW_SIZE];
 
-      sim_fetch_register (regno, buf);
+      simif_fetch_register (regno, buf);
       supply_register (regno, buf);
-      if (simif_verbose)
+      if (sim_verbose)
 	{
-	  printf_filtered ("simif_fetch_register: %d", regno);
+	  printf_filtered ("sim_fetch_register: %d", regno);
 	  dump_mem (buf, sizeof (REGISTER_TYPE));
 	}
     }
 }
 
 static void
-simif_store_register (regno)
+sim_store_register (regno)
 int regno;
 {
   if (regno  == -1) 
     {
-      if (simif_verbose)
-	printf_filtered ("simif_store_register: %d\n", regno);
+      if (sim_verbose)
+	printf_filtered ("sim_store_register: %d\n", regno);
+      /* FIXME: 16? */
       for (regno = 0; regno < 16; regno++)
-	simif_store_register (regno);
+	sim_store_register (regno);
     }
-  else 
+  else
     {
       char value[sizeof (REGISTER_TYPE)];
 
       read_register_gen (regno, value);
       SWAP_TARGET_AND_HOST (value, sizeof (REGISTER_TYPE));
-      sim_store_register (regno, value);
-      if (simif_verbose)
+      simif_store_register (regno, value);
+      if (sim_verbose)
 	{
-	  printf_filtered ("simif_store_register: %d", regno);
+	  printf_filtered ("sim_store_register: %d", regno);
 	  dump_mem (value, sizeof (REGISTER_TYPE));
 	}
     }
 }
 
 static void
-simif_kill (arg,from_tty)
+sim_kill (arg,from_tty)
 char	*arg;
 int	from_tty;
 {
-  if (simif_verbose)
-    printf_filtered ("simif_kill: arg \"%s\"\n", arg);
+  if (sim_verbose)
+    printf_filtered ("sim_kill: arg \"%s\"\n", arg);
 
-  sim_kill ();	/* close fd's, remove mappings */
+  simif_kill ();	/* close fd's, remove mappings */
   inferior_pid = 0;
 }
 
-/* Download a file specified in 'args', to the sim. */
+/* Load program PROG into the sim. */
 
 static void
-simif_load (args, fromtty)
-     char *args;
+sim_load (prog, fromtty)
+     char *prog;
      int fromtty;
 {
   bfd	*abfd;
 
-  if (simif_verbose)
-    printf_filtered ("simif_load: args \"%s\"\n", args);
+  if (sim_verbose)
+    printf_filtered ("sim_load: prog \"%s\"\n", prog);
 
   inferior_pid = 0;  
   program_loaded = 0;
-  /* FIXME: a.out should be a config parm and/or an arg.  */
-  abfd = bfd_openr (args,"a.out-sunos-big");
+  abfd = bfd_openr (prog, (char *) 0);
 
   if (!abfd) 
-    error ("Unable to open file %s.", args);
+    error ("Unable to open file %s.", prog);
 
   if (bfd_check_format (abfd, bfd_object) ==0) 
     error ("File is not an object file.");
 
-  if (sim_load (abfd, args) != 0)
+  if (simif_load (abfd, prog) != 0)
     return;
 
   program_loaded = 1;
 
-  /* It is sim_load()'s job to set this.  */
-  /*sim_set_pc (abfd->start_address); - can't do 'cus we use RMTVaddr */
+  simif_set_pc (abfd->start_address);
 }
 
 /* This is called not only when we first attach, but also when the
    user types "run" after having attached.  */
 
 static void
-simif_create_inferior (exec_file, args, env)
+sim_create_inferior (exec_file, args, env)
      char *exec_file;
      char *args;
      char **env;
@@ -161,8 +213,8 @@ simif_create_inferior (exec_file, args, env)
   if (! program_loaded)
     error ("No program loaded.");
 
-  if (simif_verbose)
-    printf_filtered ("simif_create_inferior: exec_file \"%s\", args \"%s\"\n",
+  if (sim_verbose)
+    printf_filtered ("sim_create_inferior: exec_file \"%s\", args \"%s\"\n",
       exec_file, args);
 
   if (exec_file == 0 || exec_bfd == 0)
@@ -170,7 +222,7 @@ simif_create_inferior (exec_file, args, env)
 
   entry_pt = (int) bfd_get_start_address (exec_bfd);
 
-  simif_kill (NULL, NULL);	 
+  sim_kill (NULL, NULL);	 
   remove_breakpoints ();
   init_wait_for_inferior ();
 
@@ -182,31 +234,30 @@ simif_create_inferior (exec_file, args, env)
   strcat (arg_buf, args);
   argv = buildargv (arg_buf);
   make_cleanup (freeargv, (char *) argv);
-  sim_set_args (argv, env);
+  simif_set_args (argv, env);
 
   inferior_pid = 42;
   insert_breakpoints ();	/* Needed to get correct instruction in cache */
   proceed (entry_pt, -1, 0);
 }
 
-/* Called when selecting the simulator. EG: (gdb) target sim name.
-   NAME unused at present. */
+/* Called when selecting the simulator. EG: (gdb) target sim name.  */
 
 static void
-simif_open (name, from_tty)
-     char *name;
+sim_open (args, from_tty)
+     char *args;
      int from_tty;
 {
-  if (simif_verbose)
-    printf_filtered ("simif_open: name \"%s\"\n", name);
+  if (sim_verbose)
+    printf_filtered ("sim_open: args \"%s\"\n", args);
 
-  if (sim_init (name) != 0)
+  if (simif_open (args) != 0)
     {
       error ("Unable to initialize simulator (insufficient memory?).");
       return;
     }
 
-  push_target (&simif_ops);
+  push_target (&sim_ops);
   target_fetch_registers (-1);
 
   printf_filtered ("Connected to the simulator.\n");
@@ -215,15 +266,15 @@ simif_open (name, from_tty)
 /* Close out all files and local state before this target loses control. */
 
 static void
-simif_close (quitting)
+sim_close (quitting)
      int quitting;
 {
-  if (simif_verbose)
-    printf_filtered ("simif_close: quitting %d\n", quitting);
+  if (sim_verbose)
+    printf_filtered ("sim_close: quitting %d\n", quitting);
 
   program_loaded = 0;
 
-  /* FIXME: Need to call sim_close() to close all files and
+  /* FIXME: Need to call simif_close() to close all files and
      delete all mappings. */
 }
 
@@ -232,14 +283,14 @@ simif_close (quitting)
    with your gdb.  */
 
 static void
-simif_detach (args,from_tty)
+sim_detach (args,from_tty)
      char *args;
      int from_tty;
 {
-  if (simif_verbose)
-    printf_filtered ("simif_detach: args \"%s\"\n", args);
+  if (sim_verbose)
+    printf_filtered ("sim_detach: args \"%s\"\n", args);
 
-  pop_target ();		/* calls simif_close to do the real work */
+  pop_target ();		/* calls sim_close to do the real work */
   if (from_tty)
     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 }
@@ -248,29 +299,29 @@ simif_detach (args,from_tty)
 /* FIXME: What are A and B?  */
 
 static void
-simif_resume (a,b)
+sim_resume (a,b)
 {
-  if (simif_verbose)
-    printf_filtered ("simif_resume: %d/%d\n", a, b);
+  if (sim_verbose)
+    printf_filtered ("sim_resume: %d/%d\n", a, b);
 
-  sim_resume (a, b);
+  simif_resume (a, b);
 }
 
 /* Wait until the remote machine stops, then return,
    storing status in STATUS just as `wait' would.  */
 
 static int
-simif_wait (status)
+sim_wait (status)
      WAITTYPE *status;
 {
-  if (simif_verbose)
-    printf_filtered ("simif_wait: ");
+  if (sim_verbose)
+    printf_filtered ("sim_wait: ");
 #if 1
-  *status = sim_stop_signal ();
+  *status = simif_stop_signal ();
 #else
-  WSETSTOP (*status, sim_stop_signal ());
+  WSETSTOP (*status, simif_stop_signal ());
 #endif
-  if (simif_verbose)
+  if (sim_verbose)
     printf_filtered ("status %d\n", *status);
   return 0;
 }
@@ -282,53 +333,53 @@ simif_wait (status)
    debugged.  */
 
 static void
-simif_prepare_to_store ()
+sim_prepare_to_store ()
 {
   /* Do nothing, since we can store individual regs */
 }
 
 static int
-simif_xfer_inferior_memory (memaddr, myaddr, len, write, target)
+sim_xfer_inferior_memory (memaddr, myaddr, len, write, target)
      CORE_ADDR memaddr;
      char *myaddr;
      int len;
      int write;
      struct target_ops *target;			/* ignored */
 {
-  if (simif_verbose)
-  {
-    printf_filtered ("simif_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
-      myaddr, memaddr, len, write);
-    if (simif_verbose && write)
-      dump_mem(myaddr, len);
-  }
+  if (sim_verbose)
+    {
+      printf_filtered ("sim_xfer_inferior_memory: myaddr 0x%x, memaddr 0x%x, len %d, write %d\n",
+		       myaddr, memaddr, len, write);
+      if (sim_verbose && write)
+	dump_mem(myaddr, len);
+    }
 
   if (! program_loaded)
     error ("No program loaded.");
 
   if (write)
-  {
-    len = sim_write (memaddr, myaddr, len);
-  }
+    {
+      len = simif_write (memaddr, myaddr, len);
+    }
   else 
-  {
-    len = sim_read (memaddr, myaddr, len);
-    if (simif_verbose && len  > 0)
-      dump_mem(myaddr, len);
-  } 
+    {
+      len = simif_read (memaddr, myaddr, len);
+      if (sim_verbose && len  > 0)
+	dump_mem(myaddr, len);
+    } 
   return len;
 }
 
 static void
-simif_files_info ()
+sim_files_info ()
 {
   char *file = "nothing";
 
   if (exec_bfd)
     file = bfd_get_filename (exec_bfd);
 
-  if (simif_verbose)
-    printf_filtered ("simif_files_info: file \"%s\"\n", file);
+  if (sim_verbose)
+    printf_filtered ("sim_files_info: file \"%s\"\n", file);
 
   if (exec_bfd)
     printf_filtered ("\tAttached to %s running program %s\n",
@@ -337,10 +388,10 @@ simif_files_info ()
 
 /* Clear the sims notion of what the break points are */
 static void
-simif_mourn () 
+sim_mourn () 
 { 
-  if (simif_verbose)
-    printf_filtered ("simif_mourn:\n");
+  if (sim_verbose)
+    printf_filtered ("sim_mourn:\n");
 
   remove_breakpoints ();
   generic_mourn_inferior ();
@@ -348,23 +399,23 @@ simif_mourn ()
 
 /* Define the target subroutine names */
 
-struct target_ops simif_ops = 
+struct target_ops sim_ops = 
 {
-  "sim", "SPARC64 Simulator",
-  "Use the SPARC64 Simulator",
-  simif_open, simif_close, 
-  0, simif_detach, simif_resume, simif_wait, /* attach */
-  simif_fetch_register, simif_store_register,
-  simif_prepare_to_store,
-  simif_xfer_inferior_memory, 
-  simif_files_info,
+  "sim", "Simulator",
+  "Use the Simulator",
+  sim_open, sim_close, 
+  0, sim_detach, sim_resume, sim_wait, /* attach */
+  sim_fetch_register, sim_store_register,
+  sim_prepare_to_store,
+  sim_xfer_inferior_memory, 
+  sim_files_info,
   0, 0,				/* Breakpoints */
   0, 0, 0, 0, 0,		/* Terminal handling */
-  simif_kill,			/* FIXME, kill */
-  simif_load, 
+  sim_kill,			/* FIXME, kill */
+  sim_load, 
   0,				/* lookup_symbol */
-  simif_create_inferior,	/* create_inferior */ 
-  simif_mourn,			/* mourn_inferior FIXME */
+  sim_create_inferior,	/* create_inferior */ 
+  sim_mourn,			/* mourn_inferior FIXME */
   0,				/* can_run */
   0,				/* notice_signals */
   process_stratum, 0,		/* next */
@@ -374,10 +425,10 @@ struct target_ops simif_ops =
 };
 
 static void
-simif_snoop ()
+sim_snoop ()
 {
-  simif_verbose = ! simif_verbose;  
-  if (simif_verbose)
+  sim_verbose = ! sim_verbose;  
+  if (sim_verbose)
     printf_filtered ("Snoop enabled\n");
   else
     printf_filtered ("Snoop disabled\n");
@@ -389,8 +440,8 @@ simif_snoop ()
 void
 _initialize_remote_sim ()
 {
-  add_target (&simif_ops);
-  add_com ("snoop", class_obscure, simif_snoop,
+  add_target (&sim_ops);
+  add_com ("snoop", class_obscure, sim_snoop,
 	   "Show what commands are going to the simulator");
 }
 
@@ -400,21 +451,21 @@ dump_mem (buf, len)
      int len;
 {
   if (len <= 8)
-  {
-    if (len == 8 || len == 4)
-    {
-      long l[2];
-      memcpy (l, buf, len);
-      printf_filtered ("\t0x%x", l[0]);
-      printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
-    }
-    else
     {
-      int i;
-      printf_filtered ("\t");
-      for (i = 0; i < len; i++)
-	printf_filtered ("0x%x ", buf[i]);
-      printf_filtered ("\n");
+      if (len == 8 || len == 4)
+	{
+	  long l[2];
+	  memcpy (l, buf, len);
+	  printf_filtered ("\t0x%x", l[0]);
+	  printf_filtered (len == 8 ? " 0x%x\n" : "\n", l[1]);
+	}
+      else
+	{
+	  int i;
+	  printf_filtered ("\t");
+	  for (i = 0; i < len; i++)
+	    printf_filtered ("0x%x ", buf[i]);
+	  printf_filtered ("\n");
+	}
     }
-  }
 }