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_int (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 /* In certain pathological cases, the symtabs give the wrong
1139 function (when we are in the first function in a file which
1140 is compiled without debugging symbols, the previous function
1141 is compiled with debugging symbols, and the "foo.o" symbol
1142 that is supposed to tell us where the file with debugging
1143 symbols ends has been truncated by ar because it is longer
1144 than 15 characters). This also occurs if the user uses asm()
1145 to create a function but not stabs for it (in a file compiled
1148 So look in the minimal symbol tables as well, and if it comes
1149 up with a larger address for the function use that instead.
1150 I don't think this can ever cause any problems; there
1151 shouldn't be any minimal symbols in the middle of a function;
1152 if this is ever changed many parts of GDB will need to be
1153 changed (and we'll create a find_pc_minimal_function or some
1156 struct bound_minimal_symbol msymbol
;
1158 /* Don't attempt to do this for inlined functions, which do not
1159 have a corresponding minimal symbol. */
1160 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1162 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1164 memset (&msymbol
, 0, sizeof (msymbol
));
1166 if (msymbol
.minsym
!= NULL
1167 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1168 > BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func
))))
1170 /* We also don't know anything about the function besides
1171 its address and name. */
1173 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1174 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1178 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1180 *funlang
= SYMBOL_LANGUAGE (func
);
1183 if (*funlang
== language_cplus
)
1185 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1186 to display the demangled name that we already have
1187 stored in the symbol table, but we stored a version
1188 with DMGL_PARAMS turned on, and here we don't want to
1189 display parameters. So remove the parameters. */
1190 funname
= cp_remove_params (print_name
);
1193 /* If we didn't hit the C++ case above, set *funname
1195 if (funname
== NULL
)
1196 funname
.reset (xstrdup (print_name
));
1201 struct bound_minimal_symbol msymbol
;
1204 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1207 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1208 if (msymbol
.minsym
!= NULL
)
1210 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1211 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1219 print_frame (const frame_print_options
&fp_opts
,
1220 frame_info
*frame
, int print_level
,
1221 enum print_what print_what
, int print_args
,
1222 struct symtab_and_line sal
)
1224 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1225 struct ui_out
*uiout
= current_uiout
;
1226 enum language funlang
= language_unknown
;
1227 struct value_print_options opts
;
1228 struct symbol
*func
;
1232 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1234 gdb::unique_xmalloc_ptr
<char> funname
1235 = find_frame_funname (frame
, &funlang
, &func
);
1237 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1241 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1246 uiout
->field_fmt_int (2, ui_left
, "level",
1247 frame_relative_level (frame
));
1249 get_user_print_options (&opts
);
1250 if (opts
.addressprint
)
1252 || frame_show_address (frame
, sal
)
1253 || print_what
== LOC_AND_ADDRESS
)
1255 annotate_frame_address ();
1257 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1259 uiout
->field_string ("addr", "<unavailable>",
1260 ui_out_style_kind::ADDRESS
);
1261 annotate_frame_address_end ();
1262 uiout
->text (" in ");
1264 annotate_frame_function_name ();
1267 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1268 funlang
, DMGL_ANSI
);
1269 uiout
->field_stream ("func", stb
, ui_out_style_kind::FUNCTION
);
1270 uiout
->wrap_hint (" ");
1271 annotate_frame_args ();
1278 if (gdbarch_frame_num_args_p (gdbarch
))
1280 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1281 gdb_assert (numargs
>= 0);
1287 ui_out_emit_list
list_emitter (uiout
, "args");
1290 print_frame_args (fp_opts
, func
, frame
, numargs
, gdb_stdout
);
1292 catch (const gdb_exception_error
&e
)
1296 /* FIXME: ARGS must be a list. If one argument is a string it
1297 will have " that will not be properly escaped. */
1304 const char *filename_display
;
1306 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1307 annotate_frame_source_begin ();
1308 uiout
->wrap_hint (" ");
1309 uiout
->text (" at ");
1310 annotate_frame_source_file ();
1311 uiout
->field_string ("file", filename_display
, ui_out_style_kind::FILE);
1312 if (uiout
->is_mi_like_p ())
1314 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1316 uiout
->field_string ("fullname", fullname
);
1318 annotate_frame_source_file_end ();
1320 annotate_frame_source_line ();
1321 uiout
->field_int ("line", sal
.line
);
1322 annotate_frame_source_end ();
1325 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1327 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1328 get_frame_pc (frame
));
1332 annotate_frame_where ();
1333 uiout
->wrap_hint (" ");
1334 uiout
->text (" from ");
1335 uiout
->field_string ("from", lib
);
1338 if (uiout
->is_mi_like_p ())
1339 uiout
->field_string ("arch",
1340 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1347 /* Completion function for "frame function", "info frame function", and
1348 "select-frame function" commands. */
1351 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1352 completion_tracker
&tracker
,
1353 const char *text
, const char *word
)
1355 /* This is used to complete function names within a stack. It would be
1356 nice if we only offered functions that were actually in the stack.
1357 However, this would mean unwinding the stack to completion, which
1358 could take too long, or on a corrupted stack, possibly not end.
1359 Instead, we offer all symbol names as a safer choice. */
1360 collect_symbol_completion_matches (tracker
,
1361 complete_symbol_mode::EXPRESSION
,
1362 symbol_name_match_type::EXPRESSION
,
1366 /* Core of all the "info frame" sub-commands. Print information about a
1367 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1368 frame specification, they just entered 'info frame'. If the user did
1369 provide a frame specification (for example 'info frame 0', 'info frame
1370 level 1') then SELECTED_FRAME_P will be false. */
1373 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1375 struct symbol
*func
;
1377 struct frame_info
*calling_frame_info
;
1379 const char *funname
= 0;
1380 enum language funlang
= language_unknown
;
1381 const char *pc_regname
;
1382 struct gdbarch
*gdbarch
;
1385 /* Initialize it to avoid "may be used uninitialized" warning. */
1386 CORE_ADDR caller_pc
= 0;
1387 int caller_pc_p
= 0;
1389 gdbarch
= get_frame_arch (fi
);
1391 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1392 is not a good name. */
1393 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1394 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1395 easily not match that of the internal value returned by
1397 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1399 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1400 architectures will often have a hardware register called "pc",
1401 and that register's value, again, can easily not match
1405 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1406 func
= get_frame_function (fi
);
1407 symtab_and_line sal
= find_frame_sal (fi
);
1409 gdb::unique_xmalloc_ptr
<char> func_only
;
1412 funname
= SYMBOL_PRINT_NAME (func
);
1413 funlang
= SYMBOL_LANGUAGE (func
);
1414 if (funlang
== language_cplus
)
1416 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1417 to display the demangled name that we already have
1418 stored in the symbol table, but we stored a version
1419 with DMGL_PARAMS turned on, and here we don't want to
1420 display parameters. So remove the parameters. */
1421 func_only
= cp_remove_params (funname
);
1424 funname
= func_only
.get ();
1427 else if (frame_pc_p
)
1429 struct bound_minimal_symbol msymbol
;
1431 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1432 if (msymbol
.minsym
!= NULL
)
1434 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1435 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1438 calling_frame_info
= get_prev_frame (fi
);
1440 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1442 printf_filtered (_("Stack level %d, frame at "),
1443 frame_relative_level (fi
));
1447 printf_filtered (_("Stack frame at "));
1449 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1450 printf_filtered (":\n");
1451 printf_filtered (" %s = ", pc_regname
);
1453 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1455 fputs_filtered ("<unavailable>", gdb_stdout
);
1460 printf_filtered (" in ");
1461 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1462 DMGL_ANSI
| DMGL_PARAMS
);
1466 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1468 puts_filtered ("; ");
1470 printf_filtered ("saved %s = ", pc_regname
);
1472 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1473 val_print_not_saved (gdb_stdout
);
1478 caller_pc
= frame_unwind_caller_pc (fi
);
1481 catch (const gdb_exception_error
&ex
)
1485 case NOT_AVAILABLE_ERROR
:
1486 val_print_unavailable (gdb_stdout
);
1488 case OPTIMIZED_OUT_ERROR
:
1489 val_print_not_saved (gdb_stdout
);
1492 fprintf_filtered (gdb_stdout
, _("<error: %s>"),
1500 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1501 printf_filtered ("\n");
1503 if (calling_frame_info
== NULL
)
1505 enum unwind_stop_reason reason
;
1507 reason
= get_frame_unwind_stop_reason (fi
);
1508 if (reason
!= UNWIND_NO_REASON
)
1509 printf_filtered (_(" Outermost frame: %s\n"),
1510 frame_stop_reason_string (fi
));
1512 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1513 puts_filtered (" tail call frame");
1514 else if (get_frame_type (fi
) == INLINE_FRAME
)
1515 printf_filtered (" inlined into frame %d",
1516 frame_relative_level (get_prev_frame (fi
)));
1519 printf_filtered (" called by frame at ");
1520 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1523 if (get_next_frame (fi
) && calling_frame_info
)
1524 puts_filtered (",");
1526 if (get_next_frame (fi
))
1528 printf_filtered (" caller of frame at ");
1529 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1532 if (get_next_frame (fi
) || calling_frame_info
)
1533 puts_filtered ("\n");
1536 printf_filtered (" source language %s.\n",
1537 language_str (s
->language
));
1540 /* Address of the argument list for this frame, or 0. */
1541 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1542 /* Number of args for this frame, or -1 if unknown. */
1546 printf_filtered (" Arglist at unknown address.\n");
1549 printf_filtered (" Arglist at ");
1550 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1551 printf_filtered (",");
1553 if (!gdbarch_frame_num_args_p (gdbarch
))
1556 puts_filtered (" args: ");
1560 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1561 gdb_assert (numargs
>= 0);
1563 puts_filtered (" no args.");
1564 else if (numargs
== 1)
1565 puts_filtered (" 1 arg: ");
1567 printf_filtered (" %d args: ", numargs
);
1569 print_frame_args (user_frame_print_options
,
1570 func
, fi
, numargs
, gdb_stdout
);
1571 puts_filtered ("\n");
1575 /* Address of the local variables for this frame, or 0. */
1576 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1579 printf_filtered (" Locals at unknown address,");
1582 printf_filtered (" Locals at ");
1583 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1584 printf_filtered (",");
1588 /* Print as much information as possible on the location of all the
1594 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1596 /* The sp is special; what's displayed isn't the save address, but
1597 the value of the previous frame's sp. This is a legacy thing,
1598 at one stage the frame cached the previous frame's SP instead
1599 of its address, hence it was easiest to just display the cached
1603 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1604 gdb_assert (value
!= NULL
);
1606 if (!value_optimized_out (value
) && value_entirely_available (value
))
1608 if (VALUE_LVAL (value
) == not_lval
)
1611 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1612 int sp_size
= register_size (gdbarch
, sp_regnum
);
1614 sp
= extract_unsigned_integer (value_contents_all (value
),
1615 sp_size
, byte_order
);
1617 printf_filtered (" Previous frame's sp is ");
1618 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1619 printf_filtered ("\n");
1621 else if (VALUE_LVAL (value
) == lval_memory
)
1623 printf_filtered (" Previous frame's sp at ");
1624 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1626 printf_filtered ("\n");
1628 else if (VALUE_LVAL (value
) == lval_register
)
1630 printf_filtered (" Previous frame's sp in %s\n",
1631 gdbarch_register_name (gdbarch
,
1632 VALUE_REGNUM (value
)));
1635 release_value (value
);
1638 /* else keep quiet. */
1642 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1643 for (i
= 0; i
< numregs
; i
++)
1645 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1647 enum lval_type lval
;
1653 /* Find out the location of the saved register without
1654 fetching the corresponding value. */
1655 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1656 &lval
, &addr
, &realnum
, NULL
);
1657 /* For moment, only display registers that were saved on the
1659 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1662 puts_filtered (" Saved registers:\n ");
1664 puts_filtered (",");
1666 printf_filtered (" %s at ",
1667 gdbarch_register_name (gdbarch
, i
));
1668 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1672 if (count
|| need_nl
)
1673 puts_filtered ("\n");
1677 /* Return the innermost frame at level LEVEL. */
1679 static struct frame_info
*
1680 leading_innermost_frame (int level
)
1682 struct frame_info
*leading
;
1684 leading
= get_current_frame ();
1686 gdb_assert (level
>= 0);
1688 while (leading
!= nullptr && level
)
1691 leading
= get_prev_frame (leading
);
1698 /* Return the starting frame needed to handle COUNT outermost frames. */
1700 static struct frame_info
*
1701 trailing_outermost_frame (int count
)
1703 struct frame_info
*current
;
1704 struct frame_info
*trailing
;
1706 trailing
= get_current_frame ();
1708 gdb_assert (count
> 0);
1711 while (current
!= nullptr && count
--)
1714 current
= get_prev_frame (current
);
1717 /* Will stop when CURRENT reaches the top of the stack.
1718 TRAILING will be COUNT below it. */
1719 while (current
!= nullptr)
1722 trailing
= get_prev_frame (trailing
);
1723 current
= get_prev_frame (current
);
1729 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1733 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1735 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1737 if (get_selected_frame_if_set () != prev_frame
)
1738 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1744 select_frame_for_mi (struct frame_info
*fi
)
1746 select_frame_command_core (fi
, false /* Ignored. */);
1749 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1750 means we change frame send out a change notification (otherwise, just
1751 reprint the current frame summary). */
1754 frame_command_core (struct frame_info
*fi
, bool ignored
)
1756 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1759 if (get_selected_frame_if_set () != prev_frame
)
1760 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1762 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1765 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1766 common set of sub-commands that allow a specific frame to be selected.
1767 All of the sub-command functions are static methods within this class
1768 template which is then instantiated below. The template parameter is a
1769 callback used to implement the functionality of the base command
1770 ('frame', 'select-frame', or 'info frame').
1772 In the template parameter FI is the frame being selected. The
1773 SELECTED_FRAME_P flag is true if the frame being selected was done by
1774 default, which happens when the user uses the base command with no
1775 arguments. For example the commands 'info frame', 'select-frame',
1776 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1777 SELECTED_FRAME_P is false. */
1779 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1780 class frame_command_helper
1784 /* The "frame level" family of commands. The ARG is an integer that is
1785 the frame's level in the stack. */
1787 level (const char *arg
, int from_tty
)
1789 int level
= value_as_long (parse_and_eval (arg
));
1790 struct frame_info
*fid
1791 = find_relative_frame (get_current_frame (), &level
);
1793 error (_("No frame at level %s."), arg
);
1797 /* The "frame address" family of commands. ARG is a stack-pointer
1798 address for an existing frame. This command does not allow new
1799 frames to be created. */
1802 address (const char *arg
, int from_tty
)
1804 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1805 struct frame_info
*fid
= find_frame_for_address (addr
);
1807 error (_("No frame at address %s."), arg
);
1811 /* The "frame view" family of commands. ARG is one or two addresses and
1812 is used to view a frame that might be outside the current backtrace.
1813 The addresses are stack-pointer address, and (optional) pc-address. */
1816 view (const char *args
, int from_tty
)
1818 struct frame_info
*fid
;
1821 error (_("Missing address argument to view a frame"));
1823 gdb_argv
argv (args
);
1825 if (argv
.count () == 2)
1829 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1830 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1831 fid
= create_new_frame (addr
[0], addr
[1]);
1835 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1836 fid
= create_new_frame (addr
, false);
1841 /* The "frame function" family of commands. ARG is the name of a
1842 function within the stack, the first function (searching from frame
1843 0) with that name will be selected. */
1846 function (const char *arg
, int from_tty
)
1849 error (_("Missing function name argument"));
1850 struct frame_info
*fid
= find_frame_for_function (arg
);
1852 error (_("No frame for function \"%s\"."), arg
);
1856 /* The "frame" base command, that is, when no sub-command is specified.
1857 If one argument is provided then we assume that this is a frame's
1858 level as historically, this was the supported command syntax that was
1861 If no argument is provided, then the current frame is selected. */
1864 base_command (const char *arg
, int from_tty
)
1867 FPTR (get_selected_frame (_("No stack.")), true);
1869 level (arg
, from_tty
);
1873 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1874 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1876 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1877 static frame_command_helper
<frame_command_core
> frame_cmd
;
1878 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1880 /* Print briefly all stack frames or just the innermost COUNT_EXP
1884 backtrace_command_1 (const frame_print_options
&fp_opts
,
1885 const backtrace_cmd_options
&bt_opts
,
1886 const char *count_exp
, int from_tty
)
1889 struct frame_info
*fi
;
1891 int py_start
= 0, py_end
= 0;
1892 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1894 if (!target_has_stack
)
1895 error (_("No stack."));
1899 count
= parse_and_eval_long (count_exp
);
1905 /* The argument to apply_ext_lang_frame_filter is the number
1906 of the final frame to print, and frames start at 0. */
1916 frame_filter_flags flags
= 0;
1919 flags
|= PRINT_LOCALS
;
1921 flags
|= PRINT_HIDE
;
1923 if (!bt_opts
.no_filters
)
1925 enum ext_lang_frame_args arg_type
;
1927 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1929 flags
|= PRINT_MORE_FRAMES
;
1931 if (fp_opts
.print_frame_arguments
== print_frame_arguments_scalars
)
1932 arg_type
= CLI_SCALAR_VALUES
;
1933 else if (fp_opts
.print_frame_arguments
== print_frame_arguments_all
)
1934 arg_type
= CLI_ALL_VALUES
;
1936 arg_type
= NO_VALUES
;
1938 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1939 arg_type
, current_uiout
,
1943 /* Run the inbuilt backtrace if there are no filters registered, or
1944 "-no-filters" has been specified from the command. */
1945 if (bt_opts
.no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1947 struct frame_info
*trailing
;
1949 /* The following code must do two things. First, it must set the
1950 variable TRAILING to the frame from which we should start
1951 printing. Second, it must set the variable count to the number
1952 of frames which we should print, or -1 if all of them. */
1954 if (count_exp
!= NULL
&& count
< 0)
1956 trailing
= trailing_outermost_frame (-count
);
1960 trailing
= get_current_frame ();
1962 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
1966 /* Don't use print_stack_frame; if an error() occurs it probably
1967 means further attempts to backtrace would fail (on the other
1968 hand, perhaps the code does or could be fixed to make sure
1969 the frame->prev field gets set to NULL in that case). */
1971 print_frame_info (fp_opts
, fi
, 1, LOCATION
, 1, 0);
1972 if ((flags
& PRINT_LOCALS
) != 0)
1974 struct frame_id frame_id
= get_frame_id (fi
);
1976 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
1978 /* print_frame_local_vars invalidates FI. */
1979 fi
= frame_find_by_id (frame_id
);
1983 warning (_("Unable to restore previously selected frame."));
1988 /* Save the last frame to check for error conditions. */
1992 /* If we've stopped before the end, mention that. */
1994 printf_filtered (_("(More stack frames follow...)\n"));
1996 /* If we've run out of frames, and the reason appears to be an error
1997 condition, print it. */
1998 if (fi
== NULL
&& trailing
!= NULL
)
2000 enum unwind_stop_reason reason
;
2002 reason
= get_frame_unwind_stop_reason (trailing
);
2003 if (reason
>= UNWIND_FIRST_ERROR
)
2004 printf_filtered (_("Backtrace stopped: %s\n"),
2005 frame_stop_reason_string (trailing
));
2010 /* Create an option_def_group array grouping all the "backtrace"
2011 options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts. */
2013 static inline std::array
<gdb::option::option_def_group
, 3>
2014 make_backtrace_options_def_group (frame_print_options
*fp_opts
,
2015 backtrace_cmd_options
*bt_cmd_opts
,
2016 set_backtrace_options
*set_bt_opts
)
2019 { {frame_print_option_defs
}, fp_opts
},
2020 { {set_backtrace_option_defs
}, set_bt_opts
},
2021 { {backtrace_command_option_defs
}, bt_cmd_opts
}
2025 /* Parse the backtrace command's qualifiers. Returns ARG advanced
2026 past the qualifiers, if any. BT_CMD_OPTS, if not null, is used to
2027 store the parsed qualifiers. */
2030 parse_backtrace_qualifiers (const char *arg
,
2031 backtrace_cmd_options
*bt_cmd_opts
= nullptr)
2035 const char *save_arg
= arg
;
2036 std::string this_arg
= extract_arg (&arg
);
2038 if (this_arg
.empty ())
2041 if (subset_compare (this_arg
.c_str (), "no-filters"))
2043 if (bt_cmd_opts
!= nullptr)
2044 bt_cmd_opts
->no_filters
= true;
2046 else if (subset_compare (this_arg
.c_str (), "full"))
2048 if (bt_cmd_opts
!= nullptr)
2049 bt_cmd_opts
->full
= true;
2051 else if (subset_compare (this_arg
.c_str (), "hide"))
2053 if (bt_cmd_opts
!= nullptr)
2054 bt_cmd_opts
->hide
= true;
2058 /* Not a recognized qualifier, so stop. */
2065 backtrace_command (const char *arg
, int from_tty
)
2067 frame_print_options fp_opts
= user_frame_print_options
;
2068 backtrace_cmd_options bt_cmd_opts
;
2069 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2072 = make_backtrace_options_def_group (&fp_opts
, &bt_cmd_opts
, &set_bt_opts
);
2073 gdb::option::process_options
2074 (&arg
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, grp
);
2076 /* Parse non-'-'-prefixed qualifiers, for backwards
2080 arg
= parse_backtrace_qualifiers (arg
, &bt_cmd_opts
);
2085 /* These options are handled quite deep in the unwind machinery, so
2086 we get to pass them down by swapping globals. */
2087 scoped_restore restore_set_backtrace_options
2088 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2090 backtrace_command_1 (fp_opts
, bt_cmd_opts
, arg
, from_tty
);
2093 /* Completer for the "backtrace" command. */
2096 backtrace_command_completer (struct cmd_list_element
*ignore
,
2097 completion_tracker
&tracker
,
2098 const char *text
, const char */
*word*/
)
2101 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2102 if (gdb::option::complete_options
2103 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2108 const char *p
= skip_to_space (text
);
2111 static const char *const backtrace_cmd_qualifier_choices
[] = {
2112 "full", "no-filters", "hide", nullptr,
2114 complete_on_enum (tracker
, backtrace_cmd_qualifier_choices
,
2117 if (tracker
.have_completions ())
2122 const char *cmd
= parse_backtrace_qualifiers (text
);
2123 tracker
.advance_custom_word_point_by (cmd
- text
);
2128 const char *word
= advance_to_expression_complete_word_point (tracker
, text
);
2129 expression_completer (ignore
, tracker
, text
, word
);
2132 /* Iterate over the local variables of a block B, calling CB with
2136 iterate_over_block_locals (const struct block
*b
,
2137 iterate_over_block_arg_local_vars_cb cb
,
2140 struct block_iterator iter
;
2143 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2145 switch (SYMBOL_CLASS (sym
))
2151 case LOC_OPTIMIZED_OUT
:
2152 if (SYMBOL_IS_ARGUMENT (sym
))
2154 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
2156 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
2160 /* Ignore symbols which are not locals. */
2167 /* Same, but print labels. */
2170 /* Commented out, as the code using this function has also been
2171 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2172 was commented out in the first place. The discussion introducing
2173 this change (2007-12-04: Support lexical blocks and function bodies
2174 that occupy non-contiguous address ranges) did not explain why
2175 this change was made. */
2177 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2178 int *have_default
, struct ui_file
*stream
)
2180 struct block_iterator iter
;
2182 int values_printed
= 0;
2184 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2186 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2192 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2194 struct symtab_and_line sal
;
2195 struct value_print_options opts
;
2197 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2199 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2200 get_user_print_options (&opts
);
2201 if (opts
.addressprint
)
2203 fprintf_filtered (stream
, " ");
2204 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2207 fprintf_filtered (stream
, " in file %s, line %d\n",
2208 sal
.symtab
->filename
, sal
.line
);
2212 return values_printed
;
2216 /* Iterate over all the local variables in block B, including all its
2217 superblocks, stopping when the top-level block is reached. */
2220 iterate_over_block_local_vars (const struct block
*block
,
2221 iterate_over_block_arg_local_vars_cb cb
,
2226 iterate_over_block_locals (block
, cb
, cb_data
);
2227 /* After handling the function's top-level block, stop. Don't
2228 continue to its superblock, the block of per-file
2230 if (BLOCK_FUNCTION (block
))
2232 block
= BLOCK_SUPERBLOCK (block
);
2236 /* Data to be passed around in the calls to the locals and args
2239 struct print_variable_and_value_data
2241 gdb::optional
<compiled_regex
> preg
;
2242 gdb::optional
<compiled_regex
> treg
;
2243 struct frame_id frame_id
;
2245 struct ui_file
*stream
;
2249 /* The callback for the locals and args iterators. */
2252 do_print_variable_and_value (const char *print_name
,
2256 struct print_variable_and_value_data
*p
2257 = (struct print_variable_and_value_data
*) cb_data
;
2258 struct frame_info
*frame
;
2260 if (p
->preg
.has_value ()
2261 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2264 if (p
->treg
.has_value ()
2265 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2268 frame
= frame_find_by_id (p
->frame_id
);
2271 warning (_("Unable to restore previously selected frame."));
2275 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2277 /* print_variable_and_value invalidates FRAME. */
2280 p
->values_printed
= 1;
2283 /* Prepares the regular expression REG from REGEXP.
2284 If REGEXP is NULL, it results in an empty regular expression. */
2287 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2291 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2293 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2299 /* Print all variables from the innermost up to the function block of FRAME.
2300 Print them with values to STREAM indented by NUM_TABS.
2301 If REGEXP is not NULL, only print local variables whose name
2303 If T_REGEXP is not NULL, only print local variables whose type
2305 If no local variables have been printed and !QUIET, prints a message
2306 explaining why no local variables could be printed.
2308 This function will invalidate FRAME. */
2311 print_frame_local_vars (struct frame_info
*frame
,
2313 const char *regexp
, const char *t_regexp
,
2314 int num_tabs
, struct ui_file
*stream
)
2316 struct print_variable_and_value_data cb_data
;
2317 const struct block
*block
;
2320 if (!get_frame_pc_if_available (frame
, &pc
))
2323 fprintf_filtered (stream
,
2324 _("PC unavailable, cannot determine locals.\n"));
2328 block
= get_frame_block (frame
, 0);
2332 fprintf_filtered (stream
, "No symbol table info available.\n");
2336 prepare_reg (regexp
, &cb_data
.preg
);
2337 prepare_reg (t_regexp
, &cb_data
.treg
);
2338 cb_data
.frame_id
= get_frame_id (frame
);
2339 cb_data
.num_tabs
= 4 * num_tabs
;
2340 cb_data
.stream
= stream
;
2341 cb_data
.values_printed
= 0;
2343 /* Temporarily change the selected frame to the given FRAME.
2344 This allows routines that rely on the selected frame instead
2345 of being given a frame as parameter to use the correct frame. */
2346 scoped_restore_selected_frame restore_selected_frame
;
2347 select_frame (frame
);
2349 iterate_over_block_local_vars (block
,
2350 do_print_variable_and_value
,
2353 if (!cb_data
.values_printed
&& !quiet
)
2355 if (regexp
== NULL
&& t_regexp
== NULL
)
2356 fprintf_filtered (stream
, _("No locals.\n"));
2358 fprintf_filtered (stream
, _("No matching locals.\n"));
2363 info_locals_command (const char *args
, int from_tty
)
2366 std::string t_regexp
;
2370 && extract_info_print_args (&args
, &quiet
, ®exp
, &t_regexp
))
2374 report_unrecognized_option_error ("info locals", args
);
2376 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2378 regexp
.empty () ? NULL
: regexp
.c_str (),
2379 t_regexp
.empty () ? NULL
: t_regexp
.c_str (),
2383 /* Iterate over all the argument variables in block B. */
2386 iterate_over_block_arg_vars (const struct block
*b
,
2387 iterate_over_block_arg_local_vars_cb cb
,
2390 struct block_iterator iter
;
2391 struct symbol
*sym
, *sym2
;
2393 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2395 /* Don't worry about things which aren't arguments. */
2396 if (SYMBOL_IS_ARGUMENT (sym
))
2398 /* We have to look up the symbol because arguments can have
2399 two entries (one a parameter, one a local) and the one we
2400 want is the local, which lookup_symbol will find for us.
2401 This includes gcc1 (not gcc2) on the sparc when passing a
2402 small structure and gcc2 when the argument type is float
2403 and it is passed as a double and converted to float by
2404 the prologue (in the latter case the type of the LOC_ARG
2405 symbol is double and the type of the LOC_LOCAL symbol is
2406 float). There are also LOC_ARG/LOC_REGISTER pairs which
2407 are not combined in symbol-reading. */
2409 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2410 b
, VAR_DOMAIN
).symbol
;
2411 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2416 /* Print all argument variables of the function of FRAME.
2417 Print them with values to STREAM.
2418 If REGEXP is not NULL, only print argument variables whose name
2420 If T_REGEXP is not NULL, only print argument variables whose type
2422 If no argument variables have been printed and !QUIET, prints a message
2423 explaining why no argument variables could be printed.
2425 This function will invalidate FRAME. */
2428 print_frame_arg_vars (struct frame_info
*frame
,
2430 const char *regexp
, const char *t_regexp
,
2431 struct ui_file
*stream
)
2433 struct print_variable_and_value_data cb_data
;
2434 struct symbol
*func
;
2436 gdb::optional
<compiled_regex
> preg
;
2437 gdb::optional
<compiled_regex
> treg
;
2439 if (!get_frame_pc_if_available (frame
, &pc
))
2442 fprintf_filtered (stream
,
2443 _("PC unavailable, cannot determine args.\n"));
2447 func
= get_frame_function (frame
);
2451 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2455 prepare_reg (regexp
, &cb_data
.preg
);
2456 prepare_reg (t_regexp
, &cb_data
.treg
);
2457 cb_data
.frame_id
= get_frame_id (frame
);
2458 cb_data
.num_tabs
= 0;
2459 cb_data
.stream
= stream
;
2460 cb_data
.values_printed
= 0;
2462 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2463 do_print_variable_and_value
, &cb_data
);
2465 /* do_print_variable_and_value invalidates FRAME. */
2468 if (!cb_data
.values_printed
&& !quiet
)
2470 if (regexp
== NULL
&& t_regexp
== NULL
)
2471 fprintf_filtered (stream
, _("No arguments.\n"));
2473 fprintf_filtered (stream
, _("No matching arguments.\n"));
2478 info_args_command (const char *args
, int from_tty
)
2481 std::string t_regexp
;
2485 && extract_info_print_args (&args
, &quiet
, ®exp
, &t_regexp
))
2489 report_unrecognized_option_error ("info args", args
);
2492 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2494 regexp
.empty () ? NULL
: regexp
.c_str (),
2495 t_regexp
.empty () ? NULL
: t_regexp
.c_str (),
2499 /* Return the symbol-block in which the selected frame is executing.
2500 Can return zero under various legitimate circumstances.
2502 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2503 code address within the block returned. We use this to decide
2504 which macros are in scope. */
2506 const struct block
*
2507 get_selected_block (CORE_ADDR
*addr_in_block
)
2509 if (!has_stack_frames ())
2512 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2515 /* Find a frame a certain number of levels away from FRAME.
2516 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2517 Positive means go to earlier frames (up); negative, the reverse.
2518 The int that contains the number of levels is counted toward
2519 zero as the frames for those levels are found.
2520 If the top or bottom frame is reached, that frame is returned,
2521 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2522 how much farther the original request asked to go. */
2525 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2527 /* Going up is simple: just call get_prev_frame enough times or
2528 until the initial frame is reached. */
2529 while (*level_offset_ptr
> 0)
2531 struct frame_info
*prev
= get_prev_frame (frame
);
2535 (*level_offset_ptr
)--;
2539 /* Going down is just as simple. */
2540 while (*level_offset_ptr
< 0)
2542 struct frame_info
*next
= get_next_frame (frame
);
2546 (*level_offset_ptr
)++;
2553 /* Select the frame up one or COUNT_EXP stack levels from the
2554 previously selected frame, and print it briefly. */
2557 up_silently_base (const char *count_exp
)
2559 struct frame_info
*frame
;
2563 count
= parse_and_eval_long (count_exp
);
2565 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2566 if (count
!= 0 && count_exp
== NULL
)
2567 error (_("Initial frame selected; you cannot go up."));
2568 select_frame (frame
);
2572 up_silently_command (const char *count_exp
, int from_tty
)
2574 up_silently_base (count_exp
);
2578 up_command (const char *count_exp
, int from_tty
)
2580 up_silently_base (count_exp
);
2581 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2584 /* Select the frame down one or COUNT_EXP stack levels from the previously
2585 selected frame, and print it briefly. */
2588 down_silently_base (const char *count_exp
)
2590 struct frame_info
*frame
;
2594 count
= -parse_and_eval_long (count_exp
);
2596 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2597 if (count
!= 0 && count_exp
== NULL
)
2599 /* We only do this if COUNT_EXP is not specified. That way
2600 "down" means to really go down (and let me know if that is
2601 impossible), but "down 9999" can be used to mean go all the
2602 way down without getting an error. */
2604 error (_("Bottom (innermost) frame selected; you cannot go down."));
2607 select_frame (frame
);
2611 down_silently_command (const char *count_exp
, int from_tty
)
2613 down_silently_base (count_exp
);
2617 down_command (const char *count_exp
, int from_tty
)
2619 down_silently_base (count_exp
);
2620 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2624 return_command (const char *retval_exp
, int from_tty
)
2626 /* Initialize it just to avoid a GCC false warning. */
2627 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2628 struct frame_info
*thisframe
;
2629 struct gdbarch
*gdbarch
;
2630 struct symbol
*thisfun
;
2631 struct value
*return_value
= NULL
;
2632 struct value
*function
= NULL
;
2633 const char *query_prefix
= "";
2635 thisframe
= get_selected_frame ("No selected frame.");
2636 thisfun
= get_frame_function (thisframe
);
2637 gdbarch
= get_frame_arch (thisframe
);
2639 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2640 error (_("Can not force return from an inlined function."));
2642 /* Compute the return value. If the computation triggers an error,
2643 let it bail. If the return type can't be handled, set
2644 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2648 expression_up retval_expr
= parse_expression (retval_exp
);
2649 struct type
*return_type
= NULL
;
2651 /* Compute the return value. Should the computation fail, this
2652 call throws an error. */
2653 return_value
= evaluate_expression (retval_expr
.get ());
2655 /* Cast return value to the return type of the function. Should
2656 the cast fail, this call throws an error. */
2657 if (thisfun
!= NULL
)
2658 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2659 if (return_type
== NULL
)
2661 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2662 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2663 error (_("Return value type not available for selected "
2665 "Please use an explicit cast of the value to return."));
2666 return_type
= value_type (return_value
);
2668 return_type
= check_typedef (return_type
);
2669 return_value
= value_cast (return_type
, return_value
);
2671 /* Make sure the value is fully evaluated. It may live in the
2672 stack frame we're about to pop. */
2673 if (value_lazy (return_value
))
2674 value_fetch_lazy (return_value
);
2676 if (thisfun
!= NULL
)
2677 function
= read_var_value (thisfun
, NULL
, thisframe
);
2679 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2680 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2681 /* If the return-type is "void", don't try to find the
2682 return-value's location. However, do still evaluate the
2683 return expression so that, even when the expression result
2684 is discarded, side effects such as "return i++" still
2686 return_value
= NULL
;
2687 else if (thisfun
!= NULL
)
2689 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2690 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2691 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2693 query_prefix
= "The location at which to store the "
2694 "function's return value is unknown.\n"
2695 "If you continue, the return value "
2696 "that you specified will be ignored.\n";
2697 return_value
= NULL
;
2702 /* Does an interactive user really want to do this? Include
2703 information, such as how well GDB can handle the return value, in
2704 the query message. */
2709 if (thisfun
== NULL
)
2710 confirmed
= query (_("%sMake selected stack frame return now? "),
2714 if (TYPE_NO_RETURN (thisfun
->type
))
2715 warning (_("Function does not return normally to caller."));
2716 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2717 SYMBOL_PRINT_NAME (thisfun
));
2720 error (_("Not confirmed"));
2723 /* Discard the selected frame and all frames inner-to it. */
2724 frame_pop (get_selected_frame (NULL
));
2726 /* Store RETURN_VALUE in the just-returned register set. */
2727 if (return_value
!= NULL
)
2729 struct type
*return_type
= value_type (return_value
);
2730 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2732 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2733 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2734 gdbarch_return_value (cache_arch
, function
, return_type
,
2735 get_current_regcache (), NULL
/*read*/,
2736 value_contents (return_value
) /*write*/);
2739 /* If we are at the end of a call dummy now, pop the dummy frame
2741 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2742 frame_pop (get_current_frame ());
2744 select_frame (get_current_frame ());
2745 /* If interactive, print the frame that is now current. */
2747 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2750 /* Find the most inner frame in the current stack for a function called
2751 FUNCTION_NAME. If no matching frame is found return NULL. */
2753 static struct frame_info
*
2754 find_frame_for_function (const char *function_name
)
2756 /* Used to hold the lower and upper addresses for each of the
2757 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2758 struct function_bounds
2760 CORE_ADDR low
, high
;
2762 struct frame_info
*frame
;
2766 gdb_assert (function_name
!= NULL
);
2768 frame
= get_current_frame ();
2769 std::vector
<symtab_and_line
> sals
2770 = decode_line_with_current_source (function_name
,
2771 DECODE_LINE_FUNFIRSTLINE
);
2772 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2773 for (size_t i
= 0; i
< sals
.size (); i
++)
2775 if (sals
[i
].pspace
!= current_program_space
)
2776 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2777 else if (sals
[i
].pc
== 0
2778 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2779 &func_bounds
[i
].low
,
2780 &func_bounds
[i
].high
) == 0)
2781 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2786 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2787 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2788 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2792 frame
= find_relative_frame (frame
, &level
);
2795 while (!found
&& level
== 0);
2803 /* Implements the dbx 'func' command. */
2806 func_command (const char *arg
, int from_tty
)
2811 struct frame_info
*frame
= find_frame_for_function (arg
);
2813 error (_("'%s' not within current stack frame."), arg
);
2814 if (frame
!= get_selected_frame (NULL
))
2816 select_frame (frame
);
2817 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2821 /* The qcs command line flags for the "frame apply" commands. Keep
2822 this in sync with the "thread apply" commands. */
2824 using qcs_flag_option_def
2825 = gdb::option::flag_option_def
<qcs_flags
>;
2827 static const gdb::option::option_def fr_qcs_flags_option_defs
[] = {
2828 qcs_flag_option_def
{
2829 "q", [] (qcs_flags
*opt
) { return &opt
->quiet
; },
2830 N_("Disables printing the frame location information."),
2833 qcs_flag_option_def
{
2834 "c", [] (qcs_flags
*opt
) { return &opt
->cont
; },
2835 N_("Print any error raised by COMMAND and continue."),
2838 qcs_flag_option_def
{
2839 "s", [] (qcs_flags
*opt
) { return &opt
->silent
; },
2840 N_("Silently ignore any errors or empty output produced by COMMAND."),
2844 /* Create an option_def_group array for all the "frame apply" options,
2845 with FLAGS and SET_BT_OPTS as context. */
2847 static inline std::array
<gdb::option::option_def_group
, 2>
2848 make_frame_apply_options_def_group (qcs_flags
*flags
,
2849 set_backtrace_options
*set_bt_opts
)
2852 { {fr_qcs_flags_option_defs
}, flags
},
2853 { {set_backtrace_option_defs
}, set_bt_opts
},
2857 /* Apply a GDB command to all stack frames, or a set of identified frames,
2858 or innermost COUNT frames.
2859 With a negative COUNT, apply command on outermost -COUNT frames.
2861 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2862 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2863 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2864 frame apply all -s p local_var_no_idea_in_which_frame
2865 If a frame has a local variable called
2866 local_var_no_idea_in_which_frame, print frame
2867 and value of local_var_no_idea_in_which_frame.
2868 frame apply all -s -q p local_var_no_idea_in_which_frame
2869 Same as before, but only print the variable value.
2870 frame apply level 2-5 0 4-7 -s p i = i + 1
2871 Adds 1 to the variable i in the specified frames.
2872 Note that i will be incremented twice in
2875 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2876 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2877 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2878 for error messages. */
2881 frame_apply_command_count (const char *which_command
,
2882 const char *cmd
, int from_tty
,
2883 struct frame_info
*trailing
, int count
)
2886 set_backtrace_options set_bt_opts
= user_set_backtrace_options
;
2888 auto group
= make_frame_apply_options_def_group (&flags
, &set_bt_opts
);
2889 gdb::option::process_options
2890 (&cmd
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
);
2892 validate_flags_qcs (which_command
, &flags
);
2894 if (cmd
== NULL
|| *cmd
== '\0')
2895 error (_("Please specify a command to apply on the selected frames"));
2897 /* The below will restore the current inferior/thread/frame.
2898 Usually, only the frame is effectively to be restored.
2899 But in case CMD switches of inferior/thread, better restore
2901 scoped_restore_current_thread restore_thread
;
2903 /* These options are handled quite deep in the unwind machinery, so
2904 we get to pass them down by swapping globals. */
2905 scoped_restore restore_set_backtrace_options
2906 = make_scoped_restore (&user_set_backtrace_options
, set_bt_opts
);
2908 for (frame_info
*fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2915 std::string cmd_result
;
2917 /* In case CMD switches of inferior/thread/frame, the below
2918 restores the inferior/thread/frame. FI can then be
2919 set to the selected frame. */
2920 scoped_restore_current_thread restore_fi_current_frame
;
2922 cmd_result
= execute_command_to_string
2923 (cmd
, from_tty
, gdb_stdout
->term_out ());
2925 fi
= get_selected_frame (_("frame apply "
2926 "unable to get selected frame."));
2927 if (!flags
.silent
|| cmd_result
.length () > 0)
2930 print_stack_frame (fi
, 1, LOCATION
, 0);
2931 printf_filtered ("%s", cmd_result
.c_str ());
2934 catch (const gdb_exception_error
&ex
)
2936 fi
= get_selected_frame (_("frame apply "
2937 "unable to get selected frame."));
2941 print_stack_frame (fi
, 1, LOCATION
, 0);
2943 printf_filtered ("%s\n", ex
.what ());
2951 /* Completer for the "frame apply ..." commands. */
2954 frame_apply_completer (completion_tracker
&tracker
, const char *text
)
2956 const auto group
= make_frame_apply_options_def_group (nullptr, nullptr);
2957 if (gdb::option::complete_options
2958 (tracker
, &text
, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND
, group
))
2961 complete_nested_command_line (tracker
, text
);
2964 /* Completer for the "frame apply" commands. */
2967 frame_apply_level_cmd_completer (struct cmd_list_element
*ignore
,
2968 completion_tracker
&tracker
,
2969 const char *text
, const char */
*word*/
)
2971 /* Do this explicitly because there's an early return below. */
2972 tracker
.set_use_custom_word_point (true);
2974 number_or_range_parser
levels (text
);
2976 /* Skip the LEVEL list to find the options and command args. */
2979 while (!levels
.finished ())
2981 /* Call for effect. */
2982 levels
.get_number ();
2984 if (levels
.in_range ())
2985 levels
.skip_range ();
2988 catch (const gdb_exception_error
&ex
)
2990 /* get_number throws if it parses a negative number, for
2991 example. But a seemingly negative number may be the start of
2992 an option instead. */
2995 const char *cmd
= levels
.cur_tok ();
2999 /* No level list yet. */
3003 /* Check if we're past a valid LEVEL already. */
3004 if (levels
.finished ()
3005 && cmd
> text
&& !isspace (cmd
[-1]))
3008 /* We're past LEVELs, advance word point. */
3009 tracker
.advance_custom_word_point_by (cmd
- text
);
3012 frame_apply_completer (tracker
, text
);
3015 /* Completer for the "frame apply all" command. */
3018 frame_apply_all_cmd_completer (struct cmd_list_element
*ignore
,
3019 completion_tracker
&tracker
,
3020 const char *text
, const char */
*word*/
)
3022 frame_apply_completer (tracker
, text
);
3025 /* Completer for the "frame apply COUNT" command. */
3028 frame_apply_cmd_completer (struct cmd_list_element
*ignore
,
3029 completion_tracker
&tracker
,
3030 const char *text
, const char */
*word*/
)
3032 const char *cmd
= text
;
3034 int count
= get_number_trailer (&cmd
, 0);
3038 /* Check if we're past a valid COUNT already. */
3039 if (cmd
> text
&& !isspace (cmd
[-1]))
3042 /* We're past COUNT, advance word point. */
3043 tracker
.advance_custom_word_point_by (cmd
- text
);
3046 frame_apply_completer (tracker
, text
);
3049 /* Implementation of the "frame apply level" command. */
3052 frame_apply_level_command (const char *cmd
, int from_tty
)
3054 if (!target_has_stack
)
3055 error (_("No stack."));
3057 bool level_found
= false;
3058 const char *levels_str
= cmd
;
3059 number_or_range_parser
levels (levels_str
);
3061 /* Skip the LEVEL list to find the flags and command args. */
3062 while (!levels
.finished ())
3064 /* Call for effect. */
3065 levels
.get_number ();
3068 if (levels
.in_range ())
3069 levels
.skip_range ();
3073 error (_("Missing or invalid LEVEL... argument"));
3075 cmd
= levels
.cur_tok ();
3077 /* Redo the LEVELS parsing, but applying COMMAND. */
3078 levels
.init (levels_str
);
3079 while (!levels
.finished ())
3081 const int level_beg
= levels
.get_number ();
3084 if (levels
.in_range ())
3086 n_frames
= levels
.end_value () - level_beg
+ 1;
3087 levels
.skip_range ();
3092 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
3093 leading_innermost_frame (level_beg
), n_frames
);
3097 /* Implementation of the "frame apply all" command. */
3100 frame_apply_all_command (const char *cmd
, int from_tty
)
3102 if (!target_has_stack
)
3103 error (_("No stack."));
3105 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
3106 get_current_frame (), INT_MAX
);
3109 /* Implementation of the "frame apply" command. */
3112 frame_apply_command (const char* cmd
, int from_tty
)
3115 struct frame_info
*trailing
;
3117 if (!target_has_stack
)
3118 error (_("No stack."));
3121 error (_("Missing COUNT argument."));
3122 count
= get_number_trailer (&cmd
, 0);
3124 error (_("Invalid COUNT argument."));
3128 trailing
= trailing_outermost_frame (-count
);
3132 trailing
= get_current_frame ();
3134 frame_apply_command_count ("frame apply", cmd
, from_tty
,
3138 /* Implementation of the "faas" command. */
3141 faas_command (const char *cmd
, int from_tty
)
3143 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
3144 execute_command (expanded
.c_str (), from_tty
);
3148 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
3149 matching frame can be found. */
3151 static struct frame_info
*
3152 find_frame_for_address (CORE_ADDR address
)
3155 struct frame_info
*fid
;
3157 id
= frame_id_build_wild (address
);
3159 /* If (s)he specifies the frame with an address, he deserves
3160 what (s)he gets. Still, give the highest one that matches.
3161 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3163 for (fid
= get_current_frame ();
3165 fid
= get_prev_frame (fid
))
3167 if (frame_id_eq (id
, get_frame_id (fid
)))
3169 struct frame_info
*prev_frame
;
3173 prev_frame
= get_prev_frame (fid
);
3175 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
3187 /* Commands with a prefix of `frame apply'. */
3188 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
3190 /* Commands with a prefix of `frame'. */
3191 static struct cmd_list_element
*frame_cmd_list
= NULL
;
3193 /* Commands with a prefix of `select frame'. */
3194 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
3196 /* Commands with a prefix of `info frame'. */
3197 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
3200 _initialize_stack (void)
3202 struct cmd_list_element
*cmd
;
3204 add_com ("return", class_stack
, return_command
, _("\
3205 Make selected stack frame return to its caller.\n\
3206 Control remains in the debugger, but when you continue\n\
3207 execution will resume in the frame above the one now selected.\n\
3208 If an argument is given, it is an expression for the value to return."));
3210 add_com ("up", class_stack
, up_command
, _("\
3211 Select and print stack frame that called this one.\n\
3212 An argument says how many frames up to go."));
3213 add_com ("up-silently", class_support
, up_silently_command
, _("\
3214 Same as the `up' command, but does not print anything.\n\
3215 This is useful in command scripts."));
3217 add_com ("down", class_stack
, down_command
, _("\
3218 Select and print stack frame called by this one.\n\
3219 An argument says how many frames down to go."));
3220 add_com_alias ("do", "down", class_stack
, 1);
3221 add_com_alias ("dow", "down", class_stack
, 1);
3222 add_com ("down-silently", class_support
, down_silently_command
, _("\
3223 Same as the `down' command, but does not print anything.\n\
3224 This is useful in command scripts."));
3226 add_prefix_cmd ("frame", class_stack
,
3227 &frame_cmd
.base_command
, _("\
3228 Select and print a stack frame.\n\
3229 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3230 A single numerical argument specifies the frame to select."),
3231 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3233 add_com_alias ("f", "frame", class_stack
, 1);
3235 #define FRAME_APPLY_OPTION_HELP "\
3236 Prints the frame location information followed by COMMAND output.\n\
3238 By default, an error raised during the execution of COMMAND\n\
3239 aborts \"frame apply\".\n\
3244 const auto frame_apply_opts
3245 = make_frame_apply_options_def_group (nullptr, nullptr);
3247 static std::string frame_apply_cmd_help
= gdb::option::build_help (N_("\
3248 Apply a command to a number of frames.\n\
3249 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3250 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3251 FRAME_APPLY_OPTION_HELP
),
3254 cmd
= add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
3255 frame_apply_cmd_help
.c_str (),
3256 &frame_apply_cmd_list
, "frame apply ", 1,
3258 set_cmd_completer_handle_brkchars (cmd
, frame_apply_cmd_completer
);
3260 static std::string frame_apply_all_cmd_help
= gdb::option::build_help (N_("\
3261 Apply a command to all frames.\n\
3263 Usage: frame apply all [OPTION]... COMMAND\n"
3264 FRAME_APPLY_OPTION_HELP
),
3267 cmd
= add_cmd ("all", class_stack
, frame_apply_all_command
,
3268 frame_apply_all_cmd_help
.c_str (),
3269 &frame_apply_cmd_list
);
3270 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3272 static std::string frame_apply_level_cmd_help
= gdb::option::build_help (N_("\
3273 Apply a command to a list of frames.\n\
3275 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3276 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3277 FRAME_APPLY_OPTION_HELP
),
3280 cmd
= add_cmd ("level", class_stack
, frame_apply_level_command
,
3281 frame_apply_level_cmd_help
.c_str (),
3282 &frame_apply_cmd_list
);
3283 set_cmd_completer_handle_brkchars (cmd
, frame_apply_level_cmd_completer
);
3285 cmd
= add_com ("faas", class_stack
, faas_command
, _("\
3286 Apply a command to all frames (ignoring errors and empty output).\n\
3287 Usage: faas [OPTION]... COMMAND\n\
3288 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3289 See \"help frame apply all\" for available options."));
3290 set_cmd_completer_handle_brkchars (cmd
, frame_apply_all_cmd_completer
);
3292 add_prefix_cmd ("frame", class_stack
,
3293 &frame_cmd
.base_command
, _("\
3294 Select and print a stack frame.\n\
3295 With no argument, print the selected stack frame. (See also \"info frame\").\n\
3296 A single numerical argument specifies the frame to select."),
3297 &frame_cmd_list
, "frame ", 1, &cmdlist
);
3298 add_com_alias ("f", "frame", class_stack
, 1);
3300 add_cmd ("address", class_stack
, &frame_cmd
.address
,
3302 Select and print a stack frame by stack address\n\
3304 Usage: frame address STACK-ADDRESS"),
3307 add_cmd ("view", class_stack
, &frame_cmd
.view
,
3309 View a stack frame that might be outside the current backtrace.\n\
3311 Usage: frame view STACK-ADDRESS\n\
3312 frame view STACK-ADDRESS PC-ADDRESS"),
3315 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
3317 Select and print a stack frame by function name.\n\
3319 Usage: frame function NAME\n\
3321 The innermost frame that visited function NAME is selected."),
3323 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3326 add_cmd ("level", class_stack
, &frame_cmd
.level
,
3328 Select and print a stack frame by level.\n\
3330 Usage: frame level LEVEL"),
3333 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3334 &select_frame_cmd
.base_command
, _("\
3335 Select a stack frame without printing anything.\n\
3336 A single numerical argument specifies the frame to select."),
3337 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3338 &cli_suppress_notification
.user_selected_context
);
3340 add_cmd_suppress_notification ("address", class_stack
,
3341 &select_frame_cmd
.address
, _("\
3342 Select a stack frame by stack address.\n\
3344 Usage: select-frame address STACK-ADDRESS"),
3345 &select_frame_cmd_list
,
3346 &cli_suppress_notification
.user_selected_context
);
3349 add_cmd_suppress_notification ("view", class_stack
,
3350 &select_frame_cmd
.view
, _("\
3351 Select a stack frame that might be outside the current backtrace.\n\
3353 Usage: select-frame view STACK-ADDRESS\n\
3354 select-frame view STACK-ADDRESS PC-ADDRESS"),
3355 &select_frame_cmd_list
,
3356 &cli_suppress_notification
.user_selected_context
);
3358 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3359 &select_frame_cmd
.function
, _("\
3360 Select a stack frame by function name.\n\
3362 Usage: select-frame function NAME"),
3363 &select_frame_cmd_list
,
3364 &cli_suppress_notification
.user_selected_context
);
3365 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3367 add_cmd_suppress_notification ("level", class_stack
,
3368 &select_frame_cmd
.level
, _("\
3369 Select a stack frame by level.\n\
3371 Usage: select-frame level LEVEL"),
3372 &select_frame_cmd_list
,
3373 &cli_suppress_notification
.user_selected_context
);
3375 const auto backtrace_opts
3376 = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3378 static std::string backtrace_help
3379 = gdb::option::build_help (N_("\
3380 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3381 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3385 For backward compatibility, the following qualifiers are supported:\n\
3387 full - same as -full option.\n\
3388 no-filters - same as -no-filters option.\n\
3389 hide - same as -hide.\n\
3391 With a negative COUNT, print outermost -COUNT frames."),
3394 cmd_list_element
*c
= add_com ("backtrace", class_stack
,
3396 backtrace_help
.c_str ());
3397 set_cmd_completer_handle_brkchars (c
, backtrace_command_completer
);
3399 add_com_alias ("bt", "backtrace", class_stack
, 0);
3401 add_com_alias ("where", "backtrace", class_alias
, 0);
3402 add_info ("stack", backtrace_command
,
3403 _("Backtrace of the stack, or innermost COUNT frames."));
3404 add_info_alias ("s", "stack", 1);
3406 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3407 _("All about the selected stack frame.\n\
3408 With no arguments, displays information about the currently selected stack\n\
3409 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3410 the information is then printed about the specified frame."),
3411 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3412 add_info_alias ("f", "frame", 1);
3414 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3416 Print information about a stack frame selected by stack address.\n\
3418 Usage: info frame address STACK-ADDRESS"),
3419 &info_frame_cmd_list
);
3421 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3423 Print information about a stack frame outside the current backtrace.\n\
3425 Usage: info frame view STACK-ADDRESS\n\
3426 info frame view STACK-ADDRESS PC-ADDRESS"),
3427 &info_frame_cmd_list
);
3429 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3431 Print information about a stack frame selected by function name.\n\
3433 Usage: info frame function NAME"),
3434 &info_frame_cmd_list
);
3435 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3437 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3439 Print information about a stack frame selected by level.\n\
3441 Usage: info frame level LEVEL"),
3442 &info_frame_cmd_list
);
3444 add_info ("locals", info_locals_command
,
3445 info_print_args_help (_("\
3446 All local variables of current stack frame or those matching REGEXPs.\n\
3447 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3448 Prints the local variables of the current stack frame.\n"),
3449 _("local variables")));
3450 add_info ("args", info_args_command
,
3451 info_print_args_help (_("\
3452 All argument variables of current stack frame or those matching REGEXPs.\n\
3453 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3454 Prints the argument variables of the current stack frame.\n"),
3455 _("argument variables")));
3458 add_com ("func", class_stack
, func_command
, _("\
3459 Select the stack frame that contains NAME.\n\
3460 Usage: func NAME"));
3462 /* Install "set print raw frame-arguments", a deprecated spelling of
3463 "set print raw-frame-arguments". */
3464 cmd
= add_setshow_boolean_cmd
3465 ("frame-arguments", no_class
,
3466 &user_frame_print_options
.print_raw_frame_arguments
,
3468 Set whether to print frame arguments in raw form."), _("\
3469 Show whether to print frame arguments in raw form."), _("\
3470 If set, frame arguments are printed in raw form, bypassing any\n\
3471 pretty-printers for that value."),
3473 &setprintrawlist
, &showprintrawlist
);
3474 deprecate_cmd (cmd
, "set print raw-frame-arguments");
3476 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3477 &disassemble_next_line
, _("\
3478 Set whether to disassemble next source line or insn when execution stops."),
3480 Show whether to disassemble next source line or insn when execution stops."),
3482 If ON, GDB will display disassembly of the next source line, in addition\n\
3483 to displaying the source line itself. If the next source line cannot\n\
3484 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3485 will display disassembly of next instruction instead of showing the\n\
3487 If AUTO, display disassembly of next instruction only if the source line\n\
3488 cannot be displayed.\n\
3489 If OFF (which is the default), never display the disassembly of the next\n\
3492 show_disassemble_next_line
,
3493 &setlist
, &showlist
);
3494 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3496 gdb::option::add_setshow_cmds_for_options
3497 (class_stack
, &user_frame_print_options
,
3498 frame_print_option_defs
, &setprintlist
, &showprintlist
);