1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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 void set_last_displayed_sal (int valid
,
228 struct program_space
*pspace
,
230 struct symtab
*symtab
,
233 static struct frame_info
*find_frame_for_function (const char *);
234 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
236 /* Zero means do things normally; we are interacting directly with the
237 user. One means print the full filename and linenumber when a
238 frame is printed, and do so in a format emacs18/emacs19.22 can
239 parse. Two means print similar annotations, but in many more
240 cases and in a slightly different syntax. */
242 int annotation_level
= 0;
244 /* These variables hold the last symtab and line we displayed to the user.
245 * This is where we insert a breakpoint or a skiplist entry by default. */
246 static int last_displayed_sal_valid
= 0;
247 static struct program_space
*last_displayed_pspace
= 0;
248 static CORE_ADDR last_displayed_addr
= 0;
249 static struct symtab
*last_displayed_symtab
= 0;
250 static int last_displayed_line
= 0;
256 frame_show_address (struct frame_info
*frame
,
257 struct symtab_and_line sal
)
259 /* If there is a line number, but no PC, then there is no location
260 information associated with this sal. The only way that should
261 happen is for the call sites of inlined functions (SAL comes from
262 find_frame_sal). Otherwise, we would have some PC range if the
263 SAL came from a line table. */
264 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
266 if (get_next_frame (frame
) == NULL
)
267 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
269 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
273 return get_frame_pc (frame
) != sal
.pc
;
279 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
280 int print_level
, enum print_what print_what
,
283 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
285 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
288 /* Show or print a stack frame FRAME briefly. The output is formatted
289 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
290 relative level, function name, argument list, and file name and
291 line number. If the frame's PC is not at the beginning of the
292 source line, the actual PC is printed at the beginning. */
295 print_stack_frame (struct frame_info
*frame
, int print_level
,
296 enum print_what print_what
,
300 /* For mi, alway print location and address. */
301 if (current_uiout
->is_mi_like_p ())
302 print_what
= LOC_AND_ADDRESS
;
306 print_frame_info (user_frame_print_options
,
307 frame
, print_level
, print_what
, 1 /* print_args */,
310 set_current_sal_from_frame (frame
);
312 catch (const gdb_exception_error
&e
)
317 /* Print nameless arguments of frame FRAME on STREAM, where START is
318 the offset of the first nameless argument, and NUM is the number of
319 nameless arguments to print. FIRST is nonzero if this is the first
320 argument (not just the first nameless argument). */
323 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
324 int first
, struct ui_file
*stream
)
326 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
332 for (i
= 0; i
< num
; i
++)
335 argsaddr
= get_frame_args_address (frame
);
338 arg_value
= read_memory_integer (argsaddr
+ start
,
339 sizeof (int), byte_order
);
341 fprintf_filtered (stream
, ", ");
342 fprintf_filtered (stream
, "%ld", arg_value
);
344 start
+= sizeof (int);
348 /* Print single argument of inferior function. ARG must be already
351 Errors are printed as if they would be the parameter value. Use zeroed ARG
352 iff it should not be printed accoring to user settings. */
355 print_frame_arg (const frame_print_options
&fp_opts
,
356 const struct frame_arg
*arg
)
358 struct ui_out
*uiout
= current_uiout
;
362 gdb_assert (!arg
->val
|| !arg
->error
);
363 gdb_assert (arg
->entry_kind
== print_entry_values_no
364 || arg
->entry_kind
== print_entry_values_only
365 || (!uiout
->is_mi_like_p ()
366 && arg
->entry_kind
== print_entry_values_compact
));
368 annotate_arg_emitter arg_emitter
;
369 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
370 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
371 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
372 if (arg
->entry_kind
== print_entry_values_compact
)
374 /* It is OK to provide invalid MI-like stream as with
375 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
378 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
379 SYMBOL_LANGUAGE (arg
->sym
),
380 DMGL_PARAMS
| DMGL_ANSI
);
382 if (arg
->entry_kind
== print_entry_values_only
383 || arg
->entry_kind
== print_entry_values_compact
)
385 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
386 annotate_arg_name_end ();
390 if (!arg
->val
&& !arg
->error
)
396 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
397 style
= metadata_style
.style ();
403 const struct language_defn
*language
;
404 struct value_print_options vp_opts
;
406 /* Avoid value_print because it will deref ref parameters. We
407 just want to print their addresses. Print ??? for args whose
408 address we do not know. We pass 2 as "recurse" to val_print
409 because our standard indentation here is 4 spaces, and
410 val_print indents 2 for each recurse. */
412 annotate_arg_value (value_type (arg
->val
));
414 /* Use the appropriate language to display our symbol, unless the
415 user forced the language to a specific language. */
416 if (language_mode
== language_mode_auto
)
417 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
419 language
= current_language
;
421 get_no_prettyformat_print_options (&vp_opts
);
422 vp_opts
.deref_ref
= 1;
423 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
425 /* True in "summary" mode, false otherwise. */
427 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
429 common_val_print (arg
->val
, &stb
, 2, &vp_opts
, language
);
431 catch (const gdb_exception_error
&except
)
433 stb
.printf (_("<error reading variable: %s>"),
435 style
= metadata_style
.style ();
440 uiout
->field_stream ("value", stb
, style
);
443 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
444 responsible for xfree of ARGP->ERROR. This function never throws an
448 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
449 struct frame_arg
*argp
)
457 argp
->val
= read_var_value (sym
, NULL
, frame
);
459 catch (const gdb_exception_error
&except
)
461 argp
->error
.reset (xstrdup (except
.what ()));
465 /* Read in inferior function parameter SYM at FRAME into ARGP. This
466 function never throws an exception. */
469 read_frame_arg (const frame_print_options
&fp_opts
,
470 symbol
*sym
, frame_info
*frame
,
471 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
473 struct value
*val
= NULL
, *entryval
= NULL
;
474 char *val_error
= NULL
, *entryval_error
= NULL
;
477 if (fp_opts
.print_entry_values
!= print_entry_values_only
478 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
482 val
= read_var_value (sym
, NULL
, frame
);
484 catch (const gdb_exception_error
&except
)
486 val_error
= (char *) alloca (except
.message
->size () + 1);
487 strcpy (val_error
, except
.what ());
491 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
492 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
493 && fp_opts
.print_entry_values
!= print_entry_values_no
494 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
495 || !val
|| value_optimized_out (val
)))
499 const struct symbol_computed_ops
*ops
;
501 ops
= SYMBOL_COMPUTED_OPS (sym
);
502 entryval
= ops
->read_variable_at_entry (sym
, frame
);
504 catch (const gdb_exception_error
&except
)
506 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
508 entryval_error
= (char *) alloca (except
.message
->size () + 1);
509 strcpy (entryval_error
, except
.what ());
513 if (entryval
!= NULL
&& value_optimized_out (entryval
))
516 if (fp_opts
.print_entry_values
== print_entry_values_compact
517 || fp_opts
.print_entry_values
== print_entry_values_default
)
519 /* For MI do not try to use print_entry_values_compact for ARGP. */
521 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
523 struct type
*type
= value_type (val
);
525 if (value_lazy (val
))
526 value_fetch_lazy (val
);
527 if (value_lazy (entryval
))
528 value_fetch_lazy (entryval
);
530 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
532 /* Initialize it just to avoid a GCC false warning. */
533 struct value
*val_deref
= NULL
, *entryval_deref
;
535 /* DW_AT_call_value does match with the current
536 value. If it is a reference still try to verify if
537 dereferenced DW_AT_call_data_value does not differ. */
541 struct type
*type_deref
;
543 val_deref
= coerce_ref (val
);
544 if (value_lazy (val_deref
))
545 value_fetch_lazy (val_deref
);
546 type_deref
= value_type (val_deref
);
548 entryval_deref
= coerce_ref (entryval
);
549 if (value_lazy (entryval_deref
))
550 value_fetch_lazy (entryval_deref
);
552 /* If the reference addresses match but dereferenced
553 content does not match print them. */
555 && value_contents_eq (val_deref
, 0,
557 TYPE_LENGTH (type_deref
)))
560 catch (const gdb_exception_error
&except
)
562 /* If the dereferenced content could not be
563 fetched do not display anything. */
564 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
566 else if (except
.message
!= NULL
)
569 = (char *) alloca (except
.message
->size () + 1);
570 strcpy (entryval_error
, except
.what ());
574 /* Value was not a reference; and its content matches. */
575 if (val
== val_deref
)
583 /* Try to remove possibly duplicate error message for ENTRYARGP even
586 if (val_error
&& entryval_error
587 && strcmp (val_error
, entryval_error
) == 0)
589 entryval_error
= NULL
;
591 /* Do not se VAL_EQUAL as the same error message may be shown for
592 the entry value even if no entry values are present in the
598 if (entryval
== NULL
)
600 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
602 gdb_assert (val
== NULL
);
606 val
= read_var_value (sym
, NULL
, frame
);
608 catch (const gdb_exception_error
&except
)
610 val_error
= (char *) alloca (except
.message
->size () + 1);
611 strcpy (val_error
, except
.what ());
614 if (fp_opts
.print_entry_values
== print_entry_values_only
615 || fp_opts
.print_entry_values
== print_entry_values_both
616 || (fp_opts
.print_entry_values
== print_entry_values_preferred
617 && (!val
|| value_optimized_out (val
))))
619 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
620 entryval_error
= NULL
;
623 if ((fp_opts
.print_entry_values
== print_entry_values_compact
624 || fp_opts
.print_entry_values
== print_entry_values_if_needed
625 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
626 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
634 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
635 if (!val
&& !val_error
)
636 argp
->entry_kind
= print_entry_values_only
;
637 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
638 || fp_opts
.print_entry_values
== print_entry_values_default
)
641 argp
->entry_kind
= print_entry_values_compact
;
642 gdb_assert (!current_uiout
->is_mi_like_p ());
645 argp
->entry_kind
= print_entry_values_no
;
647 entryargp
->sym
= sym
;
648 entryargp
->val
= entryval
;
649 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
650 if (!entryval
&& !entryval_error
)
651 entryargp
->entry_kind
= print_entry_values_no
;
653 entryargp
->entry_kind
= print_entry_values_only
;
656 /* Print the arguments of frame FRAME on STREAM, given the function
657 FUNC running in that frame (as a symbol), where NUM is the number
658 of arguments according to the stack frame (or -1 if the number of
659 arguments is unknown). */
661 /* Note that currently the "number of arguments according to the
662 stack frame" is only known on VAX where i refers to the "number of
663 ints of arguments according to the stack frame". */
666 print_frame_args (const frame_print_options
&fp_opts
,
667 struct symbol
*func
, struct frame_info
*frame
,
668 int num
, struct ui_file
*stream
)
670 struct ui_out
*uiout
= current_uiout
;
672 /* Offset of next stack argument beyond the one we have seen that is
673 at the highest offset, or -1 if we haven't come to a stack
675 long highest_offset
= -1;
676 /* Number of ints of arguments that we have printed so far. */
677 int args_printed
= 0;
678 /* True if we should print arg names. If false, we only indicate
679 the presence of arguments by printing ellipsis. */
681 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
682 /* True if we should print arguments, false otherwise. */
685 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
689 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
690 struct block_iterator iter
;
693 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
695 struct frame_arg arg
, entryarg
;
699 /* Keep track of the highest stack argument offset seen, and
700 skip over any kinds of symbols we don't care about. */
702 if (!SYMBOL_IS_ARGUMENT (sym
))
712 switch (SYMBOL_CLASS (sym
))
717 long current_offset
= SYMBOL_VALUE (sym
);
718 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
720 /* Compute address of next argument by adding the size of
721 this argument and rounding to an int boundary. */
723 ((current_offset
+ arg_size
+ sizeof (int) - 1)
724 & ~(sizeof (int) - 1));
726 /* If this is the highest offset seen yet, set
728 if (highest_offset
== -1
729 || (current_offset
> highest_offset
))
730 highest_offset
= current_offset
;
732 /* Add the number of ints we're about to print to
734 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
737 /* We care about types of symbols, but don't need to
738 keep track of stack offsets in them. */
740 case LOC_REGPARM_ADDR
:
742 case LOC_OPTIMIZED_OUT
:
747 /* We have to look up the symbol because arguments can have
748 two entries (one a parameter, one a local) and the one we
749 want is the local, which lookup_symbol will find for us.
750 This includes gcc1 (not gcc2) on SPARC when passing a
751 small structure and gcc2 when the argument type is float
752 and it is passed as a double and converted to float by
753 the prologue (in the latter case the type of the LOC_ARG
754 symbol is double and the type of the LOC_LOCAL symbol is
756 /* But if the parameter name is null, don't try it. Null
757 parameter names occur on the RS/6000, for traceback
758 tables. FIXME, should we even print them? */
760 if (*SYMBOL_LINKAGE_NAME (sym
))
764 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
765 b
, VAR_DOMAIN
).symbol
;
766 gdb_assert (nsym
!= NULL
);
767 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
768 && !SYMBOL_IS_ARGUMENT (nsym
))
770 /* There is a LOC_ARG/LOC_REGISTER pair. This means
771 that it was passed on the stack and loaded into a
772 register, or passed in a register and stored in a
773 stack slot. GDB 3.x used the LOC_ARG; GDB
774 4.0-4.11 used the LOC_REGISTER.
776 Reasons for using the LOC_ARG:
778 (1) Because find_saved_registers may be slow for
781 (2) Because registers are often re-used and stack
782 slots rarely (never?) are. Therefore using
783 the stack slot is much less likely to print
786 Reasons why we might want to use the LOC_REGISTER:
788 (1) So that the backtrace prints the same value
789 as "print foo". I see no compelling reason
790 why this needs to be the case; having the
791 backtrace print the value which was passed
792 in, and "print foo" print the value as
793 modified within the called function, makes
796 Additional note: It might be nice if "info args"
797 displayed both values.
799 One more note: There is a case with SPARC
800 structure passing where we need to use the
801 LOC_REGISTER, but this is dealt with by creating
802 a single LOC_REGPARM in symbol reading. */
804 /* Leave sym (the LOC_ARG) alone. */
811 /* Print the current arg. */
814 uiout
->wrap_hint (" ");
819 arg
.entry_kind
= print_entry_values_no
;
821 entryarg
.entry_kind
= print_entry_values_no
;
824 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
826 if (arg
.entry_kind
!= print_entry_values_only
)
827 print_frame_arg (fp_opts
, &arg
);
829 if (entryarg
.entry_kind
!= print_entry_values_no
)
831 if (arg
.entry_kind
!= print_entry_values_only
)
834 uiout
->wrap_hint (" ");
837 print_frame_arg (fp_opts
, &entryarg
);
844 /* Don't print nameless args in situations where we don't know
845 enough about the stack to find them. */
850 if (highest_offset
== -1)
851 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
853 start
= highest_offset
;
855 if (!print_names
&& !first
&& num
> 0)
858 print_frame_nameless_args (frame
, start
, num
- args_printed
,
863 /* Set the current source and line to the location given by frame
864 FRAME, if possible. When CENTER is true, adjust so the relevant
865 line is in the center of the next 'list'. */
868 set_current_sal_from_frame (struct frame_info
*frame
)
870 symtab_and_line sal
= find_frame_sal (frame
);
871 if (sal
.symtab
!= NULL
)
872 set_current_source_symtab_and_line (sal
);
875 /* If ON, GDB will display disassembly of the next source line when
876 execution of the program being debugged stops.
877 If AUTO (which is the default), or there's no line info to determine
878 the source line of the next instruction, display disassembly of next
879 instruction instead. */
881 static enum auto_boolean disassemble_next_line
;
884 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
885 struct cmd_list_element
*c
,
888 fprintf_filtered (file
,
889 _("Debugger's willingness to use "
890 "disassemble-next-line is %s.\n"),
894 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
895 because it will be broken by filter sometime. */
898 do_gdb_disassembly (struct gdbarch
*gdbarch
,
899 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
904 gdb_disassembly (gdbarch
, current_uiout
,
905 DISASSEMBLY_RAW_INSN
, how_many
,
908 catch (const gdb_exception_error
&exception
)
910 /* If an exception was thrown while doing the disassembly, print
911 the error message, to give the user a clue of what happened. */
912 exception_print (gdb_stderr
, exception
);
916 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
917 Value not present indicates to the caller to use default values
918 specific to the command being executed. */
920 static gdb::optional
<enum print_what
>
921 print_frame_info_to_print_what (const char *print_frame_info
)
923 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
924 if (print_frame_info
== print_frame_info_choices
[i
])
925 return print_frame_info_print_what
[i
];
927 internal_error (__FILE__
, __LINE__
,
928 "Unexpected print frame-info value `%s'.",
932 /* Print the PC from FRAME, plus any flags, to UIOUT. */
935 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info
*frame
,
938 uiout
->field_core_addr ("addr", gdbarch
, pc
);
940 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
944 uiout
->field_string ("addr_flags", flags
);
952 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
955 = print_frame_info_to_print_what
956 (user_frame_print_options
.print_frame_info
);
959 /* Print information about frame FRAME. The output is format according
960 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
961 PRINT_WHAT, see enum print_what comments in frame.h.
962 Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info
963 != print_frame_info_auto.
965 Used in "where" output, and to emit breakpoint or step
969 print_frame_info (const frame_print_options
&fp_opts
,
970 frame_info
*frame
, int print_level
,
971 enum print_what print_what
, int print_args
,
974 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
977 struct ui_out
*uiout
= current_uiout
;
979 if (!current_uiout
->is_mi_like_p ()
980 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
982 /* Use the specific frame information desired by the user. */
983 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
986 if (get_frame_type (frame
) == DUMMY_FRAME
987 || get_frame_type (frame
) == SIGTRAMP_FRAME
988 || get_frame_type (frame
) == ARCH_FRAME
)
990 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
992 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
993 gdbarch
, get_frame_pc (frame
));
995 /* Do this regardless of SOURCE because we don't have any source
996 to list for this frame. */
1000 uiout
->field_fmt_signed (2, ui_left
, "level",
1001 frame_relative_level (frame
));
1003 if (uiout
->is_mi_like_p ())
1005 annotate_frame_address ();
1006 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1007 annotate_frame_address_end ();
1010 if (get_frame_type (frame
) == DUMMY_FRAME
)
1012 annotate_function_call ();
1013 uiout
->field_string ("func", "<function called from gdb>",
1014 metadata_style
.style ());
1016 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1018 annotate_signal_handler_caller ();
1019 uiout
->field_string ("func", "<signal handler called>",
1020 metadata_style
.style ());
1022 else if (get_frame_type (frame
) == ARCH_FRAME
)
1024 uiout
->field_string ("func", "<cross-architecture call>",
1025 metadata_style
.style ());
1028 annotate_frame_end ();
1030 /* If disassemble-next-line is set to auto or on output the next
1032 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1033 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1034 do_gdb_disassembly (get_frame_arch (frame
), 1,
1035 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1040 /* If FRAME is not the innermost frame, that normally means that
1041 FRAME->pc points to *after* the call instruction, and we want to
1042 get the line containing the call, never the next line. But if
1043 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1044 next frame was not entered as the result of a call, and we want
1045 to get the line containing FRAME->pc. */
1046 symtab_and_line sal
= find_frame_sal (frame
);
1048 location_print
= (print_what
== LOCATION
1049 || print_what
== SRC_AND_LOC
1050 || print_what
== LOC_AND_ADDRESS
1051 || print_what
== SHORT_LOCATION
);
1052 if (location_print
|| !sal
.symtab
)
1053 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1055 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1057 /* If disassemble-next-line is set to auto or on and doesn't have
1058 the line debug messages for $pc, output the next instruction. */
1059 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1060 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1061 && source_print
&& !sal
.symtab
)
1062 do_gdb_disassembly (get_frame_arch (frame
), 1,
1063 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1065 if (source_print
&& sal
.symtab
)
1067 int mid_statement
= ((print_what
== SRC_LINE
)
1068 && frame_show_address (frame
, sal
));
1069 annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1070 get_frame_pc (frame
));
1072 if (deprecated_print_frame_info_listing_hook
)
1073 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1077 struct value_print_options opts
;
1079 get_user_print_options (&opts
);
1080 /* We used to do this earlier, but that is clearly
1081 wrong. This function is used by many different
1082 parts of gdb, including normal_stop in infrun.c,
1083 which uses this to print out the current PC
1084 when we stepi/nexti into the middle of a source
1085 line. Only the command line really wants this
1086 behavior. Other UIs probably would like the
1087 ability to decide for themselves if it is desired. */
1088 if (opts
.addressprint
&& mid_statement
)
1090 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1094 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1098 /* If disassemble-next-line is set to on and there is line debug
1099 messages, output assembly codes for next line. */
1100 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1101 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1103 if (set_current_sal
)
1107 if (get_frame_pc_if_available (frame
, &pc
))
1108 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1110 set_last_displayed_sal (0, 0, 0, 0, 0);
1113 annotate_frame_end ();
1115 gdb_flush (gdb_stdout
);
1118 /* Remember the last symtab and line we displayed, which we use e.g.
1119 * as the place to put a breakpoint when the `break' command is
1120 * invoked with no arguments. */
1123 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
1124 CORE_ADDR addr
, struct symtab
*symtab
,
1127 last_displayed_sal_valid
= valid
;
1128 last_displayed_pspace
= pspace
;
1129 last_displayed_addr
= addr
;
1130 last_displayed_symtab
= symtab
;
1131 last_displayed_line
= line
;
1132 if (valid
&& pspace
== NULL
)
1134 clear_last_displayed_sal ();
1135 internal_error (__FILE__
, __LINE__
,
1136 _("Trying to set NULL pspace."));
1140 /* Forget the last sal we displayed. */
1143 clear_last_displayed_sal (void)
1145 last_displayed_sal_valid
= 0;
1146 last_displayed_pspace
= 0;
1147 last_displayed_addr
= 0;
1148 last_displayed_symtab
= 0;
1149 last_displayed_line
= 0;
1152 /* Is our record of the last sal we displayed valid? If not,
1153 * the get_last_displayed_* functions will return NULL or 0, as
1157 last_displayed_sal_is_valid (void)
1159 return last_displayed_sal_valid
;
1162 /* Get the pspace of the last sal we displayed, if it's valid. */
1164 struct program_space
*
1165 get_last_displayed_pspace (void)
1167 if (last_displayed_sal_valid
)
1168 return last_displayed_pspace
;
1172 /* Get the address of the last sal we displayed, if it's valid. */
1175 get_last_displayed_addr (void)
1177 if (last_displayed_sal_valid
)
1178 return last_displayed_addr
;
1182 /* Get the symtab of the last sal we displayed, if it's valid. */
1185 get_last_displayed_symtab (void)
1187 if (last_displayed_sal_valid
)
1188 return last_displayed_symtab
;
1192 /* Get the line of the last sal we displayed, if it's valid. */
1195 get_last_displayed_line (void)
1197 if (last_displayed_sal_valid
)
1198 return last_displayed_line
;
1202 /* Get the last sal we displayed, if it's valid. */
1205 get_last_displayed_sal ()
1207 symtab_and_line sal
;
1209 if (last_displayed_sal_valid
)
1211 sal
.pspace
= last_displayed_pspace
;
1212 sal
.pc
= last_displayed_addr
;
1213 sal
.symtab
= last_displayed_symtab
;
1214 sal
.line
= last_displayed_line
;
1221 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1222 corresponding to FRAME. */
1224 gdb::unique_xmalloc_ptr
<char>
1225 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1226 struct symbol
**funcp
)
1228 struct symbol
*func
;
1229 gdb::unique_xmalloc_ptr
<char> funname
;
1231 *funlang
= language_unknown
;
1235 func
= get_frame_function (frame
);
1238 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1240 *funlang
= SYMBOL_LANGUAGE (func
);
1243 if (*funlang
== language_cplus
)
1245 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1246 to display the demangled name that we already have
1247 stored in the symbol table, but we stored a version
1248 with DMGL_PARAMS turned on, and here we don't want to
1249 display parameters. So remove the parameters. */
1250 funname
= cp_remove_params (print_name
);
1253 /* If we didn't hit the C++ case above, set *funname
1255 if (funname
== NULL
)
1256 funname
.reset (xstrdup (print_name
));
1260 struct bound_minimal_symbol msymbol
;
1263 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1266 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1267 if (msymbol
.minsym
!= NULL
)
1269 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1270 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1278 print_frame (const frame_print_options
&fp_opts
,
1279 frame_info
*frame
, int print_level
,
1280 enum print_what print_what
, int print_args
,
1281 struct symtab_and_line sal
)
1283 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1284 struct ui_out
*uiout
= current_uiout
;
1285 enum language funlang
= language_unknown
;
1286 struct value_print_options opts
;
1287 struct symbol
*func
;
1291 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1293 gdb::unique_xmalloc_ptr
<char> funname
1294 = find_frame_funname (frame
, &funlang
, &func
);
1296 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1300 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1305 uiout
->field_fmt_signed (2, ui_left
, "level",
1306 frame_relative_level (frame
));
1308 get_user_print_options (&opts
);
1309 if (opts
.addressprint
)
1311 || frame_show_address (frame
, sal
)
1312 || print_what
== LOC_AND_ADDRESS
)
1314 annotate_frame_address ();
1316 print_pc (uiout
, gdbarch
, frame
, pc
);
1318 uiout
->field_string ("addr", "<unavailable>",
1319 metadata_style
.style ());
1320 annotate_frame_address_end ();
1321 uiout
->text (" in ");
1323 annotate_frame_function_name ();
1326 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1327 funlang
, DMGL_ANSI
);
1328 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1329 uiout
->wrap_hint (" ");
1330 annotate_frame_args ();
1337 if (gdbarch_frame_num_args_p (gdbarch
))
1339 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1340 gdb_assert (numargs
>= 0);
1346 ui_out_emit_list
list_emitter (uiout
, "args");
1349 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1351 catch (const gdb_exception_error
&e
)
1355 /* FIXME: ARGS must be a list. If one argument is a string it
1356 will have " that will not be properly escaped. */
1361 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1363 const char *filename_display
;
1365 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1366 annotate_frame_source_begin ();
1367 uiout
->wrap_hint (" ");
1368 uiout
->text (" at ");
1369 annotate_frame_source_file ();
1370 uiout
->field_string ("file", filename_display
,
1371 file_name_style
.style ());
1372 if (uiout
->is_mi_like_p ())
1374 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1376 uiout
->field_string ("fullname", fullname
);
1378 annotate_frame_source_file_end ();
1380 annotate_frame_source_line ();
1381 uiout
->field_signed ("line", sal
.line
);
1382 annotate_frame_source_end ();
1385 if (print_what
!= SHORT_LOCATION
1386 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1388 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1389 get_frame_pc (frame
));
1393 annotate_frame_where ();
1394 uiout
->wrap_hint (" ");
1395 uiout
->text (" from ");
1396 uiout
->field_string ("from", lib
);
1399 if (uiout
->is_mi_like_p ())
1400 uiout
->field_string ("arch",
1401 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1408 /* Completion function for "frame function", "info frame function", and
1409 "select-frame function" commands. */
1412 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1413 completion_tracker
&tracker
,
1414 const char *text
, const char *word
)
1416 /* This is used to complete function names within a stack. It would be
1417 nice if we only offered functions that were actually in the stack.
1418 However, this would mean unwinding the stack to completion, which
1419 could take too long, or on a corrupted stack, possibly not end.
1420 Instead, we offer all symbol names as a safer choice. */
1421 collect_symbol_completion_matches (tracker
,
1422 complete_symbol_mode::EXPRESSION
,
1423 symbol_name_match_type::EXPRESSION
,
1427 /* Core of all the "info frame" sub-commands. Print information about a
1428 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1429 frame specification, they just entered 'info frame'. If the user did
1430 provide a frame specification (for example 'info frame 0', 'info frame
1431 level 1') then SELECTED_FRAME_P will be false. */
1434 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1436 struct symbol
*func
;
1438 struct frame_info
*calling_frame_info
;
1440 const char *funname
= 0;
1441 enum language funlang
= language_unknown
;
1442 const char *pc_regname
;
1443 struct gdbarch
*gdbarch
;
1446 /* Initialize it to avoid "may be used uninitialized" warning. */
1447 CORE_ADDR caller_pc
= 0;
1448 int caller_pc_p
= 0;
1450 gdbarch
= get_frame_arch (fi
);
1452 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1453 is not a good name. */
1454 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1455 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1456 easily not match that of the internal value returned by
1458 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1460 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1461 architectures will often have a hardware register called "pc",
1462 and that register's value, again, can easily not match
1466 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1467 func
= get_frame_function (fi
);
1468 symtab_and_line sal
= find_frame_sal (fi
);
1470 gdb::unique_xmalloc_ptr
<char> func_only
;
1473 funname
= SYMBOL_PRINT_NAME (func
);
1474 funlang
= SYMBOL_LANGUAGE (func
);
1475 if (funlang
== language_cplus
)
1477 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1478 to display the demangled name that we already have
1479 stored in the symbol table, but we stored a version
1480 with DMGL_PARAMS turned on, and here we don't want to
1481 display parameters. So remove the parameters. */
1482 func_only
= cp_remove_params (funname
);
1485 funname
= func_only
.get ();
1488 else if (frame_pc_p
)
1490 struct bound_minimal_symbol msymbol
;
1492 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1493 if (msymbol
.minsym
!= NULL
)
1495 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1496 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1499 calling_frame_info
= get_prev_frame (fi
);
1501 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1503 printf_filtered (_("Stack level %d, frame at "),
1504 frame_relative_level (fi
));
1508 printf_filtered (_("Stack frame at "));
1510 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1511 printf_filtered (":\n");
1512 printf_filtered (" %s = ", pc_regname
);
1514 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1516 fputs_styled ("<unavailable>", metadata_style
.style (), gdb_stdout
);
1521 printf_filtered (" in ");
1522 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1523 DMGL_ANSI
| DMGL_PARAMS
);
1527 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1529 puts_filtered ("; ");
1531 printf_filtered ("saved %s = ", pc_regname
);
1533 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1534 val_print_not_saved (gdb_stdout
);
1539 caller_pc
= frame_unwind_caller_pc (fi
);
1542 catch (const gdb_exception_error
&ex
)
1546 case NOT_AVAILABLE_ERROR
:
1547 val_print_unavailable (gdb_stdout
);
1549 case OPTIMIZED_OUT_ERROR
:
1550 val_print_not_saved (gdb_stdout
);
1553 fprintf_styled (gdb_stdout
, metadata_style
.style (),
1562 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1563 printf_filtered ("\n");
1565 if (calling_frame_info
== NULL
)
1567 enum unwind_stop_reason reason
;
1569 reason
= get_frame_unwind_stop_reason (fi
);
1570 if (reason
!= UNWIND_NO_REASON
)
1571 printf_filtered (_(" Outermost frame: %s\n"),
1572 frame_stop_reason_string (fi
));
1574 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1575 puts_filtered (" tail call frame");
1576 else if (get_frame_type (fi
) == INLINE_FRAME
)
1577 printf_filtered (" inlined into frame %d",
1578 frame_relative_level (get_prev_frame (fi
)));
1581 printf_filtered (" called by frame at ");
1582 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1585 if (get_next_frame (fi
) && calling_frame_info
)
1586 puts_filtered (",");
1588 if (get_next_frame (fi
))
1590 printf_filtered (" caller of frame at ");
1591 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1594 if (get_next_frame (fi
) || calling_frame_info
)
1595 puts_filtered ("\n");
1598 printf_filtered (" source language %s.\n",
1599 language_str (s
->language
));
1602 /* Address of the argument list for this frame, or 0. */
1603 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1604 /* Number of args for this frame, or -1 if unknown. */
1608 printf_filtered (" Arglist at unknown address.\n");
1611 printf_filtered (" Arglist at ");
1612 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1613 printf_filtered (",");
1615 if (!gdbarch_frame_num_args_p (gdbarch
))
1618 puts_filtered (" args: ");
1622 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1623 gdb_assert (numargs
>= 0);
1625 puts_filtered (" no args.");
1626 else if (numargs
== 1)
1627 puts_filtered (" 1 arg: ");
1629 printf_filtered (" %d args: ", numargs
);
1631 print_frame_args (user_frame_print_options
,
1632 func
, fi
, numargs
, gdb_stdout
);
1633 puts_filtered ("\n");
1637 /* Address of the local variables for this frame, or 0. */
1638 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1641 printf_filtered (" Locals at unknown address,");
1644 printf_filtered (" Locals at ");
1645 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1646 printf_filtered (",");
1650 /* Print as much information as possible on the location of all the
1656 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1658 /* The sp is special; what's displayed isn't the save address, but
1659 the value of the previous frame's sp. This is a legacy thing,
1660 at one stage the frame cached the previous frame's SP instead
1661 of its address, hence it was easiest to just display the cached
1665 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1666 gdb_assert (value
!= NULL
);
1668 if (!value_optimized_out (value
) && value_entirely_available (value
))
1670 if (VALUE_LVAL (value
) == not_lval
)
1673 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1674 int sp_size
= register_size (gdbarch
, sp_regnum
);
1676 sp
= extract_unsigned_integer (value_contents_all (value
),
1677 sp_size
, byte_order
);
1679 printf_filtered (" Previous frame's sp is ");
1680 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1681 printf_filtered ("\n");
1683 else if (VALUE_LVAL (value
) == lval_memory
)
1685 printf_filtered (" Previous frame's sp at ");
1686 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1688 printf_filtered ("\n");
1690 else if (VALUE_LVAL (value
) == lval_register
)
1692 printf_filtered (" Previous frame's sp in %s\n",
1693 gdbarch_register_name (gdbarch
,
1694 VALUE_REGNUM (value
)));
1697 release_value (value
);
1700 /* else keep quiet. */
1704 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1705 for (i
= 0; i
< numregs
; i
++)
1707 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1709 enum lval_type lval
;
1715 /* Find out the location of the saved register without
1716 fetching the corresponding value. */
1717 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1718 &lval
, &addr
, &realnum
, NULL
);
1719 /* For moment, only display registers that were saved on the
1721 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1724 puts_filtered (" Saved registers:\n ");
1726 puts_filtered (",");
1728 printf_filtered (" %s at ",
1729 gdbarch_register_name (gdbarch
, i
));
1730 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1734 if (count
|| need_nl
)
1735 puts_filtered ("\n");
1739 /* Return the innermost frame at level LEVEL. */
1741 static struct frame_info
*
1742 leading_innermost_frame (int level
)
1744 struct frame_info
*leading
;
1746 leading
= get_current_frame ();
1748 gdb_assert (level
>= 0);
1750 while (leading
!= nullptr && level
)
1753 leading
= get_prev_frame (leading
);
1760 /* Return the starting frame needed to handle COUNT outermost frames. */
1762 static struct frame_info
*
1763 trailing_outermost_frame (int count
)
1765 struct frame_info
*current
;
1766 struct frame_info
*trailing
;
1768 trailing
= get_current_frame ();
1770 gdb_assert (count
> 0);
1773 while (current
!= nullptr && count
--)
1776 current
= get_prev_frame (current
);
1779 /* Will stop when CURRENT reaches the top of the stack.
1780 TRAILING will be COUNT below it. */
1781 while (current
!= nullptr)
1784 trailing
= get_prev_frame (trailing
);
1785 current
= get_prev_frame (current
);
1791 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1795 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1797 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1799 if (get_selected_frame_if_set () != prev_frame
)
1800 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1806 select_frame_for_mi (struct frame_info
*fi
)
1808 select_frame_command_core (fi
, false /* Ignored. */);
1811 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1812 means we change frame send out a change notification (otherwise, just
1813 reprint the current frame summary). */
1816 frame_command_core (struct frame_info
*fi
, bool ignored
)
1818 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1821 if (get_selected_frame_if_set () != prev_frame
)
1822 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1824 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1827 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1828 common set of sub-commands that allow a specific frame to be selected.
1829 All of the sub-command functions are static methods within this class
1830 template which is then instantiated below. The template parameter is a
1831 callback used to implement the functionality of the base command
1832 ('frame', 'select-frame', or 'info frame').
1834 In the template parameter FI is the frame being selected. The
1835 SELECTED_FRAME_P flag is true if the frame being selected was done by
1836 default, which happens when the user uses the base command with no
1837 arguments. For example the commands 'info frame', 'select-frame',
1838 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1839 SELECTED_FRAME_P is false. */
1841 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1842 class frame_command_helper
1846 /* The "frame level" family of commands. The ARG is an integer that is
1847 the frame's level in the stack. */
1849 level (const char *arg
, int from_tty
)
1851 int level
= value_as_long (parse_and_eval (arg
));
1852 struct frame_info
*fid
1853 = find_relative_frame (get_current_frame (), &level
);
1855 error (_("No frame at level %s."), arg
);
1859 /* The "frame address" family of commands. ARG is a stack-pointer
1860 address for an existing frame. This command does not allow new
1861 frames to be created. */
1864 address (const char *arg
, int from_tty
)
1866 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1867 struct frame_info
*fid
= find_frame_for_address (addr
);
1869 error (_("No frame at address %s."), arg
);
1873 /* The "frame view" family of commands. ARG is one or two addresses and
1874 is used to view a frame that might be outside the current backtrace.
1875 The addresses are stack-pointer address, and (optional) pc-address. */
1878 view (const char *args
, int from_tty
)
1880 struct frame_info
*fid
;
1883 error (_("Missing address argument to view a frame"));
1885 gdb_argv
argv (args
);
1887 if (argv
.count () == 2)
1891 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1892 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1893 fid
= create_new_frame (addr
[0], addr
[1]);
1897 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1898 fid
= create_new_frame (addr
, false);
1903 /* The "frame function" family of commands. ARG is the name of a
1904 function within the stack, the first function (searching from frame
1905 0) with that name will be selected. */
1908 function (const char *arg
, int from_tty
)
1911 error (_("Missing function name argument"));
1912 struct frame_info
*fid
= find_frame_for_function (arg
);
1914 error (_("No frame for function \"%s\"."), arg
);
1918 /* The "frame" base command, that is, when no sub-command is specified.
1919 If one argument is provided then we assume that this is a frame's
1920 level as historically, this was the supported command syntax that was
1923 If no argument is provided, then the current frame is selected. */
1926 base_command (const char *arg
, int from_tty
)
1929 FPTR (get_selected_frame (_("No stack.")), true);
1931 level (arg
, from_tty
);
1935 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1936 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1938 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1939 static frame_command_helper
<frame_command_core
> frame_cmd
;
1940 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1942 /* Print briefly all stack frames or just the innermost COUNT_EXP
1946 backtrace_command_1 (const frame_print_options
&fp_opts
,
1947 const backtrace_cmd_options
&bt_opts
,
1948 const char *count_exp
, int from_tty
)
1951 struct frame_info
*fi
;
1953 int py_start
= 0, py_end
= 0;
1954 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1956 if (!target_has_stack
)
1957 error (_("No stack."));
1961 count
= parse_and_eval_long (count_exp
);
1967 /* The argument to apply_ext_lang_frame_filter is the number
1968 of the final frame to print, and frames start at 0. */
1978 frame_filter_flags flags
= 0;
1981 flags
|= PRINT_LOCALS
;
1983 flags
|= PRINT_HIDE
;
1985 if (!bt_opts
.no_filters
)
1987 enum ext_lang_frame_args arg_type
;
1989 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1991 flags
|= PRINT_MORE_FRAMES
;
1993 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
1994 arg_type
= CLI_SCALAR_VALUES
;
1995 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
1996 arg_type
= CLI_ALL_VALUES
;
1997 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
1998 arg_type
= CLI_PRESENCE
;
1999 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
2000 arg_type
= NO_VALUES
;
2004 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
2005 arg_type
, current_uiout
,
2009 /* Run the inbuilt backtrace if there are no filters registered, or
2010 "-no-filters" has been specified from the command. */
2011 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2013 struct frame_info
*trailing
;
2015 /* The following code must do two things. First, it must set the
2016 variable TRAILING to the frame from which we should start
2017 printing. Second, it must set the variable count to the number
2018 of frames which we should print, or -1 if all of them. */
2020 if (count_exp
!= NULL
&& count
< 0)
2022 trailing
= trailing_outermost_frame (-count
);
2026 trailing
= get_current_frame ();
2028 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2032 /* Don't use print_stack_frame; if an error() occurs it probably
2033 means further attempts to backtrace would fail (on the other
2034 hand, perhaps the code does or could be fixed to make sure
2035 the frame->prev field gets set to NULL in that case). */
2037 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2038 if ((flags
& PRINT_LOCALS
) != 0)
2040 struct frame_id frame_id
= get_frame_id (fi
);
2042 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2044 /* print_frame_local_vars invalidates FI. */
2045 fi
= frame_find_by_id (frame_id
);
2049 warning (_("Unable to restore previously selected frame."));
2054 /* Save the last frame to check for error conditions. */
2058 /* If we've stopped before the end, mention that. */
2060 printf_filtered (_("(More stack frames follow...)\n"));
2062 /* If we've run out of frames, and the reason appears to be an error
2063 condition, print it. */
2064 if (fi
== NULL
&& trailing
!= NULL
)
2066 enum unwind_stop_reason reason
;
2068 reason
= get_frame_unwind_stop_reason (trailing
);
2069 if (reason
>= UNWIND_FIRST_ERROR
)
2070 printf_filtered (_("Backtrace stopped: %s\n"),
2071 frame_stop_reason_string (trailing
));
2076 /* Create an option_def_group array grouping all the "backtrace"
2077 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2079 static inline std::array
<gdb::option::option_def_group
, 3>
2080 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2081 backtrace_cmd_options
*bt_cmd_opts
,
2082 set_backtrace_options
*set_bt_opts
)
2085 { {frame_print_option_defs
}, fp_opts
},
2086 { {set_backtrace_option_defs
}, set_bt_opts
},
2087 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2091 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2092 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2093 store the parsed qualifiers. */
2096 parse_backtrace_qualifiers (const char *arg
,
2097 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2101 const char *save_arg
= arg
;
2102 std::string this_arg
= extract_arg (&arg
);
2104 if (this_arg
.empty ())
2107 if (subset_compare (this_arg
.c_str (), "no-filters"))
2109 if (bt_cmd_opts
!= nullptr)
2110 bt_cmd_opts
->no_filters
= true;
2112 else if (subset_compare (this_arg
.c_str (), "full"))
2114 if (bt_cmd_opts
!= nullptr)
2115 bt_cmd_opts
->full
= true;
2117 else if (subset_compare (this_arg
.c_str (), "hide"))
2119 if (bt_cmd_opts
!= nullptr)
2120 bt_cmd_opts
->hide
= true;
2124 /* Not a recognized qualifier, so stop. */
2131 backtrace_command (const char *arg
, int from_tty
)
2133 frame_print_options fp_opts
= user_frame_print_options
;
2134 backtrace_cmd_options bt_cmd_opts
;
2135 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2138 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2139 gdb::option::process_options
2140 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2142 /* Parse non-'-'-prefixed qualifiers, for backwards
2146 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2151 /* These options are handled quite deep in the unwind machinery, so
2152 we get to pass them down by swapping globals. */
2153 scoped_restore restore_set_backtrace_options
2154 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2156 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2159 /* Completer for the "backtrace" command. */
2162 backtrace_command_completer (struct cmd_list_element
*ignore
,
2163 completion_tracker
&tracker
,
2164 const char *text
, const char */
*word*/
)
2167 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2168 if (gdb::option::complete_options
2169 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2174 const char *p
= skip_to_space (text
);
2177 static const char *const backtrace_cmd_qualifier_choices
[] = {
2178 "full", "no-filters", "hide", nullptr,
2180 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2183 if (tracker
.have_completions ())
2188 const char *cmd
= parse_backtrace_qualifiers (text
);
2189 tracker
.advance_custom_word_point_by (cmd
- text
);
2194 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2195 expression_completer (ignore
, tracker
, text
, word
);
2198 /* Iterate over the local variables of a block B, calling CB with
2202 iterate_over_block_locals (const struct block
*b
,
2203 iterate_over_block_arg_local_vars_cb cb
,
2206 struct block_iterator iter
;
2209 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2211 switch (SYMBOL_CLASS (sym
))
2217 case LOC_OPTIMIZED_OUT
:
2218 if (SYMBOL_IS_ARGUMENT (sym
))
2220 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2222 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
2226 /* Ignore symbols which are not locals. */
2233 /* Same, but print labels. */
2236 /* Commented out, as the code using this function has also been
2237 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2238 was commented out in the first place. The discussion introducing
2239 this change (2007-12-04: Support lexical blocks and function bodies
2240 that occupy non-contiguous address ranges) did not explain why
2241 this change was made. */
2243 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2244 int *have_default
, struct ui_file
*stream
)
2246 struct block_iterator iter
;
2248 int values_printed
= 0;
2250 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2252 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2258 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2260 struct symtab_and_line sal
;
2261 struct value_print_options opts
;
2263 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2265 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2266 get_user_print_options (&opts
);
2267 if (opts
.addressprint
)
2269 fprintf_filtered (stream
, " ");
2270 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2273 fprintf_filtered (stream
, " in file %s, line %d\n",
2274 sal
.symtab
->filename
, sal
.line
);
2278 return values_printed
;
2282 /* Iterate over all the local variables in block B, including all its
2283 superblocks, stopping when the top-level block is reached. */
2286 iterate_over_block_local_vars (const struct block
*block
,
2287 iterate_over_block_arg_local_vars_cb cb
,
2292 iterate_over_block_locals (block
, cb
, cb_data
);
2293 /* After handling the function's top-level block, stop. Don't
2294 continue to its superblock, the block of per-file
2296 if (BLOCK_FUNCTION (block
))
2298 block
= BLOCK_SUPERBLOCK (block
);
2302 /* Data to be passed around in the calls to the locals and args
2305 struct print_variable_and_value_data
2307 gdb::optional
<compiled_regex
> preg
;
2308 gdb::optional
<compiled_regex
> treg
;
2309 struct frame_id frame_id
;
2311 struct ui_file
*stream
;
2315 /* The callback for the locals and args iterators. */
2318 do_print_variable_and_value (const char *print_name
,
2322 struct print_variable_and_value_data
*p
2323 = (struct print_variable_and_value_data
*) cb_data
;
2324 struct frame_info
*frame
;
2326 if (p
->preg
.has_value ()
2327 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2330 if (p
->treg
.has_value ()
2331 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2334 frame
= frame_find_by_id (p
->frame_id
);
2337 warning (_("Unable to restore previously selected frame."));
2341 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2343 /* print_variable_and_value invalidates FRAME. */
2346 p
->values_printed
= 1;
2349 /* Prepares the regular expression REG from REGEXP.
2350 If REGEXP is NULL, it results in an empty regular expression. */
2353 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2357 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2359 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2365 /* Print all variables from the innermost up to the function block of FRAME.
2366 Print them with values to STREAM indented by NUM_TABS.
2367 If REGEXP is not NULL, only print local variables whose name
2369 If T_REGEXP is not NULL, only print local variables whose type
2371 If no local variables have been printed and !QUIET, prints a message
2372 explaining why no local variables could be printed.
2374 This function will invalidate FRAME. */
2377 print_frame_local_vars (struct frame_info
*frame
,
2379 const char *regexp
, const char *t_regexp
,
2380 int num_tabs
, struct ui_file
*stream
)
2382 struct print_variable_and_value_data cb_data
;
2383 const struct block
*block
;
2386 if (!get_frame_pc_if_available (frame
, &pc
))
2389 fprintf_filtered (stream
,
2390 _("PC unavailable, cannot determine locals.\n"));
2394 block
= get_frame_block (frame
, 0);
2398 fprintf_filtered (stream
, "No symbol table info available.\n");
2402 prepare_reg (regexp
, &cb_data
.preg
);
2403 prepare_reg (t_regexp
, &cb_data
.treg
);
2404 cb_data
.frame_id
= get_frame_id (frame
);
2405 cb_data
.num_tabs
= 4 * num_tabs
;
2406 cb_data
.stream
= stream
;
2407 cb_data
.values_printed
= 0;
2409 /* Temporarily change the selected frame to the given FRAME.
2410 This allows routines that rely on the selected frame instead
2411 of being given a frame as parameter to use the correct frame. */
2412 scoped_restore_selected_frame restore_selected_frame
;
2413 select_frame (frame
);
2415 iterate_over_block_local_vars (block
,
2416 do_print_variable_and_value
,
2419 if (!cb_data
.values_printed
&& !quiet
)
2421 if (regexp
== NULL
&& t_regexp
== NULL
)
2422 fprintf_filtered (stream
, _("No locals.\n"));
2424 fprintf_filtered (stream
, _("No matching locals.\n"));
2428 /* Structure to hold the values of the options used by the 'info
2429 variables' command and other similar commands. These correspond to the
2430 -q and -t options. */
2432 struct info_print_options
2435 char *type_regexp
= nullptr;
2437 ~info_print_options ()
2439 xfree (type_regexp
);
2443 /* The options used by the 'info locals' and 'info args' commands. */
2445 static const gdb::option::option_def info_print_options_defs
[] = {
2446 gdb::option::boolean_option_def
<info_print_options
> {
2448 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2449 nullptr, /* show_cmd_cb */
2450 nullptr /* set_doc */
2453 gdb::option::string_option_def
<info_print_options
> {
2455 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2456 nullptr, /* show_cmd_cb */
2457 nullptr /* set_doc */
2461 /* Returns the option group used by 'info locals' and 'info args'
2464 static gdb::option::option_def_group
2465 make_info_print_options_def_group (info_print_options
*opts
)
2467 return {{info_print_options_defs
}, opts
};
2470 /* Command completer for 'info locals' and 'info args'. */
2473 info_print_command_completer (struct cmd_list_element
*ignore
,
2474 completion_tracker
&tracker
,
2475 const char *text
, const char * /* word */)
2478 = make_info_print_options_def_group (nullptr);
2479 if (gdb::option::complete_options
2480 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2483 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2484 symbol_completer (ignore
, tracker
, text
, word
);
2487 /* Implement the 'info locals' command. */
2490 info_locals_command (const char *args
, int from_tty
)
2492 info_print_options opts
;
2493 auto grp
= make_info_print_options_def_group (&opts
);
2494 gdb::option::process_options
2495 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2496 if (args
!= nullptr && *args
== '\0')
2499 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2500 opts
.quiet
, args
, opts
.type_regexp
,
2504 /* Iterate over all the argument variables in block B. */
2507 iterate_over_block_arg_vars (const struct block
*b
,
2508 iterate_over_block_arg_local_vars_cb cb
,
2511 struct block_iterator iter
;
2512 struct symbol
*sym
, *sym2
;
2514 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2516 /* Don't worry about things which aren't arguments. */
2517 if (SYMBOL_IS_ARGUMENT (sym
))
2519 /* We have to look up the symbol because arguments can have
2520 two entries (one a parameter, one a local) and the one we
2521 want is the local, which lookup_symbol will find for us.
2522 This includes gcc1 (not gcc2) on the sparc when passing a
2523 small structure and gcc2 when the argument type is float
2524 and it is passed as a double and converted to float by
2525 the prologue (in the latter case the type of the LOC_ARG
2526 symbol is double and the type of the LOC_LOCAL symbol is
2527 float). There are also LOC_ARG/LOC_REGISTER pairs which
2528 are not combined in symbol-reading. */
2530 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2531 b
, VAR_DOMAIN
).symbol
;
2532 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2537 /* Print all argument variables of the function of FRAME.
2538 Print them with values to STREAM.
2539 If REGEXP is not NULL, only print argument variables whose name
2541 If T_REGEXP is not NULL, only print argument variables whose type
2543 If no argument variables have been printed and !QUIET, prints a message
2544 explaining why no argument variables could be printed.
2546 This function will invalidate FRAME. */
2549 print_frame_arg_vars (struct frame_info
*frame
,
2551 const char *regexp
, const char *t_regexp
,
2552 struct ui_file
*stream
)
2554 struct print_variable_and_value_data cb_data
;
2555 struct symbol
*func
;
2557 gdb::optional
<compiled_regex
> preg
;
2558 gdb::optional
<compiled_regex
> treg
;
2560 if (!get_frame_pc_if_available (frame
, &pc
))
2563 fprintf_filtered (stream
,
2564 _("PC unavailable, cannot determine args.\n"));
2568 func
= get_frame_function (frame
);
2572 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2576 prepare_reg (regexp
, &cb_data
.preg
);
2577 prepare_reg (t_regexp
, &cb_data
.treg
);
2578 cb_data
.frame_id
= get_frame_id (frame
);
2579 cb_data
.num_tabs
= 0;
2580 cb_data
.stream
= stream
;
2581 cb_data
.values_printed
= 0;
2583 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2584 do_print_variable_and_value
, &cb_data
);
2586 /* do_print_variable_and_value invalidates FRAME. */
2589 if (!cb_data
.values_printed
&& !quiet
)
2591 if (regexp
== NULL
&& t_regexp
== NULL
)
2592 fprintf_filtered (stream
, _("No arguments.\n"));
2594 fprintf_filtered (stream
, _("No matching arguments.\n"));
2598 /* Implement the 'info args' command. */
2601 info_args_command (const char *args
, int from_tty
)
2603 info_print_options opts
;
2604 auto grp
= make_info_print_options_def_group (&opts
);
2605 gdb::option::process_options
2606 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2607 if (args
!= nullptr && *args
== '\0')
2610 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2611 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2614 /* Return the symbol-block in which the selected frame is executing.
2615 Can return zero under various legitimate circumstances.
2617 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2618 code address within the block returned. We use this to decide
2619 which macros are in scope. */
2621 const struct block
*
2622 get_selected_block (CORE_ADDR
*addr_in_block
)
2624 if (!has_stack_frames ())
2627 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2630 /* Find a frame a certain number of levels away from FRAME.
2631 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2632 Positive means go to earlier frames (up); negative, the reverse.
2633 The int that contains the number of levels is counted toward
2634 zero as the frames for those levels are found.
2635 If the top or bottom frame is reached, that frame is returned,
2636 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2637 how much farther the original request asked to go. */
2640 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2642 /* Going up is simple: just call get_prev_frame enough times or
2643 until the initial frame is reached. */
2644 while (*level_offset_ptr
> 0)
2646 struct frame_info
*prev
= get_prev_frame (frame
);
2650 (*level_offset_ptr
)--;
2654 /* Going down is just as simple. */
2655 while (*level_offset_ptr
< 0)
2657 struct frame_info
*next
= get_next_frame (frame
);
2661 (*level_offset_ptr
)++;
2668 /* Select the frame up one or COUNT_EXP stack levels from the
2669 previously selected frame, and print it briefly. */
2672 up_silently_base (const char *count_exp
)
2674 struct frame_info
*frame
;
2678 count
= parse_and_eval_long (count_exp
);
2680 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2681 if (count
!= 0 && count_exp
== NULL
)
2682 error (_("Initial frame selected; you cannot go up."));
2683 select_frame (frame
);
2687 up_silently_command (const char *count_exp
, int from_tty
)
2689 up_silently_base (count_exp
);
2693 up_command (const char *count_exp
, int from_tty
)
2695 up_silently_base (count_exp
);
2696 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2699 /* Select the frame down one or COUNT_EXP stack levels from the previously
2700 selected frame, and print it briefly. */
2703 down_silently_base (const char *count_exp
)
2705 struct frame_info
*frame
;
2709 count
= -parse_and_eval_long (count_exp
);
2711 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2712 if (count
!= 0 && count_exp
== NULL
)
2714 /* We only do this if COUNT_EXP is not specified. That way
2715 "down" means to really go down (and let me know if that is
2716 impossible), but "down 9999" can be used to mean go all the
2717 way down without getting an error. */
2719 error (_("Bottom (innermost) frame selected; you cannot go down."));
2722 select_frame (frame
);
2726 down_silently_command (const char *count_exp
, int from_tty
)
2728 down_silently_base (count_exp
);
2732 down_command (const char *count_exp
, int from_tty
)
2734 down_silently_base (count_exp
);
2735 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2739 return_command (const char *retval_exp
, int from_tty
)
2741 /* Initialize it just to avoid a GCC false warning. */
2742 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2743 struct frame_info
*thisframe
;
2744 struct gdbarch
*gdbarch
;
2745 struct symbol
*thisfun
;
2746 struct value
*return_value
= NULL
;
2747 struct value
*function
= NULL
;
2748 const char *query_prefix
= "";
2750 thisframe
= get_selected_frame ("No selected frame.");
2751 thisfun
= get_frame_function (thisframe
);
2752 gdbarch
= get_frame_arch (thisframe
);
2754 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2755 error (_("Can not force return from an inlined function."));
2757 /* Compute the return value. If the computation triggers an error,
2758 let it bail. If the return type can't be handled, set
2759 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2763 expression_up retval_expr
= parse_expression (retval_exp
);
2764 struct type
*return_type
= NULL
;
2766 /* Compute the return value. Should the computation fail, this
2767 call throws an error. */
2768 return_value
= evaluate_expression (retval_expr
.get ());
2770 /* Cast return value to the return type of the function. Should
2771 the cast fail, this call throws an error. */
2772 if (thisfun
!= NULL
)
2773 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2774 if (return_type
== NULL
)
2776 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2777 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2778 error (_("Return value type not available for selected "
2780 "Please use an explicit cast of the value to return."));
2781 return_type
= value_type (return_value
);
2783 return_type
= check_typedef (return_type
);
2784 return_value
= value_cast (return_type
, return_value
);
2786 /* Make sure the value is fully evaluated. It may live in the
2787 stack frame we're about to pop. */
2788 if (value_lazy (return_value
))
2789 value_fetch_lazy (return_value
);
2791 if (thisfun
!= NULL
)
2792 function
= read_var_value (thisfun
, NULL
, thisframe
);
2794 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2795 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2796 /* If the return-type is "void", don't try to find the
2797 return-value's location. However, do still evaluate the
2798 return expression so that, even when the expression result
2799 is discarded, side effects such as "return i++" still
2801 return_value
= NULL
;
2802 else if (thisfun
!= NULL
)
2804 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2805 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2806 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2808 query_prefix
= "The location at which to store the "
2809 "function's return value is unknown.\n"
2810 "If you continue, the return value "
2811 "that you specified will be ignored.\n";
2812 return_value
= NULL
;
2817 /* Does an interactive user really want to do this? Include
2818 information, such as how well GDB can handle the return value, in
2819 the query message. */
2824 if (thisfun
== NULL
)
2825 confirmed
= query (_("%sMake selected stack frame return now? "),
2829 if (TYPE_NO_RETURN (thisfun
->type
))
2830 warning (_("Function does not return normally to caller."));
2831 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2832 SYMBOL_PRINT_NAME (thisfun
));
2835 error (_("Not confirmed"));
2838 /* Discard the selected frame and all frames inner-to it. */
2839 frame_pop (get_selected_frame (NULL
));
2841 /* Store RETURN_VALUE in the just-returned register set. */
2842 if (return_value
!= NULL
)
2844 struct type
*return_type
= value_type (return_value
);
2845 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2847 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2848 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2849 gdbarch_return_value (cache_arch
, function
, return_type
,
2850 get_current_regcache (), NULL
/*read*/,
2851 value_contents (return_value
) /*write*/);
2854 /* If we are at the end of a call dummy now, pop the dummy frame
2856 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2857 frame_pop (get_current_frame ());
2859 select_frame (get_current_frame ());
2860 /* If interactive, print the frame that is now current. */
2862 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2865 /* Find the most inner frame in the current stack for a function called
2866 FUNCTION_NAME. If no matching frame is found return NULL. */
2868 static struct frame_info
*
2869 find_frame_for_function (const char *function_name
)
2871 /* Used to hold the lower and upper addresses for each of the
2872 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2873 struct function_bounds
2875 CORE_ADDR low
, high
;
2877 struct frame_info
*frame
;
2881 gdb_assert (function_name
!= NULL
);
2883 frame
= get_current_frame ();
2884 std::vector
<symtab_and_line
> sals
2885 = decode_line_with_current_source (function_name
,
2886 DECODE_LINE_FUNFIRSTLINE
);
2887 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2888 for (size_t i
= 0; i
< sals
.size (); i
++)
2890 if (sals
[i
].pspace
!= current_program_space
)
2891 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2892 else if (sals
[i
].pc
== 0
2893 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2894 &func_bounds
[i
].low
,
2895 &func_bounds
[i
].high
) == 0)
2896 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2901 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2902 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2903 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2907 frame
= find_relative_frame (frame
, &level
);
2910 while (!found
&& level
== 0);
2918 /* Implements the dbx 'func' command. */
2921 func_command (const char *arg
, int from_tty
)
2926 struct frame_info
*frame
= find_frame_for_function (arg
);
2928 error (_("'%s' not within current stack frame."), arg
);
2929 if (frame
!= get_selected_frame (NULL
))
2931 select_frame (frame
);
2932 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2936 /* The qcs command line flags for the "frame apply" commands. Keep
2937 this in sync with the "thread apply" commands. */
2939 using qcs_flag_option_def
2940 = gdb::option::flag_option_def
<qcs_flags
>;
2942 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2943 qcs_flag_option_def
{
2944 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2945 N_("Disables printing the frame location information."),
2948 qcs_flag_option_def
{
2949 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2950 N_("Print any error raised by COMMAND and continue."),
2953 qcs_flag_option_def
{
2954 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2955 N_("Silently ignore any errors or empty output produced by COMMAND."),
2959 /* Create an option_def_group array for all the "frame apply" options,
2960 with FLAGS and SET_BT_OPTS as context. */
2962 static inline std::array
<gdb::option::option_def_group
, 2>
2963 make_frame_apply_options_def_group (qcs_flags
*flags
,
2964 set_backtrace_options
*set_bt_opts
)
2967 { {fr_qcs_flags_option_defs
}, flags
},
2968 { {set_backtrace_option_defs
}, set_bt_opts
},
2972 /* Apply a GDB command to all stack frames, or a set of identified frames,
2973 or innermost COUNT frames.
2974 With a negative COUNT, apply command on outermost -COUNT frames.
2976 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2977 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2978 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2979 frame apply all -s p local_var_no_idea_in_which_frame
2980 If a frame has a local variable called
2981 local_var_no_idea_in_which_frame, print frame
2982 and value of local_var_no_idea_in_which_frame.
2983 frame apply all -s -q p local_var_no_idea_in_which_frame
2984 Same as before, but only print the variable value.
2985 frame apply level 2-5 0 4-7 -s p i = i + 1
2986 Adds 1 to the variable i in the specified frames.
2987 Note that i will be incremented twice in
2990 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2991 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2992 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2993 for error messages. */
2996 frame_apply_command_count (const char *which_command
,
2997 const char *cmd
, int from_tty
,
2998 struct frame_info
*trailing
, int count
)
3001 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
3003 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
3004 gdb::option::process_options
3005 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
3007 validate_flags_qcs (which_command
, &flags
);
3009 if (cmd
== NULL
|| *cmd
== '\0')
3010 error (_("Please specify a command to apply on the selected frames"));
3012 /* The below will restore the current inferior/thread/frame.
3013 Usually, only the frame is effectively to be restored.
3014 But in case CMD switches of inferior/thread, better restore
3016 scoped_restore_current_thread restore_thread
;
3018 /* These options are handled quite deep in the unwind machinery, so
3019 we get to pass them down by swapping globals. */
3020 scoped_restore restore_set_backtrace_options
3021 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
3023 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
3030 std::string cmd_result
;
3032 /* In case CMD switches of inferior/thread/frame, the below
3033 restores the inferior/thread/frame. FI can then be
3034 set to the selected frame. */
3035 scoped_restore_current_thread restore_fi_current_frame
;
3037 cmd_result
= execute_command_to_string
3038 (cmd
, from_tty
, gdb_stdout
->term_out ());
3040 fi
= get_selected_frame (_("frame apply "
3041 "unable to get selected frame."));
3042 if (!flags
.silent
|| cmd_result
.length () > 0)
3045 print_stack_frame (fi
, 1, LOCATION
, 0);
3046 printf_filtered ("%s", cmd_result
.c_str ());
3049 catch (const gdb_exception_error
&ex
)
3051 fi
= get_selected_frame (_("frame apply "
3052 "unable to get selected frame."));
3056 print_stack_frame (fi
, 1, LOCATION
, 0);
3058 printf_filtered ("%s\n", ex
.what ());
3066 /* Completer for the "frame apply ..." commands. */
3069 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3071 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3072 if (gdb::option::complete_options
3073 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3076 complete_nested_command_line (tracker
, text
);
3079 /* Completer for the "frame apply" commands. */
3082 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3083 completion_tracker
&tracker
,
3084 const char *text
, const char */
*word*/
)
3086 /* Do this explicitly because there's an early return below. */
3087 tracker
.set_use_custom_word_point (true);
3089 number_or_range_parser
levels (text
);
3091 /* Skip the LEVEL list to find the options and command args. */
3094 while (!levels
.finished ())
3096 /* Call for effect. */
3097 levels
.get_number ();
3099 if (levels
.in_range ())
3100 levels
.skip_range ();
3103 catch (const gdb_exception_error
&ex
)
3105 /* get_number throws if it parses a negative number, for
3106 example. But a seemingly negative number may be the start of
3107 an option instead. */
3110 const char *cmd
= levels
.cur_tok ();
3114 /* No level list yet. */
3118 /* Check if we're past a valid LEVEL already. */
3119 if (levels
.finished ()
3120 && cmd
> text
&& !isspace (cmd
[-1]))
3123 /* We're past LEVELs, advance word point. */
3124 tracker
.advance_custom_word_point_by (cmd
- text
);
3127 frame_apply_completer (tracker
, text
);
3130 /* Completer for the "frame apply all" command. */
3133 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3134 completion_tracker
&tracker
,
3135 const char *text
, const char */
*word*/
)
3137 frame_apply_completer (tracker
, text
);
3140 /* Completer for the "frame apply COUNT" command. */
3143 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3144 completion_tracker
&tracker
,
3145 const char *text
, const char */
*word*/
)
3147 const char *cmd
= text
;
3149 int count
= get_number_trailer (&cmd
, 0);
3153 /* Check if we're past a valid COUNT already. */
3154 if (cmd
> text
&& !isspace (cmd
[-1]))
3157 /* We're past COUNT, advance word point. */
3158 tracker
.advance_custom_word_point_by (cmd
- text
);
3161 frame_apply_completer (tracker
, text
);
3164 /* Implementation of the "frame apply level" command. */
3167 frame_apply_level_command (const char *cmd
, int from_tty
)
3169 if (!target_has_stack
)
3170 error (_("No stack."));
3172 bool level_found
= false;
3173 const char *levels_str
= cmd
;
3174 number_or_range_parser
levels (levels_str
);
3176 /* Skip the LEVEL list to find the flags and command args. */
3177 while (!levels
.finished ())
3179 /* Call for effect. */
3180 levels
.get_number ();
3183 if (levels
.in_range ())
3184 levels
.skip_range ();
3188 error (_("Missing or invalid LEVEL... argument"));
3190 cmd
= levels
.cur_tok ();
3192 /* Redo the LEVELS parsing, but applying COMMAND. */
3193 levels
.init (levels_str
);
3194 while (!levels
.finished ())
3196 const int level_beg
= levels
.get_number ();
3199 if (levels
.in_range ())
3201 n_frames
= levels
.end_value () - level_beg
+ 1;
3202 levels
.skip_range ();
3207 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3208 leading_innermost_frame (level_beg
), n_frames
);
3212 /* Implementation of the "frame apply all" command. */
3215 frame_apply_all_command (const char *cmd
, int from_tty
)
3217 if (!target_has_stack
)
3218 error (_("No stack."));
3220 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3221 get_current_frame (), INT_MAX
);
3224 /* Implementation of the "frame apply" command. */
3227 frame_apply_command (const char* cmd
, int from_tty
)
3230 struct frame_info
*trailing
;
3232 if (!target_has_stack
)
3233 error (_("No stack."));
3236 error (_("Missing COUNT argument."));
3237 count
= get_number_trailer (&cmd
, 0);
3239 error (_("Invalid COUNT argument."));
3243 trailing
= trailing_outermost_frame (-count
);
3247 trailing
= get_current_frame ();
3249 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3253 /* Implementation of the "faas" command. */
3256 faas_command (const char *cmd
, int from_tty
)
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
;
3315 _initialize_stack (void)
3317 struct cmd_list_element
*cmd
;
3319 add_com ("return", class_stack
, return_command
, _("\
3320 Make selected stack frame return to its caller.\n\
3321 Control remains in the debugger, but when you continue\n\
3322 execution will resume in the frame above the one now selected.\n\
3323 If an argument is given, it is an expression for the value to return."));
3325 add_com ("up", class_stack
, up_command
, _("\
3326 Select and print stack frame that called this one.\n\
3327 An argument says how many frames up to go."));
3328 add_com ("up-silently", class_support
, up_silently_command
, _("\
3329 Same as the `up' command, but does not print anything.\n\
3330 This is useful in command scripts."));
3332 add_com ("down", class_stack
, down_command
, _("\
3333 Select and print stack frame called by this one.\n\
3334 An argument says how many frames down to go."));
3335 add_com_alias ("do", "down", class_stack
, 1);
3336 add_com_alias ("dow", "down", class_stack
, 1);
3337 add_com ("down-silently", class_support
, down_silently_command
, _("\
3338 Same as the `down' command, but does not print anything.\n\
3339 This is useful in command scripts."));
3341 add_prefix_cmd ("frame", class_stack
,
3342 &frame_cmd
.base_command
, _("\
3343 Select and print a stack frame.\n\
3344 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3345 A single numerical argument specifies the frame to select."),
3346 &frame_cmd_list
, "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_prefix_cmd ("frame", class_stack
,
3408 &frame_cmd
.base_command
, _("\
3409 Select and print a stack frame.\n\
3410 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3411 A single numerical argument specifies the frame to select."),
3412 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3413 add_com_alias ("f", "frame", class_stack
, 1);
3415 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3417 Select and print a stack frame by stack address.\n\
3419 Usage: frame address STACK-ADDRESS"),
3422 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3424 View a stack frame that might be outside the current backtrace.\n\
3426 Usage: frame view STACK-ADDRESS\n\
3427 frame view STACK-ADDRESS PC-ADDRESS"),
3430 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3432 Select and print a stack frame by function name.\n\
3434 Usage: frame function NAME\n\
3436 The innermost frame that visited function NAME is selected."),
3438 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3441 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3443 Select and print a stack frame by level.\n\
3445 Usage: frame level LEVEL"),
3448 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3449 &select_frame_cmd
.base_command
, _("\
3450 Select a stack frame without printing anything.\n\
3451 A single numerical argument specifies the frame to select."),
3452 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3453 &cli_suppress_notification
.user_selected_context
);
3455 add_cmd_suppress_notification ("address", class_stack
,
3456 &select_frame_cmd
.address
, _("\
3457 Select a stack frame by stack address.\n\
3459 Usage: select-frame address STACK-ADDRESS"),
3460 &select_frame_cmd_list
,
3461 &cli_suppress_notification
.user_selected_context
);
3464 add_cmd_suppress_notification ("view", class_stack
,
3465 &select_frame_cmd
.view
, _("\
3466 Select a stack frame that might be outside the current backtrace.\n\
3468 Usage: select-frame view STACK-ADDRESS\n\
3469 select-frame view STACK-ADDRESS PC-ADDRESS"),
3470 &select_frame_cmd_list
,
3471 &cli_suppress_notification
.user_selected_context
);
3473 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3474 &select_frame_cmd
.function
, _("\
3475 Select a stack frame by function name.\n\
3477 Usage: select-frame function NAME"),
3478 &select_frame_cmd_list
,
3479 &cli_suppress_notification
.user_selected_context
);
3480 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3482 add_cmd_suppress_notification ("level", class_stack
,
3483 &select_frame_cmd
.level
, _("\
3484 Select a stack frame by level.\n\
3486 Usage: select-frame level LEVEL"),
3487 &select_frame_cmd_list
,
3488 &cli_suppress_notification
.user_selected_context
);
3490 const auto backtrace_opts
3491 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3493 static std::string backtrace_help
3494 = gdb::option::build_help (_("\
3495 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3496 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3501 For backward compatibility, the following qualifiers are supported:\n\
3503 full - same as -full option.\n\
3504 no-filters - same as -no-filters option.\n\
3505 hide - same as -hide.\n\
3507 With a negative COUNT, print outermost -COUNT frames."),
3510 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3512 backtrace_help
.c_str ());
3513 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3515 add_com_alias ("bt", "backtrace", class_stack
, 0);
3517 add_com_alias ("where", "backtrace", class_alias
, 0);
3518 add_info ("stack", backtrace_command
,
3519 _("Backtrace of the stack, or innermost COUNT frames."));
3520 add_info_alias ("s", "stack", 1);
3522 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3523 _("All about the selected stack frame.\n\
3524 With no arguments, displays information about the currently selected stack\n\
3525 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3526 the information is then printed about the specified frame."),
3527 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3528 add_info_alias ("f", "frame", 1);
3530 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3532 Print information about a stack frame selected by stack address.\n\
3534 Usage: info frame address STACK-ADDRESS"),
3535 &info_frame_cmd_list
);
3537 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3539 Print information about a stack frame outside the current backtrace.\n\
3541 Usage: info frame view STACK-ADDRESS\n\
3542 info frame view STACK-ADDRESS PC-ADDRESS"),
3543 &info_frame_cmd_list
);
3545 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3547 Print information about a stack frame selected by function name.\n\
3549 Usage: info frame function NAME"),
3550 &info_frame_cmd_list
);
3551 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3553 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3555 Print information about a stack frame selected by level.\n\
3557 Usage: info frame level LEVEL"),
3558 &info_frame_cmd_list
);
3560 cmd
= add_info ("locals", info_locals_command
,
3561 info_print_args_help (_("\
3562 All local variables of current stack frame or those matching REGEXPs.\n\
3563 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3564 Prints the local variables of the current stack frame.\n"),
3565 _("local variables"),
3567 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3568 cmd
= add_info ("args", info_args_command
,
3569 info_print_args_help (_("\
3570 All argument variables of current stack frame or those matching REGEXPs.\n\
3571 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3572 Prints the argument variables of the current stack frame.\n"),
3573 _("argument variables"),
3575 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3578 add_com ("func", class_stack
, func_command
, _("\
3579 Select the stack frame that contains NAME.\n\
3580 Usage: func NAME"));
3582 /* Install "set print raw frame-arguments", a deprecated spelling of
3583 "set print raw-frame-arguments". */
3584 cmd
= add_setshow_boolean_cmd
3585 ("frame-arguments", no_class
,
3586 &user_frame_print_options
.print_raw_frame_arguments
,
3588 Set whether to print frame arguments in raw form."), _("\
3589 Show whether to print frame arguments in raw form."), _("\
3590 If set, frame arguments are printed in raw form, bypassing any\n\
3591 pretty-printers for that value."),
3593 &setprintrawlist
, &showprintrawlist
);
3594 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3596 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3597 &disassemble_next_line
, _("\
3598 Set whether to disassemble next source line or insn when execution stops."),
3600 Show whether to disassemble next source line or insn when execution stops."),
3602 If ON, GDB will display disassembly of the next source line, in addition\n\
3603 to displaying the source line itself. If the next source line cannot\n\
3604 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3605 will display disassembly of next instruction instead of showing the\n\
3607 If AUTO, display disassembly of next instruction only if the source line\n\
3608 cannot be displayed.\n\
3609 If OFF (which is the default), never display the disassembly of the next\n\
3612 show_disassemble_next_line
,
3613 &setlist
, &showlist
);
3614 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3616 gdb::option::add_setshow_cmds_for_options
3617 (class_stack
, &user_frame_print_options
,
3618 frame_print_option_defs
, &setprintlist
, &showprintlist
);