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"
58 /* The possible choices of "set print frame-arguments", and the value
61 const char print_frame_arguments_all
[] = "all";
62 const char print_frame_arguments_scalars
[] = "scalars";
63 const char print_frame_arguments_none
[] = "none";
64 const char print_frame_arguments_presence
[] = "presence";
66 static const char *const print_frame_arguments_choices
[] =
68 print_frame_arguments_all
,
69 print_frame_arguments_scalars
,
70 print_frame_arguments_none
,
71 print_frame_arguments_presence
,
75 /* The possible choices of "set print frame-info", and the value
78 const char print_frame_info_auto
[] = "auto";
79 const char print_frame_info_source_line
[] = "source-line";
80 const char print_frame_info_location
[] = "location";
81 const char print_frame_info_source_and_location
[] = "source-and-location";
82 const char print_frame_info_location_and_address
[] = "location-and-address";
83 const char print_frame_info_short_location
[] = "short-location";
85 static const char *const print_frame_info_choices
[] =
87 print_frame_info_auto
,
88 print_frame_info_source_line
,
89 print_frame_info_location
,
90 print_frame_info_source_and_location
,
91 print_frame_info_location_and_address
,
92 print_frame_info_short_location
,
96 /* print_frame_info_print_what[i] maps a choice to the corresponding
98 static const gdb::optional
<enum print_what
> print_frame_info_print_what
[] =
99 {{}, /* Empty value for "auto". */
100 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
102 /* The possible choices of "set print entry-values", and the value
105 const char print_entry_values_no
[] = "no";
106 const char print_entry_values_only
[] = "only";
107 const char print_entry_values_preferred
[] = "preferred";
108 const char print_entry_values_if_needed
[] = "if-needed";
109 const char print_entry_values_both
[] = "both";
110 const char print_entry_values_compact
[] = "compact";
111 const char print_entry_values_default
[] = "default";
112 static const char *const print_entry_values_choices
[] =
114 print_entry_values_no
,
115 print_entry_values_only
,
116 print_entry_values_preferred
,
117 print_entry_values_if_needed
,
118 print_entry_values_both
,
119 print_entry_values_compact
,
120 print_entry_values_default
,
125 frame_print_options user_frame_print_options
;
127 /* Option definitions for some frame-related "set print ..."
130 using boolean_option_def
131 = gdb::option::boolean_option_def
<frame_print_options
>;
132 using enum_option_def
133 = gdb::option::enum_option_def
<frame_print_options
>;
135 static const gdb::option::option_def frame_print_option_defs
[] = {
139 print_entry_values_choices
,
140 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
141 NULL
, /* show_cmd_cb */
142 N_("Set printing of function arguments at function entry."),
143 N_("Show printing of function arguments at function entry."),
144 N_("GDB can sometimes determine the values of function arguments at entry,\n\
145 in addition to their current values. This option tells GDB whether\n\
146 to print the current value, the value at entry (marked as val@entry),\n\
147 or both. Note that one or both of these values may be <optimized out>."),
152 print_frame_arguments_choices
,
153 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
154 NULL
, /* show_cmd_cb */
155 N_("Set printing of non-scalar frame arguments."),
156 N_("Show printing of non-scalar frame arguments."),
161 "raw-frame-arguments",
162 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
163 NULL
, /* show_cmd_cb */
164 N_("Set whether to print frame arguments in raw form."),
165 N_("Show whether to print frame arguments in raw form."),
166 N_("If set, frame arguments are printed in raw form, bypassing any\n\
167 pretty-printers for that value.")
172 print_frame_info_choices
,
173 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
174 NULL
, /* show_cmd_cb */
175 N_("Set printing of frame information."),
176 N_("Show printing of frame information."),
182 /* Options for the "backtrace" command. */
184 struct backtrace_cmd_options
191 using bt_flag_option_def
192 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
194 static const gdb::option::option_def backtrace_command_option_defs
[] = {
197 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
198 N_("Print values of local variables.")
203 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
204 N_("Prohibit frame filters from executing on a backtrace."),
209 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
210 N_("Causes Python frame filter elided frames to not be printed."),
214 /* Prototypes for local functions. */
216 static void print_frame_local_vars (struct frame_info
*frame
,
218 const char *regexp
, const char *t_regexp
,
219 int num_tabs
, struct ui_file
*stream
);
221 static void print_frame (const frame_print_options
&opts
,
222 frame_info
*frame
, int print_level
,
223 enum print_what print_what
, int print_args
,
224 struct symtab_and_line sal
);
226 static void set_last_displayed_sal (int valid
,
227 struct program_space
*pspace
,
229 struct symtab
*symtab
,
232 static struct frame_info
*find_frame_for_function (const char *);
233 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
235 /* Zero means do things normally; we are interacting directly with the
236 user. One means print the full filename and linenumber when a
237 frame is printed, and do so in a format emacs18/emacs19.22 can
238 parse. Two means print similar annotations, but in many more
239 cases and in a slightly different syntax. */
241 int annotation_level
= 0;
243 /* These variables hold the last symtab and line we displayed to the user.
244 * This is where we insert a breakpoint or a skiplist entry by default. */
245 static int last_displayed_sal_valid
= 0;
246 static struct program_space
*last_displayed_pspace
= 0;
247 static CORE_ADDR last_displayed_addr
= 0;
248 static struct symtab
*last_displayed_symtab
= 0;
249 static int last_displayed_line
= 0;
255 frame_show_address (struct frame_info
*frame
,
256 struct symtab_and_line sal
)
258 /* If there is a line number, but no PC, then there is no location
259 information associated with this sal. The only way that should
260 happen is for the call sites of inlined functions (SAL comes from
261 find_frame_sal). Otherwise, we would have some PC range if the
262 SAL came from a line table. */
263 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
265 if (get_next_frame (frame
) == NULL
)
266 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
268 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
272 return get_frame_pc (frame
) != sal
.pc
;
278 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
279 int print_level
, enum print_what print_what
,
282 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
284 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
287 /* Show or print a stack frame FRAME briefly. The output is formatted
288 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
289 relative level, function name, argument list, and file name and
290 line number. If the frame's PC is not at the beginning of the
291 source line, the actual PC is printed at the beginning. */
294 print_stack_frame (struct frame_info
*frame
, int print_level
,
295 enum print_what print_what
,
299 /* For mi, alway print location and address. */
300 if (current_uiout
->is_mi_like_p ())
301 print_what
= LOC_AND_ADDRESS
;
305 print_frame_info (user_frame_print_options
,
306 frame
, print_level
, print_what
, 1 /* print_args */,
309 set_current_sal_from_frame (frame
);
311 catch (const gdb_exception_error
&e
)
316 /* Print nameless arguments of frame FRAME on STREAM, where START is
317 the offset of the first nameless argument, and NUM is the number of
318 nameless arguments to print. FIRST is nonzero if this is the first
319 argument (not just the first nameless argument). */
322 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
323 int first
, struct ui_file
*stream
)
325 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
326 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
331 for (i
= 0; i
< num
; i
++)
334 argsaddr
= get_frame_args_address (frame
);
337 arg_value
= read_memory_integer (argsaddr
+ start
,
338 sizeof (int), byte_order
);
340 fprintf_filtered (stream
, ", ");
341 fprintf_filtered (stream
, "%ld", arg_value
);
343 start
+= sizeof (int);
347 /* Print single argument of inferior function. ARG must be already
350 Errors are printed as if they would be the parameter value. Use zeroed ARG
351 iff it should not be printed accoring to user settings. */
354 print_frame_arg (const frame_print_options
&fp_opts
,
355 const struct frame_arg
*arg
)
357 struct ui_out
*uiout
= current_uiout
;
361 gdb_assert (!arg
->val
|| !arg
->error
);
362 gdb_assert (arg
->entry_kind
== print_entry_values_no
363 || arg
->entry_kind
== print_entry_values_only
364 || (!uiout
->is_mi_like_p ()
365 && arg
->entry_kind
== print_entry_values_compact
));
367 annotate_arg_emitter arg_emitter
;
368 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
369 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
370 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
371 if (arg
->entry_kind
== print_entry_values_compact
)
373 /* It is OK to provide invalid MI-like stream as with
374 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
377 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
378 SYMBOL_LANGUAGE (arg
->sym
),
379 DMGL_PARAMS
| DMGL_ANSI
);
381 if (arg
->entry_kind
== print_entry_values_only
382 || arg
->entry_kind
== print_entry_values_compact
)
384 uiout
->field_stream ("name", stb
, ui_out_style_kind::VARIABLE
);
385 annotate_arg_name_end ();
388 if (!arg
->val
&& !arg
->error
)
393 stb
.printf (_("<error reading variable: %s>"), arg
->error
);
398 const struct language_defn
*language
;
399 struct value_print_options vp_opts
;
401 /* Avoid value_print because it will deref ref parameters. We
402 just want to print their addresses. Print ??? for args whose
403 address we do not know. We pass 2 as "recurse" to val_print
404 because our standard indentation here is 4 spaces, and
405 val_print indents 2 for each recurse. */
407 annotate_arg_value (value_type (arg
->val
));
409 /* Use the appropriate language to display our symbol, unless the
410 user forced the language to a specific language. */
411 if (language_mode
== language_mode_auto
)
412 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
414 language
= current_language
;
416 get_no_prettyformat_print_options (&vp_opts
);
417 vp_opts
.deref_ref
= 1;
418 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
420 /* True in "summary" mode, false otherwise. */
422 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
424 common_val_print (arg
->val
, &stb
, 2, &vp_opts
, language
);
426 catch (const gdb_exception_error
&except
)
428 stb
.printf (_("<error reading variable: %s>"),
434 uiout
->field_stream ("value", stb
);
437 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
438 responsible for xfree of ARGP->ERROR. This function never throws an
442 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
443 struct frame_arg
*argp
)
451 argp
->val
= read_var_value (sym
, NULL
, frame
);
453 catch (const gdb_exception_error
&except
)
455 argp
->error
= xstrdup (except
.what ());
459 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
460 responsible for xfree of ARGP->ERROR. This function never throws an
464 read_frame_arg (const frame_print_options
&fp_opts
,
465 symbol
*sym
, frame_info
*frame
,
466 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
468 struct value
*val
= NULL
, *entryval
= NULL
;
469 char *val_error
= NULL
, *entryval_error
= NULL
;
472 if (fp_opts
.print_entry_values
!= print_entry_values_only
473 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
477 val
= read_var_value (sym
, NULL
, frame
);
479 catch (const gdb_exception_error
&except
)
481 val_error
= (char *) alloca (except
.message
->size () + 1);
482 strcpy (val_error
, except
.what ());
486 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
487 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
488 && fp_opts
.print_entry_values
!= print_entry_values_no
489 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
490 || !val
|| value_optimized_out (val
)))
494 const struct symbol_computed_ops
*ops
;
496 ops
= SYMBOL_COMPUTED_OPS (sym
);
497 entryval
= ops
->read_variable_at_entry (sym
, frame
);
499 catch (const gdb_exception_error
&except
)
501 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
503 entryval_error
= (char *) alloca (except
.message
->size () + 1);
504 strcpy (entryval_error
, except
.what ());
508 if (entryval
!= NULL
&& value_optimized_out (entryval
))
511 if (fp_opts
.print_entry_values
== print_entry_values_compact
512 || fp_opts
.print_entry_values
== print_entry_values_default
)
514 /* For MI do not try to use print_entry_values_compact for ARGP. */
516 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
518 struct type
*type
= value_type (val
);
520 if (value_lazy (val
))
521 value_fetch_lazy (val
);
522 if (value_lazy (entryval
))
523 value_fetch_lazy (entryval
);
525 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
527 /* Initialize it just to avoid a GCC false warning. */
528 struct value
*val_deref
= NULL
, *entryval_deref
;
530 /* DW_AT_call_value does match with the current
531 value. If it is a reference still try to verify if
532 dereferenced DW_AT_call_data_value does not differ. */
536 struct type
*type_deref
;
538 val_deref
= coerce_ref (val
);
539 if (value_lazy (val_deref
))
540 value_fetch_lazy (val_deref
);
541 type_deref
= value_type (val_deref
);
543 entryval_deref
= coerce_ref (entryval
);
544 if (value_lazy (entryval_deref
))
545 value_fetch_lazy (entryval_deref
);
547 /* If the reference addresses match but dereferenced
548 content does not match print them. */
550 && value_contents_eq (val_deref
, 0,
552 TYPE_LENGTH (type_deref
)))
555 catch (const gdb_exception_error
&except
)
557 /* If the dereferenced content could not be
558 fetched do not display anything. */
559 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
561 else if (except
.message
!= NULL
)
564 = (char *) alloca (except
.message
->size () + 1);
565 strcpy (entryval_error
, except
.what ());
569 /* Value was not a reference; and its content matches. */
570 if (val
== val_deref
)
578 /* Try to remove possibly duplicate error message for ENTRYARGP even
581 if (val_error
&& entryval_error
582 && strcmp (val_error
, entryval_error
) == 0)
584 entryval_error
= NULL
;
586 /* Do not se VAL_EQUAL as the same error message may be shown for
587 the entry value even if no entry values are present in the
593 if (entryval
== NULL
)
595 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
597 gdb_assert (val
== NULL
);
601 val
= read_var_value (sym
, NULL
, frame
);
603 catch (const gdb_exception_error
&except
)
605 val_error
= (char *) alloca (except
.message
->size () + 1);
606 strcpy (val_error
, except
.what ());
609 if (fp_opts
.print_entry_values
== print_entry_values_only
610 || fp_opts
.print_entry_values
== print_entry_values_both
611 || (fp_opts
.print_entry_values
== print_entry_values_preferred
612 && (!val
|| value_optimized_out (val
))))
614 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
615 entryval_error
= NULL
;
618 if ((fp_opts
.print_entry_values
== print_entry_values_compact
619 || fp_opts
.print_entry_values
== print_entry_values_if_needed
620 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
621 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
629 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
630 if (!val
&& !val_error
)
631 argp
->entry_kind
= print_entry_values_only
;
632 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
633 || fp_opts
.print_entry_values
== print_entry_values_default
)
636 argp
->entry_kind
= print_entry_values_compact
;
637 gdb_assert (!current_uiout
->is_mi_like_p ());
640 argp
->entry_kind
= print_entry_values_no
;
642 entryargp
->sym
= sym
;
643 entryargp
->val
= entryval
;
644 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
645 if (!entryval
&& !entryval_error
)
646 entryargp
->entry_kind
= print_entry_values_no
;
648 entryargp
->entry_kind
= print_entry_values_only
;
651 /* Print the arguments of frame FRAME on STREAM, given the function
652 FUNC running in that frame (as a symbol), where NUM is the number
653 of arguments according to the stack frame (or -1 if the number of
654 arguments is unknown). */
656 /* Note that currently the "number of arguments according to the
657 stack frame" is only known on VAX where i refers to the "number of
658 ints of arguments according to the stack frame". */
661 print_frame_args (const frame_print_options
&fp_opts
,
662 struct symbol
*func
, struct frame_info
*frame
,
663 int num
, struct ui_file
*stream
)
665 struct ui_out
*uiout
= current_uiout
;
667 /* Offset of next stack argument beyond the one we have seen that is
668 at the highest offset, or -1 if we haven't come to a stack
670 long highest_offset
= -1;
671 /* Number of ints of arguments that we have printed so far. */
672 int args_printed
= 0;
673 /* True if we should print arg names. If false, we only indicate
674 the presence of arguments by printing ellipsis. */
676 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
677 /* True if we should print arguments, false otherwise. */
680 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
684 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
685 struct block_iterator iter
;
688 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
690 struct frame_arg arg
, entryarg
;
694 /* Keep track of the highest stack argument offset seen, and
695 skip over any kinds of symbols we don't care about. */
697 if (!SYMBOL_IS_ARGUMENT (sym
))
707 switch (SYMBOL_CLASS (sym
))
712 long current_offset
= SYMBOL_VALUE (sym
);
713 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
715 /* Compute address of next argument by adding the size of
716 this argument and rounding to an int boundary. */
718 ((current_offset
+ arg_size
+ sizeof (int) - 1)
719 & ~(sizeof (int) - 1));
721 /* If this is the highest offset seen yet, set
723 if (highest_offset
== -1
724 || (current_offset
> highest_offset
))
725 highest_offset
= current_offset
;
727 /* Add the number of ints we're about to print to
729 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
732 /* We care about types of symbols, but don't need to
733 keep track of stack offsets in them. */
735 case LOC_REGPARM_ADDR
:
737 case LOC_OPTIMIZED_OUT
:
742 /* We have to look up the symbol because arguments can have
743 two entries (one a parameter, one a local) and the one we
744 want is the local, which lookup_symbol will find for us.
745 This includes gcc1 (not gcc2) on SPARC when passing a
746 small structure and gcc2 when the argument type is float
747 and it is passed as a double and converted to float by
748 the prologue (in the latter case the type of the LOC_ARG
749 symbol is double and the type of the LOC_LOCAL symbol is
751 /* But if the parameter name is null, don't try it. Null
752 parameter names occur on the RS/6000, for traceback
753 tables. FIXME, should we even print them? */
755 if (*SYMBOL_LINKAGE_NAME (sym
))
759 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
760 b
, VAR_DOMAIN
).symbol
;
761 gdb_assert (nsym
!= NULL
);
762 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
763 && !SYMBOL_IS_ARGUMENT (nsym
))
765 /* There is a LOC_ARG/LOC_REGISTER pair. This means
766 that it was passed on the stack and loaded into a
767 register, or passed in a register and stored in a
768 stack slot. GDB 3.x used the LOC_ARG; GDB
769 4.0-4.11 used the LOC_REGISTER.
771 Reasons for using the LOC_ARG:
773 (1) Because find_saved_registers may be slow for
776 (2) Because registers are often re-used and stack
777 slots rarely (never?) are. Therefore using
778 the stack slot is much less likely to print
781 Reasons why we might want to use the LOC_REGISTER:
783 (1) So that the backtrace prints the same value
784 as "print foo". I see no compelling reason
785 why this needs to be the case; having the
786 backtrace print the value which was passed
787 in, and "print foo" print the value as
788 modified within the called function, makes
791 Additional note: It might be nice if "info args"
792 displayed both values.
794 One more note: There is a case with SPARC
795 structure passing where we need to use the
796 LOC_REGISTER, but this is dealt with by creating
797 a single LOC_REGPARM in symbol reading. */
799 /* Leave sym (the LOC_ARG) alone. */
806 /* Print the current arg. */
809 uiout
->wrap_hint (" ");
813 memset (&arg
, 0, sizeof (arg
));
815 arg
.entry_kind
= print_entry_values_no
;
816 memset (&entryarg
, 0, sizeof (entryarg
));
818 entryarg
.entry_kind
= print_entry_values_no
;
821 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
823 if (arg
.entry_kind
!= print_entry_values_only
)
824 print_frame_arg (fp_opts
, &arg
);
826 if (entryarg
.entry_kind
!= print_entry_values_no
)
828 if (arg
.entry_kind
!= print_entry_values_only
)
831 uiout
->wrap_hint (" ");
834 print_frame_arg (fp_opts
, &entryarg
);
838 xfree (entryarg
.error
);
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'.",
935 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
938 = print_frame_info_to_print_what
939 (user_frame_print_options
.print_frame_info
);
942 /* Print information about frame FRAME. The output is format according
943 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
944 PRINT_WHAT, see enum print_what comments in frame.h.
945 Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info
946 != print_frame_info_auto.
948 Used in "where" output, and to emit breakpoint or step
952 print_frame_info (const frame_print_options
&fp_opts
,
953 frame_info
*frame
, int print_level
,
954 enum print_what print_what
, int print_args
,
957 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
960 struct ui_out
*uiout
= current_uiout
;
962 if (!current_uiout
->is_mi_like_p ()
963 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
965 /* Use the specific frame information desired by the user. */
966 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
969 if (get_frame_type (frame
) == DUMMY_FRAME
970 || get_frame_type (frame
) == SIGTRAMP_FRAME
971 || get_frame_type (frame
) == ARCH_FRAME
)
973 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
975 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
976 gdbarch
, get_frame_pc (frame
));
978 /* Do this regardless of SOURCE because we don't have any source
979 to list for this frame. */
983 uiout
->field_fmt_signed (2, ui_left
, "level",
984 frame_relative_level (frame
));
986 if (uiout
->is_mi_like_p ())
988 annotate_frame_address ();
989 uiout
->field_core_addr ("addr",
990 gdbarch
, get_frame_pc (frame
));
991 annotate_frame_address_end ();
994 if (get_frame_type (frame
) == DUMMY_FRAME
)
996 annotate_function_call ();
997 uiout
->field_string ("func", "<function called from gdb>",
998 ui_out_style_kind::FUNCTION
);
1000 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1002 annotate_signal_handler_caller ();
1003 uiout
->field_string ("func", "<signal handler called>",
1004 ui_out_style_kind::FUNCTION
);
1006 else if (get_frame_type (frame
) == ARCH_FRAME
)
1008 uiout
->field_string ("func", "<cross-architecture call>",
1009 ui_out_style_kind::FUNCTION
);
1012 annotate_frame_end ();
1014 /* If disassemble-next-line is set to auto or on output the next
1016 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1017 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1018 do_gdb_disassembly (get_frame_arch (frame
), 1,
1019 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1024 /* If FRAME is not the innermost frame, that normally means that
1025 FRAME->pc points to *after* the call instruction, and we want to
1026 get the line containing the call, never the next line. But if
1027 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1028 next frame was not entered as the result of a call, and we want
1029 to get the line containing FRAME->pc. */
1030 symtab_and_line sal
= find_frame_sal (frame
);
1032 location_print
= (print_what
== LOCATION
1033 || print_what
== SRC_AND_LOC
1034 || print_what
== LOC_AND_ADDRESS
1035 || print_what
== SHORT_LOCATION
);
1036 if (location_print
|| !sal
.symtab
)
1037 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1039 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1041 /* If disassemble-next-line is set to auto or on and doesn't have
1042 the line debug messages for $pc, output the next instruction. */
1043 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1044 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1045 && source_print
&& !sal
.symtab
)
1046 do_gdb_disassembly (get_frame_arch (frame
), 1,
1047 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1049 if (source_print
&& sal
.symtab
)
1051 int mid_statement
= ((print_what
== SRC_LINE
)
1052 && frame_show_address (frame
, sal
));
1053 annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1054 get_frame_pc (frame
));
1056 if (deprecated_print_frame_info_listing_hook
)
1057 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1061 struct value_print_options opts
;
1063 get_user_print_options (&opts
);
1064 /* We used to do this earlier, but that is clearly
1065 wrong. This function is used by many different
1066 parts of gdb, including normal_stop in infrun.c,
1067 which uses this to print out the current PC
1068 when we stepi/nexti into the middle of a source
1069 line. Only the command line really wants this
1070 behavior. Other UIs probably would like the
1071 ability to decide for themselves if it is desired. */
1072 if (opts
.addressprint
&& mid_statement
)
1074 uiout
->field_core_addr ("addr",
1075 gdbarch
, get_frame_pc (frame
));
1079 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1083 /* If disassemble-next-line is set to on and there is line debug
1084 messages, output assembly codes for next line. */
1085 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1086 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1088 if (set_current_sal
)
1092 if (get_frame_pc_if_available (frame
, &pc
))
1093 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1095 set_last_displayed_sal (0, 0, 0, 0, 0);
1098 annotate_frame_end ();
1100 gdb_flush (gdb_stdout
);
1103 /* Remember the last symtab and line we displayed, which we use e.g.
1104 * as the place to put a breakpoint when the `break' command is
1105 * invoked with no arguments. */
1108 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
1109 CORE_ADDR addr
, struct symtab
*symtab
,
1112 last_displayed_sal_valid
= valid
;
1113 last_displayed_pspace
= pspace
;
1114 last_displayed_addr
= addr
;
1115 last_displayed_symtab
= symtab
;
1116 last_displayed_line
= line
;
1117 if (valid
&& pspace
== NULL
)
1119 clear_last_displayed_sal ();
1120 internal_error (__FILE__
, __LINE__
,
1121 _("Trying to set NULL pspace."));
1125 /* Forget the last sal we displayed. */
1128 clear_last_displayed_sal (void)
1130 last_displayed_sal_valid
= 0;
1131 last_displayed_pspace
= 0;
1132 last_displayed_addr
= 0;
1133 last_displayed_symtab
= 0;
1134 last_displayed_line
= 0;
1137 /* Is our record of the last sal we displayed valid? If not,
1138 * the get_last_displayed_* functions will return NULL or 0, as
1142 last_displayed_sal_is_valid (void)
1144 return last_displayed_sal_valid
;
1147 /* Get the pspace of the last sal we displayed, if it's valid. */
1149 struct program_space
*
1150 get_last_displayed_pspace (void)
1152 if (last_displayed_sal_valid
)
1153 return last_displayed_pspace
;
1157 /* Get the address of the last sal we displayed, if it's valid. */
1160 get_last_displayed_addr (void)
1162 if (last_displayed_sal_valid
)
1163 return last_displayed_addr
;
1167 /* Get the symtab of the last sal we displayed, if it's valid. */
1170 get_last_displayed_symtab (void)
1172 if (last_displayed_sal_valid
)
1173 return last_displayed_symtab
;
1177 /* Get the line of the last sal we displayed, if it's valid. */
1180 get_last_displayed_line (void)
1182 if (last_displayed_sal_valid
)
1183 return last_displayed_line
;
1187 /* Get the last sal we displayed, if it's valid. */
1190 get_last_displayed_sal ()
1192 symtab_and_line sal
;
1194 if (last_displayed_sal_valid
)
1196 sal
.pspace
= last_displayed_pspace
;
1197 sal
.pc
= last_displayed_addr
;
1198 sal
.symtab
= last_displayed_symtab
;
1199 sal
.line
= last_displayed_line
;
1206 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1207 corresponding to FRAME. */
1209 gdb::unique_xmalloc_ptr
<char>
1210 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1211 struct symbol
**funcp
)
1213 struct symbol
*func
;
1214 gdb::unique_xmalloc_ptr
<char> funname
;
1216 *funlang
= language_unknown
;
1220 func
= get_frame_function (frame
);
1223 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1225 *funlang
= SYMBOL_LANGUAGE (func
);
1228 if (*funlang
== language_cplus
)
1230 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1231 to display the demangled name that we already have
1232 stored in the symbol table, but we stored a version
1233 with DMGL_PARAMS turned on, and here we don't want to
1234 display parameters. So remove the parameters. */
1235 funname
= cp_remove_params (print_name
);
1238 /* If we didn't hit the C++ case above, set *funname
1240 if (funname
== NULL
)
1241 funname
.reset (xstrdup (print_name
));
1245 struct bound_minimal_symbol msymbol
;
1248 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1251 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1252 if (msymbol
.minsym
!= NULL
)
1254 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1255 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1263 print_frame (const frame_print_options
&fp_opts
,
1264 frame_info
*frame
, int print_level
,
1265 enum print_what print_what
, int print_args
,
1266 struct symtab_and_line sal
)
1268 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1269 struct ui_out
*uiout
= current_uiout
;
1270 enum language funlang
= language_unknown
;
1271 struct value_print_options opts
;
1272 struct symbol
*func
;
1276 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1278 gdb::unique_xmalloc_ptr
<char> funname
1279 = find_frame_funname (frame
, &funlang
, &func
);
1281 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1285 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1290 uiout
->field_fmt_signed (2, ui_left
, "level",
1291 frame_relative_level (frame
));
1293 get_user_print_options (&opts
);
1294 if (opts
.addressprint
)
1296 || frame_show_address (frame
, sal
)
1297 || print_what
== LOC_AND_ADDRESS
)
1299 annotate_frame_address ();
1302 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1303 if (get_frame_pc_masked (frame
))
1304 uiout
->field_string ("pac", " [PAC]");
1307 uiout
->field_string ("addr", "<unavailable>",
1308 ui_out_style_kind::ADDRESS
);
1309 annotate_frame_address_end ();
1310 uiout
->text (" in ");
1312 annotate_frame_function_name ();
1315 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1316 funlang
, DMGL_ANSI
);
1317 uiout
->field_stream ("func", stb
, ui_out_style_kind::FUNCTION
);
1318 uiout
->wrap_hint (" ");
1319 annotate_frame_args ();
1326 if (gdbarch_frame_num_args_p (gdbarch
))
1328 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1329 gdb_assert (numargs
>= 0);
1335 ui_out_emit_list
list_emitter (uiout
, "args");
1338 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1340 catch (const gdb_exception_error
&e
)
1344 /* FIXME: ARGS must be a list. If one argument is a string it
1345 will have " that will not be properly escaped. */
1350 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1352 const char *filename_display
;
1354 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1355 annotate_frame_source_begin ();
1356 uiout
->wrap_hint (" ");
1357 uiout
->text (" at ");
1358 annotate_frame_source_file ();
1359 uiout
->field_string ("file", filename_display
, ui_out_style_kind::FILE);
1360 if (uiout
->is_mi_like_p ())
1362 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1364 uiout
->field_string ("fullname", fullname
);
1366 annotate_frame_source_file_end ();
1368 annotate_frame_source_line ();
1369 uiout
->field_signed ("line", sal
.line
);
1370 annotate_frame_source_end ();
1373 if (print_what
!= SHORT_LOCATION
1374 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1376 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1377 get_frame_pc (frame
));
1381 annotate_frame_where ();
1382 uiout
->wrap_hint (" ");
1383 uiout
->text (" from ");
1384 uiout
->field_string ("from", lib
);
1387 if (uiout
->is_mi_like_p ())
1388 uiout
->field_string ("arch",
1389 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1396 /* Completion function for "frame function", "info frame function", and
1397 "select-frame function" commands. */
1400 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1401 completion_tracker
&tracker
,
1402 const char *text
, const char *word
)
1404 /* This is used to complete function names within a stack. It would be
1405 nice if we only offered functions that were actually in the stack.
1406 However, this would mean unwinding the stack to completion, which
1407 could take too long, or on a corrupted stack, possibly not end.
1408 Instead, we offer all symbol names as a safer choice. */
1409 collect_symbol_completion_matches (tracker
,
1410 complete_symbol_mode::EXPRESSION
,
1411 symbol_name_match_type::EXPRESSION
,
1415 /* Core of all the "info frame" sub-commands. Print information about a
1416 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1417 frame specification, they just entered 'info frame'. If the user did
1418 provide a frame specification (for example 'info frame 0', 'info frame
1419 level 1') then SELECTED_FRAME_P will be false. */
1422 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1424 struct symbol
*func
;
1426 struct frame_info
*calling_frame_info
;
1428 const char *funname
= 0;
1429 enum language funlang
= language_unknown
;
1430 const char *pc_regname
;
1431 struct gdbarch
*gdbarch
;
1434 /* Initialize it to avoid "may be used uninitialized" warning. */
1435 CORE_ADDR caller_pc
= 0;
1436 int caller_pc_p
= 0;
1438 gdbarch
= get_frame_arch (fi
);
1440 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1441 is not a good name. */
1442 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1443 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1444 easily not match that of the internal value returned by
1446 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1448 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1449 architectures will often have a hardware register called "pc",
1450 and that register's value, again, can easily not match
1454 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1455 func
= get_frame_function (fi
);
1456 symtab_and_line sal
= find_frame_sal (fi
);
1458 gdb::unique_xmalloc_ptr
<char> func_only
;
1461 funname
= SYMBOL_PRINT_NAME (func
);
1462 funlang
= SYMBOL_LANGUAGE (func
);
1463 if (funlang
== language_cplus
)
1465 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1466 to display the demangled name that we already have
1467 stored in the symbol table, but we stored a version
1468 with DMGL_PARAMS turned on, and here we don't want to
1469 display parameters. So remove the parameters. */
1470 func_only
= cp_remove_params (funname
);
1473 funname
= func_only
.get ();
1476 else if (frame_pc_p
)
1478 struct bound_minimal_symbol msymbol
;
1480 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1481 if (msymbol
.minsym
!= NULL
)
1483 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1484 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1487 calling_frame_info
= get_prev_frame (fi
);
1489 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1491 printf_filtered (_("Stack level %d, frame at "),
1492 frame_relative_level (fi
));
1496 printf_filtered (_("Stack frame at "));
1498 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1499 printf_filtered (":\n");
1500 printf_filtered (" %s = ", pc_regname
);
1502 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1504 fputs_filtered ("<unavailable>", gdb_stdout
);
1509 printf_filtered (" in ");
1510 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1511 DMGL_ANSI
| DMGL_PARAMS
);
1515 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1517 puts_filtered ("; ");
1519 printf_filtered ("saved %s = ", pc_regname
);
1521 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1522 val_print_not_saved (gdb_stdout
);
1527 caller_pc
= frame_unwind_caller_pc (fi
);
1530 catch (const gdb_exception_error
&ex
)
1534 case NOT_AVAILABLE_ERROR
:
1535 val_print_unavailable (gdb_stdout
);
1537 case OPTIMIZED_OUT_ERROR
:
1538 val_print_not_saved (gdb_stdout
);
1541 fprintf_filtered (gdb_stdout
, _("<error: %s>"),
1549 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1550 printf_filtered ("\n");
1552 if (calling_frame_info
== NULL
)
1554 enum unwind_stop_reason reason
;
1556 reason
= get_frame_unwind_stop_reason (fi
);
1557 if (reason
!= UNWIND_NO_REASON
)
1558 printf_filtered (_(" Outermost frame: %s\n"),
1559 frame_stop_reason_string (fi
));
1561 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1562 puts_filtered (" tail call frame");
1563 else if (get_frame_type (fi
) == INLINE_FRAME
)
1564 printf_filtered (" inlined into frame %d",
1565 frame_relative_level (get_prev_frame (fi
)));
1568 printf_filtered (" called by frame at ");
1569 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1572 if (get_next_frame (fi
) && calling_frame_info
)
1573 puts_filtered (",");
1575 if (get_next_frame (fi
))
1577 printf_filtered (" caller of frame at ");
1578 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1581 if (get_next_frame (fi
) || calling_frame_info
)
1582 puts_filtered ("\n");
1585 printf_filtered (" source language %s.\n",
1586 language_str (s
->language
));
1589 /* Address of the argument list for this frame, or 0. */
1590 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1591 /* Number of args for this frame, or -1 if unknown. */
1595 printf_filtered (" Arglist at unknown address.\n");
1598 printf_filtered (" Arglist at ");
1599 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1600 printf_filtered (",");
1602 if (!gdbarch_frame_num_args_p (gdbarch
))
1605 puts_filtered (" args: ");
1609 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1610 gdb_assert (numargs
>= 0);
1612 puts_filtered (" no args.");
1613 else if (numargs
== 1)
1614 puts_filtered (" 1 arg: ");
1616 printf_filtered (" %d args: ", numargs
);
1618 print_frame_args (user_frame_print_options
,
1619 func
, fi
, numargs
, gdb_stdout
);
1620 puts_filtered ("\n");
1624 /* Address of the local variables for this frame, or 0. */
1625 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1628 printf_filtered (" Locals at unknown address,");
1631 printf_filtered (" Locals at ");
1632 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1633 printf_filtered (",");
1637 /* Print as much information as possible on the location of all the
1643 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1645 /* The sp is special; what's displayed isn't the save address, but
1646 the value of the previous frame's sp. This is a legacy thing,
1647 at one stage the frame cached the previous frame's SP instead
1648 of its address, hence it was easiest to just display the cached
1652 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1653 gdb_assert (value
!= NULL
);
1655 if (!value_optimized_out (value
) && value_entirely_available (value
))
1657 if (VALUE_LVAL (value
) == not_lval
)
1660 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1661 int sp_size
= register_size (gdbarch
, sp_regnum
);
1663 sp
= extract_unsigned_integer (value_contents_all (value
),
1664 sp_size
, byte_order
);
1666 printf_filtered (" Previous frame's sp is ");
1667 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1668 printf_filtered ("\n");
1670 else if (VALUE_LVAL (value
) == lval_memory
)
1672 printf_filtered (" Previous frame's sp at ");
1673 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1675 printf_filtered ("\n");
1677 else if (VALUE_LVAL (value
) == lval_register
)
1679 printf_filtered (" Previous frame's sp in %s\n",
1680 gdbarch_register_name (gdbarch
,
1681 VALUE_REGNUM (value
)));
1684 release_value (value
);
1687 /* else keep quiet. */
1691 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1692 for (i
= 0; i
< numregs
; i
++)
1694 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1696 enum lval_type lval
;
1702 /* Find out the location of the saved register without
1703 fetching the corresponding value. */
1704 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1705 &lval
, &addr
, &realnum
, NULL
);
1706 /* For moment, only display registers that were saved on the
1708 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1711 puts_filtered (" Saved registers:\n ");
1713 puts_filtered (",");
1715 printf_filtered (" %s at ",
1716 gdbarch_register_name (gdbarch
, i
));
1717 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1721 if (count
|| need_nl
)
1722 puts_filtered ("\n");
1726 /* Return the innermost frame at level LEVEL. */
1728 static struct frame_info
*
1729 leading_innermost_frame (int level
)
1731 struct frame_info
*leading
;
1733 leading
= get_current_frame ();
1735 gdb_assert (level
>= 0);
1737 while (leading
!= nullptr && level
)
1740 leading
= get_prev_frame (leading
);
1747 /* Return the starting frame needed to handle COUNT outermost frames. */
1749 static struct frame_info
*
1750 trailing_outermost_frame (int count
)
1752 struct frame_info
*current
;
1753 struct frame_info
*trailing
;
1755 trailing
= get_current_frame ();
1757 gdb_assert (count
> 0);
1760 while (current
!= nullptr && count
--)
1763 current
= get_prev_frame (current
);
1766 /* Will stop when CURRENT reaches the top of the stack.
1767 TRAILING will be COUNT below it. */
1768 while (current
!= nullptr)
1771 trailing
= get_prev_frame (trailing
);
1772 current
= get_prev_frame (current
);
1778 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1782 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1784 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1786 if (get_selected_frame_if_set () != prev_frame
)
1787 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1793 select_frame_for_mi (struct frame_info
*fi
)
1795 select_frame_command_core (fi
, false /* Ignored. */);
1798 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1799 means we change frame send out a change notification (otherwise, just
1800 reprint the current frame summary). */
1803 frame_command_core (struct frame_info
*fi
, bool ignored
)
1805 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1808 if (get_selected_frame_if_set () != prev_frame
)
1809 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1811 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1814 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1815 common set of sub-commands that allow a specific frame to be selected.
1816 All of the sub-command functions are static methods within this class
1817 template which is then instantiated below. The template parameter is a
1818 callback used to implement the functionality of the base command
1819 ('frame', 'select-frame', or 'info frame').
1821 In the template parameter FI is the frame being selected. The
1822 SELECTED_FRAME_P flag is true if the frame being selected was done by
1823 default, which happens when the user uses the base command with no
1824 arguments. For example the commands 'info frame', 'select-frame',
1825 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1826 SELECTED_FRAME_P is false. */
1828 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1829 class frame_command_helper
1833 /* The "frame level" family of commands. The ARG is an integer that is
1834 the frame's level in the stack. */
1836 level (const char *arg
, int from_tty
)
1838 int level
= value_as_long (parse_and_eval (arg
));
1839 struct frame_info
*fid
1840 = find_relative_frame (get_current_frame (), &level
);
1842 error (_("No frame at level %s."), arg
);
1846 /* The "frame address" family of commands. ARG is a stack-pointer
1847 address for an existing frame. This command does not allow new
1848 frames to be created. */
1851 address (const char *arg
, int from_tty
)
1853 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1854 struct frame_info
*fid
= find_frame_for_address (addr
);
1856 error (_("No frame at address %s."), arg
);
1860 /* The "frame view" family of commands. ARG is one or two addresses and
1861 is used to view a frame that might be outside the current backtrace.
1862 The addresses are stack-pointer address, and (optional) pc-address. */
1865 view (const char *args
, int from_tty
)
1867 struct frame_info
*fid
;
1870 error (_("Missing address argument to view a frame"));
1872 gdb_argv
argv (args
);
1874 if (argv
.count () == 2)
1878 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1879 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1880 fid
= create_new_frame (addr
[0], addr
[1]);
1884 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1885 fid
= create_new_frame (addr
, false);
1890 /* The "frame function" family of commands. ARG is the name of a
1891 function within the stack, the first function (searching from frame
1892 0) with that name will be selected. */
1895 function (const char *arg
, int from_tty
)
1898 error (_("Missing function name argument"));
1899 struct frame_info
*fid
= find_frame_for_function (arg
);
1901 error (_("No frame for function \"%s\"."), arg
);
1905 /* The "frame" base command, that is, when no sub-command is specified.
1906 If one argument is provided then we assume that this is a frame's
1907 level as historically, this was the supported command syntax that was
1910 If no argument is provided, then the current frame is selected. */
1913 base_command (const char *arg
, int from_tty
)
1916 FPTR (get_selected_frame (_("No stack.")), true);
1918 level (arg
, from_tty
);
1922 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1923 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1925 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1926 static frame_command_helper
<frame_command_core
> frame_cmd
;
1927 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1929 /* Print briefly all stack frames or just the innermost COUNT_EXP
1933 backtrace_command_1 (const frame_print_options
&fp_opts
,
1934 const backtrace_cmd_options
&bt_opts
,
1935 const char *count_exp
, int from_tty
)
1938 struct frame_info
*fi
;
1940 int py_start
= 0, py_end
= 0;
1941 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1943 if (!target_has_stack
)
1944 error (_("No stack."));
1948 count
= parse_and_eval_long (count_exp
);
1954 /* The argument to apply_ext_lang_frame_filter is the number
1955 of the final frame to print, and frames start at 0. */
1965 frame_filter_flags flags
= 0;
1968 flags
|= PRINT_LOCALS
;
1970 flags
|= PRINT_HIDE
;
1972 if (!bt_opts
.no_filters
)
1974 enum ext_lang_frame_args arg_type
;
1976 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1978 flags
|= PRINT_MORE_FRAMES
;
1980 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
1981 arg_type
= CLI_SCALAR_VALUES
;
1982 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
1983 arg_type
= CLI_ALL_VALUES
;
1984 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
1985 arg_type
= CLI_PRESENCE
;
1986 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
1987 arg_type
= NO_VALUES
;
1991 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1992 arg_type
, current_uiout
,
1996 /* Run the inbuilt backtrace if there are no filters registered, or
1997 "-no-filters" has been specified from the command. */
1998 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2000 struct frame_info
*trailing
;
2002 /* The following code must do two things. First, it must set the
2003 variable TRAILING to the frame from which we should start
2004 printing. Second, it must set the variable count to the number
2005 of frames which we should print, or -1 if all of them. */
2007 if (count_exp
!= NULL
&& count
< 0)
2009 trailing
= trailing_outermost_frame (-count
);
2013 trailing
= get_current_frame ();
2015 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2019 /* Don't use print_stack_frame; if an error() occurs it probably
2020 means further attempts to backtrace would fail (on the other
2021 hand, perhaps the code does or could be fixed to make sure
2022 the frame->prev field gets set to NULL in that case). */
2024 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2025 if ((flags
& PRINT_LOCALS
) != 0)
2027 struct frame_id frame_id
= get_frame_id (fi
);
2029 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2031 /* print_frame_local_vars invalidates FI. */
2032 fi
= frame_find_by_id (frame_id
);
2036 warning (_("Unable to restore previously selected frame."));
2041 /* Save the last frame to check for error conditions. */
2045 /* If we've stopped before the end, mention that. */
2047 printf_filtered (_("(More stack frames follow...)\n"));
2049 /* If we've run out of frames, and the reason appears to be an error
2050 condition, print it. */
2051 if (fi
== NULL
&& trailing
!= NULL
)
2053 enum unwind_stop_reason reason
;
2055 reason
= get_frame_unwind_stop_reason (trailing
);
2056 if (reason
>= UNWIND_FIRST_ERROR
)
2057 printf_filtered (_("Backtrace stopped: %s\n"),
2058 frame_stop_reason_string (trailing
));
2063 /* Create an option_def_group array grouping all the "backtrace"
2064 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2066 static inline std::array
<gdb::option::option_def_group
, 3>
2067 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2068 backtrace_cmd_options
*bt_cmd_opts
,
2069 set_backtrace_options
*set_bt_opts
)
2072 { {frame_print_option_defs
}, fp_opts
},
2073 { {set_backtrace_option_defs
}, set_bt_opts
},
2074 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2078 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2079 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2080 store the parsed qualifiers. */
2083 parse_backtrace_qualifiers (const char *arg
,
2084 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2088 const char *save_arg
= arg
;
2089 std::string this_arg
= extract_arg (&arg
);
2091 if (this_arg
.empty ())
2094 if (subset_compare (this_arg
.c_str (), "no-filters"))
2096 if (bt_cmd_opts
!= nullptr)
2097 bt_cmd_opts
->no_filters
= true;
2099 else if (subset_compare (this_arg
.c_str (), "full"))
2101 if (bt_cmd_opts
!= nullptr)
2102 bt_cmd_opts
->full
= true;
2104 else if (subset_compare (this_arg
.c_str (), "hide"))
2106 if (bt_cmd_opts
!= nullptr)
2107 bt_cmd_opts
->hide
= true;
2111 /* Not a recognized qualifier, so stop. */
2118 backtrace_command (const char *arg
, int from_tty
)
2120 frame_print_options fp_opts
= user_frame_print_options
;
2121 backtrace_cmd_options bt_cmd_opts
;
2122 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2125 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2126 gdb::option::process_options
2127 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2129 /* Parse non-'-'-prefixed qualifiers, for backwards
2133 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2138 /* These options are handled quite deep in the unwind machinery, so
2139 we get to pass them down by swapping globals. */
2140 scoped_restore restore_set_backtrace_options
2141 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2143 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2146 /* Completer for the "backtrace" command. */
2149 backtrace_command_completer (struct cmd_list_element
*ignore
,
2150 completion_tracker
&tracker
,
2151 const char *text
, const char */
*word*/
)
2154 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2155 if (gdb::option::complete_options
2156 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2161 const char *p
= skip_to_space (text
);
2164 static const char *const backtrace_cmd_qualifier_choices
[] = {
2165 "full", "no-filters", "hide", nullptr,
2167 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2170 if (tracker
.have_completions ())
2175 const char *cmd
= parse_backtrace_qualifiers (text
);
2176 tracker
.advance_custom_word_point_by (cmd
- text
);
2181 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2182 expression_completer (ignore
, tracker
, text
, word
);
2185 /* Iterate over the local variables of a block B, calling CB with
2189 iterate_over_block_locals (const struct block
*b
,
2190 iterate_over_block_arg_local_vars_cb cb
,
2193 struct block_iterator iter
;
2196 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2198 switch (SYMBOL_CLASS (sym
))
2204 case LOC_OPTIMIZED_OUT
:
2205 if (SYMBOL_IS_ARGUMENT (sym
))
2207 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2209 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
2213 /* Ignore symbols which are not locals. */
2220 /* Same, but print labels. */
2223 /* Commented out, as the code using this function has also been
2224 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2225 was commented out in the first place. The discussion introducing
2226 this change (2007-12-04: Support lexical blocks and function bodies
2227 that occupy non-contiguous address ranges) did not explain why
2228 this change was made. */
2230 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2231 int *have_default
, struct ui_file
*stream
)
2233 struct block_iterator iter
;
2235 int values_printed
= 0;
2237 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2239 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2245 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2247 struct symtab_and_line sal
;
2248 struct value_print_options opts
;
2250 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2252 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2253 get_user_print_options (&opts
);
2254 if (opts
.addressprint
)
2256 fprintf_filtered (stream
, " ");
2257 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2260 fprintf_filtered (stream
, " in file %s, line %d\n",
2261 sal
.symtab
->filename
, sal
.line
);
2265 return values_printed
;
2269 /* Iterate over all the local variables in block B, including all its
2270 superblocks, stopping when the top-level block is reached. */
2273 iterate_over_block_local_vars (const struct block
*block
,
2274 iterate_over_block_arg_local_vars_cb cb
,
2279 iterate_over_block_locals (block
, cb
, cb_data
);
2280 /* After handling the function's top-level block, stop. Don't
2281 continue to its superblock, the block of per-file
2283 if (BLOCK_FUNCTION (block
))
2285 block
= BLOCK_SUPERBLOCK (block
);
2289 /* Data to be passed around in the calls to the locals and args
2292 struct print_variable_and_value_data
2294 gdb::optional
<compiled_regex
> preg
;
2295 gdb::optional
<compiled_regex
> treg
;
2296 struct frame_id frame_id
;
2298 struct ui_file
*stream
;
2302 /* The callback for the locals and args iterators. */
2305 do_print_variable_and_value (const char *print_name
,
2309 struct print_variable_and_value_data
*p
2310 = (struct print_variable_and_value_data
*) cb_data
;
2311 struct frame_info
*frame
;
2313 if (p
->preg
.has_value ()
2314 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2317 if (p
->treg
.has_value ()
2318 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2321 frame
= frame_find_by_id (p
->frame_id
);
2324 warning (_("Unable to restore previously selected frame."));
2328 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2330 /* print_variable_and_value invalidates FRAME. */
2333 p
->values_printed
= 1;
2336 /* Prepares the regular expression REG from REGEXP.
2337 If REGEXP is NULL, it results in an empty regular expression. */
2340 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2344 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2346 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2352 /* Print all variables from the innermost up to the function block of FRAME.
2353 Print them with values to STREAM indented by NUM_TABS.
2354 If REGEXP is not NULL, only print local variables whose name
2356 If T_REGEXP is not NULL, only print local variables whose type
2358 If no local variables have been printed and !QUIET, prints a message
2359 explaining why no local variables could be printed.
2361 This function will invalidate FRAME. */
2364 print_frame_local_vars (struct frame_info
*frame
,
2366 const char *regexp
, const char *t_regexp
,
2367 int num_tabs
, struct ui_file
*stream
)
2369 struct print_variable_and_value_data cb_data
;
2370 const struct block
*block
;
2373 if (!get_frame_pc_if_available (frame
, &pc
))
2376 fprintf_filtered (stream
,
2377 _("PC unavailable, cannot determine locals.\n"));
2381 block
= get_frame_block (frame
, 0);
2385 fprintf_filtered (stream
, "No symbol table info available.\n");
2389 prepare_reg (regexp
, &cb_data
.preg
);
2390 prepare_reg (t_regexp
, &cb_data
.treg
);
2391 cb_data
.frame_id
= get_frame_id (frame
);
2392 cb_data
.num_tabs
= 4 * num_tabs
;
2393 cb_data
.stream
= stream
;
2394 cb_data
.values_printed
= 0;
2396 /* Temporarily change the selected frame to the given FRAME.
2397 This allows routines that rely on the selected frame instead
2398 of being given a frame as parameter to use the correct frame. */
2399 scoped_restore_selected_frame restore_selected_frame
;
2400 select_frame (frame
);
2402 iterate_over_block_local_vars (block
,
2403 do_print_variable_and_value
,
2406 if (!cb_data
.values_printed
&& !quiet
)
2408 if (regexp
== NULL
&& t_regexp
== NULL
)
2409 fprintf_filtered (stream
, _("No locals.\n"));
2411 fprintf_filtered (stream
, _("No matching locals.\n"));
2415 /* Implement the 'info locals' command. */
2418 info_locals_command (const char *args
, int from_tty
)
2420 info_print_options opts
;
2421 extract_info_print_options (&opts
, &args
);
2423 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2424 opts
.quiet
, args
, opts
.type_regexp
,
2428 /* Iterate over all the argument variables in block B. */
2431 iterate_over_block_arg_vars (const struct block
*b
,
2432 iterate_over_block_arg_local_vars_cb cb
,
2435 struct block_iterator iter
;
2436 struct symbol
*sym
, *sym2
;
2438 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2440 /* Don't worry about things which aren't arguments. */
2441 if (SYMBOL_IS_ARGUMENT (sym
))
2443 /* We have to look up the symbol because arguments can have
2444 two entries (one a parameter, one a local) and the one we
2445 want is the local, which lookup_symbol will find for us.
2446 This includes gcc1 (not gcc2) on the sparc when passing a
2447 small structure and gcc2 when the argument type is float
2448 and it is passed as a double and converted to float by
2449 the prologue (in the latter case the type of the LOC_ARG
2450 symbol is double and the type of the LOC_LOCAL symbol is
2451 float). There are also LOC_ARG/LOC_REGISTER pairs which
2452 are not combined in symbol-reading. */
2454 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2455 b
, VAR_DOMAIN
).symbol
;
2456 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2461 /* Print all argument variables of the function of FRAME.
2462 Print them with values to STREAM.
2463 If REGEXP is not NULL, only print argument variables whose name
2465 If T_REGEXP is not NULL, only print argument variables whose type
2467 If no argument variables have been printed and !QUIET, prints a message
2468 explaining why no argument variables could be printed.
2470 This function will invalidate FRAME. */
2473 print_frame_arg_vars (struct frame_info
*frame
,
2475 const char *regexp
, const char *t_regexp
,
2476 struct ui_file
*stream
)
2478 struct print_variable_and_value_data cb_data
;
2479 struct symbol
*func
;
2481 gdb::optional
<compiled_regex
> preg
;
2482 gdb::optional
<compiled_regex
> treg
;
2484 if (!get_frame_pc_if_available (frame
, &pc
))
2487 fprintf_filtered (stream
,
2488 _("PC unavailable, cannot determine args.\n"));
2492 func
= get_frame_function (frame
);
2496 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2500 prepare_reg (regexp
, &cb_data
.preg
);
2501 prepare_reg (t_regexp
, &cb_data
.treg
);
2502 cb_data
.frame_id
= get_frame_id (frame
);
2503 cb_data
.num_tabs
= 0;
2504 cb_data
.stream
= stream
;
2505 cb_data
.values_printed
= 0;
2507 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2508 do_print_variable_and_value
, &cb_data
);
2510 /* do_print_variable_and_value invalidates FRAME. */
2513 if (!cb_data
.values_printed
&& !quiet
)
2515 if (regexp
== NULL
&& t_regexp
== NULL
)
2516 fprintf_filtered (stream
, _("No arguments.\n"));
2518 fprintf_filtered (stream
, _("No matching arguments.\n"));
2522 /* Implement the 'info args' command. */
2525 info_args_command (const char *args
, int from_tty
)
2527 info_print_options opts
;
2528 extract_info_print_options (&opts
, &args
);
2530 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2531 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2534 /* Return the symbol-block in which the selected frame is executing.
2535 Can return zero under various legitimate circumstances.
2537 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2538 code address within the block returned. We use this to decide
2539 which macros are in scope. */
2541 const struct block
*
2542 get_selected_block (CORE_ADDR
*addr_in_block
)
2544 if (!has_stack_frames ())
2547 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2550 /* Find a frame a certain number of levels away from FRAME.
2551 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2552 Positive means go to earlier frames (up); negative, the reverse.
2553 The int that contains the number of levels is counted toward
2554 zero as the frames for those levels are found.
2555 If the top or bottom frame is reached, that frame is returned,
2556 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2557 how much farther the original request asked to go. */
2560 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2562 /* Going up is simple: just call get_prev_frame enough times or
2563 until the initial frame is reached. */
2564 while (*level_offset_ptr
> 0)
2566 struct frame_info
*prev
= get_prev_frame (frame
);
2570 (*level_offset_ptr
)--;
2574 /* Going down is just as simple. */
2575 while (*level_offset_ptr
< 0)
2577 struct frame_info
*next
= get_next_frame (frame
);
2581 (*level_offset_ptr
)++;
2588 /* Select the frame up one or COUNT_EXP stack levels from the
2589 previously selected frame, and print it briefly. */
2592 up_silently_base (const char *count_exp
)
2594 struct frame_info
*frame
;
2598 count
= parse_and_eval_long (count_exp
);
2600 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2601 if (count
!= 0 && count_exp
== NULL
)
2602 error (_("Initial frame selected; you cannot go up."));
2603 select_frame (frame
);
2607 up_silently_command (const char *count_exp
, int from_tty
)
2609 up_silently_base (count_exp
);
2613 up_command (const char *count_exp
, int from_tty
)
2615 up_silently_base (count_exp
);
2616 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2619 /* Select the frame down one or COUNT_EXP stack levels from the previously
2620 selected frame, and print it briefly. */
2623 down_silently_base (const char *count_exp
)
2625 struct frame_info
*frame
;
2629 count
= -parse_and_eval_long (count_exp
);
2631 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2632 if (count
!= 0 && count_exp
== NULL
)
2634 /* We only do this if COUNT_EXP is not specified. That way
2635 "down" means to really go down (and let me know if that is
2636 impossible), but "down 9999" can be used to mean go all the
2637 way down without getting an error. */
2639 error (_("Bottom (innermost) frame selected; you cannot go down."));
2642 select_frame (frame
);
2646 down_silently_command (const char *count_exp
, int from_tty
)
2648 down_silently_base (count_exp
);
2652 down_command (const char *count_exp
, int from_tty
)
2654 down_silently_base (count_exp
);
2655 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2659 return_command (const char *retval_exp
, int from_tty
)
2661 /* Initialize it just to avoid a GCC false warning. */
2662 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2663 struct frame_info
*thisframe
;
2664 struct gdbarch
*gdbarch
;
2665 struct symbol
*thisfun
;
2666 struct value
*return_value
= NULL
;
2667 struct value
*function
= NULL
;
2668 const char *query_prefix
= "";
2670 thisframe
= get_selected_frame ("No selected frame.");
2671 thisfun
= get_frame_function (thisframe
);
2672 gdbarch
= get_frame_arch (thisframe
);
2674 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2675 error (_("Can not force return from an inlined function."));
2677 /* Compute the return value. If the computation triggers an error,
2678 let it bail. If the return type can't be handled, set
2679 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2683 expression_up retval_expr
= parse_expression (retval_exp
);
2684 struct type
*return_type
= NULL
;
2686 /* Compute the return value. Should the computation fail, this
2687 call throws an error. */
2688 return_value
= evaluate_expression (retval_expr
.get ());
2690 /* Cast return value to the return type of the function. Should
2691 the cast fail, this call throws an error. */
2692 if (thisfun
!= NULL
)
2693 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2694 if (return_type
== NULL
)
2696 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2697 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2698 error (_("Return value type not available for selected "
2700 "Please use an explicit cast of the value to return."));
2701 return_type
= value_type (return_value
);
2703 return_type
= check_typedef (return_type
);
2704 return_value
= value_cast (return_type
, return_value
);
2706 /* Make sure the value is fully evaluated. It may live in the
2707 stack frame we're about to pop. */
2708 if (value_lazy (return_value
))
2709 value_fetch_lazy (return_value
);
2711 if (thisfun
!= NULL
)
2712 function
= read_var_value (thisfun
, NULL
, thisframe
);
2714 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2715 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2716 /* If the return-type is "void", don't try to find the
2717 return-value's location. However, do still evaluate the
2718 return expression so that, even when the expression result
2719 is discarded, side effects such as "return i++" still
2721 return_value
= NULL
;
2722 else if (thisfun
!= NULL
)
2724 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2725 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2726 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2728 query_prefix
= "The location at which to store the "
2729 "function's return value is unknown.\n"
2730 "If you continue, the return value "
2731 "that you specified will be ignored.\n";
2732 return_value
= NULL
;
2737 /* Does an interactive user really want to do this? Include
2738 information, such as how well GDB can handle the return value, in
2739 the query message. */
2744 if (thisfun
== NULL
)
2745 confirmed
= query (_("%sMake selected stack frame return now? "),
2749 if (TYPE_NO_RETURN (thisfun
->type
))
2750 warning (_("Function does not return normally to caller."));
2751 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2752 SYMBOL_PRINT_NAME (thisfun
));
2755 error (_("Not confirmed"));
2758 /* Discard the selected frame and all frames inner-to it. */
2759 frame_pop (get_selected_frame (NULL
));
2761 /* Store RETURN_VALUE in the just-returned register set. */
2762 if (return_value
!= NULL
)
2764 struct type
*return_type
= value_type (return_value
);
2765 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2767 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2768 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2769 gdbarch_return_value (cache_arch
, function
, return_type
,
2770 get_current_regcache (), NULL
/*read*/,
2771 value_contents (return_value
) /*write*/);
2774 /* If we are at the end of a call dummy now, pop the dummy frame
2776 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2777 frame_pop (get_current_frame ());
2779 select_frame (get_current_frame ());
2780 /* If interactive, print the frame that is now current. */
2782 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2785 /* Find the most inner frame in the current stack for a function called
2786 FUNCTION_NAME. If no matching frame is found return NULL. */
2788 static struct frame_info
*
2789 find_frame_for_function (const char *function_name
)
2791 /* Used to hold the lower and upper addresses for each of the
2792 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2793 struct function_bounds
2795 CORE_ADDR low
, high
;
2797 struct frame_info
*frame
;
2801 gdb_assert (function_name
!= NULL
);
2803 frame
= get_current_frame ();
2804 std::vector
<symtab_and_line
> sals
2805 = decode_line_with_current_source (function_name
,
2806 DECODE_LINE_FUNFIRSTLINE
);
2807 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2808 for (size_t i
= 0; i
< sals
.size (); i
++)
2810 if (sals
[i
].pspace
!= current_program_space
)
2811 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2812 else if (sals
[i
].pc
== 0
2813 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2814 &func_bounds
[i
].low
,
2815 &func_bounds
[i
].high
) == 0)
2816 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2821 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2822 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2823 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2827 frame
= find_relative_frame (frame
, &level
);
2830 while (!found
&& level
== 0);
2838 /* Implements the dbx 'func' command. */
2841 func_command (const char *arg
, int from_tty
)
2846 struct frame_info
*frame
= find_frame_for_function (arg
);
2848 error (_("'%s' not within current stack frame."), arg
);
2849 if (frame
!= get_selected_frame (NULL
))
2851 select_frame (frame
);
2852 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2856 /* The qcs command line flags for the "frame apply" commands. Keep
2857 this in sync with the "thread apply" commands. */
2859 using qcs_flag_option_def
2860 = gdb::option::flag_option_def
<qcs_flags
>;
2862 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2863 qcs_flag_option_def
{
2864 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2865 N_("Disables printing the frame location information."),
2868 qcs_flag_option_def
{
2869 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2870 N_("Print any error raised by COMMAND and continue."),
2873 qcs_flag_option_def
{
2874 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2875 N_("Silently ignore any errors or empty output produced by COMMAND."),
2879 /* Create an option_def_group array for all the "frame apply" options,
2880 with FLAGS and SET_BT_OPTS as context. */
2882 static inline std::array
<gdb::option::option_def_group
, 2>
2883 make_frame_apply_options_def_group (qcs_flags
*flags
,
2884 set_backtrace_options
*set_bt_opts
)
2887 { {fr_qcs_flags_option_defs
}, flags
},
2888 { {set_backtrace_option_defs
}, set_bt_opts
},
2892 /* Apply a GDB command to all stack frames, or a set of identified frames,
2893 or innermost COUNT frames.
2894 With a negative COUNT, apply command on outermost -COUNT frames.
2896 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2897 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2898 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2899 frame apply all -s p local_var_no_idea_in_which_frame
2900 If a frame has a local variable called
2901 local_var_no_idea_in_which_frame, print frame
2902 and value of local_var_no_idea_in_which_frame.
2903 frame apply all -s -q p local_var_no_idea_in_which_frame
2904 Same as before, but only print the variable value.
2905 frame apply level 2-5 0 4-7 -s p i = i + 1
2906 Adds 1 to the variable i in the specified frames.
2907 Note that i will be incremented twice in
2910 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2911 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2912 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2913 for error messages. */
2916 frame_apply_command_count (const char *which_command
,
2917 const char *cmd
, int from_tty
,
2918 struct frame_info
*trailing
, int count
)
2921 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2923 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2924 gdb::option::process_options
2925 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2927 validate_flags_qcs (which_command
, &flags
);
2929 if (cmd
== NULL
|| *cmd
== '\0')
2930 error (_("Please specify a command to apply on the selected frames"));
2932 /* The below will restore the current inferior/thread/frame.
2933 Usually, only the frame is effectively to be restored.
2934 But in case CMD switches of inferior/thread, better restore
2936 scoped_restore_current_thread restore_thread
;
2938 /* These options are handled quite deep in the unwind machinery, so
2939 we get to pass them down by swapping globals. */
2940 scoped_restore restore_set_backtrace_options
2941 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2943 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2950 std::string cmd_result
;
2952 /* In case CMD switches of inferior/thread/frame, the below
2953 restores the inferior/thread/frame. FI can then be
2954 set to the selected frame. */
2955 scoped_restore_current_thread restore_fi_current_frame
;
2957 cmd_result
= execute_command_to_string
2958 (cmd
, from_tty
, gdb_stdout
->term_out ());
2960 fi
= get_selected_frame (_("frame apply "
2961 "unable to get selected frame."));
2962 if (!flags
.silent
|| cmd_result
.length () > 0)
2965 print_stack_frame (fi
, 1, LOCATION
, 0);
2966 printf_filtered ("%s", cmd_result
.c_str ());
2969 catch (const gdb_exception_error
&ex
)
2971 fi
= get_selected_frame (_("frame apply "
2972 "unable to get selected frame."));
2976 print_stack_frame (fi
, 1, LOCATION
, 0);
2978 printf_filtered ("%s\n", ex
.what ());
2986 /* Completer for the "frame apply ..." commands. */
2989 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
2991 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
2992 if (gdb::option::complete_options
2993 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2996 complete_nested_command_line (tracker
, text
);
2999 /* Completer for the "frame apply" commands. */
3002 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3003 completion_tracker
&tracker
,
3004 const char *text
, const char */
*word*/
)
3006 /* Do this explicitly because there's an early return below. */
3007 tracker
.set_use_custom_word_point (true);
3009 number_or_range_parser
levels (text
);
3011 /* Skip the LEVEL list to find the options and command args. */
3014 while (!levels
.finished ())
3016 /* Call for effect. */
3017 levels
.get_number ();
3019 if (levels
.in_range ())
3020 levels
.skip_range ();
3023 catch (const gdb_exception_error
&ex
)
3025 /* get_number throws if it parses a negative number, for
3026 example. But a seemingly negative number may be the start of
3027 an option instead. */
3030 const char *cmd
= levels
.cur_tok ();
3034 /* No level list yet. */
3038 /* Check if we're past a valid LEVEL already. */
3039 if (levels
.finished ()
3040 && cmd
> text
&& !isspace (cmd
[-1]))
3043 /* We're past LEVELs, advance word point. */
3044 tracker
.advance_custom_word_point_by (cmd
- text
);
3047 frame_apply_completer (tracker
, text
);
3050 /* Completer for the "frame apply all" command. */
3053 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3054 completion_tracker
&tracker
,
3055 const char *text
, const char */
*word*/
)
3057 frame_apply_completer (tracker
, text
);
3060 /* Completer for the "frame apply COUNT" command. */
3063 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3064 completion_tracker
&tracker
,
3065 const char *text
, const char */
*word*/
)
3067 const char *cmd
= text
;
3069 int count
= get_number_trailer (&cmd
, 0);
3073 /* Check if we're past a valid COUNT already. */
3074 if (cmd
> text
&& !isspace (cmd
[-1]))
3077 /* We're past COUNT, advance word point. */
3078 tracker
.advance_custom_word_point_by (cmd
- text
);
3081 frame_apply_completer (tracker
, text
);
3084 /* Implementation of the "frame apply level" command. */
3087 frame_apply_level_command (const char *cmd
, int from_tty
)
3089 if (!target_has_stack
)
3090 error (_("No stack."));
3092 bool level_found
= false;
3093 const char *levels_str
= cmd
;
3094 number_or_range_parser
levels (levels_str
);
3096 /* Skip the LEVEL list to find the flags and command args. */
3097 while (!levels
.finished ())
3099 /* Call for effect. */
3100 levels
.get_number ();
3103 if (levels
.in_range ())
3104 levels
.skip_range ();
3108 error (_("Missing or invalid LEVEL... argument"));
3110 cmd
= levels
.cur_tok ();
3112 /* Redo the LEVELS parsing, but applying COMMAND. */
3113 levels
.init (levels_str
);
3114 while (!levels
.finished ())
3116 const int level_beg
= levels
.get_number ();
3119 if (levels
.in_range ())
3121 n_frames
= levels
.end_value () - level_beg
+ 1;
3122 levels
.skip_range ();
3127 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3128 leading_innermost_frame (level_beg
), n_frames
);
3132 /* Implementation of the "frame apply all" command. */
3135 frame_apply_all_command (const char *cmd
, int from_tty
)
3137 if (!target_has_stack
)
3138 error (_("No stack."));
3140 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3141 get_current_frame (), INT_MAX
);
3144 /* Implementation of the "frame apply" command. */
3147 frame_apply_command (const char* cmd
, int from_tty
)
3150 struct frame_info
*trailing
;
3152 if (!target_has_stack
)
3153 error (_("No stack."));
3156 error (_("Missing COUNT argument."));
3157 count
= get_number_trailer (&cmd
, 0);
3159 error (_("Invalid COUNT argument."));
3163 trailing
= trailing_outermost_frame (-count
);
3167 trailing
= get_current_frame ();
3169 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3173 /* Implementation of the "faas" command. */
3176 faas_command (const char *cmd
, int from_tty
)
3178 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3179 execute_command (expanded
.c_str (), from_tty
);
3183 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3184 matching frame can be found. */
3186 static struct frame_info
*
3187 find_frame_for_address (CORE_ADDR address
)
3190 struct frame_info
*fid
;
3192 id
= frame_id_build_wild (address
);
3194 /* If (s)he specifies the frame with an address, he deserves
3195 what (s)he gets. Still, give the highest one that matches.
3196 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3198 for (fid
= get_current_frame ();
3200 fid
= get_prev_frame (fid
))
3202 if (frame_id_eq (id
, get_frame_id (fid
)))
3204 struct frame_info
*prev_frame
;
3208 prev_frame
= get_prev_frame (fid
);
3210 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3222 /* Commands with a prefix of `frame apply'. */
3223 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3225 /* Commands with a prefix of `frame'. */
3226 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3228 /* Commands with a prefix of `select frame'. */
3229 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3231 /* Commands with a prefix of `info frame'. */
3232 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3235 _initialize_stack (void)
3237 struct cmd_list_element
*cmd
;
3239 add_com ("return", class_stack
, return_command
, _("\
3240 Make selected stack frame return to its caller.\n\
3241 Control remains in the debugger, but when you continue\n\
3242 execution will resume in the frame above the one now selected.\n\
3243 If an argument is given, it is an expression for the value to return."));
3245 add_com ("up", class_stack
, up_command
, _("\
3246 Select and print stack frame that called this one.\n\
3247 An argument says how many frames up to go."));
3248 add_com ("up-silently", class_support
, up_silently_command
, _("\
3249 Same as the `up' command, but does not print anything.\n\
3250 This is useful in command scripts."));
3252 add_com ("down", class_stack
, down_command
, _("\
3253 Select and print stack frame called by this one.\n\
3254 An argument says how many frames down to go."));
3255 add_com_alias ("do", "down", class_stack
, 1);
3256 add_com_alias ("dow", "down", class_stack
, 1);
3257 add_com ("down-silently", class_support
, down_silently_command
, _("\
3258 Same as the `down' command, but does not print anything.\n\
3259 This is useful in command scripts."));
3261 add_prefix_cmd ("frame", class_stack
,
3262 &frame_cmd
.base_command
, _("\
3263 Select and print a stack frame.\n\
3264 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3265 A single numerical argument specifies the frame to select."),
3266 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3268 add_com_alias ("f", "frame", class_stack
, 1);
3270 #define FRAME_APPLY_OPTION_HELP "\
3271 Prints the frame location information followed by COMMAND output.\n\
3273 By default, an error raised during the execution of COMMAND\n\
3274 aborts \"frame apply\".\n\
3279 const auto frame_apply_opts
3280 = make_frame_apply_options_def_group (nullptr, nullptr);
3282 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3283 Apply a command to a number of frames.\n\
3284 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3285 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3286 FRAME_APPLY_OPTION_HELP
),
3289 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3290 frame_apply_cmd_help
.c_str (),
3291 &frame_apply_cmd_list
, "frame apply ", 1,
3293 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3295 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3296 Apply a command to all frames.\n\
3298 Usage: frame apply all [OPTION]... COMMAND\n"
3299 FRAME_APPLY_OPTION_HELP
),
3302 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3303 frame_apply_all_cmd_help
.c_str (),
3304 &frame_apply_cmd_list
);
3305 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3307 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3308 Apply a command to a list of frames.\n\
3310 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3311 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3312 FRAME_APPLY_OPTION_HELP
),
3315 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3316 frame_apply_level_cmd_help
.c_str (),
3317 &frame_apply_cmd_list
);
3318 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3320 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3321 Apply a command to all frames (ignoring errors and empty output).\n\
3322 Usage: faas [OPTION]... COMMAND\n\
3323 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3324 See \"help frame apply all\" for available options."));
3325 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3327 add_prefix_cmd ("frame", class_stack
,
3328 &frame_cmd
.base_command
, _("\
3329 Select and print a stack frame.\n\
3330 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3331 A single numerical argument specifies the frame to select."),
3332 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3333 add_com_alias ("f", "frame", class_stack
, 1);
3335 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3337 Select and print a stack frame by stack address.\n\
3339 Usage: frame address STACK-ADDRESS"),
3342 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3344 View a stack frame that might be outside the current backtrace.\n\
3346 Usage: frame view STACK-ADDRESS\n\
3347 frame view STACK-ADDRESS PC-ADDRESS"),
3350 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3352 Select and print a stack frame by function name.\n\
3354 Usage: frame function NAME\n\
3356 The innermost frame that visited function NAME is selected."),
3358 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3361 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3363 Select and print a stack frame by level.\n\
3365 Usage: frame level LEVEL"),
3368 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3369 &select_frame_cmd
.base_command
, _("\
3370 Select a stack frame without printing anything.\n\
3371 A single numerical argument specifies the frame to select."),
3372 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3373 &cli_suppress_notification
.user_selected_context
);
3375 add_cmd_suppress_notification ("address", class_stack
,
3376 &select_frame_cmd
.address
, _("\
3377 Select a stack frame by stack address.\n\
3379 Usage: select-frame address STACK-ADDRESS"),
3380 &select_frame_cmd_list
,
3381 &cli_suppress_notification
.user_selected_context
);
3384 add_cmd_suppress_notification ("view", class_stack
,
3385 &select_frame_cmd
.view
, _("\
3386 Select a stack frame that might be outside the current backtrace.\n\
3388 Usage: select-frame view STACK-ADDRESS\n\
3389 select-frame view STACK-ADDRESS PC-ADDRESS"),
3390 &select_frame_cmd_list
,
3391 &cli_suppress_notification
.user_selected_context
);
3393 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3394 &select_frame_cmd
.function
, _("\
3395 Select a stack frame by function name.\n\
3397 Usage: select-frame function NAME"),
3398 &select_frame_cmd_list
,
3399 &cli_suppress_notification
.user_selected_context
);
3400 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3402 add_cmd_suppress_notification ("level", class_stack
,
3403 &select_frame_cmd
.level
, _("\
3404 Select a stack frame by level.\n\
3406 Usage: select-frame level LEVEL"),
3407 &select_frame_cmd_list
,
3408 &cli_suppress_notification
.user_selected_context
);
3410 const auto backtrace_opts
3411 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3413 static std::string backtrace_help
3414 = gdb::option::build_help (_("\
3415 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3416 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3421 For backward compatibility, the following qualifiers are supported:\n\
3423 full - same as -full option.\n\
3424 no-filters - same as -no-filters option.\n\
3425 hide - same as -hide.\n\
3427 With a negative COUNT, print outermost -COUNT frames."),
3430 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3432 backtrace_help
.c_str ());
3433 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3435 add_com_alias ("bt", "backtrace", class_stack
, 0);
3437 add_com_alias ("where", "backtrace", class_alias
, 0);
3438 add_info ("stack", backtrace_command
,
3439 _("Backtrace of the stack, or innermost COUNT frames."));
3440 add_info_alias ("s", "stack", 1);
3442 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3443 _("All about the selected stack frame.\n\
3444 With no arguments, displays information about the currently selected stack\n\
3445 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3446 the information is then printed about the specified frame."),
3447 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3448 add_info_alias ("f", "frame", 1);
3450 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3452 Print information about a stack frame selected by stack address.\n\
3454 Usage: info frame address STACK-ADDRESS"),
3455 &info_frame_cmd_list
);
3457 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3459 Print information about a stack frame outside the current backtrace.\n\
3461 Usage: info frame view STACK-ADDRESS\n\
3462 info frame view STACK-ADDRESS PC-ADDRESS"),
3463 &info_frame_cmd_list
);
3465 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3467 Print information about a stack frame selected by function name.\n\
3469 Usage: info frame function NAME"),
3470 &info_frame_cmd_list
);
3471 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3473 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3475 Print information about a stack frame selected by level.\n\
3477 Usage: info frame level LEVEL"),
3478 &info_frame_cmd_list
);
3480 cmd
= add_info ("locals", info_locals_command
,
3481 info_print_args_help (_("\
3482 All local variables of current stack frame or those matching REGEXPs.\n\
3483 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3484 Prints the local variables of the current stack frame.\n"),
3485 _("local variables")));
3486 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3487 cmd
= add_info ("args", info_args_command
,
3488 info_print_args_help (_("\
3489 All argument variables of current stack frame or those matching REGEXPs.\n\
3490 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3491 Prints the argument variables of the current stack frame.\n"),
3492 _("argument variables")));
3493 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3496 add_com ("func", class_stack
, func_command
, _("\
3497 Select the stack frame that contains NAME.\n\
3498 Usage: func NAME"));
3500 /* Install "set print raw frame-arguments", a deprecated spelling of
3501 "set print raw-frame-arguments". */
3502 cmd
= add_setshow_boolean_cmd
3503 ("frame-arguments", no_class
,
3504 &user_frame_print_options
.print_raw_frame_arguments
,
3506 Set whether to print frame arguments in raw form."), _("\
3507 Show whether to print frame arguments in raw form."), _("\
3508 If set, frame arguments are printed in raw form, bypassing any\n\
3509 pretty-printers for that value."),
3511 &setprintrawlist
, &showprintrawlist
);
3512 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3514 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3515 &disassemble_next_line
, _("\
3516 Set whether to disassemble next source line or insn when execution stops."),
3518 Show whether to disassemble next source line or insn when execution stops."),
3520 If ON, GDB will display disassembly of the next source line, in addition\n\
3521 to displaying the source line itself. If the next source line cannot\n\
3522 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3523 will display disassembly of next instruction instead of showing the\n\
3525 If AUTO, display disassembly of next instruction only if the source line\n\
3526 cannot be displayed.\n\
3527 If OFF (which is the default), never display the disassembly of the next\n\
3530 show_disassemble_next_line
,
3531 &setlist
, &showlist
);
3532 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3534 gdb::option::add_setshow_cmds_for_options
3535 (class_stack
, &user_frame_print_options
,
3536 frame_print_option_defs
, &setprintlist
, &showprintlist
);