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 (frame_info_ptr frame
,
220 const char *regexp
, const char *t_regexp
,
221 int num_tabs
, struct ui_file
*stream
);
223 static void print_frame (const frame_print_options
&opts
,
224 frame_info_ptr frame
, int print_level
,
225 enum print_what print_what
, int print_args
,
226 struct symtab_and_line sal
);
228 static frame_info_ptr
find_frame_for_function (const char *);
229 static frame_info_ptr
find_frame_for_address (CORE_ADDR
);
231 /* Zero means do things normally; we are interacting directly with the
232 user. One means print the full filename and linenumber when a
233 frame is printed, and do so in a format emacs18/emacs19.22 can
234 parse. Two means print similar annotations, but in many more
235 cases and in a slightly different syntax. */
237 int annotation_level
= 0;
239 /* Class used to manage tracking the last symtab we displayed. */
241 class last_displayed_symtab_info_type
244 /* True if the cached information is valid. */
245 bool is_valid () const
248 /* Return the cached program_space. If the cache is invalid nullptr is
250 struct program_space
*pspace () const
253 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
255 CORE_ADDR
address () const
256 { return m_address
; }
258 /* Return the cached symtab. If the cache is invalid nullptr is
260 struct symtab
*symtab () const
263 /* Return the cached line number. If the cache is invalid 0 is
268 /* Invalidate the cache, reset all the members to their default value. */
278 /* Store a new set of values in the cache. */
279 void set (struct program_space
*pspace
, CORE_ADDR address
,
280 struct symtab
*symtab
, int line
)
282 gdb_assert (pspace
!= nullptr);
292 /* True when the cache is valid. */
293 bool m_valid
= false;
295 /* The last program space displayed. */
296 struct program_space
*m_pspace
= nullptr;
298 /* The last address displayed. */
299 CORE_ADDR m_address
= 0;
301 /* The last symtab displayed. */
302 struct symtab
*m_symtab
= nullptr;
304 /* The last line number displayed. */
308 /* An actual instance of the cache, holds information about the last symtab
310 static last_displayed_symtab_info_type last_displayed_symtab_info
;
317 frame_show_address (frame_info_ptr frame
,
318 struct symtab_and_line sal
)
320 /* If there is a line number, but no PC, then there is no location
321 information associated with this sal. The only way that should
322 happen is for the call sites of inlined functions (SAL comes from
323 find_frame_sal). Otherwise, we would have some PC range if the
324 SAL came from a line table. */
325 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
327 if (get_next_frame (frame
) == NULL
)
328 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
330 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
334 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
340 print_stack_frame_to_uiout (struct ui_out
*uiout
, frame_info_ptr frame
,
341 int print_level
, enum print_what print_what
,
344 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
346 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
349 /* Show or print a stack frame FRAME briefly. The output is formatted
350 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
351 relative level, function name, argument list, and file name and
352 line number. If the frame's PC is not at the beginning of the
353 source line, the actual PC is printed at the beginning. */
356 print_stack_frame (frame_info_ptr frame
, int print_level
,
357 enum print_what print_what
,
361 /* For mi, always print location and address. */
362 if (current_uiout
->is_mi_like_p ())
363 print_what
= LOC_AND_ADDRESS
;
365 frame
.prepare_reinflate ();
368 print_frame_info (user_frame_print_options
,
369 frame
, print_level
, print_what
, 1 /* print_args */,
373 set_current_sal_from_frame (frame
);
375 catch (const gdb_exception_error
&e
)
380 /* Print nameless arguments of frame FRAME on STREAM, where START is
381 the offset of the first nameless argument, and NUM is the number of
382 nameless arguments to print. FIRST is nonzero if this is the first
383 argument (not just the first nameless argument). */
386 print_frame_nameless_args (frame_info_ptr frame
, long start
, int num
,
387 int first
, struct ui_file
*stream
)
389 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
390 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
395 for (i
= 0; i
< num
; i
++)
398 argsaddr
= get_frame_args_address (frame
);
401 arg_value
= read_memory_integer (argsaddr
+ start
,
402 sizeof (int), byte_order
);
404 gdb_printf (stream
, ", ");
405 gdb_printf (stream
, "%ld", arg_value
);
407 start
+= sizeof (int);
411 /* Print single argument of inferior function. ARG must be already
414 Errors are printed as if they would be the parameter value. Use zeroed ARG
415 iff it should not be printed according to user settings. */
418 print_frame_arg (const frame_print_options
&fp_opts
,
419 const struct frame_arg
*arg
)
421 struct ui_out
*uiout
= current_uiout
;
425 gdb_assert (!arg
->val
|| !arg
->error
);
426 gdb_assert (arg
->entry_kind
== print_entry_values_no
427 || arg
->entry_kind
== print_entry_values_only
428 || (!uiout
->is_mi_like_p ()
429 && arg
->entry_kind
== print_entry_values_compact
));
431 annotate_arg_emitter arg_emitter
;
432 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
433 gdb_puts (arg
->sym
->print_name (), &stb
);
434 if (arg
->entry_kind
== print_entry_values_compact
)
436 /* It is OK to provide invalid MI-like stream as with
437 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
440 gdb_puts (arg
->sym
->print_name (), &stb
);
442 if (arg
->entry_kind
== print_entry_values_only
443 || arg
->entry_kind
== print_entry_values_compact
)
445 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
446 annotate_arg_name_end ();
450 if (!arg
->val
&& !arg
->error
)
456 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
457 style
= metadata_style
.style ();
463 const struct language_defn
*language
;
464 struct value_print_options vp_opts
;
466 /* Avoid value_print because it will deref ref parameters. We
467 just want to print their addresses. Print ??? for args whose
468 address we do not know. We pass 2 as "recurse" to val_print
469 because our standard indentation here is 4 spaces, and
470 val_print indents 2 for each recurse. */
472 annotate_arg_value (value_type (arg
->val
));
474 /* Use the appropriate language to display our symbol, unless the
475 user forced the language to a specific language. */
476 if (language_mode
== language_mode_auto
)
477 language
= language_def (arg
->sym
->language ());
479 language
= current_language
;
481 get_no_prettyformat_print_options (&vp_opts
);
482 vp_opts
.deref_ref
= 1;
483 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
485 /* True in "summary" mode, false otherwise. */
487 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
489 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
491 catch (const gdb_exception_error
&except
)
493 stb
.printf (_("<error reading variable: %s>"),
495 style
= metadata_style
.style ();
500 uiout
->field_stream ("value", stb
, style
);
503 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
504 responsible for xfree of ARGP->ERROR. This function never throws an
508 read_frame_local (struct symbol
*sym
, frame_info_ptr frame
,
509 struct frame_arg
*argp
)
517 argp
->val
= read_var_value (sym
, NULL
, frame
);
519 catch (const gdb_exception_error
&except
)
521 argp
->error
.reset (xstrdup (except
.what ()));
525 /* Read in inferior function parameter SYM at FRAME into ARGP. This
526 function never throws an exception. */
529 read_frame_arg (const frame_print_options
&fp_opts
,
530 symbol
*sym
, frame_info_ptr frame
,
531 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
533 struct value
*val
= NULL
, *entryval
= NULL
;
534 char *val_error
= NULL
, *entryval_error
= NULL
;
537 if (fp_opts
.print_entry_values
!= print_entry_values_only
538 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
542 val
= read_var_value (sym
, NULL
, frame
);
544 catch (const gdb_exception_error
&except
)
546 val_error
= (char *) alloca (except
.message
->size () + 1);
547 strcpy (val_error
, except
.what ());
551 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
552 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
553 && fp_opts
.print_entry_values
!= print_entry_values_no
554 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
555 || !val
|| value_optimized_out (val
)))
559 const struct symbol_computed_ops
*ops
;
561 ops
= SYMBOL_COMPUTED_OPS (sym
);
562 entryval
= ops
->read_variable_at_entry (sym
, frame
);
564 catch (const gdb_exception_error
&except
)
566 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
568 entryval_error
= (char *) alloca (except
.message
->size () + 1);
569 strcpy (entryval_error
, except
.what ());
573 if (entryval
!= NULL
&& value_optimized_out (entryval
))
576 if (fp_opts
.print_entry_values
== print_entry_values_compact
577 || fp_opts
.print_entry_values
== print_entry_values_default
)
579 /* For MI do not try to use print_entry_values_compact for ARGP. */
581 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
583 struct type
*type
= value_type (val
);
585 if (value_lazy (val
))
586 value_fetch_lazy (val
);
587 if (value_lazy (entryval
))
588 value_fetch_lazy (entryval
);
590 if (value_contents_eq (val
, 0, entryval
, 0, type
->length ()))
592 /* Initialize it just to avoid a GCC false warning. */
593 struct value
*val_deref
= NULL
, *entryval_deref
;
595 /* DW_AT_call_value does match with the current
596 value. If it is a reference still try to verify if
597 dereferenced DW_AT_call_data_value does not differ. */
601 struct type
*type_deref
;
603 val_deref
= coerce_ref (val
);
604 if (value_lazy (val_deref
))
605 value_fetch_lazy (val_deref
);
606 type_deref
= value_type (val_deref
);
608 entryval_deref
= coerce_ref (entryval
);
609 if (value_lazy (entryval_deref
))
610 value_fetch_lazy (entryval_deref
);
612 /* If the reference addresses match but dereferenced
613 content does not match print them. */
615 && value_contents_eq (val_deref
, 0,
617 type_deref
->length ()))
620 catch (const gdb_exception_error
&except
)
622 /* If the dereferenced content could not be
623 fetched do not display anything. */
624 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
626 else if (except
.message
!= NULL
)
629 = (char *) alloca (except
.message
->size () + 1);
630 strcpy (entryval_error
, except
.what ());
634 /* Value was not a reference; and its content matches. */
635 if (val
== val_deref
)
643 /* Try to remove possibly duplicate error message for ENTRYARGP even
646 if (val_error
&& entryval_error
647 && strcmp (val_error
, entryval_error
) == 0)
649 entryval_error
= NULL
;
651 /* Do not se VAL_EQUAL as the same error message may be shown for
652 the entry value even if no entry values are present in the
658 if (entryval
== NULL
)
660 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
662 gdb_assert (val
== NULL
);
666 val
= read_var_value (sym
, NULL
, frame
);
668 catch (const gdb_exception_error
&except
)
670 val_error
= (char *) alloca (except
.message
->size () + 1);
671 strcpy (val_error
, except
.what ());
674 if (fp_opts
.print_entry_values
== print_entry_values_only
675 || fp_opts
.print_entry_values
== print_entry_values_both
676 || (fp_opts
.print_entry_values
== print_entry_values_preferred
677 && (!val
|| value_optimized_out (val
))))
679 entryval
= allocate_optimized_out_value (sym
->type ());
680 entryval_error
= NULL
;
683 if ((fp_opts
.print_entry_values
== print_entry_values_compact
684 || fp_opts
.print_entry_values
== print_entry_values_if_needed
685 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
686 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
694 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
695 if (!val
&& !val_error
)
696 argp
->entry_kind
= print_entry_values_only
;
697 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
698 || fp_opts
.print_entry_values
== print_entry_values_default
)
701 argp
->entry_kind
= print_entry_values_compact
;
702 gdb_assert (!current_uiout
->is_mi_like_p ());
705 argp
->entry_kind
= print_entry_values_no
;
707 entryargp
->sym
= sym
;
708 entryargp
->val
= entryval
;
709 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
710 if (!entryval
&& !entryval_error
)
711 entryargp
->entry_kind
= print_entry_values_no
;
713 entryargp
->entry_kind
= print_entry_values_only
;
716 /* Print the arguments of frame FRAME on STREAM, given the function
717 FUNC running in that frame (as a symbol), where NUM is the number
718 of arguments according to the stack frame (or -1 if the number of
719 arguments is unknown). */
721 /* Note that currently the "number of arguments according to the
722 stack frame" is only known on VAX where i refers to the "number of
723 ints of arguments according to the stack frame". */
726 print_frame_args (const frame_print_options
&fp_opts
,
727 struct symbol
*func
, frame_info_ptr frame
,
728 int num
, struct ui_file
*stream
)
730 struct ui_out
*uiout
= current_uiout
;
732 /* Offset of next stack argument beyond the one we have seen that is
733 at the highest offset, or -1 if we haven't come to a stack
735 long highest_offset
= -1;
736 /* Number of ints of arguments that we have printed so far. */
737 int args_printed
= 0;
738 /* True if we should print arg names. If false, we only indicate
739 the presence of arguments by printing ellipsis. */
741 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
742 /* True if we should print arguments, false otherwise. */
745 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
747 /* If one of the arguments has a pretty printer that calls a
748 function of the inferior to print it, the pointer must be
750 frame
.prepare_reinflate ();
752 /* Temporarily change the selected frame to the given FRAME.
753 This allows routines that rely on the selected frame instead
754 of being given a frame as parameter to use the correct frame. */
755 scoped_restore_selected_frame restore_selected_frame
;
756 select_frame (frame
);
760 const struct block
*b
= func
->value_block ();
761 struct block_iterator iter
;
764 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
766 struct frame_arg arg
, entryarg
;
770 /* Keep track of the highest stack argument offset seen, and
771 skip over any kinds of symbols we don't care about. */
773 if (!sym
->is_argument ())
783 switch (sym
->aclass ())
788 long current_offset
= sym
->value_longest ();
789 int arg_size
= sym
->type ()->length ();
791 /* Compute address of next argument by adding the size of
792 this argument and rounding to an int boundary. */
794 ((current_offset
+ arg_size
+ sizeof (int) - 1)
795 & ~(sizeof (int) - 1));
797 /* If this is the highest offset seen yet, set
799 if (highest_offset
== -1
800 || (current_offset
> highest_offset
))
801 highest_offset
= current_offset
;
803 /* Add the number of ints we're about to print to
805 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
808 /* We care about types of symbols, but don't need to
809 keep track of stack offsets in them. */
811 case LOC_REGPARM_ADDR
:
813 case LOC_OPTIMIZED_OUT
:
818 /* We have to look up the symbol because arguments can have
819 two entries (one a parameter, one a local) and the one we
820 want is the local, which lookup_symbol will find for us.
821 This includes gcc1 (not gcc2) on SPARC when passing a
822 small structure and gcc2 when the argument type is float
823 and it is passed as a double and converted to float by
824 the prologue (in the latter case the type of the LOC_ARG
825 symbol is double and the type of the LOC_LOCAL symbol is
827 /* But if the parameter name is null, don't try it. Null
828 parameter names occur on the RS/6000, for traceback
829 tables. FIXME, should we even print them? */
831 if (*sym
->linkage_name ())
835 nsym
= lookup_symbol_search_name (sym
->search_name (),
836 b
, VAR_DOMAIN
).symbol
;
837 gdb_assert (nsym
!= NULL
);
838 if (nsym
->aclass () == LOC_REGISTER
839 && !nsym
->is_argument ())
841 /* There is a LOC_ARG/LOC_REGISTER pair. This means
842 that it was passed on the stack and loaded into a
843 register, or passed in a register and stored in a
844 stack slot. GDB 3.x used the LOC_ARG; GDB
845 4.0-4.11 used the LOC_REGISTER.
847 Reasons for using the LOC_ARG:
849 (1) Because find_saved_registers may be slow for
852 (2) Because registers are often re-used and stack
853 slots rarely (never?) are. Therefore using
854 the stack slot is much less likely to print
857 Reasons why we might want to use the LOC_REGISTER:
859 (1) So that the backtrace prints the same value
860 as "print foo". I see no compelling reason
861 why this needs to be the case; having the
862 backtrace print the value which was passed
863 in, and "print foo" print the value as
864 modified within the called function, makes
867 Additional note: It might be nice if "info args"
868 displayed both values.
870 One more note: There is a case with SPARC
871 structure passing where we need to use the
872 LOC_REGISTER, but this is dealt with by creating
873 a single LOC_REGPARM in symbol reading. */
875 /* Leave sym (the LOC_ARG) alone. */
882 /* Print the current arg. */
885 uiout
->wrap_hint (4);
890 arg
.entry_kind
= print_entry_values_no
;
892 entryarg
.entry_kind
= print_entry_values_no
;
895 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
897 if (arg
.entry_kind
!= print_entry_values_only
)
898 print_frame_arg (fp_opts
, &arg
);
900 if (entryarg
.entry_kind
!= print_entry_values_no
)
902 if (arg
.entry_kind
!= print_entry_values_only
)
905 uiout
->wrap_hint (4);
908 print_frame_arg (fp_opts
, &entryarg
);
916 /* Don't print nameless args in situations where we don't know
917 enough about the stack to find them. */
922 if (highest_offset
== -1)
923 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
925 start
= highest_offset
;
927 if (!print_names
&& !first
&& num
> 0)
930 print_frame_nameless_args (frame
, start
, num
- args_printed
,
935 /* Set the current source and line to the location given by frame
936 FRAME, if possible. When CENTER is true, adjust so the relevant
937 line is in the center of the next 'list'. */
940 set_current_sal_from_frame (frame_info_ptr frame
)
942 symtab_and_line sal
= find_frame_sal (frame
);
943 if (sal
.symtab
!= NULL
)
944 set_current_source_symtab_and_line (sal
);
947 /* If ON, GDB will display disassembly of the next source line when
948 execution of the program being debugged stops.
949 If AUTO (which is the default), or there's no line info to determine
950 the source line of the next instruction, display disassembly of next
951 instruction instead. */
953 static enum auto_boolean disassemble_next_line
;
956 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
957 struct cmd_list_element
*c
,
961 _("Debugger's willingness to use "
962 "disassemble-next-line is %s.\n"),
966 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
967 because it will be broken by filter sometime. */
970 do_gdb_disassembly (struct gdbarch
*gdbarch
,
971 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
976 gdb_disassembly (gdbarch
, current_uiout
,
977 DISASSEMBLY_RAW_INSN
, how_many
,
980 catch (const gdb_exception_error
&exception
)
982 /* If an exception was thrown while doing the disassembly, print
983 the error message, to give the user a clue of what happened. */
984 exception_print (gdb_stderr
, exception
);
988 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
989 Value not present indicates to the caller to use default values
990 specific to the command being executed. */
992 static gdb::optional
<enum print_what
>
993 print_frame_info_to_print_what (const char *print_frame_info
)
995 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
996 if (print_frame_info
== print_frame_info_choices
[i
])
997 return print_frame_info_print_what
[i
];
999 internal_error (__FILE__
, __LINE__
,
1000 "Unexpected print frame-info value `%s'.",
1004 /* Print the PC from FRAME, plus any flags, to UIOUT. */
1007 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info_ptr frame
,
1010 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1012 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
1013 if (!flags
.empty ())
1016 uiout
->field_string ("addr_flags", flags
);
1024 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
1027 = print_frame_info_to_print_what
1028 (user_frame_print_options
.print_frame_info
);
1031 /* Print information about frame FRAME. The output is format according
1032 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1033 PRINT_WHAT, see enum print_what comments in frame.h.
1034 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1035 != print_frame_info_auto.
1037 Used in "where" output, and to emit breakpoint or step
1041 print_frame_info (const frame_print_options
&fp_opts
,
1042 frame_info_ptr frame
, int print_level
,
1043 enum print_what print_what
, int print_args
,
1044 int set_current_sal
)
1046 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1049 struct ui_out
*uiout
= current_uiout
;
1051 if (!current_uiout
->is_mi_like_p ()
1052 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1054 /* Use the specific frame information desired by the user. */
1055 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1058 if (get_frame_type (frame
) == DUMMY_FRAME
1059 || get_frame_type (frame
) == SIGTRAMP_FRAME
1060 || get_frame_type (frame
) == ARCH_FRAME
)
1062 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1064 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1065 gdbarch
, get_frame_pc (frame
));
1067 /* Do this regardless of SOURCE because we don't have any source
1068 to list for this frame. */
1072 uiout
->field_fmt_signed (2, ui_left
, "level",
1073 frame_relative_level (frame
));
1075 if (uiout
->is_mi_like_p ())
1077 annotate_frame_address ();
1078 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1079 annotate_frame_address_end ();
1082 if (get_frame_type (frame
) == DUMMY_FRAME
)
1084 annotate_function_call ();
1085 uiout
->field_string ("func", "<function called from gdb>",
1086 metadata_style
.style ());
1088 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1090 annotate_signal_handler_caller ();
1091 uiout
->field_string ("func", "<signal handler called>",
1092 metadata_style
.style ());
1094 else if (get_frame_type (frame
) == ARCH_FRAME
)
1096 uiout
->field_string ("func", "<cross-architecture call>",
1097 metadata_style
.style ());
1100 annotate_frame_end ();
1102 /* If disassemble-next-line is set to auto or on output the next
1104 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1105 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1106 do_gdb_disassembly (get_frame_arch (frame
), 1,
1107 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1112 /* If FRAME is not the innermost frame, that normally means that
1113 FRAME->pc points to *after* the call instruction, and we want to
1114 get the line containing the call, never the next line. But if
1115 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1116 next frame was not entered as the result of a call, and we want
1117 to get the line containing FRAME->pc. */
1118 symtab_and_line sal
= find_frame_sal (frame
);
1120 location_print
= (print_what
== LOCATION
1121 || print_what
== SRC_AND_LOC
1122 || print_what
== LOC_AND_ADDRESS
1123 || print_what
== SHORT_LOCATION
);
1124 if (location_print
|| !sal
.symtab
)
1125 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1127 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1129 /* If disassemble-next-line is set to auto or on and doesn't have
1130 the line debug messages for $pc, output the next instruction. */
1131 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1132 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1133 && source_print
&& !sal
.symtab
)
1134 do_gdb_disassembly (get_frame_arch (frame
), 1,
1135 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1137 if (source_print
&& sal
.symtab
)
1139 int mid_statement
= ((print_what
== SRC_LINE
)
1140 && frame_show_address (frame
, sal
));
1141 if (annotation_level
> 0
1142 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1143 get_frame_pc (frame
)))
1145 /* The call to ANNOTATE_SOURCE_LINE already printed the
1146 annotation for this source line, so we avoid the two cases
1147 below and do not print the actual source line. The
1148 documentation for annotations makes it clear that the source
1149 line annotation is printed __instead__ of printing the source
1150 line, not as well as.
1152 However, if we fail to print the source line, which usually
1153 means either the source file is missing, or the requested
1154 line is out of range of the file, then we don't print the
1155 source annotation, and will pass through the "normal" print
1156 source line code below, the expectation is that this code
1157 will print an appropriate error. */
1159 else if (deprecated_print_frame_info_listing_hook
)
1160 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1164 struct value_print_options opts
;
1166 get_user_print_options (&opts
);
1167 /* We used to do this earlier, but that is clearly
1168 wrong. This function is used by many different
1169 parts of gdb, including normal_stop in infrun.c,
1170 which uses this to print out the current PC
1171 when we stepi/nexti into the middle of a source
1172 line. Only the command line really wants this
1173 behavior. Other UIs probably would like the
1174 ability to decide for themselves if it is desired. */
1175 if (opts
.addressprint
&& mid_statement
)
1177 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1181 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1185 /* If disassemble-next-line is set to on and there is line debug
1186 messages, output assembly codes for next line. */
1187 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1188 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1191 if (set_current_sal
)
1195 if (get_frame_pc_if_available (frame
, &pc
))
1196 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1198 last_displayed_symtab_info
.invalidate ();
1201 annotate_frame_end ();
1203 gdb_flush (gdb_stdout
);
1209 clear_last_displayed_sal (void)
1211 last_displayed_symtab_info
.invalidate ();
1217 last_displayed_sal_is_valid (void)
1219 return last_displayed_symtab_info
.is_valid ();
1224 struct program_space
*
1225 get_last_displayed_pspace (void)
1227 return last_displayed_symtab_info
.pspace ();
1233 get_last_displayed_addr (void)
1235 return last_displayed_symtab_info
.address ();
1241 get_last_displayed_symtab (void)
1243 return last_displayed_symtab_info
.symtab ();
1249 get_last_displayed_line (void)
1251 return last_displayed_symtab_info
.line ();
1257 get_last_displayed_sal ()
1259 symtab_and_line sal
;
1261 if (last_displayed_symtab_info
.is_valid ())
1263 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1264 sal
.pc
= last_displayed_symtab_info
.address ();
1265 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1266 sal
.line
= last_displayed_symtab_info
.line ();
1273 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1274 corresponding to FRAME. */
1276 gdb::unique_xmalloc_ptr
<char>
1277 find_frame_funname (frame_info_ptr frame
, enum language
*funlang
,
1278 struct symbol
**funcp
)
1280 struct symbol
*func
;
1281 gdb::unique_xmalloc_ptr
<char> funname
;
1283 *funlang
= language_unknown
;
1287 func
= get_frame_function (frame
);
1290 const char *print_name
= func
->print_name ();
1292 *funlang
= func
->language ();
1295 if (*funlang
== language_cplus
)
1297 /* It seems appropriate to use print_name() here,
1298 to display the demangled name that we already have
1299 stored in the symbol table, but we stored a version
1300 with DMGL_PARAMS turned on, and here we don't want to
1301 display parameters. So remove the parameters. */
1302 funname
= cp_remove_params (print_name
);
1305 /* If we didn't hit the C++ case above, set *funname
1307 if (funname
== NULL
)
1308 funname
.reset (xstrdup (print_name
));
1312 struct bound_minimal_symbol msymbol
;
1315 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1318 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1319 if (msymbol
.minsym
!= NULL
)
1321 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1322 *funlang
= msymbol
.minsym
->language ();
1330 print_frame (const frame_print_options
&fp_opts
,
1331 frame_info_ptr frame
, int print_level
,
1332 enum print_what print_what
, int print_args
,
1333 struct symtab_and_line sal
)
1335 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1336 struct ui_out
*uiout
= current_uiout
;
1337 enum language funlang
= language_unknown
;
1338 struct value_print_options opts
;
1339 struct symbol
*func
;
1343 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1345 gdb::unique_xmalloc_ptr
<char> funname
1346 = find_frame_funname (frame
, &funlang
, &func
);
1348 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1352 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1357 uiout
->field_fmt_signed (2, ui_left
, "level",
1358 frame_relative_level (frame
));
1360 get_user_print_options (&opts
);
1361 if (opts
.addressprint
)
1363 || frame_show_address (frame
, sal
)
1364 || print_what
== LOC_AND_ADDRESS
)
1366 annotate_frame_address ();
1368 print_pc (uiout
, gdbarch
, frame
, pc
);
1370 uiout
->field_string ("addr", "<unavailable>",
1371 metadata_style
.style ());
1372 annotate_frame_address_end ();
1373 uiout
->text (" in ");
1375 annotate_frame_function_name ();
1378 gdb_puts (funname
? funname
.get () : "??", &stb
);
1379 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1380 uiout
->wrap_hint (3);
1381 annotate_frame_args ();
1388 if (gdbarch_frame_num_args_p (gdbarch
))
1390 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1391 gdb_assert (numargs
>= 0);
1397 ui_out_emit_list
list_emitter (uiout
, "args");
1400 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1402 catch (const gdb_exception_error
&e
)
1406 /* FIXME: ARGS must be a list. If one argument is a string it
1407 will have " that will not be properly escaped. */
1412 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1414 const char *filename_display
;
1416 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1417 annotate_frame_source_begin ();
1418 uiout
->wrap_hint (3);
1419 uiout
->text (" at ");
1420 annotate_frame_source_file ();
1421 uiout
->field_string ("file", filename_display
,
1422 file_name_style
.style ());
1423 if (uiout
->is_mi_like_p ())
1425 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1427 uiout
->field_string ("fullname", fullname
);
1429 annotate_frame_source_file_end ();
1431 annotate_frame_source_line ();
1432 uiout
->field_signed ("line", sal
.line
);
1433 annotate_frame_source_end ();
1436 if (print_what
!= SHORT_LOCATION
1437 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1440 = solib_name_from_address (get_frame_program_space (frame
),
1441 get_frame_pc (frame
));
1445 annotate_frame_where ();
1446 uiout
->wrap_hint (2);
1447 uiout
->text (" from ");
1448 uiout
->field_string ("from", lib
, file_name_style
.style ());
1451 if (uiout
->is_mi_like_p ())
1452 uiout
->field_string ("arch",
1453 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1460 /* Completion function for "frame function", "info frame function", and
1461 "select-frame function" commands. */
1464 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1465 completion_tracker
&tracker
,
1466 const char *text
, const char *word
)
1468 /* This is used to complete function names within a stack. It would be
1469 nice if we only offered functions that were actually in the stack.
1470 However, this would mean unwinding the stack to completion, which
1471 could take too long, or on a corrupted stack, possibly not end.
1472 Instead, we offer all symbol names as a safer choice. */
1473 collect_symbol_completion_matches (tracker
,
1474 complete_symbol_mode::EXPRESSION
,
1475 symbol_name_match_type::EXPRESSION
,
1479 /* Core of all the "info frame" sub-commands. Print information about a
1480 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1481 frame specification, they just entered 'info frame'. If the user did
1482 provide a frame specification (for example 'info frame 0', 'info frame
1483 level 1') then SELECTED_FRAME_P will be false. */
1486 info_frame_command_core (frame_info_ptr fi
, bool selected_frame_p
)
1488 struct symbol
*func
;
1490 frame_info_ptr calling_frame_info
;
1492 const char *funname
= 0;
1493 enum language funlang
= language_unknown
;
1494 const char *pc_regname
;
1495 struct gdbarch
*gdbarch
;
1498 /* Initialize it to avoid "may be used uninitialized" warning. */
1499 CORE_ADDR caller_pc
= 0;
1500 int caller_pc_p
= 0;
1502 gdbarch
= get_frame_arch (fi
);
1504 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1505 is not a good name. */
1506 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1507 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1508 easily not match that of the internal value returned by
1510 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1512 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1513 architectures will often have a hardware register called "pc",
1514 and that register's value, again, can easily not match
1518 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1519 func
= get_frame_function (fi
);
1520 symtab_and_line sal
= find_frame_sal (fi
);
1522 gdb::unique_xmalloc_ptr
<char> func_only
;
1525 funname
= func
->print_name ();
1526 funlang
= func
->language ();
1527 if (funlang
== language_cplus
)
1529 /* It seems appropriate to use print_name() here,
1530 to display the demangled name that we already have
1531 stored in the symbol table, but we stored a version
1532 with DMGL_PARAMS turned on, and here we don't want to
1533 display parameters. So remove the parameters. */
1534 func_only
= cp_remove_params (funname
);
1537 funname
= func_only
.get ();
1540 else if (frame_pc_p
)
1542 struct bound_minimal_symbol msymbol
;
1544 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1545 if (msymbol
.minsym
!= NULL
)
1547 funname
= msymbol
.minsym
->print_name ();
1548 funlang
= msymbol
.minsym
->language ();
1551 calling_frame_info
= get_prev_frame (fi
);
1553 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1555 gdb_printf (_("Stack level %d, frame at "),
1556 frame_relative_level (fi
));
1560 gdb_printf (_("Stack frame at "));
1562 gdb_puts (paddress (gdbarch
, get_frame_base (fi
)));
1564 gdb_printf (" %s = ", pc_regname
);
1566 gdb_puts (paddress (gdbarch
, get_frame_pc (fi
)));
1568 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1570 gdb_stdout
->wrap_here (3);
1573 gdb_printf (" in ");
1576 gdb_stdout
->wrap_here (3);
1580 styled_string (file_name_style
.style (),
1581 symtab_to_filename_for_display (sal
.symtab
)),
1584 gdb_stdout
->wrap_here (4);
1585 gdb_printf ("saved %s = ", pc_regname
);
1587 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1588 val_print_not_saved (gdb_stdout
);
1593 caller_pc
= frame_unwind_caller_pc (fi
);
1596 catch (const gdb_exception_error
&ex
)
1600 case NOT_AVAILABLE_ERROR
:
1601 val_print_unavailable (gdb_stdout
);
1603 case OPTIMIZED_OUT_ERROR
:
1604 val_print_not_saved (gdb_stdout
);
1607 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1616 gdb_puts (paddress (gdbarch
, caller_pc
));
1619 if (calling_frame_info
== NULL
)
1621 enum unwind_stop_reason reason
;
1623 reason
= get_frame_unwind_stop_reason (fi
);
1624 if (reason
!= UNWIND_NO_REASON
)
1625 gdb_printf (_(" Outermost frame: %s\n"),
1626 frame_stop_reason_string (fi
));
1628 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1629 gdb_puts (" tail call frame");
1630 else if (get_frame_type (fi
) == INLINE_FRAME
)
1631 gdb_printf (" inlined into frame %d",
1632 frame_relative_level (get_prev_frame (fi
)));
1635 gdb_printf (" called by frame at ");
1636 gdb_puts (paddress (gdbarch
, get_frame_base (calling_frame_info
)));
1638 if (get_next_frame (fi
) && calling_frame_info
)
1640 gdb_stdout
->wrap_here (3);
1641 if (get_next_frame (fi
))
1643 gdb_printf (" caller of frame at ");
1644 gdb_puts (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))));
1646 if (get_next_frame (fi
) || calling_frame_info
)
1650 gdb_printf (" source language %s.\n",
1651 language_str (s
->language ()));
1654 /* Address of the argument list for this frame, or 0. */
1655 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1656 /* Number of args for this frame, or -1 if unknown. */
1660 gdb_printf (" Arglist at unknown address.\n");
1663 gdb_printf (" Arglist at ");
1664 gdb_puts (paddress (gdbarch
, arg_list
));
1667 if (!gdbarch_frame_num_args_p (gdbarch
))
1670 gdb_puts (" args: ");
1674 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1675 gdb_assert (numargs
>= 0);
1677 gdb_puts (" no args.");
1678 else if (numargs
== 1)
1679 gdb_puts (" 1 arg: ");
1681 gdb_printf (" %d args: ", numargs
);
1683 print_frame_args (user_frame_print_options
,
1684 func
, fi
, numargs
, gdb_stdout
);
1689 /* Address of the local variables for this frame, or 0. */
1690 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1693 gdb_printf (" Locals at unknown address,");
1696 gdb_printf (" Locals at ");
1697 gdb_puts (paddress (gdbarch
, arg_list
));
1702 /* Print as much information as possible on the location of all the
1708 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1710 /* The sp is special; what's displayed isn't the save address, but
1711 the value of the previous frame's sp. This is a legacy thing,
1712 at one stage the frame cached the previous frame's SP instead
1713 of its address, hence it was easiest to just display the cached
1717 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1718 gdb_assert (value
!= NULL
);
1720 if (!value_optimized_out (value
) && value_entirely_available (value
))
1722 if (VALUE_LVAL (value
) == not_lval
)
1725 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1726 int sp_size
= register_size (gdbarch
, sp_regnum
);
1728 sp
= extract_unsigned_integer
1729 (value_contents_all (value
).data (), sp_size
, byte_order
);
1731 gdb_printf (" Previous frame's sp is ");
1732 gdb_puts (paddress (gdbarch
, sp
));
1735 else if (VALUE_LVAL (value
) == lval_memory
)
1737 gdb_printf (" Previous frame's sp at ");
1738 gdb_puts (paddress (gdbarch
, value_address (value
)));
1741 else if (VALUE_LVAL (value
) == lval_register
)
1743 gdb_printf (" Previous frame's sp in %s\n",
1744 gdbarch_register_name (gdbarch
,
1745 VALUE_REGNUM (value
)));
1748 release_value (value
);
1751 /* else keep quiet. */
1755 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1756 for (i
= 0; i
< numregs
; i
++)
1758 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1760 enum lval_type lval
;
1766 /* Find out the location of the saved register without
1767 fetching the corresponding value. */
1768 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1769 &lval
, &addr
, &realnum
, NULL
);
1770 /* For moment, only display registers that were saved on the
1772 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1775 gdb_puts (" Saved registers:\n ");
1778 gdb_stdout
->wrap_here (1);
1779 gdb_printf (" %s at ",
1780 gdbarch_register_name (gdbarch
, i
));
1781 gdb_puts (paddress (gdbarch
, addr
));
1785 if (count
|| need_nl
)
1790 /* Return the innermost frame at level LEVEL. */
1792 static frame_info_ptr
1793 leading_innermost_frame (int level
)
1795 frame_info_ptr leading
;
1797 leading
= get_current_frame ();
1799 gdb_assert (level
>= 0);
1801 while (leading
!= nullptr && level
)
1804 leading
= get_prev_frame (leading
);
1811 /* Return the starting frame needed to handle COUNT outermost frames. */
1813 static frame_info_ptr
1814 trailing_outermost_frame (int count
)
1816 frame_info_ptr current
;
1817 frame_info_ptr trailing
;
1819 trailing
= get_current_frame ();
1821 gdb_assert (count
> 0);
1824 while (current
!= nullptr && count
--)
1827 current
= get_prev_frame (current
);
1830 /* Will stop when CURRENT reaches the top of the stack.
1831 TRAILING will be COUNT below it. */
1832 while (current
!= nullptr)
1835 trailing
= get_prev_frame (trailing
);
1836 current
= get_prev_frame (current
);
1842 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1846 select_frame_command_core (frame_info_ptr fi
, bool ignored
)
1848 frame_info_ptr prev_frame
= get_selected_frame ();
1850 if (get_selected_frame () != prev_frame
)
1851 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1854 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1855 means we change frame send out a change notification (otherwise, just
1856 reprint the current frame summary). */
1859 frame_command_core (frame_info_ptr fi
, bool ignored
)
1861 frame_info_ptr prev_frame
= get_selected_frame ();
1863 if (get_selected_frame () != prev_frame
)
1864 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1866 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1869 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1870 common set of sub-commands that allow a specific frame to be selected.
1871 All of the sub-command functions are static methods within this class
1872 template which is then instantiated below. The template parameter is a
1873 callback used to implement the functionality of the base command
1874 ('frame', 'select-frame', or 'info frame').
1876 In the template parameter FI is the frame being selected. The
1877 SELECTED_FRAME_P flag is true if the frame being selected was done by
1878 default, which happens when the user uses the base command with no
1879 arguments. For example the commands 'info frame', 'select-frame',
1880 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1881 SELECTED_FRAME_P is false. */
1883 template <void (*FPTR
) (frame_info_ptr fi
, bool selected_frame_p
)>
1884 class frame_command_helper
1888 /* The "frame level" family of commands. The ARG is an integer that is
1889 the frame's level in the stack. */
1891 level (const char *arg
, int from_tty
)
1893 int level
= value_as_long (parse_and_eval (arg
));
1895 = find_relative_frame (get_current_frame (), &level
);
1897 error (_("No frame at level %s."), arg
);
1901 /* The "frame address" family of commands. ARG is a stack-pointer
1902 address for an existing frame. This command does not allow new
1903 frames to be created. */
1906 address (const char *arg
, int from_tty
)
1908 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1909 frame_info_ptr fid
= find_frame_for_address (addr
);
1911 error (_("No frame at address %s."), arg
);
1915 /* The "frame view" family of commands. ARG is one or two addresses and
1916 is used to view a frame that might be outside the current backtrace.
1917 The addresses are stack-pointer address, and (optional) pc-address. */
1920 view (const char *args
, int from_tty
)
1925 error (_("Missing address argument to view a frame"));
1927 gdb_argv
argv (args
);
1929 if (argv
.count () == 2)
1933 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1934 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1935 fid
= create_new_frame (addr
[0], addr
[1]);
1939 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1940 fid
= create_new_frame (addr
, false);
1945 /* The "frame function" family of commands. ARG is the name of a
1946 function within the stack, the first function (searching from frame
1947 0) with that name will be selected. */
1950 function (const char *arg
, int from_tty
)
1953 error (_("Missing function name argument"));
1954 frame_info_ptr fid
= find_frame_for_function (arg
);
1956 error (_("No frame for function \"%s\"."), arg
);
1960 /* The "frame" base command, that is, when no sub-command is specified.
1961 If one argument is provided then we assume that this is a frame's
1962 level as historically, this was the supported command syntax that was
1965 If no argument is provided, then the current frame is selected. */
1968 base_command (const char *arg
, int from_tty
)
1971 FPTR (get_selected_frame (_("No stack.")), true);
1973 level (arg
, from_tty
);
1977 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1978 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1980 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1981 static frame_command_helper
<frame_command_core
> frame_cmd
;
1982 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1984 /* Print briefly all stack frames or just the innermost COUNT_EXP
1988 backtrace_command_1 (const frame_print_options
&fp_opts
,
1989 const backtrace_cmd_options
&bt_opts
,
1990 const char *count_exp
, int from_tty
)
1995 int py_start
= 0, py_end
= 0;
1996 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1998 if (!target_has_stack ())
1999 error (_("No stack."));
2003 count
= parse_and_eval_long (count_exp
);
2009 /* The argument to apply_ext_lang_frame_filter is the number
2010 of the final frame to print, and frames start at 0. */
2020 frame_filter_flags flags
= 0;
2023 flags
|= PRINT_LOCALS
;
2025 flags
|= PRINT_HIDE
;
2027 if (!bt_opts
.no_filters
)
2029 enum ext_lang_frame_args arg_type
;
2031 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2033 flags
|= PRINT_MORE_FRAMES
;
2035 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2036 arg_type
= CLI_SCALAR_VALUES
;
2037 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2038 arg_type
= CLI_ALL_VALUES
;
2039 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2040 arg_type
= CLI_PRESENCE
;
2041 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2042 arg_type
= NO_VALUES
;
2046 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2047 arg_type
, current_uiout
,
2051 /* Run the inbuilt backtrace if there are no filters registered, or
2052 "-no-filters" has been specified from the command. */
2053 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2055 frame_info_ptr trailing
;
2057 /* The following code must do two things. First, it must set the
2058 variable TRAILING to the frame from which we should start
2059 printing. Second, it must set the variable count to the number
2060 of frames which we should print, or -1 if all of them. */
2062 if (count_exp
!= NULL
&& count
< 0)
2064 trailing
= trailing_outermost_frame (-count
);
2068 trailing
= get_current_frame ();
2070 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2073 fi
.prepare_reinflate ();
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. */
2102 /* If we've stopped before the end, mention that. */
2104 gdb_printf (_("(More stack frames follow...)\n"));
2106 /* If we've run out of frames, and the reason appears to be an error
2107 condition, print it. */
2108 if (fi
== NULL
&& trailing
!= NULL
)
2110 enum unwind_stop_reason reason
;
2112 reason
= get_frame_unwind_stop_reason (trailing
);
2113 if (reason
>= UNWIND_FIRST_ERROR
)
2114 gdb_printf (_("Backtrace stopped: %s\n"),
2115 frame_stop_reason_string (trailing
));
2120 /* Create an option_def_group array grouping all the "backtrace"
2121 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2123 static inline std::array
<gdb::option::option_def_group
, 3>
2124 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2125 backtrace_cmd_options
*bt_cmd_opts
,
2126 set_backtrace_options
*set_bt_opts
)
2129 { {frame_print_option_defs
}, fp_opts
},
2130 { {set_backtrace_option_defs
}, set_bt_opts
},
2131 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2135 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2136 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2137 store the parsed qualifiers. */
2140 parse_backtrace_qualifiers (const char *arg
,
2141 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2145 const char *save_arg
= arg
;
2146 std::string this_arg
= extract_arg (&arg
);
2148 if (this_arg
.empty ())
2151 if (subset_compare (this_arg
.c_str (), "no-filters"))
2153 if (bt_cmd_opts
!= nullptr)
2154 bt_cmd_opts
->no_filters
= true;
2156 else if (subset_compare (this_arg
.c_str (), "full"))
2158 if (bt_cmd_opts
!= nullptr)
2159 bt_cmd_opts
->full
= true;
2161 else if (subset_compare (this_arg
.c_str (), "hide"))
2163 if (bt_cmd_opts
!= nullptr)
2164 bt_cmd_opts
->hide
= true;
2168 /* Not a recognized qualifier, so stop. */
2175 backtrace_command (const char *arg
, int from_tty
)
2177 frame_print_options fp_opts
= user_frame_print_options
;
2178 backtrace_cmd_options bt_cmd_opts
;
2179 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2182 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2183 gdb::option::process_options
2184 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2186 /* Parse non-'-'-prefixed qualifiers, for backwards
2190 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2195 /* These options are handled quite deep in the unwind machinery, so
2196 we get to pass them down by swapping globals. */
2197 scoped_restore restore_set_backtrace_options
2198 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2200 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2203 /* Completer for the "backtrace" command. */
2206 backtrace_command_completer (struct cmd_list_element
*ignore
,
2207 completion_tracker
&tracker
,
2208 const char *text
, const char */
*word*/
)
2211 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2212 if (gdb::option::complete_options
2213 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2218 const char *p
= skip_to_space (text
);
2221 static const char *const backtrace_cmd_qualifier_choices
[] = {
2222 "full", "no-filters", "hide", nullptr,
2224 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2227 if (tracker
.have_completions ())
2232 const char *cmd
= parse_backtrace_qualifiers (text
);
2233 tracker
.advance_custom_word_point_by (cmd
- text
);
2238 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2239 expression_completer (ignore
, tracker
, text
, word
);
2242 /* Iterate over the local variables of a block B, calling CB. */
2245 iterate_over_block_locals (const struct block
*b
,
2246 iterate_over_block_arg_local_vars_cb cb
)
2248 struct block_iterator iter
;
2251 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2253 switch (sym
->aclass ())
2260 case LOC_OPTIMIZED_OUT
:
2261 if (sym
->is_argument ())
2263 if (sym
->domain () == COMMON_BLOCK_DOMAIN
)
2265 cb (sym
->print_name (), sym
);
2269 /* Ignore symbols which are not locals. */
2275 /* Iterate over all the local variables in block B, including all its
2276 superblocks, stopping when the top-level block is reached. */
2279 iterate_over_block_local_vars (const struct block
*block
,
2280 iterate_over_block_arg_local_vars_cb cb
)
2284 iterate_over_block_locals (block
, cb
);
2285 /* After handling the function's top-level block, stop. Don't
2286 continue to its superblock, the block of per-file
2288 if (block
->function ())
2290 block
= block
->superblock ();
2294 /* Data to be passed around in the calls to the locals and args
2297 struct print_variable_and_value_data
2299 gdb::optional
<compiled_regex
> preg
;
2300 gdb::optional
<compiled_regex
> treg
;
2301 struct frame_id frame_id
;
2303 struct ui_file
*stream
;
2306 void operator() (const char *print_name
, struct symbol
*sym
);
2309 /* The callback for the locals and args iterators. */
2312 print_variable_and_value_data::operator() (const char *print_name
,
2315 frame_info_ptr frame
;
2317 if (preg
.has_value ()
2318 && preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2320 if (treg
.has_value ()
2321 && !treg_matches_sym_type_name (*treg
, sym
))
2323 if (language_def (sym
->language ())->symbol_printing_suppressed (sym
))
2326 frame
= frame_find_by_id (frame_id
);
2329 warning (_("Unable to restore previously selected frame."));
2333 print_variable_and_value (print_name
, sym
, frame
, stream
, num_tabs
);
2335 /* print_variable_and_value invalidates FRAME. */
2341 /* Prepares the regular expression REG from REGEXP.
2342 If REGEXP is NULL, it results in an empty regular expression. */
2345 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2349 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2351 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2357 /* Print all variables from the innermost up to the function block of FRAME.
2358 Print them with values to STREAM indented by NUM_TABS.
2359 If REGEXP is not NULL, only print local variables whose name
2361 If T_REGEXP is not NULL, only print local variables whose type
2363 If no local variables have been printed and !QUIET, prints a message
2364 explaining why no local variables could be printed.
2366 This function will invalidate FRAME. */
2369 print_frame_local_vars (frame_info_ptr frame
,
2371 const char *regexp
, const char *t_regexp
,
2372 int num_tabs
, struct ui_file
*stream
)
2374 struct print_variable_and_value_data cb_data
;
2375 const struct block
*block
;
2378 if (!get_frame_pc_if_available (frame
, &pc
))
2382 _("PC unavailable, cannot determine locals.\n"));
2386 block
= get_frame_block (frame
, 0);
2390 gdb_printf (stream
, "No symbol table info available.\n");
2394 prepare_reg (regexp
, &cb_data
.preg
);
2395 prepare_reg (t_regexp
, &cb_data
.treg
);
2396 cb_data
.frame_id
= get_frame_id (frame
);
2397 cb_data
.num_tabs
= 4 * num_tabs
;
2398 cb_data
.stream
= stream
;
2399 cb_data
.values_printed
= 0;
2401 /* Temporarily change the selected frame to the given FRAME.
2402 This allows routines that rely on the selected frame instead
2403 of being given a frame as parameter to use the correct frame. */
2404 scoped_restore_selected_frame restore_selected_frame
;
2405 select_frame (frame
);
2407 iterate_over_block_local_vars (block
, cb_data
);
2409 if (!cb_data
.values_printed
&& !quiet
)
2411 if (regexp
== NULL
&& t_regexp
== NULL
)
2412 gdb_printf (stream
, _("No locals.\n"));
2414 gdb_printf (stream
, _("No matching locals.\n"));
2418 /* Structure to hold the values of the options used by the 'info
2419 variables' command and other similar commands. These correspond to the
2420 -q and -t options. */
2422 struct info_print_options
2425 std::string type_regexp
;
2428 /* The options used by the 'info locals' and 'info args' commands. */
2430 static const gdb::option::option_def info_print_options_defs
[] = {
2431 gdb::option::boolean_option_def
<info_print_options
> {
2433 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2434 nullptr, /* show_cmd_cb */
2435 nullptr /* set_doc */
2438 gdb::option::string_option_def
<info_print_options
> {
2440 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2441 nullptr, /* show_cmd_cb */
2442 nullptr /* set_doc */
2446 /* Returns the option group used by 'info locals' and 'info args'
2449 static gdb::option::option_def_group
2450 make_info_print_options_def_group (info_print_options
*opts
)
2452 return {{info_print_options_defs
}, opts
};
2455 /* Command completer for 'info locals' and 'info args'. */
2458 info_print_command_completer (struct cmd_list_element
*ignore
,
2459 completion_tracker
&tracker
,
2460 const char *text
, const char * /* word */)
2463 = make_info_print_options_def_group (nullptr);
2464 if (gdb::option::complete_options
2465 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2468 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2469 symbol_completer (ignore
, tracker
, text
, word
);
2472 /* Implement the 'info locals' command. */
2475 info_locals_command (const char *args
, int from_tty
)
2477 info_print_options opts
;
2478 auto grp
= make_info_print_options_def_group (&opts
);
2479 gdb::option::process_options
2480 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2481 if (args
!= nullptr && *args
== '\0')
2484 print_frame_local_vars
2485 (get_selected_frame (_("No frame selected.")),
2487 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2491 /* Iterate over all the argument variables in block B. */
2494 iterate_over_block_arg_vars (const struct block
*b
,
2495 iterate_over_block_arg_local_vars_cb cb
)
2497 struct block_iterator iter
;
2498 struct symbol
*sym
, *sym2
;
2500 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2502 /* Don't worry about things which aren't arguments. */
2503 if (sym
->is_argument ())
2505 /* We have to look up the symbol because arguments can have
2506 two entries (one a parameter, one a local) and the one we
2507 want is the local, which lookup_symbol will find for us.
2508 This includes gcc1 (not gcc2) on the sparc when passing a
2509 small structure and gcc2 when the argument type is float
2510 and it is passed as a double and converted to float by
2511 the prologue (in the latter case the type of the LOC_ARG
2512 symbol is double and the type of the LOC_LOCAL symbol is
2513 float). There are also LOC_ARG/LOC_REGISTER pairs which
2514 are not combined in symbol-reading. */
2516 sym2
= lookup_symbol_search_name (sym
->search_name (),
2517 b
, VAR_DOMAIN
).symbol
;
2518 cb (sym
->print_name (), sym2
);
2523 /* Print all argument variables of the function of FRAME.
2524 Print them with values to STREAM.
2525 If REGEXP is not NULL, only print argument variables whose name
2527 If T_REGEXP is not NULL, only print argument variables whose type
2529 If no argument variables have been printed and !QUIET, prints a message
2530 explaining why no argument variables could be printed.
2532 This function will invalidate FRAME. */
2535 print_frame_arg_vars (frame_info_ptr frame
,
2537 const char *regexp
, const char *t_regexp
,
2538 struct ui_file
*stream
)
2540 struct print_variable_and_value_data cb_data
;
2541 struct symbol
*func
;
2543 gdb::optional
<compiled_regex
> preg
;
2544 gdb::optional
<compiled_regex
> treg
;
2546 if (!get_frame_pc_if_available (frame
, &pc
))
2550 _("PC unavailable, cannot determine args.\n"));
2554 func
= get_frame_function (frame
);
2558 gdb_printf (stream
, _("No symbol table info available.\n"));
2562 prepare_reg (regexp
, &cb_data
.preg
);
2563 prepare_reg (t_regexp
, &cb_data
.treg
);
2564 cb_data
.frame_id
= get_frame_id (frame
);
2565 cb_data
.num_tabs
= 0;
2566 cb_data
.stream
= stream
;
2567 cb_data
.values_printed
= 0;
2569 iterate_over_block_arg_vars (func
->value_block (), cb_data
);
2571 /* do_print_variable_and_value invalidates FRAME. */
2574 if (!cb_data
.values_printed
&& !quiet
)
2576 if (regexp
== NULL
&& t_regexp
== NULL
)
2577 gdb_printf (stream
, _("No arguments.\n"));
2579 gdb_printf (stream
, _("No matching arguments.\n"));
2583 /* Implement the 'info args' command. */
2586 info_args_command (const char *args
, int from_tty
)
2588 info_print_options opts
;
2589 auto grp
= make_info_print_options_def_group (&opts
);
2590 gdb::option::process_options
2591 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2592 if (args
!= nullptr && *args
== '\0')
2595 print_frame_arg_vars
2596 (get_selected_frame (_("No frame selected.")),
2598 opts
.type_regexp
.empty () ? nullptr : opts
.type_regexp
.c_str (),
2602 /* Return the symbol-block in which the selected frame is executing.
2603 Can return zero under various legitimate circumstances.
2605 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2606 code address within the block returned. We use this to decide
2607 which macros are in scope. */
2609 const struct block
*
2610 get_selected_block (CORE_ADDR
*addr_in_block
)
2612 if (!has_stack_frames ())
2615 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2618 /* Find a frame a certain number of levels away from FRAME.
2619 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2620 Positive means go to earlier frames (up); negative, the reverse.
2621 The int that contains the number of levels is counted toward
2622 zero as the frames for those levels are found.
2623 If the top or bottom frame is reached, that frame is returned,
2624 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2625 how much farther the original request asked to go. */
2628 find_relative_frame (frame_info_ptr frame
, int *level_offset_ptr
)
2630 /* Going up is simple: just call get_prev_frame enough times or
2631 until the initial frame is reached. */
2632 while (*level_offset_ptr
> 0)
2634 frame_info_ptr prev
= get_prev_frame (frame
);
2638 (*level_offset_ptr
)--;
2642 /* Going down is just as simple. */
2643 while (*level_offset_ptr
< 0)
2645 frame_info_ptr next
= get_next_frame (frame
);
2649 (*level_offset_ptr
)++;
2656 /* Select the frame up one or COUNT_EXP stack levels from the
2657 previously selected frame, and print it briefly. */
2660 up_silently_base (const char *count_exp
)
2662 frame_info_ptr frame
;
2666 count
= parse_and_eval_long (count_exp
);
2668 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2669 if (count
!= 0 && count_exp
== NULL
)
2670 error (_("Initial frame selected; you cannot go up."));
2671 select_frame (frame
);
2675 up_silently_command (const char *count_exp
, int from_tty
)
2677 up_silently_base (count_exp
);
2681 up_command (const char *count_exp
, int from_tty
)
2683 up_silently_base (count_exp
);
2684 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2687 /* Select the frame down one or COUNT_EXP stack levels from the previously
2688 selected frame, and print it briefly. */
2691 down_silently_base (const char *count_exp
)
2693 frame_info_ptr frame
;
2697 count
= -parse_and_eval_long (count_exp
);
2699 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2700 if (count
!= 0 && count_exp
== NULL
)
2702 /* We only do this if COUNT_EXP is not specified. That way
2703 "down" means to really go down (and let me know if that is
2704 impossible), but "down 9999" can be used to mean go all the
2705 way down without getting an error. */
2707 error (_("Bottom (innermost) frame selected; you cannot go down."));
2710 select_frame (frame
);
2714 down_silently_command (const char *count_exp
, int from_tty
)
2716 down_silently_base (count_exp
);
2720 down_command (const char *count_exp
, int from_tty
)
2722 down_silently_base (count_exp
);
2723 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2727 return_command (const char *retval_exp
, int from_tty
)
2729 /* Initialize it just to avoid a GCC false warning. */
2730 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2731 frame_info_ptr thisframe
;
2732 struct gdbarch
*gdbarch
;
2733 struct symbol
*thisfun
;
2734 struct value
*return_value
= NULL
;
2735 struct value
*function
= NULL
;
2736 std::string query_prefix
;
2738 thisframe
= get_selected_frame ("No selected frame.");
2739 thisfun
= get_frame_function (thisframe
);
2740 gdbarch
= get_frame_arch (thisframe
);
2742 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2743 error (_("Can not force return from an inlined function."));
2745 /* Compute the return value. If the computation triggers an error,
2746 let it bail. If the return type can't be handled, set
2747 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2751 expression_up retval_expr
= parse_expression (retval_exp
);
2752 struct type
*return_type
= NULL
;
2754 /* Compute the return value. Should the computation fail, this
2755 call throws an error. */
2756 return_value
= evaluate_expression (retval_expr
.get ());
2758 /* Cast return value to the return type of the function. Should
2759 the cast fail, this call throws an error. */
2760 if (thisfun
!= NULL
)
2761 return_type
= thisfun
->type ()->target_type ();
2762 if (return_type
== NULL
)
2764 if (retval_expr
->first_opcode () != UNOP_CAST
2765 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2766 error (_("Return value type not available for selected "
2768 "Please use an explicit cast of the value to return."));
2769 return_type
= value_type (return_value
);
2771 return_type
= check_typedef (return_type
);
2772 return_value
= value_cast (return_type
, return_value
);
2774 /* Make sure the value is fully evaluated. It may live in the
2775 stack frame we're about to pop. */
2776 if (value_lazy (return_value
))
2777 value_fetch_lazy (return_value
);
2779 if (thisfun
!= NULL
)
2780 function
= read_var_value (thisfun
, NULL
, thisframe
);
2782 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2783 if (return_type
->code () == TYPE_CODE_VOID
)
2784 /* If the return-type is "void", don't try to find the
2785 return-value's location. However, do still evaluate the
2786 return expression so that, even when the expression result
2787 is discarded, side effects such as "return i++" still
2789 return_value
= NULL
;
2790 else if (thisfun
!= NULL
)
2792 if (is_nocall_function (check_typedef (value_type (function
))))
2795 string_printf ("Function '%s' does not follow the target "
2796 "calling convention.\n"
2797 "If you continue, setting the return value "
2798 "will probably lead to unpredictable "
2800 thisfun
->print_name ());
2803 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2804 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2805 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2807 query_prefix
= "The location at which to store the "
2808 "function's return value is unknown.\n"
2809 "If you continue, the return value "
2810 "that you specified will be ignored.\n";
2811 return_value
= NULL
;
2816 /* Does an interactive user really want to do this? Include
2817 information, such as how well GDB can handle the return value, in
2818 the query message. */
2823 if (thisfun
== NULL
)
2824 confirmed
= query (_("%sMake selected stack frame return now? "),
2825 query_prefix
.c_str ());
2828 if (TYPE_NO_RETURN (thisfun
->type ()))
2829 warning (_("Function does not return normally to caller."));
2830 confirmed
= query (_("%sMake %s return now? "),
2831 query_prefix
.c_str (),
2832 thisfun
->print_name ());
2835 error (_("Not confirmed"));
2838 /* Discard the selected frame and all frames inner-to it. */
2839 frame_pop (get_selected_frame (NULL
));
2841 /* Store RETURN_VALUE in the just-returned register set. */
2842 if (return_value
!= NULL
)
2844 struct type
*return_type
= value_type (return_value
);
2845 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2847 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2848 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2849 gdbarch_return_value (cache_arch
, function
, return_type
,
2850 get_current_regcache (), NULL
/*read*/,
2851 value_contents (return_value
).data () /*write*/);
2854 /* If we are at the end of a call dummy now, pop the dummy frame
2856 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2857 frame_pop (get_current_frame ());
2859 select_frame (get_current_frame ());
2860 /* If interactive, print the frame that is now current. */
2862 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2865 /* Find the most inner frame in the current stack for a function called
2866 FUNCTION_NAME. If no matching frame is found return NULL. */
2868 static frame_info_ptr
2869 find_frame_for_function (const char *function_name
)
2871 /* Used to hold the lower and upper addresses for each of the
2872 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2873 struct function_bounds
2875 CORE_ADDR low
, high
;
2877 frame_info_ptr frame
;
2881 gdb_assert (function_name
!= NULL
);
2883 frame
= get_current_frame ();
2884 std::vector
<symtab_and_line
> sals
2885 = decode_line_with_current_source (function_name
,
2886 DECODE_LINE_FUNFIRSTLINE
);
2887 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2888 for (size_t i
= 0; i
< sals
.size (); i
++)
2890 if (sals
[i
].pspace
!= current_program_space
)
2891 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2892 else if (sals
[i
].pc
== 0
2893 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2894 &func_bounds
[i
].low
,
2895 &func_bounds
[i
].high
) == 0)
2896 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2901 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2902 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2903 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2907 frame
= find_relative_frame (frame
, &level
);
2910 while (!found
&& level
== 0);
2918 /* The qcs command line flags for the "frame apply" commands. Keep
2919 this in sync with the "thread apply" commands. */
2921 using qcs_flag_option_def
2922 = gdb::option::flag_option_def
<qcs_flags
>;
2924 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2925 qcs_flag_option_def
{
2926 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2927 N_("Disables printing the frame location information."),
2930 qcs_flag_option_def
{
2931 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2932 N_("Print any error raised by COMMAND and continue."),
2935 qcs_flag_option_def
{
2936 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2937 N_("Silently ignore any errors or empty output produced by COMMAND."),
2941 /* Create an option_def_group array for all the "frame apply" options,
2942 with FLAGS and SET_BT_OPTS as context. */
2944 static inline std::array
<gdb::option::option_def_group
, 2>
2945 make_frame_apply_options_def_group (qcs_flags
*flags
,
2946 set_backtrace_options
*set_bt_opts
)
2949 { {fr_qcs_flags_option_defs
}, flags
},
2950 { {set_backtrace_option_defs
}, set_bt_opts
},
2954 /* Apply a GDB command to all stack frames, or a set of identified frames,
2955 or innermost COUNT frames.
2956 With a negative COUNT, apply command on outermost -COUNT frames.
2958 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2959 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2960 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2961 frame apply all -s p local_var_no_idea_in_which_frame
2962 If a frame has a local variable called
2963 local_var_no_idea_in_which_frame, print frame
2964 and value of local_var_no_idea_in_which_frame.
2965 frame apply all -s -q p local_var_no_idea_in_which_frame
2966 Same as before, but only print the variable value.
2967 frame apply level 2-5 0 4-7 -s p i = i + 1
2968 Adds 1 to the variable i in the specified frames.
2969 Note that i will be incremented twice in
2972 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2973 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2974 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2975 for error messages. */
2978 frame_apply_command_count (const char *which_command
,
2979 const char *cmd
, int from_tty
,
2980 frame_info_ptr trailing
, int count
)
2983 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2985 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2986 gdb::option::process_options
2987 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2989 validate_flags_qcs (which_command
, &flags
);
2991 if (cmd
== NULL
|| *cmd
== '\0')
2992 error (_("Please specify a command to apply on the selected frames"));
2994 /* The below will restore the current inferior/thread/frame.
2995 Usually, only the frame is effectively to be restored.
2996 But in case CMD switches of inferior/thread, better restore
2998 scoped_restore_current_thread restore_thread
;
3000 /* These options are handled quite deep in the unwind machinery, so
3001 we get to pass them down by swapping globals. */
3002 scoped_restore restore_set_backtrace_options
3003 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
3005 for (frame_info_ptr fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
3012 std::string cmd_result
;
3014 /* In case CMD switches of inferior/thread/frame, the below
3015 restores the inferior/thread/frame. FI can then be
3016 set to the selected frame. */
3017 scoped_restore_current_thread restore_fi_current_frame
;
3019 execute_command_to_string
3020 (cmd_result
, cmd
, from_tty
, gdb_stdout
->term_out ());
3022 fi
= get_selected_frame (_("frame apply "
3023 "unable to get selected frame."));
3024 if (!flags
.silent
|| cmd_result
.length () > 0)
3027 print_stack_frame (fi
, 1, LOCATION
, 0);
3028 gdb_printf ("%s", cmd_result
.c_str ());
3031 catch (const gdb_exception_error
&ex
)
3033 fi
= get_selected_frame (_("frame apply "
3034 "unable to get selected frame."));
3038 print_stack_frame (fi
, 1, LOCATION
, 0);
3040 gdb_printf ("%s\n", ex
.what ());
3048 /* Completer for the "frame apply ..." commands. */
3051 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3053 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3054 if (gdb::option::complete_options
3055 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3058 complete_nested_command_line (tracker
, text
);
3061 /* Completer for the "frame apply" commands. */
3064 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3065 completion_tracker
&tracker
,
3066 const char *text
, const char */
*word*/
)
3068 /* Do this explicitly because there's an early return below. */
3069 tracker
.set_use_custom_word_point (true);
3071 number_or_range_parser
levels (text
);
3073 /* Skip the LEVEL list to find the options and command args. */
3076 while (!levels
.finished ())
3078 /* Call for effect. */
3079 levels
.get_number ();
3081 if (levels
.in_range ())
3082 levels
.skip_range ();
3085 catch (const gdb_exception_error
&ex
)
3087 /* get_number throws if it parses a negative number, for
3088 example. But a seemingly negative number may be the start of
3089 an option instead. */
3092 const char *cmd
= levels
.cur_tok ();
3096 /* No level list yet. */
3100 /* Check if we're past a valid LEVEL already. */
3101 if (levels
.finished ()
3102 && cmd
> text
&& !isspace (cmd
[-1]))
3105 /* We're past LEVELs, advance word point. */
3106 tracker
.advance_custom_word_point_by (cmd
- text
);
3109 frame_apply_completer (tracker
, text
);
3112 /* Completer for the "frame apply all" command. */
3115 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3116 completion_tracker
&tracker
,
3117 const char *text
, const char */
*word*/
)
3119 frame_apply_completer (tracker
, text
);
3122 /* Completer for the "frame apply COUNT" command. */
3125 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3126 completion_tracker
&tracker
,
3127 const char *text
, const char */
*word*/
)
3129 const char *cmd
= text
;
3131 int count
= get_number_trailer (&cmd
, 0);
3135 /* Check if we're past a valid COUNT already. */
3136 if (cmd
> text
&& !isspace (cmd
[-1]))
3139 /* We're past COUNT, advance word point. */
3140 tracker
.advance_custom_word_point_by (cmd
- text
);
3143 frame_apply_completer (tracker
, text
);
3146 /* Implementation of the "frame apply level" command. */
3149 frame_apply_level_command (const char *cmd
, int from_tty
)
3151 if (!target_has_stack ())
3152 error (_("No stack."));
3154 bool level_found
= false;
3155 const char *levels_str
= cmd
;
3156 number_or_range_parser
levels (levels_str
);
3158 /* Skip the LEVEL list to find the flags and command args. */
3159 while (!levels
.finished ())
3161 /* Call for effect. */
3162 levels
.get_number ();
3165 if (levels
.in_range ())
3166 levels
.skip_range ();
3170 error (_("Missing or invalid LEVEL... argument"));
3172 cmd
= levels
.cur_tok ();
3174 /* Redo the LEVELS parsing, but applying COMMAND. */
3175 levels
.init (levels_str
);
3176 while (!levels
.finished ())
3178 const int level_beg
= levels
.get_number ();
3181 if (levels
.in_range ())
3183 n_frames
= levels
.end_value () - level_beg
+ 1;
3184 levels
.skip_range ();
3189 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3190 leading_innermost_frame (level_beg
), n_frames
);
3194 /* Implementation of the "frame apply all" command. */
3197 frame_apply_all_command (const char *cmd
, int from_tty
)
3199 if (!target_has_stack ())
3200 error (_("No stack."));
3202 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3203 get_current_frame (), INT_MAX
);
3206 /* Implementation of the "frame apply" command. */
3209 frame_apply_command (const char* cmd
, int from_tty
)
3212 frame_info_ptr trailing
;
3214 if (!target_has_stack ())
3215 error (_("No stack."));
3218 error (_("Missing COUNT argument."));
3219 count
= get_number_trailer (&cmd
, 0);
3221 error (_("Invalid COUNT argument."));
3225 trailing
= trailing_outermost_frame (-count
);
3229 trailing
= get_current_frame ();
3231 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3235 /* Implementation of the "faas" command. */
3238 faas_command (const char *cmd
, int from_tty
)
3240 if (cmd
== NULL
|| *cmd
== '\0')
3241 error (_("Please specify a command to apply on all frames"));
3242 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3243 execute_command (expanded
.c_str (), from_tty
);
3247 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3248 matching frame can be found. */
3250 static frame_info_ptr
3251 find_frame_for_address (CORE_ADDR address
)
3256 id
= frame_id_build_wild (address
);
3258 /* If (s)he specifies the frame with an address, he deserves
3259 what (s)he gets. Still, give the highest one that matches.
3260 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3262 for (fid
= get_current_frame ();
3264 fid
= get_prev_frame (fid
))
3266 if (id
== get_frame_id (fid
))
3268 frame_info_ptr prev_frame
;
3272 prev_frame
= get_prev_frame (fid
);
3274 || id
!= get_frame_id (prev_frame
))
3286 /* Commands with a prefix of `frame apply'. */
3287 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3289 /* Commands with a prefix of `frame'. */
3290 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3292 /* Commands with a prefix of `select frame'. */
3293 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3295 /* Commands with a prefix of `info frame'. */
3296 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3298 void _initialize_stack ();
3300 _initialize_stack ()
3302 struct cmd_list_element
*cmd
;
3304 add_com ("return", class_stack
, return_command
, _("\
3305 Make selected stack frame return to its caller.\n\
3306 Control remains in the debugger, but when you continue\n\
3307 execution will resume in the frame above the one now selected.\n\
3308 If an argument is given, it is an expression for the value to return."));
3310 add_com ("up", class_stack
, up_command
, _("\
3311 Select and print stack frame that called this one.\n\
3312 An argument says how many frames up to go."));
3313 add_com ("up-silently", class_support
, up_silently_command
, _("\
3314 Same as the `up' command, but does not print anything.\n\
3315 This is useful in command scripts."));
3317 cmd_list_element
*down_cmd
3318 = add_com ("down", class_stack
, down_command
, _("\
3319 Select and print stack frame called by this one.\n\
3320 An argument says how many frames down to go."));
3321 add_com_alias ("do", down_cmd
, class_stack
, 1);
3322 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3323 add_com ("down-silently", class_support
, down_silently_command
, _("\
3324 Same as the `down' command, but does not print anything.\n\
3325 This is useful in command scripts."));
3327 cmd_list_element
*frame_cmd_el
3328 = add_prefix_cmd ("frame", class_stack
,
3329 &frame_cmd
.base_command
, _("\
3330 Select and print a stack frame.\n\
3331 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3332 A single numerical argument specifies the frame to select."),
3333 &frame_cmd_list
, 1, &cmdlist
);
3334 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3336 #define FRAME_APPLY_OPTION_HELP "\
3337 Prints the frame location information followed by COMMAND output.\n\
3339 By default, an error raised during the execution of COMMAND\n\
3340 aborts \"frame apply\".\n\
3345 const auto frame_apply_opts
3346 = make_frame_apply_options_def_group (nullptr, nullptr);
3348 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3349 Apply a command to a number of frames.\n\
3350 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3351 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3352 FRAME_APPLY_OPTION_HELP
),
3355 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3356 frame_apply_cmd_help
.c_str (),
3357 &frame_apply_cmd_list
, 1,
3359 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3361 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3362 Apply a command to all frames.\n\
3364 Usage: frame apply all [OPTION]... COMMAND\n"
3365 FRAME_APPLY_OPTION_HELP
),
3368 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3369 frame_apply_all_cmd_help
.c_str (),
3370 &frame_apply_cmd_list
);
3371 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3373 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3374 Apply a command to a list of frames.\n\
3376 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3377 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3378 FRAME_APPLY_OPTION_HELP
),
3381 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3382 frame_apply_level_cmd_help
.c_str (),
3383 &frame_apply_cmd_list
);
3384 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3386 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3387 Apply a command to all frames (ignoring errors and empty output).\n\
3388 Usage: faas [OPTION]... COMMAND\n\
3389 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3390 See \"help frame apply all\" for available options."));
3391 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3393 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3395 Select and print a stack frame by stack address.\n\
3397 Usage: frame address STACK-ADDRESS"),
3400 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3402 View a stack frame that might be outside the current backtrace.\n\
3404 Usage: frame view STACK-ADDRESS\n\
3405 frame view STACK-ADDRESS PC-ADDRESS"),
3408 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3410 Select and print a stack frame by function name.\n\
3412 Usage: frame function NAME\n\
3414 The innermost frame that visited function NAME is selected."),
3416 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3419 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3421 Select and print a stack frame by level.\n\
3423 Usage: frame level LEVEL"),
3426 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3427 &select_frame_cmd
.base_command
, _("\
3428 Select a stack frame without printing anything.\n\
3429 A single numerical argument specifies the frame to select."),
3430 &select_frame_cmd_list
, 1, &cmdlist
,
3431 &cli_suppress_notification
.user_selected_context
);
3433 add_cmd_suppress_notification ("address", class_stack
,
3434 &select_frame_cmd
.address
, _("\
3435 Select a stack frame by stack address.\n\
3437 Usage: select-frame address STACK-ADDRESS"),
3438 &select_frame_cmd_list
,
3439 &cli_suppress_notification
.user_selected_context
);
3442 add_cmd_suppress_notification ("view", class_stack
,
3443 &select_frame_cmd
.view
, _("\
3444 Select a stack frame that might be outside the current backtrace.\n\
3446 Usage: select-frame view STACK-ADDRESS\n\
3447 select-frame view STACK-ADDRESS PC-ADDRESS"),
3448 &select_frame_cmd_list
,
3449 &cli_suppress_notification
.user_selected_context
);
3451 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3452 &select_frame_cmd
.function
, _("\
3453 Select a stack frame by function name.\n\
3455 Usage: select-frame function NAME"),
3456 &select_frame_cmd_list
,
3457 &cli_suppress_notification
.user_selected_context
);
3458 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3460 add_cmd_suppress_notification ("level", class_stack
,
3461 &select_frame_cmd
.level
, _("\
3462 Select a stack frame by level.\n\
3464 Usage: select-frame level LEVEL"),
3465 &select_frame_cmd_list
,
3466 &cli_suppress_notification
.user_selected_context
);
3468 const auto backtrace_opts
3469 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3471 static std::string backtrace_help
3472 = gdb::option::build_help (_("\
3473 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3474 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3479 For backward compatibility, the following qualifiers are supported:\n\
3481 full - same as -full option.\n\
3482 no-filters - same as -no-filters option.\n\
3483 hide - same as -hide.\n\
3485 With a negative COUNT, print outermost -COUNT frames."),
3488 cmd_list_element
*backtrace_cmd
3489 = add_com ("backtrace", class_stack
, backtrace_command
,
3490 backtrace_help
.c_str ());
3491 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3493 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3495 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3496 cmd_list_element
*info_stack_cmd
3497 = add_info ("stack", backtrace_command
,
3498 _("Backtrace of the stack, or innermost COUNT frames."));
3499 add_info_alias ("s", info_stack_cmd
, 1);
3501 cmd_list_element
*info_frame_cmd_el
3502 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3503 _("All about the selected stack frame.\n\
3504 With no arguments, displays information about the currently selected stack\n\
3505 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3506 the information is then printed about the specified frame."),
3507 &info_frame_cmd_list
, 1, &infolist
);
3508 add_info_alias ("f", info_frame_cmd_el
, 1);
3510 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3512 Print information about a stack frame selected by stack address.\n\
3514 Usage: info frame address STACK-ADDRESS"),
3515 &info_frame_cmd_list
);
3517 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3519 Print information about a stack frame outside the current backtrace.\n\
3521 Usage: info frame view STACK-ADDRESS\n\
3522 info frame view STACK-ADDRESS PC-ADDRESS"),
3523 &info_frame_cmd_list
);
3525 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3527 Print information about a stack frame selected by function name.\n\
3529 Usage: info frame function NAME"),
3530 &info_frame_cmd_list
);
3531 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3533 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3535 Print information about a stack frame selected by level.\n\
3537 Usage: info frame level LEVEL"),
3538 &info_frame_cmd_list
);
3540 cmd
= add_info ("locals", info_locals_command
,
3541 info_print_args_help (_("\
3542 All local variables of current stack frame or those matching REGEXPs.\n\
3543 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3544 Prints the local variables of the current stack frame.\n"),
3545 _("local variables"),
3547 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3548 cmd
= add_info ("args", info_args_command
,
3549 info_print_args_help (_("\
3550 All argument variables of current stack frame or those matching REGEXPs.\n\
3551 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3552 Prints the argument variables of the current stack frame.\n"),
3553 _("argument variables"),
3555 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3557 /* Install "set print raw frame-arguments", a deprecated spelling of
3558 "set print raw-frame-arguments". */
3559 set_show_commands set_show_frame_args
3560 = add_setshow_boolean_cmd
3561 ("frame-arguments", no_class
,
3562 &user_frame_print_options
.print_raw_frame_arguments
,
3564 Set whether to print frame arguments in raw form."), _("\
3565 Show whether to print frame arguments in raw form."), _("\
3566 If set, frame arguments are printed in raw form, bypassing any\n\
3567 pretty-printers for that value."),
3569 &setprintrawlist
, &showprintrawlist
);
3570 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3572 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3573 &disassemble_next_line
, _("\
3574 Set whether to disassemble next source line or insn when execution stops."),
3576 Show whether to disassemble next source line or insn when execution stops."),
3578 If ON, GDB will display disassembly of the next source line, in addition\n\
3579 to displaying the source line itself. If the next source line cannot\n\
3580 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3581 will display disassembly of next instruction instead of showing the\n\
3583 If AUTO, display disassembly of next instruction only if the source line\n\
3584 cannot be displayed.\n\
3585 If OFF (which is the default), never display the disassembly of the next\n\
3588 show_disassemble_next_line
,
3589 &setlist
, &showlist
);
3590 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3592 gdb::option::add_setshow_cmds_for_options
3593 (class_stack
, &user_frame_print_options
,
3594 frame_print_option_defs
, &setprintlist
, &showprintlist
);