This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
[RFA] remote-sim.c: Add support for multiple sim instances
- From: Kevin Buettner <kevinb at redhat dot com>
- To: gdb-patches at sourceware dot org
- Date: Fri, 2 Jul 2010 15:30:17 -0700
- Subject: [RFA] remote-sim.c: Add support for multiple sim instances
The patch below was motivated by wanting to be able to examine
simulator memory after a "load", but before a "run". For more
detail, see the thread starting with the following post:
http://sourceware.org/ml/gdb-patches/2010-06/msg00656.html
In the course of working towards a solution for that problem, it
became clear to me that in order to solve it, I would need to move
certain static globals in remote-sim.c into a per-inferior data
structure. (My testing of a simpler patch was showing two regressions
in gdb.multi/base.exp, both caused by the fact that the
"program_loaded" state for one inferior did not hold for all
inferiors.) The movement of certain static globals into a per-inferior
data structure, plus addressing some of the fallout in making such a
change, is what this patch does. It does not address the problem of
being able to access sim memory just after a "load". I will submit a
separate patch for that.
A very nice side effect of this patch is that it is now possible to
have more than one runnable simulator instance. This is illustrated
by the following session using programs from the gdb.multi/base.exp
test case:
GNU gdb (GDB) 7.1.50.20100702-cvs
Copyright (C) 2010 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "--host=i686-pc-linux-gnu --target=mips-elf".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
(gdb) file testsuite/gdb.multi/hello
Reading symbols from /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hello...done.
(gdb) tar sim
Connected to the simulator.
(gdb) load
Loading section .text, size 0x804 vma 0xa0020000
Loading section .init, size 0x38 vma 0xa0020804
Loading section .fini, size 0x28 vma 0xa002083c
Loading section .eh_frame, size 0x4 vma 0xa0020864
Loading section .jcr, size 0x4 vma 0xa0020868
Loading section .ctors, size 0x8 vma 0xa002086c
Loading section .dtors, size 0x8 vma 0xa0020874
Loading section .rodata, size 0x4 vma 0xa002087c
Loading section .data, size 0x428 vma 0xa0020880
Loading section .sdata, size 0x10 vma 0xa0020ca8
Start address 0xa0020004
Transfer rate: 26048 bits in <1 sec.
(gdb) add-inferior -exec testsuite/gdb.multi/hangout
Added inferior 2
Reading symbols from /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hangout...done.
(gdb) add-inferior -exec testsuite/gdb.multi/goodbye
Added inferior 3
Reading symbols from /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/goodbye...done.
(gdb) info inferior
Num Description Executable
3 <null> /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/goodbye
2 <null> /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hangout
* 1 <null> /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hello
(gdb) inferior 1
[Switching to inferior 1 [process 0] (/mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hello)]
(gdb) load
Loading section .text, size 0x804 vma 0xa0020000
Loading section .init, size 0x38 vma 0xa0020804
Loading section .fini, size 0x28 vma 0xa002083c
Loading section .eh_frame, size 0x4 vma 0xa0020864
Loading section .jcr, size 0x4 vma 0xa0020868
Loading section .ctors, size 0x8 vma 0xa002086c
Loading section .dtors, size 0x8 vma 0xa0020874
Loading section .rodata, size 0x4 vma 0xa002087c
Loading section .data, size 0x428 vma 0xa0020880
Loading section .sdata, size 0x10 vma 0xa0020ca8
Start address 0xa0020004
Transfer rate: 26048 bits in <1 sec.
(gdb) inferior 2
[Switching to inferior 2 [process 0] (/mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hangout)]
(gdb) load
Loading section .text, size 0xacc0 vma 0xa0020000
Loading section .init, size 0x38 vma 0xa002acc0
Loading section .fini, size 0x28 vma 0xa002acf8
Loading section .eh_frame, size 0x40 vma 0xa002ad20
Loading section .jcr, size 0x4 vma 0xa002ad60
Loading section .ctors, size 0x8 vma 0xa002ad64
Loading section .dtors, size 0x8 vma 0xa002ad6c
Loading section .rodata, size 0x5e0 vma 0xa002ad78
Loading section .data, size 0x870 vma 0xa002b358
Loading section .sdata, size 0x88 vma 0xa002bbc8
Start address 0xa0020004
Transfer rate: 385632 bits in <1 sec.
(gdb) inferior 3
[Switching to inferior 3 [process 0] (/mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/goodbye)]
(gdb) load
Loading section .text, size 0x938 vma 0xa0020000
Loading section .init, size 0x38 vma 0xa0020938
Loading section .fini, size 0x28 vma 0xa0020970
Loading section .eh_frame, size 0x4 vma 0xa0020998
Loading section .jcr, size 0x4 vma 0xa002099c
Loading section .ctors, size 0x8 vma 0xa00209a0
Loading section .dtors, size 0x8 vma 0xa00209a8
Loading section .rodata, size 0x4 vma 0xa00209b0
Loading section .data, size 0x428 vma 0xa00209b8
Loading section .sdata, size 0x14 vma 0xa0020de0
Start address 0xa0020004
Transfer rate: 28544 bits in <1 sec.
(gdb) b main
Breakpoint 1 at 0xa002040c: file /ironwood1/sourceware-multi-1/mips-elf/../src/gdb/testsuite/gdb.multi/goodbye.c, line 43.
(gdb) run
Starting program: /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/goodbye
Breakpoint 1, main ()
at /ironwood1/sourceware-multi-1/mips-elf/../src/gdb/testsuite/gdb.multi/goodbye.c:43
43 mailand();
(gdb) inferior 1
[Switching to inferior 1 [process 0] (/mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hello)]
(gdb) b main
Breakpoint 2 at 0xa0020378: file /ironwood1/sourceware-multi-1/mips-elf/../src/gdb/testsuite/gdb.multi/hello.c, line 40.
(gdb) run
Starting program: /mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/hello
Breakpoint 2, main ()
at /ironwood1/sourceware-multi-1/mips-elf/../src/gdb/testsuite/gdb.multi/hello.c:40
40 bar();
(gdb) next
41 tmpx = hello(glob);
(gdb) p glob
$1 = 92
(gdb) inferior 3
[Switching to inferior 3 [process 42002] (/mesquite2/sourceware-multi-1/mips-elf/gdb/testsuite/gdb.multi/goodbye)]
[Switching to thread 1 (Thread <main>)]
#0 main ()
at /ironwood1/sourceware-multi-1/mips-elf/../src/gdb/testsuite/gdb.multi/goodbye.c:43
43 mailand();
(gdb) p glob
$2 = 45
(gdb) next
44 foo(glob);
(gdb) p glob
$3 = 46
(gdb)
The above session shows that it's now possible to run two (or more)
simulator sessions simultateously from gdb. Unfortunately, this only
works for certain simulators. The sims that I've tested and know
to work are frv and mips. The v850 sim should work, but doesn't.
I've tested the arm and powerpc sims and neither of those works with
multiple instances. (Nor are they expected to.) I am fairly certain
that neither the rx nor the m32c sim will work either.
Simulators that aren't capable of multiple instantiations are detected
and an error message is printed. E.g., this is what the message looks
like when attempting to create a second sim instance using an arm-elf
GDB:
(gdb) load
Inferior 2 and inferior 1 have identical simulator state.
(This simulator does not support the running of more than one inferior.)
When should a new sim instance be created? That's one of the
questions that I had to answer while working on this patch.
It seems to me that, long term, the right way to do it is to create a
new sim instance for each invocation of "target sim". That, however,
is not what I did.
I've structured the code in this patch so that the first sim instance
is created when "target sim" is invoked. Subsequent sim instances are
created lazily, as needed. A "load" (aka to_load) operation will
usually trigger the creation of a new sim instance, but so will
attempting to run the program without doing a load. Basically, any
operation which fetches the state using SIM_INSTANCE_NEEDED could,
potentially, cause the creation of a new simulator instance. That
assumes that one has not already been created by some earlier operation,
of course. Thus, due to their sequencing, there are certain operations
that will never be able to create a new sim instance.
But, back to the "right way" for a moment. It seems to me that,
ideally, we'd want to be able to have one inferior connected to a
remote target, another to a simulator, another to a different remote
target, yet another to a sim using a different architecture variant,
etc. In order for that to happen, the target vector will need to
become a per-inferior data structure. Since that's not the case at
the moment, it seemed to me that the next best course of action is
to allocate the sims as required.
Comments? Okay to commit?
Kevin
* remote-sim.c (program_loaded, gdbsim_desc, remote_sim_ptid):
Move these static globals...
(struct sim_inferior_data): ...into this new struct.
(sim_inferior_data_key, next_pid, sim_argv): New static globals.
(gdb_callback, callbacks_initialized): Move these globals to
a point earlier in the file.
(check_for_duplicate_sim_descriptor, get_sim_inferior_data)
(sim_inferior_data_cleanup): New functions.
(SIM_INSTANCE_NOT_NEEDED, SIM_INSTANCE_NEEDED): New constants.
(gdbsim_fetch_register, gdbsim_store_register, gdbsim_load)
(gdbsim_create_inferior, gdbsim_open, gdbsim_close, gdbsim_resume)
(gdbsim_stop, gdbsim_cntrl_c, gdbsim_wait)
(gdbsim_xfer_inferior_memory, gdbsim_files_info)
(gdbsim_mourn_inferior, simulator_command, gdbsim_thread_alive,
(gdbsim_pid_to_str): Invoke `get_sim_inferior_data' to set
new local variable `sim_data' in each of these functions. Use
`sim_data' to reference former globals `program_loaded',
`gdbsim_desc', and `remote_sim_ptid'.
(gdbsim_open): Remove local variable `argv'. Put results of call
to `gdb_buildargv' in `sim_argv' rather than in `argv'. Don't
make a cleanup for it. Free it though when a sim instance cannot
be obtained.
(gdbsim_close): Free sim_argv and null it out as appropriate.
(_initialize_remote_sim): Initialize `sim_inferior_data_key'.
Index: remote-sim.c
===================================================================
RCS file: /cvs/src/src/gdb/remote-sim.c,v
retrieving revision 1.96
diff -u -p -r1.96 remote-sim.c
--- remote-sim.c 16 May 2010 21:11:14 -0000 1.96
+++ remote-sim.c 2 Jul 2010 20:15:59 -0000
@@ -101,19 +101,125 @@ void simulator_command (char *args, int
/* Forward data declarations */
extern struct target_ops gdbsim_ops;
-static int program_loaded = 0;
+static const struct inferior_data *sim_inferior_data_key;
-/* 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. 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;
-
-/* 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;
+/* Simulator-specific, per-inferior state. */
+struct sim_inferior_data {
+ /* Flag which indicates whether or not the program has been loaded. */
+ int program_loaded;
+
+ /* Simulator descriptor for this inferior. */
+ SIM_DESC gdbsim_desc;
+
+ /* This is the ptid we use for this particular simulator instance. Its
+ value is somewhat arbitrary, as the simulator target don't have a
+ notion of tasks or threads, but we need something non-null to place
+ in inferior_ptid. For simulators which permit multiple instances,
+ we also need a unique identifier to use for each inferior. */
+ ptid_t remote_sim_ptid;
+};
+
+/* Value of the next pid to allocate for an inferior. */
+static int next_pid = 42000;
+
+/* Argument list to pass to sim_open() (for creating simulator instances). */
+static char **sim_argv = NULL;
+
+/* OS-level callback functions for write, flush, etc. */
+static host_callback gdb_callback;
+static int callbacks_initialized = 0;
+
+/* Callback for iterate_over_inferiors. It checks to see if
+ the sim descriptor of the per-inferior simulator data
+ passed via ARG is the same as that for the inferior
+ designated by INF. Return true if so; false otherwise. */
+
+static int
+check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
+{
+ struct sim_inferior_data *sd1, *sd2;
+
+ sd1 = arg;
+ sd2 = inferior_data (inf, sim_inferior_data_key);
+
+ return (sd2 != NULL && sd1 != sd2 && sd2->gdbsim_desc != NULL
+ && sd1->gdbsim_desc == sd2->gdbsim_desc);
+}
+
+/* Flags indicating whether or not a sim instance is needed. One of these
+ flags should be passed to get_sim_inferior_data(). */
+
+enum {SIM_INSTANCE_NOT_NEEDED = 0, SIM_INSTANCE_NEEDED = 1};
+
+/* Obtain pointer to per-inferior simulator data, allocating it if necessary.
+ Attempt to open the sim if SIM_INSTANCE_NEEDED is true. */
+
+static struct sim_inferior_data *
+get_sim_inferior_data (int sim_instance_needed)
+{
+ struct inferior *inf = current_inferior ();
+ struct sim_inferior_data *sim_data
+ = inferior_data (inf, sim_inferior_data_key);
+
+ if (sim_data == NULL)
+ {
+ sim_data = XZALLOC(struct sim_inferior_data);
+ set_inferior_data (inf, sim_inferior_data_key, sim_data);
+
+ /* Allocate a ptid for this inferior. */
+ sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
+ next_pid++;
+
+ /* Initialize the other instance variables. */
+ sim_data->program_loaded = 0;
+ sim_data->gdbsim_desc = NULL;
+ }
+
+ /* Try to allocate a new sim instance, if needed. */
+ if (sim_instance_needed && sim_data->gdbsim_desc == 0)
+ {
+ struct inferior *idup;
+ sim_data->gdbsim_desc
+ = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
+ if (sim_data->gdbsim_desc == NULL)
+ error (_("Unable to create simulator instance for inferior %d."), inf->num);
+
+ idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
+ sim_data);
+ if (idup != NULL)
+ {
+ /* We don't close the descriptor due to the fact that it's shared with
+ some other inferior. If we were to close it, that might needlessly
+ muck up the other inferior. Of course, it's possible that the damage
+ has already been done... But not closing it seems like the safest
+ option. Note that it *will* ultimately be closed during cleanup of
+ the other inferior. */
+ sim_data->gdbsim_desc = NULL;
+ 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); }
+ }
+
+ return sim_data;
+}
+
+/* Free the per-inferior simulator data. */
+
+static void
+sim_inferior_data_cleanup (struct inferior *inf, void *data)
+{
+ struct sim_inferior_data *sim_data = data;
+
+ if (sim_data != NULL)
+ {
+ if (sim_data->gdbsim_desc)
+ {
+ sim_close (sim_data->gdbsim_desc, 0);
+ sim_data->gdbsim_desc = NULL;
+ }
+ xfree (sim_data);
+ }
+}
static void
dump_mem (char *buf, int len)
@@ -142,9 +248,6 @@ dump_mem (char *buf, int len)
}
}
-static host_callback gdb_callback;
-static int callbacks_initialized = 0;
-
/* Initialize gdb_callback. */
static void
@@ -278,6 +381,8 @@ gdbsim_fetch_register (struct target_ops
struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
if (regno == -1)
{
@@ -310,7 +415,7 @@ gdbsim_fetch_register (struct target_ops
gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
memset (buf, 0, MAX_REGISTER_SIZE);
- nr_bytes = sim_fetch_register (gdbsim_desc,
+ nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
gdbarch_register_sim_regno
(gdbarch, regno),
buf,
@@ -350,6 +455,9 @@ gdbsim_store_register (struct target_ops
struct regcache *regcache, int regno)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
+
if (regno == -1)
{
for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
@@ -362,7 +470,7 @@ gdbsim_store_register (struct target_ops
int nr_bytes;
regcache_cooked_read (regcache, regno, tmp);
- nr_bytes = sim_store_register (gdbsim_desc,
+ nr_bytes = sim_store_register (sim_data->gdbsim_desc,
gdbarch_register_sim_regno
(gdbarch, regno),
tmp, register_size (gdbarch, regno));
@@ -404,6 +512,8 @@ gdbsim_load (char *args, int fromtty)
{
char **argv;
char *prog;
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
if (args == NULL)
error_no_arg (_("program to load"));
@@ -422,13 +532,13 @@ gdbsim_load (char *args, int fromtty)
/* 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)
+ if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
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. */
- program_loaded = 1;
+ sim_data->program_loaded = 1;
}
@@ -444,12 +554,14 @@ static void
gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
char **env, int from_tty)
{
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
int len;
char *arg_buf, **argv;
if (exec_file == 0 || exec_bfd == 0)
warning (_("No executable file specified."));
- if (!program_loaded)
+ if (!sim_data->program_loaded)
warning (_("No program loaded."));
if (remote_debug)
@@ -457,7 +569,7 @@ gdbsim_create_inferior (struct target_op
(exec_file ? exec_file : "(NULL)"),
args);
- if (ptid_equal (inferior_ptid, remote_sim_ptid))
+ if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
gdbsim_kill (target);
remove_breakpoints ();
init_wait_for_inferior ();
@@ -475,9 +587,9 @@ gdbsim_create_inferior (struct target_op
}
else
argv = NULL;
- sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
+ sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env);
- inferior_ptid = remote_sim_ptid;
+ inferior_ptid = sim_data->remote_sim_ptid;
inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
add_thread_silent (inferior_ptid);
@@ -496,7 +608,8 @@ gdbsim_open (char *args, int from_tty)
{
int len;
char *arg_buf;
- char **argv;
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
if (remote_debug)
printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
@@ -507,7 +620,7 @@ gdbsim_open (char *args, int from_tty)
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_desc != NULL)
+ if (sim_data->gdbsim_desc != NULL)
unpush_target (&gdbsim_ops);
len = (7 + 1 /* gdbsim */
@@ -543,14 +656,17 @@ gdbsim_open (char *args, int from_tty)
strcat (arg_buf, " "); /* 1 */
strcat (arg_buf, args);
}
- argv = gdb_buildargv (arg_buf);
- make_cleanup_freeargv (argv);
+ sim_argv = gdb_buildargv (arg_buf);
init_callbacks ();
- gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
+ sim_data->gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
- if (gdbsim_desc == 0)
- error (_("unable to create simulator instance"));
+ if (sim_data->gdbsim_desc == 0)
+ {
+ freeargv (sim_argv);
+ sim_argv = NULL;
+ error (_("unable to create simulator instance"));
+ }
push_target (&gdbsim_ops);
printf_filtered ("Connected to the simulator.\n");
@@ -572,21 +688,30 @@ gdbsim_open (char *args, int from_tty)
static void
gdbsim_close (int quitting)
{
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
if (remote_debug)
printf_filtered ("gdbsim_close: quitting %d\n", quitting);
- program_loaded = 0;
+ sim_data->program_loaded = 0;
- if (gdbsim_desc != NULL)
+ if (sim_data->gdbsim_desc != NULL)
{
- sim_close (gdbsim_desc, quitting);
- gdbsim_desc = NULL;
+ sim_close (sim_data->gdbsim_desc, quitting);
+ sim_data->gdbsim_desc = NULL;
+ }
+
+ if (sim_argv != NULL)
+ {
+ freeargv (sim_argv);
+ sim_argv = NULL;
}
end_callbacks ();
generic_mourn_inferior ();
- delete_thread_silent (remote_sim_ptid);
- delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
+ delete_thread_silent (sim_data->remote_sim_ptid);
+ delete_inferior_silent (ptid_get_pid (sim_data->remote_sim_ptid));
}
/* Takes a program previously attached to and detaches it.
@@ -620,7 +745,10 @@ static void
gdbsim_resume (struct target_ops *ops,
ptid_t ptid, int step, enum target_signal siggnal)
{
- if (!ptid_equal (inferior_ptid, remote_sim_ptid))
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
+ if (!ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
error (_("The program is not being run."));
if (remote_debug)
@@ -642,7 +770,10 @@ gdbsim_resume (struct target_ops *ops,
static void
gdbsim_stop (ptid_t ptid)
{
- if (!sim_stop (gdbsim_desc))
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
+
+ if (!sim_stop (sim_data->gdbsim_desc))
{
quit ();
}
@@ -676,13 +807,18 @@ gdb_os_poll_quit (host_callback *p)
static void
gdbsim_cntrl_c (int signo)
{
- gdbsim_stop (remote_sim_ptid);
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
+ gdbsim_stop (sim_data->remote_sim_ptid);
}
static ptid_t
gdbsim_wait (struct target_ops *ops,
ptid_t ptid, struct target_waitstatus *status, int options)
{
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
static RETSIGTYPE (*prev_sigint) ();
int sigrc = 0;
enum sim_stop reason = sim_running;
@@ -702,11 +838,11 @@ gdbsim_wait (struct target_ops *ops,
#else
prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
#endif
- sim_resume (gdbsim_desc, resume_step, resume_siggnal);
+ sim_resume (sim_data->gdbsim_desc, resume_step, resume_siggnal);
signal (SIGINT, prev_sigint);
resume_step = 0;
- sim_stop_reason (gdbsim_desc, &reason, &sigrc);
+ sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
switch (reason)
{
@@ -764,15 +900,26 @@ gdbsim_xfer_inferior_memory (CORE_ADDR m
int write, struct mem_attrib *attrib,
struct target_ops *target)
{
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
/* 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)
+ if (!sim_data->program_loaded)
error (_("No program loaded."));
+ /* Note that we obtained the sim_data pointer above using
+ SIM_INSTANCE_NOT_NEEDED. We do this so that we don't needlessly
+ allocate a sim instance prior to loading a program. If we
+ get to this point in the code though, gdbsim_desc should be
+ non-NULL. (Note that a sim instance is needed in order to load
+ the program...) */
+ gdb_assert (sim_data->gdbsim_desc != NULL);
+
if (remote_debug)
{
/* FIXME: Send to something other than STDOUT? */
@@ -786,11 +933,11 @@ gdbsim_xfer_inferior_memory (CORE_ADDR m
if (write)
{
- len = sim_write (gdbsim_desc, memaddr, myaddr, len);
+ len = sim_write (sim_data->gdbsim_desc, memaddr, myaddr, len);
}
else
{
- len = sim_read (gdbsim_desc, memaddr, myaddr, len);
+ len = sim_read (sim_data->gdbsim_desc, memaddr, myaddr, len);
if (remote_debug && len > 0)
dump_mem (myaddr, len);
}
@@ -800,6 +947,8 @@ gdbsim_xfer_inferior_memory (CORE_ADDR m
static void
gdbsim_files_info (struct target_ops *target)
{
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NEEDED);
const char *file = "nothing";
if (exec_bfd)
@@ -812,7 +961,7 @@ gdbsim_files_info (struct target_ops *ta
{
printf_filtered ("\tAttached to %s running program %s\n",
target_shortname, file);
- sim_info (gdbsim_desc, 0);
+ sim_info (sim_data->gdbsim_desc, 0);
}
}
@@ -821,12 +970,15 @@ gdbsim_files_info (struct target_ops *ta
static void
gdbsim_mourn_inferior (struct target_ops *target)
{
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
if (remote_debug)
printf_filtered ("gdbsim_mourn_inferior:\n");
remove_breakpoints ();
generic_mourn_inferior ();
- delete_thread_silent (remote_sim_ptid);
+ delete_thread_silent (sim_data->remote_sim_ptid);
}
/* Pass the command argument through to the simulator verbatim. The
@@ -835,7 +987,10 @@ gdbsim_mourn_inferior (struct target_ops
void
simulator_command (char *args, int from_tty)
{
- if (gdbsim_desc == NULL)
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
+ if (sim_data->gdbsim_desc == NULL)
{
/* PREVIOUSLY: The user may give a command before the simulator
@@ -851,7 +1006,7 @@ simulator_command (char *args, int from_
error (_("Not connected to the simulator target"));
}
- sim_do_command (gdbsim_desc, args);
+ sim_do_command (sim_data->gdbsim_desc, args);
/* Invalidate the register cache, in case the simulator command does
something funny. */
@@ -863,7 +1018,10 @@ simulator_command (char *args, int from_
static int
gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
{
- if (ptid_equal (ptid, remote_sim_ptid))
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
+
+ if (ptid_equal (ptid, sim_data->remote_sim_ptid))
/* The simulators' task is always alive. */
return 1;
@@ -877,8 +1035,10 @@ static char *
gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
{
static char buf[64];
+ struct sim_inferior_data *sim_data
+ = get_sim_inferior_data (SIM_INSTANCE_NOT_NEEDED);
- if (ptid_equal (remote_sim_ptid, ptid))
+ if (ptid_equal (sim_data->remote_sim_ptid, ptid))
{
xsnprintf (buf, sizeof buf, "Thread <main>");
return buf;
@@ -934,7 +1094,6 @@ _initialize_remote_sim (void)
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);
+ sim_inferior_data_key
+ = register_inferior_data_with_cleanup (sim_inferior_data_cleanup);
}