1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2021 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"
59 /* The possible choices of "set print frame-arguments", and the value
62 const char print_frame_arguments_all
[] = "all";
63 const char print_frame_arguments_scalars
[] = "scalars";
64 const char print_frame_arguments_none
[] = "none";
65 const char print_frame_arguments_presence
[] = "presence";
67 static const char *const print_frame_arguments_choices
[] =
69 print_frame_arguments_all
,
70 print_frame_arguments_scalars
,
71 print_frame_arguments_none
,
72 print_frame_arguments_presence
,
76 /* The possible choices of "set print frame-info", and the value
79 const char print_frame_info_auto
[] = "auto";
80 const char print_frame_info_source_line
[] = "source-line";
81 const char print_frame_info_location
[] = "location";
82 const char print_frame_info_source_and_location
[] = "source-and-location";
83 const char print_frame_info_location_and_address
[] = "location-and-address";
84 const char print_frame_info_short_location
[] = "short-location";
86 static const char *const print_frame_info_choices
[] =
88 print_frame_info_auto
,
89 print_frame_info_source_line
,
90 print_frame_info_location
,
91 print_frame_info_source_and_location
,
92 print_frame_info_location_and_address
,
93 print_frame_info_short_location
,
97 /* print_frame_info_print_what[i] maps a choice to the corresponding
99 static const gdb::optional
<enum print_what
> print_frame_info_print_what
[] =
100 {{}, /* Empty value for "auto". */
101 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
103 /* The possible choices of "set print entry-values", and the value
106 const char print_entry_values_no
[] = "no";
107 const char print_entry_values_only
[] = "only";
108 const char print_entry_values_preferred
[] = "preferred";
109 const char print_entry_values_if_needed
[] = "if-needed";
110 const char print_entry_values_both
[] = "both";
111 const char print_entry_values_compact
[] = "compact";
112 const char print_entry_values_default
[] = "default";
113 static const char *const print_entry_values_choices
[] =
115 print_entry_values_no
,
116 print_entry_values_only
,
117 print_entry_values_preferred
,
118 print_entry_values_if_needed
,
119 print_entry_values_both
,
120 print_entry_values_compact
,
121 print_entry_values_default
,
126 frame_print_options user_frame_print_options
;
128 /* Option definitions for some frame-related "set print ..."
131 using boolean_option_def
132 = gdb::option::boolean_option_def
<frame_print_options
>;
133 using enum_option_def
134 = gdb::option::enum_option_def
<frame_print_options
>;
136 static const gdb::option::option_def frame_print_option_defs
[] = {
140 print_entry_values_choices
,
141 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
142 NULL
, /* show_cmd_cb */
143 N_("Set printing of function arguments at function entry."),
144 N_("Show printing of function arguments at function entry."),
145 N_("GDB can sometimes determine the values of function arguments at entry,\n\
146 in addition to their current values. This option tells GDB whether\n\
147 to print the current value, the value at entry (marked as val@entry),\n\
148 or both. Note that one or both of these values may be <optimized out>."),
153 print_frame_arguments_choices
,
154 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
155 NULL
, /* show_cmd_cb */
156 N_("Set printing of non-scalar frame arguments."),
157 N_("Show printing of non-scalar frame arguments."),
162 "raw-frame-arguments",
163 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
164 NULL
, /* show_cmd_cb */
165 N_("Set whether to print frame arguments in raw form."),
166 N_("Show whether to print frame arguments in raw form."),
167 N_("If set, frame arguments are printed in raw form, bypassing any\n\
168 pretty-printers for that value.")
173 print_frame_info_choices
,
174 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
175 NULL
, /* show_cmd_cb */
176 N_("Set printing of frame information."),
177 N_("Show printing of frame information."),
183 /* Options for the "backtrace" command. */
185 struct backtrace_cmd_options
188 bool no_filters
= false;
192 using bt_flag_option_def
193 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
195 static const gdb::option::option_def backtrace_command_option_defs
[] = {
198 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
199 N_("Print values of local variables.")
204 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
205 N_("Prohibit frame filters from executing on a backtrace."),
210 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
211 N_("Causes Python frame filter elided frames to not be printed."),
215 /* Prototypes for local functions. */
217 static void print_frame_local_vars (struct frame_info
*frame
,
219 const char *regexp
, const char *t_regexp
,
220 int num_tabs
, struct ui_file
*stream
);
222 static void print_frame (const frame_print_options
&opts
,
223 frame_info
*frame
, int print_level
,
224 enum print_what print_what
, int print_args
,
225 struct symtab_and_line sal
);
227 static struct frame_info
*find_frame_for_function (const char *);
228 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
230 /* Zero means do things normally; we are interacting directly with the
231 user. One means print the full filename and linenumber when a
232 frame is printed, and do so in a format emacs18/emacs19.22 can
233 parse. Two means print similar annotations, but in many more
234 cases and in a slightly different syntax. */
236 int annotation_level
= 0;
238 /* Class used to manage tracking the last symtab we displayed. */
240 class last_displayed_symtab_info_type
243 /* True if the cached information is valid. */
244 bool is_valid () const
247 /* Return the cached program_space. If the cache is invalid nullptr is
249 struct program_space
*pspace () const
252 /* Return the cached CORE_ADDR address. If the cache is invalid 0 is
254 CORE_ADDR
address () const
255 { return m_address
; }
257 /* Return the cached symtab. If the cache is invalid nullptr is
259 struct symtab
*symtab () const
262 /* Return the cached line number. If the cache is invalid 0 is
267 /* Invalidate the cache, reset all the members to their default value. */
277 /* Store a new set of values in the cache. */
278 void set (struct program_space
*pspace
, CORE_ADDR address
,
279 struct symtab
*symtab
, int line
)
281 gdb_assert (pspace
!= nullptr);
291 /* True when the cache is valid. */
292 bool m_valid
= false;
294 /* The last program space displayed. */
295 struct program_space
*m_pspace
= nullptr;
297 /* The last address displayed. */
298 CORE_ADDR m_address
= 0;
300 /* The last symtab displayed. */
301 struct symtab
*m_symtab
= nullptr;
303 /* The last line number displayed. */
307 /* An actual instance of the cache, holds information about the last symtab
309 static last_displayed_symtab_info_type last_displayed_symtab_info
;
316 frame_show_address (struct frame_info
*frame
,
317 struct symtab_and_line sal
)
319 /* If there is a line number, but no PC, then there is no location
320 information associated with this sal. The only way that should
321 happen is for the call sites of inlined functions (SAL comes from
322 find_frame_sal). Otherwise, we would have some PC range if the
323 SAL came from a line table. */
324 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
326 if (get_next_frame (frame
) == NULL
)
327 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
329 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
333 return get_frame_pc (frame
) != sal
.pc
|| !sal
.is_stmt
;
339 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
340 int print_level
, enum print_what print_what
,
343 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
345 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
348 /* Show or print a stack frame FRAME briefly. The output is formatted
349 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
350 relative level, function name, argument list, and file name and
351 line number. If the frame's PC is not at the beginning of the
352 source line, the actual PC is printed at the beginning. */
355 print_stack_frame (struct frame_info
*frame
, int print_level
,
356 enum print_what print_what
,
360 /* For mi, always print location and address. */
361 if (current_uiout
->is_mi_like_p ())
362 print_what
= LOC_AND_ADDRESS
;
366 print_frame_info (user_frame_print_options
,
367 frame
, print_level
, print_what
, 1 /* print_args */,
370 set_current_sal_from_frame (frame
);
372 catch (const gdb_exception_error
&e
)
377 /* Print nameless arguments of frame FRAME on STREAM, where START is
378 the offset of the first nameless argument, and NUM is the number of
379 nameless arguments to print. FIRST is nonzero if this is the first
380 argument (not just the first nameless argument). */
383 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
384 int first
, struct ui_file
*stream
)
386 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
387 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
392 for (i
= 0; i
< num
; i
++)
395 argsaddr
= get_frame_args_address (frame
);
398 arg_value
= read_memory_integer (argsaddr
+ start
,
399 sizeof (int), byte_order
);
401 fprintf_filtered (stream
, ", ");
402 fprintf_filtered (stream
, "%ld", arg_value
);
404 start
+= sizeof (int);
408 /* Print single argument of inferior function. ARG must be already
411 Errors are printed as if they would be the parameter value. Use zeroed ARG
412 iff it should not be printed according to user settings. */
415 print_frame_arg (const frame_print_options
&fp_opts
,
416 const struct frame_arg
*arg
)
418 struct ui_out
*uiout
= current_uiout
;
422 gdb_assert (!arg
->val
|| !arg
->error
);
423 gdb_assert (arg
->entry_kind
== print_entry_values_no
424 || arg
->entry_kind
== print_entry_values_only
425 || (!uiout
->is_mi_like_p ()
426 && arg
->entry_kind
== print_entry_values_compact
));
428 annotate_arg_emitter arg_emitter
;
429 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
430 fputs_filtered (arg
->sym
->print_name (), &stb
);
431 if (arg
->entry_kind
== print_entry_values_compact
)
433 /* It is OK to provide invalid MI-like stream as with
434 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
437 fputs_filtered (arg
->sym
->print_name (), &stb
);
439 if (arg
->entry_kind
== print_entry_values_only
440 || arg
->entry_kind
== print_entry_values_compact
)
442 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
443 annotate_arg_name_end ();
447 if (!arg
->val
&& !arg
->error
)
453 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
454 style
= metadata_style
.style ();
460 const struct language_defn
*language
;
461 struct value_print_options vp_opts
;
463 /* Avoid value_print because it will deref ref parameters. We
464 just want to print their addresses. Print ??? for args whose
465 address we do not know. We pass 2 as "recurse" to val_print
466 because our standard indentation here is 4 spaces, and
467 val_print indents 2 for each recurse. */
469 annotate_arg_value (value_type (arg
->val
));
471 /* Use the appropriate language to display our symbol, unless the
472 user forced the language to a specific language. */
473 if (language_mode
== language_mode_auto
)
474 language
= language_def (arg
->sym
->language ());
476 language
= current_language
;
478 get_no_prettyformat_print_options (&vp_opts
);
479 vp_opts
.deref_ref
= 1;
480 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
482 /* True in "summary" mode, false otherwise. */
484 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
486 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
488 catch (const gdb_exception_error
&except
)
490 stb
.printf (_("<error reading variable: %s>"),
492 style
= metadata_style
.style ();
497 uiout
->field_stream ("value", stb
, style
);
500 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
501 responsible for xfree of ARGP->ERROR. This function never throws an
505 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
506 struct frame_arg
*argp
)
514 argp
->val
= read_var_value (sym
, NULL
, frame
);
516 catch (const gdb_exception_error
&except
)
518 argp
->error
.reset (xstrdup (except
.what ()));
522 /* Read in inferior function parameter SYM at FRAME into ARGP. This
523 function never throws an exception. */
526 read_frame_arg (const frame_print_options
&fp_opts
,
527 symbol
*sym
, frame_info
*frame
,
528 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
530 struct value
*val
= NULL
, *entryval
= NULL
;
531 char *val_error
= NULL
, *entryval_error
= NULL
;
534 if (fp_opts
.print_entry_values
!= print_entry_values_only
535 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
539 val
= read_var_value (sym
, NULL
, frame
);
541 catch (const gdb_exception_error
&except
)
543 val_error
= (char *) alloca (except
.message
->size () + 1);
544 strcpy (val_error
, except
.what ());
548 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
549 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
550 && fp_opts
.print_entry_values
!= print_entry_values_no
551 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
552 || !val
|| value_optimized_out (val
)))
556 const struct symbol_computed_ops
*ops
;
558 ops
= SYMBOL_COMPUTED_OPS (sym
);
559 entryval
= ops
->read_variable_at_entry (sym
, frame
);
561 catch (const gdb_exception_error
&except
)
563 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
565 entryval_error
= (char *) alloca (except
.message
->size () + 1);
566 strcpy (entryval_error
, except
.what ());
570 if (entryval
!= NULL
&& value_optimized_out (entryval
))
573 if (fp_opts
.print_entry_values
== print_entry_values_compact
574 || fp_opts
.print_entry_values
== print_entry_values_default
)
576 /* For MI do not try to use print_entry_values_compact for ARGP. */
578 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
580 struct type
*type
= value_type (val
);
582 if (value_lazy (val
))
583 value_fetch_lazy (val
);
584 if (value_lazy (entryval
))
585 value_fetch_lazy (entryval
);
587 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
589 /* Initialize it just to avoid a GCC false warning. */
590 struct value
*val_deref
= NULL
, *entryval_deref
;
592 /* DW_AT_call_value does match with the current
593 value. If it is a reference still try to verify if
594 dereferenced DW_AT_call_data_value does not differ. */
598 struct type
*type_deref
;
600 val_deref
= coerce_ref (val
);
601 if (value_lazy (val_deref
))
602 value_fetch_lazy (val_deref
);
603 type_deref
= value_type (val_deref
);
605 entryval_deref
= coerce_ref (entryval
);
606 if (value_lazy (entryval_deref
))
607 value_fetch_lazy (entryval_deref
);
609 /* If the reference addresses match but dereferenced
610 content does not match print them. */
612 && value_contents_eq (val_deref
, 0,
614 TYPE_LENGTH (type_deref
)))
617 catch (const gdb_exception_error
&except
)
619 /* If the dereferenced content could not be
620 fetched do not display anything. */
621 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
623 else if (except
.message
!= NULL
)
626 = (char *) alloca (except
.message
->size () + 1);
627 strcpy (entryval_error
, except
.what ());
631 /* Value was not a reference; and its content matches. */
632 if (val
== val_deref
)
640 /* Try to remove possibly duplicate error message for ENTRYARGP even
643 if (val_error
&& entryval_error
644 && strcmp (val_error
, entryval_error
) == 0)
646 entryval_error
= NULL
;
648 /* Do not se VAL_EQUAL as the same error message may be shown for
649 the entry value even if no entry values are present in the
655 if (entryval
== NULL
)
657 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
659 gdb_assert (val
== NULL
);
663 val
= read_var_value (sym
, NULL
, frame
);
665 catch (const gdb_exception_error
&except
)
667 val_error
= (char *) alloca (except
.message
->size () + 1);
668 strcpy (val_error
, except
.what ());
671 if (fp_opts
.print_entry_values
== print_entry_values_only
672 || fp_opts
.print_entry_values
== print_entry_values_both
673 || (fp_opts
.print_entry_values
== print_entry_values_preferred
674 && (!val
|| value_optimized_out (val
))))
676 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
677 entryval_error
= NULL
;
680 if ((fp_opts
.print_entry_values
== print_entry_values_compact
681 || fp_opts
.print_entry_values
== print_entry_values_if_needed
682 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
683 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
691 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
692 if (!val
&& !val_error
)
693 argp
->entry_kind
= print_entry_values_only
;
694 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
695 || fp_opts
.print_entry_values
== print_entry_values_default
)
698 argp
->entry_kind
= print_entry_values_compact
;
699 gdb_assert (!current_uiout
->is_mi_like_p ());
702 argp
->entry_kind
= print_entry_values_no
;
704 entryargp
->sym
= sym
;
705 entryargp
->val
= entryval
;
706 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
707 if (!entryval
&& !entryval_error
)
708 entryargp
->entry_kind
= print_entry_values_no
;
710 entryargp
->entry_kind
= print_entry_values_only
;
713 /* Print the arguments of frame FRAME on STREAM, given the function
714 FUNC running in that frame (as a symbol), where NUM is the number
715 of arguments according to the stack frame (or -1 if the number of
716 arguments is unknown). */
718 /* Note that currently the "number of arguments according to the
719 stack frame" is only known on VAX where i refers to the "number of
720 ints of arguments according to the stack frame". */
723 print_frame_args (const frame_print_options
&fp_opts
,
724 struct symbol
*func
, struct frame_info
*frame
,
725 int num
, struct ui_file
*stream
)
727 struct ui_out
*uiout
= current_uiout
;
729 /* Offset of next stack argument beyond the one we have seen that is
730 at the highest offset, or -1 if we haven't come to a stack
732 long highest_offset
= -1;
733 /* Number of ints of arguments that we have printed so far. */
734 int args_printed
= 0;
735 /* True if we should print arg names. If false, we only indicate
736 the presence of arguments by printing ellipsis. */
738 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
739 /* True if we should print arguments, false otherwise. */
742 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
744 /* Temporarily change the selected frame to the given FRAME.
745 This allows routines that rely on the selected frame instead
746 of being given a frame as parameter to use the correct frame. */
747 scoped_restore_selected_frame restore_selected_frame
;
748 select_frame (frame
);
752 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
753 struct block_iterator iter
;
756 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
758 struct frame_arg arg
, entryarg
;
762 /* Keep track of the highest stack argument offset seen, and
763 skip over any kinds of symbols we don't care about. */
765 if (!SYMBOL_IS_ARGUMENT (sym
))
775 switch (SYMBOL_CLASS (sym
))
780 long current_offset
= SYMBOL_VALUE (sym
);
781 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
783 /* Compute address of next argument by adding the size of
784 this argument and rounding to an int boundary. */
786 ((current_offset
+ arg_size
+ sizeof (int) - 1)
787 & ~(sizeof (int) - 1));
789 /* If this is the highest offset seen yet, set
791 if (highest_offset
== -1
792 || (current_offset
> highest_offset
))
793 highest_offset
= current_offset
;
795 /* Add the number of ints we're about to print to
797 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
800 /* We care about types of symbols, but don't need to
801 keep track of stack offsets in them. */
803 case LOC_REGPARM_ADDR
:
805 case LOC_OPTIMIZED_OUT
:
810 /* We have to look up the symbol because arguments can have
811 two entries (one a parameter, one a local) and the one we
812 want is the local, which lookup_symbol will find for us.
813 This includes gcc1 (not gcc2) on SPARC when passing a
814 small structure and gcc2 when the argument type is float
815 and it is passed as a double and converted to float by
816 the prologue (in the latter case the type of the LOC_ARG
817 symbol is double and the type of the LOC_LOCAL symbol is
819 /* But if the parameter name is null, don't try it. Null
820 parameter names occur on the RS/6000, for traceback
821 tables. FIXME, should we even print them? */
823 if (*sym
->linkage_name ())
827 nsym
= lookup_symbol_search_name (sym
->search_name (),
828 b
, VAR_DOMAIN
).symbol
;
829 gdb_assert (nsym
!= NULL
);
830 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
831 && !SYMBOL_IS_ARGUMENT (nsym
))
833 /* There is a LOC_ARG/LOC_REGISTER pair. This means
834 that it was passed on the stack and loaded into a
835 register, or passed in a register and stored in a
836 stack slot. GDB 3.x used the LOC_ARG; GDB
837 4.0-4.11 used the LOC_REGISTER.
839 Reasons for using the LOC_ARG:
841 (1) Because find_saved_registers may be slow for
844 (2) Because registers are often re-used and stack
845 slots rarely (never?) are. Therefore using
846 the stack slot is much less likely to print
849 Reasons why we might want to use the LOC_REGISTER:
851 (1) So that the backtrace prints the same value
852 as "print foo". I see no compelling reason
853 why this needs to be the case; having the
854 backtrace print the value which was passed
855 in, and "print foo" print the value as
856 modified within the called function, makes
859 Additional note: It might be nice if "info args"
860 displayed both values.
862 One more note: There is a case with SPARC
863 structure passing where we need to use the
864 LOC_REGISTER, but this is dealt with by creating
865 a single LOC_REGPARM in symbol reading. */
867 /* Leave sym (the LOC_ARG) alone. */
874 /* Print the current arg. */
877 uiout
->wrap_hint (" ");
882 arg
.entry_kind
= print_entry_values_no
;
884 entryarg
.entry_kind
= print_entry_values_no
;
887 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
889 if (arg
.entry_kind
!= print_entry_values_only
)
890 print_frame_arg (fp_opts
, &arg
);
892 if (entryarg
.entry_kind
!= print_entry_values_no
)
894 if (arg
.entry_kind
!= print_entry_values_only
)
897 uiout
->wrap_hint (" ");
900 print_frame_arg (fp_opts
, &entryarg
);
907 /* Don't print nameless args in situations where we don't know
908 enough about the stack to find them. */
913 if (highest_offset
== -1)
914 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
916 start
= highest_offset
;
918 if (!print_names
&& !first
&& num
> 0)
921 print_frame_nameless_args (frame
, start
, num
- args_printed
,
926 /* Set the current source and line to the location given by frame
927 FRAME, if possible. When CENTER is true, adjust so the relevant
928 line is in the center of the next 'list'. */
931 set_current_sal_from_frame (struct frame_info
*frame
)
933 symtab_and_line sal
= find_frame_sal (frame
);
934 if (sal
.symtab
!= NULL
)
935 set_current_source_symtab_and_line (sal
);
938 /* If ON, GDB will display disassembly of the next source line when
939 execution of the program being debugged stops.
940 If AUTO (which is the default), or there's no line info to determine
941 the source line of the next instruction, display disassembly of next
942 instruction instead. */
944 static enum auto_boolean disassemble_next_line
;
947 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
948 struct cmd_list_element
*c
,
951 fprintf_filtered (file
,
952 _("Debugger's willingness to use "
953 "disassemble-next-line is %s.\n"),
957 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
958 because it will be broken by filter sometime. */
961 do_gdb_disassembly (struct gdbarch
*gdbarch
,
962 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
967 gdb_disassembly (gdbarch
, current_uiout
,
968 DISASSEMBLY_RAW_INSN
, how_many
,
971 catch (const gdb_exception_error
&exception
)
973 /* If an exception was thrown while doing the disassembly, print
974 the error message, to give the user a clue of what happened. */
975 exception_print (gdb_stderr
, exception
);
979 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
980 Value not present indicates to the caller to use default values
981 specific to the command being executed. */
983 static gdb::optional
<enum print_what
>
984 print_frame_info_to_print_what (const char *print_frame_info
)
986 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
987 if (print_frame_info
== print_frame_info_choices
[i
])
988 return print_frame_info_print_what
[i
];
990 internal_error (__FILE__
, __LINE__
,
991 "Unexpected print frame-info value `%s'.",
995 /* Print the PC from FRAME, plus any flags, to UIOUT. */
998 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info
*frame
,
1001 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1003 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
1004 if (!flags
.empty ())
1007 uiout
->field_string ("addr_flags", flags
);
1015 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
1018 = print_frame_info_to_print_what
1019 (user_frame_print_options
.print_frame_info
);
1022 /* Print information about frame FRAME. The output is format according
1023 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1024 PRINT_WHAT, see enum print_what comments in frame.h.
1025 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1026 != print_frame_info_auto.
1028 Used in "where" output, and to emit breakpoint or step
1032 print_frame_info (const frame_print_options
&fp_opts
,
1033 frame_info
*frame
, int print_level
,
1034 enum print_what print_what
, int print_args
,
1035 int set_current_sal
)
1037 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1040 struct ui_out
*uiout
= current_uiout
;
1042 if (!current_uiout
->is_mi_like_p ()
1043 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1045 /* Use the specific frame information desired by the user. */
1046 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1049 if (get_frame_type (frame
) == DUMMY_FRAME
1050 || get_frame_type (frame
) == SIGTRAMP_FRAME
1051 || get_frame_type (frame
) == ARCH_FRAME
)
1053 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1055 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1056 gdbarch
, get_frame_pc (frame
));
1058 /* Do this regardless of SOURCE because we don't have any source
1059 to list for this frame. */
1063 uiout
->field_fmt_signed (2, ui_left
, "level",
1064 frame_relative_level (frame
));
1066 if (uiout
->is_mi_like_p ())
1068 annotate_frame_address ();
1069 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1070 annotate_frame_address_end ();
1073 if (get_frame_type (frame
) == DUMMY_FRAME
)
1075 annotate_function_call ();
1076 uiout
->field_string ("func", "<function called from gdb>",
1077 metadata_style
.style ());
1079 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1081 annotate_signal_handler_caller ();
1082 uiout
->field_string ("func", "<signal handler called>",
1083 metadata_style
.style ());
1085 else if (get_frame_type (frame
) == ARCH_FRAME
)
1087 uiout
->field_string ("func", "<cross-architecture call>",
1088 metadata_style
.style ());
1091 annotate_frame_end ();
1093 /* If disassemble-next-line is set to auto or on output the next
1095 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1096 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1097 do_gdb_disassembly (get_frame_arch (frame
), 1,
1098 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1103 /* If FRAME is not the innermost frame, that normally means that
1104 FRAME->pc points to *after* the call instruction, and we want to
1105 get the line containing the call, never the next line. But if
1106 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1107 next frame was not entered as the result of a call, and we want
1108 to get the line containing FRAME->pc. */
1109 symtab_and_line sal
= find_frame_sal (frame
);
1111 location_print
= (print_what
== LOCATION
1112 || print_what
== SRC_AND_LOC
1113 || print_what
== LOC_AND_ADDRESS
1114 || print_what
== SHORT_LOCATION
);
1115 if (location_print
|| !sal
.symtab
)
1116 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1118 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1120 /* If disassemble-next-line is set to auto or on and doesn't have
1121 the line debug messages for $pc, output the next instruction. */
1122 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1123 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1124 && source_print
&& !sal
.symtab
)
1125 do_gdb_disassembly (get_frame_arch (frame
), 1,
1126 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1128 if (source_print
&& sal
.symtab
)
1130 int mid_statement
= ((print_what
== SRC_LINE
)
1131 && frame_show_address (frame
, sal
));
1132 if (annotation_level
> 0
1133 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1134 get_frame_pc (frame
)))
1136 /* The call to ANNOTATE_SOURCE_LINE already printed the
1137 annotation for this source line, so we avoid the two cases
1138 below and do not print the actual source line. The
1139 documentation for annotations makes it clear that the source
1140 line annotation is printed __instead__ of printing the source
1141 line, not as well as.
1143 However, if we fail to print the source line, which usually
1144 means either the source file is missing, or the requested
1145 line is out of range of the file, then we don't print the
1146 source annotation, and will pass through the "normal" print
1147 source line code below, the expectation is that this code
1148 will print an appropriate error. */
1150 else if (deprecated_print_frame_info_listing_hook
)
1151 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1155 struct value_print_options opts
;
1157 get_user_print_options (&opts
);
1158 /* We used to do this earlier, but that is clearly
1159 wrong. This function is used by many different
1160 parts of gdb, including normal_stop in infrun.c,
1161 which uses this to print out the current PC
1162 when we stepi/nexti into the middle of a source
1163 line. Only the command line really wants this
1164 behavior. Other UIs probably would like the
1165 ability to decide for themselves if it is desired. */
1166 if (opts
.addressprint
&& mid_statement
)
1168 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1172 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1175 /* If disassemble-next-line is set to on and there is line debug
1176 messages, output assembly codes for next line. */
1177 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1178 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1181 if (set_current_sal
)
1185 if (get_frame_pc_if_available (frame
, &pc
))
1186 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1188 last_displayed_symtab_info
.invalidate ();
1191 annotate_frame_end ();
1193 gdb_flush (gdb_stdout
);
1199 clear_last_displayed_sal (void)
1201 last_displayed_symtab_info
.invalidate ();
1207 last_displayed_sal_is_valid (void)
1209 return last_displayed_symtab_info
.is_valid ();
1214 struct program_space
*
1215 get_last_displayed_pspace (void)
1217 return last_displayed_symtab_info
.pspace ();
1223 get_last_displayed_addr (void)
1225 return last_displayed_symtab_info
.address ();
1231 get_last_displayed_symtab (void)
1233 return last_displayed_symtab_info
.symtab ();
1239 get_last_displayed_line (void)
1241 return last_displayed_symtab_info
.line ();
1247 get_last_displayed_sal ()
1249 symtab_and_line sal
;
1251 if (last_displayed_symtab_info
.is_valid ())
1253 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1254 sal
.pc
= last_displayed_symtab_info
.address ();
1255 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1256 sal
.line
= last_displayed_symtab_info
.line ();
1263 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1264 corresponding to FRAME. */
1266 gdb::unique_xmalloc_ptr
<char>
1267 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1268 struct symbol
**funcp
)
1270 struct symbol
*func
;
1271 gdb::unique_xmalloc_ptr
<char> funname
;
1273 *funlang
= language_unknown
;
1277 func
= get_frame_function (frame
);
1280 const char *print_name
= func
->print_name ();
1282 *funlang
= func
->language ();
1285 if (*funlang
== language_cplus
)
1287 /* It seems appropriate to use print_name() here,
1288 to display the demangled name that we already have
1289 stored in the symbol table, but we stored a version
1290 with DMGL_PARAMS turned on, and here we don't want to
1291 display parameters. So remove the parameters. */
1292 funname
= cp_remove_params (print_name
);
1295 /* If we didn't hit the C++ case above, set *funname
1297 if (funname
== NULL
)
1298 funname
.reset (xstrdup (print_name
));
1302 struct bound_minimal_symbol msymbol
;
1305 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1308 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1309 if (msymbol
.minsym
!= NULL
)
1311 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1312 *funlang
= msymbol
.minsym
->language ();
1320 print_frame (const frame_print_options
&fp_opts
,
1321 frame_info
*frame
, int print_level
,
1322 enum print_what print_what
, int print_args
,
1323 struct symtab_and_line sal
)
1325 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1326 struct ui_out
*uiout
= current_uiout
;
1327 enum language funlang
= language_unknown
;
1328 struct value_print_options opts
;
1329 struct symbol
*func
;
1333 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1335 gdb::unique_xmalloc_ptr
<char> funname
1336 = find_frame_funname (frame
, &funlang
, &func
);
1338 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1342 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1347 uiout
->field_fmt_signed (2, ui_left
, "level",
1348 frame_relative_level (frame
));
1350 get_user_print_options (&opts
);
1351 if (opts
.addressprint
)
1353 || frame_show_address (frame
, sal
)
1354 || print_what
== LOC_AND_ADDRESS
)
1356 annotate_frame_address ();
1358 print_pc (uiout
, gdbarch
, frame
, pc
);
1360 uiout
->field_string ("addr", "<unavailable>",
1361 metadata_style
.style ());
1362 annotate_frame_address_end ();
1363 uiout
->text (" in ");
1365 annotate_frame_function_name ();
1368 fputs_filtered (funname
? funname
.get () : "??", &stb
);
1369 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1370 uiout
->wrap_hint (" ");
1371 annotate_frame_args ();
1378 if (gdbarch_frame_num_args_p (gdbarch
))
1380 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1381 gdb_assert (numargs
>= 0);
1387 ui_out_emit_list
list_emitter (uiout
, "args");
1390 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1392 catch (const gdb_exception_error
&e
)
1396 /* FIXME: ARGS must be a list. If one argument is a string it
1397 will have " that will not be properly escaped. */
1402 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1404 const char *filename_display
;
1406 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1407 annotate_frame_source_begin ();
1408 uiout
->wrap_hint (" ");
1409 uiout
->text (" at ");
1410 annotate_frame_source_file ();
1411 uiout
->field_string ("file", filename_display
,
1412 file_name_style
.style ());
1413 if (uiout
->is_mi_like_p ())
1415 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1417 uiout
->field_string ("fullname", fullname
);
1419 annotate_frame_source_file_end ();
1421 annotate_frame_source_line ();
1422 uiout
->field_signed ("line", sal
.line
);
1423 annotate_frame_source_end ();
1426 if (print_what
!= SHORT_LOCATION
1427 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1429 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1430 get_frame_pc (frame
));
1434 annotate_frame_where ();
1435 uiout
->wrap_hint (" ");
1436 uiout
->text (" from ");
1437 uiout
->field_string ("from", lib
, file_name_style
.style ());
1440 if (uiout
->is_mi_like_p ())
1441 uiout
->field_string ("arch",
1442 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1449 /* Completion function for "frame function", "info frame function", and
1450 "select-frame function" commands. */
1453 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1454 completion_tracker
&tracker
,
1455 const char *text
, const char *word
)
1457 /* This is used to complete function names within a stack. It would be
1458 nice if we only offered functions that were actually in the stack.
1459 However, this would mean unwinding the stack to completion, which
1460 could take too long, or on a corrupted stack, possibly not end.
1461 Instead, we offer all symbol names as a safer choice. */
1462 collect_symbol_completion_matches (tracker
,
1463 complete_symbol_mode::EXPRESSION
,
1464 symbol_name_match_type::EXPRESSION
,
1468 /* Core of all the "info frame" sub-commands. Print information about a
1469 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1470 frame specification, they just entered 'info frame'. If the user did
1471 provide a frame specification (for example 'info frame 0', 'info frame
1472 level 1') then SELECTED_FRAME_P will be false. */
1475 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1477 struct symbol
*func
;
1479 struct frame_info
*calling_frame_info
;
1481 const char *funname
= 0;
1482 enum language funlang
= language_unknown
;
1483 const char *pc_regname
;
1484 struct gdbarch
*gdbarch
;
1487 /* Initialize it to avoid "may be used uninitialized" warning. */
1488 CORE_ADDR caller_pc
= 0;
1489 int caller_pc_p
= 0;
1491 gdbarch
= get_frame_arch (fi
);
1493 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1494 is not a good name. */
1495 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1496 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1497 easily not match that of the internal value returned by
1499 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1501 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1502 architectures will often have a hardware register called "pc",
1503 and that register's value, again, can easily not match
1507 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1508 func
= get_frame_function (fi
);
1509 symtab_and_line sal
= find_frame_sal (fi
);
1511 gdb::unique_xmalloc_ptr
<char> func_only
;
1514 funname
= func
->print_name ();
1515 funlang
= func
->language ();
1516 if (funlang
== language_cplus
)
1518 /* It seems appropriate to use print_name() here,
1519 to display the demangled name that we already have
1520 stored in the symbol table, but we stored a version
1521 with DMGL_PARAMS turned on, and here we don't want to
1522 display parameters. So remove the parameters. */
1523 func_only
= cp_remove_params (funname
);
1526 funname
= func_only
.get ();
1529 else if (frame_pc_p
)
1531 struct bound_minimal_symbol msymbol
;
1533 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1534 if (msymbol
.minsym
!= NULL
)
1536 funname
= msymbol
.minsym
->print_name ();
1537 funlang
= msymbol
.minsym
->language ();
1540 calling_frame_info
= get_prev_frame (fi
);
1542 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1544 printf_filtered (_("Stack level %d, frame at "),
1545 frame_relative_level (fi
));
1549 printf_filtered (_("Stack frame at "));
1551 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1552 printf_filtered (":\n");
1553 printf_filtered (" %s = ", pc_regname
);
1555 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1557 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1562 printf_filtered (" in ");
1563 fputs_filtered (funname
, gdb_stdout
);
1569 styled_string (file_name_style
.style (),
1570 symtab_to_filename_for_display (sal
.symtab
)),
1572 puts_filtered ("; ");
1574 printf_filtered ("saved %s = ", pc_regname
);
1576 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1577 val_print_not_saved (gdb_stdout
);
1582 caller_pc
= frame_unwind_caller_pc (fi
);
1585 catch (const gdb_exception_error
&ex
)
1589 case NOT_AVAILABLE_ERROR
:
1590 val_print_unavailable (gdb_stdout
);
1592 case OPTIMIZED_OUT_ERROR
:
1593 val_print_not_saved (gdb_stdout
);
1596 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1605 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1606 printf_filtered ("\n");
1608 if (calling_frame_info
== NULL
)
1610 enum unwind_stop_reason reason
;
1612 reason
= get_frame_unwind_stop_reason (fi
);
1613 if (reason
!= UNWIND_NO_REASON
)
1614 printf_filtered (_(" Outermost frame: %s\n"),
1615 frame_stop_reason_string (fi
));
1617 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1618 puts_filtered (" tail call frame");
1619 else if (get_frame_type (fi
) == INLINE_FRAME
)
1620 printf_filtered (" inlined into frame %d",
1621 frame_relative_level (get_prev_frame (fi
)));
1624 printf_filtered (" called by frame at ");
1625 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1628 if (get_next_frame (fi
) && calling_frame_info
)
1629 puts_filtered (",");
1631 if (get_next_frame (fi
))
1633 printf_filtered (" caller of frame at ");
1634 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1637 if (get_next_frame (fi
) || calling_frame_info
)
1638 puts_filtered ("\n");
1641 printf_filtered (" source language %s.\n",
1642 language_str (s
->language
));
1645 /* Address of the argument list for this frame, or 0. */
1646 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1647 /* Number of args for this frame, or -1 if unknown. */
1651 printf_filtered (" Arglist at unknown address.\n");
1654 printf_filtered (" Arglist at ");
1655 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1656 printf_filtered (",");
1658 if (!gdbarch_frame_num_args_p (gdbarch
))
1661 puts_filtered (" args: ");
1665 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1666 gdb_assert (numargs
>= 0);
1668 puts_filtered (" no args.");
1669 else if (numargs
== 1)
1670 puts_filtered (" 1 arg: ");
1672 printf_filtered (" %d args: ", numargs
);
1674 print_frame_args (user_frame_print_options
,
1675 func
, fi
, numargs
, gdb_stdout
);
1676 puts_filtered ("\n");
1680 /* Address of the local variables for this frame, or 0. */
1681 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1684 printf_filtered (" Locals at unknown address,");
1687 printf_filtered (" Locals at ");
1688 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1689 printf_filtered (",");
1693 /* Print as much information as possible on the location of all the
1699 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1701 /* The sp is special; what's displayed isn't the save address, but
1702 the value of the previous frame's sp. This is a legacy thing,
1703 at one stage the frame cached the previous frame's SP instead
1704 of its address, hence it was easiest to just display the cached
1708 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1709 gdb_assert (value
!= NULL
);
1711 if (!value_optimized_out (value
) && value_entirely_available (value
))
1713 if (VALUE_LVAL (value
) == not_lval
)
1716 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1717 int sp_size
= register_size (gdbarch
, sp_regnum
);
1719 sp
= extract_unsigned_integer (value_contents_all (value
),
1720 sp_size
, byte_order
);
1722 printf_filtered (" Previous frame's sp is ");
1723 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1724 printf_filtered ("\n");
1726 else if (VALUE_LVAL (value
) == lval_memory
)
1728 printf_filtered (" Previous frame's sp at ");
1729 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1731 printf_filtered ("\n");
1733 else if (VALUE_LVAL (value
) == lval_register
)
1735 printf_filtered (" Previous frame's sp in %s\n",
1736 gdbarch_register_name (gdbarch
,
1737 VALUE_REGNUM (value
)));
1740 release_value (value
);
1743 /* else keep quiet. */
1747 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1748 for (i
= 0; i
< numregs
; i
++)
1750 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1752 enum lval_type lval
;
1758 /* Find out the location of the saved register without
1759 fetching the corresponding value. */
1760 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1761 &lval
, &addr
, &realnum
, NULL
);
1762 /* For moment, only display registers that were saved on the
1764 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1767 puts_filtered (" Saved registers:\n ");
1769 puts_filtered (",");
1771 printf_filtered (" %s at ",
1772 gdbarch_register_name (gdbarch
, i
));
1773 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1777 if (count
|| need_nl
)
1778 puts_filtered ("\n");
1782 /* Return the innermost frame at level LEVEL. */
1784 static struct frame_info
*
1785 leading_innermost_frame (int level
)
1787 struct frame_info
*leading
;
1789 leading
= get_current_frame ();
1791 gdb_assert (level
>= 0);
1793 while (leading
!= nullptr && level
)
1796 leading
= get_prev_frame (leading
);
1803 /* Return the starting frame needed to handle COUNT outermost frames. */
1805 static struct frame_info
*
1806 trailing_outermost_frame (int count
)
1808 struct frame_info
*current
;
1809 struct frame_info
*trailing
;
1811 trailing
= get_current_frame ();
1813 gdb_assert (count
> 0);
1816 while (current
!= nullptr && count
--)
1819 current
= get_prev_frame (current
);
1822 /* Will stop when CURRENT reaches the top of the stack.
1823 TRAILING will be COUNT below it. */
1824 while (current
!= nullptr)
1827 trailing
= get_prev_frame (trailing
);
1828 current
= get_prev_frame (current
);
1834 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1838 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1840 frame_info
*prev_frame
= get_selected_frame ();
1842 if (get_selected_frame () != prev_frame
)
1843 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1849 select_frame_for_mi (struct frame_info
*fi
)
1851 select_frame_command_core (fi
, false /* Ignored. */);
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 (struct frame_info
*fi
, bool ignored
)
1861 frame_info
*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
) (struct frame_info
*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
));
1894 struct frame_info
*fid
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 struct frame_info
*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
)
1922 struct frame_info
*fid
;
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 struct frame_info
*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
)
1993 struct frame_info
*fi
;
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 struct frame_info
*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
))
2074 /* Don't use print_stack_frame; if an error() occurs it probably
2075 means further attempts to backtrace would fail (on the other
2076 hand, perhaps the code does or could be fixed to make sure
2077 the frame->prev field gets set to NULL in that case). */
2079 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2080 if ((flags
& PRINT_LOCALS
) != 0)
2082 struct frame_id frame_id
= get_frame_id (fi
);
2084 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2086 /* print_frame_local_vars invalidates FI. */
2087 fi
= frame_find_by_id (frame_id
);
2091 warning (_("Unable to restore previously selected frame."));
2096 /* Save the last frame to check for error conditions. */
2100 /* If we've stopped before the end, mention that. */
2102 printf_filtered (_("(More stack frames follow...)\n"));
2104 /* If we've run out of frames, and the reason appears to be an error
2105 condition, print it. */
2106 if (fi
== NULL
&& trailing
!= NULL
)
2108 enum unwind_stop_reason reason
;
2110 reason
= get_frame_unwind_stop_reason (trailing
);
2111 if (reason
>= UNWIND_FIRST_ERROR
)
2112 printf_filtered (_("Backtrace stopped: %s\n"),
2113 frame_stop_reason_string (trailing
));
2118 /* Create an option_def_group array grouping all the "backtrace"
2119 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2121 static inline std::array
<gdb::option::option_def_group
, 3>
2122 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2123 backtrace_cmd_options
*bt_cmd_opts
,
2124 set_backtrace_options
*set_bt_opts
)
2127 { {frame_print_option_defs
}, fp_opts
},
2128 { {set_backtrace_option_defs
}, set_bt_opts
},
2129 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2133 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2134 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2135 store the parsed qualifiers. */
2138 parse_backtrace_qualifiers (const char *arg
,
2139 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2143 const char *save_arg
= arg
;
2144 std::string this_arg
= extract_arg (&arg
);
2146 if (this_arg
.empty ())
2149 if (subset_compare (this_arg
.c_str (), "no-filters"))
2151 if (bt_cmd_opts
!= nullptr)
2152 bt_cmd_opts
->no_filters
= true;
2154 else if (subset_compare (this_arg
.c_str (), "full"))
2156 if (bt_cmd_opts
!= nullptr)
2157 bt_cmd_opts
->full
= true;
2159 else if (subset_compare (this_arg
.c_str (), "hide"))
2161 if (bt_cmd_opts
!= nullptr)
2162 bt_cmd_opts
->hide
= true;
2166 /* Not a recognized qualifier, so stop. */
2173 backtrace_command (const char *arg
, int from_tty
)
2175 frame_print_options fp_opts
= user_frame_print_options
;
2176 backtrace_cmd_options bt_cmd_opts
;
2177 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2180 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2181 gdb::option::process_options
2182 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2184 /* Parse non-'-'-prefixed qualifiers, for backwards
2188 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2193 /* These options are handled quite deep in the unwind machinery, so
2194 we get to pass them down by swapping globals. */
2195 scoped_restore restore_set_backtrace_options
2196 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2198 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2201 /* Completer for the "backtrace" command. */
2204 backtrace_command_completer (struct cmd_list_element
*ignore
,
2205 completion_tracker
&tracker
,
2206 const char *text
, const char */
*word*/
)
2209 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2210 if (gdb::option::complete_options
2211 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2216 const char *p
= skip_to_space (text
);
2219 static const char *const backtrace_cmd_qualifier_choices
[] = {
2220 "full", "no-filters", "hide", nullptr,
2222 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2225 if (tracker
.have_completions ())
2230 const char *cmd
= parse_backtrace_qualifiers (text
);
2231 tracker
.advance_custom_word_point_by (cmd
- text
);
2236 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2237 expression_completer (ignore
, tracker
, text
, word
);
2240 /* Iterate over the local variables of a block B, calling CB with
2244 iterate_over_block_locals (const struct block
*b
,
2245 iterate_over_block_arg_local_vars_cb cb
,
2248 struct block_iterator iter
;
2251 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2253 switch (SYMBOL_CLASS (sym
))
2260 case LOC_OPTIMIZED_OUT
:
2261 if (SYMBOL_IS_ARGUMENT (sym
))
2263 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2265 (*cb
) (sym
->print_name (), sym
, cb_data
);
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
,
2285 iterate_over_block_locals (block
, cb
, cb_data
);
2286 /* After handling the function's top-level block, stop. Don't
2287 continue to its superblock, the block of per-file
2289 if (BLOCK_FUNCTION (block
))
2291 block
= BLOCK_SUPERBLOCK (block
);
2295 /* Data to be passed around in the calls to the locals and args
2298 struct print_variable_and_value_data
2300 gdb::optional
<compiled_regex
> preg
;
2301 gdb::optional
<compiled_regex
> treg
;
2302 struct frame_id frame_id
;
2304 struct ui_file
*stream
;
2308 /* The callback for the locals and args iterators. */
2311 do_print_variable_and_value (const char *print_name
,
2315 struct print_variable_and_value_data
*p
2316 = (struct print_variable_and_value_data
*) cb_data
;
2317 struct frame_info
*frame
;
2319 if (p
->preg
.has_value ()
2320 && p
->preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2322 if (p
->treg
.has_value ()
2323 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2326 frame
= frame_find_by_id (p
->frame_id
);
2329 warning (_("Unable to restore previously selected frame."));
2333 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2335 /* print_variable_and_value invalidates FRAME. */
2338 p
->values_printed
= 1;
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 (struct frame_info
*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
))
2381 fprintf_filtered (stream
,
2382 _("PC unavailable, cannot determine locals.\n"));
2386 block
= get_frame_block (frame
, 0);
2390 fprintf_filtered (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
,
2408 do_print_variable_and_value
,
2411 if (!cb_data
.values_printed
&& !quiet
)
2413 if (regexp
== NULL
&& t_regexp
== NULL
)
2414 fprintf_filtered (stream
, _("No locals.\n"));
2416 fprintf_filtered (stream
, _("No matching locals.\n"));
2420 /* Structure to hold the values of the options used by the 'info
2421 variables' command and other similar commands. These correspond to the
2422 -q and -t options. */
2424 struct info_print_options
2427 char *type_regexp
= nullptr;
2429 ~info_print_options ()
2431 xfree (type_regexp
);
2435 /* The options used by the 'info locals' and 'info args' commands. */
2437 static const gdb::option::option_def info_print_options_defs
[] = {
2438 gdb::option::boolean_option_def
<info_print_options
> {
2440 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2441 nullptr, /* show_cmd_cb */
2442 nullptr /* set_doc */
2445 gdb::option::string_option_def
<info_print_options
> {
2447 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2448 nullptr, /* show_cmd_cb */
2449 nullptr /* set_doc */
2453 /* Returns the option group used by 'info locals' and 'info args'
2456 static gdb::option::option_def_group
2457 make_info_print_options_def_group (info_print_options
*opts
)
2459 return {{info_print_options_defs
}, opts
};
2462 /* Command completer for 'info locals' and 'info args'. */
2465 info_print_command_completer (struct cmd_list_element
*ignore
,
2466 completion_tracker
&tracker
,
2467 const char *text
, const char * /* word */)
2470 = make_info_print_options_def_group (nullptr);
2471 if (gdb::option::complete_options
2472 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2475 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2476 symbol_completer (ignore
, tracker
, text
, word
);
2479 /* Implement the 'info locals' command. */
2482 info_locals_command (const char *args
, int from_tty
)
2484 info_print_options opts
;
2485 auto grp
= make_info_print_options_def_group (&opts
);
2486 gdb::option::process_options
2487 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2488 if (args
!= nullptr && *args
== '\0')
2491 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2492 opts
.quiet
, args
, opts
.type_regexp
,
2496 /* Iterate over all the argument variables in block B. */
2499 iterate_over_block_arg_vars (const struct block
*b
,
2500 iterate_over_block_arg_local_vars_cb cb
,
2503 struct block_iterator iter
;
2504 struct symbol
*sym
, *sym2
;
2506 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2508 /* Don't worry about things which aren't arguments. */
2509 if (SYMBOL_IS_ARGUMENT (sym
))
2511 /* We have to look up the symbol because arguments can have
2512 two entries (one a parameter, one a local) and the one we
2513 want is the local, which lookup_symbol will find for us.
2514 This includes gcc1 (not gcc2) on the sparc when passing a
2515 small structure and gcc2 when the argument type is float
2516 and it is passed as a double and converted to float by
2517 the prologue (in the latter case the type of the LOC_ARG
2518 symbol is double and the type of the LOC_LOCAL symbol is
2519 float). There are also LOC_ARG/LOC_REGISTER pairs which
2520 are not combined in symbol-reading. */
2522 sym2
= lookup_symbol_search_name (sym
->search_name (),
2523 b
, VAR_DOMAIN
).symbol
;
2524 (*cb
) (sym
->print_name (), sym2
, cb_data
);
2529 /* Print all argument variables of the function of FRAME.
2530 Print them with values to STREAM.
2531 If REGEXP is not NULL, only print argument variables whose name
2533 If T_REGEXP is not NULL, only print argument variables whose type
2535 If no argument variables have been printed and !QUIET, prints a message
2536 explaining why no argument variables could be printed.
2538 This function will invalidate FRAME. */
2541 print_frame_arg_vars (struct frame_info
*frame
,
2543 const char *regexp
, const char *t_regexp
,
2544 struct ui_file
*stream
)
2546 struct print_variable_and_value_data cb_data
;
2547 struct symbol
*func
;
2549 gdb::optional
<compiled_regex
> preg
;
2550 gdb::optional
<compiled_regex
> treg
;
2552 if (!get_frame_pc_if_available (frame
, &pc
))
2555 fprintf_filtered (stream
,
2556 _("PC unavailable, cannot determine args.\n"));
2560 func
= get_frame_function (frame
);
2564 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2568 prepare_reg (regexp
, &cb_data
.preg
);
2569 prepare_reg (t_regexp
, &cb_data
.treg
);
2570 cb_data
.frame_id
= get_frame_id (frame
);
2571 cb_data
.num_tabs
= 0;
2572 cb_data
.stream
= stream
;
2573 cb_data
.values_printed
= 0;
2575 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2576 do_print_variable_and_value
, &cb_data
);
2578 /* do_print_variable_and_value invalidates FRAME. */
2581 if (!cb_data
.values_printed
&& !quiet
)
2583 if (regexp
== NULL
&& t_regexp
== NULL
)
2584 fprintf_filtered (stream
, _("No arguments.\n"));
2586 fprintf_filtered (stream
, _("No matching arguments.\n"));
2590 /* Implement the 'info args' command. */
2593 info_args_command (const char *args
, int from_tty
)
2595 info_print_options opts
;
2596 auto grp
= make_info_print_options_def_group (&opts
);
2597 gdb::option::process_options
2598 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2599 if (args
!= nullptr && *args
== '\0')
2602 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2603 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2606 /* Return the symbol-block in which the selected frame is executing.
2607 Can return zero under various legitimate circumstances.
2609 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2610 code address within the block returned. We use this to decide
2611 which macros are in scope. */
2613 const struct block
*
2614 get_selected_block (CORE_ADDR
*addr_in_block
)
2616 if (!has_stack_frames ())
2619 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2622 /* Find a frame a certain number of levels away from FRAME.
2623 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2624 Positive means go to earlier frames (up); negative, the reverse.
2625 The int that contains the number of levels is counted toward
2626 zero as the frames for those levels are found.
2627 If the top or bottom frame is reached, that frame is returned,
2628 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2629 how much farther the original request asked to go. */
2632 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2634 /* Going up is simple: just call get_prev_frame enough times or
2635 until the initial frame is reached. */
2636 while (*level_offset_ptr
> 0)
2638 struct frame_info
*prev
= get_prev_frame (frame
);
2642 (*level_offset_ptr
)--;
2646 /* Going down is just as simple. */
2647 while (*level_offset_ptr
< 0)
2649 struct frame_info
*next
= get_next_frame (frame
);
2653 (*level_offset_ptr
)++;
2660 /* Select the frame up one or COUNT_EXP stack levels from the
2661 previously selected frame, and print it briefly. */
2664 up_silently_base (const char *count_exp
)
2666 struct frame_info
*frame
;
2670 count
= parse_and_eval_long (count_exp
);
2672 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2673 if (count
!= 0 && count_exp
== NULL
)
2674 error (_("Initial frame selected; you cannot go up."));
2675 select_frame (frame
);
2679 up_silently_command (const char *count_exp
, int from_tty
)
2681 up_silently_base (count_exp
);
2685 up_command (const char *count_exp
, int from_tty
)
2687 up_silently_base (count_exp
);
2688 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2691 /* Select the frame down one or COUNT_EXP stack levels from the previously
2692 selected frame, and print it briefly. */
2695 down_silently_base (const char *count_exp
)
2697 struct frame_info
*frame
;
2701 count
= -parse_and_eval_long (count_exp
);
2703 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2704 if (count
!= 0 && count_exp
== NULL
)
2706 /* We only do this if COUNT_EXP is not specified. That way
2707 "down" means to really go down (and let me know if that is
2708 impossible), but "down 9999" can be used to mean go all the
2709 way down without getting an error. */
2711 error (_("Bottom (innermost) frame selected; you cannot go down."));
2714 select_frame (frame
);
2718 down_silently_command (const char *count_exp
, int from_tty
)
2720 down_silently_base (count_exp
);
2724 down_command (const char *count_exp
, int from_tty
)
2726 down_silently_base (count_exp
);
2727 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2731 return_command (const char *retval_exp
, int from_tty
)
2733 /* Initialize it just to avoid a GCC false warning. */
2734 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2735 struct frame_info
*thisframe
;
2736 struct gdbarch
*gdbarch
;
2737 struct symbol
*thisfun
;
2738 struct value
*return_value
= NULL
;
2739 struct value
*function
= NULL
;
2740 const char *query_prefix
= "";
2742 thisframe
= get_selected_frame ("No selected frame.");
2743 thisfun
= get_frame_function (thisframe
);
2744 gdbarch
= get_frame_arch (thisframe
);
2746 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2747 error (_("Can not force return from an inlined function."));
2749 /* Compute the return value. If the computation triggers an error,
2750 let it bail. If the return type can't be handled, set
2751 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2755 expression_up retval_expr
= parse_expression (retval_exp
);
2756 struct type
*return_type
= NULL
;
2758 /* Compute the return value. Should the computation fail, this
2759 call throws an error. */
2760 return_value
= evaluate_expression (retval_expr
.get ());
2762 /* Cast return value to the return type of the function. Should
2763 the cast fail, this call throws an error. */
2764 if (thisfun
!= NULL
)
2765 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2766 if (return_type
== NULL
)
2768 if (retval_expr
->first_opcode () != UNOP_CAST
2769 && retval_expr
->first_opcode () != UNOP_CAST_TYPE
)
2770 error (_("Return value type not available for selected "
2772 "Please use an explicit cast of the value to return."));
2773 return_type
= value_type (return_value
);
2775 return_type
= check_typedef (return_type
);
2776 return_value
= value_cast (return_type
, return_value
);
2778 /* Make sure the value is fully evaluated. It may live in the
2779 stack frame we're about to pop. */
2780 if (value_lazy (return_value
))
2781 value_fetch_lazy (return_value
);
2783 if (thisfun
!= NULL
)
2784 function
= read_var_value (thisfun
, NULL
, thisframe
);
2786 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2787 if (return_type
->code () == TYPE_CODE_VOID
)
2788 /* If the return-type is "void", don't try to find the
2789 return-value's location. However, do still evaluate the
2790 return expression so that, even when the expression result
2791 is discarded, side effects such as "return i++" still
2793 return_value
= NULL
;
2794 else if (thisfun
!= NULL
)
2796 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2797 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2798 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2800 query_prefix
= "The location at which to store the "
2801 "function's return value is unknown.\n"
2802 "If you continue, the return value "
2803 "that you specified will be ignored.\n";
2804 return_value
= NULL
;
2809 /* Does an interactive user really want to do this? Include
2810 information, such as how well GDB can handle the return value, in
2811 the query message. */
2816 if (thisfun
== NULL
)
2817 confirmed
= query (_("%sMake selected stack frame return now? "),
2821 if (TYPE_NO_RETURN (thisfun
->type
))
2822 warning (_("Function does not return normally to caller."));
2823 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2824 thisfun
->print_name ());
2827 error (_("Not confirmed"));
2830 /* Discard the selected frame and all frames inner-to it. */
2831 frame_pop (get_selected_frame (NULL
));
2833 /* Store RETURN_VALUE in the just-returned register set. */
2834 if (return_value
!= NULL
)
2836 struct type
*return_type
= value_type (return_value
);
2837 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2839 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2840 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2841 gdbarch_return_value (cache_arch
, function
, return_type
,
2842 get_current_regcache (), NULL
/*read*/,
2843 value_contents (return_value
) /*write*/);
2846 /* If we are at the end of a call dummy now, pop the dummy frame
2848 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2849 frame_pop (get_current_frame ());
2851 select_frame (get_current_frame ());
2852 /* If interactive, print the frame that is now current. */
2854 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2857 /* Find the most inner frame in the current stack for a function called
2858 FUNCTION_NAME. If no matching frame is found return NULL. */
2860 static struct frame_info
*
2861 find_frame_for_function (const char *function_name
)
2863 /* Used to hold the lower and upper addresses for each of the
2864 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2865 struct function_bounds
2867 CORE_ADDR low
, high
;
2869 struct frame_info
*frame
;
2873 gdb_assert (function_name
!= NULL
);
2875 frame
= get_current_frame ();
2876 std::vector
<symtab_and_line
> sals
2877 = decode_line_with_current_source (function_name
,
2878 DECODE_LINE_FUNFIRSTLINE
);
2879 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2880 for (size_t i
= 0; i
< sals
.size (); i
++)
2882 if (sals
[i
].pspace
!= current_program_space
)
2883 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2884 else if (sals
[i
].pc
== 0
2885 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2886 &func_bounds
[i
].low
,
2887 &func_bounds
[i
].high
) == 0)
2888 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2893 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2894 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2895 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2899 frame
= find_relative_frame (frame
, &level
);
2902 while (!found
&& level
== 0);
2910 /* Implements the dbx 'func' command. */
2913 func_command (const char *arg
, int from_tty
)
2918 struct frame_info
*frame
= find_frame_for_function (arg
);
2920 error (_("'%s' not within current stack frame."), arg
);
2921 if (frame
!= get_selected_frame (NULL
))
2923 select_frame (frame
);
2924 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2928 /* The qcs command line flags for the "frame apply" commands. Keep
2929 this in sync with the "thread apply" commands. */
2931 using qcs_flag_option_def
2932 = gdb::option::flag_option_def
<qcs_flags
>;
2934 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2935 qcs_flag_option_def
{
2936 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2937 N_("Disables printing the frame location information."),
2940 qcs_flag_option_def
{
2941 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2942 N_("Print any error raised by COMMAND and continue."),
2945 qcs_flag_option_def
{
2946 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2947 N_("Silently ignore any errors or empty output produced by COMMAND."),
2951 /* Create an option_def_group array for all the "frame apply" options,
2952 with FLAGS and SET_BT_OPTS as context. */
2954 static inline std::array
<gdb::option::option_def_group
, 2>
2955 make_frame_apply_options_def_group (qcs_flags
*flags
,
2956 set_backtrace_options
*set_bt_opts
)
2959 { {fr_qcs_flags_option_defs
}, flags
},
2960 { {set_backtrace_option_defs
}, set_bt_opts
},
2964 /* Apply a GDB command to all stack frames, or a set of identified frames,
2965 or innermost COUNT frames.
2966 With a negative COUNT, apply command on outermost -COUNT frames.
2968 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2969 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2970 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2971 frame apply all -s p local_var_no_idea_in_which_frame
2972 If a frame has a local variable called
2973 local_var_no_idea_in_which_frame, print frame
2974 and value of local_var_no_idea_in_which_frame.
2975 frame apply all -s -q p local_var_no_idea_in_which_frame
2976 Same as before, but only print the variable value.
2977 frame apply level 2-5 0 4-7 -s p i = i + 1
2978 Adds 1 to the variable i in the specified frames.
2979 Note that i will be incremented twice in
2982 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2983 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2984 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2985 for error messages. */
2988 frame_apply_command_count (const char *which_command
,
2989 const char *cmd
, int from_tty
,
2990 struct frame_info
*trailing
, int count
)
2993 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2995 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2996 gdb::option::process_options
2997 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2999 validate_flags_qcs (which_command
, &flags
);
3001 if (cmd
== NULL
|| *cmd
== '\0')
3002 error (_("Please specify a command to apply on the selected frames"));
3004 /* The below will restore the current inferior/thread/frame.
3005 Usually, only the frame is effectively to be restored.
3006 But in case CMD switches of inferior/thread, better restore
3008 scoped_restore_current_thread restore_thread
;
3010 /* These options are handled quite deep in the unwind machinery, so
3011 we get to pass them down by swapping globals. */
3012 scoped_restore restore_set_backtrace_options
3013 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
3015 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
3022 std::string cmd_result
;
3024 /* In case CMD switches of inferior/thread/frame, the below
3025 restores the inferior/thread/frame. FI can then be
3026 set to the selected frame. */
3027 scoped_restore_current_thread restore_fi_current_frame
;
3029 cmd_result
= execute_command_to_string
3030 (cmd
, from_tty
, gdb_stdout
->term_out ());
3032 fi
= get_selected_frame (_("frame apply "
3033 "unable to get selected frame."));
3034 if (!flags
.silent
|| cmd_result
.length () > 0)
3037 print_stack_frame (fi
, 1, LOCATION
, 0);
3038 printf_filtered ("%s", cmd_result
.c_str ());
3041 catch (const gdb_exception_error
&ex
)
3043 fi
= get_selected_frame (_("frame apply "
3044 "unable to get selected frame."));
3048 print_stack_frame (fi
, 1, LOCATION
, 0);
3050 printf_filtered ("%s\n", ex
.what ());
3058 /* Completer for the "frame apply ..." commands. */
3061 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3063 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3064 if (gdb::option::complete_options
3065 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3068 complete_nested_command_line (tracker
, text
);
3071 /* Completer for the "frame apply" commands. */
3074 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3075 completion_tracker
&tracker
,
3076 const char *text
, const char */
*word*/
)
3078 /* Do this explicitly because there's an early return below. */
3079 tracker
.set_use_custom_word_point (true);
3081 number_or_range_parser
levels (text
);
3083 /* Skip the LEVEL list to find the options and command args. */
3086 while (!levels
.finished ())
3088 /* Call for effect. */
3089 levels
.get_number ();
3091 if (levels
.in_range ())
3092 levels
.skip_range ();
3095 catch (const gdb_exception_error
&ex
)
3097 /* get_number throws if it parses a negative number, for
3098 example. But a seemingly negative number may be the start of
3099 an option instead. */
3102 const char *cmd
= levels
.cur_tok ();
3106 /* No level list yet. */
3110 /* Check if we're past a valid LEVEL already. */
3111 if (levels
.finished ()
3112 && cmd
> text
&& !isspace (cmd
[-1]))
3115 /* We're past LEVELs, advance word point. */
3116 tracker
.advance_custom_word_point_by (cmd
- text
);
3119 frame_apply_completer (tracker
, text
);
3122 /* Completer for the "frame apply all" command. */
3125 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3126 completion_tracker
&tracker
,
3127 const char *text
, const char */
*word*/
)
3129 frame_apply_completer (tracker
, text
);
3132 /* Completer for the "frame apply COUNT" command. */
3135 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3136 completion_tracker
&tracker
,
3137 const char *text
, const char */
*word*/
)
3139 const char *cmd
= text
;
3141 int count
= get_number_trailer (&cmd
, 0);
3145 /* Check if we're past a valid COUNT already. */
3146 if (cmd
> text
&& !isspace (cmd
[-1]))
3149 /* We're past COUNT, advance word point. */
3150 tracker
.advance_custom_word_point_by (cmd
- text
);
3153 frame_apply_completer (tracker
, text
);
3156 /* Implementation of the "frame apply level" command. */
3159 frame_apply_level_command (const char *cmd
, int from_tty
)
3161 if (!target_has_stack ())
3162 error (_("No stack."));
3164 bool level_found
= false;
3165 const char *levels_str
= cmd
;
3166 number_or_range_parser
levels (levels_str
);
3168 /* Skip the LEVEL list to find the flags and command args. */
3169 while (!levels
.finished ())
3171 /* Call for effect. */
3172 levels
.get_number ();
3175 if (levels
.in_range ())
3176 levels
.skip_range ();
3180 error (_("Missing or invalid LEVEL... argument"));
3182 cmd
= levels
.cur_tok ();
3184 /* Redo the LEVELS parsing, but applying COMMAND. */
3185 levels
.init (levels_str
);
3186 while (!levels
.finished ())
3188 const int level_beg
= levels
.get_number ();
3191 if (levels
.in_range ())
3193 n_frames
= levels
.end_value () - level_beg
+ 1;
3194 levels
.skip_range ();
3199 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3200 leading_innermost_frame (level_beg
), n_frames
);
3204 /* Implementation of the "frame apply all" command. */
3207 frame_apply_all_command (const char *cmd
, int from_tty
)
3209 if (!target_has_stack ())
3210 error (_("No stack."));
3212 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3213 get_current_frame (), INT_MAX
);
3216 /* Implementation of the "frame apply" command. */
3219 frame_apply_command (const char* cmd
, int from_tty
)
3222 struct frame_info
*trailing
;
3224 if (!target_has_stack ())
3225 error (_("No stack."));
3228 error (_("Missing COUNT argument."));
3229 count
= get_number_trailer (&cmd
, 0);
3231 error (_("Invalid COUNT argument."));
3235 trailing
= trailing_outermost_frame (-count
);
3239 trailing
= get_current_frame ();
3241 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3245 /* Implementation of the "faas" command. */
3248 faas_command (const char *cmd
, int from_tty
)
3250 if (cmd
== NULL
|| *cmd
== '\0')
3251 error (_("Please specify a command to apply on all frames"));
3252 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3253 execute_command (expanded
.c_str (), from_tty
);
3257 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3258 matching frame can be found. */
3260 static struct frame_info
*
3261 find_frame_for_address (CORE_ADDR address
)
3264 struct frame_info
*fid
;
3266 id
= frame_id_build_wild (address
);
3268 /* If (s)he specifies the frame with an address, he deserves
3269 what (s)he gets. Still, give the highest one that matches.
3270 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3272 for (fid
= get_current_frame ();
3274 fid
= get_prev_frame (fid
))
3276 if (frame_id_eq (id
, get_frame_id (fid
)))
3278 struct frame_info
*prev_frame
;
3282 prev_frame
= get_prev_frame (fid
);
3284 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3296 /* Commands with a prefix of `frame apply'. */
3297 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3299 /* Commands with a prefix of `frame'. */
3300 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3302 /* Commands with a prefix of `select frame'. */
3303 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3305 /* Commands with a prefix of `info frame'. */
3306 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3308 void _initialize_stack ();
3310 _initialize_stack ()
3312 struct cmd_list_element
*cmd
;
3314 add_com ("return", class_stack
, return_command
, _("\
3315 Make selected stack frame return to its caller.\n\
3316 Control remains in the debugger, but when you continue\n\
3317 execution will resume in the frame above the one now selected.\n\
3318 If an argument is given, it is an expression for the value to return."));
3320 add_com ("up", class_stack
, up_command
, _("\
3321 Select and print stack frame that called this one.\n\
3322 An argument says how many frames up to go."));
3323 add_com ("up-silently", class_support
, up_silently_command
, _("\
3324 Same as the `up' command, but does not print anything.\n\
3325 This is useful in command scripts."));
3327 cmd_list_element
*down_cmd
3328 = add_com ("down", class_stack
, down_command
, _("\
3329 Select and print stack frame called by this one.\n\
3330 An argument says how many frames down to go."));
3331 add_com_alias ("do", down_cmd
, class_stack
, 1);
3332 add_com_alias ("dow", down_cmd
, class_stack
, 1);
3333 add_com ("down-silently", class_support
, down_silently_command
, _("\
3334 Same as the `down' command, but does not print anything.\n\
3335 This is useful in command scripts."));
3337 cmd_list_element
*frame_cmd_el
3338 = add_prefix_cmd ("frame", class_stack
,
3339 &frame_cmd
.base_command
, _("\
3340 Select and print a stack frame.\n\
3341 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3342 A single numerical argument specifies the frame to select."),
3343 &frame_cmd_list
, 1, &cmdlist
);
3344 add_com_alias ("f", frame_cmd_el
, class_stack
, 1);
3346 #define FRAME_APPLY_OPTION_HELP "\
3347 Prints the frame location information followed by COMMAND output.\n\
3349 By default, an error raised during the execution of COMMAND\n\
3350 aborts \"frame apply\".\n\
3355 const auto frame_apply_opts
3356 = make_frame_apply_options_def_group (nullptr, nullptr);
3358 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3359 Apply a command to a number of frames.\n\
3360 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3361 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3362 FRAME_APPLY_OPTION_HELP
),
3365 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3366 frame_apply_cmd_help
.c_str (),
3367 &frame_apply_cmd_list
, 1,
3369 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3371 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3372 Apply a command to all frames.\n\
3374 Usage: frame apply all [OPTION]... COMMAND\n"
3375 FRAME_APPLY_OPTION_HELP
),
3378 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3379 frame_apply_all_cmd_help
.c_str (),
3380 &frame_apply_cmd_list
);
3381 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3383 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3384 Apply a command to a list of frames.\n\
3386 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3387 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3388 FRAME_APPLY_OPTION_HELP
),
3391 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3392 frame_apply_level_cmd_help
.c_str (),
3393 &frame_apply_cmd_list
);
3394 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3396 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3397 Apply a command to all frames (ignoring errors and empty output).\n\
3398 Usage: faas [OPTION]... COMMAND\n\
3399 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3400 See \"help frame apply all\" for available options."));
3401 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3403 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3405 Select and print a stack frame by stack address.\n\
3407 Usage: frame address STACK-ADDRESS"),
3410 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3412 View a stack frame that might be outside the current backtrace.\n\
3414 Usage: frame view STACK-ADDRESS\n\
3415 frame view STACK-ADDRESS PC-ADDRESS"),
3418 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3420 Select and print a stack frame by function name.\n\
3422 Usage: frame function NAME\n\
3424 The innermost frame that visited function NAME is selected."),
3426 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3429 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3431 Select and print a stack frame by level.\n\
3433 Usage: frame level LEVEL"),
3436 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3437 &select_frame_cmd
.base_command
, _("\
3438 Select a stack frame without printing anything.\n\
3439 A single numerical argument specifies the frame to select."),
3440 &select_frame_cmd_list
, 1, &cmdlist
,
3441 &cli_suppress_notification
.user_selected_context
);
3443 add_cmd_suppress_notification ("address", class_stack
,
3444 &select_frame_cmd
.address
, _("\
3445 Select a stack frame by stack address.\n\
3447 Usage: select-frame address STACK-ADDRESS"),
3448 &select_frame_cmd_list
,
3449 &cli_suppress_notification
.user_selected_context
);
3452 add_cmd_suppress_notification ("view", class_stack
,
3453 &select_frame_cmd
.view
, _("\
3454 Select a stack frame that might be outside the current backtrace.\n\
3456 Usage: select-frame view STACK-ADDRESS\n\
3457 select-frame view STACK-ADDRESS PC-ADDRESS"),
3458 &select_frame_cmd_list
,
3459 &cli_suppress_notification
.user_selected_context
);
3461 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3462 &select_frame_cmd
.function
, _("\
3463 Select a stack frame by function name.\n\
3465 Usage: select-frame function NAME"),
3466 &select_frame_cmd_list
,
3467 &cli_suppress_notification
.user_selected_context
);
3468 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3470 add_cmd_suppress_notification ("level", class_stack
,
3471 &select_frame_cmd
.level
, _("\
3472 Select a stack frame by level.\n\
3474 Usage: select-frame level LEVEL"),
3475 &select_frame_cmd_list
,
3476 &cli_suppress_notification
.user_selected_context
);
3478 const auto backtrace_opts
3479 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3481 static std::string backtrace_help
3482 = gdb::option::build_help (_("\
3483 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3484 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3489 For backward compatibility, the following qualifiers are supported:\n\
3491 full - same as -full option.\n\
3492 no-filters - same as -no-filters option.\n\
3493 hide - same as -hide.\n\
3495 With a negative COUNT, print outermost -COUNT frames."),
3498 cmd_list_element
*backtrace_cmd
3499 = add_com ("backtrace", class_stack
, backtrace_command
,
3500 backtrace_help
.c_str ());
3501 set_cmd_completer_handle_brkchars (backtrace_cmd
, backtrace_command_completer
);
3503 add_com_alias ("bt", backtrace_cmd
, class_stack
, 0);
3505 add_com_alias ("where", backtrace_cmd
, class_stack
, 0);
3506 cmd_list_element
*info_stack_cmd
3507 = add_info ("stack", backtrace_command
,
3508 _("Backtrace of the stack, or innermost COUNT frames."));
3509 add_info_alias ("s", info_stack_cmd
, 1);
3511 cmd_list_element
*info_frame_cmd_el
3512 = add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3513 _("All about the selected stack frame.\n\
3514 With no arguments, displays information about the currently selected stack\n\
3515 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3516 the information is then printed about the specified frame."),
3517 &info_frame_cmd_list
, 1, &infolist
);
3518 add_info_alias ("f", info_frame_cmd_el
, 1);
3520 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3522 Print information about a stack frame selected by stack address.\n\
3524 Usage: info frame address STACK-ADDRESS"),
3525 &info_frame_cmd_list
);
3527 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3529 Print information about a stack frame outside the current backtrace.\n\
3531 Usage: info frame view STACK-ADDRESS\n\
3532 info frame view STACK-ADDRESS PC-ADDRESS"),
3533 &info_frame_cmd_list
);
3535 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3537 Print information about a stack frame selected by function name.\n\
3539 Usage: info frame function NAME"),
3540 &info_frame_cmd_list
);
3541 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3543 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3545 Print information about a stack frame selected by level.\n\
3547 Usage: info frame level LEVEL"),
3548 &info_frame_cmd_list
);
3550 cmd
= add_info ("locals", info_locals_command
,
3551 info_print_args_help (_("\
3552 All local variables of current stack frame or those matching REGEXPs.\n\
3553 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3554 Prints the local variables of the current stack frame.\n"),
3555 _("local variables"),
3557 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3558 cmd
= add_info ("args", info_args_command
,
3559 info_print_args_help (_("\
3560 All argument variables of current stack frame or those matching REGEXPs.\n\
3561 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3562 Prints the argument variables of the current stack frame.\n"),
3563 _("argument variables"),
3565 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3568 add_com ("func", class_stack
, func_command
, _("\
3569 Select the stack frame that contains NAME.\n\
3570 Usage: func NAME"));
3572 /* Install "set print raw frame-arguments", a deprecated spelling of
3573 "set print raw-frame-arguments". */
3574 set_show_commands set_show_frame_args
3575 = add_setshow_boolean_cmd
3576 ("frame-arguments", no_class
,
3577 &user_frame_print_options
.print_raw_frame_arguments
,
3579 Set whether to print frame arguments in raw form."), _("\
3580 Show whether to print frame arguments in raw form."), _("\
3581 If set, frame arguments are printed in raw form, bypassing any\n\
3582 pretty-printers for that value."),
3584 &setprintrawlist
, &showprintrawlist
);
3585 deprecate_cmd (set_show_frame_args
.set
, "set print raw-frame-arguments");
3587 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3588 &disassemble_next_line
, _("\
3589 Set whether to disassemble next source line or insn when execution stops."),
3591 Show whether to disassemble next source line or insn when execution stops."),
3593 If ON, GDB will display disassembly of the next source line, in addition\n\
3594 to displaying the source line itself. If the next source line cannot\n\
3595 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3596 will display disassembly of next instruction instead of showing the\n\
3598 If AUTO, display disassembly of next instruction only if the source line\n\
3599 cannot be displayed.\n\
3600 If OFF (which is the default), never display the disassembly of the next\n\
3603 show_disassemble_next_line
,
3604 &setlist
, &showlist
);
3605 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3607 gdb::option::add_setshow_cmds_for_options
3608 (class_stack
, &user_frame_print_options
,
3609 frame_print_option_defs
, &setprintlist
, &showprintlist
);