1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2022 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
53 #include "extension.h"
54 #include "observable.h"
55 #include "gdbsupport/def-vector.h"
56 #include "cli/cli-option.h"
57 #include "cli/cli-style.h"
58 #include "gdbsupport/buildargv.h"
60 /* The possible choices of "set print frame-arguments", and the value
63 const char print_frame_arguments_all
[] = "all";
64 const char print_frame_arguments_scalars
[] = "scalars";
65 const char print_frame_arguments_none
[] = "none";
66 const char print_frame_arguments_presence
[] = "presence";
68 static const char *const print_frame_arguments_choices
[] =
70 print_frame_arguments_all
,
71 print_frame_arguments_scalars
,
72 print_frame_arguments_none
,
73 print_frame_arguments_presence
,
77 /* The possible choices of "set print frame-info", and the value
80 const char print_frame_info_auto
[] = "auto";
81 const char print_frame_info_source_line
[] = "source-line";
82 const char print_frame_info_location
[] = "location";
83 const char print_frame_info_source_and_location
[] = "source-and-location";
84 const char print_frame_info_location_and_address
[] = "location-and-address";
85 const char print_frame_info_short_location
[] = "short-location";
87 static const char *const print_frame_info_choices
[] =
89 print_frame_info_auto
,
90 print_frame_info_source_line
,
91 print_frame_info_location
,
92 print_frame_info_source_and_location
,
93 print_frame_info_location_and_address
,
94 print_frame_info_short_location
,
98 /* print_frame_info_print_what[i] maps a choice to the corresponding
100 static const gdb::optional
<enum print_what
> print_frame_info_print_what
[] =
101 {{}, /* Empty value for "auto". */
102 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
104 /* The possible choices of "set print entry-values", and the value
107 const char print_entry_values_no
[] = "no";
108 const char print_entry_values_only
[] = "only";
109 const char print_entry_values_preferred
[] = "preferred";
110 const char print_entry_values_if_needed
[] = "if-needed";
111 const char print_entry_values_both
[] = "both";
112 const char print_entry_values_compact
[] = "compact";
113 const char print_entry_values_default
[] = "default";
114 static const char *const print_entry_values_choices
[] =
116 print_entry_values_no
,
117 print_entry_values_only
,
118 print_entry_values_preferred
,
119 print_entry_values_if_needed
,
120 print_entry_values_both
,
121 print_entry_values_compact
,
122 print_entry_values_default
,
127 frame_print_options user_frame_print_options
;
129 /* Option definitions for some frame-related "set print ..."
132 using boolean_option_def
133 = gdb::option::boolean_option_def
<frame_print_options
>;
134 using enum_option_def
135 = gdb::option::enum_option_def
<frame_print_options
>;
137 static const gdb::option::option_def frame_print_option_defs
[] = {
141 print_entry_values_choices
,
142 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
143 NULL
, /* show_cmd_cb */
144 N_("Set printing of function arguments at function entry."),
145 N_("Show printing of function arguments at function entry."),
146 N_("GDB can sometimes determine the values of function arguments at entry,\n\
147 in addition to their current values. This option tells GDB whether\n\
148 to print the current value, the value at entry (marked as val@entry),\n\
149 or both. Note that one or both of these values may be <optimized out>."),
154 print_frame_arguments_choices
,
155 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
156 NULL
, /* show_cmd_cb */
157 N_("Set printing of non-scalar frame arguments."),
158 N_("Show printing of non-scalar frame arguments."),
163 "raw-frame-arguments",
164 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
165 NULL
, /* show_cmd_cb */
166 N_("Set whether to print frame arguments in raw form."),
167 N_("Show whether to print frame arguments in raw form."),
168 N_("If set, frame arguments are printed in raw form, bypassing any\n\
169 pretty-printers for that value.")
174 print_frame_info_choices
,
175 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
176 NULL
, /* show_cmd_cb */
177 N_("Set printing of frame information."),
178 N_("Show printing of frame information."),
184 /* Options for the "backtrace" command. */
186 struct backtrace_cmd_options
189 bool no_filters
= false;
193 using bt_flag_option_def
194 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
196 static const gdb::option::option_def backtrace_command_option_defs
[] = {
199 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
200 N_("Print values of local variables.")
205 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
206 N_("Prohibit frame filters from executing on a backtrace."),
211 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
212 N_("Causes Python frame filter elided frames to not be printed."),
216 /* Prototypes for local functions. */
218 static void print_frame_local_vars (struct frame_info
*frame
,
220 const char *regexp
, const char *t_regexp
,
221 int num_tabs
, struct ui_file
*stream
);
223 static void print_frame (const frame_print_options
&opts
,
224 frame_info
*frame
, int print_level
,
225 enum print_what print_what
, int print_args
,
226 struct symtab_and_line sal
);
228 static struct frame_info
*find_frame_for_function (const char *);
229 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
231 /* Zero means do things normally; we are interacting directly with the
232 user. One means print the full filename and linenumber when a
233 frame is printed, and do so in a format emacs18/emacs19.22 can
234 parse. Two means print similar annotations, but in many more
235 cases and in a slightly different syntax. */
237 int annotation_level
= 0;
239 /* Class used to manage tracking the last symtab we displayed. */
241 class last_displayed_symtab_info_type
244 /* True if the cached information is valid. */
245 bool is_valid () const
248 /* Return the cached program_space. If the cache is invalid nullptr is
250 struct program_space
*pspace () const
253 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
255 CORE_ADDR
address () const
256 { return m_address
; }
258 /* Return the cached symtab. If the cache is invalid nullptr is
260 struct symtab
*symtab () const
263 /* Return the cached line number. If the cache is invalid 0 is
268 /* Invalidate the cache, reset all the members to their default value. */
278 /* Store a new set of values in the cache. */
279 void set (struct program_space
*pspace
, CORE_ADDR address
,
280 struct symtab
*symtab
, int line
)
282 gdb_assert (pspace
!= nullptr);
292 /* True when the cache is valid. */
293 bool m_valid
= false;
295 /* The last program space displayed. */
296 struct program_space
*m_pspace
= nullptr;
298 /* The last address displayed. */
299 CORE_ADDR m_address
= 0;
301 /* The last symtab displayed. */
302 struct symtab
*m_symtab
= nullptr;
304 /* The last line number displayed. */
308 /* An actual instance of the cache, holds information about the last symtab
310 static last_displayed_symtab_info_type last_displayed_symtab_info
;
317 frame_show_address (struct frame_info
*frame
,
318 struct symtab_and_line sal
)
320 /* If there is a line number, but no PC, then there is no location
321 information associated with this sal. The only way that should
322 happen is for the call sites of inlined functions (SAL comes from
323 find_frame_sal). Otherwise, we would have some PC range if the
324 SAL came from a line table. */
325 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
327 if (get_next_frame (frame
) == NULL
)
328 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
330 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
334 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
340 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
341 int print_level
, enum print_what print_what
,
344 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
346 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
349 /* Show or print a stack frame FRAME briefly. The output is formatted
350 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
351 relative level, function name, argument list, and file name and
352 line number. If the frame's PC is not at the beginning of the
353 source line, the actual PC is printed at the beginning. */
356 print_stack_frame (struct frame_info
*frame
, int print_level
,
357 enum print_what print_what
,
361 /* For mi, always print location and address. */
362 if (current_uiout
->is_mi_like_p ())
363 print_what
= LOC_AND_ADDRESS
;
367 print_frame_info (user_frame_print_options
,
368 frame
, print_level
, print_what
, 1 /* print_args */,
371 set_current_sal_from_frame (frame
);
373 catch (const gdb_exception_error
&e
)
378 /* Print nameless arguments of frame FRAME on STREAM, where START is
379 the offset of the first nameless argument, and NUM is the number of
380 nameless arguments to print. FIRST is nonzero if this is the first
381 argument (not just the first nameless argument). */
384 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
385 int first
, struct ui_file
*stream
)
387 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
388 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
393 for (i
= 0; i
< num
; i
++)
396 argsaddr
= get_frame_args_address (frame
);
399 arg_value
= read_memory_integer (argsaddr
+ start
,
400 sizeof (int), byte_order
);
402 fprintf_filtered (stream
, ", ");
403 fprintf_filtered (stream
, "%ld", arg_value
);
405 start
+= sizeof (int);
409 /* Print single argument of inferior function. ARG must be already
412 Errors are printed as if they would be the parameter value. Use zeroed ARG
413 iff it should not be printed according to user settings. */
416 print_frame_arg (const frame_print_options
&fp_opts
,
417 const struct frame_arg
*arg
)
419 struct ui_out
*uiout
= current_uiout
;
423 gdb_assert (!arg
->val
|| !arg
->error
);
424 gdb_assert (arg
->entry_kind
== print_entry_values_no
425 || arg
->entry_kind
== print_entry_values_only
426 || (!uiout
->is_mi_like_p ()
427 && arg
->entry_kind
== print_entry_values_compact
));
429 annotate_arg_emitter arg_emitter
;
430 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
431 fputs_filtered (arg
->sym
->print_name (), &stb
);
432 if (arg
->entry_kind
== print_entry_values_compact
)
434 /* It is OK to provide invalid MI-like stream as with
435 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
438 fputs_filtered (arg
->sym
->print_name (), &stb
);
440 if (arg
->entry_kind
== print_entry_values_only
441 || arg
->entry_kind
== print_entry_values_compact
)
443 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
444 annotate_arg_name_end ();
448 if (!arg
->val
&& !arg
->error
)
454 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
455 style
= metadata_style
.style ();
461 const struct language_defn
*language
;
462 struct value_print_options vp_opts
;
464 /* Avoid value_print because it will deref ref parameters. We
465 just want to print their addresses. Print ??? for args whose
466 address we do not know. We pass 2 as "recurse" to val_print
467 because our standard indentation here is 4 spaces, and
468 val_print indents 2 for each recurse. */
470 annotate_arg_value (value_type (arg
->val
));
472 /* Use the appropriate language to display our symbol, unless the
473 user forced the language to a specific language. */
474 if (language_mode
== language_mode_auto
)
475 language
= language_def (arg
->sym
->language ());
477 language
= current_language
;
479 get_no_prettyformat_print_options (&vp_opts
);
480 vp_opts
.deref_ref
= 1;
481 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
483 /* True in "summary" mode, false otherwise. */
485 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
487 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
489 catch (const gdb_exception_error
&except
)
491 stb
.printf (_("<error reading variable: %s>"),
493 style
= metadata_style
.style ();
498 uiout
->field_stream ("value", stb
, style
);
501 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
502 responsible for xfree of ARGP->ERROR. This function never throws an
506 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
507 struct frame_arg
*argp
)
515 argp
->val
= read_var_value (sym
, NULL
, frame
);
517 catch (const gdb_exception_error
&except
)
519 argp
->error
.reset (xstrdup (except
.what ()));
523 /* Read in inferior function parameter SYM at FRAME into ARGP. This
524 function never throws an exception. */
527 read_frame_arg (const frame_print_options
&fp_opts
,
528 symbol
*sym
, frame_info
*frame
,
529 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
531 struct value
*val
= NULL
, *entryval
= NULL
;
532 char *val_error
= NULL
, *entryval_error
= NULL
;
535 if (fp_opts
.print_entry_values
!= print_entry_values_only
536 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
540 val
= read_var_value (sym
, NULL
, frame
);
542 catch (const gdb_exception_error
&except
)
544 val_error
= (char *) alloca (except
.message
->size () + 1);
545 strcpy (val_error
, except
.what ());
549 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
550 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
551 && fp_opts
.print_entry_values
!= print_entry_values_no
552 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
553 || !val
|| value_optimized_out (val
)))
557 const struct symbol_computed_ops
*ops
;
559 ops
= SYMBOL_COMPUTED_OPS (sym
);
560 entryval
= ops
->read_variable_at_entry (sym
, frame
);
562 catch (const gdb_exception_error
&except
)
564 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
566 entryval_error
= (char *) alloca (except
.message
->size () + 1);
567 strcpy (entryval_error
, except
.what ());
571 if (entryval
!= NULL
&& value_optimized_out (entryval
))
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
= value_type (val
);
583 if (value_lazy (val
))
584 value_fetch_lazy (val
);
585 if (value_lazy (entryval
))
586 value_fetch_lazy (entryval
);
588 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
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 (value_lazy (val_deref
))
603 value_fetch_lazy (val_deref
);
604 type_deref
= value_type (val_deref
);
606 entryval_deref
= coerce_ref (entryval
);
607 if (value_lazy (entryval_deref
))
608 value_fetch_lazy (entryval_deref
);
610 /* If the reference addresses match but dereferenced
611 content does not match print them. */
613 && value_contents_eq (val_deref
, 0,
615 TYPE_LENGTH (type_deref
)))
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
|| value_optimized_out (val
))))
677 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
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
|| value_optimized_out (val
)) && 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
, struct frame_info
*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
);
745 /* Temporarily change the selected frame to the given FRAME.
746 This allows routines that rely on the selected frame instead
747 of being given a frame as parameter to use the correct frame. */
748 scoped_restore_selected_frame restore_selected_frame
;
749 select_frame (frame
);
753 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
754 struct block_iterator iter
;
757 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
759 struct frame_arg arg
, entryarg
;
763 /* Keep track of the highest stack argument offset seen, and
764 skip over any kinds of symbols we don't care about. */
766 if (!SYMBOL_IS_ARGUMENT (sym
))
776 switch (SYMBOL_CLASS (sym
))
781 long current_offset
= SYMBOL_VALUE (sym
);
782 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
784 /* Compute address of next argument by adding the size of
785 this argument and rounding to an int boundary. */
787 ((current_offset
+ arg_size
+ sizeof (int) - 1)
788 & ~(sizeof (int) - 1));
790 /* If this is the highest offset seen yet, set
792 if (highest_offset
== -1
793 || (current_offset
> highest_offset
))
794 highest_offset
= current_offset
;
796 /* Add the number of ints we're about to print to
798 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
801 /* We care about types of symbols, but don't need to
802 keep track of stack offsets in them. */
804 case LOC_REGPARM_ADDR
:
806 case LOC_OPTIMIZED_OUT
:
811 /* We have to look up the symbol because arguments can have
812 two entries (one a parameter, one a local) and the one we
813 want is the local, which lookup_symbol will find for us.
814 This includes gcc1 (not gcc2) on SPARC when passing a
815 small structure and gcc2 when the argument type is float
816 and it is passed as a double and converted to float by
817 the prologue (in the latter case the type of the LOC_ARG
818 symbol is double and the type of the LOC_LOCAL symbol is
820 /* But if the parameter name is null, don't try it. Null
821 parameter names occur on the RS/6000, for traceback
822 tables. FIXME, should we even print them? */
824 if (*sym
->linkage_name ())
828 nsym
= lookup_symbol_search_name (sym
->search_name (),
829 b
, VAR_DOMAIN
).symbol
;
830 gdb_assert (nsym
!= NULL
);
831 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
832 && !SYMBOL_IS_ARGUMENT (nsym
))
834 /* There is a LOC_ARG/LOC_REGISTER pair. This means
835 that it was passed on the stack and loaded into a
836 register, or passed in a register and stored in a
837 stack slot. GDB 3.x used the LOC_ARG; GDB
838 4.0-4.11 used the LOC_REGISTER.
840 Reasons for using the LOC_ARG:
842 (1) Because find_saved_registers may be slow for
845 (2) Because registers are often re-used and stack
846 slots rarely (never?) are. Therefore using
847 the stack slot is much less likely to print
850 Reasons why we might want to use the LOC_REGISTER:
852 (1) So that the backtrace prints the same value
853 as "print foo". I see no compelling reason
854 why this needs to be the case; having the
855 backtrace print the value which was passed
856 in, and "print foo" print the value as
857 modified within the called function, makes
860 Additional note: It might be nice if "info args"
861 displayed both values.
863 One more note: There is a case with SPARC
864 structure passing where we need to use the
865 LOC_REGISTER, but this is dealt with by creating
866 a single LOC_REGPARM in symbol reading. */
868 /* Leave sym (the LOC_ARG) alone. */
875 /* Print the current arg. */
878 uiout
->wrap_hint (" ");
883 arg
.entry_kind
= print_entry_values_no
;
885 entryarg
.entry_kind
= print_entry_values_no
;
888 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
890 if (arg
.entry_kind
!= print_entry_values_only
)
891 print_frame_arg (fp_opts
, &arg
);
893 if (entryarg
.entry_kind
!= print_entry_values_no
)
895 if (arg
.entry_kind
!= print_entry_values_only
)
898 uiout
->wrap_hint (" ");
901 print_frame_arg (fp_opts
, &entryarg
);
908 /* Don't print nameless args in situations where we don't know
909 enough about the stack to find them. */
914 if (highest_offset
== -1)
915 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
917 start
= highest_offset
;
919 if (!print_names
&& !first
&& num
> 0)
922 print_frame_nameless_args (frame
, start
, num
- args_printed
,
927 /* Set the current source and line to the location given by frame
928 FRAME, if possible. When CENTER is true, adjust so the relevant
929 line is in the center of the next 'list'. */
932 set_current_sal_from_frame (struct frame_info
*frame
)
934 symtab_and_line sal
= find_frame_sal (frame
);
935 if (sal
.symtab
!= NULL
)
936 set_current_source_symtab_and_line (sal
);
939 /* If ON, GDB will display disassembly of the next source line when
940 execution of the program being debugged stops.
941 If AUTO (which is the default), or there's no line info to determine
942 the source line of the next instruction, display disassembly of next
943 instruction instead. */
945 static enum auto_boolean disassemble_next_line
;
948 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
949 struct cmd_list_element
*c
,
952 fprintf_filtered (file
,
953 _("Debugger's willingness to use "
954 "disassemble-next-line is %s.\n"),
958 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
959 because it will be broken by filter sometime. */
962 do_gdb_disassembly (struct gdbarch
*gdbarch
,
963 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
968 gdb_disassembly (gdbarch
, current_uiout
,
969 DISASSEMBLY_RAW_INSN
, how_many
,
972 catch (const gdb_exception_error
&exception
)
974 /* If an exception was thrown while doing the disassembly, print
975 the error message, to give the user a clue of what happened. */
976 exception_print (gdb_stderr
, exception
);
980 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
981 Value not present indicates to the caller to use default values
982 specific to the command being executed. */
984 static gdb::optional
<enum print_what
>
985 print_frame_info_to_print_what (const char *print_frame_info
)
987 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
988 if (print_frame_info
== print_frame_info_choices
[i
])
989 return print_frame_info_print_what
[i
];
991 internal_error (__FILE__
, __LINE__
,
992 "Unexpected print frame-info value `%s'.",
996 /* Print the PC from FRAME, plus any flags, to UIOUT. */
999 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info
*frame
,
1002 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1004 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
1005 if (!flags
.empty ())
1008 uiout
->field_string ("addr_flags", flags
);
1016 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
1019 = print_frame_info_to_print_what
1020 (user_frame_print_options
.print_frame_info
);
1023 /* Print information about frame FRAME. The output is format according
1024 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1025 PRINT_WHAT, see enum print_what comments in frame.h.
1026 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1027 != print_frame_info_auto.
1029 Used in "where" output, and to emit breakpoint or step
1033 print_frame_info (const frame_print_options
&fp_opts
,
1034 frame_info
*frame
, int print_level
,
1035 enum print_what print_what
, int print_args
,
1036 int set_current_sal
)
1038 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1041 struct ui_out
*uiout
= current_uiout
;
1043 if (!current_uiout
->is_mi_like_p ()
1044 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1046 /* Use the specific frame information desired by the user. */
1047 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1050 if (get_frame_type (frame
) == DUMMY_FRAME
1051 || get_frame_type (frame
) == SIGTRAMP_FRAME
1052 || get_frame_type (frame
) == ARCH_FRAME
)
1054 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1056 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1057 gdbarch
, get_frame_pc (frame
));
1059 /* Do this regardless of SOURCE because we don't have any source
1060 to list for this frame. */
1064 uiout
->field_fmt_signed (2, ui_left
, "level",
1065 frame_relative_level (frame
));
1067 if (uiout
->is_mi_like_p ())
1069 annotate_frame_address ();
1070 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1071 annotate_frame_address_end ();
1074 if (get_frame_type (frame
) == DUMMY_FRAME
)
1076 annotate_function_call ();
1077 uiout
->field_string ("func", "<function called from gdb>",
1078 metadata_style
.style ());
1080 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1082 annotate_signal_handler_caller ();
1083 uiout
->field_string ("func", "<signal handler called>",
1084 metadata_style
.style ());
1086 else if (get_frame_type (frame
) == ARCH_FRAME
)
1088 uiout
->field_string ("func", "<cross-architecture call>",
1089 metadata_style
.style ());
1092 annotate_frame_end ();
1094 /* If disassemble-next-line is set to auto or on output the next
1096 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1097 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1098 do_gdb_disassembly (get_frame_arch (frame
), 1,
1099 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1104 /* If FRAME is not the innermost frame, that normally means that
1105 FRAME->pc points to *after* the call instruction, and we want to
1106 get the line containing the call, never the next line. But if
1107 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1108 next frame was not entered as the result of a call, and we want
1109 to get the line containing FRAME->pc. */
1110 symtab_and_line sal
= find_frame_sal (frame
);
1112 location_print
= (print_what
== LOCATION
1113 || print_what
== SRC_AND_LOC
1114 || print_what
== LOC_AND_ADDRESS
1115 || print_what
== SHORT_LOCATION
);
1116 if (location_print
|| !sal
.symtab
)
1117 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1119 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1121 /* If disassemble-next-line is set to auto or on and doesn't have
1122 the line debug messages for $pc, output the next instruction. */
1123 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1124 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1125 && source_print
&& !sal
.symtab
)
1126 do_gdb_disassembly (get_frame_arch (frame
), 1,
1127 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1129 if (source_print
&& sal
.symtab
)
1131 int mid_statement
= ((print_what
== SRC_LINE
)
1132 && frame_show_address (frame
, sal
));
1133 if (annotation_level
> 0
1134 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1135 get_frame_pc (frame
)))
1137 /* The call to ANNOTATE_SOURCE_LINE already printed the
1138 annotation for this source line, so we avoid the two cases
1139 below and do not print the actual source line. The
1140 documentation for annotations makes it clear that the source
1141 line annotation is printed __instead__ of printing the source
1142 line, not as well as.
1144 However, if we fail to print the source line, which usually
1145 means either the source file is missing, or the requested
1146 line is out of range of the file, then we don't print the
1147 source annotation, and will pass through the "normal" print
1148 source line code below, the expectation is that this code
1149 will print an appropriate error. */
1151 else if (deprecated_print_frame_info_listing_hook
)
1152 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1156 struct value_print_options opts
;
1158 get_user_print_options (&opts
);
1159 /* We used to do this earlier, but that is clearly
1160 wrong. This function is used by many different
1161 parts of gdb, including normal_stop in infrun.c,
1162 which uses this to print out the current PC
1163 when we stepi/nexti into the middle of a source
1164 line. Only the command line really wants this
1165 behavior. Other UIs probably would like the
1166 ability to decide for themselves if it is desired. */
1167 if (opts
.addressprint
&& mid_statement
)
1169 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1173 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1176 /* If disassemble-next-line is set to on and there is line debug
1177 messages, output assembly codes for next line. */
1178 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1179 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1182 if (set_current_sal
)
1186 if (get_frame_pc_if_available (frame
, &pc
))
1187 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1189 last_displayed_symtab_info
.invalidate ();
1192 annotate_frame_end ();
1194 gdb_flush (gdb_stdout
);
1200 clear_last_displayed_sal (void)
1202 last_displayed_symtab_info
.invalidate ();
1208 last_displayed_sal_is_valid (void)
1210 return last_displayed_symtab_info
.is_valid ();
1215 struct program_space
*
1216 get_last_displayed_pspace (void)
1218 return last_displayed_symtab_info
.pspace ();
1224 get_last_displayed_addr (void)
1226 return last_displayed_symtab_info
.address ();
1232 get_last_displayed_symtab (void)
1234 return last_displayed_symtab_info
.symtab ();
1240 get_last_displayed_line (void)
1242 return last_displayed_symtab_info
.line ();
1248 get_last_displayed_sal ()
1250 symtab_and_line sal
;
1252 if (last_displayed_symtab_info
.is_valid ())
1254 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1255 sal
.pc
= last_displayed_symtab_info
.address ();
1256 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1257 sal
.line
= last_displayed_symtab_info
.line ();
1264 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1265 corresponding to FRAME. */
1267 gdb::unique_xmalloc_ptr
<char>
1268 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1269 struct symbol
**funcp
)
1271 struct symbol
*func
;
1272 gdb::unique_xmalloc_ptr
<char> funname
;
1274 *funlang
= language_unknown
;
1278 func
= get_frame_function (frame
);
1281 const char *print_name
= func
->print_name ();
1283 *funlang
= func
->language ();
1286 if (*funlang
== language_cplus
)
1288 /* It seems appropriate to use print_name() here,
1289 to display the demangled name that we already have
1290 stored in the symbol table, but we stored a version
1291 with DMGL_PARAMS turned on, and here we don't want to
1292 display parameters. So remove the parameters. */
1293 funname
= cp_remove_params (print_name
);
1296 /* If we didn't hit the C++ case above, set *funname
1298 if (funname
== NULL
)
1299 funname
.reset (xstrdup (print_name
));
1303 struct bound_minimal_symbol msymbol
;
1306 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1309 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1310 if (msymbol
.minsym
!= NULL
)
1312 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1313 *funlang
= msymbol
.minsym
->language ();
1321 print_frame (const frame_print_options
&fp_opts
,
1322 frame_info
*frame
, int print_level
,
1323 enum print_what print_what
, int print_args
,
1324 struct symtab_and_line sal
)
1326 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1327 struct ui_out
*uiout
= current_uiout
;
1328 enum language funlang
= language_unknown
;
1329 struct value_print_options opts
;
1330 struct symbol
*func
;
1334 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1336 gdb::unique_xmalloc_ptr
<char> funname
1337 = find_frame_funname (frame
, &funlang
, &func
);
1339 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1343 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1348 uiout
->field_fmt_signed (2, ui_left
, "level",
1349 frame_relative_level (frame
));
1351 get_user_print_options (&opts
);
1352 if (opts
.addressprint
)
1354 || frame_show_address (frame
, sal
)
1355 || print_what
== LOC_AND_ADDRESS
)
1357 annotate_frame_address ();
1359 print_pc (uiout
, gdbarch
, frame
, pc
);
1361 uiout
->field_string ("addr", "<unavailable>",
1362 metadata_style
.style ());
1363 annotate_frame_address_end ();
1364 uiout
->text (" in ");
1366 annotate_frame_function_name ();
1369 fputs_filtered (funname
? funname
.get () : "??", &stb
);
1370 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1371 uiout
->wrap_hint (" ");
1372 annotate_frame_args ();
1379 if (gdbarch_frame_num_args_p (gdbarch
))
1381 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1382 gdb_assert (numargs
>= 0);
1388 ui_out_emit_list
list_emitter (uiout
, "args");
1391 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1393 catch (const gdb_exception_error
&e
)
1397 /* FIXME: ARGS must be a list. If one argument is a string it
1398 will have " that will not be properly escaped. */
1403 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1405 const char *filename_display
;
1407 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1408 annotate_frame_source_begin ();
1409 uiout
->wrap_hint (" ");
1410 uiout
->text (" at ");
1411 annotate_frame_source_file ();
1412 uiout
->field_string ("file", filename_display
,
1413 file_name_style
.style ());
1414 if (uiout
->is_mi_like_p ())
1416 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1418 uiout
->field_string ("fullname", fullname
);
1420 annotate_frame_source_file_end ();
1422 annotate_frame_source_line ();
1423 uiout
->field_signed ("line", sal
.line
);
1424 annotate_frame_source_end ();
1427 if (print_what
!= SHORT_LOCATION
1428 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1430 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1431 get_frame_pc (frame
));
1435 annotate_frame_where ();
1436 uiout
->wrap_hint (" ");
1437 uiout
->text (" from ");
1438 uiout
->field_string ("from", lib
, file_name_style
.style ());
1441 if (uiout
->is_mi_like_p ())
1442 uiout
->field_string ("arch",
1443 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1450 /* Completion function for "frame function", "info frame function", and
1451 "select-frame function" commands. */
1454 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1455 completion_tracker
&tracker
,
1456 const char *text
, const char *word
)
1458 /* This is used to complete function names within a stack. It would be
1459 nice if we only offered functions that were actually in the stack.
1460 However, this would mean unwinding the stack to completion, which
1461 could take too long, or on a corrupted stack, possibly not end.
1462 Instead, we offer all symbol names as a safer choice. */
1463 collect_symbol_completion_matches (tracker
,
1464 complete_symbol_mode::EXPRESSION
,
1465 symbol_name_match_type::EXPRESSION
,
1469 /* Core of all the "info frame" sub-commands. Print information about a
1470 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1471 frame specification, they just entered 'info frame'. If the user did
1472 provide a frame specification (for example 'info frame 0', 'info frame
1473 level 1') then SELECTED_FRAME_P will be false. */
1476 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1478 struct symbol
*func
;
1480 struct frame_info
*calling_frame_info
;
1482 const char *funname
= 0;
1483 enum language funlang
= language_unknown
;
1484 const char *pc_regname
;
1485 struct gdbarch
*gdbarch
;
1488 /* Initialize it to avoid "may be used uninitialized" warning. */
1489 CORE_ADDR caller_pc
= 0;
1490 int caller_pc_p
= 0;
1492 gdbarch
= get_frame_arch (fi
);
1494 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1495 is not a good name. */
1496 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1497 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1498 easily not match that of the internal value returned by
1500 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1502 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1503 architectures will often have a hardware register called "pc",
1504 and that register's value, again, can easily not match
1508 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1509 func
= get_frame_function (fi
);
1510 symtab_and_line sal
= find_frame_sal (fi
);
1512 gdb::unique_xmalloc_ptr
<char> func_only
;
1515 funname
= func
->print_name ();
1516 funlang
= func
->language ();
1517 if (funlang
== language_cplus
)
1519 /* It seems appropriate to use print_name() here,
1520 to display the demangled name that we already have
1521 stored in the symbol table, but we stored a version
1522 with DMGL_PARAMS turned on, and here we don't want to
1523 display parameters. So remove the parameters. */
1524 func_only
= cp_remove_params (funname
);
1527 funname
= func_only
.get ();
1530 else if (frame_pc_p
)
1532 struct bound_minimal_symbol msymbol
;
1534 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1535 if (msymbol
.minsym
!= NULL
)
1537 funname
= msymbol
.minsym
->print_name ();
1538 funlang
= msymbol
.minsym
->language ();
1541 calling_frame_info
= get_prev_frame (fi
);
1543 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1545 printf_filtered (_("Stack level %d, frame at "),
1546 frame_relative_level (fi
));
1550 printf_filtered (_("Stack frame at "));
1552 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1553 printf_filtered (":\n");
1554 printf_filtered (" %s = ", pc_regname
);
1556 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1558 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1563 printf_filtered (" in ");
1564 fputs_filtered (funname
, gdb_stdout
);
1570 styled_string (file_name_style
.style (),
1571 symtab_to_filename_for_display (sal
.symtab
)),
1573 puts_filtered ("; ");
1575 printf_filtered ("saved %s = ", pc_regname
);
1577 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1578 val_print_not_saved (gdb_stdout
);
1583 caller_pc
= frame_unwind_caller_pc (fi
);
1586 catch (const gdb_exception_error
&ex
)
1590 case NOT_AVAILABLE_ERROR
:
1591 val_print_unavailable (gdb_stdout
);
1593 case OPTIMIZED_OUT_ERROR
:
1594 val_print_not_saved (gdb_stdout
);
1597 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1606 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1607 printf_filtered ("\n");
1609 if (calling_frame_info
== NULL
)
1611 enum unwind_stop_reason reason
;
1613 reason
= get_frame_unwind_stop_reason (fi
);
1614 if (reason
!= UNWIND_NO_REASON
)
1615 printf_filtered (_(" Outermost frame: %s\n"),
1616 frame_stop_reason_string (fi
));
1618 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1619 puts_filtered (" tail call frame");
1620 else if (get_frame_type (fi
) == INLINE_FRAME
)
1621 printf_filtered (" inlined into frame %d",
1622 frame_relative_level (get_prev_frame (fi
)));
1625 printf_filtered (" called by frame at ");
1626 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1629 if (get_next_frame (fi
) && calling_frame_info
)
1630 puts_filtered (",");
1632 if (get_next_frame (fi
))
1634 printf_filtered (" caller of frame at ");
1635 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1638 if (get_next_frame (fi
) || calling_frame_info
)
1639 puts_filtered ("\n");
1642 printf_filtered (" source language %s.\n",
1643 language_str (s
->language
));
1646 /* Address of the argument list for this frame, or 0. */
1647 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1648 /* Number of args for this frame, or -1 if unknown. */
1652 printf_filtered (" Arglist at unknown address.\n");
1655 printf_filtered (" Arglist at ");
1656 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1657 printf_filtered (",");
1659 if (!gdbarch_frame_num_args_p (gdbarch
))
1662 puts_filtered (" args: ");
1666 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1667 gdb_assert (numargs
>= 0);
1669 puts_filtered (" no args.");
1670 else if (numargs
== 1)
1671 puts_filtered (" 1 arg: ");
1673 printf_filtered (" %d args: ", numargs
);
1675 print_frame_args (user_frame_print_options
,
1676 func
, fi
, numargs
, gdb_stdout
);
1677 puts_filtered ("\n");
1681 /* Address of the local variables for this frame, or 0. */
1682 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1685 printf_filtered (" Locals at unknown address,");
1688 printf_filtered (" Locals at ");
1689 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1690 printf_filtered (",");
1694 /* Print as much information as possible on the location of all the
1700 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1702 /* The sp is special; what's displayed isn't the save address, but
1703 the value of the previous frame's sp. This is a legacy thing,
1704 at one stage the frame cached the previous frame's SP instead
1705 of its address, hence it was easiest to just display the cached
1709 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1710 gdb_assert (value
!= NULL
);
1712 if (!value_optimized_out (value
) && value_entirely_available (value
))
1714 if (VALUE_LVAL (value
) == not_lval
)
1717 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1718 int sp_size
= register_size (gdbarch
, sp_regnum
);
1720 sp
= extract_unsigned_integer
1721 (value_contents_all (value
).data (), sp_size
, byte_order
);
1723 printf_filtered (" Previous frame's sp is ");
1724 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1725 printf_filtered ("\n");
1727 else if (VALUE_LVAL (value
) == lval_memory
)
1729 printf_filtered (" Previous frame's sp at ");
1730 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1732 printf_filtered ("\n");
1734 else if (VALUE_LVAL (value
) == lval_register
)
1736 printf_filtered (" Previous frame's sp in %s\n",
1737 gdbarch_register_name (gdbarch
,
1738 VALUE_REGNUM (value
)));
1741 release_value (value
);
1744 /* else keep quiet. */
1748 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1749 for (i
= 0; i
< numregs
; i
++)
1751 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1753 enum lval_type lval
;
1759 /* Find out the location of the saved register without
1760 fetching the corresponding value. */
1761 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1762 &lval
, &addr
, &realnum
, NULL
);
1763 /* For moment, only display registers that were saved on the
1765 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1768 puts_filtered (" Saved registers:\n ");
1770 puts_filtered (",");
1772 printf_filtered (" %s at ",
1773 gdbarch_register_name (gdbarch
, i
));
1774 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1778 if (count
|| need_nl
)
1779 puts_filtered ("\n");
1783 /* Return the innermost frame at level LEVEL. */
1785 static struct frame_info
*
1786 leading_innermost_frame (int level
)
1788 struct frame_info
*leading
;
1790 leading
= get_current_frame ();
1792 gdb_assert (level
>= 0);
1794 while (leading
!= nullptr && level
)
1797 leading
= get_prev_frame (leading
);
1804 /* Return the starting frame needed to handle COUNT outermost frames. */
1806 static struct frame_info
*
1807 trailing_outermost_frame (int count
)
1809 struct frame_info
*current
;
1810 struct frame_info
*trailing
;
1812 trailing
= get_current_frame ();
1814 gdb_assert (count
> 0);
1817 while (current
!= nullptr && count
--)
1820 current
= get_prev_frame (current
);
1823 /* Will stop when CURRENT reaches the top of the stack.
1824 TRAILING will be COUNT below it. */
1825 while (current
!= nullptr)
1828 trailing
= get_prev_frame (trailing
);
1829 current
= get_prev_frame (current
);
1835 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1839 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1841 frame_info
*prev_frame
= get_selected_frame ();
1843 if (get_selected_frame () != prev_frame
)
1844 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1850 select_frame_for_mi (struct frame_info
*fi
)
1852 select_frame_command_core (fi
, false /* Ignored. */);
1855 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1856 means we change frame send out a change notification (otherwise, just
1857 reprint the current frame summary). */
1860 frame_command_core (struct frame_info
*fi
, bool ignored
)
1862 frame_info
*prev_frame
= get_selected_frame ();
1864 if (get_selected_frame () != prev_frame
)
1865 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1867 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1870 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1871 common set of sub-commands that allow a specific frame to be selected.
1872 All of the sub-command functions are static methods within this class
1873 template which is then instantiated below. The template parameter is a
1874 callback used to implement the functionality of the base command
1875 ('frame', 'select-frame', or 'info frame').
1877 In the template parameter FI is the frame being selected. The
1878 SELECTED_FRAME_P flag is true if the frame being selected was done by
1879 default, which happens when the user uses the base command with no
1880 arguments. For example the commands 'info frame', 'select-frame',
1881 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1882 SELECTED_FRAME_P is false. */
1884 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1885 class frame_command_helper
1889 /* The "frame level" family of commands. The ARG is an integer that is
1890 the frame's level in the stack. */
1892 level (const char *arg
, int from_tty
)
1894 int level
= value_as_long (parse_and_eval (arg
));
1895 struct frame_info
*fid
1896 = find_relative_frame (get_current_frame (), &level
);
1898 error (_("No frame at level %s."), arg
);
1902 /* The "frame address" family of commands. ARG is a stack-pointer
1903 address for an existing frame. This command does not allow new
1904 frames to be created. */
1907 address (const char *arg
, int from_tty
)
1909 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1910 struct frame_info
*fid
= find_frame_for_address (addr
);
1912 error (_("No frame at address %s."), arg
);
1916 /* The "frame view" family of commands. ARG is one or two addresses and
1917 is used to view a frame that might be outside the current backtrace.
1918 The addresses are stack-pointer address, and (optional) pc-address. */
1921 view (const char *args
, int from_tty
)
1923 struct frame_info
*fid
;
1926 error (_("Missing address argument to view a frame"));
1928 gdb_argv
argv (args
);
1930 if (argv
.count () == 2)
1934 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1935 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1936 fid
= create_new_frame (addr
[0], addr
[1]);
1940 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1941 fid
= create_new_frame (addr
, false);
1946 /* The "frame function" family of commands. ARG is the name of a
1947 function within the stack, the first function (searching from frame
1948 0) with that name will be selected. */
1951 function (const char *arg
, int from_tty
)
1954 error (_("Missing function name argument"));
1955 struct frame_info
*fid
= find_frame_for_function (arg
);
1957 error (_("No frame for function \"%s\"."), arg
);
1961 /* The "frame" base command, that is, when no sub-command is specified.
1962 If one argument is provided then we assume that this is a frame's
1963 level as historically, this was the supported command syntax that was
1966 If no argument is provided, then the current frame is selected. */
1969 base_command (const char *arg
, int from_tty
)
1972 FPTR (get_selected_frame (_("No stack.")), true);
1974 level (arg
, from_tty
);
1978 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1979 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1981 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1982 static frame_command_helper
<frame_command_core
> frame_cmd
;
1983 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1985 /* Print briefly all stack frames or just the innermost COUNT_EXP
1989 backtrace_command_1 (const frame_print_options
&fp_opts
,
1990 const backtrace_cmd_options
&bt_opts
,
1991 const char *count_exp
, int from_tty
)
1994 struct frame_info
*fi
;
1996 int py_start
= 0, py_end
= 0;
1997 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1999 if (!target_has_stack ())
2000 error (_("No stack."));
2004 count
= parse_and_eval_long (count_exp
);
2010 /* The argument to apply_ext_lang_frame_filter is the number
2011 of the final frame to print, and frames start at 0. */
2021 frame_filter_flags flags
= 0;
2024 flags
|= PRINT_LOCALS
;
2026 flags
|= PRINT_HIDE
;
2028 if (!bt_opts
.no_filters
)
2030 enum ext_lang_frame_args arg_type
;
2032 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2034 flags
|= PRINT_MORE_FRAMES
;
2036 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2037 arg_type
= CLI_SCALAR_VALUES
;
2038 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2039 arg_type
= CLI_ALL_VALUES
;
2040 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2041 arg_type
= CLI_PRESENCE
;
2042 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2043 arg_type
= NO_VALUES
;
2047 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2048 arg_type
, current_uiout
,
2052 /* Run the inbuilt backtrace if there are no filters registered, or
2053 "-no-filters" has been specified from the command. */
2054 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2056 struct frame_info
*trailing
;
2058 /* The following code must do two things. First, it must set the
2059 variable TRAILING to the frame from which we should start
2060 printing. Second, it must set the variable count to the number
2061 of frames which we should print, or -1 if all of them. */
2063 if (count_exp
!= NULL
&& count
< 0)
2065 trailing
= trailing_outermost_frame (-count
);
2069 trailing
= get_current_frame ();
2071 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2075 /* Don't use print_stack_frame; if an error() occurs it probably
2076 means further attempts to backtrace would fail (on the other
2077 hand, perhaps the code does or could be fixed to make sure
2078 the frame->prev field gets set to NULL in that case). */
2080 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2081 if ((flags
& PRINT_LOCALS
) != 0)
2083 struct frame_id frame_id
= get_frame_id (fi
);
2085 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2087 /* print_frame_local_vars invalidates FI. */
2088 fi
= frame_find_by_id (frame_id
);
2092 warning (_("Unable to restore previously selected frame."));
2097 /* Save the last frame to check for error conditions. */
2101 /* If we've stopped before the end, mention that. */
2103 printf_filtered (_("(More stack frames follow...)\n"));
2105 /* If we've run out of frames, and the reason appears to be an error
2106 condition, print it. */
2107 if (fi
== NULL
&& trailing
!= NULL
)
2109 enum unwind_stop_reason reason
;
2111 reason
= get_frame_unwind_stop_reason (trailing
);
2112 if (reason
>= UNWIND_FIRST_ERROR
)
2113 printf_filtered (_("Backtrace stopped: %s\n"),
2114 frame_stop_reason_string (trailing
));
2119 /* Create an option_def_group array grouping all the "backtrace"
2120 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2122 static inline std::array
<gdb::option::option_def_group
, 3>
2123 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2124 backtrace_cmd_options
*bt_cmd_opts
,
2125 set_backtrace_options
*set_bt_opts
)
2128 { {frame_print_option_defs
}, fp_opts
},
2129 { {set_backtrace_option_defs
}, set_bt_opts
},
2130 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2134 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2135 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2136 store the parsed qualifiers. */
2139 parse_backtrace_qualifiers (const char *arg
,
2140 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2144 const char *save_arg
= arg
;
2145 std::string this_arg
= extract_arg (&arg
);
2147 if (this_arg
.empty ())
2150 if (subset_compare (this_arg
.c_str (), "no-filters"))
2152 if (bt_cmd_opts
!= nullptr)
2153 bt_cmd_opts
->no_filters
= true;
2155 else if (subset_compare (this_arg
.c_str (), "full"))
2157 if (bt_cmd_opts
!= nullptr)
2158 bt_cmd_opts
->full
= true;
2160 else if (subset_compare (this_arg
.c_str (), "hide"))
2162 if (bt_cmd_opts
!= nullptr)
2163 bt_cmd_opts
->hide
= true;
2167 /* Not a recognized qualifier, so stop. */
2174 backtrace_command (const char *arg
, int from_tty
)
2176 frame_print_options fp_opts
= user_frame_print_options
;
2177 backtrace_cmd_options bt_cmd_opts
;
2178 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2181 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2182 gdb::option::process_options
2183 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2185 /* Parse non-'-'-prefixed qualifiers, for backwards
2189 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2194 /* These options are handled quite deep in the unwind machinery, so
2195 we get to pass them down by swapping globals. */
2196 scoped_restore restore_set_backtrace_options
2197 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2199 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2202 /* Completer for the "backtrace" command. */
2205 backtrace_command_completer (struct cmd_list_element
*ignore
,
2206 completion_tracker
&tracker
,
2207 const char *text
, const char */
*word*/
)
2210 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2211 if (gdb::option::complete_options
2212 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2217 const char *p
= skip_to_space (text
);
2220 static const char *const backtrace_cmd_qualifier_choices
[] = {
2221 "full", "no-filters", "hide", nullptr,
2223 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2226 if (tracker
.have_completions ())
2231 const char *cmd
= parse_backtrace_qualifiers (text
);
2232 tracker
.advance_custom_word_point_by (cmd
- text
);
2237 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2238 expression_completer (ignore
, tracker
, text
, word
);
2241 /* Iterate over the local variables of a block B, calling CB with
2245 iterate_over_block_locals (const struct block
*b
,
2246 iterate_over_block_arg_local_vars_cb cb
,
2249 struct block_iterator iter
;
2252 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2254 switch (SYMBOL_CLASS (sym
))
2261 case LOC_OPTIMIZED_OUT
:
2262 if (SYMBOL_IS_ARGUMENT (sym
))
2264 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2266 (*cb
) (sym
->print_name (), sym
, cb_data
);
2270 /* Ignore symbols which are not locals. */
2276 /* Iterate over all the local variables in block B, including all its
2277 superblocks, stopping when the top-level block is reached. */
2280 iterate_over_block_local_vars (const struct block
*block
,
2281 iterate_over_block_arg_local_vars_cb cb
,
2286 iterate_over_block_locals (block
, cb
, cb_data
);
2287 /* After handling the function's top-level block, stop. Don't
2288 continue to its superblock, the block of per-file
2290 if (BLOCK_FUNCTION (block
))
2292 block
= BLOCK_SUPERBLOCK (block
);
2296 /* Data to be passed around in the calls to the locals and args
2299 struct print_variable_and_value_data
2301 gdb::optional
<compiled_regex
> preg
;
2302 gdb::optional
<compiled_regex
> treg
;
2303 struct frame_id frame_id
;
2305 struct ui_file
*stream
;
2309 /* The callback for the locals and args iterators. */
2312 do_print_variable_and_value (const char *print_name
,
2316 struct print_variable_and_value_data
*p
2317 = (struct print_variable_and_value_data
*) cb_data
;
2318 struct frame_info
*frame
;
2320 if (p
->preg
.has_value ()
2321 && p
->preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2323 if (p
->treg
.has_value ()
2324 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2326 if (language_def (sym
->language ())->symbol_printing_suppressed (sym
))
2329 frame
= frame_find_by_id (p
->frame_id
);
2332 warning (_("Unable to restore previously selected frame."));
2336 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2338 /* print_variable_and_value invalidates FRAME. */
2341 p
->values_printed
= 1;
2344 /* Prepares the regular expression REG from REGEXP.
2345 If REGEXP is NULL, it results in an empty regular expression. */
2348 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2352 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2354 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2360 /* Print all variables from the innermost up to the function block of FRAME.
2361 Print them with values to STREAM indented by NUM_TABS.
2362 If REGEXP is not NULL, only print local variables whose name
2364 If T_REGEXP is not NULL, only print local variables whose type
2366 If no local variables have been printed and !QUIET, prints a message
2367 explaining why no local variables could be printed.
2369 This function will invalidate FRAME. */
2372 print_frame_local_vars (struct frame_info
*frame
,
2374 const char *regexp
, const char *t_regexp
,
2375 int num_tabs
, struct ui_file
*stream
)
2377 struct print_variable_and_value_data cb_data
;
2378 const struct block
*block
;
2381 if (!get_frame_pc_if_available (frame
, &pc
))
2384 fprintf_filtered (stream
,
2385 _("PC unavailable, cannot determine locals.\n"));
2389 block
= get_frame_block (frame
, 0);
2393 fprintf_filtered (stream
, "No symbol table info available.\n");
2397 prepare_reg (regexp
, &cb_data
.preg
);
2398 prepare_reg (t_regexp
, &cb_data
.treg
);
2399 cb_data
.frame_id
= get_frame_id (frame
);
2400 cb_data
.num_tabs
= 4 * num_tabs
;
2401 cb_data
.stream
= stream
;
2402 cb_data
.values_printed
= 0;
2404 /* Temporarily change the selected frame to the given FRAME.
2405 This allows routines that rely on the selected frame instead
2406 of being given a frame as parameter to use the correct frame. */
2407 scoped_restore_selected_frame restore_selected_frame
;
2408 select_frame (frame
);
2410 iterate_over_block_local_vars (block
,
2411 do_print_variable_and_value
,
2414 if (!cb_data
.values_printed
&& !quiet
)
2416 if (regexp
== NULL
&& t_regexp
== NULL
)
2417 fprintf_filtered (stream
, _("No locals.\n"));
2419 fprintf_filtered (stream
, _("No matching locals.\n"));
2423 /* Structure to hold the values of the options used by the 'info
2424 variables' command and other similar commands. These correspond to the
2425 -q and -t options. */
2427 struct info_print_options
2430 std::string type_regexp
;
2433 /* The options used by the 'info locals' and 'info args' commands. */
2435 static const gdb::option::option_def info_print_options_defs
[] = {
2436 gdb::option::boolean_option_def
<info_print_options
> {
2438 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2439 nullptr, /* show_cmd_cb */
2440 nullptr /* set_doc */
2443 gdb::option::string_option_def
<info_print_options
> {
2445 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2446 nullptr, /* show_cmd_cb */
2447 nullptr /* set_doc */
2451 /* Returns the option group used by 'info locals' and 'info args'
2454 static gdb::option::option_def_group
2455 make_info_print_options_def_group (info_print_options
*opts
)
2457 return {{info_print_options_defs
}, opts
};
2460 /* Command completer for 'info locals' and 'info args'. */
2463 info_print_command_completer (struct cmd_list_element
*ignore
,
2464 completion_tracker
&tracker
,
2465 const char *text
, const char * /* word */)
2468 = make_info_print_options_def_group (nullptr);
2469 if (gdb::option::complete_options
2470 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2473 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2474 symbol_completer (ignore
, tracker
, text
, word
);
2477 /* Implement the 'info locals' command. */
2480 info_locals_command (const char *args
, int from_tty
)
2482 info_print_options opts
;
2483 auto grp
= make_info_print_options_def_group (&opts
);
2484 gdb::option::process_options
2485 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2486 if (args
!= nullptr && *args
== '\0')
2489 print_frame_local_vars
2490 (get_selected_frame (_("No frame selected.")),
2492 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2496 /* Iterate over all the argument variables in block B. */
2499 iterate_over_block_arg_vars (const struct block
*b
,
2500 iterate_over_block_arg_local_vars_cb cb
,
2503 struct block_iterator iter
;
2504 struct symbol
*sym
, *sym2
;
2506 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2508 /* Don't worry about things which aren't arguments. */
2509 if (SYMBOL_IS_ARGUMENT (sym
))
2511 /* We have to look up the symbol because arguments can have
2512 two entries (one a parameter, one a local) and the one we
2513 want is the local, which lookup_symbol will find for us.
2514 This includes gcc1 (not gcc2) on the sparc when passing a
2515 small structure and gcc2 when the argument type is float
2516 and it is passed as a double and converted to float by
2517 the prologue (in the latter case the type of the LOC_ARG
2518 symbol is double and the type of the LOC_LOCAL symbol is
2519 float). There are also LOC_ARG/LOC_REGISTER pairs which
2520 are not combined in symbol-reading. */
2522 sym2
= lookup_symbol_search_name (sym
->search_name (),
2523 b
, VAR_DOMAIN
).symbol
;
2524 (*cb
) (sym
->print_name (), sym2
, cb_data
);
2529 /* Print all argument variables of the function of FRAME.
2530 Print them with values to STREAM.
2531 If REGEXP is not NULL, only print argument variables whose name
2533 If T_REGEXP is not NULL, only print argument variables whose type
2535 If no argument variables have been printed and !QUIET, prints a message
2536 explaining why no argument variables could be printed.
2538 This function will invalidate FRAME. */
2541 print_frame_arg_vars (struct frame_info
*frame
,
2543 const char *regexp
, const char *t_regexp
,
2544 struct ui_file
*stream
)
2546 struct print_variable_and_value_data cb_data
;
2547 struct symbol
*func
;
2549 gdb::optional
<compiled_regex
> preg
;
2550 gdb::optional
<compiled_regex
> treg
;
2552 if (!get_frame_pc_if_available (frame
, &pc
))
2555 fprintf_filtered (stream
,
2556 _("PC unavailable, cannot determine args.\n"));
2560 func
= get_frame_function (frame
);
2564 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2568 prepare_reg (regexp
, &cb_data
.preg
);
2569 prepare_reg (t_regexp
, &cb_data
.treg
);
2570 cb_data
.frame_id
= get_frame_id (frame
);
2571 cb_data
.num_tabs
= 0;
2572 cb_data
.stream
= stream
;
2573 cb_data
.values_printed
= 0;
2575 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2576 do_print_variable_and_value
, &cb_data
);
2578 /* do_print_variable_and_value invalidates FRAME. */
2581 if (!cb_data
.values_printed
&& !quiet
)
2583 if (regexp
== NULL
&& t_regexp
== NULL
)
2584 fprintf_filtered (stream
, _("No arguments.\n"));
2586 fprintf_filtered (stream
, _("No matching arguments.\n"));
2590 /* Implement the 'info args' command. */
2593 info_args_command (const char *args
, int from_tty
)
2595 info_print_options opts
;
2596 auto grp
= make_info_print_options_def_group (&opts
);
2597 gdb::option::process_options
2598 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2599 if (args
!= nullptr && *args
== '\0')
2602 print_frame_arg_vars
2603 (get_selected_frame (_("No frame selected.")),
2605 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2609 /* Return the symbol-block in which the selected frame is executing.
2610 Can return zero under various legitimate circumstances.
2612 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2613 code address within the block returned. We use this to decide
2614 which macros are in scope. */
2616 const struct block
*
2617 get_selected_block (CORE_ADDR
*addr_in_block
)
2619 if (!has_stack_frames ())
2622 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2625 /* Find a frame a certain number of levels away from FRAME.
2626 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2627 Positive means go to earlier frames (up); negative, the reverse.
2628 The int that contains the number of levels is counted toward
2629 zero as the frames for those levels are found.
2630 If the top or bottom frame is reached, that frame is returned,
2631 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2632 how much farther the original request asked to go. */
2635 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2637 /* Going up is simple: just call get_prev_frame enough times or
2638 until the initial frame is reached. */
2639 while (*level_offset_ptr
> 0)
2641 struct frame_info
*prev
= get_prev_frame (frame
);
2645 (*level_offset_ptr
)--;
2649 /* Going down is just as simple. */
2650 while (*level_offset_ptr
< 0)
2652 struct frame_info
*next
= get_next_frame (frame
);
2656 (*level_offset_ptr
)++;
2663 /* Select the frame up one or COUNT_EXP stack levels from the
2664 previously selected frame, and print it briefly. */
2667 up_silently_base (const char *count_exp
)
2669 struct frame_info
*frame
;
2673 count
= parse_and_eval_long (count_exp
);
2675 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2676 if (count
!= 0 && count_exp
== NULL
)
2677 error (_("Initial frame selected; you cannot go up."));
2678 select_frame (frame
);
2682 up_silently_command (const char *count_exp
, int from_tty
)
2684 up_silently_base (count_exp
);
2688 up_command (const char *count_exp
, int from_tty
)
2690 up_silently_base (count_exp
);
2691 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2694 /* Select the frame down one or COUNT_EXP stack levels from the previously
2695 selected frame, and print it briefly. */
2698 down_silently_base (const char *count_exp
)
2700 struct frame_info
*frame
;
2704 count
= -parse_and_eval_long (count_exp
);
2706 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2707 if (count
!= 0 && count_exp
== NULL
)
2709 /* We only do this if COUNT_EXP is not specified. That way
2710 "down" means to really go down (and let me know if that is
2711 impossible), but "down 9999" can be used to mean go all the
2712 way down without getting an error. */
2714 error (_("Bottom (innermost) frame selected; you cannot go down."));
2717 select_frame (frame
);
2721 down_silently_command (const char *count_exp
, int from_tty
)
2723 down_silently_base (count_exp
);
2727 down_command (const char *count_exp
, int from_tty
)
2729 down_silently_base (count_exp
);
2730 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2734 return_command (const char *retval_exp
, int from_tty
)
2736 /* Initialize it just to avoid a GCC false warning. */
2737 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2738 struct frame_info
*thisframe
;
2739 struct gdbarch
*gdbarch
;
2740 struct symbol
*thisfun
;
2741 struct value
*return_value
= NULL
;
2742 struct value
*function
= NULL
;
2743 const char *query_prefix
= "";
2745 thisframe
= get_selected_frame ("No selected frame.");
2746 thisfun
= get_frame_function (thisframe
);
2747 gdbarch
= get_frame_arch (thisframe
);
2749 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2750 error (_("Can not force return from an inlined function."));
2752 /* Compute the return value. If the computation triggers an error,
2753 let it bail. If the return type can't be handled, set
2754 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2758 expression_up retval_expr
= parse_expression (retval_exp
);
2759 struct type
*return_type
= NULL
;
2761 /* Compute the return value. Should the computation fail, this
2762 call throws an error. */
2763 return_value
= evaluate_expression (retval_expr
.get ());
2765 /* Cast return value to the return type of the function. Should
2766 the cast fail, this call throws an error. */
2767 if (thisfun
!= NULL
)
2768 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2769 if (return_type
== NULL
)
2771 if (retval_expr
->first_opcode () != UNOP_CAST
2772 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2773 error (_("Return value type not available for selected "
2775 "Please use an explicit cast of the value to return."));
2776 return_type
= value_type (return_value
);
2778 return_type
= check_typedef (return_type
);
2779 return_value
= value_cast (return_type
, return_value
);
2781 /* Make sure the value is fully evaluated. It may live in the
2782 stack frame we're about to pop. */
2783 if (value_lazy (return_value
))
2784 value_fetch_lazy (return_value
);
2786 if (thisfun
!= NULL
)
2787 function
= read_var_value (thisfun
, NULL
, thisframe
);
2789 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2790 if (return_type
->code () == TYPE_CODE_VOID
)
2791 /* If the return-type is "void", don't try to find the
2792 return-value's location. However, do still evaluate the
2793 return expression so that, even when the expression result
2794 is discarded, side effects such as "return i++" still
2796 return_value
= NULL
;
2797 else if (thisfun
!= NULL
)
2799 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2800 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2801 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2803 query_prefix
= "The location at which to store the "
2804 "function's return value is unknown.\n"
2805 "If you continue, the return value "
2806 "that you specified will be ignored.\n";
2807 return_value
= NULL
;
2812 /* Does an interactive user really want to do this? Include
2813 information, such as how well GDB can handle the return value, in
2814 the query message. */
2819 if (thisfun
== NULL
)
2820 confirmed
= query (_("%sMake selected stack frame return now? "),
2824 if (TYPE_NO_RETURN (thisfun
->type
))
2825 warning (_("Function does not return normally to caller."));
2826 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2827 thisfun
->print_name ());
2830 error (_("Not confirmed"));
2833 /* Discard the selected frame and all frames inner-to it. */
2834 frame_pop (get_selected_frame (NULL
));
2836 /* Store RETURN_VALUE in the just-returned register set. */
2837 if (return_value
!= NULL
)
2839 struct type
*return_type
= value_type (return_value
);
2840 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2842 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2843 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2844 gdbarch_return_value (cache_arch
, function
, return_type
,
2845 get_current_regcache (), NULL
/*read*/,
2846 value_contents (return_value
).data () /*write*/);
2849 /* If we are at the end of a call dummy now, pop the dummy frame
2851 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2852 frame_pop (get_current_frame ());
2854 select_frame (get_current_frame ());
2855 /* If interactive, print the frame that is now current. */
2857 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2860 /* Find the most inner frame in the current stack for a function called
2861 FUNCTION_NAME. If no matching frame is found return NULL. */
2863 static struct frame_info
*
2864 find_frame_for_function (const char *function_name
)
2866 /* Used to hold the lower and upper addresses for each of the
2867 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2868 struct function_bounds
2870 CORE_ADDR low
, high
;
2872 struct frame_info
*frame
;
2876 gdb_assert (function_name
!= NULL
);
2878 frame
= get_current_frame ();
2879 std::vector
<symtab_and_line
> sals
2880 = decode_line_with_current_source (function_name
,
2881 DECODE_LINE_FUNFIRSTLINE
);
2882 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2883 for (size_t i
= 0; i
< sals
.size (); i
++)
2885 if (sals
[i
].pspace
!= current_program_space
)
2886 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2887 else if (sals
[i
].pc
== 0
2888 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2889 &func_bounds
[i
].low
,
2890 &func_bounds
[i
].high
) == 0)
2891 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2896 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2897 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2898 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2902 frame
= find_relative_frame (frame
, &level
);
2905 while (!found
&& level
== 0);
2913 /* Implements the dbx 'func' command. */
2916 func_command (const char *arg
, int from_tty
)
2921 struct frame_info
*frame
= find_frame_for_function (arg
);
2923 error (_("'%s' not within current stack frame."), arg
);
2924 if (frame
!= get_selected_frame (NULL
))
2926 select_frame (frame
);
2927 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2931 /* The qcs command line flags for the "frame apply" commands. Keep
2932 this in sync with the "thread apply" commands. */
2934 using qcs_flag_option_def
2935 = gdb::option::flag_option_def
<qcs_flags
>;
2937 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2938 qcs_flag_option_def
{
2939 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2940 N_("Disables printing the frame location information."),
2943 qcs_flag_option_def
{
2944 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2945 N_("Print any error raised by COMMAND and continue."),
2948 qcs_flag_option_def
{
2949 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2950 N_("Silently ignore any errors or empty output produced by COMMAND."),
2954 /* Create an option_def_group array for all the "frame apply" options,
2955 with FLAGS and SET_BT_OPTS as context. */
2957 static inline std::array
<gdb::option::option_def_group
, 2>
2958 make_frame_apply_options_def_group (qcs_flags
*flags
,
2959 set_backtrace_options
*set_bt_opts
)
2962 { {fr_qcs_flags_option_defs
}, flags
},
2963 { {set_backtrace_option_defs
}, set_bt_opts
},
2967 /* Apply a GDB command to all stack frames, or a set of identified frames,
2968 or innermost COUNT frames.
2969 With a negative COUNT, apply command on outermost -COUNT frames.
2971 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2972 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2973 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2974 frame apply all -s p local_var_no_idea_in_which_frame
2975 If a frame has a local variable called
2976 local_var_no_idea_in_which_frame, print frame
2977 and value of local_var_no_idea_in_which_frame.
2978 frame apply all -s -q p local_var_no_idea_in_which_frame
2979 Same as before, but only print the variable value.
2980 frame apply level 2-5 0 4-7 -s p i = i + 1
2981 Adds 1 to the variable i in the specified frames.
2982 Note that i will be incremented twice in
2985 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2986 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2987 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2988 for error messages. */
2991 frame_apply_command_count (const char *which_command
,
2992 const char *cmd
, int from_tty
,
2993 struct frame_info
*trailing
, int count
)
2996 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2998 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2999 gdb::option::process_options
3000 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
3002 validate_flags_qcs (which_command
, &flags
);
3004 if (cmd
== NULL
|| *cmd
== '\0')
3005 error (_("Please specify a command to apply on the selected frames"));
3007 /* The below will restore the current inferior/thread/frame.
3008 Usually, only the frame is effectively to be restored.
3009 But in case CMD switches of inferior/thread, better restore
3011 scoped_restore_current_thread restore_thread
;
3013 /* These options are handled quite deep in the unwind machinery, so
3014 we get to pass them down by swapping globals. */
3015 scoped_restore restore_set_backtrace_options
3016 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
3018 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
3025 std::string cmd_result
;
3027 /* In case CMD switches of inferior/thread/frame, the below
3028 restores the inferior/thread/frame. FI can then be
3029 set to the selected frame. */
3030 scoped_restore_current_thread restore_fi_current_frame
;
3032 execute_command_to_string
3033 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
3035 fi
= get_selected_frame (_("frame apply "
3036 "unable to get selected frame."));
3037 if (!flags
.silent
|| cmd_result
.length () > 0)
3040 print_stack_frame (fi
, 1, LOCATION
, 0);
3041 printf_filtered ("%s", cmd_result
.c_str ());
3044 catch (const gdb_exception_error
&ex
)
3046 fi
= get_selected_frame (_("frame apply "
3047 "unable to get selected frame."));
3051 print_stack_frame (fi
, 1, LOCATION
, 0);
3053 printf_filtered ("%s\n", ex
.what ());
3061 /* Completer for the "frame apply ..." commands. */
3064 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3066 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3067 if (gdb::option::complete_options
3068 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3071 complete_nested_command_line (tracker
, text
);
3074 /* Completer for the "frame apply" commands. */
3077 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3078 completion_tracker
&tracker
,
3079 const char *text
, const char */
*word*/
)
3081 /* Do this explicitly because there's an early return below. */
3082 tracker
.set_use_custom_word_point (true);
3084 number_or_range_parser
levels (text
);
3086 /* Skip the LEVEL list to find the options and command args. */
3089 while (!levels
.finished ())
3091 /* Call for effect. */
3092 levels
.get_number ();
3094 if (levels
.in_range ())
3095 levels
.skip_range ();
3098 catch (const gdb_exception_error
&ex
)
3100 /* get_number throws if it parses a negative number, for
3101 example. But a seemingly negative number may be the start of
3102 an option instead. */
3105 const char *cmd
= levels
.cur_tok ();
3109 /* No level list yet. */
3113 /* Check if we're past a valid LEVEL already. */
3114 if (levels
.finished ()
3115 && cmd
> text
&& !isspace (cmd
[-1]))
3118 /* We're past LEVELs, advance word point. */
3119 tracker
.advance_custom_word_point_by (cmd
- text
);
3122 frame_apply_completer (tracker
, text
);
3125 /* Completer for the "frame apply all" command. */
3128 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3129 completion_tracker
&tracker
,
3130 const char *text
, const char */
*word*/
)
3132 frame_apply_completer (tracker
, text
);
3135 /* Completer for the "frame apply COUNT" command. */
3138 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3139 completion_tracker
&tracker
,
3140 const char *text
, const char */
*word*/
)
3142 const char *cmd
= text
;
3144 int count
= get_number_trailer (&cmd
, 0);
3148 /* Check if we're past a valid COUNT already. */
3149 if (cmd
> text
&& !isspace (cmd
[-1]))
3152 /* We're past COUNT, advance word point. */
3153 tracker
.advance_custom_word_point_by (cmd
- text
);
3156 frame_apply_completer (tracker
, text
);
3159 /* Implementation of the "frame apply level" command. */
3162 frame_apply_level_command (const char *cmd
, int from_tty
)
3164 if (!target_has_stack ())
3165 error (_("No stack."));
3167 bool level_found
= false;
3168 const char *levels_str
= cmd
;
3169 number_or_range_parser
levels (levels_str
);
3171 /* Skip the LEVEL list to find the flags and command args. */
3172 while (!levels
.finished ())
3174 /* Call for effect. */
3175 levels
.get_number ();
3178 if (levels
.in_range ())
3179 levels
.skip_range ();
3183 error (_("Missing or invalid LEVEL... argument"));
3185 cmd
= levels
.cur_tok ();
3187 /* Redo the LEVELS parsing, but applying COMMAND. */
3188 levels
.init (levels_str
);
3189 while (!levels
.finished ())
3191 const int level_beg
= levels
.get_number ();
3194 if (levels
.in_range ())
3196 n_frames
= levels
.end_value () - level_beg
+ 1;
3197 levels
.skip_range ();
3202 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3203 leading_innermost_frame (level_beg
), n_frames
);
3207 /* Implementation of the "frame apply all" command. */
3210 frame_apply_all_command (const char *cmd
, int from_tty
)
3212 if (!target_has_stack ())
3213 error (_("No stack."));
3215 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3216 get_current_frame (), INT_MAX
);
3219 /* Implementation of the "frame apply" command. */
3222 frame_apply_command (const char* cmd
, int from_tty
)
3225 struct frame_info
*trailing
;
3227 if (!target_has_stack ())
3228 error (_("No stack."));
3231 error (_("Missing COUNT argument."));
3232 count
= get_number_trailer (&cmd
, 0);
3234 error (_("Invalid COUNT argument."));
3238 trailing
= trailing_outermost_frame (-count
);
3242 trailing
= get_current_frame ();
3244 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3248 /* Implementation of the "faas" command. */
3251 faas_command (const char *cmd
, int from_tty
)
3253 if (cmd
== NULL
|| *cmd
== '\0')
3254 error (_("Please specify a command to apply on all frames"));
3255 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3256 execute_command (expanded
.c_str (), from_tty
);
3260 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3261 matching frame can be found. */
3263 static struct frame_info
*
3264 find_frame_for_address (CORE_ADDR address
)
3267 struct frame_info
*fid
;
3269 id
= frame_id_build_wild (address
);
3271 /* If (s)he specifies the frame with an address, he deserves
3272 what (s)he gets. Still, give the highest one that matches.
3273 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3275 for (fid
= get_current_frame ();
3277 fid
= get_prev_frame (fid
))
3279 if (frame_id_eq (id
, get_frame_id (fid
)))
3281 struct frame_info
*prev_frame
;
3285 prev_frame
= get_prev_frame (fid
);
3287 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3299 /* Commands with a prefix of `frame apply'. */
3300 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3302 /* Commands with a prefix of `frame'. */
3303 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3305 /* Commands with a prefix of `select frame'. */
3306 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3308 /* Commands with a prefix of `info frame'. */
3309 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3311 void _initialize_stack ();
3313 _initialize_stack ()
3315 struct cmd_list_element
*cmd
;
3317 add_com ("return", class_stack
, return_command
, _("\
3318 Make selected stack frame return to its caller.\n\
3319 Control remains in the debugger, but when you continue\n\
3320 execution will resume in the frame above the one now selected.\n\
3321 If an argument is given, it is an expression for the value to return."));
3323 add_com ("up", class_stack
, up_command
, _("\
3324 Select and print stack frame that called this one.\n\
3325 An argument says how many frames up to go."));
3326 add_com ("up-silently", class_support
, up_silently_command
, _("\
3327 Same as the `up' command, but does not print anything.\n\
3328 This is useful in command scripts."));
3330 cmd_list_element
*down_cmd
3331 = add_com ("down", class_stack
, down_command
, _("\
3332 Select and print stack frame called by this one.\n\
3333 An argument says how many frames down to go."));
3334 add_com_alias ("do", down_cmd
, class_stack
, 1);
3335 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3336 add_com ("down-silently", class_support
, down_silently_command
, _("\
3337 Same as the `down' command, but does not print anything.\n\
3338 This is useful in command scripts."));
3340 cmd_list_element
*frame_cmd_el
3341 = add_prefix_cmd ("frame", class_stack
,
3342 &frame_cmd
.base_command
, _("\
3343 Select and print a stack frame.\n\
3344 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3345 A single numerical argument specifies the frame to select."),
3346 &frame_cmd_list
, 1, &cmdlist
);
3347 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3349 #define FRAME_APPLY_OPTION_HELP "\
3350 Prints the frame location information followed by COMMAND output.\n\
3352 By default, an error raised during the execution of COMMAND\n\
3353 aborts \"frame apply\".\n\
3358 const auto frame_apply_opts
3359 = make_frame_apply_options_def_group (nullptr, nullptr);
3361 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3362 Apply a command to a number of frames.\n\
3363 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3364 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3365 FRAME_APPLY_OPTION_HELP
),
3368 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3369 frame_apply_cmd_help
.c_str (),
3370 &frame_apply_cmd_list
, 1,
3372 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3374 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3375 Apply a command to all frames.\n\
3377 Usage: frame apply all [OPTION]... COMMAND\n"
3378 FRAME_APPLY_OPTION_HELP
),
3381 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3382 frame_apply_all_cmd_help
.c_str (),
3383 &frame_apply_cmd_list
);
3384 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3386 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3387 Apply a command to a list of frames.\n\
3389 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3390 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3391 FRAME_APPLY_OPTION_HELP
),
3394 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3395 frame_apply_level_cmd_help
.c_str (),
3396 &frame_apply_cmd_list
);
3397 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3399 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3400 Apply a command to all frames (ignoring errors and empty output).\n\
3401 Usage: faas [OPTION]... COMMAND\n\
3402 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3403 See \"help frame apply all\" for available options."));
3404 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3406 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3408 Select and print a stack frame by stack address.\n\
3410 Usage: frame address STACK-ADDRESS"),
3413 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3415 View a stack frame that might be outside the current backtrace.\n\
3417 Usage: frame view STACK-ADDRESS\n\
3418 frame view STACK-ADDRESS PC-ADDRESS"),
3421 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3423 Select and print a stack frame by function name.\n\
3425 Usage: frame function NAME\n\
3427 The innermost frame that visited function NAME is selected."),
3429 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3432 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3434 Select and print a stack frame by level.\n\
3436 Usage: frame level LEVEL"),
3439 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3440 &select_frame_cmd
.base_command
, _("\
3441 Select a stack frame without printing anything.\n\
3442 A single numerical argument specifies the frame to select."),
3443 &select_frame_cmd_list
, 1, &cmdlist
,
3444 &cli_suppress_notification
.user_selected_context
);
3446 add_cmd_suppress_notification ("address", class_stack
,
3447 &select_frame_cmd
.address
, _("\
3448 Select a stack frame by stack address.\n\
3450 Usage: select-frame address STACK-ADDRESS"),
3451 &select_frame_cmd_list
,
3452 &cli_suppress_notification
.user_selected_context
);
3455 add_cmd_suppress_notification ("view", class_stack
,
3456 &select_frame_cmd
.view
, _("\
3457 Select a stack frame that might be outside the current backtrace.\n\
3459 Usage: select-frame view STACK-ADDRESS\n\
3460 select-frame view STACK-ADDRESS PC-ADDRESS"),
3461 &select_frame_cmd_list
,
3462 &cli_suppress_notification
.user_selected_context
);
3464 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3465 &select_frame_cmd
.function
, _("\
3466 Select a stack frame by function name.\n\
3468 Usage: select-frame function NAME"),
3469 &select_frame_cmd_list
,
3470 &cli_suppress_notification
.user_selected_context
);
3471 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3473 add_cmd_suppress_notification ("level", class_stack
,
3474 &select_frame_cmd
.level
, _("\
3475 Select a stack frame by level.\n\
3477 Usage: select-frame level LEVEL"),
3478 &select_frame_cmd_list
,
3479 &cli_suppress_notification
.user_selected_context
);
3481 const auto backtrace_opts
3482 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3484 static std::string backtrace_help
3485 = gdb::option::build_help (_("\
3486 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3487 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3492 For backward compatibility, the following qualifiers are supported:\n\
3494 full - same as -full option.\n\
3495 no-filters - same as -no-filters option.\n\
3496 hide - same as -hide.\n\
3498 With a negative COUNT, print outermost -COUNT frames."),
3501 cmd_list_element
*backtrace_cmd
3502 = add_com ("backtrace", class_stack
, backtrace_command
,
3503 backtrace_help
.c_str ());
3504 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3506 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3508 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3509 cmd_list_element
*info_stack_cmd
3510 = add_info ("stack", backtrace_command
,
3511 _("Backtrace of the stack, or innermost COUNT frames."));
3512 add_info_alias ("s", info_stack_cmd
, 1);
3514 cmd_list_element
*info_frame_cmd_el
3515 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3516 _("All about the selected stack frame.\n\
3517 With no arguments, displays information about the currently selected stack\n\
3518 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3519 the information is then printed about the specified frame."),
3520 &info_frame_cmd_list
, 1, &infolist
);
3521 add_info_alias ("f", info_frame_cmd_el
, 1);
3523 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3525 Print information about a stack frame selected by stack address.\n\
3527 Usage: info frame address STACK-ADDRESS"),
3528 &info_frame_cmd_list
);
3530 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3532 Print information about a stack frame outside the current backtrace.\n\
3534 Usage: info frame view STACK-ADDRESS\n\
3535 info frame view STACK-ADDRESS PC-ADDRESS"),
3536 &info_frame_cmd_list
);
3538 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3540 Print information about a stack frame selected by function name.\n\
3542 Usage: info frame function NAME"),
3543 &info_frame_cmd_list
);
3544 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3546 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3548 Print information about a stack frame selected by level.\n\
3550 Usage: info frame level LEVEL"),
3551 &info_frame_cmd_list
);
3553 cmd
= add_info ("locals", info_locals_command
,
3554 info_print_args_help (_("\
3555 All local variables of current stack frame or those matching REGEXPs.\n\
3556 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3557 Prints the local variables of the current stack frame.\n"),
3558 _("local variables"),
3560 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3561 cmd
= add_info ("args", info_args_command
,
3562 info_print_args_help (_("\
3563 All argument variables of current stack frame or those matching REGEXPs.\n\
3564 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3565 Prints the argument variables of the current stack frame.\n"),
3566 _("argument variables"),
3568 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3571 add_com ("func", class_stack
, func_command
, _("\
3572 Select the stack frame that contains NAME.\n\
3573 Usage: func NAME"));
3575 /* Install "set print raw frame-arguments", a deprecated spelling of
3576 "set print raw-frame-arguments". */
3577 set_show_commands set_show_frame_args
3578 = add_setshow_boolean_cmd
3579 ("frame-arguments", no_class
,
3580 &user_frame_print_options
.print_raw_frame_arguments
,
3582 Set whether to print frame arguments in raw form."), _("\
3583 Show whether to print frame arguments in raw form."), _("\
3584 If set, frame arguments are printed in raw form, bypassing any\n\
3585 pretty-printers for that value."),
3587 &setprintrawlist
, &showprintrawlist
);
3588 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3590 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3591 &disassemble_next_line
, _("\
3592 Set whether to disassemble next source line or insn when execution stops."),
3594 Show whether to disassemble next source line or insn when execution stops."),
3596 If ON, GDB will display disassembly of the next source line, in addition\n\
3597 to displaying the source line itself. If the next source line cannot\n\
3598 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3599 will display disassembly of next instruction instead of showing the\n\
3601 If AUTO, display disassembly of next instruction only if the source line\n\
3602 cannot be displayed.\n\
3603 If OFF (which is the default), never display the disassembly of the next\n\
3606 show_disassemble_next_line
,
3607 &setlist
, &showlist
);
3608 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3610 gdb::option::add_setshow_cmds_for_options
3611 (class_stack
, &user_frame_print_options
,
3612 frame_print_option_defs
, &setprintlist
, &showprintlist
);