/* MI Command Set.
- Copyright (C) 2000-2015 Free Software Foundation, Inc.
+ Copyright (C) 2000-2016 Free Software Foundation, Inc.
Contributed by Cygnus Solutions (a Red Hat company).
#include "linespec.h"
#include "extension.h"
#include "gdbcmd.h"
+#include "observer.h"
#include <ctype.h>
-#include <sys/time.h>
-
-#if defined HAVE_SYS_RESOURCE_H
-#include <sys/resource.h>
-#endif
-
-#ifdef HAVE_GETRUSAGE
-struct rusage rusage;
-#endif
+#include "run-time-clock.h"
+#include <chrono>
enum
{
int mi_debug_p;
-struct ui_file *raw_stdout;
-
/* This is used to pass the current command timestamp down to
continuation routines. */
static struct mi_timestamp *current_command_ts;
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);
}
}
else
{
- struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
+ scoped_restore save_multi = make_scoped_restore (&sched_multi);
if (current_context->all)
{
same. */
continue_1 (1);
}
- do_cleanups (back_to);
}
}
{
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)
{
switch_to_thread (null_ptid);
set_current_program_space (inf->pspace);
}
- mi_execute_cli_command (run_cmd, mi_async_p (),
- mi_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 i;
int start_p = 0;
/* Parse the command options. */
else
{
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, mi_async_p (),
- mi_async_p () ? "&" : NULL);
+ mi_execute_cli_command (run_cmd, async_p,
+ async_p ? "&" : NULL);
}
}
{
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
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)
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)
- ui_out_field_string (uiout, "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->pspace_exec_filename != NULL)
{
- ui_out_field_string (uiout, "executable",
+ uiout->field_string ("executable",
inferior->pspace->pspace_exec_filename);
}
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);
}
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);
}
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);
}
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);
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);
}
{
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));
}
}
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);
}
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);
}
}
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"));
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;
struct value *val = value_of_register (regnum, frame);
struct cleanup *tuple_cleanup;
return;
tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_int (uiout, "number", regnum);
+ uiout->field_int ("number", regnum);
if (format == 'N')
format = 0;
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);
+ uiout->field_stream ("value", stb);
do_cleanups (tuple_cleanup);
}
void
mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
{
- struct expression *expr;
struct cleanup *old_chain;
struct value *val;
struct ui_file *stb;
error (_("-data-evaluate-expression: "
"Usage: -data-evaluate-expression expression"));
- expr = parse_expression (argv[0]);
+ expression_up expr = parse_expression (argv[0]);
- make_cleanup (free_current_contents, &expr);
-
- 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, 0, &opts, current_language);
- ui_out_field_stream (uiout, "value", stb);
+ uiout->field_stream ("value", stb);
do_cleanups (old_chain);
}
{
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, nr_cols, nr_rows;
char word_format;
long word_size;
char word_asize;
char aschar;
- gdb_byte *mbuf;
int nr_bytes;
long offset = 0;
int oind = 0;
/* 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<gdb_byte[]> 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 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");
{
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);
- print_scalar_formatted (mbuf + col_byte, word_type, &opts,
+ print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
word_asize, stream);
- ui_out_field_stream (uiout, NULL, stream);
+ uiout->field_stream (NULL, stream);
}
}
do_cleanups (cleanup_list_data);
else
fputc_unfiltered (mbuf[byte], stream);
}
- ui_out_field_stream (uiout, "ascii", stream);
+ uiout->field_stream ("ascii", stream);
}
do_cleanups (cleanup_tuple);
}
do_cleanups (cleanup_stream);
}
- do_cleanups (cleanups);
}
void
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."));
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 * unit_size + 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) * unit_size);
{
sprintf (p, "%02x", read_result->data[i]);
}
- ui_out_field_string (uiout, "contents", data);
+ uiout->field_string ("contents", data);
xfree (data);
do_cleanups (t);
}
/* 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 oind = 0;
/* 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. */
else
count_units = len_units;
- databuf = xmalloc (len_bytes * sizeof (gdb_byte));
+ databuf = XNEWVEC (gdb_byte, len_bytes);
back_to = make_cleanup (xfree, databuf);
for (i = 0; i < len_bytes; ++i)
{
/* Pattern is made of less units than count:
repeat pattern to fill memory. */
- data = xmalloc (count_units * unit_size);
+ data = (gdb_byte *) xmalloc (count_units * unit_size);
make_cleanup (xfree, data);
/* Number of times the pattern is entirely repeated. */
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");
- 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");
+ 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)))
- ui_out_field_string (uiout, NULL, "python");
+ uiout->field_string (NULL, "python");
do_cleanups (cleanup);
return;
cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
if (mi_async_p ())
- ui_out_field_string (uiout, NULL, "async");
+ 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;
}
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
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)
/* 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);
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
/* 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);
{
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);
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 ("\"", 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\"", raw_stdout);
+ fputs_unfiltered (",code=\"undefined-command\"", mi->raw_stdout);
break;
}
- fputs_unfiltered ("\n", raw_stdout);
+ 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
if (command != NULL)
{
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);
}
}
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);
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 ()))
+ 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)
{
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);
+
+ do_cleanups (cleanup);
}
}
mi_cmd_execute (struct mi_parse *parse)
{
struct cleanup *cleanup;
- enum language saved_language;
cleanup = prepare_execute_command ();
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);
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);
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
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)
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);
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 ();
+ using namespace std::chrono;
- 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->wallclock = steady_clock::now ();
+ run_time_clock::now (tv->utime, tv->stime);
}
static void
-print_diff_now (struct mi_timestamp *start)
+print_diff_now (struct ui_file *file, struct mi_timestamp *start)
{
struct mi_timestamp now;
timestamp (&now);
- print_diff (start, &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 (do_timings && current_command_ts)
- print_diff_now (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);
+ print_diff_now (file, current_command_ts);
}
static void
-print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
+print_diff (struct ui_file *file, struct mi_timestamp *start,
+ struct mi_timestamp *end)
{
+ using namespace std::chrono;
+
+ duration<double> wallclock = end->wallclock - start->wallclock;
+ duration<double> utime = end->utime - start->utime;
+ duration<double> stime = end->stime - start->stime;
+
fprintf_unfiltered
- (raw_stdout,
+ (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);
+ wallclock.count (), utime.count (), stime.count ());
}
void
mi_cmd_trace_define_variable (char *command, char **argv, int argc)
{
- struct expression *expr;
LONGEST initval = 0;
struct trace_state_variable *tsv;
char *name = 0;
break;
}
}
+
+ if (argc - oind != 1)
+ error (_("Exactly one argument required "
+ "(file in which to save trace data)"));
+
filename = argv[oind];
if (generate_ctf)
/* Print EXPRESSION according to VALUES. */
static void
-print_variable_or_computed (char *expression, enum print_values values)
+print_variable_or_computed (const char *expression, enum print_values values)
{
- struct expression *expr;
struct cleanup *old_chain;
struct value *val;
struct ui_file *stb;
- struct value_print_options opts;
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);
+ expression_up expr = parse_expression (expression);
if (values == PRINT_SIMPLE_VALUES)
- val = evaluate_type (expr);
+ val = evaluate_type (expr.get ());
else
- val = evaluate_expression (expr);
+ val = evaluate_expression (expr.get ());
if (values != PRINT_NO_VALUES)
make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_string (uiout, "name", expression);
+ uiout->field_string ("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);
+ uiout->field_stream ("type", stb);
if (TYPE_CODE (type) != TYPE_CODE_ARRAY
&& TYPE_CODE (type) != TYPE_CODE_STRUCT
&& TYPE_CODE (type) != TYPE_CODE_UNION)
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);
+ uiout->field_stream ("value", stb);
}
break;
case PRINT_ALL_VALUES:
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);
+ uiout->field_stream ("value", stb);
}
break;
}
old_chain = make_cleanup_restore_current_thread ();
select_frame (get_current_frame ());
- encode_actions_and_make_cleanup (tloc, &tracepoint_list,
- &stepping_list);
+ encode_actions (tloc, &tracepoint_list, &stepping_list);
if (stepping_frame)
clist = &stepping_list;
/* 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);
+
+ const std::vector<std::string> &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);
}
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);
+
+ const std::vector<std::string> &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);
}
if (tsv != NULL)
{
- tsvname = xrealloc (tsvname, strlen (tsv->name) + 2);
+ tsvname = (char *) xrealloc (tsvname, strlen (tsv->name) + 2);
tsvname[0] = '$';
strcpy (tsvname + 1, tsv->name);
- ui_out_field_string (uiout, "name", tsvname);
+ uiout->field_string ("name", tsvname);
tsv->value_known = target_get_trace_state_variable_value (tsv->number,
&tsv->value);
- ui_out_field_int (uiout, "current", tsv->value);
+ uiout->field_int ("current", tsv->value);
}
else
{
- ui_out_field_skip (uiout, "name");
- ui_out_field_skip (uiout, "current");
+ uiout->field_skip ("name");
+ uiout->field_skip ("current");
}
do_cleanups (cleanup_child);
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);
+ uiout->field_core_addr ("address", gdbarch, r->start);
+ uiout->field_int ("length", r->length);
- data = xmalloc (r->length);
+ data = (gdb_byte *) xmalloc (r->length);
make_cleanup (xfree, data);
if (memory_contents)
int m;
char *data_str, *p;
- data_str = xmalloc (r->length * 2 + 1);
+ 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);
+ uiout->field_string ("contents", data_str);
}
else
- ui_out_field_skip (uiout, "contents");
+ uiout->field_skip ("contents");
}
do_cleanups (cleanup_child);
}