1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
53 #include "extension.h"
54 #include "observable.h"
55 #include "gdbsupport/def-vector.h"
56 #include "cli/cli-option.h"
58 /* The possible choices of "set print frame-arguments", and the value
61 const char print_frame_arguments_all
[] = "all";
62 const char print_frame_arguments_scalars
[] = "scalars";
63 const char print_frame_arguments_none
[] = "none";
65 static const char *const print_frame_arguments_choices
[] =
67 print_frame_arguments_all
,
68 print_frame_arguments_scalars
,
69 print_frame_arguments_none
,
73 /* The possible choices of "set print entry-values", and the value
76 const char print_entry_values_no
[] = "no";
77 const char print_entry_values_only
[] = "only";
78 const char print_entry_values_preferred
[] = "preferred";
79 const char print_entry_values_if_needed
[] = "if-needed";
80 const char print_entry_values_both
[] = "both";
81 const char print_entry_values_compact
[] = "compact";
82 const char print_entry_values_default
[] = "default";
83 static const char *const print_entry_values_choices
[] =
85 print_entry_values_no
,
86 print_entry_values_only
,
87 print_entry_values_preferred
,
88 print_entry_values_if_needed
,
89 print_entry_values_both
,
90 print_entry_values_compact
,
91 print_entry_values_default
,
96 frame_print_options user_frame_print_options
;
98 /* Option definitions for some frame-related "set print ..."
101 using boolean_option_def
102 = gdb::option::boolean_option_def
<frame_print_options
>;
103 using enum_option_def
104 = gdb::option::enum_option_def
<frame_print_options
>;
106 static const gdb::option::option_def frame_print_option_defs
[] = {
110 print_entry_values_choices
,
111 [] (frame_print_options
*opt
) { return &opt
->print_entry_values
; },
112 NULL
, /* show_cmd_cb */
113 N_("Set printing of function arguments at function entry"),
114 N_("Show printing of function arguments at function entry"),
115 N_("GDB can sometimes determine the values of function arguments at entry,\n\
116 in addition to their current values. This option tells GDB whether\n\
117 to print the current value, the value at entry (marked as val@entry),\n\
118 or both. Note that one or both of these values may be <optimized out>."),
123 print_frame_arguments_choices
,
124 [] (frame_print_options
*opt
) { return &opt
->print_frame_arguments
; },
125 NULL
, /* show_cmd_cb */
126 N_("Set printing of non-scalar frame arguments"),
127 N_("Show printing of non-scalar frame arguments"),
132 "raw-frame-arguments",
133 [] (frame_print_options
*opt
) { return &opt
->print_raw_frame_arguments
; },
134 NULL
, /* show_cmd_cb */
135 N_("Set whether to print frame arguments in raw form."),
136 N_("Show whether to print frame arguments in raw form."),
137 N_("If set, frame arguments are printed in raw form, bypassing any\n\
138 pretty-printers for that value.")
142 /* Options for the "backtrace" command. */
144 struct backtrace_cmd_options
151 using bt_flag_option_def
152 = gdb::option::flag_option_def
<backtrace_cmd_options
>;
154 static const gdb::option::option_def backtrace_command_option_defs
[] = {
157 [] (backtrace_cmd_options
*opt
) { return &opt
->full
; },
158 N_("Print values of local variables.")
163 [] (backtrace_cmd_options
*opt
) { return &opt
->no_filters
; },
164 N_("Prohibit frame filters from executing on a backtrace."),
169 [] (backtrace_cmd_options
*opt
) { return &opt
->hide
; },
170 N_("Causes Python frame filter elided frames to not be printed."),
174 /* Prototypes for local functions. */
176 static void print_frame_local_vars (struct frame_info
*frame
,
178 const char *regexp
, const char *t_regexp
,
179 int num_tabs
, struct ui_file
*stream
);
181 static void print_frame (const frame_print_options
&opts
,
182 frame_info
*frame
, int print_level
,
183 enum print_what print_what
, int print_args
,
184 struct symtab_and_line sal
);
186 static void set_last_displayed_sal (int valid
,
187 struct program_space
*pspace
,
189 struct symtab
*symtab
,
192 static struct frame_info
*find_frame_for_function (const char *);
193 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
195 /* Zero means do things normally; we are interacting directly with the
196 user. One means print the full filename and linenumber when a
197 frame is printed, and do so in a format emacs18/emacs19.22 can
198 parse. Two means print similar annotations, but in many more
199 cases and in a slightly different syntax. */
201 int annotation_level
= 0;
203 /* These variables hold the last symtab and line we displayed to the user.
204 * This is where we insert a breakpoint or a skiplist entry by default. */
205 static int last_displayed_sal_valid
= 0;
206 static struct program_space
*last_displayed_pspace
= 0;
207 static CORE_ADDR last_displayed_addr
= 0;
208 static struct symtab
*last_displayed_symtab
= 0;
209 static int last_displayed_line
= 0;
212 /* Return 1 if we should display the address in addition to the location,
213 because we are in the middle of a statement. */
216 frame_show_address (struct frame_info
*frame
,
217 struct symtab_and_line sal
)
219 /* If there is a line number, but no PC, then there is no location
220 information associated with this sal. The only way that should
221 happen is for the call sites of inlined functions (SAL comes from
222 find_frame_sal). Otherwise, we would have some PC range if the
223 SAL came from a line table. */
224 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
226 if (get_next_frame (frame
) == NULL
)
227 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
229 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
233 return get_frame_pc (frame
) != sal
.pc
;
239 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
240 int print_level
, enum print_what print_what
,
243 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
245 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
248 /* Show or print a stack frame FRAME briefly. The output is formatted
249 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
250 relative level, function name, argument list, and file name and
251 line number. If the frame's PC is not at the beginning of the
252 source line, the actual PC is printed at the beginning. */
255 print_stack_frame (struct frame_info
*frame
, int print_level
,
256 enum print_what print_what
,
260 /* For mi, alway print location and address. */
261 if (current_uiout
->is_mi_like_p ())
262 print_what
= LOC_AND_ADDRESS
;
266 print_frame_info (user_frame_print_options
,
267 frame
, print_level
, print_what
, 1 /* print_args */,
270 set_current_sal_from_frame (frame
);
272 catch (const gdb_exception_error
&e
)
277 /* Print nameless arguments of frame FRAME on STREAM, where START is
278 the offset of the first nameless argument, and NUM is the number of
279 nameless arguments to print. FIRST is nonzero if this is the first
280 argument (not just the first nameless argument). */
283 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
284 int first
, struct ui_file
*stream
)
286 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
287 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
292 for (i
= 0; i
< num
; i
++)
295 argsaddr
= get_frame_args_address (frame
);
298 arg_value
= read_memory_integer (argsaddr
+ start
,
299 sizeof (int), byte_order
);
301 fprintf_filtered (stream
, ", ");
302 fprintf_filtered (stream
, "%ld", arg_value
);
304 start
+= sizeof (int);
308 /* Print single argument of inferior function. ARG must be already
311 Errors are printed as if they would be the parameter value. Use zeroed ARG
312 iff it should not be printed accoring to user settings. */
315 print_frame_arg (const frame_print_options
&fp_opts
,
316 const struct frame_arg
*arg
)
318 struct ui_out
*uiout
= current_uiout
;
322 gdb_assert (!arg
->val
|| !arg
->error
);
323 gdb_assert (arg
->entry_kind
== print_entry_values_no
324 || arg
->entry_kind
== print_entry_values_only
325 || (!uiout
->is_mi_like_p ()
326 && arg
->entry_kind
== print_entry_values_compact
));
328 annotate_arg_emitter arg_emitter
;
329 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
330 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
331 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
332 if (arg
->entry_kind
== print_entry_values_compact
)
334 /* It is OK to provide invalid MI-like stream as with
335 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
338 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
339 SYMBOL_LANGUAGE (arg
->sym
),
340 DMGL_PARAMS
| DMGL_ANSI
);
342 if (arg
->entry_kind
== print_entry_values_only
343 || arg
->entry_kind
== print_entry_values_compact
)
345 uiout
->field_stream ("name", stb
, ui_out_style_kind::VARIABLE
);
346 annotate_arg_name_end ();
349 if (!arg
->val
&& !arg
->error
)
354 stb
.printf (_("<error reading variable: %s>"), arg
->error
);
359 const struct language_defn
*language
;
360 struct value_print_options vp_opts
;
362 /* Avoid value_print because it will deref ref parameters. We
363 just want to print their addresses. Print ??? for args whose
364 address we do not know. We pass 2 as "recurse" to val_print
365 because our standard indentation here is 4 spaces, and
366 val_print indents 2 for each recurse. */
368 annotate_arg_value (value_type (arg
->val
));
370 /* Use the appropriate language to display our symbol, unless the
371 user forced the language to a specific language. */
372 if (language_mode
== language_mode_auto
)
373 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
375 language
= current_language
;
377 get_no_prettyformat_print_options (&vp_opts
);
378 vp_opts
.deref_ref
= 1;
379 vp_opts
.raw
= fp_opts
.print_raw_frame_arguments
;
381 /* True in "summary" mode, false otherwise. */
383 = fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
;
385 common_val_print (arg
->val
, &stb
, 2, &vp_opts
, language
);
387 catch (const gdb_exception_error
&except
)
389 stb
.printf (_("<error reading variable: %s>"),
395 uiout
->field_stream ("value", stb
);
398 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
399 responsible for xfree of ARGP->ERROR. This function never throws an
403 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
404 struct frame_arg
*argp
)
412 argp
->val
= read_var_value (sym
, NULL
, frame
);
414 catch (const gdb_exception_error
&except
)
416 argp
->error
= xstrdup (except
.what ());
420 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
421 responsible for xfree of ARGP->ERROR. This function never throws an
425 read_frame_arg (const frame_print_options
&fp_opts
,
426 symbol
*sym
, frame_info
*frame
,
427 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
429 struct value
*val
= NULL
, *entryval
= NULL
;
430 char *val_error
= NULL
, *entryval_error
= NULL
;
433 if (fp_opts
.print_entry_values
!= print_entry_values_only
434 && fp_opts
.print_entry_values
!= print_entry_values_preferred
)
438 val
= read_var_value (sym
, NULL
, frame
);
440 catch (const gdb_exception_error
&except
)
442 val_error
= (char *) alloca (except
.message
->size () + 1);
443 strcpy (val_error
, except
.what ());
447 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
448 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
449 && fp_opts
.print_entry_values
!= print_entry_values_no
450 && (fp_opts
.print_entry_values
!= print_entry_values_if_needed
451 || !val
|| value_optimized_out (val
)))
455 const struct symbol_computed_ops
*ops
;
457 ops
= SYMBOL_COMPUTED_OPS (sym
);
458 entryval
= ops
->read_variable_at_entry (sym
, frame
);
460 catch (const gdb_exception_error
&except
)
462 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
464 entryval_error
= (char *) alloca (except
.message
->size () + 1);
465 strcpy (entryval_error
, except
.what ());
469 if (entryval
!= NULL
&& value_optimized_out (entryval
))
472 if (fp_opts
.print_entry_values
== print_entry_values_compact
473 || fp_opts
.print_entry_values
== print_entry_values_default
)
475 /* For MI do not try to use print_entry_values_compact for ARGP. */
477 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
479 struct type
*type
= value_type (val
);
481 if (value_lazy (val
))
482 value_fetch_lazy (val
);
483 if (value_lazy (entryval
))
484 value_fetch_lazy (entryval
);
486 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
488 /* Initialize it just to avoid a GCC false warning. */
489 struct value
*val_deref
= NULL
, *entryval_deref
;
491 /* DW_AT_call_value does match with the current
492 value. If it is a reference still try to verify if
493 dereferenced DW_AT_call_data_value does not differ. */
497 struct type
*type_deref
;
499 val_deref
= coerce_ref (val
);
500 if (value_lazy (val_deref
))
501 value_fetch_lazy (val_deref
);
502 type_deref
= value_type (val_deref
);
504 entryval_deref
= coerce_ref (entryval
);
505 if (value_lazy (entryval_deref
))
506 value_fetch_lazy (entryval_deref
);
508 /* If the reference addresses match but dereferenced
509 content does not match print them. */
511 && value_contents_eq (val_deref
, 0,
513 TYPE_LENGTH (type_deref
)))
516 catch (const gdb_exception_error
&except
)
518 /* If the dereferenced content could not be
519 fetched do not display anything. */
520 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
522 else if (except
.message
!= NULL
)
525 = (char *) alloca (except
.message
->size () + 1);
526 strcpy (entryval_error
, except
.what ());
530 /* Value was not a reference; and its content matches. */
531 if (val
== val_deref
)
539 /* Try to remove possibly duplicate error message for ENTRYARGP even
542 if (val_error
&& entryval_error
543 && strcmp (val_error
, entryval_error
) == 0)
545 entryval_error
= NULL
;
547 /* Do not se VAL_EQUAL as the same error message may be shown for
548 the entry value even if no entry values are present in the
554 if (entryval
== NULL
)
556 if (fp_opts
.print_entry_values
== print_entry_values_preferred
)
558 gdb_assert (val
== NULL
);
562 val
= read_var_value (sym
, NULL
, frame
);
564 catch (const gdb_exception_error
&except
)
566 val_error
= (char *) alloca (except
.message
->size () + 1);
567 strcpy (val_error
, except
.what ());
570 if (fp_opts
.print_entry_values
== print_entry_values_only
571 || fp_opts
.print_entry_values
== print_entry_values_both
572 || (fp_opts
.print_entry_values
== print_entry_values_preferred
573 && (!val
|| value_optimized_out (val
))))
575 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
576 entryval_error
= NULL
;
579 if ((fp_opts
.print_entry_values
== print_entry_values_compact
580 || fp_opts
.print_entry_values
== print_entry_values_if_needed
581 || fp_opts
.print_entry_values
== print_entry_values_preferred
)
582 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
590 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
591 if (!val
&& !val_error
)
592 argp
->entry_kind
= print_entry_values_only
;
593 else if ((fp_opts
.print_entry_values
== print_entry_values_compact
594 || fp_opts
.print_entry_values
== print_entry_values_default
)
597 argp
->entry_kind
= print_entry_values_compact
;
598 gdb_assert (!current_uiout
->is_mi_like_p ());
601 argp
->entry_kind
= print_entry_values_no
;
603 entryargp
->sym
= sym
;
604 entryargp
->val
= entryval
;
605 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
606 if (!entryval
&& !entryval_error
)
607 entryargp
->entry_kind
= print_entry_values_no
;
609 entryargp
->entry_kind
= print_entry_values_only
;
612 /* Print the arguments of frame FRAME on STREAM, given the function
613 FUNC running in that frame (as a symbol), where NUM is the number
614 of arguments according to the stack frame (or -1 if the number of
615 arguments is unknown). */
617 /* Note that currently the "number of arguments according to the
618 stack frame" is only known on VAX where i refers to the "number of
619 ints of arguments according to the stack frame". */
622 print_frame_args (const frame_print_options
&fp_opts
,
623 struct symbol
*func
, struct frame_info
*frame
,
624 int num
, struct ui_file
*stream
)
626 struct ui_out
*uiout
= current_uiout
;
628 /* Offset of next stack argument beyond the one we have seen that is
629 at the highest offset, or -1 if we haven't come to a stack
631 long highest_offset
= -1;
632 /* Number of ints of arguments that we have printed so far. */
633 int args_printed
= 0;
634 /* True if we should print arguments, false otherwise. */
636 = fp_opts
.print_frame_arguments
!= print_frame_arguments_none
;
640 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
641 struct block_iterator iter
;
644 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
646 struct frame_arg arg
, entryarg
;
650 /* Keep track of the highest stack argument offset seen, and
651 skip over any kinds of symbols we don't care about. */
653 if (!SYMBOL_IS_ARGUMENT (sym
))
656 switch (SYMBOL_CLASS (sym
))
661 long current_offset
= SYMBOL_VALUE (sym
);
662 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
664 /* Compute address of next argument by adding the size of
665 this argument and rounding to an int boundary. */
667 ((current_offset
+ arg_size
+ sizeof (int) - 1)
668 & ~(sizeof (int) - 1));
670 /* If this is the highest offset seen yet, set
672 if (highest_offset
== -1
673 || (current_offset
> highest_offset
))
674 highest_offset
= current_offset
;
676 /* Add the number of ints we're about to print to
678 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
681 /* We care about types of symbols, but don't need to
682 keep track of stack offsets in them. */
684 case LOC_REGPARM_ADDR
:
686 case LOC_OPTIMIZED_OUT
:
691 /* We have to look up the symbol because arguments can have
692 two entries (one a parameter, one a local) and the one we
693 want is the local, which lookup_symbol will find for us.
694 This includes gcc1 (not gcc2) on SPARC when passing a
695 small structure and gcc2 when the argument type is float
696 and it is passed as a double and converted to float by
697 the prologue (in the latter case the type of the LOC_ARG
698 symbol is double and the type of the LOC_LOCAL symbol is
700 /* But if the parameter name is null, don't try it. Null
701 parameter names occur on the RS/6000, for traceback
702 tables. FIXME, should we even print them? */
704 if (*SYMBOL_LINKAGE_NAME (sym
))
708 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
709 b
, VAR_DOMAIN
).symbol
;
710 gdb_assert (nsym
!= NULL
);
711 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
712 && !SYMBOL_IS_ARGUMENT (nsym
))
714 /* There is a LOC_ARG/LOC_REGISTER pair. This means
715 that it was passed on the stack and loaded into a
716 register, or passed in a register and stored in a
717 stack slot. GDB 3.x used the LOC_ARG; GDB
718 4.0-4.11 used the LOC_REGISTER.
720 Reasons for using the LOC_ARG:
722 (1) Because find_saved_registers may be slow for
725 (2) Because registers are often re-used and stack
726 slots rarely (never?) are. Therefore using
727 the stack slot is much less likely to print
730 Reasons why we might want to use the LOC_REGISTER:
732 (1) So that the backtrace prints the same value
733 as "print foo". I see no compelling reason
734 why this needs to be the case; having the
735 backtrace print the value which was passed
736 in, and "print foo" print the value as
737 modified within the called function, makes
740 Additional note: It might be nice if "info args"
741 displayed both values.
743 One more note: There is a case with SPARC
744 structure passing where we need to use the
745 LOC_REGISTER, but this is dealt with by creating
746 a single LOC_REGPARM in symbol reading. */
748 /* Leave sym (the LOC_ARG) alone. */
755 /* Print the current arg. */
758 uiout
->wrap_hint (" ");
762 memset (&arg
, 0, sizeof (arg
));
764 arg
.entry_kind
= print_entry_values_no
;
765 memset (&entryarg
, 0, sizeof (entryarg
));
767 entryarg
.entry_kind
= print_entry_values_no
;
770 read_frame_arg (fp_opts
, sym
, frame
, &arg
, &entryarg
);
772 if (arg
.entry_kind
!= print_entry_values_only
)
773 print_frame_arg (fp_opts
, &arg
);
775 if (entryarg
.entry_kind
!= print_entry_values_no
)
777 if (arg
.entry_kind
!= print_entry_values_only
)
780 uiout
->wrap_hint (" ");
783 print_frame_arg (fp_opts
, &entryarg
);
787 xfree (entryarg
.error
);
793 /* Don't print nameless args in situations where we don't know
794 enough about the stack to find them. */
799 if (highest_offset
== -1)
800 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
802 start
= highest_offset
;
804 print_frame_nameless_args (frame
, start
, num
- args_printed
,
809 /* Set the current source and line to the location given by frame
810 FRAME, if possible. When CENTER is true, adjust so the relevant
811 line is in the center of the next 'list'. */
814 set_current_sal_from_frame (struct frame_info
*frame
)
816 symtab_and_line sal
= find_frame_sal (frame
);
817 if (sal
.symtab
!= NULL
)
818 set_current_source_symtab_and_line (sal
);
821 /* If ON, GDB will display disassembly of the next source line when
822 execution of the program being debugged stops.
823 If AUTO (which is the default), or there's no line info to determine
824 the source line of the next instruction, display disassembly of next
825 instruction instead. */
827 static enum auto_boolean disassemble_next_line
;
830 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
831 struct cmd_list_element
*c
,
834 fprintf_filtered (file
,
835 _("Debugger's willingness to use "
836 "disassemble-next-line is %s.\n"),
840 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
841 because it will be broken by filter sometime. */
844 do_gdb_disassembly (struct gdbarch
*gdbarch
,
845 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
850 gdb_disassembly (gdbarch
, current_uiout
,
851 DISASSEMBLY_RAW_INSN
, how_many
,
854 catch (const gdb_exception_error
&exception
)
856 /* If an exception was thrown while doing the disassembly, print
857 the error message, to give the user a clue of what happened. */
858 exception_print (gdb_stderr
, exception
);
862 /* Print information about frame FRAME. The output is format according
863 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
866 SRC_LINE: Print only source line.
867 LOCATION: Print only location.
868 SRC_AND_LOC: Print location and source line.
870 Used in "where" output, and to emit breakpoint or step
874 print_frame_info (const frame_print_options
&fp_opts
,
875 frame_info
*frame
, int print_level
,
876 enum print_what print_what
, int print_args
,
879 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
882 struct ui_out
*uiout
= current_uiout
;
884 if (get_frame_type (frame
) == DUMMY_FRAME
885 || get_frame_type (frame
) == SIGTRAMP_FRAME
886 || get_frame_type (frame
) == ARCH_FRAME
)
888 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
890 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
891 gdbarch
, get_frame_pc (frame
));
893 /* Do this regardless of SOURCE because we don't have any source
894 to list for this frame. */
898 uiout
->field_fmt_signed (2, ui_left
, "level",
899 frame_relative_level (frame
));
901 if (uiout
->is_mi_like_p ())
903 annotate_frame_address ();
904 uiout
->field_core_addr ("addr",
905 gdbarch
, get_frame_pc (frame
));
906 annotate_frame_address_end ();
909 if (get_frame_type (frame
) == DUMMY_FRAME
)
911 annotate_function_call ();
912 uiout
->field_string ("func", "<function called from gdb>",
913 ui_out_style_kind::FUNCTION
);
915 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
917 annotate_signal_handler_caller ();
918 uiout
->field_string ("func", "<signal handler called>",
919 ui_out_style_kind::FUNCTION
);
921 else if (get_frame_type (frame
) == ARCH_FRAME
)
923 uiout
->field_string ("func", "<cross-architecture call>",
924 ui_out_style_kind::FUNCTION
);
927 annotate_frame_end ();
929 /* If disassemble-next-line is set to auto or on output the next
931 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
932 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
933 do_gdb_disassembly (get_frame_arch (frame
), 1,
934 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
939 /* If FRAME is not the innermost frame, that normally means that
940 FRAME->pc points to *after* the call instruction, and we want to
941 get the line containing the call, never the next line. But if
942 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
943 next frame was not entered as the result of a call, and we want
944 to get the line containing FRAME->pc. */
945 symtab_and_line sal
= find_frame_sal (frame
);
947 location_print
= (print_what
== LOCATION
948 || print_what
== LOC_AND_ADDRESS
949 || print_what
== SRC_AND_LOC
);
951 if (location_print
|| !sal
.symtab
)
952 print_frame (fp_opts
, frame
, print_level
, print_what
, print_args
, sal
);
954 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
956 /* If disassemble-next-line is set to auto or on and doesn't have
957 the line debug messages for $pc, output the next instruction. */
958 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
959 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
960 && source_print
&& !sal
.symtab
)
961 do_gdb_disassembly (get_frame_arch (frame
), 1,
962 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
964 if (source_print
&& sal
.symtab
)
966 int mid_statement
= ((print_what
== SRC_LINE
)
967 && frame_show_address (frame
, sal
));
968 annotate_source_line (sal
.symtab
, sal
.line
, mid_statement
,
969 get_frame_pc (frame
));
971 if (deprecated_print_frame_info_listing_hook
)
972 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
,
976 struct value_print_options opts
;
978 get_user_print_options (&opts
);
979 /* We used to do this earlier, but that is clearly
980 wrong. This function is used by many different
981 parts of gdb, including normal_stop in infrun.c,
982 which uses this to print out the current PC
983 when we stepi/nexti into the middle of a source
984 line. Only the command line really wants this
985 behavior. Other UIs probably would like the
986 ability to decide for themselves if it is desired. */
987 if (opts
.addressprint
&& mid_statement
)
989 uiout
->field_core_addr ("addr",
990 gdbarch
, get_frame_pc (frame
));
994 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
998 /* If disassemble-next-line is set to on and there is line debug
999 messages, output assembly codes for next line. */
1000 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
1001 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
1003 if (set_current_sal
)
1007 if (get_frame_pc_if_available (frame
, &pc
))
1008 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
1010 set_last_displayed_sal (0, 0, 0, 0, 0);
1013 annotate_frame_end ();
1015 gdb_flush (gdb_stdout
);
1018 /* Remember the last symtab and line we displayed, which we use e.g.
1019 * as the place to put a breakpoint when the `break' command is
1020 * invoked with no arguments. */
1023 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
1024 CORE_ADDR addr
, struct symtab
*symtab
,
1027 last_displayed_sal_valid
= valid
;
1028 last_displayed_pspace
= pspace
;
1029 last_displayed_addr
= addr
;
1030 last_displayed_symtab
= symtab
;
1031 last_displayed_line
= line
;
1032 if (valid
&& pspace
== NULL
)
1034 clear_last_displayed_sal ();
1035 internal_error (__FILE__
, __LINE__
,
1036 _("Trying to set NULL pspace."));
1040 /* Forget the last sal we displayed. */
1043 clear_last_displayed_sal (void)
1045 last_displayed_sal_valid
= 0;
1046 last_displayed_pspace
= 0;
1047 last_displayed_addr
= 0;
1048 last_displayed_symtab
= 0;
1049 last_displayed_line
= 0;
1052 /* Is our record of the last sal we displayed valid? If not,
1053 * the get_last_displayed_* functions will return NULL or 0, as
1057 last_displayed_sal_is_valid (void)
1059 return last_displayed_sal_valid
;
1062 /* Get the pspace of the last sal we displayed, if it's valid. */
1064 struct program_space
*
1065 get_last_displayed_pspace (void)
1067 if (last_displayed_sal_valid
)
1068 return last_displayed_pspace
;
1072 /* Get the address of the last sal we displayed, if it's valid. */
1075 get_last_displayed_addr (void)
1077 if (last_displayed_sal_valid
)
1078 return last_displayed_addr
;
1082 /* Get the symtab of the last sal we displayed, if it's valid. */
1085 get_last_displayed_symtab (void)
1087 if (last_displayed_sal_valid
)
1088 return last_displayed_symtab
;
1092 /* Get the line of the last sal we displayed, if it's valid. */
1095 get_last_displayed_line (void)
1097 if (last_displayed_sal_valid
)
1098 return last_displayed_line
;
1102 /* Get the last sal we displayed, if it's valid. */
1105 get_last_displayed_sal ()
1107 symtab_and_line sal
;
1109 if (last_displayed_sal_valid
)
1111 sal
.pspace
= last_displayed_pspace
;
1112 sal
.pc
= last_displayed_addr
;
1113 sal
.symtab
= last_displayed_symtab
;
1114 sal
.line
= last_displayed_line
;
1121 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1122 corresponding to FRAME. */
1124 gdb::unique_xmalloc_ptr
<char>
1125 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1126 struct symbol
**funcp
)
1128 struct symbol
*func
;
1129 gdb::unique_xmalloc_ptr
<char> funname
;
1131 *funlang
= language_unknown
;
1135 func
= get_frame_function (frame
);
1138 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1140 *funlang
= SYMBOL_LANGUAGE (func
);
1143 if (*funlang
== language_cplus
)
1145 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1146 to display the demangled name that we already have
1147 stored in the symbol table, but we stored a version
1148 with DMGL_PARAMS turned on, and here we don't want to
1149 display parameters. So remove the parameters. */
1150 funname
= cp_remove_params (print_name
);
1153 /* If we didn't hit the C++ case above, set *funname
1155 if (funname
== NULL
)
1156 funname
.reset (xstrdup (print_name
));
1160 struct bound_minimal_symbol msymbol
;
1163 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1166 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1167 if (msymbol
.minsym
!= NULL
)
1169 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1170 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1178 print_frame (const frame_print_options
&fp_opts
,
1179 frame_info
*frame
, int print_level
,
1180 enum print_what print_what
, int print_args
,
1181 struct symtab_and_line sal
)
1183 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1184 struct ui_out
*uiout
= current_uiout
;
1185 enum language funlang
= language_unknown
;
1186 struct value_print_options opts
;
1187 struct symbol
*func
;
1191 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1193 gdb::unique_xmalloc_ptr
<char> funname
1194 = find_frame_funname (frame
, &funlang
, &func
);
1196 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1200 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1205 uiout
->field_fmt_signed (2, ui_left
, "level",
1206 frame_relative_level (frame
));
1208 get_user_print_options (&opts
);
1209 if (opts
.addressprint
)
1211 || frame_show_address (frame
, sal
)
1212 || print_what
== LOC_AND_ADDRESS
)
1214 annotate_frame_address ();
1216 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1218 uiout
->field_string ("addr", "<unavailable>",
1219 ui_out_style_kind::ADDRESS
);
1220 annotate_frame_address_end ();
1221 uiout
->text (" in ");
1223 annotate_frame_function_name ();
1226 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1227 funlang
, DMGL_ANSI
);
1228 uiout
->field_stream ("func", stb
, ui_out_style_kind::FUNCTION
);
1229 uiout
->wrap_hint (" ");
1230 annotate_frame_args ();
1237 if (gdbarch_frame_num_args_p (gdbarch
))
1239 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1240 gdb_assert (numargs
>= 0);
1246 ui_out_emit_list
list_emitter (uiout
, "args");
1249 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1251 catch (const gdb_exception_error
&e
)
1255 /* FIXME: ARGS must be a list. If one argument is a string it
1256 will have " that will not be properly escaped. */
1263 const char *filename_display
;
1265 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1266 annotate_frame_source_begin ();
1267 uiout
->wrap_hint (" ");
1268 uiout
->text (" at ");
1269 annotate_frame_source_file ();
1270 uiout
->field_string ("file", filename_display
, ui_out_style_kind::FILE);
1271 if (uiout
->is_mi_like_p ())
1273 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1275 uiout
->field_string ("fullname", fullname
);
1277 annotate_frame_source_file_end ();
1279 annotate_frame_source_line ();
1280 uiout
->field_signed ("line", sal
.line
);
1281 annotate_frame_source_end ();
1284 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1286 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1287 get_frame_pc (frame
));
1291 annotate_frame_where ();
1292 uiout
->wrap_hint (" ");
1293 uiout
->text (" from ");
1294 uiout
->field_string ("from", lib
);
1297 if (uiout
->is_mi_like_p ())
1298 uiout
->field_string ("arch",
1299 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1306 /* Completion function for "frame function", "info frame function", and
1307 "select-frame function" commands. */
1310 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1311 completion_tracker
&tracker
,
1312 const char *text
, const char *word
)
1314 /* This is used to complete function names within a stack. It would be
1315 nice if we only offered functions that were actually in the stack.
1316 However, this would mean unwinding the stack to completion, which
1317 could take too long, or on a corrupted stack, possibly not end.
1318 Instead, we offer all symbol names as a safer choice. */
1319 collect_symbol_completion_matches (tracker
,
1320 complete_symbol_mode::EXPRESSION
,
1321 symbol_name_match_type::EXPRESSION
,
1325 /* Core of all the "info frame" sub-commands. Print information about a
1326 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1327 frame specification, they just entered 'info frame'. If the user did
1328 provide a frame specification (for example 'info frame 0', 'info frame
1329 level 1') then SELECTED_FRAME_P will be false. */
1332 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1334 struct symbol
*func
;
1336 struct frame_info
*calling_frame_info
;
1338 const char *funname
= 0;
1339 enum language funlang
= language_unknown
;
1340 const char *pc_regname
;
1341 struct gdbarch
*gdbarch
;
1344 /* Initialize it to avoid "may be used uninitialized" warning. */
1345 CORE_ADDR caller_pc
= 0;
1346 int caller_pc_p
= 0;
1348 gdbarch
= get_frame_arch (fi
);
1350 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1351 is not a good name. */
1352 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1353 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1354 easily not match that of the internal value returned by
1356 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1358 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1359 architectures will often have a hardware register called "pc",
1360 and that register's value, again, can easily not match
1364 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1365 func
= get_frame_function (fi
);
1366 symtab_and_line sal
= find_frame_sal (fi
);
1368 gdb::unique_xmalloc_ptr
<char> func_only
;
1371 funname
= SYMBOL_PRINT_NAME (func
);
1372 funlang
= SYMBOL_LANGUAGE (func
);
1373 if (funlang
== language_cplus
)
1375 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1376 to display the demangled name that we already have
1377 stored in the symbol table, but we stored a version
1378 with DMGL_PARAMS turned on, and here we don't want to
1379 display parameters. So remove the parameters. */
1380 func_only
= cp_remove_params (funname
);
1383 funname
= func_only
.get ();
1386 else if (frame_pc_p
)
1388 struct bound_minimal_symbol msymbol
;
1390 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1391 if (msymbol
.minsym
!= NULL
)
1393 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1394 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1397 calling_frame_info
= get_prev_frame (fi
);
1399 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1401 printf_filtered (_("Stack level %d, frame at "),
1402 frame_relative_level (fi
));
1406 printf_filtered (_("Stack frame at "));
1408 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1409 printf_filtered (":\n");
1410 printf_filtered (" %s = ", pc_regname
);
1412 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1414 fputs_filtered ("<unavailable>", gdb_stdout
);
1419 printf_filtered (" in ");
1420 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1421 DMGL_ANSI
| DMGL_PARAMS
);
1425 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1427 puts_filtered ("; ");
1429 printf_filtered ("saved %s = ", pc_regname
);
1431 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1432 val_print_not_saved (gdb_stdout
);
1437 caller_pc
= frame_unwind_caller_pc (fi
);
1440 catch (const gdb_exception_error
&ex
)
1444 case NOT_AVAILABLE_ERROR
:
1445 val_print_unavailable (gdb_stdout
);
1447 case OPTIMIZED_OUT_ERROR
:
1448 val_print_not_saved (gdb_stdout
);
1451 fprintf_filtered (gdb_stdout
, _("<error: %s>"),
1459 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1460 printf_filtered ("\n");
1462 if (calling_frame_info
== NULL
)
1464 enum unwind_stop_reason reason
;
1466 reason
= get_frame_unwind_stop_reason (fi
);
1467 if (reason
!= UNWIND_NO_REASON
)
1468 printf_filtered (_(" Outermost frame: %s\n"),
1469 frame_stop_reason_string (fi
));
1471 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1472 puts_filtered (" tail call frame");
1473 else if (get_frame_type (fi
) == INLINE_FRAME
)
1474 printf_filtered (" inlined into frame %d",
1475 frame_relative_level (get_prev_frame (fi
)));
1478 printf_filtered (" called by frame at ");
1479 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1482 if (get_next_frame (fi
) && calling_frame_info
)
1483 puts_filtered (",");
1485 if (get_next_frame (fi
))
1487 printf_filtered (" caller of frame at ");
1488 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1491 if (get_next_frame (fi
) || calling_frame_info
)
1492 puts_filtered ("\n");
1495 printf_filtered (" source language %s.\n",
1496 language_str (s
->language
));
1499 /* Address of the argument list for this frame, or 0. */
1500 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1501 /* Number of args for this frame, or -1 if unknown. */
1505 printf_filtered (" Arglist at unknown address.\n");
1508 printf_filtered (" Arglist at ");
1509 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1510 printf_filtered (",");
1512 if (!gdbarch_frame_num_args_p (gdbarch
))
1515 puts_filtered (" args: ");
1519 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1520 gdb_assert (numargs
>= 0);
1522 puts_filtered (" no args.");
1523 else if (numargs
== 1)
1524 puts_filtered (" 1 arg: ");
1526 printf_filtered (" %d args: ", numargs
);
1528 print_frame_args (user_frame_print_options
,
1529 func
, fi
, numargs
, gdb_stdout
);
1530 puts_filtered ("\n");
1534 /* Address of the local variables for this frame, or 0. */
1535 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1538 printf_filtered (" Locals at unknown address,");
1541 printf_filtered (" Locals at ");
1542 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1543 printf_filtered (",");
1547 /* Print as much information as possible on the location of all the
1553 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1555 /* The sp is special; what's displayed isn't the save address, but
1556 the value of the previous frame's sp. This is a legacy thing,
1557 at one stage the frame cached the previous frame's SP instead
1558 of its address, hence it was easiest to just display the cached
1562 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1563 gdb_assert (value
!= NULL
);
1565 if (!value_optimized_out (value
) && value_entirely_available (value
))
1567 if (VALUE_LVAL (value
) == not_lval
)
1570 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1571 int sp_size
= register_size (gdbarch
, sp_regnum
);
1573 sp
= extract_unsigned_integer (value_contents_all (value
),
1574 sp_size
, byte_order
);
1576 printf_filtered (" Previous frame's sp is ");
1577 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1578 printf_filtered ("\n");
1580 else if (VALUE_LVAL (value
) == lval_memory
)
1582 printf_filtered (" Previous frame's sp at ");
1583 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1585 printf_filtered ("\n");
1587 else if (VALUE_LVAL (value
) == lval_register
)
1589 printf_filtered (" Previous frame's sp in %s\n",
1590 gdbarch_register_name (gdbarch
,
1591 VALUE_REGNUM (value
)));
1594 release_value (value
);
1597 /* else keep quiet. */
1601 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1602 for (i
= 0; i
< numregs
; i
++)
1604 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1606 enum lval_type lval
;
1612 /* Find out the location of the saved register without
1613 fetching the corresponding value. */
1614 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1615 &lval
, &addr
, &realnum
, NULL
);
1616 /* For moment, only display registers that were saved on the
1618 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1621 puts_filtered (" Saved registers:\n ");
1623 puts_filtered (",");
1625 printf_filtered (" %s at ",
1626 gdbarch_register_name (gdbarch
, i
));
1627 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1631 if (count
|| need_nl
)
1632 puts_filtered ("\n");
1636 /* Return the innermost frame at level LEVEL. */
1638 static struct frame_info
*
1639 leading_innermost_frame (int level
)
1641 struct frame_info
*leading
;
1643 leading
= get_current_frame ();
1645 gdb_assert (level
>= 0);
1647 while (leading
!= nullptr && level
)
1650 leading
= get_prev_frame (leading
);
1657 /* Return the starting frame needed to handle COUNT outermost frames. */
1659 static struct frame_info
*
1660 trailing_outermost_frame (int count
)
1662 struct frame_info
*current
;
1663 struct frame_info
*trailing
;
1665 trailing
= get_current_frame ();
1667 gdb_assert (count
> 0);
1670 while (current
!= nullptr && count
--)
1673 current
= get_prev_frame (current
);
1676 /* Will stop when CURRENT reaches the top of the stack.
1677 TRAILING will be COUNT below it. */
1678 while (current
!= nullptr)
1681 trailing
= get_prev_frame (trailing
);
1682 current
= get_prev_frame (current
);
1688 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1692 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1694 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1696 if (get_selected_frame_if_set () != prev_frame
)
1697 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1703 select_frame_for_mi (struct frame_info
*fi
)
1705 select_frame_command_core (fi
, false /* Ignored. */);
1708 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1709 means we change frame send out a change notification (otherwise, just
1710 reprint the current frame summary). */
1713 frame_command_core (struct frame_info
*fi
, bool ignored
)
1715 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1718 if (get_selected_frame_if_set () != prev_frame
)
1719 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1721 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1724 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1725 common set of sub-commands that allow a specific frame to be selected.
1726 All of the sub-command functions are static methods within this class
1727 template which is then instantiated below. The template parameter is a
1728 callback used to implement the functionality of the base command
1729 ('frame', 'select-frame', or 'info frame').
1731 In the template parameter FI is the frame being selected. The
1732 SELECTED_FRAME_P flag is true if the frame being selected was done by
1733 default, which happens when the user uses the base command with no
1734 arguments. For example the commands 'info frame', 'select-frame',
1735 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1736 SELECTED_FRAME_P is false. */
1738 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1739 class frame_command_helper
1743 /* The "frame level" family of commands. The ARG is an integer that is
1744 the frame's level in the stack. */
1746 level (const char *arg
, int from_tty
)
1748 int level
= value_as_long (parse_and_eval (arg
));
1749 struct frame_info
*fid
1750 = find_relative_frame (get_current_frame (), &level
);
1752 error (_("No frame at level %s."), arg
);
1756 /* The "frame address" family of commands. ARG is a stack-pointer
1757 address for an existing frame. This command does not allow new
1758 frames to be created. */
1761 address (const char *arg
, int from_tty
)
1763 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1764 struct frame_info
*fid
= find_frame_for_address (addr
);
1766 error (_("No frame at address %s."), arg
);
1770 /* The "frame view" family of commands. ARG is one or two addresses and
1771 is used to view a frame that might be outside the current backtrace.
1772 The addresses are stack-pointer address, and (optional) pc-address. */
1775 view (const char *args
, int from_tty
)
1777 struct frame_info
*fid
;
1780 error (_("Missing address argument to view a frame"));
1782 gdb_argv
argv (args
);
1784 if (argv
.count () == 2)
1788 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1789 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1790 fid
= create_new_frame (addr
[0], addr
[1]);
1794 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1795 fid
= create_new_frame (addr
, false);
1800 /* The "frame function" family of commands. ARG is the name of a
1801 function within the stack, the first function (searching from frame
1802 0) with that name will be selected. */
1805 function (const char *arg
, int from_tty
)
1808 error (_("Missing function name argument"));
1809 struct frame_info
*fid
= find_frame_for_function (arg
);
1811 error (_("No frame for function \"%s\"."), arg
);
1815 /* The "frame" base command, that is, when no sub-command is specified.
1816 If one argument is provided then we assume that this is a frame's
1817 level as historically, this was the supported command syntax that was
1820 If no argument is provided, then the current frame is selected. */
1823 base_command (const char *arg
, int from_tty
)
1826 FPTR (get_selected_frame (_("No stack.")), true);
1828 level (arg
, from_tty
);
1832 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1833 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1835 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1836 static frame_command_helper
<frame_command_core
> frame_cmd
;
1837 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1839 /* Print briefly all stack frames or just the innermost COUNT_EXP
1843 backtrace_command_1 (const frame_print_options
&fp_opts
,
1844 const backtrace_cmd_options
&bt_opts
,
1845 const char *count_exp
, int from_tty
)
1848 struct frame_info
*fi
;
1850 int py_start
= 0, py_end
= 0;
1851 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1853 if (!target_has_stack
)
1854 error (_("No stack."));
1858 count
= parse_and_eval_long (count_exp
);
1864 /* The argument to apply_ext_lang_frame_filter is the number
1865 of the final frame to print, and frames start at 0. */
1875 frame_filter_flags flags
= 0;
1878 flags
|= PRINT_LOCALS
;
1880 flags
|= PRINT_HIDE
;
1882 if (!bt_opts
.no_filters
)
1884 enum ext_lang_frame_args arg_type
;
1886 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1888 flags
|= PRINT_MORE_FRAMES
;
1890 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
1891 arg_type
= CLI_SCALAR_VALUES
;
1892 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
1893 arg_type
= CLI_ALL_VALUES
;
1895 arg_type
= NO_VALUES
;
1897 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1898 arg_type
, current_uiout
,
1902 /* Run the inbuilt backtrace if there are no filters registered, or
1903 "-no-filters" has been specified from the command. */
1904 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1906 struct frame_info
*trailing
;
1908 /* The following code must do two things. First, it must set the
1909 variable TRAILING to the frame from which we should start
1910 printing. Second, it must set the variable count to the number
1911 of frames which we should print, or -1 if all of them. */
1913 if (count_exp
!= NULL
&& count
< 0)
1915 trailing
= trailing_outermost_frame (-count
);
1919 trailing
= get_current_frame ();
1921 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
1925 /* Don't use print_stack_frame; if an error() occurs it probably
1926 means further attempts to backtrace would fail (on the other
1927 hand, perhaps the code does or could be fixed to make sure
1928 the frame->prev field gets set to NULL in that case). */
1930 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
1931 if ((flags
& PRINT_LOCALS
) != 0)
1933 struct frame_id frame_id
= get_frame_id (fi
);
1935 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
1937 /* print_frame_local_vars invalidates FI. */
1938 fi
= frame_find_by_id (frame_id
);
1942 warning (_("Unable to restore previously selected frame."));
1947 /* Save the last frame to check for error conditions. */
1951 /* If we've stopped before the end, mention that. */
1953 printf_filtered (_("(More stack frames follow...)\n"));
1955 /* If we've run out of frames, and the reason appears to be an error
1956 condition, print it. */
1957 if (fi
== NULL
&& trailing
!= NULL
)
1959 enum unwind_stop_reason reason
;
1961 reason
= get_frame_unwind_stop_reason (trailing
);
1962 if (reason
>= UNWIND_FIRST_ERROR
)
1963 printf_filtered (_("Backtrace stopped: %s\n"),
1964 frame_stop_reason_string (trailing
));
1969 /* Create an option_def_group array grouping all the "backtrace"
1970 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
1972 static inline std::array
<gdb::option::option_def_group
, 3>
1973 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
1974 backtrace_cmd_options
*bt_cmd_opts
,
1975 set_backtrace_options
*set_bt_opts
)
1978 { {frame_print_option_defs
}, fp_opts
},
1979 { {set_backtrace_option_defs
}, set_bt_opts
},
1980 { {backtrace_command_option_defs
}, bt_cmd_opts
}
1984 /* Parse the backtrace command's qualifiers. Returns ARG advanced
1985 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
1986 store the parsed qualifiers. */
1989 parse_backtrace_qualifiers (const char *arg
,
1990 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
1994 const char *save_arg
= arg
;
1995 std::string this_arg
= extract_arg (&arg
);
1997 if (this_arg
.empty ())
2000 if (subset_compare (this_arg
.c_str (), "no-filters"))
2002 if (bt_cmd_opts
!= nullptr)
2003 bt_cmd_opts
->no_filters
= true;
2005 else if (subset_compare (this_arg
.c_str (), "full"))
2007 if (bt_cmd_opts
!= nullptr)
2008 bt_cmd_opts
->full
= true;
2010 else if (subset_compare (this_arg
.c_str (), "hide"))
2012 if (bt_cmd_opts
!= nullptr)
2013 bt_cmd_opts
->hide
= true;
2017 /* Not a recognized qualifier, so stop. */
2024 backtrace_command (const char *arg
, int from_tty
)
2026 frame_print_options fp_opts
= user_frame_print_options
;
2027 backtrace_cmd_options bt_cmd_opts
;
2028 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2031 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2032 gdb::option::process_options
2033 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2035 /* Parse non-'-'-prefixed qualifiers, for backwards
2039 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2044 /* These options are handled quite deep in the unwind machinery, so
2045 we get to pass them down by swapping globals. */
2046 scoped_restore restore_set_backtrace_options
2047 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2049 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2052 /* Completer for the "backtrace" command. */
2055 backtrace_command_completer (struct cmd_list_element
*ignore
,
2056 completion_tracker
&tracker
,
2057 const char *text
, const char */
*word*/
)
2060 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2061 if (gdb::option::complete_options
2062 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2067 const char *p
= skip_to_space (text
);
2070 static const char *const backtrace_cmd_qualifier_choices
[] = {
2071 "full", "no-filters", "hide", nullptr,
2073 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2076 if (tracker
.have_completions ())
2081 const char *cmd
= parse_backtrace_qualifiers (text
);
2082 tracker
.advance_custom_word_point_by (cmd
- text
);
2087 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2088 expression_completer (ignore
, tracker
, text
, word
);
2091 /* Iterate over the local variables of a block B, calling CB with
2095 iterate_over_block_locals (const struct block
*b
,
2096 iterate_over_block_arg_local_vars_cb cb
,
2099 struct block_iterator iter
;
2102 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2104 switch (SYMBOL_CLASS (sym
))
2110 case LOC_OPTIMIZED_OUT
:
2111 if (SYMBOL_IS_ARGUMENT (sym
))
2113 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2115 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
2119 /* Ignore symbols which are not locals. */
2126 /* Same, but print labels. */
2129 /* Commented out, as the code using this function has also been
2130 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2131 was commented out in the first place. The discussion introducing
2132 this change (2007-12-04: Support lexical blocks and function bodies
2133 that occupy non-contiguous address ranges) did not explain why
2134 this change was made. */
2136 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2137 int *have_default
, struct ui_file
*stream
)
2139 struct block_iterator iter
;
2141 int values_printed
= 0;
2143 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2145 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2151 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2153 struct symtab_and_line sal
;
2154 struct value_print_options opts
;
2156 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2158 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2159 get_user_print_options (&opts
);
2160 if (opts
.addressprint
)
2162 fprintf_filtered (stream
, " ");
2163 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2166 fprintf_filtered (stream
, " in file %s, line %d\n",
2167 sal
.symtab
->filename
, sal
.line
);
2171 return values_printed
;
2175 /* Iterate over all the local variables in block B, including all its
2176 superblocks, stopping when the top-level block is reached. */
2179 iterate_over_block_local_vars (const struct block
*block
,
2180 iterate_over_block_arg_local_vars_cb cb
,
2185 iterate_over_block_locals (block
, cb
, cb_data
);
2186 /* After handling the function's top-level block, stop. Don't
2187 continue to its superblock, the block of per-file
2189 if (BLOCK_FUNCTION (block
))
2191 block
= BLOCK_SUPERBLOCK (block
);
2195 /* Data to be passed around in the calls to the locals and args
2198 struct print_variable_and_value_data
2200 gdb::optional
<compiled_regex
> preg
;
2201 gdb::optional
<compiled_regex
> treg
;
2202 struct frame_id frame_id
;
2204 struct ui_file
*stream
;
2208 /* The callback for the locals and args iterators. */
2211 do_print_variable_and_value (const char *print_name
,
2215 struct print_variable_and_value_data
*p
2216 = (struct print_variable_and_value_data
*) cb_data
;
2217 struct frame_info
*frame
;
2219 if (p
->preg
.has_value ()
2220 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2223 if (p
->treg
.has_value ()
2224 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2227 frame
= frame_find_by_id (p
->frame_id
);
2230 warning (_("Unable to restore previously selected frame."));
2234 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2236 /* print_variable_and_value invalidates FRAME. */
2239 p
->values_printed
= 1;
2242 /* Prepares the regular expression REG from REGEXP.
2243 If REGEXP is NULL, it results in an empty regular expression. */
2246 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2250 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2252 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2258 /* Print all variables from the innermost up to the function block of FRAME.
2259 Print them with values to STREAM indented by NUM_TABS.
2260 If REGEXP is not NULL, only print local variables whose name
2262 If T_REGEXP is not NULL, only print local variables whose type
2264 If no local variables have been printed and !QUIET, prints a message
2265 explaining why no local variables could be printed.
2267 This function will invalidate FRAME. */
2270 print_frame_local_vars (struct frame_info
*frame
,
2272 const char *regexp
, const char *t_regexp
,
2273 int num_tabs
, struct ui_file
*stream
)
2275 struct print_variable_and_value_data cb_data
;
2276 const struct block
*block
;
2279 if (!get_frame_pc_if_available (frame
, &pc
))
2282 fprintf_filtered (stream
,
2283 _("PC unavailable, cannot determine locals.\n"));
2287 block
= get_frame_block (frame
, 0);
2291 fprintf_filtered (stream
, "No symbol table info available.\n");
2295 prepare_reg (regexp
, &cb_data
.preg
);
2296 prepare_reg (t_regexp
, &cb_data
.treg
);
2297 cb_data
.frame_id
= get_frame_id (frame
);
2298 cb_data
.num_tabs
= 4 * num_tabs
;
2299 cb_data
.stream
= stream
;
2300 cb_data
.values_printed
= 0;
2302 /* Temporarily change the selected frame to the given FRAME.
2303 This allows routines that rely on the selected frame instead
2304 of being given a frame as parameter to use the correct frame. */
2305 scoped_restore_selected_frame restore_selected_frame
;
2306 select_frame (frame
);
2308 iterate_over_block_local_vars (block
,
2309 do_print_variable_and_value
,
2312 if (!cb_data
.values_printed
&& !quiet
)
2314 if (regexp
== NULL
&& t_regexp
== NULL
)
2315 fprintf_filtered (stream
, _("No locals.\n"));
2317 fprintf_filtered (stream
, _("No matching locals.\n"));
2321 /* Implement the 'info locals' command. */
2324 info_locals_command (const char *args
, int from_tty
)
2326 info_print_options opts
;
2327 extract_info_print_options (&opts
, &args
);
2329 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2330 opts
.quiet
, args
, opts
.type_regexp
,
2334 /* Iterate over all the argument variables in block B. */
2337 iterate_over_block_arg_vars (const struct block
*b
,
2338 iterate_over_block_arg_local_vars_cb cb
,
2341 struct block_iterator iter
;
2342 struct symbol
*sym
, *sym2
;
2344 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2346 /* Don't worry about things which aren't arguments. */
2347 if (SYMBOL_IS_ARGUMENT (sym
))
2349 /* We have to look up the symbol because arguments can have
2350 two entries (one a parameter, one a local) and the one we
2351 want is the local, which lookup_symbol will find for us.
2352 This includes gcc1 (not gcc2) on the sparc when passing a
2353 small structure and gcc2 when the argument type is float
2354 and it is passed as a double and converted to float by
2355 the prologue (in the latter case the type of the LOC_ARG
2356 symbol is double and the type of the LOC_LOCAL symbol is
2357 float). There are also LOC_ARG/LOC_REGISTER pairs which
2358 are not combined in symbol-reading. */
2360 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2361 b
, VAR_DOMAIN
).symbol
;
2362 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2367 /* Print all argument variables of the function of FRAME.
2368 Print them with values to STREAM.
2369 If REGEXP is not NULL, only print argument variables whose name
2371 If T_REGEXP is not NULL, only print argument variables whose type
2373 If no argument variables have been printed and !QUIET, prints a message
2374 explaining why no argument variables could be printed.
2376 This function will invalidate FRAME. */
2379 print_frame_arg_vars (struct frame_info
*frame
,
2381 const char *regexp
, const char *t_regexp
,
2382 struct ui_file
*stream
)
2384 struct print_variable_and_value_data cb_data
;
2385 struct symbol
*func
;
2387 gdb::optional
<compiled_regex
> preg
;
2388 gdb::optional
<compiled_regex
> treg
;
2390 if (!get_frame_pc_if_available (frame
, &pc
))
2393 fprintf_filtered (stream
,
2394 _("PC unavailable, cannot determine args.\n"));
2398 func
= get_frame_function (frame
);
2402 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2406 prepare_reg (regexp
, &cb_data
.preg
);
2407 prepare_reg (t_regexp
, &cb_data
.treg
);
2408 cb_data
.frame_id
= get_frame_id (frame
);
2409 cb_data
.num_tabs
= 0;
2410 cb_data
.stream
= stream
;
2411 cb_data
.values_printed
= 0;
2413 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2414 do_print_variable_and_value
, &cb_data
);
2416 /* do_print_variable_and_value invalidates FRAME. */
2419 if (!cb_data
.values_printed
&& !quiet
)
2421 if (regexp
== NULL
&& t_regexp
== NULL
)
2422 fprintf_filtered (stream
, _("No arguments.\n"));
2424 fprintf_filtered (stream
, _("No matching arguments.\n"));
2428 /* Implement the 'info args' command. */
2431 info_args_command (const char *args
, int from_tty
)
2433 info_print_options opts
;
2434 extract_info_print_options (&opts
, &args
);
2436 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2437 opts
.quiet
, args
, opts
.type_regexp
, gdb_stdout
);
2440 /* Return the symbol-block in which the selected frame is executing.
2441 Can return zero under various legitimate circumstances.
2443 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2444 code address within the block returned. We use this to decide
2445 which macros are in scope. */
2447 const struct block
*
2448 get_selected_block (CORE_ADDR
*addr_in_block
)
2450 if (!has_stack_frames ())
2453 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2456 /* Find a frame a certain number of levels away from FRAME.
2457 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2458 Positive means go to earlier frames (up); negative, the reverse.
2459 The int that contains the number of levels is counted toward
2460 zero as the frames for those levels are found.
2461 If the top or bottom frame is reached, that frame is returned,
2462 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2463 how much farther the original request asked to go. */
2466 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2468 /* Going up is simple: just call get_prev_frame enough times or
2469 until the initial frame is reached. */
2470 while (*level_offset_ptr
> 0)
2472 struct frame_info
*prev
= get_prev_frame (frame
);
2476 (*level_offset_ptr
)--;
2480 /* Going down is just as simple. */
2481 while (*level_offset_ptr
< 0)
2483 struct frame_info
*next
= get_next_frame (frame
);
2487 (*level_offset_ptr
)++;
2494 /* Select the frame up one or COUNT_EXP stack levels from the
2495 previously selected frame, and print it briefly. */
2498 up_silently_base (const char *count_exp
)
2500 struct frame_info
*frame
;
2504 count
= parse_and_eval_long (count_exp
);
2506 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2507 if (count
!= 0 && count_exp
== NULL
)
2508 error (_("Initial frame selected; you cannot go up."));
2509 select_frame (frame
);
2513 up_silently_command (const char *count_exp
, int from_tty
)
2515 up_silently_base (count_exp
);
2519 up_command (const char *count_exp
, int from_tty
)
2521 up_silently_base (count_exp
);
2522 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2525 /* Select the frame down one or COUNT_EXP stack levels from the previously
2526 selected frame, and print it briefly. */
2529 down_silently_base (const char *count_exp
)
2531 struct frame_info
*frame
;
2535 count
= -parse_and_eval_long (count_exp
);
2537 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2538 if (count
!= 0 && count_exp
== NULL
)
2540 /* We only do this if COUNT_EXP is not specified. That way
2541 "down" means to really go down (and let me know if that is
2542 impossible), but "down 9999" can be used to mean go all the
2543 way down without getting an error. */
2545 error (_("Bottom (innermost) frame selected; you cannot go down."));
2548 select_frame (frame
);
2552 down_silently_command (const char *count_exp
, int from_tty
)
2554 down_silently_base (count_exp
);
2558 down_command (const char *count_exp
, int from_tty
)
2560 down_silently_base (count_exp
);
2561 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2565 return_command (const char *retval_exp
, int from_tty
)
2567 /* Initialize it just to avoid a GCC false warning. */
2568 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2569 struct frame_info
*thisframe
;
2570 struct gdbarch
*gdbarch
;
2571 struct symbol
*thisfun
;
2572 struct value
*return_value
= NULL
;
2573 struct value
*function
= NULL
;
2574 const char *query_prefix
= "";
2576 thisframe
= get_selected_frame ("No selected frame.");
2577 thisfun
= get_frame_function (thisframe
);
2578 gdbarch
= get_frame_arch (thisframe
);
2580 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2581 error (_("Can not force return from an inlined function."));
2583 /* Compute the return value. If the computation triggers an error,
2584 let it bail. If the return type can't be handled, set
2585 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2589 expression_up retval_expr
= parse_expression (retval_exp
);
2590 struct type
*return_type
= NULL
;
2592 /* Compute the return value. Should the computation fail, this
2593 call throws an error. */
2594 return_value
= evaluate_expression (retval_expr
.get ());
2596 /* Cast return value to the return type of the function. Should
2597 the cast fail, this call throws an error. */
2598 if (thisfun
!= NULL
)
2599 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2600 if (return_type
== NULL
)
2602 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2603 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2604 error (_("Return value type not available for selected "
2606 "Please use an explicit cast of the value to return."));
2607 return_type
= value_type (return_value
);
2609 return_type
= check_typedef (return_type
);
2610 return_value
= value_cast (return_type
, return_value
);
2612 /* Make sure the value is fully evaluated. It may live in the
2613 stack frame we're about to pop. */
2614 if (value_lazy (return_value
))
2615 value_fetch_lazy (return_value
);
2617 if (thisfun
!= NULL
)
2618 function
= read_var_value (thisfun
, NULL
, thisframe
);
2620 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2621 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2622 /* If the return-type is "void", don't try to find the
2623 return-value's location. However, do still evaluate the
2624 return expression so that, even when the expression result
2625 is discarded, side effects such as "return i++" still
2627 return_value
= NULL
;
2628 else if (thisfun
!= NULL
)
2630 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2631 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2632 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2634 query_prefix
= "The location at which to store the "
2635 "function's return value is unknown.\n"
2636 "If you continue, the return value "
2637 "that you specified will be ignored.\n";
2638 return_value
= NULL
;
2643 /* Does an interactive user really want to do this? Include
2644 information, such as how well GDB can handle the return value, in
2645 the query message. */
2650 if (thisfun
== NULL
)
2651 confirmed
= query (_("%sMake selected stack frame return now? "),
2655 if (TYPE_NO_RETURN (thisfun
->type
))
2656 warning (_("Function does not return normally to caller."));
2657 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2658 SYMBOL_PRINT_NAME (thisfun
));
2661 error (_("Not confirmed"));
2664 /* Discard the selected frame and all frames inner-to it. */
2665 frame_pop (get_selected_frame (NULL
));
2667 /* Store RETURN_VALUE in the just-returned register set. */
2668 if (return_value
!= NULL
)
2670 struct type
*return_type
= value_type (return_value
);
2671 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2673 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2674 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2675 gdbarch_return_value (cache_arch
, function
, return_type
,
2676 get_current_regcache (), NULL
/*read*/,
2677 value_contents (return_value
) /*write*/);
2680 /* If we are at the end of a call dummy now, pop the dummy frame
2682 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2683 frame_pop (get_current_frame ());
2685 select_frame (get_current_frame ());
2686 /* If interactive, print the frame that is now current. */
2688 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2691 /* Find the most inner frame in the current stack for a function called
2692 FUNCTION_NAME. If no matching frame is found return NULL. */
2694 static struct frame_info
*
2695 find_frame_for_function (const char *function_name
)
2697 /* Used to hold the lower and upper addresses for each of the
2698 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2699 struct function_bounds
2701 CORE_ADDR low
, high
;
2703 struct frame_info
*frame
;
2707 gdb_assert (function_name
!= NULL
);
2709 frame
= get_current_frame ();
2710 std::vector
<symtab_and_line
> sals
2711 = decode_line_with_current_source (function_name
,
2712 DECODE_LINE_FUNFIRSTLINE
);
2713 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2714 for (size_t i
= 0; i
< sals
.size (); i
++)
2716 if (sals
[i
].pspace
!= current_program_space
)
2717 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2718 else if (sals
[i
].pc
== 0
2719 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2720 &func_bounds
[i
].low
,
2721 &func_bounds
[i
].high
) == 0)
2722 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2727 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2728 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2729 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2733 frame
= find_relative_frame (frame
, &level
);
2736 while (!found
&& level
== 0);
2744 /* Implements the dbx 'func' command. */
2747 func_command (const char *arg
, int from_tty
)
2752 struct frame_info
*frame
= find_frame_for_function (arg
);
2754 error (_("'%s' not within current stack frame."), arg
);
2755 if (frame
!= get_selected_frame (NULL
))
2757 select_frame (frame
);
2758 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2762 /* The qcs command line flags for the "frame apply" commands. Keep
2763 this in sync with the "thread apply" commands. */
2765 using qcs_flag_option_def
2766 = gdb::option::flag_option_def
<qcs_flags
>;
2768 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2769 qcs_flag_option_def
{
2770 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2771 N_("Disables printing the frame location information."),
2774 qcs_flag_option_def
{
2775 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2776 N_("Print any error raised by COMMAND and continue."),
2779 qcs_flag_option_def
{
2780 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2781 N_("Silently ignore any errors or empty output produced by COMMAND."),
2785 /* Create an option_def_group array for all the "frame apply" options,
2786 with FLAGS and SET_BT_OPTS as context. */
2788 static inline std::array
<gdb::option::option_def_group
, 2>
2789 make_frame_apply_options_def_group (qcs_flags
*flags
,
2790 set_backtrace_options
*set_bt_opts
)
2793 { {fr_qcs_flags_option_defs
}, flags
},
2794 { {set_backtrace_option_defs
}, set_bt_opts
},
2798 /* Apply a GDB command to all stack frames, or a set of identified frames,
2799 or innermost COUNT frames.
2800 With a negative COUNT, apply command on outermost -COUNT frames.
2802 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2803 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2804 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2805 frame apply all -s p local_var_no_idea_in_which_frame
2806 If a frame has a local variable called
2807 local_var_no_idea_in_which_frame, print frame
2808 and value of local_var_no_idea_in_which_frame.
2809 frame apply all -s -q p local_var_no_idea_in_which_frame
2810 Same as before, but only print the variable value.
2811 frame apply level 2-5 0 4-7 -s p i = i + 1
2812 Adds 1 to the variable i in the specified frames.
2813 Note that i will be incremented twice in
2816 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2817 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2818 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2819 for error messages. */
2822 frame_apply_command_count (const char *which_command
,
2823 const char *cmd
, int from_tty
,
2824 struct frame_info
*trailing
, int count
)
2827 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2829 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2830 gdb::option::process_options
2831 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2833 validate_flags_qcs (which_command
, &flags
);
2835 if (cmd
== NULL
|| *cmd
== '\0')
2836 error (_("Please specify a command to apply on the selected frames"));
2838 /* The below will restore the current inferior/thread/frame.
2839 Usually, only the frame is effectively to be restored.
2840 But in case CMD switches of inferior/thread, better restore
2842 scoped_restore_current_thread restore_thread
;
2844 /* These options are handled quite deep in the unwind machinery, so
2845 we get to pass them down by swapping globals. */
2846 scoped_restore restore_set_backtrace_options
2847 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2849 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2856 std::string cmd_result
;
2858 /* In case CMD switches of inferior/thread/frame, the below
2859 restores the inferior/thread/frame. FI can then be
2860 set to the selected frame. */
2861 scoped_restore_current_thread restore_fi_current_frame
;
2863 cmd_result
= execute_command_to_string
2864 (cmd
, from_tty
, gdb_stdout
->term_out ());
2866 fi
= get_selected_frame (_("frame apply "
2867 "unable to get selected frame."));
2868 if (!flags
.silent
|| cmd_result
.length () > 0)
2871 print_stack_frame (fi
, 1, LOCATION
, 0);
2872 printf_filtered ("%s", cmd_result
.c_str ());
2875 catch (const gdb_exception_error
&ex
)
2877 fi
= get_selected_frame (_("frame apply "
2878 "unable to get selected frame."));
2882 print_stack_frame (fi
, 1, LOCATION
, 0);
2884 printf_filtered ("%s\n", ex
.what ());
2892 /* Completer for the "frame apply ..." commands. */
2895 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
2897 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
2898 if (gdb::option::complete_options
2899 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2902 complete_nested_command_line (tracker
, text
);
2905 /* Completer for the "frame apply" commands. */
2908 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
2909 completion_tracker
&tracker
,
2910 const char *text
, const char */
*word*/
)
2912 /* Do this explicitly because there's an early return below. */
2913 tracker
.set_use_custom_word_point (true);
2915 number_or_range_parser
levels (text
);
2917 /* Skip the LEVEL list to find the options and command args. */
2920 while (!levels
.finished ())
2922 /* Call for effect. */
2923 levels
.get_number ();
2925 if (levels
.in_range ())
2926 levels
.skip_range ();
2929 catch (const gdb_exception_error
&ex
)
2931 /* get_number throws if it parses a negative number, for
2932 example. But a seemingly negative number may be the start of
2933 an option instead. */
2936 const char *cmd
= levels
.cur_tok ();
2940 /* No level list yet. */
2944 /* Check if we're past a valid LEVEL already. */
2945 if (levels
.finished ()
2946 && cmd
> text
&& !isspace (cmd
[-1]))
2949 /* We're past LEVELs, advance word point. */
2950 tracker
.advance_custom_word_point_by (cmd
- text
);
2953 frame_apply_completer (tracker
, text
);
2956 /* Completer for the "frame apply all" command. */
2959 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
2960 completion_tracker
&tracker
,
2961 const char *text
, const char */
*word*/
)
2963 frame_apply_completer (tracker
, text
);
2966 /* Completer for the "frame apply COUNT" command. */
2969 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
2970 completion_tracker
&tracker
,
2971 const char *text
, const char */
*word*/
)
2973 const char *cmd
= text
;
2975 int count
= get_number_trailer (&cmd
, 0);
2979 /* Check if we're past a valid COUNT already. */
2980 if (cmd
> text
&& !isspace (cmd
[-1]))
2983 /* We're past COUNT, advance word point. */
2984 tracker
.advance_custom_word_point_by (cmd
- text
);
2987 frame_apply_completer (tracker
, text
);
2990 /* Implementation of the "frame apply level" command. */
2993 frame_apply_level_command (const char *cmd
, int from_tty
)
2995 if (!target_has_stack
)
2996 error (_("No stack."));
2998 bool level_found
= false;
2999 const char *levels_str
= cmd
;
3000 number_or_range_parser
levels (levels_str
);
3002 /* Skip the LEVEL list to find the flags and command args. */
3003 while (!levels
.finished ())
3005 /* Call for effect. */
3006 levels
.get_number ();
3009 if (levels
.in_range ())
3010 levels
.skip_range ();
3014 error (_("Missing or invalid LEVEL... argument"));
3016 cmd
= levels
.cur_tok ();
3018 /* Redo the LEVELS parsing, but applying COMMAND. */
3019 levels
.init (levels_str
);
3020 while (!levels
.finished ())
3022 const int level_beg
= levels
.get_number ();
3025 if (levels
.in_range ())
3027 n_frames
= levels
.end_value () - level_beg
+ 1;
3028 levels
.skip_range ();
3033 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3034 leading_innermost_frame (level_beg
), n_frames
);
3038 /* Implementation of the "frame apply all" command. */
3041 frame_apply_all_command (const char *cmd
, int from_tty
)
3043 if (!target_has_stack
)
3044 error (_("No stack."));
3046 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3047 get_current_frame (), INT_MAX
);
3050 /* Implementation of the "frame apply" command. */
3053 frame_apply_command (const char* cmd
, int from_tty
)
3056 struct frame_info
*trailing
;
3058 if (!target_has_stack
)
3059 error (_("No stack."));
3062 error (_("Missing COUNT argument."));
3063 count
= get_number_trailer (&cmd
, 0);
3065 error (_("Invalid COUNT argument."));
3069 trailing
= trailing_outermost_frame (-count
);
3073 trailing
= get_current_frame ();
3075 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3079 /* Implementation of the "faas" command. */
3082 faas_command (const char *cmd
, int from_tty
)
3084 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3085 execute_command (expanded
.c_str (), from_tty
);
3089 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3090 matching frame can be found. */
3092 static struct frame_info
*
3093 find_frame_for_address (CORE_ADDR address
)
3096 struct frame_info
*fid
;
3098 id
= frame_id_build_wild (address
);
3100 /* If (s)he specifies the frame with an address, he deserves
3101 what (s)he gets. Still, give the highest one that matches.
3102 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3104 for (fid
= get_current_frame ();
3106 fid
= get_prev_frame (fid
))
3108 if (frame_id_eq (id
, get_frame_id (fid
)))
3110 struct frame_info
*prev_frame
;
3114 prev_frame
= get_prev_frame (fid
);
3116 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3128 /* Commands with a prefix of `frame apply'. */
3129 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3131 /* Commands with a prefix of `frame'. */
3132 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3134 /* Commands with a prefix of `select frame'. */
3135 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3137 /* Commands with a prefix of `info frame'. */
3138 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3141 _initialize_stack (void)
3143 struct cmd_list_element
*cmd
;
3145 add_com ("return", class_stack
, return_command
, _("\
3146 Make selected stack frame return to its caller.\n\
3147 Control remains in the debugger, but when you continue\n\
3148 execution will resume in the frame above the one now selected.\n\
3149 If an argument is given, it is an expression for the value to return."));
3151 add_com ("up", class_stack
, up_command
, _("\
3152 Select and print stack frame that called this one.\n\
3153 An argument says how many frames up to go."));
3154 add_com ("up-silently", class_support
, up_silently_command
, _("\
3155 Same as the `up' command, but does not print anything.\n\
3156 This is useful in command scripts."));
3158 add_com ("down", class_stack
, down_command
, _("\
3159 Select and print stack frame called by this one.\n\
3160 An argument says how many frames down to go."));
3161 add_com_alias ("do", "down", class_stack
, 1);
3162 add_com_alias ("dow", "down", class_stack
, 1);
3163 add_com ("down-silently", class_support
, down_silently_command
, _("\
3164 Same as the `down' command, but does not print anything.\n\
3165 This is useful in command scripts."));
3167 add_prefix_cmd ("frame", class_stack
,
3168 &frame_cmd
.base_command
, _("\
3169 Select and print a stack frame.\n\
3170 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3171 A single numerical argument specifies the frame to select."),
3172 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3174 add_com_alias ("f", "frame", class_stack
, 1);
3176 #define FRAME_APPLY_OPTION_HELP "\
3177 Prints the frame location information followed by COMMAND output.\n\
3179 By default, an error raised during the execution of COMMAND\n\
3180 aborts \"frame apply\".\n\
3185 const auto frame_apply_opts
3186 = make_frame_apply_options_def_group (nullptr, nullptr);
3188 static std::string frame_apply_cmd_help
= gdb::option::build_help (N_("\
3189 Apply a command to a number of frames.\n\
3190 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3191 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3192 FRAME_APPLY_OPTION_HELP
),
3195 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3196 frame_apply_cmd_help
.c_str (),
3197 &frame_apply_cmd_list
, "frame apply ", 1,
3199 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3201 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (N_("\
3202 Apply a command to all frames.\n\
3204 Usage: frame apply all [OPTION]... COMMAND\n"
3205 FRAME_APPLY_OPTION_HELP
),
3208 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3209 frame_apply_all_cmd_help
.c_str (),
3210 &frame_apply_cmd_list
);
3211 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3213 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (N_("\
3214 Apply a command to a list of frames.\n\
3216 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3217 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3218 FRAME_APPLY_OPTION_HELP
),
3221 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3222 frame_apply_level_cmd_help
.c_str (),
3223 &frame_apply_cmd_list
);
3224 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3226 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3227 Apply a command to all frames (ignoring errors and empty output).\n\
3228 Usage: faas [OPTION]... COMMAND\n\
3229 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3230 See \"help frame apply all\" for available options."));
3231 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3233 add_prefix_cmd ("frame", class_stack
,
3234 &frame_cmd
.base_command
, _("\
3235 Select and print a stack frame.\n\
3236 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3237 A single numerical argument specifies the frame to select."),
3238 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3239 add_com_alias ("f", "frame", class_stack
, 1);
3241 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3243 Select and print a stack frame by stack address\n\
3245 Usage: frame address STACK-ADDRESS"),
3248 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3250 View a stack frame that might be outside the current backtrace.\n\
3252 Usage: frame view STACK-ADDRESS\n\
3253 frame view STACK-ADDRESS PC-ADDRESS"),
3256 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3258 Select and print a stack frame by function name.\n\
3260 Usage: frame function NAME\n\
3262 The innermost frame that visited function NAME is selected."),
3264 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3267 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3269 Select and print a stack frame by level.\n\
3271 Usage: frame level LEVEL"),
3274 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3275 &select_frame_cmd
.base_command
, _("\
3276 Select a stack frame without printing anything.\n\
3277 A single numerical argument specifies the frame to select."),
3278 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3279 &cli_suppress_notification
.user_selected_context
);
3281 add_cmd_suppress_notification ("address", class_stack
,
3282 &select_frame_cmd
.address
, _("\
3283 Select a stack frame by stack address.\n\
3285 Usage: select-frame address STACK-ADDRESS"),
3286 &select_frame_cmd_list
,
3287 &cli_suppress_notification
.user_selected_context
);
3290 add_cmd_suppress_notification ("view", class_stack
,
3291 &select_frame_cmd
.view
, _("\
3292 Select a stack frame that might be outside the current backtrace.\n\
3294 Usage: select-frame view STACK-ADDRESS\n\
3295 select-frame view STACK-ADDRESS PC-ADDRESS"),
3296 &select_frame_cmd_list
,
3297 &cli_suppress_notification
.user_selected_context
);
3299 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3300 &select_frame_cmd
.function
, _("\
3301 Select a stack frame by function name.\n\
3303 Usage: select-frame function NAME"),
3304 &select_frame_cmd_list
,
3305 &cli_suppress_notification
.user_selected_context
);
3306 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3308 add_cmd_suppress_notification ("level", class_stack
,
3309 &select_frame_cmd
.level
, _("\
3310 Select a stack frame by level.\n\
3312 Usage: select-frame level LEVEL"),
3313 &select_frame_cmd_list
,
3314 &cli_suppress_notification
.user_selected_context
);
3316 const auto backtrace_opts
3317 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3319 static std::string backtrace_help
3320 = gdb::option::build_help (N_("\
3321 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3322 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3326 For backward compatibility, the following qualifiers are supported:\n\
3328 full - same as -full option.\n\
3329 no-filters - same as -no-filters option.\n\
3330 hide - same as -hide.\n\
3332 With a negative COUNT, print outermost -COUNT frames."),
3335 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3337 backtrace_help
.c_str ());
3338 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3340 add_com_alias ("bt", "backtrace", class_stack
, 0);
3342 add_com_alias ("where", "backtrace", class_alias
, 0);
3343 add_info ("stack", backtrace_command
,
3344 _("Backtrace of the stack, or innermost COUNT frames."));
3345 add_info_alias ("s", "stack", 1);
3347 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3348 _("All about the selected stack frame.\n\
3349 With no arguments, displays information about the currently selected stack\n\
3350 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3351 the information is then printed about the specified frame."),
3352 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3353 add_info_alias ("f", "frame", 1);
3355 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3357 Print information about a stack frame selected by stack address.\n\
3359 Usage: info frame address STACK-ADDRESS"),
3360 &info_frame_cmd_list
);
3362 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3364 Print information about a stack frame outside the current backtrace.\n\
3366 Usage: info frame view STACK-ADDRESS\n\
3367 info frame view STACK-ADDRESS PC-ADDRESS"),
3368 &info_frame_cmd_list
);
3370 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3372 Print information about a stack frame selected by function name.\n\
3374 Usage: info frame function NAME"),
3375 &info_frame_cmd_list
);
3376 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3378 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3380 Print information about a stack frame selected by level.\n\
3382 Usage: info frame level LEVEL"),
3383 &info_frame_cmd_list
);
3385 cmd
= add_info ("locals", info_locals_command
,
3386 info_print_args_help (_("\
3387 All local variables of current stack frame or those matching REGEXPs.\n\
3388 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3389 Prints the local variables of the current stack frame.\n"),
3390 _("local variables")));
3391 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3392 cmd
= add_info ("args", info_args_command
,
3393 info_print_args_help (_("\
3394 All argument variables of current stack frame or those matching REGEXPs.\n\
3395 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3396 Prints the argument variables of the current stack frame.\n"),
3397 _("argument variables")));
3398 set_cmd_completer_handle_brkchars (cmd
, info_print_command_completer
);
3401 add_com ("func", class_stack
, func_command
, _("\
3402 Select the stack frame that contains NAME.\n\
3403 Usage: func NAME"));
3405 /* Install "set print raw frame-arguments", a deprecated spelling of
3406 "set print raw-frame-arguments". */
3407 cmd
= add_setshow_boolean_cmd
3408 ("frame-arguments", no_class
,
3409 &user_frame_print_options
.print_raw_frame_arguments
,
3411 Set whether to print frame arguments in raw form."), _("\
3412 Show whether to print frame arguments in raw form."), _("\
3413 If set, frame arguments are printed in raw form, bypassing any\n\
3414 pretty-printers for that value."),
3416 &setprintrawlist
, &showprintrawlist
);
3417 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3419 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3420 &disassemble_next_line
, _("\
3421 Set whether to disassemble next source line or insn when execution stops."),
3423 Show whether to disassemble next source line or insn when execution stops."),
3425 If ON, GDB will display disassembly of the next source line, in addition\n\
3426 to displaying the source line itself. If the next source line cannot\n\
3427 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3428 will display disassembly of next instruction instead of showing the\n\
3430 If AUTO, display disassembly of next instruction only if the source line\n\
3431 cannot be displayed.\n\
3432 If OFF (which is the default), never display the disassembly of the next\n\
3435 show_disassemble_next_line
,
3436 &setlist
, &showlist
);
3437 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3439 gdb::option::add_setshow_cmds_for_options
3440 (class_stack
, &user_frame_print_options
,
3441 frame_print_option_defs
, &setprintlist
, &showprintlist
);