X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fmi%2Fmi-main.c;h=ace9ff76b666b4dbc9ccc4d3aec3b19313b5905a;hb=112e8700a6fd2fed65ca70132c9cbed4132e8bd4;hp=3ad11bb232a306c0b6f814c335dc53812c3a45c8;hpb=19ba03f49581e407097a3e4821a957c422551ae5;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c index 3ad11bb232..ace9ff76b6 100644 --- a/gdb/mi/mi-main.c +++ b/gdb/mi/mi-main.c @@ -1,6 +1,6 @@ /* 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). @@ -53,17 +53,11 @@ #include "linespec.h" #include "extension.h" #include "gdbcmd.h" +#include "observer.h" #include -#include "gdb_sys_time.h" - -#if defined HAVE_SYS_RESOURCE_H -#include -#endif - -#ifdef HAVE_GETRUSAGE -struct rusage rusage; -#endif +#include "run-time-clock.h" +#include enum { @@ -72,8 +66,6 @@ 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; @@ -149,18 +141,21 @@ mi_async_p (void) 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); } @@ -299,7 +294,7 @@ exec_continue (char **argv, int argc) } else { - struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi); + scoped_restore save_multi = make_scoped_restore (&sched_multi); if (current_context->all) { @@ -314,7 +309,6 @@ exec_continue (char **argv, int argc) same. */ continue_1 (1); } - do_cleanups (back_to); } } @@ -415,6 +409,8 @@ 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) { @@ -435,15 +431,14 @@ run_one_inferior (struct inferior *inf, void *arg) 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. */ @@ -489,9 +484,11 @@ mi_cmd_exec_run (char *command, char **argv, int argc) 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); } } @@ -560,17 +557,29 @@ mi_cmd_thread_select (char *command, char **argv, int argc) { enum gdb_rc rc; char *mi_error_message; + ptid_t previous_ptid = inferior_ptid; if (argc != 1) error (_("-thread-select: USAGE: threadnum.")); rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message); + /* If thread switch did not succeed don't notify or print. */ if (rc == GDB_RC_FAIL) { make_cleanup (xfree, mi_error_message); error ("%s", mi_error_message); } + + print_selected_thread_frame (current_uiout, + USER_SELECTED_THREAD | USER_SELECTED_FRAME); + + /* Notify if the thread has effectively changed. */ + if (!ptid_equal (inferior_ptid, previous_ptid)) + { + observer_notify_user_selected_context_changed (USER_SELECTED_THREAD + | USER_SELECTED_FRAME); + } } void @@ -656,17 +665,17 @@ print_one_inferior (struct inferior *inferior, void *xdata) struct cleanup *back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_fmt (uiout, "id", "i%d", inferior->num); - ui_out_field_string (uiout, "type", "process"); + uiout->field_fmt ("id", "i%d", inferior->num); + uiout->field_string ("type", "process"); if (inferior->has_exit_code) - 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); } @@ -692,7 +701,7 @@ print_one_inferior (struct inferior *inferior, void *xdata) e = unique (b, e); for (; b != e; ++b) - ui_out_field_int (uiout, NULL, *b); + uiout->field_int (NULL, *b); do_cleanups (back_to_2); } @@ -721,7 +730,7 @@ output_cores (struct ui_out *uiout, const char *field_name, const char *xcores) make_cleanup (xfree, cores); for (p = strtok (p, ","); p; p = strtok (NULL, ",")) - ui_out_field_string (uiout, NULL, p); + uiout->field_string (NULL, p); do_cleanups (back_to); } @@ -844,12 +853,12 @@ list_available_thread_groups (VEC (int) *ids, int recurse) back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_fmt (uiout, "id", "%s", pid); - ui_out_field_string (uiout, "type", "process"); + uiout->field_fmt ("id", "%s", pid); + uiout->field_string ("type", "process"); if (cmd) - ui_out_field_string (uiout, "description", cmd); + uiout->field_string ("description", cmd); if (user) - ui_out_field_string (uiout, "user", user); + uiout->field_string ("user", user); if (cores) output_cores (uiout, "cores", cores); @@ -873,9 +882,9 @@ list_available_thread_groups (VEC (int) *ids, int recurse) const char *tid = get_osdata_column (child, "tid"); const char *tcore = get_osdata_column (child, "core"); - ui_out_field_string (uiout, "id", tid); + uiout->field_string ("id", tid); if (tcore) - ui_out_field_string (uiout, "core", tcore); + uiout->field_string ("core", tcore); do_cleanups (back_to_2); } @@ -1019,10 +1028,9 @@ mi_cmd_data_list_register_names (char *command, char **argv, int argc) { if (gdbarch_register_name (gdbarch, regnum) == NULL || *(gdbarch_register_name (gdbarch, regnum)) == '\0') - ui_out_field_string (uiout, NULL, ""); + uiout->field_string (NULL, ""); else - ui_out_field_string (uiout, NULL, - gdbarch_register_name (gdbarch, regnum)); + uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum)); } } @@ -1035,10 +1043,9 @@ mi_cmd_data_list_register_names (char *command, char **argv, int argc) if (gdbarch_register_name (gdbarch, regnum) == NULL || *(gdbarch_register_name (gdbarch, regnum)) == '\0') - ui_out_field_string (uiout, NULL, ""); + uiout->field_string (NULL, ""); else - ui_out_field_string (uiout, NULL, - gdbarch_register_name (gdbarch, regnum)); + uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum)); } do_cleanups (cleanup); } @@ -1090,7 +1097,7 @@ mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) error (_("-data-list-changed-registers: " "Unable to read register contents.")); else if (changed) - ui_out_field_int (uiout, NULL, regnum); + uiout->field_int (NULL, regnum); } } @@ -1109,7 +1116,7 @@ mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) error (_("-data-list-changed-registers: " "Unable to read register contents.")); else if (changed) - ui_out_field_int (uiout, NULL, regnum); + uiout->field_int (NULL, regnum); } else error (_("bad register number")); @@ -1250,7 +1257,6 @@ static void 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; @@ -1261,7 +1267,7 @@ output_register (struct frame_info *frame, int regnum, int format, 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; @@ -1275,10 +1281,9 @@ output_register (struct frame_info *frame, int regnum, int format, 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); } @@ -1347,7 +1352,6 @@ mi_cmd_data_write_register_values (char *command, char **argv, int argc) 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; @@ -1361,18 +1365,16 @@ mi_cmd_data_evaluate_expression (char *command, char **argv, int argc) 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); } @@ -1401,7 +1403,6 @@ 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, nr_cols, nr_rows; char word_format; @@ -1409,7 +1410,6 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) long word_size; char word_asize; char aschar; - gdb_byte *mbuf; int nr_bytes; long offset = 0; int oind = 0; @@ -1494,27 +1494,25 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) /* Create a buffer and read it in. */ total_bytes = word_size * nr_rows * nr_cols; - mbuf = XCNEWVEC (gdb_byte, total_bytes); - make_cleanup (xfree, mbuf); + + std::unique_ptr mbuf (new gdb_byte[total_bytes]); /* Dispatch memory reads to the topmost target, not the flattened current_target. */ nr_bytes = target_read (current_target.beneath, - TARGET_OBJECT_MEMORY, NULL, mbuf, + TARGET_OBJECT_MEMORY, NULL, mbuf.get (), addr, total_bytes); if (nr_bytes <= 0) error (_("Unable to read memory.")); /* Output the header information. */ - ui_out_field_core_addr (uiout, "addr", gdbarch, addr); - ui_out_field_int (uiout, "nr-bytes", nr_bytes); - ui_out_field_int (uiout, "total-bytes", total_bytes); - ui_out_field_core_addr (uiout, "next-row", - gdbarch, addr + word_size * nr_cols); - ui_out_field_core_addr (uiout, "prev-row", - gdbarch, addr - word_size * nr_cols); - ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes); - ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes); + uiout->field_core_addr ("addr", gdbarch, addr); + uiout->field_int ("nr-bytes", nr_bytes); + uiout->field_int ("total-bytes", total_bytes); + uiout->field_core_addr ("next-row", gdbarch, addr + word_size * nr_cols); + uiout->field_core_addr ("prev-row", gdbarch, addr - word_size * nr_cols); + uiout->field_core_addr ("next-page", gdbarch, addr + total_bytes); + uiout->field_core_addr ("prev-page", gdbarch, addr - total_bytes); /* Build the result as a two dimentional table. */ { @@ -1538,7 +1536,7 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) struct value_print_options opts; cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte); + uiout->field_core_addr ("addr", gdbarch, addr + row_byte); /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */ cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data"); @@ -1549,14 +1547,14 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) { if (col_byte + word_size > nr_bytes) { - ui_out_field_string (uiout, NULL, "N/A"); + uiout->field_string (NULL, "N/A"); } else { ui_file_rewind (stream); - 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); @@ -1575,13 +1573,12 @@ mi_cmd_data_read_memory (char *command, char **argv, int argc) 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 @@ -1633,7 +1630,7 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) result = read_memory_robust (current_target.beneath, addr, length); - cleanups = make_cleanup (free_memory_read_result_vector, result); + cleanups = make_cleanup (free_memory_read_result_vector, &result); if (VEC_length (memory_read_result_s, result) == 0) error (_("Unable to read memory.")); @@ -1648,10 +1645,9 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) 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); alloc_len = (read_result->end - read_result->begin) * 2 * unit_size + 1; data = (char *) xmalloc (alloc_len); @@ -1662,7 +1658,7 @@ mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc) { sprintf (p, "%02x", read_result->data[i]); } - ui_out_field_string (uiout, "contents", data); + uiout->field_string ("contents", data); xfree (data); do_cleanups (t); } @@ -1696,7 +1692,7 @@ mi_cmd_data_write_memory (char *command, char **argv, int argc) /* 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; @@ -1744,7 +1740,7 @@ mi_cmd_data_write_memory (char *command, char **argv, int argc) /* Get the value as a number. */ value = parse_and_eval_address (argv[3]); /* Get the value into an array. */ - buffer = xmalloc (word_size); + buffer = (gdb_byte *) xmalloc (word_size); old_chain = make_cleanup (xfree, buffer); store_signed_integer (buffer, word_size, byte_order, value); /* Write it down to memory. */ @@ -1865,19 +1861,19 @@ mi_cmd_list_features (char *command, char **argv, int argc) 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; @@ -1896,9 +1892,9 @@ mi_cmd_list_target_features (char *command, char **argv, int argc) 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; } @@ -1916,7 +1912,7 @@ mi_cmd_add_inferior (char *command, char **argv, int argc) inf = add_inferior_with_spaces (); - ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num); + current_uiout->field_fmt ("inferior", "i%d", inf->num); } /* Callback used to find the first inferior other than the current @@ -1981,6 +1977,7 @@ mi_cmd_remove_inferior (char *command, char **argv, int argc) 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) @@ -1997,7 +1994,8 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) /* A MI command was read from the input stream. */ if (mi_debug_p) /* FIXME: gdb_???? */ - fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n", + fprintf_unfiltered (mi->raw_stdout, + " token=`%s' command=`%s' args=`%s'\n", context->token, context->command, context->args); mi_cmd_execute (context); @@ -2010,15 +2008,15 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *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 @@ -2037,7 +2035,7 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) /* Echo the command on the console. */ fprintf_unfiltered (gdb_stdlog, "%s\n", context->command); /* Call the "console" interpreter. */ - argv[0] = "console"; + argv[0] = INTERP_CONSOLE; argv[1] = context->command; mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2); @@ -2049,12 +2047,12 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) { if (!running_result_record_printed) { - fputs_unfiltered (context->token, raw_stdout); - fputs_unfiltered ("^done", raw_stdout); - mi_out_put (uiout, raw_stdout); + fputs_unfiltered (context->token, mi->raw_stdout); + fputs_unfiltered ("^done", mi->raw_stdout); + mi_out_put (uiout, mi->raw_stdout); mi_out_rewind (uiout); - mi_print_timing_maybe (); - fputs_unfiltered ("\n", raw_stdout); + mi_print_timing_maybe (mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); } else mi_out_rewind (uiout); @@ -2071,22 +2069,53 @@ captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context) static void mi_print_exception (const char *token, struct gdb_exception exception) { - fputs_unfiltered (token, raw_stdout); - fputs_unfiltered ("^error,msg=\"", raw_stdout); + struct mi_interp *mi + = (struct mi_interp *) interp_data (current_interpreter ()); + + fputs_unfiltered (token, mi->raw_stdout); + fputs_unfiltered ("^error,msg=\"", mi->raw_stdout); if (exception.message == NULL) - fputs_unfiltered ("unknown error", raw_stdout); + fputs_unfiltered ("unknown error", mi->raw_stdout); else - fputstr_unfiltered (exception.message, '"', raw_stdout); - fputs_unfiltered ("\"", 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 @@ -2116,12 +2145,19 @@ mi_execute_command (const char *cmd, int from_tty) 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 = XNEW (struct mi_timestamp); + command->cmd_start = new mi_timestamp (); timestamp (command->cmd_start); } @@ -2131,6 +2167,13 @@ mi_execute_command (const char *cmd, int from_tty) } 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); @@ -2142,14 +2185,13 @@ mi_execute_command (const char *cmd, int from_tty) 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 = (struct mi_interp *) top_level_interpreter_data (); @@ -2165,22 +2207,19 @@ mi_execute_command (const char *cmd, int from_tty) { struct thread_info *ti = inferior_thread (); - report_change = (ti->num != command->thread); + report_change = (ti->global_num != command->thread); } if (report_change) { - struct thread_info *ti = inferior_thread (); - - target_terminal_ours (); - fprintf_unfiltered (mi->event_channel, - "thread-selected,id=\"%d\"", - ti->num); - gdb_flush (mi->event_channel); + observer_notify_user_selected_context_changed + (USER_SELECTED_THREAD | USER_SELECTED_FRAME); } } mi_parse_free (command); + + do_cleanups (cleanup); } } @@ -2188,7 +2227,6 @@ static void mi_cmd_execute (struct mi_parse *parse) { struct cleanup *cleanup; - enum language saved_language; cleanup = prepare_execute_command (); @@ -2226,7 +2264,7 @@ mi_cmd_execute (struct mi_parse *parse) 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); @@ -2258,12 +2296,6 @@ mi_cmd_execute (struct mi_parse *parse) 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); @@ -2346,12 +2378,14 @@ mi_load_progress (const char *section_name, unsigned long total_sent, unsigned long grand_total) { - struct timeval time_now, delta, update_threshold; - static struct timeval last_update; + using namespace std::chrono; + static steady_clock::time_point last_update; static char *previous_sect_name = NULL; int new_section; struct ui_out *saved_uiout; struct ui_out *uiout; + struct mi_interp *mi + = (struct mi_interp *) interp_data (current_interpreter ()); /* This function is called through deprecated_show_load_progress which means uiout may not be correct. Fix it for the duration @@ -2370,19 +2404,6 @@ mi_load_progress (const char *section_name, uiout = current_uiout; - update_threshold.tv_sec = 0; - update_threshold.tv_usec = 500000; - gettimeofday (&time_now, NULL); - - delta.tv_usec = time_now.tv_usec - last_update.tv_usec; - delta.tv_sec = time_now.tv_sec - last_update.tv_sec; - - if (delta.tv_usec < 0) - { - delta.tv_sec -= 1; - delta.tv_usec += 1000000L; - } - new_section = (previous_sect_name ? strcmp (previous_sect_name, section_name) : 1); if (new_section) @@ -2393,38 +2414,37 @@ mi_load_progress (const char *section_name, previous_sect_name = xstrdup (section_name); if (current_token) - fputs_unfiltered (current_token, raw_stdout); - fputs_unfiltered ("+download", raw_stdout); + fputs_unfiltered (current_token, mi->raw_stdout); + fputs_unfiltered ("+download", mi->raw_stdout); cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_string (uiout, "section", section_name); - ui_out_field_int (uiout, "section-size", total_section); - ui_out_field_int (uiout, "total-size", grand_total); + uiout->field_string ("section", section_name); + uiout->field_int ("section-size", total_section); + uiout->field_int ("total-size", grand_total); do_cleanups (cleanup_tuple); - mi_out_put (uiout, raw_stdout); - fputs_unfiltered ("\n", raw_stdout); - gdb_flush (raw_stdout); + mi_out_put (uiout, mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); + gdb_flush (mi->raw_stdout); } - if (delta.tv_sec >= update_threshold.tv_sec && - delta.tv_usec >= update_threshold.tv_usec) + steady_clock::time_point time_now = steady_clock::now (); + if (time_now - last_update > milliseconds (500)) { struct cleanup *cleanup_tuple; - last_update.tv_sec = time_now.tv_sec; - last_update.tv_usec = time_now.tv_usec; + last_update = time_now; if (current_token) - fputs_unfiltered (current_token, raw_stdout); - fputs_unfiltered ("+download", raw_stdout); + fputs_unfiltered (current_token, mi->raw_stdout); + fputs_unfiltered ("+download", mi->raw_stdout); cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - ui_out_field_string (uiout, "section", section_name); - ui_out_field_int (uiout, "section-sent", sent_so_far); - ui_out_field_int (uiout, "section-size", total_section); - ui_out_field_int (uiout, "total-sent", total_sent); - ui_out_field_int (uiout, "total-size", grand_total); + uiout->field_string ("section", section_name); + uiout->field_int ("section-sent", sent_so_far); + uiout->field_int ("section-size", total_section); + uiout->field_int ("total-sent", total_sent); + uiout->field_int ("total-size", grand_total); do_cleanups (cleanup_tuple); - mi_out_put (uiout, raw_stdout); - fputs_unfiltered ("\n", raw_stdout); - gdb_flush (raw_stdout); + mi_out_put (uiout, mi->raw_stdout); + fputs_unfiltered ("\n", mi->raw_stdout); + gdb_flush (mi->raw_stdout); } xfree (uiout); @@ -2434,65 +2454,49 @@ mi_load_progress (const char *section_name, 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 wallclock = end->wallclock - start->wallclock; + duration utime = end->utime - start->utime; + duration 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; @@ -2645,6 +2649,11 @@ mi_cmd_trace_save (char *command, char **argv, int argc) break; } } + + if (argc - oind != 1) + error (_("Exactly one argument required " + "(file in which to save trace data)")); + filename = argv[oind]; if (generate_ctf) @@ -2686,38 +2695,34 @@ mi_cmd_ada_task_info (char *command, char **argv, int argc) /* 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) @@ -2727,7 +2732,7 @@ print_variable_or_computed (char *expression, enum print_values 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; case PRINT_ALL_VALUES: @@ -2737,7 +2742,7 @@ print_variable_or_computed (char *expression, enum print_values 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; } @@ -2816,8 +2821,7 @@ mi_cmd_trace_frame_collected (char *command, char **argv, int argc) 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; @@ -2829,13 +2833,19 @@ mi_cmd_trace_frame_collected (char *command, char **argv, int argc) /* 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 &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); } @@ -2848,8 +2858,14 @@ mi_cmd_trace_frame_collected (char *command, char **argv, int argc) 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 &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); } @@ -2908,16 +2924,16 @@ mi_cmd_trace_frame_collected (char *command, char **argv, int argc) 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); @@ -2946,8 +2962,8 @@ mi_cmd_trace_frame_collected (char *command, char **argv, int argc) 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 = (gdb_byte *) xmalloc (r->length); make_cleanup (xfree, data); @@ -2964,10 +2980,10 @@ mi_cmd_trace_frame_collected (char *command, char **argv, int argc) 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); }