X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fremote-sim.c;h=ae039502dde38f11c0bcbce999379e50ca7fa9d5;hb=001f13d822104158239fe26a05d9154d967cbe56;hp=9b7a7b4db5b72fb1a493f76ce64c6c4380c6bf04;hpb=0c012db1eb9c6b7c951e60cb74d0f6d7bb8738f9;p=binutils-gdb.git diff --git a/gdb/remote-sim.c b/gdb/remote-sim.c index 9b7a7b4db5b..ae039502dde 100644 --- a/gdb/remote-sim.c +++ b/gdb/remote-sim.c @@ -1,7 +1,6 @@ /* Generic remote debugging interface for simulators. - Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, - 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 1993-2013 Free Software Foundation, Inc. Contributed by Cygnus Support. Steve Chamberlain (sac@cygnus.com). @@ -63,7 +62,7 @@ static void gdb_os_flush_stderr (host_callback *); static int gdb_os_poll_quit (host_callback *); -/* printf_filtered is depreciated */ +/* printf_filtered is depreciated. */ static void gdb_os_printf_filtered (host_callback *, const char *, ...); static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list); @@ -79,7 +78,7 @@ static void gdbsim_load (char *prog, int fromtty); static void gdbsim_open (char *args, int from_tty); -static void gdbsim_close (int quitting); +static void gdbsim_close (void); static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty); @@ -119,7 +118,7 @@ struct sim_inferior_data { ptid_t remote_sim_ptid; /* Signal with which to resume. */ - enum target_signal resume_siggnal; + enum gdb_signal resume_siggnal; /* Flag which indicates whether resume should step or not. */ int resume_step; @@ -218,7 +217,7 @@ get_sim_inferior_data (struct inferior *inf, int sim_instance_needed) /* Initialize the other instance variables. */ sim_data->program_loaded = 0; sim_data->gdbsim_desc = sim_desc; - sim_data->resume_siggnal = TARGET_SIGNAL_0; + sim_data->resume_siggnal = GDB_SIGNAL_0; sim_data->resume_step = 0; } else if (sim_desc) @@ -274,28 +273,26 @@ sim_inferior_data_cleanup (struct inferior *inf, void *data) static void dump_mem (char *buf, int len) { - if (len <= 8) + printf_filtered ("\t"); + + if (len == 8 || len == 4) { - if (len == 8 || len == 4) - { - long l[2]; + uint32_t l[2]; - memcpy (l, buf, len); - printf_filtered ("\t0x%lx", l[0]); - if (len == 8) - printf_filtered (" 0x%lx", l[1]); - printf_filtered ("\n"); - } - else - { - int i; + memcpy (l, buf, len); + printf_filtered ("0x%08x", l[0]); + if (len == 8) + printf_filtered (" 0x%08x", l[1]); + } + else + { + int i; - printf_filtered ("\t"); - for (i = 0; i < len; i++) - printf_filtered ("0x%x ", buf[i]); - printf_filtered ("\n"); - } + for (i = 0; i < len; i++) + printf_filtered ("0x%02x ", buf[i]); } + + printf_filtered ("\n"); } /* Initialize gdb_callback. */ @@ -449,7 +446,7 @@ gdbsim_fetch_register (struct target_ops *ops, { /* For moment treat a `does not exist' register the same way as an ``unavailable'' register. */ - char buf[MAX_REGISTER_SIZE]; + gdb_byte buf[MAX_REGISTER_SIZE]; int nr_bytes; memset (buf, 0, MAX_REGISTER_SIZE); @@ -460,7 +457,7 @@ gdbsim_fetch_register (struct target_ops *ops, default: { static int warn_user = 1; - char buf[MAX_REGISTER_SIZE]; + gdb_byte buf[MAX_REGISTER_SIZE]; int nr_bytes; gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch)); @@ -474,7 +471,8 @@ gdbsim_fetch_register (struct target_ops *ops, && nr_bytes != register_size (gdbarch, regno) && warn_user) { fprintf_unfiltered (gdb_stderr, - "Size of register %s (%d/%d) incorrect (%d instead of %d))", + "Size of register %s (%d/%d) " + "incorrect (%d instead of %d))", gdbarch_register_name (gdbarch, regno), regno, gdbarch_register_sim_regno @@ -527,9 +525,13 @@ gdbsim_store_register (struct target_ops *ops, if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno)) internal_error (__FILE__, __LINE__, _("Register size different to expected")); - /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0' - indicating that GDB and the SIM have different ideas about - which registers are fetchable. */ + if (nr_bytes < 0) + internal_error (__FILE__, __LINE__, + _("Register %d not updated"), regno); + if (nr_bytes == 0) + warning (_("Register %s not updated"), + gdbarch_register_name (gdbarch, regno)); + if (remote_debug) { printf_filtered ("gdbsim_store_register: %d", regno); @@ -586,7 +588,7 @@ gdbsim_load (char *args, int fromtty) error (_("unable to load program")); /* FIXME: If a load command should reset the targets registers then - a call to sim_create_inferior() should go here. */ + a call to sim_create_inferior() should go here. */ sim_data->program_loaded = 1; } @@ -637,13 +639,20 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args, } else argv = NULL; - sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env); + + if (!have_inferiors ()) + init_thread_list (); + + if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env) + != SIM_RC_OK) + error (_("Unable to create sim inferior.")); inferior_ptid = sim_data->remote_sim_ptid; inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid)); add_thread_silent (inferior_ptid); - insert_breakpoints (); /* Needed to get correct instruction in cache */ + insert_breakpoints (); /* Needed to get correct instruction + in cache. */ clear_proceed_status (); } @@ -651,7 +660,7 @@ gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args, /* The open routine takes the rest of the parameters from the command, and (if successful) pushes a new target onto the stack. Targets should supply this routine, if only to provide an error message. */ -/* Called when selecting the simulator. EG: (gdb) target sim name. */ +/* Called when selecting the simulator. E.g. (gdb) target sim name. */ static void gdbsim_open (char *args, int from_tty) @@ -677,12 +686,13 @@ gdbsim_open (char *args, int from_tty) len = (7 + 1 /* gdbsim */ + strlen (" -E little") + strlen (" --architecture=xxxxxxxxxx") + + strlen (" --sysroot=") + strlen (gdb_sysroot) + + (args ? strlen (args) : 0) + 50) /* slack */ ; arg_buf = (char *) alloca (len); strcpy (arg_buf, "gdbsim"); /* 7 */ /* Specify the byte order for the target when it is explicitly - specified by the user (not auto detected). */ + specified by the user (not auto detected). */ switch (selected_byte_order ()) { case BFD_ENDIAN_BIG: @@ -701,6 +711,9 @@ gdbsim_open (char *args, int from_tty) strcat (arg_buf, " --architecture="); strcat (arg_buf, selected_architecture_name ()); } + /* Pass along gdb's concept of the sysroot. */ + strcat (arg_buf, " --sysroot="); + strcat (arg_buf, gdb_sysroot); /* finally, any explicit args */ if (args) { @@ -724,7 +737,8 @@ gdbsim_open (char *args, int from_tty) /* Allocate the inferior data, but do not allocate a sim instance since we've already just done that. */ - sim_data = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED); + sim_data = get_sim_inferior_data (current_inferior (), + SIM_INSTANCE_NOT_NEEDED); sim_data->gdbsim_desc = gdbsim_desc; @@ -754,7 +768,7 @@ gdbsim_close_inferior (struct inferior *inf, void *arg) set_inferior_data (inf, sim_inferior_data_key, NULL); /* Having a ptid allocated and stored in remote_sim_ptid does - not mean that a corresponding inferior was ever created. + not mean that a corresponding inferior was ever created. Thus we need to verify the existence of an inferior using the pid in question before setting inferior_ptid via switch_to_thread() or mourning the inferior. */ @@ -768,23 +782,16 @@ gdbsim_close_inferior (struct inferior *inf, void *arg) return 0; } -/* Does whatever cleanup is required for a target that we are no longer - going to be calling. Argument says whether we are quitting gdb and - should not get hung in case of errors, or whether we want a clean - termination even if it takes a while. This routine is automatically - always called just before a routine is popped off the target stack. - Closing file descriptors and freeing memory are typical things it should - do. */ -/* Close out all files and local state before this target loses control. */ +/* Close out all files and local state before this target loses control. */ static void -gdbsim_close (int quitting) +gdbsim_close (void) { struct sim_inferior_data *sim_data = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED); if (remote_debug) - printf_filtered ("gdbsim_close: quitting %d\n", quitting); + printf_filtered ("gdbsim_close\n"); iterate_over_inferiors (gdbsim_close_inferior, NULL); @@ -825,7 +832,7 @@ gdbsim_detach (struct target_ops *ops, char *args, int from_tty) struct resume_data { - enum target_signal siggnal; + enum gdb_signal siggnal; int step; }; @@ -854,7 +861,7 @@ gdbsim_resume_inferior (struct inferior *inf, void *arg) static void gdbsim_resume (struct target_ops *ops, - ptid_t ptid, int step, enum target_signal siggnal) + ptid_t ptid, int step, enum gdb_signal siggnal) { struct resume_data rd; struct sim_inferior_data *sim_data @@ -863,7 +870,7 @@ gdbsim_resume (struct target_ops *ops, rd.siggnal = siggnal; rd.step = step; - /* We don't access any sim_data members within this function. + /* We don't access any sim_data members within this function. What's of interest is whether or not the call to get_sim_inferior_data_by_ptid(), above, is able to obtain a non-NULL pointer. If it managed to obtain a non-NULL pointer, we @@ -921,7 +928,8 @@ gdbsim_stop (ptid_t ptid) struct inferior *inf = find_inferior_pid (ptid_get_pid (ptid)); if (inf == NULL) - error (_("Can't stop pid %d. No inferior found."), ptid_get_pid (ptid)); + error (_("Can't stop pid %d. No inferior found."), + ptid_get_pid (ptid)); gdbsim_stop_inferior (inf, NULL); } @@ -936,13 +944,9 @@ gdb_os_poll_quit (host_callback *p) if (deprecated_ui_loop_hook != NULL) deprecated_ui_loop_hook (0); - if (quit_flag) /* gdb's idea of quit */ - { - quit_flag = 0; /* we've stolen it */ - return 1; - } - else if (immediate_quit) + if (check_quit_flag ()) /* gdb's idea of quit */ { + clear_quit_flag (); /* we've stolen it */ return 1; } return 0; @@ -950,7 +954,7 @@ gdb_os_poll_quit (host_callback *p) /* Wait for inferior process to do something. Return pid of child, or -1 in case of error; store status through argument pointer STATUS, - just as `wait' would. */ + just as `wait' would. */ static void gdbsim_cntrl_c (int signo) @@ -971,7 +975,8 @@ gdbsim_wait (struct target_ops *ops, When ptid is minus_one_ptid, just use the current inferior. If we're given an explicit pid, we'll try to find it and use that instead. */ if (ptid_equal (ptid, minus_one_ptid)) - sim_data = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED); + sim_data = get_sim_inferior_data (current_inferior (), + SIM_INSTANCE_NEEDED); else { sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED); @@ -1013,11 +1018,11 @@ gdbsim_wait (struct target_ops *ops, case sim_stopped: switch (sigrc) { - case TARGET_SIGNAL_ABRT: + case GDB_SIGNAL_ABRT: quit (); break; - case TARGET_SIGNAL_INT: - case TARGET_SIGNAL_TRAP: + case GDB_SIGNAL_INT: + case GDB_SIGNAL_TRAP: default: status->kind = TARGET_WAITKIND_STOPPED; status->value.sig = sigrc; @@ -1030,7 +1035,7 @@ gdbsim_wait (struct target_ops *ops, break; case sim_running: case sim_polling: - /* FIXME: Is this correct? */ + /* FIXME: Is this correct? */ break; } @@ -1046,14 +1051,14 @@ gdbsim_wait (struct target_ops *ops, static void gdbsim_prepare_to_store (struct regcache *regcache) { - /* Do nothing, since we can store individual regs */ + /* Do nothing, since we can store individual regs. */ } /* Transfer LEN bytes between GDB address MYADDR and target address MEMADDR. If WRITE is non-zero, transfer them to the target, otherwise transfer them from the target. TARGET is unused. - Returns the number of bytes transferred. */ + Returns the number of bytes transferred. */ static int gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, @@ -1082,11 +1087,11 @@ gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, if (remote_debug) { - /* FIXME: Send to something other than STDOUT? */ + /* FIXME: Send to something other than STDOUT? */ printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x"); gdb_print_host_address (myaddr, gdb_stdout); printf_filtered (", memaddr %s, len %d, write %d\n", - paddress (target_gdbarch, memaddr), len, write); + paddress (target_gdbarch (), memaddr), len, write); if (remote_debug && write) dump_mem (myaddr, len); } @@ -1166,12 +1171,12 @@ simulator_command (char *args, int from_tty) /* PREVIOUSLY: The user may give a command before the simulator is opened. [...] (??? assuming of course one wishes to continue to allow commands to be sent to unopened simulators, - which isn't entirely unreasonable). */ + which isn't entirely unreasonable). */ /* The simulator is a builtin abstraction of a remote target. Consistent with that model, access to the simulator, via sim commands, is restricted to the period when the channel to the - simulator is open. */ + simulator is open. */ error (_("Not connected to the simulator target")); } @@ -1179,10 +1184,35 @@ simulator_command (char *args, int from_tty) sim_do_command (sim_data->gdbsim_desc, args); /* Invalidate the register cache, in case the simulator command does - something funny. */ + something funny. */ registers_changed (); } +static VEC (char_ptr) * +sim_command_completer (struct cmd_list_element *ignore, const char *text, + const char *word) +{ + struct sim_inferior_data *sim_data; + char **tmp; + int i; + VEC (char_ptr) *result = NULL; + + sim_data = inferior_data (current_inferior (), sim_inferior_data_key); + if (sim_data == NULL || sim_data->gdbsim_desc == NULL) + return NULL; + + tmp = sim_complete_command (sim_data->gdbsim_desc, text, word); + if (tmp == NULL) + return NULL; + + /* Transform the array into a VEC, and then free the array. */ + for (i = 0; tmp[i] != NULL; i++) + VEC_safe_push (char_ptr, result, tmp[i]); + xfree (tmp); + + return result; +} + /* Check to see if a thread is still alive. */ static int @@ -1212,7 +1242,7 @@ gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid) /* Simulator memory may be accessed after the program has been loaded. */ -int +static int gdbsim_has_all_memory (struct target_ops *ops) { struct sim_inferior_data *sim_data @@ -1224,7 +1254,7 @@ gdbsim_has_all_memory (struct target_ops *ops) return 1; } -int +static int gdbsim_has_memory (struct target_ops *ops) { struct sim_inferior_data *sim_data @@ -1236,7 +1266,7 @@ gdbsim_has_memory (struct target_ops *ops) return 1; } -/* Define the target subroutine names */ +/* Define the target subroutine names. */ struct target_ops gdbsim_ops; @@ -1277,12 +1307,15 @@ init_gdbsim_ops (void) void _initialize_remote_sim (void) { + struct cmd_list_element *c; + init_gdbsim_ops (); add_target (&gdbsim_ops); - add_com ("sim", class_obscure, simulator_command, - _("Send a command to the simulator.")); + c = add_com ("sim", class_obscure, simulator_command, + _("Send a command to the simulator.")); + set_cmd_completer (c, sim_command_completer); sim_inferior_data_key - = register_inferior_data_with_cleanup (sim_inferior_data_cleanup); + = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup); }