1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
53 #include "extension.h"
54 #include "observable.h"
55 #include "common/def-vector.h"
56 #include "cli/cli-option.h"
58 /* The possible choices of "set print frame-arguments", and the value
61 const char print_frame_arguments_all[] = "all";
62 const char print_frame_arguments_scalars[] = "scalars";
63 const char print_frame_arguments_none[] = "none";
65 static const char *const print_frame_arguments_choices[] =
67 print_frame_arguments_all,
68 print_frame_arguments_scalars,
69 print_frame_arguments_none,
73 /* The possible choices of "set print entry-values", and the value
76 const char print_entry_values_no[] = "no";
77 const char print_entry_values_only[] = "only";
78 const char print_entry_values_preferred[] = "preferred";
79 const char print_entry_values_if_needed[] = "if-needed";
80 const char print_entry_values_both[] = "both";
81 const char print_entry_values_compact[] = "compact";
82 const char print_entry_values_default[] = "default";
83 static const char *const print_entry_values_choices[] =
85 print_entry_values_no,
86 print_entry_values_only,
87 print_entry_values_preferred,
88 print_entry_values_if_needed,
89 print_entry_values_both,
90 print_entry_values_compact,
91 print_entry_values_default,
96 frame_print_options user_frame_print_options;
98 /* Option definitions for some frame-related "set print ..."
101 using boolean_option_def
102 = gdb::option::boolean_option_def<frame_print_options>;
103 using enum_option_def
104 = gdb::option::enum_option_def<frame_print_options>;
106 static const gdb::option::option_def frame_print_option_defs[] = {
110 print_entry_values_choices,
111 [] (frame_print_options *opt) { return &opt->print_entry_values; },
112 NULL, /* show_cmd_cb */
113 N_("Set printing of function arguments at function entry"),
114 N_("Show printing of function arguments at function entry"),
115 N_("GDB can sometimes determine the values of function arguments at entry,\n\
116 in addition to their current values. This option tells GDB whether\n\
117 to print the current value, the value at entry (marked as val@entry),\n\
118 or both. Note that one or both of these values may be <optimized out>."),
123 print_frame_arguments_choices,
124 [] (frame_print_options *opt) { return &opt->print_frame_arguments; },
125 NULL, /* show_cmd_cb */
126 N_("Set printing of non-scalar frame arguments"),
127 N_("Show printing of non-scalar frame arguments"),
132 "raw-frame-arguments",
133 [] (frame_print_options *opt) { return &opt->print_raw_frame_arguments; },
134 NULL, /* show_cmd_cb */
135 N_("Set whether to print frame arguments in raw form."),
136 N_("Show whether to print frame arguments in raw form."),
137 N_("If set, frame arguments are printed in raw form, bypassing any\n\
138 pretty-printers for that value.")
142 /* Options for the "backtrace" command. */
144 struct backtrace_cmd_options
151 using bt_flag_option_def
152 = gdb::option::flag_option_def<backtrace_cmd_options>;
154 static const gdb::option::option_def backtrace_command_option_defs[] = {
157 [] (backtrace_cmd_options *opt) { return &opt->full; },
158 N_("Print values of local variables.")
163 [] (backtrace_cmd_options *opt) { return &opt->no_filters; },
164 N_("Prohibit frame filters from executing on a backtrace."),
169 [] (backtrace_cmd_options *opt) { return &opt->hide; },
170 N_("Causes Python frame filter elided frames to not be printed."),
174 /* Prototypes for local functions. */
176 static void print_frame_local_vars (struct frame_info *frame,
178 const char *regexp, const char *t_regexp,
179 int num_tabs, struct ui_file *stream);
181 static void print_frame (const frame_print_options &opts,
182 frame_info *frame, int print_level,
183 enum print_what print_what, int print_args,
184 struct symtab_and_line sal);
186 static void set_last_displayed_sal (int valid,
187 struct program_space *pspace,
189 struct symtab *symtab,
192 static struct frame_info *find_frame_for_function (const char *);
193 static struct frame_info *find_frame_for_address (CORE_ADDR);
195 /* Zero means do things normally; we are interacting directly with the
196 user. One means print the full filename and linenumber when a
197 frame is printed, and do so in a format emacs18/emacs19.22 can
198 parse. Two means print similar annotations, but in many more
199 cases and in a slightly different syntax. */
201 int annotation_level = 0;
203 /* These variables hold the last symtab and line we displayed to the user.
204 * This is where we insert a breakpoint or a skiplist entry by default. */
205 static int last_displayed_sal_valid = 0;
206 static struct program_space *last_displayed_pspace = 0;
207 static CORE_ADDR last_displayed_addr = 0;
208 static struct symtab *last_displayed_symtab = 0;
209 static int last_displayed_line = 0;
212 /* Return 1 if we should display the address in addition to the location,
213 because we are in the middle of a statement. */
216 frame_show_address (struct frame_info *frame,
217 struct symtab_and_line sal)
219 /* If there is a line number, but no PC, then there is no location
220 information associated with this sal. The only way that should
221 happen is for the call sites of inlined functions (SAL comes from
222 find_frame_sal). Otherwise, we would have some PC range if the
223 SAL came from a line table. */
224 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
226 if (get_next_frame (frame) == NULL)
227 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
229 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
233 return get_frame_pc (frame) != sal.pc;
239 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
240 int print_level, enum print_what print_what,
243 scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
245 print_stack_frame (frame, print_level, print_what, set_current_sal);
248 /* Show or print a stack frame FRAME briefly. The output is formatted
249 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
250 relative level, function name, argument list, and file name and
251 line number. If the frame's PC is not at the beginning of the
252 source line, the actual PC is printed at the beginning. */
255 print_stack_frame (struct frame_info *frame, int print_level,
256 enum print_what print_what,
260 /* For mi, alway print location and address. */
261 if (current_uiout->is_mi_like_p ())
262 print_what = LOC_AND_ADDRESS;
266 print_frame_info (user_frame_print_options,
267 frame, print_level, print_what, 1 /* print_args */,
270 set_current_sal_from_frame (frame);
272 catch (const gdb_exception_error &e)
277 /* Print nameless arguments of frame FRAME on STREAM, where START is
278 the offset of the first nameless argument, and NUM is the number of
279 nameless arguments to print. FIRST is nonzero if this is the first
280 argument (not just the first nameless argument). */
283 print_frame_nameless_args (struct frame_info *frame, long start, int num,
284 int first, struct ui_file *stream)
286 struct gdbarch *gdbarch = get_frame_arch (frame);
287 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
292 for (i = 0; i < num; i++)
295 argsaddr = get_frame_args_address (frame);
298 arg_value = read_memory_integer (argsaddr + start,
299 sizeof (int), byte_order);
301 fprintf_filtered (stream, ", ");
302 fprintf_filtered (stream, "%ld", arg_value);
304 start += sizeof (int);
308 /* Print single argument of inferior function. ARG must be already
311 Errors are printed as if they would be the parameter value. Use zeroed ARG
312 iff it should not be printed accoring to user settings. */
315 print_frame_arg (const frame_print_options &fp_opts,
316 const struct frame_arg *arg)
318 struct ui_out *uiout = current_uiout;
322 gdb_assert (!arg->val || !arg->error);
323 gdb_assert (arg->entry_kind == print_entry_values_no
324 || arg->entry_kind == print_entry_values_only
325 || (!uiout->is_mi_like_p ()
326 && arg->entry_kind == print_entry_values_compact));
328 annotate_arg_emitter arg_emitter;
329 ui_out_emit_tuple tuple_emitter (uiout, NULL);
330 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
331 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
332 if (arg->entry_kind == print_entry_values_compact)
334 /* It is OK to provide invalid MI-like stream as with
335 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
338 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
339 SYMBOL_LANGUAGE (arg->sym),
340 DMGL_PARAMS | DMGL_ANSI);
342 if (arg->entry_kind == print_entry_values_only
343 || arg->entry_kind == print_entry_values_compact)
345 uiout->field_stream ("name", stb, ui_out_style_kind::VARIABLE);
346 annotate_arg_name_end ();
349 if (!arg->val && !arg->error)
354 stb.printf (_("<error reading variable: %s>"), arg->error);
359 const struct language_defn *language;
360 struct value_print_options vp_opts;
362 /* Avoid value_print because it will deref ref parameters. We
363 just want to print their addresses. Print ??? for args whose
364 address we do not know. We pass 2 as "recurse" to val_print
365 because our standard indentation here is 4 spaces, and
366 val_print indents 2 for each recurse. */
368 annotate_arg_value (value_type (arg->val));
370 /* Use the appropriate language to display our symbol, unless the
371 user forced the language to a specific language. */
372 if (language_mode == language_mode_auto)
373 language = language_def (SYMBOL_LANGUAGE (arg->sym));
375 language = current_language;
377 get_no_prettyformat_print_options (&vp_opts);
378 vp_opts.deref_ref = 1;
379 vp_opts.raw = fp_opts.print_raw_frame_arguments;
381 /* True in "summary" mode, false otherwise. */
383 = fp_opts.print_frame_arguments == print_frame_arguments_scalars;
385 common_val_print (arg->val, &stb, 2, &vp_opts, language);
387 catch (const gdb_exception_error &except)
389 stb.printf (_("<error reading variable: %s>"),
395 uiout->field_stream ("value", stb);
398 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
399 responsible for xfree of ARGP->ERROR. This function never throws an
403 read_frame_local (struct symbol *sym, struct frame_info *frame,
404 struct frame_arg *argp)
412 argp->val = read_var_value (sym, NULL, frame);
414 catch (const gdb_exception_error &except)
416 argp->error = xstrdup (except.what ());
420 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
421 responsible for xfree of ARGP->ERROR. This function never throws an
425 read_frame_arg (const frame_print_options &fp_opts,
426 symbol *sym, frame_info *frame,
427 struct frame_arg *argp, struct frame_arg *entryargp)
429 struct value *val = NULL, *entryval = NULL;
430 char *val_error = NULL, *entryval_error = NULL;
433 if (fp_opts.print_entry_values != print_entry_values_only
434 && fp_opts.print_entry_values != print_entry_values_preferred)
438 val = read_var_value (sym, NULL, frame);
440 catch (const gdb_exception_error &except)
442 val_error = (char *) alloca (except.message->size () + 1);
443 strcpy (val_error, except.what ());
447 if (SYMBOL_COMPUTED_OPS (sym) != NULL
448 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
449 && fp_opts.print_entry_values != print_entry_values_no
450 && (fp_opts.print_entry_values != print_entry_values_if_needed
451 || !val || value_optimized_out (val)))
455 const struct symbol_computed_ops *ops;
457 ops = SYMBOL_COMPUTED_OPS (sym);
458 entryval = ops->read_variable_at_entry (sym, frame);
460 catch (const gdb_exception_error &except)
462 if (except.error != NO_ENTRY_VALUE_ERROR)
464 entryval_error = (char *) alloca (except.message->size () + 1);
465 strcpy (entryval_error, except.what ());
469 if (entryval != NULL && value_optimized_out (entryval))
472 if (fp_opts.print_entry_values == print_entry_values_compact
473 || fp_opts.print_entry_values == print_entry_values_default)
475 /* For MI do not try to use print_entry_values_compact for ARGP. */
477 if (val && entryval && !current_uiout->is_mi_like_p ())
479 struct type *type = value_type (val);
481 if (value_lazy (val))
482 value_fetch_lazy (val);
483 if (value_lazy (entryval))
484 value_fetch_lazy (entryval);
486 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
488 /* Initialize it just to avoid a GCC false warning. */
489 struct value *val_deref = NULL, *entryval_deref;
491 /* DW_AT_call_value does match with the current
492 value. If it is a reference still try to verify if
493 dereferenced DW_AT_call_data_value does not differ. */
497 struct type *type_deref;
499 val_deref = coerce_ref (val);
500 if (value_lazy (val_deref))
501 value_fetch_lazy (val_deref);
502 type_deref = value_type (val_deref);
504 entryval_deref = coerce_ref (entryval);
505 if (value_lazy (entryval_deref))
506 value_fetch_lazy (entryval_deref);
508 /* If the reference addresses match but dereferenced
509 content does not match print them. */
511 && value_contents_eq (val_deref, 0,
513 TYPE_LENGTH (type_deref)))
516 catch (const gdb_exception_error &except)
518 /* If the dereferenced content could not be
519 fetched do not display anything. */
520 if (except.error == NO_ENTRY_VALUE_ERROR)
522 else if (except.message != NULL)
525 = (char *) alloca (except.message->size () + 1);
526 strcpy (entryval_error, except.what ());
530 /* Value was not a reference; and its content matches. */
531 if (val == val_deref)
539 /* Try to remove possibly duplicate error message for ENTRYARGP even
542 if (val_error && entryval_error
543 && strcmp (val_error, entryval_error) == 0)
545 entryval_error = NULL;
547 /* Do not se VAL_EQUAL as the same error message may be shown for
548 the entry value even if no entry values are present in the
554 if (entryval == NULL)
556 if (fp_opts.print_entry_values == print_entry_values_preferred)
558 gdb_assert (val == NULL);
562 val = read_var_value (sym, NULL, frame);
564 catch (const gdb_exception_error &except)
566 val_error = (char *) alloca (except.message->size () + 1);
567 strcpy (val_error, except.what ());
570 if (fp_opts.print_entry_values == print_entry_values_only
571 || fp_opts.print_entry_values == print_entry_values_both
572 || (fp_opts.print_entry_values == print_entry_values_preferred
573 && (!val || value_optimized_out (val))))
575 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
576 entryval_error = NULL;
579 if ((fp_opts.print_entry_values == print_entry_values_compact
580 || fp_opts.print_entry_values == print_entry_values_if_needed
581 || fp_opts.print_entry_values == print_entry_values_preferred)
582 && (!val || value_optimized_out (val)) && entryval != NULL)
590 argp->error = val_error ? xstrdup (val_error) : NULL;
591 if (!val && !val_error)
592 argp->entry_kind = print_entry_values_only;
593 else if ((fp_opts.print_entry_values == print_entry_values_compact
594 || fp_opts.print_entry_values == print_entry_values_default)
597 argp->entry_kind = print_entry_values_compact;
598 gdb_assert (!current_uiout->is_mi_like_p ());
601 argp->entry_kind = print_entry_values_no;
603 entryargp->sym = sym;
604 entryargp->val = entryval;
605 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
606 if (!entryval && !entryval_error)
607 entryargp->entry_kind = print_entry_values_no;
609 entryargp->entry_kind = print_entry_values_only;
612 /* Print the arguments of frame FRAME on STREAM, given the function
613 FUNC running in that frame (as a symbol), where NUM is the number
614 of arguments according to the stack frame (or -1 if the number of
615 arguments is unknown). */
617 /* Note that currently the "number of arguments according to the
618 stack frame" is only known on VAX where i refers to the "number of
619 ints of arguments according to the stack frame". */
622 print_frame_args (const frame_print_options &fp_opts,
623 struct symbol *func, struct frame_info *frame,
624 int num, struct ui_file *stream)
626 struct ui_out *uiout = current_uiout;
628 /* Offset of next stack argument beyond the one we have seen that is
629 at the highest offset, or -1 if we haven't come to a stack
631 long highest_offset = -1;
632 /* Number of ints of arguments that we have printed so far. */
633 int args_printed = 0;
634 /* True if we should print arguments, false otherwise. */
636 = fp_opts.print_frame_arguments != print_frame_arguments_none;
640 const struct block *b = SYMBOL_BLOCK_VALUE (func);
641 struct block_iterator iter;
644 ALL_BLOCK_SYMBOLS (b, iter, sym)
646 struct frame_arg arg, entryarg;
650 /* Keep track of the highest stack argument offset seen, and
651 skip over any kinds of symbols we don't care about. */
653 if (!SYMBOL_IS_ARGUMENT (sym))
656 switch (SYMBOL_CLASS (sym))
661 long current_offset = SYMBOL_VALUE (sym);
662 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
664 /* Compute address of next argument by adding the size of
665 this argument and rounding to an int boundary. */
667 ((current_offset + arg_size + sizeof (int) - 1)
668 & ~(sizeof (int) - 1));
670 /* If this is the highest offset seen yet, set
672 if (highest_offset == -1
673 || (current_offset > highest_offset))
674 highest_offset = current_offset;
676 /* Add the number of ints we're about to print to
678 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
681 /* We care about types of symbols, but don't need to
682 keep track of stack offsets in them. */
684 case LOC_REGPARM_ADDR:
686 case LOC_OPTIMIZED_OUT:
691 /* We have to look up the symbol because arguments can have
692 two entries (one a parameter, one a local) and the one we
693 want is the local, which lookup_symbol will find for us.
694 This includes gcc1 (not gcc2) on SPARC when passing a
695 small structure and gcc2 when the argument type is float
696 and it is passed as a double and converted to float by
697 the prologue (in the latter case the type of the LOC_ARG
698 symbol is double and the type of the LOC_LOCAL symbol is
700 /* But if the parameter name is null, don't try it. Null
701 parameter names occur on the RS/6000, for traceback
702 tables. FIXME, should we even print them? */
704 if (*SYMBOL_LINKAGE_NAME (sym))
708 nsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
709 b, VAR_DOMAIN).symbol;
710 gdb_assert (nsym != NULL);
711 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
712 && !SYMBOL_IS_ARGUMENT (nsym))
714 /* There is a LOC_ARG/LOC_REGISTER pair. This means
715 that it was passed on the stack and loaded into a
716 register, or passed in a register and stored in a
717 stack slot. GDB 3.x used the LOC_ARG; GDB
718 4.0-4.11 used the LOC_REGISTER.
720 Reasons for using the LOC_ARG:
722 (1) Because find_saved_registers may be slow for
725 (2) Because registers are often re-used and stack
726 slots rarely (never?) are. Therefore using
727 the stack slot is much less likely to print
730 Reasons why we might want to use the LOC_REGISTER:
732 (1) So that the backtrace prints the same value
733 as "print foo". I see no compelling reason
734 why this needs to be the case; having the
735 backtrace print the value which was passed
736 in, and "print foo" print the value as
737 modified within the called function, makes
740 Additional note: It might be nice if "info args"
741 displayed both values.
743 One more note: There is a case with SPARC
744 structure passing where we need to use the
745 LOC_REGISTER, but this is dealt with by creating
746 a single LOC_REGPARM in symbol reading. */
748 /* Leave sym (the LOC_ARG) alone. */
755 /* Print the current arg. */
758 uiout->wrap_hint (" ");
762 memset (&arg, 0, sizeof (arg));
764 arg.entry_kind = print_entry_values_no;
765 memset (&entryarg, 0, sizeof (entryarg));
767 entryarg.entry_kind = print_entry_values_no;
770 read_frame_arg (fp_opts, sym, frame, &arg, &entryarg);
772 if (arg.entry_kind != print_entry_values_only)
773 print_frame_arg (fp_opts, &arg);
775 if (entryarg.entry_kind != print_entry_values_no)
777 if (arg.entry_kind != print_entry_values_only)
780 uiout->wrap_hint (" ");
783 print_frame_arg (fp_opts, &entryarg);
787 xfree (entryarg.error);
793 /* Don't print nameless args in situations where we don't know
794 enough about the stack to find them. */
799 if (highest_offset == -1)
800 start = gdbarch_frame_args_skip (get_frame_arch (frame));
802 start = highest_offset;
804 print_frame_nameless_args (frame, start, num - args_printed,
809 /* Set the current source and line to the location given by frame
810 FRAME, if possible. When CENTER is true, adjust so the relevant
811 line is in the center of the next 'list'. */
814 set_current_sal_from_frame (struct frame_info *frame)
816 symtab_and_line sal = find_frame_sal (frame);
817 if (sal.symtab != NULL)
818 set_current_source_symtab_and_line (sal);
821 /* If ON, GDB will display disassembly of the next source line when
822 execution of the program being debugged stops.
823 If AUTO (which is the default), or there's no line info to determine
824 the source line of the next instruction, display disassembly of next
825 instruction instead. */
827 static enum auto_boolean disassemble_next_line;
830 show_disassemble_next_line (struct ui_file *file, int from_tty,
831 struct cmd_list_element *c,
834 fprintf_filtered (file,
835 _("Debugger's willingness to use "
836 "disassemble-next-line is %s.\n"),
840 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
841 because it will be broken by filter sometime. */
844 do_gdb_disassembly (struct gdbarch *gdbarch,
845 int how_many, CORE_ADDR low, CORE_ADDR high)
850 gdb_disassembly (gdbarch, current_uiout,
851 DISASSEMBLY_RAW_INSN, how_many,
854 catch (const gdb_exception_error &exception)
856 /* If an exception was thrown while doing the disassembly, print
857 the error message, to give the user a clue of what happened. */
858 exception_print (gdb_stderr, exception);
862 /* Print information about frame FRAME. The output is format according
863 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
866 SRC_LINE: Print only source line.
867 LOCATION: Print only location.
868 SRC_AND_LOC: Print location and source line.
870 Used in "where" output, and to emit breakpoint or step
874 print_frame_info (const frame_print_options &fp_opts,
875 frame_info *frame, int print_level,
876 enum print_what print_what, int print_args,
879 struct gdbarch *gdbarch = get_frame_arch (frame);
882 struct ui_out *uiout = current_uiout;
884 if (get_frame_type (frame) == DUMMY_FRAME
885 || get_frame_type (frame) == SIGTRAMP_FRAME
886 || get_frame_type (frame) == ARCH_FRAME)
888 ui_out_emit_tuple tuple_emitter (uiout, "frame");
890 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
891 gdbarch, get_frame_pc (frame));
893 /* Do this regardless of SOURCE because we don't have any source
894 to list for this frame. */
898 uiout->field_fmt_int (2, ui_left, "level",
899 frame_relative_level (frame));
901 if (uiout->is_mi_like_p ())
903 annotate_frame_address ();
904 uiout->field_core_addr ("addr",
905 gdbarch, get_frame_pc (frame));
906 annotate_frame_address_end ();
909 if (get_frame_type (frame) == DUMMY_FRAME)
911 annotate_function_call ();
912 uiout->field_string ("func", "<function called from gdb>",
913 ui_out_style_kind::FUNCTION);
915 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
917 annotate_signal_handler_caller ();
918 uiout->field_string ("func", "<signal handler called>",
919 ui_out_style_kind::FUNCTION);
921 else if (get_frame_type (frame) == ARCH_FRAME)
923 uiout->field_string ("func", "<cross-architecture call>",
924 ui_out_style_kind::FUNCTION);
927 annotate_frame_end ();
929 /* If disassemble-next-line is set to auto or on output the next
931 if (disassemble_next_line == AUTO_BOOLEAN_AUTO
932 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
933 do_gdb_disassembly (get_frame_arch (frame), 1,
934 get_frame_pc (frame), get_frame_pc (frame) + 1);
939 /* If FRAME is not the innermost frame, that normally means that
940 FRAME->pc points to *after* the call instruction, and we want to
941 get the line containing the call, never the next line. But if
942 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
943 next frame was not entered as the result of a call, and we want
944 to get the line containing FRAME->pc. */
945 symtab_and_line sal = find_frame_sal (frame);
947 location_print = (print_what == LOCATION
948 || print_what == LOC_AND_ADDRESS
949 || print_what == SRC_AND_LOC);
951 if (location_print || !sal.symtab)
952 print_frame (fp_opts, frame, print_level, print_what, print_args, sal);
954 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
956 /* If disassemble-next-line is set to auto or on and doesn't have
957 the line debug messages for $pc, output the next instruction. */
958 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
959 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
960 && source_print && !sal.symtab)
961 do_gdb_disassembly (get_frame_arch (frame), 1,
962 get_frame_pc (frame), get_frame_pc (frame) + 1);
964 if (source_print && sal.symtab)
966 int mid_statement = ((print_what == SRC_LINE)
967 && frame_show_address (frame, sal));
968 bool done = annotate_source_line (sal.symtab, sal.line, mid_statement,
969 get_frame_pc (frame));
973 if (deprecated_print_frame_info_listing_hook)
974 deprecated_print_frame_info_listing_hook (sal.symtab,
979 struct value_print_options opts;
981 get_user_print_options (&opts);
982 /* We used to do this earlier, but that is clearly
983 wrong. This function is used by many different
984 parts of gdb, including normal_stop in infrun.c,
985 which uses this to print out the current PC
986 when we stepi/nexti into the middle of a source
987 line. Only the command line really wants this
988 behavior. Other UIs probably would like the
989 ability to decide for themselves if it is desired. */
990 if (opts.addressprint && mid_statement)
992 uiout->field_core_addr ("addr",
993 gdbarch, get_frame_pc (frame));
997 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1001 /* If disassemble-next-line is set to on and there is line debug
1002 messages, output assembly codes for next line. */
1003 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
1004 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
1007 if (set_current_sal)
1011 if (get_frame_pc_if_available (frame, &pc))
1012 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
1014 set_last_displayed_sal (0, 0, 0, 0, 0);
1017 annotate_frame_end ();
1019 gdb_flush (gdb_stdout);
1022 /* Remember the last symtab and line we displayed, which we use e.g.
1023 * as the place to put a breakpoint when the `break' command is
1024 * invoked with no arguments. */
1027 set_last_displayed_sal (int valid, struct program_space *pspace,
1028 CORE_ADDR addr, struct symtab *symtab,
1031 last_displayed_sal_valid = valid;
1032 last_displayed_pspace = pspace;
1033 last_displayed_addr = addr;
1034 last_displayed_symtab = symtab;
1035 last_displayed_line = line;
1036 if (valid && pspace == NULL)
1038 clear_last_displayed_sal ();
1039 internal_error (__FILE__, __LINE__,
1040 _("Trying to set NULL pspace."));
1044 /* Forget the last sal we displayed. */
1047 clear_last_displayed_sal (void)
1049 last_displayed_sal_valid = 0;
1050 last_displayed_pspace = 0;
1051 last_displayed_addr = 0;
1052 last_displayed_symtab = 0;
1053 last_displayed_line = 0;
1056 /* Is our record of the last sal we displayed valid? If not,
1057 * the get_last_displayed_* functions will return NULL or 0, as
1061 last_displayed_sal_is_valid (void)
1063 return last_displayed_sal_valid;
1066 /* Get the pspace of the last sal we displayed, if it's valid. */
1068 struct program_space *
1069 get_last_displayed_pspace (void)
1071 if (last_displayed_sal_valid)
1072 return last_displayed_pspace;
1076 /* Get the address of the last sal we displayed, if it's valid. */
1079 get_last_displayed_addr (void)
1081 if (last_displayed_sal_valid)
1082 return last_displayed_addr;
1086 /* Get the symtab of the last sal we displayed, if it's valid. */
1089 get_last_displayed_symtab (void)
1091 if (last_displayed_sal_valid)
1092 return last_displayed_symtab;
1096 /* Get the line of the last sal we displayed, if it's valid. */
1099 get_last_displayed_line (void)
1101 if (last_displayed_sal_valid)
1102 return last_displayed_line;
1106 /* Get the last sal we displayed, if it's valid. */
1109 get_last_displayed_sal ()
1111 symtab_and_line sal;
1113 if (last_displayed_sal_valid)
1115 sal.pspace = last_displayed_pspace;
1116 sal.pc = last_displayed_addr;
1117 sal.symtab = last_displayed_symtab;
1118 sal.line = last_displayed_line;
1125 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1126 corresponding to FRAME. */
1128 gdb::unique_xmalloc_ptr<char>
1129 find_frame_funname (struct frame_info *frame, enum language *funlang,
1130 struct symbol **funcp)
1132 struct symbol *func;
1133 gdb::unique_xmalloc_ptr<char> funname;
1135 *funlang = language_unknown;
1139 func = get_frame_function (frame);
1142 /* In certain pathological cases, the symtabs give the wrong
1143 function (when we are in the first function in a file which
1144 is compiled without debugging symbols, the previous function
1145 is compiled with debugging symbols, and the "foo.o" symbol
1146 that is supposed to tell us where the file with debugging
1147 symbols ends has been truncated by ar because it is longer
1148 than 15 characters). This also occurs if the user uses asm()
1149 to create a function but not stabs for it (in a file compiled
1152 So look in the minimal symbol tables as well, and if it comes
1153 up with a larger address for the function use that instead.
1154 I don't think this can ever cause any problems; there
1155 shouldn't be any minimal symbols in the middle of a function;
1156 if this is ever changed many parts of GDB will need to be
1157 changed (and we'll create a find_pc_minimal_function or some
1160 struct bound_minimal_symbol msymbol;
1162 /* Don't attempt to do this for inlined functions, which do not
1163 have a corresponding minimal symbol. */
1164 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1166 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1168 memset (&msymbol, 0, sizeof (msymbol));
1170 if (msymbol.minsym != NULL
1171 && (BMSYMBOL_VALUE_ADDRESS (msymbol)
1172 > BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func))))
1174 /* We also don't know anything about the function besides
1175 its address and name. */
1177 funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1178 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1182 const char *print_name = SYMBOL_PRINT_NAME (func);
1184 *funlang = SYMBOL_LANGUAGE (func);
1187 if (*funlang == language_cplus)
1189 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1190 to display the demangled name that we already have
1191 stored in the symbol table, but we stored a version
1192 with DMGL_PARAMS turned on, and here we don't want to
1193 display parameters. So remove the parameters. */
1194 funname = cp_remove_params (print_name);
1197 /* If we didn't hit the C++ case above, set *funname
1199 if (funname == NULL)
1200 funname.reset (xstrdup (print_name));
1205 struct bound_minimal_symbol msymbol;
1208 if (!get_frame_address_in_block_if_available (frame, &pc))
1211 msymbol = lookup_minimal_symbol_by_pc (pc);
1212 if (msymbol.minsym != NULL)
1214 funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1215 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1223 print_frame (const frame_print_options &fp_opts,
1224 frame_info *frame, int print_level,
1225 enum print_what print_what, int print_args,
1226 struct symtab_and_line sal)
1228 struct gdbarch *gdbarch = get_frame_arch (frame);
1229 struct ui_out *uiout = current_uiout;
1230 enum language funlang = language_unknown;
1231 struct value_print_options opts;
1232 struct symbol *func;
1236 pc_p = get_frame_pc_if_available (frame, &pc);
1238 gdb::unique_xmalloc_ptr<char> funname
1239 = find_frame_funname (frame, &funlang, &func);
1241 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1245 ui_out_emit_tuple tuple_emitter (uiout, "frame");
1250 uiout->field_fmt_int (2, ui_left, "level",
1251 frame_relative_level (frame));
1253 get_user_print_options (&opts);
1254 if (opts.addressprint)
1256 || frame_show_address (frame, sal)
1257 || print_what == LOC_AND_ADDRESS)
1259 annotate_frame_address ();
1261 uiout->field_core_addr ("addr", gdbarch, pc);
1263 uiout->field_string ("addr", "<unavailable>",
1264 ui_out_style_kind::ADDRESS);
1265 annotate_frame_address_end ();
1266 uiout->text (" in ");
1268 annotate_frame_function_name ();
1271 fprintf_symbol_filtered (&stb, funname ? funname.get () : "??",
1272 funlang, DMGL_ANSI);
1273 uiout->field_stream ("func", stb, ui_out_style_kind::FUNCTION);
1274 uiout->wrap_hint (" ");
1275 annotate_frame_args ();
1282 if (gdbarch_frame_num_args_p (gdbarch))
1284 numargs = gdbarch_frame_num_args (gdbarch, frame);
1285 gdb_assert (numargs >= 0);
1291 ui_out_emit_list list_emitter (uiout, "args");
1294 print_frame_args (fp_opts, func, frame, numargs, gdb_stdout);
1296 catch (const gdb_exception_error &e)
1300 /* FIXME: ARGS must be a list. If one argument is a string it
1301 will have " that will not be properly escaped. */
1308 const char *filename_display;
1310 filename_display = symtab_to_filename_for_display (sal.symtab);
1311 annotate_frame_source_begin ();
1312 uiout->wrap_hint (" ");
1313 uiout->text (" at ");
1314 annotate_frame_source_file ();
1315 uiout->field_string ("file", filename_display, ui_out_style_kind::FILE);
1316 if (uiout->is_mi_like_p ())
1318 const char *fullname = symtab_to_fullname (sal.symtab);
1320 uiout->field_string ("fullname", fullname);
1322 annotate_frame_source_file_end ();
1324 annotate_frame_source_line ();
1325 uiout->field_int ("line", sal.line);
1326 annotate_frame_source_end ();
1329 if (pc_p && (funname == NULL || sal.symtab == NULL))
1331 char *lib = solib_name_from_address (get_frame_program_space (frame),
1332 get_frame_pc (frame));
1336 annotate_frame_where ();
1337 uiout->wrap_hint (" ");
1338 uiout->text (" from ");
1339 uiout->field_string ("from", lib);
1342 if (uiout->is_mi_like_p ())
1343 uiout->field_string ("arch",
1344 (gdbarch_bfd_arch_info (gdbarch))->printable_name);
1351 /* Completion function for "frame function", "info frame function", and
1352 "select-frame function" commands. */
1355 frame_selection_by_function_completer (struct cmd_list_element *ignore,
1356 completion_tracker &tracker,
1357 const char *text, const char *word)
1359 /* This is used to complete function names within a stack. It would be
1360 nice if we only offered functions that were actually in the stack.
1361 However, this would mean unwinding the stack to completion, which
1362 could take too long, or on a corrupted stack, possibly not end.
1363 Instead, we offer all symbol names as a safer choice. */
1364 collect_symbol_completion_matches (tracker,
1365 complete_symbol_mode::EXPRESSION,
1366 symbol_name_match_type::EXPRESSION,
1370 /* Core of all the "info frame" sub-commands. Print information about a
1371 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1372 frame specification, they just entered 'info frame'. If the user did
1373 provide a frame specification (for example 'info frame 0', 'info frame
1374 level 1') then SELECTED_FRAME_P will be false. */
1377 info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
1379 struct symbol *func;
1381 struct frame_info *calling_frame_info;
1383 const char *funname = 0;
1384 enum language funlang = language_unknown;
1385 const char *pc_regname;
1386 struct gdbarch *gdbarch;
1389 /* Initialize it to avoid "may be used uninitialized" warning. */
1390 CORE_ADDR caller_pc = 0;
1391 int caller_pc_p = 0;
1393 gdbarch = get_frame_arch (fi);
1395 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1396 is not a good name. */
1397 if (gdbarch_pc_regnum (gdbarch) >= 0)
1398 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1399 easily not match that of the internal value returned by
1401 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1403 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1404 architectures will often have a hardware register called "pc",
1405 and that register's value, again, can easily not match
1409 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1410 func = get_frame_function (fi);
1411 symtab_and_line sal = find_frame_sal (fi);
1413 gdb::unique_xmalloc_ptr<char> func_only;
1416 funname = SYMBOL_PRINT_NAME (func);
1417 funlang = SYMBOL_LANGUAGE (func);
1418 if (funlang == language_cplus)
1420 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1421 to display the demangled name that we already have
1422 stored in the symbol table, but we stored a version
1423 with DMGL_PARAMS turned on, and here we don't want to
1424 display parameters. So remove the parameters. */
1425 func_only = cp_remove_params (funname);
1428 funname = func_only.get ();
1431 else if (frame_pc_p)
1433 struct bound_minimal_symbol msymbol;
1435 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1436 if (msymbol.minsym != NULL)
1438 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1439 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1442 calling_frame_info = get_prev_frame (fi);
1444 if (selected_frame_p && frame_relative_level (fi) >= 0)
1446 printf_filtered (_("Stack level %d, frame at "),
1447 frame_relative_level (fi));
1451 printf_filtered (_("Stack frame at "));
1453 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1454 printf_filtered (":\n");
1455 printf_filtered (" %s = ", pc_regname);
1457 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1459 fputs_filtered ("<unavailable>", gdb_stdout);
1464 printf_filtered (" in ");
1465 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1466 DMGL_ANSI | DMGL_PARAMS);
1470 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1472 puts_filtered ("; ");
1474 printf_filtered ("saved %s = ", pc_regname);
1476 if (!frame_id_p (frame_unwind_caller_id (fi)))
1477 val_print_not_saved (gdb_stdout);
1482 caller_pc = frame_unwind_caller_pc (fi);
1485 catch (const gdb_exception_error &ex)
1489 case NOT_AVAILABLE_ERROR:
1490 val_print_unavailable (gdb_stdout);
1492 case OPTIMIZED_OUT_ERROR:
1493 val_print_not_saved (gdb_stdout);
1496 fprintf_filtered (gdb_stdout, _("<error: %s>"),
1504 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1505 printf_filtered ("\n");
1507 if (calling_frame_info == NULL)
1509 enum unwind_stop_reason reason;
1511 reason = get_frame_unwind_stop_reason (fi);
1512 if (reason != UNWIND_NO_REASON)
1513 printf_filtered (_(" Outermost frame: %s\n"),
1514 frame_stop_reason_string (fi));
1516 else if (get_frame_type (fi) == TAILCALL_FRAME)
1517 puts_filtered (" tail call frame");
1518 else if (get_frame_type (fi) == INLINE_FRAME)
1519 printf_filtered (" inlined into frame %d",
1520 frame_relative_level (get_prev_frame (fi)));
1523 printf_filtered (" called by frame at ");
1524 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1527 if (get_next_frame (fi) && calling_frame_info)
1528 puts_filtered (",");
1530 if (get_next_frame (fi))
1532 printf_filtered (" caller of frame at ");
1533 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1536 if (get_next_frame (fi) || calling_frame_info)
1537 puts_filtered ("\n");
1540 printf_filtered (" source language %s.\n",
1541 language_str (s->language));
1544 /* Address of the argument list for this frame, or 0. */
1545 CORE_ADDR arg_list = get_frame_args_address (fi);
1546 /* Number of args for this frame, or -1 if unknown. */
1550 printf_filtered (" Arglist at unknown address.\n");
1553 printf_filtered (" Arglist at ");
1554 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1555 printf_filtered (",");
1557 if (!gdbarch_frame_num_args_p (gdbarch))
1560 puts_filtered (" args: ");
1564 numargs = gdbarch_frame_num_args (gdbarch, fi);
1565 gdb_assert (numargs >= 0);
1567 puts_filtered (" no args.");
1568 else if (numargs == 1)
1569 puts_filtered (" 1 arg: ");
1571 printf_filtered (" %d args: ", numargs);
1573 print_frame_args (user_frame_print_options,
1574 func, fi, numargs, gdb_stdout);
1575 puts_filtered ("\n");
1579 /* Address of the local variables for this frame, or 0. */
1580 CORE_ADDR arg_list = get_frame_locals_address (fi);
1583 printf_filtered (" Locals at unknown address,");
1586 printf_filtered (" Locals at ");
1587 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1588 printf_filtered (",");
1592 /* Print as much information as possible on the location of all the
1598 int sp_regnum = gdbarch_sp_regnum (gdbarch);
1600 /* The sp is special; what's displayed isn't the save address, but
1601 the value of the previous frame's sp. This is a legacy thing,
1602 at one stage the frame cached the previous frame's SP instead
1603 of its address, hence it was easiest to just display the cached
1607 struct value *value = frame_unwind_register_value (fi, sp_regnum);
1608 gdb_assert (value != NULL);
1610 if (!value_optimized_out (value) && value_entirely_available (value))
1612 if (VALUE_LVAL (value) == not_lval)
1615 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1616 int sp_size = register_size (gdbarch, sp_regnum);
1618 sp = extract_unsigned_integer (value_contents_all (value),
1619 sp_size, byte_order);
1621 printf_filtered (" Previous frame's sp is ");
1622 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1623 printf_filtered ("\n");
1625 else if (VALUE_LVAL (value) == lval_memory)
1627 printf_filtered (" Previous frame's sp at ");
1628 fputs_filtered (paddress (gdbarch, value_address (value)),
1630 printf_filtered ("\n");
1632 else if (VALUE_LVAL (value) == lval_register)
1634 printf_filtered (" Previous frame's sp in %s\n",
1635 gdbarch_register_name (gdbarch,
1636 VALUE_REGNUM (value)));
1639 release_value (value);
1642 /* else keep quiet. */
1646 numregs = gdbarch_num_cooked_regs (gdbarch);
1647 for (i = 0; i < numregs; i++)
1649 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1651 enum lval_type lval;
1657 /* Find out the location of the saved register without
1658 fetching the corresponding value. */
1659 frame_register_unwind (fi, i, &optimized, &unavailable,
1660 &lval, &addr, &realnum, NULL);
1661 /* For moment, only display registers that were saved on the
1663 if (!optimized && !unavailable && lval == lval_memory)
1666 puts_filtered (" Saved registers:\n ");
1668 puts_filtered (",");
1670 printf_filtered (" %s at ",
1671 gdbarch_register_name (gdbarch, i));
1672 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1676 if (count || need_nl)
1677 puts_filtered ("\n");
1681 /* Return the innermost frame at level LEVEL. */
1683 static struct frame_info *
1684 leading_innermost_frame (int level)
1686 struct frame_info *leading;
1688 leading = get_current_frame ();
1690 gdb_assert (level >= 0);
1692 while (leading != nullptr && level)
1695 leading = get_prev_frame (leading);
1702 /* Return the starting frame needed to handle COUNT outermost frames. */
1704 static struct frame_info *
1705 trailing_outermost_frame (int count)
1707 struct frame_info *current;
1708 struct frame_info *trailing;
1710 trailing = get_current_frame ();
1712 gdb_assert (count > 0);
1715 while (current != nullptr && count--)
1718 current = get_prev_frame (current);
1721 /* Will stop when CURRENT reaches the top of the stack.
1722 TRAILING will be COUNT below it. */
1723 while (current != nullptr)
1726 trailing = get_prev_frame (trailing);
1727 current = get_prev_frame (current);
1733 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1737 select_frame_command_core (struct frame_info *fi, bool ignored)
1739 struct frame_info *prev_frame = get_selected_frame_if_set ();
1741 if (get_selected_frame_if_set () != prev_frame)
1742 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1748 select_frame_for_mi (struct frame_info *fi)
1750 select_frame_command_core (fi, false /* Ignored. */);
1753 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1754 means we change frame send out a change notification (otherwise, just
1755 reprint the current frame summary). */
1758 frame_command_core (struct frame_info *fi, bool ignored)
1760 struct frame_info *prev_frame = get_selected_frame_if_set ();
1763 if (get_selected_frame_if_set () != prev_frame)
1764 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1766 print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
1769 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1770 common set of sub-commands that allow a specific frame to be selected.
1771 All of the sub-command functions are static methods within this class
1772 template which is then instantiated below. The template parameter is a
1773 callback used to implement the functionality of the base command
1774 ('frame', 'select-frame', or 'info frame').
1776 In the template parameter FI is the frame being selected. The
1777 SELECTED_FRAME_P flag is true if the frame being selected was done by
1778 default, which happens when the user uses the base command with no
1779 arguments. For example the commands 'info frame', 'select-frame',
1780 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1781 SELECTED_FRAME_P is false. */
1783 template <void (*FPTR) (struct frame_info *fi, bool selected_frame_p)>
1784 class frame_command_helper
1788 /* The "frame level" family of commands. The ARG is an integer that is
1789 the frame's level in the stack. */
1791 level (const char *arg, int from_tty)
1793 int level = value_as_long (parse_and_eval (arg));
1794 struct frame_info *fid
1795 = find_relative_frame (get_current_frame (), &level);
1797 error (_("No frame at level %s."), arg);
1801 /* The "frame address" family of commands. ARG is a stack-pointer
1802 address for an existing frame. This command does not allow new
1803 frames to be created. */
1806 address (const char *arg, int from_tty)
1808 CORE_ADDR addr = value_as_address (parse_and_eval (arg));
1809 struct frame_info *fid = find_frame_for_address (addr);
1811 error (_("No frame at address %s."), arg);
1815 /* The "frame view" family of commands. ARG is one or two addresses and
1816 is used to view a frame that might be outside the current backtrace.
1817 The addresses are stack-pointer address, and (optional) pc-address. */
1820 view (const char *args, int from_tty)
1822 struct frame_info *fid;
1825 error (_("Missing address argument to view a frame"));
1827 gdb_argv argv (args);
1829 if (argv.count () == 2)
1833 addr [0] = value_as_address (parse_and_eval (argv[0]));
1834 addr [1] = value_as_address (parse_and_eval (argv[1]));
1835 fid = create_new_frame (addr[0], addr[1]);
1839 CORE_ADDR addr = value_as_address (parse_and_eval (argv[0]));
1840 fid = create_new_frame (addr, false);
1845 /* The "frame function" family of commands. ARG is the name of a
1846 function within the stack, the first function (searching from frame
1847 0) with that name will be selected. */
1850 function (const char *arg, int from_tty)
1853 error (_("Missing function name argument"));
1854 struct frame_info *fid = find_frame_for_function (arg);
1856 error (_("No frame for function \"%s\"."), arg);
1860 /* The "frame" base command, that is, when no sub-command is specified.
1861 If one argument is provided then we assume that this is a frame's
1862 level as historically, this was the supported command syntax that was
1865 If no argument is provided, then the current frame is selected. */
1868 base_command (const char *arg, int from_tty)
1871 FPTR (get_selected_frame (_("No stack.")), true);
1873 level (arg, from_tty);
1877 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1878 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1880 static frame_command_helper <info_frame_command_core> info_frame_cmd;
1881 static frame_command_helper <frame_command_core> frame_cmd;
1882 static frame_command_helper <select_frame_command_core> select_frame_cmd;
1884 /* Print briefly all stack frames or just the innermost COUNT_EXP
1888 backtrace_command_1 (const frame_print_options &fp_opts,
1889 const backtrace_cmd_options &bt_opts,
1890 const char *count_exp, int from_tty)
1893 struct frame_info *fi;
1895 int py_start = 0, py_end = 0;
1896 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1898 if (!target_has_stack)
1899 error (_("No stack."));
1903 count = parse_and_eval_long (count_exp);
1909 /* The argument to apply_ext_lang_frame_filter is the number
1910 of the final frame to print, and frames start at 0. */
1920 frame_filter_flags flags = 0;
1923 flags |= PRINT_LOCALS;
1925 flags |= PRINT_HIDE;
1927 if (!bt_opts.no_filters)
1929 enum ext_lang_frame_args arg_type;
1931 flags |= PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1933 flags |= PRINT_MORE_FRAMES;
1935 if (fp_opts.print_frame_arguments == print_frame_arguments_scalars)
1936 arg_type = CLI_SCALAR_VALUES;
1937 else if (fp_opts.print_frame_arguments == print_frame_arguments_all)
1938 arg_type = CLI_ALL_VALUES;
1940 arg_type = NO_VALUES;
1942 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1943 arg_type, current_uiout,
1947 /* Run the inbuilt backtrace if there are no filters registered, or
1948 "-no-filters" has been specified from the command. */
1949 if (bt_opts.no_filters || result == EXT_LANG_BT_NO_FILTERS)
1951 struct frame_info *trailing;
1953 /* The following code must do two things. First, it must set the
1954 variable TRAILING to the frame from which we should start
1955 printing. Second, it must set the variable count to the number
1956 of frames which we should print, or -1 if all of them. */
1958 if (count_exp != NULL && count < 0)
1960 trailing = trailing_outermost_frame (-count);
1964 trailing = get_current_frame ();
1966 for (fi = trailing; fi && count--; fi = get_prev_frame (fi))
1970 /* Don't use print_stack_frame; if an error() occurs it probably
1971 means further attempts to backtrace would fail (on the other
1972 hand, perhaps the code does or could be fixed to make sure
1973 the frame->prev field gets set to NULL in that case). */
1975 print_frame_info (fp_opts, fi, 1, LOCATION, 1, 0);
1976 if ((flags & PRINT_LOCALS) != 0)
1978 struct frame_id frame_id = get_frame_id (fi);
1980 print_frame_local_vars (fi, false, NULL, NULL, 1, gdb_stdout);
1982 /* print_frame_local_vars invalidates FI. */
1983 fi = frame_find_by_id (frame_id);
1987 warning (_("Unable to restore previously selected frame."));
1992 /* Save the last frame to check for error conditions. */
1996 /* If we've stopped before the end, mention that. */
1998 printf_filtered (_("(More stack frames follow...)\n"));
2000 /* If we've run out of frames, and the reason appears to be an error
2001 condition, print it. */
2002 if (fi == NULL && trailing != NULL)
2004 enum unwind_stop_reason reason;
2006 reason = get_frame_unwind_stop_reason (trailing);
2007 if (reason >= UNWIND_FIRST_ERROR)
2008 printf_filtered (_("Backtrace stopped: %s\n"),
2009 frame_stop_reason_string (trailing));
2014 /* Create an option_def_group array grouping all the "backtrace"
2015 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2017 static inline std::array<gdb::option::option_def_group, 3>
2018 make_backtrace_options_def_group (frame_print_options *fp_opts,
2019 backtrace_cmd_options *bt_cmd_opts,
2020 set_backtrace_options *set_bt_opts)
2023 { {frame_print_option_defs}, fp_opts },
2024 { {set_backtrace_option_defs}, set_bt_opts },
2025 { {backtrace_command_option_defs}, bt_cmd_opts }
2029 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2030 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2031 store the parsed qualifiers. */
2034 parse_backtrace_qualifiers (const char *arg,
2035 backtrace_cmd_options *bt_cmd_opts = nullptr)
2039 const char *save_arg = arg;
2040 std::string this_arg = extract_arg (&arg);
2042 if (this_arg.empty ())
2045 if (subset_compare (this_arg.c_str (), "no-filters"))
2047 if (bt_cmd_opts != nullptr)
2048 bt_cmd_opts->no_filters = true;
2050 else if (subset_compare (this_arg.c_str (), "full"))
2052 if (bt_cmd_opts != nullptr)
2053 bt_cmd_opts->full = true;
2055 else if (subset_compare (this_arg.c_str (), "hide"))
2057 if (bt_cmd_opts != nullptr)
2058 bt_cmd_opts->hide = true;
2062 /* Not a recognized qualifier, so stop. */
2069 backtrace_command (const char *arg, int from_tty)
2071 frame_print_options fp_opts = user_frame_print_options;
2072 backtrace_cmd_options bt_cmd_opts;
2073 set_backtrace_options set_bt_opts = user_set_backtrace_options;
2076 = make_backtrace_options_def_group (&fp_opts, &bt_cmd_opts, &set_bt_opts);
2077 gdb::option::process_options
2078 (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2080 /* Parse non-'-'-prefixed qualifiers, for backwards
2084 arg = parse_backtrace_qualifiers (arg, &bt_cmd_opts);
2089 /* These options are handled quite deep in the unwind machinery, so
2090 we get to pass them down by swapping globals. */
2091 scoped_restore restore_set_backtrace_options
2092 = make_scoped_restore (&user_set_backtrace_options, set_bt_opts);
2094 backtrace_command_1 (fp_opts, bt_cmd_opts, arg, from_tty);
2097 /* Completer for the "backtrace" command. */
2100 backtrace_command_completer (struct cmd_list_element *ignore,
2101 completion_tracker &tracker,
2102 const char *text, const char */*word*/)
2105 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2106 if (gdb::option::complete_options
2107 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
2112 const char *p = skip_to_space (text);
2115 static const char *const backtrace_cmd_qualifier_choices[] = {
2116 "full", "no-filters", "hide", nullptr,
2118 complete_on_enum (tracker, backtrace_cmd_qualifier_choices,
2121 if (tracker.have_completions ())
2126 const char *cmd = parse_backtrace_qualifiers (text);
2127 tracker.advance_custom_word_point_by (cmd - text);
2132 const char *word = advance_to_expression_complete_word_point (tracker, text);
2133 expression_completer (ignore, tracker, text, word);
2136 /* Iterate over the local variables of a block B, calling CB with
2140 iterate_over_block_locals (const struct block *b,
2141 iterate_over_block_arg_local_vars_cb cb,
2144 struct block_iterator iter;
2147 ALL_BLOCK_SYMBOLS (b, iter, sym)
2149 switch (SYMBOL_CLASS (sym))
2155 case LOC_OPTIMIZED_OUT:
2156 if (SYMBOL_IS_ARGUMENT (sym))
2158 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
2160 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
2164 /* Ignore symbols which are not locals. */
2171 /* Same, but print labels. */
2174 /* Commented out, as the code using this function has also been
2175 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2176 was commented out in the first place. The discussion introducing
2177 this change (2007-12-04: Support lexical blocks and function bodies
2178 that occupy non-contiguous address ranges) did not explain why
2179 this change was made. */
2181 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
2182 int *have_default, struct ui_file *stream)
2184 struct block_iterator iter;
2186 int values_printed = 0;
2188 ALL_BLOCK_SYMBOLS (b, iter, sym)
2190 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
2196 if (SYMBOL_CLASS (sym) == LOC_LABEL)
2198 struct symtab_and_line sal;
2199 struct value_print_options opts;
2201 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2203 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
2204 get_user_print_options (&opts);
2205 if (opts.addressprint)
2207 fprintf_filtered (stream, " ");
2208 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2211 fprintf_filtered (stream, " in file %s, line %d\n",
2212 sal.symtab->filename, sal.line);
2216 return values_printed;
2220 /* Iterate over all the local variables in block B, including all its
2221 superblocks, stopping when the top-level block is reached. */
2224 iterate_over_block_local_vars (const struct block *block,
2225 iterate_over_block_arg_local_vars_cb cb,
2230 iterate_over_block_locals (block, cb, cb_data);
2231 /* After handling the function's top-level block, stop. Don't
2232 continue to its superblock, the block of per-file
2234 if (BLOCK_FUNCTION (block))
2236 block = BLOCK_SUPERBLOCK (block);
2240 /* Data to be passed around in the calls to the locals and args
2243 struct print_variable_and_value_data
2245 gdb::optional<compiled_regex> preg;
2246 gdb::optional<compiled_regex> treg;
2247 struct frame_id frame_id;
2249 struct ui_file *stream;
2253 /* The callback for the locals and args iterators. */
2256 do_print_variable_and_value (const char *print_name,
2260 struct print_variable_and_value_data *p
2261 = (struct print_variable_and_value_data *) cb_data;
2262 struct frame_info *frame;
2264 if (p->preg.has_value ()
2265 && p->preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
2268 if (p->treg.has_value ()
2269 && !treg_matches_sym_type_name (*p->treg, sym))
2272 frame = frame_find_by_id (p->frame_id);
2275 warning (_("Unable to restore previously selected frame."));
2279 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2281 /* print_variable_and_value invalidates FRAME. */
2284 p->values_printed = 1;
2287 /* Prepares the regular expression REG from REGEXP.
2288 If REGEXP is NULL, it results in an empty regular expression. */
2291 prepare_reg (const char *regexp, gdb::optional<compiled_regex> *reg)
2295 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
2297 reg->emplace (regexp, cflags, _("Invalid regexp"));
2303 /* Print all variables from the innermost up to the function block of FRAME.
2304 Print them with values to STREAM indented by NUM_TABS.
2305 If REGEXP is not NULL, only print local variables whose name
2307 If T_REGEXP is not NULL, only print local variables whose type
2309 If no local variables have been printed and !QUIET, prints a message
2310 explaining why no local variables could be printed.
2312 This function will invalidate FRAME. */
2315 print_frame_local_vars (struct frame_info *frame,
2317 const char *regexp, const char *t_regexp,
2318 int num_tabs, struct ui_file *stream)
2320 struct print_variable_and_value_data cb_data;
2321 const struct block *block;
2324 if (!get_frame_pc_if_available (frame, &pc))
2327 fprintf_filtered (stream,
2328 _("PC unavailable, cannot determine locals.\n"));
2332 block = get_frame_block (frame, 0);
2336 fprintf_filtered (stream, "No symbol table info available.\n");
2340 prepare_reg (regexp, &cb_data.preg);
2341 prepare_reg (t_regexp, &cb_data.treg);
2342 cb_data.frame_id = get_frame_id (frame);
2343 cb_data.num_tabs = 4 * num_tabs;
2344 cb_data.stream = stream;
2345 cb_data.values_printed = 0;
2347 /* Temporarily change the selected frame to the given FRAME.
2348 This allows routines that rely on the selected frame instead
2349 of being given a frame as parameter to use the correct frame. */
2350 scoped_restore_selected_frame restore_selected_frame;
2351 select_frame (frame);
2353 iterate_over_block_local_vars (block,
2354 do_print_variable_and_value,
2357 if (!cb_data.values_printed && !quiet)
2359 if (regexp == NULL && t_regexp == NULL)
2360 fprintf_filtered (stream, _("No locals.\n"));
2362 fprintf_filtered (stream, _("No matching locals.\n"));
2367 info_locals_command (const char *args, int from_tty)
2370 std::string t_regexp;
2374 && extract_info_print_args (&args, &quiet, ®exp, &t_regexp))
2378 report_unrecognized_option_error ("info locals", args);
2380 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2382 regexp.empty () ? NULL : regexp.c_str (),
2383 t_regexp.empty () ? NULL : t_regexp.c_str (),
2387 /* Iterate over all the argument variables in block B. */
2390 iterate_over_block_arg_vars (const struct block *b,
2391 iterate_over_block_arg_local_vars_cb cb,
2394 struct block_iterator iter;
2395 struct symbol *sym, *sym2;
2397 ALL_BLOCK_SYMBOLS (b, iter, sym)
2399 /* Don't worry about things which aren't arguments. */
2400 if (SYMBOL_IS_ARGUMENT (sym))
2402 /* We have to look up the symbol because arguments can have
2403 two entries (one a parameter, one a local) and the one we
2404 want is the local, which lookup_symbol will find for us.
2405 This includes gcc1 (not gcc2) on the sparc when passing a
2406 small structure and gcc2 when the argument type is float
2407 and it is passed as a double and converted to float by
2408 the prologue (in the latter case the type of the LOC_ARG
2409 symbol is double and the type of the LOC_LOCAL symbol is
2410 float). There are also LOC_ARG/LOC_REGISTER pairs which
2411 are not combined in symbol-reading. */
2413 sym2 = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
2414 b, VAR_DOMAIN).symbol;
2415 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2420 /* Print all argument variables of the function of FRAME.
2421 Print them with values to STREAM.
2422 If REGEXP is not NULL, only print argument variables whose name
2424 If T_REGEXP is not NULL, only print argument variables whose type
2426 If no argument variables have been printed and !QUIET, prints a message
2427 explaining why no argument variables could be printed.
2429 This function will invalidate FRAME. */
2432 print_frame_arg_vars (struct frame_info *frame,
2434 const char *regexp, const char *t_regexp,
2435 struct ui_file *stream)
2437 struct print_variable_and_value_data cb_data;
2438 struct symbol *func;
2440 gdb::optional<compiled_regex> preg;
2441 gdb::optional<compiled_regex> treg;
2443 if (!get_frame_pc_if_available (frame, &pc))
2446 fprintf_filtered (stream,
2447 _("PC unavailable, cannot determine args.\n"));
2451 func = get_frame_function (frame);
2455 fprintf_filtered (stream, _("No symbol table info available.\n"));
2459 prepare_reg (regexp, &cb_data.preg);
2460 prepare_reg (t_regexp, &cb_data.treg);
2461 cb_data.frame_id = get_frame_id (frame);
2462 cb_data.num_tabs = 0;
2463 cb_data.stream = stream;
2464 cb_data.values_printed = 0;
2466 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2467 do_print_variable_and_value, &cb_data);
2469 /* do_print_variable_and_value invalidates FRAME. */
2472 if (!cb_data.values_printed && !quiet)
2474 if (regexp == NULL && t_regexp == NULL)
2475 fprintf_filtered (stream, _("No arguments.\n"));
2477 fprintf_filtered (stream, _("No matching arguments.\n"));
2482 info_args_command (const char *args, int from_tty)
2485 std::string t_regexp;
2489 && extract_info_print_args (&args, &quiet, ®exp, &t_regexp))
2493 report_unrecognized_option_error ("info args", args);
2496 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2498 regexp.empty () ? NULL : regexp.c_str (),
2499 t_regexp.empty () ? NULL : t_regexp.c_str (),
2503 /* Return the symbol-block in which the selected frame is executing.
2504 Can return zero under various legitimate circumstances.
2506 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2507 code address within the block returned. We use this to decide
2508 which macros are in scope. */
2510 const struct block *
2511 get_selected_block (CORE_ADDR *addr_in_block)
2513 if (!has_stack_frames ())
2516 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2519 /* Find a frame a certain number of levels away from FRAME.
2520 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2521 Positive means go to earlier frames (up); negative, the reverse.
2522 The int that contains the number of levels is counted toward
2523 zero as the frames for those levels are found.
2524 If the top or bottom frame is reached, that frame is returned,
2525 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2526 how much farther the original request asked to go. */
2529 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2531 /* Going up is simple: just call get_prev_frame enough times or
2532 until the initial frame is reached. */
2533 while (*level_offset_ptr > 0)
2535 struct frame_info *prev = get_prev_frame (frame);
2539 (*level_offset_ptr)--;
2543 /* Going down is just as simple. */
2544 while (*level_offset_ptr < 0)
2546 struct frame_info *next = get_next_frame (frame);
2550 (*level_offset_ptr)++;
2557 /* Select the frame up one or COUNT_EXP stack levels from the
2558 previously selected frame, and print it briefly. */
2561 up_silently_base (const char *count_exp)
2563 struct frame_info *frame;
2567 count = parse_and_eval_long (count_exp);
2569 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2570 if (count != 0 && count_exp == NULL)
2571 error (_("Initial frame selected; you cannot go up."));
2572 select_frame (frame);
2576 up_silently_command (const char *count_exp, int from_tty)
2578 up_silently_base (count_exp);
2582 up_command (const char *count_exp, int from_tty)
2584 up_silently_base (count_exp);
2585 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
2588 /* Select the frame down one or COUNT_EXP stack levels from the previously
2589 selected frame, and print it briefly. */
2592 down_silently_base (const char *count_exp)
2594 struct frame_info *frame;
2598 count = -parse_and_eval_long (count_exp);
2600 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2601 if (count != 0 && count_exp == NULL)
2603 /* We only do this if COUNT_EXP is not specified. That way
2604 "down" means to really go down (and let me know if that is
2605 impossible), but "down 9999" can be used to mean go all the
2606 way down without getting an error. */
2608 error (_("Bottom (innermost) frame selected; you cannot go down."));
2611 select_frame (frame);
2615 down_silently_command (const char *count_exp, int from_tty)
2617 down_silently_base (count_exp);
2621 down_command (const char *count_exp, int from_tty)
2623 down_silently_base (count_exp);
2624 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
2628 return_command (const char *retval_exp, int from_tty)
2630 /* Initialize it just to avoid a GCC false warning. */
2631 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2632 struct frame_info *thisframe;
2633 struct gdbarch *gdbarch;
2634 struct symbol *thisfun;
2635 struct value *return_value = NULL;
2636 struct value *function = NULL;
2637 const char *query_prefix = "";
2639 thisframe = get_selected_frame ("No selected frame.");
2640 thisfun = get_frame_function (thisframe);
2641 gdbarch = get_frame_arch (thisframe);
2643 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2644 error (_("Can not force return from an inlined function."));
2646 /* Compute the return value. If the computation triggers an error,
2647 let it bail. If the return type can't be handled, set
2648 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2652 expression_up retval_expr = parse_expression (retval_exp);
2653 struct type *return_type = NULL;
2655 /* Compute the return value. Should the computation fail, this
2656 call throws an error. */
2657 return_value = evaluate_expression (retval_expr.get ());
2659 /* Cast return value to the return type of the function. Should
2660 the cast fail, this call throws an error. */
2661 if (thisfun != NULL)
2662 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2663 if (return_type == NULL)
2665 if (retval_expr->elts[0].opcode != UNOP_CAST
2666 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2667 error (_("Return value type not available for selected "
2669 "Please use an explicit cast of the value to return."));
2670 return_type = value_type (return_value);
2672 return_type = check_typedef (return_type);
2673 return_value = value_cast (return_type, return_value);
2675 /* Make sure the value is fully evaluated. It may live in the
2676 stack frame we're about to pop. */
2677 if (value_lazy (return_value))
2678 value_fetch_lazy (return_value);
2680 if (thisfun != NULL)
2681 function = read_var_value (thisfun, NULL, thisframe);
2683 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2684 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2685 /* If the return-type is "void", don't try to find the
2686 return-value's location. However, do still evaluate the
2687 return expression so that, even when the expression result
2688 is discarded, side effects such as "return i++" still
2690 return_value = NULL;
2691 else if (thisfun != NULL)
2693 rv_conv = struct_return_convention (gdbarch, function, return_type);
2694 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2695 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2697 query_prefix = "The location at which to store the "
2698 "function's return value is unknown.\n"
2699 "If you continue, the return value "
2700 "that you specified will be ignored.\n";
2701 return_value = NULL;
2706 /* Does an interactive user really want to do this? Include
2707 information, such as how well GDB can handle the return value, in
2708 the query message. */
2713 if (thisfun == NULL)
2714 confirmed = query (_("%sMake selected stack frame return now? "),
2718 if (TYPE_NO_RETURN (thisfun->type))
2719 warning (_("Function does not return normally to caller."));
2720 confirmed = query (_("%sMake %s return now? "), query_prefix,
2721 SYMBOL_PRINT_NAME (thisfun));
2724 error (_("Not confirmed"));
2727 /* Discard the selected frame and all frames inner-to it. */
2728 frame_pop (get_selected_frame (NULL));
2730 /* Store RETURN_VALUE in the just-returned register set. */
2731 if (return_value != NULL)
2733 struct type *return_type = value_type (return_value);
2734 struct gdbarch *cache_arch = get_current_regcache ()->arch ();
2736 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2737 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2738 gdbarch_return_value (cache_arch, function, return_type,
2739 get_current_regcache (), NULL /*read*/,
2740 value_contents (return_value) /*write*/);
2743 /* If we are at the end of a call dummy now, pop the dummy frame
2745 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2746 frame_pop (get_current_frame ());
2748 select_frame (get_current_frame ());
2749 /* If interactive, print the frame that is now current. */
2751 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2754 /* Find the most inner frame in the current stack for a function called
2755 FUNCTION_NAME. If no matching frame is found return NULL. */
2757 static struct frame_info *
2758 find_frame_for_function (const char *function_name)
2760 /* Used to hold the lower and upper addresses for each of the
2761 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2762 struct function_bounds
2764 CORE_ADDR low, high;
2766 struct frame_info *frame;
2770 gdb_assert (function_name != NULL);
2772 frame = get_current_frame ();
2773 std::vector<symtab_and_line> sals
2774 = decode_line_with_current_source (function_name,
2775 DECODE_LINE_FUNFIRSTLINE);
2776 gdb::def_vector<function_bounds> func_bounds (sals.size ());
2777 for (size_t i = 0; i < sals.size (); i++)
2779 if (sals[i].pspace != current_program_space)
2780 func_bounds[i].low = func_bounds[i].high = 0;
2781 else if (sals[i].pc == 0
2782 || find_pc_partial_function (sals[i].pc, NULL,
2783 &func_bounds[i].low,
2784 &func_bounds[i].high) == 0)
2785 func_bounds[i].low = func_bounds[i].high = 0;
2790 for (size_t i = 0; (i < sals.size () && !found); i++)
2791 found = (get_frame_pc (frame) >= func_bounds[i].low
2792 && get_frame_pc (frame) < func_bounds[i].high);
2796 frame = find_relative_frame (frame, &level);
2799 while (!found && level == 0);
2807 /* Implements the dbx 'func' command. */
2810 func_command (const char *arg, int from_tty)
2815 struct frame_info *frame = find_frame_for_function (arg);
2817 error (_("'%s' not within current stack frame."), arg);
2818 if (frame != get_selected_frame (NULL))
2820 select_frame (frame);
2821 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2825 /* The qcs command line flags for the "frame apply" commands. Keep
2826 this in sync with the "thread apply" commands. */
2828 using qcs_flag_option_def
2829 = gdb::option::flag_option_def<qcs_flags>;
2831 static const gdb::option::option_def fr_qcs_flags_option_defs[] = {
2832 qcs_flag_option_def {
2833 "q", [] (qcs_flags *opt) { return &opt->quiet; },
2834 N_("Disables printing the frame location information."),
2837 qcs_flag_option_def {
2838 "c", [] (qcs_flags *opt) { return &opt->cont; },
2839 N_("Print any error raised by COMMAND and continue."),
2842 qcs_flag_option_def {
2843 "s", [] (qcs_flags *opt) { return &opt->silent; },
2844 N_("Silently ignore any errors or empty output produced by COMMAND."),
2848 /* Create an option_def_group array for all the "frame apply" options,
2849 with FLAGS and SET_BT_OPTS as context. */
2851 static inline std::array<gdb::option::option_def_group, 2>
2852 make_frame_apply_options_def_group (qcs_flags *flags,
2853 set_backtrace_options *set_bt_opts)
2856 { {fr_qcs_flags_option_defs}, flags },
2857 { {set_backtrace_option_defs}, set_bt_opts },
2861 /* Apply a GDB command to all stack frames, or a set of identified frames,
2862 or innermost COUNT frames.
2863 With a negative COUNT, apply command on outermost -COUNT frames.
2865 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2866 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2867 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2868 frame apply all -s p local_var_no_idea_in_which_frame
2869 If a frame has a local variable called
2870 local_var_no_idea_in_which_frame, print frame
2871 and value of local_var_no_idea_in_which_frame.
2872 frame apply all -s -q p local_var_no_idea_in_which_frame
2873 Same as before, but only print the variable value.
2874 frame apply level 2-5 0 4-7 -s p i = i + 1
2875 Adds 1 to the variable i in the specified frames.
2876 Note that i will be incremented twice in
2879 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2880 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2881 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2882 for error messages. */
2885 frame_apply_command_count (const char *which_command,
2886 const char *cmd, int from_tty,
2887 struct frame_info *trailing, int count)
2890 set_backtrace_options set_bt_opts = user_set_backtrace_options;
2892 auto group = make_frame_apply_options_def_group (&flags, &set_bt_opts);
2893 gdb::option::process_options
2894 (&cmd, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group);
2896 validate_flags_qcs (which_command, &flags);
2898 if (cmd == NULL || *cmd == '\0')
2899 error (_("Please specify a command to apply on the selected frames"));
2901 /* The below will restore the current inferior/thread/frame.
2902 Usually, only the frame is effectively to be restored.
2903 But in case CMD switches of inferior/thread, better restore
2905 scoped_restore_current_thread restore_thread;
2907 /* These options are handled quite deep in the unwind machinery, so
2908 we get to pass them down by swapping globals. */
2909 scoped_restore restore_set_backtrace_options
2910 = make_scoped_restore (&user_set_backtrace_options, set_bt_opts);
2912 for (frame_info *fi = trailing; fi && count--; fi = get_prev_frame (fi))
2919 std::string cmd_result;
2921 /* In case CMD switches of inferior/thread/frame, the below
2922 restores the inferior/thread/frame. FI can then be
2923 set to the selected frame. */
2924 scoped_restore_current_thread restore_fi_current_frame;
2926 cmd_result = execute_command_to_string
2927 (cmd, from_tty, gdb_stdout->term_out ());
2929 fi = get_selected_frame (_("frame apply "
2930 "unable to get selected frame."));
2931 if (!flags.silent || cmd_result.length () > 0)
2934 print_stack_frame (fi, 1, LOCATION, 0);
2935 printf_filtered ("%s", cmd_result.c_str ());
2938 catch (const gdb_exception_error &ex)
2940 fi = get_selected_frame (_("frame apply "
2941 "unable to get selected frame."));
2945 print_stack_frame (fi, 1, LOCATION, 0);
2947 printf_filtered ("%s\n", ex.what ());
2955 /* Completer for the "frame apply ..." commands. */
2958 frame_apply_completer (completion_tracker &tracker, const char *text)
2960 const auto group = make_frame_apply_options_def_group (nullptr, nullptr);
2961 if (gdb::option::complete_options
2962 (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
2965 complete_nested_command_line (tracker, text);
2968 /* Completer for the "frame apply" commands. */
2971 frame_apply_level_cmd_completer (struct cmd_list_element *ignore,
2972 completion_tracker &tracker,
2973 const char *text, const char */*word*/)
2975 /* Do this explicitly because there's an early return below. */
2976 tracker.set_use_custom_word_point (true);
2978 number_or_range_parser levels (text);
2980 /* Skip the LEVEL list to find the options and command args. */
2983 while (!levels.finished ())
2985 /* Call for effect. */
2986 levels.get_number ();
2988 if (levels.in_range ())
2989 levels.skip_range ();
2992 catch (const gdb_exception_error &ex)
2994 /* get_number throws if it parses a negative number, for
2995 example. But a seemingly negative number may be the start of
2996 an option instead. */
2999 const char *cmd = levels.cur_tok ();
3003 /* No level list yet. */
3007 /* Check if we're past a valid LEVEL already. */
3008 if (levels.finished ()
3009 && cmd > text && !isspace (cmd[-1]))
3012 /* We're past LEVELs, advance word point. */
3013 tracker.advance_custom_word_point_by (cmd - text);
3016 frame_apply_completer (tracker, text);
3019 /* Completer for the "frame apply all" command. */
3022 frame_apply_all_cmd_completer (struct cmd_list_element *ignore,
3023 completion_tracker &tracker,
3024 const char *text, const char */*word*/)
3026 frame_apply_completer (tracker, text);
3029 /* Completer for the "frame apply COUNT" command. */
3032 frame_apply_cmd_completer (struct cmd_list_element *ignore,
3033 completion_tracker &tracker,
3034 const char *text, const char */*word*/)
3036 const char *cmd = text;
3038 int count = get_number_trailer (&cmd, 0);
3042 /* Check if we're past a valid COUNT already. */
3043 if (cmd > text && !isspace (cmd[-1]))
3046 /* We're past COUNT, advance word point. */
3047 tracker.advance_custom_word_point_by (cmd - text);
3050 frame_apply_completer (tracker, text);
3053 /* Implementation of the "frame apply level" command. */
3056 frame_apply_level_command (const char *cmd, int from_tty)
3058 if (!target_has_stack)
3059 error (_("No stack."));
3061 bool level_found = false;
3062 const char *levels_str = cmd;
3063 number_or_range_parser levels (levels_str);
3065 /* Skip the LEVEL list to find the flags and command args. */
3066 while (!levels.finished ())
3068 /* Call for effect. */
3069 levels.get_number ();
3072 if (levels.in_range ())
3073 levels.skip_range ();
3077 error (_("Missing or invalid LEVEL... argument"));
3079 cmd = levels.cur_tok ();
3081 /* Redo the LEVELS parsing, but applying COMMAND. */
3082 levels.init (levels_str);
3083 while (!levels.finished ())
3085 const int level_beg = levels.get_number ();
3088 if (levels.in_range ())
3090 n_frames = levels.end_value () - level_beg + 1;
3091 levels.skip_range ();
3096 frame_apply_command_count ("frame apply level", cmd, from_tty,
3097 leading_innermost_frame (level_beg), n_frames);
3101 /* Implementation of the "frame apply all" command. */
3104 frame_apply_all_command (const char *cmd, int from_tty)
3106 if (!target_has_stack)
3107 error (_("No stack."));
3109 frame_apply_command_count ("frame apply all", cmd, from_tty,
3110 get_current_frame (), INT_MAX);
3113 /* Implementation of the "frame apply" command. */
3116 frame_apply_command (const char* cmd, int from_tty)
3119 struct frame_info *trailing;
3121 if (!target_has_stack)
3122 error (_("No stack."));
3125 error (_("Missing COUNT argument."));
3126 count = get_number_trailer (&cmd, 0);
3128 error (_("Invalid COUNT argument."));
3132 trailing = trailing_outermost_frame (-count);
3136 trailing = get_current_frame ();
3138 frame_apply_command_count ("frame apply", cmd, from_tty,
3142 /* Implementation of the "faas" command. */
3145 faas_command (const char *cmd, int from_tty)
3147 std::string expanded = std::string ("frame apply all -s ") + cmd;
3148 execute_command (expanded.c_str (), from_tty);
3152 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3153 matching frame can be found. */
3155 static struct frame_info *
3156 find_frame_for_address (CORE_ADDR address)
3159 struct frame_info *fid;
3161 id = frame_id_build_wild (address);
3163 /* If (s)he specifies the frame with an address, he deserves
3164 what (s)he gets. Still, give the highest one that matches.
3165 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3167 for (fid = get_current_frame ();
3169 fid = get_prev_frame (fid))
3171 if (frame_id_eq (id, get_frame_id (fid)))
3173 struct frame_info *prev_frame;
3177 prev_frame = get_prev_frame (fid);
3179 || !frame_id_eq (id, get_frame_id (prev_frame)))
3191 /* Commands with a prefix of `frame apply'. */
3192 static struct cmd_list_element *frame_apply_cmd_list = NULL;
3194 /* Commands with a prefix of `frame'. */
3195 static struct cmd_list_element *frame_cmd_list = NULL;
3197 /* Commands with a prefix of `select frame'. */
3198 static struct cmd_list_element *select_frame_cmd_list = NULL;
3200 /* Commands with a prefix of `info frame'. */
3201 static struct cmd_list_element *info_frame_cmd_list = NULL;
3204 _initialize_stack (void)
3206 struct cmd_list_element *cmd;
3208 add_com ("return", class_stack, return_command, _("\
3209 Make selected stack frame return to its caller.\n\
3210 Control remains in the debugger, but when you continue\n\
3211 execution will resume in the frame above the one now selected.\n\
3212 If an argument is given, it is an expression for the value to return."));
3214 add_com ("up", class_stack, up_command, _("\
3215 Select and print stack frame that called this one.\n\
3216 An argument says how many frames up to go."));
3217 add_com ("up-silently", class_support, up_silently_command, _("\
3218 Same as the `up' command, but does not print anything.\n\
3219 This is useful in command scripts."));
3221 add_com ("down", class_stack, down_command, _("\
3222 Select and print stack frame called by this one.\n\
3223 An argument says how many frames down to go."));
3224 add_com_alias ("do", "down", class_stack, 1);
3225 add_com_alias ("dow", "down", class_stack, 1);
3226 add_com ("down-silently", class_support, down_silently_command, _("\
3227 Same as the `down' command, but does not print anything.\n\
3228 This is useful in command scripts."));
3230 add_prefix_cmd ("frame", class_stack,
3231 &frame_cmd.base_command, _("\
3232 Select and print a stack frame.\n\
3233 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3234 A single numerical argument specifies the frame to select."),
3235 &frame_cmd_list, "frame ", 1, &cmdlist);
3237 add_com_alias ("f", "frame", class_stack, 1);
3239 #define FRAME_APPLY_OPTION_HELP "\
3240 Prints the frame location information followed by COMMAND output.\n\
3242 By default, an error raised during the execution of COMMAND\n\
3243 aborts \"frame apply\".\n\
3248 const auto frame_apply_opts
3249 = make_frame_apply_options_def_group (nullptr, nullptr);
3251 static std::string frame_apply_cmd_help = gdb::option::build_help (N_("\
3252 Apply a command to a number of frames.\n\
3253 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3254 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3255 FRAME_APPLY_OPTION_HELP),
3258 cmd = add_prefix_cmd ("apply", class_stack, frame_apply_command,
3259 frame_apply_cmd_help.c_str (),
3260 &frame_apply_cmd_list, "frame apply ", 1,
3262 set_cmd_completer_handle_brkchars (cmd, frame_apply_cmd_completer);
3264 static std::string frame_apply_all_cmd_help = gdb::option::build_help (N_("\
3265 Apply a command to all frames.\n\
3267 Usage: frame apply all [OPTION]... COMMAND\n"
3268 FRAME_APPLY_OPTION_HELP),
3271 cmd = add_cmd ("all", class_stack, frame_apply_all_command,
3272 frame_apply_all_cmd_help.c_str (),
3273 &frame_apply_cmd_list);
3274 set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
3276 static std::string frame_apply_level_cmd_help = gdb::option::build_help (N_("\
3277 Apply a command to a list of frames.\n\
3279 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3280 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3281 FRAME_APPLY_OPTION_HELP),
3284 cmd = add_cmd ("level", class_stack, frame_apply_level_command,
3285 frame_apply_level_cmd_help.c_str (),
3286 &frame_apply_cmd_list);
3287 set_cmd_completer_handle_brkchars (cmd, frame_apply_level_cmd_completer);
3289 cmd = add_com ("faas", class_stack, faas_command, _("\
3290 Apply a command to all frames (ignoring errors and empty output).\n\
3291 Usage: faas [OPTION]... COMMAND\n\
3292 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3293 See \"help frame apply all\" for available options."));
3294 set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
3296 add_prefix_cmd ("frame", class_stack,
3297 &frame_cmd.base_command, _("\
3298 Select and print a stack frame.\n\
3299 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3300 A single numerical argument specifies the frame to select."),
3301 &frame_cmd_list, "frame ", 1, &cmdlist);
3302 add_com_alias ("f", "frame", class_stack, 1);
3304 add_cmd ("address", class_stack, &frame_cmd.address,
3306 Select and print a stack frame by stack address\n\
3308 Usage: frame address STACK-ADDRESS"),
3311 add_cmd ("view", class_stack, &frame_cmd.view,
3313 View a stack frame that might be outside the current backtrace.\n\
3315 Usage: frame view STACK-ADDRESS\n\
3316 frame view STACK-ADDRESS PC-ADDRESS"),
3319 cmd = add_cmd ("function", class_stack, &frame_cmd.function,
3321 Select and print a stack frame by function name.\n\
3323 Usage: frame function NAME\n\
3325 The innermost frame that visited function NAME is selected."),
3327 set_cmd_completer (cmd, frame_selection_by_function_completer);
3330 add_cmd ("level", class_stack, &frame_cmd.level,
3332 Select and print a stack frame by level.\n\
3334 Usage: frame level LEVEL"),
3337 cmd = add_prefix_cmd_suppress_notification ("select-frame", class_stack,
3338 &select_frame_cmd.base_command, _("\
3339 Select a stack frame without printing anything.\n\
3340 A single numerical argument specifies the frame to select."),
3341 &select_frame_cmd_list, "select-frame ", 1, &cmdlist,
3342 &cli_suppress_notification.user_selected_context);
3344 add_cmd_suppress_notification ("address", class_stack,
3345 &select_frame_cmd.address, _("\
3346 Select a stack frame by stack address.\n\
3348 Usage: select-frame address STACK-ADDRESS"),
3349 &select_frame_cmd_list,
3350 &cli_suppress_notification.user_selected_context);
3353 add_cmd_suppress_notification ("view", class_stack,
3354 &select_frame_cmd.view, _("\
3355 Select a stack frame that might be outside the current backtrace.\n\
3357 Usage: select-frame view STACK-ADDRESS\n\
3358 select-frame view STACK-ADDRESS PC-ADDRESS"),
3359 &select_frame_cmd_list,
3360 &cli_suppress_notification.user_selected_context);
3362 cmd = add_cmd_suppress_notification ("function", class_stack,
3363 &select_frame_cmd.function, _("\
3364 Select a stack frame by function name.\n\
3366 Usage: select-frame function NAME"),
3367 &select_frame_cmd_list,
3368 &cli_suppress_notification.user_selected_context);
3369 set_cmd_completer (cmd, frame_selection_by_function_completer);
3371 add_cmd_suppress_notification ("level", class_stack,
3372 &select_frame_cmd.level, _("\
3373 Select a stack frame by level.\n\
3375 Usage: select-frame level LEVEL"),
3376 &select_frame_cmd_list,
3377 &cli_suppress_notification.user_selected_context);
3379 const auto backtrace_opts
3380 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3382 static std::string backtrace_help
3383 = gdb::option::build_help (N_("\
3384 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3385 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3389 For backward compatibility, the following qualifiers are supported:\n\
3391 full - same as -full option.\n\
3392 no-filters - same as -no-filters option.\n\
3393 hide - same as -hide.\n\
3395 With a negative COUNT, print outermost -COUNT frames."),
3398 cmd_list_element *c = add_com ("backtrace", class_stack,
3400 backtrace_help.c_str ());
3401 set_cmd_completer_handle_brkchars (c, backtrace_command_completer);
3403 add_com_alias ("bt", "backtrace", class_stack, 0);
3405 add_com_alias ("where", "backtrace", class_alias, 0);
3406 add_info ("stack", backtrace_command,
3407 _("Backtrace of the stack, or innermost COUNT frames."));
3408 add_info_alias ("s", "stack", 1);
3410 add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command,
3411 _("All about the selected stack frame.\n\
3412 With no arguments, displays information about the currently selected stack\n\
3413 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3414 the information is then printed about the specified frame."),
3415 &info_frame_cmd_list, "info frame ", 1, &infolist);
3416 add_info_alias ("f", "frame", 1);
3418 add_cmd ("address", class_stack, &info_frame_cmd.address,
3420 Print information about a stack frame selected by stack address.\n\
3422 Usage: info frame address STACK-ADDRESS"),
3423 &info_frame_cmd_list);
3425 add_cmd ("view", class_stack, &info_frame_cmd.view,
3427 Print information about a stack frame outside the current backtrace.\n\
3429 Usage: info frame view STACK-ADDRESS\n\
3430 info frame view STACK-ADDRESS PC-ADDRESS"),
3431 &info_frame_cmd_list);
3433 cmd = add_cmd ("function", class_stack, &info_frame_cmd.function,
3435 Print information about a stack frame selected by function name.\n\
3437 Usage: info frame function NAME"),
3438 &info_frame_cmd_list);
3439 set_cmd_completer (cmd, frame_selection_by_function_completer);
3441 add_cmd ("level", class_stack, &info_frame_cmd.level,
3443 Print information about a stack frame selected by level.\n\
3445 Usage: info frame level LEVEL"),
3446 &info_frame_cmd_list);
3448 add_info ("locals", info_locals_command,
3449 info_print_args_help (_("\
3450 All local variables of current stack frame or those matching REGEXPs.\n\
3451 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3452 Prints the local variables of the current stack frame.\n"),
3453 _("local variables")));
3454 add_info ("args", info_args_command,
3455 info_print_args_help (_("\
3456 All argument variables of current stack frame or those matching REGEXPs.\n\
3457 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3458 Prints the argument variables of the current stack frame.\n"),
3459 _("argument variables")));
3462 add_com ("func", class_stack, func_command, _("\
3463 Select the stack frame that contains NAME.\n\
3464 Usage: func NAME"));
3466 /* Install "set print raw frame-arguments", a deprecated spelling of
3467 "set print raw-frame-arguments". */
3468 cmd = add_setshow_boolean_cmd
3469 ("frame-arguments", no_class,
3470 &user_frame_print_options.print_raw_frame_arguments,
3472 Set whether to print frame arguments in raw form."), _("\
3473 Show whether to print frame arguments in raw form."), _("\
3474 If set, frame arguments are printed in raw form, bypassing any\n\
3475 pretty-printers for that value."),
3477 &setprintrawlist, &showprintrawlist);
3478 deprecate_cmd (cmd, "set print raw-frame-arguments");
3480 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
3481 &disassemble_next_line, _("\
3482 Set whether to disassemble next source line or insn when execution stops."),
3484 Show whether to disassemble next source line or insn when execution stops."),
3486 If ON, GDB will display disassembly of the next source line, in addition\n\
3487 to displaying the source line itself. If the next source line cannot\n\
3488 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3489 will display disassembly of next instruction instead of showing the\n\
3491 If AUTO, display disassembly of next instruction only if the source line\n\
3492 cannot be displayed.\n\
3493 If OFF (which is the default), never display the disassembly of the next\n\
3496 show_disassemble_next_line,
3497 &setlist, &showlist);
3498 disassemble_next_line = AUTO_BOOLEAN_FALSE;
3500 gdb::option::add_setshow_cmds_for_options
3501 (class_stack, &user_frame_print_options,
3502 frame_print_option_defs, &setprintlist, &showprintlist);