X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmi%2Fmi-main.c;h=ace9ff76b666b4dbc9ccc4d3aec3b19313b5905a;hb=112e8700a6fd2fed65ca70132c9cbed4132e8bd4;hp=eefe9ecb667911dbb5da8071fd87f36283f8c3f7;hpb=f8eba3c61629b3c03ac1f33853eab4d8507adb9c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c index eefe9ecb66..ace9ff76b6 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -1,7 +1,6 @@ /* MI Command Set. - Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, - 2011 Free Software Foundation, Inc. + Copyright (C) 2000-2016 Free Software Foundation, Inc. Contributed by Cygnus Solutions (a Red Hat company). @@ -20,14 +19,11 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ -/* Work in progress. */ - #include "defs.h" #include "arch-utils.h" #include "target.h" #include "inferior.h" -#include "gdb_string.h" -#include "exceptions.h" +#include "infrun.h" #include "top.h" #include "gdbthread.h" #include "mi-cmds.h" @@ -52,19 +48,16 @@ #include "osdata.h" #include "splay-tree.h" #include "tracepoint.h" +#include "ctf.h" #include "ada-lang.h" #include "linespec.h" +#include "extension.h" +#include "gdbcmd.h" +#include "observer.h" #include -#include - -#if defined HAVE_SYS_RESOURCE_H -#include -#endif - -#ifdef HAVE_GETRUSAGE -struct rusage rusage; -#endif +#include "run-time-clock.h" +#include enum { @@ -72,18 +65,17 @@ enum }; int mi_debug_p; -struct ui_file *raw_stdout; -/* This is used to pass the current command timestamp - down to continuation routines. */ +/* This is used to pass the current command timestamp down to + continuation routines. */ static struct mi_timestamp *current_command_ts; static int do_timings = 0; char *current_token; -/* Few commands would like to know if options like --thread-group - were explicitly specified. This variable keeps the current - parsed command including all option, and make it possible. */ +/* Few commands would like to know if options like --thread-group were + explicitly specified. This variable keeps the current parsed + command including all option, and make it possible. */ static struct mi_parse *current_context; int running_result_record_printed = 1; @@ -97,11 +89,51 @@ static void mi_cmd_execute (struct mi_parse *parse); static void mi_execute_cli_command (const char *cmd, int args_p, const char *args); -static void mi_execute_async_cli_command (char *cli_command, +static void mi_execute_async_cli_command (char *cli_command, char **argv, int argc); static int register_changed_p (int regnum, struct regcache *, struct regcache *); -static void get_register (struct frame_info *, int regnum, int format); +static void output_register (struct frame_info *, int regnum, int format, + int skip_unavailable); + +/* Controls whether the frontend wants MI in async mode. */ +static int mi_async = 0; + +/* The set command writes to this variable. If the inferior is + executing, mi_async is *not* updated. */ +static int mi_async_1 = 0; + +static void +set_mi_async_command (char *args, int from_tty, + struct cmd_list_element *c) +{ + if (have_live_inferiors ()) + { + mi_async_1 = mi_async; + error (_("Cannot change this setting while the inferior is running.")); + } + + mi_async = mi_async_1; +} + +static void +show_mi_async_command (struct ui_file *file, int from_tty, + struct cmd_list_element *c, + const char *value) +{ + fprintf_filtered (file, + _("Whether MI is in asynchronous mode is %s.\n"), + value); +} + +/* A wrapper for target_can_async_p that takes the MI setting into + account. */ + +int +mi_async_p (void) +{ + return mi_async && target_can_async_p (); +} /* Command implementations. FIXME: Is this libgdb? No. This is the MI layer that calls libgdb. Any operation used in the below should be @@ -109,18 +141,21 @@ static void get_register (struct frame_info *, int regnum, int format); static void timestamp (struct mi_timestamp *tv); -static void print_diff_now (struct mi_timestamp *start); -static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end); +static void print_diff (struct ui_file *file, struct mi_timestamp *start, + struct mi_timestamp *end); void mi_cmd_gdb_exit (char *command, char **argv, int argc) { + struct mi_interp *mi + = (struct mi_interp *) interp_data (current_interpreter ()); + /* We have to print everything right here because we never return. */ if (current_token) - fputs_unfiltered (current_token, raw_stdout); - fputs_unfiltered ("^exit\n", raw_stdout); - mi_out_put (current_uiout, raw_stdout); - gdb_flush (raw_stdout); + fputs_unfiltered (current_token, mi->raw_stdout); + fputs_unfiltered ("^exit\n", mi->raw_stdout); + mi_out_put (current_uiout, mi->raw_stdout); + gdb_flush (mi->raw_stdout); /* FIXME: The function called is not yet a formal libgdb function. */ quit_force (NULL, FROM_TTY); } @@ -179,7 +214,7 @@ void mi_cmd_exec_return (char *command, char **argv, int argc) { /* This command doesn't really execute the target, it just pops the - specified number of frames. */ + specified number of frames. */ if (argc) /* Call return_command with from_tty argument equal to 0 so as to avoid being queried. */ @@ -191,7 +226,7 @@ mi_cmd_exec_return (char *command, char **argv, int argc) /* Because we have called return_command with from_tty = 0, we need to print the frame here. */ - print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS); + print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1); } void @@ -200,22 +235,21 @@ mi_cmd_exec_jump (char *args, char **argv, int argc) /* FIXME: Should call a libgdb function, not a cli wrapper. */ mi_execute_async_cli_command ("jump", argv, argc); } - + static void proceed_thread (struct thread_info *thread, int pid) { if (!is_stopped (thread->ptid)) return; - if (pid != 0 && PIDGET (thread->ptid) != pid) + if (pid != 0 && ptid_get_pid (thread->ptid) != pid) return; switch_to_thread (thread->ptid); - clear_proceed_status (); - proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0); + clear_proceed_status (0); + proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT); } - static int proceed_thread_callback (struct thread_info *thread, void *arg) { @@ -228,11 +262,14 @@ proceed_thread_callback (struct thread_info *thread, void *arg) static void exec_continue (char **argv, int argc) { + prepare_execution_command (¤t_target, mi_async_p ()); + if (non_stop) { - /* In non-stop mode, 'resume' always resumes a single thread. Therefore, - to resume all threads of the current inferior, or all threads in all - inferiors, we need to iterate over threads. + /* In non-stop mode, 'resume' always resumes a single thread. + Therefore, to resume all threads of the current inferior, or + all threads in all inferiors, we need to iterate over + threads. See comment on infcmd.c:proceed_thread_callback for rationale. */ if (current_context->all || current_context->thread_group != -1) @@ -257,7 +294,7 @@ exec_continue (char **argv, int argc) } else { - struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi); + scoped_restore save_multi = make_scoped_restore (&sched_multi); if (current_context->all) { @@ -266,12 +303,12 @@ exec_continue (char **argv, int argc) } else { - /* In all-stop mode, -exec-continue traditionally resumed either - all threads, or one thread, depending on the 'scheduler-locking' - variable. Let's continue to do the same. */ + /* In all-stop mode, -exec-continue traditionally resumed + either all threads, or one thread, depending on the + 'scheduler-locking' variable. Let's continue to do the + same. */ continue_1 (1); } - do_cleanups (back_to); } } @@ -316,18 +353,19 @@ interrupt_thread_callback (struct thread_info *thread, void *arg) if (!is_running (thread->ptid)) return 0; - if (PIDGET (thread->ptid) != pid) + if (ptid_get_pid (thread->ptid) != pid) return 0; target_stop (thread->ptid); return 0; } -/* Interrupt the execution of the target. Note how we must play around - with the token variables, in order to display the current token in - the result of the interrupt command, and the previous execution - token when the target finally stops. See comments in +/* Interrupt the execution of the target. Note how we must play + around with the token variables, in order to display the current + token in the result of the interrupt command, and the previous + execution token when the target finally stops. See comments in mi_cmd_execute. */ + void mi_cmd_exec_interrupt (char *command, char **argv, int argc) { @@ -359,9 +397,21 @@ mi_cmd_exec_interrupt (char *command, char **argv, int argc) } } +/* Callback for iterate_over_inferiors which starts the execution + of the given inferior. + + ARG is a pointer to an integer whose value, if non-zero, indicates + that the program should be stopped when reaching the main subprogram + (similar to what the CLI "start" command does). */ + static int run_one_inferior (struct inferior *inf, void *arg) { + int start_p = *(int *) arg; + const char *run_cmd = start_p ? "start" : "run"; + struct target_ops *run_target = find_run_target (); + int async_p = mi_async && run_target->to_can_async_p (run_target); + if (inf->pid != 0) { if (inf->pid != ptid_get_pid (inferior_ptid)) @@ -381,25 +431,64 @@ run_one_inferior (struct inferior *inf, void *arg) switch_to_thread (null_ptid); set_current_program_space (inf->pspace); } - mi_execute_cli_command ("run", target_can_async_p (), - target_can_async_p () ? "&" : NULL); + mi_execute_cli_command (run_cmd, async_p, + async_p ? "&" : NULL); return 0; } void mi_cmd_exec_run (char *command, char **argv, int argc) { + int start_p = 0; + + /* Parse the command options. */ + enum opt + { + START_OPT, + }; + static const struct mi_opt opts[] = + { + {"-start", START_OPT, 0}, + {NULL, 0, 0}, + }; + + int oind = 0; + char *oarg; + + while (1) + { + int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg); + + if (opt < 0) + break; + switch ((enum opt) opt) + { + case START_OPT: + start_p = 1; + break; + } + } + + /* This command does not accept any argument. Make sure the user + did not provide any. */ + if (oind != argc) + error (_("Invalid argument: %s"), argv[oind]); + if (current_context->all) { struct cleanup *back_to = save_current_space_and_thread (); - iterate_over_inferiors (run_one_inferior, NULL); + iterate_over_inferiors (run_one_inferior, &start_p); do_cleanups (back_to); } else { - mi_execute_cli_command ("run", target_can_async_p (), - target_can_async_p () ? "&" : NULL); + const char *run_cmd = start_p ? "start" : "run"; + struct target_ops *run_target = find_run_target (); + int async_p = mi_async && run_target->to_can_async_p (run_target); + + mi_execute_cli_command (run_cmd, async_p, + async_p ? "&" : NULL); } } @@ -409,7 +498,7 @@ find_thread_of_process (struct thread_info *ti, void *p) { int pid = *(int *)p; - if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid)) + if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid)) return 1; return 0; @@ -468,17 +557,29 @@ mi_cmd_thread_select (char *command, char **argv, int argc) { enum gdb_rc rc; char *mi_error_message; + ptid_t previous_ptid = inferior_ptid; if (argc != 1) error (_("-thread-select: USAGE: threadnum.")); rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message); + /* If thread switch did not succeed don't notify or print. */ if (rc == GDB_RC_FAIL) { make_cleanup (xfree, mi_error_message); error ("%s", mi_error_message); } + + print_selected_thread_frame (current_uiout, + USER_SELECTED_THREAD | USER_SELECTED_FRAME); + + /* Notify if the thread has effectively changed. */ + if (!ptid_equal (inferior_ptid, previous_ptid)) + { + observer_notify_user_selected_context_changed (USER_SELECTED_THREAD + | USER_SELECTED_FRAME); + } } void @@ -518,7 +619,7 @@ struct collect_cores_data static int collect_cores (struct thread_info *ti, void *xdata) { - struct collect_cores_data *data = xdata; + struct collect_cores_data *data = (struct collect_cores_data *) xdata; if (ptid_get_pid (ti->ptid) == data->pid) { @@ -551,7 +652,8 @@ struct print_one_inferior_data static int print_one_inferior (struct inferior *inferior, void *xdata) { - struct print_one_inferior_data *top_data = xdata; + struct print_one_inferior_data *top_data + = (struct print_one_inferior_data *) xdata; struct ui_out *uiout = current_uiout; if (VEC_empty (int, top_data->inferiors) @@ -563,15 +665,18 @@ print_one_inferior (struct inferior *inferior, void *xdata) struct cleanup *back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_fmt (uiout, "id", "i%d", inferior->num); - ui_out_field_string (uiout, "type", "process"); + uiout->field_fmt ("id", "i%d", inferior->num); + uiout->field_string ("type", "process"); + if (inferior->has_exit_code) + uiout->field_string ("exit-code", + int_string (inferior->exit_code, 8, 0, 0, 1)); if (inferior->pid != 0) - ui_out_field_int (uiout, "pid", inferior->pid); + uiout->field_int ("pid", inferior->pid); - if (inferior->pspace->ebfd) + if (inferior->pspace->pspace_exec_filename != NULL) { - ui_out_field_string (uiout, "executable", - bfd_get_filename (inferior->pspace->ebfd)); + uiout->field_string ("executable", + inferior->pspace->pspace_exec_filename); } data.cores = 0; @@ -596,7 +701,7 @@ print_one_inferior (struct inferior *inferior, void *xdata) e = unique (b, e); for (; b != e; ++b) - ui_out_field_int (uiout, NULL, *b); + uiout->field_int (NULL, *b); do_cleanups (back_to_2); } @@ -610,8 +715,9 @@ print_one_inferior (struct inferior *inferior, void *xdata) return 0; } -/* Output a field named 'cores' with a list as the value. The elements of - the list are obtained by splitting 'cores' on comma. */ +/* Output a field named 'cores' with a list as the value. The + elements of the list are obtained by splitting 'cores' on + comma. */ static void output_cores (struct ui_out *uiout, const char *field_name, const char *xcores) @@ -624,7 +730,7 @@ output_cores (struct ui_out *uiout, const char *field_name, const char *xcores) make_cleanup (xfree, cores); for (p = strtok (p, ","); p; p = strtok (NULL, ",")) - ui_out_field_string (uiout, NULL, p); + uiout->field_string (NULL, p); do_cleanups (back_to); } @@ -632,7 +738,7 @@ output_cores (struct ui_out *uiout, const char *field_name, const char *xcores) static void free_vector_of_ints (void *xvector) { - VEC (int) **vector = xvector; + VEC (int) **vector = (VEC (int) **) xvector; VEC_free (int, *vector); } @@ -663,7 +769,7 @@ splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb) static void free_splay_tree (void *xt) { - splay_tree t = xt; + splay_tree t = (splay_tree) xt; splay_tree_delete (t); } @@ -674,6 +780,7 @@ list_available_thread_groups (VEC (int) *ids, int recurse) struct osdata_item *item; int ix_items; struct ui_out *uiout = current_uiout; + struct cleanup *cleanup; /* This keeps a map from integer (pid) to VEC (struct osdata_item *)* The vector contains information about all threads for the given pid. @@ -683,7 +790,7 @@ list_available_thread_groups (VEC (int) *ids, int recurse) /* get_osdata will throw if it cannot return data. */ data = get_osdata ("processes"); - make_cleanup_osdata_free (data); + cleanup = make_cleanup_osdata_free (data); if (recurse) { @@ -746,12 +853,12 @@ list_available_thread_groups (VEC (int) *ids, int recurse) back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_fmt (uiout, "id", "%s", pid); - ui_out_field_string (uiout, "type", "process"); + uiout->field_fmt ("id", "%s", pid); + uiout->field_string ("type", "process"); if (cmd) - ui_out_field_string (uiout, "description", cmd); + uiout->field_string ("description", cmd); if (user) - ui_out_field_string (uiout, "user", user); + uiout->field_string ("user", user); if (cores) output_cores (uiout, "cores", cores); @@ -775,9 +882,9 @@ list_available_thread_groups (VEC (int) *ids, int recurse) const char *tid = get_osdata_column (child, "tid"); const char *tcore = get_osdata_column (child, "core"); - ui_out_field_string (uiout, "id", tid); + uiout->field_string ("id", tid); if (tcore) - ui_out_field_string (uiout, "core", tcore); + uiout->field_string ("core", tcore); do_cleanups (back_to_2); } @@ -786,6 +893,8 @@ list_available_thread_groups (VEC (int) *ids, int recurse) do_cleanups (back_to); } + + do_cleanups (cleanup); } void @@ -798,23 +907,23 @@ mi_cmd_list_thread_groups (char *command, char **argv, int argc) VEC (int) *ids = 0; enum opt - { - AVAILABLE_OPT, RECURSE_OPT - }; - static const struct mi_opt opts[] = { - {"-available", AVAILABLE_OPT, 0}, - {"-recurse", RECURSE_OPT, 1}, - { 0, 0, 0 } + AVAILABLE_OPT, RECURSE_OPT }; + static const struct mi_opt opts[] = + { + {"-available", AVAILABLE_OPT, 0}, + {"-recurse", RECURSE_OPT, 1}, + { 0, 0, 0 } + }; - int optind = 0; - char *optarg; + int oind = 0; + char *oarg; while (1) { int opt = mi_getopt ("-list-thread-groups", argc, argv, opts, - &optind, &optarg); + &oind, &oarg); if (opt < 0) break; @@ -824,9 +933,9 @@ mi_cmd_list_thread_groups (char *command, char **argv, int argc) available = 1; break; case RECURSE_OPT: - if (strcmp (optarg, "0") == 0) + if (strcmp (oarg, "0") == 0) ; - else if (strcmp (optarg, "1") == 0) + else if (strcmp (oarg, "1") == 0) recurse = 1; else error (_("only '0' and '1' are valid values " @@ -835,18 +944,18 @@ mi_cmd_list_thread_groups (char *command, char **argv, int argc) } } - for (; optind < argc; ++optind) + for (; oind < argc; ++oind) { char *end; int inf; - if (*(argv[optind]) != 'i') - error (_("invalid syntax of group id '%s'"), argv[optind]); + if (*(argv[oind]) != 'i') + error (_("invalid syntax of group id '%s'"), argv[oind]); - inf = strtoul (argv[optind] + 1, &end, 0); + inf = strtoul (argv[oind] + 1, &end, 0); if (*end != '\0') - error (_("invalid syntax of group id '%s'"), argv[optind]); + error (_("invalid syntax of group id '%s'"), argv[oind]); VEC_safe_push (int, ids, inf); } if (VEC_length (int, ids) > 1) @@ -862,13 +971,13 @@ mi_cmd_list_thread_groups (char *command, char **argv, int argc) } else if (VEC_length (int, ids) == 1) { - /* Local thread groups, single id. */ + /* Local thread groups, single id. */ int id = *VEC_address (int, ids); struct inferior *inf = find_inferior_id (id); if (!inf) error (_("Non-existent thread group id '%d'"), id); - + print_thread_info (uiout, NULL, inf->pid); } else @@ -900,10 +1009,11 @@ mi_cmd_data_list_register_names (char *command, char **argv, int argc) struct cleanup *cleanup; /* Note that the test for a valid register must include checking the - gdbarch_register_name because gdbarch_num_regs may be allocated for - the union of the register sets within a family of related processors. - In this case, some entries of gdbarch_register_name will change depending - upon the particular processor being debugged. */ + gdbarch_register_name because gdbarch_num_regs may be allocated + for the union of the register sets within a family of related + processors. In this case, some entries of gdbarch_register_name + will change depending upon the particular processor being + debugged. */ gdbarch = get_current_arch (); numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); @@ -918,10 +1028,9 @@ mi_cmd_data_list_register_names (char *command, char **argv, int argc) { if (gdbarch_register_name (gdbarch, regnum) == NULL || *(gdbarch_register_name (gdbarch, regnum)) == '\0') - ui_out_field_string (uiout, NULL, ""); + uiout->field_string (NULL, ""); else - ui_out_field_string (uiout, NULL, - gdbarch_register_name (gdbarch, regnum)); + uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum)); } } @@ -934,10 +1043,9 @@ mi_cmd_data_list_register_names (char *command, char **argv, int argc) if (gdbarch_register_name (gdbarch, regnum) == NULL || *(gdbarch_register_name (gdbarch, regnum)) == '\0') - ui_out_field_string (uiout, NULL, ""); + uiout->field_string (NULL, ""); else - ui_out_field_string (uiout, NULL, - gdbarch_register_name (gdbarch, regnum)); + uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum)); } do_cleanups (cleanup); } @@ -953,27 +1061,30 @@ mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) int i; struct cleanup *cleanup; - /* The last time we visited this function, the current frame's register - contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS, - and refresh THIS_REGS with the now-current register contents. */ + /* The last time we visited this function, the current frame's + register contents were saved in THIS_REGS. Move THIS_REGS over + to PREV_REGS, and refresh THIS_REGS with the now-current register + contents. */ prev_regs = this_regs; this_regs = frame_save_as_regcache (get_selected_frame (NULL)); cleanup = make_cleanup_regcache_xfree (prev_regs); /* Note that the test for a valid register must include checking the - gdbarch_register_name because gdbarch_num_regs may be allocated for - the union of the register sets within a family of related processors. - In this case, some entries of gdbarch_register_name will change depending - upon the particular processor being debugged. */ + gdbarch_register_name because gdbarch_num_regs may be allocated + for the union of the register sets within a family of related + processors. In this case, some entries of gdbarch_register_name + will change depending upon the particular processor being + debugged. */ gdbarch = get_regcache_arch (this_regs); numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); make_cleanup_ui_out_list_begin_end (uiout, "changed-registers"); - if (argc == 0) /* No args, just do all the regs. */ + if (argc == 0) { + /* No args, just do all the regs. */ for (regnum = 0; regnum < numregs; regnum++) @@ -986,7 +1097,7 @@ mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) error (_("-data-list-changed-registers: " "Unable to read register contents.")); else if (changed) - ui_out_field_int (uiout, NULL, regnum); + uiout->field_int (NULL, regnum); } } @@ -1005,7 +1116,7 @@ mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) error (_("-data-list-changed-registers: " "Unable to read register contents.")); else if (changed) - ui_out_field_int (uiout, NULL, regnum); + uiout->field_int (NULL, regnum); } else error (_("bad register number")); @@ -1043,11 +1154,13 @@ register_changed_p (int regnum, struct regcache *prev_regs, /* Return a list of register number and value pairs. The valid arguments expected are: a letter indicating the format in which to - display the registers contents. This can be one of: x (hexadecimal), d - (decimal), N (natural), t (binary), o (octal), r (raw). After the - format argumetn there can be a sequence of numbers, indicating which - registers to fetch the content of. If the format is the only argument, - a list of all the registers with their values is returned. */ + display the registers contents. This can be one of: x + (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r + (raw). After the format argument there can be a sequence of + numbers, indicating which registers to fetch the content of. If + the format is the only argument, a list of all the registers with + their values is returned. */ + void mi_cmd_data_list_register_values (char *command, char **argv, int argc) { @@ -1056,19 +1169,48 @@ mi_cmd_data_list_register_values (char *command, char **argv, int argc) struct gdbarch *gdbarch; int regnum, numregs, format; int i; - struct cleanup *list_cleanup, *tuple_cleanup; + struct cleanup *list_cleanup; + int skip_unavailable = 0; + int oind = 0; + enum opt + { + SKIP_UNAVAILABLE, + }; + static const struct mi_opt opts[] = + { + {"-skip-unavailable", SKIP_UNAVAILABLE, 0}, + { 0, 0, 0 } + }; /* Note that the test for a valid register must include checking the - gdbarch_register_name because gdbarch_num_regs may be allocated for - the union of the register sets within a family of related processors. - In this case, some entries of gdbarch_register_name will change depending - upon the particular processor being debugged. */ + gdbarch_register_name because gdbarch_num_regs may be allocated + for the union of the register sets within a family of related + processors. In this case, some entries of gdbarch_register_name + will change depending upon the particular processor being + debugged. */ - if (argc == 0) + while (1) + { + char *oarg; + int opt = mi_getopt ("-data-list-register-values", argc, argv, + opts, &oind, &oarg); + + if (opt < 0) + break; + switch ((enum opt) opt) + { + case SKIP_UNAVAILABLE: + skip_unavailable = 1; + break; + } + } + + if (argc - oind < 1) error (_("-data-list-register-values: Usage: " - "-data-list-register-values [...]")); + "-data-list-register-values [--skip-unavailable] " + " [...]")); - format = (int) argv[0][0]; + format = (int) argv[oind][0]; frame = get_selected_frame (NULL); gdbarch = get_frame_arch (frame); @@ -1076,8 +1218,9 @@ mi_cmd_data_list_register_values (char *command, char **argv, int argc) list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values"); - if (argc == 1) /* No args, beside the format: do all the regs. */ + if (argc - oind == 1) { + /* No args, beside the format: do all the regs. */ for (regnum = 0; regnum < numregs; regnum++) @@ -1085,15 +1228,13 @@ mi_cmd_data_list_register_values (char *command, char **argv, int argc) if (gdbarch_register_name (gdbarch, regnum) == NULL || *(gdbarch_register_name (gdbarch, regnum)) == '\0') continue; - tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_int (uiout, "number", regnum); - get_register (frame, regnum, format); - do_cleanups (tuple_cleanup); + + output_register (frame, regnum, format, skip_unavailable); } } /* Else, list of register #s, just do listed regs. */ - for (i = 1; i < argc; i++) + for (i = 1 + oind; i < argc; i++) { regnum = atoi (argv[i]); @@ -1101,75 +1242,54 @@ mi_cmd_data_list_register_values (char *command, char **argv, int argc) && regnum < numregs && gdbarch_register_name (gdbarch, regnum) != NULL && *gdbarch_register_name (gdbarch, regnum) != '\000') - { - tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_int (uiout, "number", regnum); - get_register (frame, regnum, format); - do_cleanups (tuple_cleanup); - } + output_register (frame, regnum, format, skip_unavailable); else error (_("bad register number")); } do_cleanups (list_cleanup); } -/* Output one register's contents in the desired format. */ +/* Output one register REGNUM's contents in the desired FORMAT. If + SKIP_UNAVAILABLE is true, skip the register if it is + unavailable. */ + static void -get_register (struct frame_info *frame, int regnum, int format) +output_register (struct frame_info *frame, int regnum, int format, + int skip_unavailable) { - struct gdbarch *gdbarch = get_frame_arch (frame); struct ui_out *uiout = current_uiout; - CORE_ADDR addr; - enum lval_type lval; - struct ui_stream *stb; - struct value *val; + struct value *val = value_of_register (regnum, frame); + struct cleanup *tuple_cleanup; + struct value_print_options opts; + struct ui_file *stb; + + if (skip_unavailable && !value_entirely_available (val)) + return; - stb = ui_out_stream_new (uiout); + tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); + uiout->field_int ("number", regnum); if (format == 'N') format = 0; - val = get_frame_register_value (frame, regnum); - - if (value_optimized_out (val)) - error (_("Optimized out")); - if (format == 'r') - { - int j; - char *ptr, buf[1024]; - const gdb_byte *valaddr = value_contents_for_printing (val); + format = 'z'; - strcpy (buf, "0x"); - ptr = buf + 2; - for (j = 0; j < register_size (gdbarch, regnum); j++) - { - int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ? - j : register_size (gdbarch, regnum) - 1 - j; + stb = mem_fileopen (); + make_cleanup_ui_file_delete (stb); - sprintf (ptr, "%02x", (unsigned char) valaddr[idx]); - ptr += 2; - } - ui_out_field_string (uiout, "value", buf); - /*fputs_filtered (buf, gdb_stdout); */ - } - else - { - struct value_print_options opts; + get_formatted_print_options (&opts, format); + opts.deref_ref = 1; + val_print (value_type (val), + value_embedded_offset (val), 0, + stb, 0, val, &opts, current_language); + uiout->field_stream ("value", stb); - get_formatted_print_options (&opts, format); - opts.deref_ref = 1; - val_print (value_type (val), - value_contents_for_printing (val), - value_embedded_offset (val), 0, - stb->stream, 0, val, &opts, current_language); - ui_out_field_stream (uiout, "value", stb); - ui_out_stream_delete (stb); - } + do_cleanups (tuple_cleanup); } /* Write given values into registers. The registers and values are - given as pairs. The corresponding MI command is + given as pairs. The corresponding MI command is -data-write-register-values [ ... ] */ void @@ -1178,13 +1298,13 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc) struct regcache *regcache; struct gdbarch *gdbarch; int numregs, i; - char format; /* Note that the test for a valid register must include checking the - gdbarch_register_name because gdbarch_num_regs may be allocated for - the union of the register sets within a family of related processors. - In this case, some entries of gdbarch_register_name will change depending - upon the particular processor being debugged. */ + gdbarch_register_name because gdbarch_num_regs may be allocated + for the union of the register sets within a family of related + processors. In this case, some entries of gdbarch_register_name + will change depending upon the particular processor being + debugged. */ regcache = get_current_regcache (); gdbarch = get_regcache_arch (regcache); @@ -1194,8 +1314,6 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc) error (_("-data-write-register-values: Usage: -data-write-register-" "values [ ... ]")); - format = (int) argv[0][0]; - if (!target_has_registers) error (_("-data-write-register-values: No registers.")); @@ -1230,46 +1348,41 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc) /* Evaluate the value of the argument. The argument is an expression. If the expression contains spaces it needs to be included in double quotes. */ + void mi_cmd_data_evaluate_expression (char *command, char **argv, int argc) { - struct expression *expr; - struct cleanup *old_chain = NULL; + struct cleanup *old_chain; struct value *val; - struct ui_stream *stb = NULL; + struct ui_file *stb; struct value_print_options opts; struct ui_out *uiout = current_uiout; - stb = ui_out_stream_new (uiout); + stb = mem_fileopen (); + old_chain = make_cleanup_ui_file_delete (stb); if (argc != 1) - { - ui_out_stream_delete (stb); - error (_("-data-evaluate-expression: " - "Usage: -data-evaluate-expression expression")); - } - - expr = parse_expression (argv[0]); + error (_("-data-evaluate-expression: " + "Usage: -data-evaluate-expression expression")); - old_chain = make_cleanup (free_current_contents, &expr); + expression_up expr = parse_expression (argv[0]); - val = evaluate_expression (expr); + val = evaluate_expression (expr.get ()); /* Print the result of the expression evaluation. */ get_user_print_options (&opts); opts.deref_ref = 0; - common_val_print (val, stb->stream, 0, &opts, current_language); + common_val_print (val, stb, 0, &opts, current_language); - ui_out_field_stream (uiout, "value", stb); - ui_out_stream_delete (stb); + uiout->field_stream ("value", stb); do_cleanups (old_chain); } -/* DATA-MEMORY-READ: +/* This is the -data-read-memory command. ADDR: start address of data to be dumped. - WORD-FORMAT: a char indicating format for the ``word''. See + WORD-FORMAT: a char indicating format for the ``word''. See the ``x'' command. WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes. NR_ROW: Number of rows. @@ -1282,55 +1395,51 @@ mi_cmd_data_evaluate_expression (char *command, char **argv, int argc) {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...} - Returns: - The number of bytes read is SIZE*ROW*COL. */ + Returns: + The number of bytes read is SIZE*ROW*COL. */ void mi_cmd_data_read_memory (char *command, char **argv, int argc) { struct gdbarch *gdbarch = get_current_arch (); struct ui_out *uiout = current_uiout; - struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); CORE_ADDR addr; - long total_bytes; - long nr_cols; - long nr_rows; + long total_bytes, nr_cols, nr_rows; char word_format; struct type *word_type; long word_size; char word_asize; char aschar; - gdb_byte *mbuf; int nr_bytes; long offset = 0; - int optind = 0; - char *optarg; + int oind = 0; + char *oarg; enum opt - { - OFFSET_OPT - }; - static const struct mi_opt opts[] = { - {"o", OFFSET_OPT, 1}, - { 0, 0, 0 } + OFFSET_OPT }; + static const struct mi_opt opts[] = + { + {"o", OFFSET_OPT, 1}, + { 0, 0, 0 } + }; while (1) { int opt = mi_getopt ("-data-read-memory", argc, argv, opts, - &optind, &optarg); + &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case OFFSET_OPT: - offset = atol (optarg); + offset = atol (oarg); break; } } - argv += optind; - argc -= optind; + argv += oind; + argc -= oind; if (argc < 5 || argc > 6) error (_("-data-read-memory: Usage: " @@ -1341,7 +1450,7 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) /* Start address of the memory dump. */ addr = parse_and_eval_address (argv[0]) + offset; /* The format character to use when displaying a memory word. See - the ``x'' command. */ + the ``x'' command. */ word_format = argv[1][0]; /* The size of the memory word. */ word_size = atol (argv[2]); @@ -1385,36 +1494,37 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) /* Create a buffer and read it in. */ total_bytes = word_size * nr_rows * nr_cols; - mbuf = xcalloc (total_bytes, 1); - make_cleanup (xfree, mbuf); + + std::unique_ptr mbuf (new gdb_byte[total_bytes]); /* Dispatch memory reads to the topmost target, not the flattened current_target. */ nr_bytes = target_read (current_target.beneath, - TARGET_OBJECT_MEMORY, NULL, mbuf, + TARGET_OBJECT_MEMORY, NULL, mbuf.get (), addr, total_bytes); if (nr_bytes <= 0) error (_("Unable to read memory.")); /* Output the header information. */ - ui_out_field_core_addr (uiout, "addr", gdbarch, addr); - ui_out_field_int (uiout, "nr-bytes", nr_bytes); - ui_out_field_int (uiout, "total-bytes", total_bytes); - ui_out_field_core_addr (uiout, "next-row", - gdbarch, addr + word_size * nr_cols); - ui_out_field_core_addr (uiout, "prev-row", - gdbarch, addr - word_size * nr_cols); - ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes); - ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes); + uiout->field_core_addr ("addr", gdbarch, addr); + uiout->field_int ("nr-bytes", nr_bytes); + uiout->field_int ("total-bytes", total_bytes); + uiout->field_core_addr ("next-row", gdbarch, addr + word_size * nr_cols); + uiout->field_core_addr ("prev-row", gdbarch, addr - word_size * nr_cols); + uiout->field_core_addr ("next-page", gdbarch, addr + total_bytes); + uiout->field_core_addr ("prev-page", gdbarch, addr - total_bytes); /* Build the result as a two dimentional table. */ { - struct ui_stream *stream = ui_out_stream_new (uiout); - struct cleanup *cleanup_list_memory; + struct ui_file *stream; + struct cleanup *cleanup_stream; int row; int row_byte; - cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory"); + stream = mem_fileopen (); + cleanup_stream = make_cleanup_ui_file_delete (stream); + + make_cleanup_ui_out_list_begin_end (uiout, "memory"); for (row = 0, row_byte = 0; row < nr_rows; row++, row_byte += nr_cols * word_size) @@ -1426,7 +1536,7 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) struct value_print_options opts; cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte); + uiout->field_core_addr ("addr", gdbarch, addr + row_byte); /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */ cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data"); @@ -1437,14 +1547,14 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) { if (col_byte + word_size > nr_bytes) { - ui_out_field_string (uiout, NULL, "N/A"); + uiout->field_string (NULL, "N/A"); } else { - ui_file_rewind (stream->stream); - print_scalar_formatted (mbuf + col_byte, word_type, &opts, - word_asize, stream->stream); - ui_out_field_stream (uiout, NULL, stream); + ui_file_rewind (stream); + print_scalar_formatted (&mbuf[col_byte], word_type, &opts, + word_asize, stream); + uiout->field_stream (NULL, stream); } } do_cleanups (cleanup_list_data); @@ -1452,29 +1562,23 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) { int byte; - ui_file_rewind (stream->stream); + ui_file_rewind (stream); for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++) { if (byte >= nr_bytes) - { - fputc_unfiltered ('X', stream->stream); - } + fputc_unfiltered ('X', stream); else if (mbuf[byte] < 32 || mbuf[byte] > 126) - { - fputc_unfiltered (aschar, stream->stream); - } + fputc_unfiltered (aschar, stream); else - fputc_unfiltered (mbuf[byte], stream->stream); + fputc_unfiltered (mbuf[byte], stream); } - ui_out_field_stream (uiout, "ascii", stream); + uiout->field_stream ("ascii", stream); } do_cleanups (cleanup_tuple); } - ui_out_stream_delete (stream); - do_cleanups (cleanup_list_memory); + do_cleanups (cleanup_stream); } - do_cleanups (cleanups); } void @@ -1489,33 +1593,34 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) int ix; VEC(memory_read_result_s) *result; long offset = 0; - int optind = 0; - char *optarg; + int unit_size = gdbarch_addressable_memory_unit_size (gdbarch); + int oind = 0; + char *oarg; enum opt - { - OFFSET_OPT - }; - static const struct mi_opt opts[] = { - {"o", OFFSET_OPT, 1}, - { 0, 0, 0 } + OFFSET_OPT }; + static const struct mi_opt opts[] = + { + {"o", OFFSET_OPT, 1}, + { 0, 0, 0 } + }; while (1) { int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts, - &optind, &optarg); + &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case OFFSET_OPT: - offset = atol (optarg); + offset = atol (oarg); break; } } - argv += optind; - argc -= optind; + argv += oind; + argc -= oind; if (argc != 2) error (_("Usage: [ -o OFFSET ] ADDR LENGTH.")); @@ -1525,7 +1630,7 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) result = read_memory_robust (current_target.beneath, addr, length); - cleanups = make_cleanup (free_memory_read_result_vector, result); + cleanups = make_cleanup (free_memory_read_result_vector, &result); if (VEC_length (memory_read_result_s, result) == 0) error (_("Unable to read memory.")); @@ -1538,29 +1643,29 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); char *data, *p; int i; + int alloc_len; - ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin); - ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin - - addr); - ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end); + uiout->field_core_addr ("begin", gdbarch, read_result->begin); + uiout->field_core_addr ("offset", gdbarch, read_result->begin - addr); + uiout->field_core_addr ("end", gdbarch, read_result->end); - data = xmalloc ((read_result->end - read_result->begin) * 2 + 1); + alloc_len = (read_result->end - read_result->begin) * 2 * unit_size + 1; + data = (char *) xmalloc (alloc_len); for (i = 0, p = data; - i < (read_result->end - read_result->begin); + i < ((read_result->end - read_result->begin) * unit_size); ++i, p += 2) { sprintf (p, "%02x", read_result->data[i]); } - ui_out_field_string (uiout, "contents", data); + uiout->field_string ("contents", data); xfree (data); do_cleanups (t); } do_cleanups (cleanups); } - -/* DATA-MEMORY-WRITE: +/* Implementation of the -data-write_memory command. COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The offset from the beginning of the memory grid row where the cell to @@ -1568,7 +1673,7 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) ADDR: start address of the row in the memory grid where the memory cell is, if OFFSET_COLUMN is specified. Otherwise, the address of the location to write to. - FORMAT: a char indicating format for the ``word''. See + FORMAT: a char indicating format for the ``word''. See the ``x'' command. WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes VALUE: value to be written into the memory address. @@ -1576,48 +1681,48 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE). Prints nothing. */ + void mi_cmd_data_write_memory (char *command, char **argv, int argc) { struct gdbarch *gdbarch = get_current_arch (); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); CORE_ADDR addr; - char word_format; long word_size; /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big enough when using a compiler other than GCC. */ LONGEST value; - void *buffer; + gdb_byte *buffer; struct cleanup *old_chain; long offset = 0; - int optind = 0; - char *optarg; + int oind = 0; + char *oarg; enum opt - { - OFFSET_OPT - }; - static const struct mi_opt opts[] = { - {"o", OFFSET_OPT, 1}, - { 0, 0, 0 } + OFFSET_OPT }; + static const struct mi_opt opts[] = + { + {"o", OFFSET_OPT, 1}, + { 0, 0, 0 } + }; while (1) { int opt = mi_getopt ("-data-write-memory", argc, argv, opts, - &optind, &optarg); + &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case OFFSET_OPT: - offset = atol (optarg); + offset = atol (oarg); break; } } - argv += optind; - argc -= optind; + argv += oind; + argc -= oind; if (argc != 4) error (_("-data-write-memory: Usage: " @@ -1626,10 +1731,7 @@ mi_cmd_data_write_memory (char *command, char **argv, int argc) /* Extract all the arguments. */ /* Start address of the memory dump. */ addr = parse_and_eval_address (argv[0]); - /* The format character to use when displaying a memory word. See - the ``x'' command. */ - word_format = argv[1][0]; - /* The size of the memory word. */ + /* The size of the memory word. */ word_size = atol (argv[2]); /* Calculate the real address of the write destination. */ @@ -1638,53 +1740,95 @@ mi_cmd_data_write_memory (char *command, char **argv, int argc) /* Get the value as a number. */ value = parse_and_eval_address (argv[3]); /* Get the value into an array. */ - buffer = xmalloc (word_size); + buffer = (gdb_byte *) xmalloc (word_size); old_chain = make_cleanup (xfree, buffer); store_signed_integer (buffer, word_size, byte_order, value); /* Write it down to memory. */ - write_memory (addr, buffer, word_size); + write_memory_with_notification (addr, buffer, word_size); /* Free the buffer. */ do_cleanups (old_chain); } -/* DATA-MEMORY-WRITE-RAW: +/* Implementation of the -data-write-memory-bytes command. ADDR: start address - DATA: string of bytes to write at that address. */ + DATA: string of bytes to write at that address + COUNT: number of bytes to be filled (decimal integer). */ + void mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc) { CORE_ADDR addr; char *cdata; gdb_byte *data; - int len, r, i; + gdb_byte *databuf; + size_t len_hex, len_bytes, len_units, i, steps, remaining_units; + long int count_units; struct cleanup *back_to; + int unit_size; - if (argc != 2) - error (_("Usage: ADDR DATA.")); + if (argc != 2 && argc != 3) + error (_("Usage: ADDR DATA [COUNT].")); addr = parse_and_eval_address (argv[0]); cdata = argv[1]; - len = strlen (cdata)/2; + len_hex = strlen (cdata); + unit_size = gdbarch_addressable_memory_unit_size (get_current_arch ()); + + if (len_hex % (unit_size * 2) != 0) + error (_("Hex-encoded '%s' must represent an integral number of " + "addressable memory units."), + cdata); - data = xmalloc (len); - back_to = make_cleanup (xfree, data); + len_bytes = len_hex / 2; + len_units = len_bytes / unit_size; - for (i = 0; i < len; ++i) + if (argc == 3) + count_units = strtoul (argv[2], NULL, 10); + else + count_units = len_units; + + databuf = XNEWVEC (gdb_byte, len_bytes); + back_to = make_cleanup (xfree, databuf); + + for (i = 0; i < len_bytes; ++i) { int x; - sscanf (cdata + i * 2, "%02x", &x); - data[i] = (gdb_byte)x; + if (sscanf (cdata + i * 2, "%02x", &x) != 1) + error (_("Invalid argument")); + databuf[i] = (gdb_byte) x; + } + + if (len_units < count_units) + { + /* Pattern is made of less units than count: + repeat pattern to fill memory. */ + data = (gdb_byte *) xmalloc (count_units * unit_size); + make_cleanup (xfree, data); + + /* Number of times the pattern is entirely repeated. */ + steps = count_units / len_units; + /* Number of remaining addressable memory units. */ + remaining_units = count_units % len_units; + for (i = 0; i < steps; i++) + memcpy (data + i * len_bytes, databuf, len_bytes); + + if (remaining_units > 0) + memcpy (data + steps * len_bytes, databuf, + remaining_units * unit_size); + } + else + { + /* Pattern is longer than or equal to count: + just copy count addressable memory units. */ + data = databuf; } - r = target_write_memory (addr, data, len); - if (r != 0) - error (_("Could not write memory")); + write_memory_with_notification (addr, data, count_units); do_cleanups (back_to); } - void mi_cmd_enable_timings (char *command, char **argv, int argc) { @@ -1701,7 +1845,7 @@ mi_cmd_enable_timings (char *command, char **argv, int argc) } else goto usage_error; - + return; usage_error: @@ -1716,18 +1860,21 @@ mi_cmd_list_features (char *command, char **argv, int argc) struct cleanup *cleanup = NULL; struct ui_out *uiout = current_uiout; - cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features"); - ui_out_field_string (uiout, NULL, "frozen-varobjs"); - ui_out_field_string (uiout, NULL, "pending-breakpoints"); - ui_out_field_string (uiout, NULL, "thread-info"); - ui_out_field_string (uiout, NULL, "data-read-memory-bytes"); - ui_out_field_string (uiout, NULL, "breakpoint-notifications"); - ui_out_field_string (uiout, NULL, "ada-task-info"); - -#if HAVE_PYTHON - ui_out_field_string (uiout, NULL, "python"); -#endif - + cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features"); + uiout->field_string (NULL, "frozen-varobjs"); + uiout->field_string (NULL, "pending-breakpoints"); + uiout->field_string (NULL, "thread-info"); + uiout->field_string (NULL, "data-read-memory-bytes"); + uiout->field_string (NULL, "breakpoint-notifications"); + uiout->field_string (NULL, "ada-task-info"); + uiout->field_string (NULL, "language-option"); + uiout->field_string (NULL, "info-gdb-mi-command"); + uiout->field_string (NULL, "undefined-command-error-code"); + uiout->field_string (NULL, "exec-run-start-option"); + + if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON))) + uiout->field_string (NULL, "python"); + do_cleanups (cleanup); return; } @@ -1743,12 +1890,11 @@ mi_cmd_list_target_features (char *command, char **argv, int argc) struct cleanup *cleanup = NULL; struct ui_out *uiout = current_uiout; - cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features"); - if (target_can_async_p ()) - ui_out_field_string (uiout, NULL, "async"); + cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features"); + if (mi_async_p ()) + uiout->field_string (NULL, "async"); if (target_can_execute_reverse) - ui_out_field_string (uiout, NULL, "reverse"); - + uiout->field_string (NULL, "reverse"); do_cleanups (cleanup); return; } @@ -1766,12 +1912,12 @@ mi_cmd_add_inferior (char *command, char **argv, int argc) inf = add_inferior_with_spaces (); - ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num); + current_uiout->field_fmt ("inferior", "i%d", inf->num); } -/* Callback used to find the first inferior other than the - current one. */ - +/* Callback used to find the first inferior other than the current + one. */ + static int get_other_inferior (struct inferior *inf, void *arg) { @@ -1803,7 +1949,7 @@ mi_cmd_remove_inferior (char *command, char **argv, int argc) if (inf == current_inferior ()) { struct thread_info *tp = 0; - struct inferior *new_inferior + struct inferior *new_inferior = iterate_over_inferiors (get_other_inferior, NULL); if (new_inferior == NULL) @@ -1816,7 +1962,7 @@ mi_cmd_remove_inferior (char *command, char **argv, int argc) set_current_program_space (new_inferior->pspace); } - delete_inferior_1 (inf, 1 /* silent */); + delete_inferior (inf); } @@ -1826,11 +1972,12 @@ mi_cmd_remove_inferior (char *command, char **argv, int argc) args->action will tell mi_execute_command what action to perfrom after the given command has executed (display/suppress - prompt, display error). */ + prompt, display error). */ static void captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) { + struct mi_interp *mi = (struct mi_interp *) interp_data (command_interp ()); struct cleanup *cleanup; if (do_timings) @@ -1847,34 +1994,34 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) /* A MI command was read from the input stream. */ if (mi_debug_p) /* FIXME: gdb_???? */ - fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n", + fprintf_unfiltered (mi->raw_stdout, + " token=`%s' command=`%s' args=`%s'\n", context->token, context->command, context->args); - mi_cmd_execute (context); /* Print the result if there were no errors. Remember that on the way out of executing a command, you have - to directly use the mi_interp's uiout, since the command could - have reset the interpreter, in which case the current uiout - will most likely crash in the mi_out_* routines. */ + to directly use the mi_interp's uiout, since the command + could have reset the interpreter, in which case the current + uiout will most likely crash in the mi_out_* routines. */ if (!running_result_record_printed) { - fputs_unfiltered (context->token, raw_stdout); + fputs_unfiltered (context->token, mi->raw_stdout); /* There's no particularly good reason why target-connect results in not ^done. Should kill ^connected for MI3. */ fputs_unfiltered (strcmp (context->command, "target-select") == 0 - ? "^connected" : "^done", raw_stdout); - mi_out_put (uiout, raw_stdout); + ? "^connected" : "^done", mi->raw_stdout); + mi_out_put (uiout, mi->raw_stdout); mi_out_rewind (uiout); - mi_print_timing_maybe (); - fputs_unfiltered ("\n", raw_stdout); + mi_print_timing_maybe (mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); } else - /* The command does not want anything to be printed. In that - case, the command probably should not have written anything - to uiout, but in case it has written something, discard it. */ + /* The command does not want anything to be printed. In that + case, the command probably should not have written anything + to uiout, but in case it has written something, discard it. */ mi_out_rewind (uiout); break; @@ -1888,7 +2035,7 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) /* Echo the command on the console. */ fprintf_unfiltered (gdb_stdlog, "%s\n", context->command); /* Call the "console" interpreter. */ - argv[0] = "console"; + argv[0] = INTERP_CONSOLE; argv[1] = context->command; mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2); @@ -1900,24 +2047,21 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) { if (!running_result_record_printed) { - fputs_unfiltered (context->token, raw_stdout); - fputs_unfiltered ("^done", raw_stdout); - mi_out_put (uiout, raw_stdout); + fputs_unfiltered (context->token, mi->raw_stdout); + fputs_unfiltered ("^done", mi->raw_stdout); + mi_out_put (uiout, mi->raw_stdout); mi_out_rewind (uiout); - mi_print_timing_maybe (); - fputs_unfiltered ("\n", raw_stdout); + mi_print_timing_maybe (mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); } else mi_out_rewind (uiout); } break; } - } do_cleanups (cleanup); - - return; } /* Print a gdb exception to the MI output stream. */ @@ -1925,21 +2069,60 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) static void mi_print_exception (const char *token, struct gdb_exception exception) { - fputs_unfiltered (token, raw_stdout); - fputs_unfiltered ("^error,msg=\"", raw_stdout); + struct mi_interp *mi + = (struct mi_interp *) interp_data (current_interpreter ()); + + fputs_unfiltered (token, mi->raw_stdout); + fputs_unfiltered ("^error,msg=\"", mi->raw_stdout); if (exception.message == NULL) - fputs_unfiltered ("unknown error", raw_stdout); + fputs_unfiltered ("unknown error", mi->raw_stdout); else - fputstr_unfiltered (exception.message, '"', raw_stdout); - fputs_unfiltered ("\"\n", raw_stdout); + fputstr_unfiltered (exception.message, '"', mi->raw_stdout); + fputs_unfiltered ("\"", mi->raw_stdout); + + switch (exception.error) + { + case UNDEFINED_COMMAND_ERROR: + fputs_unfiltered (",code=\"undefined-command\"", mi->raw_stdout); + break; + } + + fputs_unfiltered ("\n", mi->raw_stdout); +} + +/* Determine whether the parsed command already notifies the + user_selected_context_changed observer. */ + +static int +command_notifies_uscc_observer (struct mi_parse *command) +{ + if (command->op == CLI_COMMAND) + { + /* CLI commands "thread" and "inferior" already send it. */ + return (strncmp (command->command, "thread ", 7) == 0 + || strncmp (command->command, "inferior ", 9) == 0); + } + else /* MI_COMMAND */ + { + if (strcmp (command->command, "interpreter-exec") == 0 + && command->argc > 1) + { + /* "thread" and "inferior" again, but through -interpreter-exec. */ + return (strncmp (command->argv[1], "thread ", 7) == 0 + || strncmp (command->argv[1], "inferior ", 9) == 0); + } + + else + /* -thread-select already sends it. */ + return strcmp (command->command, "thread-select") == 0; + } } void -mi_execute_command (char *cmd, int from_tty) +mi_execute_command (const char *cmd, int from_tty) { char *token; struct mi_parse *command = NULL; - volatile struct gdb_exception exception; /* This is to handle EOF (^D). We just quit gdb. */ /* FIXME: we should call some API function here. */ @@ -1948,55 +2131,70 @@ mi_execute_command (char *cmd, int from_tty) target_log_command (cmd); - TRY_CATCH (exception, RETURN_MASK_ALL) + TRY { command = mi_parse (cmd, &token); } - if (exception.reason < 0) + CATCH (exception, RETURN_MASK_ALL) { mi_print_exception (token, exception); xfree (token); } - else + END_CATCH + + if (command != NULL) { - volatile struct gdb_exception result; ptid_t previous_ptid = inferior_ptid; + struct cleanup *cleanup = make_cleanup (null_cleanup, NULL); command->token = token; + if (command->cmd != NULL && command->cmd->suppress_notification != NULL) + { + make_cleanup_restore_integer (command->cmd->suppress_notification); + *command->cmd->suppress_notification = 1; + } + if (do_timings) { - command->cmd_start = (struct mi_timestamp *) - xmalloc (sizeof (struct mi_timestamp)); + command->cmd_start = new mi_timestamp (); timestamp (command->cmd_start); } - TRY_CATCH (result, RETURN_MASK_ALL) + TRY { captured_mi_execute_command (current_uiout, command); } - if (result.reason < 0) + CATCH (result, RETURN_MASK_ALL) { + /* Like in start_event_loop, enable input and force display + of the prompt. Otherwise, any command that calls + async_disable_stdin, and then throws, will leave input + disabled. */ + async_enable_stdin (); + current_ui->prompt_state = PROMPT_NEEDED; + /* The command execution failed and error() was called somewhere. */ mi_print_exception (command->token, result); mi_out_rewind (current_uiout); } + END_CATCH bpstat_do_actions (); if (/* The notifications are only output when the top-level - interpreter (specified on the command line) is MI. */ - ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ())) - /* Don't try report anything if there are no threads -- + interpreter (specified on the command line) is MI. */ + interp_ui_out (top_level_interpreter ())->is_mi_like_p () + /* Don't try report anything if there are no threads -- the program is dead. */ && thread_count () != 0 - /* -thread-select explicitly changes thread. If frontend uses that - internally, we don't want to emit =thread-selected, since - =thread-selected is supposed to indicate user's intentions. */ - && strcmp (command->command, "thread-select") != 0) + /* If the command already reports the thread change, no need to do it + again. */ + && !command_notifies_uscc_observer (command)) { - struct mi_interp *mi = top_level_interpreter_data (); + struct mi_interp *mi + = (struct mi_interp *) top_level_interpreter_data (); int report_change = 0; if (command->thread == -1) @@ -2009,28 +2207,20 @@ mi_execute_command (char *cmd, int from_tty) { struct thread_info *ti = inferior_thread (); - report_change = (ti->num != command->thread); + report_change = (ti->global_num != command->thread); } if (report_change) - { - struct thread_info *ti = inferior_thread (); - - target_terminal_ours (); - fprintf_unfiltered (mi->event_channel, - "thread-selected,id=\"%d\"", - ti->num); - gdb_flush (mi->event_channel); + { + observer_notify_user_selected_context_changed + (USER_SELECTED_THREAD | USER_SELECTED_FRAME); } } mi_parse_free (command); - } - fputs_unfiltered ("(gdb) \n", raw_stdout); - gdb_flush (raw_stdout); - /* Print any buffered hook code. */ - /* ..... */ + do_cleanups (cleanup); + } } static void @@ -2062,18 +2252,19 @@ mi_cmd_execute (struct mi_parse *parse) set_current_inferior (inf); /* This behaviour means that if --thread-group option identifies - an inferior with multiple threads, then a random one will be picked. - This is not a problem -- frontend should always provide --thread if - it wishes to operate on a specific thread. */ + an inferior with multiple threads, then a random one will be + picked. This is not a problem -- frontend should always + provide --thread if it wishes to operate on a specific + thread. */ if (inf->pid != 0) - tp = any_thread_of_process (inf->pid); + tp = any_live_thread_of_process (inf->pid); switch_to_thread (tp ? tp->ptid : null_ptid); set_current_program_space (inf->pspace); } if (parse->thread != -1) { - struct thread_info *tp = find_thread_id (parse->thread); + struct thread_info *tp = find_thread_global_id (parse->thread); if (!tp) error (_("Invalid thread id: %d"), parse->thread); @@ -2097,14 +2288,14 @@ mi_cmd_execute (struct mi_parse *parse) error (_("Invalid frame id: %d"), frame); } - current_context = parse; - - if (strncmp (parse->command, "break-", sizeof ("break-") - 1 ) == 0) + if (parse->language != language_unknown) { - make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications); - mi_suppress_breakpoint_notifications = 1; + make_cleanup_restore_current_language (); + set_language (parse->language); } + current_context = parse; + if (parse->cmd->argv_func != NULL) { parse->cmd->argv_func (parse->command, parse->argv, parse->argc); @@ -2155,7 +2346,7 @@ mi_execute_cli_command (const char *cmd, int args_p, const char *args) fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n", cmd, run); old_cleanups = make_cleanup (xfree, run); - execute_command ( /*ui */ run, 0 /*from_tty */ ); + execute_command (run, 0 /* from_tty */ ); do_cleanups (old_cleanups); return; } @@ -2167,13 +2358,13 @@ mi_execute_async_cli_command (char *cli_command, char **argv, int argc) struct cleanup *old_cleanups; char *run; - if (target_can_async_p ()) + if (mi_async_p ()) run = xstrprintf ("%s %s&", cli_command, argc ? *argv : ""); else run = xstrprintf ("%s %s", cli_command, argc ? *argv : ""); - old_cleanups = make_cleanup (xfree, run); + old_cleanups = make_cleanup (xfree, run); - execute_command ( /*ui */ run, 0 /*from_tty */ ); + execute_command (run, 0 /* from_tty */ ); /* Do this before doing any printing. It would appear that some print code leaves garbage around in the buffer. */ @@ -2187,12 +2378,14 @@ mi_load_progress (const char *section_name, unsigned long total_sent, unsigned long grand_total) { - struct timeval time_now, delta, update_threshold; - static struct timeval last_update; + using namespace std::chrono; + static steady_clock::time_point last_update; static char *previous_sect_name = NULL; int new_section; struct ui_out *saved_uiout; struct ui_out *uiout; + struct mi_interp *mi + = (struct mi_interp *) interp_data (current_interpreter ()); /* This function is called through deprecated_show_load_progress which means uiout may not be correct. Fix it for the duration @@ -2211,19 +2404,6 @@ mi_load_progress (const char *section_name, uiout = current_uiout; - update_threshold.tv_sec = 0; - update_threshold.tv_usec = 500000; - gettimeofday (&time_now, NULL); - - delta.tv_usec = time_now.tv_usec - last_update.tv_usec; - delta.tv_sec = time_now.tv_sec - last_update.tv_sec; - - if (delta.tv_usec < 0) - { - delta.tv_sec -= 1; - delta.tv_usec += 1000000L; - } - new_section = (previous_sect_name ? strcmp (previous_sect_name, section_name) : 1); if (new_section) @@ -2234,107 +2414,89 @@ mi_load_progress (const char *section_name, previous_sect_name = xstrdup (section_name); if (current_token) - fputs_unfiltered (current_token, raw_stdout); - fputs_unfiltered ("+download", raw_stdout); + fputs_unfiltered (current_token, mi->raw_stdout); + fputs_unfiltered ("+download", mi->raw_stdout); cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_string (uiout, "section", section_name); - ui_out_field_int (uiout, "section-size", total_section); - ui_out_field_int (uiout, "total-size", grand_total); + uiout->field_string ("section", section_name); + uiout->field_int ("section-size", total_section); + uiout->field_int ("total-size", grand_total); do_cleanups (cleanup_tuple); - mi_out_put (uiout, raw_stdout); - fputs_unfiltered ("\n", raw_stdout); - gdb_flush (raw_stdout); + mi_out_put (uiout, mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); + gdb_flush (mi->raw_stdout); } - if (delta.tv_sec >= update_threshold.tv_sec && - delta.tv_usec >= update_threshold.tv_usec) + steady_clock::time_point time_now = steady_clock::now (); + if (time_now - last_update > milliseconds (500)) { struct cleanup *cleanup_tuple; - last_update.tv_sec = time_now.tv_sec; - last_update.tv_usec = time_now.tv_usec; + last_update = time_now; if (current_token) - fputs_unfiltered (current_token, raw_stdout); - fputs_unfiltered ("+download", raw_stdout); + fputs_unfiltered (current_token, mi->raw_stdout); + fputs_unfiltered ("+download", mi->raw_stdout); cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_string (uiout, "section", section_name); - ui_out_field_int (uiout, "section-sent", sent_so_far); - ui_out_field_int (uiout, "section-size", total_section); - ui_out_field_int (uiout, "total-sent", total_sent); - ui_out_field_int (uiout, "total-size", grand_total); + uiout->field_string ("section", section_name); + uiout->field_int ("section-sent", sent_so_far); + uiout->field_int ("section-size", total_section); + uiout->field_int ("total-sent", total_sent); + uiout->field_int ("total-size", grand_total); do_cleanups (cleanup_tuple); - mi_out_put (uiout, raw_stdout); - fputs_unfiltered ("\n", raw_stdout); - gdb_flush (raw_stdout); + mi_out_put (uiout, mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); + gdb_flush (mi->raw_stdout); } xfree (uiout); current_uiout = saved_uiout; } -static void +static void timestamp (struct mi_timestamp *tv) - { - gettimeofday (&tv->wallclock, NULL); -#ifdef HAVE_GETRUSAGE - getrusage (RUSAGE_SELF, &rusage); - tv->utime.tv_sec = rusage.ru_utime.tv_sec; - tv->utime.tv_usec = rusage.ru_utime.tv_usec; - tv->stime.tv_sec = rusage.ru_stime.tv_sec; - tv->stime.tv_usec = rusage.ru_stime.tv_usec; -#else - { - long usec = get_run_time (); - - tv->utime.tv_sec = usec/1000000L; - tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec; - tv->stime.tv_sec = 0; - tv->stime.tv_usec = 0; - } -#endif - } +{ + using namespace std::chrono; -static void -print_diff_now (struct mi_timestamp *start) - { - struct mi_timestamp now; + tv->wallclock = steady_clock::now (); + run_time_clock::now (tv->utime, tv->stime); +} - timestamp (&now); - print_diff (start, &now); - } +static void +print_diff_now (struct ui_file *file, struct mi_timestamp *start) +{ + struct mi_timestamp now; + + timestamp (&now); + print_diff (file, start, &now); +} void -mi_print_timing_maybe (void) +mi_print_timing_maybe (struct ui_file *file) { - /* If the command is -enable-timing then do_timings may be - true whilst current_command_ts is not initialized. */ + /* If the command is -enable-timing then do_timings may be true + whilst current_command_ts is not initialized. */ if (do_timings && current_command_ts) - print_diff_now (current_command_ts); + print_diff_now (file, current_command_ts); } -static long -timeval_diff (struct timeval start, struct timeval end) - { - return ((end.tv_sec - start.tv_sec) * 1000000L) - + (end.tv_usec - start.tv_usec); - } +static void +print_diff (struct ui_file *file, struct mi_timestamp *start, + struct mi_timestamp *end) +{ + using namespace std::chrono; -static void -print_diff (struct mi_timestamp *start, struct mi_timestamp *end) - { - fprintf_unfiltered - (raw_stdout, - ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}", - timeval_diff (start->wallclock, end->wallclock) / 1000000.0, - timeval_diff (start->utime, end->utime) / 1000000.0, - timeval_diff (start->stime, end->stime) / 1000000.0); - } + duration wallclock = end->wallclock - start->wallclock; + duration utime = end->utime - start->utime; + duration stime = end->stime - start->stime; + + fprintf_unfiltered + (file, + ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}", + wallclock.count (), utime.count (), stime.count ()); +} void mi_cmd_trace_define_variable (char *command, char **argv, int argc) { - struct expression *expr; - struct cleanup *back_to; LONGEST initval = 0; struct trace_state_variable *tsv; char *name = 0; @@ -2342,19 +2504,11 @@ mi_cmd_trace_define_variable (char *command, char **argv, int argc) if (argc != 1 && argc != 2) error (_("Usage: -trace-define-variable VARIABLE [VALUE]")); - expr = parse_expression (argv[0]); - back_to = make_cleanup (xfree, expr); - - if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR) - { - struct internalvar *intvar = expr->elts[1].internalvar; - - if (intvar) - name = internalvar_name (intvar); - } + name = argv[0]; + if (*name++ != '$') + error (_("Name of trace variable should start with '$'")); - if (!name || *name == '\0') - error (_("Invalid name of trace variable")); + validate_trace_state_variable_name (name); tsv = find_trace_state_variable (name); if (!tsv) @@ -2364,15 +2518,13 @@ mi_cmd_trace_define_variable (char *command, char **argv, int argc) initval = value_as_long (parse_and_eval (argv[1])); tsv->initial_value = initval; - - do_cleanups (back_to); } void mi_cmd_trace_list_variables (char *command, char **argv, int argc) { if (argc != 0) - error (_("-trace-list-variables: no arguments are allowed")); + error (_("-trace-list-variables: no arguments allowed")); tvariables_info_1 (); } @@ -2393,8 +2545,7 @@ mi_cmd_trace_find (char *command, char **argv, int argc) return; } - if (current_trace_status ()->running) - error (_("May not look at trace frames while trace is running.")); + check_trace_running (current_trace_status ()); if (strcmp (mode, "frame-number") == 0) { @@ -2438,7 +2589,8 @@ mi_cmd_trace_find (char *command, char **argv, int argc) if (argc != 2) error (_("Line is required")); - sals = decode_line_spec (argv[1], DECODE_LINE_FUNFIRSTLINE); + sals = decode_line_with_current_source (argv[1], + DECODE_LINE_FUNFIRSTLINE); back_to = make_cleanup (xfree, sals.sals); sal = sals.sals[0]; @@ -2457,36 +2609,58 @@ mi_cmd_trace_find (char *command, char **argv, int argc) error (_("Invalid mode '%s'"), mode); if (has_stack_frames () || get_traceframe_number () >= 0) - { - print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); - } + print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1); } void mi_cmd_trace_save (char *command, char **argv, int argc) { int target_saves = 0; + int generate_ctf = 0; char *filename; + int oind = 0; + char *oarg; - if (argc != 1 && argc != 2) - error (_("Usage: -trace-save [-r] filename")); - - if (argc == 2) + enum opt + { + TARGET_SAVE_OPT, CTF_OPT + }; + static const struct mi_opt opts[] = { - filename = argv[1]; - if (strcmp (argv[0], "-r") == 0) - target_saves = 1; - else - error (_("Invalid option: %s"), argv[0]); - } - else + {"r", TARGET_SAVE_OPT, 0}, + {"ctf", CTF_OPT, 0}, + { 0, 0, 0 } + }; + + while (1) { - filename = argv[0]; + int opt = mi_getopt ("-trace-save", argc, argv, opts, + &oind, &oarg); + + if (opt < 0) + break; + switch ((enum opt) opt) + { + case TARGET_SAVE_OPT: + target_saves = 1; + break; + case CTF_OPT: + generate_ctf = 1; + break; + } } - trace_save (filename, target_saves); -} + if (argc - oind != 1) + error (_("Exactly one argument required " + "(file in which to save trace data)")); + + filename = argv[oind]; + if (generate_ctf) + trace_save_ctf (filename, target_saves); + else + trace_save_tfile (filename, target_saves); +} void mi_cmd_trace_start (char *command, char **argv, int argc) @@ -2507,7 +2681,7 @@ mi_cmd_trace_stop (char *command, char **argv, int argc) trace_status_mi (1); } -/* Implement the "-ada-task-info" GDB/MI command. */ +/* Implement the "-ada-task-info" command. */ void mi_cmd_ada_task_info (char *command, char **argv, int argc) @@ -2517,3 +2691,327 @@ mi_cmd_ada_task_info (char *command, char **argv, int argc) print_ada_task_info (current_uiout, argv[0], current_inferior ()); } + +/* Print EXPRESSION according to VALUES. */ + +static void +print_variable_or_computed (const char *expression, enum print_values values) +{ + struct cleanup *old_chain; + struct value *val; + struct ui_file *stb; + struct type *type; + struct ui_out *uiout = current_uiout; + + stb = mem_fileopen (); + old_chain = make_cleanup_ui_file_delete (stb); + + expression_up expr = parse_expression (expression); + + if (values == PRINT_SIMPLE_VALUES) + val = evaluate_type (expr.get ()); + else + val = evaluate_expression (expr.get ()); + + if (values != PRINT_NO_VALUES) + make_cleanup_ui_out_tuple_begin_end (uiout, NULL); + uiout->field_string ("name", expression); + + switch (values) + { + case PRINT_SIMPLE_VALUES: + type = check_typedef (value_type (val)); + type_print (value_type (val), "", stb, -1); + uiout->field_stream ("type", stb); + if (TYPE_CODE (type) != TYPE_CODE_ARRAY + && TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_UNION) + { + struct value_print_options opts; + + get_no_prettyformat_print_options (&opts); + opts.deref_ref = 1; + common_val_print (val, stb, 0, &opts, current_language); + uiout->field_stream ("value", stb); + } + break; + case PRINT_ALL_VALUES: + { + struct value_print_options opts; + + get_no_prettyformat_print_options (&opts); + opts.deref_ref = 1; + common_val_print (val, stb, 0, &opts, current_language); + uiout->field_stream ("value", stb); + } + break; + } + + do_cleanups (old_chain); +} + +/* Implement the "-trace-frame-collected" command. */ + +void +mi_cmd_trace_frame_collected (char *command, char **argv, int argc) +{ + struct cleanup *old_chain; + struct bp_location *tloc; + int stepping_frame; + struct collection_list *clist; + struct collection_list tracepoint_list, stepping_list; + struct traceframe_info *tinfo; + int oind = 0; + enum print_values var_print_values = PRINT_ALL_VALUES; + enum print_values comp_print_values = PRINT_ALL_VALUES; + int registers_format = 'x'; + int memory_contents = 0; + struct ui_out *uiout = current_uiout; + enum opt + { + VAR_PRINT_VALUES, + COMP_PRINT_VALUES, + REGISTERS_FORMAT, + MEMORY_CONTENTS, + }; + static const struct mi_opt opts[] = + { + {"-var-print-values", VAR_PRINT_VALUES, 1}, + {"-comp-print-values", COMP_PRINT_VALUES, 1}, + {"-registers-format", REGISTERS_FORMAT, 1}, + {"-memory-contents", MEMORY_CONTENTS, 0}, + { 0, 0, 0 } + }; + + while (1) + { + char *oarg; + int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts, + &oind, &oarg); + if (opt < 0) + break; + switch ((enum opt) opt) + { + case VAR_PRINT_VALUES: + var_print_values = mi_parse_print_values (oarg); + break; + case COMP_PRINT_VALUES: + comp_print_values = mi_parse_print_values (oarg); + break; + case REGISTERS_FORMAT: + registers_format = oarg[0]; + case MEMORY_CONTENTS: + memory_contents = 1; + break; + } + } + + if (oind != argc) + error (_("Usage: -trace-frame-collected " + "[--var-print-values PRINT_VALUES] " + "[--comp-print-values PRINT_VALUES] " + "[--registers-format FORMAT]" + "[--memory-contents]")); + + /* This throws an error is not inspecting a trace frame. */ + tloc = get_traceframe_location (&stepping_frame); + + /* This command only makes sense for the current frame, not the + selected frame. */ + old_chain = make_cleanup_restore_current_thread (); + select_frame (get_current_frame ()); + + encode_actions (tloc, &tracepoint_list, &stepping_list); + + if (stepping_frame) + clist = &stepping_list; + else + clist = &tracepoint_list; + + tinfo = get_traceframe_info (); + + /* Explicitly wholly collected variables. */ + { + struct cleanup *list_cleanup; + int i; + + list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, + "explicit-variables"); + + const std::vector &wholly_collected + = clist->wholly_collected (); + for (size_t i = 0; i < wholly_collected.size (); i++) + { + const std::string &str = wholly_collected[i]; + print_variable_or_computed (str.c_str (), var_print_values); + } + + do_cleanups (list_cleanup); + } + + /* Computed expressions. */ + { + struct cleanup *list_cleanup; + char *p; + int i; + + list_cleanup + = make_cleanup_ui_out_list_begin_end (uiout, + "computed-expressions"); + + const std::vector &computed = clist->computed (); + for (size_t i = 0; i < computed.size (); i++) + { + const std::string &str = computed[i]; + print_variable_or_computed (str.c_str (), comp_print_values); + } + + do_cleanups (list_cleanup); + } + + /* Registers. Given pseudo-registers, and that some architectures + (like MIPS) actually hide the raw registers, we don't go through + the trace frame info, but instead consult the register cache for + register availability. */ + { + struct cleanup *list_cleanup; + struct frame_info *frame; + struct gdbarch *gdbarch; + int regnum; + int numregs; + + list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "registers"); + + frame = get_selected_frame (NULL); + gdbarch = get_frame_arch (frame); + numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); + + for (regnum = 0; regnum < numregs; regnum++) + { + if (gdbarch_register_name (gdbarch, regnum) == NULL + || *(gdbarch_register_name (gdbarch, regnum)) == '\0') + continue; + + output_register (frame, regnum, registers_format, 1); + } + + do_cleanups (list_cleanup); + } + + /* Trace state variables. */ + { + struct cleanup *list_cleanup; + int tvar; + char *tsvname; + int i; + + list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars"); + + tsvname = NULL; + make_cleanup (free_current_contents, &tsvname); + + for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++) + { + struct cleanup *cleanup_child; + struct trace_state_variable *tsv; + + tsv = find_trace_state_variable_by_number (tvar); + + cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); + + if (tsv != NULL) + { + tsvname = (char *) xrealloc (tsvname, strlen (tsv->name) + 2); + tsvname[0] = '$'; + strcpy (tsvname + 1, tsv->name); + uiout->field_string ("name", tsvname); + + tsv->value_known = target_get_trace_state_variable_value (tsv->number, + &tsv->value); + uiout->field_int ("current", tsv->value); + } + else + { + uiout->field_skip ("name"); + uiout->field_skip ("current"); + } + + do_cleanups (cleanup_child); + } + + do_cleanups (list_cleanup); + } + + /* Memory. */ + { + struct cleanup *list_cleanup; + VEC(mem_range_s) *available_memory = NULL; + struct mem_range *r; + int i; + + traceframe_available_memory (&available_memory, 0, ULONGEST_MAX); + make_cleanup (VEC_cleanup(mem_range_s), &available_memory); + + list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory"); + + for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++) + { + struct cleanup *cleanup_child; + gdb_byte *data; + struct gdbarch *gdbarch = target_gdbarch (); + + cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); + + uiout->field_core_addr ("address", gdbarch, r->start); + uiout->field_int ("length", r->length); + + data = (gdb_byte *) xmalloc (r->length); + make_cleanup (xfree, data); + + if (memory_contents) + { + if (target_read_memory (r->start, data, r->length) == 0) + { + int m; + char *data_str, *p; + + data_str = (char *) xmalloc (r->length * 2 + 1); + make_cleanup (xfree, data_str); + + for (m = 0, p = data_str; m < r->length; ++m, p += 2) + sprintf (p, "%02x", data[m]); + uiout->field_string ("contents", data_str); + } + else + uiout->field_skip ("contents"); + } + do_cleanups (cleanup_child); + } + + do_cleanups (list_cleanup); + } + + do_cleanups (old_chain); +} + +void +_initialize_mi_main (void) +{ + struct cmd_list_element *c; + + add_setshow_boolean_cmd ("mi-async", class_run, + &mi_async_1, _("\ +Set whether MI asynchronous mode is enabled."), _("\ +Show whether MI asynchronous mode is enabled."), _("\ +Tells GDB whether MI should be in asynchronous mode."), + set_mi_async_command, + show_mi_async_command, + &setlist, + &showlist); + + /* Alias old "target-async" to "mi-async". */ + c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &setlist); + deprecate_cmd (c, "set mi-async"); + c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &showlist); + deprecate_cmd (c, "show mi-async"); +}