36#include "sim/callback.h"
42#include "readline/readline.h"
44#include "gdbsupport/byte-vector.h"
47#include "gdbsupport/buildargv.h"
84#define INITIAL_PID 42000
87struct sim_inferior_data {
88 explicit sim_inferior_data (SIM_DESC desc)
90 remote_sim_ptid (next_pid, 0, next_pid)
92 gdb_assert (remote_sim_ptid != null_ptid);
96 ~sim_inferior_data ();
99 bool program_loaded =
false;
102 SIM_DESC gdbsim_desc;
109 ptid_t remote_sim_ptid;
112 enum gdb_signal resume_siggnal = GDB_SIGNAL_0;
121 N_(
"Use the compiled-in simulator.")
132 void close ()
override;
136 void resume (ptid_t,
int,
enum gdb_signal)
override;
146 const gdb_byte *writebuf,
147 ULONGEST offset, ULONGEST len,
148 ULONGEST *xfered_len)
override;
152 void kill ()
override;
154 void load (
const char *,
int)
override;
158 char **,
int)
override;
170 std::vector<mem_region>
memory_map ()
override;
174 int sim_instance_needed);
205static struct sim_inferior_data *
208 SIM_DESC sim_desc = NULL;
216 && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
220 if (sim_desc == NULL)
221 error (_(
"Unable to create simulator instance for inferior %d."),
228 sim_inferior_data *other_sim_data
231 if (other_sim_data != NULL
232 && other_sim_data->gdbsim_desc == sim_desc)
242_(
"Inferior %d and inferior %d would have identical simulator state.\n"
243 "(This simulator does not support the running of more than one inferior.)"),
244 inf->num, other_inf->num);
249 if (sim_data == NULL)
257 sim_data->gdbsim_desc = sim_desc;
270 int sim_instance_needed)
288sim_inferior_data::~sim_inferior_data ()
291 sim_close (gdbsim_desc, 0);
299 if (len == 8 || len == 4)
303 memcpy (l, buf, len);
312 for (i = 0; i < len; i++)
379 for (i = 0; i < len; i++)
403 va_start (
args, format);
427gdb_os_error (host_callback * p, const
char *format, ...)
431 va_start (
args, format);
449 struct sim_inferior_data *sim_data
473 static int warn_user = 1;
475 gdb::byte_vector buf (regsize, 0);
479 nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
482 buf.data (), regsize);
483 if (nr_bytes > 0 && nr_bytes != regsize && warn_user)
486 "Size of register %s (%d/%d) "
487 "incorrect (%d instead of %d))",
503 "gdbsim_fetch_register: %d", regno);
518 struct sim_inferior_data *sim_data
530 gdb::byte_vector tmp (regsize);
534 nr_bytes = sim_store_register (sim_data->gdbsim_desc,
537 tmp.data (), regsize);
539 if (nr_bytes > 0 && nr_bytes != regsize)
540 internal_error (_(
"Register size different to expected"));
542 internal_error (_(
"Register %d not updated"), regno);
544 warning (_(
"Register %s not updated"),
578 struct sim_inferior_data *sim_data
584 gdb_argv argv (args);
586 prog = tilde_expand (argv[0]);
589 error (_(
"GDB sim does not yet support a load offset."));
597 if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
598 error (_(
"unable to load program"));
603 sim_data->program_loaded =
true;
617 const std::string &allargs,
618 char **env,
int from_tty)
620 struct sim_inferior_data *sim_data
624 const char *args = allargs.c_str ();
627 warning (_(
"No executable file specified."));
628 if (!sim_data->program_loaded)
629 warning (_(
"No program loaded."));
633 "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
634 (exec_file ? exec_file :
"(NULL)"),
643 if (exec_file != NULL)
645 len = strlen (exec_file) + 1 + allargs.size () + 1 + 10;
646 arg_buf = (
char *) alloca (len);
648 strcat (arg_buf, exec_file);
649 strcat (arg_buf,
" ");
650 strcat (arg_buf, args);
651 built_argv.reset (arg_buf);
654 if (sim_create_inferior (sim_data->gdbsim_desc,
656 built_argv.get (), env)
658 error (_(
"Unable to create sim inferior."));
661 sim_data->remote_sim_ptid.pid ());
681 struct sim_inferior_data *sim_data;
682 SIM_DESC gdbsim_desc;
690 "gdbsim_open: args \"%s\"\n", args ? args :
"(null)");
703 + strlen (
" -E little")
704 + strlen (
" --architecture=xxxxxxxxxx")
705 + strlen (
" --sysroot=") + strlen (sysroot) +
706 + (args ? strlen (args) : 0)
708 arg_buf = (
char *) alloca (len);
709 strcpy (arg_buf,
"gdbsim");
715 strcat (arg_buf,
" -E big");
717 case BFD_ENDIAN_LITTLE:
718 strcat (arg_buf,
" -E little");
720 case BFD_ENDIAN_UNKNOWN:
727 strcat (arg_buf,
" --architecture=");
731 strcat (arg_buf,
" --sysroot=");
732 strcat (arg_buf, sysroot);
736 strcat (arg_buf,
" ");
737 strcat (arg_buf, args);
740 gdb_argv argv (arg_buf);
747 if (gdbsim_desc == 0)
751 error (_(
"unable to create simulator instance"));
762 sim_data->gdbsim_desc = gdbsim_desc;
780 if (sim_data != NULL)
782 ptid_t ptid = sim_data->remote_sim_ptid;
835 inf->unpush_target (
this);
848 struct sim_inferior_data *sim_data
853 sim_data->resume_siggnal = siggnal;
854 sim_data->resume_step = step;
858 _(
"gdbsim_resume: pid %d, step %d, signal %d\n"),
866 struct sim_inferior_data *sim_data
878 else if (ptid == minus_one_ptid)
884 error (_(
"The program is not being run."));
901 sim_inferior_data *sim_data
904 if (sim_data !=
nullptr && !sim_stop (sim_data->gdbsim_desc))
935 target_wait_flags options)
937 struct sim_inferior_data *sim_data;
938 static sighandler_t prev_sigint;
940 enum sim_stop reason = sim_running;
945 if (ptid == minus_one_ptid)
951 if (sim_data == NULL)
952 error (_(
"Unable to wait for pid %d. Inferior not found."),
959#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
961 struct sigaction sa, osa;
963 sigemptyset (&sa.sa_mask);
965 sigaction (SIGINT, &sa, &osa);
966 prev_sigint = osa.sa_handler;
971 sim_resume (sim_data->gdbsim_desc, sim_data->resume_step ? 1 : 0,
972 sim_data->resume_siggnal);
974 signal (SIGINT, prev_sigint);
975 sim_data->resume_step =
false;
977 sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
982 status->set_exited (sigrc);
987 case GDB_SIGNAL_ABRT:
991 case GDB_SIGNAL_TRAP:
993 status->set_stopped ((gdb_signal) sigrc);
998 status->set_signalled ((gdb_signal) sigrc);
1006 return sim_data->remote_sim_ptid;
1026 gdb_byte *readbuf,
const gdb_byte *writebuf,
1027 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
1029 struct sim_inferior_data *sim_data
1039 if (!sim_data->program_loaded)
1040 error (_(
"No program loaded."));
1048 gdb_assert (sim_data->gdbsim_desc != NULL);
1052 "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1053 "memaddr %s, len %s\n",
1054 host_address_to_string (readbuf),
1055 host_address_to_string (writebuf),
1063 l = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);
1067 l = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
1073 *xfered_len = (ULONGEST) l;
1086 const char *annex, gdb_byte *readbuf,
1087 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1088 ULONGEST *xfered_len)
1104 struct sim_inferior_data *sim_data
1106 const char *file =
"nothing";
1116 gdb_printf (
"\tAttached to %s running program %s\n",
1118 sim_info (sim_data->gdbsim_desc, 0);
1140 struct sim_inferior_data *sim_data;
1153 if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1166 error (_(
"Not connected to the simulator target"));
1169 sim_do_command (sim_data->gdbsim_desc, args);
1179 const char *text,
const char *word)
1181 struct sim_inferior_data *sim_data;
1184 if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
1189 struct sim_completions_deleter
1191 void operator() (
char **ptr)
const
1193 for (
size_t i = 0; ptr[i] != NULL; i++)
1199 std::unique_ptr<char *[], sim_completions_deleter> sim_completions
1200 (sim_complete_command (sim_data->gdbsim_desc, text, word));
1201 if (sim_completions == NULL)
1208 while (sim_completions[count] != NULL)
1211 for (
size_t i = count; i > 0; i--)
1213 gdb::unique_xmalloc_ptr<char> match (sim_completions[i - 1]);
1214 sim_completions[i - 1] = NULL;
1224 struct sim_inferior_data *sim_data
1227 if (sim_data == NULL)
1230 if (ptid == sim_data->remote_sim_ptid)
1250 struct sim_inferior_data *sim_data
1253 if (!sim_data->program_loaded)
1262 struct sim_inferior_data *sim_data
1265 if (!sim_data->program_loaded)
1273std::vector<mem_region>
1276 struct sim_inferior_data *sim_data
1278 std::vector<mem_region> result;
1279 gdb::unique_xmalloc_ptr<char> text (sim_memory_map (sim_data->gdbsim_desc));
1281 if (text !=
nullptr)
1296 _(
"Send a command to the simulator."));
struct gdbarch * target_gdbarch(void)
enum bfd_endian selected_byte_order(void)
const char * selected_architecture_name(void)
int remove_breakpoints(void)
void insert_breakpoints(void)
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
int unpush_target(struct target_ops *t)
void push_target(struct target_ops *t)
const std::string & args() const
enum register_status cooked_read(int regnum, gdb_byte *buf)
void raw_supply(int regnum, const void *buf) override
void raw_supply_zeroed(int regnum)
virtual void puts(const char *str)
void virtual void write(const char *buf, long length_buf)=0
void error_no_arg(const char *why)
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_simple_func_ftype *fun, const char *doc)
int check_quit_flag(void)
int(* deprecated_ui_loop_hook)(int signo)
int is_target_filename(const char *name)
#define TARGET_SYSROOT_PREFIX
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
int gdbarch_num_regs(struct gdbarch *gdbarch)
int gdbarch_register_sim_regno(struct gdbarch *gdbarch, int reg_nr)
struct thread_info * add_thread_silent(process_stratum_target *targ, ptid_t ptid)
void switch_to_thread(struct thread_info *thr)
void switch_to_no_thread()
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
void inferior_appeared(struct inferior *inf, int pid)
struct inferior * find_inferior_ptid(process_stratum_target *targ, ptid_t ptid)
struct inferior * find_inferior_pid(process_stratum_target *targ, int pid)
struct inferior * current_inferior(void)
all_inferiors_range all_inferiors(process_stratum_target *proc_target=nullptr)
void generic_mourn_inferior(void)
void clear_proceed_status(int step)
void init_wait_for_inferior(void)
struct ui_file * gdb_stdtarg
struct ui_file * gdb_stdtargerr
std::vector< mem_region > parse_memory_map(const char *memory_map)
struct program_space * current_program_space
int register_size(struct gdbarch *gdbarch, int regnum)
void registers_changed(void)
@ SIM_INSTANCE_NOT_NEEDED
static void gdb_os_evprintf_filtered(host_callback *, const char *, va_list)
static void simulator_command(const char *args, int from_tty)
static host_callback gdb_callback
static int callbacks_initialized
static enum target_xfer_status gdbsim_xfer_memory(struct target_ops *target, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
static const target_info gdbsim_target_info
static const registry< inferior >::key< sim_inferior_data > sim_inferior_data_key
static bool gdbsim_is_open
static int gdb_os_write_stdout(host_callback *, const char *, int)
static void gdbsim_cntrl_c(int signo)
static void dump_mem(const gdb_byte *buf, int len)
static void gdb_os_error(host_callback *, const char *,...)
static void gdb_os_vprintf_filtered(host_callback *, const char *, va_list)
int one2one_register_sim_regno(struct gdbarch *gdbarch, int regnum)
static void gdb_os_printf_filtered(host_callback *, const char *,...)
static void gdbsim_target_open(const char *args, int from_tty)
static int gdb_os_poll_quit(host_callback *)
static struct gdbsim_target gdbsim_ops
static void end_callbacks(void)
static void init_callbacks(void)
static void gdb_os_flush_stderr(host_callback *)
static void gdb_os_flush_stdout(host_callback *)
static int gdb_os_write_stderr(host_callback *, const char *, int)
static struct sim_inferior_data * get_sim_inferior_data(struct inferior *inf, int sim_instance_needed)
void _initialize_remote_sim()
static void ATTRIBUTE_PRINTF(2, 3)
static void sim_command_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
@ SIM_REGNO_DOES_NOT_EXIST
@ LEGACY_SIM_REGNO_IGNORE
bool can_create_inferior() override
void resume_one_inferior(inferior *inf, bool step, gdb_signal siggnal)
void create_inferior(const char *, const std::string &, char **, int) override
void resume(ptid_t, int, enum gdb_signal) override
bool has_all_memory() override
void prepare_to_store(struct regcache *) override
void interrupt() override
void mourn_inferior() override
void close_one_inferior(inferior *inf)
bool has_memory() override
ptid_t wait(ptid_t, struct target_waitstatus *, target_wait_flags) override
std::string pid_to_str(ptid_t) override
void detach(inferior *inf, int) override
void load(const char *, int) override
void fetch_registers(struct regcache *, int) override
enum target_xfer_status xfer_partial(enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) override
std::vector< mem_region > memory_map() override
bool thread_alive(ptid_t ptid) override
void files_info() override
const target_info & info() const override
void store_registers(struct regcache *, int) override
sim_inferior_data * get_inferior_data_by_ptid(ptid_t ptid, int sim_instance_needed)
virtual bool has_memory()
void add_target(const target_info &t, target_open_ftype *func, completer_ftype *completer)
std::string normal_pid_to_str(ptid_t ptid)
const char * target_shortname()
void target_mourn_inferior(ptid_t ptid)
void verror(const char *string, va_list args)
void gdb_vprintf(struct ui_file *stream, const char *format, va_list args)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
void gdb_puts(const char *linebuffer, struct ui_file *stream)