1 /* Generic remote debugging interface for simulators.
3 Copyright (C) 1993-2020 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/>. */
34 #include "process-stratum-target.h"
36 #include "gdb/callback.h"
37 #include "gdb/remote-sim.h"
40 #include "sim-regno.h"
41 #include "arch-utils.h"
42 #include "readline/readline.h"
43 #include "gdbthread.h"
44 #include "gdbsupport/byte-vector.h"
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 *, ...)
74 sim_* are the interface to the simulator (see remote-sim.h).
75 gdbsim_* are stuff which is internal to gdb. */
77 /* Value of the next pid to allocate for an inferior. As indicated
78 elsewhere, its initial value is somewhat arbitrary; it's critical
79 though that it's not zero or negative. */
81 #define INITIAL_PID 42000
83 /* Simulator-specific, per-inferior state. */
84 struct sim_inferior_data
{
85 explicit sim_inferior_data (SIM_DESC desc
)
87 remote_sim_ptid (next_pid
, 0, next_pid
)
92 ~sim_inferior_data ();
94 /* Flag which indicates whether or not the program has been loaded. */
95 int program_loaded
= 0;
97 /* Simulator descriptor for this inferior. */
100 /* This is the ptid we use for this particular simulator instance. Its
101 value is somewhat arbitrary, as the simulator target don't have a
102 notion of tasks or threads, but we need something non-null to place
103 in inferior_ptid. For simulators which permit multiple instances,
104 we also need a unique identifier to use for each inferior. */
105 ptid_t remote_sim_ptid
;
107 /* Signal with which to resume. */
108 enum gdb_signal resume_siggnal
= GDB_SIGNAL_0
;
110 /* Flag which indicates whether resume should step or not. */
114 static const target_info gdbsim_target_info
= {
117 N_("Use the compiled-in simulator.")
120 struct gdbsim_target final
121 : public memory_breakpoint_target
<process_stratum_target
>
123 gdbsim_target () = default;
125 const target_info
&info () const override
126 { return gdbsim_target_info
; }
128 void close () override
;
130 void detach (inferior
*inf
, int) override
;
132 void resume (ptid_t
, int, enum gdb_signal
) override
;
133 ptid_t
wait (ptid_t
, struct target_waitstatus
*, int) override
;
135 void fetch_registers (struct regcache
*, int) override
;
136 void store_registers (struct regcache
*, int) override
;
137 void prepare_to_store (struct regcache
*) override
;
139 enum target_xfer_status
xfer_partial (enum target_object object
,
142 const gdb_byte
*writebuf
,
143 ULONGEST offset
, ULONGEST len
,
144 ULONGEST
*xfered_len
) override
;
146 void files_info () override
;
148 void kill () override
;
150 void load (const char *, int) override
;
152 bool can_create_inferior () override
{ return true; }
153 void create_inferior (const char *, const std::string
&,
154 char **, int) override
;
156 void mourn_inferior () override
;
158 void interrupt () override
;
160 bool thread_alive (ptid_t ptid
) override
;
162 std::string
pid_to_str (ptid_t
) override
;
164 bool has_all_memory () override
;
165 bool has_memory () override
;
168 sim_inferior_data
*get_inferior_data_by_ptid (ptid_t ptid
,
169 int sim_instance_needed
);
170 void resume_one_inferior (inferior
*inf
, bool step
, gdb_signal siggnal
);
171 void close_one_inferior (inferior
*inf
);
174 static struct gdbsim_target gdbsim_ops
;
176 static inferior_key
<sim_inferior_data
> sim_inferior_data_key
;
178 /* Flag indicating the "open" status of this module. It's set to 1
179 in gdbsim_open() and 0 in gdbsim_close(). */
180 static int gdbsim_is_open
= 0;
182 /* Argument list to pass to sim_open(). It is allocated in gdbsim_open()
183 and deallocated in gdbsim_close(). The lifetime needs to extend beyond
184 the call to gdbsim_open() due to the fact that other sim instances other
185 than the first will be allocated after the gdbsim_open() call. */
186 static char **sim_argv
= NULL
;
188 /* OS-level callback functions for write, flush, etc. */
189 static host_callback gdb_callback
;
190 static int callbacks_initialized
= 0;
192 /* Flags indicating whether or not a sim instance is needed. One of these
193 flags should be passed to get_sim_inferior_data(). */
195 enum {SIM_INSTANCE_NOT_NEEDED
= 0, SIM_INSTANCE_NEEDED
= 1};
197 /* Obtain pointer to per-inferior simulator data, allocating it if necessary.
198 Attempt to open the sim if SIM_INSTANCE_NEEDED is true. */
200 static struct sim_inferior_data
*
201 get_sim_inferior_data (struct inferior
*inf
, int sim_instance_needed
)
203 SIM_DESC sim_desc
= NULL
;
204 struct sim_inferior_data
*sim_data
= sim_inferior_data_key
.get (inf
);
206 /* Try to allocate a new sim instance, if needed. We do this ahead of
207 a potential allocation of a sim_inferior_data struct in order to
208 avoid needlessly allocating that struct in the event that the sim
209 instance allocation fails. */
210 if (sim_instance_needed
== SIM_INSTANCE_NEEDED
211 && (sim_data
== NULL
|| sim_data
->gdbsim_desc
== NULL
))
213 sim_desc
= sim_open (SIM_OPEN_DEBUG
, &gdb_callback
, exec_bfd
, sim_argv
);
214 if (sim_desc
== NULL
)
215 error (_("Unable to create simulator instance for inferior %d."),
218 /* Check if the sim descriptor is the same as that of another
220 for (inferior
*other_inf
: all_inferiors ())
222 sim_inferior_data
*other_sim_data
223 = sim_inferior_data_key
.get (other_inf
);
225 if (other_sim_data
!= NULL
226 && other_sim_data
->gdbsim_desc
== sim_desc
)
228 /* We don't close the descriptor due to the fact that it's
229 shared with some other inferior. If we were to close it,
230 that might needlessly muck up the other inferior. Of
231 course, it's possible that the damage has already been
232 done... Note that it *will* ultimately be closed during
233 cleanup of the other inferior. */
236 _("Inferior %d and inferior %d would have identical simulator state.\n"
237 "(This simulator does not support the running of more than one inferior.)"),
238 inf
->num
, other_inf
->num
);
243 if (sim_data
== NULL
)
245 sim_data
= sim_inferior_data_key
.emplace (inf
, sim_desc
);
249 /* This handles the case where sim_data was allocated prior to
250 needing a sim instance. */
251 sim_data
->gdbsim_desc
= sim_desc
;
258 /* Return pointer to per-inferior simulator data using PTID to find the
259 inferior in question. Return NULL when no inferior is found or
260 when ptid has a zero or negative pid component. */
263 gdbsim_target::get_inferior_data_by_ptid (ptid_t ptid
,
264 int sim_instance_needed
)
266 struct inferior
*inf
;
267 int pid
= ptid
.pid ();
272 inf
= find_inferior_pid (this, pid
);
275 return get_sim_inferior_data (inf
, sim_instance_needed
);
280 /* Free the per-inferior simulator data. */
282 sim_inferior_data::~sim_inferior_data ()
285 sim_close (gdbsim_desc
, 0);
289 dump_mem (const gdb_byte
*buf
, int len
)
291 fputs_unfiltered ("\t", gdb_stdlog
);
293 if (len
== 8 || len
== 4)
297 memcpy (l
, buf
, len
);
298 fprintf_unfiltered (gdb_stdlog
, "0x%08x", l
[0]);
300 fprintf_unfiltered (gdb_stdlog
, " 0x%08x", l
[1]);
306 for (i
= 0; i
< len
; i
++)
307 fprintf_unfiltered (gdb_stdlog
, "0x%02x ", buf
[i
]);
310 fputs_unfiltered ("\n", gdb_stdlog
);
313 /* Initialize gdb_callback. */
316 init_callbacks (void)
318 if (!callbacks_initialized
)
320 gdb_callback
= default_callback
;
321 gdb_callback
.init (&gdb_callback
);
322 gdb_callback
.write_stdout
= gdb_os_write_stdout
;
323 gdb_callback
.flush_stdout
= gdb_os_flush_stdout
;
324 gdb_callback
.write_stderr
= gdb_os_write_stderr
;
325 gdb_callback
.flush_stderr
= gdb_os_flush_stderr
;
326 gdb_callback
.printf_filtered
= gdb_os_printf_filtered
;
327 gdb_callback
.vprintf_filtered
= gdb_os_vprintf_filtered
;
328 gdb_callback
.evprintf_filtered
= gdb_os_evprintf_filtered
;
329 gdb_callback
.error
= gdb_os_error
;
330 gdb_callback
.poll_quit
= gdb_os_poll_quit
;
331 gdb_callback
.magic
= HOST_CALLBACK_MAGIC
;
332 callbacks_initialized
= 1;
336 /* Release callbacks (free resources used by them). */
341 if (callbacks_initialized
)
343 gdb_callback
.shutdown (&gdb_callback
);
344 callbacks_initialized
= 0;
348 /* GDB version of os_write_stdout callback. */
351 gdb_os_write_stdout (host_callback
*p
, const char *buf
, int len
)
353 ui_file_write (gdb_stdtarg
, buf
, len
);
357 /* GDB version of os_flush_stdout callback. */
360 gdb_os_flush_stdout (host_callback
*p
)
362 gdb_flush (gdb_stdtarg
);
365 /* GDB version of os_write_stderr callback. */
368 gdb_os_write_stderr (host_callback
*p
, const char *buf
, int len
)
373 for (i
= 0; i
< len
; i
++)
377 fputs_unfiltered (b
, gdb_stdtargerr
);
382 /* GDB version of os_flush_stderr callback. */
385 gdb_os_flush_stderr (host_callback
*p
)
387 gdb_flush (gdb_stdtargerr
);
390 /* GDB version of printf_filtered callback. */
392 static void ATTRIBUTE_PRINTF (2, 3)
393 gdb_os_printf_filtered (host_callback
* p
, const char *format
, ...)
397 va_start (args
, format
);
398 vfprintf_filtered (gdb_stdout
, format
, args
);
402 /* GDB version of error vprintf_filtered. */
404 static void ATTRIBUTE_PRINTF (2, 0)
405 gdb_os_vprintf_filtered (host_callback
* p
, const char *format
, va_list ap
)
407 vfprintf_filtered (gdb_stdout
, format
, ap
);
410 /* GDB version of error evprintf_filtered. */
412 static void ATTRIBUTE_PRINTF (2, 0)
413 gdb_os_evprintf_filtered (host_callback
* p
, const char *format
, va_list ap
)
415 vfprintf_filtered (gdb_stderr
, format
, ap
);
418 /* GDB version of error callback. */
420 static void ATTRIBUTE_PRINTF (2, 3)
421 gdb_os_error (host_callback
* p
, const char *format
, ...)
425 va_start (args
, format
);
426 verror (format
, args
);
431 one2one_register_sim_regno (struct gdbarch
*gdbarch
, int regnum
)
433 /* Only makes sense to supply raw registers. */
434 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_regs (gdbarch
));
439 gdbsim_target::fetch_registers (struct regcache
*regcache
, int regno
)
441 struct gdbarch
*gdbarch
= regcache
->arch ();
442 struct inferior
*inf
= find_inferior_ptid (this, regcache
->ptid ());
443 struct sim_inferior_data
*sim_data
444 = get_sim_inferior_data (inf
, SIM_INSTANCE_NEEDED
);
448 for (regno
= 0; regno
< gdbarch_num_regs (gdbarch
); regno
++)
449 fetch_registers (regcache
, regno
);
453 switch (gdbarch_register_sim_regno (gdbarch
, regno
))
455 case LEGACY_SIM_REGNO_IGNORE
:
457 case SIM_REGNO_DOES_NOT_EXIST
:
459 /* For moment treat a `does not exist' register the same way
460 as an ``unavailable'' register. */
461 regcache
->raw_supply_zeroed (regno
);
467 static int warn_user
= 1;
468 int regsize
= register_size (gdbarch
, regno
);
469 gdb::byte_vector
buf (regsize
, 0);
472 gdb_assert (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
));
473 nr_bytes
= sim_fetch_register (sim_data
->gdbsim_desc
,
474 gdbarch_register_sim_regno
476 buf
.data (), regsize
);
477 if (nr_bytes
> 0 && nr_bytes
!= regsize
&& warn_user
)
479 fprintf_unfiltered (gdb_stderr
,
480 "Size of register %s (%d/%d) "
481 "incorrect (%d instead of %d))",
482 gdbarch_register_name (gdbarch
, regno
),
484 gdbarch_register_sim_regno (gdbarch
, regno
),
488 /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
489 indicating that GDB and the SIM have different ideas about
490 which registers are fetchable. */
491 /* Else if (nr_bytes < 0): an old simulator, that doesn't
492 think to return the register size. Just assume all is ok. */
493 regcache
->raw_supply (regno
, buf
.data ());
496 fprintf_unfiltered (gdb_stdlog
,
497 "gdbsim_fetch_register: %d", regno
);
498 /* FIXME: We could print something more intelligible. */
499 dump_mem (buf
.data (), regsize
);
508 gdbsim_target::store_registers (struct regcache
*regcache
, int regno
)
510 struct gdbarch
*gdbarch
= regcache
->arch ();
511 struct inferior
*inf
= find_inferior_ptid (this, regcache
->ptid ());
512 struct sim_inferior_data
*sim_data
513 = get_sim_inferior_data (inf
, SIM_INSTANCE_NEEDED
);
517 for (regno
= 0; regno
< gdbarch_num_regs (gdbarch
); regno
++)
518 store_registers (regcache
, regno
);
521 else if (gdbarch_register_sim_regno (gdbarch
, regno
) >= 0)
523 int regsize
= register_size (gdbarch
, regno
);
524 gdb::byte_vector
tmp (regsize
);
527 regcache
->cooked_read (regno
, tmp
.data ());
528 nr_bytes
= sim_store_register (sim_data
->gdbsim_desc
,
529 gdbarch_register_sim_regno
531 tmp
.data (), regsize
);
533 if (nr_bytes
> 0 && nr_bytes
!= regsize
)
534 internal_error (__FILE__
, __LINE__
,
535 _("Register size different to expected"));
537 internal_error (__FILE__
, __LINE__
,
538 _("Register %d not updated"), regno
);
540 warning (_("Register %s not updated"),
541 gdbarch_register_name (gdbarch
, regno
));
545 fprintf_unfiltered (gdb_stdlog
, "gdbsim_store_register: %d", regno
);
546 /* FIXME: We could print something more intelligible. */
547 dump_mem (tmp
.data (), regsize
);
552 /* Kill the running program. This may involve closing any open files
553 and releasing other resources acquired by the simulated program. */
556 gdbsim_target::kill ()
559 fprintf_unfiltered (gdb_stdlog
, "gdbsim_kill\n");
561 /* There is no need to `kill' running simulator - the simulator is
562 not running. Mourning it is enough. */
563 target_mourn_inferior (inferior_ptid
);
566 /* Load an executable file into the target process. This is expected to
567 not only bring new code into the target process, but also to update
568 GDB's symbol tables to match. */
571 gdbsim_target::load (const char *args
, int fromtty
)
574 struct sim_inferior_data
*sim_data
575 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED
);
578 error_no_arg (_("program to load"));
580 gdb_argv
argv (args
);
582 prog
= tilde_expand (argv
[0]);
585 error (_("GDB sim does not yet support a load offset."));
588 fprintf_unfiltered (gdb_stdlog
, "gdbsim_load: prog \"%s\"\n", prog
);
590 /* FIXME: We will print two messages on error.
591 Need error to either not print anything if passed NULL or need
592 another routine that doesn't take any arguments. */
593 if (sim_load (sim_data
->gdbsim_desc
, prog
, NULL
, fromtty
) == SIM_RC_FAIL
)
594 error (_("unable to load program"));
596 /* FIXME: If a load command should reset the targets registers then
597 a call to sim_create_inferior() should go here. */
599 sim_data
->program_loaded
= 1;
603 /* Start an inferior process and set inferior_ptid to its pid.
604 EXEC_FILE is the file to run.
605 ARGS is a string containing the arguments to the program.
606 ENV is the environment vector to pass. Errors reported with error().
607 On VxWorks and various standalone systems, we ignore exec_file. */
608 /* This is called not only when we first attach, but also when the
609 user types "run" after having attached. */
612 gdbsim_target::create_inferior (const char *exec_file
,
613 const std::string
&allargs
,
614 char **env
, int from_tty
)
616 struct sim_inferior_data
*sim_data
617 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED
);
620 const char *args
= allargs
.c_str ();
622 if (exec_file
== 0 || exec_bfd
== 0)
623 warning (_("No executable file specified."));
624 if (!sim_data
->program_loaded
)
625 warning (_("No program loaded."));
628 fprintf_unfiltered (gdb_stdlog
,
629 "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
630 (exec_file
? exec_file
: "(NULL)"),
633 if (inferior_ptid
== sim_data
->remote_sim_ptid
)
635 remove_breakpoints ();
636 init_wait_for_inferior ();
639 if (exec_file
!= NULL
)
641 len
= strlen (exec_file
) + 1 + allargs
.size () + 1 + /*slop */ 10;
642 arg_buf
= (char *) alloca (len
);
644 strcat (arg_buf
, exec_file
);
645 strcat (arg_buf
, " ");
646 strcat (arg_buf
, args
);
647 built_argv
.reset (arg_buf
);
650 if (sim_create_inferior (sim_data
->gdbsim_desc
, exec_bfd
,
651 built_argv
.get (), env
)
653 error (_("Unable to create sim inferior."));
655 inferior_ptid
= sim_data
->remote_sim_ptid
;
656 inferior_appeared (current_inferior (), inferior_ptid
.pid ());
657 add_thread_silent (this, 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_target_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
);
735 gdb_argv
argv (arg_buf
);
736 sim_argv
= argv
.release ();
739 gdbsim_desc
= sim_open (SIM_OPEN_DEBUG
, &gdb_callback
, exec_bfd
, sim_argv
);
741 if (gdbsim_desc
== 0)
745 error (_("unable to create simulator instance"));
748 /* Reset the pid numberings for this batch of sim instances. */
749 next_pid
= INITIAL_PID
;
751 /* Allocate the inferior data, but do not allocate a sim instance
752 since we've already just done that. */
753 sim_data
= get_sim_inferior_data (current_inferior (),
754 SIM_INSTANCE_NOT_NEEDED
);
756 sim_data
->gdbsim_desc
= gdbsim_desc
;
758 push_target (&gdbsim_ops
);
759 printf_filtered ("Connected to the simulator.\n");
761 /* There's nothing running after "target sim" or "load"; not until
763 inferior_ptid
= null_ptid
;
768 /* Helper for gdbsim_target::close. */
771 gdbsim_target::close_one_inferior (inferior
*inf
)
773 struct sim_inferior_data
*sim_data
= sim_inferior_data_key
.get (inf
);
774 if (sim_data
!= NULL
)
776 ptid_t ptid
= sim_data
->remote_sim_ptid
;
778 sim_inferior_data_key
.clear (inf
);
780 /* Having a ptid allocated and stored in remote_sim_ptid does
781 not mean that a corresponding inferior was ever created.
782 Thus we need to verify the existence of an inferior using the
783 pid in question before setting inferior_ptid via
784 switch_to_thread() or mourning the inferior. */
785 if (find_inferior_ptid (this, ptid
) != NULL
)
787 switch_to_thread (this, ptid
);
788 generic_mourn_inferior ();
793 /* Close out all files and local state before this target loses control. */
796 gdbsim_target::close ()
799 fprintf_unfiltered (gdb_stdlog
, "gdbsim_close\n");
801 for (inferior
*inf
: all_inferiors (this))
802 close_one_inferior (inf
);
804 if (sim_argv
!= NULL
)
815 /* Takes a program previously attached to and detaches it.
816 The program may resume execution (some targets do, some don't) and will
817 no longer stop on signals, etc. We better not have left any breakpoints
818 in the program or it'll die when it hits one. FROM_TTY says whether to be
820 /* Terminate the open connection to the remote debugger.
821 Use this when you want to detach and do something else with your gdb. */
824 gdbsim_target::detach (inferior
*inf
, int from_tty
)
827 fprintf_unfiltered (gdb_stdlog
, "gdbsim_detach\n");
829 unpush_target (this); /* calls gdbsim_close to do the real work */
831 printf_filtered ("Ending simulator %s debugging\n", target_shortname
);
834 /* Resume execution of the target process. STEP says whether to single-step
835 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
836 to the target, or zero for no signal. */
839 gdbsim_target::resume_one_inferior (inferior
*inf
, bool step
,
842 struct sim_inferior_data
*sim_data
843 = get_sim_inferior_data (inf
, SIM_INSTANCE_NOT_NEEDED
);
847 sim_data
->resume_siggnal
= siggnal
;
848 sim_data
->resume_step
= step
;
851 fprintf_unfiltered (gdb_stdlog
,
852 _("gdbsim_resume: pid %d, step %d, signal %d\n"),
853 inf
->pid
, step
, siggnal
);
858 gdbsim_target::resume (ptid_t ptid
, int step
, enum gdb_signal siggnal
)
860 struct sim_inferior_data
*sim_data
861 = get_inferior_data_by_ptid (ptid
, SIM_INSTANCE_NOT_NEEDED
);
863 /* We don't access any sim_data members within this function.
864 What's of interest is whether or not the call to
865 get_sim_inferior_data_by_ptid(), above, is able to obtain a
866 non-NULL pointer. If it managed to obtain a non-NULL pointer, we
867 know we have a single inferior to consider. If it's NULL, we
868 either have multiple inferiors to resume or an error condition. */
871 resume_one_inferior (find_inferior_ptid (this, ptid
), step
, siggnal
);
872 else if (ptid
== minus_one_ptid
)
874 for (inferior
*inf
: all_inferiors (this))
875 resume_one_inferior (inf
, step
, siggnal
);
878 error (_("The program is not being run."));
881 /* Notify the simulator of an asynchronous request to interrupt.
883 The simulator shall ensure that the interrupt request is eventually
884 delivered to the simulator. If the call is made while the
885 simulator is not running then the interrupt request is processed when
886 the simulator is next resumed.
888 For simulators that do not support this operation, just abort. */
891 gdbsim_target::interrupt ()
893 for (inferior
*inf
: all_inferiors ())
895 sim_inferior_data
*sim_data
896 = get_sim_inferior_data (inf
, SIM_INSTANCE_NEEDED
);
898 if (sim_data
!= nullptr && !sim_stop (sim_data
->gdbsim_desc
))
903 /* GDB version of os_poll_quit callback.
904 Taken from gdb/util.c - should be in a library. */
907 gdb_os_poll_quit (host_callback
*p
)
909 if (deprecated_ui_loop_hook
!= NULL
)
910 deprecated_ui_loop_hook (0);
912 if (check_quit_flag ()) /* gdb's idea of quit */
917 /* Wait for inferior process to do something. Return pid of child,
918 or -1 in case of error; store status through argument pointer STATUS,
919 just as `wait' would. */
922 gdbsim_cntrl_c (int signo
)
924 gdbsim_ops
.interrupt ();
928 gdbsim_target::wait (ptid_t ptid
, struct target_waitstatus
*status
, int options
)
930 struct sim_inferior_data
*sim_data
;
931 static sighandler_t prev_sigint
;
933 enum sim_stop reason
= sim_running
;
935 /* This target isn't able to (yet) resume more than one inferior at a time.
936 When ptid is minus_one_ptid, just use the current inferior. If we're
937 given an explicit pid, we'll try to find it and use that instead. */
938 if (ptid
== minus_one_ptid
)
939 sim_data
= get_sim_inferior_data (current_inferior (),
940 SIM_INSTANCE_NEEDED
);
943 sim_data
= get_inferior_data_by_ptid (ptid
, SIM_INSTANCE_NEEDED
);
944 if (sim_data
== NULL
)
945 error (_("Unable to wait for pid %d. Inferior not found."),
947 inferior_ptid
= ptid
;
951 fprintf_unfiltered (gdb_stdlog
, "gdbsim_wait\n");
953 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
955 struct sigaction sa
, osa
;
956 sa
.sa_handler
= gdbsim_cntrl_c
;
957 sigemptyset (&sa
.sa_mask
);
959 sigaction (SIGINT
, &sa
, &osa
);
960 prev_sigint
= osa
.sa_handler
;
963 prev_sigint
= signal (SIGINT
, gdbsim_cntrl_c
);
965 sim_resume (sim_data
->gdbsim_desc
, sim_data
->resume_step
,
966 sim_data
->resume_siggnal
);
968 signal (SIGINT
, prev_sigint
);
969 sim_data
->resume_step
= 0;
971 sim_stop_reason (sim_data
->gdbsim_desc
, &reason
, &sigrc
);
976 status
->kind
= TARGET_WAITKIND_EXITED
;
977 status
->value
.integer
= sigrc
;
982 case GDB_SIGNAL_ABRT
:
986 case GDB_SIGNAL_TRAP
:
988 status
->kind
= TARGET_WAITKIND_STOPPED
;
989 status
->value
.sig
= (enum gdb_signal
) sigrc
;
994 status
->kind
= TARGET_WAITKIND_SIGNALLED
;
995 status
->value
.sig
= (enum gdb_signal
) sigrc
;
999 /* FIXME: Is this correct? */
1003 return sim_data
->remote_sim_ptid
;
1006 /* Get ready to modify the registers array. On machines which store
1007 individual registers, this doesn't need to do anything. On machines
1008 which store all the registers in one fell swoop, this makes sure
1009 that registers contains all the registers from the program being
1013 gdbsim_target::prepare_to_store (struct regcache
*regcache
)
1015 /* Do nothing, since we can store individual regs. */
1018 /* Helper for gdbsim_xfer_partial that handles memory transfers.
1019 Arguments are like target_xfer_partial. */
1021 static enum target_xfer_status
1022 gdbsim_xfer_memory (struct target_ops
*target
,
1023 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
1024 ULONGEST memaddr
, ULONGEST len
, ULONGEST
*xfered_len
)
1026 struct sim_inferior_data
*sim_data
1027 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1030 /* If this target doesn't have memory yet, return 0 causing the
1031 request to be passed to a lower target, hopefully an exec
1033 if (!target
->has_memory ())
1034 return TARGET_XFER_EOF
;
1036 if (!sim_data
->program_loaded
)
1037 error (_("No program loaded."));
1039 /* Note that we obtained the sim_data pointer above using
1040 SIM_INSTANCE_NOT_NEEDED. We do this so that we don't needlessly
1041 allocate a sim instance prior to loading a program. If we
1042 get to this point in the code though, gdbsim_desc should be
1043 non-NULL. (Note that a sim instance is needed in order to load
1045 gdb_assert (sim_data
->gdbsim_desc
!= NULL
);
1048 fprintf_unfiltered (gdb_stdlog
,
1049 "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1050 "memaddr %s, len %s\n",
1051 host_address_to_string (readbuf
),
1052 host_address_to_string (writebuf
),
1053 paddress (target_gdbarch (), memaddr
),
1058 if (remote_debug
&& len
> 0)
1059 dump_mem (writebuf
, len
);
1060 l
= sim_write (sim_data
->gdbsim_desc
, memaddr
, writebuf
, len
);
1064 l
= sim_read (sim_data
->gdbsim_desc
, memaddr
, readbuf
, len
);
1065 if (remote_debug
&& len
> 0)
1066 dump_mem (readbuf
, len
);
1070 *xfered_len
= (ULONGEST
) l
;
1071 return TARGET_XFER_OK
;
1074 return TARGET_XFER_EOF
;
1076 return TARGET_XFER_E_IO
;
1079 /* Target to_xfer_partial implementation. */
1081 enum target_xfer_status
1082 gdbsim_target::xfer_partial (enum target_object object
,
1083 const char *annex
, gdb_byte
*readbuf
,
1084 const gdb_byte
*writebuf
, ULONGEST offset
, ULONGEST len
,
1085 ULONGEST
*xfered_len
)
1089 case TARGET_OBJECT_MEMORY
:
1090 return gdbsim_xfer_memory (this, readbuf
, writebuf
, offset
, len
,
1094 return TARGET_XFER_E_IO
;
1099 gdbsim_target::files_info ()
1101 struct sim_inferior_data
*sim_data
1102 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED
);
1103 const char *file
= "nothing";
1106 file
= bfd_get_filename (exec_bfd
);
1109 fprintf_unfiltered (gdb_stdlog
, "gdbsim_files_info: file \"%s\"\n", file
);
1113 fprintf_unfiltered (gdb_stdlog
, "\tAttached to %s running program %s\n",
1114 target_shortname
, file
);
1115 sim_info (sim_data
->gdbsim_desc
, 0);
1119 /* Clear the simulator's notion of what the break points are. */
1122 gdbsim_target::mourn_inferior ()
1125 fprintf_unfiltered (gdb_stdlog
, "gdbsim_mourn_inferior:\n");
1127 remove_breakpoints ();
1128 generic_mourn_inferior ();
1131 /* Pass the command argument through to the simulator verbatim. The
1132 simulator must do any command interpretation work. */
1135 simulator_command (const char *args
, int from_tty
)
1137 struct sim_inferior_data
*sim_data
;
1139 /* We use inferior_data() instead of get_sim_inferior_data() here in
1140 order to avoid attaching a sim_inferior_data struct to an
1141 inferior unnecessarily. The reason we take such care here is due
1142 to the fact that this function, simulator_command(), may be called
1143 even when the sim target is not active. If we were to use
1144 get_sim_inferior_data() here, it is possible that this call would
1145 be made either prior to gdbsim_open() or after gdbsim_close(),
1146 thus allocating memory that would not be garbage collected until
1147 the ultimate destruction of the associated inferior. */
1149 sim_data
= sim_inferior_data_key
.get (current_inferior ());
1150 if (sim_data
== NULL
|| sim_data
->gdbsim_desc
== NULL
)
1153 /* PREVIOUSLY: The user may give a command before the simulator
1154 is opened. [...] (??? assuming of course one wishes to
1155 continue to allow commands to be sent to unopened simulators,
1156 which isn't entirely unreasonable). */
1158 /* The simulator is a builtin abstraction of a remote target.
1159 Consistent with that model, access to the simulator, via sim
1160 commands, is restricted to the period when the channel to the
1161 simulator is open. */
1163 error (_("Not connected to the simulator target"));
1166 sim_do_command (sim_data
->gdbsim_desc
, args
);
1168 /* Invalidate the register cache, in case the simulator command does
1170 registers_changed ();
1174 sim_command_completer (struct cmd_list_element
*ignore
,
1175 completion_tracker
&tracker
,
1176 const char *text
, const char *word
)
1178 struct sim_inferior_data
*sim_data
;
1180 sim_data
= sim_inferior_data_key
.get (current_inferior ());
1181 if (sim_data
== NULL
|| sim_data
->gdbsim_desc
== NULL
)
1184 /* sim_complete_command returns a NULL-terminated malloc'ed array of
1185 malloc'ed strings. */
1186 struct sim_completions_deleter
1188 void operator() (char **ptr
) const
1190 for (size_t i
= 0; ptr
[i
] != NULL
; i
++)
1196 std::unique_ptr
<char *[], sim_completions_deleter
> sim_completions
1197 (sim_complete_command (sim_data
->gdbsim_desc
, text
, word
));
1198 if (sim_completions
== NULL
)
1201 /* Count the elements and add completions from tail to head because
1202 below we'll swap elements out of the array in case add_completion
1203 throws and the deleter deletes until it finds a NULL element. */
1205 while (sim_completions
[count
] != NULL
)
1208 for (size_t i
= count
; i
> 0; i
--)
1210 gdb::unique_xmalloc_ptr
<char> match (sim_completions
[i
- 1]);
1211 sim_completions
[i
- 1] = NULL
;
1212 tracker
.add_completion (std::move (match
));
1216 /* Check to see if a thread is still alive. */
1219 gdbsim_target::thread_alive (ptid_t ptid
)
1221 struct sim_inferior_data
*sim_data
1222 = get_inferior_data_by_ptid (ptid
, SIM_INSTANCE_NOT_NEEDED
);
1224 if (sim_data
== NULL
)
1227 if (ptid
== sim_data
->remote_sim_ptid
)
1228 /* The simulators' task is always alive. */
1234 /* Convert a thread ID to a string. */
1237 gdbsim_target::pid_to_str (ptid_t ptid
)
1239 return normal_pid_to_str (ptid
);
1242 /* Simulator memory may be accessed after the program has been loaded. */
1245 gdbsim_target::has_all_memory ()
1247 struct sim_inferior_data
*sim_data
1248 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1250 if (!sim_data
->program_loaded
)
1257 gdbsim_target::has_memory ()
1259 struct sim_inferior_data
*sim_data
1260 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED
);
1262 if (!sim_data
->program_loaded
)
1268 void _initialize_remote_sim ();
1270 _initialize_remote_sim ()
1272 struct cmd_list_element
*c
;
1274 add_target (gdbsim_target_info
, gdbsim_target_open
);
1276 c
= add_com ("sim", class_obscure
, simulator_command
,
1277 _("Send a command to the simulator."));
1278 set_cmd_completer (c
, sim_command_completer
);