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 (struct ui_out
*uiout
,
224 const frame_print_options
&opts
,
225 frame_info_ptr frame
, int print_level
,
226 enum print_what print_what
, int print_args
,
227 struct symtab_and_line sal
);
229 static frame_info_ptr
find_frame_for_function (const char *);
230 static frame_info_ptr
find_frame_for_address (CORE_ADDR
);
232 /* Zero means do things normally; we are interacting directly with the
233 user. One means print the full filename and linenumber when a
234 frame is printed, and do so in a format emacs18/emacs19.22 can
235 parse. Two means print similar annotations, but in many more
236 cases and in a slightly different syntax. */
238 int annotation_level
= 0;
240 /* Class used to manage tracking the last symtab we displayed. */
242 class last_displayed_symtab_info_type
245 /* True if the cached information is valid. */
246 bool is_valid () const
249 /* Return the cached program_space. If the cache is invalid nullptr is
251 struct program_space
*pspace () const
254 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
256 CORE_ADDR
address () const
257 { return m_address
; }
259 /* Return the cached symtab. If the cache is invalid nullptr is
261 struct symtab
*symtab () const
264 /* Return the cached line number. If the cache is invalid 0 is
269 /* Invalidate the cache, reset all the members to their default value. */
279 /* Store a new set of values in the cache. */
280 void set (struct program_space
*pspace
, CORE_ADDR address
,
281 struct symtab
*symtab
, int line
)
283 gdb_assert (pspace
!= nullptr);
293 /* True when the cache is valid. */
294 bool m_valid
= false;
296 /* The last program space displayed. */
297 struct program_space
*m_pspace
= nullptr;
299 /* The last address displayed. */
300 CORE_ADDR m_address
= 0;
302 /* The last symtab displayed. */
303 struct symtab
*m_symtab
= nullptr;
305 /* The last line number displayed. */
309 /* An actual instance of the cache, holds information about the last symtab
311 static last_displayed_symtab_info_type last_displayed_symtab_info
;
318 frame_show_address (frame_info_ptr frame
,
319 struct symtab_and_line sal
)
321 /* If there is a line number, but no PC, then there is no location
322 information associated with this sal. The only way that should
323 happen is for the call sites of inlined functions (SAL comes from
324 find_frame_sal). Otherwise, we would have some PC range if the
325 SAL came from a line table. */
326 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
328 if (get_next_frame (frame
) == NULL
)
329 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
331 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
335 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
341 print_stack_frame_to_uiout (struct ui_out
*uiout
, frame_info_ptr frame
,
342 int print_level
, enum print_what print_what
,
345 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
347 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
350 /* Show or print a stack frame FRAME briefly. The output is formatted
351 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
352 relative level, function name, argument list, and file name and
353 line number. If the frame's PC is not at the beginning of the
354 source line, the actual PC is printed at the beginning. */
357 print_stack_frame (frame_info_ptr frame
, int print_level
,
358 enum print_what print_what
,
362 /* For mi, always print location and address. */
363 if (current_uiout
->is_mi_like_p ())
364 print_what
= LOC_AND_ADDRESS
;
368 print_frame_info (user_frame_print_options
,
369 frame
, print_level
, print_what
, 1 /* print_args */,
372 set_current_sal_from_frame (frame
);
374 catch (const gdb_exception_error
&e
)
379 /* Print nameless arguments of frame FRAME on STREAM, where START is
380 the offset of the first nameless argument, and NUM is the number of
381 nameless arguments to print. FIRST is nonzero if this is the first
382 argument (not just the first nameless argument). */
385 print_frame_nameless_args (frame_info_ptr frame
, long start
, int num
,
386 int first
, struct ui_file
*stream
)
388 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
389 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
394 for (i
= 0; i
< num
; i
++)
397 argsaddr
= get_frame_args_address (frame
);
400 arg_value
= read_memory_integer (argsaddr
+ start
,
401 sizeof (int), byte_order
);
403 gdb_printf (stream
, ", ");
404 gdb_printf (stream
, "%ld", arg_value
);
406 start
+= sizeof (int);
410 /* Print single argument of inferior function. ARG must be already
413 Errors are printed as if they would be the parameter value. Use zeroed ARG
414 iff it should not be printed according to user settings. */
417 print_frame_arg (const frame_print_options
&fp_opts
,
418 const struct frame_arg
*arg
)
420 struct ui_out
*uiout
= current_uiout
;
424 gdb_assert (!arg
->val
|| !arg
->error
);
425 gdb_assert (arg
->entry_kind
== print_entry_values_no
426 || arg
->entry_kind
== print_entry_values_only
427 || (!uiout
->is_mi_like_p ()
428 && arg
->entry_kind
== print_entry_values_compact
));
430 annotate_arg_emitter arg_emitter
;
431 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
432 gdb_puts (arg
->sym
->print_name (), &stb
);
433 if (arg
->entry_kind
== print_entry_values_compact
)
435 /* It is OK to provide invalid MI-like stream as with
436 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
439 gdb_puts (arg
->sym
->print_name (), &stb
);
441 if (arg
->entry_kind
== print_entry_values_only
442 || arg
->entry_kind
== print_entry_values_compact
)
444 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
445 annotate_arg_name_end ();
449 if (!arg
->val
&& !arg
->error
)
455 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
456 style
= metadata_style
.style ();
462 const struct language_defn
*language
;
463 struct value_print_options vp_opts
;
465 /* Avoid value_print because it will deref ref parameters. We
466 just want to print their addresses. Print ??? for args whose
467 address we do not know. We pass 2 as "recurse" to val_print
468 because our standard indentation here is 4 spaces, and
469 val_print indents 2 for each recurse. */
471 annotate_arg_value (arg
->val
->type ());
473 /* Use the appropriate language to display our symbol, unless the
474 user forced the language to a specific language. */
475 if (language_mode
== language_mode_auto
)
476 language
= language_def (arg
->sym
->language ());
478 language
= current_language
;
480 get_no_prettyformat_print_options (&vp_opts
);
481 vp_opts
.deref_ref
= true;
482 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
484 /* True in "summary" mode, false otherwise. */
486 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
488 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
490 catch (const gdb_exception_error
&except
)
492 stb
.printf (_("<error reading variable: %s>"),
494 style
= metadata_style
.style ();
499 uiout
->field_stream ("value", stb
, style
);
502 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
503 responsible for xfree of ARGP->ERROR. This function never throws an
507 read_frame_local (struct symbol
*sym
, frame_info_ptr frame
,
508 struct frame_arg
*argp
)
516 argp
->val
= read_var_value (sym
, NULL
, frame
);
518 catch (const gdb_exception_error
&except
)
520 argp
->error
.reset (xstrdup (except
.what ()));
524 /* Read in inferior function parameter SYM at FRAME into ARGP. This
525 function never throws an exception. */
528 read_frame_arg (const frame_print_options
&fp_opts
,
529 symbol
*sym
, frame_info_ptr frame
,
530 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
532 struct value
*val
= NULL
, *entryval
= NULL
;
533 char *val_error
= NULL
, *entryval_error
= NULL
;
536 if (fp_opts
.print_entry_values
!= print_entry_values_only
537 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
541 val
= read_var_value (sym
, NULL
, frame
);
543 catch (const gdb_exception_error
&except
)
545 val_error
= (char *) alloca (except
.message
->size () + 1);
546 strcpy (val_error
, except
.what ());
550 if (const symbol_computed_ops
*computed_ops
= sym
->computed_ops ();
551 (computed_ops
!= nullptr
552 && computed_ops
->read_variable_at_entry
!= nullptr
553 && fp_opts
.print_entry_values
!= print_entry_values_no
554 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
|| !val
555 || val
->optimized_out ())))
559 entryval
= computed_ops
->read_variable_at_entry (sym
, frame
);
561 catch (const gdb_exception_error
&except
)
563 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
565 entryval_error
= (char *) alloca (except
.message
->size () + 1);
566 strcpy (entryval_error
, except
.what ());
570 if (entryval
!= NULL
&& entryval
->optimized_out ())
573 if (fp_opts
.print_entry_values
== print_entry_values_compact
574 || fp_opts
.print_entry_values
== print_entry_values_default
)
576 /* For MI do not try to use print_entry_values_compact for ARGP. */
578 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
580 struct type
*type
= val
->type ();
584 if (entryval
->lazy ())
585 entryval
->fetch_lazy ();
587 if (val
->contents_eq (0, entryval
, 0, type
->length ()))
589 /* Initialize it just to avoid a GCC false warning. */
590 struct value
*val_deref
= NULL
, *entryval_deref
;
592 /* DW_AT_call_value does match with the current
593 value. If it is a reference still try to verify if
594 dereferenced DW_AT_call_data_value does not differ. */
598 struct type
*type_deref
;
600 val_deref
= coerce_ref (val
);
601 if (val_deref
->lazy ())
602 val_deref
->fetch_lazy ();
603 type_deref
= val_deref
->type ();
605 entryval_deref
= coerce_ref (entryval
);
606 if (entryval_deref
->lazy ())
607 entryval_deref
->fetch_lazy ();
609 /* If the reference addresses match but dereferenced
610 content does not match print them. */
612 && val_deref
->contents_eq (0,
614 type_deref
->length ()))
617 catch (const gdb_exception_error
&except
)
619 /* If the dereferenced content could not be
620 fetched do not display anything. */
621 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
623 else if (except
.message
!= NULL
)
626 = (char *) alloca (except
.message
->size () + 1);
627 strcpy (entryval_error
, except
.what ());
631 /* Value was not a reference; and its content matches. */
632 if (val
== val_deref
)
640 /* Try to remove possibly duplicate error message for ENTRYARGP even
643 if (val_error
&& entryval_error
644 && strcmp (val_error
, entryval_error
) == 0)
646 entryval_error
= NULL
;
648 /* Do not se VAL_EQUAL as the same error message may be shown for
649 the entry value even if no entry values are present in the
655 if (entryval
== NULL
)
657 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
659 gdb_assert (val
== NULL
);
663 val
= read_var_value (sym
, NULL
, frame
);
665 catch (const gdb_exception_error
&except
)
667 val_error
= (char *) alloca (except
.message
->size () + 1);
668 strcpy (val_error
, except
.what ());
671 if (fp_opts
.print_entry_values
== print_entry_values_only
672 || fp_opts
.print_entry_values
== print_entry_values_both
673 || (fp_opts
.print_entry_values
== print_entry_values_preferred
674 && (!val
|| val
->optimized_out ())))
676 entryval
= value::allocate_optimized_out (sym
->type ());
677 entryval_error
= NULL
;
680 if ((fp_opts
.print_entry_values
== print_entry_values_compact
681 || fp_opts
.print_entry_values
== print_entry_values_if_needed
682 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
683 && (!val
|| val
->optimized_out ()) && entryval
!= NULL
)
691 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
692 if (!val
&& !val_error
)
693 argp
->entry_kind
= print_entry_values_only
;
694 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
695 || fp_opts
.print_entry_values
== print_entry_values_default
)
698 argp
->entry_kind
= print_entry_values_compact
;
699 gdb_assert (!current_uiout
->is_mi_like_p ());
702 argp
->entry_kind
= print_entry_values_no
;
704 entryargp
->sym
= sym
;
705 entryargp
->val
= entryval
;
706 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
707 if (!entryval
&& !entryval_error
)
708 entryargp
->entry_kind
= print_entry_values_no
;
710 entryargp
->entry_kind
= print_entry_values_only
;
713 /* Print the arguments of frame FRAME on STREAM, given the function
714 FUNC running in that frame (as a symbol), where NUM is the number
715 of arguments according to the stack frame (or -1 if the number of
716 arguments is unknown). */
718 /* Note that currently the "number of arguments according to the
719 stack frame" is only known on VAX where i refers to the "number of
720 ints of arguments according to the stack frame". */
723 print_frame_args (const frame_print_options
&fp_opts
,
724 struct symbol
*func
, frame_info_ptr frame
,
725 int num
, struct ui_file
*stream
)
727 struct ui_out
*uiout
= current_uiout
;
729 /* Offset of next stack argument beyond the one we have seen that is
730 at the highest offset, or -1 if we haven't come to a stack
732 long highest_offset
= -1;
733 /* Number of ints of arguments that we have printed so far. */
734 int args_printed
= 0;
735 /* True if we should print arg names. If false, we only indicate
736 the presence of arguments by printing ellipsis. */
738 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
739 /* True if we should print arguments, false otherwise. */
742 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
746 const struct block
*b
= func
->value_block ();
748 for (struct symbol
*sym
: block_iterator_range (b
))
750 struct frame_arg arg
, entryarg
;
754 /* Keep track of the highest stack argument offset seen, and
755 skip over any kinds of symbols we don't care about. */
757 if (!sym
->is_argument ())
767 switch (sym
->aclass ())
772 long current_offset
= sym
->value_longest ();
773 int arg_size
= sym
->type ()->length ();
775 /* Compute address of next argument by adding the size of
776 this argument and rounding to an int boundary. */
778 ((current_offset
+ arg_size
+ sizeof (int) - 1)
779 & ~(sizeof (int) - 1));
781 /* If this is the highest offset seen yet, set
783 if (highest_offset
== -1
784 || (current_offset
> highest_offset
))
785 highest_offset
= current_offset
;
787 /* Add the number of ints we're about to print to
789 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
792 /* We care about types of symbols, but don't need to
793 keep track of stack offsets in them. */
795 case LOC_REGPARM_ADDR
:
797 case LOC_OPTIMIZED_OUT
:
802 /* We have to look up the symbol because arguments can have
803 two entries (one a parameter, one a local) and the one we
804 want is the local, which lookup_symbol will find for us.
805 This includes gcc1 (not gcc2) on SPARC when passing a
806 small structure and gcc2 when the argument type is float
807 and it is passed as a double and converted to float by
808 the prologue (in the latter case the type of the LOC_ARG
809 symbol is double and the type of the LOC_LOCAL symbol is
811 /* But if the parameter name is null, don't try it. Null
812 parameter names occur on the RS/6000, for traceback
813 tables. FIXME, should we even print them? */
815 if (*sym
->linkage_name ())
819 nsym
= lookup_symbol_search_name (sym
->search_name (),
820 b
, SEARCH_VAR_DOMAIN
).symbol
;
821 gdb_assert (nsym
!= NULL
);
822 if (nsym
->aclass () == LOC_REGISTER
823 && !nsym
->is_argument ())
825 /* There is a LOC_ARG/LOC_REGISTER pair. This means
826 that it was passed on the stack and loaded into a
827 register, or passed in a register and stored in a
828 stack slot. GDB 3.x used the LOC_ARG; GDB
829 4.0-4.11 used the LOC_REGISTER.
831 Reasons for using the LOC_ARG:
833 (1) Because find_saved_registers may be slow for
836 (2) Because registers are often re-used and stack
837 slots rarely (never?) are. Therefore using
838 the stack slot is much less likely to print
841 Reasons why we might want to use the LOC_REGISTER:
843 (1) So that the backtrace prints the same value
844 as "print foo". I see no compelling reason
845 why this needs to be the case; having the
846 backtrace print the value which was passed
847 in, and "print foo" print the value as
848 modified within the called function, makes
851 Additional note: It might be nice if "info args"
852 displayed both values.
854 One more note: There is a case with SPARC
855 structure passing where we need to use the
856 LOC_REGISTER, but this is dealt with by creating
857 a single LOC_REGPARM in symbol reading. */
859 /* Leave sym (the LOC_ARG) alone. */
866 /* Print the current arg. */
869 uiout
->wrap_hint (4);
874 arg
.entry_kind
= print_entry_values_no
;
876 entryarg
.entry_kind
= print_entry_values_no
;
879 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
881 if (arg
.entry_kind
!= print_entry_values_only
)
882 print_frame_arg (fp_opts
, &arg
);
884 if (entryarg
.entry_kind
!= print_entry_values_no
)
886 if (arg
.entry_kind
!= print_entry_values_only
)
889 uiout
->wrap_hint (4);
892 print_frame_arg (fp_opts
, &entryarg
);
899 /* Don't print nameless args in situations where we don't know
900 enough about the stack to find them. */
905 if (highest_offset
== -1)
906 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
908 start
= highest_offset
;
910 if (!print_names
&& !first
&& num
> 0)
913 print_frame_nameless_args (frame
, start
, num
- args_printed
,
918 /* Set the current source and line to the location given by frame
919 FRAME, if possible. When CENTER is true, adjust so the relevant
920 line is in the center of the next 'list'. */
923 set_current_sal_from_frame (frame_info_ptr frame
)
925 symtab_and_line sal
= find_frame_sal (frame
);
926 if (sal
.symtab
!= NULL
)
927 set_current_source_symtab_and_line (sal
);
930 /* If ON, GDB will display disassembly of the next source line when
931 execution of the program being debugged stops.
932 If AUTO (which is the default), or there's no line info to determine
933 the source line of the next instruction, display disassembly of next
934 instruction instead. */
936 static enum auto_boolean disassemble_next_line
;
939 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
940 struct cmd_list_element
*c
,
944 _("Debugger's willingness to use "
945 "disassemble-next-line is %s.\n"),
949 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
950 because it will be broken by filter sometime. */
953 do_gdb_disassembly (struct gdbarch
*gdbarch
,
954 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
959 gdb_disassembly (gdbarch
, current_uiout
,
960 DISASSEMBLY_RAW_INSN
, how_many
,
963 catch (const gdb_exception_error
&exception
)
965 /* If an exception was thrown while doing the disassembly, print
966 the error message, to give the user a clue of what happened. */
967 exception_print (gdb_stderr
, exception
);
971 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
972 Value not present indicates to the caller to use default values
973 specific to the command being executed. */
975 static std::optional
<enum print_what
>
976 print_frame_info_to_print_what (const char *print_frame_info
)
978 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
979 if (print_frame_info
== print_frame_info_choices
[i
])
980 return print_frame_info_print_what
[i
];
982 internal_error ("Unexpected print frame-info value `%s'.",
986 /* Print the PC from FRAME, plus any flags, to UIOUT. */
989 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info_ptr frame
,
992 uiout
->field_core_addr ("addr", gdbarch
, pc
);
994 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
998 uiout
->field_string ("addr_flags", flags
);
1006 get_user_print_what_frame_info (std::optional
<enum print_what
> *what
)
1009 = print_frame_info_to_print_what
1010 (user_frame_print_options
.print_frame_info
);
1013 /* Print information about frame FRAME. The output is format according
1014 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1015 PRINT_WHAT, see enum print_what comments in frame.h.
1016 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1017 != print_frame_info_auto.
1019 Used in "where" output, and to emit breakpoint or step
1023 do_print_frame_info (struct ui_out
*uiout
, const frame_print_options
&fp_opts
,
1024 frame_info_ptr frame
, int print_level
,
1025 enum print_what print_what
, int print_args
,
1026 int set_current_sal
)
1028 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1032 if (!current_uiout
->is_mi_like_p ()
1033 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1035 /* Use the specific frame information desired by the user. */
1036 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1039 if (get_frame_type (frame
) == DUMMY_FRAME
1040 || get_frame_type (frame
) == SIGTRAMP_FRAME
1041 || get_frame_type (frame
) == ARCH_FRAME
)
1043 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1045 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1046 gdbarch
, get_frame_pc (frame
));
1048 /* Do this regardless of SOURCE because we don't have any source
1049 to list for this frame. */
1053 uiout
->field_fmt_signed (2, ui_left
, "level",
1054 frame_relative_level (frame
));
1056 if (uiout
->is_mi_like_p ())
1058 annotate_frame_address ();
1059 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1060 annotate_frame_address_end ();
1063 if (get_frame_type (frame
) == DUMMY_FRAME
)
1065 annotate_function_call ();
1066 uiout
->field_string ("func", "<function called from gdb>",
1067 metadata_style
.style ());
1069 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1071 annotate_signal_handler_caller ();
1072 uiout
->field_string ("func", "<signal handler called>",
1073 metadata_style
.style ());
1075 else if (get_frame_type (frame
) == ARCH_FRAME
)
1077 uiout
->field_string ("func", "<cross-architecture call>",
1078 metadata_style
.style ());
1081 annotate_frame_end ();
1083 /* If disassemble-next-line is set to auto or on output the next
1085 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1086 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1087 do_gdb_disassembly (get_frame_arch (frame
), 1,
1088 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1093 /* If FRAME is not the innermost frame, that normally means that
1094 FRAME->pc points to *after* the call instruction, and we want to
1095 get the line containing the call, never the next line. But if
1096 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1097 next frame was not entered as the result of a call, and we want
1098 to get the line containing FRAME->pc. */
1099 symtab_and_line sal
= find_frame_sal (frame
);
1101 location_print
= (print_what
== LOCATION
1102 || print_what
== SRC_AND_LOC
1103 || print_what
== LOC_AND_ADDRESS
1104 || print_what
== SHORT_LOCATION
);
1105 if (location_print
|| !sal
.symtab
)
1106 print_frame (uiout
, fp_opts
, frame
, print_level
,
1107 print_what
, print_args
, sal
);
1109 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1111 /* If disassemble-next-line is set to auto or on and doesn't have
1112 the line debug messages for $pc, output the next instruction. */
1113 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1114 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1115 && source_print
&& !sal
.symtab
)
1116 do_gdb_disassembly (get_frame_arch (frame
), 1,
1117 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1119 if (source_print
&& sal
.symtab
)
1121 int mid_statement
= ((print_what
== SRC_LINE
)
1122 && frame_show_address (frame
, sal
));
1123 if (annotation_level
> 0
1124 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1125 get_frame_pc (frame
)))
1127 /* The call to ANNOTATE_SOURCE_LINE already printed the
1128 annotation for this source line, so we avoid the two cases
1129 below and do not print the actual source line. The
1130 documentation for annotations makes it clear that the source
1131 line annotation is printed __instead__ of printing the source
1132 line, not as well as.
1134 However, if we fail to print the source line, which usually
1135 means either the source file is missing, or the requested
1136 line is out of range of the file, then we don't print the
1137 source annotation, and will pass through the "normal" print
1138 source line code below, the expectation is that this code
1139 will print an appropriate error. */
1141 else if (deprecated_print_frame_info_listing_hook
)
1142 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1146 struct value_print_options opts
;
1148 get_user_print_options (&opts
);
1149 /* We used to do this earlier, but that is clearly
1150 wrong. This function is used by many different
1151 parts of gdb, including normal_stop in infrun.c,
1152 which uses this to print out the current PC
1153 when we stepi/nexti into the middle of a source
1154 line. Only the command line really wants this
1155 behavior. Other UIs probably would like the
1156 ability to decide for themselves if it is desired. */
1157 if (opts
.addressprint
&& mid_statement
)
1159 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1163 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1166 /* If disassemble-next-line is set to on and there is line debug
1167 messages, output assembly codes for next line. */
1168 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1169 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1172 if (set_current_sal
)
1176 if (get_frame_pc_if_available (frame
, &pc
))
1177 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1179 last_displayed_symtab_info
.invalidate ();
1182 annotate_frame_end ();
1184 gdb_flush (gdb_stdout
);
1187 /* Redirect output to a temporary buffer for the duration
1188 of do_print_frame_info. */
1191 print_frame_info (const frame_print_options
&fp_opts
,
1192 frame_info_ptr frame
, int print_level
,
1193 enum print_what print_what
, int print_args
,
1194 int set_current_sal
)
1196 do_with_buffered_output (do_print_frame_info
, current_uiout
,
1197 fp_opts
, frame
, print_level
, print_what
,
1198 print_args
, set_current_sal
);
1204 clear_last_displayed_sal (void)
1206 last_displayed_symtab_info
.invalidate ();
1212 last_displayed_sal_is_valid (void)
1214 return last_displayed_symtab_info
.is_valid ();
1219 struct program_space
*
1220 get_last_displayed_pspace (void)
1222 return last_displayed_symtab_info
.pspace ();
1228 get_last_displayed_addr (void)
1230 return last_displayed_symtab_info
.address ();
1236 get_last_displayed_symtab (void)
1238 return last_displayed_symtab_info
.symtab ();
1244 get_last_displayed_line (void)
1246 return last_displayed_symtab_info
.line ();
1252 get_last_displayed_sal ()
1254 symtab_and_line sal
;
1256 if (last_displayed_symtab_info
.is_valid ())
1258 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1259 sal
.pc
= last_displayed_symtab_info
.address ();
1260 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1261 sal
.line
= last_displayed_symtab_info
.line ();
1268 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1269 corresponding to FRAME. */
1271 gdb::unique_xmalloc_ptr
<char>
1272 find_frame_funname (frame_info_ptr frame
, enum language
*funlang
,
1273 struct symbol
**funcp
)
1275 struct symbol
*func
;
1276 gdb::unique_xmalloc_ptr
<char> funname
;
1278 *funlang
= language_unknown
;
1282 func
= get_frame_function (frame
);
1285 const char *print_name
= func
->print_name ();
1287 *funlang
= func
->language ();
1290 if (*funlang
== language_cplus
)
1292 /* It seems appropriate to use print_name() here,
1293 to display the demangled name that we already have
1294 stored in the symbol table, but we stored a version
1295 with DMGL_PARAMS turned on, and here we don't want to
1296 display parameters. So remove the parameters. */
1297 funname
= cp_remove_params (print_name
);
1300 /* If we didn't hit the C++ case above, set *funname
1302 if (funname
== NULL
)
1303 funname
.reset (xstrdup (print_name
));
1307 struct bound_minimal_symbol msymbol
;
1310 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1313 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1314 if (msymbol
.minsym
!= NULL
)
1316 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1317 *funlang
= msymbol
.minsym
->language ();
1325 print_frame (struct ui_out
*uiout
,
1326 const frame_print_options
&fp_opts
,
1327 frame_info_ptr frame
, int print_level
,
1328 enum print_what print_what
, int print_args
,
1329 struct symtab_and_line sal
)
1331 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1332 enum language funlang
= language_unknown
;
1333 struct value_print_options opts
;
1334 struct symbol
*func
;
1338 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1340 gdb::unique_xmalloc_ptr
<char> funname
1341 = find_frame_funname (frame
, &funlang
, &func
);
1343 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1347 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1352 uiout
->field_fmt_signed (2, ui_left
, "level",
1353 frame_relative_level (frame
));
1355 get_user_print_options (&opts
);
1356 if (opts
.addressprint
)
1358 || frame_show_address (frame
, sal
)
1359 || print_what
== LOC_AND_ADDRESS
)
1361 annotate_frame_address ();
1363 print_pc (uiout
, gdbarch
, frame
, pc
);
1365 uiout
->field_string ("addr", "<unavailable>",
1366 metadata_style
.style ());
1367 annotate_frame_address_end ();
1368 uiout
->text (" in ");
1370 annotate_frame_function_name ();
1373 gdb_puts (funname
? funname
.get () : "??", &stb
);
1374 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1375 uiout
->wrap_hint (3);
1376 annotate_frame_args ();
1383 if (gdbarch_frame_num_args_p (gdbarch
))
1385 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1386 gdb_assert (numargs
>= 0);
1392 ui_out_emit_list
list_emitter (uiout
, "args");
1395 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1397 catch (const gdb_exception_error
&e
)
1401 /* FIXME: ARGS must be a list. If one argument is a string it
1402 will have " that will not be properly escaped. */
1407 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1409 const char *filename_display
;
1411 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1412 annotate_frame_source_begin ();
1413 uiout
->wrap_hint (3);
1414 uiout
->text (" at ");
1415 annotate_frame_source_file ();
1416 uiout
->field_string ("file", filename_display
,
1417 file_name_style
.style ());
1418 if (uiout
->is_mi_like_p ())
1420 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1422 uiout
->field_string ("fullname", fullname
);
1424 annotate_frame_source_file_end ();
1426 annotate_frame_source_line ();
1427 uiout
->field_signed ("line", sal
.line
);
1428 annotate_frame_source_end ();
1431 if (print_what
!= SHORT_LOCATION
1432 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1435 = solib_name_from_address (get_frame_program_space (frame
),
1436 get_frame_address_in_block (frame
));
1440 annotate_frame_where ();
1441 uiout
->wrap_hint (2);
1442 uiout
->text (" from ");
1443 uiout
->field_string ("from", lib
, file_name_style
.style ());
1446 if (uiout
->is_mi_like_p ())
1447 uiout
->field_string ("arch",
1448 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1455 /* Completion function for "frame function", "info frame function", and
1456 "select-frame function" commands. */
1459 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1460 completion_tracker
&tracker
,
1461 const char *text
, const char *word
)
1463 /* This is used to complete function names within a stack. It would be
1464 nice if we only offered functions that were actually in the stack.
1465 However, this would mean unwinding the stack to completion, which
1466 could take too long, or on a corrupted stack, possibly not end.
1467 Instead, we offer all symbol names as a safer choice. */
1468 collect_symbol_completion_matches (tracker
,
1469 complete_symbol_mode::EXPRESSION
,
1470 symbol_name_match_type::EXPRESSION
,
1474 /* Core of all the "info frame" sub-commands. Print information about a
1475 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1476 frame specification, they just entered 'info frame'. If the user did
1477 provide a frame specification (for example 'info frame 0', 'info frame
1478 level 1') then SELECTED_FRAME_P will be false. */
1481 info_frame_command_core (frame_info_ptr fi
, bool selected_frame_p
)
1483 struct symbol
*func
;
1485 frame_info_ptr calling_frame_info
;
1487 const char *funname
= 0;
1488 enum language funlang
= language_unknown
;
1489 const char *pc_regname
;
1490 struct gdbarch
*gdbarch
;
1493 /* Initialize it to avoid "may be used uninitialized" warning. */
1494 CORE_ADDR caller_pc
= 0;
1495 int caller_pc_p
= 0;
1497 gdbarch
= get_frame_arch (fi
);
1499 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1500 is not a good name. */
1501 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1502 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1503 easily not match that of the internal value returned by
1505 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1507 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1508 architectures will often have a hardware register called "pc",
1509 and that register's value, again, can easily not match
1513 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1514 func
= get_frame_function (fi
);
1515 symtab_and_line sal
= find_frame_sal (fi
);
1517 gdb::unique_xmalloc_ptr
<char> func_only
;
1520 funname
= func
->print_name ();
1521 funlang
= func
->language ();
1522 if (funlang
== language_cplus
)
1524 /* It seems appropriate to use print_name() here,
1525 to display the demangled name that we already have
1526 stored in the symbol table, but we stored a version
1527 with DMGL_PARAMS turned on, and here we don't want to
1528 display parameters. So remove the parameters. */
1529 func_only
= cp_remove_params (funname
);
1532 funname
= func_only
.get ();
1535 else if (frame_pc_p
)
1537 struct bound_minimal_symbol msymbol
;
1539 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1540 if (msymbol
.minsym
!= NULL
)
1542 funname
= msymbol
.minsym
->print_name ();
1543 funlang
= msymbol
.minsym
->language ();
1546 calling_frame_info
= get_prev_frame (fi
);
1548 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1550 gdb_printf (_("Stack level %d, frame at "),
1551 frame_relative_level (fi
));
1555 gdb_printf (_("Stack frame at "));
1557 gdb_puts (paddress (gdbarch
, get_frame_base (fi
)));
1559 gdb_printf (" %s = ", pc_regname
);
1561 gdb_puts (paddress (gdbarch
, get_frame_pc (fi
)));
1563 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1565 gdb_stdout
->wrap_here (3);
1568 gdb_printf (" in ");
1571 gdb_stdout
->wrap_here (3);
1575 styled_string (file_name_style
.style (),
1576 symtab_to_filename_for_display (sal
.symtab
)),
1579 gdb_stdout
->wrap_here (4);
1580 gdb_printf ("saved %s = ", pc_regname
);
1582 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1583 val_print_not_saved (gdb_stdout
);
1588 caller_pc
= frame_unwind_caller_pc (fi
);
1591 catch (const gdb_exception_error
&ex
)
1595 case NOT_AVAILABLE_ERROR
:
1596 val_print_unavailable (gdb_stdout
);
1598 case OPTIMIZED_OUT_ERROR
:
1599 val_print_not_saved (gdb_stdout
);
1602 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1611 gdb_puts (paddress (gdbarch
, caller_pc
));
1614 if (calling_frame_info
== NULL
)
1616 enum unwind_stop_reason reason
;
1618 reason
= get_frame_unwind_stop_reason (fi
);
1619 if (reason
!= UNWIND_NO_REASON
)
1620 gdb_printf (_(" Outermost frame: %s\n"),
1621 frame_stop_reason_string (fi
));
1623 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1624 gdb_puts (" tail call frame");
1625 else if (get_frame_type (fi
) == INLINE_FRAME
)
1626 gdb_printf (" inlined into frame %d",
1627 frame_relative_level (get_prev_frame (fi
)));
1630 gdb_printf (" called by frame at ");
1631 gdb_puts (paddress (gdbarch
, get_frame_base (calling_frame_info
)));
1633 if (get_next_frame (fi
) && calling_frame_info
)
1635 gdb_stdout
->wrap_here (3);
1636 if (get_next_frame (fi
))
1638 gdb_printf (" caller of frame at ");
1639 gdb_puts (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))));
1641 if (get_next_frame (fi
) || calling_frame_info
)
1645 gdb_printf (" source language %s.\n",
1646 language_str (s
->language ()));
1649 /* Address of the argument list for this frame, or 0. */
1650 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1651 /* Number of args for this frame, or -1 if unknown. */
1655 gdb_printf (" Arglist at unknown address.\n");
1658 gdb_printf (" Arglist at ");
1659 gdb_puts (paddress (gdbarch
, arg_list
));
1662 if (!gdbarch_frame_num_args_p (gdbarch
))
1665 gdb_puts (" args: ");
1669 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1670 gdb_assert (numargs
>= 0);
1672 gdb_puts (" no args.");
1673 else if (numargs
== 1)
1674 gdb_puts (" 1 arg: ");
1676 gdb_printf (" %d args: ", numargs
);
1679 print_frame_args (user_frame_print_options
,
1680 func
, fi
, numargs
, gdb_stdout
);
1685 /* Address of the local variables for this frame, or 0. */
1686 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1689 gdb_printf (" Locals at unknown address,");
1692 gdb_printf (" Locals at ");
1693 gdb_puts (paddress (gdbarch
, arg_list
));
1698 /* Print as much information as possible on the location of all the
1704 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1706 /* The sp is special; what's displayed isn't the save address, but
1707 the value of the previous frame's sp. This is a legacy thing,
1708 at one stage the frame cached the previous frame's SP instead
1709 of its address, hence it was easiest to just display the cached
1713 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1714 gdb_assert (value
!= NULL
);
1716 if (!value
->optimized_out () && value
->entirely_available ())
1718 if (value
->lval () == not_lval
)
1721 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1722 int sp_size
= register_size (gdbarch
, sp_regnum
);
1724 sp
= extract_unsigned_integer
1725 (value
->contents_all ().data (), sp_size
, byte_order
);
1727 gdb_printf (" Previous frame's sp is ");
1728 gdb_puts (paddress (gdbarch
, sp
));
1731 else if (value
->lval () == lval_memory
)
1733 gdb_printf (" Previous frame's sp at ");
1734 gdb_puts (paddress (gdbarch
, value
->address ()));
1737 else if (value
->lval () == lval_register
)
1738 gdb_printf (" Previous frame's sp in %s\n",
1739 gdbarch_register_name (gdbarch
, value
->regnum ()));
1741 release_value (value
);
1744 /* else keep quiet. */
1748 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1749 for (i
= 0; i
< numregs
; i
++)
1751 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1753 enum lval_type lval
;
1759 /* Find out the location of the saved register without
1760 fetching the corresponding value. */
1761 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1762 &lval
, &addr
, &realnum
, NULL
);
1763 /* For moment, only display registers that were saved on the
1765 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1768 gdb_puts (" Saved registers:\n ");
1771 gdb_stdout
->wrap_here (1);
1772 gdb_printf (" %s at ",
1773 gdbarch_register_name (gdbarch
, i
));
1774 gdb_puts (paddress (gdbarch
, addr
));
1778 if (count
|| need_nl
)
1783 /* Return the innermost frame at level LEVEL. */
1785 static frame_info_ptr
1786 leading_innermost_frame (int level
)
1788 frame_info_ptr leading
;
1790 leading
= get_current_frame ();
1792 gdb_assert (level
>= 0);
1794 while (leading
!= nullptr && level
)
1797 leading
= get_prev_frame (leading
);
1804 /* Return the starting frame needed to handle COUNT outermost frames. */
1806 static frame_info_ptr
1807 trailing_outermost_frame (int count
)
1809 frame_info_ptr current
;
1810 frame_info_ptr trailing
;
1812 trailing
= get_current_frame ();
1814 gdb_assert (count
> 0);
1817 while (current
!= nullptr && count
--)
1820 current
= get_prev_frame (current
);
1823 /* Will stop when CURRENT reaches the top of the stack.
1824 TRAILING will be COUNT below it. */
1825 while (current
!= nullptr)
1828 trailing
= get_prev_frame (trailing
);
1829 current
= get_prev_frame (current
);
1835 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1839 select_frame_command_core (frame_info_ptr fi
, bool ignored
)
1841 frame_info_ptr prev_frame
= get_selected_frame ();
1843 if (get_selected_frame () != prev_frame
)
1844 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1847 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1848 means we change frame send out a change notification (otherwise, just
1849 reprint the current frame summary). */
1852 frame_command_core (frame_info_ptr fi
, bool ignored
)
1854 frame_info_ptr prev_frame
= get_selected_frame ();
1856 if (get_selected_frame () != prev_frame
)
1857 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1859 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1862 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1863 common set of sub-commands that allow a specific frame to be selected.
1864 All of the sub-command functions are static methods within this class
1865 template which is then instantiated below. The template parameter is a
1866 callback used to implement the functionality of the base command
1867 ('frame', 'select-frame', or 'info frame').
1869 In the template parameter FI is the frame being selected. The
1870 SELECTED_FRAME_P flag is true if the frame being selected was done by
1871 default, which happens when the user uses the base command with no
1872 arguments. For example the commands 'info frame', 'select-frame',
1873 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1874 SELECTED_FRAME_P is false. */
1876 template <void (*FPTR
) (frame_info_ptr fi
, bool selected_frame_p
)>
1877 class frame_command_helper
1881 /* The "frame level" family of commands. The ARG is an integer that is
1882 the frame's level in the stack. */
1884 level (const char *arg
, int from_tty
)
1886 int level
= value_as_long (parse_and_eval (arg
));
1888 = find_relative_frame (get_current_frame (), &level
);
1890 error (_("No frame at level %s."), arg
);
1894 /* The "frame address" family of commands. ARG is a stack-pointer
1895 address for an existing frame. This command does not allow new
1896 frames to be created. */
1899 address (const char *arg
, int from_tty
)
1901 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1902 frame_info_ptr fid
= find_frame_for_address (addr
);
1904 error (_("No frame at address %s."), arg
);
1908 /* The "frame view" family of commands. ARG is one or two addresses and
1909 is used to view a frame that might be outside the current backtrace.
1910 The addresses are stack-pointer address, and (optional) pc-address. */
1913 view (const char *args
, int from_tty
)
1918 error (_("Missing address argument to view a frame"));
1920 gdb_argv
argv (args
);
1922 if (argv
.count () == 2)
1926 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1927 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1928 fid
= create_new_frame (addr
[0], addr
[1]);
1932 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1933 fid
= create_new_frame (addr
, false);
1938 /* The "frame function" family of commands. ARG is the name of a
1939 function within the stack, the first function (searching from frame
1940 0) with that name will be selected. */
1943 function (const char *arg
, int from_tty
)
1946 error (_("Missing function name argument"));
1947 frame_info_ptr fid
= find_frame_for_function (arg
);
1949 error (_("No frame for function \"%s\"."), arg
);
1953 /* The "frame" base command, that is, when no sub-command is specified.
1954 If one argument is provided then we assume that this is a frame's
1955 level as historically, this was the supported command syntax that was
1958 If no argument is provided, then the current frame is selected. */
1961 base_command (const char *arg
, int from_tty
)
1964 FPTR (get_selected_frame (_("No stack.")), true);
1966 level (arg
, from_tty
);
1970 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1971 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1973 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1974 static frame_command_helper
<frame_command_core
> frame_cmd
;
1975 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1977 /* Print briefly all stack frames or just the innermost COUNT_EXP
1981 backtrace_command_1 (const frame_print_options
&fp_opts
,
1982 const backtrace_cmd_options
&bt_opts
,
1983 const char *count_exp
, int from_tty
)
1988 int py_start
= 0, py_end
= 0;
1989 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1991 if (!target_has_stack ())
1992 error (_("No stack."));
1996 count
= parse_and_eval_long (count_exp
);
2002 /* The argument to apply_ext_lang_frame_filter is the number
2003 of the final frame to print, and frames start at 0. */
2013 frame_filter_flags flags
= 0;
2016 flags
|= PRINT_LOCALS
;
2018 flags
|= PRINT_HIDE
;
2020 if (!bt_opts
.no_filters
)
2022 enum ext_lang_frame_args arg_type
;
2024 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2026 flags
|= PRINT_MORE_FRAMES
;
2028 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2029 arg_type
= CLI_SCALAR_VALUES
;
2030 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2031 arg_type
= CLI_ALL_VALUES
;
2032 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2033 arg_type
= CLI_PRESENCE
;
2034 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2035 arg_type
= NO_VALUES
;
2039 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2040 arg_type
, current_uiout
,
2044 /* Run the inbuilt backtrace if there are no filters registered, or
2045 "-no-filters" has been specified from the command. */
2046 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2048 frame_info_ptr trailing
;
2050 /* The following code must do two things. First, it must set the
2051 variable TRAILING to the frame from which we should start
2052 printing. Second, it must set the variable count to the number
2053 of frames which we should print, or -1 if all of them. */
2055 if (count_exp
!= NULL
&& count
< 0)
2057 trailing
= trailing_outermost_frame (-count
);
2061 trailing
= get_current_frame ();
2063 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2067 /* Don't use print_stack_frame; if an error() occurs it probably
2068 means further attempts to backtrace would fail (on the other
2069 hand, perhaps the code does or could be fixed to make sure
2070 the frame->prev field gets set to NULL in that case). */
2072 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2073 if ((flags
& PRINT_LOCALS
) != 0)
2074 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2076 /* Save the last frame to check for error conditions. */
2080 /* If we've stopped before the end, mention that. */
2082 gdb_printf (_("(More stack frames follow...)\n"));
2084 /* If we've run out of frames, and the reason appears to be an error
2085 condition, print it. */
2086 if (fi
== NULL
&& trailing
!= NULL
)
2088 enum unwind_stop_reason reason
;
2090 reason
= get_frame_unwind_stop_reason (trailing
);
2091 if (reason
>= UNWIND_FIRST_ERROR
)
2092 gdb_printf (_("Backtrace stopped: %s\n"),
2093 frame_stop_reason_string (trailing
));
2098 /* Create an option_def_group array grouping all the "backtrace"
2099 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2101 static inline std::array
<gdb::option::option_def_group
, 3>
2102 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2103 backtrace_cmd_options
*bt_cmd_opts
,
2104 set_backtrace_options
*set_bt_opts
)
2107 { {frame_print_option_defs
}, fp_opts
},
2108 { {set_backtrace_option_defs
}, set_bt_opts
},
2109 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2113 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2114 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2115 store the parsed qualifiers. */
2118 parse_backtrace_qualifiers (const char *arg
,
2119 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2123 const char *save_arg
= arg
;
2124 std::string this_arg
= extract_arg (&arg
);
2126 if (this_arg
.empty ())
2129 if (startswith ("no-filters", this_arg
))
2131 if (bt_cmd_opts
!= nullptr)
2132 bt_cmd_opts
->no_filters
= true;
2134 else if (startswith ("full", this_arg
))
2136 if (bt_cmd_opts
!= nullptr)
2137 bt_cmd_opts
->full
= true;
2139 else if (startswith ("hide", this_arg
))
2141 if (bt_cmd_opts
!= nullptr)
2142 bt_cmd_opts
->hide
= true;
2146 /* Not a recognized qualifier, so stop. */
2153 backtrace_command (const char *arg
, int from_tty
)
2155 frame_print_options fp_opts
= user_frame_print_options
;
2156 backtrace_cmd_options bt_cmd_opts
;
2157 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2160 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2161 gdb::option::process_options
2162 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2164 /* Parse non-'-'-prefixed qualifiers, for backwards
2168 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2173 /* These options are handled quite deep in the unwind machinery, so
2174 we get to pass them down by swapping globals. */
2175 scoped_restore restore_set_backtrace_options
2176 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2178 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2181 /* Completer for the "backtrace" command. */
2184 backtrace_command_completer (struct cmd_list_element
*ignore
,
2185 completion_tracker
&tracker
,
2186 const char *text
, const char */
*word*/
)
2189 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2190 if (gdb::option::complete_options
2191 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2196 const char *p
= skip_to_space (text
);
2199 static const char *const backtrace_cmd_qualifier_choices
[] = {
2200 "full", "no-filters", "hide", nullptr,
2202 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2205 if (tracker
.have_completions ())
2210 const char *cmd
= parse_backtrace_qualifiers (text
);
2211 tracker
.advance_custom_word_point_by (cmd
- text
);
2216 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2217 expression_completer (ignore
, tracker
, text
, word
);
2220 /* Iterate over the local variables of a block B, calling CB. */
2223 iterate_over_block_locals (const struct block
*b
,
2224 iterate_over_block_arg_local_vars_cb cb
)
2226 for (struct symbol
*sym
: block_iterator_range (b
))
2228 switch (sym
->aclass ())
2235 case LOC_OPTIMIZED_OUT
:
2236 if (sym
->is_argument ())
2238 if (sym
->domain () == COMMON_BLOCK_DOMAIN
)
2240 cb (sym
->print_name (), sym
);
2244 /* Ignore symbols which are not locals. */
2250 /* Iterate over all the local variables in block B, including all its
2251 superblocks, stopping when the top-level block is reached. */
2254 iterate_over_block_local_vars (const struct block
*block
,
2255 iterate_over_block_arg_local_vars_cb cb
)
2259 iterate_over_block_locals (block
, cb
);
2260 /* After handling the function's top-level block, stop. Don't
2261 continue to its superblock, the block of per-file
2263 if (block
->function ())
2265 block
= block
->superblock ();
2269 /* Data to be passed around in the calls to the locals and args
2272 struct print_variable_and_value_data
2274 std::optional
<compiled_regex
> preg
;
2275 std::optional
<compiled_regex
> treg
;
2276 struct frame_id frame_id
;
2278 struct ui_file
*stream
;
2281 void operator() (const char *print_name
, struct symbol
*sym
);
2284 /* The callback for the locals and args iterators. */
2287 print_variable_and_value_data::operator() (const char *print_name
,
2290 frame_info_ptr frame
;
2292 if (preg
.has_value ()
2293 && preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2295 if (treg
.has_value ()
2296 && !treg_matches_sym_type_name (*treg
, sym
))
2298 if (language_def (sym
->language ())->symbol_printing_suppressed (sym
))
2301 frame
= frame_find_by_id (frame_id
);
2304 warning (_("Unable to restore previously selected frame."));
2308 print_variable_and_value (print_name
, sym
, frame
, stream
, num_tabs
);
2313 /* Prepares the regular expression REG from REGEXP.
2314 If REGEXP is NULL, it results in an empty regular expression. */
2317 prepare_reg (const char *regexp
, std::optional
<compiled_regex
> *reg
)
2321 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2323 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2329 /* Print all variables from the innermost up to the function block of FRAME.
2330 Print them with values to STREAM indented by NUM_TABS.
2331 If REGEXP is not NULL, only print local variables whose name
2333 If T_REGEXP is not NULL, only print local variables whose type
2335 If no local variables have been printed and !QUIET, prints a message
2336 explaining why no local variables could be printed. */
2339 print_frame_local_vars (frame_info_ptr frame
,
2341 const char *regexp
, const char *t_regexp
,
2342 int num_tabs
, struct ui_file
*stream
)
2344 struct print_variable_and_value_data cb_data
;
2345 const struct block
*block
;
2348 if (!get_frame_pc_if_available (frame
, &pc
))
2352 _("PC unavailable, cannot determine locals.\n"));
2356 block
= get_frame_block (frame
, 0);
2360 gdb_printf (stream
, "No symbol table info available.\n");
2364 prepare_reg (regexp
, &cb_data
.preg
);
2365 prepare_reg (t_regexp
, &cb_data
.treg
);
2366 cb_data
.frame_id
= get_frame_id (frame
);
2367 cb_data
.num_tabs
= 4 * num_tabs
;
2368 cb_data
.stream
= stream
;
2369 cb_data
.values_printed
= 0;
2371 /* Temporarily change the selected frame to the given FRAME.
2372 This allows routines that rely on the selected frame instead
2373 of being given a frame as parameter to use the correct frame. */
2374 scoped_restore_selected_frame restore_selected_frame
;
2375 select_frame (frame
);
2377 iterate_over_block_local_vars (block
, cb_data
);
2379 if (!cb_data
.values_printed
&& !quiet
)
2381 if (regexp
== NULL
&& t_regexp
== NULL
)
2382 gdb_printf (stream
, _("No locals.\n"));
2384 gdb_printf (stream
, _("No matching locals.\n"));
2388 /* Structure to hold the values of the options used by the 'info
2389 variables' command and other similar commands. These correspond to the
2390 -q and -t options. */
2392 struct info_print_options
2395 std::string type_regexp
;
2398 /* The options used by the 'info locals' and 'info args' commands. */
2400 static const gdb::option::option_def info_print_options_defs
[] = {
2401 gdb::option::boolean_option_def
<info_print_options
> {
2403 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2404 nullptr, /* show_cmd_cb */
2405 nullptr /* set_doc */
2408 gdb::option::string_option_def
<info_print_options
> {
2410 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2411 nullptr, /* show_cmd_cb */
2412 nullptr /* set_doc */
2416 /* Returns the option group used by 'info locals' and 'info args'
2419 static gdb::option::option_def_group
2420 make_info_print_options_def_group (info_print_options
*opts
)
2422 return {{info_print_options_defs
}, opts
};
2425 /* Command completer for 'info locals' and 'info args'. */
2428 info_print_command_completer (struct cmd_list_element
*ignore
,
2429 completion_tracker
&tracker
,
2430 const char *text
, const char * /* word */)
2433 = make_info_print_options_def_group (nullptr);
2434 if (gdb::option::complete_options
2435 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2438 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2439 symbol_completer (ignore
, tracker
, text
, word
);
2442 /* Implement the 'info locals' command. */
2445 info_locals_command (const char *args
, int from_tty
)
2447 info_print_options opts
;
2448 auto grp
= make_info_print_options_def_group (&opts
);
2449 gdb::option::process_options
2450 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2451 if (args
!= nullptr && *args
== '\0')
2454 print_frame_local_vars
2455 (get_selected_frame (_("No frame selected.")),
2457 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2461 /* Iterate over all the argument variables in block B. */
2464 iterate_over_block_arg_vars (const struct block
*b
,
2465 iterate_over_block_arg_local_vars_cb cb
)
2467 for (struct symbol
*sym
: block_iterator_range (b
))
2469 /* Don't worry about things which aren't arguments. */
2470 if (sym
->is_argument ())
2472 /* We have to look up the symbol because arguments can have
2473 two entries (one a parameter, one a local) and the one we
2474 want is the local, which lookup_symbol will find for us.
2475 This includes gcc1 (not gcc2) on the sparc when passing a
2476 small structure and gcc2 when the argument type is float
2477 and it is passed as a double and converted to float by
2478 the prologue (in the latter case the type of the LOC_ARG
2479 symbol is double and the type of the LOC_LOCAL symbol is
2480 float). There are also LOC_ARG/LOC_REGISTER pairs which
2481 are not combined in symbol-reading. */
2484 = lookup_symbol_search_name (sym
->search_name (),
2485 b
, SEARCH_VAR_DOMAIN
).symbol
;
2486 cb (sym
->print_name (), sym2
);
2491 /* Print all argument variables of the function of FRAME.
2492 Print them with values to STREAM.
2493 If REGEXP is not NULL, only print argument variables whose name
2495 If T_REGEXP is not NULL, only print argument variables whose type
2497 If no argument variables have been printed and !QUIET, prints a message
2498 explaining why no argument variables could be printed. */
2501 print_frame_arg_vars (frame_info_ptr frame
,
2503 const char *regexp
, const char *t_regexp
,
2504 struct ui_file
*stream
)
2506 struct print_variable_and_value_data cb_data
;
2507 struct symbol
*func
;
2509 std::optional
<compiled_regex
> preg
;
2510 std::optional
<compiled_regex
> treg
;
2512 if (!get_frame_pc_if_available (frame
, &pc
))
2516 _("PC unavailable, cannot determine args.\n"));
2520 func
= get_frame_function (frame
);
2524 gdb_printf (stream
, _("No symbol table info available.\n"));
2528 prepare_reg (regexp
, &cb_data
.preg
);
2529 prepare_reg (t_regexp
, &cb_data
.treg
);
2530 cb_data
.frame_id
= get_frame_id (frame
);
2531 cb_data
.num_tabs
= 0;
2532 cb_data
.stream
= stream
;
2533 cb_data
.values_printed
= 0;
2535 iterate_over_block_arg_vars (func
->value_block (), cb_data
);
2537 if (!cb_data
.values_printed
&& !quiet
)
2539 if (regexp
== NULL
&& t_regexp
== NULL
)
2540 gdb_printf (stream
, _("No arguments.\n"));
2542 gdb_printf (stream
, _("No matching arguments.\n"));
2546 /* Implement the 'info args' command. */
2549 info_args_command (const char *args
, int from_tty
)
2551 info_print_options opts
;
2552 auto grp
= make_info_print_options_def_group (&opts
);
2553 gdb::option::process_options
2554 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2555 if (args
!= nullptr && *args
== '\0')
2558 print_frame_arg_vars
2559 (get_selected_frame (_("No frame selected.")),
2561 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2565 /* Return the symbol-block in which the selected frame is executing.
2566 Can return zero under various legitimate circumstances.
2568 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2569 code address within the block returned. We use this to decide
2570 which macros are in scope. */
2572 const struct block
*
2573 get_selected_block (CORE_ADDR
*addr_in_block
)
2575 if (!has_stack_frames ())
2578 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2581 /* Find a frame a certain number of levels away from FRAME.
2582 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2583 Positive means go to earlier frames (up); negative, the reverse.
2584 The int that contains the number of levels is counted toward
2585 zero as the frames for those levels are found.
2586 If the top or bottom frame is reached, that frame is returned,
2587 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2588 how much farther the original request asked to go. */
2591 find_relative_frame (frame_info_ptr frame
, int *level_offset_ptr
)
2593 /* Going up is simple: just call get_prev_frame enough times or
2594 until the initial frame is reached. */
2595 while (*level_offset_ptr
> 0)
2597 frame_info_ptr prev
= get_prev_frame (frame
);
2601 (*level_offset_ptr
)--;
2605 /* Going down is just as simple. */
2606 while (*level_offset_ptr
< 0)
2608 frame_info_ptr next
= get_next_frame (frame
);
2612 (*level_offset_ptr
)++;
2619 /* Select the frame up one or COUNT_EXP stack levels from the
2620 previously selected frame, and print it briefly. */
2623 up_silently_base (const char *count_exp
)
2625 frame_info_ptr frame
;
2629 count
= parse_and_eval_long (count_exp
);
2631 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2632 if (count
!= 0 && count_exp
== NULL
)
2633 error (_("Initial frame selected; you cannot go up."));
2634 select_frame (frame
);
2638 up_silently_command (const char *count_exp
, int from_tty
)
2640 up_silently_base (count_exp
);
2644 up_command (const char *count_exp
, int from_tty
)
2646 up_silently_base (count_exp
);
2647 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2650 /* Select the frame down one or COUNT_EXP stack levels from the previously
2651 selected frame, and print it briefly. */
2654 down_silently_base (const char *count_exp
)
2656 frame_info_ptr frame
;
2660 count
= -parse_and_eval_long (count_exp
);
2662 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2663 if (count
!= 0 && count_exp
== NULL
)
2665 /* We only do this if COUNT_EXP is not specified. That way
2666 "down" means to really go down (and let me know if that is
2667 impossible), but "down 9999" can be used to mean go all the
2668 way down without getting an error. */
2670 error (_("Bottom (innermost) frame selected; you cannot go down."));
2673 select_frame (frame
);
2677 down_silently_command (const char *count_exp
, int from_tty
)
2679 down_silently_base (count_exp
);
2683 down_command (const char *count_exp
, int from_tty
)
2685 down_silently_base (count_exp
);
2686 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2690 return_command (const char *retval_exp
, int from_tty
)
2692 /* Initialize it just to avoid a GCC false warning. */
2693 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2694 frame_info_ptr thisframe
;
2695 struct gdbarch
*gdbarch
;
2696 struct symbol
*thisfun
;
2697 struct value
*return_value
= NULL
;
2698 struct value
*function
= NULL
;
2699 std::string query_prefix
;
2701 thisframe
= get_selected_frame ("No selected frame.");
2702 thisfun
= get_frame_function (thisframe
);
2703 gdbarch
= get_frame_arch (thisframe
);
2705 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2706 error (_("Can not force return from an inlined function."));
2708 /* Compute the return value. If the computation triggers an error,
2709 let it bail. If the return type can't be handled, set
2710 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2714 expression_up retval_expr
= parse_expression (retval_exp
);
2715 struct type
*return_type
= NULL
;
2717 /* Compute the return value. Should the computation fail, this
2718 call throws an error. */
2719 return_value
= retval_expr
->evaluate ();
2721 /* Cast return value to the return type of the function. Should
2722 the cast fail, this call throws an error. */
2723 if (thisfun
!= NULL
)
2724 return_type
= thisfun
->type ()->target_type ();
2725 if (return_type
== NULL
)
2727 if (retval_expr
->first_opcode () != UNOP_CAST
2728 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2729 error (_("Return value type not available for selected "
2731 "Please use an explicit cast of the value to return."));
2732 return_type
= return_value
->type ();
2734 return_type
= check_typedef (return_type
);
2735 return_value
= value_cast (return_type
, return_value
);
2737 /* Make sure the value is fully evaluated. It may live in the
2738 stack frame we're about to pop. */
2739 if (return_value
->lazy ())
2740 return_value
->fetch_lazy ();
2742 if (thisfun
!= NULL
)
2743 function
= read_var_value (thisfun
, NULL
, thisframe
);
2745 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2746 if (return_type
->code () == TYPE_CODE_VOID
)
2747 /* If the return-type is "void", don't try to find the
2748 return-value's location. However, do still evaluate the
2749 return expression so that, even when the expression result
2750 is discarded, side effects such as "return i++" still
2752 return_value
= NULL
;
2753 else if (thisfun
!= NULL
)
2755 if (is_nocall_function (check_typedef (function
->type ())))
2758 string_printf ("Function '%s' does not follow the target "
2759 "calling convention.\n"
2760 "If you continue, setting the return value "
2761 "will probably lead to unpredictable "
2763 thisfun
->print_name ());
2766 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2767 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2768 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2770 query_prefix
= "The location at which to store the "
2771 "function's return value is unknown.\n"
2772 "If you continue, the return value "
2773 "that you specified will be ignored.\n";
2774 return_value
= NULL
;
2779 /* Does an interactive user really want to do this? Include
2780 information, such as how well GDB can handle the return value, in
2781 the query message. */
2786 if (thisfun
== NULL
)
2787 confirmed
= query (_("%sMake selected stack frame return now? "),
2788 query_prefix
.c_str ());
2791 if (TYPE_NO_RETURN (thisfun
->type ()))
2792 warning (_("Function does not return normally to caller."));
2793 confirmed
= query (_("%sMake %s return now? "),
2794 query_prefix
.c_str (),
2795 thisfun
->print_name ());
2798 error (_("Not confirmed"));
2801 /* Discard the selected frame and all frames inner-to it. */
2802 frame_pop (get_selected_frame (NULL
));
2804 /* Store RETURN_VALUE in the just-returned register set. */
2805 if (return_value
!= NULL
)
2807 struct type
*return_type
= return_value
->type ();
2808 regcache
*regcache
= get_thread_regcache (inferior_thread ());
2809 struct gdbarch
*cache_arch
= regcache
->arch ();
2811 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2812 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2813 gdbarch_return_value_as_value
2814 (cache_arch
, function
, return_type
, regcache
, NULL
/*read*/,
2815 return_value
->contents ().data () /*write*/);
2818 /* If we are at the end of a call dummy now, pop the dummy frame
2820 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2821 frame_pop (get_current_frame ());
2823 select_frame (get_current_frame ());
2824 /* If interactive, print the frame that is now current. */
2826 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2829 /* Find the most inner frame in the current stack for a function called
2830 FUNCTION_NAME. If no matching frame is found return NULL. */
2832 static frame_info_ptr
2833 find_frame_for_function (const char *function_name
)
2835 /* Used to hold the lower and upper addresses for each of the
2836 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2837 struct function_bounds
2839 CORE_ADDR low
, high
;
2841 frame_info_ptr frame
;
2845 gdb_assert (function_name
!= NULL
);
2847 frame
= get_current_frame ();
2848 std::vector
<symtab_and_line
> sals
2849 = decode_line_with_current_source (function_name
,
2850 DECODE_LINE_FUNFIRSTLINE
);
2851 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2852 for (size_t i
= 0; i
< sals
.size (); i
++)
2854 if (sals
[i
].pspace
!= current_program_space
)
2855 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2856 else if (sals
[i
].pc
== 0
2857 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2858 &func_bounds
[i
].low
,
2859 &func_bounds
[i
].high
) == 0)
2860 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2865 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2866 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2867 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2871 frame
= find_relative_frame (frame
, &level
);
2874 while (!found
&& level
== 0);
2882 /* The qcs command line flags for the "frame apply" commands. Keep
2883 this in sync with the "thread apply" commands. */
2885 using qcs_flag_option_def
2886 = gdb::option::flag_option_def
<qcs_flags
>;
2888 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2889 qcs_flag_option_def
{
2890 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2891 N_("Disables printing the frame location information."),
2894 qcs_flag_option_def
{
2895 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2896 N_("Print any error raised by COMMAND and continue."),
2899 qcs_flag_option_def
{
2900 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2901 N_("Silently ignore any errors or empty output produced by COMMAND."),
2905 /* Create an option_def_group array for all the "frame apply" options,
2906 with FLAGS and SET_BT_OPTS as context. */
2908 static inline std::array
<gdb::option::option_def_group
, 2>
2909 make_frame_apply_options_def_group (qcs_flags
*flags
,
2910 set_backtrace_options
*set_bt_opts
)
2913 { {fr_qcs_flags_option_defs
}, flags
},
2914 { {set_backtrace_option_defs
}, set_bt_opts
},
2918 /* Apply a GDB command to all stack frames, or a set of identified frames,
2919 or innermost COUNT frames.
2920 With a negative COUNT, apply command on outermost -COUNT frames.
2922 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2923 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2924 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2925 frame apply all -s p local_var_no_idea_in_which_frame
2926 If a frame has a local variable called
2927 local_var_no_idea_in_which_frame, print frame
2928 and value of local_var_no_idea_in_which_frame.
2929 frame apply all -s -q p local_var_no_idea_in_which_frame
2930 Same as before, but only print the variable value.
2931 frame apply level 2-5 0 4-7 -s p i = i + 1
2932 Adds 1 to the variable i in the specified frames.
2933 Note that i will be incremented twice in
2936 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2937 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2938 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2939 for error messages. */
2942 frame_apply_command_count (const char *which_command
,
2943 const char *cmd
, int from_tty
,
2944 frame_info_ptr trailing
, int count
)
2947 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2949 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2950 gdb::option::process_options
2951 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2953 validate_flags_qcs (which_command
, &flags
);
2955 if (cmd
== NULL
|| *cmd
== '\0')
2956 error (_("Please specify a command to apply on the selected frames"));
2958 /* The below will restore the current inferior/thread/frame.
2959 Usually, only the frame is effectively to be restored.
2960 But in case CMD switches of inferior/thread, better restore
2962 scoped_restore_current_thread restore_thread
;
2964 /* These options are handled quite deep in the unwind machinery, so
2965 we get to pass them down by swapping globals. */
2966 scoped_restore restore_set_backtrace_options
2967 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2969 for (frame_info_ptr fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2976 std::string cmd_result
;
2978 /* In case CMD switches of inferior/thread/frame, the below
2979 restores the inferior/thread/frame. FI can then be
2980 set to the selected frame. */
2981 scoped_restore_current_thread restore_fi_current_frame
;
2983 execute_command_to_string
2984 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
2986 fi
= get_selected_frame (_("frame apply "
2987 "unable to get selected frame."));
2988 if (!flags
.silent
|| cmd_result
.length () > 0)
2991 print_stack_frame (fi
, 1, LOCATION
, 0);
2992 gdb_printf ("%s", cmd_result
.c_str ());
2995 catch (const gdb_exception_error
&ex
)
2997 fi
= get_selected_frame (_("frame apply "
2998 "unable to get selected frame."));
3002 print_stack_frame (fi
, 1, LOCATION
, 0);
3004 gdb_printf ("%s\n", ex
.what ());
3012 /* Completer for the "frame apply ..." commands. */
3015 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3017 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3018 if (gdb::option::complete_options
3019 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3022 complete_nested_command_line (tracker
, text
);
3025 /* Completer for the "frame apply" commands. */
3028 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3029 completion_tracker
&tracker
,
3030 const char *text
, const char */
*word*/
)
3032 /* Do this explicitly because there's an early return below. */
3033 tracker
.set_use_custom_word_point (true);
3035 number_or_range_parser
levels (text
);
3037 /* Skip the LEVEL list to find the options and command args. */
3040 while (!levels
.finished ())
3042 /* Call for effect. */
3043 levels
.get_number ();
3045 if (levels
.in_range ())
3046 levels
.skip_range ();
3049 catch (const gdb_exception_error
&ex
)
3051 /* get_number throws if it parses a negative number, for
3052 example. But a seemingly negative number may be the start of
3053 an option instead. */
3056 const char *cmd
= levels
.cur_tok ();
3060 /* No level list yet. */
3064 /* Check if we're past a valid LEVEL already. */
3065 if (levels
.finished ()
3066 && cmd
> text
&& !isspace (cmd
[-1]))
3069 /* We're past LEVELs, advance word point. */
3070 tracker
.advance_custom_word_point_by (cmd
- text
);
3073 frame_apply_completer (tracker
, text
);
3076 /* Completer for the "frame apply all" command. */
3079 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3080 completion_tracker
&tracker
,
3081 const char *text
, const char */
*word*/
)
3083 frame_apply_completer (tracker
, text
);
3086 /* Completer for the "frame apply COUNT" command. */
3089 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3090 completion_tracker
&tracker
,
3091 const char *text
, const char */
*word*/
)
3093 const char *cmd
= text
;
3095 int count
= get_number_trailer (&cmd
, 0);
3099 /* Check if we're past a valid COUNT already. */
3100 if (cmd
> text
&& !isspace (cmd
[-1]))
3103 /* We're past COUNT, advance word point. */
3104 tracker
.advance_custom_word_point_by (cmd
- text
);
3107 frame_apply_completer (tracker
, text
);
3110 /* Implementation of the "frame apply level" command. */
3113 frame_apply_level_command (const char *cmd
, int from_tty
)
3115 if (!target_has_stack ())
3116 error (_("No stack."));
3118 bool level_found
= false;
3119 const char *levels_str
= cmd
;
3120 number_or_range_parser
levels (levels_str
);
3122 /* Skip the LEVEL list to find the flags and command args. */
3123 while (!levels
.finished ())
3125 /* Call for effect. */
3126 levels
.get_number ();
3129 if (levels
.in_range ())
3130 levels
.skip_range ();
3134 error (_("Missing or invalid LEVEL... argument"));
3136 cmd
= levels
.cur_tok ();
3138 /* Redo the LEVELS parsing, but applying COMMAND. */
3139 levels
.init (levels_str
);
3140 while (!levels
.finished ())
3142 const int level_beg
= levels
.get_number ();
3145 if (levels
.in_range ())
3147 n_frames
= levels
.end_value () - level_beg
+ 1;
3148 levels
.skip_range ();
3153 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3154 leading_innermost_frame (level_beg
), n_frames
);
3158 /* Implementation of the "frame apply all" command. */
3161 frame_apply_all_command (const char *cmd
, int from_tty
)
3163 if (!target_has_stack ())
3164 error (_("No stack."));
3166 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3167 get_current_frame (), INT_MAX
);
3170 /* Implementation of the "frame apply" command. */
3173 frame_apply_command (const char* cmd
, int from_tty
)
3176 frame_info_ptr trailing
;
3178 if (!target_has_stack ())
3179 error (_("No stack."));
3182 error (_("Missing COUNT argument."));
3183 count
= get_number_trailer (&cmd
, 0);
3185 error (_("Invalid COUNT argument."));
3189 trailing
= trailing_outermost_frame (-count
);
3193 trailing
= get_current_frame ();
3195 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3199 /* Implementation of the "faas" command. */
3202 faas_command (const char *cmd
, int from_tty
)
3204 if (cmd
== NULL
|| *cmd
== '\0')
3205 error (_("Please specify a command to apply on all frames"));
3206 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3207 execute_command (expanded
.c_str (), from_tty
);
3211 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3212 matching frame can be found. */
3214 static frame_info_ptr
3215 find_frame_for_address (CORE_ADDR address
)
3220 id
= frame_id_build_wild (address
);
3222 /* If (s)he specifies the frame with an address, he deserves
3223 what (s)he gets. Still, give the highest one that matches.
3224 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3226 for (fid
= get_current_frame ();
3228 fid
= get_prev_frame (fid
))
3230 if (id
== get_frame_id (fid
))
3232 frame_info_ptr prev_frame
;
3236 prev_frame
= get_prev_frame (fid
);
3238 || id
!= get_frame_id (prev_frame
))
3250 /* Commands with a prefix of `frame apply'. */
3251 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3253 /* Commands with a prefix of `frame'. */
3254 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3256 /* Commands with a prefix of `select frame'. */
3257 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3259 /* Commands with a prefix of `info frame'. */
3260 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3262 void _initialize_stack ();
3264 _initialize_stack ()
3266 struct cmd_list_element
*cmd
;
3268 add_com ("return", class_stack
, return_command
, _("\
3269 Make selected stack frame return to its caller.\n\
3270 Control remains in the debugger, but when you continue\n\
3271 execution will resume in the frame above the one now selected.\n\
3272 If an argument is given, it is an expression for the value to return."));
3274 add_com ("up", class_stack
, up_command
, _("\
3275 Select and print stack frame that called this one.\n\
3276 An argument says how many frames up to go."));
3277 add_com ("up-silently", class_support
, up_silently_command
, _("\
3278 Same as the `up' command, but does not print anything.\n\
3279 This is useful in command scripts."));
3281 cmd_list_element
*down_cmd
3282 = add_com ("down", class_stack
, down_command
, _("\
3283 Select and print stack frame called by this one.\n\
3284 An argument says how many frames down to go."));
3285 add_com_alias ("do", down_cmd
, class_stack
, 1);
3286 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3287 add_com ("down-silently", class_support
, down_silently_command
, _("\
3288 Same as the `down' command, but does not print anything.\n\
3289 This is useful in command scripts."));
3291 cmd_list_element
*frame_cmd_el
3292 = add_prefix_cmd ("frame", class_stack
,
3293 &frame_cmd
.base_command
, _("\
3294 Select and print a stack frame.\n\
3295 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3296 A single numerical argument specifies the frame to select."),
3297 &frame_cmd_list
, 1, &cmdlist
);
3298 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3300 #define FRAME_APPLY_OPTION_HELP "\
3301 Prints the frame location information followed by COMMAND output.\n\
3303 By default, an error raised during the execution of COMMAND\n\
3304 aborts \"frame apply\".\n\
3309 const auto frame_apply_opts
3310 = make_frame_apply_options_def_group (nullptr, nullptr);
3312 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3313 Apply a command to a number of frames.\n\
3314 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3315 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3316 FRAME_APPLY_OPTION_HELP
),
3319 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3320 frame_apply_cmd_help
.c_str (),
3321 &frame_apply_cmd_list
, 1,
3323 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3325 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3326 Apply a command to all frames.\n\
3328 Usage: frame apply all [OPTION]... COMMAND\n"
3329 FRAME_APPLY_OPTION_HELP
),
3332 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3333 frame_apply_all_cmd_help
.c_str (),
3334 &frame_apply_cmd_list
);
3335 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3337 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3338 Apply a command to a list of frames.\n\
3340 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3341 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3342 FRAME_APPLY_OPTION_HELP
),
3345 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3346 frame_apply_level_cmd_help
.c_str (),
3347 &frame_apply_cmd_list
);
3348 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3350 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3351 Apply a command to all frames (ignoring errors and empty output).\n\
3352 Usage: faas [OPTION]... COMMAND\n\
3353 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3354 See \"help frame apply all\" for available options."));
3355 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3357 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3359 Select and print a stack frame by stack address.\n\
3361 Usage: frame address STACK-ADDRESS"),
3364 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3366 View a stack frame that might be outside the current backtrace.\n\
3368 Usage: frame view STACK-ADDRESS\n\
3369 frame view STACK-ADDRESS PC-ADDRESS"),
3372 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3374 Select and print a stack frame by function name.\n\
3376 Usage: frame function NAME\n\
3378 The innermost frame that visited function NAME is selected."),
3380 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3383 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3385 Select and print a stack frame by level.\n\
3387 Usage: frame level LEVEL"),
3390 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3391 &select_frame_cmd
.base_command
, _("\
3392 Select a stack frame without printing anything.\n\
3393 A single numerical argument specifies the frame to select."),
3394 &select_frame_cmd_list
, 1, &cmdlist
,
3395 &cli_suppress_notification
.user_selected_context
);
3397 add_cmd_suppress_notification ("address", class_stack
,
3398 &select_frame_cmd
.address
, _("\
3399 Select a stack frame by stack address.\n\
3401 Usage: select-frame address STACK-ADDRESS"),
3402 &select_frame_cmd_list
,
3403 &cli_suppress_notification
.user_selected_context
);
3406 add_cmd_suppress_notification ("view", class_stack
,
3407 &select_frame_cmd
.view
, _("\
3408 Select a stack frame that might be outside the current backtrace.\n\
3410 Usage: select-frame view STACK-ADDRESS\n\
3411 select-frame view STACK-ADDRESS PC-ADDRESS"),
3412 &select_frame_cmd_list
,
3413 &cli_suppress_notification
.user_selected_context
);
3415 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3416 &select_frame_cmd
.function
, _("\
3417 Select a stack frame by function name.\n\
3419 Usage: select-frame function NAME"),
3420 &select_frame_cmd_list
,
3421 &cli_suppress_notification
.user_selected_context
);
3422 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3424 add_cmd_suppress_notification ("level", class_stack
,
3425 &select_frame_cmd
.level
, _("\
3426 Select a stack frame by level.\n\
3428 Usage: select-frame level LEVEL"),
3429 &select_frame_cmd_list
,
3430 &cli_suppress_notification
.user_selected_context
);
3432 const auto backtrace_opts
3433 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3435 static std::string backtrace_help
3436 = gdb::option::build_help (_("\
3437 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3438 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3443 For backward compatibility, the following qualifiers are supported:\n\
3445 full - same as -full option.\n\
3446 no-filters - same as -no-filters option.\n\
3447 hide - same as -hide.\n\
3449 With a negative COUNT, print outermost -COUNT frames."),
3452 cmd_list_element
*backtrace_cmd
3453 = add_com ("backtrace", class_stack
, backtrace_command
,
3454 backtrace_help
.c_str ());
3455 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3457 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3459 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3460 cmd_list_element
*info_stack_cmd
3461 = add_info ("stack", backtrace_command
,
3462 _("Backtrace of the stack, or innermost COUNT frames."));
3463 add_info_alias ("s", info_stack_cmd
, 1);
3465 cmd_list_element
*info_frame_cmd_el
3466 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3467 _("All about the selected stack frame.\n\
3468 With no arguments, displays information about the currently selected stack\n\
3469 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3470 the information is then printed about the specified frame."),
3471 &info_frame_cmd_list
, 1, &infolist
);
3472 add_info_alias ("f", info_frame_cmd_el
, 1);
3474 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3476 Print information about a stack frame selected by stack address.\n\
3478 Usage: info frame address STACK-ADDRESS"),
3479 &info_frame_cmd_list
);
3481 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3483 Print information about a stack frame outside the current backtrace.\n\
3485 Usage: info frame view STACK-ADDRESS\n\
3486 info frame view STACK-ADDRESS PC-ADDRESS"),
3487 &info_frame_cmd_list
);
3489 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3491 Print information about a stack frame selected by function name.\n\
3493 Usage: info frame function NAME"),
3494 &info_frame_cmd_list
);
3495 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3497 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3499 Print information about a stack frame selected by level.\n\
3501 Usage: info frame level LEVEL"),
3502 &info_frame_cmd_list
);
3504 cmd
= add_info ("locals", info_locals_command
,
3505 info_print_args_help (_("\
3506 All local variables of current stack frame or those matching REGEXPs.\n\
3507 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3508 Prints the local variables of the current stack frame.\n"),
3509 _("local variables"),
3511 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3512 cmd
= add_info ("args", info_args_command
,
3513 info_print_args_help (_("\
3514 All argument variables of current stack frame or those matching REGEXPs.\n\
3515 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3516 Prints the argument variables of the current stack frame.\n"),
3517 _("argument variables"),
3519 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3521 /* Install "set print raw frame-arguments", a deprecated spelling of
3522 "set print raw-frame-arguments". */
3523 set_show_commands set_show_frame_args
3524 = add_setshow_boolean_cmd
3525 ("frame-arguments", no_class
,
3526 &user_frame_print_options
.print_raw_frame_arguments
,
3528 Set whether to print frame arguments in raw form."), _("\
3529 Show whether to print frame arguments in raw form."), _("\
3530 If set, frame arguments are printed in raw form, bypassing any\n\
3531 pretty-printers for that value."),
3533 &setprintrawlist
, &showprintrawlist
);
3534 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3536 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3537 &disassemble_next_line
, _("\
3538 Set whether to disassemble next source line or insn when execution stops."),
3540 Show whether to disassemble next source line or insn when execution stops."),
3542 If ON, GDB will display disassembly of the next source line, in addition\n\
3543 to displaying the source line itself. If the next source line cannot\n\
3544 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3545 will display disassembly of next instruction instead of showing the\n\
3547 If AUTO, display disassembly of next instruction only if the source line\n\
3548 cannot be displayed.\n\
3549 If OFF (which is the default), never display the disassembly of the next\n\
3552 show_disassemble_next_line
,
3553 &setlist
, &showlist
);
3554 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3556 gdb::option::add_setshow_cmds_for_options
3557 (class_stack
, &user_frame_print_options
,
3558 frame_print_option_defs
, &setprintlist
, &showprintlist
);