From 595dc9a4ed8f7319e09123a36f24a0155feac733 Mon Sep 17 00:00:00 2001 From: David Edelsohn Date: Wed, 14 Jul 1993 02:21:59 +0000 Subject: Restore function naming scheme (sim_xxx vs simif_xxx). Make more generic (remove any reference to sparc64). Document simif_xxx fns. --- gdb/remote-sp64sim.c | 303 ++++++++++++++++++++++++++++++--------------------- 1 file changed, 177 insertions(+), 126 deletions(-) (limited to 'gdb/remote-sp64sim.c') 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"); + } } - } } -- cgit v1.1