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/>. */
20 #include "event-top.h"
21 #include "extract-store-integer.h"
26 #include "expression.h"
29 #include "cli/cli-cmds.h"
33 #include "breakpoint.h"
40 #include "dictionary.h"
41 #include "reggroups.h"
45 #include "gdbthread.h"
46 #include "cp-support.h"
48 #include "inline-frame.h"
50 #include "cli/cli-utils.h"
55 #include "extension.h"
56 #include "observable.h"
57 #include "gdbsupport/def-vector.h"
58 #include "cli/cli-option.h"
59 #include "cli/cli-style.h"
60 #include "gdbsupport/buildargv.h"
62 /* The possible choices of "set print frame-arguments", and the value
65 const char print_frame_arguments_all
[] = "all";
66 const char print_frame_arguments_scalars
[] = "scalars";
67 const char print_frame_arguments_none
[] = "none";
68 const char print_frame_arguments_presence
[] = "presence";
70 static const char *const print_frame_arguments_choices
[] =
72 print_frame_arguments_all
,
73 print_frame_arguments_scalars
,
74 print_frame_arguments_none
,
75 print_frame_arguments_presence
,
79 /* The possible choices of "set print frame-info", and the value
82 const char print_frame_info_auto
[] = "auto";
83 const char print_frame_info_source_line
[] = "source-line";
84 const char print_frame_info_location
[] = "location";
85 const char print_frame_info_source_and_location
[] = "source-and-location";
86 const char print_frame_info_location_and_address
[] = "location-and-address";
87 const char print_frame_info_short_location
[] = "short-location";
89 static const char *const print_frame_info_choices
[] =
91 print_frame_info_auto
,
92 print_frame_info_source_line
,
93 print_frame_info_location
,
94 print_frame_info_source_and_location
,
95 print_frame_info_location_and_address
,
96 print_frame_info_short_location
,
100 /* print_frame_info_print_what[i] maps a choice to the corresponding
102 static const std::optional
<enum print_what
> print_frame_info_print_what
[] =
103 {{}, /* Empty value for "auto". */
104 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
106 /* The possible choices of "set print entry-values", and the value
109 const char print_entry_values_no
[] = "no";
110 const char print_entry_values_only
[] = "only";
111 const char print_entry_values_preferred
[] = "preferred";
112 const char print_entry_values_if_needed
[] = "if-needed";
113 const char print_entry_values_both
[] = "both";
114 const char print_entry_values_compact
[] = "compact";
115 const char print_entry_values_default
[] = "default";
116 static const char *const print_entry_values_choices
[] =
118 print_entry_values_no
,
119 print_entry_values_only
,
120 print_entry_values_preferred
,
121 print_entry_values_if_needed
,
122 print_entry_values_both
,
123 print_entry_values_compact
,
124 print_entry_values_default
,
129 frame_print_options user_frame_print_options
;
131 /* Option definitions for some frame-related "set print ..."
134 using boolean_option_def
135 = gdb::option::boolean_option_def
<frame_print_options
>;
136 using enum_option_def
137 = gdb::option::enum_option_def
<frame_print_options
>;
139 static const gdb::option::option_def frame_print_option_defs
[] = {
143 print_entry_values_choices
,
144 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
145 NULL
, /* show_cmd_cb */
146 N_("Set printing of function arguments at function entry."),
147 N_("Show printing of function arguments at function entry."),
148 N_("GDB can sometimes determine the values of function arguments at entry,\n\
149 in addition to their current values. This option tells GDB whether\n\
150 to print the current value, the value at entry (marked as val@entry),\n\
151 or both. Note that one or both of these values may be <optimized out>."),
156 print_frame_arguments_choices
,
157 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
158 NULL
, /* show_cmd_cb */
159 N_("Set printing of non-scalar frame arguments."),
160 N_("Show printing of non-scalar frame arguments."),
165 "raw-frame-arguments",
166 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
167 NULL
, /* show_cmd_cb */
168 N_("Set whether to print frame arguments in raw form."),
169 N_("Show whether to print frame arguments in raw form."),
170 N_("If set, frame arguments are printed in raw form, bypassing any\n\
171 pretty-printers for that value.")
176 print_frame_info_choices
,
177 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
178 NULL
, /* show_cmd_cb */
179 N_("Set printing of frame information."),
180 N_("Show printing of frame information."),
186 /* Options for the "backtrace" command. */
188 struct backtrace_cmd_options
191 bool no_filters
= false;
195 using bt_flag_option_def
196 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
198 static const gdb::option::option_def backtrace_command_option_defs
[] = {
201 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
202 N_("Print values of local variables.")
207 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
208 N_("Prohibit frame filters from executing on a backtrace."),
213 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
214 N_("Causes Python frame filter elided frames to not be printed."),
218 /* Prototypes for local functions. */
220 static void print_frame_local_vars (const frame_info_ptr
&frame
,
222 const char *regexp
, const char *t_regexp
,
223 int num_tabs
, struct ui_file
*stream
);
225 static void print_frame (struct ui_out
*uiout
,
226 const frame_print_options
&opts
,
227 const frame_info_ptr
&frame
, int print_level
,
228 enum print_what print_what
, int print_args
,
229 struct symtab_and_line sal
);
231 static frame_info_ptr
find_frame_for_function (const char *);
232 static frame_info_ptr
find_frame_for_address (CORE_ADDR
);
234 /* Class used to manage tracking the last symtab we displayed. */
236 class last_displayed_symtab_info_type
239 /* True if the cached information is valid. */
240 bool is_valid () const
243 /* Return the cached program_space. If the cache is invalid nullptr is
245 struct program_space
*pspace () const
248 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
250 CORE_ADDR
address () const
251 { return m_address
; }
253 /* Return the cached symtab. If the cache is invalid nullptr is
255 struct symtab
*symtab () const
258 /* Return the cached line number. If the cache is invalid 0 is
263 /* Invalidate the cache, reset all the members to their default value. */
273 /* Store a new set of values in the cache. */
274 void set (struct program_space
*pspace
, CORE_ADDR address
,
275 struct symtab
*symtab
, int line
)
277 gdb_assert (pspace
!= nullptr);
287 /* True when the cache is valid. */
288 bool m_valid
= false;
290 /* The last program space displayed. */
291 struct program_space
*m_pspace
= nullptr;
293 /* The last address displayed. */
294 CORE_ADDR m_address
= 0;
296 /* The last symtab displayed. */
297 struct symtab
*m_symtab
= nullptr;
299 /* The last line number displayed. */
303 /* An actual instance of the cache, holds information about the last symtab
305 static last_displayed_symtab_info_type last_displayed_symtab_info
;
312 frame_show_address (const frame_info_ptr
&frame
,
313 struct symtab_and_line sal
)
315 /* If there is a line number, but no PC, then there is no location
316 information associated with this sal. The only way that should
317 happen is for the call sites of inlined functions (SAL comes from
318 find_frame_sal). Otherwise, we would have some PC range if the
319 SAL came from a line table. */
320 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
322 if (get_next_frame (frame
) == NULL
)
323 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
325 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
329 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
335 print_stack_frame_to_uiout (struct ui_out
*uiout
, const frame_info_ptr
&frame
,
336 int print_level
, enum print_what print_what
,
339 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
341 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
344 /* Show or print a stack frame FRAME briefly. The output is formatted
345 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
346 relative level, function name, argument list, and file name and
347 line number. If the frame's PC is not at the beginning of the
348 source line, the actual PC is printed at the beginning. */
351 print_stack_frame (const frame_info_ptr
&frame
, int print_level
,
352 enum print_what print_what
,
356 /* For mi, always print location and address. */
357 if (current_uiout
->is_mi_like_p ())
358 print_what
= LOC_AND_ADDRESS
;
362 print_frame_info (user_frame_print_options
,
363 frame
, print_level
, print_what
, 1 /* print_args */,
366 set_current_sal_from_frame (frame
);
368 catch (const gdb_exception_error
&e
)
373 /* Print nameless arguments of frame FRAME on STREAM, where START is
374 the offset of the first nameless argument, and NUM is the number of
375 nameless arguments to print. FIRST is nonzero if this is the first
376 argument (not just the first nameless argument). */
379 print_frame_nameless_args (const frame_info_ptr
&frame
, long start
, int num
,
380 int first
, struct ui_file
*stream
)
382 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
383 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
388 for (i
= 0; i
< num
; i
++)
391 argsaddr
= get_frame_args_address (frame
);
394 arg_value
= read_memory_integer (argsaddr
+ start
,
395 sizeof (int), byte_order
);
397 gdb_printf (stream
, ", ");
398 gdb_printf (stream
, "%ld", arg_value
);
400 start
+= sizeof (int);
404 /* Print single argument of inferior function. ARG must be already
407 Errors are printed as if they would be the parameter value. Use zeroed ARG
408 iff it should not be printed according to user settings. */
411 print_frame_arg (const frame_print_options
&fp_opts
,
412 const struct frame_arg
*arg
)
414 struct ui_out
*uiout
= current_uiout
;
418 gdb_assert (!arg
->val
|| !arg
->error
);
419 gdb_assert (arg
->entry_kind
== print_entry_values_no
420 || arg
->entry_kind
== print_entry_values_only
421 || (!uiout
->is_mi_like_p ()
422 && arg
->entry_kind
== print_entry_values_compact
));
424 annotate_arg_emitter arg_emitter
;
425 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
426 gdb_puts (arg
->sym
->print_name (), &stb
);
427 if (arg
->entry_kind
== print_entry_values_compact
)
429 /* It is OK to provide invalid MI-like stream as with
430 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
433 gdb_puts (arg
->sym
->print_name (), &stb
);
435 if (arg
->entry_kind
== print_entry_values_only
436 || arg
->entry_kind
== print_entry_values_compact
)
438 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
439 annotate_arg_name_end ();
443 if (!arg
->val
&& !arg
->error
)
449 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
450 style
= metadata_style
.style ();
456 const struct language_defn
*language
;
457 struct value_print_options vp_opts
;
459 /* Avoid value_print because it will deref ref parameters. We
460 just want to print their addresses. Print ??? for args whose
461 address we do not know. We pass 2 as "recurse" to val_print
462 because our standard indentation here is 4 spaces, and
463 val_print indents 2 for each recurse. */
465 annotate_arg_value (arg
->val
->type ());
467 /* Use the appropriate language to display our symbol, unless the
468 user forced the language to a specific language. */
469 if (language_mode
== language_mode_auto
)
470 language
= language_def (arg
->sym
->language ());
472 language
= current_language
;
474 get_no_prettyformat_print_options (&vp_opts
);
475 vp_opts
.deref_ref
= true;
476 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
478 /* True in "summary" mode, false otherwise. */
480 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
482 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
484 catch (const gdb_exception_error
&except
)
486 stb
.printf (_("<error reading variable: %s>"),
488 style
= metadata_style
.style ();
493 uiout
->field_stream ("value", stb
, style
);
496 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
497 responsible for xfree of ARGP->ERROR. This function never throws an
501 read_frame_local (struct symbol
*sym
, const frame_info_ptr
&frame
,
502 struct frame_arg
*argp
)
510 argp
->val
= read_var_value (sym
, NULL
, frame
);
512 catch (const gdb_exception_error
&except
)
514 argp
->error
.reset (xstrdup (except
.what ()));
518 /* Read in inferior function parameter SYM at FRAME into ARGP. This
519 function never throws an exception. */
522 read_frame_arg (const frame_print_options
&fp_opts
,
523 symbol
*sym
, const frame_info_ptr
&frame
,
524 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
526 struct value
*val
= NULL
, *entryval
= NULL
;
527 char *val_error
= NULL
, *entryval_error
= NULL
;
530 if (fp_opts
.print_entry_values
!= print_entry_values_only
531 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
535 val
= read_var_value (sym
, NULL
, frame
);
537 catch (const gdb_exception_error
&except
)
539 val_error
= (char *) alloca (except
.message
->size () + 1);
540 strcpy (val_error
, except
.what ());
544 if (const symbol_computed_ops
*computed_ops
= sym
->computed_ops ();
545 (computed_ops
!= nullptr
546 && computed_ops
->read_variable_at_entry
!= nullptr
547 && fp_opts
.print_entry_values
!= print_entry_values_no
548 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
|| !val
549 || val
->optimized_out ())))
553 entryval
= computed_ops
->read_variable_at_entry (sym
, frame
);
555 catch (const gdb_exception_error
&except
)
557 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
559 entryval_error
= (char *) alloca (except
.message
->size () + 1);
560 strcpy (entryval_error
, except
.what ());
564 if (entryval
!= NULL
&& entryval
->optimized_out ())
567 if (fp_opts
.print_entry_values
== print_entry_values_compact
568 || fp_opts
.print_entry_values
== print_entry_values_default
)
570 /* For MI do not try to use print_entry_values_compact for ARGP. */
572 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
574 struct type
*type
= val
->type ();
578 if (entryval
->lazy ())
579 entryval
->fetch_lazy ();
581 if (val
->contents_eq (0, entryval
, 0, type
->length ()))
583 /* Initialize it just to avoid a GCC false warning. */
584 struct value
*val_deref
= NULL
, *entryval_deref
;
586 /* DW_AT_call_value does match with the current
587 value. If it is a reference still try to verify if
588 dereferenced DW_AT_call_data_value does not differ. */
592 struct type
*type_deref
;
594 val_deref
= coerce_ref (val
);
595 if (val_deref
->lazy ())
596 val_deref
->fetch_lazy ();
597 type_deref
= val_deref
->type ();
599 entryval_deref
= coerce_ref (entryval
);
600 if (entryval_deref
->lazy ())
601 entryval_deref
->fetch_lazy ();
603 /* If the reference addresses match but dereferenced
604 content does not match print them. */
606 && val_deref
->contents_eq (0,
608 type_deref
->length ()))
611 catch (const gdb_exception_error
&except
)
613 /* If the dereferenced content could not be
614 fetched do not display anything. */
615 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
617 else if (except
.message
!= NULL
)
620 = (char *) alloca (except
.message
->size () + 1);
621 strcpy (entryval_error
, except
.what ());
625 /* Value was not a reference; and its content matches. */
626 if (val
== val_deref
)
634 /* Try to remove possibly duplicate error message for ENTRYARGP even
637 if (val_error
&& entryval_error
638 && strcmp (val_error
, entryval_error
) == 0)
640 entryval_error
= NULL
;
642 /* Do not se VAL_EQUAL as the same error message may be shown for
643 the entry value even if no entry values are present in the
649 if (entryval
== NULL
)
651 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
653 gdb_assert (val
== NULL
);
657 val
= read_var_value (sym
, NULL
, frame
);
659 catch (const gdb_exception_error
&except
)
661 val_error
= (char *) alloca (except
.message
->size () + 1);
662 strcpy (val_error
, except
.what ());
665 if (fp_opts
.print_entry_values
== print_entry_values_only
666 || fp_opts
.print_entry_values
== print_entry_values_both
667 || (fp_opts
.print_entry_values
== print_entry_values_preferred
668 && (!val
|| val
->optimized_out ())))
670 entryval
= value::allocate_optimized_out (sym
->type ());
671 entryval_error
= NULL
;
674 if ((fp_opts
.print_entry_values
== print_entry_values_compact
675 || fp_opts
.print_entry_values
== print_entry_values_if_needed
676 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
677 && (!val
|| val
->optimized_out ()) && entryval
!= NULL
)
685 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
686 if (!val
&& !val_error
)
687 argp
->entry_kind
= print_entry_values_only
;
688 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
689 || fp_opts
.print_entry_values
== print_entry_values_default
)
692 argp
->entry_kind
= print_entry_values_compact
;
693 gdb_assert (!current_uiout
->is_mi_like_p ());
696 argp
->entry_kind
= print_entry_values_no
;
698 entryargp
->sym
= sym
;
699 entryargp
->val
= entryval
;
700 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
701 if (!entryval
&& !entryval_error
)
702 entryargp
->entry_kind
= print_entry_values_no
;
704 entryargp
->entry_kind
= print_entry_values_only
;
707 /* Print the arguments of frame FRAME on STREAM, given the function
708 FUNC running in that frame (as a symbol), where NUM is the number
709 of arguments according to the stack frame (or -1 if the number of
710 arguments is unknown). */
712 /* Note that currently the "number of arguments according to the
713 stack frame" is only known on VAX where i refers to the "number of
714 ints of arguments according to the stack frame". */
717 print_frame_args (const frame_print_options
&fp_opts
,
718 struct symbol
*func
, const frame_info_ptr
&frame
,
719 int num
, struct ui_file
*stream
)
721 struct ui_out
*uiout
= current_uiout
;
723 /* Offset of next stack argument beyond the one we have seen that is
724 at the highest offset, or -1 if we haven't come to a stack
726 long highest_offset
= -1;
727 /* Number of ints of arguments that we have printed so far. */
728 int args_printed
= 0;
729 /* True if we should print arg names. If false, we only indicate
730 the presence of arguments by printing ellipsis. */
732 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
733 /* True if we should print arguments, false otherwise. */
736 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
740 const struct block
*b
= func
->value_block ();
742 for (struct symbol
*sym
: block_iterator_range (b
))
744 struct frame_arg arg
, entryarg
;
748 /* Keep track of the highest stack argument offset seen, and
749 skip over any kinds of symbols we don't care about. */
751 if (!sym
->is_argument ())
761 switch (sym
->aclass ())
766 long current_offset
= sym
->value_longest ();
767 int arg_size
= sym
->type ()->length ();
769 /* Compute address of next argument by adding the size of
770 this argument and rounding to an int boundary. */
772 ((current_offset
+ arg_size
+ sizeof (int) - 1)
773 & ~(sizeof (int) - 1));
775 /* If this is the highest offset seen yet, set
777 if (highest_offset
== -1
778 || (current_offset
> highest_offset
))
779 highest_offset
= current_offset
;
781 /* Add the number of ints we're about to print to
783 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
786 /* We care about types of symbols, but don't need to
787 keep track of stack offsets in them. */
789 case LOC_REGPARM_ADDR
:
791 case LOC_OPTIMIZED_OUT
:
796 /* We have to look up the symbol because arguments can have
797 two entries (one a parameter, one a local) and the one we
798 want is the local, which lookup_symbol will find for us.
799 This includes gcc1 (not gcc2) on SPARC when passing a
800 small structure and gcc2 when the argument type is float
801 and it is passed as a double and converted to float by
802 the prologue (in the latter case the type of the LOC_ARG
803 symbol is double and the type of the LOC_LOCAL symbol is
805 /* But if the parameter name is null, don't try it. Null
806 parameter names occur on the RS/6000, for traceback
807 tables. FIXME, should we even print them? */
809 if (*sym
->linkage_name ())
813 nsym
= lookup_symbol_search_name (sym
->search_name (),
814 b
, SEARCH_VAR_DOMAIN
).symbol
;
815 gdb_assert (nsym
!= NULL
);
816 if (nsym
->aclass () == LOC_REGISTER
817 && !nsym
->is_argument ())
819 /* There is a LOC_ARG/LOC_REGISTER pair. This means
820 that it was passed on the stack and loaded into a
821 register, or passed in a register and stored in a
822 stack slot. GDB 3.x used the LOC_ARG; GDB
823 4.0-4.11 used the LOC_REGISTER.
825 Reasons for using the LOC_ARG:
827 (1) Because find_saved_registers may be slow for
830 (2) Because registers are often re-used and stack
831 slots rarely (never?) are. Therefore using
832 the stack slot is much less likely to print
835 Reasons why we might want to use the LOC_REGISTER:
837 (1) So that the backtrace prints the same value
838 as "print foo". I see no compelling reason
839 why this needs to be the case; having the
840 backtrace print the value which was passed
841 in, and "print foo" print the value as
842 modified within the called function, makes
845 Additional note: It might be nice if "info args"
846 displayed both values.
848 One more note: There is a case with SPARC
849 structure passing where we need to use the
850 LOC_REGISTER, but this is dealt with by creating
851 a single LOC_REGPARM in symbol reading. */
853 /* Leave sym (the LOC_ARG) alone. */
860 /* Print the current arg. */
863 uiout
->wrap_hint (4);
868 arg
.entry_kind
= print_entry_values_no
;
870 entryarg
.entry_kind
= print_entry_values_no
;
873 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
875 if (arg
.entry_kind
!= print_entry_values_only
)
876 print_frame_arg (fp_opts
, &arg
);
878 if (entryarg
.entry_kind
!= print_entry_values_no
)
880 if (arg
.entry_kind
!= print_entry_values_only
)
883 uiout
->wrap_hint (4);
886 print_frame_arg (fp_opts
, &entryarg
);
893 /* Don't print nameless args in situations where we don't know
894 enough about the stack to find them. */
899 if (highest_offset
== -1)
900 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
902 start
= highest_offset
;
904 if (!print_names
&& !first
&& num
> 0)
907 print_frame_nameless_args (frame
, start
, num
- args_printed
,
912 /* Set the current source and line to the location given by frame
913 FRAME, if possible. When CENTER is true, adjust so the relevant
914 line is in the center of the next 'list'. */
917 set_current_sal_from_frame (const frame_info_ptr
&frame
)
919 symtab_and_line sal
= find_frame_sal (frame
);
920 if (sal
.symtab
!= NULL
)
921 set_current_source_symtab_and_line (sal
);
924 /* If ON, GDB will display disassembly of the next source line when
925 execution of the program being debugged stops.
926 If AUTO (which is the default), or there's no line info to determine
927 the source line of the next instruction, display disassembly of next
928 instruction instead. */
930 static enum auto_boolean disassemble_next_line
;
933 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
934 struct cmd_list_element
*c
,
938 _("Debugger's willingness to use "
939 "disassemble-next-line is %s.\n"),
943 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
944 because it will be broken by filter sometime. */
947 do_gdb_disassembly (struct gdbarch
*gdbarch
,
948 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
953 gdb_disassembly (gdbarch
, current_uiout
,
954 DISASSEMBLY_RAW_INSN
, how_many
,
957 catch (const gdb_exception_error
&exception
)
959 /* If an exception was thrown while doing the disassembly, print
960 the error message, to give the user a clue of what happened. */
961 exception_print (gdb_stderr
, exception
);
965 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
966 Value not present indicates to the caller to use default values
967 specific to the command being executed. */
969 static std::optional
<enum print_what
>
970 print_frame_info_to_print_what (const char *print_frame_info
)
972 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
973 if (print_frame_info
== print_frame_info_choices
[i
])
974 return print_frame_info_print_what
[i
];
976 internal_error ("Unexpected print frame-info value `%s'.",
980 /* Print the PC from FRAME, plus any flags, to UIOUT. */
983 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, const frame_info_ptr
&frame
,
986 uiout
->field_core_addr ("addr", gdbarch
, pc
);
988 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
992 uiout
->field_string ("addr_flags", flags
);
1000 get_user_print_what_frame_info (std::optional
<enum print_what
> *what
)
1003 = print_frame_info_to_print_what
1004 (user_frame_print_options
.print_frame_info
);
1007 /* Print information about frame FRAME. The output is format according
1008 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1009 PRINT_WHAT, see enum print_what comments in frame.h.
1010 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1011 != print_frame_info_auto.
1013 Used in "where" output, and to emit breakpoint or step
1017 do_print_frame_info (struct ui_out
*uiout
, const frame_print_options
&fp_opts
,
1018 const frame_info_ptr
&frame
, int print_level
,
1019 enum print_what print_what
, int print_args
,
1020 int set_current_sal
)
1022 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1026 if (!current_uiout
->is_mi_like_p ()
1027 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1029 /* Use the specific frame information desired by the user. */
1030 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1033 if (get_frame_type (frame
) == DUMMY_FRAME
1034 || get_frame_type (frame
) == SIGTRAMP_FRAME
1035 || get_frame_type (frame
) == ARCH_FRAME
)
1037 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1039 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1040 gdbarch
, get_frame_pc (frame
));
1042 /* Do this regardless of SOURCE because we don't have any source
1043 to list for this frame. */
1047 uiout
->field_fmt_signed (2, ui_left
, "level",
1048 frame_relative_level (frame
));
1050 if (uiout
->is_mi_like_p ())
1052 annotate_frame_address ();
1053 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1054 annotate_frame_address_end ();
1057 if (get_frame_type (frame
) == DUMMY_FRAME
)
1059 annotate_function_call ();
1060 uiout
->field_string ("func", "<function called from gdb>",
1061 metadata_style
.style ());
1063 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1065 annotate_signal_handler_caller ();
1066 uiout
->field_string ("func", "<signal handler called>",
1067 metadata_style
.style ());
1069 else if (get_frame_type (frame
) == ARCH_FRAME
)
1071 uiout
->field_string ("func", "<cross-architecture call>",
1072 metadata_style
.style ());
1075 annotate_frame_end ();
1077 /* If disassemble-next-line is set to auto or on output the next
1079 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1080 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1081 do_gdb_disassembly (get_frame_arch (frame
), 1,
1082 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1087 /* If FRAME is not the innermost frame, that normally means that
1088 FRAME->pc points to *after* the call instruction, and we want to
1089 get the line containing the call, never the next line. But if
1090 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1091 next frame was not entered as the result of a call, and we want
1092 to get the line containing FRAME->pc. */
1093 symtab_and_line sal
= find_frame_sal (frame
);
1095 location_print
= (print_what
== LOCATION
1096 || print_what
== SRC_AND_LOC
1097 || print_what
== LOC_AND_ADDRESS
1098 || print_what
== SHORT_LOCATION
);
1099 if (location_print
|| !sal
.symtab
)
1100 print_frame (uiout
, fp_opts
, frame
, print_level
,
1101 print_what
, print_args
, sal
);
1103 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1105 /* If disassemble-next-line is set to auto or on and doesn't have
1106 the line debug messages for $pc, output the next instruction. */
1107 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1108 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1109 && source_print
&& !sal
.symtab
)
1110 do_gdb_disassembly (get_frame_arch (frame
), 1,
1111 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1113 if (source_print
&& sal
.symtab
)
1115 int mid_statement
= ((print_what
== SRC_LINE
)
1116 && frame_show_address (frame
, sal
));
1117 if (annotation_level
> 0
1118 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1119 get_frame_pc (frame
)))
1121 /* The call to ANNOTATE_SOURCE_LINE already printed the
1122 annotation for this source line, so we avoid the two cases
1123 below and do not print the actual source line. The
1124 documentation for annotations makes it clear that the source
1125 line annotation is printed __instead__ of printing the source
1126 line, not as well as.
1128 However, if we fail to print the source line, which usually
1129 means either the source file is missing, or the requested
1130 line is out of range of the file, then we don't print the
1131 source annotation, and will pass through the "normal" print
1132 source line code below, the expectation is that this code
1133 will print an appropriate error. */
1135 else if (deprecated_print_frame_info_listing_hook
)
1136 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1140 struct value_print_options opts
;
1142 get_user_print_options (&opts
);
1143 /* We used to do this earlier, but that is clearly
1144 wrong. This function is used by many different
1145 parts of gdb, including normal_stop in infrun.c,
1146 which uses this to print out the current PC
1147 when we stepi/nexti into the middle of a source
1148 line. Only the command line really wants this
1149 behavior. Other UIs probably would like the
1150 ability to decide for themselves if it is desired. */
1151 if (opts
.addressprint
&& mid_statement
)
1153 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1157 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1160 /* If disassemble-next-line is set to on and there is line debug
1161 messages, output assembly codes for next line. */
1162 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1163 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1166 if (set_current_sal
)
1170 if (get_frame_pc_if_available (frame
, &pc
))
1171 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1173 last_displayed_symtab_info
.invalidate ();
1176 annotate_frame_end ();
1178 gdb_flush (gdb_stdout
);
1181 /* Redirect output to a temporary buffer for the duration
1182 of do_print_frame_info. */
1185 print_frame_info (const frame_print_options
&fp_opts
,
1186 const frame_info_ptr
&frame
, int print_level
,
1187 enum print_what print_what
, int print_args
,
1188 int set_current_sal
)
1190 do_with_buffered_output (do_print_frame_info
, current_uiout
,
1191 fp_opts
, frame
, print_level
, print_what
,
1192 print_args
, set_current_sal
);
1198 clear_last_displayed_sal (void)
1200 last_displayed_symtab_info
.invalidate ();
1206 last_displayed_sal_is_valid (void)
1208 return last_displayed_symtab_info
.is_valid ();
1213 struct program_space
*
1214 get_last_displayed_pspace (void)
1216 return last_displayed_symtab_info
.pspace ();
1222 get_last_displayed_addr (void)
1224 return last_displayed_symtab_info
.address ();
1230 get_last_displayed_symtab (void)
1232 return last_displayed_symtab_info
.symtab ();
1238 get_last_displayed_line (void)
1240 return last_displayed_symtab_info
.line ();
1246 get_last_displayed_sal ()
1248 symtab_and_line sal
;
1250 if (last_displayed_symtab_info
.is_valid ())
1252 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1253 sal
.pc
= last_displayed_symtab_info
.address ();
1254 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1255 sal
.line
= last_displayed_symtab_info
.line ();
1262 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1263 corresponding to FRAME. */
1265 gdb::unique_xmalloc_ptr
<char>
1266 find_frame_funname (const frame_info_ptr
&frame
, enum language
*funlang
,
1267 struct symbol
**funcp
)
1269 struct symbol
*func
;
1270 gdb::unique_xmalloc_ptr
<char> funname
;
1272 *funlang
= language_unknown
;
1276 func
= get_frame_function (frame
);
1279 const char *print_name
= func
->print_name ();
1281 *funlang
= func
->language ();
1284 if (*funlang
== language_cplus
)
1286 /* It seems appropriate to use print_name() here,
1287 to display the demangled name that we already have
1288 stored in the symbol table, but we stored a version
1289 with DMGL_PARAMS turned on, and here we don't want to
1290 display parameters. So remove the parameters. */
1291 funname
= cp_remove_params (print_name
);
1294 /* If we didn't hit the C++ case above, set *funname
1296 if (funname
== NULL
)
1297 funname
.reset (xstrdup (print_name
));
1301 struct bound_minimal_symbol msymbol
;
1304 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1307 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1308 if (msymbol
.minsym
!= NULL
)
1310 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1311 *funlang
= msymbol
.minsym
->language ();
1319 print_frame (struct ui_out
*uiout
,
1320 const frame_print_options
&fp_opts
,
1321 const frame_info_ptr
&frame
, int print_level
,
1322 enum print_what print_what
, int print_args
,
1323 struct symtab_and_line sal
)
1325 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1326 enum language funlang
= language_unknown
;
1327 struct value_print_options opts
;
1328 struct symbol
*func
;
1332 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1334 gdb::unique_xmalloc_ptr
<char> funname
1335 = find_frame_funname (frame
, &funlang
, &func
);
1337 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1341 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1346 uiout
->field_fmt_signed (2, ui_left
, "level",
1347 frame_relative_level (frame
));
1349 get_user_print_options (&opts
);
1350 if (opts
.addressprint
)
1352 || frame_show_address (frame
, sal
)
1353 || print_what
== LOC_AND_ADDRESS
)
1355 annotate_frame_address ();
1357 print_pc (uiout
, gdbarch
, frame
, pc
);
1359 uiout
->field_string ("addr", "<unavailable>",
1360 metadata_style
.style ());
1361 annotate_frame_address_end ();
1362 uiout
->text (" in ");
1364 annotate_frame_function_name ();
1367 gdb_puts (funname
? funname
.get () : "??", &stb
);
1368 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1369 uiout
->wrap_hint (3);
1370 annotate_frame_args ();
1377 if (gdbarch_frame_num_args_p (gdbarch
))
1379 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1380 gdb_assert (numargs
>= 0);
1386 ui_out_emit_list
list_emitter (uiout
, "args");
1389 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1391 catch (const gdb_exception_error
&e
)
1395 /* FIXME: ARGS must be a list. If one argument is a string it
1396 will have " that will not be properly escaped. */
1401 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1403 const char *filename_display
;
1405 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1406 annotate_frame_source_begin ();
1407 uiout
->wrap_hint (3);
1408 uiout
->text (" at ");
1409 annotate_frame_source_file ();
1410 uiout
->field_string ("file", filename_display
,
1411 file_name_style
.style ());
1412 if (uiout
->is_mi_like_p ())
1414 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1416 uiout
->field_string ("fullname", fullname
);
1418 annotate_frame_source_file_end ();
1420 annotate_frame_source_line ();
1421 uiout
->field_signed ("line", sal
.line
);
1422 annotate_frame_source_end ();
1425 if (print_what
!= SHORT_LOCATION
1426 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1429 = solib_name_from_address (get_frame_program_space (frame
),
1430 get_frame_address_in_block (frame
));
1434 annotate_frame_where ();
1435 uiout
->wrap_hint (2);
1436 uiout
->text (" from ");
1437 uiout
->field_string ("from", lib
, file_name_style
.style ());
1440 if (uiout
->is_mi_like_p ())
1441 uiout
->field_string ("arch",
1442 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1449 /* Completion function for "frame function", "info frame function", and
1450 "select-frame function" commands. */
1453 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1454 completion_tracker
&tracker
,
1455 const char *text
, const char *word
)
1457 /* This is used to complete function names within a stack. It would be
1458 nice if we only offered functions that were actually in the stack.
1459 However, this would mean unwinding the stack to completion, which
1460 could take too long, or on a corrupted stack, possibly not end.
1461 Instead, we offer all symbol names as a safer choice. */
1462 collect_symbol_completion_matches (tracker
,
1463 complete_symbol_mode::EXPRESSION
,
1464 symbol_name_match_type::EXPRESSION
,
1468 /* Core of all the "info frame" sub-commands. Print information about a
1469 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1470 frame specification, they just entered 'info frame'. If the user did
1471 provide a frame specification (for example 'info frame 0', 'info frame
1472 level 1') then SELECTED_FRAME_P will be false. */
1475 info_frame_command_core (const frame_info_ptr
&fi
, bool selected_frame_p
)
1477 struct symbol
*func
;
1479 frame_info_ptr calling_frame_info
;
1481 const char *funname
= 0;
1482 enum language funlang
= language_unknown
;
1483 const char *pc_regname
;
1484 struct gdbarch
*gdbarch
;
1487 /* Initialize it to avoid "may be used uninitialized" warning. */
1488 CORE_ADDR caller_pc
= 0;
1489 int caller_pc_p
= 0;
1491 gdbarch
= get_frame_arch (fi
);
1493 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1494 is not a good name. */
1495 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1496 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1497 easily not match that of the internal value returned by
1499 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1501 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1502 architectures will often have a hardware register called "pc",
1503 and that register's value, again, can easily not match
1507 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1508 func
= get_frame_function (fi
);
1509 symtab_and_line sal
= find_frame_sal (fi
);
1511 gdb::unique_xmalloc_ptr
<char> func_only
;
1514 funname
= func
->print_name ();
1515 funlang
= func
->language ();
1516 if (funlang
== language_cplus
)
1518 /* It seems appropriate to use print_name() here,
1519 to display the demangled name that we already have
1520 stored in the symbol table, but we stored a version
1521 with DMGL_PARAMS turned on, and here we don't want to
1522 display parameters. So remove the parameters. */
1523 func_only
= cp_remove_params (funname
);
1526 funname
= func_only
.get ();
1529 else if (frame_pc_p
)
1531 struct bound_minimal_symbol msymbol
;
1533 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1534 if (msymbol
.minsym
!= NULL
)
1536 funname
= msymbol
.minsym
->print_name ();
1537 funlang
= msymbol
.minsym
->language ();
1540 calling_frame_info
= get_prev_frame (fi
);
1542 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1544 gdb_printf (_("Stack level %d, frame at "),
1545 frame_relative_level (fi
));
1549 gdb_printf (_("Stack frame at "));
1551 gdb_puts (paddress (gdbarch
, get_frame_base (fi
)));
1553 gdb_printf (" %s = ", pc_regname
);
1555 gdb_puts (paddress (gdbarch
, get_frame_pc (fi
)));
1557 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1559 gdb_stdout
->wrap_here (3);
1562 gdb_printf (" in ");
1565 gdb_stdout
->wrap_here (3);
1569 styled_string (file_name_style
.style (),
1570 symtab_to_filename_for_display (sal
.symtab
)),
1573 gdb_stdout
->wrap_here (4);
1574 gdb_printf ("saved %s = ", pc_regname
);
1576 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1577 val_print_not_saved (gdb_stdout
);
1582 caller_pc
= frame_unwind_caller_pc (fi
);
1585 catch (const gdb_exception_error
&ex
)
1589 case NOT_AVAILABLE_ERROR
:
1590 val_print_unavailable (gdb_stdout
);
1592 case OPTIMIZED_OUT_ERROR
:
1593 val_print_not_saved (gdb_stdout
);
1596 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1605 gdb_puts (paddress (gdbarch
, caller_pc
));
1608 if (calling_frame_info
== NULL
)
1610 enum unwind_stop_reason reason
;
1612 reason
= get_frame_unwind_stop_reason (fi
);
1613 if (reason
!= UNWIND_NO_REASON
)
1614 gdb_printf (_(" Outermost frame: %s\n"),
1615 frame_stop_reason_string (fi
));
1617 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1618 gdb_puts (" tail call frame");
1619 else if (get_frame_type (fi
) == INLINE_FRAME
)
1620 gdb_printf (" inlined into frame %d",
1621 frame_relative_level (get_prev_frame (fi
)));
1624 gdb_printf (" called by frame at ");
1625 gdb_puts (paddress (gdbarch
, get_frame_base (calling_frame_info
)));
1627 if (get_next_frame (fi
) && calling_frame_info
)
1629 gdb_stdout
->wrap_here (3);
1630 if (get_next_frame (fi
))
1632 gdb_printf (" caller of frame at ");
1633 gdb_puts (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))));
1635 if (get_next_frame (fi
) || calling_frame_info
)
1639 gdb_printf (" source language %s.\n",
1640 language_str (s
->language ()));
1643 /* Address of the argument list for this frame, or 0. */
1644 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1645 /* Number of args for this frame, or -1 if unknown. */
1649 gdb_printf (" Arglist at unknown address.\n");
1652 gdb_printf (" Arglist at ");
1653 gdb_puts (paddress (gdbarch
, arg_list
));
1656 if (!gdbarch_frame_num_args_p (gdbarch
))
1659 gdb_puts (" args: ");
1663 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1664 gdb_assert (numargs
>= 0);
1666 gdb_puts (" no args.");
1667 else if (numargs
== 1)
1668 gdb_puts (" 1 arg: ");
1670 gdb_printf (" %d args: ", numargs
);
1673 print_frame_args (user_frame_print_options
,
1674 func
, fi
, numargs
, gdb_stdout
);
1679 /* Address of the local variables for this frame, or 0. */
1680 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1683 gdb_printf (" Locals at unknown address,");
1686 gdb_printf (" Locals at ");
1687 gdb_puts (paddress (gdbarch
, arg_list
));
1692 /* Print as much information as possible on the location of all the
1698 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1700 /* The sp is special; what's displayed isn't the save address, but
1701 the value of the previous frame's sp. This is a legacy thing,
1702 at one stage the frame cached the previous frame's SP instead
1703 of its address, hence it was easiest to just display the cached
1707 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1708 gdb_assert (value
!= NULL
);
1710 if (!value
->optimized_out () && value
->entirely_available ())
1712 if (value
->lval () == not_lval
)
1715 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1716 int sp_size
= register_size (gdbarch
, sp_regnum
);
1718 sp
= extract_unsigned_integer
1719 (value
->contents_all ().data (), sp_size
, byte_order
);
1721 gdb_printf (" Previous frame's sp is ");
1722 gdb_puts (paddress (gdbarch
, sp
));
1725 else if (value
->lval () == lval_memory
)
1727 gdb_printf (" Previous frame's sp at ");
1728 gdb_puts (paddress (gdbarch
, value
->address ()));
1731 else if (value
->lval () == lval_register
)
1732 gdb_printf (" Previous frame's sp in %s\n",
1733 gdbarch_register_name (gdbarch
, value
->regnum ()));
1735 release_value (value
);
1738 /* else keep quiet. */
1742 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1743 for (i
= 0; i
< numregs
; i
++)
1745 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1747 enum lval_type lval
;
1753 /* Find out the location of the saved register without
1754 fetching the corresponding value. */
1755 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1756 &lval
, &addr
, &realnum
, NULL
);
1757 /* For moment, only display registers that were saved on the
1759 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1762 gdb_puts (" Saved registers:\n ");
1765 gdb_stdout
->wrap_here (1);
1766 gdb_printf (" %s at ",
1767 gdbarch_register_name (gdbarch
, i
));
1768 gdb_puts (paddress (gdbarch
, addr
));
1772 if (count
|| need_nl
)
1777 /* Return the innermost frame at level LEVEL. */
1779 static frame_info_ptr
1780 leading_innermost_frame (int level
)
1782 frame_info_ptr leading
;
1784 leading
= get_current_frame ();
1786 gdb_assert (level
>= 0);
1788 while (leading
!= nullptr && level
)
1791 leading
= get_prev_frame (leading
);
1798 /* Return the starting frame needed to handle COUNT outermost frames. */
1800 static frame_info_ptr
1801 trailing_outermost_frame (int count
)
1803 frame_info_ptr current
;
1804 frame_info_ptr trailing
;
1806 trailing
= get_current_frame ();
1808 gdb_assert (count
> 0);
1811 while (current
!= nullptr && count
--)
1814 current
= get_prev_frame (current
);
1817 /* Will stop when CURRENT reaches the top of the stack.
1818 TRAILING will be COUNT below it. */
1819 while (current
!= nullptr)
1822 trailing
= get_prev_frame (trailing
);
1823 current
= get_prev_frame (current
);
1829 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1833 select_frame_command_core (const frame_info_ptr
&fi
, bool ignored
)
1835 frame_info_ptr prev_frame
= get_selected_frame ();
1837 if (get_selected_frame () != prev_frame
)
1838 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1841 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1842 means we change frame send out a change notification (otherwise, just
1843 reprint the current frame summary). */
1846 frame_command_core (const frame_info_ptr
&fi
, bool ignored
)
1848 frame_info_ptr prev_frame
= get_selected_frame ();
1850 if (get_selected_frame () != prev_frame
)
1851 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1853 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1856 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1857 common set of sub-commands that allow a specific frame to be selected.
1858 All of the sub-command functions are static methods within this class
1859 template which is then instantiated below. The template parameter is a
1860 callback used to implement the functionality of the base command
1861 ('frame', 'select-frame', or 'info frame').
1863 In the template parameter FI is the frame being selected. The
1864 SELECTED_FRAME_P flag is true if the frame being selected was done by
1865 default, which happens when the user uses the base command with no
1866 arguments. For example the commands 'info frame', 'select-frame',
1867 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1868 SELECTED_FRAME_P is false. */
1870 template <void (*FPTR
) (const frame_info_ptr
&fi
, bool selected_frame_p
)>
1871 class frame_command_helper
1875 /* The "frame level" family of commands. The ARG is an integer that is
1876 the frame's level in the stack. */
1878 level (const char *arg
, int from_tty
)
1880 int level
= value_as_long (parse_and_eval (arg
));
1882 = find_relative_frame (get_current_frame (), &level
);
1884 error (_("No frame at level %s."), arg
);
1888 /* The "frame address" family of commands. ARG is a stack-pointer
1889 address for an existing frame. This command does not allow new
1890 frames to be created. */
1893 address (const char *arg
, int from_tty
)
1895 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1896 frame_info_ptr fid
= find_frame_for_address (addr
);
1898 error (_("No frame at address %s."), arg
);
1902 /* The "frame view" family of commands. ARG is one or two addresses and
1903 is used to view a frame that might be outside the current backtrace.
1904 The addresses are stack-pointer address, and (optional) pc-address. */
1907 view (const char *args
, int from_tty
)
1912 error (_("Missing address argument to view a frame"));
1914 gdb_argv
argv (args
);
1916 if (argv
.count () == 2)
1920 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1921 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1922 fid
= create_new_frame (addr
[0], addr
[1]);
1926 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1927 fid
= create_new_frame (addr
, false);
1932 /* The "frame function" family of commands. ARG is the name of a
1933 function within the stack, the first function (searching from frame
1934 0) with that name will be selected. */
1937 function (const char *arg
, int from_tty
)
1940 error (_("Missing function name argument"));
1941 frame_info_ptr fid
= find_frame_for_function (arg
);
1943 error (_("No frame for function \"%s\"."), arg
);
1947 /* The "frame" base command, that is, when no sub-command is specified.
1948 If one argument is provided then we assume that this is a frame's
1949 level as historically, this was the supported command syntax that was
1952 If no argument is provided, then the current frame is selected. */
1955 base_command (const char *arg
, int from_tty
)
1958 FPTR (get_selected_frame (_("No stack.")), true);
1960 level (arg
, from_tty
);
1964 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1965 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1967 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1968 static frame_command_helper
<frame_command_core
> frame_cmd
;
1969 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1971 /* Print briefly all stack frames or just the innermost COUNT_EXP
1975 backtrace_command_1 (const frame_print_options
&fp_opts
,
1976 const backtrace_cmd_options
&bt_opts
,
1977 const char *count_exp
, int from_tty
)
1982 int py_start
= 0, py_end
= 0;
1983 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1985 if (!target_has_stack ())
1986 error (_("No stack."));
1990 count
= parse_and_eval_long (count_exp
);
1996 /* The argument to apply_ext_lang_frame_filter is the number
1997 of the final frame to print, and frames start at 0. */
2007 frame_filter_flags flags
= 0;
2010 flags
|= PRINT_LOCALS
;
2012 flags
|= PRINT_HIDE
;
2013 if (fp_opts
.print_raw_frame_arguments
)
2014 flags
|= PRINT_RAW_FRAME_ARGUMENTS
;
2016 if (!bt_opts
.no_filters
)
2018 enum ext_lang_frame_args arg_type
;
2020 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2022 flags
|= PRINT_MORE_FRAMES
;
2024 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2025 arg_type
= CLI_SCALAR_VALUES
;
2026 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2027 arg_type
= CLI_ALL_VALUES
;
2028 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2029 arg_type
= CLI_PRESENCE
;
2030 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2031 arg_type
= NO_VALUES
;
2035 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2036 arg_type
, current_uiout
,
2040 /* Run the inbuilt backtrace if there are no filters registered, or
2041 "-no-filters" has been specified from the command. */
2042 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2044 frame_info_ptr trailing
;
2046 /* The following code must do two things. First, it must set the
2047 variable TRAILING to the frame from which we should start
2048 printing. Second, it must set the variable count to the number
2049 of frames which we should print, or -1 if all of them. */
2051 if (count_exp
!= NULL
&& count
< 0)
2053 trailing
= trailing_outermost_frame (-count
);
2057 trailing
= get_current_frame ();
2059 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2063 /* Don't use print_stack_frame; if an error() occurs it probably
2064 means further attempts to backtrace would fail (on the other
2065 hand, perhaps the code does or could be fixed to make sure
2066 the frame->prev field gets set to NULL in that case). */
2068 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2069 if ((flags
& PRINT_LOCALS
) != 0)
2070 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2072 /* Save the last frame to check for error conditions. */
2076 /* If we've stopped before the end, mention that. */
2078 gdb_printf (_("(More stack frames follow...)\n"));
2080 /* If we've run out of frames, and the reason appears to be an error
2081 condition, print it. */
2082 if (fi
== NULL
&& trailing
!= NULL
)
2084 enum unwind_stop_reason reason
;
2086 reason
= get_frame_unwind_stop_reason (trailing
);
2087 if (reason
>= UNWIND_FIRST_ERROR
)
2088 gdb_printf (_("Backtrace stopped: %s\n"),
2089 frame_stop_reason_string (trailing
));
2094 /* Create an option_def_group array grouping all the "backtrace"
2095 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2097 static inline std::array
<gdb::option::option_def_group
, 3>
2098 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2099 backtrace_cmd_options
*bt_cmd_opts
,
2100 set_backtrace_options
*set_bt_opts
)
2103 { {frame_print_option_defs
}, fp_opts
},
2104 { {set_backtrace_option_defs
}, set_bt_opts
},
2105 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2109 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2110 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2111 store the parsed qualifiers. */
2114 parse_backtrace_qualifiers (const char *arg
,
2115 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2119 const char *save_arg
= arg
;
2120 std::string this_arg
= extract_arg (&arg
);
2122 if (this_arg
.empty ())
2125 if (startswith ("no-filters", this_arg
))
2127 if (bt_cmd_opts
!= nullptr)
2128 bt_cmd_opts
->no_filters
= true;
2130 else if (startswith ("full", this_arg
))
2132 if (bt_cmd_opts
!= nullptr)
2133 bt_cmd_opts
->full
= true;
2135 else if (startswith ("hide", this_arg
))
2137 if (bt_cmd_opts
!= nullptr)
2138 bt_cmd_opts
->hide
= true;
2142 /* Not a recognized qualifier, so stop. */
2149 backtrace_command (const char *arg
, int from_tty
)
2151 frame_print_options fp_opts
= user_frame_print_options
;
2152 backtrace_cmd_options bt_cmd_opts
;
2153 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2156 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2157 gdb::option::process_options
2158 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2160 /* Parse non-'-'-prefixed qualifiers, for backwards
2164 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2169 /* These options are handled quite deep in the unwind machinery, so
2170 we get to pass them down by swapping globals. */
2171 scoped_restore restore_set_backtrace_options
2172 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2174 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2177 /* Completer for the "backtrace" command. */
2180 backtrace_command_completer (struct cmd_list_element
*ignore
,
2181 completion_tracker
&tracker
,
2182 const char *text
, const char */
*word*/
)
2185 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2186 if (gdb::option::complete_options
2187 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2192 const char *p
= skip_to_space (text
);
2195 static const char *const backtrace_cmd_qualifier_choices
[] = {
2196 "full", "no-filters", "hide", nullptr,
2198 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2201 if (tracker
.have_completions ())
2206 const char *cmd
= parse_backtrace_qualifiers (text
);
2207 tracker
.advance_custom_word_point_by (cmd
- text
);
2212 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2213 expression_completer (ignore
, tracker
, text
, word
);
2216 /* Iterate over the local variables of a block B, calling CB. */
2219 iterate_over_block_locals (const struct block
*b
,
2220 iterate_over_block_arg_local_vars_cb cb
)
2222 for (struct symbol
*sym
: block_iterator_range (b
))
2224 switch (sym
->aclass ())
2231 case LOC_OPTIMIZED_OUT
:
2232 if (sym
->is_argument ())
2234 if (sym
->domain () == COMMON_BLOCK_DOMAIN
)
2236 cb (sym
->print_name (), sym
);
2240 /* Ignore symbols which are not locals. */
2246 /* Iterate over all the local variables in block B, including all its
2247 superblocks, stopping when the top-level block is reached. */
2250 iterate_over_block_local_vars (const struct block
*block
,
2251 iterate_over_block_arg_local_vars_cb cb
)
2255 iterate_over_block_locals (block
, cb
);
2256 /* After handling the function's top-level block, stop. Don't
2257 continue to its superblock, the block of per-file
2259 if (block
->function ())
2261 block
= block
->superblock ();
2265 /* Data to be passed around in the calls to the locals and args
2268 struct print_variable_and_value_data
2270 std::optional
<compiled_regex
> preg
;
2271 std::optional
<compiled_regex
> treg
;
2272 struct frame_id frame_id
;
2274 struct ui_file
*stream
;
2277 void operator() (const char *print_name
, struct symbol
*sym
);
2280 /* The callback for the locals and args iterators. */
2283 print_variable_and_value_data::operator() (const char *print_name
,
2286 frame_info_ptr frame
;
2288 if (preg
.has_value ()
2289 && preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2291 if (treg
.has_value ()
2292 && !treg_matches_sym_type_name (*treg
, sym
))
2294 if (language_def (sym
->language ())->symbol_printing_suppressed (sym
))
2297 frame
= frame_find_by_id (frame_id
);
2300 warning (_("Unable to restore previously selected frame."));
2304 print_variable_and_value (print_name
, sym
, frame
, stream
, num_tabs
);
2309 /* Prepares the regular expression REG from REGEXP.
2310 If REGEXP is NULL, it results in an empty regular expression. */
2313 prepare_reg (const char *regexp
, std::optional
<compiled_regex
> *reg
)
2317 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2319 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2325 /* Print all variables from the innermost up to the function block of FRAME.
2326 Print them with values to STREAM indented by NUM_TABS.
2327 If REGEXP is not NULL, only print local variables whose name
2329 If T_REGEXP is not NULL, only print local variables whose type
2331 If no local variables have been printed and !QUIET, prints a message
2332 explaining why no local variables could be printed. */
2335 print_frame_local_vars (const frame_info_ptr
&frame
,
2337 const char *regexp
, const char *t_regexp
,
2338 int num_tabs
, struct ui_file
*stream
)
2340 struct print_variable_and_value_data cb_data
;
2341 const struct block
*block
;
2344 if (!get_frame_pc_if_available (frame
, &pc
))
2348 _("PC unavailable, cannot determine locals.\n"));
2352 block
= get_frame_block (frame
, 0);
2356 gdb_printf (stream
, "No symbol table info available.\n");
2360 prepare_reg (regexp
, &cb_data
.preg
);
2361 prepare_reg (t_regexp
, &cb_data
.treg
);
2362 cb_data
.frame_id
= get_frame_id (frame
);
2363 cb_data
.num_tabs
= 4 * num_tabs
;
2364 cb_data
.stream
= stream
;
2365 cb_data
.values_printed
= 0;
2367 /* Temporarily change the selected frame to the given FRAME.
2368 This allows routines that rely on the selected frame instead
2369 of being given a frame as parameter to use the correct frame. */
2370 scoped_restore_selected_frame restore_selected_frame
;
2371 select_frame (frame
);
2373 iterate_over_block_local_vars (block
, cb_data
);
2375 if (!cb_data
.values_printed
&& !quiet
)
2377 if (regexp
== NULL
&& t_regexp
== NULL
)
2378 gdb_printf (stream
, _("No locals.\n"));
2380 gdb_printf (stream
, _("No matching locals.\n"));
2384 /* Structure to hold the values of the options used by the 'info
2385 variables' command and other similar commands. These correspond to the
2386 -q and -t options. */
2388 struct info_print_options
2391 std::string type_regexp
;
2394 /* The options used by the 'info locals' and 'info args' commands. */
2396 static const gdb::option::option_def info_print_options_defs
[] = {
2397 gdb::option::boolean_option_def
<info_print_options
> {
2399 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2400 nullptr, /* show_cmd_cb */
2401 nullptr /* set_doc */
2404 gdb::option::string_option_def
<info_print_options
> {
2406 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2407 nullptr, /* show_cmd_cb */
2408 nullptr /* set_doc */
2412 /* Returns the option group used by 'info locals' and 'info args'
2415 static gdb::option::option_def_group
2416 make_info_print_options_def_group (info_print_options
*opts
)
2418 return {{info_print_options_defs
}, opts
};
2421 /* Command completer for 'info locals' and 'info args'. */
2424 info_print_command_completer (struct cmd_list_element
*ignore
,
2425 completion_tracker
&tracker
,
2426 const char *text
, const char * /* word */)
2429 = make_info_print_options_def_group (nullptr);
2430 if (gdb::option::complete_options
2431 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2434 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2435 symbol_completer (ignore
, tracker
, text
, word
);
2438 /* Implement the 'info locals' command. */
2441 info_locals_command (const char *args
, int from_tty
)
2443 info_print_options opts
;
2444 auto grp
= make_info_print_options_def_group (&opts
);
2445 gdb::option::process_options
2446 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2447 if (args
!= nullptr && *args
== '\0')
2450 print_frame_local_vars
2451 (get_selected_frame (_("No frame selected.")),
2453 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2457 /* Iterate over all the argument variables in block B. */
2460 iterate_over_block_arg_vars (const struct block
*b
,
2461 iterate_over_block_arg_local_vars_cb cb
)
2463 for (struct symbol
*sym
: block_iterator_range (b
))
2465 /* Don't worry about things which aren't arguments. */
2466 if (sym
->is_argument ())
2468 /* We have to look up the symbol because arguments can have
2469 two entries (one a parameter, one a local) and the one we
2470 want is the local, which lookup_symbol will find for us.
2471 This includes gcc1 (not gcc2) on the sparc when passing a
2472 small structure and gcc2 when the argument type is float
2473 and it is passed as a double and converted to float by
2474 the prologue (in the latter case the type of the LOC_ARG
2475 symbol is double and the type of the LOC_LOCAL symbol is
2476 float). There are also LOC_ARG/LOC_REGISTER pairs which
2477 are not combined in symbol-reading. */
2480 = lookup_symbol_search_name (sym
->search_name (),
2481 b
, SEARCH_VAR_DOMAIN
).symbol
;
2482 cb (sym
->print_name (), sym2
);
2487 /* Print all argument variables of the function of FRAME.
2488 Print them with values to STREAM.
2489 If REGEXP is not NULL, only print argument variables whose name
2491 If T_REGEXP is not NULL, only print argument variables whose type
2493 If no argument variables have been printed and !QUIET, prints a message
2494 explaining why no argument variables could be printed. */
2497 print_frame_arg_vars (const frame_info_ptr
&frame
,
2499 const char *regexp
, const char *t_regexp
,
2500 struct ui_file
*stream
)
2502 struct print_variable_and_value_data cb_data
;
2503 struct symbol
*func
;
2505 std::optional
<compiled_regex
> preg
;
2506 std::optional
<compiled_regex
> treg
;
2508 if (!get_frame_pc_if_available (frame
, &pc
))
2512 _("PC unavailable, cannot determine args.\n"));
2516 func
= get_frame_function (frame
);
2520 gdb_printf (stream
, _("No symbol table info available.\n"));
2524 prepare_reg (regexp
, &cb_data
.preg
);
2525 prepare_reg (t_regexp
, &cb_data
.treg
);
2526 cb_data
.frame_id
= get_frame_id (frame
);
2527 cb_data
.num_tabs
= 0;
2528 cb_data
.stream
= stream
;
2529 cb_data
.values_printed
= 0;
2531 iterate_over_block_arg_vars (func
->value_block (), cb_data
);
2533 if (!cb_data
.values_printed
&& !quiet
)
2535 if (regexp
== NULL
&& t_regexp
== NULL
)
2536 gdb_printf (stream
, _("No arguments.\n"));
2538 gdb_printf (stream
, _("No matching arguments.\n"));
2542 /* Implement the 'info args' command. */
2545 info_args_command (const char *args
, int from_tty
)
2547 info_print_options opts
;
2548 auto grp
= make_info_print_options_def_group (&opts
);
2549 gdb::option::process_options
2550 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2551 if (args
!= nullptr && *args
== '\0')
2554 print_frame_arg_vars
2555 (get_selected_frame (_("No frame selected.")),
2557 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2561 /* Return the symbol-block in which the selected frame is executing.
2562 Can return zero under various legitimate circumstances.
2564 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2565 code address within the block returned. We use this to decide
2566 which macros are in scope. */
2568 const struct block
*
2569 get_selected_block (CORE_ADDR
*addr_in_block
)
2571 if (!has_stack_frames ())
2574 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2577 /* Find a frame a certain number of levels away from FRAME.
2578 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2579 Positive means go to earlier frames (up); negative, the reverse.
2580 The int that contains the number of levels is counted toward
2581 zero as the frames for those levels are found.
2582 If the top or bottom frame is reached, that frame is returned,
2583 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2584 how much farther the original request asked to go. */
2587 find_relative_frame (frame_info_ptr frame
, int *level_offset_ptr
)
2589 /* Going up is simple: just call get_prev_frame enough times or
2590 until the initial frame is reached. */
2591 while (*level_offset_ptr
> 0)
2593 frame_info_ptr prev
= get_prev_frame (frame
);
2597 (*level_offset_ptr
)--;
2601 /* Going down is just as simple. */
2602 while (*level_offset_ptr
< 0)
2604 frame_info_ptr next
= get_next_frame (frame
);
2608 (*level_offset_ptr
)++;
2615 /* Select the frame up one or COUNT_EXP stack levels from the
2616 previously selected frame, and print it briefly. */
2619 up_silently_base (const char *count_exp
)
2621 frame_info_ptr frame
;
2625 count
= parse_and_eval_long (count_exp
);
2627 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2628 if (count
!= 0 && count_exp
== NULL
)
2629 error (_("Initial frame selected; you cannot go up."));
2630 select_frame (frame
);
2634 up_silently_command (const char *count_exp
, int from_tty
)
2636 up_silently_base (count_exp
);
2640 up_command (const char *count_exp
, int from_tty
)
2642 up_silently_base (count_exp
);
2643 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2646 /* Select the frame down one or COUNT_EXP stack levels from the previously
2647 selected frame, and print it briefly. */
2650 down_silently_base (const char *count_exp
)
2652 frame_info_ptr frame
;
2656 count
= -parse_and_eval_long (count_exp
);
2658 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2659 if (count
!= 0 && count_exp
== NULL
)
2661 /* We only do this if COUNT_EXP is not specified. That way
2662 "down" means to really go down (and let me know if that is
2663 impossible), but "down 9999" can be used to mean go all the
2664 way down without getting an error. */
2666 error (_("Bottom (innermost) frame selected; you cannot go down."));
2669 select_frame (frame
);
2673 down_silently_command (const char *count_exp
, int from_tty
)
2675 down_silently_base (count_exp
);
2679 down_command (const char *count_exp
, int from_tty
)
2681 down_silently_base (count_exp
);
2682 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2686 return_command (const char *retval_exp
, int from_tty
)
2688 /* Initialize it just to avoid a GCC false warning. */
2689 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2690 frame_info_ptr thisframe
;
2691 struct gdbarch
*gdbarch
;
2692 struct symbol
*thisfun
;
2693 struct value
*return_value
= NULL
;
2694 struct value
*function
= NULL
;
2695 std::string query_prefix
;
2697 thisframe
= get_selected_frame ("No selected frame.");
2698 thisfun
= get_frame_function (thisframe
);
2699 gdbarch
= get_frame_arch (thisframe
);
2701 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2702 error (_("Can not force return from an inlined function."));
2704 /* Compute the return value. If the computation triggers an error,
2705 let it bail. If the return type can't be handled, set
2706 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2710 expression_up retval_expr
= parse_expression (retval_exp
);
2711 struct type
*return_type
= NULL
;
2713 /* Compute the return value. Should the computation fail, this
2714 call throws an error. */
2715 return_value
= retval_expr
->evaluate ();
2717 /* Cast return value to the return type of the function. Should
2718 the cast fail, this call throws an error. */
2719 if (thisfun
!= NULL
)
2720 return_type
= thisfun
->type ()->target_type ();
2721 if (return_type
== NULL
)
2723 if (retval_expr
->first_opcode () != UNOP_CAST
2724 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2725 error (_("Return value type not available for selected "
2727 "Please use an explicit cast of the value to return."));
2728 return_type
= return_value
->type ();
2730 return_type
= check_typedef (return_type
);
2731 return_value
= value_cast (return_type
, return_value
);
2733 /* Make sure the value is fully evaluated. It may live in the
2734 stack frame we're about to pop. */
2735 if (return_value
->lazy ())
2736 return_value
->fetch_lazy ();
2738 if (thisfun
!= NULL
)
2739 function
= read_var_value (thisfun
, NULL
, thisframe
);
2741 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2742 if (return_type
->code () == TYPE_CODE_VOID
)
2743 /* If the return-type is "void", don't try to find the
2744 return-value's location. However, do still evaluate the
2745 return expression so that, even when the expression result
2746 is discarded, side effects such as "return i++" still
2748 return_value
= NULL
;
2749 else if (thisfun
!= NULL
)
2751 if (is_nocall_function (check_typedef (function
->type ())))
2754 string_printf ("Function '%s' does not follow the target "
2755 "calling convention.\n"
2756 "If you continue, setting the return value "
2757 "will probably lead to unpredictable "
2759 thisfun
->print_name ());
2762 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2763 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2764 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2766 query_prefix
= "The location at which to store the "
2767 "function's return value is unknown.\n"
2768 "If you continue, the return value "
2769 "that you specified will be ignored.\n";
2770 return_value
= NULL
;
2775 /* Does an interactive user really want to do this? Include
2776 information, such as how well GDB can handle the return value, in
2777 the query message. */
2782 if (thisfun
== NULL
)
2783 confirmed
= query (_("%sMake selected stack frame return now? "),
2784 query_prefix
.c_str ());
2787 if (TYPE_NO_RETURN (thisfun
->type ()))
2788 warning (_("Function does not return normally to caller."));
2789 confirmed
= query (_("%sMake %s return now? "),
2790 query_prefix
.c_str (),
2791 thisfun
->print_name ());
2794 error (_("Not confirmed"));
2797 /* Discard the selected frame and all frames inner-to it. */
2798 frame_pop (get_selected_frame (NULL
));
2800 /* Store RETURN_VALUE in the just-returned register set. */
2801 if (return_value
!= NULL
)
2803 struct type
*return_type
= return_value
->type ();
2804 regcache
*regcache
= get_thread_regcache (inferior_thread ());
2805 struct gdbarch
*cache_arch
= regcache
->arch ();
2807 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2808 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2809 gdbarch_return_value_as_value
2810 (cache_arch
, function
, return_type
, regcache
, NULL
/*read*/,
2811 return_value
->contents ().data () /*write*/);
2814 /* If we are at the end of a call dummy now, pop the dummy frame
2816 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2817 frame_pop (get_current_frame ());
2819 select_frame (get_current_frame ());
2820 /* If interactive, print the frame that is now current. */
2822 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2825 /* Find the most inner frame in the current stack for a function called
2826 FUNCTION_NAME. If no matching frame is found return NULL. */
2828 static frame_info_ptr
2829 find_frame_for_function (const char *function_name
)
2831 /* Used to hold the lower and upper addresses for each of the
2832 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2833 struct function_bounds
2835 CORE_ADDR low
, high
;
2837 frame_info_ptr frame
;
2841 gdb_assert (function_name
!= NULL
);
2843 frame
= get_current_frame ();
2844 std::vector
<symtab_and_line
> sals
2845 = decode_line_with_current_source (function_name
,
2846 DECODE_LINE_FUNFIRSTLINE
);
2847 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2848 for (size_t i
= 0; i
< sals
.size (); i
++)
2850 if (sals
[i
].pspace
!= current_program_space
)
2851 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2852 else if (sals
[i
].pc
== 0
2853 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2854 &func_bounds
[i
].low
,
2855 &func_bounds
[i
].high
) == 0)
2856 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2861 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2862 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2863 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2867 frame
= find_relative_frame (frame
, &level
);
2870 while (!found
&& level
== 0);
2878 /* The qcs command line flags for the "frame apply" commands. Keep
2879 this in sync with the "thread apply" commands. */
2881 using qcs_flag_option_def
2882 = gdb::option::flag_option_def
<qcs_flags
>;
2884 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2885 qcs_flag_option_def
{
2886 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2887 N_("Disables printing the frame location information."),
2890 qcs_flag_option_def
{
2891 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2892 N_("Print any error raised by COMMAND and continue."),
2895 qcs_flag_option_def
{
2896 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2897 N_("Silently ignore any errors or empty output produced by COMMAND."),
2901 /* Create an option_def_group array for all the "frame apply" options,
2902 with FLAGS and SET_BT_OPTS as context. */
2904 static inline std::array
<gdb::option::option_def_group
, 2>
2905 make_frame_apply_options_def_group (qcs_flags
*flags
,
2906 set_backtrace_options
*set_bt_opts
)
2909 { {fr_qcs_flags_option_defs
}, flags
},
2910 { {set_backtrace_option_defs
}, set_bt_opts
},
2914 /* Apply a GDB command to all stack frames, or a set of identified frames,
2915 or innermost COUNT frames.
2916 With a negative COUNT, apply command on outermost -COUNT frames.
2918 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2919 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2920 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2921 frame apply all -s p local_var_no_idea_in_which_frame
2922 If a frame has a local variable called
2923 local_var_no_idea_in_which_frame, print frame
2924 and value of local_var_no_idea_in_which_frame.
2925 frame apply all -s -q p local_var_no_idea_in_which_frame
2926 Same as before, but only print the variable value.
2927 frame apply level 2-5 0 4-7 -s p i = i + 1
2928 Adds 1 to the variable i in the specified frames.
2929 Note that i will be incremented twice in
2932 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2933 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2934 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2935 for error messages. */
2938 frame_apply_command_count (const char *which_command
,
2939 const char *cmd
, int from_tty
,
2940 frame_info_ptr trailing
, int count
)
2943 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2945 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2946 gdb::option::process_options
2947 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2949 validate_flags_qcs (which_command
, &flags
);
2951 if (cmd
== NULL
|| *cmd
== '\0')
2952 error (_("Please specify a command to apply on the selected frames"));
2954 /* The below will restore the current inferior/thread/frame.
2955 Usually, only the frame is effectively to be restored.
2956 But in case CMD switches of inferior/thread, better restore
2958 scoped_restore_current_thread restore_thread
;
2960 /* These options are handled quite deep in the unwind machinery, so
2961 we get to pass them down by swapping globals. */
2962 scoped_restore restore_set_backtrace_options
2963 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2965 for (frame_info_ptr fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2972 std::string cmd_result
;
2974 /* In case CMD switches of inferior/thread/frame, the below
2975 restores the inferior/thread/frame. FI can then be
2976 set to the selected frame. */
2977 scoped_restore_current_thread restore_fi_current_frame
;
2979 execute_command_to_string
2980 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
2982 fi
= get_selected_frame (_("frame apply "
2983 "unable to get selected frame."));
2984 if (!flags
.silent
|| cmd_result
.length () > 0)
2987 print_stack_frame (fi
, 1, LOCATION
, 0);
2988 gdb_printf ("%s", cmd_result
.c_str ());
2991 catch (const gdb_exception_error
&ex
)
2993 fi
= get_selected_frame (_("frame apply "
2994 "unable to get selected frame."));
2998 print_stack_frame (fi
, 1, LOCATION
, 0);
3000 gdb_printf ("%s\n", ex
.what ());
3008 /* Completer for the "frame apply ..." commands. */
3011 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3013 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3014 if (gdb::option::complete_options
3015 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3018 complete_nested_command_line (tracker
, text
);
3021 /* Completer for the "frame apply" commands. */
3024 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3025 completion_tracker
&tracker
,
3026 const char *text
, const char */
*word*/
)
3028 /* Do this explicitly because there's an early return below. */
3029 tracker
.set_use_custom_word_point (true);
3031 number_or_range_parser
levels (text
);
3033 /* Skip the LEVEL list to find the options and command args. */
3036 while (!levels
.finished ())
3038 /* Call for effect. */
3039 levels
.get_number ();
3041 if (levels
.in_range ())
3042 levels
.skip_range ();
3045 catch (const gdb_exception_error
&ex
)
3047 /* get_number throws if it parses a negative number, for
3048 example. But a seemingly negative number may be the start of
3049 an option instead. */
3052 const char *cmd
= levels
.cur_tok ();
3056 /* No level list yet. */
3060 /* Check if we're past a valid LEVEL already. */
3061 if (levels
.finished ()
3062 && cmd
> text
&& !isspace (cmd
[-1]))
3065 /* We're past LEVELs, advance word point. */
3066 tracker
.advance_custom_word_point_by (cmd
- text
);
3069 frame_apply_completer (tracker
, text
);
3072 /* Completer for the "frame apply all" command. */
3075 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3076 completion_tracker
&tracker
,
3077 const char *text
, const char */
*word*/
)
3079 frame_apply_completer (tracker
, text
);
3082 /* Completer for the "frame apply COUNT" command. */
3085 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3086 completion_tracker
&tracker
,
3087 const char *text
, const char */
*word*/
)
3089 const char *cmd
= text
;
3091 int count
= get_number_trailer (&cmd
, 0);
3095 /* Check if we're past a valid COUNT already. */
3096 if (cmd
> text
&& !isspace (cmd
[-1]))
3099 /* We're past COUNT, advance word point. */
3100 tracker
.advance_custom_word_point_by (cmd
- text
);
3103 frame_apply_completer (tracker
, text
);
3106 /* Implementation of the "frame apply level" command. */
3109 frame_apply_level_command (const char *cmd
, int from_tty
)
3111 if (!target_has_stack ())
3112 error (_("No stack."));
3114 bool level_found
= false;
3115 const char *levels_str
= cmd
;
3116 number_or_range_parser
levels (levels_str
);
3118 /* Skip the LEVEL list to find the flags and command args. */
3119 while (!levels
.finished ())
3121 /* Call for effect. */
3122 levels
.get_number ();
3125 if (levels
.in_range ())
3126 levels
.skip_range ();
3130 error (_("Missing or invalid LEVEL... argument"));
3132 cmd
= levels
.cur_tok ();
3134 /* Redo the LEVELS parsing, but applying COMMAND. */
3135 levels
.init (levels_str
);
3136 while (!levels
.finished ())
3138 const int level_beg
= levels
.get_number ();
3141 if (levels
.in_range ())
3143 n_frames
= levels
.end_value () - level_beg
+ 1;
3144 levels
.skip_range ();
3149 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3150 leading_innermost_frame (level_beg
), n_frames
);
3154 /* Implementation of the "frame apply all" command. */
3157 frame_apply_all_command (const char *cmd
, int from_tty
)
3159 if (!target_has_stack ())
3160 error (_("No stack."));
3162 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3163 get_current_frame (), INT_MAX
);
3166 /* Implementation of the "frame apply" command. */
3169 frame_apply_command (const char* cmd
, int from_tty
)
3172 frame_info_ptr trailing
;
3174 if (!target_has_stack ())
3175 error (_("No stack."));
3178 error (_("Missing COUNT argument."));
3179 count
= get_number_trailer (&cmd
, 0);
3181 error (_("Invalid COUNT argument."));
3185 trailing
= trailing_outermost_frame (-count
);
3189 trailing
= get_current_frame ();
3191 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3195 /* Implementation of the "faas" command. */
3198 faas_command (const char *cmd
, int from_tty
)
3200 if (cmd
== NULL
|| *cmd
== '\0')
3201 error (_("Please specify a command to apply on all frames"));
3202 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3203 execute_command (expanded
.c_str (), from_tty
);
3207 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3208 matching frame can be found. */
3210 static frame_info_ptr
3211 find_frame_for_address (CORE_ADDR address
)
3216 id
= frame_id_build_wild (address
);
3218 /* If (s)he specifies the frame with an address, he deserves
3219 what (s)he gets. Still, give the highest one that matches.
3220 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3222 for (fid
= get_current_frame ();
3224 fid
= get_prev_frame (fid
))
3226 if (id
== get_frame_id (fid
))
3228 frame_info_ptr prev_frame
;
3232 prev_frame
= get_prev_frame (fid
);
3234 || id
!= get_frame_id (prev_frame
))
3246 /* Commands with a prefix of `frame apply'. */
3247 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3249 /* Commands with a prefix of `frame'. */
3250 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3252 /* Commands with a prefix of `select frame'. */
3253 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3255 /* Commands with a prefix of `info frame'. */
3256 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3258 void _initialize_stack ();
3260 _initialize_stack ()
3262 struct cmd_list_element
*cmd
;
3264 add_com ("return", class_stack
, return_command
, _("\
3265 Make selected stack frame return to its caller.\n\
3266 Control remains in the debugger, but when you continue\n\
3267 execution will resume in the frame above the one now selected.\n\
3268 If an argument is given, it is an expression for the value to return."));
3270 add_com ("up", class_stack
, up_command
, _("\
3271 Select and print stack frame that called this one.\n\
3272 An argument says how many frames up to go."));
3273 add_com ("up-silently", class_support
, up_silently_command
, _("\
3274 Same as the `up' command, but does not print anything.\n\
3275 This is useful in command scripts."));
3277 cmd_list_element
*down_cmd
3278 = add_com ("down", class_stack
, down_command
, _("\
3279 Select and print stack frame called by this one.\n\
3280 An argument says how many frames down to go."));
3281 add_com_alias ("do", down_cmd
, class_stack
, 1);
3282 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3283 add_com ("down-silently", class_support
, down_silently_command
, _("\
3284 Same as the `down' command, but does not print anything.\n\
3285 This is useful in command scripts."));
3287 cmd_list_element
*frame_cmd_el
3288 = add_prefix_cmd ("frame", class_stack
,
3289 &frame_cmd
.base_command
, _("\
3290 Select and print a stack frame.\n\
3291 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3292 A single numerical argument specifies the frame to select."),
3293 &frame_cmd_list
, 1, &cmdlist
);
3294 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3296 #define FRAME_APPLY_OPTION_HELP "\
3297 Prints the frame location information followed by COMMAND output.\n\
3299 By default, an error raised during the execution of COMMAND\n\
3300 aborts \"frame apply\".\n\
3305 const auto frame_apply_opts
3306 = make_frame_apply_options_def_group (nullptr, nullptr);
3308 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3309 Apply a command to a number of frames.\n\
3310 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3311 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3312 FRAME_APPLY_OPTION_HELP
),
3315 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3316 frame_apply_cmd_help
.c_str (),
3317 &frame_apply_cmd_list
, 1,
3319 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3321 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3322 Apply a command to all frames.\n\
3324 Usage: frame apply all [OPTION]... COMMAND\n"
3325 FRAME_APPLY_OPTION_HELP
),
3328 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3329 frame_apply_all_cmd_help
.c_str (),
3330 &frame_apply_cmd_list
);
3331 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3333 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3334 Apply a command to a list of frames.\n\
3336 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3337 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3338 FRAME_APPLY_OPTION_HELP
),
3341 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3342 frame_apply_level_cmd_help
.c_str (),
3343 &frame_apply_cmd_list
);
3344 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3346 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3347 Apply a command to all frames (ignoring errors and empty output).\n\
3348 Usage: faas [OPTION]... COMMAND\n\
3349 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3350 See \"help frame apply all\" for available options."));
3351 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3353 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3355 Select and print a stack frame by stack address.\n\
3357 Usage: frame address STACK-ADDRESS"),
3360 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3362 View a stack frame that might be outside the current backtrace.\n\
3364 Usage: frame view STACK-ADDRESS\n\
3365 frame view STACK-ADDRESS PC-ADDRESS"),
3368 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3370 Select and print a stack frame by function name.\n\
3372 Usage: frame function NAME\n\
3374 The innermost frame that visited function NAME is selected."),
3376 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3379 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3381 Select and print a stack frame by level.\n\
3383 Usage: frame level LEVEL"),
3386 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3387 &select_frame_cmd
.base_command
, _("\
3388 Select a stack frame without printing anything.\n\
3389 A single numerical argument specifies the frame to select."),
3390 &select_frame_cmd_list
, 1, &cmdlist
,
3391 &cli_suppress_notification
.user_selected_context
);
3393 add_cmd_suppress_notification ("address", class_stack
,
3394 &select_frame_cmd
.address
, _("\
3395 Select a stack frame by stack address.\n\
3397 Usage: select-frame address STACK-ADDRESS"),
3398 &select_frame_cmd_list
,
3399 &cli_suppress_notification
.user_selected_context
);
3402 add_cmd_suppress_notification ("view", class_stack
,
3403 &select_frame_cmd
.view
, _("\
3404 Select a stack frame that might be outside the current backtrace.\n\
3406 Usage: select-frame view STACK-ADDRESS\n\
3407 select-frame view STACK-ADDRESS PC-ADDRESS"),
3408 &select_frame_cmd_list
,
3409 &cli_suppress_notification
.user_selected_context
);
3411 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3412 &select_frame_cmd
.function
, _("\
3413 Select a stack frame by function name.\n\
3415 Usage: select-frame function NAME"),
3416 &select_frame_cmd_list
,
3417 &cli_suppress_notification
.user_selected_context
);
3418 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3420 add_cmd_suppress_notification ("level", class_stack
,
3421 &select_frame_cmd
.level
, _("\
3422 Select a stack frame by level.\n\
3424 Usage: select-frame level LEVEL"),
3425 &select_frame_cmd_list
,
3426 &cli_suppress_notification
.user_selected_context
);
3428 const auto backtrace_opts
3429 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3431 static std::string backtrace_help
3432 = gdb::option::build_help (_("\
3433 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3434 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3439 For backward compatibility, the following qualifiers are supported:\n\
3441 full - same as -full option.\n\
3442 no-filters - same as -no-filters option.\n\
3443 hide - same as -hide.\n\
3445 With a negative COUNT, print outermost -COUNT frames."),
3448 cmd_list_element
*backtrace_cmd
3449 = add_com ("backtrace", class_stack
, backtrace_command
,
3450 backtrace_help
.c_str ());
3451 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3453 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3455 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3456 cmd_list_element
*info_stack_cmd
3457 = add_info ("stack", backtrace_command
,
3458 _("Backtrace of the stack, or innermost COUNT frames."));
3459 add_info_alias ("s", info_stack_cmd
, 1);
3461 cmd_list_element
*info_frame_cmd_el
3462 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3463 _("All about the selected stack frame.\n\
3464 With no arguments, displays information about the currently selected stack\n\
3465 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3466 the information is then printed about the specified frame."),
3467 &info_frame_cmd_list
, 1, &infolist
);
3468 add_info_alias ("f", info_frame_cmd_el
, 1);
3470 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3472 Print information about a stack frame selected by stack address.\n\
3474 Usage: info frame address STACK-ADDRESS"),
3475 &info_frame_cmd_list
);
3477 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3479 Print information about a stack frame outside the current backtrace.\n\
3481 Usage: info frame view STACK-ADDRESS\n\
3482 info frame view STACK-ADDRESS PC-ADDRESS"),
3483 &info_frame_cmd_list
);
3485 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3487 Print information about a stack frame selected by function name.\n\
3489 Usage: info frame function NAME"),
3490 &info_frame_cmd_list
);
3491 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3493 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3495 Print information about a stack frame selected by level.\n\
3497 Usage: info frame level LEVEL"),
3498 &info_frame_cmd_list
);
3500 cmd
= add_info ("locals", info_locals_command
,
3501 info_print_args_help (_("\
3502 All local variables of current stack frame or those matching REGEXPs.\n\
3503 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3504 Prints the local variables of the current stack frame.\n"),
3505 _("local variables"),
3507 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3508 cmd
= add_info ("args", info_args_command
,
3509 info_print_args_help (_("\
3510 All argument variables of current stack frame or those matching REGEXPs.\n\
3511 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3512 Prints the argument variables of the current stack frame.\n"),
3513 _("argument variables"),
3515 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3517 /* Install "set print raw frame-arguments", a deprecated spelling of
3518 "set print raw-frame-arguments". */
3519 set_show_commands set_show_frame_args
3520 = add_setshow_boolean_cmd
3521 ("frame-arguments", no_class
,
3522 &user_frame_print_options
.print_raw_frame_arguments
,
3524 Set whether to print frame arguments in raw form."), _("\
3525 Show whether to print frame arguments in raw form."), _("\
3526 If set, frame arguments are printed in raw form, bypassing any\n\
3527 pretty-printers for that value."),
3529 &setprintrawlist
, &showprintrawlist
);
3530 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3532 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3533 &disassemble_next_line
, _("\
3534 Set whether to disassemble next source line or insn when execution stops."),
3536 Show whether to disassemble next source line or insn when execution stops."),
3538 If ON, GDB will display disassembly of the next source line, in addition\n\
3539 to displaying the source line itself. If the next source line cannot\n\
3540 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3541 will display disassembly of next instruction instead of showing the\n\
3543 If AUTO, display disassembly of next instruction only if the source line\n\
3544 cannot be displayed.\n\
3545 If OFF (which is the default), never display the disassembly of the next\n\
3548 show_disassemble_next_line
,
3549 &setlist
, &showlist
);
3550 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3552 gdb::option::add_setshow_cmds_for_options
3553 (class_stack
, &user_frame_print_options
,
3554 frame_print_option_defs
, &setprintlist
, &showprintlist
);