/* 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).
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
-/* 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"
#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 <ctype.h>
-#include <sys/time.h>
+#include "gdb_sys_time.h"
#if defined HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
};
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;
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
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 (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);
}
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. */
/* 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
/* 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)
{
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)
}
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);
enum exec_direction_kind dir = execution_direction;
struct cleanup *old_chain;
- if (dir == EXEC_ERROR)
- error (_("Target %s does not support this command."), target_shortname);
-
if (dir == EXEC_REVERSE)
error (_("Already in reverse mode."));
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)
{
}
}
+/* 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))
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);
}
}
{
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;
mi_cmd_target_detach (char *command, char **argv, int argc)
{
if (argc != 0 && argc != 1)
- error ("Usage: -target-detach [pid | thread-group]");
+ error (_("Usage: -target-detach [pid | thread-group]"));
if (argc == 1)
{
char *mi_error_message;
if (argc != 1)
- error ("mi_cmd_thread_select: USAGE: threadnum.");
+ error (_("-thread-select: USAGE: threadnum."));
- rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
+ rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
if (rc == GDB_RC_FAIL)
{
char *mi_error_message;
if (argc != 0)
- error ("mi_cmd_thread_list_ids: No arguments required.");
+ error (_("-thread-list-ids: No arguments required."));
- rc = gdb_list_thread_ids (uiout, &mi_error_message);
+ rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
if (rc == GDB_RC_FAIL)
{
void
mi_cmd_thread_info (char *command, char **argv, int argc)
{
- int thread = -1;
-
if (argc != 0 && argc != 1)
- error ("Invalid MI command");
+ error (_("Invalid MI command"));
- if (argc == 1)
- thread = atoi (argv[0]);
-
- print_thread_info (uiout, thread, -1);
+ print_thread_info (current_uiout, argv[0], -1);
}
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)
{
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)
|| bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
ui_out_field_string (uiout, "type", "process");
+ if (inferior->has_exit_code)
+ ui_out_field_string (uiout, "exit-code",
+ int_string (inferior->exit_code, 8, 0, 0, 1));
if (inferior->pid != 0)
ui_out_field_int (uiout, "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));
+ inferior->pspace->pspace_exec_filename);
}
data.cores = 0;
}
if (top_data->recurse)
- print_thread_info (uiout, -1, inferior->pid);
+ print_thread_info (uiout, NULL, inferior->pid);
do_cleanups (back_to);
}
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)
static void
free_vector_of_ints (void *xvector)
{
- VEC (int) **vector = xvector;
+ VEC (int) **vector = (VEC (int) **) xvector;
VEC_free (int, *vector);
}
static void
free_splay_tree (void *xt)
{
- splay_tree t = xt;
+ splay_tree t = (splay_tree) xt;
splay_tree_delete (t);
}
struct osdata *data;
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.
/* 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)
{
do_cleanups (back_to);
}
+
+ do_cleanups (cleanup);
}
void
mi_cmd_list_thread_groups (char *command, char **argv, int argc)
{
+ struct ui_out *uiout = current_uiout;
struct cleanup *back_to;
int available = 0;
int recurse = 0;
VEC (int) *ids = 0;
enum opt
- {
- AVAILABLE_OPT, RECURSE_OPT
- };
- static 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;
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 "
- "for the '--recurse' option");
+ error (_("only '0' and '1' are valid values "
+ "for the '--recurse' option"));
break;
}
}
- 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)
}
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, -1, inf->pid);
+ error (_("Non-existent thread group id '%d'"), id);
+
+ print_thread_info (uiout, NULL, inf->pid);
}
else
{
mi_cmd_data_list_register_names (char *command, char **argv, int argc)
{
struct gdbarch *gdbarch;
+ struct ui_out *uiout = current_uiout;
int regnum, numregs;
int i;
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);
{
regnum = atoi (argv[i]);
if (regnum < 0 || regnum >= numregs)
- error ("bad register number");
+ error (_("bad register number"));
if (gdbarch_register_name (gdbarch, regnum) == NULL
|| *(gdbarch_register_name (gdbarch, regnum)) == '\0')
mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
{
static struct regcache *this_regs = NULL;
+ struct ui_out *uiout = current_uiout;
struct regcache *prev_regs;
struct gdbarch *gdbarch;
int regnum, numregs, changed;
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++)
continue;
changed = register_changed_p (regnum, prev_regs, this_regs);
if (changed < 0)
- error ("mi_cmd_data_list_changed_registers: "
- "Unable to read register contents.");
+ error (_("-data-list-changed-registers: "
+ "Unable to read register contents."));
else if (changed)
ui_out_field_int (uiout, NULL, regnum);
}
{
changed = register_changed_p (regnum, prev_regs, this_regs);
if (changed < 0)
- error ("mi_cmd_data_list_register_change: "
- "Unable to read register contents.");
+ error (_("-data-list-changed-registers: "
+ "Unable to read register contents."));
else if (changed)
ui_out_field_int (uiout, NULL, regnum);
}
else
- error ("bad register number");
+ error (_("bad register number"));
}
do_cleanups (cleanup);
}
struct gdbarch *gdbarch = get_regcache_arch (this_regs);
gdb_byte prev_buffer[MAX_REGISTER_SIZE];
gdb_byte this_buffer[MAX_REGISTER_SIZE];
+ enum register_status prev_status;
+ enum register_status this_status;
- /* Registers not valid in this frame return count as unchanged. */
- if (!regcache_valid_p (this_regs, regnum))
- return 0;
-
- /* First time through or after gdbarch change consider all registers as
- changed. Same for registers not valid in the previous frame. */
- if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
- || !regcache_valid_p (prev_regs, regnum))
+ /* First time through or after gdbarch change consider all registers
+ as changed. */
+ if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
return 1;
/* Get register contents and compare. */
- regcache_cooked_read (prev_regs, regnum, prev_buffer);
- regcache_cooked_read (this_regs, regnum, this_buffer);
+ prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
+ this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
- return memcmp (prev_buffer, this_buffer,
- register_size (gdbarch, regnum)) != 0;
+ if (this_status != prev_status)
+ return 1;
+ else if (this_status == REG_VALID)
+ return memcmp (prev_buffer, this_buffer,
+ register_size (gdbarch, regnum)) != 0;
+ else
+ return 0;
}
/* 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)
{
+ struct ui_out *uiout = current_uiout;
struct frame_info *frame;
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)
- error ("mi_cmd_data_list_register_values: Usage: "
- "-data-list-register-values <format> [<regnum1>...<regnumN>]");
+ 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;
+ }
+ }
- format = (int) argv[0][0];
+ if (argc - oind < 1)
+ error (_("-data-list-register-values: Usage: "
+ "-data-list-register-values [--skip-unavailable] <format>"
+ " [<regnum1>...<regnumN>]"));
+
+ format = (int) argv[oind][0];
frame = get_selected_frame (NULL);
gdbarch = get_frame_arch (frame);
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++)
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]);
&& 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");
+ 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);
- gdb_byte buffer[MAX_REGISTER_SIZE];
- int optim;
- int realnum;
- CORE_ADDR addr;
- enum lval_type lval;
- static struct ui_stream *stb = NULL;
+ struct ui_out *uiout = current_uiout;
+ 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);
+ ui_out_field_int (uiout, "number", regnum);
if (format == 'N')
format = 0;
- frame_register (frame, regnum, &optim, &lval, &addr, &realnum, buffer);
-
- if (optim)
- error ("Optimized out");
-
if (format == 'r')
- {
- int j;
- char *ptr, buf[1024];
+ 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) buffer[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_contents_for_printing (val),
+ value_embedded_offset (val), 0,
+ stb, 0, val, &opts, current_language);
+ ui_out_field_stream (uiout, "value", stb);
- get_formatted_print_options (&opts, format);
- opts.deref_ref = 1;
- val_print (register_type (gdbarch, regnum), buffer, 0, 0,
- stb->stream, 0, NULL, &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 <format>
[<regnum1> <value1>...<regnumN> <valueN>] */
void
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);
numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
if (argc == 0)
- error ("mi_cmd_data_write_register_values: Usage: -data-write-register-"
- "values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
-
- format = (int) argv[0][0];
+ error (_("-data-write-register-values: Usage: -data-write-register-"
+ "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
if (!target_has_registers)
- error ("mi_cmd_data_write_register_values: No registers.");
+ error (_("-data-write-register-values: No registers."));
if (!(argc - 1))
- error ("mi_cmd_data_write_register_values: No regs and values specified.");
+ error (_("-data-write-register-values: No regs and values specified."));
if ((argc - 1) % 2)
- error ("mi_cmd_data_write_register_values: "
- "Regs and vals are not in pairs.");
+ error (_("-data-write-register-values: "
+ "Regs and vals are not in pairs."));
for (i = 1; i < argc; i = i + 2)
{
regcache_cooked_write_signed (regcache, regnum, value);
}
else
- error ("bad register number");
+ error (_("bad register number"));
}
}
/* 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 ("mi_cmd_data_evaluate_expression: "
- "Usage: -data-evaluate-expression expression");
- }
+ error (_("-data-evaluate-expression: "
+ "Usage: -data-evaluate-expression expression"));
expr = parse_expression (argv[0]);
- old_chain = make_cleanup (free_current_contents, &expr);
+ make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
/* 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);
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.
{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;
gdb_byte *mbuf;
int nr_bytes;
long offset = 0;
- int optind = 0;
- char *optarg;
+ int oind = 0;
+ char *oarg;
enum opt
- {
- OFFSET_OPT
- };
- static 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 ("mi_cmd_data_read_memory", argc, argv, opts,
- &optind, &optarg);
+ int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
+ &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 ("mi_cmd_data_read_memory: Usage: "
- "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
+ error (_("-data-read-memory: Usage: "
+ "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
/* Extract all the arguments. */
/* 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]);
/* The number of rows. */
nr_rows = atol (argv[3]);
if (nr_rows <= 0)
- error ("mi_cmd_data_read_memory: invalid number of rows.");
+ error (_("-data-read-memory: invalid number of rows."));
/* Number of bytes per row. */
nr_cols = atol (argv[4]);
if (nr_cols <= 0)
- error ("mi_cmd_data_read_memory: invalid number of columns.");
+ error (_("-data-read-memory: invalid number of columns."));
/* The un-printable character when printing ascii. */
if (argc == 6)
/* Create a buffer and read it in. */
total_bytes = word_size * nr_rows * nr_cols;
- mbuf = xcalloc (total_bytes, 1);
+ mbuf = XCNEWVEC (gdb_byte, total_bytes);
make_cleanup (xfree, mbuf);
/* Dispatch memory reads to the topmost target, not the flattened
TARGET_OBJECT_MEMORY, NULL, mbuf,
addr, total_bytes);
if (nr_bytes <= 0)
- error ("Unable to read memory.");
+ error (_("Unable to read memory."));
/* Output the header information. */
ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
/* 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)
}
else
{
- ui_file_rewind (stream->stream);
+ ui_file_rewind (stream);
print_scalar_formatted (mbuf + col_byte, word_type, &opts,
- word_asize, stream->stream);
+ word_asize, stream);
ui_out_field_stream (uiout, NULL, stream);
}
}
{
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);
}
do_cleanups (cleanup_tuple);
}
- ui_out_stream_delete (stream);
- do_cleanups (cleanup_list_memory);
+ do_cleanups (cleanup_stream);
}
do_cleanups (cleanups);
}
mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
{
struct gdbarch *gdbarch = get_current_arch ();
+ struct ui_out *uiout = current_uiout;
struct cleanup *cleanups;
CORE_ADDR addr;
LONGEST length;
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 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 ("mi_cmd_data_read_memory_bytes", argc, argv, opts,
- &optind, &optarg);
+ int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
+ &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.");
+ error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
addr = parse_and_eval_address (argv[0]) + offset;
length = atol (argv[1]);
cleanups = make_cleanup (free_memory_read_result_vector, result);
if (VEC_length (memory_read_result_s, result) == 0)
- error ("Unable to read memory.");
+ error (_("Unable to read memory."));
make_cleanup_ui_out_list_begin_end (uiout, "memory");
for (ix = 0;
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);
- 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]);
do_cleanups (cleanups);
}
+/* Implementation of the -data-write_memory command.
-/* DATA-MEMORY-WRITE:
-
- COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
+ COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
offset from the beginning of the memory grid row where the cell to
be written is.
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.
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 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 ("mi_cmd_data_write_memory", argc, argv, opts,
- &optind, &optarg);
+ int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
+ &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 ("mi_cmd_data_write_memory: Usage: "
- "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
+ error (_("-data-write-memory: Usage: "
+ "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
/* 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. */
/* 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;
}
- r = target_write_memory (addr, data, len);
- if (r != 0)
- error (_("Could not write memory"));
+ 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;
+ }
+
+ write_memory_with_notification (addr, data, count_units);
do_cleanups (back_to);
}
-
void
mi_cmd_enable_timings (char *command, char **argv, int argc)
{
}
else
goto usage_error;
-
+
return;
usage_error:
- error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
+ error (_("-enable-timings: Usage: %s {yes|no}"), command);
}
void
if (argc == 0)
{
struct cleanup *cleanup = NULL;
+ struct ui_out *uiout = current_uiout;
- cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
+ 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");
-
-#if HAVE_PYTHON
- ui_out_field_string (uiout, NULL, "python");
-#endif
-
+ ui_out_field_string (uiout, NULL, "breakpoint-notifications");
+ ui_out_field_string (uiout, NULL, "ada-task-info");
+ ui_out_field_string (uiout, NULL, "language-option");
+ ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
+ ui_out_field_string (uiout, NULL, "undefined-command-error-code");
+ ui_out_field_string (uiout, NULL, "exec-run-start-option");
+
+ if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
+ ui_out_field_string (uiout, NULL, "python");
+
do_cleanups (cleanup);
return;
}
- error ("-list-features should be passed no arguments");
+ error (_("-list-features should be passed no arguments"));
}
void
if (argc == 0)
{
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 ())
+ cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
+ if (mi_async_p ())
ui_out_field_string (uiout, NULL, "async");
if (target_can_execute_reverse)
ui_out_field_string (uiout, NULL, "reverse");
-
do_cleanups (cleanup);
return;
}
- error ("-list-target-features should be passed no arguments");
+ error (_("-list-target-features should be passed no arguments"));
}
void
inf = add_inferior_with_spaces ();
- ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
+ ui_out_field_fmt (current_uiout, "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)
{
struct inferior *inf;
if (argc != 1)
- error ("-remove-inferior should be passed a single argument");
+ error (_("-remove-inferior should be passed a single argument"));
if (sscanf (argv[0], "i%d", &id) != 1)
- error ("the thread group id is syntactically invalid");
+ error (_("the thread group id is syntactically invalid"));
inf = find_inferior_id (id);
if (!inf)
- error ("the specified thread group does not exist");
+ error (_("the specified thread group does not exist"));
if (inf->pid != 0)
error (_("cannot remove an active inferior"));
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)
set_current_program_space (new_inferior->pspace);
}
- delete_inferior_1 (inf, 1 /* silent */);
+ delete_inferior (inf);
}
\f
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, void *data)
+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;
- struct mi_parse *context = (struct mi_parse *) data;
if (do_timings)
current_command_ts = context->cmd_start;
/* 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;
{
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. */
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);
}
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. */
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)
{
- struct gdb_exception result;
ptid_t previous_ptid = inferior_ptid;
command->token = token;
if (do_timings)
{
- command->cmd_start = (struct mi_timestamp *)
- xmalloc (sizeof (struct mi_timestamp));
+ command->cmd_start = XNEW (struct mi_timestamp);
timestamp (command->cmd_start);
}
- result = catch_exception (uiout, captured_mi_execute_command, command,
- RETURN_MASK_ALL);
- if (result.reason < 0)
+ TRY
+ {
+ captured_mi_execute_command (current_uiout, command);
+ }
+ CATCH (result, RETURN_MASK_ALL)
{
/* The command execution failed and error() was called
somewhere. */
mi_print_exception (command->token, result);
- mi_out_rewind (uiout);
+ 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. */
+ 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 --
+ /* 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
=thread-selected is supposed to indicate user's intentions. */
&& strcmp (command->command, "thread-select") != 0)
{
- 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)
{
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 ();
+ struct cleanup *old_chain;
+
+ old_chain = make_cleanup_restore_target_terminal ();
+ target_terminal_ours_for_output ();
- target_terminal_ours ();
- fprintf_unfiltered (mi->event_channel,
+ fprintf_unfiltered (mi->event_channel,
"thread-selected,id=\"%d\"",
- ti->num);
+ ti->global_num);
gdb_flush (mi->event_channel);
+
+ do_cleanups (old_chain);
}
}
mi_parse_free (command);
}
-
- fputs_unfiltered ("(gdb) \n", raw_stdout);
- gdb_flush (raw_stdout);
- /* Print any buffered hook code. */
- /* ..... */
}
static void
{
struct cleanup *cleanup;
- prepare_execute_command ();
-
- cleanup = make_cleanup (null_cleanup, NULL);
+ cleanup = prepare_execute_command ();
if (parse->all && parse->thread_group != -1)
error (_("Cannot specify --thread-group together with --all"));
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);
error (_("Invalid frame id: %d"), frame);
}
+ if (parse->language != language_unknown)
+ {
+ make_cleanup_restore_current_language ();
+ set_language (parse->language);
+ }
+
current_context = parse;
+ if (parse->cmd->suppress_notification != NULL)
+ {
+ make_cleanup_restore_integer (parse->cmd->suppress_notification);
+ *parse->cmd->suppress_notification = 1;
+ }
+
if (parse->cmd->argv_func != NULL)
- parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
+ {
+ parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
+ }
else if (parse->cmd->cli.cmd != 0)
{
/* FIXME: DELETE THIS. */
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;
}
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 */ );
- if (target_can_async_p ())
- {
- /* If we're not executing, an exception should have been throw. */
- gdb_assert (is_running (inferior_ptid));
- do_cleanups (old_cleanups);
- }
- else
- {
- /* Do this before doing any printing. It would appear that some
- print code leaves garbage around in the buffer. */
- do_cleanups (old_cleanups);
- }
+ /* Do this before doing any printing. It would appear that some
+ print code leaves garbage around in the buffer. */
+ do_cleanups (old_cleanups);
}
void
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
of this function. */
- saved_uiout = uiout;
+ saved_uiout = current_uiout;
if (current_interp_named_p (INTERP_MI)
|| current_interp_named_p (INTERP_MI2))
- uiout = mi_out_new (2);
+ current_uiout = mi_out_new (2);
else if (current_interp_named_p (INTERP_MI1))
- uiout = mi_out_new (1);
+ current_uiout = mi_out_new (1);
else if (current_interp_named_p (INTERP_MI3))
- uiout = mi_out_new (3);
+ current_uiout = mi_out_new (3);
else
return;
+ uiout = current_uiout;
+
update_threshold.tv_sec = 0;
update_threshold.tv_usec = 500000;
gettimeofday (&time_now, NULL);
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);
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 &&
last_update.tv_sec = time_now.tv_sec;
last_update.tv_usec = time_now.tv_usec;
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, "total-sent", total_sent);
ui_out_field_int (uiout, "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);
- uiout = saved_uiout;
+ current_uiout = saved_uiout;
}
-static void
+static void
timestamp (struct mi_timestamp *tv)
- {
- gettimeofday (&tv->wallclock, NULL);
+{
+ 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;
+ 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 ();
+ {
+ 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
+ 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
+}
-static void
-print_diff_now (struct mi_timestamp *start)
- {
- struct mi_timestamp now;
+static void
+print_diff_now (struct ui_file *file, struct mi_timestamp *start)
+{
+ struct mi_timestamp now;
- timestamp (&now);
- print_diff (start, &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
+static long
timeval_diff (struct timeval start, struct timeval end)
- {
- return ((end.tv_sec - start.tv_sec) * 1000000L)
- + (end.tv_usec - start.tv_usec);
- }
+{
+ return ((end.tv_sec - start.tv_sec) * 1000000L)
+ + (end.tv_usec - start.tv_usec);
+}
-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);
- }
+static void
+print_diff (struct ui_file *file, struct mi_timestamp *start,
+ struct mi_timestamp *end)
+{
+ fprintf_unfiltered
+ (file,
+ ",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);
+}
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;
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)
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 ();
}
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)
{
if (argc != 2)
error (_("Line is required"));
- sals = decode_line_spec (argv[1], 1);
+ sals = decode_line_with_current_source (argv[1],
+ DECODE_LINE_FUNFIRSTLINE);
back_to = make_cleanup (xfree, sals.sals);
sal = sals.sals[0];
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;
+ }
}
+ filename = argv[oind];
- trace_save (filename, target_saves);
+ 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)
{
- start_tracing ();
+ start_tracing (NULL);
}
void
void
mi_cmd_trace_stop (char *command, char **argv, int argc)
{
- stop_tracing ();
+ stop_tracing (NULL);
trace_status_mi (1);
}
+
+/* Implement the "-ada-task-info" command. */
+
+void
+mi_cmd_ada_task_info (char *command, char **argv, int argc)
+{
+ if (argc != 0 && argc != 1)
+ error (_("Invalid MI command"));
+
+ print_ada_task_info (current_uiout, argv[0], current_inferior ());
+}
+
+/* Print EXPRESSION according to VALUES. */
+
+static void
+print_variable_or_computed (char *expression, enum print_values values)
+{
+ struct expression *expr;
+ 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);
+
+ expr = parse_expression (expression);
+
+ make_cleanup (free_current_contents, &expr);
+
+ if (values == PRINT_SIMPLE_VALUES)
+ val = evaluate_type (expr);
+ else
+ val = evaluate_expression (expr);
+
+ if (values != PRINT_NO_VALUES)
+ make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
+ ui_out_field_string (uiout, "name", expression);
+
+ switch (values)
+ {
+ case PRINT_SIMPLE_VALUES:
+ type = check_typedef (value_type (val));
+ type_print (value_type (val), "", stb, -1);
+ ui_out_field_stream (uiout, "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);
+ ui_out_field_stream (uiout, "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);
+ ui_out_field_stream (uiout, "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_and_make_cleanup (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;
+ char *p;
+ int i;
+
+ list_cleanup = make_cleanup_ui_out_list_begin_end (uiout,
+ "explicit-variables");
+ for (i = 0; VEC_iterate (char_ptr, clist->wholly_collected, i, p); i++)
+ print_variable_or_computed (p, 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");
+ for (i = 0; VEC_iterate (char_ptr, clist->computed, i, p); i++)
+ print_variable_or_computed (p, 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);
+ ui_out_field_string (uiout, "name", tsvname);
+
+ tsv->value_known = target_get_trace_state_variable_value (tsv->number,
+ &tsv->value);
+ ui_out_field_int (uiout, "current", tsv->value);
+ }
+ else
+ {
+ ui_out_field_skip (uiout, "name");
+ ui_out_field_skip (uiout, "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);
+
+ ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
+ ui_out_field_int (uiout, "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]);
+ ui_out_field_string (uiout, "contents", data_str);
+ }
+ else
+ ui_out_field_skip (uiout, "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");
+}
projects / external / binutils.git / blobdiff