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
.get ());
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
.reset (xstrdup (except
.what ()));
459 /* Read in inferior function parameter SYM at FRAME into ARGP. This
460 function never throws an exception. */
463 read_frame_arg (const frame_print_options
&fp_opts
,
464 symbol
*sym
, frame_info
*frame
,
465 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
467 struct value
*val
= NULL
, *entryval
= NULL
;
468 char *val_error
= NULL
, *entryval_error
= NULL
;
471 if (fp_opts
.print_entry_values
!= print_entry_values_only
472 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
476 val
= read_var_value (sym
, NULL
, frame
);
478 catch (const gdb_exception_error
&except
)
480 val_error
= (char *) alloca (except
.message
->size () + 1);
481 strcpy (val_error
, except
.what ());
485 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
486 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
487 && fp_opts
.print_entry_values
!= print_entry_values_no
488 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
489 || !val
|| value_optimized_out (val
)))
493 const struct symbol_computed_ops
*ops
;
495 ops
= SYMBOL_COMPUTED_OPS (sym
);
496 entryval
= ops
->read_variable_at_entry (sym
, frame
);
498 catch (const gdb_exception_error
&except
)
500 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
502 entryval_error
= (char *) alloca (except
.message
->size () + 1);
503 strcpy (entryval_error
, except
.what ());
507 if (entryval
!= NULL
&& value_optimized_out (entryval
))
510 if (fp_opts
.print_entry_values
== print_entry_values_compact
511 || fp_opts
.print_entry_values
== print_entry_values_default
)
513 /* For MI do not try to use print_entry_values_compact for ARGP. */
515 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
517 struct type
*type
= value_type (val
);
519 if (value_lazy (val
))
520 value_fetch_lazy (val
);
521 if (value_lazy (entryval
))
522 value_fetch_lazy (entryval
);
524 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
526 /* Initialize it just to avoid a GCC false warning. */
527 struct value
*val_deref
= NULL
, *entryval_deref
;
529 /* DW_AT_call_value does match with the current
530 value. If it is a reference still try to verify if
531 dereferenced DW_AT_call_data_value does not differ. */
535 struct type
*type_deref
;
537 val_deref
= coerce_ref (val
);
538 if (value_lazy (val_deref
))
539 value_fetch_lazy (val_deref
);
540 type_deref
= value_type (val_deref
);
542 entryval_deref
= coerce_ref (entryval
);
543 if (value_lazy (entryval_deref
))
544 value_fetch_lazy (entryval_deref
);
546 /* If the reference addresses match but dereferenced
547 content does not match print them. */
549 && value_contents_eq (val_deref
, 0,
551 TYPE_LENGTH (type_deref
)))
554 catch (const gdb_exception_error
&except
)
556 /* If the dereferenced content could not be
557 fetched do not display anything. */
558 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
560 else if (except
.message
!= NULL
)
563 = (char *) alloca (except
.message
->size () + 1);
564 strcpy (entryval_error
, except
.what ());
568 /* Value was not a reference; and its content matches. */
569 if (val
== val_deref
)
577 /* Try to remove possibly duplicate error message for ENTRYARGP even
580 if (val_error
&& entryval_error
581 && strcmp (val_error
, entryval_error
) == 0)
583 entryval_error
= NULL
;
585 /* Do not se VAL_EQUAL as the same error message may be shown for
586 the entry value even if no entry values are present in the
592 if (entryval
== NULL
)
594 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
596 gdb_assert (val
== NULL
);
600 val
= read_var_value (sym
, NULL
, frame
);
602 catch (const gdb_exception_error
&except
)
604 val_error
= (char *) alloca (except
.message
->size () + 1);
605 strcpy (val_error
, except
.what ());
608 if (fp_opts
.print_entry_values
== print_entry_values_only
609 || fp_opts
.print_entry_values
== print_entry_values_both
610 || (fp_opts
.print_entry_values
== print_entry_values_preferred
611 && (!val
|| value_optimized_out (val
))))
613 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
614 entryval_error
= NULL
;
617 if ((fp_opts
.print_entry_values
== print_entry_values_compact
618 || fp_opts
.print_entry_values
== print_entry_values_if_needed
619 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
620 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
628 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
629 if (!val
&& !val_error
)
630 argp
->entry_kind
= print_entry_values_only
;
631 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
632 || fp_opts
.print_entry_values
== print_entry_values_default
)
635 argp
->entry_kind
= print_entry_values_compact
;
636 gdb_assert (!current_uiout
->is_mi_like_p ());
639 argp
->entry_kind
= print_entry_values_no
;
641 entryargp
->sym
= sym
;
642 entryargp
->val
= entryval
;
643 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
644 if (!entryval
&& !entryval_error
)
645 entryargp
->entry_kind
= print_entry_values_no
;
647 entryargp
->entry_kind
= print_entry_values_only
;
650 /* Print the arguments of frame FRAME on STREAM, given the function
651 FUNC running in that frame (as a symbol), where NUM is the number
652 of arguments according to the stack frame (or -1 if the number of
653 arguments is unknown). */
655 /* Note that currently the "number of arguments according to the
656 stack frame" is only known on VAX where i refers to the "number of
657 ints of arguments according to the stack frame". */
660 print_frame_args (const frame_print_options
&fp_opts
,
661 struct symbol
*func
, struct frame_info
*frame
,
662 int num
, struct ui_file
*stream
)
664 struct ui_out
*uiout
= current_uiout
;
666 /* Offset of next stack argument beyond the one we have seen that is
667 at the highest offset, or -1 if we haven't come to a stack
669 long highest_offset
= -1;
670 /* Number of ints of arguments that we have printed so far. */
671 int args_printed
= 0;
672 /* True if we should print arg names. If false, we only indicate
673 the presence of arguments by printing ellipsis. */
675 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
676 /* True if we should print arguments, false otherwise. */
679 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
683 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
684 struct block_iterator iter
;
687 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
689 struct frame_arg arg
, entryarg
;
693 /* Keep track of the highest stack argument offset seen, and
694 skip over any kinds of symbols we don't care about. */
696 if (!SYMBOL_IS_ARGUMENT (sym
))
706 switch (SYMBOL_CLASS (sym
))
711 long current_offset
= SYMBOL_VALUE (sym
);
712 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
714 /* Compute address of next argument by adding the size of
715 this argument and rounding to an int boundary. */
717 ((current_offset
+ arg_size
+ sizeof (int) - 1)
718 & ~(sizeof (int) - 1));
720 /* If this is the highest offset seen yet, set
722 if (highest_offset
== -1
723 || (current_offset
> highest_offset
))
724 highest_offset
= current_offset
;
726 /* Add the number of ints we're about to print to
728 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
731 /* We care about types of symbols, but don't need to
732 keep track of stack offsets in them. */
734 case LOC_REGPARM_ADDR
:
736 case LOC_OPTIMIZED_OUT
:
741 /* We have to look up the symbol because arguments can have
742 two entries (one a parameter, one a local) and the one we
743 want is the local, which lookup_symbol will find for us.
744 This includes gcc1 (not gcc2) on SPARC when passing a
745 small structure and gcc2 when the argument type is float
746 and it is passed as a double and converted to float by
747 the prologue (in the latter case the type of the LOC_ARG
748 symbol is double and the type of the LOC_LOCAL symbol is
750 /* But if the parameter name is null, don't try it. Null
751 parameter names occur on the RS/6000, for traceback
752 tables. FIXME, should we even print them? */
754 if (*SYMBOL_LINKAGE_NAME (sym
))
758 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
759 b
, VAR_DOMAIN
).symbol
;
760 gdb_assert (nsym
!= NULL
);
761 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
762 && !SYMBOL_IS_ARGUMENT (nsym
))
764 /* There is a LOC_ARG/LOC_REGISTER pair. This means
765 that it was passed on the stack and loaded into a
766 register, or passed in a register and stored in a
767 stack slot. GDB 3.x used the LOC_ARG; GDB
768 4.0-4.11 used the LOC_REGISTER.
770 Reasons for using the LOC_ARG:
772 (1) Because find_saved_registers may be slow for
775 (2) Because registers are often re-used and stack
776 slots rarely (never?) are. Therefore using
777 the stack slot is much less likely to print
780 Reasons why we might want to use the LOC_REGISTER:
782 (1) So that the backtrace prints the same value
783 as "print foo". I see no compelling reason
784 why this needs to be the case; having the
785 backtrace print the value which was passed
786 in, and "print foo" print the value as
787 modified within the called function, makes
790 Additional note: It might be nice if "info args"
791 displayed both values.
793 One more note: There is a case with SPARC
794 structure passing where we need to use the
795 LOC_REGISTER, but this is dealt with by creating
796 a single LOC_REGPARM in symbol reading. */
798 /* Leave sym (the LOC_ARG) alone. */
805 /* Print the current arg. */
808 uiout
->wrap_hint (" ");
813 arg
.entry_kind
= print_entry_values_no
;
815 entryarg
.entry_kind
= print_entry_values_no
;
818 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
820 if (arg
.entry_kind
!= print_entry_values_only
)
821 print_frame_arg (fp_opts
, &arg
);
823 if (entryarg
.entry_kind
!= print_entry_values_no
)
825 if (arg
.entry_kind
!= print_entry_values_only
)
828 uiout
->wrap_hint (" ");
831 print_frame_arg (fp_opts
, &entryarg
);
838 /* Don't print nameless args in situations where we don't know
839 enough about the stack to find them. */
844 if (highest_offset
== -1)
845 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
847 start
= highest_offset
;
849 if (!print_names
&& !first
&& num
> 0)
852 print_frame_nameless_args (frame
, start
, num
- args_printed
,
857 /* Set the current source and line to the location given by frame
858 FRAME, if possible. When CENTER is true, adjust so the relevant
859 line is in the center of the next 'list'. */
862 set_current_sal_from_frame (struct frame_info
*frame
)
864 symtab_and_line sal
= find_frame_sal (frame
);
865 if (sal
.symtab
!= NULL
)
866 set_current_source_symtab_and_line (sal
);
869 /* If ON, GDB will display disassembly of the next source line when
870 execution of the program being debugged stops.
871 If AUTO (which is the default), or there's no line info to determine
872 the source line of the next instruction, display disassembly of next
873 instruction instead. */
875 static enum auto_boolean disassemble_next_line
;
878 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
879 struct cmd_list_element
*c
,
882 fprintf_filtered (file
,
883 _("Debugger's willingness to use "
884 "disassemble-next-line is %s.\n"),
888 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
889 because it will be broken by filter sometime. */
892 do_gdb_disassembly (struct gdbarch
*gdbarch
,
893 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
898 gdb_disassembly (gdbarch
, current_uiout
,
899 DISASSEMBLY_RAW_INSN
, how_many
,
902 catch (const gdb_exception_error
&exception
)
904 /* If an exception was thrown while doing the disassembly, print
905 the error message, to give the user a clue of what happened. */
906 exception_print (gdb_stderr
, exception
);
910 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
911 Value not present indicates to the caller to use default values
912 specific to the command being executed. */
914 static gdb::optional
<enum print_what
>
915 print_frame_info_to_print_what (const char *print_frame_info
)
917 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
918 if (print_frame_info
== print_frame_info_choices
[i
])
919 return print_frame_info_print_what
[i
];
921 internal_error (__FILE__
, __LINE__
,
922 "Unexpected print frame-info value `%s'.",
926 /* Print the PC from FRAME, plus any flags, to UIOUT. */
929 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info
*frame
,
932 uiout
->field_core_addr ("addr", gdbarch
, pc
);
934 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
938 uiout
->field_string ("addr_flags", flags
);
946 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
949 = print_frame_info_to_print_what
950 (user_frame_print_options
.print_frame_info
);
953 /* Print information about frame FRAME. The output is format according
954 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
955 PRINT_WHAT, see enum print_what comments in frame.h.
956 Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info
957 != print_frame_info_auto.
959 Used in "where" output, and to emit breakpoint or step
963 print_frame_info (const frame_print_options
&fp_opts
,
964 frame_info
*frame
, int print_level
,
965 enum print_what print_what
, int print_args
,
968 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
971 struct ui_out
*uiout
= current_uiout
;
973 if (!current_uiout
->is_mi_like_p ()
974 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
976 /* Use the specific frame information desired by the user. */
977 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
980 if (get_frame_type (frame
) == DUMMY_FRAME
981 || get_frame_type (frame
) == SIGTRAMP_FRAME
982 || get_frame_type (frame
) == ARCH_FRAME
)
984 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
986 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
987 gdbarch
, get_frame_pc (frame
));
989 /* Do this regardless of SOURCE because we don't have any source
990 to list for this frame. */
994 uiout
->field_fmt_signed (2, ui_left
, "level",
995 frame_relative_level (frame
));
997 if (uiout
->is_mi_like_p ())
999 annotate_frame_address ();
1000 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1001 annotate_frame_address_end ();
1004 if (get_frame_type (frame
) == DUMMY_FRAME
)
1006 annotate_function_call ();
1007 uiout
->field_string ("func", "<function called from gdb>",
1008 ui_out_style_kind::FUNCTION
);
1010 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1012 annotate_signal_handler_caller ();
1013 uiout
->field_string ("func", "<signal handler called>",
1014 ui_out_style_kind::FUNCTION
);
1016 else if (get_frame_type (frame
) == ARCH_FRAME
)
1018 uiout
->field_string ("func", "<cross-architecture call>",
1019 ui_out_style_kind::FUNCTION
);
1022 annotate_frame_end ();
1024 /* If disassemble-next-line is set to auto or on output the next
1026 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1027 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1028 do_gdb_disassembly (get_frame_arch (frame
), 1,
1029 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1034 /* If FRAME is not the innermost frame, that normally means that
1035 FRAME->pc points to *after* the call instruction, and we want to
1036 get the line containing the call, never the next line. But if
1037 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1038 next frame was not entered as the result of a call, and we want
1039 to get the line containing FRAME->pc. */
1040 symtab_and_line sal
= find_frame_sal (frame
);
1042 location_print
= (print_what
== LOCATION
1043 || print_what
== SRC_AND_LOC
1044 || print_what
== LOC_AND_ADDRESS
1045 || print_what
== SHORT_LOCATION
);
1046 if (location_print
|| !sal
.symtab
)
1047 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1049 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1051 /* If disassemble-next-line is set to auto or on and doesn't have
1052 the line debug messages for $pc, output the next instruction. */
1053 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1054 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1055 && source_print
&& !sal
.symtab
)
1056 do_gdb_disassembly (get_frame_arch (frame
), 1,
1057 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1059 if (source_print
&& sal
.symtab
)
1061 int mid_statement
= ((print_what
== SRC_LINE
)
1062 && frame_show_address (frame
, sal
));
1063 annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1064 get_frame_pc (frame
));
1066 if (deprecated_print_frame_info_listing_hook
)
1067 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1071 struct value_print_options opts
;
1073 get_user_print_options (&opts
);
1074 /* We used to do this earlier, but that is clearly
1075 wrong. This function is used by many different
1076 parts of gdb, including normal_stop in infrun.c,
1077 which uses this to print out the current PC
1078 when we stepi/nexti into the middle of a source
1079 line. Only the command line really wants this
1080 behavior. Other UIs probably would like the
1081 ability to decide for themselves if it is desired. */
1082 if (opts
.addressprint
&& mid_statement
)
1084 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1088 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1092 /* If disassemble-next-line is set to on and there is line debug
1093 messages, output assembly codes for next line. */
1094 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1095 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1097 if (set_current_sal
)
1101 if (get_frame_pc_if_available (frame
, &pc
))
1102 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1104 set_last_displayed_sal (0, 0, 0, 0, 0);
1107 annotate_frame_end ();
1109 gdb_flush (gdb_stdout
);
1112 /* Remember the last symtab and line we displayed, which we use e.g.
1113 * as the place to put a breakpoint when the `break' command is
1114 * invoked with no arguments. */
1117 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
1118 CORE_ADDR addr
, struct symtab
*symtab
,
1121 last_displayed_sal_valid
= valid
;
1122 last_displayed_pspace
= pspace
;
1123 last_displayed_addr
= addr
;
1124 last_displayed_symtab
= symtab
;
1125 last_displayed_line
= line
;
1126 if (valid
&& pspace
== NULL
)
1128 clear_last_displayed_sal ();
1129 internal_error (__FILE__
, __LINE__
,
1130 _("Trying to set NULL pspace."));
1134 /* Forget the last sal we displayed. */
1137 clear_last_displayed_sal (void)
1139 last_displayed_sal_valid
= 0;
1140 last_displayed_pspace
= 0;
1141 last_displayed_addr
= 0;
1142 last_displayed_symtab
= 0;
1143 last_displayed_line
= 0;
1146 /* Is our record of the last sal we displayed valid? If not,
1147 * the get_last_displayed_* functions will return NULL or 0, as
1151 last_displayed_sal_is_valid (void)
1153 return last_displayed_sal_valid
;
1156 /* Get the pspace of the last sal we displayed, if it's valid. */
1158 struct program_space
*
1159 get_last_displayed_pspace (void)
1161 if (last_displayed_sal_valid
)
1162 return last_displayed_pspace
;
1166 /* Get the address of the last sal we displayed, if it's valid. */
1169 get_last_displayed_addr (void)
1171 if (last_displayed_sal_valid
)
1172 return last_displayed_addr
;
1176 /* Get the symtab of the last sal we displayed, if it's valid. */
1179 get_last_displayed_symtab (void)
1181 if (last_displayed_sal_valid
)
1182 return last_displayed_symtab
;
1186 /* Get the line of the last sal we displayed, if it's valid. */
1189 get_last_displayed_line (void)
1191 if (last_displayed_sal_valid
)
1192 return last_displayed_line
;
1196 /* Get the last sal we displayed, if it's valid. */
1199 get_last_displayed_sal ()
1201 symtab_and_line sal
;
1203 if (last_displayed_sal_valid
)
1205 sal
.pspace
= last_displayed_pspace
;
1206 sal
.pc
= last_displayed_addr
;
1207 sal
.symtab
= last_displayed_symtab
;
1208 sal
.line
= last_displayed_line
;
1215 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1216 corresponding to FRAME. */
1218 gdb::unique_xmalloc_ptr
<char>
1219 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1220 struct symbol
**funcp
)
1222 struct symbol
*func
;
1223 gdb::unique_xmalloc_ptr
<char> funname
;
1225 *funlang
= language_unknown
;
1229 func
= get_frame_function (frame
);
1232 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1234 *funlang
= SYMBOL_LANGUAGE (func
);
1237 if (*funlang
== language_cplus
)
1239 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1240 to display the demangled name that we already have
1241 stored in the symbol table, but we stored a version
1242 with DMGL_PARAMS turned on, and here we don't want to
1243 display parameters. So remove the parameters. */
1244 funname
= cp_remove_params (print_name
);
1247 /* If we didn't hit the C++ case above, set *funname
1249 if (funname
== NULL
)
1250 funname
.reset (xstrdup (print_name
));
1254 struct bound_minimal_symbol msymbol
;
1257 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1260 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1261 if (msymbol
.minsym
!= NULL
)
1263 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1264 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1272 print_frame (const frame_print_options
&fp_opts
,
1273 frame_info
*frame
, int print_level
,
1274 enum print_what print_what
, int print_args
,
1275 struct symtab_and_line sal
)
1277 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1278 struct ui_out
*uiout
= current_uiout
;
1279 enum language funlang
= language_unknown
;
1280 struct value_print_options opts
;
1281 struct symbol
*func
;
1285 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1287 gdb::unique_xmalloc_ptr
<char> funname
1288 = find_frame_funname (frame
, &funlang
, &func
);
1290 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1294 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1299 uiout
->field_fmt_signed (2, ui_left
, "level",
1300 frame_relative_level (frame
));
1302 get_user_print_options (&opts
);
1303 if (opts
.addressprint
)
1305 || frame_show_address (frame
, sal
)
1306 || print_what
== LOC_AND_ADDRESS
)
1308 annotate_frame_address ();
1310 print_pc (uiout
, gdbarch
, frame
, pc
);
1312 uiout
->field_string ("addr", "<unavailable>",
1313 ui_out_style_kind::ADDRESS
);
1314 annotate_frame_address_end ();
1315 uiout
->text (" in ");
1317 annotate_frame_function_name ();
1320 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1321 funlang
, DMGL_ANSI
);
1322 uiout
->field_stream ("func", stb
, ui_out_style_kind::FUNCTION
);
1323 uiout
->wrap_hint (" ");
1324 annotate_frame_args ();
1331 if (gdbarch_frame_num_args_p (gdbarch
))
1333 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1334 gdb_assert (numargs
>= 0);
1340 ui_out_emit_list
list_emitter (uiout
, "args");
1343 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1345 catch (const gdb_exception_error
&e
)
1349 /* FIXME: ARGS must be a list. If one argument is a string it
1350 will have " that will not be properly escaped. */
1355 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1357 const char *filename_display
;
1359 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1360 annotate_frame_source_begin ();
1361 uiout
->wrap_hint (" ");
1362 uiout
->text (" at ");
1363 annotate_frame_source_file ();
1364 uiout
->field_string ("file", filename_display
, ui_out_style_kind::FILE);
1365 if (uiout
->is_mi_like_p ())
1367 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1369 uiout
->field_string ("fullname", fullname
);
1371 annotate_frame_source_file_end ();
1373 annotate_frame_source_line ();
1374 uiout
->field_signed ("line", sal
.line
);
1375 annotate_frame_source_end ();
1378 if (print_what
!= SHORT_LOCATION
1379 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1381 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1382 get_frame_pc (frame
));
1386 annotate_frame_where ();
1387 uiout
->wrap_hint (" ");
1388 uiout
->text (" from ");
1389 uiout
->field_string ("from", lib
);
1392 if (uiout
->is_mi_like_p ())
1393 uiout
->field_string ("arch",
1394 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1401 /* Completion function for "frame function", "info frame function", and
1402 "select-frame function" commands. */
1405 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1406 completion_tracker
&tracker
,
1407 const char *text
, const char *word
)
1409 /* This is used to complete function names within a stack. It would be
1410 nice if we only offered functions that were actually in the stack.
1411 However, this would mean unwinding the stack to completion, which
1412 could take too long, or on a corrupted stack, possibly not end.
1413 Instead, we offer all symbol names as a safer choice. */
1414 collect_symbol_completion_matches (tracker
,
1415 complete_symbol_mode::EXPRESSION
,
1416 symbol_name_match_type::EXPRESSION
,
1420 /* Core of all the "info frame" sub-commands. Print information about a
1421 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1422 frame specification, they just entered 'info frame'. If the user did
1423 provide a frame specification (for example 'info frame 0', 'info frame
1424 level 1') then SELECTED_FRAME_P will be false. */
1427 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1429 struct symbol
*func
;
1431 struct frame_info
*calling_frame_info
;
1433 const char *funname
= 0;
1434 enum language funlang
= language_unknown
;
1435 const char *pc_regname
;
1436 struct gdbarch
*gdbarch
;
1439 /* Initialize it to avoid "may be used uninitialized" warning. */
1440 CORE_ADDR caller_pc
= 0;
1441 int caller_pc_p
= 0;
1443 gdbarch
= get_frame_arch (fi
);
1445 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1446 is not a good name. */
1447 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1448 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1449 easily not match that of the internal value returned by
1451 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1453 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1454 architectures will often have a hardware register called "pc",
1455 and that register's value, again, can easily not match
1459 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1460 func
= get_frame_function (fi
);
1461 symtab_and_line sal
= find_frame_sal (fi
);
1463 gdb::unique_xmalloc_ptr
<char> func_only
;
1466 funname
= SYMBOL_PRINT_NAME (func
);
1467 funlang
= SYMBOL_LANGUAGE (func
);
1468 if (funlang
== language_cplus
)
1470 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1471 to display the demangled name that we already have
1472 stored in the symbol table, but we stored a version
1473 with DMGL_PARAMS turned on, and here we don't want to
1474 display parameters. So remove the parameters. */
1475 func_only
= cp_remove_params (funname
);
1478 funname
= func_only
.get ();
1481 else if (frame_pc_p
)
1483 struct bound_minimal_symbol msymbol
;
1485 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1486 if (msymbol
.minsym
!= NULL
)
1488 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1489 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1492 calling_frame_info
= get_prev_frame (fi
);
1494 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1496 printf_filtered (_("Stack level %d, frame at "),
1497 frame_relative_level (fi
));
1501 printf_filtered (_("Stack frame at "));
1503 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1504 printf_filtered (":\n");
1505 printf_filtered (" %s = ", pc_regname
);
1507 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1509 fputs_filtered ("<unavailable>", gdb_stdout
);
1514 printf_filtered (" in ");
1515 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1516 DMGL_ANSI
| DMGL_PARAMS
);
1520 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1522 puts_filtered ("; ");
1524 printf_filtered ("saved %s = ", pc_regname
);
1526 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1527 val_print_not_saved (gdb_stdout
);
1532 caller_pc
= frame_unwind_caller_pc (fi
);
1535 catch (const gdb_exception_error
&ex
)
1539 case NOT_AVAILABLE_ERROR
:
1540 val_print_unavailable (gdb_stdout
);
1542 case OPTIMIZED_OUT_ERROR
:
1543 val_print_not_saved (gdb_stdout
);
1546 fprintf_filtered (gdb_stdout
, _("<error: %s>"),
1554 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1555 printf_filtered ("\n");
1557 if (calling_frame_info
== NULL
)
1559 enum unwind_stop_reason reason
;
1561 reason
= get_frame_unwind_stop_reason (fi
);
1562 if (reason
!= UNWIND_NO_REASON
)
1563 printf_filtered (_(" Outermost frame: %s\n"),
1564 frame_stop_reason_string (fi
));
1566 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1567 puts_filtered (" tail call frame");
1568 else if (get_frame_type (fi
) == INLINE_FRAME
)
1569 printf_filtered (" inlined into frame %d",
1570 frame_relative_level (get_prev_frame (fi
)));
1573 printf_filtered (" called by frame at ");
1574 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1577 if (get_next_frame (fi
) && calling_frame_info
)
1578 puts_filtered (",");
1580 if (get_next_frame (fi
))
1582 printf_filtered (" caller of frame at ");
1583 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1586 if (get_next_frame (fi
) || calling_frame_info
)
1587 puts_filtered ("\n");
1590 printf_filtered (" source language %s.\n",
1591 language_str (s
->language
));
1594 /* Address of the argument list for this frame, or 0. */
1595 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1596 /* Number of args for this frame, or -1 if unknown. */
1600 printf_filtered (" Arglist at unknown address.\n");
1603 printf_filtered (" Arglist at ");
1604 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1605 printf_filtered (",");
1607 if (!gdbarch_frame_num_args_p (gdbarch
))
1610 puts_filtered (" args: ");
1614 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1615 gdb_assert (numargs
>= 0);
1617 puts_filtered (" no args.");
1618 else if (numargs
== 1)
1619 puts_filtered (" 1 arg: ");
1621 printf_filtered (" %d args: ", numargs
);
1623 print_frame_args (user_frame_print_options
,
1624 func
, fi
, numargs
, gdb_stdout
);
1625 puts_filtered ("\n");
1629 /* Address of the local variables for this frame, or 0. */
1630 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1633 printf_filtered (" Locals at unknown address,");
1636 printf_filtered (" Locals at ");
1637 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1638 printf_filtered (",");
1642 /* Print as much information as possible on the location of all the
1648 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1650 /* The sp is special; what's displayed isn't the save address, but
1651 the value of the previous frame's sp. This is a legacy thing,
1652 at one stage the frame cached the previous frame's SP instead
1653 of its address, hence it was easiest to just display the cached
1657 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1658 gdb_assert (value
!= NULL
);
1660 if (!value_optimized_out (value
) && value_entirely_available (value
))
1662 if (VALUE_LVAL (value
) == not_lval
)
1665 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1666 int sp_size
= register_size (gdbarch
, sp_regnum
);
1668 sp
= extract_unsigned_integer (value_contents_all (value
),
1669 sp_size
, byte_order
);
1671 printf_filtered (" Previous frame's sp is ");
1672 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1673 printf_filtered ("\n");
1675 else if (VALUE_LVAL (value
) == lval_memory
)
1677 printf_filtered (" Previous frame's sp at ");
1678 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1680 printf_filtered ("\n");
1682 else if (VALUE_LVAL (value
) == lval_register
)
1684 printf_filtered (" Previous frame's sp in %s\n",
1685 gdbarch_register_name (gdbarch
,
1686 VALUE_REGNUM (value
)));
1689 release_value (value
);
1692 /* else keep quiet. */
1696 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1697 for (i
= 0; i
< numregs
; i
++)
1699 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1701 enum lval_type lval
;
1707 /* Find out the location of the saved register without
1708 fetching the corresponding value. */
1709 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1710 &lval
, &addr
, &realnum
, NULL
);
1711 /* For moment, only display registers that were saved on the
1713 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1716 puts_filtered (" Saved registers:\n ");
1718 puts_filtered (",");
1720 printf_filtered (" %s at ",
1721 gdbarch_register_name (gdbarch
, i
));
1722 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1726 if (count
|| need_nl
)
1727 puts_filtered ("\n");
1731 /* Return the innermost frame at level LEVEL. */
1733 static struct frame_info
*
1734 leading_innermost_frame (int level
)
1736 struct frame_info
*leading
;
1738 leading
= get_current_frame ();
1740 gdb_assert (level
>= 0);
1742 while (leading
!= nullptr && level
)
1745 leading
= get_prev_frame (leading
);
1752 /* Return the starting frame needed to handle COUNT outermost frames. */
1754 static struct frame_info
*
1755 trailing_outermost_frame (int count
)
1757 struct frame_info
*current
;
1758 struct frame_info
*trailing
;
1760 trailing
= get_current_frame ();
1762 gdb_assert (count
> 0);
1765 while (current
!= nullptr && count
--)
1768 current
= get_prev_frame (current
);
1771 /* Will stop when CURRENT reaches the top of the stack.
1772 TRAILING will be COUNT below it. */
1773 while (current
!= nullptr)
1776 trailing
= get_prev_frame (trailing
);
1777 current
= get_prev_frame (current
);
1783 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1787 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1789 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1791 if (get_selected_frame_if_set () != prev_frame
)
1792 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1798 select_frame_for_mi (struct frame_info
*fi
)
1800 select_frame_command_core (fi
, false /* Ignored. */);
1803 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1804 means we change frame send out a change notification (otherwise, just
1805 reprint the current frame summary). */
1808 frame_command_core (struct frame_info
*fi
, bool ignored
)
1810 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1813 if (get_selected_frame_if_set () != prev_frame
)
1814 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1816 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1819 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1820 common set of sub-commands that allow a specific frame to be selected.
1821 All of the sub-command functions are static methods within this class
1822 template which is then instantiated below. The template parameter is a
1823 callback used to implement the functionality of the base command
1824 ('frame', 'select-frame', or 'info frame').
1826 In the template parameter FI is the frame being selected. The
1827 SELECTED_FRAME_P flag is true if the frame being selected was done by
1828 default, which happens when the user uses the base command with no
1829 arguments. For example the commands 'info frame', 'select-frame',
1830 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1831 SELECTED_FRAME_P is false. */
1833 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1834 class frame_command_helper
1838 /* The "frame level" family of commands. The ARG is an integer that is
1839 the frame's level in the stack. */
1841 level (const char *arg
, int from_tty
)
1843 int level
= value_as_long (parse_and_eval (arg
));
1844 struct frame_info
*fid
1845 = find_relative_frame (get_current_frame (), &level
);
1847 error (_("No frame at level %s."), arg
);
1851 /* The "frame address" family of commands. ARG is a stack-pointer
1852 address for an existing frame. This command does not allow new
1853 frames to be created. */
1856 address (const char *arg
, int from_tty
)
1858 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1859 struct frame_info
*fid
= find_frame_for_address (addr
);
1861 error (_("No frame at address %s."), arg
);
1865 /* The "frame view" family of commands. ARG is one or two addresses and
1866 is used to view a frame that might be outside the current backtrace.
1867 The addresses are stack-pointer address, and (optional) pc-address. */
1870 view (const char *args
, int from_tty
)
1872 struct frame_info
*fid
;
1875 error (_("Missing address argument to view a frame"));
1877 gdb_argv
argv (args
);
1879 if (argv
.count () == 2)
1883 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1884 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1885 fid
= create_new_frame (addr
[0], addr
[1]);
1889 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1890 fid
= create_new_frame (addr
, false);
1895 /* The "frame function" family of commands. ARG is the name of a
1896 function within the stack, the first function (searching from frame
1897 0) with that name will be selected. */
1900 function (const char *arg
, int from_tty
)
1903 error (_("Missing function name argument"));
1904 struct frame_info
*fid
= find_frame_for_function (arg
);
1906 error (_("No frame for function \"%s\"."), arg
);
1910 /* The "frame" base command, that is, when no sub-command is specified.
1911 If one argument is provided then we assume that this is a frame's
1912 level as historically, this was the supported command syntax that was
1915 If no argument is provided, then the current frame is selected. */
1918 base_command (const char *arg
, int from_tty
)
1921 FPTR (get_selected_frame (_("No stack.")), true);
1923 level (arg
, from_tty
);
1927 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1928 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1930 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1931 static frame_command_helper
<frame_command_core
> frame_cmd
;
1932 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1934 /* Print briefly all stack frames or just the innermost COUNT_EXP
1938 backtrace_command_1 (const frame_print_options
&fp_opts
,
1939 const backtrace_cmd_options
&bt_opts
,
1940 const char *count_exp
, int from_tty
)
1943 struct frame_info
*fi
;
1945 int py_start
= 0, py_end
= 0;
1946 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1948 if (!target_has_stack
)
1949 error (_("No stack."));
1953 count
= parse_and_eval_long (count_exp
);
1959 /* The argument to apply_ext_lang_frame_filter is the number
1960 of the final frame to print, and frames start at 0. */
1970 frame_filter_flags flags
= 0;
1973 flags
|= PRINT_LOCALS
;
1975 flags
|= PRINT_HIDE
;
1977 if (!bt_opts
.no_filters
)
1979 enum ext_lang_frame_args arg_type
;
1981 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1983 flags
|= PRINT_MORE_FRAMES
;
1985 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
1986 arg_type
= CLI_SCALAR_VALUES
;
1987 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
1988 arg_type
= CLI_ALL_VALUES
;
1989 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
1990 arg_type
= CLI_PRESENCE
;
1991 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
1992 arg_type
= NO_VALUES
;
1996 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1997 arg_type
, current_uiout
,
2001 /* Run the inbuilt backtrace if there are no filters registered, or
2002 "-no-filters" has been specified from the command. */
2003 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2005 struct frame_info
*trailing
;
2007 /* The following code must do two things. First, it must set the
2008 variable TRAILING to the frame from which we should start
2009 printing. Second, it must set the variable count to the number
2010 of frames which we should print, or -1 if all of them. */
2012 if (count_exp
!= NULL
&& count
< 0)
2014 trailing
= trailing_outermost_frame (-count
);
2018 trailing
= get_current_frame ();
2020 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2024 /* Don't use print_stack_frame; if an error() occurs it probably
2025 means further attempts to backtrace would fail (on the other
2026 hand, perhaps the code does or could be fixed to make sure
2027 the frame->prev field gets set to NULL in that case). */
2029 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2030 if ((flags
& PRINT_LOCALS
) != 0)
2032 struct frame_id frame_id
= get_frame_id (fi
);
2034 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2036 /* print_frame_local_vars invalidates FI. */
2037 fi
= frame_find_by_id (frame_id
);
2041 warning (_("Unable to restore previously selected frame."));
2046 /* Save the last frame to check for error conditions. */
2050 /* If we've stopped before the end, mention that. */
2052 printf_filtered (_("(More stack frames follow...)\n"));
2054 /* If we've run out of frames, and the reason appears to be an error
2055 condition, print it. */
2056 if (fi
== NULL
&& trailing
!= NULL
)
2058 enum unwind_stop_reason reason
;
2060 reason
= get_frame_unwind_stop_reason (trailing
);
2061 if (reason
>= UNWIND_FIRST_ERROR
)
2062 printf_filtered (_("Backtrace stopped: %s\n"),
2063 frame_stop_reason_string (trailing
));
2068 /* Create an option_def_group array grouping all the "backtrace"
2069 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2071 static inline std::array
<gdb::option::option_def_group
, 3>
2072 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2073 backtrace_cmd_options
*bt_cmd_opts
,
2074 set_backtrace_options
*set_bt_opts
)
2077 { {frame_print_option_defs
}, fp_opts
},
2078 { {set_backtrace_option_defs
}, set_bt_opts
},
2079 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2083 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2084 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2085 store the parsed qualifiers. */
2088 parse_backtrace_qualifiers (const char *arg
,
2089 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2093 const char *save_arg
= arg
;
2094 std::string this_arg
= extract_arg (&arg
);
2096 if (this_arg
.empty ())
2099 if (subset_compare (this_arg
.c_str (), "no-filters"))
2101 if (bt_cmd_opts
!= nullptr)
2102 bt_cmd_opts
->no_filters
= true;
2104 else if (subset_compare (this_arg
.c_str (), "full"))
2106 if (bt_cmd_opts
!= nullptr)
2107 bt_cmd_opts
->full
= true;
2109 else if (subset_compare (this_arg
.c_str (), "hide"))
2111 if (bt_cmd_opts
!= nullptr)
2112 bt_cmd_opts
->hide
= true;
2116 /* Not a recognized qualifier, so stop. */
2123 backtrace_command (const char *arg
, int from_tty
)
2125 frame_print_options fp_opts
= user_frame_print_options
;
2126 backtrace_cmd_options bt_cmd_opts
;
2127 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2130 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2131 gdb::option::process_options
2132 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2134 /* Parse non-'-'-prefixed qualifiers, for backwards
2138 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2143 /* These options are handled quite deep in the unwind machinery, so
2144 we get to pass them down by swapping globals. */
2145 scoped_restore restore_set_backtrace_options
2146 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2148 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2151 /* Completer for the "backtrace" command. */
2154 backtrace_command_completer (struct cmd_list_element
*ignore
,
2155 completion_tracker
&tracker
,
2156 const char *text
, const char */
*word*/
)
2159 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2160 if (gdb::option::complete_options
2161 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2166 const char *p
= skip_to_space (text
);
2169 static const char *const backtrace_cmd_qualifier_choices
[] = {
2170 "full", "no-filters", "hide", nullptr,
2172 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2175 if (tracker
.have_completions ())
2180 const char *cmd
= parse_backtrace_qualifiers (text
);
2181 tracker
.advance_custom_word_point_by (cmd
- text
);
2186 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2187 expression_completer (ignore
, tracker
, text
, word
);
2190 /* Iterate over the local variables of a block B, calling CB with
2194 iterate_over_block_locals (const struct block
*b
,
2195 iterate_over_block_arg_local_vars_cb cb
,
2198 struct block_iterator iter
;
2201 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2203 switch (SYMBOL_CLASS (sym
))
2209 case LOC_OPTIMIZED_OUT
:
2210 if (SYMBOL_IS_ARGUMENT (sym
))
2212 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2214 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
2218 /* Ignore symbols which are not locals. */
2225 /* Same, but print labels. */
2228 /* Commented out, as the code using this function has also been
2229 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2230 was commented out in the first place. The discussion introducing
2231 this change (2007-12-04: Support lexical blocks and function bodies
2232 that occupy non-contiguous address ranges) did not explain why
2233 this change was made. */
2235 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2236 int *have_default
, struct ui_file
*stream
)
2238 struct block_iterator iter
;
2240 int values_printed
= 0;
2242 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2244 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2250 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2252 struct symtab_and_line sal
;
2253 struct value_print_options opts
;
2255 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2257 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2258 get_user_print_options (&opts
);
2259 if (opts
.addressprint
)
2261 fprintf_filtered (stream
, " ");
2262 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2265 fprintf_filtered (stream
, " in file %s, line %d\n",
2266 sal
.symtab
->filename
, sal
.line
);
2270 return values_printed
;
2274 /* Iterate over all the local variables in block B, including all its
2275 superblocks, stopping when the top-level block is reached. */
2278 iterate_over_block_local_vars (const struct block
*block
,
2279 iterate_over_block_arg_local_vars_cb cb
,
2284 iterate_over_block_locals (block
, cb
, cb_data
);
2285 /* After handling the function's top-level block, stop. Don't
2286 continue to its superblock, the block of per-file
2288 if (BLOCK_FUNCTION (block
))
2290 block
= BLOCK_SUPERBLOCK (block
);
2294 /* Data to be passed around in the calls to the locals and args
2297 struct print_variable_and_value_data
2299 gdb::optional
<compiled_regex
> preg
;
2300 gdb::optional
<compiled_regex
> treg
;
2301 struct frame_id frame_id
;
2303 struct ui_file
*stream
;
2307 /* The callback for the locals and args iterators. */
2310 do_print_variable_and_value (const char *print_name
,
2314 struct print_variable_and_value_data
*p
2315 = (struct print_variable_and_value_data
*) cb_data
;
2316 struct frame_info
*frame
;
2318 if (p
->preg
.has_value ()
2319 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2322 if (p
->treg
.has_value ()
2323 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2326 frame
= frame_find_by_id (p
->frame_id
);
2329 warning (_("Unable to restore previously selected frame."));
2333 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2335 /* print_variable_and_value invalidates FRAME. */
2338 p
->values_printed
= 1;
2341 /* Prepares the regular expression REG from REGEXP.
2342 If REGEXP is NULL, it results in an empty regular expression. */
2345 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2349 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2351 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2357 /* Print all variables from the innermost up to the function block of FRAME.
2358 Print them with values to STREAM indented by NUM_TABS.
2359 If REGEXP is not NULL, only print local variables whose name
2361 If T_REGEXP is not NULL, only print local variables whose type
2363 If no local variables have been printed and !QUIET, prints a message
2364 explaining why no local variables could be printed.
2366 This function will invalidate FRAME. */
2369 print_frame_local_vars (struct frame_info
*frame
,
2371 const char *regexp
, const char *t_regexp
,
2372 int num_tabs
, struct ui_file
*stream
)
2374 struct print_variable_and_value_data cb_data
;
2375 const struct block
*block
;
2378 if (!get_frame_pc_if_available (frame
, &pc
))
2381 fprintf_filtered (stream
,
2382 _("PC unavailable, cannot determine locals.\n"));
2386 block
= get_frame_block (frame
, 0);
2390 fprintf_filtered (stream
, "No symbol table info available.\n");
2394 prepare_reg (regexp
, &cb_data
.preg
);
2395 prepare_reg (t_regexp
, &cb_data
.treg
);
2396 cb_data
.frame_id
= get_frame_id (frame
);
2397 cb_data
.num_tabs
= 4 * num_tabs
;
2398 cb_data
.stream
= stream
;
2399 cb_data
.values_printed
= 0;
2401 /* Temporarily change the selected frame to the given FRAME.
2402 This allows routines that rely on the selected frame instead
2403 of being given a frame as parameter to use the correct frame. */
2404 scoped_restore_selected_frame restore_selected_frame
;
2405 select_frame (frame
);
2407 iterate_over_block_local_vars (block
,
2408 do_print_variable_and_value
,
2411 if (!cb_data
.values_printed
&& !quiet
)
2413 if (regexp
== NULL
&& t_regexp
== NULL
)
2414 fprintf_filtered (stream
, _("No locals.\n"));
2416 fprintf_filtered (stream
, _("No matching locals.\n"));
2420 /* Implement the 'info locals' command. */
2423 info_locals_command (const char *args
, int from_tty
)
2425 info_print_options opts
;
2426 extract_info_print_options (&opts
, &args
);
2428 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2429 opts
.quiet
, args
, opts
.type_regexp
,
2433 /* Iterate over all the argument variables in block B. */
2436 iterate_over_block_arg_vars (const struct block
*b
,
2437 iterate_over_block_arg_local_vars_cb cb
,
2440 struct block_iterator iter
;
2441 struct symbol
*sym
, *sym2
;
2443 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2445 /* Don't worry about things which aren't arguments. */
2446 if (SYMBOL_IS_ARGUMENT (sym
))
2448 /* We have to look up the symbol because arguments can have
2449 two entries (one a parameter, one a local) and the one we
2450 want is the local, which lookup_symbol will find for us.
2451 This includes gcc1 (not gcc2) on the sparc when passing a
2452 small structure and gcc2 when the argument type is float
2453 and it is passed as a double and converted to float by
2454 the prologue (in the latter case the type of the LOC_ARG
2455 symbol is double and the type of the LOC_LOCAL symbol is
2456 float). There are also LOC_ARG/LOC_REGISTER pairs which
2457 are not combined in symbol-reading. */
2459 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2460 b
, VAR_DOMAIN
).symbol
;
2461 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2466 /* Print all argument variables of the function of FRAME.
2467 Print them with values to STREAM.
2468 If REGEXP is not NULL, only print argument variables whose name
2470 If T_REGEXP is not NULL, only print argument variables whose type
2472 If no argument variables have been printed and !QUIET, prints a message
2473 explaining why no argument variables could be printed.
2475 This function will invalidate FRAME. */
2478 print_frame_arg_vars (struct frame_info
*frame
,
2480 const char *regexp
, const char *t_regexp
,
2481 struct ui_file
*stream
)
2483 struct print_variable_and_value_data cb_data
;
2484 struct symbol
*func
;
2486 gdb::optional
<compiled_regex
> preg
;
2487 gdb::optional
<compiled_regex
> treg
;
2489 if (!get_frame_pc_if_available (frame
, &pc
))
2492 fprintf_filtered (stream
,
2493 _("PC unavailable, cannot determine args.\n"));
2497 func
= get_frame_function (frame
);
2501 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2505 prepare_reg (regexp
, &cb_data
.preg
);
2506 prepare_reg (t_regexp
, &cb_data
.treg
);
2507 cb_data
.frame_id
= get_frame_id (frame
);
2508 cb_data
.num_tabs
= 0;
2509 cb_data
.stream
= stream
;
2510 cb_data
.values_printed
= 0;
2512 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2513 do_print_variable_and_value
, &cb_data
);
2515 /* do_print_variable_and_value invalidates FRAME. */
2518 if (!cb_data
.values_printed
&& !quiet
)
2520 if (regexp
== NULL
&& t_regexp
== NULL
)
2521 fprintf_filtered (stream
, _("No arguments.\n"));
2523 fprintf_filtered (stream
, _("No matching arguments.\n"));
2527 /* Implement the 'info args' command. */
2530 info_args_command (const char *args
, int from_tty
)
2532 info_print_options opts
;
2533 extract_info_print_options (&opts
, &args
);
2535 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2536 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2539 /* Return the symbol-block in which the selected frame is executing.
2540 Can return zero under various legitimate circumstances.
2542 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2543 code address within the block returned. We use this to decide
2544 which macros are in scope. */
2546 const struct block
*
2547 get_selected_block (CORE_ADDR
*addr_in_block
)
2549 if (!has_stack_frames ())
2552 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2555 /* Find a frame a certain number of levels away from FRAME.
2556 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2557 Positive means go to earlier frames (up); negative, the reverse.
2558 The int that contains the number of levels is counted toward
2559 zero as the frames for those levels are found.
2560 If the top or bottom frame is reached, that frame is returned,
2561 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2562 how much farther the original request asked to go. */
2565 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2567 /* Going up is simple: just call get_prev_frame enough times or
2568 until the initial frame is reached. */
2569 while (*level_offset_ptr
> 0)
2571 struct frame_info
*prev
= get_prev_frame (frame
);
2575 (*level_offset_ptr
)--;
2579 /* Going down is just as simple. */
2580 while (*level_offset_ptr
< 0)
2582 struct frame_info
*next
= get_next_frame (frame
);
2586 (*level_offset_ptr
)++;
2593 /* Select the frame up one or COUNT_EXP stack levels from the
2594 previously selected frame, and print it briefly. */
2597 up_silently_base (const char *count_exp
)
2599 struct frame_info
*frame
;
2603 count
= parse_and_eval_long (count_exp
);
2605 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2606 if (count
!= 0 && count_exp
== NULL
)
2607 error (_("Initial frame selected; you cannot go up."));
2608 select_frame (frame
);
2612 up_silently_command (const char *count_exp
, int from_tty
)
2614 up_silently_base (count_exp
);
2618 up_command (const char *count_exp
, int from_tty
)
2620 up_silently_base (count_exp
);
2621 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2624 /* Select the frame down one or COUNT_EXP stack levels from the previously
2625 selected frame, and print it briefly. */
2628 down_silently_base (const char *count_exp
)
2630 struct frame_info
*frame
;
2634 count
= -parse_and_eval_long (count_exp
);
2636 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2637 if (count
!= 0 && count_exp
== NULL
)
2639 /* We only do this if COUNT_EXP is not specified. That way
2640 "down" means to really go down (and let me know if that is
2641 impossible), but "down 9999" can be used to mean go all the
2642 way down without getting an error. */
2644 error (_("Bottom (innermost) frame selected; you cannot go down."));
2647 select_frame (frame
);
2651 down_silently_command (const char *count_exp
, int from_tty
)
2653 down_silently_base (count_exp
);
2657 down_command (const char *count_exp
, int from_tty
)
2659 down_silently_base (count_exp
);
2660 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2664 return_command (const char *retval_exp
, int from_tty
)
2666 /* Initialize it just to avoid a GCC false warning. */
2667 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2668 struct frame_info
*thisframe
;
2669 struct gdbarch
*gdbarch
;
2670 struct symbol
*thisfun
;
2671 struct value
*return_value
= NULL
;
2672 struct value
*function
= NULL
;
2673 const char *query_prefix
= "";
2675 thisframe
= get_selected_frame ("No selected frame.");
2676 thisfun
= get_frame_function (thisframe
);
2677 gdbarch
= get_frame_arch (thisframe
);
2679 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2680 error (_("Can not force return from an inlined function."));
2682 /* Compute the return value. If the computation triggers an error,
2683 let it bail. If the return type can't be handled, set
2684 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2688 expression_up retval_expr
= parse_expression (retval_exp
);
2689 struct type
*return_type
= NULL
;
2691 /* Compute the return value. Should the computation fail, this
2692 call throws an error. */
2693 return_value
= evaluate_expression (retval_expr
.get ());
2695 /* Cast return value to the return type of the function. Should
2696 the cast fail, this call throws an error. */
2697 if (thisfun
!= NULL
)
2698 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2699 if (return_type
== NULL
)
2701 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2702 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2703 error (_("Return value type not available for selected "
2705 "Please use an explicit cast of the value to return."));
2706 return_type
= value_type (return_value
);
2708 return_type
= check_typedef (return_type
);
2709 return_value
= value_cast (return_type
, return_value
);
2711 /* Make sure the value is fully evaluated. It may live in the
2712 stack frame we're about to pop. */
2713 if (value_lazy (return_value
))
2714 value_fetch_lazy (return_value
);
2716 if (thisfun
!= NULL
)
2717 function
= read_var_value (thisfun
, NULL
, thisframe
);
2719 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2720 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2721 /* If the return-type is "void", don't try to find the
2722 return-value's location. However, do still evaluate the
2723 return expression so that, even when the expression result
2724 is discarded, side effects such as "return i++" still
2726 return_value
= NULL
;
2727 else if (thisfun
!= NULL
)
2729 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2730 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2731 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2733 query_prefix
= "The location at which to store the "
2734 "function's return value is unknown.\n"
2735 "If you continue, the return value "
2736 "that you specified will be ignored.\n";
2737 return_value
= NULL
;
2742 /* Does an interactive user really want to do this? Include
2743 information, such as how well GDB can handle the return value, in
2744 the query message. */
2749 if (thisfun
== NULL
)
2750 confirmed
= query (_("%sMake selected stack frame return now? "),
2754 if (TYPE_NO_RETURN (thisfun
->type
))
2755 warning (_("Function does not return normally to caller."));
2756 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2757 SYMBOL_PRINT_NAME (thisfun
));
2760 error (_("Not confirmed"));
2763 /* Discard the selected frame and all frames inner-to it. */
2764 frame_pop (get_selected_frame (NULL
));
2766 /* Store RETURN_VALUE in the just-returned register set. */
2767 if (return_value
!= NULL
)
2769 struct type
*return_type
= value_type (return_value
);
2770 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2772 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2773 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2774 gdbarch_return_value (cache_arch
, function
, return_type
,
2775 get_current_regcache (), NULL
/*read*/,
2776 value_contents (return_value
) /*write*/);
2779 /* If we are at the end of a call dummy now, pop the dummy frame
2781 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2782 frame_pop (get_current_frame ());
2784 select_frame (get_current_frame ());
2785 /* If interactive, print the frame that is now current. */
2787 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2790 /* Find the most inner frame in the current stack for a function called
2791 FUNCTION_NAME. If no matching frame is found return NULL. */
2793 static struct frame_info
*
2794 find_frame_for_function (const char *function_name
)
2796 /* Used to hold the lower and upper addresses for each of the
2797 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2798 struct function_bounds
2800 CORE_ADDR low
, high
;
2802 struct frame_info
*frame
;
2806 gdb_assert (function_name
!= NULL
);
2808 frame
= get_current_frame ();
2809 std::vector
<symtab_and_line
> sals
2810 = decode_line_with_current_source (function_name
,
2811 DECODE_LINE_FUNFIRSTLINE
);
2812 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2813 for (size_t i
= 0; i
< sals
.size (); i
++)
2815 if (sals
[i
].pspace
!= current_program_space
)
2816 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2817 else if (sals
[i
].pc
== 0
2818 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2819 &func_bounds
[i
].low
,
2820 &func_bounds
[i
].high
) == 0)
2821 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2826 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2827 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2828 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2832 frame
= find_relative_frame (frame
, &level
);
2835 while (!found
&& level
== 0);
2843 /* Implements the dbx 'func' command. */
2846 func_command (const char *arg
, int from_tty
)
2851 struct frame_info
*frame
= find_frame_for_function (arg
);
2853 error (_("'%s' not within current stack frame."), arg
);
2854 if (frame
!= get_selected_frame (NULL
))
2856 select_frame (frame
);
2857 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2861 /* The qcs command line flags for the "frame apply" commands. Keep
2862 this in sync with the "thread apply" commands. */
2864 using qcs_flag_option_def
2865 = gdb::option::flag_option_def
<qcs_flags
>;
2867 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2868 qcs_flag_option_def
{
2869 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2870 N_("Disables printing the frame location information."),
2873 qcs_flag_option_def
{
2874 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2875 N_("Print any error raised by COMMAND and continue."),
2878 qcs_flag_option_def
{
2879 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2880 N_("Silently ignore any errors or empty output produced by COMMAND."),
2884 /* Create an option_def_group array for all the "frame apply" options,
2885 with FLAGS and SET_BT_OPTS as context. */
2887 static inline std::array
<gdb::option::option_def_group
, 2>
2888 make_frame_apply_options_def_group (qcs_flags
*flags
,
2889 set_backtrace_options
*set_bt_opts
)
2892 { {fr_qcs_flags_option_defs
}, flags
},
2893 { {set_backtrace_option_defs
}, set_bt_opts
},
2897 /* Apply a GDB command to all stack frames, or a set of identified frames,
2898 or innermost COUNT frames.
2899 With a negative COUNT, apply command on outermost -COUNT frames.
2901 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2902 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2903 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2904 frame apply all -s p local_var_no_idea_in_which_frame
2905 If a frame has a local variable called
2906 local_var_no_idea_in_which_frame, print frame
2907 and value of local_var_no_idea_in_which_frame.
2908 frame apply all -s -q p local_var_no_idea_in_which_frame
2909 Same as before, but only print the variable value.
2910 frame apply level 2-5 0 4-7 -s p i = i + 1
2911 Adds 1 to the variable i in the specified frames.
2912 Note that i will be incremented twice in
2915 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2916 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2917 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2918 for error messages. */
2921 frame_apply_command_count (const char *which_command
,
2922 const char *cmd
, int from_tty
,
2923 struct frame_info
*trailing
, int count
)
2926 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2928 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2929 gdb::option::process_options
2930 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2932 validate_flags_qcs (which_command
, &flags
);
2934 if (cmd
== NULL
|| *cmd
== '\0')
2935 error (_("Please specify a command to apply on the selected frames"));
2937 /* The below will restore the current inferior/thread/frame.
2938 Usually, only the frame is effectively to be restored.
2939 But in case CMD switches of inferior/thread, better restore
2941 scoped_restore_current_thread restore_thread
;
2943 /* These options are handled quite deep in the unwind machinery, so
2944 we get to pass them down by swapping globals. */
2945 scoped_restore restore_set_backtrace_options
2946 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2948 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2955 std::string cmd_result
;
2957 /* In case CMD switches of inferior/thread/frame, the below
2958 restores the inferior/thread/frame. FI can then be
2959 set to the selected frame. */
2960 scoped_restore_current_thread restore_fi_current_frame
;
2962 cmd_result
= execute_command_to_string
2963 (cmd
, from_tty
, gdb_stdout
->term_out ());
2965 fi
= get_selected_frame (_("frame apply "
2966 "unable to get selected frame."));
2967 if (!flags
.silent
|| cmd_result
.length () > 0)
2970 print_stack_frame (fi
, 1, LOCATION
, 0);
2971 printf_filtered ("%s", cmd_result
.c_str ());
2974 catch (const gdb_exception_error
&ex
)
2976 fi
= get_selected_frame (_("frame apply "
2977 "unable to get selected frame."));
2981 print_stack_frame (fi
, 1, LOCATION
, 0);
2983 printf_filtered ("%s\n", ex
.what ());
2991 /* Completer for the "frame apply ..." commands. */
2994 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
2996 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
2997 if (gdb::option::complete_options
2998 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3001 complete_nested_command_line (tracker
, text
);
3004 /* Completer for the "frame apply" commands. */
3007 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3008 completion_tracker
&tracker
,
3009 const char *text
, const char */
*word*/
)
3011 /* Do this explicitly because there's an early return below. */
3012 tracker
.set_use_custom_word_point (true);
3014 number_or_range_parser
levels (text
);
3016 /* Skip the LEVEL list to find the options and command args. */
3019 while (!levels
.finished ())
3021 /* Call for effect. */
3022 levels
.get_number ();
3024 if (levels
.in_range ())
3025 levels
.skip_range ();
3028 catch (const gdb_exception_error
&ex
)
3030 /* get_number throws if it parses a negative number, for
3031 example. But a seemingly negative number may be the start of
3032 an option instead. */
3035 const char *cmd
= levels
.cur_tok ();
3039 /* No level list yet. */
3043 /* Check if we're past a valid LEVEL already. */
3044 if (levels
.finished ()
3045 && cmd
> text
&& !isspace (cmd
[-1]))
3048 /* We're past LEVELs, advance word point. */
3049 tracker
.advance_custom_word_point_by (cmd
- text
);
3052 frame_apply_completer (tracker
, text
);
3055 /* Completer for the "frame apply all" command. */
3058 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3059 completion_tracker
&tracker
,
3060 const char *text
, const char */
*word*/
)
3062 frame_apply_completer (tracker
, text
);
3065 /* Completer for the "frame apply COUNT" command. */
3068 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3069 completion_tracker
&tracker
,
3070 const char *text
, const char */
*word*/
)
3072 const char *cmd
= text
;
3074 int count
= get_number_trailer (&cmd
, 0);
3078 /* Check if we're past a valid COUNT already. */
3079 if (cmd
> text
&& !isspace (cmd
[-1]))
3082 /* We're past COUNT, advance word point. */
3083 tracker
.advance_custom_word_point_by (cmd
- text
);
3086 frame_apply_completer (tracker
, text
);
3089 /* Implementation of the "frame apply level" command. */
3092 frame_apply_level_command (const char *cmd
, int from_tty
)
3094 if (!target_has_stack
)
3095 error (_("No stack."));
3097 bool level_found
= false;
3098 const char *levels_str
= cmd
;
3099 number_or_range_parser
levels (levels_str
);
3101 /* Skip the LEVEL list to find the flags and command args. */
3102 while (!levels
.finished ())
3104 /* Call for effect. */
3105 levels
.get_number ();
3108 if (levels
.in_range ())
3109 levels
.skip_range ();
3113 error (_("Missing or invalid LEVEL... argument"));
3115 cmd
= levels
.cur_tok ();
3117 /* Redo the LEVELS parsing, but applying COMMAND. */
3118 levels
.init (levels_str
);
3119 while (!levels
.finished ())
3121 const int level_beg
= levels
.get_number ();
3124 if (levels
.in_range ())
3126 n_frames
= levels
.end_value () - level_beg
+ 1;
3127 levels
.skip_range ();
3132 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3133 leading_innermost_frame (level_beg
), n_frames
);
3137 /* Implementation of the "frame apply all" command. */
3140 frame_apply_all_command (const char *cmd
, int from_tty
)
3142 if (!target_has_stack
)
3143 error (_("No stack."));
3145 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3146 get_current_frame (), INT_MAX
);
3149 /* Implementation of the "frame apply" command. */
3152 frame_apply_command (const char* cmd
, int from_tty
)
3155 struct frame_info
*trailing
;
3157 if (!target_has_stack
)
3158 error (_("No stack."));
3161 error (_("Missing COUNT argument."));
3162 count
= get_number_trailer (&cmd
, 0);
3164 error (_("Invalid COUNT argument."));
3168 trailing
= trailing_outermost_frame (-count
);
3172 trailing
= get_current_frame ();
3174 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3178 /* Implementation of the "faas" command. */
3181 faas_command (const char *cmd
, int from_tty
)
3183 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3184 execute_command (expanded
.c_str (), from_tty
);
3188 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3189 matching frame can be found. */
3191 static struct frame_info
*
3192 find_frame_for_address (CORE_ADDR address
)
3195 struct frame_info
*fid
;
3197 id
= frame_id_build_wild (address
);
3199 /* If (s)he specifies the frame with an address, he deserves
3200 what (s)he gets. Still, give the highest one that matches.
3201 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3203 for (fid
= get_current_frame ();
3205 fid
= get_prev_frame (fid
))
3207 if (frame_id_eq (id
, get_frame_id (fid
)))
3209 struct frame_info
*prev_frame
;
3213 prev_frame
= get_prev_frame (fid
);
3215 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3227 /* Commands with a prefix of `frame apply'. */
3228 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3230 /* Commands with a prefix of `frame'. */
3231 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3233 /* Commands with a prefix of `select frame'. */
3234 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3236 /* Commands with a prefix of `info frame'. */
3237 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3240 _initialize_stack (void)
3242 struct cmd_list_element
*cmd
;
3244 add_com ("return", class_stack
, return_command
, _("\
3245 Make selected stack frame return to its caller.\n\
3246 Control remains in the debugger, but when you continue\n\
3247 execution will resume in the frame above the one now selected.\n\
3248 If an argument is given, it is an expression for the value to return."));
3250 add_com ("up", class_stack
, up_command
, _("\
3251 Select and print stack frame that called this one.\n\
3252 An argument says how many frames up to go."));
3253 add_com ("up-silently", class_support
, up_silently_command
, _("\
3254 Same as the `up' command, but does not print anything.\n\
3255 This is useful in command scripts."));
3257 add_com ("down", class_stack
, down_command
, _("\
3258 Select and print stack frame called by this one.\n\
3259 An argument says how many frames down to go."));
3260 add_com_alias ("do", "down", class_stack
, 1);
3261 add_com_alias ("dow", "down", class_stack
, 1);
3262 add_com ("down-silently", class_support
, down_silently_command
, _("\
3263 Same as the `down' command, but does not print anything.\n\
3264 This is useful in command scripts."));
3266 add_prefix_cmd ("frame", class_stack
,
3267 &frame_cmd
.base_command
, _("\
3268 Select and print a stack frame.\n\
3269 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3270 A single numerical argument specifies the frame to select."),
3271 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3273 add_com_alias ("f", "frame", class_stack
, 1);
3275 #define FRAME_APPLY_OPTION_HELP "\
3276 Prints the frame location information followed by COMMAND output.\n\
3278 By default, an error raised during the execution of COMMAND\n\
3279 aborts \"frame apply\".\n\
3284 const auto frame_apply_opts
3285 = make_frame_apply_options_def_group (nullptr, nullptr);
3287 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3288 Apply a command to a number of frames.\n\
3289 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3290 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3291 FRAME_APPLY_OPTION_HELP
),
3294 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3295 frame_apply_cmd_help
.c_str (),
3296 &frame_apply_cmd_list
, "frame apply ", 1,
3298 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3300 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3301 Apply a command to all frames.\n\
3303 Usage: frame apply all [OPTION]... COMMAND\n"
3304 FRAME_APPLY_OPTION_HELP
),
3307 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3308 frame_apply_all_cmd_help
.c_str (),
3309 &frame_apply_cmd_list
);
3310 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3312 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3313 Apply a command to a list of frames.\n\
3315 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3316 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3317 FRAME_APPLY_OPTION_HELP
),
3320 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3321 frame_apply_level_cmd_help
.c_str (),
3322 &frame_apply_cmd_list
);
3323 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3325 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3326 Apply a command to all frames (ignoring errors and empty output).\n\
3327 Usage: faas [OPTION]... COMMAND\n\
3328 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3329 See \"help frame apply all\" for available options."));
3330 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3332 add_prefix_cmd ("frame", class_stack
,
3333 &frame_cmd
.base_command
, _("\
3334 Select and print a stack frame.\n\
3335 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3336 A single numerical argument specifies the frame to select."),
3337 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3338 add_com_alias ("f", "frame", class_stack
, 1);
3340 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3342 Select and print a stack frame by stack address.\n\
3344 Usage: frame address STACK-ADDRESS"),
3347 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3349 View a stack frame that might be outside the current backtrace.\n\
3351 Usage: frame view STACK-ADDRESS\n\
3352 frame view STACK-ADDRESS PC-ADDRESS"),
3355 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3357 Select and print a stack frame by function name.\n\
3359 Usage: frame function NAME\n\
3361 The innermost frame that visited function NAME is selected."),
3363 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3366 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3368 Select and print a stack frame by level.\n\
3370 Usage: frame level LEVEL"),
3373 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3374 &select_frame_cmd
.base_command
, _("\
3375 Select a stack frame without printing anything.\n\
3376 A single numerical argument specifies the frame to select."),
3377 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3378 &cli_suppress_notification
.user_selected_context
);
3380 add_cmd_suppress_notification ("address", class_stack
,
3381 &select_frame_cmd
.address
, _("\
3382 Select a stack frame by stack address.\n\
3384 Usage: select-frame address STACK-ADDRESS"),
3385 &select_frame_cmd_list
,
3386 &cli_suppress_notification
.user_selected_context
);
3389 add_cmd_suppress_notification ("view", class_stack
,
3390 &select_frame_cmd
.view
, _("\
3391 Select a stack frame that might be outside the current backtrace.\n\
3393 Usage: select-frame view STACK-ADDRESS\n\
3394 select-frame view STACK-ADDRESS PC-ADDRESS"),
3395 &select_frame_cmd_list
,
3396 &cli_suppress_notification
.user_selected_context
);
3398 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3399 &select_frame_cmd
.function
, _("\
3400 Select a stack frame by function name.\n\
3402 Usage: select-frame function NAME"),
3403 &select_frame_cmd_list
,
3404 &cli_suppress_notification
.user_selected_context
);
3405 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3407 add_cmd_suppress_notification ("level", class_stack
,
3408 &select_frame_cmd
.level
, _("\
3409 Select a stack frame by level.\n\
3411 Usage: select-frame level LEVEL"),
3412 &select_frame_cmd_list
,
3413 &cli_suppress_notification
.user_selected_context
);
3415 const auto backtrace_opts
3416 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3418 static std::string backtrace_help
3419 = gdb::option::build_help (_("\
3420 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3421 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3426 For backward compatibility, the following qualifiers are supported:\n\
3428 full - same as -full option.\n\
3429 no-filters - same as -no-filters option.\n\
3430 hide - same as -hide.\n\
3432 With a negative COUNT, print outermost -COUNT frames."),
3435 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3437 backtrace_help
.c_str ());
3438 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3440 add_com_alias ("bt", "backtrace", class_stack
, 0);
3442 add_com_alias ("where", "backtrace", class_alias
, 0);
3443 add_info ("stack", backtrace_command
,
3444 _("Backtrace of the stack, or innermost COUNT frames."));
3445 add_info_alias ("s", "stack", 1);
3447 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3448 _("All about the selected stack frame.\n\
3449 With no arguments, displays information about the currently selected stack\n\
3450 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3451 the information is then printed about the specified frame."),
3452 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3453 add_info_alias ("f", "frame", 1);
3455 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3457 Print information about a stack frame selected by stack address.\n\
3459 Usage: info frame address STACK-ADDRESS"),
3460 &info_frame_cmd_list
);
3462 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3464 Print information about a stack frame outside the current backtrace.\n\
3466 Usage: info frame view STACK-ADDRESS\n\
3467 info frame view STACK-ADDRESS PC-ADDRESS"),
3468 &info_frame_cmd_list
);
3470 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3472 Print information about a stack frame selected by function name.\n\
3474 Usage: info frame function NAME"),
3475 &info_frame_cmd_list
);
3476 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3478 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3480 Print information about a stack frame selected by level.\n\
3482 Usage: info frame level LEVEL"),
3483 &info_frame_cmd_list
);
3485 cmd
= add_info ("locals", info_locals_command
,
3486 info_print_args_help (_("\
3487 All local variables of current stack frame or those matching REGEXPs.\n\
3488 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3489 Prints the local variables of the current stack frame.\n"),
3490 _("local variables")));
3491 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3492 cmd
= add_info ("args", info_args_command
,
3493 info_print_args_help (_("\
3494 All argument variables of current stack frame or those matching REGEXPs.\n\
3495 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3496 Prints the argument variables of the current stack frame.\n"),
3497 _("argument variables")));
3498 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3501 add_com ("func", class_stack
, func_command
, _("\
3502 Select the stack frame that contains NAME.\n\
3503 Usage: func NAME"));
3505 /* Install "set print raw frame-arguments", a deprecated spelling of
3506 "set print raw-frame-arguments". */
3507 cmd
= add_setshow_boolean_cmd
3508 ("frame-arguments", no_class
,
3509 &user_frame_print_options
.print_raw_frame_arguments
,
3511 Set whether to print frame arguments in raw form."), _("\
3512 Show whether to print frame arguments in raw form."), _("\
3513 If set, frame arguments are printed in raw form, bypassing any\n\
3514 pretty-printers for that value."),
3516 &setprintrawlist
, &showprintrawlist
);
3517 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3519 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3520 &disassemble_next_line
, _("\
3521 Set whether to disassemble next source line or insn when execution stops."),
3523 Show whether to disassemble next source line or insn when execution stops."),
3525 If ON, GDB will display disassembly of the next source line, in addition\n\
3526 to displaying the source line itself. If the next source line cannot\n\
3527 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3528 will display disassembly of next instruction instead of showing the\n\
3530 If AUTO, display disassembly of next instruction only if the source line\n\
3531 cannot be displayed.\n\
3532 If OFF (which is the default), never display the disassembly of the next\n\
3535 show_disassemble_next_line
,
3536 &setlist
, &showlist
);
3537 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3539 gdb::option::add_setshow_cmds_for_options
3540 (class_stack
, &user_frame_print_options
,
3541 frame_print_option_defs
, &setprintlist
, &showprintlist
);