1 /* Generic remote debugging interface for simulators.
3 Copyright (C) 1993-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Support.
6 Steve Chamberlain (sac@cygnus.com).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
35 #include "gdb/callback.h"
36 #include "gdb/remote-sim.h"
39 #include "gdb_assert.h"
40 #include "sim-regno.h"
41 #include "arch-utils.h"
42 #include "readline/readline.h"
43 #include "gdbthread.h"
47 extern void _initialize_remote_sim (void);
49 static void init_callbacks (void);
51 static void end_callbacks (void);
53 static int gdb_os_write_stdout (host_callback *, const char *, int);
55 static void gdb_os_flush_stdout (host_callback *);
57 static int gdb_os_write_stderr (host_callback *, const char *, int);
59 static void gdb_os_flush_stderr (host_callback *);
61 static int gdb_os_poll_quit (host_callback *);
63 /* printf_filtered is depreciated. */
64 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
66 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
68 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
70 static void gdb_os_error (host_callback *, const char *, ...)
73 static void gdbsim_kill (struct target_ops *);
75 static void gdbsim_load (char *prog, int fromtty);
77 static void gdbsim_open (char *args, int from_tty);
79 static void gdbsim_close (void);
81 static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
83 static void gdbsim_prepare_to_store (struct regcache *regcache);
85 static void gdbsim_files_info (struct target_ops *target);
87 static void gdbsim_mourn_inferior (struct target_ops *target);
89 static void gdbsim_stop (ptid_t ptid);
91 void simulator_command (char *args, int from_tty);
95 sim_* are the interface to the simulator (see remote-sim.h).
96 gdbsim_* are stuff which is internal to gdb. */
98 /* Forward data declarations */
99 extern struct target_ops gdbsim_ops;
101 static const struct inferior_data *sim_inferior_data_key;
103 /* Simulator-specific, per-inferior state. */
104 struct sim_inferior_data {
105 /* Flag which indicates whether or not the program has been loaded. */
108 /* Simulator descriptor for this inferior. */
109 SIM_DESC gdbsim_desc;
111 /* This is the ptid we use for this particular simulator instance. Its
112 value is somewhat arbitrary, as the simulator target don't have a
113 notion of tasks or threads, but we need something non-null to place
114 in inferior_ptid. For simulators which permit multiple instances,
115 we also need a unique identifier to use for each inferior. */
116 ptid_t remote_sim_ptid;
118 /* Signal with which to resume. */
119 enum gdb_signal resume_siggnal;
121 /* Flag which indicates whether resume should step or not. */
125 /* Flag indicating the "open" status of this module. It's set to 1
126 in gdbsim_open() and 0 in gdbsim_close(). */
127 static int gdbsim_is_open = 0;
129 /* Value of the next pid to allocate for an inferior. As indicated
130 elsewhere, its initial value is somewhat arbitrary; it's critical
131 though that it's not zero or negative. */
133 #define INITIAL_PID 42000
135 /* Argument list to pass to sim_open(). It is allocated in gdbsim_open()
136 and deallocated in gdbsim_close(). The lifetime needs to extend beyond
137 the call to gdbsim_open() due to the fact that other sim instances other
138 than the first will be allocated after the gdbsim_open() call. */
139 static char **sim_argv = NULL;
141 /* OS-level callback functions for write, flush, etc. */
142 static host_callback gdb_callback;
143 static int callbacks_initialized = 0;
145 /* Callback for iterate_over_inferiors. It checks to see if the sim
146 descriptor passed via ARG is the same as that for the inferior
147 designated by INF. Return true if so; false otherwise. */
150 check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
152 struct sim_inferior_data *sim_data;
153 SIM_DESC new_sim_desc = arg;
155 sim_data = inferior_data (inf, sim_inferior_data_key);
157 return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
160 /* Flags indicating whether or not a sim instance is needed. One of these
161 flags should be passed to get_sim_inferior_data(). */
163 enum {SIM_INSTANCE_NOT_NEEDED = 0, SIM_INSTANCE_NEEDED = 1};
165 /* Obtain pointer to per-inferior simulator data, allocating it if necessary.
166 Attempt to open the sim if SIM_INSTANCE_NEEDED is true. */
168 static struct sim_inferior_data *
169 get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
171 SIM_DESC sim_desc = NULL;
172 struct sim_inferior_data *sim_data
173 = inferior_data (inf, sim_inferior_data_key);
175 /* Try to allocate a new sim instance, if needed. We do this ahead of
176 a potential allocation of a sim_inferior_data struct in order to
177 avoid needlessly allocating that struct in the event that the sim
178 instance allocation fails. */
179 if (sim_instance_needed == SIM_INSTANCE_NEEDED
180 && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
182 struct inferior *idup;
183 sim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
184 if (sim_desc == NULL)
185 error (_("Unable to create simulator instance for inferior %d."),
188 idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
192 /* We don't close the descriptor due to the fact that it's
193 shared with some other inferior. If we were to close it,
194 that might needlessly muck up the other inferior. Of
195 course, it's possible that the damage has already been
196 done... Note that it *will* ultimately be closed during
197 cleanup of the other inferior. */
200 _("Inferior %d and inferior %d would have identical simulator state.\n"
201 "(This simulator does not support the running of more than one inferior.)"),
202 inf->num, idup->num);
206 if (sim_data == NULL)
208 sim_data = XZALLOC(struct sim_inferior_data);
209 set_inferior_data (inf, sim_inferior_data_key, sim_data);
211 /* Allocate a ptid for this inferior. */
212 sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
215 /* Initialize the other instance variables. */
216 sim_data->program_loaded = 0;
217 sim_data->gdbsim_desc = sim_desc;
218 sim_data->resume_siggnal = GDB_SIGNAL_0;
219 sim_data->resume_step = 0;
223 /* This handles the case where sim_data was allocated prior to
224 needing a sim instance. */
225 sim_data->gdbsim_desc = sim_desc;
232 /* Return pointer to per-inferior simulator data using PTID to find the
233 inferior in question. Return NULL when no inferior is found or
234 when ptid has a zero or negative pid component. */
236 static struct sim_inferior_data *
237 get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
239 struct inferior *inf;
240 int pid = ptid_get_pid (ptid);
245 inf = find_inferior_pid (pid);
248 return get_sim_inferior_data (inf, sim_instance_needed);
253 /* Free the per-inferior simulator data. */
256 sim_inferior_data_cleanup (struct inferior *inf, void *data)
258 struct sim_inferior_data *sim_data = data;
260 if (sim_data != NULL)
262 if (sim_data->gdbsim_desc)
264 sim_close (sim_data->gdbsim_desc, 0);
265 sim_data->gdbsim_desc = NULL;
272 dump_mem (const gdb_byte *buf, int len)
274 printf_filtered ("\t");
276 if (len == 8 || len == 4)
280 memcpy (l, buf, len);
281 printf_filtered ("0x%08x", l[0]);
283 printf_filtered (" 0x%08x", l[1]);
289 for (i = 0; i < len; i++)
290 printf_filtered ("0x%02x ", buf[i]);
293 printf_filtered ("\n");
296 /* Initialize gdb_callback. */
299 init_callbacks (void)
301 if (!callbacks_initialized)
303 gdb_callback = default_callback;
304 gdb_callback.init (&gdb_callback);
305 gdb_callback.write_stdout = gdb_os_write_stdout;
306 gdb_callback.flush_stdout = gdb_os_flush_stdout;
307 gdb_callback.write_stderr = gdb_os_write_stderr;
308 gdb_callback.flush_stderr = gdb_os_flush_stderr;
309 gdb_callback.printf_filtered = gdb_os_printf_filtered;
310 gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
311 gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
312 gdb_callback.error = gdb_os_error;
313 gdb_callback.poll_quit = gdb_os_poll_quit;
314 gdb_callback.magic = HOST_CALLBACK_MAGIC;
315 callbacks_initialized = 1;
319 /* Release callbacks (free resources used by them). */
324 if (callbacks_initialized)
326 gdb_callback.shutdown (&gdb_callback);
327 callbacks_initialized = 0;
331 /* GDB version of os_write_stdout callback. */
334 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
339 ui_file_write (gdb_stdtarg, buf, len);
343 /* GDB version of os_flush_stdout callback. */
346 gdb_os_flush_stdout (host_callback *p)
348 gdb_flush (gdb_stdtarg);
351 /* GDB version of os_write_stderr callback. */
354 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
359 for (i = 0; i < len; i++)
363 fputs_unfiltered (b, gdb_stdtargerr);
368 /* GDB version of os_flush_stderr callback. */
371 gdb_os_flush_stderr (host_callback *p)
373 gdb_flush (gdb_stdtargerr);
376 /* GDB version of printf_filtered callback. */
379 gdb_os_printf_filtered (host_callback * p, const char *format,...)
383 va_start (args, format);
384 vfprintf_filtered (gdb_stdout, format, args);
388 /* GDB version of error vprintf_filtered. */
391 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
393 vfprintf_filtered (gdb_stdout, format, ap);
396 /* GDB version of error evprintf_filtered. */
399 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
401 vfprintf_filtered (gdb_stderr, format, ap);
404 /* GDB version of error callback. */
407 gdb_os_error (host_callback * p, const char *format, ...)
411 va_start (args, format);
412 verror (format, args);
417 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
419 /* Only makes sense to supply raw registers. */
420 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
425 gdbsim_fetch_register (struct target_ops *ops,
426 struct regcache *regcache, int regno)
428 struct gdbarch *gdbarch = get_regcache_arch (regcache);
429 struct sim_inferior_data *sim_data
430 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
434 for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
435 gdbsim_fetch_register (ops, regcache, regno);
439 switch (gdbarch_register_sim_regno (gdbarch, regno))
441 case LEGACY_SIM_REGNO_IGNORE:
443 case SIM_REGNO_DOES_NOT_EXIST:
445 /* For moment treat a `does not exist' register the same way
446 as an ``unavailable'' register. */
447 gdb_byte buf[MAX_REGISTER_SIZE];
450 memset (buf, 0, MAX_REGISTER_SIZE);
451 regcache_raw_supply (regcache, regno, buf);
457 static int warn_user = 1;
458 gdb_byte buf[MAX_REGISTER_SIZE];
461 gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
462 memset (buf, 0, MAX_REGISTER_SIZE);
463 nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
464 gdbarch_register_sim_regno
467 register_size (gdbarch, regno));
469 && nr_bytes != register_size (gdbarch, regno) && warn_user)
471 fprintf_unfiltered (gdb_stderr,
472 "Size of register %s (%d/%d) "
473 "incorrect (%d instead of %d))",
474 gdbarch_register_name (gdbarch, regno),
476 gdbarch_register_sim_regno
478 nr_bytes, register_size (gdbarch, regno));
481 /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
482 indicating that GDB and the SIM have different ideas about
483 which registers are fetchable. */
484 /* Else if (nr_bytes < 0): an old simulator, that doesn't
485 think to return the register size. Just assume all is ok. */
486 regcache_raw_supply (regcache, regno, buf);
489 printf_filtered ("gdbsim_fetch_register: %d", regno);
490 /* FIXME: We could print something more intelligible. */
491 dump_mem (buf, register_size (gdbarch, regno));
500 gdbsim_store_register (struct target_ops *ops,
501 struct regcache *regcache, int regno)
503 struct gdbarch *gdbarch = get_regcache_arch (regcache);
504 struct sim_inferior_data *sim_data
505 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
509 for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
510 gdbsim_store_register (ops, regcache, regno);
513 else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
515 gdb_byte tmp[MAX_REGISTER_SIZE];
518 regcache_cooked_read (regcache, regno, tmp);
519 nr_bytes = sim_store_register (sim_data->gdbsim_desc,
520 gdbarch_register_sim_regno
522 tmp, register_size (gdbarch, regno));
523 if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
524 internal_error (__FILE__, __LINE__,
525 _("Register size different to expected"));
527 internal_error (__FILE__, __LINE__,
528 _("Register %d not updated"), regno);
530 warning (_("Register %s not updated"),
531 gdbarch_register_name (gdbarch, regno));
535 printf_filtered ("gdbsim_store_register: %d", regno);
536 /* FIXME: We could print something more intelligible. */
537 dump_mem (tmp, register_size (gdbarch, regno));
542 /* Kill the running program. This may involve closing any open files
543 and releasing other resources acquired by the simulated program. */
546 gdbsim_kill (struct target_ops *ops)
549 printf_filtered ("gdbsim_kill\n");
551 /* There is no need to `kill' running simulator - the simulator is
552 not running. Mourning it is enough. */
553 target_mourn_inferior ();
556 /* Load an executable file into the target process. This is expected to
557 not only bring new code into the target process, but also to update
558 GDB's symbol tables to match. */
561 gdbsim_load (char *args, int fromtty)
565 struct sim_inferior_data *sim_data
566 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
569 error_no_arg (_("program to load"));
571 argv = gdb_buildargv (args);
572 make_cleanup_freeargv (argv);
574 prog = tilde_expand (argv[0]);
577 error (_("GDB sim does not yet support a load offset."));
580 printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
582 /* FIXME: We will print two messages on error.
583 Need error to either not print anything if passed NULL or need
584 another routine that doesn't take any arguments. */
585 if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
586 error (_("unable to load program"));
588 /* FIXME: If a load command should reset the targets registers then
589 a call to sim_create_inferior() should go here. */
591 sim_data->program_loaded = 1;
595 /* Start an inferior process and set inferior_ptid to its pid.
596 EXEC_FILE is the file to run.
597 ARGS is a string containing the arguments to the program.
598 ENV is the environment vector to pass. Errors reported with error().
599 On VxWorks and various standalone systems, we ignore exec_file. */
600 /* This is called not only when we first attach, but also when the
601 user types "run" after having attached. */
604 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
605 char **env, int from_tty)
607 struct sim_inferior_data *sim_data
608 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
610 char *arg_buf, **argv;
612 if (exec_file == 0 || exec_bfd == 0)
613 warning (_("No executable file specified."));
614 if (!sim_data->program_loaded)
615 warning (_("No program loaded."));
618 printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
619 (exec_file ? exec_file : "(NULL)"),
622 if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
623 gdbsim_kill (target);
624 remove_breakpoints ();
625 init_wait_for_inferior ();
627 if (exec_file != NULL)
629 len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
630 arg_buf = (char *) alloca (len);
632 strcat (arg_buf, exec_file);
633 strcat (arg_buf, " ");
634 strcat (arg_buf, args);
635 argv = gdb_buildargv (arg_buf);
636 make_cleanup_freeargv (argv);
641 if (!have_inferiors ())
644 if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
646 error (_("Unable to create sim inferior."));
648 inferior_ptid = sim_data->remote_sim_ptid;
649 inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
650 add_thread_silent (inferior_ptid);
652 insert_breakpoints (); /* Needed to get correct instruction
655 clear_proceed_status ();
658 /* The open routine takes the rest of the parameters from the command,
659 and (if successful) pushes a new target onto the stack.
660 Targets should supply this routine, if only to provide an error message. */
661 /* Called when selecting the simulator. E.g. (gdb) target sim name. */
664 gdbsim_open (char *args, int from_tty)
668 struct sim_inferior_data *sim_data;
669 SIM_DESC gdbsim_desc;
672 printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
674 /* Ensure that the sim target is not on the target stack. This is
675 necessary, because if it is on the target stack, the call to
676 push_target below will invoke sim_close(), thus freeing various
677 state (including a sim instance) that we allocate prior to
678 invoking push_target(). We want to delay the push_target()
679 operation until after we complete those operations which could
682 unpush_target (&gdbsim_ops);
684 len = (7 + 1 /* gdbsim */
685 + strlen (" -E little")
686 + strlen (" --architecture=xxxxxxxxxx")
687 + strlen (" --sysroot=") + strlen (gdb_sysroot) +
688 + (args ? strlen (args) : 0)
690 arg_buf = (char *) alloca (len);
691 strcpy (arg_buf, "gdbsim"); /* 7 */
692 /* Specify the byte order for the target when it is explicitly
693 specified by the user (not auto detected). */
694 switch (selected_byte_order ())
697 strcat (arg_buf, " -E big");
699 case BFD_ENDIAN_LITTLE:
700 strcat (arg_buf, " -E little");
702 case BFD_ENDIAN_UNKNOWN:
705 /* Specify the architecture of the target when it has been
706 explicitly specified */
707 if (selected_architecture_name () != NULL)
709 strcat (arg_buf, " --architecture=");
710 strcat (arg_buf, selected_architecture_name ());
712 /* Pass along gdb's concept of the sysroot. */
713 strcat (arg_buf, " --sysroot=");
714 strcat (arg_buf, gdb_sysroot);
715 /* finally, any explicit args */
718 strcat (arg_buf, " "); /* 1 */
719 strcat (arg_buf, args);
721 sim_argv = gdb_buildargv (arg_buf);
724 gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
726 if (gdbsim_desc == 0)
730 error (_("unable to create simulator instance"));
733 /* Reset the pid numberings for this batch of sim instances. */
734 next_pid = INITIAL_PID;
736 /* Allocate the inferior data, but do not allocate a sim instance
737 since we've already just done that. */
738 sim_data = get_sim_inferior_data (current_inferior (),
739 SIM_INSTANCE_NOT_NEEDED);
741 sim_data->gdbsim_desc = gdbsim_desc;
743 push_target (&gdbsim_ops);
744 printf_filtered ("Connected to the simulator.\n");
746 /* There's nothing running after "target sim" or "load"; not until
748 inferior_ptid = null_ptid;
753 /* Callback for iterate_over_inferiors. Called (indirectly) by
757 gdbsim_close_inferior (struct inferior *inf, void *arg)
759 struct sim_inferior_data *sim_data = inferior_data (inf,
760 sim_inferior_data_key);
761 if (sim_data != NULL)
763 ptid_t ptid = sim_data->remote_sim_ptid;
765 sim_inferior_data_cleanup (inf, sim_data);
766 set_inferior_data (inf, sim_inferior_data_key, NULL);
768 /* Having a ptid allocated and stored in remote_sim_ptid does
769 not mean that a corresponding inferior was ever created.
770 Thus we need to verify the existence of an inferior using the
771 pid in question before setting inferior_ptid via
772 switch_to_thread() or mourning the inferior. */
773 if (find_inferior_pid (ptid_get_pid (ptid)) != NULL)
775 switch_to_thread (ptid);
776 generic_mourn_inferior ();
783 /* Close out all files and local state before this target loses control. */
788 struct sim_inferior_data *sim_data
789 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
792 printf_filtered ("gdbsim_close\n");
794 iterate_over_inferiors (gdbsim_close_inferior, NULL);
796 if (sim_argv != NULL)
807 /* Takes a program previously attached to and detaches it.
808 The program may resume execution (some targets do, some don't) and will
809 no longer stop on signals, etc. We better not have left any breakpoints
810 in the program or it'll die when it hits one. ARGS is arguments
811 typed by the user (e.g. a signal to send the process). FROM_TTY
812 says whether to be verbose or not. */
813 /* Terminate the open connection to the remote debugger.
814 Use this when you want to detach and do something else with your gdb. */
817 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
820 printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
822 unpush_target (ops); /* calls gdbsim_close to do the real work */
824 printf_filtered ("Ending simulator %s debugging\n", target_shortname);
827 /* Resume execution of the target process. STEP says whether to single-step
828 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
829 to the target, or zero for no signal. */
833 enum gdb_signal siggnal;
838 gdbsim_resume_inferior (struct inferior *inf, void *arg)
840 struct sim_inferior_data *sim_data
841 = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
842 struct resume_data *rd = arg;
846 sim_data->resume_siggnal = rd->siggnal;
847 sim_data->resume_step = rd->step;
850 printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
851 inf->pid, rd->step, rd->siggnal);
854 /* When called from iterate_over_inferiors, a zero return causes the
855 iteration process to proceed until there are no more inferiors to
861 gdbsim_resume (struct target_ops *ops,
862 ptid_t ptid, int step, enum gdb_signal siggnal)
864 struct resume_data rd;
865 struct sim_inferior_data *sim_data
866 = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
868 rd.siggnal = siggnal;
871 /* We don't access any sim_data members within this function.
872 What's of interest is whether or not the call to
873 get_sim_inferior_data_by_ptid(), above, is able to obtain a
874 non-NULL pointer. If it managed to obtain a non-NULL pointer, we
875 know we have a single inferior to consider. If it's NULL, we
876 either have multiple inferiors to resume or an error condition. */
879 gdbsim_resume_inferior (find_inferior_pid (ptid_get_pid (ptid)), &rd);
880 else if (ptid_equal (ptid, minus_one_ptid))
881 iterate_over_inferiors (gdbsim_resume_inferior, &rd);
883 error (_("The program is not being run."));
886 /* Notify the simulator of an asynchronous request to stop.
888 The simulator shall ensure that the stop request is eventually
889 delivered to the simulator. If the call is made while the
890 simulator is not running then the stop request is processed when
891 the simulator is next resumed.
893 For simulators that do not support this operation, just abort. */
896 gdbsim_stop_inferior (struct inferior *inf, void *arg)
898 struct sim_inferior_data *sim_data
899 = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
903 if (!sim_stop (sim_data->gdbsim_desc))
909 /* When called from iterate_over_inferiors, a zero return causes the
910 iteration process to proceed until there are no more inferiors to
916 gdbsim_stop (ptid_t ptid)
918 struct sim_inferior_data *sim_data;
920 if (ptid_equal (ptid, minus_one_ptid))
922 iterate_over_inferiors (gdbsim_stop_inferior, NULL);
926 struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid));
929 error (_("Can't stop pid %d. No inferior found."),
930 ptid_get_pid (ptid));
932 gdbsim_stop_inferior (inf, NULL);
936 /* GDB version of os_poll_quit callback.
937 Taken from gdb/util.c - should be in a library. */
940 gdb_os_poll_quit (host_callback *p)
942 if (deprecated_ui_loop_hook != NULL)
943 deprecated_ui_loop_hook (0);
945 if (check_quit_flag ()) /* gdb's idea of quit */
947 clear_quit_flag (); /* we've stolen it */
953 /* Wait for inferior process to do something. Return pid of child,
954 or -1 in case of error; store status through argument pointer STATUS,
955 just as `wait' would. */
958 gdbsim_cntrl_c (int signo)
960 gdbsim_stop (minus_one_ptid);
964 gdbsim_wait (struct target_ops *ops,
965 ptid_t ptid, struct target_waitstatus *status, int options)
967 struct sim_inferior_data *sim_data;
968 static RETSIGTYPE (*prev_sigint) ();
970 enum sim_stop reason = sim_running;
972 /* This target isn't able to (yet) resume more than one inferior at a time.
973 When ptid is minus_one_ptid, just use the current inferior. If we're
974 given an explicit pid, we'll try to find it and use that instead. */
975 if (ptid_equal (ptid, minus_one_ptid))
976 sim_data = get_sim_inferior_data (current_inferior (),
977 SIM_INSTANCE_NEEDED);
980 sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
981 if (sim_data == NULL)
982 error (_("Unable to wait for pid %d. Inferior not found."),
983 ptid_get_pid (ptid));
984 inferior_ptid = ptid;
988 printf_filtered ("gdbsim_wait\n");
990 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
992 struct sigaction sa, osa;
993 sa.sa_handler = gdbsim_cntrl_c;
994 sigemptyset (&sa.sa_mask);
996 sigaction (SIGINT, &sa, &osa);
997 prev_sigint = osa.sa_handler;
1000 prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1002 sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
1003 sim_data->resume_siggnal);
1005 signal (SIGINT, prev_sigint);
1006 sim_data->resume_step = 0;
1008 sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
1013 status->kind = TARGET_WAITKIND_EXITED;
1014 status->value.integer = sigrc;
1019 case GDB_SIGNAL_ABRT:
1022 case GDB_SIGNAL_INT:
1023 case GDB_SIGNAL_TRAP:
1025 status->kind = TARGET_WAITKIND_STOPPED;
1026 status->value.sig = sigrc;
1031 status->kind = TARGET_WAITKIND_SIGNALLED;
1032 status->value.sig = sigrc;
1036 /* FIXME: Is this correct? */
1040 return inferior_ptid;
1043 /* Get ready to modify the registers array. On machines which store
1044 individual registers, this doesn't need to do anything. On machines
1045 which store all the registers in one fell swoop, this makes sure
1046 that registers contains all the registers from the program being
1050 gdbsim_prepare_to_store (struct regcache *regcache)
1052 /* Do nothing, since we can store individual regs. */
1055 /* Helper for gdbsim_xfer_partial that handles memory transfers.
1056 Arguments are like target_xfer_partial. */
1059 gdbsim_xfer_memory (struct target_ops *target,
1060 gdb_byte *readbuf, const gdb_byte *writebuf,
1061 ULONGEST memaddr, LONGEST len)
1063 struct sim_inferior_data *sim_data
1064 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1066 /* If this target doesn't have memory yet, return 0 causing the
1067 request to be passed to a lower target, hopefully an exec
1069 if (!target->to_has_memory (target))
1072 if (!sim_data->program_loaded)
1073 error (_("No program loaded."));
1075 /* Note that we obtained the sim_data pointer above using
1076 SIM_INSTANCE_NOT_NEEDED. We do this so that we don't needlessly
1077 allocate a sim instance prior to loading a program. If we
1078 get to this point in the code though, gdbsim_desc should be
1079 non-NULL. (Note that a sim instance is needed in order to load
1081 gdb_assert (sim_data->gdbsim_desc != NULL);
1084 fprintf_unfiltered (gdb_stdlog,
1085 "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1086 "memaddr %s, len %s\n",
1087 host_address_to_string (readbuf),
1088 host_address_to_string (writebuf),
1089 paddress (target_gdbarch (), memaddr),
1094 if (remote_debug && len > 0)
1095 dump_mem (writebuf, len);
1096 len = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);
1100 len = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
1101 if (remote_debug && len > 0)
1102 dump_mem (readbuf, len);
1107 /* Target to_xfer_partial implementation. */
1110 gdbsim_xfer_partial (struct target_ops *ops, enum target_object object,
1111 const char *annex, gdb_byte *readbuf,
1112 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
1116 case TARGET_OBJECT_MEMORY:
1117 return gdbsim_xfer_memory (ops, readbuf, writebuf, offset, len);
1125 gdbsim_files_info (struct target_ops *target)
1127 struct sim_inferior_data *sim_data
1128 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1129 const char *file = "nothing";
1132 file = bfd_get_filename (exec_bfd);
1135 printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
1139 printf_filtered ("\tAttached to %s running program %s\n",
1140 target_shortname, file);
1141 sim_info (sim_data->gdbsim_desc, 0);
1145 /* Clear the simulator's notion of what the break points are. */
1148 gdbsim_mourn_inferior (struct target_ops *target)
1150 struct sim_inferior_data *sim_data
1151 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1154 printf_filtered ("gdbsim_mourn_inferior:\n");
1156 remove_breakpoints ();
1157 generic_mourn_inferior ();
1158 delete_thread_silent (sim_data->remote_sim_ptid);
1161 /* Pass the command argument through to the simulator verbatim. The
1162 simulator must do any command interpretation work. */
1165 simulator_command (char *args, int from_tty)
1167 struct sim_inferior_data *sim_data;
1169 /* We use inferior_data() instead of get_sim_inferior_data() here in
1170 order to avoid attaching a sim_inferior_data struct to an
1171 inferior unnecessarily. The reason we take such care here is due
1172 to the fact that this function, simulator_command(), may be called
1173 even when the sim target is not active. If we were to use
1174 get_sim_inferior_data() here, it is possible that this call would
1175 be made either prior to gdbsim_open() or after gdbsim_close(),
1176 thus allocating memory that would not be garbage collected until
1177 the ultimate destruction of the associated inferior. */
1179 sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1180 if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1183 /* PREVIOUSLY: The user may give a command before the simulator
1184 is opened. [...] (??? assuming of course one wishes to
1185 continue to allow commands to be sent to unopened simulators,
1186 which isn't entirely unreasonable). */
1188 /* The simulator is a builtin abstraction of a remote target.
1189 Consistent with that model, access to the simulator, via sim
1190 commands, is restricted to the period when the channel to the
1191 simulator is open. */
1193 error (_("Not connected to the simulator target"));
1196 sim_do_command (sim_data->gdbsim_desc, args);
1198 /* Invalidate the register cache, in case the simulator command does
1200 registers_changed ();
1203 static VEC (char_ptr) *
1204 sim_command_completer (struct cmd_list_element *ignore, const char *text,
1207 struct sim_inferior_data *sim_data;
1210 VEC (char_ptr) *result = NULL;
1212 sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
1213 if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1216 tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
1220 /* Transform the array into a VEC, and then free the array. */
1221 for (i = 0; tmp[i] != NULL; i++)
1222 VEC_safe_push (char_ptr, result, tmp[i]);
1228 /* Check to see if a thread is still alive. */
1231 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
1233 struct sim_inferior_data *sim_data
1234 = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1236 if (sim_data == NULL)
1239 if (ptid_equal (ptid, sim_data->remote_sim_ptid))
1240 /* The simulators' task is always alive. */
1246 /* Convert a thread ID to a string. Returns the string in a static
1250 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
1252 return normal_pid_to_str (ptid);
1255 /* Simulator memory may be accessed after the program has been loaded. */
1258 gdbsim_has_all_memory (struct target_ops *ops)
1260 struct sim_inferior_data *sim_data
1261 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1263 if (!sim_data->program_loaded)
1270 gdbsim_has_memory (struct target_ops *ops)
1272 struct sim_inferior_data *sim_data
1273 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1275 if (!sim_data->program_loaded)
1281 /* Define the target subroutine names. */
1283 struct target_ops gdbsim_ops;
1286 init_gdbsim_ops (void)
1288 gdbsim_ops.to_shortname = "sim";
1289 gdbsim_ops.to_longname = "simulator";
1290 gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1291 gdbsim_ops.to_open = gdbsim_open;
1292 gdbsim_ops.to_close = gdbsim_close;
1293 gdbsim_ops.to_detach = gdbsim_detach;
1294 gdbsim_ops.to_resume = gdbsim_resume;
1295 gdbsim_ops.to_wait = gdbsim_wait;
1296 gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1297 gdbsim_ops.to_store_registers = gdbsim_store_register;
1298 gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
1299 gdbsim_ops.to_xfer_partial = gdbsim_xfer_partial;
1300 gdbsim_ops.to_files_info = gdbsim_files_info;
1301 gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1302 gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
1303 gdbsim_ops.to_kill = gdbsim_kill;
1304 gdbsim_ops.to_load = gdbsim_load;
1305 gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
1306 gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
1307 gdbsim_ops.to_stop = gdbsim_stop;
1308 gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1309 gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
1310 gdbsim_ops.to_stratum = process_stratum;
1311 gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1312 gdbsim_ops.to_has_memory = gdbsim_has_memory;
1313 gdbsim_ops.to_has_stack = default_child_has_stack;
1314 gdbsim_ops.to_has_registers = default_child_has_registers;
1315 gdbsim_ops.to_has_execution = default_child_has_execution;
1316 gdbsim_ops.to_magic = OPS_MAGIC;
1320 _initialize_remote_sim (void)
1322 struct cmd_list_element *c;
1325 add_target (&gdbsim_ops);
1327 c = add_com ("sim", class_obscure, simulator_command,
1328 _("Send a command to the simulator."));
1329 set_cmd_completer (c, sim_command_completer);
1331 sim_inferior_data_key
1332 = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);