(sim_open): Return a `descriptor' as result.
(*): New argument of descriptor result from sim_open.
* remote-sim.c (gdbsim_desc): Renamed from gdbsim_open_p.
(gdbsim_open): Record result of sim_open in gdbsim_desc.
Pass argv list to sim_open, argv[0] = pseudo program name.
(*): Pass gdbsim_desc to sim_foo fns.
+Thu Mar 13 11:00:22 1997 Doug Evans <dje@canuck.cygnus.com>
+
+ * remote-sim.h (sim_state, SIM_DESC): New types.
+ (sim_open): Return a `descriptor' as result.
+ (*): New argument of descriptor result from sim_open.
+ * remote-sim.c (gdbsim_desc): Renamed from gdbsim_open_p.
+ (gdbsim_open): Record result of sim_open in gdbsim_desc.
+ Pass argv list to sim_open, argv[0] = pseudo program name.
+ (*): Pass gdbsim_desc to sim_foo fns.
+
+Tue Mar 11 07:25:27 1997 Mark Alexander <marka@cygnus.com>
+
+ First cut at supporting simulators in gdbserver:
+
+ * configure, configure.in: Allow gdbserver to be configured
+ for cross-target environments.
+ * gdbserver/Makefile.in: Add simulator support.
+ * gdbserver/configure.in: Eliminate assumption that host == target.
+ Simplify using gdb/configure.tgt and gdb/configure.host.
+ Fix other minor configuration errors.
+ * gdbserver/low-sparc.c: Fix compile error.
+ * gdbserver/remote-utils.c: Eliminate assumption that registers
+ and addresses are four bytes. Fix minor compile errors and warnings.
+ * gdbserver/server.c: Rewrite numerous instances of identical code
+ for starting inferior processes to call new function start_inferior.
+ Eliminate assumption that registers and addresses are four bytes.
+ * gdbserver/server.h: Add missing prototypes to eliminate compiler
+ warnings.
+ * gdbserver/low-sim.c: New file to mate gdbserver with simulators.
+ * config/mips/vr5000.mt: Add Vr5000 simulator support to gdbserver.
+ * config/i386/linux.mh: Eliminate gdbserver support as a first step
+ in moving such support from host to target makefile fragments.
+ * config/i386/linux.mt: Move gdbserver support here from linux.mh.
+
Mon Mar 10 12:27:47 1997 Michael Snyder <msnyder@cleaver.cygnus.com>
* symtab.h (INIT_SAL): New macro to initialize symtab_and_line,
/* Generic remote debugging interface for simulators.
- Copyright 1993, 1994, 1996 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
Contributed by Cygnus Support.
Steve Chamberlain (sac@cygnus.com).
/* We must keep track of whether the simulator has been opened or not because
GDB can call a target's close routine twice, but sim_close doesn't allow
- this. */
-static int gdbsim_open_p = 0;
+ this. We also need to record the result of sim_open so we can pass it
+ back to the other sim_foo routines. */
+static SIM_DESC gdbsim_desc = 0;
static void
dump_mem (buf, len)
gdb_callback.write_stdout = gdb_os_write_stdout;
gdb_callback.printf_filtered = gdb_os_printf_filtered;
gdb_callback.error = gdb_os_error;
- sim_set_callbacks (&gdb_callback);
+ sim_set_callbacks (gdbsim_desc, &gdb_callback);
callbacks_initialized = 1;
}
}
{
char buf[MAX_REGISTER_RAW_SIZE];
- sim_fetch_register (regno, buf);
+ sim_fetch_register (gdbsim_desc, regno, buf);
supply_register (regno, buf);
if (sr_get_debug ())
{
/* FIXME: Until read_register() returns LONGEST, we have this. */
char tmp[MAX_REGISTER_RAW_SIZE];
read_register_gen (regno, tmp);
- sim_store_register (regno, tmp);
+ sim_store_register (gdbsim_desc, regno, tmp);
if (sr_get_debug ())
{
printf_filtered ("gdbsim_store_register: %d", regno);
if (sr_get_debug ())
printf_filtered ("gdbsim_kill\n");
- sim_kill (); /* close fd's, remove mappings */
+ sim_kill (gdbsim_desc); /* close fd's, remove mappings, etc. */
inferior_pid = 0;
}
/* This must be done before calling gr_load_image. */
program_loaded = 1;
- if (sim_load (prog, fromtty) != 0)
+ if (sim_load (gdbsim_desc, prog, fromtty) != 0)
generic_load (prog, fromtty);
}
strcat (arg_buf, args);
argv = buildargv (arg_buf);
make_cleanup (freeargv, (char *) argv);
- sim_create_inferior (entry_pt, argv, env);
+ sim_create_inferior (gdbsim_desc, entry_pt, argv, env);
inferior_pid = 42;
insert_breakpoints (); /* Needed to get correct instruction in cache */
char *args;
int from_tty;
{
+ int len;
+ char *arg_buf;
+ char **argv;
+
if (sr_get_debug ())
printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
sim_close to be called if the simulator is already open, but push_target
is called after sim_open! We can't move the call to push_target before
the call to sim_open because sim_open may invoke `error'. */
- if (gdbsim_open_p)
+ if (gdbsim_desc != NULL)
unpush_target (&gdbsim_ops);
init_callbacks ();
- sim_open (args);
- gdbsim_open_p = 1;
+ len = 7 + 1 + (args ? strlen (args) : 0) + 1 + /*slop*/ 10;
+ arg_buf = (char *) alloca (len);
+ strcpy (arg_buf, "gdbsim");
+ if (args)
+ {
+ strcat (arg_buf, " ");
+ strcat (arg_buf, args);
+ }
+ argv = buildargv (arg_buf);
+ if (argv == NULL)
+ error ("Insufficient memory available to allocate simulator arg list.");
+ make_cleanup (freeargv, (char *) argv);
+
+ /* FIXME: sim_open may call `error' if it fails, but perhaps it should
+ just return an error indicator and let us call `error'. */
+ gdbsim_desc = sim_open (argv);
push_target (&gdbsim_ops);
target_fetch_registers (-1);
program_loaded = 0;
- if (gdbsim_open_p)
+ if (gdbsim_desc != NULL)
{
- sim_close (quitting);
- gdbsim_open_p = 0;
+ sim_close (gdbsim_desc, quitting);
+ gdbsim_desc = NULL;
}
end_callbacks ();
if (sr_get_debug ())
printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
- sim_resume (step, target_signal_to_host (siggnal));
+ sim_resume (gdbsim_desc, step, target_signal_to_host (siggnal));
}
/* Wait for inferior process to do something. Return pid of child,
if (sr_get_debug ())
printf_filtered ("gdbsim_wait\n");
- sim_stop_reason (&reason, &sigrc);
+ sim_stop_reason (gdbsim_desc, &reason, &sigrc);
switch (reason)
{
case sim_exited:
if (write)
{
- len = sim_write (memaddr, myaddr, len);
+ len = sim_write (gdbsim_desc, memaddr, myaddr, len);
}
else
{
- len = sim_read (memaddr, myaddr, len);
+ len = sim_read (gdbsim_desc, memaddr, myaddr, len);
if (sr_get_debug () && len > 0)
dump_mem(myaddr, len);
}
{
printf_filtered ("\tAttached to %s running program %s\n",
target_shortname, file);
- sim_info (0);
+ sim_info (gdbsim_desc, 0);
}
}
ensure that the callbacks have been set up. */
init_callbacks ();
- sim_do_command (args);
+ /* Note that if the simulator hasn't been opened, gdbsim_desc == NULL
+ which is correct (??? assuming of course one wishes to continue to
+ allow commands to be sent to unopened simulators, which isn't entirely
+ unreasonable). */
+ sim_do_command (gdbsim_desc, args);
}
/* Define the target subroutine names */
/* This file defines the interface between the simulator and gdb.
- Copyright (C) 1993, 1994, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
This file is part of GDB.
typedef CORE_ADDR_TYPE SIM_ADDR;
#endif
+/* Semi-opaque type used as result of sim_open and passed back to all
+ other routines. "desc" is short for "descriptor".
+ It is up to each simulator to define `sim_state'. */
+
+typedef struct sim_state *SIM_DESC;
+
/* Main simulator entry points. */
/* Initialize the simulator. This function is called when the simulator
- is selected from the command line. ARGS is passed from the command line
+ is selected from the command line. ARGV 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,
- which is trivial to do with the buildargv function in libiberty. */
-/* FIXME: Eventually create a STATE and return its address and pass it to
- all other main entry points. */
+ ARGV is the standard NULL terminated array of pointers. */
-void sim_open PARAMS ((char *args));
+SIM_DESC sim_open PARAMS ((char **argv));
/* Terminate usage of the simulator. This may involve freeing target memory
and closing any open files and mmap'd areas. You cannot assume sim_kill
has already been called.
QUITTING is non-zero if we cannot hang on errors. */
-void sim_close PARAMS ((int quitting));
+void sim_close PARAMS ((SIM_DESC sd, int quitting));
/* Load program PROG into the simulator.
Return non-zero if you wish the caller to handle it
(it is done this way because most simulators can use gr_load_image,
but defining it as a callback seems awkward). */
-int sim_load PARAMS ((char *prog, int from_tty));
+int sim_load PARAMS ((SIM_DESC sd, char *prog, int from_tty));
/* Prepare to run the simulated program.
START_ADDRESS is, yes, you guessed it, the start address of the program.
sim_store_register, so the START_ADDRESS argument is there as a
workaround. */
-void sim_create_inferior PARAMS ((SIM_ADDR start_address,
+void sim_create_inferior PARAMS ((SIM_DESC sd, SIM_ADDR start_address,
char **argv, char **env));
/* Kill the running program.
This may involve closing any open files and deleting any mmap'd areas. */
-void sim_kill PARAMS ((void));
+void sim_kill PARAMS ((SIM_DESC sd));
/* Read LENGTH bytes of the simulated program's memory and store in BUF.
Result is number of bytes read, or zero if error. */
-int sim_read PARAMS ((SIM_ADDR mem, unsigned char *buf, int length));
+int sim_read PARAMS ((SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length));
/* Store LENGTH bytes from BUF in the simulated program's memory.
Result is number of bytes write, or zero if error. */
-int sim_write PARAMS ((SIM_ADDR mem, unsigned char *buf, int length));
+int sim_write PARAMS ((SIM_DESC sd, SIM_ADDR mem, unsigned char *buf, int length));
/* Fetch register REGNO and store the raw value in BUF. */
-void sim_fetch_register PARAMS ((int regno, unsigned char *buf));
+void sim_fetch_register PARAMS ((SIM_DESC sd, int regno, unsigned char *buf));
/* Store register REGNO from BUF (in raw format). */
-void sim_store_register PARAMS ((int regno, unsigned char *buf));
+void sim_store_register PARAMS ((SIM_DESC sd, int regno, unsigned char *buf));
/* Print some interesting information about the simulator.
VERBOSE is non-zero for the wordy version. */
-void sim_info PARAMS ((int verbose));
+void sim_info PARAMS ((SIM_DESC sd, int verbose));
/* Fetch why the program stopped.
SIGRC will contain either the argument to exit() or the signal number. */
enum sim_stop { sim_exited, sim_stopped, sim_signalled };
-void sim_stop_reason PARAMS ((enum sim_stop *reason, int *sigrc));
+void sim_stop_reason PARAMS ((SIM_DESC sd, enum sim_stop *reason, int *sigrc));
/* Run (or resume) the program. */
-void sim_resume PARAMS ((int step, int siggnal));
+void sim_resume PARAMS ((SIM_DESC sd, int step, int siggnal));
/* Passthru for other commands that the simulator might support. */
-void sim_do_command PARAMS ((char *cmd));
+void sim_do_command PARAMS ((SIM_DESC sd, char *cmd));
/* Provide simulator with a standard host_callback_struct. */
-void sim_set_callbacks PARAMS ((struct host_callback_struct *));
+void sim_set_callbacks PARAMS ((SIM_DESC sd, struct host_callback_struct *));
#endif /* !defined (REMOTE_SIM_H) */
projects / platform / upstream / binutils.git / commitdiff