/* MI Command Set.
- Copyright (C) 2000-2014 Free Software Foundation, Inc.
+ Copyright (C) 2000-2016 Free Software Foundation, Inc.
Contributed by Cygnus Solutions (a Red Hat company).
#include "arch-utils.h"
#include "target.h"
#include "inferior.h"
-#include <string.h>
-#include "exceptions.h"
+#include "infrun.h"
#include "top.h"
#include "gdbthread.h"
#include "mi-cmds.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. */
static struct mi_timestamp *current_command_ts;
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
formalized. */
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);
}
return;
switch_to_thread (thread->ptid);
- clear_proceed_status ();
- proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
+ clear_proceed_status (0);
+ proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
static int
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.
{
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, 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 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, target_can_async_p (),
- target_can_async_p () ? "&" : NULL);
+ mi_execute_cli_command (run_cmd, async_p,
+ async_p ? "&" : NULL);
}
}
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)
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);
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);
}
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;
/* 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
int ix;
VEC(memory_read_result_s) *result;
long offset = 0;
+ int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
int oind = 0;
char *oarg;
enum opt
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]);
/* 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. */
char *cdata;
gdb_byte *data;
gdb_byte *databuf;
- size_t len, i, steps, remainder;
- long int count, j;
+ 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 && argc != 3)
error (_("Usage: ADDR DATA [COUNT]."));
addr = parse_and_eval_address (argv[0]);
cdata = argv[1];
- if (strlen (cdata) % 2)
- error (_("Hex-encoded '%s' must have an even number of characters."),
+ 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);
- len = strlen (cdata)/2;
+ len_bytes = len_hex / 2;
+ len_units = len_bytes / unit_size;
+
if (argc == 3)
- count = strtoul (argv[2], NULL, 10);
+ count_units = strtoul (argv[2], NULL, 10);
else
- count = len;
+ count_units = len_units;
- databuf = xmalloc (len * sizeof (gdb_byte));
+ databuf = XNEWVEC (gdb_byte, len_bytes);
back_to = make_cleanup (xfree, databuf);
- for (i = 0; i < len; ++i)
+ for (i = 0; i < len_bytes; ++i)
{
int x;
if (sscanf (cdata + i * 2, "%02x", &x) != 1)
databuf[i] = (gdb_byte) x;
}
- if (len < count)
+ if (len_units < count_units)
{
- /* Pattern is made of less bytes than count:
+ /* Pattern is made of less units than count:
repeat pattern to fill memory. */
- data = xmalloc (count);
+ data = (gdb_byte *) xmalloc (count_units * unit_size);
make_cleanup (xfree, data);
- steps = count / len;
- remainder = count % len;
- for (j = 0; j < steps; j++)
- memcpy (data + j * len, databuf, len);
+ /* 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 (remainder > 0)
- memcpy (data + steps * len, databuf, remainder);
+ 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 bytes. */
+ just copy count addressable memory units. */
data = databuf;
}
- write_memory_with_notification (addr, data, count);
+ write_memory_with_notification (addr, data, count_units);
do_cleanups (back_to);
}
struct ui_out *uiout = current_uiout;
cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
- if (target_can_async_p ())
+ 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;
}
set_current_program_space (new_inferior->pspace);
}
- delete_inferior_1 (inf, 1 /* silent */);
+ delete_inferior (inf);
}
\f
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
{
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);
}
void
{
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)
{
- volatile 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);
}
- TRY_CATCH (result, RETURN_MASK_ALL)
+ TRY
{
captured_mi_execute_command (current_uiout, command);
}
- if (result.reason < 0)
+ CATCH (result, RETURN_MASK_ALL)
{
/* The command execution failed and error() was called
somewhere. */
mi_print_exception (command->token, result);
mi_out_rewind (current_uiout);
}
+ END_CATCH
bpstat_do_actions ();
=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,
"thread-selected,id=\"%d\"",
- ti->num);
+ ti->global_num);
gdb_flush (mi->event_channel);
+
+ do_cleanups (old_chain);
}
}
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);
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 : "");
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
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);
}
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);
+ print_diff_now (file, current_command_ts);
}
static long
}
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)
{
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,
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;
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)
{
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;
struct collection_list tracepoint_list, stepping_list;
struct traceframe_info *tinfo;
int oind = 0;
- int var_print_values = PRINT_ALL_VALUES;
- int comp_print_values = PRINT_ALL_VALUES;
+ 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;
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);
ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
ui_out_field_int (uiout, "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)
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");
+}