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"
52 #include "extension.h"
53 #include "observable.h"
54 #include "common/def-vector.h"
56 /* The possible choices of "set print frame-arguments", and the value
59 static const char *const print_frame_arguments_choices
[] =
60 {"all", "scalars", "none", NULL
};
61 static const char *print_frame_arguments
= "scalars";
63 /* If non-zero, don't invoke pretty-printers for frame arguments. */
64 static int print_raw_frame_arguments
;
66 /* The possible choices of "set print entry-values", and the value
69 const char print_entry_values_no
[] = "no";
70 const char print_entry_values_only
[] = "only";
71 const char print_entry_values_preferred
[] = "preferred";
72 const char print_entry_values_if_needed
[] = "if-needed";
73 const char print_entry_values_both
[] = "both";
74 const char print_entry_values_compact
[] = "compact";
75 const char print_entry_values_default
[] = "default";
76 static const char *const print_entry_values_choices
[] =
78 print_entry_values_no
,
79 print_entry_values_only
,
80 print_entry_values_preferred
,
81 print_entry_values_if_needed
,
82 print_entry_values_both
,
83 print_entry_values_compact
,
84 print_entry_values_default
,
87 const char *print_entry_values
= print_entry_values_default
;
89 /* Prototypes for local functions. */
91 static void print_frame_local_vars (struct frame_info
*frame
,
93 const char *regexp
, const char *t_regexp
,
94 int num_tabs
, struct ui_file
*stream
);
96 static void print_frame (struct frame_info
*frame
, int print_level
,
97 enum print_what print_what
, int print_args
,
98 struct symtab_and_line sal
);
100 static void set_last_displayed_sal (int valid
,
101 struct program_space
*pspace
,
103 struct symtab
*symtab
,
106 static struct frame_info
*find_frame_for_function (const char *);
107 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
109 /* Zero means do things normally; we are interacting directly with the
110 user. One means print the full filename and linenumber when a
111 frame is printed, and do so in a format emacs18/emacs19.22 can
112 parse. Two means print similar annotations, but in many more
113 cases and in a slightly different syntax. */
115 int annotation_level
= 0;
117 /* These variables hold the last symtab and line we displayed to the user.
118 * This is where we insert a breakpoint or a skiplist entry by default. */
119 static int last_displayed_sal_valid
= 0;
120 static struct program_space
*last_displayed_pspace
= 0;
121 static CORE_ADDR last_displayed_addr
= 0;
122 static struct symtab
*last_displayed_symtab
= 0;
123 static int last_displayed_line
= 0;
126 /* Return 1 if we should display the address in addition to the location,
127 because we are in the middle of a statement. */
130 frame_show_address (struct frame_info
*frame
,
131 struct symtab_and_line sal
)
133 /* If there is a line number, but no PC, then there is no location
134 information associated with this sal. The only way that should
135 happen is for the call sites of inlined functions (SAL comes from
136 find_frame_sal). Otherwise, we would have some PC range if the
137 SAL came from a line table. */
138 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
140 if (get_next_frame (frame
) == NULL
)
141 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
143 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
147 return get_frame_pc (frame
) != sal
.pc
;
153 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
154 int print_level
, enum print_what print_what
,
157 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
159 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
162 /* Show or print a stack frame FRAME briefly. The output is formatted
163 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
164 relative level, function name, argument list, and file name and
165 line number. If the frame's PC is not at the beginning of the
166 source line, the actual PC is printed at the beginning. */
169 print_stack_frame (struct frame_info
*frame
, int print_level
,
170 enum print_what print_what
,
174 /* For mi, alway print location and address. */
175 if (current_uiout
->is_mi_like_p ())
176 print_what
= LOC_AND_ADDRESS
;
180 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
183 set_current_sal_from_frame (frame
);
185 CATCH (e
, RETURN_MASK_ERROR
)
191 /* Print nameless arguments of frame FRAME on STREAM, where START is
192 the offset of the first nameless argument, and NUM is the number of
193 nameless arguments to print. FIRST is nonzero if this is the first
194 argument (not just the first nameless argument). */
197 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
198 int first
, struct ui_file
*stream
)
200 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
201 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
206 for (i
= 0; i
< num
; i
++)
209 argsaddr
= get_frame_args_address (frame
);
212 arg_value
= read_memory_integer (argsaddr
+ start
,
213 sizeof (int), byte_order
);
215 fprintf_filtered (stream
, ", ");
216 fprintf_filtered (stream
, "%ld", arg_value
);
218 start
+= sizeof (int);
222 /* Print single argument of inferior function. ARG must be already
225 Errors are printed as if they would be the parameter value. Use zeroed ARG
226 iff it should not be printed accoring to user settings. */
229 print_frame_arg (const struct frame_arg
*arg
)
231 struct ui_out
*uiout
= current_uiout
;
235 gdb_assert (!arg
->val
|| !arg
->error
);
236 gdb_assert (arg
->entry_kind
== print_entry_values_no
237 || arg
->entry_kind
== print_entry_values_only
238 || (!uiout
->is_mi_like_p ()
239 && arg
->entry_kind
== print_entry_values_compact
));
241 annotate_arg_emitter arg_emitter
;
242 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
243 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
244 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
245 if (arg
->entry_kind
== print_entry_values_compact
)
247 /* It is OK to provide invalid MI-like stream as with
248 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
251 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
252 SYMBOL_LANGUAGE (arg
->sym
),
253 DMGL_PARAMS
| DMGL_ANSI
);
255 if (arg
->entry_kind
== print_entry_values_only
256 || arg
->entry_kind
== print_entry_values_compact
)
258 uiout
->field_stream ("name", stb
, ui_out_style_kind::VARIABLE
);
259 annotate_arg_name_end ();
262 if (!arg
->val
&& !arg
->error
)
267 stb
.printf (_("<error reading variable: %s>"), arg
->error
);
272 const struct language_defn
*language
;
273 struct value_print_options opts
;
275 /* Avoid value_print because it will deref ref parameters. We
276 just want to print their addresses. Print ??? for args whose
277 address we do not know. We pass 2 as "recurse" to val_print
278 because our standard indentation here is 4 spaces, and
279 val_print indents 2 for each recurse. */
281 annotate_arg_value (value_type (arg
->val
));
283 /* Use the appropriate language to display our symbol, unless the
284 user forced the language to a specific language. */
285 if (language_mode
== language_mode_auto
)
286 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
288 language
= current_language
;
290 get_no_prettyformat_print_options (&opts
);
292 opts
.raw
= print_raw_frame_arguments
;
294 /* True in "summary" mode, false otherwise. */
295 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
297 common_val_print (arg
->val
, &stb
, 2, &opts
, language
);
299 CATCH (except
, RETURN_MASK_ERROR
)
301 stb
.printf (_("<error reading variable: %s>"),
308 uiout
->field_stream ("value", stb
);
311 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
312 responsible for xfree of ARGP->ERROR. This function never throws an
316 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
317 struct frame_arg
*argp
)
325 argp
->val
= read_var_value (sym
, NULL
, frame
);
327 CATCH (except
, RETURN_MASK_ERROR
)
329 argp
->error
= xstrdup (except
.what ());
334 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
335 responsible for xfree of ARGP->ERROR. This function never throws an
339 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
340 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
342 struct value
*val
= NULL
, *entryval
= NULL
;
343 char *val_error
= NULL
, *entryval_error
= NULL
;
346 if (print_entry_values
!= print_entry_values_only
347 && print_entry_values
!= print_entry_values_preferred
)
351 val
= read_var_value (sym
, NULL
, frame
);
353 CATCH (except
, RETURN_MASK_ERROR
)
355 val_error
= (char *) alloca (except
.message
->size () + 1);
356 strcpy (val_error
, except
.what ());
361 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
362 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
363 && print_entry_values
!= print_entry_values_no
364 && (print_entry_values
!= print_entry_values_if_needed
365 || !val
|| value_optimized_out (val
)))
369 const struct symbol_computed_ops
*ops
;
371 ops
= SYMBOL_COMPUTED_OPS (sym
);
372 entryval
= ops
->read_variable_at_entry (sym
, frame
);
374 CATCH (except
, RETURN_MASK_ERROR
)
376 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
378 entryval_error
= (char *) alloca (except
.message
->size () + 1);
379 strcpy (entryval_error
, except
.what ());
384 if (entryval
!= NULL
&& value_optimized_out (entryval
))
387 if (print_entry_values
== print_entry_values_compact
388 || print_entry_values
== print_entry_values_default
)
390 /* For MI do not try to use print_entry_values_compact for ARGP. */
392 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
394 struct type
*type
= value_type (val
);
396 if (value_lazy (val
))
397 value_fetch_lazy (val
);
398 if (value_lazy (entryval
))
399 value_fetch_lazy (entryval
);
401 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
403 /* Initialize it just to avoid a GCC false warning. */
404 struct value
*val_deref
= NULL
, *entryval_deref
;
406 /* DW_AT_call_value does match with the current
407 value. If it is a reference still try to verify if
408 dereferenced DW_AT_call_data_value does not differ. */
412 struct type
*type_deref
;
414 val_deref
= coerce_ref (val
);
415 if (value_lazy (val_deref
))
416 value_fetch_lazy (val_deref
);
417 type_deref
= value_type (val_deref
);
419 entryval_deref
= coerce_ref (entryval
);
420 if (value_lazy (entryval_deref
))
421 value_fetch_lazy (entryval_deref
);
423 /* If the reference addresses match but dereferenced
424 content does not match print them. */
426 && value_contents_eq (val_deref
, 0,
428 TYPE_LENGTH (type_deref
)))
431 CATCH (except
, RETURN_MASK_ERROR
)
433 /* If the dereferenced content could not be
434 fetched do not display anything. */
435 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
437 else if (except
.message
!= NULL
)
440 = (char *) alloca (except
.message
->size () + 1);
441 strcpy (entryval_error
, except
.what ());
446 /* Value was not a reference; and its content matches. */
447 if (val
== val_deref
)
455 /* Try to remove possibly duplicate error message for ENTRYARGP even
458 if (val_error
&& entryval_error
459 && strcmp (val_error
, entryval_error
) == 0)
461 entryval_error
= NULL
;
463 /* Do not se VAL_EQUAL as the same error message may be shown for
464 the entry value even if no entry values are present in the
470 if (entryval
== NULL
)
472 if (print_entry_values
== print_entry_values_preferred
)
474 gdb_assert (val
== NULL
);
478 val
= read_var_value (sym
, NULL
, frame
);
480 CATCH (except
, RETURN_MASK_ERROR
)
482 val_error
= (char *) alloca (except
.message
->size () + 1);
483 strcpy (val_error
, except
.what ());
487 if (print_entry_values
== print_entry_values_only
488 || print_entry_values
== print_entry_values_both
489 || (print_entry_values
== print_entry_values_preferred
490 && (!val
|| value_optimized_out (val
))))
492 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
493 entryval_error
= NULL
;
496 if ((print_entry_values
== print_entry_values_compact
497 || print_entry_values
== print_entry_values_if_needed
498 || print_entry_values
== print_entry_values_preferred
)
499 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
507 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
508 if (!val
&& !val_error
)
509 argp
->entry_kind
= print_entry_values_only
;
510 else if ((print_entry_values
== print_entry_values_compact
511 || print_entry_values
== print_entry_values_default
) && val_equal
)
513 argp
->entry_kind
= print_entry_values_compact
;
514 gdb_assert (!current_uiout
->is_mi_like_p ());
517 argp
->entry_kind
= print_entry_values_no
;
519 entryargp
->sym
= sym
;
520 entryargp
->val
= entryval
;
521 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
522 if (!entryval
&& !entryval_error
)
523 entryargp
->entry_kind
= print_entry_values_no
;
525 entryargp
->entry_kind
= print_entry_values_only
;
528 /* Print the arguments of frame FRAME on STREAM, given the function
529 FUNC running in that frame (as a symbol), where NUM is the number
530 of arguments according to the stack frame (or -1 if the number of
531 arguments is unknown). */
533 /* Note that currently the "number of arguments according to the
534 stack frame" is only known on VAX where i refers to the "number of
535 ints of arguments according to the stack frame". */
538 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
539 int num
, struct ui_file
*stream
)
541 struct ui_out
*uiout
= current_uiout
;
543 /* Offset of next stack argument beyond the one we have seen that is
544 at the highest offset, or -1 if we haven't come to a stack
546 long highest_offset
= -1;
547 /* Number of ints of arguments that we have printed so far. */
548 int args_printed
= 0;
549 /* True if we should print arguments, false otherwise. */
550 int print_args
= strcmp (print_frame_arguments
, "none");
554 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
555 struct block_iterator iter
;
558 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
560 struct frame_arg arg
, entryarg
;
564 /* Keep track of the highest stack argument offset seen, and
565 skip over any kinds of symbols we don't care about. */
567 if (!SYMBOL_IS_ARGUMENT (sym
))
570 switch (SYMBOL_CLASS (sym
))
575 long current_offset
= SYMBOL_VALUE (sym
);
576 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
578 /* Compute address of next argument by adding the size of
579 this argument and rounding to an int boundary. */
581 ((current_offset
+ arg_size
+ sizeof (int) - 1)
582 & ~(sizeof (int) - 1));
584 /* If this is the highest offset seen yet, set
586 if (highest_offset
== -1
587 || (current_offset
> highest_offset
))
588 highest_offset
= current_offset
;
590 /* Add the number of ints we're about to print to
592 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
595 /* We care about types of symbols, but don't need to
596 keep track of stack offsets in them. */
598 case LOC_REGPARM_ADDR
:
600 case LOC_OPTIMIZED_OUT
:
605 /* We have to look up the symbol because arguments can have
606 two entries (one a parameter, one a local) and the one we
607 want is the local, which lookup_symbol will find for us.
608 This includes gcc1 (not gcc2) on SPARC when passing a
609 small structure and gcc2 when the argument type is float
610 and it is passed as a double and converted to float by
611 the prologue (in the latter case the type of the LOC_ARG
612 symbol is double and the type of the LOC_LOCAL symbol is
614 /* But if the parameter name is null, don't try it. Null
615 parameter names occur on the RS/6000, for traceback
616 tables. FIXME, should we even print them? */
618 if (*SYMBOL_LINKAGE_NAME (sym
))
622 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
623 b
, VAR_DOMAIN
).symbol
;
624 gdb_assert (nsym
!= NULL
);
625 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
626 && !SYMBOL_IS_ARGUMENT (nsym
))
628 /* There is a LOC_ARG/LOC_REGISTER pair. This means
629 that it was passed on the stack and loaded into a
630 register, or passed in a register and stored in a
631 stack slot. GDB 3.x used the LOC_ARG; GDB
632 4.0-4.11 used the LOC_REGISTER.
634 Reasons for using the LOC_ARG:
636 (1) Because find_saved_registers may be slow for
639 (2) Because registers are often re-used and stack
640 slots rarely (never?) are. Therefore using
641 the stack slot is much less likely to print
644 Reasons why we might want to use the LOC_REGISTER:
646 (1) So that the backtrace prints the same value
647 as "print foo". I see no compelling reason
648 why this needs to be the case; having the
649 backtrace print the value which was passed
650 in, and "print foo" print the value as
651 modified within the called function, makes
654 Additional note: It might be nice if "info args"
655 displayed both values.
657 One more note: There is a case with SPARC
658 structure passing where we need to use the
659 LOC_REGISTER, but this is dealt with by creating
660 a single LOC_REGPARM in symbol reading. */
662 /* Leave sym (the LOC_ARG) alone. */
669 /* Print the current arg. */
672 uiout
->wrap_hint (" ");
676 memset (&arg
, 0, sizeof (arg
));
678 arg
.entry_kind
= print_entry_values_no
;
679 memset (&entryarg
, 0, sizeof (entryarg
));
681 entryarg
.entry_kind
= print_entry_values_no
;
684 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
686 if (arg
.entry_kind
!= print_entry_values_only
)
687 print_frame_arg (&arg
);
689 if (entryarg
.entry_kind
!= print_entry_values_no
)
691 if (arg
.entry_kind
!= print_entry_values_only
)
694 uiout
->wrap_hint (" ");
697 print_frame_arg (&entryarg
);
701 xfree (entryarg
.error
);
707 /* Don't print nameless args in situations where we don't know
708 enough about the stack to find them. */
713 if (highest_offset
== -1)
714 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
716 start
= highest_offset
;
718 print_frame_nameless_args (frame
, start
, num
- args_printed
,
723 /* Set the current source and line to the location given by frame
724 FRAME, if possible. When CENTER is true, adjust so the relevant
725 line is in the center of the next 'list'. */
728 set_current_sal_from_frame (struct frame_info
*frame
)
730 symtab_and_line sal
= find_frame_sal (frame
);
731 if (sal
.symtab
!= NULL
)
732 set_current_source_symtab_and_line (sal
);
735 /* If ON, GDB will display disassembly of the next source line when
736 execution of the program being debugged stops.
737 If AUTO (which is the default), or there's no line info to determine
738 the source line of the next instruction, display disassembly of next
739 instruction instead. */
741 static enum auto_boolean disassemble_next_line
;
744 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
745 struct cmd_list_element
*c
,
748 fprintf_filtered (file
,
749 _("Debugger's willingness to use "
750 "disassemble-next-line is %s.\n"),
754 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
755 because it will be broken by filter sometime. */
758 do_gdb_disassembly (struct gdbarch
*gdbarch
,
759 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
764 gdb_disassembly (gdbarch
, current_uiout
,
765 DISASSEMBLY_RAW_INSN
, how_many
,
768 CATCH (exception
, RETURN_MASK_ERROR
)
770 /* If an exception was thrown while doing the disassembly, print
771 the error message, to give the user a clue of what happened. */
772 exception_print (gdb_stderr
, exception
);
777 /* Print information about frame FRAME. The output is format according
778 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
781 SRC_LINE: Print only source line.
782 LOCATION: Print only location.
783 SRC_AND_LOC: Print location and source line.
785 Used in "where" output, and to emit breakpoint or step
789 print_frame_info (struct frame_info
*frame
, int print_level
,
790 enum print_what print_what
, int print_args
,
793 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
796 struct ui_out
*uiout
= current_uiout
;
798 if (get_frame_type (frame
) == DUMMY_FRAME
799 || get_frame_type (frame
) == SIGTRAMP_FRAME
800 || get_frame_type (frame
) == ARCH_FRAME
)
802 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
804 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
805 gdbarch
, get_frame_pc (frame
));
807 /* Do this regardless of SOURCE because we don't have any source
808 to list for this frame. */
812 uiout
->field_fmt_int (2, ui_left
, "level",
813 frame_relative_level (frame
));
815 if (uiout
->is_mi_like_p ())
817 annotate_frame_address ();
818 uiout
->field_core_addr ("addr",
819 gdbarch
, get_frame_pc (frame
));
820 annotate_frame_address_end ();
823 if (get_frame_type (frame
) == DUMMY_FRAME
)
825 annotate_function_call ();
826 uiout
->field_string ("func", "<function called from gdb>",
827 ui_out_style_kind::FUNCTION
);
829 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
831 annotate_signal_handler_caller ();
832 uiout
->field_string ("func", "<signal handler called>",
833 ui_out_style_kind::FUNCTION
);
835 else if (get_frame_type (frame
) == ARCH_FRAME
)
837 uiout
->field_string ("func", "<cross-architecture call>",
838 ui_out_style_kind::FUNCTION
);
841 annotate_frame_end ();
843 /* If disassemble-next-line is set to auto or on output the next
845 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
846 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
847 do_gdb_disassembly (get_frame_arch (frame
), 1,
848 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
853 /* If FRAME is not the innermost frame, that normally means that
854 FRAME->pc points to *after* the call instruction, and we want to
855 get the line containing the call, never the next line. But if
856 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
857 next frame was not entered as the result of a call, and we want
858 to get the line containing FRAME->pc. */
859 symtab_and_line sal
= find_frame_sal (frame
);
861 location_print
= (print_what
== LOCATION
862 || print_what
== LOC_AND_ADDRESS
863 || print_what
== SRC_AND_LOC
);
865 if (location_print
|| !sal
.symtab
)
866 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
868 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
870 /* If disassemble-next-line is set to auto or on and doesn't have
871 the line debug messages for $pc, output the next instruction. */
872 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
873 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
874 && source_print
&& !sal
.symtab
)
875 do_gdb_disassembly (get_frame_arch (frame
), 1,
876 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
878 if (source_print
&& sal
.symtab
)
881 int mid_statement
= ((print_what
== SRC_LINE
)
882 && frame_show_address (frame
, sal
));
884 if (annotation_level
)
885 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
886 get_frame_pc (frame
));
889 if (deprecated_print_frame_info_listing_hook
)
890 deprecated_print_frame_info_listing_hook (sal
.symtab
,
895 struct value_print_options opts
;
897 get_user_print_options (&opts
);
898 /* We used to do this earlier, but that is clearly
899 wrong. This function is used by many different
900 parts of gdb, including normal_stop in infrun.c,
901 which uses this to print out the current PC
902 when we stepi/nexti into the middle of a source
903 line. Only the command line really wants this
904 behavior. Other UIs probably would like the
905 ability to decide for themselves if it is desired. */
906 if (opts
.addressprint
&& mid_statement
)
908 uiout
->field_core_addr ("addr",
909 gdbarch
, get_frame_pc (frame
));
913 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
917 /* If disassemble-next-line is set to on and there is line debug
918 messages, output assembly codes for next line. */
919 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
920 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
927 if (get_frame_pc_if_available (frame
, &pc
))
928 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
930 set_last_displayed_sal (0, 0, 0, 0, 0);
933 annotate_frame_end ();
935 gdb_flush (gdb_stdout
);
938 /* Remember the last symtab and line we displayed, which we use e.g.
939 * as the place to put a breakpoint when the `break' command is
940 * invoked with no arguments. */
943 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
944 CORE_ADDR addr
, struct symtab
*symtab
,
947 last_displayed_sal_valid
= valid
;
948 last_displayed_pspace
= pspace
;
949 last_displayed_addr
= addr
;
950 last_displayed_symtab
= symtab
;
951 last_displayed_line
= line
;
952 if (valid
&& pspace
== NULL
)
954 clear_last_displayed_sal ();
955 internal_error (__FILE__
, __LINE__
,
956 _("Trying to set NULL pspace."));
960 /* Forget the last sal we displayed. */
963 clear_last_displayed_sal (void)
965 last_displayed_sal_valid
= 0;
966 last_displayed_pspace
= 0;
967 last_displayed_addr
= 0;
968 last_displayed_symtab
= 0;
969 last_displayed_line
= 0;
972 /* Is our record of the last sal we displayed valid? If not,
973 * the get_last_displayed_* functions will return NULL or 0, as
977 last_displayed_sal_is_valid (void)
979 return last_displayed_sal_valid
;
982 /* Get the pspace of the last sal we displayed, if it's valid. */
984 struct program_space
*
985 get_last_displayed_pspace (void)
987 if (last_displayed_sal_valid
)
988 return last_displayed_pspace
;
992 /* Get the address of the last sal we displayed, if it's valid. */
995 get_last_displayed_addr (void)
997 if (last_displayed_sal_valid
)
998 return last_displayed_addr
;
1002 /* Get the symtab of the last sal we displayed, if it's valid. */
1005 get_last_displayed_symtab (void)
1007 if (last_displayed_sal_valid
)
1008 return last_displayed_symtab
;
1012 /* Get the line of the last sal we displayed, if it's valid. */
1015 get_last_displayed_line (void)
1017 if (last_displayed_sal_valid
)
1018 return last_displayed_line
;
1022 /* Get the last sal we displayed, if it's valid. */
1025 get_last_displayed_sal ()
1027 symtab_and_line sal
;
1029 if (last_displayed_sal_valid
)
1031 sal
.pspace
= last_displayed_pspace
;
1032 sal
.pc
= last_displayed_addr
;
1033 sal
.symtab
= last_displayed_symtab
;
1034 sal
.line
= last_displayed_line
;
1041 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1042 corresponding to FRAME. */
1044 gdb::unique_xmalloc_ptr
<char>
1045 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1046 struct symbol
**funcp
)
1048 struct symbol
*func
;
1049 gdb::unique_xmalloc_ptr
<char> funname
;
1051 *funlang
= language_unknown
;
1055 func
= get_frame_function (frame
);
1058 /* In certain pathological cases, the symtabs give the wrong
1059 function (when we are in the first function in a file which
1060 is compiled without debugging symbols, the previous function
1061 is compiled with debugging symbols, and the "foo.o" symbol
1062 that is supposed to tell us where the file with debugging
1063 symbols ends has been truncated by ar because it is longer
1064 than 15 characters). This also occurs if the user uses asm()
1065 to create a function but not stabs for it (in a file compiled
1068 So look in the minimal symbol tables as well, and if it comes
1069 up with a larger address for the function use that instead.
1070 I don't think this can ever cause any problems; there
1071 shouldn't be any minimal symbols in the middle of a function;
1072 if this is ever changed many parts of GDB will need to be
1073 changed (and we'll create a find_pc_minimal_function or some
1076 struct bound_minimal_symbol msymbol
;
1078 /* Don't attempt to do this for inlined functions, which do not
1079 have a corresponding minimal symbol. */
1080 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1082 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1084 memset (&msymbol
, 0, sizeof (msymbol
));
1086 if (msymbol
.minsym
!= NULL
1087 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1088 > BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func
))))
1090 /* We also don't know anything about the function besides
1091 its address and name. */
1093 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1094 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1098 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1100 *funlang
= SYMBOL_LANGUAGE (func
);
1103 if (*funlang
== language_cplus
)
1105 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1106 to display the demangled name that we already have
1107 stored in the symbol table, but we stored a version
1108 with DMGL_PARAMS turned on, and here we don't want to
1109 display parameters. So remove the parameters. */
1110 funname
= cp_remove_params (print_name
);
1113 /* If we didn't hit the C++ case above, set *funname
1115 if (funname
== NULL
)
1116 funname
.reset (xstrdup (print_name
));
1121 struct bound_minimal_symbol msymbol
;
1124 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1127 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1128 if (msymbol
.minsym
!= NULL
)
1130 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1131 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1139 print_frame (struct frame_info
*frame
, int print_level
,
1140 enum print_what print_what
, int print_args
,
1141 struct symtab_and_line sal
)
1143 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1144 struct ui_out
*uiout
= current_uiout
;
1145 enum language funlang
= language_unknown
;
1146 struct value_print_options opts
;
1147 struct symbol
*func
;
1151 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1153 gdb::unique_xmalloc_ptr
<char> funname
1154 = find_frame_funname (frame
, &funlang
, &func
);
1156 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1160 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1165 uiout
->field_fmt_int (2, ui_left
, "level",
1166 frame_relative_level (frame
));
1168 get_user_print_options (&opts
);
1169 if (opts
.addressprint
)
1171 || frame_show_address (frame
, sal
)
1172 || print_what
== LOC_AND_ADDRESS
)
1174 annotate_frame_address ();
1176 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1178 uiout
->field_string ("addr", "<unavailable>",
1179 ui_out_style_kind::ADDRESS
);
1180 annotate_frame_address_end ();
1181 uiout
->text (" in ");
1183 annotate_frame_function_name ();
1186 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1187 funlang
, DMGL_ANSI
);
1188 uiout
->field_stream ("func", stb
, ui_out_style_kind::FUNCTION
);
1189 uiout
->wrap_hint (" ");
1190 annotate_frame_args ();
1197 if (gdbarch_frame_num_args_p (gdbarch
))
1199 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1200 gdb_assert (numargs
>= 0);
1206 ui_out_emit_list
list_emitter (uiout
, "args");
1209 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1211 CATCH (e
, RETURN_MASK_ERROR
)
1216 /* FIXME: ARGS must be a list. If one argument is a string it
1217 will have " that will not be properly escaped. */
1224 const char *filename_display
;
1226 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1227 annotate_frame_source_begin ();
1228 uiout
->wrap_hint (" ");
1229 uiout
->text (" at ");
1230 annotate_frame_source_file ();
1231 uiout
->field_string ("file", filename_display
, ui_out_style_kind::FILE);
1232 if (uiout
->is_mi_like_p ())
1234 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1236 uiout
->field_string ("fullname", fullname
);
1238 annotate_frame_source_file_end ();
1240 annotate_frame_source_line ();
1241 uiout
->field_int ("line", sal
.line
);
1242 annotate_frame_source_end ();
1245 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1247 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1248 get_frame_pc (frame
));
1252 annotate_frame_where ();
1253 uiout
->wrap_hint (" ");
1254 uiout
->text (" from ");
1255 uiout
->field_string ("from", lib
);
1258 if (uiout
->is_mi_like_p ())
1259 uiout
->field_string ("arch",
1260 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1267 /* Completion function for "frame function", "info frame function", and
1268 "select-frame function" commands. */
1271 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1272 completion_tracker
&tracker
,
1273 const char *text
, const char *word
)
1275 /* This is used to complete function names within a stack. It would be
1276 nice if we only offered functions that were actually in the stack.
1277 However, this would mean unwinding the stack to completion, which
1278 could take too long, or on a corrupted stack, possibly not end.
1279 Instead, we offer all symbol names as a safer choice. */
1280 collect_symbol_completion_matches (tracker
,
1281 complete_symbol_mode::EXPRESSION
,
1282 symbol_name_match_type::EXPRESSION
,
1286 /* Core of all the "info frame" sub-commands. Print information about a
1287 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1288 frame specification, they just entered 'info frame'. If the user did
1289 provide a frame specification (for example 'info frame 0', 'info frame
1290 level 1') then SELECTED_FRAME_P will be false. */
1293 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1295 struct symbol
*func
;
1297 struct frame_info
*calling_frame_info
;
1299 const char *funname
= 0;
1300 enum language funlang
= language_unknown
;
1301 const char *pc_regname
;
1302 struct gdbarch
*gdbarch
;
1305 /* Initialize it to avoid "may be used uninitialized" warning. */
1306 CORE_ADDR caller_pc
= 0;
1307 int caller_pc_p
= 0;
1309 gdbarch
= get_frame_arch (fi
);
1311 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1312 is not a good name. */
1313 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1314 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1315 easily not match that of the internal value returned by
1317 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1319 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1320 architectures will often have a hardware register called "pc",
1321 and that register's value, again, can easily not match
1325 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1326 func
= get_frame_function (fi
);
1327 symtab_and_line sal
= find_frame_sal (fi
);
1329 gdb::unique_xmalloc_ptr
<char> func_only
;
1332 funname
= SYMBOL_PRINT_NAME (func
);
1333 funlang
= SYMBOL_LANGUAGE (func
);
1334 if (funlang
== language_cplus
)
1336 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1337 to display the demangled name that we already have
1338 stored in the symbol table, but we stored a version
1339 with DMGL_PARAMS turned on, and here we don't want to
1340 display parameters. So remove the parameters. */
1341 func_only
= cp_remove_params (funname
);
1344 funname
= func_only
.get ();
1347 else if (frame_pc_p
)
1349 struct bound_minimal_symbol msymbol
;
1351 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1352 if (msymbol
.minsym
!= NULL
)
1354 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1355 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1358 calling_frame_info
= get_prev_frame (fi
);
1360 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1362 printf_filtered (_("Stack level %d, frame at "),
1363 frame_relative_level (fi
));
1367 printf_filtered (_("Stack frame at "));
1369 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1370 printf_filtered (":\n");
1371 printf_filtered (" %s = ", pc_regname
);
1373 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1375 fputs_filtered ("<unavailable>", gdb_stdout
);
1380 printf_filtered (" in ");
1381 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1382 DMGL_ANSI
| DMGL_PARAMS
);
1386 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1388 puts_filtered ("; ");
1390 printf_filtered ("saved %s = ", pc_regname
);
1392 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1393 val_print_not_saved (gdb_stdout
);
1398 caller_pc
= frame_unwind_caller_pc (fi
);
1401 CATCH (ex
, RETURN_MASK_ERROR
)
1405 case NOT_AVAILABLE_ERROR
:
1406 val_print_unavailable (gdb_stdout
);
1408 case OPTIMIZED_OUT_ERROR
:
1409 val_print_not_saved (gdb_stdout
);
1412 fprintf_filtered (gdb_stdout
, _("<error: %s>"),
1421 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1422 printf_filtered ("\n");
1424 if (calling_frame_info
== NULL
)
1426 enum unwind_stop_reason reason
;
1428 reason
= get_frame_unwind_stop_reason (fi
);
1429 if (reason
!= UNWIND_NO_REASON
)
1430 printf_filtered (_(" Outermost frame: %s\n"),
1431 frame_stop_reason_string (fi
));
1433 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1434 puts_filtered (" tail call frame");
1435 else if (get_frame_type (fi
) == INLINE_FRAME
)
1436 printf_filtered (" inlined into frame %d",
1437 frame_relative_level (get_prev_frame (fi
)));
1440 printf_filtered (" called by frame at ");
1441 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1444 if (get_next_frame (fi
) && calling_frame_info
)
1445 puts_filtered (",");
1447 if (get_next_frame (fi
))
1449 printf_filtered (" caller of frame at ");
1450 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1453 if (get_next_frame (fi
) || calling_frame_info
)
1454 puts_filtered ("\n");
1457 printf_filtered (" source language %s.\n",
1458 language_str (s
->language
));
1461 /* Address of the argument list for this frame, or 0. */
1462 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1463 /* Number of args for this frame, or -1 if unknown. */
1467 printf_filtered (" Arglist at unknown address.\n");
1470 printf_filtered (" Arglist at ");
1471 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1472 printf_filtered (",");
1474 if (!gdbarch_frame_num_args_p (gdbarch
))
1477 puts_filtered (" args: ");
1481 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1482 gdb_assert (numargs
>= 0);
1484 puts_filtered (" no args.");
1485 else if (numargs
== 1)
1486 puts_filtered (" 1 arg: ");
1488 printf_filtered (" %d args: ", numargs
);
1490 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1491 puts_filtered ("\n");
1495 /* Address of the local variables for this frame, or 0. */
1496 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1499 printf_filtered (" Locals at unknown address,");
1502 printf_filtered (" Locals at ");
1503 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1504 printf_filtered (",");
1508 /* Print as much information as possible on the location of all the
1514 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1516 /* The sp is special; what's displayed isn't the save address, but
1517 the value of the previous frame's sp. This is a legacy thing,
1518 at one stage the frame cached the previous frame's SP instead
1519 of its address, hence it was easiest to just display the cached
1523 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1524 gdb_assert (value
!= NULL
);
1526 if (!value_optimized_out (value
) && value_entirely_available (value
))
1528 if (VALUE_LVAL (value
) == not_lval
)
1531 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1532 int sp_size
= register_size (gdbarch
, sp_regnum
);
1534 sp
= extract_unsigned_integer (value_contents_all (value
),
1535 sp_size
, byte_order
);
1537 printf_filtered (" Previous frame's sp is ");
1538 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1539 printf_filtered ("\n");
1541 else if (VALUE_LVAL (value
) == lval_memory
)
1543 printf_filtered (" Previous frame's sp at ");
1544 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1546 printf_filtered ("\n");
1548 else if (VALUE_LVAL (value
) == lval_register
)
1550 printf_filtered (" Previous frame's sp in %s\n",
1551 gdbarch_register_name (gdbarch
,
1552 VALUE_REGNUM (value
)));
1555 release_value (value
);
1558 /* else keep quiet. */
1562 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1563 for (i
= 0; i
< numregs
; i
++)
1565 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1567 enum lval_type lval
;
1573 /* Find out the location of the saved register without
1574 fetching the corresponding value. */
1575 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1576 &lval
, &addr
, &realnum
, NULL
);
1577 /* For moment, only display registers that were saved on the
1579 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1582 puts_filtered (" Saved registers:\n ");
1584 puts_filtered (",");
1586 printf_filtered (" %s at ",
1587 gdbarch_register_name (gdbarch
, i
));
1588 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1592 if (count
|| need_nl
)
1593 puts_filtered ("\n");
1597 /* Return the innermost frame at level LEVEL. */
1599 static struct frame_info
*
1600 leading_innermost_frame (int level
)
1602 struct frame_info
*leading
;
1604 leading
= get_current_frame ();
1606 gdb_assert (level
>= 0);
1608 while (leading
!= nullptr && level
)
1611 leading
= get_prev_frame (leading
);
1618 /* Return the starting frame needed to handle COUNT outermost frames. */
1620 static struct frame_info
*
1621 trailing_outermost_frame (int count
)
1623 struct frame_info
*current
;
1624 struct frame_info
*trailing
;
1626 trailing
= get_current_frame ();
1628 gdb_assert (count
> 0);
1631 while (current
!= nullptr && count
--)
1634 current
= get_prev_frame (current
);
1637 /* Will stop when CURRENT reaches the top of the stack.
1638 TRAILING will be COUNT below it. */
1639 while (current
!= nullptr)
1642 trailing
= get_prev_frame (trailing
);
1643 current
= get_prev_frame (current
);
1649 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1653 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1655 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1657 if (get_selected_frame_if_set () != prev_frame
)
1658 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1664 select_frame_for_mi (struct frame_info
*fi
)
1666 select_frame_command_core (fi
, FALSE
/* Ignored. */);
1669 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1670 means we change frame send out a change notification (otherwise, just
1671 reprint the current frame summary). */
1674 frame_command_core (struct frame_info
*fi
, bool ignored
)
1676 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1679 if (get_selected_frame_if_set () != prev_frame
)
1680 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1682 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1685 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1686 common set of sub-commands that allow a specific frame to be selected.
1687 All of the sub-command functions are static methods within this class
1688 template which is then instantiated below. The template parameter is a
1689 callback used to implement the functionality of the base command
1690 ('frame', 'select-frame', or 'info frame').
1692 In the template parameter FI is the frame being selected. The
1693 SELECTED_FRAME_P flag is true if the frame being selected was done by
1694 default, which happens when the user uses the base command with no
1695 arguments. For example the commands 'info frame', 'select-frame',
1696 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1697 SELECTED_FRAME_P is false. */
1699 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1700 class frame_command_helper
1704 /* The "frame level" family of commands. The ARG is an integer that is
1705 the frame's level in the stack. */
1707 level (const char *arg
, int from_tty
)
1709 int level
= value_as_long (parse_and_eval (arg
));
1710 struct frame_info
*fid
1711 = find_relative_frame (get_current_frame (), &level
);
1713 error (_("No frame at level %s."), arg
);
1717 /* The "frame address" family of commands. ARG is a stack-pointer
1718 address for an existing frame. This command does not allow new
1719 frames to be created. */
1722 address (const char *arg
, int from_tty
)
1724 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1725 struct frame_info
*fid
= find_frame_for_address (addr
);
1727 error (_("No frame at address %s."), arg
);
1731 /* The "frame view" family of commands. ARG is one or two addresses and
1732 is used to view a frame that might be outside the current backtrace.
1733 The addresses are stack-pointer address, and (optional) pc-address. */
1736 view (const char *args
, int from_tty
)
1738 struct frame_info
*fid
;
1741 error (_("Missing address argument to view a frame"));
1743 gdb_argv
argv (args
);
1745 if (argv
.count () == 2)
1749 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1750 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1751 fid
= create_new_frame (addr
[0], addr
[1]);
1755 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1756 fid
= create_new_frame (addr
, false);
1761 /* The "frame function" family of commands. ARG is the name of a
1762 function within the stack, the first function (searching from frame
1763 0) with that name will be selected. */
1766 function (const char *arg
, int from_tty
)
1769 error (_("Missing function name argument"));
1770 struct frame_info
*fid
= find_frame_for_function (arg
);
1772 error (_("No frame for function \"%s\"."), arg
);
1776 /* The "frame" base command, that is, when no sub-command is specified.
1777 If one argument is provided then we assume that this is a frame's
1778 level as historically, this was the supported command syntax that was
1781 If no argument is provided, then the current frame is selected. */
1784 base_command (const char *arg
, int from_tty
)
1787 FPTR (get_selected_frame (_("No stack.")), true);
1789 level (arg
, from_tty
);
1793 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1794 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1796 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1797 static frame_command_helper
<frame_command_core
> frame_cmd
;
1798 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1800 /* Print briefly all stack frames or just the innermost COUNT_EXP
1804 backtrace_command_1 (const char *count_exp
, frame_filter_flags flags
,
1805 int no_filters
, int from_tty
)
1807 struct frame_info
*fi
;
1809 int py_start
= 0, py_end
= 0;
1810 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1812 if (!target_has_stack
)
1813 error (_("No stack."));
1817 count
= parse_and_eval_long (count_exp
);
1823 /* The argument to apply_ext_lang_frame_filter is the number
1824 of the final frame to print, and frames start at 0. */
1836 enum ext_lang_frame_args arg_type
;
1838 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1840 flags
|= PRINT_MORE_FRAMES
;
1842 if (!strcmp (print_frame_arguments
, "scalars"))
1843 arg_type
= CLI_SCALAR_VALUES
;
1844 else if (!strcmp (print_frame_arguments
, "all"))
1845 arg_type
= CLI_ALL_VALUES
;
1847 arg_type
= NO_VALUES
;
1849 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1850 arg_type
, current_uiout
,
1854 /* Run the inbuilt backtrace if there are no filters registered, or
1855 "no-filters" has been specified from the command. */
1856 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1858 struct frame_info
*trailing
;
1860 /* The following code must do two things. First, it must set the
1861 variable TRAILING to the frame from which we should start
1862 printing. Second, it must set the variable count to the number
1863 of frames which we should print, or -1 if all of them. */
1865 if (count_exp
!= NULL
&& count
< 0)
1867 trailing
= trailing_outermost_frame (-count
);
1871 trailing
= get_current_frame ();
1873 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
1877 /* Don't use print_stack_frame; if an error() occurs it probably
1878 means further attempts to backtrace would fail (on the other
1879 hand, perhaps the code does or could be fixed to make sure
1880 the frame->prev field gets set to NULL in that case). */
1882 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1883 if ((flags
& PRINT_LOCALS
) != 0)
1885 struct frame_id frame_id
= get_frame_id (fi
);
1887 print_frame_local_vars (fi
, false, NULL
, NULL
, 1, gdb_stdout
);
1889 /* print_frame_local_vars invalidates FI. */
1890 fi
= frame_find_by_id (frame_id
);
1894 warning (_("Unable to restore previously selected frame."));
1899 /* Save the last frame to check for error conditions. */
1903 /* If we've stopped before the end, mention that. */
1905 printf_filtered (_("(More stack frames follow...)\n"));
1907 /* If we've run out of frames, and the reason appears to be an error
1908 condition, print it. */
1909 if (fi
== NULL
&& trailing
!= NULL
)
1911 enum unwind_stop_reason reason
;
1913 reason
= get_frame_unwind_stop_reason (trailing
);
1914 if (reason
>= UNWIND_FIRST_ERROR
)
1915 printf_filtered (_("Backtrace stopped: %s\n"),
1916 frame_stop_reason_string (trailing
));
1922 backtrace_command (const char *arg
, int from_tty
)
1924 bool filters
= true;
1925 frame_filter_flags flags
= 0;
1933 const char *save_arg
= arg
;
1934 std::string this_arg
= extract_arg (&arg
);
1936 if (this_arg
.empty ())
1939 if (subset_compare (this_arg
.c_str (), "no-filters"))
1941 else if (subset_compare (this_arg
.c_str (), "full"))
1942 flags
|= PRINT_LOCALS
;
1943 else if (subset_compare (this_arg
.c_str (), "hide"))
1944 flags
|= PRINT_HIDE
;
1947 /* Not a recognized argument, so stop. */
1957 backtrace_command_1 (arg
, flags
, !filters
/* no frame-filters */, from_tty
);
1960 /* Iterate over the local variables of a block B, calling CB with
1964 iterate_over_block_locals (const struct block
*b
,
1965 iterate_over_block_arg_local_vars_cb cb
,
1968 struct block_iterator iter
;
1971 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1973 switch (SYMBOL_CLASS (sym
))
1979 case LOC_OPTIMIZED_OUT
:
1980 if (SYMBOL_IS_ARGUMENT (sym
))
1982 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1984 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1988 /* Ignore symbols which are not locals. */
1995 /* Same, but print labels. */
1998 /* Commented out, as the code using this function has also been
1999 commented out. FIXME:brobecker/2009-01-13: Find out why the code
2000 was commented out in the first place. The discussion introducing
2001 this change (2007-12-04: Support lexical blocks and function bodies
2002 that occupy non-contiguous address ranges) did not explain why
2003 this change was made. */
2005 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2006 int *have_default
, struct ui_file
*stream
)
2008 struct block_iterator iter
;
2010 int values_printed
= 0;
2012 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2014 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2020 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2022 struct symtab_and_line sal
;
2023 struct value_print_options opts
;
2025 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2027 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2028 get_user_print_options (&opts
);
2029 if (opts
.addressprint
)
2031 fprintf_filtered (stream
, " ");
2032 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2035 fprintf_filtered (stream
, " in file %s, line %d\n",
2036 sal
.symtab
->filename
, sal
.line
);
2040 return values_printed
;
2044 /* Iterate over all the local variables in block B, including all its
2045 superblocks, stopping when the top-level block is reached. */
2048 iterate_over_block_local_vars (const struct block
*block
,
2049 iterate_over_block_arg_local_vars_cb cb
,
2054 iterate_over_block_locals (block
, cb
, cb_data
);
2055 /* After handling the function's top-level block, stop. Don't
2056 continue to its superblock, the block of per-file
2058 if (BLOCK_FUNCTION (block
))
2060 block
= BLOCK_SUPERBLOCK (block
);
2064 /* Data to be passed around in the calls to the locals and args
2067 struct print_variable_and_value_data
2069 gdb::optional
<compiled_regex
> preg
;
2070 gdb::optional
<compiled_regex
> treg
;
2071 struct frame_id frame_id
;
2073 struct ui_file
*stream
;
2077 /* The callback for the locals and args iterators. */
2080 do_print_variable_and_value (const char *print_name
,
2084 struct print_variable_and_value_data
*p
2085 = (struct print_variable_and_value_data
*) cb_data
;
2086 struct frame_info
*frame
;
2088 if (p
->preg
.has_value ()
2089 && p
->preg
->exec (SYMBOL_NATURAL_NAME (sym
), 0,
2092 if (p
->treg
.has_value ()
2093 && !treg_matches_sym_type_name (*p
->treg
, sym
))
2096 frame
= frame_find_by_id (p
->frame_id
);
2099 warning (_("Unable to restore previously selected frame."));
2103 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2105 /* print_variable_and_value invalidates FRAME. */
2108 p
->values_printed
= 1;
2111 /* Prepares the regular expression REG from REGEXP.
2112 If REGEXP is NULL, it results in an empty regular expression. */
2115 prepare_reg (const char *regexp
, gdb::optional
<compiled_regex
> *reg
)
2119 int cflags
= REG_NOSUB
| (case_sensitivity
== case_sensitive_off
2121 reg
->emplace (regexp
, cflags
, _("Invalid regexp"));
2127 /* Print all variables from the innermost up to the function block of FRAME.
2128 Print them with values to STREAM indented by NUM_TABS.
2129 If REGEXP is not NULL, only print local variables whose name
2131 If T_REGEXP is not NULL, only print local variables whose type
2133 If no local variables have been printed and !QUIET, prints a message
2134 explaining why no local variables could be printed.
2136 This function will invalidate FRAME. */
2139 print_frame_local_vars (struct frame_info
*frame
,
2141 const char *regexp
, const char *t_regexp
,
2142 int num_tabs
, struct ui_file
*stream
)
2144 struct print_variable_and_value_data cb_data
;
2145 const struct block
*block
;
2148 if (!get_frame_pc_if_available (frame
, &pc
))
2151 fprintf_filtered (stream
,
2152 _("PC unavailable, cannot determine locals.\n"));
2156 block
= get_frame_block (frame
, 0);
2160 fprintf_filtered (stream
, "No symbol table info available.\n");
2164 prepare_reg (regexp
, &cb_data
.preg
);
2165 prepare_reg (t_regexp
, &cb_data
.treg
);
2166 cb_data
.frame_id
= get_frame_id (frame
);
2167 cb_data
.num_tabs
= 4 * num_tabs
;
2168 cb_data
.stream
= stream
;
2169 cb_data
.values_printed
= 0;
2171 /* Temporarily change the selected frame to the given FRAME.
2172 This allows routines that rely on the selected frame instead
2173 of being given a frame as parameter to use the correct frame. */
2174 scoped_restore_selected_frame restore_selected_frame
;
2175 select_frame (frame
);
2177 iterate_over_block_local_vars (block
,
2178 do_print_variable_and_value
,
2181 if (!cb_data
.values_printed
&& !quiet
)
2183 if (regexp
== NULL
&& t_regexp
== NULL
)
2184 fprintf_filtered (stream
, _("No locals.\n"));
2186 fprintf_filtered (stream
, _("No matching locals.\n"));
2191 info_locals_command (const char *args
, int from_tty
)
2194 std::string t_regexp
;
2198 && extract_info_print_args (&args
, &quiet
, ®exp
, &t_regexp
))
2202 report_unrecognized_option_error ("info locals", args
);
2204 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2206 regexp
.empty () ? NULL
: regexp
.c_str (),
2207 t_regexp
.empty () ? NULL
: t_regexp
.c_str (),
2211 /* Iterate over all the argument variables in block B. */
2214 iterate_over_block_arg_vars (const struct block
*b
,
2215 iterate_over_block_arg_local_vars_cb cb
,
2218 struct block_iterator iter
;
2219 struct symbol
*sym
, *sym2
;
2221 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2223 /* Don't worry about things which aren't arguments. */
2224 if (SYMBOL_IS_ARGUMENT (sym
))
2226 /* We have to look up the symbol because arguments can have
2227 two entries (one a parameter, one a local) and the one we
2228 want is the local, which lookup_symbol will find for us.
2229 This includes gcc1 (not gcc2) on the sparc when passing a
2230 small structure and gcc2 when the argument type is float
2231 and it is passed as a double and converted to float by
2232 the prologue (in the latter case the type of the LOC_ARG
2233 symbol is double and the type of the LOC_LOCAL symbol is
2234 float). There are also LOC_ARG/LOC_REGISTER pairs which
2235 are not combined in symbol-reading. */
2237 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2238 b
, VAR_DOMAIN
).symbol
;
2239 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2244 /* Print all argument variables of the function of FRAME.
2245 Print them with values to STREAM.
2246 If REGEXP is not NULL, only print argument variables whose name
2248 If T_REGEXP is not NULL, only print argument variables whose type
2250 If no argument variables have been printed and !QUIET, prints a message
2251 explaining why no argument variables could be printed.
2253 This function will invalidate FRAME. */
2256 print_frame_arg_vars (struct frame_info
*frame
,
2258 const char *regexp
, const char *t_regexp
,
2259 struct ui_file
*stream
)
2261 struct print_variable_and_value_data cb_data
;
2262 struct symbol
*func
;
2264 gdb::optional
<compiled_regex
> preg
;
2265 gdb::optional
<compiled_regex
> treg
;
2267 if (!get_frame_pc_if_available (frame
, &pc
))
2270 fprintf_filtered (stream
,
2271 _("PC unavailable, cannot determine args.\n"));
2275 func
= get_frame_function (frame
);
2279 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2283 prepare_reg (regexp
, &cb_data
.preg
);
2284 prepare_reg (t_regexp
, &cb_data
.treg
);
2285 cb_data
.frame_id
= get_frame_id (frame
);
2286 cb_data
.num_tabs
= 0;
2287 cb_data
.stream
= stream
;
2288 cb_data
.values_printed
= 0;
2290 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2291 do_print_variable_and_value
, &cb_data
);
2293 /* do_print_variable_and_value invalidates FRAME. */
2296 if (!cb_data
.values_printed
&& !quiet
)
2298 if (regexp
== NULL
&& t_regexp
== NULL
)
2299 fprintf_filtered (stream
, _("No arguments.\n"));
2301 fprintf_filtered (stream
, _("No matching arguments.\n"));
2306 info_args_command (const char *args
, int from_tty
)
2309 std::string t_regexp
;
2313 && extract_info_print_args (&args
, &quiet
, ®exp
, &t_regexp
))
2317 report_unrecognized_option_error ("info args", args
);
2320 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2322 regexp
.empty () ? NULL
: regexp
.c_str (),
2323 t_regexp
.empty () ? NULL
: t_regexp
.c_str (),
2327 /* Return the symbol-block in which the selected frame is executing.
2328 Can return zero under various legitimate circumstances.
2330 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2331 code address within the block returned. We use this to decide
2332 which macros are in scope. */
2334 const struct block
*
2335 get_selected_block (CORE_ADDR
*addr_in_block
)
2337 if (!has_stack_frames ())
2340 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2343 /* Find a frame a certain number of levels away from FRAME.
2344 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2345 Positive means go to earlier frames (up); negative, the reverse.
2346 The int that contains the number of levels is counted toward
2347 zero as the frames for those levels are found.
2348 If the top or bottom frame is reached, that frame is returned,
2349 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2350 how much farther the original request asked to go. */
2353 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2355 /* Going up is simple: just call get_prev_frame enough times or
2356 until the initial frame is reached. */
2357 while (*level_offset_ptr
> 0)
2359 struct frame_info
*prev
= get_prev_frame (frame
);
2363 (*level_offset_ptr
)--;
2367 /* Going down is just as simple. */
2368 while (*level_offset_ptr
< 0)
2370 struct frame_info
*next
= get_next_frame (frame
);
2374 (*level_offset_ptr
)++;
2381 /* Select the frame up one or COUNT_EXP stack levels from the
2382 previously selected frame, and print it briefly. */
2385 up_silently_base (const char *count_exp
)
2387 struct frame_info
*frame
;
2391 count
= parse_and_eval_long (count_exp
);
2393 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2394 if (count
!= 0 && count_exp
== NULL
)
2395 error (_("Initial frame selected; you cannot go up."));
2396 select_frame (frame
);
2400 up_silently_command (const char *count_exp
, int from_tty
)
2402 up_silently_base (count_exp
);
2406 up_command (const char *count_exp
, int from_tty
)
2408 up_silently_base (count_exp
);
2409 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2412 /* Select the frame down one or COUNT_EXP stack levels from the previously
2413 selected frame, and print it briefly. */
2416 down_silently_base (const char *count_exp
)
2418 struct frame_info
*frame
;
2422 count
= -parse_and_eval_long (count_exp
);
2424 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2425 if (count
!= 0 && count_exp
== NULL
)
2427 /* We only do this if COUNT_EXP is not specified. That way
2428 "down" means to really go down (and let me know if that is
2429 impossible), but "down 9999" can be used to mean go all the
2430 way down without getting an error. */
2432 error (_("Bottom (innermost) frame selected; you cannot go down."));
2435 select_frame (frame
);
2439 down_silently_command (const char *count_exp
, int from_tty
)
2441 down_silently_base (count_exp
);
2445 down_command (const char *count_exp
, int from_tty
)
2447 down_silently_base (count_exp
);
2448 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2452 return_command (const char *retval_exp
, int from_tty
)
2454 /* Initialize it just to avoid a GCC false warning. */
2455 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2456 struct frame_info
*thisframe
;
2457 struct gdbarch
*gdbarch
;
2458 struct symbol
*thisfun
;
2459 struct value
*return_value
= NULL
;
2460 struct value
*function
= NULL
;
2461 const char *query_prefix
= "";
2463 thisframe
= get_selected_frame ("No selected frame.");
2464 thisfun
= get_frame_function (thisframe
);
2465 gdbarch
= get_frame_arch (thisframe
);
2467 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2468 error (_("Can not force return from an inlined function."));
2470 /* Compute the return value. If the computation triggers an error,
2471 let it bail. If the return type can't be handled, set
2472 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2476 expression_up retval_expr
= parse_expression (retval_exp
);
2477 struct type
*return_type
= NULL
;
2479 /* Compute the return value. Should the computation fail, this
2480 call throws an error. */
2481 return_value
= evaluate_expression (retval_expr
.get ());
2483 /* Cast return value to the return type of the function. Should
2484 the cast fail, this call throws an error. */
2485 if (thisfun
!= NULL
)
2486 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2487 if (return_type
== NULL
)
2489 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2490 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2491 error (_("Return value type not available for selected "
2493 "Please use an explicit cast of the value to return."));
2494 return_type
= value_type (return_value
);
2496 return_type
= check_typedef (return_type
);
2497 return_value
= value_cast (return_type
, return_value
);
2499 /* Make sure the value is fully evaluated. It may live in the
2500 stack frame we're about to pop. */
2501 if (value_lazy (return_value
))
2502 value_fetch_lazy (return_value
);
2504 if (thisfun
!= NULL
)
2505 function
= read_var_value (thisfun
, NULL
, thisframe
);
2507 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2508 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2509 /* If the return-type is "void", don't try to find the
2510 return-value's location. However, do still evaluate the
2511 return expression so that, even when the expression result
2512 is discarded, side effects such as "return i++" still
2514 return_value
= NULL
;
2515 else if (thisfun
!= NULL
)
2517 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2518 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2519 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2521 query_prefix
= "The location at which to store the "
2522 "function's return value is unknown.\n"
2523 "If you continue, the return value "
2524 "that you specified will be ignored.\n";
2525 return_value
= NULL
;
2530 /* Does an interactive user really want to do this? Include
2531 information, such as how well GDB can handle the return value, in
2532 the query message. */
2537 if (thisfun
== NULL
)
2538 confirmed
= query (_("%sMake selected stack frame return now? "),
2542 if (TYPE_NO_RETURN (thisfun
->type
))
2543 warning (_("Function does not return normally to caller."));
2544 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2545 SYMBOL_PRINT_NAME (thisfun
));
2548 error (_("Not confirmed"));
2551 /* Discard the selected frame and all frames inner-to it. */
2552 frame_pop (get_selected_frame (NULL
));
2554 /* Store RETURN_VALUE in the just-returned register set. */
2555 if (return_value
!= NULL
)
2557 struct type
*return_type
= value_type (return_value
);
2558 struct gdbarch
*cache_arch
= get_current_regcache ()->arch ();
2560 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2561 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2562 gdbarch_return_value (cache_arch
, function
, return_type
,
2563 get_current_regcache (), NULL
/*read*/,
2564 value_contents (return_value
) /*write*/);
2567 /* If we are at the end of a call dummy now, pop the dummy frame
2569 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2570 frame_pop (get_current_frame ());
2572 select_frame (get_current_frame ());
2573 /* If interactive, print the frame that is now current. */
2575 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2578 /* Find the most inner frame in the current stack for a function called
2579 FUNCTION_NAME. If no matching frame is found return NULL. */
2581 static struct frame_info
*
2582 find_frame_for_function (const char *function_name
)
2584 /* Used to hold the lower and upper addresses for each of the
2585 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2586 struct function_bounds
2588 CORE_ADDR low
, high
;
2590 struct frame_info
*frame
;
2594 gdb_assert (function_name
!= NULL
);
2596 frame
= get_current_frame ();
2597 std::vector
<symtab_and_line
> sals
2598 = decode_line_with_current_source (function_name
,
2599 DECODE_LINE_FUNFIRSTLINE
);
2600 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2601 for (size_t i
= 0; i
< sals
.size (); i
++)
2603 if (sals
[i
].pspace
!= current_program_space
)
2604 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2605 else if (sals
[i
].pc
== 0
2606 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2607 &func_bounds
[i
].low
,
2608 &func_bounds
[i
].high
) == 0)
2609 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2614 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2615 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2616 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2620 frame
= find_relative_frame (frame
, &level
);
2623 while (!found
&& level
== 0);
2631 /* Implements the dbx 'func' command. */
2634 func_command (const char *arg
, int from_tty
)
2639 struct frame_info
*frame
= find_frame_for_function (arg
);
2641 error (_("'%s' not within current stack frame."), arg
);
2642 if (frame
!= get_selected_frame (NULL
))
2644 select_frame (frame
);
2645 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2649 /* Apply a GDB command to all stack frames, or a set of identified frames,
2650 or innermost COUNT frames.
2651 With a negative COUNT, apply command on outermost -COUNT frames.
2653 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2654 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2655 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2656 frame apply all -s p local_var_no_idea_in_which_frame
2657 If a frame has a local variable called
2658 local_var_no_idea_in_which_frame, print frame
2659 and value of local_var_no_idea_in_which_frame.
2660 frame apply all -s -q p local_var_no_idea_in_which_frame
2661 Same as before, but only print the variable value.
2662 frame apply level 2-5 0 4-7 -s p i = i + 1
2663 Adds 1 to the variable i in the specified frames.
2664 Note that i will be incremented twice in
2667 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2668 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2669 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2670 for error messages. */
2673 frame_apply_command_count (const char *which_command
,
2674 const char *cmd
, int from_tty
,
2675 struct frame_info
*trailing
, int count
)
2678 struct frame_info
*fi
;
2680 while (cmd
!= NULL
&& parse_flags_qcs (which_command
, &cmd
, &flags
))
2683 if (cmd
== NULL
|| *cmd
== '\0')
2684 error (_("Please specify a command to apply on the selected frames"));
2686 /* The below will restore the current inferior/thread/frame.
2687 Usually, only the frame is effectively to be restored.
2688 But in case CMD switches of inferior/thread, better restore
2690 scoped_restore_current_thread restore_thread
;
2692 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2699 std::string cmd_result
;
2701 /* In case CMD switches of inferior/thread/frame, the below
2702 restores the inferior/thread/frame. FI can then be
2703 set to the selected frame. */
2704 scoped_restore_current_thread restore_fi_current_frame
;
2706 cmd_result
= execute_command_to_string (cmd
, from_tty
);
2708 fi
= get_selected_frame (_("frame apply "
2709 "unable to get selected frame."));
2710 if (!flags
.silent
|| cmd_result
.length () > 0)
2713 print_stack_frame (fi
, 1, LOCATION
, 0);
2714 printf_filtered ("%s", cmd_result
.c_str ());
2717 CATCH (ex
, RETURN_MASK_ERROR
)
2719 fi
= get_selected_frame (_("frame apply "
2720 "unable to get selected frame."));
2724 print_stack_frame (fi
, 1, LOCATION
, 0);
2726 printf_filtered ("%s\n", ex
.what ());
2728 throw_exception (ex
);
2735 /* Implementation of the "frame apply level" command. */
2738 frame_apply_level_command (const char *cmd
, int from_tty
)
2740 if (!target_has_stack
)
2741 error (_("No stack."));
2743 bool level_found
= false;
2744 const char *levels_str
= cmd
;
2745 number_or_range_parser
levels (levels_str
);
2747 /* Skip the LEVEL list to find the flags and command args. */
2748 while (!levels
.finished ())
2750 /* Call for effect. */
2751 levels
.get_number ();
2754 if (levels
.in_range ())
2755 levels
.skip_range ();
2759 error (_("Missing or invalid LEVEL... argument"));
2761 cmd
= levels
.cur_tok ();
2763 /* Redo the LEVELS parsing, but applying COMMAND. */
2764 levels
.init (levels_str
);
2765 while (!levels
.finished ())
2767 const int level_beg
= levels
.get_number ();
2770 if (levels
.in_range ())
2772 n_frames
= levels
.end_value () - level_beg
+ 1;
2773 levels
.skip_range ();
2778 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
2779 leading_innermost_frame (level_beg
), n_frames
);
2783 /* Implementation of the "frame apply all" command. */
2786 frame_apply_all_command (const char *cmd
, int from_tty
)
2788 if (!target_has_stack
)
2789 error (_("No stack."));
2791 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
2792 get_current_frame (), INT_MAX
);
2795 /* Implementation of the "frame apply" command. */
2798 frame_apply_command (const char* cmd
, int from_tty
)
2801 struct frame_info
*trailing
;
2803 if (!target_has_stack
)
2804 error (_("No stack."));
2807 error (_("Missing COUNT argument."));
2808 count
= get_number_trailer (&cmd
, 0);
2810 error (_("Invalid COUNT argument."));
2814 trailing
= trailing_outermost_frame (-count
);
2818 trailing
= get_current_frame ();
2820 frame_apply_command_count ("frame apply", cmd
, from_tty
,
2824 /* Implementation of the "faas" command. */
2827 faas_command (const char *cmd
, int from_tty
)
2829 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
2830 execute_command (expanded
.c_str (), from_tty
);
2834 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
2835 matching frame can be found. */
2837 static struct frame_info
*
2838 find_frame_for_address (CORE_ADDR address
)
2841 struct frame_info
*fid
;
2843 id
= frame_id_build_wild (address
);
2845 /* If (s)he specifies the frame with an address, he deserves
2846 what (s)he gets. Still, give the highest one that matches.
2847 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
2849 for (fid
= get_current_frame ();
2851 fid
= get_prev_frame (fid
))
2853 if (frame_id_eq (id
, get_frame_id (fid
)))
2855 struct frame_info
*prev_frame
;
2859 prev_frame
= get_prev_frame (fid
);
2861 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
2873 /* Commands with a prefix of `frame apply'. */
2874 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
2876 /* Commands with a prefix of `frame'. */
2877 static struct cmd_list_element
*frame_cmd_list
= NULL
;
2879 /* Commands with a prefix of `select frame'. */
2880 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
2882 /* Commands with a prefix of `info frame'. */
2883 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
2886 _initialize_stack (void)
2888 struct cmd_list_element
*cmd
;
2890 add_com ("return", class_stack
, return_command
, _("\
2891 Make selected stack frame return to its caller.\n\
2892 Control remains in the debugger, but when you continue\n\
2893 execution will resume in the frame above the one now selected.\n\
2894 If an argument is given, it is an expression for the value to return."));
2896 add_com ("up", class_stack
, up_command
, _("\
2897 Select and print stack frame that called this one.\n\
2898 An argument says how many frames up to go."));
2899 add_com ("up-silently", class_support
, up_silently_command
, _("\
2900 Same as the `up' command, but does not print anything.\n\
2901 This is useful in command scripts."));
2903 add_com ("down", class_stack
, down_command
, _("\
2904 Select and print stack frame called by this one.\n\
2905 An argument says how many frames down to go."));
2906 add_com_alias ("do", "down", class_stack
, 1);
2907 add_com_alias ("dow", "down", class_stack
, 1);
2908 add_com ("down-silently", class_support
, down_silently_command
, _("\
2909 Same as the `down' command, but does not print anything.\n\
2910 This is useful in command scripts."));
2912 add_prefix_cmd ("frame", class_stack
,
2913 &frame_cmd
.base_command
, _("\
2914 Select and print a stack frame.\n\
2915 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2916 A single numerical argument specifies the frame to select."),
2917 &frame_cmd_list
, "frame ", 1, &cmdlist
);
2919 add_com_alias ("f", "frame", class_stack
, 1);
2921 #define FRAME_APPLY_FLAGS_HELP "\
2922 Prints the frame location information followed by COMMAND output.\n\
2923 FLAG arguments are -q (quiet), -c (continue), -s (silent).\n\
2924 Flag -q disables printing the frame location information.\n\
2925 By default, if a COMMAND raises an error, frame apply is aborted.\n\
2926 Flag -c indicates to print the error and continue.\n\
2927 Flag -s indicates to silently ignore a COMMAND that raises an error\n\
2928 or produces no output."
2930 add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
2931 _("Apply a command to a number of frames.\n\
2932 Usage: frame apply COUNT [FLAG]... COMMAND\n\
2933 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
2934 FRAME_APPLY_FLAGS_HELP
),
2935 &frame_apply_cmd_list
, "frame apply ", 1, &frame_cmd_list
);
2937 add_cmd ("all", class_stack
, frame_apply_all_command
,
2939 Apply a command to all frames.\n\
2941 Usage: frame apply all [FLAG]... COMMAND\n"
2942 FRAME_APPLY_FLAGS_HELP
),
2943 &frame_apply_cmd_list
);
2945 add_cmd ("level", class_stack
, frame_apply_level_command
,
2947 Apply a command to a list of frames.\n\
2949 Usage: frame apply level LEVEL... [FLAG]... COMMAND\n\
2950 ID is a space-separated list of LEVELs of frames to apply COMMAND on.\n"
2951 FRAME_APPLY_FLAGS_HELP
),
2952 &frame_apply_cmd_list
);
2954 add_com ("faas", class_stack
, faas_command
, _("\
2955 Apply a command to all frames (ignoring errors and empty output).\n\
2956 Usage: faas COMMAND\n\
2957 shortcut for 'frame apply all -s COMMAND'"));
2960 add_prefix_cmd ("frame", class_stack
,
2961 &frame_cmd
.base_command
, _("\
2962 Select and print a stack frame.\n\
2963 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2964 A single numerical argument specifies the frame to select."),
2965 &frame_cmd_list
, "frame ", 1, &cmdlist
);
2966 add_com_alias ("f", "frame", class_stack
, 1);
2968 add_cmd ("address", class_stack
, &frame_cmd
.address
,
2970 Select and print a stack frame by stack address\n\
2972 Usage: frame address STACK-ADDRESS"),
2975 add_cmd ("view", class_stack
, &frame_cmd
.view
,
2977 View a stack frame that might be outside the current backtrace.\n\
2979 Usage: frame view STACK-ADDRESS\n\
2980 frame view STACK-ADDRESS PC-ADDRESS"),
2983 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
2985 Select and print a stack frame by function name.\n\
2987 Usage: frame function NAME\n\
2989 The innermost frame that visited function NAME is selected."),
2991 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
2994 add_cmd ("level", class_stack
, &frame_cmd
.level
,
2996 Select and print a stack frame by level.\n\
2998 Usage: frame level LEVEL"),
3001 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
3002 &select_frame_cmd
.base_command
, _("\
3003 Select a stack frame without printing anything.\n\
3004 A single numerical argument specifies the frame to select."),
3005 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
3006 &cli_suppress_notification
.user_selected_context
);
3008 add_cmd_suppress_notification ("address", class_stack
,
3009 &select_frame_cmd
.address
, _("\
3010 Select a stack frame by stack address.\n\
3012 Usage: select-frame address STACK-ADDRESS"),
3013 &select_frame_cmd_list
,
3014 &cli_suppress_notification
.user_selected_context
);
3017 add_cmd_suppress_notification ("view", class_stack
,
3018 &select_frame_cmd
.view
, _("\
3019 Select a stack frame that might be outside the current backtrace.\n\
3021 Usage: select-frame view STACK-ADDRESS\n\
3022 select-frame view STACK-ADDRESS PC-ADDRESS"),
3023 &select_frame_cmd_list
,
3024 &cli_suppress_notification
.user_selected_context
);
3026 cmd
= add_cmd_suppress_notification ("function", class_stack
,
3027 &select_frame_cmd
.function
, _("\
3028 Select a stack frame by function name.\n\
3030 Usage: select-frame function NAME"),
3031 &select_frame_cmd_list
,
3032 &cli_suppress_notification
.user_selected_context
);
3033 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3035 add_cmd_suppress_notification ("level", class_stack
,
3036 &select_frame_cmd
.level
, _("\
3037 Select a stack frame by level.\n\
3039 Usage: select-frame level LEVEL"),
3040 &select_frame_cmd_list
,
3041 &cli_suppress_notification
.user_selected_context
);
3043 add_com ("backtrace", class_stack
, backtrace_command
, _("\
3044 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3045 Usage: backtrace [QUALIFIERS]... [COUNT]\n\
3046 With a negative argument, print outermost -COUNT frames.\n\
3047 Use of the 'full' qualifier also prints the values of the local variables.\n\
3048 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
3049 on this backtrace."));
3050 add_com_alias ("bt", "backtrace", class_stack
, 0);
3052 add_com_alias ("where", "backtrace", class_alias
, 0);
3053 add_info ("stack", backtrace_command
,
3054 _("Backtrace of the stack, or innermost COUNT frames."));
3055 add_info_alias ("s", "stack", 1);
3057 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
3058 _("All about the selected stack frame.\n\
3059 With no arguments, displays information about the currently selected stack\n\
3060 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3061 the information is then printed about the specified frame."),
3062 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
3063 add_info_alias ("f", "frame", 1);
3065 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
3067 Print information about a stack frame selected by stack address.\n\
3069 Usage: info frame address STACK-ADDRESS"),
3070 &info_frame_cmd_list
);
3072 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
3074 Print information about a stack frame outside the current backtrace.\n\
3076 Usage: info frame view STACK-ADDRESS\n\
3077 info frame view STACK-ADDRESS PC-ADDRESS"),
3078 &info_frame_cmd_list
);
3080 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
3082 Print information about a stack frame selected by function name.\n\
3084 Usage: info frame function NAME"),
3085 &info_frame_cmd_list
);
3086 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
3088 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
3090 Print information about a stack frame selected by level.\n\
3092 Usage: info frame level LEVEL"),
3093 &info_frame_cmd_list
);
3095 add_info ("locals", info_locals_command
,
3096 info_print_args_help (_("\
3097 All local variables of current stack frame or those matching REGEXPs.\n\
3098 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3099 Prints the local variables of the current stack frame.\n"),
3100 _("local variables")));
3101 add_info ("args", info_args_command
,
3102 info_print_args_help (_("\
3103 All argument variables of current stack frame or those matching REGEXPs.\n\
3104 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3105 Prints the argument variables of the current stack frame.\n"),
3106 _("argument variables")));
3109 add_com ("func", class_stack
, func_command
, _("\
3110 Select the stack frame that contains NAME.\n\
3111 Usage: func NAME"));
3113 add_setshow_enum_cmd ("frame-arguments", class_stack
,
3114 print_frame_arguments_choices
, &print_frame_arguments
,
3115 _("Set printing of non-scalar frame arguments"),
3116 _("Show printing of non-scalar frame arguments"),
3117 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
3119 add_setshow_boolean_cmd ("frame-arguments", no_class
,
3120 &print_raw_frame_arguments
, _("\
3121 Set whether to print frame arguments in raw form."), _("\
3122 Show whether to print frame arguments in raw form."), _("\
3123 If set, frame arguments are printed in raw form, bypassing any\n\
3124 pretty-printers for that value."),
3126 &setprintrawlist
, &showprintrawlist
);
3128 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3129 &disassemble_next_line
, _("\
3130 Set whether to disassemble next source line or insn when execution stops."),
3132 Show whether to disassemble next source line or insn when execution stops."),
3134 If ON, GDB will display disassembly of the next source line, in addition\n\
3135 to displaying the source line itself. If the next source line cannot\n\
3136 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3137 will display disassembly of next instruction instead of showing the\n\
3139 If AUTO, display disassembly of next instruction only if the source line\n\
3140 cannot be displayed.\n\
3141 If OFF (which is the default), never display the disassembly of the next\n\
3144 show_disassemble_next_line
,
3145 &setlist
, &showlist
);
3146 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3148 add_setshow_enum_cmd ("entry-values", class_stack
,
3149 print_entry_values_choices
, &print_entry_values
,
3150 _("Set printing of function arguments at function "
3152 _("Show printing of function arguments at function "
3155 GDB can sometimes determine the values of function arguments at entry,\n\
3156 in addition to their current values. This option tells GDB whether\n\
3157 to print the current value, the value at entry (marked as val@entry),\n\
3158 or both. Note that one or both of these values may be <optimized out>."),
3159 NULL
, NULL
, &setprintlist
, &showprintlist
);