1 /* Generic remote debugging interface for simulators.
3 Copyright (C) 1993-2017 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/>. */
35 #include "gdb/callback.h"
36 #include "gdb/remote-sim.h"
39 #include "sim-regno.h"
40 #include "arch-utils.h"
41 #include "readline/readline.h"
42 #include "gdbthread.h"
46 extern void _initialize_remote_sim (void);
48 static void init_callbacks (void);
50 static void end_callbacks (void);
52 static int gdb_os_write_stdout (host_callback
*, const char *, int);
54 static void gdb_os_flush_stdout (host_callback
*);
56 static int gdb_os_write_stderr (host_callback
*, const char *, int);
58 static void gdb_os_flush_stderr (host_callback
*);
60 static int gdb_os_poll_quit (host_callback
*);
62 /* printf_filtered is depreciated. */
63 static void gdb_os_printf_filtered (host_callback
*, const char *, ...);
65 static void gdb_os_vprintf_filtered (host_callback
*, const char *, va_list);
67 static void gdb_os_evprintf_filtered (host_callback
*, const char *, va_list);
69 static void gdb_os_error (host_callback
*, const char *, ...)
72 static void gdbsim_kill (struct target_ops
*);
74 static void gdbsim_load (struct target_ops
*self
, const char *prog
,
77 static void gdbsim_open (const char *args
, int from_tty
);
79 static void gdbsim_close (struct target_ops
*self
);
81 static void gdbsim_detach (struct target_ops
*ops
, const char *args
,
84 static void gdbsim_prepare_to_store (struct target_ops
*self
,
85 struct regcache
*regcache
);
87 static void gdbsim_files_info (struct target_ops
*target
);
89 static void gdbsim_mourn_inferior (struct target_ops
*target
);
91 static void gdbsim_interrupt (struct target_ops
*self
, ptid_t ptid
);
93 void simulator_command (char *args
, int from_tty
);
97 sim_* are the interface to the simulator (see remote-sim.h).
98 gdbsim_* are stuff which is internal to gdb. */
100 /* Forward data declarations */
101 extern struct target_ops gdbsim_ops
;
103 static const struct inferior_data
*sim_inferior_data_key
;
105 /* Simulator-specific, per-inferior state. */
106 struct sim_inferior_data
{
107 /* Flag which indicates whether or not the program has been loaded. */
110 /* Simulator descriptor for this inferior. */
111 SIM_DESC gdbsim_desc
;
113 /* This is the ptid we use for this particular simulator instance. Its
114 value is somewhat arbitrary, as the simulator target don't have a
115 notion of tasks or threads, but we need something non-null to place
116 in inferior_ptid. For simulators which permit multiple instances,
117 we also need a unique identifier to use for each inferior. */
118 ptid_t remote_sim_ptid
;
120 /* Signal with which to resume. */
121 enum gdb_signal resume_siggnal
;
123 /* Flag which indicates whether resume should step or not. */
127 /* Flag indicating the "open" status of this module. It's set to 1
128 in gdbsim_open() and 0 in gdbsim_close(). */
129 static int gdbsim_is_open
= 0;
131 /* Value of the next pid to allocate for an inferior. As indicated
132 elsewhere, its initial value is somewhat arbitrary; it's critical
133 though that it's not zero or negative. */
135 #define INITIAL_PID 42000
137 /* Argument list to pass to sim_open(). It is allocated in gdbsim_open()
138 and deallocated in gdbsim_close(). The lifetime needs to extend beyond
139 the call to gdbsim_open() due to the fact that other sim instances other
140 than the first will be allocated after the gdbsim_open() call. */
141 static char **sim_argv
= NULL
;
143 /* OS-level callback functions for write, flush, etc. */
144 static host_callback gdb_callback
;
145 static int callbacks_initialized
= 0;
147 /* Callback for iterate_over_inferiors. It checks to see if the sim
148 descriptor passed via ARG is the same as that for the inferior
149 designated by INF. Return true if so; false otherwise. */
152 check_for_duplicate_sim_descriptor (struct inferior
*inf
, void *arg
)
154 struct sim_inferior_data
*sim_data
;
155 SIM_DESC new_sim_desc
= (SIM_DESC
) arg
;
157 sim_data
= ((struct sim_inferior_data
*)
158 inferior_data (inf
, sim_inferior_data_key
));
160 return (sim_data
!= NULL
&& sim_data
->gdbsim_desc
== new_sim_desc
);
163 /* Flags indicating whether or not a sim instance is needed. One of these
164 flags should be passed to get_sim_inferior_data(). */
166 enum {SIM_INSTANCE_NOT_NEEDED
= 0, SIM_INSTANCE_NEEDED
= 1};
168 /* Obtain pointer to per-inferior simulator data, allocating it if necessary.
169 Attempt to open the sim if SIM_INSTANCE_NEEDED is true. */
171 static struct sim_inferior_data
*
172 get_sim_inferior_data (struct inferior
*inf
, int sim_instance_needed
)
174 SIM_DESC sim_desc
= NULL
;
175 struct sim_inferior_data
*sim_data
176 = (struct sim_inferior_data
*) inferior_data (inf
, sim_inferior_data_key
);
178 /* Try to allocate a new sim instance, if needed. We do this ahead of
179 a potential allocation of a sim_inferior_data struct in order to
180 avoid needlessly allocating that struct in the event that the sim
181 instance allocation fails. */
182 if (sim_instance_needed
== SIM_INSTANCE_NEEDED
183 && (sim_data
== NULL
|| sim_data
->gdbsim_desc
== NULL
))
185 struct inferior
*idup
;
186 sim_desc
= sim_open (SIM_OPEN_DEBUG
, &gdb_callback
, exec_bfd
, sim_argv
);
187 if (sim_desc
== NULL
)
188 error (_("Unable to create simulator instance for inferior %d."),
191 idup
= iterate_over_inferiors (check_for_duplicate_sim_descriptor
,
195 /* We don't close the descriptor due to the fact that it's
196 shared with some other inferior. If we were to close it,
197 that might needlessly muck up the other inferior. Of
198 course, it's possible that the damage has already been
199 done... Note that it *will* ultimately be closed during
200 cleanup of the other inferior. */
203 _("Inferior %d and inferior %d would have identical simulator state.\n"
204 "(This simulator does not support the running of more than one inferior.)"),
205 inf
->num
, idup
->num
);
209 if (sim_data
== NULL
)
211 sim_data
= XCNEW(struct sim_inferior_data
);
212 set_inferior_data (inf
, sim_inferior_data_key
, sim_data
);
214 /* Allocate a ptid for this inferior. */
215 sim_data
->remote_sim_ptid
= ptid_build (next_pid
, 0, next_pid
);
218 /* Initialize the other instance variables. */
219 sim_data
->program_loaded
= 0;
220 sim_data
->gdbsim_desc
= sim_desc
;
221 sim_data
->resume_siggnal
= GDB_SIGNAL_0
;
222 sim_data
->resume_step
= 0;
226 /* This handles the case where sim_data was allocated prior to
227 needing a sim instance. */
228 sim_data
->gdbsim_desc
= sim_desc
;
235 /* Return pointer to per-inferior simulator data using PTID to find the
236 inferior in question. Return NULL when no inferior is found or
237 when ptid has a zero or negative pid component. */
239 static struct sim_inferior_data
*
240 get_sim_inferior_data_by_ptid (ptid_t ptid
, int sim_instance_needed
)
242 struct inferior
*inf
;
243 int pid
= ptid_get_pid (ptid
);
248 inf
= find_inferior_pid (pid
);
251 return get_sim_inferior_data (inf
, sim_instance_needed
);
256 /* Free the per-inferior simulator data. */
259 sim_inferior_data_cleanup (struct inferior
*inf
, void *data
)
261 struct sim_inferior_data
*sim_data
= (struct sim_inferior_data
*) data
;
263 if (sim_data
!= NULL
)
265 if (sim_data
->gdbsim_desc
)
267 sim_close (sim_data
->gdbsim_desc
, 0);
268 sim_data
->gdbsim_desc
= NULL
;
275 dump_mem (const gdb_byte
*buf
, int len
)
277 fputs_unfiltered ("\t", gdb_stdlog
);
279 if (len
== 8 || len
== 4)
283 memcpy (l
, buf
, len
);
284 fprintf_unfiltered (gdb_stdlog
, "0x%08x", l
[0]);
286 fprintf_unfiltered (gdb_stdlog
, " 0x%08x", l
[1]);
292 for (i
= 0; i
< len
; i
++)
293 fprintf_unfiltered (gdb_stdlog
, "0x%02x ", buf
[i
]);
296 fputs_unfiltered ("\n", gdb_stdlog
);
299 /* Initialize gdb_callback. */
302 init_callbacks (void)
304 if (!callbacks_initialized
)
306 gdb_callback
= default_callback
;
307 gdb_callback
.init (&gdb_callback
);
308 gdb_callback
.write_stdout
= gdb_os_write_stdout
;
309 gdb_callback
.flush_stdout
= gdb_os_flush_stdout
;
310 gdb_callback
.write_stderr
= gdb_os_write_stderr
;
311 gdb_callback
.flush_stderr
= gdb_os_flush_stderr
;
312 gdb_callback
.printf_filtered
= gdb_os_printf_filtered
;
313 gdb_callback
.vprintf_filtered
= gdb_os_vprintf_filtered
;
314 gdb_callback
.evprintf_filtered
= gdb_os_evprintf_filtered
;
315 gdb_callback
.error
= gdb_os_error
;
316 gdb_callback
.poll_quit
= gdb_os_poll_quit
;
317 gdb_callback
.magic
= HOST_CALLBACK_MAGIC
;
318 callbacks_initialized
= 1;
322 /* Release callbacks (free resources used by them). */
327 if (callbacks_initialized
)
329 gdb_callback
.shutdown (&gdb_callback
);
330 callbacks_initialized
= 0;
334 /* GDB version of os_write_stdout callback. */
337 gdb_os_write_stdout (host_callback
*p
, const char *buf
, int len
)
342 ui_file_write (gdb_stdtarg
, buf
, len
);
346 /* GDB version of os_flush_stdout callback. */
349 gdb_os_flush_stdout (host_callback
*p
)
351 gdb_flush (gdb_stdtarg
);
354 /* GDB version of os_write_stderr callback. */
357 gdb_os_write_stderr (host_callback
*p
, const char *buf
, int len
)
362 for (i
= 0; i
< len
; i
++)
366 fputs_unfiltered (b
, gdb_stdtargerr
);
371 /* GDB version of os_flush_stderr callback. */
374 gdb_os_flush_stderr (host_callback
*p
)
376 gdb_flush (gdb_stdtargerr
);
379 /* GDB version of printf_filtered callback. */
382 gdb_os_printf_filtered (host_callback
* p
, const char *format
,...)
386 va_start (args
, format
);
387 vfprintf_filtered (gdb_stdout
, format
, args
);
391 /* GDB version of error vprintf_filtered. */
394 gdb_os_vprintf_filtered (host_callback
* p
, const char *format
, va_list ap
)
396 vfprintf_filtered (gdb_stdout
, format
, ap
);
399 /* GDB version of error evprintf_filtered. */
402 gdb_os_evprintf_filtered (host_callback
* p
, const char *format
, va_list ap
)
404 vfprintf_filtered (gdb_stderr
, format
, ap
);
407 /* GDB version of error callback. */
410 gdb_os_error (host_callback
* p
, const char *format
, ...)
414 va_start (args
, format
);
415 verror (format
, args
);
420 one2one_register_sim_regno (struct gdbarch
*gdbarch
, int regnum
)
422 /* Only makes sense to supply raw registers. */
423 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
));
428 gdbsim_fetch_register (struct target_ops
*ops
,
429 struct regcache
*regcache
, int regno
)
431 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
432 struct inferior
*inf
= find_inferior_ptid (regcache_get_ptid (regcache
));
433 struct sim_inferior_data
*sim_data
434 = get_sim_inferior_data (inf
, SIM_INSTANCE_NEEDED
);
438 for (regno
= 0; regno
< gdbarch_num_regs (gdbarch
); regno
++)
439 gdbsim_fetch_register (ops
, regcache
, regno
);
443 switch (gdbarch_register_sim_regno (gdbarch
, regno
))
445 case LEGACY_SIM_REGNO_IGNORE
:
447 case SIM_REGNO_DOES_NOT_EXIST
:
449 /* For moment treat a `does not exist' register the same way
450 as an ``unavailable'' register. */
451 gdb_byte buf
[MAX_REGISTER_SIZE
];
454 memset (buf
, 0, MAX_REGISTER_SIZE
);
455 regcache_raw_supply (regcache
, regno
, buf
);
461 static int warn_user
= 1;
462 gdb_byte buf
[MAX_REGISTER_SIZE
];
465 gdb_assert (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
));
466 memset (buf
, 0, MAX_REGISTER_SIZE
);
467 nr_bytes
= sim_fetch_register (sim_data
->gdbsim_desc
,
468 gdbarch_register_sim_regno
471 register_size (gdbarch
, regno
));
473 && nr_bytes
!= register_size (gdbarch
, regno
) && warn_user
)
475 fprintf_unfiltered (gdb_stderr
,
476 "Size of register %s (%d/%d) "
477 "incorrect (%d instead of %d))",
478 gdbarch_register_name (gdbarch
, regno
),
480 gdbarch_register_sim_regno
482 nr_bytes
, register_size (gdbarch
, regno
));
485 /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
486 indicating that GDB and the SIM have different ideas about
487 which registers are fetchable. */
488 /* Else if (nr_bytes < 0): an old simulator, that doesn't
489 think to return the register size. Just assume all is ok. */
490 regcache_raw_supply (regcache
, regno
, buf
);
493 fprintf_unfiltered (gdb_stdlog
,
494 "gdbsim_fetch_register: %d", regno
);
495 /* FIXME: We could print something more intelligible. */
496 dump_mem (buf
, register_size (gdbarch
, regno
));
505 gdbsim_store_register (struct target_ops
*ops
,
506 struct regcache
*regcache
, int regno
)
508 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
509 struct inferior
*inf
= find_inferior_ptid (regcache_get_ptid (regcache
));
510 struct sim_inferior_data
*sim_data
511 = get_sim_inferior_data (inf
, SIM_INSTANCE_NEEDED
);
515 for (regno
= 0; regno
< gdbarch_num_regs (gdbarch
); regno
++)
516 gdbsim_store_register (ops
, regcache
, regno
);
519 else if (gdbarch_register_sim_regno (gdbarch
, regno
) >= 0)
521 gdb_byte tmp
[MAX_REGISTER_SIZE
];
524 regcache_cooked_read (regcache
, regno
, tmp
);
525 nr_bytes
= sim_store_register (sim_data
->gdbsim_desc
,
526 gdbarch_register_sim_regno
528 tmp
, register_size (gdbarch
, regno
));
529 if (nr_bytes
> 0 && nr_bytes
!= register_size (gdbarch
, regno
))
530 internal_error (__FILE__
, __LINE__
,
531 _("Register size different to expected"));
533 internal_error (__FILE__
, __LINE__
,
534 _("Register %d not updated"), regno
);
536 warning (_("Register %s not updated"),
537 gdbarch_register_name (gdbarch
, regno
));
541 fprintf_unfiltered (gdb_stdlog
, "gdbsim_store_register: %d", regno
);
542 /* FIXME: We could print something more intelligible. */
543 dump_mem (tmp
, register_size (gdbarch
, regno
));
548 /* Kill the running program. This may involve closing any open files
549 and releasing other resources acquired by the simulated program. */
552 gdbsim_kill (struct target_ops
*ops
)
555 fprintf_unfiltered (gdb_stdlog
, "gdbsim_kill\n");
557 /* There is no need to `kill' running simulator - the simulator is
558 not running. Mourning it is enough. */
559 target_mourn_inferior (inferior_ptid
);
562 /* Load an executable file into the target process. This is expected to
563 not only bring new code into the target process, but also to update
564 GDB's symbol tables to match. */
567 gdbsim_load (struct target_ops
*self
, const char *args
, int fromtty
)
571 struct sim_inferior_data
*sim_data
572 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED
);
575 error_no_arg (_("program to load"));
577 argv
= gdb_buildargv (args
);
578 make_cleanup_freeargv (argv
);
580 prog
= tilde_expand (argv
[0]);
583 error (_("GDB sim does not yet support a load offset."));
586 fprintf_unfiltered (gdb_stdlog
, "gdbsim_load: prog \"%s\"\n", prog
);
588 /* FIXME: We will print two messages on error.
589 Need error to either not print anything if passed NULL or need
590 another routine that doesn't take any arguments. */
591 if (sim_load (sim_data
->gdbsim_desc
, prog
, NULL
, fromtty
) == SIM_RC_FAIL
)
592 error (_("unable to load program"));
594 /* FIXME: If a load command should reset the targets registers then
595 a call to sim_create_inferior() should go here. */
597 sim_data
->program_loaded
= 1;
601 /* Start an inferior process and set inferior_ptid to its pid.
602 EXEC_FILE is the file to run.
603 ARGS is a string containing the arguments to the program.
604 ENV is the environment vector to pass. Errors reported with error().
605 On VxWorks and various standalone systems, we ignore exec_file. */
606 /* This is called not only when we first attach, but also when the
607 user types "run" after having attached. */
610 gdbsim_create_inferior (struct target_ops
*target
, char *exec_file
, char *args
,
611 char **env
, int from_tty
)
613 struct sim_inferior_data
*sim_data
614 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED
);
616 char *arg_buf
, **argv
;
618 if (exec_file
== 0 || exec_bfd
== 0)
619 warning (_("No executable file specified."));
620 if (!sim_data
->program_loaded
)
621 warning (_("No program loaded."));
624 fprintf_unfiltered (gdb_stdlog
,
625 "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
626 (exec_file
? exec_file
: "(NULL)"),
629 if (ptid_equal (inferior_ptid
, sim_data
->remote_sim_ptid
))
630 gdbsim_kill (target
);
631 remove_breakpoints ();
632 init_wait_for_inferior ();
634 if (exec_file
!= NULL
)
636 len
= strlen (exec_file
) + 1 + strlen (args
) + 1 + /*slop */ 10;
637 arg_buf
= (char *) alloca (len
);
639 strcat (arg_buf
, exec_file
);
640 strcat (arg_buf
, " ");
641 strcat (arg_buf
, args
);
642 argv
= gdb_buildargv (arg_buf
);
643 make_cleanup_freeargv (argv
);
648 if (!have_inferiors ())
651 if (sim_create_inferior (sim_data
->gdbsim_desc
, exec_bfd
, argv
, env
)
653 error (_("Unable to create sim inferior."));
655 inferior_ptid
= sim_data
->remote_sim_ptid
;
656 inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid
));
657 add_thread_silent (inferior_ptid
);
659 insert_breakpoints (); /* Needed to get correct instruction
662 clear_proceed_status (0);
665 /* The open routine takes the rest of the parameters from the command,
666 and (if successful) pushes a new target onto the stack.
667 Targets should supply this routine, if only to provide an error message. */
668 /* Called when selecting the simulator. E.g. (gdb) target sim name. */
671 gdbsim_open (const char *args
, int from_tty
)
675 struct sim_inferior_data
*sim_data
;
677 SIM_DESC gdbsim_desc
;
679 sysroot
= gdb_sysroot
;
680 if (is_target_filename (sysroot
))
681 sysroot
+= strlen (TARGET_SYSROOT_PREFIX
);
684 fprintf_unfiltered (gdb_stdlog
,
685 "gdbsim_open: args \"%s\"\n", args
? args
: "(null)");
687 /* Ensure that the sim target is not on the target stack. This is
688 necessary, because if it is on the target stack, the call to
689 push_target below will invoke sim_close(), thus freeing various
690 state (including a sim instance) that we allocate prior to
691 invoking push_target(). We want to delay the push_target()
692 operation until after we complete those operations which could
695 unpush_target (&gdbsim_ops
);
697 len
= (7 + 1 /* gdbsim */
698 + strlen (" -E little")
699 + strlen (" --architecture=xxxxxxxxxx")
700 + strlen (" --sysroot=") + strlen (sysroot
) +
701 + (args
? strlen (args
) : 0)
703 arg_buf
= (char *) alloca (len
);
704 strcpy (arg_buf
, "gdbsim"); /* 7 */
705 /* Specify the byte order for the target when it is explicitly
706 specified by the user (not auto detected). */
707 switch (selected_byte_order ())
710 strcat (arg_buf
, " -E big");
712 case BFD_ENDIAN_LITTLE
:
713 strcat (arg_buf
, " -E little");
715 case BFD_ENDIAN_UNKNOWN
:
718 /* Specify the architecture of the target when it has been
719 explicitly specified */
720 if (selected_architecture_name () != NULL
)
722 strcat (arg_buf
, " --architecture=");
723 strcat (arg_buf
, selected_architecture_name ());
725 /* Pass along gdb's concept of the sysroot. */
726 strcat (arg_buf
, " --sysroot=");
727 strcat (arg_buf
, sysroot
);
728 /* finally, any explicit args */
731 strcat (arg_buf
, " "); /* 1 */
732 strcat (arg_buf
, args
);
734 sim_argv
= gdb_buildargv (arg_buf
);
737 gdbsim_desc
= sim_open (SIM_OPEN_DEBUG
, &gdb_callback
, exec_bfd
, sim_argv
);
739 if (gdbsim_desc
== 0)
743 error (_("unable to create simulator instance"));
746 /* Reset the pid numberings for this batch of sim instances. */
747 next_pid
= INITIAL_PID
;
749 /* Allocate the inferior data, but do not allocate a sim instance
750 since we've already just done that. */
751 sim_data
= get_sim_inferior_data (current_inferior (),
752 SIM_INSTANCE_NOT_NEEDED
);
754 sim_data
->gdbsim_desc
= gdbsim_desc
;
756 push_target (&gdbsim_ops
);
757 printf_filtered ("Connected to the simulator.\n");
759 /* There's nothing running after "target sim" or "load"; not until
761 inferior_ptid
= null_ptid
;
766 /* Callback for iterate_over_inferiors. Called (indirectly) by
770 gdbsim_close_inferior (struct inferior
*inf
, void *arg
)
772 struct sim_inferior_data
*sim_data
773 = (struct sim_inferior_data
*) inferior_data (inf
, sim_inferior_data_key
);
774 if (sim_data
!= NULL
)
776 ptid_t ptid
= sim_data
->remote_sim_ptid
;
778 sim_inferior_data_cleanup (inf
, sim_data
);
779 set_inferior_data (inf
, sim_inferior_data_key
, NULL
);
781 /* Having a ptid allocated and stored in remote_sim_ptid does
782 not mean that a corresponding inferior was ever created.
783 Thus we need to verify the existence of an inferior using the
784 pid in question before setting inferior_ptid via
785 switch_to_thread() or mourning the inferior. */
786 if (find_inferior_ptid (ptid
) != NULL
)
788 switch_to_thread (ptid
);
789 generic_mourn_inferior ();
796 /* Close out all files and local state before this target loses control. */
799 gdbsim_close (struct target_ops
*self
)
801 struct sim_inferior_data
*sim_data
802 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
805 fprintf_unfiltered (gdb_stdlog
, "gdbsim_close\n");
807 iterate_over_inferiors (gdbsim_close_inferior
, NULL
);
809 if (sim_argv
!= NULL
)
820 /* Takes a program previously attached to and detaches it.
821 The program may resume execution (some targets do, some don't) and will
822 no longer stop on signals, etc. We better not have left any breakpoints
823 in the program or it'll die when it hits one. ARGS is arguments
824 typed by the user (e.g. a signal to send the process). FROM_TTY
825 says whether to be verbose or not. */
826 /* Terminate the open connection to the remote debugger.
827 Use this when you want to detach and do something else with your gdb. */
830 gdbsim_detach (struct target_ops
*ops
, const char *args
, int from_tty
)
833 fprintf_unfiltered (gdb_stdlog
, "gdbsim_detach: args \"%s\"\n", args
);
835 unpush_target (ops
); /* calls gdbsim_close to do the real work */
837 printf_filtered ("Ending simulator %s debugging\n", target_shortname
);
840 /* Resume execution of the target process. STEP says whether to single-step
841 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
842 to the target, or zero for no signal. */
846 enum gdb_signal siggnal
;
851 gdbsim_resume_inferior (struct inferior
*inf
, void *arg
)
853 struct sim_inferior_data
*sim_data
854 = get_sim_inferior_data (inf
, SIM_INSTANCE_NOT_NEEDED
);
855 struct resume_data
*rd
= (struct resume_data
*) arg
;
859 sim_data
->resume_siggnal
= rd
->siggnal
;
860 sim_data
->resume_step
= rd
->step
;
863 fprintf_unfiltered (gdb_stdlog
,
864 _("gdbsim_resume: pid %d, step %d, signal %d\n"),
865 inf
->pid
, rd
->step
, rd
->siggnal
);
868 /* When called from iterate_over_inferiors, a zero return causes the
869 iteration process to proceed until there are no more inferiors to
875 gdbsim_resume (struct target_ops
*ops
,
876 ptid_t ptid
, int step
, enum gdb_signal siggnal
)
878 struct resume_data rd
;
879 struct sim_inferior_data
*sim_data
880 = get_sim_inferior_data_by_ptid (ptid
, SIM_INSTANCE_NOT_NEEDED
);
882 rd
.siggnal
= siggnal
;
885 /* We don't access any sim_data members within this function.
886 What's of interest is whether or not the call to
887 get_sim_inferior_data_by_ptid(), above, is able to obtain a
888 non-NULL pointer. If it managed to obtain a non-NULL pointer, we
889 know we have a single inferior to consider. If it's NULL, we
890 either have multiple inferiors to resume or an error condition. */
893 gdbsim_resume_inferior (find_inferior_ptid (ptid
), &rd
);
894 else if (ptid_equal (ptid
, minus_one_ptid
))
895 iterate_over_inferiors (gdbsim_resume_inferior
, &rd
);
897 error (_("The program is not being run."));
900 /* Notify the simulator of an asynchronous request to interrupt.
902 The simulator shall ensure that the interrupt request is eventually
903 delivered to the simulator. If the call is made while the
904 simulator is not running then the interrupt request is processed when
905 the simulator is next resumed.
907 For simulators that do not support this operation, just abort. */
910 gdbsim_interrupt_inferior (struct inferior
*inf
, void *arg
)
912 struct sim_inferior_data
*sim_data
913 = get_sim_inferior_data (inf
, SIM_INSTANCE_NEEDED
);
917 if (!sim_stop (sim_data
->gdbsim_desc
))
923 /* When called from iterate_over_inferiors, a zero return causes the
924 iteration process to proceed until there are no more inferiors to
930 gdbsim_interrupt (struct target_ops
*self
, ptid_t ptid
)
932 struct sim_inferior_data
*sim_data
;
934 if (ptid_equal (ptid
, minus_one_ptid
))
936 iterate_over_inferiors (gdbsim_interrupt_inferior
, NULL
);
940 struct inferior
*inf
= find_inferior_ptid (ptid
);
943 error (_("Can't stop pid %d. No inferior found."),
944 ptid_get_pid (ptid
));
946 gdbsim_interrupt_inferior (inf
, NULL
);
950 /* GDB version of os_poll_quit callback.
951 Taken from gdb/util.c - should be in a library. */
954 gdb_os_poll_quit (host_callback
*p
)
956 if (deprecated_ui_loop_hook
!= NULL
)
957 deprecated_ui_loop_hook (0);
959 if (check_quit_flag ()) /* gdb's idea of quit */
964 /* Wait for inferior process to do something. Return pid of child,
965 or -1 in case of error; store status through argument pointer STATUS,
966 just as `wait' would. */
969 gdbsim_cntrl_c (int signo
)
971 gdbsim_interrupt (NULL
, minus_one_ptid
);
975 gdbsim_wait (struct target_ops
*ops
,
976 ptid_t ptid
, struct target_waitstatus
*status
, int options
)
978 struct sim_inferior_data
*sim_data
;
979 static sighandler_t prev_sigint
;
981 enum sim_stop reason
= sim_running
;
983 /* This target isn't able to (yet) resume more than one inferior at a time.
984 When ptid is minus_one_ptid, just use the current inferior. If we're
985 given an explicit pid, we'll try to find it and use that instead. */
986 if (ptid_equal (ptid
, minus_one_ptid
))
987 sim_data
= get_sim_inferior_data (current_inferior (),
988 SIM_INSTANCE_NEEDED
);
991 sim_data
= get_sim_inferior_data_by_ptid (ptid
, SIM_INSTANCE_NEEDED
);
992 if (sim_data
== NULL
)
993 error (_("Unable to wait for pid %d. Inferior not found."),
994 ptid_get_pid (ptid
));
995 inferior_ptid
= ptid
;
999 fprintf_unfiltered (gdb_stdlog
, "gdbsim_wait\n");
1001 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
1003 struct sigaction sa
, osa
;
1004 sa
.sa_handler
= gdbsim_cntrl_c
;
1005 sigemptyset (&sa
.sa_mask
);
1007 sigaction (SIGINT
, &sa
, &osa
);
1008 prev_sigint
= osa
.sa_handler
;
1011 prev_sigint
= signal (SIGINT
, gdbsim_cntrl_c
);
1013 sim_resume (sim_data
->gdbsim_desc
, sim_data
->resume_step
,
1014 sim_data
->resume_siggnal
);
1016 signal (SIGINT
, prev_sigint
);
1017 sim_data
->resume_step
= 0;
1019 sim_stop_reason (sim_data
->gdbsim_desc
, &reason
, &sigrc
);
1024 status
->kind
= TARGET_WAITKIND_EXITED
;
1025 status
->value
.integer
= sigrc
;
1030 case GDB_SIGNAL_ABRT
:
1033 case GDB_SIGNAL_INT
:
1034 case GDB_SIGNAL_TRAP
:
1036 status
->kind
= TARGET_WAITKIND_STOPPED
;
1037 status
->value
.sig
= (enum gdb_signal
) sigrc
;
1042 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
1043 status
->value
.sig
= (enum gdb_signal
) sigrc
;
1047 /* FIXME: Is this correct? */
1051 return inferior_ptid
;
1054 /* Get ready to modify the registers array. On machines which store
1055 individual registers, this doesn't need to do anything. On machines
1056 which store all the registers in one fell swoop, this makes sure
1057 that registers contains all the registers from the program being
1061 gdbsim_prepare_to_store (struct target_ops
*self
, struct regcache
*regcache
)
1063 /* Do nothing, since we can store individual regs. */
1066 /* Helper for gdbsim_xfer_partial that handles memory transfers.
1067 Arguments are like target_xfer_partial. */
1069 static enum target_xfer_status
1070 gdbsim_xfer_memory (struct target_ops
*target
,
1071 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1072 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1074 struct sim_inferior_data
*sim_data
1075 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1078 /* If this target doesn't have memory yet, return 0 causing the
1079 request to be passed to a lower target, hopefully an exec
1081 if (!target
->to_has_memory (target
))
1082 return TARGET_XFER_EOF
;
1084 if (!sim_data
->program_loaded
)
1085 error (_("No program loaded."));
1087 /* Note that we obtained the sim_data pointer above using
1088 SIM_INSTANCE_NOT_NEEDED. We do this so that we don't needlessly
1089 allocate a sim instance prior to loading a program. If we
1090 get to this point in the code though, gdbsim_desc should be
1091 non-NULL. (Note that a sim instance is needed in order to load
1093 gdb_assert (sim_data
->gdbsim_desc
!= NULL
);
1096 fprintf_unfiltered (gdb_stdlog
,
1097 "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1098 "memaddr %s, len %s\n",
1099 host_address_to_string (readbuf
),
1100 host_address_to_string (writebuf
),
1101 paddress (target_gdbarch (), memaddr
),
1106 if (remote_debug
&& len
> 0)
1107 dump_mem (writebuf
, len
);
1108 l
= sim_write (sim_data
->gdbsim_desc
, memaddr
, writebuf
, len
);
1112 l
= sim_read (sim_data
->gdbsim_desc
, memaddr
, readbuf
, len
);
1113 if (remote_debug
&& len
> 0)
1114 dump_mem (readbuf
, len
);
1118 *xfered_len
= (ULONGEST
) l
;
1119 return TARGET_XFER_OK
;
1122 return TARGET_XFER_EOF
;
1124 return TARGET_XFER_E_IO
;
1127 /* Target to_xfer_partial implementation. */
1129 static enum target_xfer_status
1130 gdbsim_xfer_partial (struct target_ops
*ops
, enum target_object object
,
1131 const char *annex
, gdb_byte
*readbuf
,
1132 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
1133 ULONGEST
*xfered_len
)
1137 case TARGET_OBJECT_MEMORY
:
1138 return gdbsim_xfer_memory (ops
, readbuf
, writebuf
, offset
, len
,
1142 return TARGET_XFER_E_IO
;
1147 gdbsim_files_info (struct target_ops
*target
)
1149 struct sim_inferior_data
*sim_data
1150 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED
);
1151 const char *file
= "nothing";
1154 file
= bfd_get_filename (exec_bfd
);
1157 fprintf_unfiltered (gdb_stdlog
, "gdbsim_files_info: file \"%s\"\n", file
);
1161 fprintf_unfiltered (gdb_stdlog
, "\tAttached to %s running program %s\n",
1162 target_shortname
, file
);
1163 sim_info (sim_data
->gdbsim_desc
, 0);
1167 /* Clear the simulator's notion of what the break points are. */
1170 gdbsim_mourn_inferior (struct target_ops
*target
)
1172 struct sim_inferior_data
*sim_data
1173 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1176 fprintf_unfiltered (gdb_stdlog
, "gdbsim_mourn_inferior:\n");
1178 remove_breakpoints ();
1179 generic_mourn_inferior ();
1180 delete_thread_silent (sim_data
->remote_sim_ptid
);
1183 /* Pass the command argument through to the simulator verbatim. The
1184 simulator must do any command interpretation work. */
1187 simulator_command (char *args
, int from_tty
)
1189 struct sim_inferior_data
*sim_data
;
1191 /* We use inferior_data() instead of get_sim_inferior_data() here in
1192 order to avoid attaching a sim_inferior_data struct to an
1193 inferior unnecessarily. The reason we take such care here is due
1194 to the fact that this function, simulator_command(), may be called
1195 even when the sim target is not active. If we were to use
1196 get_sim_inferior_data() here, it is possible that this call would
1197 be made either prior to gdbsim_open() or after gdbsim_close(),
1198 thus allocating memory that would not be garbage collected until
1199 the ultimate destruction of the associated inferior. */
1201 sim_data
= ((struct sim_inferior_data
*)
1202 inferior_data (current_inferior (), sim_inferior_data_key
));
1203 if (sim_data
== NULL
|| sim_data
->gdbsim_desc
== NULL
)
1206 /* PREVIOUSLY: The user may give a command before the simulator
1207 is opened. [...] (??? assuming of course one wishes to
1208 continue to allow commands to be sent to unopened simulators,
1209 which isn't entirely unreasonable). */
1211 /* The simulator is a builtin abstraction of a remote target.
1212 Consistent with that model, access to the simulator, via sim
1213 commands, is restricted to the period when the channel to the
1214 simulator is open. */
1216 error (_("Not connected to the simulator target"));
1219 sim_do_command (sim_data
->gdbsim_desc
, args
);
1221 /* Invalidate the register cache, in case the simulator command does
1223 registers_changed ();
1226 static VEC (char_ptr
) *
1227 sim_command_completer (struct cmd_list_element
*ignore
, const char *text
,
1230 struct sim_inferior_data
*sim_data
;
1233 VEC (char_ptr
) *result
= NULL
;
1235 sim_data
= ((struct sim_inferior_data
*)
1236 inferior_data (current_inferior (), sim_inferior_data_key
));
1237 if (sim_data
== NULL
|| sim_data
->gdbsim_desc
== NULL
)
1240 tmp
= sim_complete_command (sim_data
->gdbsim_desc
, text
, word
);
1244 /* Transform the array into a VEC, and then free the array. */
1245 for (i
= 0; tmp
[i
] != NULL
; i
++)
1246 VEC_safe_push (char_ptr
, result
, tmp
[i
]);
1252 /* Check to see if a thread is still alive. */
1255 gdbsim_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
1257 struct sim_inferior_data
*sim_data
1258 = get_sim_inferior_data_by_ptid (ptid
, SIM_INSTANCE_NOT_NEEDED
);
1260 if (sim_data
== NULL
)
1263 if (ptid_equal (ptid
, sim_data
->remote_sim_ptid
))
1264 /* The simulators' task is always alive. */
1270 /* Convert a thread ID to a string. Returns the string in a static
1274 gdbsim_pid_to_str (struct target_ops
*ops
, ptid_t ptid
)
1276 return normal_pid_to_str (ptid
);
1279 /* Simulator memory may be accessed after the program has been loaded. */
1282 gdbsim_has_all_memory (struct target_ops
*ops
)
1284 struct sim_inferior_data
*sim_data
1285 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1287 if (!sim_data
->program_loaded
)
1294 gdbsim_has_memory (struct target_ops
*ops
)
1296 struct sim_inferior_data
*sim_data
1297 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1299 if (!sim_data
->program_loaded
)
1305 /* Define the target subroutine names. */
1307 struct target_ops gdbsim_ops
;
1310 init_gdbsim_ops (void)
1312 gdbsim_ops
.to_shortname
= "sim";
1313 gdbsim_ops
.to_longname
= "simulator";
1314 gdbsim_ops
.to_doc
= "Use the compiled-in simulator.";
1315 gdbsim_ops
.to_open
= gdbsim_open
;
1316 gdbsim_ops
.to_close
= gdbsim_close
;
1317 gdbsim_ops
.to_detach
= gdbsim_detach
;
1318 gdbsim_ops
.to_resume
= gdbsim_resume
;
1319 gdbsim_ops
.to_wait
= gdbsim_wait
;
1320 gdbsim_ops
.to_fetch_registers
= gdbsim_fetch_register
;
1321 gdbsim_ops
.to_store_registers
= gdbsim_store_register
;
1322 gdbsim_ops
.to_prepare_to_store
= gdbsim_prepare_to_store
;
1323 gdbsim_ops
.to_xfer_partial
= gdbsim_xfer_partial
;
1324 gdbsim_ops
.to_files_info
= gdbsim_files_info
;
1325 gdbsim_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
1326 gdbsim_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
1327 gdbsim_ops
.to_kill
= gdbsim_kill
;
1328 gdbsim_ops
.to_load
= gdbsim_load
;
1329 gdbsim_ops
.to_create_inferior
= gdbsim_create_inferior
;
1330 gdbsim_ops
.to_mourn_inferior
= gdbsim_mourn_inferior
;
1331 gdbsim_ops
.to_interrupt
= gdbsim_interrupt
;
1332 gdbsim_ops
.to_thread_alive
= gdbsim_thread_alive
;
1333 gdbsim_ops
.to_pid_to_str
= gdbsim_pid_to_str
;
1334 gdbsim_ops
.to_stratum
= process_stratum
;
1335 gdbsim_ops
.to_has_all_memory
= gdbsim_has_all_memory
;
1336 gdbsim_ops
.to_has_memory
= gdbsim_has_memory
;
1337 gdbsim_ops
.to_has_stack
= default_child_has_stack
;
1338 gdbsim_ops
.to_has_registers
= default_child_has_registers
;
1339 gdbsim_ops
.to_has_execution
= default_child_has_execution
;
1340 gdbsim_ops
.to_magic
= OPS_MAGIC
;
1344 _initialize_remote_sim (void)
1346 struct cmd_list_element
*c
;
1349 add_target (&gdbsim_ops
);
1351 c
= add_com ("sim", class_obscure
, simulator_command
,
1352 _("Send a command to the simulator."));
1353 set_cmd_completer (c
, sim_command_completer
);
1355 sim_inferior_data_key
1356 = register_inferior_data_with_cleanup (NULL
, sim_inferior_data_cleanup
);