1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2024 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 "gdbsupport/def-vector.h"
56 #include "cli/cli-option.h"
57 #include "cli/cli-style.h"
58 #include "gdbsupport/buildargv.h"
60 /* The possible choices of "set print frame-arguments", and the value
63 const char print_frame_arguments_all
[] = "all";
64 const char print_frame_arguments_scalars
[] = "scalars";
65 const char print_frame_arguments_none
[] = "none";
66 const char print_frame_arguments_presence
[] = "presence";
68 static const char *const print_frame_arguments_choices
[] =
70 print_frame_arguments_all
,
71 print_frame_arguments_scalars
,
72 print_frame_arguments_none
,
73 print_frame_arguments_presence
,
77 /* The possible choices of "set print frame-info", and the value
80 const char print_frame_info_auto
[] = "auto";
81 const char print_frame_info_source_line
[] = "source-line";
82 const char print_frame_info_location
[] = "location";
83 const char print_frame_info_source_and_location
[] = "source-and-location";
84 const char print_frame_info_location_and_address
[] = "location-and-address";
85 const char print_frame_info_short_location
[] = "short-location";
87 static const char *const print_frame_info_choices
[] =
89 print_frame_info_auto
,
90 print_frame_info_source_line
,
91 print_frame_info_location
,
92 print_frame_info_source_and_location
,
93 print_frame_info_location_and_address
,
94 print_frame_info_short_location
,
98 /* print_frame_info_print_what[i] maps a choice to the corresponding
100 static const std::optional
<enum print_what
> print_frame_info_print_what
[] =
101 {{}, /* Empty value for "auto". */
102 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
104 /* The possible choices of "set print entry-values", and the value
107 const char print_entry_values_no
[] = "no";
108 const char print_entry_values_only
[] = "only";
109 const char print_entry_values_preferred
[] = "preferred";
110 const char print_entry_values_if_needed
[] = "if-needed";
111 const char print_entry_values_both
[] = "both";
112 const char print_entry_values_compact
[] = "compact";
113 const char print_entry_values_default
[] = "default";
114 static const char *const print_entry_values_choices
[] =
116 print_entry_values_no
,
117 print_entry_values_only
,
118 print_entry_values_preferred
,
119 print_entry_values_if_needed
,
120 print_entry_values_both
,
121 print_entry_values_compact
,
122 print_entry_values_default
,
127 frame_print_options user_frame_print_options
;
129 /* Option definitions for some frame-related "set print ..."
132 using boolean_option_def
133 = gdb::option::boolean_option_def
<frame_print_options
>;
134 using enum_option_def
135 = gdb::option::enum_option_def
<frame_print_options
>;
137 static const gdb::option::option_def frame_print_option_defs
[] = {
141 print_entry_values_choices
,
142 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
143 NULL
, /* show_cmd_cb */
144 N_("Set printing of function arguments at function entry."),
145 N_("Show printing of function arguments at function entry."),
146 N_("GDB can sometimes determine the values of function arguments at entry,\n\
147 in addition to their current values. This option tells GDB whether\n\
148 to print the current value, the value at entry (marked as val@entry),\n\
149 or both. Note that one or both of these values may be <optimized out>."),
154 print_frame_arguments_choices
,
155 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
156 NULL
, /* show_cmd_cb */
157 N_("Set printing of non-scalar frame arguments."),
158 N_("Show printing of non-scalar frame arguments."),
163 "raw-frame-arguments",
164 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
165 NULL
, /* show_cmd_cb */
166 N_("Set whether to print frame arguments in raw form."),
167 N_("Show whether to print frame arguments in raw form."),
168 N_("If set, frame arguments are printed in raw form, bypassing any\n\
169 pretty-printers for that value.")
174 print_frame_info_choices
,
175 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
176 NULL
, /* show_cmd_cb */
177 N_("Set printing of frame information."),
178 N_("Show printing of frame information."),
184 /* Options for the "backtrace" command. */
186 struct backtrace_cmd_options
189 bool no_filters
= false;
193 using bt_flag_option_def
194 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
196 static const gdb::option::option_def backtrace_command_option_defs
[] = {
199 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
200 N_("Print values of local variables.")
205 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
206 N_("Prohibit frame filters from executing on a backtrace."),
211 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
212 N_("Causes Python frame filter elided frames to not be printed."),
216 /* Prototypes for local functions. */
218 static void print_frame_local_vars (frame_info_ptr frame
,
220 const char *regexp
, const char *t_regexp
,
221 int num_tabs
, struct ui_file
*stream
);
223 static void print_frame (const frame_print_options
&opts
,
224 frame_info_ptr frame
, int print_level
,
225 enum print_what print_what
, int print_args
,
226 struct symtab_and_line sal
);
228 static frame_info_ptr
find_frame_for_function (const char *);
229 static frame_info_ptr
find_frame_for_address (CORE_ADDR
);
231 /* Zero means do things normally; we are interacting directly with the
232 user. One means print the full filename and linenumber when a
233 frame is printed, and do so in a format emacs18/emacs19.22 can
234 parse. Two means print similar annotations, but in many more
235 cases and in a slightly different syntax. */
237 int annotation_level
= 0;
239 /* Class used to manage tracking the last symtab we displayed. */
241 class last_displayed_symtab_info_type
244 /* True if the cached information is valid. */
245 bool is_valid () const
248 /* Return the cached program_space. If the cache is invalid nullptr is
250 struct program_space
*pspace () const
253 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
255 CORE_ADDR
address () const
256 { return m_address
; }
258 /* Return the cached symtab. If the cache is invalid nullptr is
260 struct symtab
*symtab () const
263 /* Return the cached line number. If the cache is invalid 0 is
268 /* Invalidate the cache, reset all the members to their default value. */
278 /* Store a new set of values in the cache. */
279 void set (struct program_space
*pspace
, CORE_ADDR address
,
280 struct symtab
*symtab
, int line
)
282 gdb_assert (pspace
!= nullptr);
292 /* True when the cache is valid. */
293 bool m_valid
= false;
295 /* The last program space displayed. */
296 struct program_space
*m_pspace
= nullptr;
298 /* The last address displayed. */
299 CORE_ADDR m_address
= 0;
301 /* The last symtab displayed. */
302 struct symtab
*m_symtab
= nullptr;
304 /* The last line number displayed. */
308 /* An actual instance of the cache, holds information about the last symtab
310 static last_displayed_symtab_info_type last_displayed_symtab_info
;
317 frame_show_address (frame_info_ptr frame
,
318 struct symtab_and_line sal
)
320 /* If there is a line number, but no PC, then there is no location
321 information associated with this sal. The only way that should
322 happen is for the call sites of inlined functions (SAL comes from
323 find_frame_sal). Otherwise, we would have some PC range if the
324 SAL came from a line table. */
325 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
327 if (get_next_frame (frame
) == NULL
)
328 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
330 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
334 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
340 print_stack_frame_to_uiout (struct ui_out
*uiout
, frame_info_ptr frame
,
341 int print_level
, enum print_what print_what
,
344 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
346 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
349 /* Show or print a stack frame FRAME briefly. The output is formatted
350 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
351 relative level, function name, argument list, and file name and
352 line number. If the frame's PC is not at the beginning of the
353 source line, the actual PC is printed at the beginning. */
356 print_stack_frame (frame_info_ptr frame
, int print_level
,
357 enum print_what print_what
,
361 /* For mi, always print location and address. */
362 if (current_uiout
->is_mi_like_p ())
363 print_what
= LOC_AND_ADDRESS
;
367 print_frame_info (user_frame_print_options
,
368 frame
, print_level
, print_what
, 1 /* print_args */,
371 set_current_sal_from_frame (frame
);
373 catch (const gdb_exception_error
&e
)
378 /* Print nameless arguments of frame FRAME on STREAM, where START is
379 the offset of the first nameless argument, and NUM is the number of
380 nameless arguments to print. FIRST is nonzero if this is the first
381 argument (not just the first nameless argument). */
384 print_frame_nameless_args (frame_info_ptr frame
, long start
, int num
,
385 int first
, struct ui_file
*stream
)
387 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
388 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
393 for (i
= 0; i
< num
; i
++)
396 argsaddr
= get_frame_args_address (frame
);
399 arg_value
= read_memory_integer (argsaddr
+ start
,
400 sizeof (int), byte_order
);
402 gdb_printf (stream
, ", ");
403 gdb_printf (stream
, "%ld", arg_value
);
405 start
+= sizeof (int);
409 /* Print single argument of inferior function. ARG must be already
412 Errors are printed as if they would be the parameter value. Use zeroed ARG
413 iff it should not be printed according to user settings. */
416 print_frame_arg (const frame_print_options
&fp_opts
,
417 const struct frame_arg
*arg
)
419 struct ui_out
*uiout
= current_uiout
;
423 gdb_assert (!arg
->val
|| !arg
->error
);
424 gdb_assert (arg
->entry_kind
== print_entry_values_no
425 || arg
->entry_kind
== print_entry_values_only
426 || (!uiout
->is_mi_like_p ()
427 && arg
->entry_kind
== print_entry_values_compact
));
429 annotate_arg_emitter arg_emitter
;
430 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
431 gdb_puts (arg
->sym
->print_name (), &stb
);
432 if (arg
->entry_kind
== print_entry_values_compact
)
434 /* It is OK to provide invalid MI-like stream as with
435 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
438 gdb_puts (arg
->sym
->print_name (), &stb
);
440 if (arg
->entry_kind
== print_entry_values_only
441 || arg
->entry_kind
== print_entry_values_compact
)
443 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
444 annotate_arg_name_end ();
448 if (!arg
->val
&& !arg
->error
)
454 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
455 style
= metadata_style
.style ();
461 const struct language_defn
*language
;
462 struct value_print_options vp_opts
;
464 /* Avoid value_print because it will deref ref parameters. We
465 just want to print their addresses. Print ??? for args whose
466 address we do not know. We pass 2 as "recurse" to val_print
467 because our standard indentation here is 4 spaces, and
468 val_print indents 2 for each recurse. */
470 annotate_arg_value (arg
->val
->type ());
472 /* Use the appropriate language to display our symbol, unless the
473 user forced the language to a specific language. */
474 if (language_mode
== language_mode_auto
)
475 language
= language_def (arg
->sym
->language ());
477 language
= current_language
;
479 get_no_prettyformat_print_options (&vp_opts
);
480 vp_opts
.deref_ref
= true;
481 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
483 /* True in "summary" mode, false otherwise. */
485 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
487 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
489 catch (const gdb_exception_error
&except
)
491 stb
.printf (_("<error reading variable: %s>"),
493 style
= metadata_style
.style ();
498 uiout
->field_stream ("value", stb
, style
);
501 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
502 responsible for xfree of ARGP->ERROR. This function never throws an
506 read_frame_local (struct symbol
*sym
, frame_info_ptr frame
,
507 struct frame_arg
*argp
)
515 argp
->val
= read_var_value (sym
, NULL
, frame
);
517 catch (const gdb_exception_error
&except
)
519 argp
->error
.reset (xstrdup (except
.what ()));
523 /* Read in inferior function parameter SYM at FRAME into ARGP. This
524 function never throws an exception. */
527 read_frame_arg (const frame_print_options
&fp_opts
,
528 symbol
*sym
, frame_info_ptr frame
,
529 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
531 struct value
*val
= NULL
, *entryval
= NULL
;
532 char *val_error
= NULL
, *entryval_error
= NULL
;
535 if (fp_opts
.print_entry_values
!= print_entry_values_only
536 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
540 val
= read_var_value (sym
, NULL
, frame
);
542 catch (const gdb_exception_error
&except
)
544 val_error
= (char *) alloca (except
.message
->size () + 1);
545 strcpy (val_error
, except
.what ());
549 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
550 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
551 && fp_opts
.print_entry_values
!= print_entry_values_no
552 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
553 || !val
|| val
->optimized_out ()))
557 const struct symbol_computed_ops
*ops
;
559 ops
= SYMBOL_COMPUTED_OPS (sym
);
560 entryval
= ops
->read_variable_at_entry (sym
, frame
);
562 catch (const gdb_exception_error
&except
)
564 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
566 entryval_error
= (char *) alloca (except
.message
->size () + 1);
567 strcpy (entryval_error
, except
.what ());
571 if (entryval
!= NULL
&& entryval
->optimized_out ())
574 if (fp_opts
.print_entry_values
== print_entry_values_compact
575 || fp_opts
.print_entry_values
== print_entry_values_default
)
577 /* For MI do not try to use print_entry_values_compact for ARGP. */
579 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
581 struct type
*type
= val
->type ();
585 if (entryval
->lazy ())
586 entryval
->fetch_lazy ();
588 if (val
->contents_eq (0, entryval
, 0, type
->length ()))
590 /* Initialize it just to avoid a GCC false warning. */
591 struct value
*val_deref
= NULL
, *entryval_deref
;
593 /* DW_AT_call_value does match with the current
594 value. If it is a reference still try to verify if
595 dereferenced DW_AT_call_data_value does not differ. */
599 struct type
*type_deref
;
601 val_deref
= coerce_ref (val
);
602 if (val_deref
->lazy ())
603 val_deref
->fetch_lazy ();
604 type_deref
= val_deref
->type ();
606 entryval_deref
= coerce_ref (entryval
);
607 if (entryval_deref
->lazy ())
608 entryval_deref
->fetch_lazy ();
610 /* If the reference addresses match but dereferenced
611 content does not match print them. */
613 && val_deref
->contents_eq (0,
615 type_deref
->length ()))
618 catch (const gdb_exception_error
&except
)
620 /* If the dereferenced content could not be
621 fetched do not display anything. */
622 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
624 else if (except
.message
!= NULL
)
627 = (char *) alloca (except
.message
->size () + 1);
628 strcpy (entryval_error
, except
.what ());
632 /* Value was not a reference; and its content matches. */
633 if (val
== val_deref
)
641 /* Try to remove possibly duplicate error message for ENTRYARGP even
644 if (val_error
&& entryval_error
645 && strcmp (val_error
, entryval_error
) == 0)
647 entryval_error
= NULL
;
649 /* Do not se VAL_EQUAL as the same error message may be shown for
650 the entry value even if no entry values are present in the
656 if (entryval
== NULL
)
658 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
660 gdb_assert (val
== NULL
);
664 val
= read_var_value (sym
, NULL
, frame
);
666 catch (const gdb_exception_error
&except
)
668 val_error
= (char *) alloca (except
.message
->size () + 1);
669 strcpy (val_error
, except
.what ());
672 if (fp_opts
.print_entry_values
== print_entry_values_only
673 || fp_opts
.print_entry_values
== print_entry_values_both
674 || (fp_opts
.print_entry_values
== print_entry_values_preferred
675 && (!val
|| val
->optimized_out ())))
677 entryval
= value::allocate_optimized_out (sym
->type ());
678 entryval_error
= NULL
;
681 if ((fp_opts
.print_entry_values
== print_entry_values_compact
682 || fp_opts
.print_entry_values
== print_entry_values_if_needed
683 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
684 && (!val
|| val
->optimized_out ()) && entryval
!= NULL
)
692 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
693 if (!val
&& !val_error
)
694 argp
->entry_kind
= print_entry_values_only
;
695 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
696 || fp_opts
.print_entry_values
== print_entry_values_default
)
699 argp
->entry_kind
= print_entry_values_compact
;
700 gdb_assert (!current_uiout
->is_mi_like_p ());
703 argp
->entry_kind
= print_entry_values_no
;
705 entryargp
->sym
= sym
;
706 entryargp
->val
= entryval
;
707 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
708 if (!entryval
&& !entryval_error
)
709 entryargp
->entry_kind
= print_entry_values_no
;
711 entryargp
->entry_kind
= print_entry_values_only
;
714 /* Print the arguments of frame FRAME on STREAM, given the function
715 FUNC running in that frame (as a symbol), where NUM is the number
716 of arguments according to the stack frame (or -1 if the number of
717 arguments is unknown). */
719 /* Note that currently the "number of arguments according to the
720 stack frame" is only known on VAX where i refers to the "number of
721 ints of arguments according to the stack frame". */
724 print_frame_args (const frame_print_options
&fp_opts
,
725 struct symbol
*func
, frame_info_ptr frame
,
726 int num
, struct ui_file
*stream
)
728 struct ui_out
*uiout
= current_uiout
;
730 /* Offset of next stack argument beyond the one we have seen that is
731 at the highest offset, or -1 if we haven't come to a stack
733 long highest_offset
= -1;
734 /* Number of ints of arguments that we have printed so far. */
735 int args_printed
= 0;
736 /* True if we should print arg names. If false, we only indicate
737 the presence of arguments by printing ellipsis. */
739 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
740 /* True if we should print arguments, false otherwise. */
743 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
747 const struct block
*b
= func
->value_block ();
749 for (struct symbol
*sym
: block_iterator_range (b
))
751 struct frame_arg arg
, entryarg
;
755 /* Keep track of the highest stack argument offset seen, and
756 skip over any kinds of symbols we don't care about. */
758 if (!sym
->is_argument ())
768 switch (sym
->aclass ())
773 long current_offset
= sym
->value_longest ();
774 int arg_size
= sym
->type ()->length ();
776 /* Compute address of next argument by adding the size of
777 this argument and rounding to an int boundary. */
779 ((current_offset
+ arg_size
+ sizeof (int) - 1)
780 & ~(sizeof (int) - 1));
782 /* If this is the highest offset seen yet, set
784 if (highest_offset
== -1
785 || (current_offset
> highest_offset
))
786 highest_offset
= current_offset
;
788 /* Add the number of ints we're about to print to
790 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
793 /* We care about types of symbols, but don't need to
794 keep track of stack offsets in them. */
796 case LOC_REGPARM_ADDR
:
798 case LOC_OPTIMIZED_OUT
:
803 /* We have to look up the symbol because arguments can have
804 two entries (one a parameter, one a local) and the one we
805 want is the local, which lookup_symbol will find for us.
806 This includes gcc1 (not gcc2) on SPARC when passing a
807 small structure and gcc2 when the argument type is float
808 and it is passed as a double and converted to float by
809 the prologue (in the latter case the type of the LOC_ARG
810 symbol is double and the type of the LOC_LOCAL symbol is
812 /* But if the parameter name is null, don't try it. Null
813 parameter names occur on the RS/6000, for traceback
814 tables. FIXME, should we even print them? */
816 if (*sym
->linkage_name ())
820 nsym
= lookup_symbol_search_name (sym
->search_name (),
821 b
, VAR_DOMAIN
).symbol
;
822 gdb_assert (nsym
!= NULL
);
823 if (nsym
->aclass () == LOC_REGISTER
824 && !nsym
->is_argument ())
826 /* There is a LOC_ARG/LOC_REGISTER pair. This means
827 that it was passed on the stack and loaded into a
828 register, or passed in a register and stored in a
829 stack slot. GDB 3.x used the LOC_ARG; GDB
830 4.0-4.11 used the LOC_REGISTER.
832 Reasons for using the LOC_ARG:
834 (1) Because find_saved_registers may be slow for
837 (2) Because registers are often re-used and stack
838 slots rarely (never?) are. Therefore using
839 the stack slot is much less likely to print
842 Reasons why we might want to use the LOC_REGISTER:
844 (1) So that the backtrace prints the same value
845 as "print foo". I see no compelling reason
846 why this needs to be the case; having the
847 backtrace print the value which was passed
848 in, and "print foo" print the value as
849 modified within the called function, makes
852 Additional note: It might be nice if "info args"
853 displayed both values.
855 One more note: There is a case with SPARC
856 structure passing where we need to use the
857 LOC_REGISTER, but this is dealt with by creating
858 a single LOC_REGPARM in symbol reading. */
860 /* Leave sym (the LOC_ARG) alone. */
867 /* Print the current arg. */
870 uiout
->wrap_hint (4);
875 arg
.entry_kind
= print_entry_values_no
;
877 entryarg
.entry_kind
= print_entry_values_no
;
880 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
882 if (arg
.entry_kind
!= print_entry_values_only
)
883 print_frame_arg (fp_opts
, &arg
);
885 if (entryarg
.entry_kind
!= print_entry_values_no
)
887 if (arg
.entry_kind
!= print_entry_values_only
)
890 uiout
->wrap_hint (4);
893 print_frame_arg (fp_opts
, &entryarg
);
900 /* Don't print nameless args in situations where we don't know
901 enough about the stack to find them. */
906 if (highest_offset
== -1)
907 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
909 start
= highest_offset
;
911 if (!print_names
&& !first
&& num
> 0)
914 print_frame_nameless_args (frame
, start
, num
- args_printed
,
919 /* Set the current source and line to the location given by frame
920 FRAME, if possible. When CENTER is true, adjust so the relevant
921 line is in the center of the next 'list'. */
924 set_current_sal_from_frame (frame_info_ptr frame
)
926 symtab_and_line sal
= find_frame_sal (frame
);
927 if (sal
.symtab
!= NULL
)
928 set_current_source_symtab_and_line (sal
);
931 /* If ON, GDB will display disassembly of the next source line when
932 execution of the program being debugged stops.
933 If AUTO (which is the default), or there's no line info to determine
934 the source line of the next instruction, display disassembly of next
935 instruction instead. */
937 static enum auto_boolean disassemble_next_line
;
940 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
941 struct cmd_list_element
*c
,
945 _("Debugger's willingness to use "
946 "disassemble-next-line is %s.\n"),
950 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
951 because it will be broken by filter sometime. */
954 do_gdb_disassembly (struct gdbarch
*gdbarch
,
955 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
960 gdb_disassembly (gdbarch
, current_uiout
,
961 DISASSEMBLY_RAW_INSN
, how_many
,
964 catch (const gdb_exception_error
&exception
)
966 /* If an exception was thrown while doing the disassembly, print
967 the error message, to give the user a clue of what happened. */
968 exception_print (gdb_stderr
, exception
);
972 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
973 Value not present indicates to the caller to use default values
974 specific to the command being executed. */
976 static std::optional
<enum print_what
>
977 print_frame_info_to_print_what (const char *print_frame_info
)
979 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
980 if (print_frame_info
== print_frame_info_choices
[i
])
981 return print_frame_info_print_what
[i
];
983 internal_error ("Unexpected print frame-info value `%s'.",
987 /* Print the PC from FRAME, plus any flags, to UIOUT. */
990 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info_ptr frame
,
993 uiout
->field_core_addr ("addr", gdbarch
, pc
);
995 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
999 uiout
->field_string ("addr_flags", flags
);
1007 get_user_print_what_frame_info (std::optional
<enum print_what
> *what
)
1010 = print_frame_info_to_print_what
1011 (user_frame_print_options
.print_frame_info
);
1014 /* Print information about frame FRAME. The output is format according
1015 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1016 PRINT_WHAT, see enum print_what comments in frame.h.
1017 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1018 != print_frame_info_auto.
1020 Used in "where" output, and to emit breakpoint or step
1024 print_frame_info (const frame_print_options
&fp_opts
,
1025 frame_info_ptr frame
, int print_level
,
1026 enum print_what print_what
, int print_args
,
1027 int set_current_sal
)
1029 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1032 struct ui_out
*uiout
= current_uiout
;
1034 if (!current_uiout
->is_mi_like_p ()
1035 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1037 /* Use the specific frame information desired by the user. */
1038 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1041 if (get_frame_type (frame
) == DUMMY_FRAME
1042 || get_frame_type (frame
) == SIGTRAMP_FRAME
1043 || get_frame_type (frame
) == ARCH_FRAME
)
1045 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1047 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1048 gdbarch
, get_frame_pc (frame
));
1050 /* Do this regardless of SOURCE because we don't have any source
1051 to list for this frame. */
1055 uiout
->field_fmt_signed (2, ui_left
, "level",
1056 frame_relative_level (frame
));
1058 if (uiout
->is_mi_like_p ())
1060 annotate_frame_address ();
1061 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1062 annotate_frame_address_end ();
1065 if (get_frame_type (frame
) == DUMMY_FRAME
)
1067 annotate_function_call ();
1068 uiout
->field_string ("func", "<function called from gdb>",
1069 metadata_style
.style ());
1071 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1073 annotate_signal_handler_caller ();
1074 uiout
->field_string ("func", "<signal handler called>",
1075 metadata_style
.style ());
1077 else if (get_frame_type (frame
) == ARCH_FRAME
)
1079 uiout
->field_string ("func", "<cross-architecture call>",
1080 metadata_style
.style ());
1083 annotate_frame_end ();
1085 /* If disassemble-next-line is set to auto or on output the next
1087 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1088 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1089 do_gdb_disassembly (get_frame_arch (frame
), 1,
1090 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1095 /* If FRAME is not the innermost frame, that normally means that
1096 FRAME->pc points to *after* the call instruction, and we want to
1097 get the line containing the call, never the next line. But if
1098 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1099 next frame was not entered as the result of a call, and we want
1100 to get the line containing FRAME->pc. */
1101 symtab_and_line sal
= find_frame_sal (frame
);
1103 location_print
= (print_what
== LOCATION
1104 || print_what
== SRC_AND_LOC
1105 || print_what
== LOC_AND_ADDRESS
1106 || print_what
== SHORT_LOCATION
);
1107 if (location_print
|| !sal
.symtab
)
1108 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1110 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1112 /* If disassemble-next-line is set to auto or on and doesn't have
1113 the line debug messages for $pc, output the next instruction. */
1114 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1115 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1116 && source_print
&& !sal
.symtab
)
1117 do_gdb_disassembly (get_frame_arch (frame
), 1,
1118 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1120 if (source_print
&& sal
.symtab
)
1122 int mid_statement
= ((print_what
== SRC_LINE
)
1123 && frame_show_address (frame
, sal
));
1124 if (annotation_level
> 0
1125 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1126 get_frame_pc (frame
)))
1128 /* The call to ANNOTATE_SOURCE_LINE already printed the
1129 annotation for this source line, so we avoid the two cases
1130 below and do not print the actual source line. The
1131 documentation for annotations makes it clear that the source
1132 line annotation is printed __instead__ of printing the source
1133 line, not as well as.
1135 However, if we fail to print the source line, which usually
1136 means either the source file is missing, or the requested
1137 line is out of range of the file, then we don't print the
1138 source annotation, and will pass through the "normal" print
1139 source line code below, the expectation is that this code
1140 will print an appropriate error. */
1142 else if (deprecated_print_frame_info_listing_hook
)
1143 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1147 struct value_print_options opts
;
1149 get_user_print_options (&opts
);
1150 /* We used to do this earlier, but that is clearly
1151 wrong. This function is used by many different
1152 parts of gdb, including normal_stop in infrun.c,
1153 which uses this to print out the current PC
1154 when we stepi/nexti into the middle of a source
1155 line. Only the command line really wants this
1156 behavior. Other UIs probably would like the
1157 ability to decide for themselves if it is desired. */
1158 if (opts
.addressprint
&& mid_statement
)
1160 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1164 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1167 /* If disassemble-next-line is set to on and there is line debug
1168 messages, output assembly codes for next line. */
1169 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1170 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1173 if (set_current_sal
)
1177 if (get_frame_pc_if_available (frame
, &pc
))
1178 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1180 last_displayed_symtab_info
.invalidate ();
1183 annotate_frame_end ();
1185 gdb_flush (gdb_stdout
);
1191 clear_last_displayed_sal (void)
1193 last_displayed_symtab_info
.invalidate ();
1199 last_displayed_sal_is_valid (void)
1201 return last_displayed_symtab_info
.is_valid ();
1206 struct program_space
*
1207 get_last_displayed_pspace (void)
1209 return last_displayed_symtab_info
.pspace ();
1215 get_last_displayed_addr (void)
1217 return last_displayed_symtab_info
.address ();
1223 get_last_displayed_symtab (void)
1225 return last_displayed_symtab_info
.symtab ();
1231 get_last_displayed_line (void)
1233 return last_displayed_symtab_info
.line ();
1239 get_last_displayed_sal ()
1241 symtab_and_line sal
;
1243 if (last_displayed_symtab_info
.is_valid ())
1245 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1246 sal
.pc
= last_displayed_symtab_info
.address ();
1247 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1248 sal
.line
= last_displayed_symtab_info
.line ();
1255 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1256 corresponding to FRAME. */
1258 gdb::unique_xmalloc_ptr
<char>
1259 find_frame_funname (frame_info_ptr frame
, enum language
*funlang
,
1260 struct symbol
**funcp
)
1262 struct symbol
*func
;
1263 gdb::unique_xmalloc_ptr
<char> funname
;
1265 *funlang
= language_unknown
;
1269 func
= get_frame_function (frame
);
1272 const char *print_name
= func
->print_name ();
1274 *funlang
= func
->language ();
1277 if (*funlang
== language_cplus
)
1279 /* It seems appropriate to use print_name() here,
1280 to display the demangled name that we already have
1281 stored in the symbol table, but we stored a version
1282 with DMGL_PARAMS turned on, and here we don't want to
1283 display parameters. So remove the parameters. */
1284 funname
= cp_remove_params (print_name
);
1287 /* If we didn't hit the C++ case above, set *funname
1289 if (funname
== NULL
)
1290 funname
.reset (xstrdup (print_name
));
1294 struct bound_minimal_symbol msymbol
;
1297 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1300 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1301 if (msymbol
.minsym
!= NULL
)
1303 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1304 *funlang
= msymbol
.minsym
->language ();
1312 print_frame (const frame_print_options
&fp_opts
,
1313 frame_info_ptr frame
, int print_level
,
1314 enum print_what print_what
, int print_args
,
1315 struct symtab_and_line sal
)
1317 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1318 struct ui_out
*uiout
= current_uiout
;
1319 enum language funlang
= language_unknown
;
1320 struct value_print_options opts
;
1321 struct symbol
*func
;
1325 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1327 gdb::unique_xmalloc_ptr
<char> funname
1328 = find_frame_funname (frame
, &funlang
, &func
);
1330 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1334 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1339 uiout
->field_fmt_signed (2, ui_left
, "level",
1340 frame_relative_level (frame
));
1342 get_user_print_options (&opts
);
1343 if (opts
.addressprint
)
1345 || frame_show_address (frame
, sal
)
1346 || print_what
== LOC_AND_ADDRESS
)
1348 annotate_frame_address ();
1350 print_pc (uiout
, gdbarch
, frame
, pc
);
1352 uiout
->field_string ("addr", "<unavailable>",
1353 metadata_style
.style ());
1354 annotate_frame_address_end ();
1355 uiout
->text (" in ");
1357 annotate_frame_function_name ();
1360 gdb_puts (funname
? funname
.get () : "??", &stb
);
1361 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1362 uiout
->wrap_hint (3);
1363 annotate_frame_args ();
1370 if (gdbarch_frame_num_args_p (gdbarch
))
1372 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1373 gdb_assert (numargs
>= 0);
1379 ui_out_emit_list
list_emitter (uiout
, "args");
1382 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1384 catch (const gdb_exception_error
&e
)
1388 /* FIXME: ARGS must be a list. If one argument is a string it
1389 will have " that will not be properly escaped. */
1394 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1396 const char *filename_display
;
1398 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1399 annotate_frame_source_begin ();
1400 uiout
->wrap_hint (3);
1401 uiout
->text (" at ");
1402 annotate_frame_source_file ();
1403 uiout
->field_string ("file", filename_display
,
1404 file_name_style
.style ());
1405 if (uiout
->is_mi_like_p ())
1407 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1409 uiout
->field_string ("fullname", fullname
);
1411 annotate_frame_source_file_end ();
1413 annotate_frame_source_line ();
1414 uiout
->field_signed ("line", sal
.line
);
1415 annotate_frame_source_end ();
1418 if (print_what
!= SHORT_LOCATION
1419 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1422 = solib_name_from_address (get_frame_program_space (frame
),
1423 get_frame_address_in_block (frame
));
1427 annotate_frame_where ();
1428 uiout
->wrap_hint (2);
1429 uiout
->text (" from ");
1430 uiout
->field_string ("from", lib
, file_name_style
.style ());
1433 if (uiout
->is_mi_like_p ())
1434 uiout
->field_string ("arch",
1435 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1442 /* Completion function for "frame function", "info frame function", and
1443 "select-frame function" commands. */
1446 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1447 completion_tracker
&tracker
,
1448 const char *text
, const char *word
)
1450 /* This is used to complete function names within a stack. It would be
1451 nice if we only offered functions that were actually in the stack.
1452 However, this would mean unwinding the stack to completion, which
1453 could take too long, or on a corrupted stack, possibly not end.
1454 Instead, we offer all symbol names as a safer choice. */
1455 collect_symbol_completion_matches (tracker
,
1456 complete_symbol_mode::EXPRESSION
,
1457 symbol_name_match_type::EXPRESSION
,
1461 /* Core of all the "info frame" sub-commands. Print information about a
1462 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1463 frame specification, they just entered 'info frame'. If the user did
1464 provide a frame specification (for example 'info frame 0', 'info frame
1465 level 1') then SELECTED_FRAME_P will be false. */
1468 info_frame_command_core (frame_info_ptr fi
, bool selected_frame_p
)
1470 struct symbol
*func
;
1472 frame_info_ptr calling_frame_info
;
1474 const char *funname
= 0;
1475 enum language funlang
= language_unknown
;
1476 const char *pc_regname
;
1477 struct gdbarch
*gdbarch
;
1480 /* Initialize it to avoid "may be used uninitialized" warning. */
1481 CORE_ADDR caller_pc
= 0;
1482 int caller_pc_p
= 0;
1484 gdbarch
= get_frame_arch (fi
);
1486 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1487 is not a good name. */
1488 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1489 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1490 easily not match that of the internal value returned by
1492 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1494 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1495 architectures will often have a hardware register called "pc",
1496 and that register's value, again, can easily not match
1500 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1501 func
= get_frame_function (fi
);
1502 symtab_and_line sal
= find_frame_sal (fi
);
1504 gdb::unique_xmalloc_ptr
<char> func_only
;
1507 funname
= func
->print_name ();
1508 funlang
= func
->language ();
1509 if (funlang
== language_cplus
)
1511 /* It seems appropriate to use print_name() here,
1512 to display the demangled name that we already have
1513 stored in the symbol table, but we stored a version
1514 with DMGL_PARAMS turned on, and here we don't want to
1515 display parameters. So remove the parameters. */
1516 func_only
= cp_remove_params (funname
);
1519 funname
= func_only
.get ();
1522 else if (frame_pc_p
)
1524 struct bound_minimal_symbol msymbol
;
1526 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1527 if (msymbol
.minsym
!= NULL
)
1529 funname
= msymbol
.minsym
->print_name ();
1530 funlang
= msymbol
.minsym
->language ();
1533 calling_frame_info
= get_prev_frame (fi
);
1535 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1537 gdb_printf (_("Stack level %d, frame at "),
1538 frame_relative_level (fi
));
1542 gdb_printf (_("Stack frame at "));
1544 gdb_puts (paddress (gdbarch
, get_frame_base (fi
)));
1546 gdb_printf (" %s = ", pc_regname
);
1548 gdb_puts (paddress (gdbarch
, get_frame_pc (fi
)));
1550 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1552 gdb_stdout
->wrap_here (3);
1555 gdb_printf (" in ");
1558 gdb_stdout
->wrap_here (3);
1562 styled_string (file_name_style
.style (),
1563 symtab_to_filename_for_display (sal
.symtab
)),
1566 gdb_stdout
->wrap_here (4);
1567 gdb_printf ("saved %s = ", pc_regname
);
1569 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1570 val_print_not_saved (gdb_stdout
);
1575 caller_pc
= frame_unwind_caller_pc (fi
);
1578 catch (const gdb_exception_error
&ex
)
1582 case NOT_AVAILABLE_ERROR
:
1583 val_print_unavailable (gdb_stdout
);
1585 case OPTIMIZED_OUT_ERROR
:
1586 val_print_not_saved (gdb_stdout
);
1589 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1598 gdb_puts (paddress (gdbarch
, caller_pc
));
1601 if (calling_frame_info
== NULL
)
1603 enum unwind_stop_reason reason
;
1605 reason
= get_frame_unwind_stop_reason (fi
);
1606 if (reason
!= UNWIND_NO_REASON
)
1607 gdb_printf (_(" Outermost frame: %s\n"),
1608 frame_stop_reason_string (fi
));
1610 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1611 gdb_puts (" tail call frame");
1612 else if (get_frame_type (fi
) == INLINE_FRAME
)
1613 gdb_printf (" inlined into frame %d",
1614 frame_relative_level (get_prev_frame (fi
)));
1617 gdb_printf (" called by frame at ");
1618 gdb_puts (paddress (gdbarch
, get_frame_base (calling_frame_info
)));
1620 if (get_next_frame (fi
) && calling_frame_info
)
1622 gdb_stdout
->wrap_here (3);
1623 if (get_next_frame (fi
))
1625 gdb_printf (" caller of frame at ");
1626 gdb_puts (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))));
1628 if (get_next_frame (fi
) || calling_frame_info
)
1632 gdb_printf (" source language %s.\n",
1633 language_str (s
->language ()));
1636 /* Address of the argument list for this frame, or 0. */
1637 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1638 /* Number of args for this frame, or -1 if unknown. */
1642 gdb_printf (" Arglist at unknown address.\n");
1645 gdb_printf (" Arglist at ");
1646 gdb_puts (paddress (gdbarch
, arg_list
));
1649 if (!gdbarch_frame_num_args_p (gdbarch
))
1652 gdb_puts (" args: ");
1656 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1657 gdb_assert (numargs
>= 0);
1659 gdb_puts (" no args.");
1660 else if (numargs
== 1)
1661 gdb_puts (" 1 arg: ");
1663 gdb_printf (" %d args: ", numargs
);
1666 print_frame_args (user_frame_print_options
,
1667 func
, fi
, numargs
, gdb_stdout
);
1672 /* Address of the local variables for this frame, or 0. */
1673 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1676 gdb_printf (" Locals at unknown address,");
1679 gdb_printf (" Locals at ");
1680 gdb_puts (paddress (gdbarch
, arg_list
));
1685 /* Print as much information as possible on the location of all the
1691 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1693 /* The sp is special; what's displayed isn't the save address, but
1694 the value of the previous frame's sp. This is a legacy thing,
1695 at one stage the frame cached the previous frame's SP instead
1696 of its address, hence it was easiest to just display the cached
1700 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1701 gdb_assert (value
!= NULL
);
1703 if (!value
->optimized_out () && value
->entirely_available ())
1705 if (value
->lval () == not_lval
)
1708 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1709 int sp_size
= register_size (gdbarch
, sp_regnum
);
1711 sp
= extract_unsigned_integer
1712 (value
->contents_all ().data (), sp_size
, byte_order
);
1714 gdb_printf (" Previous frame's sp is ");
1715 gdb_puts (paddress (gdbarch
, sp
));
1718 else if (value
->lval () == lval_memory
)
1720 gdb_printf (" Previous frame's sp at ");
1721 gdb_puts (paddress (gdbarch
, value
->address ()));
1724 else if (value
->lval () == lval_register
)
1726 gdb_printf (" Previous frame's sp in %s\n",
1727 gdbarch_register_name (gdbarch
, value
->regnum ()));
1730 release_value (value
);
1733 /* else keep quiet. */
1737 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1738 for (i
= 0; i
< numregs
; i
++)
1740 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1742 enum lval_type lval
;
1748 /* Find out the location of the saved register without
1749 fetching the corresponding value. */
1750 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1751 &lval
, &addr
, &realnum
, NULL
);
1752 /* For moment, only display registers that were saved on the
1754 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1757 gdb_puts (" Saved registers:\n ");
1760 gdb_stdout
->wrap_here (1);
1761 gdb_printf (" %s at ",
1762 gdbarch_register_name (gdbarch
, i
));
1763 gdb_puts (paddress (gdbarch
, addr
));
1767 if (count
|| need_nl
)
1772 /* Return the innermost frame at level LEVEL. */
1774 static frame_info_ptr
1775 leading_innermost_frame (int level
)
1777 frame_info_ptr leading
;
1779 leading
= get_current_frame ();
1781 gdb_assert (level
>= 0);
1783 while (leading
!= nullptr && level
)
1786 leading
= get_prev_frame (leading
);
1793 /* Return the starting frame needed to handle COUNT outermost frames. */
1795 static frame_info_ptr
1796 trailing_outermost_frame (int count
)
1798 frame_info_ptr current
;
1799 frame_info_ptr trailing
;
1801 trailing
= get_current_frame ();
1803 gdb_assert (count
> 0);
1806 while (current
!= nullptr && count
--)
1809 current
= get_prev_frame (current
);
1812 /* Will stop when CURRENT reaches the top of the stack.
1813 TRAILING will be COUNT below it. */
1814 while (current
!= nullptr)
1817 trailing
= get_prev_frame (trailing
);
1818 current
= get_prev_frame (current
);
1824 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1828 select_frame_command_core (frame_info_ptr fi
, bool ignored
)
1830 frame_info_ptr prev_frame
= get_selected_frame ();
1832 if (get_selected_frame () != prev_frame
)
1833 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1836 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1837 means we change frame send out a change notification (otherwise, just
1838 reprint the current frame summary). */
1841 frame_command_core (frame_info_ptr fi
, bool ignored
)
1843 frame_info_ptr prev_frame
= get_selected_frame ();
1845 if (get_selected_frame () != prev_frame
)
1846 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1848 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1851 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1852 common set of sub-commands that allow a specific frame to be selected.
1853 All of the sub-command functions are static methods within this class
1854 template which is then instantiated below. The template parameter is a
1855 callback used to implement the functionality of the base command
1856 ('frame', 'select-frame', or 'info frame').
1858 In the template parameter FI is the frame being selected. The
1859 SELECTED_FRAME_P flag is true if the frame being selected was done by
1860 default, which happens when the user uses the base command with no
1861 arguments. For example the commands 'info frame', 'select-frame',
1862 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1863 SELECTED_FRAME_P is false. */
1865 template <void (*FPTR
) (frame_info_ptr fi
, bool selected_frame_p
)>
1866 class frame_command_helper
1870 /* The "frame level" family of commands. The ARG is an integer that is
1871 the frame's level in the stack. */
1873 level (const char *arg
, int from_tty
)
1875 int level
= value_as_long (parse_and_eval (arg
));
1877 = find_relative_frame (get_current_frame (), &level
);
1879 error (_("No frame at level %s."), arg
);
1883 /* The "frame address" family of commands. ARG is a stack-pointer
1884 address for an existing frame. This command does not allow new
1885 frames to be created. */
1888 address (const char *arg
, int from_tty
)
1890 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1891 frame_info_ptr fid
= find_frame_for_address (addr
);
1893 error (_("No frame at address %s."), arg
);
1897 /* The "frame view" family of commands. ARG is one or two addresses and
1898 is used to view a frame that might be outside the current backtrace.
1899 The addresses are stack-pointer address, and (optional) pc-address. */
1902 view (const char *args
, int from_tty
)
1907 error (_("Missing address argument to view a frame"));
1909 gdb_argv
argv (args
);
1911 if (argv
.count () == 2)
1915 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1916 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1917 fid
= create_new_frame (addr
[0], addr
[1]);
1921 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1922 fid
= create_new_frame (addr
, false);
1927 /* The "frame function" family of commands. ARG is the name of a
1928 function within the stack, the first function (searching from frame
1929 0) with that name will be selected. */
1932 function (const char *arg
, int from_tty
)
1935 error (_("Missing function name argument"));
1936 frame_info_ptr fid
= find_frame_for_function (arg
);
1938 error (_("No frame for function \"%s\"."), arg
);
1942 /* The "frame" base command, that is, when no sub-command is specified.
1943 If one argument is provided then we assume that this is a frame's
1944 level as historically, this was the supported command syntax that was
1947 If no argument is provided, then the current frame is selected. */
1950 base_command (const char *arg
, int from_tty
)
1953 FPTR (get_selected_frame (_("No stack.")), true);
1955 level (arg
, from_tty
);
1959 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1960 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1962 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1963 static frame_command_helper
<frame_command_core
> frame_cmd
;
1964 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1966 /* Print briefly all stack frames or just the innermost COUNT_EXP
1970 backtrace_command_1 (const frame_print_options
&fp_opts
,
1971 const backtrace_cmd_options
&bt_opts
,
1972 const char *count_exp
, int from_tty
)
1977 int py_start
= 0, py_end
= 0;
1978 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1980 if (!target_has_stack ())
1981 error (_("No stack."));
1985 count
= parse_and_eval_long (count_exp
);
1991 /* The argument to apply_ext_lang_frame_filter is the number
1992 of the final frame to print, and frames start at 0. */
2002 frame_filter_flags flags
= 0;
2005 flags
|= PRINT_LOCALS
;
2007 flags
|= PRINT_HIDE
;
2009 if (!bt_opts
.no_filters
)
2011 enum ext_lang_frame_args arg_type
;
2013 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2015 flags
|= PRINT_MORE_FRAMES
;
2017 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2018 arg_type
= CLI_SCALAR_VALUES
;
2019 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2020 arg_type
= CLI_ALL_VALUES
;
2021 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2022 arg_type
= CLI_PRESENCE
;
2023 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2024 arg_type
= NO_VALUES
;
2028 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2029 arg_type
, current_uiout
,
2033 /* Run the inbuilt backtrace if there are no filters registered, or
2034 "-no-filters" has been specified from the command. */
2035 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2037 frame_info_ptr trailing
;
2039 /* The following code must do two things. First, it must set the
2040 variable TRAILING to the frame from which we should start
2041 printing. Second, it must set the variable count to the number
2042 of frames which we should print, or -1 if all of them. */
2044 if (count_exp
!= NULL
&& count
< 0)
2046 trailing
= trailing_outermost_frame (-count
);
2050 trailing
= get_current_frame ();
2052 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2056 /* Don't use print_stack_frame; if an error() occurs it probably
2057 means further attempts to backtrace would fail (on the other
2058 hand, perhaps the code does or could be fixed to make sure
2059 the frame->prev field gets set to NULL in that case). */
2061 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2062 if ((flags
& PRINT_LOCALS
) != 0)
2063 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2065 /* Save the last frame to check for error conditions. */
2069 /* If we've stopped before the end, mention that. */
2071 gdb_printf (_("(More stack frames follow...)\n"));
2073 /* If we've run out of frames, and the reason appears to be an error
2074 condition, print it. */
2075 if (fi
== NULL
&& trailing
!= NULL
)
2077 enum unwind_stop_reason reason
;
2079 reason
= get_frame_unwind_stop_reason (trailing
);
2080 if (reason
>= UNWIND_FIRST_ERROR
)
2081 gdb_printf (_("Backtrace stopped: %s\n"),
2082 frame_stop_reason_string (trailing
));
2087 /* Create an option_def_group array grouping all the "backtrace"
2088 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2090 static inline std::array
<gdb::option::option_def_group
, 3>
2091 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2092 backtrace_cmd_options
*bt_cmd_opts
,
2093 set_backtrace_options
*set_bt_opts
)
2096 { {frame_print_option_defs
}, fp_opts
},
2097 { {set_backtrace_option_defs
}, set_bt_opts
},
2098 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2102 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2103 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2104 store the parsed qualifiers. */
2107 parse_backtrace_qualifiers (const char *arg
,
2108 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2112 const char *save_arg
= arg
;
2113 std::string this_arg
= extract_arg (&arg
);
2115 if (this_arg
.empty ())
2118 if (startswith ("no-filters", this_arg
))
2120 if (bt_cmd_opts
!= nullptr)
2121 bt_cmd_opts
->no_filters
= true;
2123 else if (startswith ("full", this_arg
))
2125 if (bt_cmd_opts
!= nullptr)
2126 bt_cmd_opts
->full
= true;
2128 else if (startswith ("hide", this_arg
))
2130 if (bt_cmd_opts
!= nullptr)
2131 bt_cmd_opts
->hide
= true;
2135 /* Not a recognized qualifier, so stop. */
2142 backtrace_command (const char *arg
, int from_tty
)
2144 frame_print_options fp_opts
= user_frame_print_options
;
2145 backtrace_cmd_options bt_cmd_opts
;
2146 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2149 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2150 gdb::option::process_options
2151 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2153 /* Parse non-'-'-prefixed qualifiers, for backwards
2157 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2162 /* These options are handled quite deep in the unwind machinery, so
2163 we get to pass them down by swapping globals. */
2164 scoped_restore restore_set_backtrace_options
2165 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2167 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2170 /* Completer for the "backtrace" command. */
2173 backtrace_command_completer (struct cmd_list_element
*ignore
,
2174 completion_tracker
&tracker
,
2175 const char *text
, const char */
*word*/
)
2178 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2179 if (gdb::option::complete_options
2180 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2185 const char *p
= skip_to_space (text
);
2188 static const char *const backtrace_cmd_qualifier_choices
[] = {
2189 "full", "no-filters", "hide", nullptr,
2191 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2194 if (tracker
.have_completions ())
2199 const char *cmd
= parse_backtrace_qualifiers (text
);
2200 tracker
.advance_custom_word_point_by (cmd
- text
);
2205 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2206 expression_completer (ignore
, tracker
, text
, word
);
2209 /* Iterate over the local variables of a block B, calling CB. */
2212 iterate_over_block_locals (const struct block
*b
,
2213 iterate_over_block_arg_local_vars_cb cb
)
2215 for (struct symbol
*sym
: block_iterator_range (b
))
2217 switch (sym
->aclass ())
2224 case LOC_OPTIMIZED_OUT
:
2225 if (sym
->is_argument ())
2227 if (sym
->domain () == COMMON_BLOCK_DOMAIN
)
2229 cb (sym
->print_name (), sym
);
2233 /* Ignore symbols which are not locals. */
2239 /* Iterate over all the local variables in block B, including all its
2240 superblocks, stopping when the top-level block is reached. */
2243 iterate_over_block_local_vars (const struct block
*block
,
2244 iterate_over_block_arg_local_vars_cb cb
)
2248 iterate_over_block_locals (block
, cb
);
2249 /* After handling the function's top-level block, stop. Don't
2250 continue to its superblock, the block of per-file
2252 if (block
->function ())
2254 block
= block
->superblock ();
2258 /* Data to be passed around in the calls to the locals and args
2261 struct print_variable_and_value_data
2263 std::optional
<compiled_regex
> preg
;
2264 std::optional
<compiled_regex
> treg
;
2265 struct frame_id frame_id
;
2267 struct ui_file
*stream
;
2270 void operator() (const char *print_name
, struct symbol
*sym
);
2273 /* The callback for the locals and args iterators. */
2276 print_variable_and_value_data::operator() (const char *print_name
,
2279 frame_info_ptr frame
;
2281 if (preg
.has_value ()
2282 && preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2284 if (treg
.has_value ()
2285 && !treg_matches_sym_type_name (*treg
, sym
))
2287 if (language_def (sym
->language ())->symbol_printing_suppressed (sym
))
2290 frame
= frame_find_by_id (frame_id
);
2293 warning (_("Unable to restore previously selected frame."));
2297 print_variable_and_value (print_name
, sym
, frame
, stream
, num_tabs
);
2299 /* print_variable_and_value invalidates FRAME. */
2305 /* Prepares the regular expression REG from REGEXP.
2306 If REGEXP is NULL, it results in an empty regular expression. */
2309 prepare_reg (const char *regexp
, std::optional
<compiled_regex
> *reg
)
2313 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2315 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2321 /* Print all variables from the innermost up to the function block of FRAME.
2322 Print them with values to STREAM indented by NUM_TABS.
2323 If REGEXP is not NULL, only print local variables whose name
2325 If T_REGEXP is not NULL, only print local variables whose type
2327 If no local variables have been printed and !QUIET, prints a message
2328 explaining why no local variables could be printed. */
2331 print_frame_local_vars (frame_info_ptr frame
,
2333 const char *regexp
, const char *t_regexp
,
2334 int num_tabs
, struct ui_file
*stream
)
2336 struct print_variable_and_value_data cb_data
;
2337 const struct block
*block
;
2340 if (!get_frame_pc_if_available (frame
, &pc
))
2344 _("PC unavailable, cannot determine locals.\n"));
2348 block
= get_frame_block (frame
, 0);
2352 gdb_printf (stream
, "No symbol table info available.\n");
2356 prepare_reg (regexp
, &cb_data
.preg
);
2357 prepare_reg (t_regexp
, &cb_data
.treg
);
2358 cb_data
.frame_id
= get_frame_id (frame
);
2359 cb_data
.num_tabs
= 4 * num_tabs
;
2360 cb_data
.stream
= stream
;
2361 cb_data
.values_printed
= 0;
2363 /* Temporarily change the selected frame to the given FRAME.
2364 This allows routines that rely on the selected frame instead
2365 of being given a frame as parameter to use the correct frame. */
2366 scoped_restore_selected_frame restore_selected_frame
;
2367 select_frame (frame
);
2369 iterate_over_block_local_vars (block
, cb_data
);
2371 if (!cb_data
.values_printed
&& !quiet
)
2373 if (regexp
== NULL
&& t_regexp
== NULL
)
2374 gdb_printf (stream
, _("No locals.\n"));
2376 gdb_printf (stream
, _("No matching locals.\n"));
2380 /* Structure to hold the values of the options used by the 'info
2381 variables' command and other similar commands. These correspond to the
2382 -q and -t options. */
2384 struct info_print_options
2387 std::string type_regexp
;
2390 /* The options used by the 'info locals' and 'info args' commands. */
2392 static const gdb::option::option_def info_print_options_defs
[] = {
2393 gdb::option::boolean_option_def
<info_print_options
> {
2395 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2396 nullptr, /* show_cmd_cb */
2397 nullptr /* set_doc */
2400 gdb::option::string_option_def
<info_print_options
> {
2402 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2403 nullptr, /* show_cmd_cb */
2404 nullptr /* set_doc */
2408 /* Returns the option group used by 'info locals' and 'info args'
2411 static gdb::option::option_def_group
2412 make_info_print_options_def_group (info_print_options
*opts
)
2414 return {{info_print_options_defs
}, opts
};
2417 /* Command completer for 'info locals' and 'info args'. */
2420 info_print_command_completer (struct cmd_list_element
*ignore
,
2421 completion_tracker
&tracker
,
2422 const char *text
, const char * /* word */)
2425 = make_info_print_options_def_group (nullptr);
2426 if (gdb::option::complete_options
2427 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2430 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2431 symbol_completer (ignore
, tracker
, text
, word
);
2434 /* Implement the 'info locals' command. */
2437 info_locals_command (const char *args
, int from_tty
)
2439 info_print_options opts
;
2440 auto grp
= make_info_print_options_def_group (&opts
);
2441 gdb::option::process_options
2442 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2443 if (args
!= nullptr && *args
== '\0')
2446 print_frame_local_vars
2447 (get_selected_frame (_("No frame selected.")),
2449 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2453 /* Iterate over all the argument variables in block B. */
2456 iterate_over_block_arg_vars (const struct block
*b
,
2457 iterate_over_block_arg_local_vars_cb cb
)
2459 for (struct symbol
*sym
: block_iterator_range (b
))
2461 /* Don't worry about things which aren't arguments. */
2462 if (sym
->is_argument ())
2464 /* We have to look up the symbol because arguments can have
2465 two entries (one a parameter, one a local) and the one we
2466 want is the local, which lookup_symbol will find for us.
2467 This includes gcc1 (not gcc2) on the sparc when passing a
2468 small structure and gcc2 when the argument type is float
2469 and it is passed as a double and converted to float by
2470 the prologue (in the latter case the type of the LOC_ARG
2471 symbol is double and the type of the LOC_LOCAL symbol is
2472 float). There are also LOC_ARG/LOC_REGISTER pairs which
2473 are not combined in symbol-reading. */
2476 = lookup_symbol_search_name (sym
->search_name (),
2477 b
, VAR_DOMAIN
).symbol
;
2478 cb (sym
->print_name (), sym2
);
2483 /* Print all argument variables of the function of FRAME.
2484 Print them with values to STREAM.
2485 If REGEXP is not NULL, only print argument variables whose name
2487 If T_REGEXP is not NULL, only print argument variables whose type
2489 If no argument variables have been printed and !QUIET, prints a message
2490 explaining why no argument variables could be printed. */
2493 print_frame_arg_vars (frame_info_ptr frame
,
2495 const char *regexp
, const char *t_regexp
,
2496 struct ui_file
*stream
)
2498 struct print_variable_and_value_data cb_data
;
2499 struct symbol
*func
;
2501 std::optional
<compiled_regex
> preg
;
2502 std::optional
<compiled_regex
> treg
;
2504 if (!get_frame_pc_if_available (frame
, &pc
))
2508 _("PC unavailable, cannot determine args.\n"));
2512 func
= get_frame_function (frame
);
2516 gdb_printf (stream
, _("No symbol table info available.\n"));
2520 prepare_reg (regexp
, &cb_data
.preg
);
2521 prepare_reg (t_regexp
, &cb_data
.treg
);
2522 cb_data
.frame_id
= get_frame_id (frame
);
2523 cb_data
.num_tabs
= 0;
2524 cb_data
.stream
= stream
;
2525 cb_data
.values_printed
= 0;
2527 iterate_over_block_arg_vars (func
->value_block (), cb_data
);
2529 if (!cb_data
.values_printed
&& !quiet
)
2531 if (regexp
== NULL
&& t_regexp
== NULL
)
2532 gdb_printf (stream
, _("No arguments.\n"));
2534 gdb_printf (stream
, _("No matching arguments.\n"));
2538 /* Implement the 'info args' command. */
2541 info_args_command (const char *args
, int from_tty
)
2543 info_print_options opts
;
2544 auto grp
= make_info_print_options_def_group (&opts
);
2545 gdb::option::process_options
2546 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2547 if (args
!= nullptr && *args
== '\0')
2550 print_frame_arg_vars
2551 (get_selected_frame (_("No frame selected.")),
2553 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2557 /* Return the symbol-block in which the selected frame is executing.
2558 Can return zero under various legitimate circumstances.
2560 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2561 code address within the block returned. We use this to decide
2562 which macros are in scope. */
2564 const struct block
*
2565 get_selected_block (CORE_ADDR
*addr_in_block
)
2567 if (!has_stack_frames ())
2570 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2573 /* Find a frame a certain number of levels away from FRAME.
2574 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2575 Positive means go to earlier frames (up); negative, the reverse.
2576 The int that contains the number of levels is counted toward
2577 zero as the frames for those levels are found.
2578 If the top or bottom frame is reached, that frame is returned,
2579 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2580 how much farther the original request asked to go. */
2583 find_relative_frame (frame_info_ptr frame
, int *level_offset_ptr
)
2585 /* Going up is simple: just call get_prev_frame enough times or
2586 until the initial frame is reached. */
2587 while (*level_offset_ptr
> 0)
2589 frame_info_ptr prev
= get_prev_frame (frame
);
2593 (*level_offset_ptr
)--;
2597 /* Going down is just as simple. */
2598 while (*level_offset_ptr
< 0)
2600 frame_info_ptr next
= get_next_frame (frame
);
2604 (*level_offset_ptr
)++;
2611 /* Select the frame up one or COUNT_EXP stack levels from the
2612 previously selected frame, and print it briefly. */
2615 up_silently_base (const char *count_exp
)
2617 frame_info_ptr frame
;
2621 count
= parse_and_eval_long (count_exp
);
2623 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2624 if (count
!= 0 && count_exp
== NULL
)
2625 error (_("Initial frame selected; you cannot go up."));
2626 select_frame (frame
);
2630 up_silently_command (const char *count_exp
, int from_tty
)
2632 up_silently_base (count_exp
);
2636 up_command (const char *count_exp
, int from_tty
)
2638 up_silently_base (count_exp
);
2639 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2642 /* Select the frame down one or COUNT_EXP stack levels from the previously
2643 selected frame, and print it briefly. */
2646 down_silently_base (const char *count_exp
)
2648 frame_info_ptr frame
;
2652 count
= -parse_and_eval_long (count_exp
);
2654 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2655 if (count
!= 0 && count_exp
== NULL
)
2657 /* We only do this if COUNT_EXP is not specified. That way
2658 "down" means to really go down (and let me know if that is
2659 impossible), but "down 9999" can be used to mean go all the
2660 way down without getting an error. */
2662 error (_("Bottom (innermost) frame selected; you cannot go down."));
2665 select_frame (frame
);
2669 down_silently_command (const char *count_exp
, int from_tty
)
2671 down_silently_base (count_exp
);
2675 down_command (const char *count_exp
, int from_tty
)
2677 down_silently_base (count_exp
);
2678 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2682 return_command (const char *retval_exp
, int from_tty
)
2684 /* Initialize it just to avoid a GCC false warning. */
2685 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2686 frame_info_ptr thisframe
;
2687 struct gdbarch
*gdbarch
;
2688 struct symbol
*thisfun
;
2689 struct value
*return_value
= NULL
;
2690 struct value
*function
= NULL
;
2691 std::string query_prefix
;
2693 thisframe
= get_selected_frame ("No selected frame.");
2694 thisfun
= get_frame_function (thisframe
);
2695 gdbarch
= get_frame_arch (thisframe
);
2697 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2698 error (_("Can not force return from an inlined function."));
2700 /* Compute the return value. If the computation triggers an error,
2701 let it bail. If the return type can't be handled, set
2702 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2706 expression_up retval_expr
= parse_expression (retval_exp
);
2707 struct type
*return_type
= NULL
;
2709 /* Compute the return value. Should the computation fail, this
2710 call throws an error. */
2711 return_value
= retval_expr
->evaluate ();
2713 /* Cast return value to the return type of the function. Should
2714 the cast fail, this call throws an error. */
2715 if (thisfun
!= NULL
)
2716 return_type
= thisfun
->type ()->target_type ();
2717 if (return_type
== NULL
)
2719 if (retval_expr
->first_opcode () != UNOP_CAST
2720 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2721 error (_("Return value type not available for selected "
2723 "Please use an explicit cast of the value to return."));
2724 return_type
= return_value
->type ();
2726 return_type
= check_typedef (return_type
);
2727 return_value
= value_cast (return_type
, return_value
);
2729 /* Make sure the value is fully evaluated. It may live in the
2730 stack frame we're about to pop. */
2731 if (return_value
->lazy ())
2732 return_value
->fetch_lazy ();
2734 if (thisfun
!= NULL
)
2735 function
= read_var_value (thisfun
, NULL
, thisframe
);
2737 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2738 if (return_type
->code () == TYPE_CODE_VOID
)
2739 /* If the return-type is "void", don't try to find the
2740 return-value's location. However, do still evaluate the
2741 return expression so that, even when the expression result
2742 is discarded, side effects such as "return i++" still
2744 return_value
= NULL
;
2745 else if (thisfun
!= NULL
)
2747 if (is_nocall_function (check_typedef (function
->type ())))
2750 string_printf ("Function '%s' does not follow the target "
2751 "calling convention.\n"
2752 "If you continue, setting the return value "
2753 "will probably lead to unpredictable "
2755 thisfun
->print_name ());
2758 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2759 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2760 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2762 query_prefix
= "The location at which to store the "
2763 "function's return value is unknown.\n"
2764 "If you continue, the return value "
2765 "that you specified will be ignored.\n";
2766 return_value
= NULL
;
2771 /* Does an interactive user really want to do this? Include
2772 information, such as how well GDB can handle the return value, in
2773 the query message. */
2778 if (thisfun
== NULL
)
2779 confirmed
= query (_("%sMake selected stack frame return now? "),
2780 query_prefix
.c_str ());
2783 if (TYPE_NO_RETURN (thisfun
->type ()))
2784 warning (_("Function does not return normally to caller."));
2785 confirmed
= query (_("%sMake %s return now? "),
2786 query_prefix
.c_str (),
2787 thisfun
->print_name ());
2790 error (_("Not confirmed"));
2793 /* Discard the selected frame and all frames inner-to it. */
2794 frame_pop (get_selected_frame (NULL
));
2796 /* Store RETURN_VALUE in the just-returned register set. */
2797 if (return_value
!= NULL
)
2799 struct type
*return_type
= return_value
->type ();
2800 regcache
*regcache
= get_thread_regcache (inferior_thread ());
2801 struct gdbarch
*cache_arch
= regcache
->arch ();
2803 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2804 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2805 gdbarch_return_value_as_value
2806 (cache_arch
, function
, return_type
, regcache
, NULL
/*read*/,
2807 return_value
->contents ().data () /*write*/);
2810 /* If we are at the end of a call dummy now, pop the dummy frame
2812 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2813 frame_pop (get_current_frame ());
2815 select_frame (get_current_frame ());
2816 /* If interactive, print the frame that is now current. */
2818 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2821 /* Find the most inner frame in the current stack for a function called
2822 FUNCTION_NAME. If no matching frame is found return NULL. */
2824 static frame_info_ptr
2825 find_frame_for_function (const char *function_name
)
2827 /* Used to hold the lower and upper addresses for each of the
2828 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2829 struct function_bounds
2831 CORE_ADDR low
, high
;
2833 frame_info_ptr frame
;
2837 gdb_assert (function_name
!= NULL
);
2839 frame
= get_current_frame ();
2840 std::vector
<symtab_and_line
> sals
2841 = decode_line_with_current_source (function_name
,
2842 DECODE_LINE_FUNFIRSTLINE
);
2843 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2844 for (size_t i
= 0; i
< sals
.size (); i
++)
2846 if (sals
[i
].pspace
!= current_program_space
)
2847 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2848 else if (sals
[i
].pc
== 0
2849 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2850 &func_bounds
[i
].low
,
2851 &func_bounds
[i
].high
) == 0)
2852 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2857 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2858 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2859 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2863 frame
= find_relative_frame (frame
, &level
);
2866 while (!found
&& level
== 0);
2874 /* The qcs command line flags for the "frame apply" commands. Keep
2875 this in sync with the "thread apply" commands. */
2877 using qcs_flag_option_def
2878 = gdb::option::flag_option_def
<qcs_flags
>;
2880 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2881 qcs_flag_option_def
{
2882 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2883 N_("Disables printing the frame location information."),
2886 qcs_flag_option_def
{
2887 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2888 N_("Print any error raised by COMMAND and continue."),
2891 qcs_flag_option_def
{
2892 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2893 N_("Silently ignore any errors or empty output produced by COMMAND."),
2897 /* Create an option_def_group array for all the "frame apply" options,
2898 with FLAGS and SET_BT_OPTS as context. */
2900 static inline std::array
<gdb::option::option_def_group
, 2>
2901 make_frame_apply_options_def_group (qcs_flags
*flags
,
2902 set_backtrace_options
*set_bt_opts
)
2905 { {fr_qcs_flags_option_defs
}, flags
},
2906 { {set_backtrace_option_defs
}, set_bt_opts
},
2910 /* Apply a GDB command to all stack frames, or a set of identified frames,
2911 or innermost COUNT frames.
2912 With a negative COUNT, apply command on outermost -COUNT frames.
2914 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2915 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2916 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2917 frame apply all -s p local_var_no_idea_in_which_frame
2918 If a frame has a local variable called
2919 local_var_no_idea_in_which_frame, print frame
2920 and value of local_var_no_idea_in_which_frame.
2921 frame apply all -s -q p local_var_no_idea_in_which_frame
2922 Same as before, but only print the variable value.
2923 frame apply level 2-5 0 4-7 -s p i = i + 1
2924 Adds 1 to the variable i in the specified frames.
2925 Note that i will be incremented twice in
2928 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2929 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2930 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2931 for error messages. */
2934 frame_apply_command_count (const char *which_command
,
2935 const char *cmd
, int from_tty
,
2936 frame_info_ptr trailing
, int count
)
2939 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2941 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2942 gdb::option::process_options
2943 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2945 validate_flags_qcs (which_command
, &flags
);
2947 if (cmd
== NULL
|| *cmd
== '\0')
2948 error (_("Please specify a command to apply on the selected frames"));
2950 /* The below will restore the current inferior/thread/frame.
2951 Usually, only the frame is effectively to be restored.
2952 But in case CMD switches of inferior/thread, better restore
2954 scoped_restore_current_thread restore_thread
;
2956 /* These options are handled quite deep in the unwind machinery, so
2957 we get to pass them down by swapping globals. */
2958 scoped_restore restore_set_backtrace_options
2959 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2961 for (frame_info_ptr fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2968 std::string cmd_result
;
2970 /* In case CMD switches of inferior/thread/frame, the below
2971 restores the inferior/thread/frame. FI can then be
2972 set to the selected frame. */
2973 scoped_restore_current_thread restore_fi_current_frame
;
2975 execute_command_to_string
2976 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
2978 fi
= get_selected_frame (_("frame apply "
2979 "unable to get selected frame."));
2980 if (!flags
.silent
|| cmd_result
.length () > 0)
2983 print_stack_frame (fi
, 1, LOCATION
, 0);
2984 gdb_printf ("%s", cmd_result
.c_str ());
2987 catch (const gdb_exception_error
&ex
)
2989 fi
= get_selected_frame (_("frame apply "
2990 "unable to get selected frame."));
2994 print_stack_frame (fi
, 1, LOCATION
, 0);
2996 gdb_printf ("%s\n", ex
.what ());
3004 /* Completer for the "frame apply ..." commands. */
3007 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3009 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3010 if (gdb::option::complete_options
3011 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3014 complete_nested_command_line (tracker
, text
);
3017 /* Completer for the "frame apply" commands. */
3020 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3021 completion_tracker
&tracker
,
3022 const char *text
, const char */
*word*/
)
3024 /* Do this explicitly because there's an early return below. */
3025 tracker
.set_use_custom_word_point (true);
3027 number_or_range_parser
levels (text
);
3029 /* Skip the LEVEL list to find the options and command args. */
3032 while (!levels
.finished ())
3034 /* Call for effect. */
3035 levels
.get_number ();
3037 if (levels
.in_range ())
3038 levels
.skip_range ();
3041 catch (const gdb_exception_error
&ex
)
3043 /* get_number throws if it parses a negative number, for
3044 example. But a seemingly negative number may be the start of
3045 an option instead. */
3048 const char *cmd
= levels
.cur_tok ();
3052 /* No level list yet. */
3056 /* Check if we're past a valid LEVEL already. */
3057 if (levels
.finished ()
3058 && cmd
> text
&& !isspace (cmd
[-1]))
3061 /* We're past LEVELs, advance word point. */
3062 tracker
.advance_custom_word_point_by (cmd
- text
);
3065 frame_apply_completer (tracker
, text
);
3068 /* Completer for the "frame apply all" command. */
3071 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3072 completion_tracker
&tracker
,
3073 const char *text
, const char */
*word*/
)
3075 frame_apply_completer (tracker
, text
);
3078 /* Completer for the "frame apply COUNT" command. */
3081 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3082 completion_tracker
&tracker
,
3083 const char *text
, const char */
*word*/
)
3085 const char *cmd
= text
;
3087 int count
= get_number_trailer (&cmd
, 0);
3091 /* Check if we're past a valid COUNT already. */
3092 if (cmd
> text
&& !isspace (cmd
[-1]))
3095 /* We're past COUNT, advance word point. */
3096 tracker
.advance_custom_word_point_by (cmd
- text
);
3099 frame_apply_completer (tracker
, text
);
3102 /* Implementation of the "frame apply level" command. */
3105 frame_apply_level_command (const char *cmd
, int from_tty
)
3107 if (!target_has_stack ())
3108 error (_("No stack."));
3110 bool level_found
= false;
3111 const char *levels_str
= cmd
;
3112 number_or_range_parser
levels (levels_str
);
3114 /* Skip the LEVEL list to find the flags and command args. */
3115 while (!levels
.finished ())
3117 /* Call for effect. */
3118 levels
.get_number ();
3121 if (levels
.in_range ())
3122 levels
.skip_range ();
3126 error (_("Missing or invalid LEVEL... argument"));
3128 cmd
= levels
.cur_tok ();
3130 /* Redo the LEVELS parsing, but applying COMMAND. */
3131 levels
.init (levels_str
);
3132 while (!levels
.finished ())
3134 const int level_beg
= levels
.get_number ();
3137 if (levels
.in_range ())
3139 n_frames
= levels
.end_value () - level_beg
+ 1;
3140 levels
.skip_range ();
3145 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3146 leading_innermost_frame (level_beg
), n_frames
);
3150 /* Implementation of the "frame apply all" command. */
3153 frame_apply_all_command (const char *cmd
, int from_tty
)
3155 if (!target_has_stack ())
3156 error (_("No stack."));
3158 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3159 get_current_frame (), INT_MAX
);
3162 /* Implementation of the "frame apply" command. */
3165 frame_apply_command (const char* cmd
, int from_tty
)
3168 frame_info_ptr trailing
;
3170 if (!target_has_stack ())
3171 error (_("No stack."));
3174 error (_("Missing COUNT argument."));
3175 count
= get_number_trailer (&cmd
, 0);
3177 error (_("Invalid COUNT argument."));
3181 trailing
= trailing_outermost_frame (-count
);
3185 trailing
= get_current_frame ();
3187 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3191 /* Implementation of the "faas" command. */
3194 faas_command (const char *cmd
, int from_tty
)
3196 if (cmd
== NULL
|| *cmd
== '\0')
3197 error (_("Please specify a command to apply on all frames"));
3198 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3199 execute_command (expanded
.c_str (), from_tty
);
3203 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3204 matching frame can be found. */
3206 static frame_info_ptr
3207 find_frame_for_address (CORE_ADDR address
)
3212 id
= frame_id_build_wild (address
);
3214 /* If (s)he specifies the frame with an address, he deserves
3215 what (s)he gets. Still, give the highest one that matches.
3216 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3218 for (fid
= get_current_frame ();
3220 fid
= get_prev_frame (fid
))
3222 if (id
== get_frame_id (fid
))
3224 frame_info_ptr prev_frame
;
3228 prev_frame
= get_prev_frame (fid
);
3230 || id
!= get_frame_id (prev_frame
))
3242 /* Commands with a prefix of `frame apply'. */
3243 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3245 /* Commands with a prefix of `frame'. */
3246 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3248 /* Commands with a prefix of `select frame'. */
3249 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3251 /* Commands with a prefix of `info frame'. */
3252 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3254 void _initialize_stack ();
3256 _initialize_stack ()
3258 struct cmd_list_element
*cmd
;
3260 add_com ("return", class_stack
, return_command
, _("\
3261 Make selected stack frame return to its caller.\n\
3262 Control remains in the debugger, but when you continue\n\
3263 execution will resume in the frame above the one now selected.\n\
3264 If an argument is given, it is an expression for the value to return."));
3266 add_com ("up", class_stack
, up_command
, _("\
3267 Select and print stack frame that called this one.\n\
3268 An argument says how many frames up to go."));
3269 add_com ("up-silently", class_support
, up_silently_command
, _("\
3270 Same as the `up' command, but does not print anything.\n\
3271 This is useful in command scripts."));
3273 cmd_list_element
*down_cmd
3274 = add_com ("down", class_stack
, down_command
, _("\
3275 Select and print stack frame called by this one.\n\
3276 An argument says how many frames down to go."));
3277 add_com_alias ("do", down_cmd
, class_stack
, 1);
3278 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3279 add_com ("down-silently", class_support
, down_silently_command
, _("\
3280 Same as the `down' command, but does not print anything.\n\
3281 This is useful in command scripts."));
3283 cmd_list_element
*frame_cmd_el
3284 = add_prefix_cmd ("frame", class_stack
,
3285 &frame_cmd
.base_command
, _("\
3286 Select and print a stack frame.\n\
3287 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3288 A single numerical argument specifies the frame to select."),
3289 &frame_cmd_list
, 1, &cmdlist
);
3290 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3292 #define FRAME_APPLY_OPTION_HELP "\
3293 Prints the frame location information followed by COMMAND output.\n\
3295 By default, an error raised during the execution of COMMAND\n\
3296 aborts \"frame apply\".\n\
3301 const auto frame_apply_opts
3302 = make_frame_apply_options_def_group (nullptr, nullptr);
3304 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3305 Apply a command to a number of frames.\n\
3306 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3307 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3308 FRAME_APPLY_OPTION_HELP
),
3311 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3312 frame_apply_cmd_help
.c_str (),
3313 &frame_apply_cmd_list
, 1,
3315 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3317 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3318 Apply a command to all frames.\n\
3320 Usage: frame apply all [OPTION]... COMMAND\n"
3321 FRAME_APPLY_OPTION_HELP
),
3324 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3325 frame_apply_all_cmd_help
.c_str (),
3326 &frame_apply_cmd_list
);
3327 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3329 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3330 Apply a command to a list of frames.\n\
3332 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3333 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3334 FRAME_APPLY_OPTION_HELP
),
3337 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3338 frame_apply_level_cmd_help
.c_str (),
3339 &frame_apply_cmd_list
);
3340 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3342 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3343 Apply a command to all frames (ignoring errors and empty output).\n\
3344 Usage: faas [OPTION]... COMMAND\n\
3345 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3346 See \"help frame apply all\" for available options."));
3347 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3349 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3351 Select and print a stack frame by stack address.\n\
3353 Usage: frame address STACK-ADDRESS"),
3356 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3358 View a stack frame that might be outside the current backtrace.\n\
3360 Usage: frame view STACK-ADDRESS\n\
3361 frame view STACK-ADDRESS PC-ADDRESS"),
3364 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3366 Select and print a stack frame by function name.\n\
3368 Usage: frame function NAME\n\
3370 The innermost frame that visited function NAME is selected."),
3372 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3375 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3377 Select and print a stack frame by level.\n\
3379 Usage: frame level LEVEL"),
3382 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3383 &select_frame_cmd
.base_command
, _("\
3384 Select a stack frame without printing anything.\n\
3385 A single numerical argument specifies the frame to select."),
3386 &select_frame_cmd_list
, 1, &cmdlist
,
3387 &cli_suppress_notification
.user_selected_context
);
3389 add_cmd_suppress_notification ("address", class_stack
,
3390 &select_frame_cmd
.address
, _("\
3391 Select a stack frame by stack address.\n\
3393 Usage: select-frame address STACK-ADDRESS"),
3394 &select_frame_cmd_list
,
3395 &cli_suppress_notification
.user_selected_context
);
3398 add_cmd_suppress_notification ("view", class_stack
,
3399 &select_frame_cmd
.view
, _("\
3400 Select a stack frame that might be outside the current backtrace.\n\
3402 Usage: select-frame view STACK-ADDRESS\n\
3403 select-frame view STACK-ADDRESS PC-ADDRESS"),
3404 &select_frame_cmd_list
,
3405 &cli_suppress_notification
.user_selected_context
);
3407 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3408 &select_frame_cmd
.function
, _("\
3409 Select a stack frame by function name.\n\
3411 Usage: select-frame function NAME"),
3412 &select_frame_cmd_list
,
3413 &cli_suppress_notification
.user_selected_context
);
3414 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3416 add_cmd_suppress_notification ("level", class_stack
,
3417 &select_frame_cmd
.level
, _("\
3418 Select a stack frame by level.\n\
3420 Usage: select-frame level LEVEL"),
3421 &select_frame_cmd_list
,
3422 &cli_suppress_notification
.user_selected_context
);
3424 const auto backtrace_opts
3425 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3427 static std::string backtrace_help
3428 = gdb::option::build_help (_("\
3429 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3430 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3435 For backward compatibility, the following qualifiers are supported:\n\
3437 full - same as -full option.\n\
3438 no-filters - same as -no-filters option.\n\
3439 hide - same as -hide.\n\
3441 With a negative COUNT, print outermost -COUNT frames."),
3444 cmd_list_element
*backtrace_cmd
3445 = add_com ("backtrace", class_stack
, backtrace_command
,
3446 backtrace_help
.c_str ());
3447 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3449 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3451 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3452 cmd_list_element
*info_stack_cmd
3453 = add_info ("stack", backtrace_command
,
3454 _("Backtrace of the stack, or innermost COUNT frames."));
3455 add_info_alias ("s", info_stack_cmd
, 1);
3457 cmd_list_element
*info_frame_cmd_el
3458 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3459 _("All about the selected stack frame.\n\
3460 With no arguments, displays information about the currently selected stack\n\
3461 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3462 the information is then printed about the specified frame."),
3463 &info_frame_cmd_list
, 1, &infolist
);
3464 add_info_alias ("f", info_frame_cmd_el
, 1);
3466 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3468 Print information about a stack frame selected by stack address.\n\
3470 Usage: info frame address STACK-ADDRESS"),
3471 &info_frame_cmd_list
);
3473 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3475 Print information about a stack frame outside the current backtrace.\n\
3477 Usage: info frame view STACK-ADDRESS\n\
3478 info frame view STACK-ADDRESS PC-ADDRESS"),
3479 &info_frame_cmd_list
);
3481 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3483 Print information about a stack frame selected by function name.\n\
3485 Usage: info frame function NAME"),
3486 &info_frame_cmd_list
);
3487 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3489 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3491 Print information about a stack frame selected by level.\n\
3493 Usage: info frame level LEVEL"),
3494 &info_frame_cmd_list
);
3496 cmd
= add_info ("locals", info_locals_command
,
3497 info_print_args_help (_("\
3498 All local variables of current stack frame or those matching REGEXPs.\n\
3499 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3500 Prints the local variables of the current stack frame.\n"),
3501 _("local variables"),
3503 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3504 cmd
= add_info ("args", info_args_command
,
3505 info_print_args_help (_("\
3506 All argument variables of current stack frame or those matching REGEXPs.\n\
3507 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3508 Prints the argument variables of the current stack frame.\n"),
3509 _("argument variables"),
3511 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3513 /* Install "set print raw frame-arguments", a deprecated spelling of
3514 "set print raw-frame-arguments". */
3515 set_show_commands set_show_frame_args
3516 = add_setshow_boolean_cmd
3517 ("frame-arguments", no_class
,
3518 &user_frame_print_options
.print_raw_frame_arguments
,
3520 Set whether to print frame arguments in raw form."), _("\
3521 Show whether to print frame arguments in raw form."), _("\
3522 If set, frame arguments are printed in raw form, bypassing any\n\
3523 pretty-printers for that value."),
3525 &setprintrawlist
, &showprintrawlist
);
3526 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3528 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3529 &disassemble_next_line
, _("\
3530 Set whether to disassemble next source line or insn when execution stops."),
3532 Show whether to disassemble next source line or insn when execution stops."),
3534 If ON, GDB will display disassembly of the next source line, in addition\n\
3535 to displaying the source line itself. If the next source line cannot\n\
3536 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3537 will display disassembly of next instruction instead of showing the\n\
3539 If AUTO, display disassembly of next instruction only if the source line\n\
3540 cannot be displayed.\n\
3541 If OFF (which is the default), never display the disassembly of the next\n\
3544 show_disassemble_next_line
,
3545 &setlist
, &showlist
);
3546 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3548 gdb::option::add_setshow_cmds_for_options
3549 (class_stack
, &user_frame_print_options
,
3550 frame_print_option_defs
, &setprintlist
, &showprintlist
);