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"
25 #include "expression.h"
32 #include "breakpoint.h"
39 #include "dictionary.h"
40 #include "reggroups.h"
44 #include "gdbthread.h"
45 #include "cp-support.h"
47 #include "inline-frame.h"
49 #include "cli/cli-utils.h"
54 #include "extension.h"
55 #include "observable.h"
56 #include "gdbsupport/def-vector.h"
57 #include "cli/cli-option.h"
58 #include "cli/cli-style.h"
59 #include "gdbsupport/buildargv.h"
61 /* The possible choices of "set print frame-arguments", and the value
64 const char print_frame_arguments_all
[] = "all";
65 const char print_frame_arguments_scalars
[] = "scalars";
66 const char print_frame_arguments_none
[] = "none";
67 const char print_frame_arguments_presence
[] = "presence";
69 static const char *const print_frame_arguments_choices
[] =
71 print_frame_arguments_all
,
72 print_frame_arguments_scalars
,
73 print_frame_arguments_none
,
74 print_frame_arguments_presence
,
78 /* The possible choices of "set print frame-info", and the value
81 const char print_frame_info_auto
[] = "auto";
82 const char print_frame_info_source_line
[] = "source-line";
83 const char print_frame_info_location
[] = "location";
84 const char print_frame_info_source_and_location
[] = "source-and-location";
85 const char print_frame_info_location_and_address
[] = "location-and-address";
86 const char print_frame_info_short_location
[] = "short-location";
88 static const char *const print_frame_info_choices
[] =
90 print_frame_info_auto
,
91 print_frame_info_source_line
,
92 print_frame_info_location
,
93 print_frame_info_source_and_location
,
94 print_frame_info_location_and_address
,
95 print_frame_info_short_location
,
99 /* print_frame_info_print_what[i] maps a choice to the corresponding
101 static const std::optional
<enum print_what
> print_frame_info_print_what
[] =
102 {{}, /* Empty value for "auto". */
103 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
105 /* The possible choices of "set print entry-values", and the value
108 const char print_entry_values_no
[] = "no";
109 const char print_entry_values_only
[] = "only";
110 const char print_entry_values_preferred
[] = "preferred";
111 const char print_entry_values_if_needed
[] = "if-needed";
112 const char print_entry_values_both
[] = "both";
113 const char print_entry_values_compact
[] = "compact";
114 const char print_entry_values_default
[] = "default";
115 static const char *const print_entry_values_choices
[] =
117 print_entry_values_no
,
118 print_entry_values_only
,
119 print_entry_values_preferred
,
120 print_entry_values_if_needed
,
121 print_entry_values_both
,
122 print_entry_values_compact
,
123 print_entry_values_default
,
128 frame_print_options user_frame_print_options
;
130 /* Option definitions for some frame-related "set print ..."
133 using boolean_option_def
134 = gdb::option::boolean_option_def
<frame_print_options
>;
135 using enum_option_def
136 = gdb::option::enum_option_def
<frame_print_options
>;
138 static const gdb::option::option_def frame_print_option_defs
[] = {
142 print_entry_values_choices
,
143 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
144 NULL
, /* show_cmd_cb */
145 N_("Set printing of function arguments at function entry."),
146 N_("Show printing of function arguments at function entry."),
147 N_("GDB can sometimes determine the values of function arguments at entry,\n\
148 in addition to their current values. This option tells GDB whether\n\
149 to print the current value, the value at entry (marked as val@entry),\n\
150 or both. Note that one or both of these values may be <optimized out>."),
155 print_frame_arguments_choices
,
156 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
157 NULL
, /* show_cmd_cb */
158 N_("Set printing of non-scalar frame arguments."),
159 N_("Show printing of non-scalar frame arguments."),
164 "raw-frame-arguments",
165 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
166 NULL
, /* show_cmd_cb */
167 N_("Set whether to print frame arguments in raw form."),
168 N_("Show whether to print frame arguments in raw form."),
169 N_("If set, frame arguments are printed in raw form, bypassing any\n\
170 pretty-printers for that value.")
175 print_frame_info_choices
,
176 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
177 NULL
, /* show_cmd_cb */
178 N_("Set printing of frame information."),
179 N_("Show printing of frame information."),
185 /* Options for the "backtrace" command. */
187 struct backtrace_cmd_options
190 bool no_filters
= false;
194 using bt_flag_option_def
195 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
197 static const gdb::option::option_def backtrace_command_option_defs
[] = {
200 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
201 N_("Print values of local variables.")
206 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
207 N_("Prohibit frame filters from executing on a backtrace."),
212 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
213 N_("Causes Python frame filter elided frames to not be printed."),
217 /* Prototypes for local functions. */
219 static void print_frame_local_vars (const frame_info_ptr
&frame
,
221 const char *regexp
, const char *t_regexp
,
222 int num_tabs
, struct ui_file
*stream
);
224 static void print_frame (struct ui_out
*uiout
,
225 const frame_print_options
&opts
,
226 const frame_info_ptr
&frame
, int print_level
,
227 enum print_what print_what
, int print_args
,
228 struct symtab_and_line sal
);
230 static frame_info_ptr
find_frame_for_function (const char *);
231 static frame_info_ptr
find_frame_for_address (CORE_ADDR
);
233 /* Zero means do things normally; we are interacting directly with the
234 user. One means print the full filename and linenumber when a
235 frame is printed, and do so in a format emacs18/emacs19.22 can
236 parse. Two means print similar annotations, but in many more
237 cases and in a slightly different syntax. */
239 int annotation_level
= 0;
241 /* Class used to manage tracking the last symtab we displayed. */
243 class last_displayed_symtab_info_type
246 /* True if the cached information is valid. */
247 bool is_valid () const
250 /* Return the cached program_space. If the cache is invalid nullptr is
252 struct program_space
*pspace () const
255 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
257 CORE_ADDR
address () const
258 { return m_address
; }
260 /* Return the cached symtab. If the cache is invalid nullptr is
262 struct symtab
*symtab () const
265 /* Return the cached line number. If the cache is invalid 0 is
270 /* Invalidate the cache, reset all the members to their default value. */
280 /* Store a new set of values in the cache. */
281 void set (struct program_space
*pspace
, CORE_ADDR address
,
282 struct symtab
*symtab
, int line
)
284 gdb_assert (pspace
!= nullptr);
294 /* True when the cache is valid. */
295 bool m_valid
= false;
297 /* The last program space displayed. */
298 struct program_space
*m_pspace
= nullptr;
300 /* The last address displayed. */
301 CORE_ADDR m_address
= 0;
303 /* The last symtab displayed. */
304 struct symtab
*m_symtab
= nullptr;
306 /* The last line number displayed. */
310 /* An actual instance of the cache, holds information about the last symtab
312 static last_displayed_symtab_info_type last_displayed_symtab_info
;
319 frame_show_address (const frame_info_ptr
&frame
,
320 struct symtab_and_line sal
)
322 /* If there is a line number, but no PC, then there is no location
323 information associated with this sal. The only way that should
324 happen is for the call sites of inlined functions (SAL comes from
325 find_frame_sal). Otherwise, we would have some PC range if the
326 SAL came from a line table. */
327 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
329 if (get_next_frame (frame
) == NULL
)
330 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
332 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
336 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
342 print_stack_frame_to_uiout (struct ui_out
*uiout
, const frame_info_ptr
&frame
,
343 int print_level
, enum print_what print_what
,
346 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
348 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
351 /* Show or print a stack frame FRAME briefly. The output is formatted
352 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
353 relative level, function name, argument list, and file name and
354 line number. If the frame's PC is not at the beginning of the
355 source line, the actual PC is printed at the beginning. */
358 print_stack_frame (const frame_info_ptr
&frame
, int print_level
,
359 enum print_what print_what
,
363 /* For mi, always print location and address. */
364 if (current_uiout
->is_mi_like_p ())
365 print_what
= LOC_AND_ADDRESS
;
369 print_frame_info (user_frame_print_options
,
370 frame
, print_level
, print_what
, 1 /* print_args */,
373 set_current_sal_from_frame (frame
);
375 catch (const gdb_exception_error
&e
)
380 /* Print nameless arguments of frame FRAME on STREAM, where START is
381 the offset of the first nameless argument, and NUM is the number of
382 nameless arguments to print. FIRST is nonzero if this is the first
383 argument (not just the first nameless argument). */
386 print_frame_nameless_args (const frame_info_ptr
&frame
, long start
, int num
,
387 int first
, struct ui_file
*stream
)
389 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
390 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
395 for (i
= 0; i
< num
; i
++)
398 argsaddr
= get_frame_args_address (frame
);
401 arg_value
= read_memory_integer (argsaddr
+ start
,
402 sizeof (int), byte_order
);
404 gdb_printf (stream
, ", ");
405 gdb_printf (stream
, "%ld", arg_value
);
407 start
+= sizeof (int);
411 /* Print single argument of inferior function. ARG must be already
414 Errors are printed as if they would be the parameter value. Use zeroed ARG
415 iff it should not be printed according to user settings. */
418 print_frame_arg (const frame_print_options
&fp_opts
,
419 const struct frame_arg
*arg
)
421 struct ui_out
*uiout
= current_uiout
;
425 gdb_assert (!arg
->val
|| !arg
->error
);
426 gdb_assert (arg
->entry_kind
== print_entry_values_no
427 || arg
->entry_kind
== print_entry_values_only
428 || (!uiout
->is_mi_like_p ()
429 && arg
->entry_kind
== print_entry_values_compact
));
431 annotate_arg_emitter arg_emitter
;
432 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
433 gdb_puts (arg
->sym
->print_name (), &stb
);
434 if (arg
->entry_kind
== print_entry_values_compact
)
436 /* It is OK to provide invalid MI-like stream as with
437 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
440 gdb_puts (arg
->sym
->print_name (), &stb
);
442 if (arg
->entry_kind
== print_entry_values_only
443 || arg
->entry_kind
== print_entry_values_compact
)
445 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
446 annotate_arg_name_end ();
450 if (!arg
->val
&& !arg
->error
)
456 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
457 style
= metadata_style
.style ();
463 const struct language_defn
*language
;
464 struct value_print_options vp_opts
;
466 /* Avoid value_print because it will deref ref parameters. We
467 just want to print their addresses. Print ??? for args whose
468 address we do not know. We pass 2 as "recurse" to val_print
469 because our standard indentation here is 4 spaces, and
470 val_print indents 2 for each recurse. */
472 annotate_arg_value (arg
->val
->type ());
474 /* Use the appropriate language to display our symbol, unless the
475 user forced the language to a specific language. */
476 if (language_mode
== language_mode_auto
)
477 language
= language_def (arg
->sym
->language ());
479 language
= current_language
;
481 get_no_prettyformat_print_options (&vp_opts
);
482 vp_opts
.deref_ref
= true;
483 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
485 /* True in "summary" mode, false otherwise. */
487 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
489 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
491 catch (const gdb_exception_error
&except
)
493 stb
.printf (_("<error reading variable: %s>"),
495 style
= metadata_style
.style ();
500 uiout
->field_stream ("value", stb
, style
);
503 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
504 responsible for xfree of ARGP->ERROR. This function never throws an
508 read_frame_local (struct symbol
*sym
, const frame_info_ptr
&frame
,
509 struct frame_arg
*argp
)
517 argp
->val
= read_var_value (sym
, NULL
, frame
);
519 catch (const gdb_exception_error
&except
)
521 argp
->error
.reset (xstrdup (except
.what ()));
525 /* Read in inferior function parameter SYM at FRAME into ARGP. This
526 function never throws an exception. */
529 read_frame_arg (const frame_print_options
&fp_opts
,
530 symbol
*sym
, const frame_info_ptr
&frame
,
531 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
533 struct value
*val
= NULL
, *entryval
= NULL
;
534 char *val_error
= NULL
, *entryval_error
= NULL
;
537 if (fp_opts
.print_entry_values
!= print_entry_values_only
538 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
542 val
= read_var_value (sym
, NULL
, frame
);
544 catch (const gdb_exception_error
&except
)
546 val_error
= (char *) alloca (except
.message
->size () + 1);
547 strcpy (val_error
, except
.what ());
551 if (const symbol_computed_ops
*computed_ops
= sym
->computed_ops ();
552 (computed_ops
!= nullptr
553 && computed_ops
->read_variable_at_entry
!= nullptr
554 && fp_opts
.print_entry_values
!= print_entry_values_no
555 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
|| !val
556 || val
->optimized_out ())))
560 entryval
= computed_ops
->read_variable_at_entry (sym
, frame
);
562 catch (const gdb_exception_error
&except
)
564 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
566 entryval_error
= (char *) alloca (except
.message
->size () + 1);
567 strcpy (entryval_error
, except
.what ());
571 if (entryval
!= NULL
&& entryval
->optimized_out ())
574 if (fp_opts
.print_entry_values
== print_entry_values_compact
575 || fp_opts
.print_entry_values
== print_entry_values_default
)
577 /* For MI do not try to use print_entry_values_compact for ARGP. */
579 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
581 struct type
*type
= val
->type ();
585 if (entryval
->lazy ())
586 entryval
->fetch_lazy ();
588 if (val
->contents_eq (0, entryval
, 0, type
->length ()))
590 /* Initialize it just to avoid a GCC false warning. */
591 struct value
*val_deref
= NULL
, *entryval_deref
;
593 /* DW_AT_call_value does match with the current
594 value. If it is a reference still try to verify if
595 dereferenced DW_AT_call_data_value does not differ. */
599 struct type
*type_deref
;
601 val_deref
= coerce_ref (val
);
602 if (val_deref
->lazy ())
603 val_deref
->fetch_lazy ();
604 type_deref
= val_deref
->type ();
606 entryval_deref
= coerce_ref (entryval
);
607 if (entryval_deref
->lazy ())
608 entryval_deref
->fetch_lazy ();
610 /* If the reference addresses match but dereferenced
611 content does not match print them. */
613 && val_deref
->contents_eq (0,
615 type_deref
->length ()))
618 catch (const gdb_exception_error
&except
)
620 /* If the dereferenced content could not be
621 fetched do not display anything. */
622 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
624 else if (except
.message
!= NULL
)
627 = (char *) alloca (except
.message
->size () + 1);
628 strcpy (entryval_error
, except
.what ());
632 /* Value was not a reference; and its content matches. */
633 if (val
== val_deref
)
641 /* Try to remove possibly duplicate error message for ENTRYARGP even
644 if (val_error
&& entryval_error
645 && strcmp (val_error
, entryval_error
) == 0)
647 entryval_error
= NULL
;
649 /* Do not se VAL_EQUAL as the same error message may be shown for
650 the entry value even if no entry values are present in the
656 if (entryval
== NULL
)
658 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
660 gdb_assert (val
== NULL
);
664 val
= read_var_value (sym
, NULL
, frame
);
666 catch (const gdb_exception_error
&except
)
668 val_error
= (char *) alloca (except
.message
->size () + 1);
669 strcpy (val_error
, except
.what ());
672 if (fp_opts
.print_entry_values
== print_entry_values_only
673 || fp_opts
.print_entry_values
== print_entry_values_both
674 || (fp_opts
.print_entry_values
== print_entry_values_preferred
675 && (!val
|| val
->optimized_out ())))
677 entryval
= value::allocate_optimized_out (sym
->type ());
678 entryval_error
= NULL
;
681 if ((fp_opts
.print_entry_values
== print_entry_values_compact
682 || fp_opts
.print_entry_values
== print_entry_values_if_needed
683 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
684 && (!val
|| val
->optimized_out ()) && entryval
!= NULL
)
692 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
693 if (!val
&& !val_error
)
694 argp
->entry_kind
= print_entry_values_only
;
695 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
696 || fp_opts
.print_entry_values
== print_entry_values_default
)
699 argp
->entry_kind
= print_entry_values_compact
;
700 gdb_assert (!current_uiout
->is_mi_like_p ());
703 argp
->entry_kind
= print_entry_values_no
;
705 entryargp
->sym
= sym
;
706 entryargp
->val
= entryval
;
707 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
708 if (!entryval
&& !entryval_error
)
709 entryargp
->entry_kind
= print_entry_values_no
;
711 entryargp
->entry_kind
= print_entry_values_only
;
714 /* Print the arguments of frame FRAME on STREAM, given the function
715 FUNC running in that frame (as a symbol), where NUM is the number
716 of arguments according to the stack frame (or -1 if the number of
717 arguments is unknown). */
719 /* Note that currently the "number of arguments according to the
720 stack frame" is only known on VAX where i refers to the "number of
721 ints of arguments according to the stack frame". */
724 print_frame_args (const frame_print_options
&fp_opts
,
725 struct symbol
*func
, const frame_info_ptr
&frame
,
726 int num
, struct ui_file
*stream
)
728 struct ui_out
*uiout
= current_uiout
;
730 /* Offset of next stack argument beyond the one we have seen that is
731 at the highest offset, or -1 if we haven't come to a stack
733 long highest_offset
= -1;
734 /* Number of ints of arguments that we have printed so far. */
735 int args_printed
= 0;
736 /* True if we should print arg names. If false, we only indicate
737 the presence of arguments by printing ellipsis. */
739 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
740 /* True if we should print arguments, false otherwise. */
743 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
747 const struct block
*b
= func
->value_block ();
749 for (struct symbol
*sym
: block_iterator_range (b
))
751 struct frame_arg arg
, entryarg
;
755 /* Keep track of the highest stack argument offset seen, and
756 skip over any kinds of symbols we don't care about. */
758 if (!sym
->is_argument ())
768 switch (sym
->aclass ())
773 long current_offset
= sym
->value_longest ();
774 int arg_size
= sym
->type ()->length ();
776 /* Compute address of next argument by adding the size of
777 this argument and rounding to an int boundary. */
779 ((current_offset
+ arg_size
+ sizeof (int) - 1)
780 & ~(sizeof (int) - 1));
782 /* If this is the highest offset seen yet, set
784 if (highest_offset
== -1
785 || (current_offset
> highest_offset
))
786 highest_offset
= current_offset
;
788 /* Add the number of ints we're about to print to
790 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
793 /* We care about types of symbols, but don't need to
794 keep track of stack offsets in them. */
796 case LOC_REGPARM_ADDR
:
798 case LOC_OPTIMIZED_OUT
:
803 /* We have to look up the symbol because arguments can have
804 two entries (one a parameter, one a local) and the one we
805 want is the local, which lookup_symbol will find for us.
806 This includes gcc1 (not gcc2) on SPARC when passing a
807 small structure and gcc2 when the argument type is float
808 and it is passed as a double and converted to float by
809 the prologue (in the latter case the type of the LOC_ARG
810 symbol is double and the type of the LOC_LOCAL symbol is
812 /* But if the parameter name is null, don't try it. Null
813 parameter names occur on the RS/6000, for traceback
814 tables. FIXME, should we even print them? */
816 if (*sym
->linkage_name ())
820 nsym
= lookup_symbol_search_name (sym
->search_name (),
821 b
, SEARCH_VAR_DOMAIN
).symbol
;
822 gdb_assert (nsym
!= NULL
);
823 if (nsym
->aclass () == LOC_REGISTER
824 && !nsym
->is_argument ())
826 /* There is a LOC_ARG/LOC_REGISTER pair. This means
827 that it was passed on the stack and loaded into a
828 register, or passed in a register and stored in a
829 stack slot. GDB 3.x used the LOC_ARG; GDB
830 4.0-4.11 used the LOC_REGISTER.
832 Reasons for using the LOC_ARG:
834 (1) Because find_saved_registers may be slow for
837 (2) Because registers are often re-used and stack
838 slots rarely (never?) are. Therefore using
839 the stack slot is much less likely to print
842 Reasons why we might want to use the LOC_REGISTER:
844 (1) So that the backtrace prints the same value
845 as "print foo". I see no compelling reason
846 why this needs to be the case; having the
847 backtrace print the value which was passed
848 in, and "print foo" print the value as
849 modified within the called function, makes
852 Additional note: It might be nice if "info args"
853 displayed both values.
855 One more note: There is a case with SPARC
856 structure passing where we need to use the
857 LOC_REGISTER, but this is dealt with by creating
858 a single LOC_REGPARM in symbol reading. */
860 /* Leave sym (the LOC_ARG) alone. */
867 /* Print the current arg. */
870 uiout
->wrap_hint (4);
875 arg
.entry_kind
= print_entry_values_no
;
877 entryarg
.entry_kind
= print_entry_values_no
;
880 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
882 if (arg
.entry_kind
!= print_entry_values_only
)
883 print_frame_arg (fp_opts
, &arg
);
885 if (entryarg
.entry_kind
!= print_entry_values_no
)
887 if (arg
.entry_kind
!= print_entry_values_only
)
890 uiout
->wrap_hint (4);
893 print_frame_arg (fp_opts
, &entryarg
);
900 /* Don't print nameless args in situations where we don't know
901 enough about the stack to find them. */
906 if (highest_offset
== -1)
907 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
909 start
= highest_offset
;
911 if (!print_names
&& !first
&& num
> 0)
914 print_frame_nameless_args (frame
, start
, num
- args_printed
,
919 /* Set the current source and line to the location given by frame
920 FRAME, if possible. When CENTER is true, adjust so the relevant
921 line is in the center of the next 'list'. */
924 set_current_sal_from_frame (const frame_info_ptr
&frame
)
926 symtab_and_line sal
= find_frame_sal (frame
);
927 if (sal
.symtab
!= NULL
)
928 set_current_source_symtab_and_line (sal
);
931 /* If ON, GDB will display disassembly of the next source line when
932 execution of the program being debugged stops.
933 If AUTO (which is the default), or there's no line info to determine
934 the source line of the next instruction, display disassembly of next
935 instruction instead. */
937 static enum auto_boolean disassemble_next_line
;
940 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
941 struct cmd_list_element
*c
,
945 _("Debugger's willingness to use "
946 "disassemble-next-line is %s.\n"),
950 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
951 because it will be broken by filter sometime. */
954 do_gdb_disassembly (struct gdbarch
*gdbarch
,
955 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
960 gdb_disassembly (gdbarch
, current_uiout
,
961 DISASSEMBLY_RAW_INSN
, how_many
,
964 catch (const gdb_exception_error
&exception
)
966 /* If an exception was thrown while doing the disassembly, print
967 the error message, to give the user a clue of what happened. */
968 exception_print (gdb_stderr
, exception
);
972 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
973 Value not present indicates to the caller to use default values
974 specific to the command being executed. */
976 static std::optional
<enum print_what
>
977 print_frame_info_to_print_what (const char *print_frame_info
)
979 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
980 if (print_frame_info
== print_frame_info_choices
[i
])
981 return print_frame_info_print_what
[i
];
983 internal_error ("Unexpected print frame-info value `%s'.",
987 /* Print the PC from FRAME, plus any flags, to UIOUT. */
990 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, const frame_info_ptr
&frame
,
993 uiout
->field_core_addr ("addr", gdbarch
, pc
);
995 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
999 uiout
->field_string ("addr_flags", flags
);
1007 get_user_print_what_frame_info (std::optional
<enum print_what
> *what
)
1010 = print_frame_info_to_print_what
1011 (user_frame_print_options
.print_frame_info
);
1014 /* Print information about frame FRAME. The output is format according
1015 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1016 PRINT_WHAT, see enum print_what comments in frame.h.
1017 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1018 != print_frame_info_auto.
1020 Used in "where" output, and to emit breakpoint or step
1024 do_print_frame_info (struct ui_out
*uiout
, const frame_print_options
&fp_opts
,
1025 const frame_info_ptr
&frame
, int print_level
,
1026 enum print_what print_what
, int print_args
,
1027 int set_current_sal
)
1029 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1033 if (!current_uiout
->is_mi_like_p ()
1034 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1036 /* Use the specific frame information desired by the user. */
1037 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1040 if (get_frame_type (frame
) == DUMMY_FRAME
1041 || get_frame_type (frame
) == SIGTRAMP_FRAME
1042 || get_frame_type (frame
) == ARCH_FRAME
)
1044 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1046 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1047 gdbarch
, get_frame_pc (frame
));
1049 /* Do this regardless of SOURCE because we don't have any source
1050 to list for this frame. */
1054 uiout
->field_fmt_signed (2, ui_left
, "level",
1055 frame_relative_level (frame
));
1057 if (uiout
->is_mi_like_p ())
1059 annotate_frame_address ();
1060 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1061 annotate_frame_address_end ();
1064 if (get_frame_type (frame
) == DUMMY_FRAME
)
1066 annotate_function_call ();
1067 uiout
->field_string ("func", "<function called from gdb>",
1068 metadata_style
.style ());
1070 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1072 annotate_signal_handler_caller ();
1073 uiout
->field_string ("func", "<signal handler called>",
1074 metadata_style
.style ());
1076 else if (get_frame_type (frame
) == ARCH_FRAME
)
1078 uiout
->field_string ("func", "<cross-architecture call>",
1079 metadata_style
.style ());
1082 annotate_frame_end ();
1084 /* If disassemble-next-line is set to auto or on output the next
1086 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1087 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1088 do_gdb_disassembly (get_frame_arch (frame
), 1,
1089 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1094 /* If FRAME is not the innermost frame, that normally means that
1095 FRAME->pc points to *after* the call instruction, and we want to
1096 get the line containing the call, never the next line. But if
1097 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1098 next frame was not entered as the result of a call, and we want
1099 to get the line containing FRAME->pc. */
1100 symtab_and_line sal
= find_frame_sal (frame
);
1102 location_print
= (print_what
== LOCATION
1103 || print_what
== SRC_AND_LOC
1104 || print_what
== LOC_AND_ADDRESS
1105 || print_what
== SHORT_LOCATION
);
1106 if (location_print
|| !sal
.symtab
)
1107 print_frame (uiout
, fp_opts
, frame
, print_level
,
1108 print_what
, print_args
, sal
);
1110 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1112 /* If disassemble-next-line is set to auto or on and doesn't have
1113 the line debug messages for $pc, output the next instruction. */
1114 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1115 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1116 && source_print
&& !sal
.symtab
)
1117 do_gdb_disassembly (get_frame_arch (frame
), 1,
1118 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1120 if (source_print
&& sal
.symtab
)
1122 int mid_statement
= ((print_what
== SRC_LINE
)
1123 && frame_show_address (frame
, sal
));
1124 if (annotation_level
> 0
1125 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1126 get_frame_pc (frame
)))
1128 /* The call to ANNOTATE_SOURCE_LINE already printed the
1129 annotation for this source line, so we avoid the two cases
1130 below and do not print the actual source line. The
1131 documentation for annotations makes it clear that the source
1132 line annotation is printed __instead__ of printing the source
1133 line, not as well as.
1135 However, if we fail to print the source line, which usually
1136 means either the source file is missing, or the requested
1137 line is out of range of the file, then we don't print the
1138 source annotation, and will pass through the "normal" print
1139 source line code below, the expectation is that this code
1140 will print an appropriate error. */
1142 else if (deprecated_print_frame_info_listing_hook
)
1143 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1147 struct value_print_options opts
;
1149 get_user_print_options (&opts
);
1150 /* We used to do this earlier, but that is clearly
1151 wrong. This function is used by many different
1152 parts of gdb, including normal_stop in infrun.c,
1153 which uses this to print out the current PC
1154 when we stepi/nexti into the middle of a source
1155 line. Only the command line really wants this
1156 behavior. Other UIs probably would like the
1157 ability to decide for themselves if it is desired. */
1158 if (opts
.addressprint
&& mid_statement
)
1160 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1164 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1167 /* If disassemble-next-line is set to on and there is line debug
1168 messages, output assembly codes for next line. */
1169 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1170 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1173 if (set_current_sal
)
1177 if (get_frame_pc_if_available (frame
, &pc
))
1178 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1180 last_displayed_symtab_info
.invalidate ();
1183 annotate_frame_end ();
1185 gdb_flush (gdb_stdout
);
1188 /* Redirect output to a temporary buffer for the duration
1189 of do_print_frame_info. */
1192 print_frame_info (const frame_print_options
&fp_opts
,
1193 const frame_info_ptr
&frame
, int print_level
,
1194 enum print_what print_what
, int print_args
,
1195 int set_current_sal
)
1197 do_with_buffered_output (do_print_frame_info
, current_uiout
,
1198 fp_opts
, frame
, print_level
, print_what
,
1199 print_args
, set_current_sal
);
1205 clear_last_displayed_sal (void)
1207 last_displayed_symtab_info
.invalidate ();
1213 last_displayed_sal_is_valid (void)
1215 return last_displayed_symtab_info
.is_valid ();
1220 struct program_space
*
1221 get_last_displayed_pspace (void)
1223 return last_displayed_symtab_info
.pspace ();
1229 get_last_displayed_addr (void)
1231 return last_displayed_symtab_info
.address ();
1237 get_last_displayed_symtab (void)
1239 return last_displayed_symtab_info
.symtab ();
1245 get_last_displayed_line (void)
1247 return last_displayed_symtab_info
.line ();
1253 get_last_displayed_sal ()
1255 symtab_and_line sal
;
1257 if (last_displayed_symtab_info
.is_valid ())
1259 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1260 sal
.pc
= last_displayed_symtab_info
.address ();
1261 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1262 sal
.line
= last_displayed_symtab_info
.line ();
1269 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1270 corresponding to FRAME. */
1272 gdb::unique_xmalloc_ptr
<char>
1273 find_frame_funname (const frame_info_ptr
&frame
, enum language
*funlang
,
1274 struct symbol
**funcp
)
1276 struct symbol
*func
;
1277 gdb::unique_xmalloc_ptr
<char> funname
;
1279 *funlang
= language_unknown
;
1283 func
= get_frame_function (frame
);
1286 const char *print_name
= func
->print_name ();
1288 *funlang
= func
->language ();
1291 if (*funlang
== language_cplus
)
1293 /* It seems appropriate to use print_name() here,
1294 to display the demangled name that we already have
1295 stored in the symbol table, but we stored a version
1296 with DMGL_PARAMS turned on, and here we don't want to
1297 display parameters. So remove the parameters. */
1298 funname
= cp_remove_params (print_name
);
1301 /* If we didn't hit the C++ case above, set *funname
1303 if (funname
== NULL
)
1304 funname
.reset (xstrdup (print_name
));
1308 struct bound_minimal_symbol msymbol
;
1311 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1314 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1315 if (msymbol
.minsym
!= NULL
)
1317 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1318 *funlang
= msymbol
.minsym
->language ();
1326 print_frame (struct ui_out
*uiout
,
1327 const frame_print_options
&fp_opts
,
1328 const frame_info_ptr
&frame
, int print_level
,
1329 enum print_what print_what
, int print_args
,
1330 struct symtab_and_line sal
)
1332 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1333 enum language funlang
= language_unknown
;
1334 struct value_print_options opts
;
1335 struct symbol
*func
;
1339 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1341 gdb::unique_xmalloc_ptr
<char> funname
1342 = find_frame_funname (frame
, &funlang
, &func
);
1344 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1348 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1353 uiout
->field_fmt_signed (2, ui_left
, "level",
1354 frame_relative_level (frame
));
1356 get_user_print_options (&opts
);
1357 if (opts
.addressprint
)
1359 || frame_show_address (frame
, sal
)
1360 || print_what
== LOC_AND_ADDRESS
)
1362 annotate_frame_address ();
1364 print_pc (uiout
, gdbarch
, frame
, pc
);
1366 uiout
->field_string ("addr", "<unavailable>",
1367 metadata_style
.style ());
1368 annotate_frame_address_end ();
1369 uiout
->text (" in ");
1371 annotate_frame_function_name ();
1374 gdb_puts (funname
? funname
.get () : "??", &stb
);
1375 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1376 uiout
->wrap_hint (3);
1377 annotate_frame_args ();
1384 if (gdbarch_frame_num_args_p (gdbarch
))
1386 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1387 gdb_assert (numargs
>= 0);
1393 ui_out_emit_list
list_emitter (uiout
, "args");
1396 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1398 catch (const gdb_exception_error
&e
)
1402 /* FIXME: ARGS must be a list. If one argument is a string it
1403 will have " that will not be properly escaped. */
1408 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1410 const char *filename_display
;
1412 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1413 annotate_frame_source_begin ();
1414 uiout
->wrap_hint (3);
1415 uiout
->text (" at ");
1416 annotate_frame_source_file ();
1417 uiout
->field_string ("file", filename_display
,
1418 file_name_style
.style ());
1419 if (uiout
->is_mi_like_p ())
1421 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1423 uiout
->field_string ("fullname", fullname
);
1425 annotate_frame_source_file_end ();
1427 annotate_frame_source_line ();
1428 uiout
->field_signed ("line", sal
.line
);
1429 annotate_frame_source_end ();
1432 if (print_what
!= SHORT_LOCATION
1433 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1436 = solib_name_from_address (get_frame_program_space (frame
),
1437 get_frame_address_in_block (frame
));
1441 annotate_frame_where ();
1442 uiout
->wrap_hint (2);
1443 uiout
->text (" from ");
1444 uiout
->field_string ("from", lib
, file_name_style
.style ());
1447 if (uiout
->is_mi_like_p ())
1448 uiout
->field_string ("arch",
1449 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1456 /* Completion function for "frame function", "info frame function", and
1457 "select-frame function" commands. */
1460 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1461 completion_tracker
&tracker
,
1462 const char *text
, const char *word
)
1464 /* This is used to complete function names within a stack. It would be
1465 nice if we only offered functions that were actually in the stack.
1466 However, this would mean unwinding the stack to completion, which
1467 could take too long, or on a corrupted stack, possibly not end.
1468 Instead, we offer all symbol names as a safer choice. */
1469 collect_symbol_completion_matches (tracker
,
1470 complete_symbol_mode::EXPRESSION
,
1471 symbol_name_match_type::EXPRESSION
,
1475 /* Core of all the "info frame" sub-commands. Print information about a
1476 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1477 frame specification, they just entered 'info frame'. If the user did
1478 provide a frame specification (for example 'info frame 0', 'info frame
1479 level 1') then SELECTED_FRAME_P will be false. */
1482 info_frame_command_core (const frame_info_ptr
&fi
, bool selected_frame_p
)
1484 struct symbol
*func
;
1486 frame_info_ptr calling_frame_info
;
1488 const char *funname
= 0;
1489 enum language funlang
= language_unknown
;
1490 const char *pc_regname
;
1491 struct gdbarch
*gdbarch
;
1494 /* Initialize it to avoid "may be used uninitialized" warning. */
1495 CORE_ADDR caller_pc
= 0;
1496 int caller_pc_p
= 0;
1498 gdbarch
= get_frame_arch (fi
);
1500 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1501 is not a good name. */
1502 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1503 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1504 easily not match that of the internal value returned by
1506 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1508 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1509 architectures will often have a hardware register called "pc",
1510 and that register's value, again, can easily not match
1514 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1515 func
= get_frame_function (fi
);
1516 symtab_and_line sal
= find_frame_sal (fi
);
1518 gdb::unique_xmalloc_ptr
<char> func_only
;
1521 funname
= func
->print_name ();
1522 funlang
= func
->language ();
1523 if (funlang
== language_cplus
)
1525 /* It seems appropriate to use print_name() here,
1526 to display the demangled name that we already have
1527 stored in the symbol table, but we stored a version
1528 with DMGL_PARAMS turned on, and here we don't want to
1529 display parameters. So remove the parameters. */
1530 func_only
= cp_remove_params (funname
);
1533 funname
= func_only
.get ();
1536 else if (frame_pc_p
)
1538 struct bound_minimal_symbol msymbol
;
1540 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1541 if (msymbol
.minsym
!= NULL
)
1543 funname
= msymbol
.minsym
->print_name ();
1544 funlang
= msymbol
.minsym
->language ();
1547 calling_frame_info
= get_prev_frame (fi
);
1549 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1551 gdb_printf (_("Stack level %d, frame at "),
1552 frame_relative_level (fi
));
1556 gdb_printf (_("Stack frame at "));
1558 gdb_puts (paddress (gdbarch
, get_frame_base (fi
)));
1560 gdb_printf (" %s = ", pc_regname
);
1562 gdb_puts (paddress (gdbarch
, get_frame_pc (fi
)));
1564 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1566 gdb_stdout
->wrap_here (3);
1569 gdb_printf (" in ");
1572 gdb_stdout
->wrap_here (3);
1576 styled_string (file_name_style
.style (),
1577 symtab_to_filename_for_display (sal
.symtab
)),
1580 gdb_stdout
->wrap_here (4);
1581 gdb_printf ("saved %s = ", pc_regname
);
1583 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1584 val_print_not_saved (gdb_stdout
);
1589 caller_pc
= frame_unwind_caller_pc (fi
);
1592 catch (const gdb_exception_error
&ex
)
1596 case NOT_AVAILABLE_ERROR
:
1597 val_print_unavailable (gdb_stdout
);
1599 case OPTIMIZED_OUT_ERROR
:
1600 val_print_not_saved (gdb_stdout
);
1603 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1612 gdb_puts (paddress (gdbarch
, caller_pc
));
1615 if (calling_frame_info
== NULL
)
1617 enum unwind_stop_reason reason
;
1619 reason
= get_frame_unwind_stop_reason (fi
);
1620 if (reason
!= UNWIND_NO_REASON
)
1621 gdb_printf (_(" Outermost frame: %s\n"),
1622 frame_stop_reason_string (fi
));
1624 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1625 gdb_puts (" tail call frame");
1626 else if (get_frame_type (fi
) == INLINE_FRAME
)
1627 gdb_printf (" inlined into frame %d",
1628 frame_relative_level (get_prev_frame (fi
)));
1631 gdb_printf (" called by frame at ");
1632 gdb_puts (paddress (gdbarch
, get_frame_base (calling_frame_info
)));
1634 if (get_next_frame (fi
) && calling_frame_info
)
1636 gdb_stdout
->wrap_here (3);
1637 if (get_next_frame (fi
))
1639 gdb_printf (" caller of frame at ");
1640 gdb_puts (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))));
1642 if (get_next_frame (fi
) || calling_frame_info
)
1646 gdb_printf (" source language %s.\n",
1647 language_str (s
->language ()));
1650 /* Address of the argument list for this frame, or 0. */
1651 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1652 /* Number of args for this frame, or -1 if unknown. */
1656 gdb_printf (" Arglist at unknown address.\n");
1659 gdb_printf (" Arglist at ");
1660 gdb_puts (paddress (gdbarch
, arg_list
));
1663 if (!gdbarch_frame_num_args_p (gdbarch
))
1666 gdb_puts (" args: ");
1670 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1671 gdb_assert (numargs
>= 0);
1673 gdb_puts (" no args.");
1674 else if (numargs
== 1)
1675 gdb_puts (" 1 arg: ");
1677 gdb_printf (" %d args: ", numargs
);
1680 print_frame_args (user_frame_print_options
,
1681 func
, fi
, numargs
, gdb_stdout
);
1686 /* Address of the local variables for this frame, or 0. */
1687 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1690 gdb_printf (" Locals at unknown address,");
1693 gdb_printf (" Locals at ");
1694 gdb_puts (paddress (gdbarch
, arg_list
));
1699 /* Print as much information as possible on the location of all the
1705 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1707 /* The sp is special; what's displayed isn't the save address, but
1708 the value of the previous frame's sp. This is a legacy thing,
1709 at one stage the frame cached the previous frame's SP instead
1710 of its address, hence it was easiest to just display the cached
1714 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1715 gdb_assert (value
!= NULL
);
1717 if (!value
->optimized_out () && value
->entirely_available ())
1719 if (value
->lval () == not_lval
)
1722 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1723 int sp_size
= register_size (gdbarch
, sp_regnum
);
1725 sp
= extract_unsigned_integer
1726 (value
->contents_all ().data (), sp_size
, byte_order
);
1728 gdb_printf (" Previous frame's sp is ");
1729 gdb_puts (paddress (gdbarch
, sp
));
1732 else if (value
->lval () == lval_memory
)
1734 gdb_printf (" Previous frame's sp at ");
1735 gdb_puts (paddress (gdbarch
, value
->address ()));
1738 else if (value
->lval () == lval_register
)
1739 gdb_printf (" Previous frame's sp in %s\n",
1740 gdbarch_register_name (gdbarch
, value
->regnum ()));
1742 release_value (value
);
1745 /* else keep quiet. */
1749 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1750 for (i
= 0; i
< numregs
; i
++)
1752 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1754 enum lval_type lval
;
1760 /* Find out the location of the saved register without
1761 fetching the corresponding value. */
1762 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1763 &lval
, &addr
, &realnum
, NULL
);
1764 /* For moment, only display registers that were saved on the
1766 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1769 gdb_puts (" Saved registers:\n ");
1772 gdb_stdout
->wrap_here (1);
1773 gdb_printf (" %s at ",
1774 gdbarch_register_name (gdbarch
, i
));
1775 gdb_puts (paddress (gdbarch
, addr
));
1779 if (count
|| need_nl
)
1784 /* Return the innermost frame at level LEVEL. */
1786 static frame_info_ptr
1787 leading_innermost_frame (int level
)
1789 frame_info_ptr leading
;
1791 leading
= get_current_frame ();
1793 gdb_assert (level
>= 0);
1795 while (leading
!= nullptr && level
)
1798 leading
= get_prev_frame (leading
);
1805 /* Return the starting frame needed to handle COUNT outermost frames. */
1807 static frame_info_ptr
1808 trailing_outermost_frame (int count
)
1810 frame_info_ptr current
;
1811 frame_info_ptr trailing
;
1813 trailing
= get_current_frame ();
1815 gdb_assert (count
> 0);
1818 while (current
!= nullptr && count
--)
1821 current
= get_prev_frame (current
);
1824 /* Will stop when CURRENT reaches the top of the stack.
1825 TRAILING will be COUNT below it. */
1826 while (current
!= nullptr)
1829 trailing
= get_prev_frame (trailing
);
1830 current
= get_prev_frame (current
);
1836 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1840 select_frame_command_core (const frame_info_ptr
&fi
, bool ignored
)
1842 frame_info_ptr prev_frame
= get_selected_frame ();
1844 if (get_selected_frame () != prev_frame
)
1845 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1848 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1849 means we change frame send out a change notification (otherwise, just
1850 reprint the current frame summary). */
1853 frame_command_core (const frame_info_ptr
&fi
, bool ignored
)
1855 frame_info_ptr prev_frame
= get_selected_frame ();
1857 if (get_selected_frame () != prev_frame
)
1858 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
1860 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1863 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1864 common set of sub-commands that allow a specific frame to be selected.
1865 All of the sub-command functions are static methods within this class
1866 template which is then instantiated below. The template parameter is a
1867 callback used to implement the functionality of the base command
1868 ('frame', 'select-frame', or 'info frame').
1870 In the template parameter FI is the frame being selected. The
1871 SELECTED_FRAME_P flag is true if the frame being selected was done by
1872 default, which happens when the user uses the base command with no
1873 arguments. For example the commands 'info frame', 'select-frame',
1874 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1875 SELECTED_FRAME_P is false. */
1877 template <void (*FPTR
) (const frame_info_ptr
&fi
, bool selected_frame_p
)>
1878 class frame_command_helper
1882 /* The "frame level" family of commands. The ARG is an integer that is
1883 the frame's level in the stack. */
1885 level (const char *arg
, int from_tty
)
1887 int level
= value_as_long (parse_and_eval (arg
));
1889 = find_relative_frame (get_current_frame (), &level
);
1891 error (_("No frame at level %s."), arg
);
1895 /* The "frame address" family of commands. ARG is a stack-pointer
1896 address for an existing frame. This command does not allow new
1897 frames to be created. */
1900 address (const char *arg
, int from_tty
)
1902 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1903 frame_info_ptr fid
= find_frame_for_address (addr
);
1905 error (_("No frame at address %s."), arg
);
1909 /* The "frame view" family of commands. ARG is one or two addresses and
1910 is used to view a frame that might be outside the current backtrace.
1911 The addresses are stack-pointer address, and (optional) pc-address. */
1914 view (const char *args
, int from_tty
)
1919 error (_("Missing address argument to view a frame"));
1921 gdb_argv
argv (args
);
1923 if (argv
.count () == 2)
1927 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1928 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1929 fid
= create_new_frame (addr
[0], addr
[1]);
1933 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1934 fid
= create_new_frame (addr
, false);
1939 /* The "frame function" family of commands. ARG is the name of a
1940 function within the stack, the first function (searching from frame
1941 0) with that name will be selected. */
1944 function (const char *arg
, int from_tty
)
1947 error (_("Missing function name argument"));
1948 frame_info_ptr fid
= find_frame_for_function (arg
);
1950 error (_("No frame for function \"%s\"."), arg
);
1954 /* The "frame" base command, that is, when no sub-command is specified.
1955 If one argument is provided then we assume that this is a frame's
1956 level as historically, this was the supported command syntax that was
1959 If no argument is provided, then the current frame is selected. */
1962 base_command (const char *arg
, int from_tty
)
1965 FPTR (get_selected_frame (_("No stack.")), true);
1967 level (arg
, from_tty
);
1971 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1972 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1974 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1975 static frame_command_helper
<frame_command_core
> frame_cmd
;
1976 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1978 /* Print briefly all stack frames or just the innermost COUNT_EXP
1982 backtrace_command_1 (const frame_print_options
&fp_opts
,
1983 const backtrace_cmd_options
&bt_opts
,
1984 const char *count_exp
, int from_tty
)
1989 int py_start
= 0, py_end
= 0;
1990 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1992 if (!target_has_stack ())
1993 error (_("No stack."));
1997 count
= parse_and_eval_long (count_exp
);
2003 /* The argument to apply_ext_lang_frame_filter is the number
2004 of the final frame to print, and frames start at 0. */
2014 frame_filter_flags flags
= 0;
2017 flags
|= PRINT_LOCALS
;
2019 flags
|= PRINT_HIDE
;
2020 if (fp_opts
.print_raw_frame_arguments
)
2021 flags
|= PRINT_RAW_FRAME_ARGUMENTS
;
2023 if (!bt_opts
.no_filters
)
2025 enum ext_lang_frame_args arg_type
;
2027 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2029 flags
|= PRINT_MORE_FRAMES
;
2031 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2032 arg_type
= CLI_SCALAR_VALUES
;
2033 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2034 arg_type
= CLI_ALL_VALUES
;
2035 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2036 arg_type
= CLI_PRESENCE
;
2037 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2038 arg_type
= NO_VALUES
;
2042 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2043 arg_type
, current_uiout
,
2047 /* Run the inbuilt backtrace if there are no filters registered, or
2048 "-no-filters" has been specified from the command. */
2049 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2051 frame_info_ptr trailing
;
2053 /* The following code must do two things. First, it must set the
2054 variable TRAILING to the frame from which we should start
2055 printing. Second, it must set the variable count to the number
2056 of frames which we should print, or -1 if all of them. */
2058 if (count_exp
!= NULL
&& count
< 0)
2060 trailing
= trailing_outermost_frame (-count
);
2064 trailing
= get_current_frame ();
2066 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2070 /* Don't use print_stack_frame; if an error() occurs it probably
2071 means further attempts to backtrace would fail (on the other
2072 hand, perhaps the code does or could be fixed to make sure
2073 the frame->prev field gets set to NULL in that case). */
2075 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2076 if ((flags
& PRINT_LOCALS
) != 0)
2077 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2079 /* Save the last frame to check for error conditions. */
2083 /* If we've stopped before the end, mention that. */
2085 gdb_printf (_("(More stack frames follow...)\n"));
2087 /* If we've run out of frames, and the reason appears to be an error
2088 condition, print it. */
2089 if (fi
== NULL
&& trailing
!= NULL
)
2091 enum unwind_stop_reason reason
;
2093 reason
= get_frame_unwind_stop_reason (trailing
);
2094 if (reason
>= UNWIND_FIRST_ERROR
)
2095 gdb_printf (_("Backtrace stopped: %s\n"),
2096 frame_stop_reason_string (trailing
));
2101 /* Create an option_def_group array grouping all the "backtrace"
2102 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2104 static inline std::array
<gdb::option::option_def_group
, 3>
2105 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2106 backtrace_cmd_options
*bt_cmd_opts
,
2107 set_backtrace_options
*set_bt_opts
)
2110 { {frame_print_option_defs
}, fp_opts
},
2111 { {set_backtrace_option_defs
}, set_bt_opts
},
2112 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2116 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2117 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2118 store the parsed qualifiers. */
2121 parse_backtrace_qualifiers (const char *arg
,
2122 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2126 const char *save_arg
= arg
;
2127 std::string this_arg
= extract_arg (&arg
);
2129 if (this_arg
.empty ())
2132 if (startswith ("no-filters", this_arg
))
2134 if (bt_cmd_opts
!= nullptr)
2135 bt_cmd_opts
->no_filters
= true;
2137 else if (startswith ("full", this_arg
))
2139 if (bt_cmd_opts
!= nullptr)
2140 bt_cmd_opts
->full
= true;
2142 else if (startswith ("hide", this_arg
))
2144 if (bt_cmd_opts
!= nullptr)
2145 bt_cmd_opts
->hide
= true;
2149 /* Not a recognized qualifier, so stop. */
2156 backtrace_command (const char *arg
, int from_tty
)
2158 frame_print_options fp_opts
= user_frame_print_options
;
2159 backtrace_cmd_options bt_cmd_opts
;
2160 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2163 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2164 gdb::option::process_options
2165 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2167 /* Parse non-'-'-prefixed qualifiers, for backwards
2171 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2176 /* These options are handled quite deep in the unwind machinery, so
2177 we get to pass them down by swapping globals. */
2178 scoped_restore restore_set_backtrace_options
2179 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2181 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2184 /* Completer for the "backtrace" command. */
2187 backtrace_command_completer (struct cmd_list_element
*ignore
,
2188 completion_tracker
&tracker
,
2189 const char *text
, const char */
*word*/
)
2192 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2193 if (gdb::option::complete_options
2194 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2199 const char *p
= skip_to_space (text
);
2202 static const char *const backtrace_cmd_qualifier_choices
[] = {
2203 "full", "no-filters", "hide", nullptr,
2205 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2208 if (tracker
.have_completions ())
2213 const char *cmd
= parse_backtrace_qualifiers (text
);
2214 tracker
.advance_custom_word_point_by (cmd
- text
);
2219 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2220 expression_completer (ignore
, tracker
, text
, word
);
2223 /* Iterate over the local variables of a block B, calling CB. */
2226 iterate_over_block_locals (const struct block
*b
,
2227 iterate_over_block_arg_local_vars_cb cb
)
2229 for (struct symbol
*sym
: block_iterator_range (b
))
2231 switch (sym
->aclass ())
2238 case LOC_OPTIMIZED_OUT
:
2239 if (sym
->is_argument ())
2241 if (sym
->domain () == COMMON_BLOCK_DOMAIN
)
2243 cb (sym
->print_name (), sym
);
2247 /* Ignore symbols which are not locals. */
2253 /* Iterate over all the local variables in block B, including all its
2254 superblocks, stopping when the top-level block is reached. */
2257 iterate_over_block_local_vars (const struct block
*block
,
2258 iterate_over_block_arg_local_vars_cb cb
)
2262 iterate_over_block_locals (block
, cb
);
2263 /* After handling the function's top-level block, stop. Don't
2264 continue to its superblock, the block of per-file
2266 if (block
->function ())
2268 block
= block
->superblock ();
2272 /* Data to be passed around in the calls to the locals and args
2275 struct print_variable_and_value_data
2277 std::optional
<compiled_regex
> preg
;
2278 std::optional
<compiled_regex
> treg
;
2279 struct frame_id frame_id
;
2281 struct ui_file
*stream
;
2284 void operator() (const char *print_name
, struct symbol
*sym
);
2287 /* The callback for the locals and args iterators. */
2290 print_variable_and_value_data::operator() (const char *print_name
,
2293 frame_info_ptr frame
;
2295 if (preg
.has_value ()
2296 && preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2298 if (treg
.has_value ()
2299 && !treg_matches_sym_type_name (*treg
, sym
))
2301 if (language_def (sym
->language ())->symbol_printing_suppressed (sym
))
2304 frame
= frame_find_by_id (frame_id
);
2307 warning (_("Unable to restore previously selected frame."));
2311 print_variable_and_value (print_name
, sym
, frame
, stream
, num_tabs
);
2316 /* Prepares the regular expression REG from REGEXP.
2317 If REGEXP is NULL, it results in an empty regular expression. */
2320 prepare_reg (const char *regexp
, std::optional
<compiled_regex
> *reg
)
2324 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2326 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2332 /* Print all variables from the innermost up to the function block of FRAME.
2333 Print them with values to STREAM indented by NUM_TABS.
2334 If REGEXP is not NULL, only print local variables whose name
2336 If T_REGEXP is not NULL, only print local variables whose type
2338 If no local variables have been printed and !QUIET, prints a message
2339 explaining why no local variables could be printed. */
2342 print_frame_local_vars (const frame_info_ptr
&frame
,
2344 const char *regexp
, const char *t_regexp
,
2345 int num_tabs
, struct ui_file
*stream
)
2347 struct print_variable_and_value_data cb_data
;
2348 const struct block
*block
;
2351 if (!get_frame_pc_if_available (frame
, &pc
))
2355 _("PC unavailable, cannot determine locals.\n"));
2359 block
= get_frame_block (frame
, 0);
2363 gdb_printf (stream
, "No symbol table info available.\n");
2367 prepare_reg (regexp
, &cb_data
.preg
);
2368 prepare_reg (t_regexp
, &cb_data
.treg
);
2369 cb_data
.frame_id
= get_frame_id (frame
);
2370 cb_data
.num_tabs
= 4 * num_tabs
;
2371 cb_data
.stream
= stream
;
2372 cb_data
.values_printed
= 0;
2374 /* Temporarily change the selected frame to the given FRAME.
2375 This allows routines that rely on the selected frame instead
2376 of being given a frame as parameter to use the correct frame. */
2377 scoped_restore_selected_frame restore_selected_frame
;
2378 select_frame (frame
);
2380 iterate_over_block_local_vars (block
, cb_data
);
2382 if (!cb_data
.values_printed
&& !quiet
)
2384 if (regexp
== NULL
&& t_regexp
== NULL
)
2385 gdb_printf (stream
, _("No locals.\n"));
2387 gdb_printf (stream
, _("No matching locals.\n"));
2391 /* Structure to hold the values of the options used by the 'info
2392 variables' command and other similar commands. These correspond to the
2393 -q and -t options. */
2395 struct info_print_options
2398 std::string type_regexp
;
2401 /* The options used by the 'info locals' and 'info args' commands. */
2403 static const gdb::option::option_def info_print_options_defs
[] = {
2404 gdb::option::boolean_option_def
<info_print_options
> {
2406 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2407 nullptr, /* show_cmd_cb */
2408 nullptr /* set_doc */
2411 gdb::option::string_option_def
<info_print_options
> {
2413 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2414 nullptr, /* show_cmd_cb */
2415 nullptr /* set_doc */
2419 /* Returns the option group used by 'info locals' and 'info args'
2422 static gdb::option::option_def_group
2423 make_info_print_options_def_group (info_print_options
*opts
)
2425 return {{info_print_options_defs
}, opts
};
2428 /* Command completer for 'info locals' and 'info args'. */
2431 info_print_command_completer (struct cmd_list_element
*ignore
,
2432 completion_tracker
&tracker
,
2433 const char *text
, const char * /* word */)
2436 = make_info_print_options_def_group (nullptr);
2437 if (gdb::option::complete_options
2438 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2441 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2442 symbol_completer (ignore
, tracker
, text
, word
);
2445 /* Implement the 'info locals' command. */
2448 info_locals_command (const char *args
, int from_tty
)
2450 info_print_options opts
;
2451 auto grp
= make_info_print_options_def_group (&opts
);
2452 gdb::option::process_options
2453 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2454 if (args
!= nullptr && *args
== '\0')
2457 print_frame_local_vars
2458 (get_selected_frame (_("No frame selected.")),
2460 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2464 /* Iterate over all the argument variables in block B. */
2467 iterate_over_block_arg_vars (const struct block
*b
,
2468 iterate_over_block_arg_local_vars_cb cb
)
2470 for (struct symbol
*sym
: block_iterator_range (b
))
2472 /* Don't worry about things which aren't arguments. */
2473 if (sym
->is_argument ())
2475 /* We have to look up the symbol because arguments can have
2476 two entries (one a parameter, one a local) and the one we
2477 want is the local, which lookup_symbol will find for us.
2478 This includes gcc1 (not gcc2) on the sparc when passing a
2479 small structure and gcc2 when the argument type is float
2480 and it is passed as a double and converted to float by
2481 the prologue (in the latter case the type of the LOC_ARG
2482 symbol is double and the type of the LOC_LOCAL symbol is
2483 float). There are also LOC_ARG/LOC_REGISTER pairs which
2484 are not combined in symbol-reading. */
2487 = lookup_symbol_search_name (sym
->search_name (),
2488 b
, SEARCH_VAR_DOMAIN
).symbol
;
2489 cb (sym
->print_name (), sym2
);
2494 /* Print all argument variables of the function of FRAME.
2495 Print them with values to STREAM.
2496 If REGEXP is not NULL, only print argument variables whose name
2498 If T_REGEXP is not NULL, only print argument variables whose type
2500 If no argument variables have been printed and !QUIET, prints a message
2501 explaining why no argument variables could be printed. */
2504 print_frame_arg_vars (const frame_info_ptr
&frame
,
2506 const char *regexp
, const char *t_regexp
,
2507 struct ui_file
*stream
)
2509 struct print_variable_and_value_data cb_data
;
2510 struct symbol
*func
;
2512 std::optional
<compiled_regex
> preg
;
2513 std::optional
<compiled_regex
> treg
;
2515 if (!get_frame_pc_if_available (frame
, &pc
))
2519 _("PC unavailable, cannot determine args.\n"));
2523 func
= get_frame_function (frame
);
2527 gdb_printf (stream
, _("No symbol table info available.\n"));
2531 prepare_reg (regexp
, &cb_data
.preg
);
2532 prepare_reg (t_regexp
, &cb_data
.treg
);
2533 cb_data
.frame_id
= get_frame_id (frame
);
2534 cb_data
.num_tabs
= 0;
2535 cb_data
.stream
= stream
;
2536 cb_data
.values_printed
= 0;
2538 iterate_over_block_arg_vars (func
->value_block (), cb_data
);
2540 if (!cb_data
.values_printed
&& !quiet
)
2542 if (regexp
== NULL
&& t_regexp
== NULL
)
2543 gdb_printf (stream
, _("No arguments.\n"));
2545 gdb_printf (stream
, _("No matching arguments.\n"));
2549 /* Implement the 'info args' command. */
2552 info_args_command (const char *args
, int from_tty
)
2554 info_print_options opts
;
2555 auto grp
= make_info_print_options_def_group (&opts
);
2556 gdb::option::process_options
2557 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2558 if (args
!= nullptr && *args
== '\0')
2561 print_frame_arg_vars
2562 (get_selected_frame (_("No frame selected.")),
2564 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2568 /* Return the symbol-block in which the selected frame is executing.
2569 Can return zero under various legitimate circumstances.
2571 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2572 code address within the block returned. We use this to decide
2573 which macros are in scope. */
2575 const struct block
*
2576 get_selected_block (CORE_ADDR
*addr_in_block
)
2578 if (!has_stack_frames ())
2581 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2584 /* Find a frame a certain number of levels away from FRAME.
2585 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2586 Positive means go to earlier frames (up); negative, the reverse.
2587 The int that contains the number of levels is counted toward
2588 zero as the frames for those levels are found.
2589 If the top or bottom frame is reached, that frame is returned,
2590 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2591 how much farther the original request asked to go. */
2594 find_relative_frame (frame_info_ptr frame
, int *level_offset_ptr
)
2596 /* Going up is simple: just call get_prev_frame enough times or
2597 until the initial frame is reached. */
2598 while (*level_offset_ptr
> 0)
2600 frame_info_ptr prev
= get_prev_frame (frame
);
2604 (*level_offset_ptr
)--;
2608 /* Going down is just as simple. */
2609 while (*level_offset_ptr
< 0)
2611 frame_info_ptr next
= get_next_frame (frame
);
2615 (*level_offset_ptr
)++;
2622 /* Select the frame up one or COUNT_EXP stack levels from the
2623 previously selected frame, and print it briefly. */
2626 up_silently_base (const char *count_exp
)
2628 frame_info_ptr frame
;
2632 count
= parse_and_eval_long (count_exp
);
2634 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2635 if (count
!= 0 && count_exp
== NULL
)
2636 error (_("Initial frame selected; you cannot go up."));
2637 select_frame (frame
);
2641 up_silently_command (const char *count_exp
, int from_tty
)
2643 up_silently_base (count_exp
);
2647 up_command (const char *count_exp
, int from_tty
)
2649 up_silently_base (count_exp
);
2650 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2653 /* Select the frame down one or COUNT_EXP stack levels from the previously
2654 selected frame, and print it briefly. */
2657 down_silently_base (const char *count_exp
)
2659 frame_info_ptr frame
;
2663 count
= -parse_and_eval_long (count_exp
);
2665 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2666 if (count
!= 0 && count_exp
== NULL
)
2668 /* We only do this if COUNT_EXP is not specified. That way
2669 "down" means to really go down (and let me know if that is
2670 impossible), but "down 9999" can be used to mean go all the
2671 way down without getting an error. */
2673 error (_("Bottom (innermost) frame selected; you cannot go down."));
2676 select_frame (frame
);
2680 down_silently_command (const char *count_exp
, int from_tty
)
2682 down_silently_base (count_exp
);
2686 down_command (const char *count_exp
, int from_tty
)
2688 down_silently_base (count_exp
);
2689 notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2693 return_command (const char *retval_exp
, int from_tty
)
2695 /* Initialize it just to avoid a GCC false warning. */
2696 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2697 frame_info_ptr thisframe
;
2698 struct gdbarch
*gdbarch
;
2699 struct symbol
*thisfun
;
2700 struct value
*return_value
= NULL
;
2701 struct value
*function
= NULL
;
2702 std::string query_prefix
;
2704 thisframe
= get_selected_frame ("No selected frame.");
2705 thisfun
= get_frame_function (thisframe
);
2706 gdbarch
= get_frame_arch (thisframe
);
2708 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2709 error (_("Can not force return from an inlined function."));
2711 /* Compute the return value. If the computation triggers an error,
2712 let it bail. If the return type can't be handled, set
2713 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2717 expression_up retval_expr
= parse_expression (retval_exp
);
2718 struct type
*return_type
= NULL
;
2720 /* Compute the return value. Should the computation fail, this
2721 call throws an error. */
2722 return_value
= retval_expr
->evaluate ();
2724 /* Cast return value to the return type of the function. Should
2725 the cast fail, this call throws an error. */
2726 if (thisfun
!= NULL
)
2727 return_type
= thisfun
->type ()->target_type ();
2728 if (return_type
== NULL
)
2730 if (retval_expr
->first_opcode () != UNOP_CAST
2731 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2732 error (_("Return value type not available for selected "
2734 "Please use an explicit cast of the value to return."));
2735 return_type
= return_value
->type ();
2737 return_type
= check_typedef (return_type
);
2738 return_value
= value_cast (return_type
, return_value
);
2740 /* Make sure the value is fully evaluated. It may live in the
2741 stack frame we're about to pop. */
2742 if (return_value
->lazy ())
2743 return_value
->fetch_lazy ();
2745 if (thisfun
!= NULL
)
2746 function
= read_var_value (thisfun
, NULL
, thisframe
);
2748 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2749 if (return_type
->code () == TYPE_CODE_VOID
)
2750 /* If the return-type is "void", don't try to find the
2751 return-value's location. However, do still evaluate the
2752 return expression so that, even when the expression result
2753 is discarded, side effects such as "return i++" still
2755 return_value
= NULL
;
2756 else if (thisfun
!= NULL
)
2758 if (is_nocall_function (check_typedef (function
->type ())))
2761 string_printf ("Function '%s' does not follow the target "
2762 "calling convention.\n"
2763 "If you continue, setting the return value "
2764 "will probably lead to unpredictable "
2766 thisfun
->print_name ());
2769 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2770 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2771 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2773 query_prefix
= "The location at which to store the "
2774 "function's return value is unknown.\n"
2775 "If you continue, the return value "
2776 "that you specified will be ignored.\n";
2777 return_value
= NULL
;
2782 /* Does an interactive user really want to do this? Include
2783 information, such as how well GDB can handle the return value, in
2784 the query message. */
2789 if (thisfun
== NULL
)
2790 confirmed
= query (_("%sMake selected stack frame return now? "),
2791 query_prefix
.c_str ());
2794 if (TYPE_NO_RETURN (thisfun
->type ()))
2795 warning (_("Function does not return normally to caller."));
2796 confirmed
= query (_("%sMake %s return now? "),
2797 query_prefix
.c_str (),
2798 thisfun
->print_name ());
2801 error (_("Not confirmed"));
2804 /* Discard the selected frame and all frames inner-to it. */
2805 frame_pop (get_selected_frame (NULL
));
2807 /* Store RETURN_VALUE in the just-returned register set. */
2808 if (return_value
!= NULL
)
2810 struct type
*return_type
= return_value
->type ();
2811 regcache
*regcache
= get_thread_regcache (inferior_thread ());
2812 struct gdbarch
*cache_arch
= regcache
->arch ();
2814 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2815 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2816 gdbarch_return_value_as_value
2817 (cache_arch
, function
, return_type
, regcache
, NULL
/*read*/,
2818 return_value
->contents ().data () /*write*/);
2821 /* If we are at the end of a call dummy now, pop the dummy frame
2823 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2824 frame_pop (get_current_frame ());
2826 select_frame (get_current_frame ());
2827 /* If interactive, print the frame that is now current. */
2829 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2832 /* Find the most inner frame in the current stack for a function called
2833 FUNCTION_NAME. If no matching frame is found return NULL. */
2835 static frame_info_ptr
2836 find_frame_for_function (const char *function_name
)
2838 /* Used to hold the lower and upper addresses for each of the
2839 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2840 struct function_bounds
2842 CORE_ADDR low
, high
;
2844 frame_info_ptr frame
;
2848 gdb_assert (function_name
!= NULL
);
2850 frame
= get_current_frame ();
2851 std::vector
<symtab_and_line
> sals
2852 = decode_line_with_current_source (function_name
,
2853 DECODE_LINE_FUNFIRSTLINE
);
2854 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2855 for (size_t i
= 0; i
< sals
.size (); i
++)
2857 if (sals
[i
].pspace
!= current_program_space
)
2858 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2859 else if (sals
[i
].pc
== 0
2860 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2861 &func_bounds
[i
].low
,
2862 &func_bounds
[i
].high
) == 0)
2863 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2868 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2869 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2870 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2874 frame
= find_relative_frame (frame
, &level
);
2877 while (!found
&& level
== 0);
2885 /* The qcs command line flags for the "frame apply" commands. Keep
2886 this in sync with the "thread apply" commands. */
2888 using qcs_flag_option_def
2889 = gdb::option::flag_option_def
<qcs_flags
>;
2891 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2892 qcs_flag_option_def
{
2893 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2894 N_("Disables printing the frame location information."),
2897 qcs_flag_option_def
{
2898 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2899 N_("Print any error raised by COMMAND and continue."),
2902 qcs_flag_option_def
{
2903 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2904 N_("Silently ignore any errors or empty output produced by COMMAND."),
2908 /* Create an option_def_group array for all the "frame apply" options,
2909 with FLAGS and SET_BT_OPTS as context. */
2911 static inline std::array
<gdb::option::option_def_group
, 2>
2912 make_frame_apply_options_def_group (qcs_flags
*flags
,
2913 set_backtrace_options
*set_bt_opts
)
2916 { {fr_qcs_flags_option_defs
}, flags
},
2917 { {set_backtrace_option_defs
}, set_bt_opts
},
2921 /* Apply a GDB command to all stack frames, or a set of identified frames,
2922 or innermost COUNT frames.
2923 With a negative COUNT, apply command on outermost -COUNT frames.
2925 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2926 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2927 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2928 frame apply all -s p local_var_no_idea_in_which_frame
2929 If a frame has a local variable called
2930 local_var_no_idea_in_which_frame, print frame
2931 and value of local_var_no_idea_in_which_frame.
2932 frame apply all -s -q p local_var_no_idea_in_which_frame
2933 Same as before, but only print the variable value.
2934 frame apply level 2-5 0 4-7 -s p i = i + 1
2935 Adds 1 to the variable i in the specified frames.
2936 Note that i will be incremented twice in
2939 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2940 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2941 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2942 for error messages. */
2945 frame_apply_command_count (const char *which_command
,
2946 const char *cmd
, int from_tty
,
2947 frame_info_ptr trailing
, int count
)
2950 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2952 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2953 gdb::option::process_options
2954 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2956 validate_flags_qcs (which_command
, &flags
);
2958 if (cmd
== NULL
|| *cmd
== '\0')
2959 error (_("Please specify a command to apply on the selected frames"));
2961 /* The below will restore the current inferior/thread/frame.
2962 Usually, only the frame is effectively to be restored.
2963 But in case CMD switches of inferior/thread, better restore
2965 scoped_restore_current_thread restore_thread
;
2967 /* These options are handled quite deep in the unwind machinery, so
2968 we get to pass them down by swapping globals. */
2969 scoped_restore restore_set_backtrace_options
2970 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2972 for (frame_info_ptr fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2979 std::string cmd_result
;
2981 /* In case CMD switches of inferior/thread/frame, the below
2982 restores the inferior/thread/frame. FI can then be
2983 set to the selected frame. */
2984 scoped_restore_current_thread restore_fi_current_frame
;
2986 execute_command_to_string
2987 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
2989 fi
= get_selected_frame (_("frame apply "
2990 "unable to get selected frame."));
2991 if (!flags
.silent
|| cmd_result
.length () > 0)
2994 print_stack_frame (fi
, 1, LOCATION
, 0);
2995 gdb_printf ("%s", cmd_result
.c_str ());
2998 catch (const gdb_exception_error
&ex
)
3000 fi
= get_selected_frame (_("frame apply "
3001 "unable to get selected frame."));
3005 print_stack_frame (fi
, 1, LOCATION
, 0);
3007 gdb_printf ("%s\n", ex
.what ());
3015 /* Completer for the "frame apply ..." commands. */
3018 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3020 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3021 if (gdb::option::complete_options
3022 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3025 complete_nested_command_line (tracker
, text
);
3028 /* Completer for the "frame apply" commands. */
3031 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3032 completion_tracker
&tracker
,
3033 const char *text
, const char */
*word*/
)
3035 /* Do this explicitly because there's an early return below. */
3036 tracker
.set_use_custom_word_point (true);
3038 number_or_range_parser
levels (text
);
3040 /* Skip the LEVEL list to find the options and command args. */
3043 while (!levels
.finished ())
3045 /* Call for effect. */
3046 levels
.get_number ();
3048 if (levels
.in_range ())
3049 levels
.skip_range ();
3052 catch (const gdb_exception_error
&ex
)
3054 /* get_number throws if it parses a negative number, for
3055 example. But a seemingly negative number may be the start of
3056 an option instead. */
3059 const char *cmd
= levels
.cur_tok ();
3063 /* No level list yet. */
3067 /* Check if we're past a valid LEVEL already. */
3068 if (levels
.finished ()
3069 && cmd
> text
&& !isspace (cmd
[-1]))
3072 /* We're past LEVELs, advance word point. */
3073 tracker
.advance_custom_word_point_by (cmd
- text
);
3076 frame_apply_completer (tracker
, text
);
3079 /* Completer for the "frame apply all" command. */
3082 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3083 completion_tracker
&tracker
,
3084 const char *text
, const char */
*word*/
)
3086 frame_apply_completer (tracker
, text
);
3089 /* Completer for the "frame apply COUNT" command. */
3092 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3093 completion_tracker
&tracker
,
3094 const char *text
, const char */
*word*/
)
3096 const char *cmd
= text
;
3098 int count
= get_number_trailer (&cmd
, 0);
3102 /* Check if we're past a valid COUNT already. */
3103 if (cmd
> text
&& !isspace (cmd
[-1]))
3106 /* We're past COUNT, advance word point. */
3107 tracker
.advance_custom_word_point_by (cmd
- text
);
3110 frame_apply_completer (tracker
, text
);
3113 /* Implementation of the "frame apply level" command. */
3116 frame_apply_level_command (const char *cmd
, int from_tty
)
3118 if (!target_has_stack ())
3119 error (_("No stack."));
3121 bool level_found
= false;
3122 const char *levels_str
= cmd
;
3123 number_or_range_parser
levels (levels_str
);
3125 /* Skip the LEVEL list to find the flags and command args. */
3126 while (!levels
.finished ())
3128 /* Call for effect. */
3129 levels
.get_number ();
3132 if (levels
.in_range ())
3133 levels
.skip_range ();
3137 error (_("Missing or invalid LEVEL... argument"));
3139 cmd
= levels
.cur_tok ();
3141 /* Redo the LEVELS parsing, but applying COMMAND. */
3142 levels
.init (levels_str
);
3143 while (!levels
.finished ())
3145 const int level_beg
= levels
.get_number ();
3148 if (levels
.in_range ())
3150 n_frames
= levels
.end_value () - level_beg
+ 1;
3151 levels
.skip_range ();
3156 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3157 leading_innermost_frame (level_beg
), n_frames
);
3161 /* Implementation of the "frame apply all" command. */
3164 frame_apply_all_command (const char *cmd
, int from_tty
)
3166 if (!target_has_stack ())
3167 error (_("No stack."));
3169 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3170 get_current_frame (), INT_MAX
);
3173 /* Implementation of the "frame apply" command. */
3176 frame_apply_command (const char* cmd
, int from_tty
)
3179 frame_info_ptr trailing
;
3181 if (!target_has_stack ())
3182 error (_("No stack."));
3185 error (_("Missing COUNT argument."));
3186 count
= get_number_trailer (&cmd
, 0);
3188 error (_("Invalid COUNT argument."));
3192 trailing
= trailing_outermost_frame (-count
);
3196 trailing
= get_current_frame ();
3198 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3202 /* Implementation of the "faas" command. */
3205 faas_command (const char *cmd
, int from_tty
)
3207 if (cmd
== NULL
|| *cmd
== '\0')
3208 error (_("Please specify a command to apply on all frames"));
3209 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3210 execute_command (expanded
.c_str (), from_tty
);
3214 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3215 matching frame can be found. */
3217 static frame_info_ptr
3218 find_frame_for_address (CORE_ADDR address
)
3223 id
= frame_id_build_wild (address
);
3225 /* If (s)he specifies the frame with an address, he deserves
3226 what (s)he gets. Still, give the highest one that matches.
3227 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3229 for (fid
= get_current_frame ();
3231 fid
= get_prev_frame (fid
))
3233 if (id
== get_frame_id (fid
))
3235 frame_info_ptr prev_frame
;
3239 prev_frame
= get_prev_frame (fid
);
3241 || id
!= get_frame_id (prev_frame
))
3253 /* Commands with a prefix of `frame apply'. */
3254 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3256 /* Commands with a prefix of `frame'. */
3257 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3259 /* Commands with a prefix of `select frame'. */
3260 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3262 /* Commands with a prefix of `info frame'. */
3263 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3265 void _initialize_stack ();
3267 _initialize_stack ()
3269 struct cmd_list_element
*cmd
;
3271 add_com ("return", class_stack
, return_command
, _("\
3272 Make selected stack frame return to its caller.\n\
3273 Control remains in the debugger, but when you continue\n\
3274 execution will resume in the frame above the one now selected.\n\
3275 If an argument is given, it is an expression for the value to return."));
3277 add_com ("up", class_stack
, up_command
, _("\
3278 Select and print stack frame that called this one.\n\
3279 An argument says how many frames up to go."));
3280 add_com ("up-silently", class_support
, up_silently_command
, _("\
3281 Same as the `up' command, but does not print anything.\n\
3282 This is useful in command scripts."));
3284 cmd_list_element
*down_cmd
3285 = add_com ("down", class_stack
, down_command
, _("\
3286 Select and print stack frame called by this one.\n\
3287 An argument says how many frames down to go."));
3288 add_com_alias ("do", down_cmd
, class_stack
, 1);
3289 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3290 add_com ("down-silently", class_support
, down_silently_command
, _("\
3291 Same as the `down' command, but does not print anything.\n\
3292 This is useful in command scripts."));
3294 cmd_list_element
*frame_cmd_el
3295 = add_prefix_cmd ("frame", class_stack
,
3296 &frame_cmd
.base_command
, _("\
3297 Select and print a stack frame.\n\
3298 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3299 A single numerical argument specifies the frame to select."),
3300 &frame_cmd_list
, 1, &cmdlist
);
3301 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3303 #define FRAME_APPLY_OPTION_HELP "\
3304 Prints the frame location information followed by COMMAND output.\n\
3306 By default, an error raised during the execution of COMMAND\n\
3307 aborts \"frame apply\".\n\
3312 const auto frame_apply_opts
3313 = make_frame_apply_options_def_group (nullptr, nullptr);
3315 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3316 Apply a command to a number of frames.\n\
3317 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3318 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3319 FRAME_APPLY_OPTION_HELP
),
3322 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3323 frame_apply_cmd_help
.c_str (),
3324 &frame_apply_cmd_list
, 1,
3326 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3328 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3329 Apply a command to all frames.\n\
3331 Usage: frame apply all [OPTION]... COMMAND\n"
3332 FRAME_APPLY_OPTION_HELP
),
3335 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3336 frame_apply_all_cmd_help
.c_str (),
3337 &frame_apply_cmd_list
);
3338 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3340 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3341 Apply a command to a list of frames.\n\
3343 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3344 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3345 FRAME_APPLY_OPTION_HELP
),
3348 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3349 frame_apply_level_cmd_help
.c_str (),
3350 &frame_apply_cmd_list
);
3351 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3353 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3354 Apply a command to all frames (ignoring errors and empty output).\n\
3355 Usage: faas [OPTION]... COMMAND\n\
3356 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3357 See \"help frame apply all\" for available options."));
3358 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3360 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3362 Select and print a stack frame by stack address.\n\
3364 Usage: frame address STACK-ADDRESS"),
3367 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3369 View a stack frame that might be outside the current backtrace.\n\
3371 Usage: frame view STACK-ADDRESS\n\
3372 frame view STACK-ADDRESS PC-ADDRESS"),
3375 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3377 Select and print a stack frame by function name.\n\
3379 Usage: frame function NAME\n\
3381 The innermost frame that visited function NAME is selected."),
3383 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3386 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3388 Select and print a stack frame by level.\n\
3390 Usage: frame level LEVEL"),
3393 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3394 &select_frame_cmd
.base_command
, _("\
3395 Select a stack frame without printing anything.\n\
3396 A single numerical argument specifies the frame to select."),
3397 &select_frame_cmd_list
, 1, &cmdlist
,
3398 &cli_suppress_notification
.user_selected_context
);
3400 add_cmd_suppress_notification ("address", class_stack
,
3401 &select_frame_cmd
.address
, _("\
3402 Select a stack frame by stack address.\n\
3404 Usage: select-frame address STACK-ADDRESS"),
3405 &select_frame_cmd_list
,
3406 &cli_suppress_notification
.user_selected_context
);
3409 add_cmd_suppress_notification ("view", class_stack
,
3410 &select_frame_cmd
.view
, _("\
3411 Select a stack frame that might be outside the current backtrace.\n\
3413 Usage: select-frame view STACK-ADDRESS\n\
3414 select-frame view STACK-ADDRESS PC-ADDRESS"),
3415 &select_frame_cmd_list
,
3416 &cli_suppress_notification
.user_selected_context
);
3418 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3419 &select_frame_cmd
.function
, _("\
3420 Select a stack frame by function name.\n\
3422 Usage: select-frame function NAME"),
3423 &select_frame_cmd_list
,
3424 &cli_suppress_notification
.user_selected_context
);
3425 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3427 add_cmd_suppress_notification ("level", class_stack
,
3428 &select_frame_cmd
.level
, _("\
3429 Select a stack frame by level.\n\
3431 Usage: select-frame level LEVEL"),
3432 &select_frame_cmd_list
,
3433 &cli_suppress_notification
.user_selected_context
);
3435 const auto backtrace_opts
3436 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3438 static std::string backtrace_help
3439 = gdb::option::build_help (_("\
3440 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3441 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3446 For backward compatibility, the following qualifiers are supported:\n\
3448 full - same as -full option.\n\
3449 no-filters - same as -no-filters option.\n\
3450 hide - same as -hide.\n\
3452 With a negative COUNT, print outermost -COUNT frames."),
3455 cmd_list_element
*backtrace_cmd
3456 = add_com ("backtrace", class_stack
, backtrace_command
,
3457 backtrace_help
.c_str ());
3458 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3460 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3462 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3463 cmd_list_element
*info_stack_cmd
3464 = add_info ("stack", backtrace_command
,
3465 _("Backtrace of the stack, or innermost COUNT frames."));
3466 add_info_alias ("s", info_stack_cmd
, 1);
3468 cmd_list_element
*info_frame_cmd_el
3469 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3470 _("All about the selected stack frame.\n\
3471 With no arguments, displays information about the currently selected stack\n\
3472 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3473 the information is then printed about the specified frame."),
3474 &info_frame_cmd_list
, 1, &infolist
);
3475 add_info_alias ("f", info_frame_cmd_el
, 1);
3477 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3479 Print information about a stack frame selected by stack address.\n\
3481 Usage: info frame address STACK-ADDRESS"),
3482 &info_frame_cmd_list
);
3484 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3486 Print information about a stack frame outside the current backtrace.\n\
3488 Usage: info frame view STACK-ADDRESS\n\
3489 info frame view STACK-ADDRESS PC-ADDRESS"),
3490 &info_frame_cmd_list
);
3492 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3494 Print information about a stack frame selected by function name.\n\
3496 Usage: info frame function NAME"),
3497 &info_frame_cmd_list
);
3498 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3500 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3502 Print information about a stack frame selected by level.\n\
3504 Usage: info frame level LEVEL"),
3505 &info_frame_cmd_list
);
3507 cmd
= add_info ("locals", info_locals_command
,
3508 info_print_args_help (_("\
3509 All local variables of current stack frame or those matching REGEXPs.\n\
3510 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3511 Prints the local variables of the current stack frame.\n"),
3512 _("local variables"),
3514 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3515 cmd
= add_info ("args", info_args_command
,
3516 info_print_args_help (_("\
3517 All argument variables of current stack frame or those matching REGEXPs.\n\
3518 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3519 Prints the argument variables of the current stack frame.\n"),
3520 _("argument variables"),
3522 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3524 /* Install "set print raw frame-arguments", a deprecated spelling of
3525 "set print raw-frame-arguments". */
3526 set_show_commands set_show_frame_args
3527 = add_setshow_boolean_cmd
3528 ("frame-arguments", no_class
,
3529 &user_frame_print_options
.print_raw_frame_arguments
,
3531 Set whether to print frame arguments in raw form."), _("\
3532 Show whether to print frame arguments in raw form."), _("\
3533 If set, frame arguments are printed in raw form, bypassing any\n\
3534 pretty-printers for that value."),
3536 &setprintrawlist
, &showprintrawlist
);
3537 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3539 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3540 &disassemble_next_line
, _("\
3541 Set whether to disassemble next source line or insn when execution stops."),
3543 Show whether to disassemble next source line or insn when execution stops."),
3545 If ON, GDB will display disassembly of the next source line, in addition\n\
3546 to displaying the source line itself. If the next source line cannot\n\
3547 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3548 will display disassembly of next instruction instead of showing the\n\
3550 If AUTO, display disassembly of next instruction only if the source line\n\
3551 cannot be displayed.\n\
3552 If OFF (which is the default), never display the disassembly of the next\n\
3555 show_disassemble_next_line
,
3556 &setlist
, &showlist
);
3557 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3559 gdb::option::add_setshow_cmds_for_options
3560 (class_stack
, &user_frame_print_options
,
3561 frame_print_option_defs
, &setprintlist
, &showprintlist
);