1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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 fprintf_symbol_filtered (&stb
, arg
->sym
->print_name (),
431 arg
->sym
->language (), DMGL_PARAMS
| DMGL_ANSI
);
432 if (arg
->entry_kind
== print_entry_values_compact
)
434 /* It is OK to provide invalid MI-like stream as with
435 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
438 fprintf_symbol_filtered (&stb
, arg
->sym
->print_name (),
439 arg
->sym
->language (),
440 DMGL_PARAMS
| DMGL_ANSI
);
442 if (arg
->entry_kind
== print_entry_values_only
443 || arg
->entry_kind
== print_entry_values_compact
)
445 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
446 annotate_arg_name_end ();
450 if (!arg
->val
&& !arg
->error
)
456 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
457 style
= metadata_style
.style ();
463 const struct language_defn
*language
;
464 struct value_print_options vp_opts
;
466 /* Avoid value_print because it will deref ref parameters. We
467 just want to print their addresses. Print ??? for args whose
468 address we do not know. We pass 2 as "recurse" to val_print
469 because our standard indentation here is 4 spaces, and
470 val_print indents 2 for each recurse. */
472 annotate_arg_value (value_type (arg
->val
));
474 /* Use the appropriate language to display our symbol, unless the
475 user forced the language to a specific language. */
476 if (language_mode
== language_mode_auto
)
477 language
= language_def (arg
->sym
->language ());
479 language
= current_language
;
481 get_no_prettyformat_print_options (&vp_opts
);
482 vp_opts
.deref_ref
= 1;
483 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
485 /* True in "summary" mode, false otherwise. */
487 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
489 common_val_print_checked (arg
->val
, &stb
, 2, &vp_opts
, language
);
491 catch (const gdb_exception_error
&except
)
493 stb
.printf (_("<error reading variable: %s>"),
495 style
= metadata_style
.style ();
500 uiout
->field_stream ("value", stb
, style
);
503 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
504 responsible for xfree of ARGP->ERROR. This function never throws an
508 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
509 struct frame_arg
*argp
)
517 argp
->val
= read_var_value (sym
, NULL
, frame
);
519 catch (const gdb_exception_error
&except
)
521 argp
->error
.reset (xstrdup (except
.what ()));
525 /* Read in inferior function parameter SYM at FRAME into ARGP. This
526 function never throws an exception. */
529 read_frame_arg (const frame_print_options
&fp_opts
,
530 symbol
*sym
, frame_info
*frame
,
531 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
533 struct value
*val
= NULL
, *entryval
= NULL
;
534 char *val_error
= NULL
, *entryval_error
= NULL
;
537 if (fp_opts
.print_entry_values
!= print_entry_values_only
538 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
542 val
= read_var_value (sym
, NULL
, frame
);
544 catch (const gdb_exception_error
&except
)
546 val_error
= (char *) alloca (except
.message
->size () + 1);
547 strcpy (val_error
, except
.what ());
551 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
552 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
553 && fp_opts
.print_entry_values
!= print_entry_values_no
554 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
555 || !val
|| value_optimized_out (val
)))
559 const struct symbol_computed_ops
*ops
;
561 ops
= SYMBOL_COMPUTED_OPS (sym
);
562 entryval
= ops
->read_variable_at_entry (sym
, frame
);
564 catch (const gdb_exception_error
&except
)
566 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
568 entryval_error
= (char *) alloca (except
.message
->size () + 1);
569 strcpy (entryval_error
, except
.what ());
573 if (entryval
!= NULL
&& value_optimized_out (entryval
))
576 if (fp_opts
.print_entry_values
== print_entry_values_compact
577 || fp_opts
.print_entry_values
== print_entry_values_default
)
579 /* For MI do not try to use print_entry_values_compact for ARGP. */
581 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
583 struct type
*type
= value_type (val
);
585 if (value_lazy (val
))
586 value_fetch_lazy (val
);
587 if (value_lazy (entryval
))
588 value_fetch_lazy (entryval
);
590 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
592 /* Initialize it just to avoid a GCC false warning. */
593 struct value
*val_deref
= NULL
, *entryval_deref
;
595 /* DW_AT_call_value does match with the current
596 value. If it is a reference still try to verify if
597 dereferenced DW_AT_call_data_value does not differ. */
601 struct type
*type_deref
;
603 val_deref
= coerce_ref (val
);
604 if (value_lazy (val_deref
))
605 value_fetch_lazy (val_deref
);
606 type_deref
= value_type (val_deref
);
608 entryval_deref
= coerce_ref (entryval
);
609 if (value_lazy (entryval_deref
))
610 value_fetch_lazy (entryval_deref
);
612 /* If the reference addresses match but dereferenced
613 content does not match print them. */
615 && value_contents_eq (val_deref
, 0,
617 TYPE_LENGTH (type_deref
)))
620 catch (const gdb_exception_error
&except
)
622 /* If the dereferenced content could not be
623 fetched do not display anything. */
624 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
626 else if (except
.message
!= NULL
)
629 = (char *) alloca (except
.message
->size () + 1);
630 strcpy (entryval_error
, except
.what ());
634 /* Value was not a reference; and its content matches. */
635 if (val
== val_deref
)
643 /* Try to remove possibly duplicate error message for ENTRYARGP even
646 if (val_error
&& entryval_error
647 && strcmp (val_error
, entryval_error
) == 0)
649 entryval_error
= NULL
;
651 /* Do not se VAL_EQUAL as the same error message may be shown for
652 the entry value even if no entry values are present in the
658 if (entryval
== NULL
)
660 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
662 gdb_assert (val
== NULL
);
666 val
= read_var_value (sym
, NULL
, frame
);
668 catch (const gdb_exception_error
&except
)
670 val_error
= (char *) alloca (except
.message
->size () + 1);
671 strcpy (val_error
, except
.what ());
674 if (fp_opts
.print_entry_values
== print_entry_values_only
675 || fp_opts
.print_entry_values
== print_entry_values_both
676 || (fp_opts
.print_entry_values
== print_entry_values_preferred
677 && (!val
|| value_optimized_out (val
))))
679 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
680 entryval_error
= NULL
;
683 if ((fp_opts
.print_entry_values
== print_entry_values_compact
684 || fp_opts
.print_entry_values
== print_entry_values_if_needed
685 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
686 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
694 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
695 if (!val
&& !val_error
)
696 argp
->entry_kind
= print_entry_values_only
;
697 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
698 || fp_opts
.print_entry_values
== print_entry_values_default
)
701 argp
->entry_kind
= print_entry_values_compact
;
702 gdb_assert (!current_uiout
->is_mi_like_p ());
705 argp
->entry_kind
= print_entry_values_no
;
707 entryargp
->sym
= sym
;
708 entryargp
->val
= entryval
;
709 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
710 if (!entryval
&& !entryval_error
)
711 entryargp
->entry_kind
= print_entry_values_no
;
713 entryargp
->entry_kind
= print_entry_values_only
;
716 /* Print the arguments of frame FRAME on STREAM, given the function
717 FUNC running in that frame (as a symbol), where NUM is the number
718 of arguments according to the stack frame (or -1 if the number of
719 arguments is unknown). */
721 /* Note that currently the "number of arguments according to the
722 stack frame" is only known on VAX where i refers to the "number of
723 ints of arguments according to the stack frame". */
726 print_frame_args (const frame_print_options
&fp_opts
,
727 struct symbol
*func
, struct frame_info
*frame
,
728 int num
, struct ui_file
*stream
)
730 struct ui_out
*uiout
= current_uiout
;
732 /* Offset of next stack argument beyond the one we have seen that is
733 at the highest offset, or -1 if we haven't come to a stack
735 long highest_offset
= -1;
736 /* Number of ints of arguments that we have printed so far. */
737 int args_printed
= 0;
738 /* True if we should print arg names. If false, we only indicate
739 the presence of arguments by printing ellipsis. */
741 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
742 /* True if we should print arguments, false otherwise. */
745 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
747 /* Temporarily change the selected frame to the given FRAME.
748 This allows routines that rely on the selected frame instead
749 of being given a frame as parameter to use the correct frame. */
750 scoped_restore_selected_frame restore_selected_frame
;
751 select_frame (frame
);
755 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
756 struct block_iterator iter
;
759 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
761 struct frame_arg arg
, entryarg
;
765 /* Keep track of the highest stack argument offset seen, and
766 skip over any kinds of symbols we don't care about. */
768 if (!SYMBOL_IS_ARGUMENT (sym
))
778 switch (SYMBOL_CLASS (sym
))
783 long current_offset
= SYMBOL_VALUE (sym
);
784 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
786 /* Compute address of next argument by adding the size of
787 this argument and rounding to an int boundary. */
789 ((current_offset
+ arg_size
+ sizeof (int) - 1)
790 & ~(sizeof (int) - 1));
792 /* If this is the highest offset seen yet, set
794 if (highest_offset
== -1
795 || (current_offset
> highest_offset
))
796 highest_offset
= current_offset
;
798 /* Add the number of ints we're about to print to
800 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
803 /* We care about types of symbols, but don't need to
804 keep track of stack offsets in them. */
806 case LOC_REGPARM_ADDR
:
808 case LOC_OPTIMIZED_OUT
:
813 /* We have to look up the symbol because arguments can have
814 two entries (one a parameter, one a local) and the one we
815 want is the local, which lookup_symbol will find for us.
816 This includes gcc1 (not gcc2) on SPARC when passing a
817 small structure and gcc2 when the argument type is float
818 and it is passed as a double and converted to float by
819 the prologue (in the latter case the type of the LOC_ARG
820 symbol is double and the type of the LOC_LOCAL symbol is
822 /* But if the parameter name is null, don't try it. Null
823 parameter names occur on the RS/6000, for traceback
824 tables. FIXME, should we even print them? */
826 if (*sym
->linkage_name ())
830 nsym
= lookup_symbol_search_name (sym
->search_name (),
831 b
, VAR_DOMAIN
).symbol
;
832 gdb_assert (nsym
!= NULL
);
833 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
834 && !SYMBOL_IS_ARGUMENT (nsym
))
836 /* There is a LOC_ARG/LOC_REGISTER pair. This means
837 that it was passed on the stack and loaded into a
838 register, or passed in a register and stored in a
839 stack slot. GDB 3.x used the LOC_ARG; GDB
840 4.0-4.11 used the LOC_REGISTER.
842 Reasons for using the LOC_ARG:
844 (1) Because find_saved_registers may be slow for
847 (2) Because registers are often re-used and stack
848 slots rarely (never?) are. Therefore using
849 the stack slot is much less likely to print
852 Reasons why we might want to use the LOC_REGISTER:
854 (1) So that the backtrace prints the same value
855 as "print foo". I see no compelling reason
856 why this needs to be the case; having the
857 backtrace print the value which was passed
858 in, and "print foo" print the value as
859 modified within the called function, makes
862 Additional note: It might be nice if "info args"
863 displayed both values.
865 One more note: There is a case with SPARC
866 structure passing where we need to use the
867 LOC_REGISTER, but this is dealt with by creating
868 a single LOC_REGPARM in symbol reading. */
870 /* Leave sym (the LOC_ARG) alone. */
877 /* Print the current arg. */
880 uiout
->wrap_hint (" ");
885 arg
.entry_kind
= print_entry_values_no
;
887 entryarg
.entry_kind
= print_entry_values_no
;
890 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
892 if (arg
.entry_kind
!= print_entry_values_only
)
893 print_frame_arg (fp_opts
, &arg
);
895 if (entryarg
.entry_kind
!= print_entry_values_no
)
897 if (arg
.entry_kind
!= print_entry_values_only
)
900 uiout
->wrap_hint (" ");
903 print_frame_arg (fp_opts
, &entryarg
);
910 /* Don't print nameless args in situations where we don't know
911 enough about the stack to find them. */
916 if (highest_offset
== -1)
917 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
919 start
= highest_offset
;
921 if (!print_names
&& !first
&& num
> 0)
924 print_frame_nameless_args (frame
, start
, num
- args_printed
,
929 /* Set the current source and line to the location given by frame
930 FRAME, if possible. When CENTER is true, adjust so the relevant
931 line is in the center of the next 'list'. */
934 set_current_sal_from_frame (struct frame_info
*frame
)
936 symtab_and_line sal
= find_frame_sal (frame
);
937 if (sal
.symtab
!= NULL
)
938 set_current_source_symtab_and_line (sal
);
941 /* If ON, GDB will display disassembly of the next source line when
942 execution of the program being debugged stops.
943 If AUTO (which is the default), or there's no line info to determine
944 the source line of the next instruction, display disassembly of next
945 instruction instead. */
947 static enum auto_boolean disassemble_next_line
;
950 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
951 struct cmd_list_element
*c
,
954 fprintf_filtered (file
,
955 _("Debugger's willingness to use "
956 "disassemble-next-line is %s.\n"),
960 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
961 because it will be broken by filter sometime. */
964 do_gdb_disassembly (struct gdbarch
*gdbarch
,
965 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
970 gdb_disassembly (gdbarch
, current_uiout
,
971 DISASSEMBLY_RAW_INSN
, how_many
,
974 catch (const gdb_exception_error
&exception
)
976 /* If an exception was thrown while doing the disassembly, print
977 the error message, to give the user a clue of what happened. */
978 exception_print (gdb_stderr
, exception
);
982 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
983 Value not present indicates to the caller to use default values
984 specific to the command being executed. */
986 static gdb::optional
<enum print_what
>
987 print_frame_info_to_print_what (const char *print_frame_info
)
989 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
990 if (print_frame_info
== print_frame_info_choices
[i
])
991 return print_frame_info_print_what
[i
];
993 internal_error (__FILE__
, __LINE__
,
994 "Unexpected print frame-info value `%s'.",
998 /* Print the PC from FRAME, plus any flags, to UIOUT. */
1001 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info
*frame
,
1004 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1006 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
1007 if (!flags
.empty ())
1010 uiout
->field_string ("addr_flags", flags
);
1018 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
1021 = print_frame_info_to_print_what
1022 (user_frame_print_options
.print_frame_info
);
1025 /* Print information about frame FRAME. The output is format according
1026 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
1027 PRINT_WHAT, see enum print_what comments in frame.h.
1028 Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1029 != print_frame_info_auto.
1031 Used in "where" output, and to emit breakpoint or step
1035 print_frame_info (const frame_print_options
&fp_opts
,
1036 frame_info
*frame
, int print_level
,
1037 enum print_what print_what
, int print_args
,
1038 int set_current_sal
)
1040 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1043 struct ui_out
*uiout
= current_uiout
;
1045 if (!current_uiout
->is_mi_like_p ()
1046 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
1048 /* Use the specific frame information desired by the user. */
1049 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
1052 if (get_frame_type (frame
) == DUMMY_FRAME
1053 || get_frame_type (frame
) == SIGTRAMP_FRAME
1054 || get_frame_type (frame
) == ARCH_FRAME
)
1056 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1058 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1059 gdbarch
, get_frame_pc (frame
));
1061 /* Do this regardless of SOURCE because we don't have any source
1062 to list for this frame. */
1066 uiout
->field_fmt_signed (2, ui_left
, "level",
1067 frame_relative_level (frame
));
1069 if (uiout
->is_mi_like_p ())
1071 annotate_frame_address ();
1072 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1073 annotate_frame_address_end ();
1076 if (get_frame_type (frame
) == DUMMY_FRAME
)
1078 annotate_function_call ();
1079 uiout
->field_string ("func", "<function called from gdb>",
1080 metadata_style
.style ());
1082 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1084 annotate_signal_handler_caller ();
1085 uiout
->field_string ("func", "<signal handler called>",
1086 metadata_style
.style ());
1088 else if (get_frame_type (frame
) == ARCH_FRAME
)
1090 uiout
->field_string ("func", "<cross-architecture call>",
1091 metadata_style
.style ());
1094 annotate_frame_end ();
1096 /* If disassemble-next-line is set to auto or on output the next
1098 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1099 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1100 do_gdb_disassembly (get_frame_arch (frame
), 1,
1101 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1106 /* If FRAME is not the innermost frame, that normally means that
1107 FRAME->pc points to *after* the call instruction, and we want to
1108 get the line containing the call, never the next line. But if
1109 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1110 next frame was not entered as the result of a call, and we want
1111 to get the line containing FRAME->pc. */
1112 symtab_and_line sal
= find_frame_sal (frame
);
1114 location_print
= (print_what
== LOCATION
1115 || print_what
== SRC_AND_LOC
1116 || print_what
== LOC_AND_ADDRESS
1117 || print_what
== SHORT_LOCATION
);
1118 if (location_print
|| !sal
.symtab
)
1119 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1121 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1123 /* If disassemble-next-line is set to auto or on and doesn't have
1124 the line debug messages for $pc, output the next instruction. */
1125 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1126 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1127 && source_print
&& !sal
.symtab
)
1128 do_gdb_disassembly (get_frame_arch (frame
), 1,
1129 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1131 if (source_print
&& sal
.symtab
)
1133 int mid_statement
= ((print_what
== SRC_LINE
)
1134 && frame_show_address (frame
, sal
));
1135 if (annotation_level
> 0
1136 && annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1137 get_frame_pc (frame
)))
1139 /* The call to ANNOTATE_SOURCE_LINE already printed the
1140 annotation for this source line, so we avoid the two cases
1141 below and do not print the actual source line. The
1142 documentation for annotations makes it clear that the source
1143 line annotation is printed __instead__ of printing the source
1144 line, not as well as.
1146 However, if we fail to print the source line, which usually
1147 means either the source file is missing, or the requested
1148 line is out of range of the file, then we don't print the
1149 source annotation, and will pass through the "normal" print
1150 source line code below, the expectation is that this code
1151 will print an appropriate error. */
1153 else if (deprecated_print_frame_info_listing_hook
)
1154 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1158 struct value_print_options opts
;
1160 get_user_print_options (&opts
);
1161 /* We used to do this earlier, but that is clearly
1162 wrong. This function is used by many different
1163 parts of gdb, including normal_stop in infrun.c,
1164 which uses this to print out the current PC
1165 when we stepi/nexti into the middle of a source
1166 line. Only the command line really wants this
1167 behavior. Other UIs probably would like the
1168 ability to decide for themselves if it is desired. */
1169 if (opts
.addressprint
&& mid_statement
)
1171 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1175 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1178 /* If disassemble-next-line is set to on and there is line debug
1179 messages, output assembly codes for next line. */
1180 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1181 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1184 if (set_current_sal
)
1188 if (get_frame_pc_if_available (frame
, &pc
))
1189 last_displayed_symtab_info
.set (sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1191 last_displayed_symtab_info
.invalidate ();
1194 annotate_frame_end ();
1196 gdb_flush (gdb_stdout
);
1202 clear_last_displayed_sal (void)
1204 last_displayed_symtab_info
.invalidate ();
1210 last_displayed_sal_is_valid (void)
1212 return last_displayed_symtab_info
.is_valid ();
1217 struct program_space
*
1218 get_last_displayed_pspace (void)
1220 return last_displayed_symtab_info
.pspace ();
1226 get_last_displayed_addr (void)
1228 return last_displayed_symtab_info
.address ();
1234 get_last_displayed_symtab (void)
1236 return last_displayed_symtab_info
.symtab ();
1242 get_last_displayed_line (void)
1244 return last_displayed_symtab_info
.line ();
1250 get_last_displayed_sal ()
1252 symtab_and_line sal
;
1254 if (last_displayed_symtab_info
.is_valid ())
1256 sal
.pspace
= last_displayed_symtab_info
.pspace ();
1257 sal
.pc
= last_displayed_symtab_info
.address ();
1258 sal
.symtab
= last_displayed_symtab_info
.symtab ();
1259 sal
.line
= last_displayed_symtab_info
.line ();
1266 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1267 corresponding to FRAME. */
1269 gdb::unique_xmalloc_ptr
<char>
1270 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1271 struct symbol
**funcp
)
1273 struct symbol
*func
;
1274 gdb::unique_xmalloc_ptr
<char> funname
;
1276 *funlang
= language_unknown
;
1280 func
= get_frame_function (frame
);
1283 const char *print_name
= func
->print_name ();
1285 *funlang
= func
->language ();
1288 if (*funlang
== language_cplus
)
1290 /* It seems appropriate to use print_name() here,
1291 to display the demangled name that we already have
1292 stored in the symbol table, but we stored a version
1293 with DMGL_PARAMS turned on, and here we don't want to
1294 display parameters. So remove the parameters. */
1295 funname
= cp_remove_params (print_name
);
1298 /* If we didn't hit the C++ case above, set *funname
1300 if (funname
== NULL
)
1301 funname
.reset (xstrdup (print_name
));
1305 struct bound_minimal_symbol msymbol
;
1308 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1311 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1312 if (msymbol
.minsym
!= NULL
)
1314 funname
.reset (xstrdup (msymbol
.minsym
->print_name ()));
1315 *funlang
= msymbol
.minsym
->language ();
1323 print_frame (const frame_print_options
&fp_opts
,
1324 frame_info
*frame
, int print_level
,
1325 enum print_what print_what
, int print_args
,
1326 struct symtab_and_line sal
)
1328 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1329 struct ui_out
*uiout
= current_uiout
;
1330 enum language funlang
= language_unknown
;
1331 struct value_print_options opts
;
1332 struct symbol
*func
;
1336 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1338 gdb::unique_xmalloc_ptr
<char> funname
1339 = find_frame_funname (frame
, &funlang
, &func
);
1341 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1345 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1350 uiout
->field_fmt_signed (2, ui_left
, "level",
1351 frame_relative_level (frame
));
1353 get_user_print_options (&opts
);
1354 if (opts
.addressprint
)
1356 || frame_show_address (frame
, sal
)
1357 || print_what
== LOC_AND_ADDRESS
)
1359 annotate_frame_address ();
1361 print_pc (uiout
, gdbarch
, frame
, pc
);
1363 uiout
->field_string ("addr", "<unavailable>",
1364 metadata_style
.style ());
1365 annotate_frame_address_end ();
1366 uiout
->text (" in ");
1368 annotate_frame_function_name ();
1371 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1372 funlang
, DMGL_ANSI
);
1373 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1374 uiout
->wrap_hint (" ");
1375 annotate_frame_args ();
1382 if (gdbarch_frame_num_args_p (gdbarch
))
1384 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1385 gdb_assert (numargs
>= 0);
1391 ui_out_emit_list
list_emitter (uiout
, "args");
1394 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1396 catch (const gdb_exception_error
&e
)
1400 /* FIXME: ARGS must be a list. If one argument is a string it
1401 will have " that will not be properly escaped. */
1406 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1408 const char *filename_display
;
1410 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1411 annotate_frame_source_begin ();
1412 uiout
->wrap_hint (" ");
1413 uiout
->text (" at ");
1414 annotate_frame_source_file ();
1415 uiout
->field_string ("file", filename_display
,
1416 file_name_style
.style ());
1417 if (uiout
->is_mi_like_p ())
1419 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1421 uiout
->field_string ("fullname", fullname
);
1423 annotate_frame_source_file_end ();
1425 annotate_frame_source_line ();
1426 uiout
->field_signed ("line", sal
.line
);
1427 annotate_frame_source_end ();
1430 if (print_what
!= SHORT_LOCATION
1431 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1433 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1434 get_frame_pc (frame
));
1438 annotate_frame_where ();
1439 uiout
->wrap_hint (" ");
1440 uiout
->text (" from ");
1441 uiout
->field_string ("from", lib
, file_name_style
.style ());
1444 if (uiout
->is_mi_like_p ())
1445 uiout
->field_string ("arch",
1446 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1453 /* Completion function for "frame function", "info frame function", and
1454 "select-frame function" commands. */
1457 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1458 completion_tracker
&tracker
,
1459 const char *text
, const char *word
)
1461 /* This is used to complete function names within a stack. It would be
1462 nice if we only offered functions that were actually in the stack.
1463 However, this would mean unwinding the stack to completion, which
1464 could take too long, or on a corrupted stack, possibly not end.
1465 Instead, we offer all symbol names as a safer choice. */
1466 collect_symbol_completion_matches (tracker
,
1467 complete_symbol_mode::EXPRESSION
,
1468 symbol_name_match_type::EXPRESSION
,
1472 /* Core of all the "info frame" sub-commands. Print information about a
1473 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1474 frame specification, they just entered 'info frame'. If the user did
1475 provide a frame specification (for example 'info frame 0', 'info frame
1476 level 1') then SELECTED_FRAME_P will be false. */
1479 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1481 struct symbol
*func
;
1483 struct frame_info
*calling_frame_info
;
1485 const char *funname
= 0;
1486 enum language funlang
= language_unknown
;
1487 const char *pc_regname
;
1488 struct gdbarch
*gdbarch
;
1491 /* Initialize it to avoid "may be used uninitialized" warning. */
1492 CORE_ADDR caller_pc
= 0;
1493 int caller_pc_p
= 0;
1495 gdbarch
= get_frame_arch (fi
);
1497 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1498 is not a good name. */
1499 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1500 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1501 easily not match that of the internal value returned by
1503 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1505 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1506 architectures will often have a hardware register called "pc",
1507 and that register's value, again, can easily not match
1511 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1512 func
= get_frame_function (fi
);
1513 symtab_and_line sal
= find_frame_sal (fi
);
1515 gdb::unique_xmalloc_ptr
<char> func_only
;
1518 funname
= func
->print_name ();
1519 funlang
= func
->language ();
1520 if (funlang
== language_cplus
)
1522 /* It seems appropriate to use print_name() here,
1523 to display the demangled name that we already have
1524 stored in the symbol table, but we stored a version
1525 with DMGL_PARAMS turned on, and here we don't want to
1526 display parameters. So remove the parameters. */
1527 func_only
= cp_remove_params (funname
);
1530 funname
= func_only
.get ();
1533 else if (frame_pc_p
)
1535 struct bound_minimal_symbol msymbol
;
1537 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1538 if (msymbol
.minsym
!= NULL
)
1540 funname
= msymbol
.minsym
->print_name ();
1541 funlang
= msymbol
.minsym
->language ();
1544 calling_frame_info
= get_prev_frame (fi
);
1546 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1548 printf_filtered (_("Stack level %d, frame at "),
1549 frame_relative_level (fi
));
1553 printf_filtered (_("Stack frame at "));
1555 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1556 printf_filtered (":\n");
1557 printf_filtered (" %s = ", pc_regname
);
1559 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1561 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1566 printf_filtered (" in ");
1567 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1568 DMGL_ANSI
| DMGL_PARAMS
);
1574 styled_string (file_name_style
.style (),
1575 symtab_to_filename_for_display (sal
.symtab
)),
1577 puts_filtered ("; ");
1579 printf_filtered ("saved %s = ", pc_regname
);
1581 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1582 val_print_not_saved (gdb_stdout
);
1587 caller_pc
= frame_unwind_caller_pc (fi
);
1590 catch (const gdb_exception_error
&ex
)
1594 case NOT_AVAILABLE_ERROR
:
1595 val_print_unavailable (gdb_stdout
);
1597 case OPTIMIZED_OUT_ERROR
:
1598 val_print_not_saved (gdb_stdout
);
1601 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1610 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1611 printf_filtered ("\n");
1613 if (calling_frame_info
== NULL
)
1615 enum unwind_stop_reason reason
;
1617 reason
= get_frame_unwind_stop_reason (fi
);
1618 if (reason
!= UNWIND_NO_REASON
)
1619 printf_filtered (_(" Outermost frame: %s\n"),
1620 frame_stop_reason_string (fi
));
1622 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1623 puts_filtered (" tail call frame");
1624 else if (get_frame_type (fi
) == INLINE_FRAME
)
1625 printf_filtered (" inlined into frame %d",
1626 frame_relative_level (get_prev_frame (fi
)));
1629 printf_filtered (" called by frame at ");
1630 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1633 if (get_next_frame (fi
) && calling_frame_info
)
1634 puts_filtered (",");
1636 if (get_next_frame (fi
))
1638 printf_filtered (" caller of frame at ");
1639 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1642 if (get_next_frame (fi
) || calling_frame_info
)
1643 puts_filtered ("\n");
1646 printf_filtered (" source language %s.\n",
1647 language_str (s
->language
));
1650 /* Address of the argument list for this frame, or 0. */
1651 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1652 /* Number of args for this frame, or -1 if unknown. */
1656 printf_filtered (" Arglist at unknown address.\n");
1659 printf_filtered (" Arglist at ");
1660 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1661 printf_filtered (",");
1663 if (!gdbarch_frame_num_args_p (gdbarch
))
1666 puts_filtered (" args: ");
1670 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1671 gdb_assert (numargs
>= 0);
1673 puts_filtered (" no args.");
1674 else if (numargs
== 1)
1675 puts_filtered (" 1 arg: ");
1677 printf_filtered (" %d args: ", numargs
);
1679 print_frame_args (user_frame_print_options
,
1680 func
, fi
, numargs
, gdb_stdout
);
1681 puts_filtered ("\n");
1685 /* Address of the local variables for this frame, or 0. */
1686 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1689 printf_filtered (" Locals at unknown address,");
1692 printf_filtered (" Locals at ");
1693 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1694 printf_filtered (",");
1698 /* Print as much information as possible on the location of all the
1704 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1706 /* The sp is special; what's displayed isn't the save address, but
1707 the value of the previous frame's sp. This is a legacy thing,
1708 at one stage the frame cached the previous frame's SP instead
1709 of its address, hence it was easiest to just display the cached
1713 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1714 gdb_assert (value
!= NULL
);
1716 if (!value_optimized_out (value
) && value_entirely_available (value
))
1718 if (VALUE_LVAL (value
) == not_lval
)
1721 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1722 int sp_size
= register_size (gdbarch
, sp_regnum
);
1724 sp
= extract_unsigned_integer (value_contents_all (value
),
1725 sp_size
, byte_order
);
1727 printf_filtered (" Previous frame's sp is ");
1728 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1729 printf_filtered ("\n");
1731 else if (VALUE_LVAL (value
) == lval_memory
)
1733 printf_filtered (" Previous frame's sp at ");
1734 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1736 printf_filtered ("\n");
1738 else if (VALUE_LVAL (value
) == lval_register
)
1740 printf_filtered (" Previous frame's sp in %s\n",
1741 gdbarch_register_name (gdbarch
,
1742 VALUE_REGNUM (value
)));
1745 release_value (value
);
1748 /* else keep quiet. */
1752 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1753 for (i
= 0; i
< numregs
; i
++)
1755 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1757 enum lval_type lval
;
1763 /* Find out the location of the saved register without
1764 fetching the corresponding value. */
1765 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1766 &lval
, &addr
, &realnum
, NULL
);
1767 /* For moment, only display registers that were saved on the
1769 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1772 puts_filtered (" Saved registers:\n ");
1774 puts_filtered (",");
1776 printf_filtered (" %s at ",
1777 gdbarch_register_name (gdbarch
, i
));
1778 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1782 if (count
|| need_nl
)
1783 puts_filtered ("\n");
1787 /* Return the innermost frame at level LEVEL. */
1789 static struct frame_info
*
1790 leading_innermost_frame (int level
)
1792 struct frame_info
*leading
;
1794 leading
= get_current_frame ();
1796 gdb_assert (level
>= 0);
1798 while (leading
!= nullptr && level
)
1801 leading
= get_prev_frame (leading
);
1808 /* Return the starting frame needed to handle COUNT outermost frames. */
1810 static struct frame_info
*
1811 trailing_outermost_frame (int count
)
1813 struct frame_info
*current
;
1814 struct frame_info
*trailing
;
1816 trailing
= get_current_frame ();
1818 gdb_assert (count
> 0);
1821 while (current
!= nullptr && count
--)
1824 current
= get_prev_frame (current
);
1827 /* Will stop when CURRENT reaches the top of the stack.
1828 TRAILING will be COUNT below it. */
1829 while (current
!= nullptr)
1832 trailing
= get_prev_frame (trailing
);
1833 current
= get_prev_frame (current
);
1839 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1843 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1845 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1847 if (get_selected_frame_if_set () != prev_frame
)
1848 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1854 select_frame_for_mi (struct frame_info
*fi
)
1856 select_frame_command_core (fi
, false /* Ignored. */);
1859 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1860 means we change frame send out a change notification (otherwise, just
1861 reprint the current frame summary). */
1864 frame_command_core (struct frame_info
*fi
, bool ignored
)
1866 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1869 if (get_selected_frame_if_set () != prev_frame
)
1870 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1872 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1875 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1876 common set of sub-commands that allow a specific frame to be selected.
1877 All of the sub-command functions are static methods within this class
1878 template which is then instantiated below. The template parameter is a
1879 callback used to implement the functionality of the base command
1880 ('frame', 'select-frame', or 'info frame').
1882 In the template parameter FI is the frame being selected. The
1883 SELECTED_FRAME_P flag is true if the frame being selected was done by
1884 default, which happens when the user uses the base command with no
1885 arguments. For example the commands 'info frame', 'select-frame',
1886 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1887 SELECTED_FRAME_P is false. */
1889 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1890 class frame_command_helper
1894 /* The "frame level" family of commands. The ARG is an integer that is
1895 the frame's level in the stack. */
1897 level (const char *arg
, int from_tty
)
1899 int level
= value_as_long (parse_and_eval (arg
));
1900 struct frame_info
*fid
1901 = find_relative_frame (get_current_frame (), &level
);
1903 error (_("No frame at level %s."), arg
);
1907 /* The "frame address" family of commands. ARG is a stack-pointer
1908 address for an existing frame. This command does not allow new
1909 frames to be created. */
1912 address (const char *arg
, int from_tty
)
1914 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1915 struct frame_info
*fid
= find_frame_for_address (addr
);
1917 error (_("No frame at address %s."), arg
);
1921 /* The "frame view" family of commands. ARG is one or two addresses and
1922 is used to view a frame that might be outside the current backtrace.
1923 The addresses are stack-pointer address, and (optional) pc-address. */
1926 view (const char *args
, int from_tty
)
1928 struct frame_info
*fid
;
1931 error (_("Missing address argument to view a frame"));
1933 gdb_argv
argv (args
);
1935 if (argv
.count () == 2)
1939 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1940 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1941 fid
= create_new_frame (addr
[0], addr
[1]);
1945 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1946 fid
= create_new_frame (addr
, false);
1951 /* The "frame function" family of commands. ARG is the name of a
1952 function within the stack, the first function (searching from frame
1953 0) with that name will be selected. */
1956 function (const char *arg
, int from_tty
)
1959 error (_("Missing function name argument"));
1960 struct frame_info
*fid
= find_frame_for_function (arg
);
1962 error (_("No frame for function \"%s\"."), arg
);
1966 /* The "frame" base command, that is, when no sub-command is specified.
1967 If one argument is provided then we assume that this is a frame's
1968 level as historically, this was the supported command syntax that was
1971 If no argument is provided, then the current frame is selected. */
1974 base_command (const char *arg
, int from_tty
)
1977 FPTR (get_selected_frame (_("No stack.")), true);
1979 level (arg
, from_tty
);
1983 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1984 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1986 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1987 static frame_command_helper
<frame_command_core
> frame_cmd
;
1988 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1990 /* Print briefly all stack frames or just the innermost COUNT_EXP
1994 backtrace_command_1 (const frame_print_options
&fp_opts
,
1995 const backtrace_cmd_options
&bt_opts
,
1996 const char *count_exp
, int from_tty
)
1999 struct frame_info
*fi
;
2001 int py_start
= 0, py_end
= 0;
2002 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
2004 if (!target_has_stack
)
2005 error (_("No stack."));
2009 count
= parse_and_eval_long (count_exp
);
2015 /* The argument to apply_ext_lang_frame_filter is the number
2016 of the final frame to print, and frames start at 0. */
2026 frame_filter_flags flags
= 0;
2029 flags
|= PRINT_LOCALS
;
2031 flags
|= PRINT_HIDE
;
2033 if (!bt_opts
.no_filters
)
2035 enum ext_lang_frame_args arg_type
;
2037 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
2039 flags
|= PRINT_MORE_FRAMES
;
2041 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
2042 arg_type
= CLI_SCALAR_VALUES
;
2043 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
2044 arg_type
= CLI_ALL_VALUES
;
2045 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
2046 arg_type
= CLI_PRESENCE
;
2047 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2048 arg_type
= NO_VALUES
;
2052 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2053 arg_type
, current_uiout
,
2057 /* Run the inbuilt backtrace if there are no filters registered, or
2058 "-no-filters" has been specified from the command. */
2059 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2061 struct frame_info
*trailing
;
2063 /* The following code must do two things. First, it must set the
2064 variable TRAILING to the frame from which we should start
2065 printing. Second, it must set the variable count to the number
2066 of frames which we should print, or -1 if all of them. */
2068 if (count_exp
!= NULL
&& count
< 0)
2070 trailing
= trailing_outermost_frame (-count
);
2074 trailing
= get_current_frame ();
2076 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2080 /* Don't use print_stack_frame; if an error() occurs it probably
2081 means further attempts to backtrace would fail (on the other
2082 hand, perhaps the code does or could be fixed to make sure
2083 the frame->prev field gets set to NULL in that case). */
2085 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2086 if ((flags
& PRINT_LOCALS
) != 0)
2088 struct frame_id frame_id
= get_frame_id (fi
);
2090 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2092 /* print_frame_local_vars invalidates FI. */
2093 fi
= frame_find_by_id (frame_id
);
2097 warning (_("Unable to restore previously selected frame."));
2102 /* Save the last frame to check for error conditions. */
2106 /* If we've stopped before the end, mention that. */
2108 printf_filtered (_("(More stack frames follow...)\n"));
2110 /* If we've run out of frames, and the reason appears to be an error
2111 condition, print it. */
2112 if (fi
== NULL
&& trailing
!= NULL
)
2114 enum unwind_stop_reason reason
;
2116 reason
= get_frame_unwind_stop_reason (trailing
);
2117 if (reason
>= UNWIND_FIRST_ERROR
)
2118 printf_filtered (_("Backtrace stopped: %s\n"),
2119 frame_stop_reason_string (trailing
));
2124 /* Create an option_def_group array grouping all the "backtrace"
2125 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2127 static inline std::array
<gdb::option::option_def_group
, 3>
2128 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2129 backtrace_cmd_options
*bt_cmd_opts
,
2130 set_backtrace_options
*set_bt_opts
)
2133 { {frame_print_option_defs
}, fp_opts
},
2134 { {set_backtrace_option_defs
}, set_bt_opts
},
2135 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2139 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2140 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2141 store the parsed qualifiers. */
2144 parse_backtrace_qualifiers (const char *arg
,
2145 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2149 const char *save_arg
= arg
;
2150 std::string this_arg
= extract_arg (&arg
);
2152 if (this_arg
.empty ())
2155 if (subset_compare (this_arg
.c_str (), "no-filters"))
2157 if (bt_cmd_opts
!= nullptr)
2158 bt_cmd_opts
->no_filters
= true;
2160 else if (subset_compare (this_arg
.c_str (), "full"))
2162 if (bt_cmd_opts
!= nullptr)
2163 bt_cmd_opts
->full
= true;
2165 else if (subset_compare (this_arg
.c_str (), "hide"))
2167 if (bt_cmd_opts
!= nullptr)
2168 bt_cmd_opts
->hide
= true;
2172 /* Not a recognized qualifier, so stop. */
2179 backtrace_command (const char *arg
, int from_tty
)
2181 frame_print_options fp_opts
= user_frame_print_options
;
2182 backtrace_cmd_options bt_cmd_opts
;
2183 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2186 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2187 gdb::option::process_options
2188 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2190 /* Parse non-'-'-prefixed qualifiers, for backwards
2194 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2199 /* These options are handled quite deep in the unwind machinery, so
2200 we get to pass them down by swapping globals. */
2201 scoped_restore restore_set_backtrace_options
2202 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2204 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2207 /* Completer for the "backtrace" command. */
2210 backtrace_command_completer (struct cmd_list_element
*ignore
,
2211 completion_tracker
&tracker
,
2212 const char *text
, const char */
*word*/
)
2215 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2216 if (gdb::option::complete_options
2217 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2222 const char *p
= skip_to_space (text
);
2225 static const char *const backtrace_cmd_qualifier_choices
[] = {
2226 "full", "no-filters", "hide", nullptr,
2228 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2231 if (tracker
.have_completions ())
2236 const char *cmd
= parse_backtrace_qualifiers (text
);
2237 tracker
.advance_custom_word_point_by (cmd
- text
);
2242 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2243 expression_completer (ignore
, tracker
, text
, word
);
2246 /* Iterate over the local variables of a block B, calling CB with
2250 iterate_over_block_locals (const struct block
*b
,
2251 iterate_over_block_arg_local_vars_cb cb
,
2254 struct block_iterator iter
;
2257 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2259 switch (SYMBOL_CLASS (sym
))
2266 case LOC_OPTIMIZED_OUT
:
2267 if (SYMBOL_IS_ARGUMENT (sym
))
2269 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2271 (*cb
) (sym
->print_name (), sym
, cb_data
);
2275 /* Ignore symbols which are not locals. */
2281 /* Iterate over all the local variables in block B, including all its
2282 superblocks, stopping when the top-level block is reached. */
2285 iterate_over_block_local_vars (const struct block
*block
,
2286 iterate_over_block_arg_local_vars_cb cb
,
2291 iterate_over_block_locals (block
, cb
, cb_data
);
2292 /* After handling the function's top-level block, stop. Don't
2293 continue to its superblock, the block of per-file
2295 if (BLOCK_FUNCTION (block
))
2297 block
= BLOCK_SUPERBLOCK (block
);
2301 /* Data to be passed around in the calls to the locals and args
2304 struct print_variable_and_value_data
2306 gdb::optional
<compiled_regex
> preg
;
2307 gdb::optional
<compiled_regex
> treg
;
2308 struct frame_id frame_id
;
2310 struct ui_file
*stream
;
2314 /* The callback for the locals and args iterators. */
2317 do_print_variable_and_value (const char *print_name
,
2321 struct print_variable_and_value_data
*p
2322 = (struct print_variable_and_value_data
*) cb_data
;
2323 struct frame_info
*frame
;
2325 if (p
->preg
.has_value ()
2326 && p
->preg
->exec (sym
->natural_name (), 0, NULL
, 0) != 0)
2328 if (p
->treg
.has_value ()
2329 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2332 frame
= frame_find_by_id (p
->frame_id
);
2335 warning (_("Unable to restore previously selected frame."));
2339 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2341 /* print_variable_and_value invalidates FRAME. */
2344 p
->values_printed
= 1;
2347 /* Prepares the regular expression REG from REGEXP.
2348 If REGEXP is NULL, it results in an empty regular expression. */
2351 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2355 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2357 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2363 /* Print all variables from the innermost up to the function block of FRAME.
2364 Print them with values to STREAM indented by NUM_TABS.
2365 If REGEXP is not NULL, only print local variables whose name
2367 If T_REGEXP is not NULL, only print local variables whose type
2369 If no local variables have been printed and !QUIET, prints a message
2370 explaining why no local variables could be printed.
2372 This function will invalidate FRAME. */
2375 print_frame_local_vars (struct frame_info
*frame
,
2377 const char *regexp
, const char *t_regexp
,
2378 int num_tabs
, struct ui_file
*stream
)
2380 struct print_variable_and_value_data cb_data
;
2381 const struct block
*block
;
2384 if (!get_frame_pc_if_available (frame
, &pc
))
2387 fprintf_filtered (stream
,
2388 _("PC unavailable, cannot determine locals.\n"));
2392 block
= get_frame_block (frame
, 0);
2396 fprintf_filtered (stream
, "No symbol table info available.\n");
2400 prepare_reg (regexp
, &cb_data
.preg
);
2401 prepare_reg (t_regexp
, &cb_data
.treg
);
2402 cb_data
.frame_id
= get_frame_id (frame
);
2403 cb_data
.num_tabs
= 4 * num_tabs
;
2404 cb_data
.stream
= stream
;
2405 cb_data
.values_printed
= 0;
2407 /* Temporarily change the selected frame to the given FRAME.
2408 This allows routines that rely on the selected frame instead
2409 of being given a frame as parameter to use the correct frame. */
2410 scoped_restore_selected_frame restore_selected_frame
;
2411 select_frame (frame
);
2413 iterate_over_block_local_vars (block
,
2414 do_print_variable_and_value
,
2417 if (!cb_data
.values_printed
&& !quiet
)
2419 if (regexp
== NULL
&& t_regexp
== NULL
)
2420 fprintf_filtered (stream
, _("No locals.\n"));
2422 fprintf_filtered (stream
, _("No matching locals.\n"));
2426 /* Structure to hold the values of the options used by the 'info
2427 variables' command and other similar commands. These correspond to the
2428 -q and -t options. */
2430 struct info_print_options
2433 char *type_regexp
= nullptr;
2435 ~info_print_options ()
2437 xfree (type_regexp
);
2441 /* The options used by the 'info locals' and 'info args' commands. */
2443 static const gdb::option::option_def info_print_options_defs
[] = {
2444 gdb::option::boolean_option_def
<info_print_options
> {
2446 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2447 nullptr, /* show_cmd_cb */
2448 nullptr /* set_doc */
2451 gdb::option::string_option_def
<info_print_options
> {
2453 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2454 nullptr, /* show_cmd_cb */
2455 nullptr /* set_doc */
2459 /* Returns the option group used by 'info locals' and 'info args'
2462 static gdb::option::option_def_group
2463 make_info_print_options_def_group (info_print_options
*opts
)
2465 return {{info_print_options_defs
}, opts
};
2468 /* Command completer for 'info locals' and 'info args'. */
2471 info_print_command_completer (struct cmd_list_element
*ignore
,
2472 completion_tracker
&tracker
,
2473 const char *text
, const char * /* word */)
2476 = make_info_print_options_def_group (nullptr);
2477 if (gdb::option::complete_options
2478 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2481 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2482 symbol_completer (ignore
, tracker
, text
, word
);
2485 /* Implement the 'info locals' command. */
2488 info_locals_command (const char *args
, int from_tty
)
2490 info_print_options opts
;
2491 auto grp
= make_info_print_options_def_group (&opts
);
2492 gdb::option::process_options
2493 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2494 if (args
!= nullptr && *args
== '\0')
2497 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2498 opts
.quiet
, args
, opts
.type_regexp
,
2502 /* Iterate over all the argument variables in block B. */
2505 iterate_over_block_arg_vars (const struct block
*b
,
2506 iterate_over_block_arg_local_vars_cb cb
,
2509 struct block_iterator iter
;
2510 struct symbol
*sym
, *sym2
;
2512 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2514 /* Don't worry about things which aren't arguments. */
2515 if (SYMBOL_IS_ARGUMENT (sym
))
2517 /* We have to look up the symbol because arguments can have
2518 two entries (one a parameter, one a local) and the one we
2519 want is the local, which lookup_symbol will find for us.
2520 This includes gcc1 (not gcc2) on the sparc when passing a
2521 small structure and gcc2 when the argument type is float
2522 and it is passed as a double and converted to float by
2523 the prologue (in the latter case the type of the LOC_ARG
2524 symbol is double and the type of the LOC_LOCAL symbol is
2525 float). There are also LOC_ARG/LOC_REGISTER pairs which
2526 are not combined in symbol-reading. */
2528 sym2
= lookup_symbol_search_name (sym
->search_name (),
2529 b
, VAR_DOMAIN
).symbol
;
2530 (*cb
) (sym
->print_name (), sym2
, cb_data
);
2535 /* Print all argument variables of the function of FRAME.
2536 Print them with values to STREAM.
2537 If REGEXP is not NULL, only print argument variables whose name
2539 If T_REGEXP is not NULL, only print argument variables whose type
2541 If no argument variables have been printed and !QUIET, prints a message
2542 explaining why no argument variables could be printed.
2544 This function will invalidate FRAME. */
2547 print_frame_arg_vars (struct frame_info
*frame
,
2549 const char *regexp
, const char *t_regexp
,
2550 struct ui_file
*stream
)
2552 struct print_variable_and_value_data cb_data
;
2553 struct symbol
*func
;
2555 gdb::optional
<compiled_regex
> preg
;
2556 gdb::optional
<compiled_regex
> treg
;
2558 if (!get_frame_pc_if_available (frame
, &pc
))
2561 fprintf_filtered (stream
,
2562 _("PC unavailable, cannot determine args.\n"));
2566 func
= get_frame_function (frame
);
2570 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2574 prepare_reg (regexp
, &cb_data
.preg
);
2575 prepare_reg (t_regexp
, &cb_data
.treg
);
2576 cb_data
.frame_id
= get_frame_id (frame
);
2577 cb_data
.num_tabs
= 0;
2578 cb_data
.stream
= stream
;
2579 cb_data
.values_printed
= 0;
2581 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2582 do_print_variable_and_value
, &cb_data
);
2584 /* do_print_variable_and_value invalidates FRAME. */
2587 if (!cb_data
.values_printed
&& !quiet
)
2589 if (regexp
== NULL
&& t_regexp
== NULL
)
2590 fprintf_filtered (stream
, _("No arguments.\n"));
2592 fprintf_filtered (stream
, _("No matching arguments.\n"));
2596 /* Implement the 'info args' command. */
2599 info_args_command (const char *args
, int from_tty
)
2601 info_print_options opts
;
2602 auto grp
= make_info_print_options_def_group (&opts
);
2603 gdb::option::process_options
2604 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2605 if (args
!= nullptr && *args
== '\0')
2608 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2609 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2612 /* Return the symbol-block in which the selected frame is executing.
2613 Can return zero under various legitimate circumstances.
2615 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2616 code address within the block returned. We use this to decide
2617 which macros are in scope. */
2619 const struct block
*
2620 get_selected_block (CORE_ADDR
*addr_in_block
)
2622 if (!has_stack_frames ())
2625 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2628 /* Find a frame a certain number of levels away from FRAME.
2629 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2630 Positive means go to earlier frames (up); negative, the reverse.
2631 The int that contains the number of levels is counted toward
2632 zero as the frames for those levels are found.
2633 If the top or bottom frame is reached, that frame is returned,
2634 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2635 how much farther the original request asked to go. */
2638 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2640 /* Going up is simple: just call get_prev_frame enough times or
2641 until the initial frame is reached. */
2642 while (*level_offset_ptr
> 0)
2644 struct frame_info
*prev
= get_prev_frame (frame
);
2648 (*level_offset_ptr
)--;
2652 /* Going down is just as simple. */
2653 while (*level_offset_ptr
< 0)
2655 struct frame_info
*next
= get_next_frame (frame
);
2659 (*level_offset_ptr
)++;
2666 /* Select the frame up one or COUNT_EXP stack levels from the
2667 previously selected frame, and print it briefly. */
2670 up_silently_base (const char *count_exp
)
2672 struct frame_info
*frame
;
2676 count
= parse_and_eval_long (count_exp
);
2678 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2679 if (count
!= 0 && count_exp
== NULL
)
2680 error (_("Initial frame selected; you cannot go up."));
2681 select_frame (frame
);
2685 up_silently_command (const char *count_exp
, int from_tty
)
2687 up_silently_base (count_exp
);
2691 up_command (const char *count_exp
, int from_tty
)
2693 up_silently_base (count_exp
);
2694 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2697 /* Select the frame down one or COUNT_EXP stack levels from the previously
2698 selected frame, and print it briefly. */
2701 down_silently_base (const char *count_exp
)
2703 struct frame_info
*frame
;
2707 count
= -parse_and_eval_long (count_exp
);
2709 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2710 if (count
!= 0 && count_exp
== NULL
)
2712 /* We only do this if COUNT_EXP is not specified. That way
2713 "down" means to really go down (and let me know if that is
2714 impossible), but "down 9999" can be used to mean go all the
2715 way down without getting an error. */
2717 error (_("Bottom (innermost) frame selected; you cannot go down."));
2720 select_frame (frame
);
2724 down_silently_command (const char *count_exp
, int from_tty
)
2726 down_silently_base (count_exp
);
2730 down_command (const char *count_exp
, int from_tty
)
2732 down_silently_base (count_exp
);
2733 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2737 return_command (const char *retval_exp
, int from_tty
)
2739 /* Initialize it just to avoid a GCC false warning. */
2740 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2741 struct frame_info
*thisframe
;
2742 struct gdbarch
*gdbarch
;
2743 struct symbol
*thisfun
;
2744 struct value
*return_value
= NULL
;
2745 struct value
*function
= NULL
;
2746 const char *query_prefix
= "";
2748 thisframe
= get_selected_frame ("No selected frame.");
2749 thisfun
= get_frame_function (thisframe
);
2750 gdbarch
= get_frame_arch (thisframe
);
2752 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2753 error (_("Can not force return from an inlined function."));
2755 /* Compute the return value. If the computation triggers an error,
2756 let it bail. If the return type can't be handled, set
2757 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2761 expression_up retval_expr
= parse_expression (retval_exp
);
2762 struct type
*return_type
= NULL
;
2764 /* Compute the return value. Should the computation fail, this
2765 call throws an error. */
2766 return_value
= evaluate_expression (retval_expr
.get ());
2768 /* Cast return value to the return type of the function. Should
2769 the cast fail, this call throws an error. */
2770 if (thisfun
!= NULL
)
2771 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2772 if (return_type
== NULL
)
2774 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2775 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2776 error (_("Return value type not available for selected "
2778 "Please use an explicit cast of the value to return."));
2779 return_type
= value_type (return_value
);
2781 return_type
= check_typedef (return_type
);
2782 return_value
= value_cast (return_type
, return_value
);
2784 /* Make sure the value is fully evaluated. It may live in the
2785 stack frame we're about to pop. */
2786 if (value_lazy (return_value
))
2787 value_fetch_lazy (return_value
);
2789 if (thisfun
!= NULL
)
2790 function
= read_var_value (thisfun
, NULL
, thisframe
);
2792 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2793 if (return_type
->code () == TYPE_CODE_VOID
)
2794 /* If the return-type is "void", don't try to find the
2795 return-value's location. However, do still evaluate the
2796 return expression so that, even when the expression result
2797 is discarded, side effects such as "return i++" still
2799 return_value
= NULL
;
2800 else if (thisfun
!= NULL
)
2802 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2803 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2804 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2806 query_prefix
= "The location at which to store the "
2807 "function's return value is unknown.\n"
2808 "If you continue, the return value "
2809 "that you specified will be ignored.\n";
2810 return_value
= NULL
;
2815 /* Does an interactive user really want to do this? Include
2816 information, such as how well GDB can handle the return value, in
2817 the query message. */
2822 if (thisfun
== NULL
)
2823 confirmed
= query (_("%sMake selected stack frame return now? "),
2827 if (TYPE_NO_RETURN (thisfun
->type
))
2828 warning (_("Function does not return normally to caller."));
2829 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2830 thisfun
->print_name ());
2833 error (_("Not confirmed"));
2836 /* Discard the selected frame and all frames inner-to it. */
2837 frame_pop (get_selected_frame (NULL
));
2839 /* Store RETURN_VALUE in the just-returned register set. */
2840 if (return_value
!= NULL
)
2842 struct type
*return_type
= value_type (return_value
);
2843 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2845 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2846 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2847 gdbarch_return_value (cache_arch
, function
, return_type
,
2848 get_current_regcache (), NULL
/*read*/,
2849 value_contents (return_value
) /*write*/);
2852 /* If we are at the end of a call dummy now, pop the dummy frame
2854 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2855 frame_pop (get_current_frame ());
2857 select_frame (get_current_frame ());
2858 /* If interactive, print the frame that is now current. */
2860 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2863 /* Find the most inner frame in the current stack for a function called
2864 FUNCTION_NAME. If no matching frame is found return NULL. */
2866 static struct frame_info
*
2867 find_frame_for_function (const char *function_name
)
2869 /* Used to hold the lower and upper addresses for each of the
2870 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2871 struct function_bounds
2873 CORE_ADDR low
, high
;
2875 struct frame_info
*frame
;
2879 gdb_assert (function_name
!= NULL
);
2881 frame
= get_current_frame ();
2882 std::vector
<symtab_and_line
> sals
2883 = decode_line_with_current_source (function_name
,
2884 DECODE_LINE_FUNFIRSTLINE
);
2885 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2886 for (size_t i
= 0; i
< sals
.size (); i
++)
2888 if (sals
[i
].pspace
!= current_program_space
)
2889 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2890 else if (sals
[i
].pc
== 0
2891 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2892 &func_bounds
[i
].low
,
2893 &func_bounds
[i
].high
) == 0)
2894 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2899 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2900 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2901 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2905 frame
= find_relative_frame (frame
, &level
);
2908 while (!found
&& level
== 0);
2916 /* Implements the dbx 'func' command. */
2919 func_command (const char *arg
, int from_tty
)
2924 struct frame_info
*frame
= find_frame_for_function (arg
);
2926 error (_("'%s' not within current stack frame."), arg
);
2927 if (frame
!= get_selected_frame (NULL
))
2929 select_frame (frame
);
2930 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2934 /* The qcs command line flags for the "frame apply" commands. Keep
2935 this in sync with the "thread apply" commands. */
2937 using qcs_flag_option_def
2938 = gdb::option::flag_option_def
<qcs_flags
>;
2940 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2941 qcs_flag_option_def
{
2942 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2943 N_("Disables printing the frame location information."),
2946 qcs_flag_option_def
{
2947 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2948 N_("Print any error raised by COMMAND and continue."),
2951 qcs_flag_option_def
{
2952 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2953 N_("Silently ignore any errors or empty output produced by COMMAND."),
2957 /* Create an option_def_group array for all the "frame apply" options,
2958 with FLAGS and SET_BT_OPTS as context. */
2960 static inline std::array
<gdb::option::option_def_group
, 2>
2961 make_frame_apply_options_def_group (qcs_flags
*flags
,
2962 set_backtrace_options
*set_bt_opts
)
2965 { {fr_qcs_flags_option_defs
}, flags
},
2966 { {set_backtrace_option_defs
}, set_bt_opts
},
2970 /* Apply a GDB command to all stack frames, or a set of identified frames,
2971 or innermost COUNT frames.
2972 With a negative COUNT, apply command on outermost -COUNT frames.
2974 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2975 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2976 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2977 frame apply all -s p local_var_no_idea_in_which_frame
2978 If a frame has a local variable called
2979 local_var_no_idea_in_which_frame, print frame
2980 and value of local_var_no_idea_in_which_frame.
2981 frame apply all -s -q p local_var_no_idea_in_which_frame
2982 Same as before, but only print the variable value.
2983 frame apply level 2-5 0 4-7 -s p i = i + 1
2984 Adds 1 to the variable i in the specified frames.
2985 Note that i will be incremented twice in
2988 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2989 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2990 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2991 for error messages. */
2994 frame_apply_command_count (const char *which_command
,
2995 const char *cmd
, int from_tty
,
2996 struct frame_info
*trailing
, int count
)
2999 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
3001 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
3002 gdb::option::process_options
3003 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
3005 validate_flags_qcs (which_command
, &flags
);
3007 if (cmd
== NULL
|| *cmd
== '\0')
3008 error (_("Please specify a command to apply on the selected frames"));
3010 /* The below will restore the current inferior/thread/frame.
3011 Usually, only the frame is effectively to be restored.
3012 But in case CMD switches of inferior/thread, better restore
3014 scoped_restore_current_thread restore_thread
;
3016 /* These options are handled quite deep in the unwind machinery, so
3017 we get to pass them down by swapping globals. */
3018 scoped_restore restore_set_backtrace_options
3019 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
3021 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
3028 std::string cmd_result
;
3030 /* In case CMD switches of inferior/thread/frame, the below
3031 restores the inferior/thread/frame. FI can then be
3032 set to the selected frame. */
3033 scoped_restore_current_thread restore_fi_current_frame
;
3035 cmd_result
= execute_command_to_string
3036 (cmd
, from_tty
, gdb_stdout
->term_out ());
3038 fi
= get_selected_frame (_("frame apply "
3039 "unable to get selected frame."));
3040 if (!flags
.silent
|| cmd_result
.length () > 0)
3043 print_stack_frame (fi
, 1, LOCATION
, 0);
3044 printf_filtered ("%s", cmd_result
.c_str ());
3047 catch (const gdb_exception_error
&ex
)
3049 fi
= get_selected_frame (_("frame apply "
3050 "unable to get selected frame."));
3054 print_stack_frame (fi
, 1, LOCATION
, 0);
3056 printf_filtered ("%s\n", ex
.what ());
3064 /* Completer for the "frame apply ..." commands. */
3067 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3069 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3070 if (gdb::option::complete_options
3071 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3074 complete_nested_command_line (tracker
, text
);
3077 /* Completer for the "frame apply" commands. */
3080 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3081 completion_tracker
&tracker
,
3082 const char *text
, const char */
*word*/
)
3084 /* Do this explicitly because there's an early return below. */
3085 tracker
.set_use_custom_word_point (true);
3087 number_or_range_parser
levels (text
);
3089 /* Skip the LEVEL list to find the options and command args. */
3092 while (!levels
.finished ())
3094 /* Call for effect. */
3095 levels
.get_number ();
3097 if (levels
.in_range ())
3098 levels
.skip_range ();
3101 catch (const gdb_exception_error
&ex
)
3103 /* get_number throws if it parses a negative number, for
3104 example. But a seemingly negative number may be the start of
3105 an option instead. */
3108 const char *cmd
= levels
.cur_tok ();
3112 /* No level list yet. */
3116 /* Check if we're past a valid LEVEL already. */
3117 if (levels
.finished ()
3118 && cmd
> text
&& !isspace (cmd
[-1]))
3121 /* We're past LEVELs, advance word point. */
3122 tracker
.advance_custom_word_point_by (cmd
- text
);
3125 frame_apply_completer (tracker
, text
);
3128 /* Completer for the "frame apply all" command. */
3131 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3132 completion_tracker
&tracker
,
3133 const char *text
, const char */
*word*/
)
3135 frame_apply_completer (tracker
, text
);
3138 /* Completer for the "frame apply COUNT" command. */
3141 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3142 completion_tracker
&tracker
,
3143 const char *text
, const char */
*word*/
)
3145 const char *cmd
= text
;
3147 int count
= get_number_trailer (&cmd
, 0);
3151 /* Check if we're past a valid COUNT already. */
3152 if (cmd
> text
&& !isspace (cmd
[-1]))
3155 /* We're past COUNT, advance word point. */
3156 tracker
.advance_custom_word_point_by (cmd
- text
);
3159 frame_apply_completer (tracker
, text
);
3162 /* Implementation of the "frame apply level" command. */
3165 frame_apply_level_command (const char *cmd
, int from_tty
)
3167 if (!target_has_stack
)
3168 error (_("No stack."));
3170 bool level_found
= false;
3171 const char *levels_str
= cmd
;
3172 number_or_range_parser
levels (levels_str
);
3174 /* Skip the LEVEL list to find the flags and command args. */
3175 while (!levels
.finished ())
3177 /* Call for effect. */
3178 levels
.get_number ();
3181 if (levels
.in_range ())
3182 levels
.skip_range ();
3186 error (_("Missing or invalid LEVEL... argument"));
3188 cmd
= levels
.cur_tok ();
3190 /* Redo the LEVELS parsing, but applying COMMAND. */
3191 levels
.init (levels_str
);
3192 while (!levels
.finished ())
3194 const int level_beg
= levels
.get_number ();
3197 if (levels
.in_range ())
3199 n_frames
= levels
.end_value () - level_beg
+ 1;
3200 levels
.skip_range ();
3205 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3206 leading_innermost_frame (level_beg
), n_frames
);
3210 /* Implementation of the "frame apply all" command. */
3213 frame_apply_all_command (const char *cmd
, int from_tty
)
3215 if (!target_has_stack
)
3216 error (_("No stack."));
3218 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3219 get_current_frame (), INT_MAX
);
3222 /* Implementation of the "frame apply" command. */
3225 frame_apply_command (const char* cmd
, int from_tty
)
3228 struct frame_info
*trailing
;
3230 if (!target_has_stack
)
3231 error (_("No stack."));
3234 error (_("Missing COUNT argument."));
3235 count
= get_number_trailer (&cmd
, 0);
3237 error (_("Invalid COUNT argument."));
3241 trailing
= trailing_outermost_frame (-count
);
3245 trailing
= get_current_frame ();
3247 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3251 /* Implementation of the "faas" command. */
3254 faas_command (const char *cmd
, int from_tty
)
3256 if (cmd
== NULL
|| *cmd
== '\0')
3257 error (_("Please specify a command to apply on all frames"));
3258 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3259 execute_command (expanded
.c_str (), from_tty
);
3263 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3264 matching frame can be found. */
3266 static struct frame_info
*
3267 find_frame_for_address (CORE_ADDR address
)
3270 struct frame_info
*fid
;
3272 id
= frame_id_build_wild (address
);
3274 /* If (s)he specifies the frame with an address, he deserves
3275 what (s)he gets. Still, give the highest one that matches.
3276 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3278 for (fid
= get_current_frame ();
3280 fid
= get_prev_frame (fid
))
3282 if (frame_id_eq (id
, get_frame_id (fid
)))
3284 struct frame_info
*prev_frame
;
3288 prev_frame
= get_prev_frame (fid
);
3290 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3302 /* Commands with a prefix of `frame apply'. */
3303 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3305 /* Commands with a prefix of `frame'. */
3306 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3308 /* Commands with a prefix of `select frame'. */
3309 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3311 /* Commands with a prefix of `info frame'. */
3312 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3314 void _initialize_stack ();
3316 _initialize_stack ()
3318 struct cmd_list_element
*cmd
;
3320 add_com ("return", class_stack
, return_command
, _("\
3321 Make selected stack frame return to its caller.\n\
3322 Control remains in the debugger, but when you continue\n\
3323 execution will resume in the frame above the one now selected.\n\
3324 If an argument is given, it is an expression for the value to return."));
3326 add_com ("up", class_stack
, up_command
, _("\
3327 Select and print stack frame that called this one.\n\
3328 An argument says how many frames up to go."));
3329 add_com ("up-silently", class_support
, up_silently_command
, _("\
3330 Same as the `up' command, but does not print anything.\n\
3331 This is useful in command scripts."));
3333 add_com ("down", class_stack
, down_command
, _("\
3334 Select and print stack frame called by this one.\n\
3335 An argument says how many frames down to go."));
3336 add_com_alias ("do", "down", class_stack
, 1);
3337 add_com_alias ("dow", "down", class_stack
, 1);
3338 add_com ("down-silently", class_support
, down_silently_command
, _("\
3339 Same as the `down' command, but does not print anything.\n\
3340 This is useful in command scripts."));
3342 add_prefix_cmd ("frame", class_stack
,
3343 &frame_cmd
.base_command
, _("\
3344 Select and print a stack frame.\n\
3345 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3346 A single numerical argument specifies the frame to select."),
3347 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3348 add_com_alias ("f", "frame", class_stack
, 1);
3350 #define FRAME_APPLY_OPTION_HELP "\
3351 Prints the frame location information followed by COMMAND output.\n\
3353 By default, an error raised during the execution of COMMAND\n\
3354 aborts \"frame apply\".\n\
3359 const auto frame_apply_opts
3360 = make_frame_apply_options_def_group (nullptr, nullptr);
3362 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3363 Apply a command to a number of frames.\n\
3364 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3365 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3366 FRAME_APPLY_OPTION_HELP
),
3369 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3370 frame_apply_cmd_help
.c_str (),
3371 &frame_apply_cmd_list
, "frame apply ", 1,
3373 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3375 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3376 Apply a command to all frames.\n\
3378 Usage: frame apply all [OPTION]... COMMAND\n"
3379 FRAME_APPLY_OPTION_HELP
),
3382 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3383 frame_apply_all_cmd_help
.c_str (),
3384 &frame_apply_cmd_list
);
3385 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3387 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3388 Apply a command to a list of frames.\n\
3390 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3391 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3392 FRAME_APPLY_OPTION_HELP
),
3395 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3396 frame_apply_level_cmd_help
.c_str (),
3397 &frame_apply_cmd_list
);
3398 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3400 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3401 Apply a command to all frames (ignoring errors and empty output).\n\
3402 Usage: faas [OPTION]... COMMAND\n\
3403 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3404 See \"help frame apply all\" for available options."));
3405 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3407 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3409 Select and print a stack frame by stack address.\n\
3411 Usage: frame address STACK-ADDRESS"),
3414 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3416 View a stack frame that might be outside the current backtrace.\n\
3418 Usage: frame view STACK-ADDRESS\n\
3419 frame view STACK-ADDRESS PC-ADDRESS"),
3422 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3424 Select and print a stack frame by function name.\n\
3426 Usage: frame function NAME\n\
3428 The innermost frame that visited function NAME is selected."),
3430 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3433 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3435 Select and print a stack frame by level.\n\
3437 Usage: frame level LEVEL"),
3440 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3441 &select_frame_cmd
.base_command
, _("\
3442 Select a stack frame without printing anything.\n\
3443 A single numerical argument specifies the frame to select."),
3444 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3445 &cli_suppress_notification
.user_selected_context
);
3447 add_cmd_suppress_notification ("address", class_stack
,
3448 &select_frame_cmd
.address
, _("\
3449 Select a stack frame by stack address.\n\
3451 Usage: select-frame address STACK-ADDRESS"),
3452 &select_frame_cmd_list
,
3453 &cli_suppress_notification
.user_selected_context
);
3456 add_cmd_suppress_notification ("view", class_stack
,
3457 &select_frame_cmd
.view
, _("\
3458 Select a stack frame that might be outside the current backtrace.\n\
3460 Usage: select-frame view STACK-ADDRESS\n\
3461 select-frame view STACK-ADDRESS PC-ADDRESS"),
3462 &select_frame_cmd_list
,
3463 &cli_suppress_notification
.user_selected_context
);
3465 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3466 &select_frame_cmd
.function
, _("\
3467 Select a stack frame by function name.\n\
3469 Usage: select-frame function NAME"),
3470 &select_frame_cmd_list
,
3471 &cli_suppress_notification
.user_selected_context
);
3472 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3474 add_cmd_suppress_notification ("level", class_stack
,
3475 &select_frame_cmd
.level
, _("\
3476 Select a stack frame by level.\n\
3478 Usage: select-frame level LEVEL"),
3479 &select_frame_cmd_list
,
3480 &cli_suppress_notification
.user_selected_context
);
3482 const auto backtrace_opts
3483 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3485 static std::string backtrace_help
3486 = gdb::option::build_help (_("\
3487 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3488 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3493 For backward compatibility, the following qualifiers are supported:\n\
3495 full - same as -full option.\n\
3496 no-filters - same as -no-filters option.\n\
3497 hide - same as -hide.\n\
3499 With a negative COUNT, print outermost -COUNT frames."),
3502 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3504 backtrace_help
.c_str ());
3505 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3507 add_com_alias ("bt", "backtrace", class_stack
, 0);
3509 add_com_alias ("where", "backtrace", class_stack
, 0);
3510 add_info ("stack", backtrace_command
,
3511 _("Backtrace of the stack, or innermost COUNT frames."));
3512 add_info_alias ("s", "stack", 1);
3514 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3515 _("All about the selected stack frame.\n\
3516 With no arguments, displays information about the currently selected stack\n\
3517 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3518 the information is then printed about the specified frame."),
3519 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3520 add_info_alias ("f", "frame", 1);
3522 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3524 Print information about a stack frame selected by stack address.\n\
3526 Usage: info frame address STACK-ADDRESS"),
3527 &info_frame_cmd_list
);
3529 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3531 Print information about a stack frame outside the current backtrace.\n\
3533 Usage: info frame view STACK-ADDRESS\n\
3534 info frame view STACK-ADDRESS PC-ADDRESS"),
3535 &info_frame_cmd_list
);
3537 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3539 Print information about a stack frame selected by function name.\n\
3541 Usage: info frame function NAME"),
3542 &info_frame_cmd_list
);
3543 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3545 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3547 Print information about a stack frame selected by level.\n\
3549 Usage: info frame level LEVEL"),
3550 &info_frame_cmd_list
);
3552 cmd
= add_info ("locals", info_locals_command
,
3553 info_print_args_help (_("\
3554 All local variables of current stack frame or those matching REGEXPs.\n\
3555 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3556 Prints the local variables of the current stack frame.\n"),
3557 _("local variables"),
3559 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3560 cmd
= add_info ("args", info_args_command
,
3561 info_print_args_help (_("\
3562 All argument variables of current stack frame or those matching REGEXPs.\n\
3563 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3564 Prints the argument variables of the current stack frame.\n"),
3565 _("argument variables"),
3567 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3570 add_com ("func", class_stack
, func_command
, _("\
3571 Select the stack frame that contains NAME.\n\
3572 Usage: func NAME"));
3574 /* Install "set print raw frame-arguments", a deprecated spelling of
3575 "set print raw-frame-arguments". */
3576 cmd
= add_setshow_boolean_cmd
3577 ("frame-arguments", no_class
,
3578 &user_frame_print_options
.print_raw_frame_arguments
,
3580 Set whether to print frame arguments in raw form."), _("\
3581 Show whether to print frame arguments in raw form."), _("\
3582 If set, frame arguments are printed in raw form, bypassing any\n\
3583 pretty-printers for that value."),
3585 &setprintrawlist
, &showprintrawlist
);
3586 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3588 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3589 &disassemble_next_line
, _("\
3590 Set whether to disassemble next source line or insn when execution stops."),
3592 Show whether to disassemble next source line or insn when execution stops."),
3594 If ON, GDB will display disassembly of the next source line, in addition\n\
3595 to displaying the source line itself. If the next source line cannot\n\
3596 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3597 will display disassembly of next instruction instead of showing the\n\
3599 If AUTO, display disassembly of next instruction only if the source line\n\
3600 cannot be displayed.\n\
3601 If OFF (which is the default), never display the disassembly of the next\n\
3604 show_disassemble_next_line
,
3605 &setlist
, &showlist
);
3606 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3608 gdb::option::add_setshow_cmds_for_options
3609 (class_stack
, &user_frame_print_options
,
3610 frame_print_option_defs
, &setprintlist
, &showprintlist
);