1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
53 #include "extension.h"
54 #include "observable.h"
55 #include "gdbsupport/def-vector.h"
56 #include "cli/cli-option.h"
57 #include "cli/cli-style.h"
59 /* The possible choices of "set print frame-arguments", and the value
62 const char print_frame_arguments_all
[] = "all";
63 const char print_frame_arguments_scalars
[] = "scalars";
64 const char print_frame_arguments_none
[] = "none";
65 const char print_frame_arguments_presence
[] = "presence";
67 static const char *const print_frame_arguments_choices
[] =
69 print_frame_arguments_all
,
70 print_frame_arguments_scalars
,
71 print_frame_arguments_none
,
72 print_frame_arguments_presence
,
76 /* The possible choices of "set print frame-info", and the value
79 const char print_frame_info_auto
[] = "auto";
80 const char print_frame_info_source_line
[] = "source-line";
81 const char print_frame_info_location
[] = "location";
82 const char print_frame_info_source_and_location
[] = "source-and-location";
83 const char print_frame_info_location_and_address
[] = "location-and-address";
84 const char print_frame_info_short_location
[] = "short-location";
86 static const char *const print_frame_info_choices
[] =
88 print_frame_info_auto
,
89 print_frame_info_source_line
,
90 print_frame_info_location
,
91 print_frame_info_source_and_location
,
92 print_frame_info_location_and_address
,
93 print_frame_info_short_location
,
97 /* print_frame_info_print_what[i] maps a choice to the corresponding
99 static const gdb::optional
<enum print_what
> print_frame_info_print_what
[] =
100 {{}, /* Empty value for "auto". */
101 SRC_LINE
, LOCATION
, SRC_AND_LOC
, LOC_AND_ADDRESS
, SHORT_LOCATION
};
103 /* The possible choices of "set print entry-values", and the value
106 const char print_entry_values_no
[] = "no";
107 const char print_entry_values_only
[] = "only";
108 const char print_entry_values_preferred
[] = "preferred";
109 const char print_entry_values_if_needed
[] = "if-needed";
110 const char print_entry_values_both
[] = "both";
111 const char print_entry_values_compact
[] = "compact";
112 const char print_entry_values_default
[] = "default";
113 static const char *const print_entry_values_choices
[] =
115 print_entry_values_no
,
116 print_entry_values_only
,
117 print_entry_values_preferred
,
118 print_entry_values_if_needed
,
119 print_entry_values_both
,
120 print_entry_values_compact
,
121 print_entry_values_default
,
126 frame_print_options user_frame_print_options
;
128 /* Option definitions for some frame-related "set print ..."
131 using boolean_option_def
132 = gdb::option::boolean_option_def
<frame_print_options
>;
133 using enum_option_def
134 = gdb::option::enum_option_def
<frame_print_options
>;
136 static const gdb::option::option_def frame_print_option_defs
[] = {
140 print_entry_values_choices
,
141 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
142 NULL
, /* show_cmd_cb */
143 N_("Set printing of function arguments at function entry."),
144 N_("Show printing of function arguments at function entry."),
145 N_("GDB can sometimes determine the values of function arguments at entry,\n\
146 in addition to their current values. This option tells GDB whether\n\
147 to print the current value, the value at entry (marked as val@entry),\n\
148 or both. Note that one or both of these values may be <optimized out>."),
153 print_frame_arguments_choices
,
154 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
155 NULL
, /* show_cmd_cb */
156 N_("Set printing of non-scalar frame arguments."),
157 N_("Show printing of non-scalar frame arguments."),
162 "raw-frame-arguments",
163 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
164 NULL
, /* show_cmd_cb */
165 N_("Set whether to print frame arguments in raw form."),
166 N_("Show whether to print frame arguments in raw form."),
167 N_("If set, frame arguments are printed in raw form, bypassing any\n\
168 pretty-printers for that value.")
173 print_frame_info_choices
,
174 [] (frame_print_options
*opt
) { return &opt
->print_frame_info
; },
175 NULL
, /* show_cmd_cb */
176 N_("Set printing of frame information."),
177 N_("Show printing of frame information."),
183 /* Options for the "backtrace" command. */
185 struct backtrace_cmd_options
188 bool no_filters
= false;
192 using bt_flag_option_def
193 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
195 static const gdb::option::option_def backtrace_command_option_defs
[] = {
198 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
199 N_("Print values of local variables.")
204 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
205 N_("Prohibit frame filters from executing on a backtrace."),
210 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
211 N_("Causes Python frame filter elided frames to not be printed."),
215 /* Prototypes for local functions. */
217 static void print_frame_local_vars (struct frame_info
*frame
,
219 const char *regexp
, const char *t_regexp
,
220 int num_tabs
, struct ui_file
*stream
);
222 static void print_frame (const frame_print_options
&opts
,
223 frame_info
*frame
, int print_level
,
224 enum print_what print_what
, int print_args
,
225 struct symtab_and_line sal
);
227 static void set_last_displayed_sal (int valid
,
228 struct program_space
*pspace
,
230 struct symtab
*symtab
,
233 static struct frame_info
*find_frame_for_function (const char *);
234 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
236 /* Zero means do things normally; we are interacting directly with the
237 user. One means print the full filename and linenumber when a
238 frame is printed, and do so in a format emacs18/emacs19.22 can
239 parse. Two means print similar annotations, but in many more
240 cases and in a slightly different syntax. */
242 int annotation_level
= 0;
244 /* These variables hold the last symtab and line we displayed to the user.
245 * This is where we insert a breakpoint or a skiplist entry by default. */
246 static int last_displayed_sal_valid
= 0;
247 static struct program_space
*last_displayed_pspace
= 0;
248 static CORE_ADDR last_displayed_addr
= 0;
249 static struct symtab
*last_displayed_symtab
= 0;
250 static int last_displayed_line
= 0;
256 frame_show_address (struct frame_info
*frame
,
257 struct symtab_and_line sal
)
259 /* If there is a line number, but no PC, then there is no location
260 information associated with this sal. The only way that should
261 happen is for the call sites of inlined functions (SAL comes from
262 find_frame_sal). Otherwise, we would have some PC range if the
263 SAL came from a line table. */
264 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
266 if (get_next_frame (frame
) == NULL
)
267 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
269 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
273 return get_frame_pc (frame
) != sal
.pc
;
279 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
280 int print_level
, enum print_what print_what
,
283 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
285 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
288 /* Show or print a stack frame FRAME briefly. The output is formatted
289 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
290 relative level, function name, argument list, and file name and
291 line number. If the frame's PC is not at the beginning of the
292 source line, the actual PC is printed at the beginning. */
295 print_stack_frame (struct frame_info
*frame
, int print_level
,
296 enum print_what print_what
,
300 /* For mi, alway print location and address. */
301 if (current_uiout
->is_mi_like_p ())
302 print_what
= LOC_AND_ADDRESS
;
306 print_frame_info (user_frame_print_options
,
307 frame
, print_level
, print_what
, 1 /* print_args */,
310 set_current_sal_from_frame (frame
);
312 catch (const gdb_exception_error
&e
)
317 /* Print nameless arguments of frame FRAME on STREAM, where START is
318 the offset of the first nameless argument, and NUM is the number of
319 nameless arguments to print. FIRST is nonzero if this is the first
320 argument (not just the first nameless argument). */
323 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
324 int first
, struct ui_file
*stream
)
326 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
332 for (i
= 0; i
< num
; i
++)
335 argsaddr
= get_frame_args_address (frame
);
338 arg_value
= read_memory_integer (argsaddr
+ start
,
339 sizeof (int), byte_order
);
341 fprintf_filtered (stream
, ", ");
342 fprintf_filtered (stream
, "%ld", arg_value
);
344 start
+= sizeof (int);
348 /* Print single argument of inferior function. ARG must be already
351 Errors are printed as if they would be the parameter value. Use zeroed ARG
352 iff it should not be printed accoring to user settings. */
355 print_frame_arg (const frame_print_options
&fp_opts
,
356 const struct frame_arg
*arg
)
358 struct ui_out
*uiout
= current_uiout
;
362 gdb_assert (!arg
->val
|| !arg
->error
);
363 gdb_assert (arg
->entry_kind
== print_entry_values_no
364 || arg
->entry_kind
== print_entry_values_only
365 || (!uiout
->is_mi_like_p ()
366 && arg
->entry_kind
== print_entry_values_compact
));
368 annotate_arg_emitter arg_emitter
;
369 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
370 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
371 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
372 if (arg
->entry_kind
== print_entry_values_compact
)
374 /* It is OK to provide invalid MI-like stream as with
375 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
378 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
379 SYMBOL_LANGUAGE (arg
->sym
),
380 DMGL_PARAMS
| DMGL_ANSI
);
382 if (arg
->entry_kind
== print_entry_values_only
383 || arg
->entry_kind
== print_entry_values_compact
)
385 uiout
->field_stream ("name", stb
, variable_name_style
.style ());
386 annotate_arg_name_end ();
389 if (!arg
->val
&& !arg
->error
)
394 stb
.printf (_("<error reading variable: %s>"), arg
->error
.get ());
399 const struct language_defn
*language
;
400 struct value_print_options vp_opts
;
402 /* Avoid value_print because it will deref ref parameters. We
403 just want to print their addresses. Print ??? for args whose
404 address we do not know. We pass 2 as "recurse" to val_print
405 because our standard indentation here is 4 spaces, and
406 val_print indents 2 for each recurse. */
408 annotate_arg_value (value_type (arg
->val
));
410 /* Use the appropriate language to display our symbol, unless the
411 user forced the language to a specific language. */
412 if (language_mode
== language_mode_auto
)
413 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
415 language
= current_language
;
417 get_no_prettyformat_print_options (&vp_opts
);
418 vp_opts
.deref_ref
= 1;
419 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
421 /* True in "summary" mode, false otherwise. */
423 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
425 common_val_print (arg
->val
, &stb
, 2, &vp_opts
, language
);
427 catch (const gdb_exception_error
&except
)
429 stb
.printf (_("<error reading variable: %s>"),
435 uiout
->field_stream ("value", stb
);
438 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
439 responsible for xfree of ARGP->ERROR. This function never throws an
443 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
444 struct frame_arg
*argp
)
452 argp
->val
= read_var_value (sym
, NULL
, frame
);
454 catch (const gdb_exception_error
&except
)
456 argp
->error
.reset (xstrdup (except
.what ()));
460 /* Read in inferior function parameter SYM at FRAME into ARGP. This
461 function never throws an exception. */
464 read_frame_arg (const frame_print_options
&fp_opts
,
465 symbol
*sym
, frame_info
*frame
,
466 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
468 struct value
*val
= NULL
, *entryval
= NULL
;
469 char *val_error
= NULL
, *entryval_error
= NULL
;
472 if (fp_opts
.print_entry_values
!= print_entry_values_only
473 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
477 val
= read_var_value (sym
, NULL
, frame
);
479 catch (const gdb_exception_error
&except
)
481 val_error
= (char *) alloca (except
.message
->size () + 1);
482 strcpy (val_error
, except
.what ());
486 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
487 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
488 && fp_opts
.print_entry_values
!= print_entry_values_no
489 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
490 || !val
|| value_optimized_out (val
)))
494 const struct symbol_computed_ops
*ops
;
496 ops
= SYMBOL_COMPUTED_OPS (sym
);
497 entryval
= ops
->read_variable_at_entry (sym
, frame
);
499 catch (const gdb_exception_error
&except
)
501 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
503 entryval_error
= (char *) alloca (except
.message
->size () + 1);
504 strcpy (entryval_error
, except
.what ());
508 if (entryval
!= NULL
&& value_optimized_out (entryval
))
511 if (fp_opts
.print_entry_values
== print_entry_values_compact
512 || fp_opts
.print_entry_values
== print_entry_values_default
)
514 /* For MI do not try to use print_entry_values_compact for ARGP. */
516 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
518 struct type
*type
= value_type (val
);
520 if (value_lazy (val
))
521 value_fetch_lazy (val
);
522 if (value_lazy (entryval
))
523 value_fetch_lazy (entryval
);
525 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
527 /* Initialize it just to avoid a GCC false warning. */
528 struct value
*val_deref
= NULL
, *entryval_deref
;
530 /* DW_AT_call_value does match with the current
531 value. If it is a reference still try to verify if
532 dereferenced DW_AT_call_data_value does not differ. */
536 struct type
*type_deref
;
538 val_deref
= coerce_ref (val
);
539 if (value_lazy (val_deref
))
540 value_fetch_lazy (val_deref
);
541 type_deref
= value_type (val_deref
);
543 entryval_deref
= coerce_ref (entryval
);
544 if (value_lazy (entryval_deref
))
545 value_fetch_lazy (entryval_deref
);
547 /* If the reference addresses match but dereferenced
548 content does not match print them. */
550 && value_contents_eq (val_deref
, 0,
552 TYPE_LENGTH (type_deref
)))
555 catch (const gdb_exception_error
&except
)
557 /* If the dereferenced content could not be
558 fetched do not display anything. */
559 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
561 else if (except
.message
!= NULL
)
564 = (char *) alloca (except
.message
->size () + 1);
565 strcpy (entryval_error
, except
.what ());
569 /* Value was not a reference; and its content matches. */
570 if (val
== val_deref
)
578 /* Try to remove possibly duplicate error message for ENTRYARGP even
581 if (val_error
&& entryval_error
582 && strcmp (val_error
, entryval_error
) == 0)
584 entryval_error
= NULL
;
586 /* Do not se VAL_EQUAL as the same error message may be shown for
587 the entry value even if no entry values are present in the
593 if (entryval
== NULL
)
595 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
597 gdb_assert (val
== NULL
);
601 val
= read_var_value (sym
, NULL
, frame
);
603 catch (const gdb_exception_error
&except
)
605 val_error
= (char *) alloca (except
.message
->size () + 1);
606 strcpy (val_error
, except
.what ());
609 if (fp_opts
.print_entry_values
== print_entry_values_only
610 || fp_opts
.print_entry_values
== print_entry_values_both
611 || (fp_opts
.print_entry_values
== print_entry_values_preferred
612 && (!val
|| value_optimized_out (val
))))
614 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
615 entryval_error
= NULL
;
618 if ((fp_opts
.print_entry_values
== print_entry_values_compact
619 || fp_opts
.print_entry_values
== print_entry_values_if_needed
620 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
621 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
629 argp
->error
.reset (val_error
? xstrdup (val_error
) : NULL
);
630 if (!val
&& !val_error
)
631 argp
->entry_kind
= print_entry_values_only
;
632 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
633 || fp_opts
.print_entry_values
== print_entry_values_default
)
636 argp
->entry_kind
= print_entry_values_compact
;
637 gdb_assert (!current_uiout
->is_mi_like_p ());
640 argp
->entry_kind
= print_entry_values_no
;
642 entryargp
->sym
= sym
;
643 entryargp
->val
= entryval
;
644 entryargp
->error
.reset (entryval_error
? xstrdup (entryval_error
) : NULL
);
645 if (!entryval
&& !entryval_error
)
646 entryargp
->entry_kind
= print_entry_values_no
;
648 entryargp
->entry_kind
= print_entry_values_only
;
651 /* Print the arguments of frame FRAME on STREAM, given the function
652 FUNC running in that frame (as a symbol), where NUM is the number
653 of arguments according to the stack frame (or -1 if the number of
654 arguments is unknown). */
656 /* Note that currently the "number of arguments according to the
657 stack frame" is only known on VAX where i refers to the "number of
658 ints of arguments according to the stack frame". */
661 print_frame_args (const frame_print_options
&fp_opts
,
662 struct symbol
*func
, struct frame_info
*frame
,
663 int num
, struct ui_file
*stream
)
665 struct ui_out
*uiout
= current_uiout
;
667 /* Offset of next stack argument beyond the one we have seen that is
668 at the highest offset, or -1 if we haven't come to a stack
670 long highest_offset
= -1;
671 /* Number of ints of arguments that we have printed so far. */
672 int args_printed
= 0;
673 /* True if we should print arg names. If false, we only indicate
674 the presence of arguments by printing ellipsis. */
676 = fp_opts
.print_frame_arguments
!= print_frame_arguments_presence
;
677 /* True if we should print arguments, false otherwise. */
680 && fp_opts
.print_frame_arguments
!= print_frame_arguments_none
);
684 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
685 struct block_iterator iter
;
688 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
690 struct frame_arg arg
, entryarg
;
694 /* Keep track of the highest stack argument offset seen, and
695 skip over any kinds of symbols we don't care about. */
697 if (!SYMBOL_IS_ARGUMENT (sym
))
707 switch (SYMBOL_CLASS (sym
))
712 long current_offset
= SYMBOL_VALUE (sym
);
713 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
715 /* Compute address of next argument by adding the size of
716 this argument and rounding to an int boundary. */
718 ((current_offset
+ arg_size
+ sizeof (int) - 1)
719 & ~(sizeof (int) - 1));
721 /* If this is the highest offset seen yet, set
723 if (highest_offset
== -1
724 || (current_offset
> highest_offset
))
725 highest_offset
= current_offset
;
727 /* Add the number of ints we're about to print to
729 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
732 /* We care about types of symbols, but don't need to
733 keep track of stack offsets in them. */
735 case LOC_REGPARM_ADDR
:
737 case LOC_OPTIMIZED_OUT
:
742 /* We have to look up the symbol because arguments can have
743 two entries (one a parameter, one a local) and the one we
744 want is the local, which lookup_symbol will find for us.
745 This includes gcc1 (not gcc2) on SPARC when passing a
746 small structure and gcc2 when the argument type is float
747 and it is passed as a double and converted to float by
748 the prologue (in the latter case the type of the LOC_ARG
749 symbol is double and the type of the LOC_LOCAL symbol is
751 /* But if the parameter name is null, don't try it. Null
752 parameter names occur on the RS/6000, for traceback
753 tables. FIXME, should we even print them? */
755 if (*SYMBOL_LINKAGE_NAME (sym
))
759 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
760 b
, VAR_DOMAIN
).symbol
;
761 gdb_assert (nsym
!= NULL
);
762 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
763 && !SYMBOL_IS_ARGUMENT (nsym
))
765 /* There is a LOC_ARG/LOC_REGISTER pair. This means
766 that it was passed on the stack and loaded into a
767 register, or passed in a register and stored in a
768 stack slot. GDB 3.x used the LOC_ARG; GDB
769 4.0-4.11 used the LOC_REGISTER.
771 Reasons for using the LOC_ARG:
773 (1) Because find_saved_registers may be slow for
776 (2) Because registers are often re-used and stack
777 slots rarely (never?) are. Therefore using
778 the stack slot is much less likely to print
781 Reasons why we might want to use the LOC_REGISTER:
783 (1) So that the backtrace prints the same value
784 as "print foo". I see no compelling reason
785 why this needs to be the case; having the
786 backtrace print the value which was passed
787 in, and "print foo" print the value as
788 modified within the called function, makes
791 Additional note: It might be nice if "info args"
792 displayed both values.
794 One more note: There is a case with SPARC
795 structure passing where we need to use the
796 LOC_REGISTER, but this is dealt with by creating
797 a single LOC_REGPARM in symbol reading. */
799 /* Leave sym (the LOC_ARG) alone. */
806 /* Print the current arg. */
809 uiout
->wrap_hint (" ");
814 arg
.entry_kind
= print_entry_values_no
;
816 entryarg
.entry_kind
= print_entry_values_no
;
819 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
821 if (arg
.entry_kind
!= print_entry_values_only
)
822 print_frame_arg (fp_opts
, &arg
);
824 if (entryarg
.entry_kind
!= print_entry_values_no
)
826 if (arg
.entry_kind
!= print_entry_values_only
)
829 uiout
->wrap_hint (" ");
832 print_frame_arg (fp_opts
, &entryarg
);
839 /* Don't print nameless args in situations where we don't know
840 enough about the stack to find them. */
845 if (highest_offset
== -1)
846 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
848 start
= highest_offset
;
850 if (!print_names
&& !first
&& num
> 0)
853 print_frame_nameless_args (frame
, start
, num
- args_printed
,
858 /* Set the current source and line to the location given by frame
859 FRAME, if possible. When CENTER is true, adjust so the relevant
860 line is in the center of the next 'list'. */
863 set_current_sal_from_frame (struct frame_info
*frame
)
865 symtab_and_line sal
= find_frame_sal (frame
);
866 if (sal
.symtab
!= NULL
)
867 set_current_source_symtab_and_line (sal
);
870 /* If ON, GDB will display disassembly of the next source line when
871 execution of the program being debugged stops.
872 If AUTO (which is the default), or there's no line info to determine
873 the source line of the next instruction, display disassembly of next
874 instruction instead. */
876 static enum auto_boolean disassemble_next_line
;
879 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
880 struct cmd_list_element
*c
,
883 fprintf_filtered (file
,
884 _("Debugger's willingness to use "
885 "disassemble-next-line is %s.\n"),
889 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
890 because it will be broken by filter sometime. */
893 do_gdb_disassembly (struct gdbarch
*gdbarch
,
894 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
899 gdb_disassembly (gdbarch
, current_uiout
,
900 DISASSEMBLY_RAW_INSN
, how_many
,
903 catch (const gdb_exception_error
&exception
)
905 /* If an exception was thrown while doing the disassembly, print
906 the error message, to give the user a clue of what happened. */
907 exception_print (gdb_stderr
, exception
);
911 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
912 Value not present indicates to the caller to use default values
913 specific to the command being executed. */
915 static gdb::optional
<enum print_what
>
916 print_frame_info_to_print_what (const char *print_frame_info
)
918 for (int i
= 0; print_frame_info_choices
[i
] != NULL
; i
++)
919 if (print_frame_info
== print_frame_info_choices
[i
])
920 return print_frame_info_print_what
[i
];
922 internal_error (__FILE__
, __LINE__
,
923 "Unexpected print frame-info value `%s'.",
927 /* Print the PC from FRAME, plus any flags, to UIOUT. */
930 print_pc (struct ui_out
*uiout
, struct gdbarch
*gdbarch
, frame_info
*frame
,
933 uiout
->field_core_addr ("addr", gdbarch
, pc
);
935 std::string flags
= gdbarch_get_pc_address_flags (gdbarch
, frame
, pc
);
939 uiout
->field_string ("addr_flags", flags
);
947 get_user_print_what_frame_info (gdb::optional
<enum print_what
> *what
)
950 = print_frame_info_to_print_what
951 (user_frame_print_options
.print_frame_info
);
954 /* Print information about frame FRAME. The output is format according
955 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. For the meaning of
956 PRINT_WHAT, see enum print_what comments in frame.h.
957 Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info
958 != print_frame_info_auto.
960 Used in "where" output, and to emit breakpoint or step
964 print_frame_info (const frame_print_options
&fp_opts
,
965 frame_info
*frame
, int print_level
,
966 enum print_what print_what
, int print_args
,
969 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
972 struct ui_out
*uiout
= current_uiout
;
974 if (!current_uiout
->is_mi_like_p ()
975 && fp_opts
.print_frame_info
!= print_frame_info_auto
)
977 /* Use the specific frame information desired by the user. */
978 print_what
= *print_frame_info_to_print_what (fp_opts
.print_frame_info
);
981 if (get_frame_type (frame
) == DUMMY_FRAME
982 || get_frame_type (frame
) == SIGTRAMP_FRAME
983 || get_frame_type (frame
) == ARCH_FRAME
)
985 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
987 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
988 gdbarch
, get_frame_pc (frame
));
990 /* Do this regardless of SOURCE because we don't have any source
991 to list for this frame. */
995 uiout
->field_fmt_signed (2, ui_left
, "level",
996 frame_relative_level (frame
));
998 if (uiout
->is_mi_like_p ())
1000 annotate_frame_address ();
1001 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1002 annotate_frame_address_end ();
1005 if (get_frame_type (frame
) == DUMMY_FRAME
)
1007 annotate_function_call ();
1008 uiout
->field_string ("func", "<function called from gdb>",
1009 function_name_style
.style ());
1011 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
1013 annotate_signal_handler_caller ();
1014 uiout
->field_string ("func", "<signal handler called>",
1015 function_name_style
.style ());
1017 else if (get_frame_type (frame
) == ARCH_FRAME
)
1019 uiout
->field_string ("func", "<cross-architecture call>",
1020 function_name_style
.style ());
1023 annotate_frame_end ();
1025 /* If disassemble-next-line is set to auto or on output the next
1027 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
1028 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1029 do_gdb_disassembly (get_frame_arch (frame
), 1,
1030 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1035 /* If FRAME is not the innermost frame, that normally means that
1036 FRAME->pc points to *after* the call instruction, and we want to
1037 get the line containing the call, never the next line. But if
1038 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1039 next frame was not entered as the result of a call, and we want
1040 to get the line containing FRAME->pc. */
1041 symtab_and_line sal
= find_frame_sal (frame
);
1043 location_print
= (print_what
== LOCATION
1044 || print_what
== SRC_AND_LOC
1045 || print_what
== LOC_AND_ADDRESS
1046 || print_what
== SHORT_LOCATION
);
1047 if (location_print
|| !sal
.symtab
)
1048 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
1050 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
1052 /* If disassemble-next-line is set to auto or on and doesn't have
1053 the line debug messages for $pc, output the next instruction. */
1054 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
1055 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1056 && source_print
&& !sal
.symtab
)
1057 do_gdb_disassembly (get_frame_arch (frame
), 1,
1058 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
1060 if (source_print
&& sal
.symtab
)
1062 int mid_statement
= ((print_what
== SRC_LINE
)
1063 && frame_show_address (frame
, sal
));
1064 annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
1065 get_frame_pc (frame
));
1067 if (deprecated_print_frame_info_listing_hook
)
1068 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
1072 struct value_print_options opts
;
1074 get_user_print_options (&opts
);
1075 /* We used to do this earlier, but that is clearly
1076 wrong. This function is used by many different
1077 parts of gdb, including normal_stop in infrun.c,
1078 which uses this to print out the current PC
1079 when we stepi/nexti into the middle of a source
1080 line. Only the command line really wants this
1081 behavior. Other UIs probably would like the
1082 ability to decide for themselves if it is desired. */
1083 if (opts
.addressprint
&& mid_statement
)
1085 print_pc (uiout
, gdbarch
, frame
, get_frame_pc (frame
));
1089 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1093 /* If disassemble-next-line is set to on and there is line debug
1094 messages, output assembly codes for next line. */
1095 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1096 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1098 if (set_current_sal
)
1102 if (get_frame_pc_if_available (frame
, &pc
))
1103 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1105 set_last_displayed_sal (0, 0, 0, 0, 0);
1108 annotate_frame_end ();
1110 gdb_flush (gdb_stdout
);
1113 /* Remember the last symtab and line we displayed, which we use e.g.
1114 * as the place to put a breakpoint when the `break' command is
1115 * invoked with no arguments. */
1118 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
1119 CORE_ADDR addr
, struct symtab
*symtab
,
1122 last_displayed_sal_valid
= valid
;
1123 last_displayed_pspace
= pspace
;
1124 last_displayed_addr
= addr
;
1125 last_displayed_symtab
= symtab
;
1126 last_displayed_line
= line
;
1127 if (valid
&& pspace
== NULL
)
1129 clear_last_displayed_sal ();
1130 internal_error (__FILE__
, __LINE__
,
1131 _("Trying to set NULL pspace."));
1135 /* Forget the last sal we displayed. */
1138 clear_last_displayed_sal (void)
1140 last_displayed_sal_valid
= 0;
1141 last_displayed_pspace
= 0;
1142 last_displayed_addr
= 0;
1143 last_displayed_symtab
= 0;
1144 last_displayed_line
= 0;
1147 /* Is our record of the last sal we displayed valid? If not,
1148 * the get_last_displayed_* functions will return NULL or 0, as
1152 last_displayed_sal_is_valid (void)
1154 return last_displayed_sal_valid
;
1157 /* Get the pspace of the last sal we displayed, if it's valid. */
1159 struct program_space
*
1160 get_last_displayed_pspace (void)
1162 if (last_displayed_sal_valid
)
1163 return last_displayed_pspace
;
1167 /* Get the address of the last sal we displayed, if it's valid. */
1170 get_last_displayed_addr (void)
1172 if (last_displayed_sal_valid
)
1173 return last_displayed_addr
;
1177 /* Get the symtab of the last sal we displayed, if it's valid. */
1180 get_last_displayed_symtab (void)
1182 if (last_displayed_sal_valid
)
1183 return last_displayed_symtab
;
1187 /* Get the line of the last sal we displayed, if it's valid. */
1190 get_last_displayed_line (void)
1192 if (last_displayed_sal_valid
)
1193 return last_displayed_line
;
1197 /* Get the last sal we displayed, if it's valid. */
1200 get_last_displayed_sal ()
1202 symtab_and_line sal
;
1204 if (last_displayed_sal_valid
)
1206 sal
.pspace
= last_displayed_pspace
;
1207 sal
.pc
= last_displayed_addr
;
1208 sal
.symtab
= last_displayed_symtab
;
1209 sal
.line
= last_displayed_line
;
1216 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1217 corresponding to FRAME. */
1219 gdb::unique_xmalloc_ptr
<char>
1220 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1221 struct symbol
**funcp
)
1223 struct symbol
*func
;
1224 gdb::unique_xmalloc_ptr
<char> funname
;
1226 *funlang
= language_unknown
;
1230 func
= get_frame_function (frame
);
1233 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1235 *funlang
= SYMBOL_LANGUAGE (func
);
1238 if (*funlang
== language_cplus
)
1240 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1241 to display the demangled name that we already have
1242 stored in the symbol table, but we stored a version
1243 with DMGL_PARAMS turned on, and here we don't want to
1244 display parameters. So remove the parameters. */
1245 funname
= cp_remove_params (print_name
);
1248 /* If we didn't hit the C++ case above, set *funname
1250 if (funname
== NULL
)
1251 funname
.reset (xstrdup (print_name
));
1255 struct bound_minimal_symbol msymbol
;
1258 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1261 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1262 if (msymbol
.minsym
!= NULL
)
1264 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1265 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1273 print_frame (const frame_print_options
&fp_opts
,
1274 frame_info
*frame
, int print_level
,
1275 enum print_what print_what
, int print_args
,
1276 struct symtab_and_line sal
)
1278 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1279 struct ui_out
*uiout
= current_uiout
;
1280 enum language funlang
= language_unknown
;
1281 struct value_print_options opts
;
1282 struct symbol
*func
;
1286 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1288 gdb::unique_xmalloc_ptr
<char> funname
1289 = find_frame_funname (frame
, &funlang
, &func
);
1291 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1295 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1300 uiout
->field_fmt_signed (2, ui_left
, "level",
1301 frame_relative_level (frame
));
1303 get_user_print_options (&opts
);
1304 if (opts
.addressprint
)
1306 || frame_show_address (frame
, sal
)
1307 || print_what
== LOC_AND_ADDRESS
)
1309 annotate_frame_address ();
1311 print_pc (uiout
, gdbarch
, frame
, pc
);
1313 uiout
->field_string ("addr", "<unavailable>",
1314 address_style
.style ());
1315 annotate_frame_address_end ();
1316 uiout
->text (" in ");
1318 annotate_frame_function_name ();
1321 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1322 funlang
, DMGL_ANSI
);
1323 uiout
->field_stream ("func", stb
, function_name_style
.style ());
1324 uiout
->wrap_hint (" ");
1325 annotate_frame_args ();
1332 if (gdbarch_frame_num_args_p (gdbarch
))
1334 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1335 gdb_assert (numargs
>= 0);
1341 ui_out_emit_list
list_emitter (uiout
, "args");
1344 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1346 catch (const gdb_exception_error
&e
)
1350 /* FIXME: ARGS must be a list. If one argument is a string it
1351 will have " that will not be properly escaped. */
1356 if (print_what
!= SHORT_LOCATION
&& sal
.symtab
)
1358 const char *filename_display
;
1360 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1361 annotate_frame_source_begin ();
1362 uiout
->wrap_hint (" ");
1363 uiout
->text (" at ");
1364 annotate_frame_source_file ();
1365 uiout
->field_string ("file", filename_display
,
1366 file_name_style
.style ());
1367 if (uiout
->is_mi_like_p ())
1369 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1371 uiout
->field_string ("fullname", fullname
);
1373 annotate_frame_source_file_end ();
1375 annotate_frame_source_line ();
1376 uiout
->field_signed ("line", sal
.line
);
1377 annotate_frame_source_end ();
1380 if (print_what
!= SHORT_LOCATION
1381 && pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1383 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1384 get_frame_pc (frame
));
1388 annotate_frame_where ();
1389 uiout
->wrap_hint (" ");
1390 uiout
->text (" from ");
1391 uiout
->field_string ("from", lib
);
1394 if (uiout
->is_mi_like_p ())
1395 uiout
->field_string ("arch",
1396 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1403 /* Completion function for "frame function", "info frame function", and
1404 "select-frame function" commands. */
1407 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1408 completion_tracker
&tracker
,
1409 const char *text
, const char *word
)
1411 /* This is used to complete function names within a stack. It would be
1412 nice if we only offered functions that were actually in the stack.
1413 However, this would mean unwinding the stack to completion, which
1414 could take too long, or on a corrupted stack, possibly not end.
1415 Instead, we offer all symbol names as a safer choice. */
1416 collect_symbol_completion_matches (tracker
,
1417 complete_symbol_mode::EXPRESSION
,
1418 symbol_name_match_type::EXPRESSION
,
1422 /* Core of all the "info frame" sub-commands. Print information about a
1423 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1424 frame specification, they just entered 'info frame'. If the user did
1425 provide a frame specification (for example 'info frame 0', 'info frame
1426 level 1') then SELECTED_FRAME_P will be false. */
1429 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1431 struct symbol
*func
;
1433 struct frame_info
*calling_frame_info
;
1435 const char *funname
= 0;
1436 enum language funlang
= language_unknown
;
1437 const char *pc_regname
;
1438 struct gdbarch
*gdbarch
;
1441 /* Initialize it to avoid "may be used uninitialized" warning. */
1442 CORE_ADDR caller_pc
= 0;
1443 int caller_pc_p
= 0;
1445 gdbarch
= get_frame_arch (fi
);
1447 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1448 is not a good name. */
1449 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1450 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1451 easily not match that of the internal value returned by
1453 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1455 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1456 architectures will often have a hardware register called "pc",
1457 and that register's value, again, can easily not match
1461 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1462 func
= get_frame_function (fi
);
1463 symtab_and_line sal
= find_frame_sal (fi
);
1465 gdb::unique_xmalloc_ptr
<char> func_only
;
1468 funname
= SYMBOL_PRINT_NAME (func
);
1469 funlang
= SYMBOL_LANGUAGE (func
);
1470 if (funlang
== language_cplus
)
1472 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1473 to display the demangled name that we already have
1474 stored in the symbol table, but we stored a version
1475 with DMGL_PARAMS turned on, and here we don't want to
1476 display parameters. So remove the parameters. */
1477 func_only
= cp_remove_params (funname
);
1480 funname
= func_only
.get ();
1483 else if (frame_pc_p
)
1485 struct bound_minimal_symbol msymbol
;
1487 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1488 if (msymbol
.minsym
!= NULL
)
1490 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1491 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1494 calling_frame_info
= get_prev_frame (fi
);
1496 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1498 printf_filtered (_("Stack level %d, frame at "),
1499 frame_relative_level (fi
));
1503 printf_filtered (_("Stack frame at "));
1505 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1506 printf_filtered (":\n");
1507 printf_filtered (" %s = ", pc_regname
);
1509 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1511 fputs_filtered ("<unavailable>", gdb_stdout
);
1516 printf_filtered (" in ");
1517 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1518 DMGL_ANSI
| DMGL_PARAMS
);
1522 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1524 puts_filtered ("; ");
1526 printf_filtered ("saved %s = ", pc_regname
);
1528 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1529 val_print_not_saved (gdb_stdout
);
1534 caller_pc
= frame_unwind_caller_pc (fi
);
1537 catch (const gdb_exception_error
&ex
)
1541 case NOT_AVAILABLE_ERROR
:
1542 val_print_unavailable (gdb_stdout
);
1544 case OPTIMIZED_OUT_ERROR
:
1545 val_print_not_saved (gdb_stdout
);
1548 fprintf_filtered (gdb_stdout
, _("<error: %s>"),
1556 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1557 printf_filtered ("\n");
1559 if (calling_frame_info
== NULL
)
1561 enum unwind_stop_reason reason
;
1563 reason
= get_frame_unwind_stop_reason (fi
);
1564 if (reason
!= UNWIND_NO_REASON
)
1565 printf_filtered (_(" Outermost frame: %s\n"),
1566 frame_stop_reason_string (fi
));
1568 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1569 puts_filtered (" tail call frame");
1570 else if (get_frame_type (fi
) == INLINE_FRAME
)
1571 printf_filtered (" inlined into frame %d",
1572 frame_relative_level (get_prev_frame (fi
)));
1575 printf_filtered (" called by frame at ");
1576 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1579 if (get_next_frame (fi
) && calling_frame_info
)
1580 puts_filtered (",");
1582 if (get_next_frame (fi
))
1584 printf_filtered (" caller of frame at ");
1585 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1588 if (get_next_frame (fi
) || calling_frame_info
)
1589 puts_filtered ("\n");
1592 printf_filtered (" source language %s.\n",
1593 language_str (s
->language
));
1596 /* Address of the argument list for this frame, or 0. */
1597 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1598 /* Number of args for this frame, or -1 if unknown. */
1602 printf_filtered (" Arglist at unknown address.\n");
1605 printf_filtered (" Arglist at ");
1606 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1607 printf_filtered (",");
1609 if (!gdbarch_frame_num_args_p (gdbarch
))
1612 puts_filtered (" args: ");
1616 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1617 gdb_assert (numargs
>= 0);
1619 puts_filtered (" no args.");
1620 else if (numargs
== 1)
1621 puts_filtered (" 1 arg: ");
1623 printf_filtered (" %d args: ", numargs
);
1625 print_frame_args (user_frame_print_options
,
1626 func
, fi
, numargs
, gdb_stdout
);
1627 puts_filtered ("\n");
1631 /* Address of the local variables for this frame, or 0. */
1632 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1635 printf_filtered (" Locals at unknown address,");
1638 printf_filtered (" Locals at ");
1639 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1640 printf_filtered (",");
1644 /* Print as much information as possible on the location of all the
1650 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1652 /* The sp is special; what's displayed isn't the save address, but
1653 the value of the previous frame's sp. This is a legacy thing,
1654 at one stage the frame cached the previous frame's SP instead
1655 of its address, hence it was easiest to just display the cached
1659 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1660 gdb_assert (value
!= NULL
);
1662 if (!value_optimized_out (value
) && value_entirely_available (value
))
1664 if (VALUE_LVAL (value
) == not_lval
)
1667 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1668 int sp_size
= register_size (gdbarch
, sp_regnum
);
1670 sp
= extract_unsigned_integer (value_contents_all (value
),
1671 sp_size
, byte_order
);
1673 printf_filtered (" Previous frame's sp is ");
1674 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1675 printf_filtered ("\n");
1677 else if (VALUE_LVAL (value
) == lval_memory
)
1679 printf_filtered (" Previous frame's sp at ");
1680 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1682 printf_filtered ("\n");
1684 else if (VALUE_LVAL (value
) == lval_register
)
1686 printf_filtered (" Previous frame's sp in %s\n",
1687 gdbarch_register_name (gdbarch
,
1688 VALUE_REGNUM (value
)));
1691 release_value (value
);
1694 /* else keep quiet. */
1698 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1699 for (i
= 0; i
< numregs
; i
++)
1701 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1703 enum lval_type lval
;
1709 /* Find out the location of the saved register without
1710 fetching the corresponding value. */
1711 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1712 &lval
, &addr
, &realnum
, NULL
);
1713 /* For moment, only display registers that were saved on the
1715 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1718 puts_filtered (" Saved registers:\n ");
1720 puts_filtered (",");
1722 printf_filtered (" %s at ",
1723 gdbarch_register_name (gdbarch
, i
));
1724 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1728 if (count
|| need_nl
)
1729 puts_filtered ("\n");
1733 /* Return the innermost frame at level LEVEL. */
1735 static struct frame_info
*
1736 leading_innermost_frame (int level
)
1738 struct frame_info
*leading
;
1740 leading
= get_current_frame ();
1742 gdb_assert (level
>= 0);
1744 while (leading
!= nullptr && level
)
1747 leading
= get_prev_frame (leading
);
1754 /* Return the starting frame needed to handle COUNT outermost frames. */
1756 static struct frame_info
*
1757 trailing_outermost_frame (int count
)
1759 struct frame_info
*current
;
1760 struct frame_info
*trailing
;
1762 trailing
= get_current_frame ();
1764 gdb_assert (count
> 0);
1767 while (current
!= nullptr && count
--)
1770 current
= get_prev_frame (current
);
1773 /* Will stop when CURRENT reaches the top of the stack.
1774 TRAILING will be COUNT below it. */
1775 while (current
!= nullptr)
1778 trailing
= get_prev_frame (trailing
);
1779 current
= get_prev_frame (current
);
1785 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1789 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1791 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1793 if (get_selected_frame_if_set () != prev_frame
)
1794 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1800 select_frame_for_mi (struct frame_info
*fi
)
1802 select_frame_command_core (fi
, false /* Ignored. */);
1805 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1806 means we change frame send out a change notification (otherwise, just
1807 reprint the current frame summary). */
1810 frame_command_core (struct frame_info
*fi
, bool ignored
)
1812 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1815 if (get_selected_frame_if_set () != prev_frame
)
1816 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1818 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1821 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1822 common set of sub-commands that allow a specific frame to be selected.
1823 All of the sub-command functions are static methods within this class
1824 template which is then instantiated below. The template parameter is a
1825 callback used to implement the functionality of the base command
1826 ('frame', 'select-frame', or 'info frame').
1828 In the template parameter FI is the frame being selected. The
1829 SELECTED_FRAME_P flag is true if the frame being selected was done by
1830 default, which happens when the user uses the base command with no
1831 arguments. For example the commands 'info frame', 'select-frame',
1832 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1833 SELECTED_FRAME_P is false. */
1835 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1836 class frame_command_helper
1840 /* The "frame level" family of commands. The ARG is an integer that is
1841 the frame's level in the stack. */
1843 level (const char *arg
, int from_tty
)
1845 int level
= value_as_long (parse_and_eval (arg
));
1846 struct frame_info
*fid
1847 = find_relative_frame (get_current_frame (), &level
);
1849 error (_("No frame at level %s."), arg
);
1853 /* The "frame address" family of commands. ARG is a stack-pointer
1854 address for an existing frame. This command does not allow new
1855 frames to be created. */
1858 address (const char *arg
, int from_tty
)
1860 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1861 struct frame_info
*fid
= find_frame_for_address (addr
);
1863 error (_("No frame at address %s."), arg
);
1867 /* The "frame view" family of commands. ARG is one or two addresses and
1868 is used to view a frame that might be outside the current backtrace.
1869 The addresses are stack-pointer address, and (optional) pc-address. */
1872 view (const char *args
, int from_tty
)
1874 struct frame_info
*fid
;
1877 error (_("Missing address argument to view a frame"));
1879 gdb_argv
argv (args
);
1881 if (argv
.count () == 2)
1885 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1886 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1887 fid
= create_new_frame (addr
[0], addr
[1]);
1891 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1892 fid
= create_new_frame (addr
, false);
1897 /* The "frame function" family of commands. ARG is the name of a
1898 function within the stack, the first function (searching from frame
1899 0) with that name will be selected. */
1902 function (const char *arg
, int from_tty
)
1905 error (_("Missing function name argument"));
1906 struct frame_info
*fid
= find_frame_for_function (arg
);
1908 error (_("No frame for function \"%s\"."), arg
);
1912 /* The "frame" base command, that is, when no sub-command is specified.
1913 If one argument is provided then we assume that this is a frame's
1914 level as historically, this was the supported command syntax that was
1917 If no argument is provided, then the current frame is selected. */
1920 base_command (const char *arg
, int from_tty
)
1923 FPTR (get_selected_frame (_("No stack.")), true);
1925 level (arg
, from_tty
);
1929 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1930 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1932 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1933 static frame_command_helper
<frame_command_core
> frame_cmd
;
1934 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1936 /* Print briefly all stack frames or just the innermost COUNT_EXP
1940 backtrace_command_1 (const frame_print_options
&fp_opts
,
1941 const backtrace_cmd_options
&bt_opts
,
1942 const char *count_exp
, int from_tty
)
1945 struct frame_info
*fi
;
1947 int py_start
= 0, py_end
= 0;
1948 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1950 if (!target_has_stack
)
1951 error (_("No stack."));
1955 count
= parse_and_eval_long (count_exp
);
1961 /* The argument to apply_ext_lang_frame_filter is the number
1962 of the final frame to print, and frames start at 0. */
1972 frame_filter_flags flags
= 0;
1975 flags
|= PRINT_LOCALS
;
1977 flags
|= PRINT_HIDE
;
1979 if (!bt_opts
.no_filters
)
1981 enum ext_lang_frame_args arg_type
;
1983 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1985 flags
|= PRINT_MORE_FRAMES
;
1987 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
1988 arg_type
= CLI_SCALAR_VALUES
;
1989 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
1990 arg_type
= CLI_ALL_VALUES
;
1991 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_presence
)
1992 arg_type
= CLI_PRESENCE
;
1993 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_none
)
1994 arg_type
= NO_VALUES
;
1998 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1999 arg_type
, current_uiout
,
2003 /* Run the inbuilt backtrace if there are no filters registered, or
2004 "-no-filters" has been specified from the command. */
2005 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
2007 struct frame_info
*trailing
;
2009 /* The following code must do two things. First, it must set the
2010 variable TRAILING to the frame from which we should start
2011 printing. Second, it must set the variable count to the number
2012 of frames which we should print, or -1 if all of them. */
2014 if (count_exp
!= NULL
&& count
< 0)
2016 trailing
= trailing_outermost_frame (-count
);
2020 trailing
= get_current_frame ();
2022 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2026 /* Don't use print_stack_frame; if an error() occurs it probably
2027 means further attempts to backtrace would fail (on the other
2028 hand, perhaps the code does or could be fixed to make sure
2029 the frame->prev field gets set to NULL in that case). */
2031 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
2032 if ((flags
& PRINT_LOCALS
) != 0)
2034 struct frame_id frame_id
= get_frame_id (fi
);
2036 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
2038 /* print_frame_local_vars invalidates FI. */
2039 fi
= frame_find_by_id (frame_id
);
2043 warning (_("Unable to restore previously selected frame."));
2048 /* Save the last frame to check for error conditions. */
2052 /* If we've stopped before the end, mention that. */
2054 printf_filtered (_("(More stack frames follow...)\n"));
2056 /* If we've run out of frames, and the reason appears to be an error
2057 condition, print it. */
2058 if (fi
== NULL
&& trailing
!= NULL
)
2060 enum unwind_stop_reason reason
;
2062 reason
= get_frame_unwind_stop_reason (trailing
);
2063 if (reason
>= UNWIND_FIRST_ERROR
)
2064 printf_filtered (_("Backtrace stopped: %s\n"),
2065 frame_stop_reason_string (trailing
));
2070 /* Create an option_def_group array grouping all the "backtrace"
2071 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2073 static inline std::array
<gdb::option::option_def_group
, 3>
2074 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2075 backtrace_cmd_options
*bt_cmd_opts
,
2076 set_backtrace_options
*set_bt_opts
)
2079 { {frame_print_option_defs
}, fp_opts
},
2080 { {set_backtrace_option_defs
}, set_bt_opts
},
2081 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2085 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2086 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2087 store the parsed qualifiers. */
2090 parse_backtrace_qualifiers (const char *arg
,
2091 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2095 const char *save_arg
= arg
;
2096 std::string this_arg
= extract_arg (&arg
);
2098 if (this_arg
.empty ())
2101 if (subset_compare (this_arg
.c_str (), "no-filters"))
2103 if (bt_cmd_opts
!= nullptr)
2104 bt_cmd_opts
->no_filters
= true;
2106 else if (subset_compare (this_arg
.c_str (), "full"))
2108 if (bt_cmd_opts
!= nullptr)
2109 bt_cmd_opts
->full
= true;
2111 else if (subset_compare (this_arg
.c_str (), "hide"))
2113 if (bt_cmd_opts
!= nullptr)
2114 bt_cmd_opts
->hide
= true;
2118 /* Not a recognized qualifier, so stop. */
2125 backtrace_command (const char *arg
, int from_tty
)
2127 frame_print_options fp_opts
= user_frame_print_options
;
2128 backtrace_cmd_options bt_cmd_opts
;
2129 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2132 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2133 gdb::option::process_options
2134 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2136 /* Parse non-'-'-prefixed qualifiers, for backwards
2140 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2145 /* These options are handled quite deep in the unwind machinery, so
2146 we get to pass them down by swapping globals. */
2147 scoped_restore restore_set_backtrace_options
2148 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2150 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2153 /* Completer for the "backtrace" command. */
2156 backtrace_command_completer (struct cmd_list_element
*ignore
,
2157 completion_tracker
&tracker
,
2158 const char *text
, const char */
*word*/
)
2161 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2162 if (gdb::option::complete_options
2163 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2168 const char *p
= skip_to_space (text
);
2171 static const char *const backtrace_cmd_qualifier_choices
[] = {
2172 "full", "no-filters", "hide", nullptr,
2174 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2177 if (tracker
.have_completions ())
2182 const char *cmd
= parse_backtrace_qualifiers (text
);
2183 tracker
.advance_custom_word_point_by (cmd
- text
);
2188 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2189 expression_completer (ignore
, tracker
, text
, word
);
2192 /* Iterate over the local variables of a block B, calling CB with
2196 iterate_over_block_locals (const struct block
*b
,
2197 iterate_over_block_arg_local_vars_cb cb
,
2200 struct block_iterator iter
;
2203 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2205 switch (SYMBOL_CLASS (sym
))
2211 case LOC_OPTIMIZED_OUT
:
2212 if (SYMBOL_IS_ARGUMENT (sym
))
2214 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2216 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
2220 /* Ignore symbols which are not locals. */
2227 /* Same, but print labels. */
2230 /* Commented out, as the code using this function has also been
2231 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2232 was commented out in the first place. The discussion introducing
2233 this change (2007-12-04: Support lexical blocks and function bodies
2234 that occupy non-contiguous address ranges) did not explain why
2235 this change was made. */
2237 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2238 int *have_default
, struct ui_file
*stream
)
2240 struct block_iterator iter
;
2242 int values_printed
= 0;
2244 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2246 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2252 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2254 struct symtab_and_line sal
;
2255 struct value_print_options opts
;
2257 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2259 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2260 get_user_print_options (&opts
);
2261 if (opts
.addressprint
)
2263 fprintf_filtered (stream
, " ");
2264 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2267 fprintf_filtered (stream
, " in file %s, line %d\n",
2268 sal
.symtab
->filename
, sal
.line
);
2272 return values_printed
;
2276 /* Iterate over all the local variables in block B, including all its
2277 superblocks, stopping when the top-level block is reached. */
2280 iterate_over_block_local_vars (const struct block
*block
,
2281 iterate_over_block_arg_local_vars_cb cb
,
2286 iterate_over_block_locals (block
, cb
, cb_data
);
2287 /* After handling the function's top-level block, stop. Don't
2288 continue to its superblock, the block of per-file
2290 if (BLOCK_FUNCTION (block
))
2292 block
= BLOCK_SUPERBLOCK (block
);
2296 /* Data to be passed around in the calls to the locals and args
2299 struct print_variable_and_value_data
2301 gdb::optional
<compiled_regex
> preg
;
2302 gdb::optional
<compiled_regex
> treg
;
2303 struct frame_id frame_id
;
2305 struct ui_file
*stream
;
2309 /* The callback for the locals and args iterators. */
2312 do_print_variable_and_value (const char *print_name
,
2316 struct print_variable_and_value_data
*p
2317 = (struct print_variable_and_value_data
*) cb_data
;
2318 struct frame_info
*frame
;
2320 if (p
->preg
.has_value ()
2321 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2324 if (p
->treg
.has_value ()
2325 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2328 frame
= frame_find_by_id (p
->frame_id
);
2331 warning (_("Unable to restore previously selected frame."));
2335 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2337 /* print_variable_and_value invalidates FRAME. */
2340 p
->values_printed
= 1;
2343 /* Prepares the regular expression REG from REGEXP.
2344 If REGEXP is NULL, it results in an empty regular expression. */
2347 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2351 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2353 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2359 /* Print all variables from the innermost up to the function block of FRAME.
2360 Print them with values to STREAM indented by NUM_TABS.
2361 If REGEXP is not NULL, only print local variables whose name
2363 If T_REGEXP is not NULL, only print local variables whose type
2365 If no local variables have been printed and !QUIET, prints a message
2366 explaining why no local variables could be printed.
2368 This function will invalidate FRAME. */
2371 print_frame_local_vars (struct frame_info
*frame
,
2373 const char *regexp
, const char *t_regexp
,
2374 int num_tabs
, struct ui_file
*stream
)
2376 struct print_variable_and_value_data cb_data
;
2377 const struct block
*block
;
2380 if (!get_frame_pc_if_available (frame
, &pc
))
2383 fprintf_filtered (stream
,
2384 _("PC unavailable, cannot determine locals.\n"));
2388 block
= get_frame_block (frame
, 0);
2392 fprintf_filtered (stream
, "No symbol table info available.\n");
2396 prepare_reg (regexp
, &cb_data
.preg
);
2397 prepare_reg (t_regexp
, &cb_data
.treg
);
2398 cb_data
.frame_id
= get_frame_id (frame
);
2399 cb_data
.num_tabs
= 4 * num_tabs
;
2400 cb_data
.stream
= stream
;
2401 cb_data
.values_printed
= 0;
2403 /* Temporarily change the selected frame to the given FRAME.
2404 This allows routines that rely on the selected frame instead
2405 of being given a frame as parameter to use the correct frame. */
2406 scoped_restore_selected_frame restore_selected_frame
;
2407 select_frame (frame
);
2409 iterate_over_block_local_vars (block
,
2410 do_print_variable_and_value
,
2413 if (!cb_data
.values_printed
&& !quiet
)
2415 if (regexp
== NULL
&& t_regexp
== NULL
)
2416 fprintf_filtered (stream
, _("No locals.\n"));
2418 fprintf_filtered (stream
, _("No matching locals.\n"));
2422 /* Structure to hold the values of the options used by the 'info
2423 variables' command and other similar commands. These correspond to the
2424 -q and -t options. */
2426 struct info_print_options
2429 char *type_regexp
= nullptr;
2431 ~info_print_options ()
2433 xfree (type_regexp
);
2437 /* The options used by the 'info locals' and 'info args' commands. */
2439 static const gdb::option::option_def info_print_options_defs
[] = {
2440 gdb::option::boolean_option_def
<info_print_options
> {
2442 [] (info_print_options
*opt
) { return &opt
->quiet
; },
2443 nullptr, /* show_cmd_cb */
2444 nullptr /* set_doc */
2447 gdb::option::string_option_def
<info_print_options
> {
2449 [] (info_print_options
*opt
) { return &opt
->type_regexp
; },
2450 nullptr, /* show_cmd_cb */
2451 nullptr /* set_doc */
2455 /* Returns the option group used by 'info locals' and 'info args'
2458 static gdb::option::option_def_group
2459 make_info_print_options_def_group (info_print_options
*opts
)
2461 return {{info_print_options_defs
}, opts
};
2464 /* Command completer for 'info locals' and 'info args'. */
2467 info_print_command_completer (struct cmd_list_element
*ignore
,
2468 completion_tracker
&tracker
,
2469 const char *text
, const char * /* word */)
2472 = make_info_print_options_def_group (nullptr);
2473 if (gdb::option::complete_options
2474 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2477 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2478 symbol_completer (ignore
, tracker
, text
, word
);
2481 /* Implement the 'info locals' command. */
2484 info_locals_command (const char *args
, int from_tty
)
2486 info_print_options opts
;
2487 auto grp
= make_info_print_options_def_group (&opts
);
2488 gdb::option::process_options
2489 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2490 if (args
!= nullptr && *args
== '\0')
2493 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2494 opts
.quiet
, args
, opts
.type_regexp
,
2498 /* Iterate over all the argument variables in block B. */
2501 iterate_over_block_arg_vars (const struct block
*b
,
2502 iterate_over_block_arg_local_vars_cb cb
,
2505 struct block_iterator iter
;
2506 struct symbol
*sym
, *sym2
;
2508 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2510 /* Don't worry about things which aren't arguments. */
2511 if (SYMBOL_IS_ARGUMENT (sym
))
2513 /* We have to look up the symbol because arguments can have
2514 two entries (one a parameter, one a local) and the one we
2515 want is the local, which lookup_symbol will find for us.
2516 This includes gcc1 (not gcc2) on the sparc when passing a
2517 small structure and gcc2 when the argument type is float
2518 and it is passed as a double and converted to float by
2519 the prologue (in the latter case the type of the LOC_ARG
2520 symbol is double and the type of the LOC_LOCAL symbol is
2521 float). There are also LOC_ARG/LOC_REGISTER pairs which
2522 are not combined in symbol-reading. */
2524 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2525 b
, VAR_DOMAIN
).symbol
;
2526 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2531 /* Print all argument variables of the function of FRAME.
2532 Print them with values to STREAM.
2533 If REGEXP is not NULL, only print argument variables whose name
2535 If T_REGEXP is not NULL, only print argument variables whose type
2537 If no argument variables have been printed and !QUIET, prints a message
2538 explaining why no argument variables could be printed.
2540 This function will invalidate FRAME. */
2543 print_frame_arg_vars (struct frame_info
*frame
,
2545 const char *regexp
, const char *t_regexp
,
2546 struct ui_file
*stream
)
2548 struct print_variable_and_value_data cb_data
;
2549 struct symbol
*func
;
2551 gdb::optional
<compiled_regex
> preg
;
2552 gdb::optional
<compiled_regex
> treg
;
2554 if (!get_frame_pc_if_available (frame
, &pc
))
2557 fprintf_filtered (stream
,
2558 _("PC unavailable, cannot determine args.\n"));
2562 func
= get_frame_function (frame
);
2566 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2570 prepare_reg (regexp
, &cb_data
.preg
);
2571 prepare_reg (t_regexp
, &cb_data
.treg
);
2572 cb_data
.frame_id
= get_frame_id (frame
);
2573 cb_data
.num_tabs
= 0;
2574 cb_data
.stream
= stream
;
2575 cb_data
.values_printed
= 0;
2577 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2578 do_print_variable_and_value
, &cb_data
);
2580 /* do_print_variable_and_value invalidates FRAME. */
2583 if (!cb_data
.values_printed
&& !quiet
)
2585 if (regexp
== NULL
&& t_regexp
== NULL
)
2586 fprintf_filtered (stream
, _("No arguments.\n"));
2588 fprintf_filtered (stream
, _("No matching arguments.\n"));
2592 /* Implement the 'info args' command. */
2595 info_args_command (const char *args
, int from_tty
)
2597 info_print_options opts
;
2598 auto grp
= make_info_print_options_def_group (&opts
);
2599 gdb::option::process_options
2600 (&args
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2601 if (args
!= nullptr && *args
== '\0')
2604 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2605 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2608 /* Return the symbol-block in which the selected frame is executing.
2609 Can return zero under various legitimate circumstances.
2611 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2612 code address within the block returned. We use this to decide
2613 which macros are in scope. */
2615 const struct block
*
2616 get_selected_block (CORE_ADDR
*addr_in_block
)
2618 if (!has_stack_frames ())
2621 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2624 /* Find a frame a certain number of levels away from FRAME.
2625 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2626 Positive means go to earlier frames (up); negative, the reverse.
2627 The int that contains the number of levels is counted toward
2628 zero as the frames for those levels are found.
2629 If the top or bottom frame is reached, that frame is returned,
2630 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2631 how much farther the original request asked to go. */
2634 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2636 /* Going up is simple: just call get_prev_frame enough times or
2637 until the initial frame is reached. */
2638 while (*level_offset_ptr
> 0)
2640 struct frame_info
*prev
= get_prev_frame (frame
);
2644 (*level_offset_ptr
)--;
2648 /* Going down is just as simple. */
2649 while (*level_offset_ptr
< 0)
2651 struct frame_info
*next
= get_next_frame (frame
);
2655 (*level_offset_ptr
)++;
2662 /* Select the frame up one or COUNT_EXP stack levels from the
2663 previously selected frame, and print it briefly. */
2666 up_silently_base (const char *count_exp
)
2668 struct frame_info
*frame
;
2672 count
= parse_and_eval_long (count_exp
);
2674 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2675 if (count
!= 0 && count_exp
== NULL
)
2676 error (_("Initial frame selected; you cannot go up."));
2677 select_frame (frame
);
2681 up_silently_command (const char *count_exp
, int from_tty
)
2683 up_silently_base (count_exp
);
2687 up_command (const char *count_exp
, int from_tty
)
2689 up_silently_base (count_exp
);
2690 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2693 /* Select the frame down one or COUNT_EXP stack levels from the previously
2694 selected frame, and print it briefly. */
2697 down_silently_base (const char *count_exp
)
2699 struct frame_info
*frame
;
2703 count
= -parse_and_eval_long (count_exp
);
2705 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2706 if (count
!= 0 && count_exp
== NULL
)
2708 /* We only do this if COUNT_EXP is not specified. That way
2709 "down" means to really go down (and let me know if that is
2710 impossible), but "down 9999" can be used to mean go all the
2711 way down without getting an error. */
2713 error (_("Bottom (innermost) frame selected; you cannot go down."));
2716 select_frame (frame
);
2720 down_silently_command (const char *count_exp
, int from_tty
)
2722 down_silently_base (count_exp
);
2726 down_command (const char *count_exp
, int from_tty
)
2728 down_silently_base (count_exp
);
2729 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2733 return_command (const char *retval_exp
, int from_tty
)
2735 /* Initialize it just to avoid a GCC false warning. */
2736 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2737 struct frame_info
*thisframe
;
2738 struct gdbarch
*gdbarch
;
2739 struct symbol
*thisfun
;
2740 struct value
*return_value
= NULL
;
2741 struct value
*function
= NULL
;
2742 const char *query_prefix
= "";
2744 thisframe
= get_selected_frame ("No selected frame.");
2745 thisfun
= get_frame_function (thisframe
);
2746 gdbarch
= get_frame_arch (thisframe
);
2748 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2749 error (_("Can not force return from an inlined function."));
2751 /* Compute the return value. If the computation triggers an error,
2752 let it bail. If the return type can't be handled, set
2753 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2757 expression_up retval_expr
= parse_expression (retval_exp
);
2758 struct type
*return_type
= NULL
;
2760 /* Compute the return value. Should the computation fail, this
2761 call throws an error. */
2762 return_value
= evaluate_expression (retval_expr
.get ());
2764 /* Cast return value to the return type of the function. Should
2765 the cast fail, this call throws an error. */
2766 if (thisfun
!= NULL
)
2767 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2768 if (return_type
== NULL
)
2770 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2771 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2772 error (_("Return value type not available for selected "
2774 "Please use an explicit cast of the value to return."));
2775 return_type
= value_type (return_value
);
2777 return_type
= check_typedef (return_type
);
2778 return_value
= value_cast (return_type
, return_value
);
2780 /* Make sure the value is fully evaluated. It may live in the
2781 stack frame we're about to pop. */
2782 if (value_lazy (return_value
))
2783 value_fetch_lazy (return_value
);
2785 if (thisfun
!= NULL
)
2786 function
= read_var_value (thisfun
, NULL
, thisframe
);
2788 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2789 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2790 /* If the return-type is "void", don't try to find the
2791 return-value's location. However, do still evaluate the
2792 return expression so that, even when the expression result
2793 is discarded, side effects such as "return i++" still
2795 return_value
= NULL
;
2796 else if (thisfun
!= NULL
)
2798 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2799 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2800 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2802 query_prefix
= "The location at which to store the "
2803 "function's return value is unknown.\n"
2804 "If you continue, the return value "
2805 "that you specified will be ignored.\n";
2806 return_value
= NULL
;
2811 /* Does an interactive user really want to do this? Include
2812 information, such as how well GDB can handle the return value, in
2813 the query message. */
2818 if (thisfun
== NULL
)
2819 confirmed
= query (_("%sMake selected stack frame return now? "),
2823 if (TYPE_NO_RETURN (thisfun
->type
))
2824 warning (_("Function does not return normally to caller."));
2825 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2826 SYMBOL_PRINT_NAME (thisfun
));
2829 error (_("Not confirmed"));
2832 /* Discard the selected frame and all frames inner-to it. */
2833 frame_pop (get_selected_frame (NULL
));
2835 /* Store RETURN_VALUE in the just-returned register set. */
2836 if (return_value
!= NULL
)
2838 struct type
*return_type
= value_type (return_value
);
2839 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2841 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2842 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2843 gdbarch_return_value (cache_arch
, function
, return_type
,
2844 get_current_regcache (), NULL
/*read*/,
2845 value_contents (return_value
) /*write*/);
2848 /* If we are at the end of a call dummy now, pop the dummy frame
2850 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2851 frame_pop (get_current_frame ());
2853 select_frame (get_current_frame ());
2854 /* If interactive, print the frame that is now current. */
2856 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2859 /* Find the most inner frame in the current stack for a function called
2860 FUNCTION_NAME. If no matching frame is found return NULL. */
2862 static struct frame_info
*
2863 find_frame_for_function (const char *function_name
)
2865 /* Used to hold the lower and upper addresses for each of the
2866 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2867 struct function_bounds
2869 CORE_ADDR low
, high
;
2871 struct frame_info
*frame
;
2875 gdb_assert (function_name
!= NULL
);
2877 frame
= get_current_frame ();
2878 std::vector
<symtab_and_line
> sals
2879 = decode_line_with_current_source (function_name
,
2880 DECODE_LINE_FUNFIRSTLINE
);
2881 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2882 for (size_t i
= 0; i
< sals
.size (); i
++)
2884 if (sals
[i
].pspace
!= current_program_space
)
2885 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2886 else if (sals
[i
].pc
== 0
2887 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2888 &func_bounds
[i
].low
,
2889 &func_bounds
[i
].high
) == 0)
2890 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2895 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2896 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2897 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2901 frame
= find_relative_frame (frame
, &level
);
2904 while (!found
&& level
== 0);
2912 /* Implements the dbx 'func' command. */
2915 func_command (const char *arg
, int from_tty
)
2920 struct frame_info
*frame
= find_frame_for_function (arg
);
2922 error (_("'%s' not within current stack frame."), arg
);
2923 if (frame
!= get_selected_frame (NULL
))
2925 select_frame (frame
);
2926 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2930 /* The qcs command line flags for the "frame apply" commands. Keep
2931 this in sync with the "thread apply" commands. */
2933 using qcs_flag_option_def
2934 = gdb::option::flag_option_def
<qcs_flags
>;
2936 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2937 qcs_flag_option_def
{
2938 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2939 N_("Disables printing the frame location information."),
2942 qcs_flag_option_def
{
2943 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2944 N_("Print any error raised by COMMAND and continue."),
2947 qcs_flag_option_def
{
2948 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2949 N_("Silently ignore any errors or empty output produced by COMMAND."),
2953 /* Create an option_def_group array for all the "frame apply" options,
2954 with FLAGS and SET_BT_OPTS as context. */
2956 static inline std::array
<gdb::option::option_def_group
, 2>
2957 make_frame_apply_options_def_group (qcs_flags
*flags
,
2958 set_backtrace_options
*set_bt_opts
)
2961 { {fr_qcs_flags_option_defs
}, flags
},
2962 { {set_backtrace_option_defs
}, set_bt_opts
},
2966 /* Apply a GDB command to all stack frames, or a set of identified frames,
2967 or innermost COUNT frames.
2968 With a negative COUNT, apply command on outermost -COUNT frames.
2970 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2971 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2972 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2973 frame apply all -s p local_var_no_idea_in_which_frame
2974 If a frame has a local variable called
2975 local_var_no_idea_in_which_frame, print frame
2976 and value of local_var_no_idea_in_which_frame.
2977 frame apply all -s -q p local_var_no_idea_in_which_frame
2978 Same as before, but only print the variable value.
2979 frame apply level 2-5 0 4-7 -s p i = i + 1
2980 Adds 1 to the variable i in the specified frames.
2981 Note that i will be incremented twice in
2984 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2985 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2986 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2987 for error messages. */
2990 frame_apply_command_count (const char *which_command
,
2991 const char *cmd
, int from_tty
,
2992 struct frame_info
*trailing
, int count
)
2995 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2997 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2998 gdb::option::process_options
2999 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
3001 validate_flags_qcs (which_command
, &flags
);
3003 if (cmd
== NULL
|| *cmd
== '\0')
3004 error (_("Please specify a command to apply on the selected frames"));
3006 /* The below will restore the current inferior/thread/frame.
3007 Usually, only the frame is effectively to be restored.
3008 But in case CMD switches of inferior/thread, better restore
3010 scoped_restore_current_thread restore_thread
;
3012 /* These options are handled quite deep in the unwind machinery, so
3013 we get to pass them down by swapping globals. */
3014 scoped_restore restore_set_backtrace_options
3015 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
3017 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
3024 std::string cmd_result
;
3026 /* In case CMD switches of inferior/thread/frame, the below
3027 restores the inferior/thread/frame. FI can then be
3028 set to the selected frame. */
3029 scoped_restore_current_thread restore_fi_current_frame
;
3031 cmd_result
= execute_command_to_string
3032 (cmd
, from_tty
, gdb_stdout
->term_out ());
3034 fi
= get_selected_frame (_("frame apply "
3035 "unable to get selected frame."));
3036 if (!flags
.silent
|| cmd_result
.length () > 0)
3039 print_stack_frame (fi
, 1, LOCATION
, 0);
3040 printf_filtered ("%s", cmd_result
.c_str ());
3043 catch (const gdb_exception_error
&ex
)
3045 fi
= get_selected_frame (_("frame apply "
3046 "unable to get selected frame."));
3050 print_stack_frame (fi
, 1, LOCATION
, 0);
3052 printf_filtered ("%s\n", ex
.what ());
3060 /* Completer for the "frame apply ..." commands. */
3063 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
3065 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
3066 if (gdb::option::complete_options
3067 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
3070 complete_nested_command_line (tracker
, text
);
3073 /* Completer for the "frame apply" commands. */
3076 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
3077 completion_tracker
&tracker
,
3078 const char *text
, const char */
*word*/
)
3080 /* Do this explicitly because there's an early return below. */
3081 tracker
.set_use_custom_word_point (true);
3083 number_or_range_parser
levels (text
);
3085 /* Skip the LEVEL list to find the options and command args. */
3088 while (!levels
.finished ())
3090 /* Call for effect. */
3091 levels
.get_number ();
3093 if (levels
.in_range ())
3094 levels
.skip_range ();
3097 catch (const gdb_exception_error
&ex
)
3099 /* get_number throws if it parses a negative number, for
3100 example. But a seemingly negative number may be the start of
3101 an option instead. */
3104 const char *cmd
= levels
.cur_tok ();
3108 /* No level list yet. */
3112 /* Check if we're past a valid LEVEL already. */
3113 if (levels
.finished ()
3114 && cmd
> text
&& !isspace (cmd
[-1]))
3117 /* We're past LEVELs, advance word point. */
3118 tracker
.advance_custom_word_point_by (cmd
- text
);
3121 frame_apply_completer (tracker
, text
);
3124 /* Completer for the "frame apply all" command. */
3127 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3128 completion_tracker
&tracker
,
3129 const char *text
, const char */
*word*/
)
3131 frame_apply_completer (tracker
, text
);
3134 /* Completer for the "frame apply COUNT" command. */
3137 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3138 completion_tracker
&tracker
,
3139 const char *text
, const char */
*word*/
)
3141 const char *cmd
= text
;
3143 int count
= get_number_trailer (&cmd
, 0);
3147 /* Check if we're past a valid COUNT already. */
3148 if (cmd
> text
&& !isspace (cmd
[-1]))
3151 /* We're past COUNT, advance word point. */
3152 tracker
.advance_custom_word_point_by (cmd
- text
);
3155 frame_apply_completer (tracker
, text
);
3158 /* Implementation of the "frame apply level" command. */
3161 frame_apply_level_command (const char *cmd
, int from_tty
)
3163 if (!target_has_stack
)
3164 error (_("No stack."));
3166 bool level_found
= false;
3167 const char *levels_str
= cmd
;
3168 number_or_range_parser
levels (levels_str
);
3170 /* Skip the LEVEL list to find the flags and command args. */
3171 while (!levels
.finished ())
3173 /* Call for effect. */
3174 levels
.get_number ();
3177 if (levels
.in_range ())
3178 levels
.skip_range ();
3182 error (_("Missing or invalid LEVEL... argument"));
3184 cmd
= levels
.cur_tok ();
3186 /* Redo the LEVELS parsing, but applying COMMAND. */
3187 levels
.init (levels_str
);
3188 while (!levels
.finished ())
3190 const int level_beg
= levels
.get_number ();
3193 if (levels
.in_range ())
3195 n_frames
= levels
.end_value () - level_beg
+ 1;
3196 levels
.skip_range ();
3201 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3202 leading_innermost_frame (level_beg
), n_frames
);
3206 /* Implementation of the "frame apply all" command. */
3209 frame_apply_all_command (const char *cmd
, int from_tty
)
3211 if (!target_has_stack
)
3212 error (_("No stack."));
3214 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3215 get_current_frame (), INT_MAX
);
3218 /* Implementation of the "frame apply" command. */
3221 frame_apply_command (const char* cmd
, int from_tty
)
3224 struct frame_info
*trailing
;
3226 if (!target_has_stack
)
3227 error (_("No stack."));
3230 error (_("Missing COUNT argument."));
3231 count
= get_number_trailer (&cmd
, 0);
3233 error (_("Invalid COUNT argument."));
3237 trailing
= trailing_outermost_frame (-count
);
3241 trailing
= get_current_frame ();
3243 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3247 /* Implementation of the "faas" command. */
3250 faas_command (const char *cmd
, int from_tty
)
3252 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3253 execute_command (expanded
.c_str (), from_tty
);
3257 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3258 matching frame can be found. */
3260 static struct frame_info
*
3261 find_frame_for_address (CORE_ADDR address
)
3264 struct frame_info
*fid
;
3266 id
= frame_id_build_wild (address
);
3268 /* If (s)he specifies the frame with an address, he deserves
3269 what (s)he gets. Still, give the highest one that matches.
3270 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3272 for (fid
= get_current_frame ();
3274 fid
= get_prev_frame (fid
))
3276 if (frame_id_eq (id
, get_frame_id (fid
)))
3278 struct frame_info
*prev_frame
;
3282 prev_frame
= get_prev_frame (fid
);
3284 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3296 /* Commands with a prefix of `frame apply'. */
3297 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3299 /* Commands with a prefix of `frame'. */
3300 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3302 /* Commands with a prefix of `select frame'. */
3303 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3305 /* Commands with a prefix of `info frame'. */
3306 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3309 _initialize_stack (void)
3311 struct cmd_list_element
*cmd
;
3313 add_com ("return", class_stack
, return_command
, _("\
3314 Make selected stack frame return to its caller.\n\
3315 Control remains in the debugger, but when you continue\n\
3316 execution will resume in the frame above the one now selected.\n\
3317 If an argument is given, it is an expression for the value to return."));
3319 add_com ("up", class_stack
, up_command
, _("\
3320 Select and print stack frame that called this one.\n\
3321 An argument says how many frames up to go."));
3322 add_com ("up-silently", class_support
, up_silently_command
, _("\
3323 Same as the `up' command, but does not print anything.\n\
3324 This is useful in command scripts."));
3326 add_com ("down", class_stack
, down_command
, _("\
3327 Select and print stack frame called by this one.\n\
3328 An argument says how many frames down to go."));
3329 add_com_alias ("do", "down", class_stack
, 1);
3330 add_com_alias ("dow", "down", class_stack
, 1);
3331 add_com ("down-silently", class_support
, down_silently_command
, _("\
3332 Same as the `down' command, but does not print anything.\n\
3333 This is useful in command scripts."));
3335 add_prefix_cmd ("frame", class_stack
,
3336 &frame_cmd
.base_command
, _("\
3337 Select and print a stack frame.\n\
3338 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3339 A single numerical argument specifies the frame to select."),
3340 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3342 add_com_alias ("f", "frame", class_stack
, 1);
3344 #define FRAME_APPLY_OPTION_HELP "\
3345 Prints the frame location information followed by COMMAND output.\n\
3347 By default, an error raised during the execution of COMMAND\n\
3348 aborts \"frame apply\".\n\
3353 const auto frame_apply_opts
3354 = make_frame_apply_options_def_group (nullptr, nullptr);
3356 static std::string frame_apply_cmd_help
= gdb::option::build_help (_("\
3357 Apply a command to a number of frames.\n\
3358 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3359 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3360 FRAME_APPLY_OPTION_HELP
),
3363 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3364 frame_apply_cmd_help
.c_str (),
3365 &frame_apply_cmd_list
, "frame apply ", 1,
3367 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3369 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (_("\
3370 Apply a command to all frames.\n\
3372 Usage: frame apply all [OPTION]... COMMAND\n"
3373 FRAME_APPLY_OPTION_HELP
),
3376 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3377 frame_apply_all_cmd_help
.c_str (),
3378 &frame_apply_cmd_list
);
3379 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3381 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (_("\
3382 Apply a command to a list of frames.\n\
3384 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3385 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3386 FRAME_APPLY_OPTION_HELP
),
3389 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3390 frame_apply_level_cmd_help
.c_str (),
3391 &frame_apply_cmd_list
);
3392 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3394 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3395 Apply a command to all frames (ignoring errors and empty output).\n\
3396 Usage: faas [OPTION]... COMMAND\n\
3397 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3398 See \"help frame apply all\" for available options."));
3399 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3401 add_prefix_cmd ("frame", class_stack
,
3402 &frame_cmd
.base_command
, _("\
3403 Select and print a stack frame.\n\
3404 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3405 A single numerical argument specifies the frame to select."),
3406 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3407 add_com_alias ("f", "frame", class_stack
, 1);
3409 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3411 Select and print a stack frame by stack address.\n\
3413 Usage: frame address STACK-ADDRESS"),
3416 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3418 View a stack frame that might be outside the current backtrace.\n\
3420 Usage: frame view STACK-ADDRESS\n\
3421 frame view STACK-ADDRESS PC-ADDRESS"),
3424 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3426 Select and print a stack frame by function name.\n\
3428 Usage: frame function NAME\n\
3430 The innermost frame that visited function NAME is selected."),
3432 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3435 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3437 Select and print a stack frame by level.\n\
3439 Usage: frame level LEVEL"),
3442 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3443 &select_frame_cmd
.base_command
, _("\
3444 Select a stack frame without printing anything.\n\
3445 A single numerical argument specifies the frame to select."),
3446 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3447 &cli_suppress_notification
.user_selected_context
);
3449 add_cmd_suppress_notification ("address", class_stack
,
3450 &select_frame_cmd
.address
, _("\
3451 Select a stack frame by stack address.\n\
3453 Usage: select-frame address STACK-ADDRESS"),
3454 &select_frame_cmd_list
,
3455 &cli_suppress_notification
.user_selected_context
);
3458 add_cmd_suppress_notification ("view", class_stack
,
3459 &select_frame_cmd
.view
, _("\
3460 Select a stack frame that might be outside the current backtrace.\n\
3462 Usage: select-frame view STACK-ADDRESS\n\
3463 select-frame view STACK-ADDRESS PC-ADDRESS"),
3464 &select_frame_cmd_list
,
3465 &cli_suppress_notification
.user_selected_context
);
3467 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3468 &select_frame_cmd
.function
, _("\
3469 Select a stack frame by function name.\n\
3471 Usage: select-frame function NAME"),
3472 &select_frame_cmd_list
,
3473 &cli_suppress_notification
.user_selected_context
);
3474 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3476 add_cmd_suppress_notification ("level", class_stack
,
3477 &select_frame_cmd
.level
, _("\
3478 Select a stack frame by level.\n\
3480 Usage: select-frame level LEVEL"),
3481 &select_frame_cmd_list
,
3482 &cli_suppress_notification
.user_selected_context
);
3484 const auto backtrace_opts
3485 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3487 static std::string backtrace_help
3488 = gdb::option::build_help (_("\
3489 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3490 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3495 For backward compatibility, the following qualifiers are supported:\n\
3497 full - same as -full option.\n\
3498 no-filters - same as -no-filters option.\n\
3499 hide - same as -hide.\n\
3501 With a negative COUNT, print outermost -COUNT frames."),
3504 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3506 backtrace_help
.c_str ());
3507 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3509 add_com_alias ("bt", "backtrace", class_stack
, 0);
3511 add_com_alias ("where", "backtrace", class_alias
, 0);
3512 add_info ("stack", backtrace_command
,
3513 _("Backtrace of the stack, or innermost COUNT frames."));
3514 add_info_alias ("s", "stack", 1);
3516 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3517 _("All about the selected stack frame.\n\
3518 With no arguments, displays information about the currently selected stack\n\
3519 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3520 the information is then printed about the specified frame."),
3521 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3522 add_info_alias ("f", "frame", 1);
3524 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3526 Print information about a stack frame selected by stack address.\n\
3528 Usage: info frame address STACK-ADDRESS"),
3529 &info_frame_cmd_list
);
3531 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3533 Print information about a stack frame outside the current backtrace.\n\
3535 Usage: info frame view STACK-ADDRESS\n\
3536 info frame view STACK-ADDRESS PC-ADDRESS"),
3537 &info_frame_cmd_list
);
3539 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3541 Print information about a stack frame selected by function name.\n\
3543 Usage: info frame function NAME"),
3544 &info_frame_cmd_list
);
3545 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3547 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3549 Print information about a stack frame selected by level.\n\
3551 Usage: info frame level LEVEL"),
3552 &info_frame_cmd_list
);
3554 cmd
= add_info ("locals", info_locals_command
,
3555 info_print_args_help (_("\
3556 All local variables of current stack frame or those matching REGEXPs.\n\
3557 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3558 Prints the local variables of the current stack frame.\n"),
3559 _("local variables"),
3561 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3562 cmd
= add_info ("args", info_args_command
,
3563 info_print_args_help (_("\
3564 All argument variables of current stack frame or those matching REGEXPs.\n\
3565 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3566 Prints the argument variables of the current stack frame.\n"),
3567 _("argument variables"),
3569 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3572 add_com ("func", class_stack
, func_command
, _("\
3573 Select the stack frame that contains NAME.\n\
3574 Usage: func NAME"));
3576 /* Install "set print raw frame-arguments", a deprecated spelling of
3577 "set print raw-frame-arguments". */
3578 cmd
= add_setshow_boolean_cmd
3579 ("frame-arguments", no_class
,
3580 &user_frame_print_options
.print_raw_frame_arguments
,
3582 Set whether to print frame arguments in raw form."), _("\
3583 Show whether to print frame arguments in raw form."), _("\
3584 If set, frame arguments are printed in raw form, bypassing any\n\
3585 pretty-printers for that value."),
3587 &setprintrawlist
, &showprintrawlist
);
3588 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3590 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3591 &disassemble_next_line
, _("\
3592 Set whether to disassemble next source line or insn when execution stops."),
3594 Show whether to disassemble next source line or insn when execution stops."),
3596 If ON, GDB will display disassembly of the next source line, in addition\n\
3597 to displaying the source line itself. If the next source line cannot\n\
3598 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3599 will display disassembly of next instruction instead of showing the\n\
3601 If AUTO, display disassembly of next instruction only if the source line\n\
3602 cannot be displayed.\n\
3603 If OFF (which is the default), never display the disassembly of the next\n\
3606 show_disassemble_next_line
,
3607 &setlist
, &showlist
);
3608 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3610 gdb::option::add_setshow_cmds_for_options
3611 (class_stack
, &user_frame_print_options
,
3612 frame_print_option_defs
, &setprintlist
, &showprintlist
);