X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fstack.c;h=228205248710d32cac4454f40c2cd5e11f0b5685;hb=c1b5c1ebc938b6dc0277363b8c47d75b0b5a621f;hp=c68b3876d35428a81137034edb3f51bce04fd6f0;hpb=590042fc45f857c981bee4e0c76f6b3b528a224e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stack.c b/gdb/stack.c index c68b3876d3..2282052487 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -54,6 +54,7 @@ #include "observable.h" #include "gdbsupport/def-vector.h" #include "cli/cli-option.h" +#include "cli/cli-style.h" /* The possible choices of "set print frame-arguments", and the value of this setting. */ @@ -183,9 +184,9 @@ pretty-printers for that value.") struct backtrace_cmd_options { - int full = 0; - int no_filters = 0; - int hide = 0; + bool full = false; + bool no_filters = false; + bool hide = false; }; using bt_flag_option_def @@ -223,12 +224,6 @@ static void print_frame (const frame_print_options &opts, enum print_what print_what, int print_args, struct symtab_and_line sal); -static void set_last_displayed_sal (int valid, - struct program_space *pspace, - CORE_ADDR addr, - struct symtab *symtab, - int line); - static struct frame_info *find_frame_for_function (const char *); static struct frame_info *find_frame_for_address (CORE_ADDR); @@ -240,18 +235,84 @@ static struct frame_info *find_frame_for_address (CORE_ADDR); int annotation_level = 0; -/* These variables hold the last symtab and line we displayed to the user. - * This is where we insert a breakpoint or a skiplist entry by default. */ -static int last_displayed_sal_valid = 0; -static struct program_space *last_displayed_pspace = 0; -static CORE_ADDR last_displayed_addr = 0; -static struct symtab *last_displayed_symtab = 0; -static int last_displayed_line = 0; +/* Class used to manage tracking the last symtab we displayed. */ + +class last_displayed_symtab_info_type +{ +public: + /* True if the cached information is valid. */ + bool is_valid () const + { return m_valid; } + + /* Return the cached program_space. If the cache is invalid nullptr is + returned. */ + struct program_space *pspace () const + { return m_pspace; } + + /* Return the cached CORE_ADDR address. If the cache is invalid 0 is + returned. */ + CORE_ADDR address () const + { return m_address; } + + /* Return the cached symtab. If the cache is invalid nullptr is + returned. */ + struct symtab *symtab () const + { return m_symtab; } + + /* Return the cached line number. If the cache is invalid 0 is + returned. */ + int line () const + { return m_line; } + + /* Invalidate the cache, reset all the members to their default value. */ + void invalidate () + { + m_valid = false; + m_pspace = nullptr; + m_address = 0; + m_symtab = nullptr; + m_line = 0; + } + + /* Store a new set of values in the cache. */ + void set (struct program_space *pspace, CORE_ADDR address, + struct symtab *symtab, int line) + { + gdb_assert (pspace != nullptr); + + m_valid = true; + m_pspace = pspace; + m_address = address; + m_symtab = symtab; + m_line = line; + } + +private: + /* True when the cache is valid. */ + bool m_valid = false; + + /* The last program space displayed. */ + struct program_space *m_pspace = nullptr; + + /* The last address displayed. */ + CORE_ADDR m_address = 0; + + /* The last symtab displayed. */ + struct symtab *m_symtab = nullptr; + + /* The last line number displayed. */ + int m_line = 0; +}; + +/* An actual instance of the cache, holds information about the last symtab + displayed. */ +static last_displayed_symtab_info_type last_displayed_symtab_info; + /* See stack.h. */ -int +bool frame_show_address (struct frame_info *frame, struct symtab_and_line sal) { @@ -266,7 +327,7 @@ frame_show_address (struct frame_info *frame, gdb_assert (inline_skipped_frames (inferior_thread ()) > 0); else gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME); - return 0; + return false; } return get_frame_pc (frame) != sal.pc; @@ -296,7 +357,7 @@ print_stack_frame (struct frame_info *frame, int print_level, int set_current_sal) { - /* For mi, alway print location and address. */ + /* For mi, always print location and address. */ if (current_uiout->is_mi_like_p ()) print_what = LOC_AND_ADDRESS; @@ -348,7 +409,7 @@ print_frame_nameless_args (struct frame_info *frame, long start, int num, read in. Errors are printed as if they would be the parameter value. Use zeroed ARG - iff it should not be printed accoring to user settings. */ + iff it should not be printed according to user settings. */ static void print_frame_arg (const frame_print_options &fp_opts, @@ -366,31 +427,35 @@ print_frame_arg (const frame_print_options &fp_opts, annotate_arg_emitter arg_emitter; ui_out_emit_tuple tuple_emitter (uiout, NULL); - fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym), - SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI); + fprintf_symbol_filtered (&stb, arg->sym->print_name (), + arg->sym->language (), DMGL_PARAMS | DMGL_ANSI); if (arg->entry_kind == print_entry_values_compact) { /* It is OK to provide invalid MI-like stream as with PRINT_ENTRY_VALUE_COMPACT we never use MI. */ stb.puts ("="); - fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym), - SYMBOL_LANGUAGE (arg->sym), + fprintf_symbol_filtered (&stb, arg->sym->print_name (), + arg->sym->language (), DMGL_PARAMS | DMGL_ANSI); } if (arg->entry_kind == print_entry_values_only || arg->entry_kind == print_entry_values_compact) stb.puts ("@entry"); - uiout->field_stream ("name", stb, ui_out_style_kind::VARIABLE); + uiout->field_stream ("name", stb, variable_name_style.style ()); annotate_arg_name_end (); uiout->text ("="); + ui_file_style style; if (!arg->val && !arg->error) uiout->text ("..."); else { if (arg->error) - stb.printf (_(""), arg->error); + { + stb.printf (_(""), arg->error.get ()); + style = metadata_style.style (); + } else { try @@ -409,7 +474,7 @@ print_frame_arg (const frame_print_options &fp_opts, /* Use the appropriate language to display our symbol, unless the user forced the language to a specific language. */ if (language_mode == language_mode_auto) - language = language_def (SYMBOL_LANGUAGE (arg->sym)); + language = language_def (arg->sym->language ()); else language = current_language; @@ -427,11 +492,12 @@ print_frame_arg (const frame_print_options &fp_opts, { stb.printf (_(""), except.what ()); + style = metadata_style.style (); } } } - uiout->field_stream ("value", stb); + uiout->field_stream ("value", stb, style); } /* Read in inferior function local SYM at FRAME into ARGP. Caller is @@ -452,13 +518,12 @@ read_frame_local (struct symbol *sym, struct frame_info *frame, } catch (const gdb_exception_error &except) { - argp->error = xstrdup (except.what ()); + argp->error.reset (xstrdup (except.what ())); } } -/* Read in inferior function parameter SYM at FRAME into ARGP. Caller is - responsible for xfree of ARGP->ERROR. This function never throws an - exception. */ +/* Read in inferior function parameter SYM at FRAME into ARGP. This + function never throws an exception. */ void read_frame_arg (const frame_print_options &fp_opts, @@ -626,7 +691,7 @@ read_frame_arg (const frame_print_options &fp_opts, argp->sym = sym; argp->val = val; - argp->error = val_error ? xstrdup (val_error) : NULL; + argp->error.reset (val_error ? xstrdup (val_error) : NULL); if (!val && !val_error) argp->entry_kind = print_entry_values_only; else if ((fp_opts.print_entry_values == print_entry_values_compact @@ -641,7 +706,7 @@ read_frame_arg (const frame_print_options &fp_opts, entryargp->sym = sym; entryargp->val = entryval; - entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL; + entryargp->error.reset (entryval_error ? xstrdup (entryval_error) : NULL); if (!entryval && !entryval_error) entryargp->entry_kind = print_entry_values_no; else @@ -752,11 +817,11 @@ print_frame_args (const frame_print_options &fp_opts, parameter names occur on the RS/6000, for traceback tables. FIXME, should we even print them? */ - if (*SYMBOL_LINKAGE_NAME (sym)) + if (*sym->linkage_name ()) { struct symbol *nsym; - nsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym), + nsym = lookup_symbol_search_name (sym->search_name (), b, VAR_DOMAIN).symbol; gdb_assert (nsym != NULL); if (SYMBOL_CLASS (nsym) == LOC_REGISTER @@ -810,10 +875,8 @@ print_frame_args (const frame_print_options &fp_opts, if (!print_args) { - memset (&arg, 0, sizeof (arg)); arg.sym = sym; arg.entry_kind = print_entry_values_no; - memset (&entryarg, 0, sizeof (entryarg)); entryarg.sym = sym; entryarg.entry_kind = print_entry_values_no; } @@ -834,9 +897,6 @@ print_frame_args (const frame_print_options &fp_opts, print_frame_arg (fp_opts, &entryarg); } - xfree (arg.error); - xfree (entryarg.error); - first = 0; } } @@ -929,6 +989,23 @@ print_frame_info_to_print_what (const char *print_frame_info) print_frame_info); } +/* Print the PC from FRAME, plus any flags, to UIOUT. */ + +static void +print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info *frame, + CORE_ADDR pc) +{ + uiout->field_core_addr ("addr", gdbarch, pc); + + std::string flags = gdbarch_get_pc_address_flags (gdbarch, frame, pc); + if (!flags.empty ()) + { + uiout->text (" ["); + uiout->field_string ("addr_flags", flags); + uiout->text ("]"); + } +} + /* See stack.h. */ void @@ -942,7 +1019,7 @@ get_user_print_what_frame_info (gdb::optional *what) /* Print information about frame FRAME. The output is format according to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of PRINT_WHAT, see enum print_what comments in frame.h. - Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info + Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info != print_frame_info_auto. Used in "where" output, and to emit breakpoint or step @@ -986,8 +1063,7 @@ print_frame_info (const frame_print_options &fp_opts, if (uiout->is_mi_like_p ()) { annotate_frame_address (); - uiout->field_core_addr ("addr", - gdbarch, get_frame_pc (frame)); + print_pc (uiout, gdbarch, frame, get_frame_pc (frame)); annotate_frame_address_end (); } @@ -995,18 +1071,18 @@ print_frame_info (const frame_print_options &fp_opts, { annotate_function_call (); uiout->field_string ("func", "", - ui_out_style_kind::FUNCTION); + metadata_style.style ()); } else if (get_frame_type (frame) == SIGTRAMP_FRAME) { annotate_signal_handler_caller (); uiout->field_string ("func", "", - ui_out_style_kind::FUNCTION); + metadata_style.style ()); } else if (get_frame_type (frame) == ARCH_FRAME) { uiout->field_string ("func", "", - ui_out_style_kind::FUNCTION); + metadata_style.style ()); } uiout->text ("\n"); annotate_frame_end (); @@ -1071,8 +1147,7 @@ print_frame_info (const frame_print_options &fp_opts, ability to decide for themselves if it is desired. */ if (opts.addressprint && mid_statement) { - uiout->field_core_addr ("addr", - gdbarch, get_frame_pc (frame)); + print_pc (uiout, gdbarch, frame, get_frame_pc (frame)); uiout->text ("\t"); } @@ -1090,9 +1165,9 @@ print_frame_info (const frame_print_options &fp_opts, CORE_ADDR pc; if (get_frame_pc_if_available (frame, &pc)) - set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line); + last_displayed_symtab_info.set (sal.pspace, pc, sal.symtab, sal.line); else - set_last_displayed_sal (0, 0, 0, 0, 0); + last_displayed_symtab_info.invalidate (); } annotate_frame_end (); @@ -1100,103 +1175,67 @@ print_frame_info (const frame_print_options &fp_opts, gdb_flush (gdb_stdout); } -/* Remember the last symtab and line we displayed, which we use e.g. - * as the place to put a breakpoint when the `break' command is - * invoked with no arguments. */ - -static void -set_last_displayed_sal (int valid, struct program_space *pspace, - CORE_ADDR addr, struct symtab *symtab, - int line) -{ - last_displayed_sal_valid = valid; - last_displayed_pspace = pspace; - last_displayed_addr = addr; - last_displayed_symtab = symtab; - last_displayed_line = line; - if (valid && pspace == NULL) - { - clear_last_displayed_sal (); - internal_error (__FILE__, __LINE__, - _("Trying to set NULL pspace.")); - } -} - -/* Forget the last sal we displayed. */ +/* See stack.h. */ void clear_last_displayed_sal (void) { - last_displayed_sal_valid = 0; - last_displayed_pspace = 0; - last_displayed_addr = 0; - last_displayed_symtab = 0; - last_displayed_line = 0; + last_displayed_symtab_info.invalidate (); } -/* Is our record of the last sal we displayed valid? If not, - * the get_last_displayed_* functions will return NULL or 0, as - * appropriate. */ +/* See stack.h. */ -int +bool last_displayed_sal_is_valid (void) { - return last_displayed_sal_valid; + return last_displayed_symtab_info.is_valid (); } -/* Get the pspace of the last sal we displayed, if it's valid. */ +/* See stack.h. */ struct program_space * get_last_displayed_pspace (void) { - if (last_displayed_sal_valid) - return last_displayed_pspace; - return 0; + return last_displayed_symtab_info.pspace (); } -/* Get the address of the last sal we displayed, if it's valid. */ +/* See stack.h. */ CORE_ADDR get_last_displayed_addr (void) { - if (last_displayed_sal_valid) - return last_displayed_addr; - return 0; + return last_displayed_symtab_info.address (); } -/* Get the symtab of the last sal we displayed, if it's valid. */ +/* See stack.h. */ struct symtab* get_last_displayed_symtab (void) { - if (last_displayed_sal_valid) - return last_displayed_symtab; - return 0; + return last_displayed_symtab_info.symtab (); } -/* Get the line of the last sal we displayed, if it's valid. */ +/* See stack.h. */ int get_last_displayed_line (void) { - if (last_displayed_sal_valid) - return last_displayed_line; - return 0; + return last_displayed_symtab_info.line (); } -/* Get the last sal we displayed, if it's valid. */ +/* See stack.h. */ symtab_and_line get_last_displayed_sal () { symtab_and_line sal; - if (last_displayed_sal_valid) + if (last_displayed_symtab_info.is_valid ()) { - sal.pspace = last_displayed_pspace; - sal.pc = last_displayed_addr; - sal.symtab = last_displayed_symtab; - sal.line = last_displayed_line; + sal.pspace = last_displayed_symtab_info.pspace (); + sal.pc = last_displayed_symtab_info.address (); + sal.symtab = last_displayed_symtab_info.symtab (); + sal.line = last_displayed_symtab_info.line (); } return sal; @@ -1220,14 +1259,14 @@ find_frame_funname (struct frame_info *frame, enum language *funlang, func = get_frame_function (frame); if (func) { - const char *print_name = SYMBOL_PRINT_NAME (func); + const char *print_name = func->print_name (); - *funlang = SYMBOL_LANGUAGE (func); + *funlang = func->language (); if (funcp) *funcp = func; if (*funlang == language_cplus) { - /* It seems appropriate to use SYMBOL_PRINT_NAME() here, + /* It seems appropriate to use print_name() here, to display the demangled name that we already have stored in the symbol table, but we stored a version with DMGL_PARAMS turned on, and here we don't want to @@ -1251,8 +1290,8 @@ find_frame_funname (struct frame_info *frame, enum language *funlang, msymbol = lookup_minimal_symbol_by_pc (pc); if (msymbol.minsym != NULL) { - funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym))); - *funlang = MSYMBOL_LANGUAGE (msymbol.minsym); + funname.reset (xstrdup (msymbol.minsym->print_name ())); + *funlang = msymbol.minsym->language (); } } @@ -1298,10 +1337,10 @@ print_frame (const frame_print_options &fp_opts, { annotate_frame_address (); if (pc_p) - uiout->field_core_addr ("addr", gdbarch, pc); + print_pc (uiout, gdbarch, frame, pc); else uiout->field_string ("addr", "", - ui_out_style_kind::ADDRESS); + metadata_style.style ()); annotate_frame_address_end (); uiout->text (" in "); } @@ -1310,7 +1349,7 @@ print_frame (const frame_print_options &fp_opts, string_file stb; fprintf_symbol_filtered (&stb, funname ? funname.get () : "??", funlang, DMGL_ANSI); - uiout->field_stream ("func", stb, ui_out_style_kind::FUNCTION); + uiout->field_stream ("func", stb, function_name_style.style ()); uiout->wrap_hint (" "); annotate_frame_args (); @@ -1352,7 +1391,8 @@ print_frame (const frame_print_options &fp_opts, uiout->wrap_hint (" "); uiout->text (" at "); annotate_frame_source_file (); - uiout->field_string ("file", filename_display, ui_out_style_kind::FILE); + uiout->field_string ("file", filename_display, + file_name_style.style ()); if (uiout->is_mi_like_p ()) { const char *fullname = symtab_to_fullname (sal.symtab); @@ -1377,7 +1417,7 @@ print_frame (const frame_print_options &fp_opts, annotate_frame_where (); uiout->wrap_hint (" "); uiout->text (" from "); - uiout->field_string ("from", lib); + uiout->field_string ("from", lib, file_name_style.style ()); } } if (uiout->is_mi_like_p ()) @@ -1392,7 +1432,7 @@ print_frame (const frame_print_options &fp_opts, /* Completion function for "frame function", "info frame function", and "select-frame function" commands. */ -void +static void frame_selection_by_function_completer (struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word) @@ -1454,11 +1494,11 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) gdb::unique_xmalloc_ptr func_only; if (func) { - funname = SYMBOL_PRINT_NAME (func); - funlang = SYMBOL_LANGUAGE (func); + funname = func->print_name (); + funlang = func->language (); if (funlang == language_cplus) { - /* It seems appropriate to use SYMBOL_PRINT_NAME() here, + /* It seems appropriate to use print_name() here, to display the demangled name that we already have stored in the symbol table, but we stored a version with DMGL_PARAMS turned on, and here we don't want to @@ -1476,8 +1516,8 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) msymbol = lookup_minimal_symbol_by_pc (frame_pc); if (msymbol.minsym != NULL) { - funname = MSYMBOL_PRINT_NAME (msymbol.minsym); - funlang = MSYMBOL_LANGUAGE (msymbol.minsym); + funname = msymbol.minsym->print_name (); + funlang = msymbol.minsym->language (); } } calling_frame_info = get_prev_frame (fi); @@ -1497,7 +1537,7 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) if (frame_pc_p) fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout); else - fputs_filtered ("", gdb_stdout); + fputs_styled ("", metadata_style.style (), gdb_stdout); wrap_here (" "); if (funname) @@ -1508,8 +1548,11 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) } wrap_here (" "); if (sal.symtab) - printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab), - sal.line); + printf_filtered + (" (%ps:%d)", + styled_string (file_name_style.style (), + symtab_to_filename_for_display (sal.symtab)), + sal.line); puts_filtered ("; "); wrap_here (" "); printf_filtered ("saved %s = ", pc_regname); @@ -1534,8 +1577,9 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) val_print_not_saved (gdb_stdout); break; default: - fprintf_filtered (gdb_stdout, _(""), - ex.what ()); + fprintf_styled (gdb_stdout, metadata_style.style (), + _(""), + ex.what ()); break; } } @@ -2202,7 +2246,7 @@ iterate_over_block_locals (const struct block *b, break; if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN) break; - (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data); + (*cb) (sym->print_name (), sym, cb_data); break; default: @@ -2232,7 +2276,7 @@ print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, ALL_BLOCK_SYMBOLS (b, iter, sym) { - if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0) + if (strcmp (sym->linkage_name (), "default") == 0) { if (*have_default) continue; @@ -2245,7 +2289,7 @@ print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0); values_printed = 1; - fputs_filtered (SYMBOL_PRINT_NAME (sym), stream); + fputs_filtered (sym->print_name (), stream); get_user_print_options (&opts); if (opts.addressprint) { @@ -2307,8 +2351,7 @@ do_print_variable_and_value (const char *print_name, struct frame_info *frame; if (p->preg.has_value () - && p->preg->exec (SYMBOL_NATURAL_NAME (sym), 0, - NULL, 0) != 0) + && p->preg->exec (sym->natural_name (), 0, NULL, 0) != 0) return; if (p->treg.has_value () && !treg_matches_sym_type_name (*p->treg, sym)) @@ -2408,13 +2451,76 @@ print_frame_local_vars (struct frame_info *frame, } } +/* Structure to hold the values of the options used by the 'info + variables' command and other similar commands. These correspond to the + -q and -t options. */ + +struct info_print_options +{ + bool quiet = false; + char *type_regexp = nullptr; + + ~info_print_options () + { + xfree (type_regexp); + } +}; + +/* The options used by the 'info locals' and 'info args' commands. */ + +static const gdb::option::option_def info_print_options_defs[] = { + gdb::option::boolean_option_def { + "q", + [] (info_print_options *opt) { return &opt->quiet; }, + nullptr, /* show_cmd_cb */ + nullptr /* set_doc */ + }, + + gdb::option::string_option_def { + "t", + [] (info_print_options *opt) { return &opt->type_regexp; }, + nullptr, /* show_cmd_cb */ + nullptr /* set_doc */ + } +}; + +/* Returns the option group used by 'info locals' and 'info args' + commands. */ + +static gdb::option::option_def_group +make_info_print_options_def_group (info_print_options *opts) +{ + return {{info_print_options_defs}, opts}; +} + +/* Command completer for 'info locals' and 'info args'. */ + +static void +info_print_command_completer (struct cmd_list_element *ignore, + completion_tracker &tracker, + const char *text, const char * /* word */) +{ + const auto group + = make_info_print_options_def_group (nullptr); + if (gdb::option::complete_options + (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group)) + return; + + const char *word = advance_to_expression_complete_word_point (tracker, text); + symbol_completer (ignore, tracker, text, word); +} + /* Implement the 'info locals' command. */ void info_locals_command (const char *args, int from_tty) { info_print_options opts; - extract_info_print_options (&opts, &args); + auto grp = make_info_print_options_def_group (&opts); + gdb::option::process_options + (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); + if (args != nullptr && *args == '\0') + args = nullptr; print_frame_local_vars (get_selected_frame (_("No frame selected.")), opts.quiet, args, opts.type_regexp, @@ -2447,9 +2553,9 @@ iterate_over_block_arg_vars (const struct block *b, float). There are also LOC_ARG/LOC_REGISTER pairs which are not combined in symbol-reading. */ - sym2 = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym), + sym2 = lookup_symbol_search_name (sym->search_name (), b, VAR_DOMAIN).symbol; - (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data); + (*cb) (sym->print_name (), sym2, cb_data); } } } @@ -2521,7 +2627,11 @@ void info_args_command (const char *args, int from_tty) { info_print_options opts; - extract_info_print_options (&opts, &args); + auto grp = make_info_print_options_def_group (&opts); + gdb::option::process_options + (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp); + if (args != nullptr && *args == '\0') + args = nullptr; print_frame_arg_vars (get_selected_frame (_("No frame selected.")), opts.quiet, args, opts.type_regexp, gdb_stdout); @@ -2745,7 +2855,7 @@ return_command (const char *retval_exp, int from_tty) if (TYPE_NO_RETURN (thisfun->type)) warning (_("Function does not return normally to caller.")); confirmed = query (_("%sMake %s return now? "), query_prefix, - SYMBOL_PRINT_NAME (thisfun)); + thisfun->print_name ()); } if (!confirmed) error (_("Not confirmed")); @@ -3171,6 +3281,8 @@ frame_apply_command (const char* cmd, int from_tty) static void faas_command (const char *cmd, int from_tty) { + if (cmd == NULL || *cmd == '\0') + error (_("Please specify a command to apply on all frames")); std::string expanded = std::string ("frame apply all -s ") + cmd; execute_command (expanded.c_str (), from_tty); } @@ -3478,14 +3590,16 @@ Usage: info frame level LEVEL"), All local variables of current stack frame or those matching REGEXPs.\n\ Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\ Prints the local variables of the current stack frame.\n"), - _("local variables"))); + _("local variables"), + false)); set_cmd_completer_handle_brkchars (cmd, info_print_command_completer); cmd = add_info ("args", info_args_command, info_print_args_help (_("\ All argument variables of current stack frame or those matching REGEXPs.\n\ Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\ Prints the argument variables of the current stack frame.\n"), - _("argument variables"))); + _("argument variables"), + false)); set_cmd_completer_handle_brkchars (cmd, info_print_command_completer); if (dbx_commands)