1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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
*, int,
94 static void print_frame (struct frame_info
*frame
, int print_level
,
95 enum print_what print_what
, int print_args
,
96 struct symtab_and_line sal
);
98 static void set_last_displayed_sal (int valid
,
99 struct program_space
*pspace
,
101 struct symtab
*symtab
,
104 static struct frame_info
*find_frame_for_function (const char *);
105 static struct frame_info
*find_frame_for_address (CORE_ADDR
);
107 /* Zero means do things normally; we are interacting directly with the
108 user. One means print the full filename and linenumber when a
109 frame is printed, and do so in a format emacs18/emacs19.22 can
110 parse. Two means print similar annotations, but in many more
111 cases and in a slightly different syntax. */
113 int annotation_level
= 0;
115 /* These variables hold the last symtab and line we displayed to the user.
116 * This is where we insert a breakpoint or a skiplist entry by default. */
117 static int last_displayed_sal_valid
= 0;
118 static struct program_space
*last_displayed_pspace
= 0;
119 static CORE_ADDR last_displayed_addr
= 0;
120 static struct symtab
*last_displayed_symtab
= 0;
121 static int last_displayed_line
= 0;
124 /* Return 1 if we should display the address in addition to the location,
125 because we are in the middle of a statement. */
128 frame_show_address (struct frame_info
*frame
,
129 struct symtab_and_line sal
)
131 /* If there is a line number, but no PC, then there is no location
132 information associated with this sal. The only way that should
133 happen is for the call sites of inlined functions (SAL comes from
134 find_frame_sal). Otherwise, we would have some PC range if the
135 SAL came from a line table. */
136 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
138 if (get_next_frame (frame
) == NULL
)
139 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
141 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
145 return get_frame_pc (frame
) != sal
.pc
;
151 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
152 int print_level
, enum print_what print_what
,
155 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
157 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
160 /* Show or print a stack frame FRAME briefly. The output is formatted
161 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
162 relative level, function name, argument list, and file name and
163 line number. If the frame's PC is not at the beginning of the
164 source line, the actual PC is printed at the beginning. */
167 print_stack_frame (struct frame_info
*frame
, int print_level
,
168 enum print_what print_what
,
172 /* For mi, alway print location and address. */
173 if (current_uiout
->is_mi_like_p ())
174 print_what
= LOC_AND_ADDRESS
;
178 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
181 set_current_sal_from_frame (frame
);
183 CATCH (e
, RETURN_MASK_ERROR
)
189 /* Print nameless arguments of frame FRAME on STREAM, where START is
190 the offset of the first nameless argument, and NUM is the number of
191 nameless arguments to print. FIRST is nonzero if this is the first
192 argument (not just the first nameless argument). */
195 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
196 int first
, struct ui_file
*stream
)
198 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
199 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
204 for (i
= 0; i
< num
; i
++)
207 argsaddr
= get_frame_args_address (frame
);
210 arg_value
= read_memory_integer (argsaddr
+ start
,
211 sizeof (int), byte_order
);
213 fprintf_filtered (stream
, ", ");
214 fprintf_filtered (stream
, "%ld", arg_value
);
216 start
+= sizeof (int);
220 /* Print single argument of inferior function. ARG must be already
223 Errors are printed as if they would be the parameter value. Use zeroed ARG
224 iff it should not be printed accoring to user settings. */
227 print_frame_arg (const struct frame_arg
*arg
)
229 struct ui_out
*uiout
= current_uiout
;
230 const char *error_message
= NULL
;
234 gdb_assert (!arg
->val
|| !arg
->error
);
235 gdb_assert (arg
->entry_kind
== print_entry_values_no
236 || arg
->entry_kind
== print_entry_values_only
237 || (!uiout
->is_mi_like_p ()
238 && arg
->entry_kind
== print_entry_values_compact
));
240 annotate_arg_emitter arg_emitter
;
241 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
242 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
243 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
244 if (arg
->entry_kind
== print_entry_values_compact
)
246 /* It is OK to provide invalid MI-like stream as with
247 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
250 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
251 SYMBOL_LANGUAGE (arg
->sym
),
252 DMGL_PARAMS
| DMGL_ANSI
);
254 if (arg
->entry_kind
== print_entry_values_only
255 || arg
->entry_kind
== print_entry_values_compact
)
257 uiout
->field_stream ("name", stb
);
258 annotate_arg_name_end ();
261 if (!arg
->val
&& !arg
->error
)
266 error_message
= arg
->error
;
271 const struct language_defn
*language
;
272 struct value_print_options opts
;
274 /* Avoid value_print because it will deref ref parameters. We
275 just want to print their addresses. Print ??? for args whose
276 address we do not know. We pass 2 as "recurse" to val_print
277 because our standard indentation here is 4 spaces, and
278 val_print indents 2 for each recurse. */
280 annotate_arg_value (value_type (arg
->val
));
282 /* Use the appropriate language to display our symbol, unless the
283 user forced the language to a specific language. */
284 if (language_mode
== language_mode_auto
)
285 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
287 language
= current_language
;
289 get_no_prettyformat_print_options (&opts
);
291 opts
.raw
= print_raw_frame_arguments
;
293 /* True in "summary" mode, false otherwise. */
294 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
296 common_val_print (arg
->val
, &stb
, 2, &opts
, language
);
298 CATCH (except
, RETURN_MASK_ERROR
)
300 error_message
= except
.message
;
304 if (error_message
!= NULL
)
305 stb
.printf (_("<error reading variable: %s>"), error_message
);
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
.message
);
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 (strlen (except
.message
) + 1);
356 strcpy (val_error
, except
.message
);
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 (strlen (except
.message
) + 1);
379 strcpy (entryval_error
, except
.message
);
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
)
439 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
440 strcpy (entryval_error
, except
.message
);
445 /* Value was not a reference; and its content matches. */
446 if (val
== val_deref
)
454 /* Try to remove possibly duplicate error message for ENTRYARGP even
457 if (val_error
&& entryval_error
458 && strcmp (val_error
, entryval_error
) == 0)
460 entryval_error
= NULL
;
462 /* Do not se VAL_EQUAL as the same error message may be shown for
463 the entry value even if no entry values are present in the
469 if (entryval
== NULL
)
471 if (print_entry_values
== print_entry_values_preferred
)
473 gdb_assert (val
== NULL
);
477 val
= read_var_value (sym
, NULL
, frame
);
479 CATCH (except
, RETURN_MASK_ERROR
)
481 val_error
= (char *) alloca (strlen (except
.message
) + 1);
482 strcpy (val_error
, except
.message
);
486 if (print_entry_values
== print_entry_values_only
487 || print_entry_values
== print_entry_values_both
488 || (print_entry_values
== print_entry_values_preferred
489 && (!val
|| value_optimized_out (val
))))
491 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
492 entryval_error
= NULL
;
495 if ((print_entry_values
== print_entry_values_compact
496 || print_entry_values
== print_entry_values_if_needed
497 || print_entry_values
== print_entry_values_preferred
)
498 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
506 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
507 if (!val
&& !val_error
)
508 argp
->entry_kind
= print_entry_values_only
;
509 else if ((print_entry_values
== print_entry_values_compact
510 || print_entry_values
== print_entry_values_default
) && val_equal
)
512 argp
->entry_kind
= print_entry_values_compact
;
513 gdb_assert (!current_uiout
->is_mi_like_p ());
516 argp
->entry_kind
= print_entry_values_no
;
518 entryargp
->sym
= sym
;
519 entryargp
->val
= entryval
;
520 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
521 if (!entryval
&& !entryval_error
)
522 entryargp
->entry_kind
= print_entry_values_no
;
524 entryargp
->entry_kind
= print_entry_values_only
;
527 /* Print the arguments of frame FRAME on STREAM, given the function
528 FUNC running in that frame (as a symbol), where NUM is the number
529 of arguments according to the stack frame (or -1 if the number of
530 arguments is unknown). */
532 /* Note that currently the "number of arguments according to the
533 stack frame" is only known on VAX where i refers to the "number of
534 ints of arguments according to the stack frame". */
537 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
538 int num
, struct ui_file
*stream
)
540 struct ui_out
*uiout
= current_uiout
;
542 /* Offset of next stack argument beyond the one we have seen that is
543 at the highest offset, or -1 if we haven't come to a stack
545 long highest_offset
= -1;
546 /* Number of ints of arguments that we have printed so far. */
547 int args_printed
= 0;
548 /* True if we should print arguments, false otherwise. */
549 int print_args
= strcmp (print_frame_arguments
, "none");
553 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
554 struct block_iterator iter
;
557 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
559 struct frame_arg arg
, entryarg
;
563 /* Keep track of the highest stack argument offset seen, and
564 skip over any kinds of symbols we don't care about. */
566 if (!SYMBOL_IS_ARGUMENT (sym
))
569 switch (SYMBOL_CLASS (sym
))
574 long current_offset
= SYMBOL_VALUE (sym
);
575 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
577 /* Compute address of next argument by adding the size of
578 this argument and rounding to an int boundary. */
580 ((current_offset
+ arg_size
+ sizeof (int) - 1)
581 & ~(sizeof (int) - 1));
583 /* If this is the highest offset seen yet, set
585 if (highest_offset
== -1
586 || (current_offset
> highest_offset
))
587 highest_offset
= current_offset
;
589 /* Add the number of ints we're about to print to
591 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
594 /* We care about types of symbols, but don't need to
595 keep track of stack offsets in them. */
597 case LOC_REGPARM_ADDR
:
599 case LOC_OPTIMIZED_OUT
:
604 /* We have to look up the symbol because arguments can have
605 two entries (one a parameter, one a local) and the one we
606 want is the local, which lookup_symbol will find for us.
607 This includes gcc1 (not gcc2) on SPARC when passing a
608 small structure and gcc2 when the argument type is float
609 and it is passed as a double and converted to float by
610 the prologue (in the latter case the type of the LOC_ARG
611 symbol is double and the type of the LOC_LOCAL symbol is
613 /* But if the parameter name is null, don't try it. Null
614 parameter names occur on the RS/6000, for traceback
615 tables. FIXME, should we even print them? */
617 if (*SYMBOL_LINKAGE_NAME (sym
))
621 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
622 b
, VAR_DOMAIN
).symbol
;
623 gdb_assert (nsym
!= NULL
);
624 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
625 && !SYMBOL_IS_ARGUMENT (nsym
))
627 /* There is a LOC_ARG/LOC_REGISTER pair. This means
628 that it was passed on the stack and loaded into a
629 register, or passed in a register and stored in a
630 stack slot. GDB 3.x used the LOC_ARG; GDB
631 4.0-4.11 used the LOC_REGISTER.
633 Reasons for using the LOC_ARG:
635 (1) Because find_saved_registers may be slow for
638 (2) Because registers are often re-used and stack
639 slots rarely (never?) are. Therefore using
640 the stack slot is much less likely to print
643 Reasons why we might want to use the LOC_REGISTER:
645 (1) So that the backtrace prints the same value
646 as "print foo". I see no compelling reason
647 why this needs to be the case; having the
648 backtrace print the value which was passed
649 in, and "print foo" print the value as
650 modified within the called function, makes
653 Additional note: It might be nice if "info args"
654 displayed both values.
656 One more note: There is a case with SPARC
657 structure passing where we need to use the
658 LOC_REGISTER, but this is dealt with by creating
659 a single LOC_REGPARM in symbol reading. */
661 /* Leave sym (the LOC_ARG) alone. */
668 /* Print the current arg. */
671 uiout
->wrap_hint (" ");
675 memset (&arg
, 0, sizeof (arg
));
677 arg
.entry_kind
= print_entry_values_no
;
678 memset (&entryarg
, 0, sizeof (entryarg
));
680 entryarg
.entry_kind
= print_entry_values_no
;
683 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
685 if (arg
.entry_kind
!= print_entry_values_only
)
686 print_frame_arg (&arg
);
688 if (entryarg
.entry_kind
!= print_entry_values_no
)
690 if (arg
.entry_kind
!= print_entry_values_only
)
693 uiout
->wrap_hint (" ");
696 print_frame_arg (&entryarg
);
700 xfree (entryarg
.error
);
706 /* Don't print nameless args in situations where we don't know
707 enough about the stack to find them. */
712 if (highest_offset
== -1)
713 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
715 start
= highest_offset
;
717 print_frame_nameless_args (frame
, start
, num
- args_printed
,
722 /* Set the current source and line to the location given by frame
723 FRAME, if possible. When CENTER is true, adjust so the relevant
724 line is in the center of the next 'list'. */
727 set_current_sal_from_frame (struct frame_info
*frame
)
729 symtab_and_line sal
= find_frame_sal (frame
);
730 if (sal
.symtab
!= NULL
)
731 set_current_source_symtab_and_line (sal
);
734 /* If ON, GDB will display disassembly of the next source line when
735 execution of the program being debugged stops.
736 If AUTO (which is the default), or there's no line info to determine
737 the source line of the next instruction, display disassembly of next
738 instruction instead. */
740 static enum auto_boolean disassemble_next_line
;
743 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
744 struct cmd_list_element
*c
,
747 fprintf_filtered (file
,
748 _("Debugger's willingness to use "
749 "disassemble-next-line is %s.\n"),
753 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
754 because it will be broken by filter sometime. */
757 do_gdb_disassembly (struct gdbarch
*gdbarch
,
758 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
763 gdb_disassembly (gdbarch
, current_uiout
,
764 DISASSEMBLY_RAW_INSN
, how_many
,
767 CATCH (exception
, RETURN_MASK_ERROR
)
769 /* If an exception was thrown while doing the disassembly, print
770 the error message, to give the user a clue of what happened. */
771 exception_print (gdb_stderr
, exception
);
776 /* Print information about frame FRAME. The output is format according
777 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
780 SRC_LINE: Print only source line.
781 LOCATION: Print only location.
782 SRC_AND_LOC: Print location and source line.
784 Used in "where" output, and to emit breakpoint or step
788 print_frame_info (struct frame_info
*frame
, int print_level
,
789 enum print_what print_what
, int print_args
,
792 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
795 struct ui_out
*uiout
= current_uiout
;
797 if (get_frame_type (frame
) == DUMMY_FRAME
798 || get_frame_type (frame
) == SIGTRAMP_FRAME
799 || get_frame_type (frame
) == ARCH_FRAME
)
801 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
803 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
804 gdbarch
, get_frame_pc (frame
));
806 /* Do this regardless of SOURCE because we don't have any source
807 to list for this frame. */
811 uiout
->field_fmt_int (2, ui_left
, "level",
812 frame_relative_level (frame
));
814 if (uiout
->is_mi_like_p ())
816 annotate_frame_address ();
817 uiout
->field_core_addr ("addr",
818 gdbarch
, get_frame_pc (frame
));
819 annotate_frame_address_end ();
822 if (get_frame_type (frame
) == DUMMY_FRAME
)
824 annotate_function_call ();
825 uiout
->field_string ("func", "<function called from gdb>");
827 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
829 annotate_signal_handler_caller ();
830 uiout
->field_string ("func", "<signal handler called>");
832 else if (get_frame_type (frame
) == ARCH_FRAME
)
834 uiout
->field_string ("func", "<cross-architecture call>");
837 annotate_frame_end ();
839 /* If disassemble-next-line is set to auto or on output the next
841 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
842 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
843 do_gdb_disassembly (get_frame_arch (frame
), 1,
844 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
849 /* If FRAME is not the innermost frame, that normally means that
850 FRAME->pc points to *after* the call instruction, and we want to
851 get the line containing the call, never the next line. But if
852 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
853 next frame was not entered as the result of a call, and we want
854 to get the line containing FRAME->pc. */
855 symtab_and_line sal
= find_frame_sal (frame
);
857 location_print
= (print_what
== LOCATION
858 || print_what
== LOC_AND_ADDRESS
859 || print_what
== SRC_AND_LOC
);
861 if (location_print
|| !sal
.symtab
)
862 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
864 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
866 /* If disassemble-next-line is set to auto or on and doesn't have
867 the line debug messages for $pc, output the next instruction. */
868 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
869 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
870 && source_print
&& !sal
.symtab
)
871 do_gdb_disassembly (get_frame_arch (frame
), 1,
872 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
874 if (source_print
&& sal
.symtab
)
877 int mid_statement
= ((print_what
== SRC_LINE
)
878 && frame_show_address (frame
, sal
));
880 if (annotation_level
)
881 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
882 get_frame_pc (frame
));
885 if (deprecated_print_frame_info_listing_hook
)
886 deprecated_print_frame_info_listing_hook (sal
.symtab
,
891 struct value_print_options opts
;
893 get_user_print_options (&opts
);
894 /* We used to do this earlier, but that is clearly
895 wrong. This function is used by many different
896 parts of gdb, including normal_stop in infrun.c,
897 which uses this to print out the current PC
898 when we stepi/nexti into the middle of a source
899 line. Only the command line really wants this
900 behavior. Other UIs probably would like the
901 ability to decide for themselves if it is desired. */
902 if (opts
.addressprint
&& mid_statement
)
904 uiout
->field_core_addr ("addr",
905 gdbarch
, get_frame_pc (frame
));
909 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
913 /* If disassemble-next-line is set to on and there is line debug
914 messages, output assembly codes for next line. */
915 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
916 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
923 if (get_frame_pc_if_available (frame
, &pc
))
924 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
926 set_last_displayed_sal (0, 0, 0, 0, 0);
929 annotate_frame_end ();
931 gdb_flush (gdb_stdout
);
934 /* Remember the last symtab and line we displayed, which we use e.g.
935 * as the place to put a breakpoint when the `break' command is
936 * invoked with no arguments. */
939 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
940 CORE_ADDR addr
, struct symtab
*symtab
,
943 last_displayed_sal_valid
= valid
;
944 last_displayed_pspace
= pspace
;
945 last_displayed_addr
= addr
;
946 last_displayed_symtab
= symtab
;
947 last_displayed_line
= line
;
948 if (valid
&& pspace
== NULL
)
950 clear_last_displayed_sal ();
951 internal_error (__FILE__
, __LINE__
,
952 _("Trying to set NULL pspace."));
956 /* Forget the last sal we displayed. */
959 clear_last_displayed_sal (void)
961 last_displayed_sal_valid
= 0;
962 last_displayed_pspace
= 0;
963 last_displayed_addr
= 0;
964 last_displayed_symtab
= 0;
965 last_displayed_line
= 0;
968 /* Is our record of the last sal we displayed valid? If not,
969 * the get_last_displayed_* functions will return NULL or 0, as
973 last_displayed_sal_is_valid (void)
975 return last_displayed_sal_valid
;
978 /* Get the pspace of the last sal we displayed, if it's valid. */
980 struct program_space
*
981 get_last_displayed_pspace (void)
983 if (last_displayed_sal_valid
)
984 return last_displayed_pspace
;
988 /* Get the address of the last sal we displayed, if it's valid. */
991 get_last_displayed_addr (void)
993 if (last_displayed_sal_valid
)
994 return last_displayed_addr
;
998 /* Get the symtab of the last sal we displayed, if it's valid. */
1001 get_last_displayed_symtab (void)
1003 if (last_displayed_sal_valid
)
1004 return last_displayed_symtab
;
1008 /* Get the line of the last sal we displayed, if it's valid. */
1011 get_last_displayed_line (void)
1013 if (last_displayed_sal_valid
)
1014 return last_displayed_line
;
1018 /* Get the last sal we displayed, if it's valid. */
1021 get_last_displayed_sal ()
1023 symtab_and_line sal
;
1025 if (last_displayed_sal_valid
)
1027 sal
.pspace
= last_displayed_pspace
;
1028 sal
.pc
= last_displayed_addr
;
1029 sal
.symtab
= last_displayed_symtab
;
1030 sal
.line
= last_displayed_line
;
1037 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1038 corresponding to FRAME. */
1040 gdb::unique_xmalloc_ptr
<char>
1041 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1042 struct symbol
**funcp
)
1044 struct symbol
*func
;
1045 gdb::unique_xmalloc_ptr
<char> funname
;
1047 *funlang
= language_unknown
;
1051 func
= get_frame_function (frame
);
1054 /* In certain pathological cases, the symtabs give the wrong
1055 function (when we are in the first function in a file which
1056 is compiled without debugging symbols, the previous function
1057 is compiled with debugging symbols, and the "foo.o" symbol
1058 that is supposed to tell us where the file with debugging
1059 symbols ends has been truncated by ar because it is longer
1060 than 15 characters). This also occurs if the user uses asm()
1061 to create a function but not stabs for it (in a file compiled
1064 So look in the minimal symbol tables as well, and if it comes
1065 up with a larger address for the function use that instead.
1066 I don't think this can ever cause any problems; there
1067 shouldn't be any minimal symbols in the middle of a function;
1068 if this is ever changed many parts of GDB will need to be
1069 changed (and we'll create a find_pc_minimal_function or some
1072 struct bound_minimal_symbol msymbol
;
1074 /* Don't attempt to do this for inlined functions, which do not
1075 have a corresponding minimal symbol. */
1076 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1078 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1080 memset (&msymbol
, 0, sizeof (msymbol
));
1082 if (msymbol
.minsym
!= NULL
1083 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1084 > BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func
))))
1086 /* We also don't know anything about the function besides
1087 its address and name. */
1089 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1090 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1094 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1096 *funlang
= SYMBOL_LANGUAGE (func
);
1099 if (*funlang
== language_cplus
)
1101 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1102 to display the demangled name that we already have
1103 stored in the symbol table, but we stored a version
1104 with DMGL_PARAMS turned on, and here we don't want to
1105 display parameters. So remove the parameters. */
1106 funname
= cp_remove_params (print_name
);
1109 /* If we didn't hit the C++ case above, set *funname
1111 if (funname
== NULL
)
1112 funname
.reset (xstrdup (print_name
));
1117 struct bound_minimal_symbol msymbol
;
1120 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1123 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1124 if (msymbol
.minsym
!= NULL
)
1126 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1127 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1135 print_frame (struct frame_info
*frame
, int print_level
,
1136 enum print_what print_what
, int print_args
,
1137 struct symtab_and_line sal
)
1139 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1140 struct ui_out
*uiout
= current_uiout
;
1141 enum language funlang
= language_unknown
;
1142 struct value_print_options opts
;
1143 struct symbol
*func
;
1147 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1149 gdb::unique_xmalloc_ptr
<char> funname
1150 = find_frame_funname (frame
, &funlang
, &func
);
1152 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1156 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1161 uiout
->field_fmt_int (2, ui_left
, "level",
1162 frame_relative_level (frame
));
1164 get_user_print_options (&opts
);
1165 if (opts
.addressprint
)
1167 || frame_show_address (frame
, sal
)
1168 || print_what
== LOC_AND_ADDRESS
)
1170 annotate_frame_address ();
1172 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1174 uiout
->field_string ("addr", "<unavailable>");
1175 annotate_frame_address_end ();
1176 uiout
->text (" in ");
1178 annotate_frame_function_name ();
1181 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1182 funlang
, DMGL_ANSI
);
1183 uiout
->field_stream ("func", stb
);
1184 uiout
->wrap_hint (" ");
1185 annotate_frame_args ();
1190 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1193 if (gdbarch_frame_num_args_p (gdbarch
))
1195 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1196 gdb_assert (numargs
>= 0);
1202 ui_out_emit_list
list_emitter (uiout
, "args");
1205 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1207 CATCH (e
, RETURN_MASK_ERROR
)
1212 /* FIXME: ARGS must be a list. If one argument is a string it
1213 will have " that will not be properly escaped. */
1220 const char *filename_display
;
1222 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1223 annotate_frame_source_begin ();
1224 uiout
->wrap_hint (" ");
1225 uiout
->text (" at ");
1226 annotate_frame_source_file ();
1227 uiout
->field_string ("file", filename_display
);
1228 if (uiout
->is_mi_like_p ())
1230 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1232 uiout
->field_string ("fullname", fullname
);
1234 annotate_frame_source_file_end ();
1236 annotate_frame_source_line ();
1237 uiout
->field_int ("line", sal
.line
);
1238 annotate_frame_source_end ();
1241 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1243 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1244 get_frame_pc (frame
));
1248 annotate_frame_where ();
1249 uiout
->wrap_hint (" ");
1250 uiout
->text (" from ");
1251 uiout
->field_string ("from", lib
);
1254 if (uiout
->is_mi_like_p ())
1255 uiout
->field_string ("arch",
1256 (gdbarch_bfd_arch_info (gdbarch
))->printable_name
);
1263 /* Completion function for "frame function", "info frame function", and
1264 "select-frame function" commands. */
1267 frame_selection_by_function_completer (struct cmd_list_element
*ignore
,
1268 completion_tracker
&tracker
,
1269 const char *text
, const char *word
)
1271 /* This is used to complete function names within a stack. It would be
1272 nice if we only offered functions that were actually in the stack.
1273 However, this would mean unwinding the stack to completion, which
1274 could take too long, or on a corrupted stack, possibly not end.
1275 Instead, we offer all symbol names as a safer choice. */
1276 collect_symbol_completion_matches (tracker
,
1277 complete_symbol_mode::EXPRESSION
,
1278 symbol_name_match_type::EXPRESSION
,
1282 /* Core of all the "info frame" sub-commands. Print information about a
1283 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1284 frame specification, they just entered 'info frame'. If the user did
1285 provide a frame specification (for example 'info frame 0', 'info frame
1286 level 1') then SELECTED_FRAME_P will be false. */
1289 info_frame_command_core (struct frame_info
*fi
, bool selected_frame_p
)
1291 struct symbol
*func
;
1293 struct frame_info
*calling_frame_info
;
1295 const char *funname
= 0;
1296 enum language funlang
= language_unknown
;
1297 const char *pc_regname
;
1298 struct gdbarch
*gdbarch
;
1301 /* Initialize it to avoid "may be used uninitialized" warning. */
1302 CORE_ADDR caller_pc
= 0;
1303 int caller_pc_p
= 0;
1305 gdbarch
= get_frame_arch (fi
);
1307 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1308 is not a good name. */
1309 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1310 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1311 easily not match that of the internal value returned by
1313 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1315 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1316 architectures will often have a hardware register called "pc",
1317 and that register's value, again, can easily not match
1321 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1322 func
= get_frame_function (fi
);
1323 symtab_and_line sal
= find_frame_sal (fi
);
1325 gdb::unique_xmalloc_ptr
<char> func_only
;
1328 funname
= SYMBOL_PRINT_NAME (func
);
1329 funlang
= SYMBOL_LANGUAGE (func
);
1330 if (funlang
== language_cplus
)
1332 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1333 to display the demangled name that we already have
1334 stored in the symbol table, but we stored a version
1335 with DMGL_PARAMS turned on, and here we don't want to
1336 display parameters. So remove the parameters. */
1337 func_only
= cp_remove_params (funname
);
1340 funname
= func_only
.get ();
1343 else if (frame_pc_p
)
1345 struct bound_minimal_symbol msymbol
;
1347 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1348 if (msymbol
.minsym
!= NULL
)
1350 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1351 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1354 calling_frame_info
= get_prev_frame (fi
);
1356 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1358 printf_filtered (_("Stack level %d, frame at "),
1359 frame_relative_level (fi
));
1363 printf_filtered (_("Stack frame at "));
1365 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1366 printf_filtered (":\n");
1367 printf_filtered (" %s = ", pc_regname
);
1369 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1371 fputs_filtered ("<unavailable>", gdb_stdout
);
1376 printf_filtered (" in ");
1377 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1378 DMGL_ANSI
| DMGL_PARAMS
);
1382 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1384 puts_filtered ("; ");
1386 printf_filtered ("saved %s = ", pc_regname
);
1388 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1389 val_print_not_saved (gdb_stdout
);
1394 caller_pc
= frame_unwind_caller_pc (fi
);
1397 CATCH (ex
, RETURN_MASK_ERROR
)
1401 case NOT_AVAILABLE_ERROR
:
1402 val_print_unavailable (gdb_stdout
);
1404 case OPTIMIZED_OUT_ERROR
:
1405 val_print_not_saved (gdb_stdout
);
1408 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1416 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1417 printf_filtered ("\n");
1419 if (calling_frame_info
== NULL
)
1421 enum unwind_stop_reason reason
;
1423 reason
= get_frame_unwind_stop_reason (fi
);
1424 if (reason
!= UNWIND_NO_REASON
)
1425 printf_filtered (_(" Outermost frame: %s\n"),
1426 frame_stop_reason_string (fi
));
1428 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1429 puts_filtered (" tail call frame");
1430 else if (get_frame_type (fi
) == INLINE_FRAME
)
1431 printf_filtered (" inlined into frame %d",
1432 frame_relative_level (get_prev_frame (fi
)));
1435 printf_filtered (" called by frame at ");
1436 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1439 if (get_next_frame (fi
) && calling_frame_info
)
1440 puts_filtered (",");
1442 if (get_next_frame (fi
))
1444 printf_filtered (" caller of frame at ");
1445 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1448 if (get_next_frame (fi
) || calling_frame_info
)
1449 puts_filtered ("\n");
1452 printf_filtered (" source language %s.\n",
1453 language_str (s
->language
));
1456 /* Address of the argument list for this frame, or 0. */
1457 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1458 /* Number of args for this frame, or -1 if unknown. */
1462 printf_filtered (" Arglist at unknown address.\n");
1465 printf_filtered (" Arglist at ");
1466 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1467 printf_filtered (",");
1469 if (!gdbarch_frame_num_args_p (gdbarch
))
1472 puts_filtered (" args: ");
1476 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1477 gdb_assert (numargs
>= 0);
1479 puts_filtered (" no args.");
1480 else if (numargs
== 1)
1481 puts_filtered (" 1 arg: ");
1483 printf_filtered (" %d args: ", numargs
);
1485 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1486 puts_filtered ("\n");
1490 /* Address of the local variables for this frame, or 0. */
1491 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1494 printf_filtered (" Locals at unknown address,");
1497 printf_filtered (" Locals at ");
1498 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1499 printf_filtered (",");
1503 /* Print as much information as possible on the location of all the
1509 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1511 /* The sp is special; what's displayed isn't the save address, but
1512 the value of the previous frame's sp. This is a legacy thing,
1513 at one stage the frame cached the previous frame's SP instead
1514 of its address, hence it was easiest to just display the cached
1518 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1519 gdb_assert (value
!= NULL
);
1521 if (!value_optimized_out (value
) && value_entirely_available (value
))
1523 if (VALUE_LVAL (value
) == not_lval
)
1526 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1527 int sp_size
= register_size (gdbarch
, sp_regnum
);
1529 sp
= extract_unsigned_integer (value_contents_all (value
),
1530 sp_size
, byte_order
);
1532 printf_filtered (" Previous frame's sp is ");
1533 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1534 printf_filtered ("\n");
1536 else if (VALUE_LVAL (value
) == lval_memory
)
1538 printf_filtered (" Previous frame's sp at ");
1539 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1541 printf_filtered ("\n");
1543 else if (VALUE_LVAL (value
) == lval_register
)
1545 printf_filtered (" Previous frame's sp in %s\n",
1546 gdbarch_register_name (gdbarch
,
1547 VALUE_REGNUM (value
)));
1550 release_value (value
);
1553 /* else keep quiet. */
1557 numregs
= gdbarch_num_regs (gdbarch
)
1558 + gdbarch_num_pseudo_regs (gdbarch
);
1559 for (i
= 0; i
< numregs
; i
++)
1561 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1563 enum lval_type lval
;
1569 /* Find out the location of the saved register without
1570 fetching the corresponding value. */
1571 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1572 &lval
, &addr
, &realnum
, NULL
);
1573 /* For moment, only display registers that were saved on the
1575 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1578 puts_filtered (" Saved registers:\n ");
1580 puts_filtered (",");
1582 printf_filtered (" %s at ",
1583 gdbarch_register_name (gdbarch
, i
));
1584 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1588 if (count
|| need_nl
)
1589 puts_filtered ("\n");
1593 /* Return the innermost frame at level LEVEL. */
1595 static struct frame_info
*
1596 leading_innermost_frame (int level
)
1598 struct frame_info
*leading
;
1600 leading
= get_current_frame ();
1602 gdb_assert (level
>= 0);
1604 while (leading
!= nullptr && level
)
1607 leading
= get_prev_frame (leading
);
1614 /* Return the starting frame needed to handle COUNT outermost frames. */
1616 static struct frame_info
*
1617 trailing_outermost_frame (int count
)
1619 struct frame_info
*current
;
1620 struct frame_info
*trailing
;
1622 trailing
= get_current_frame ();
1624 gdb_assert (count
> 0);
1627 while (current
!= nullptr && count
--)
1630 current
= get_prev_frame (current
);
1633 /* Will stop when CURRENT reaches the top of the stack.
1634 TRAILING will be COUNT below it. */
1635 while (current
!= nullptr)
1638 trailing
= get_prev_frame (trailing
);
1639 current
= get_prev_frame (current
);
1645 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1649 select_frame_command_core (struct frame_info
*fi
, bool ignored
)
1651 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1653 if (get_selected_frame_if_set () != prev_frame
)
1654 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1660 select_frame_for_mi (struct frame_info
*fi
)
1662 select_frame_command_core (fi
, FALSE
/* Ignored. */);
1665 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1666 means we change frame send out a change notification (otherwise, just
1667 reprint the current frame summary). */
1670 frame_command_core (struct frame_info
*fi
, bool ignored
)
1672 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
1675 if (get_selected_frame_if_set () != prev_frame
)
1676 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
1678 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
1681 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1682 common set of sub-commands that allow a specific frame to be selected.
1683 All of the sub-command functions are static methods within this class
1684 template which is then instantiated below. The template parameter is a
1685 callback used to implement the functionality of the base command
1686 ('frame', 'select-frame', or 'info frame').
1688 In the template parameter FI is the frame being selected. The
1689 SELECTED_FRAME_P flag is true if the frame being selected was done by
1690 default, which happens when the user uses the base command with no
1691 arguments. For example the commands 'info frame', 'select-frame',
1692 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1693 SELECTED_FRAME_P is false. */
1695 template <void (*FPTR
) (struct frame_info
*fi
, bool selected_frame_p
)>
1696 class frame_command_helper
1700 /* The "frame level" family of commands. The ARG is an integer that is
1701 the frame's level in the stack. */
1703 level (const char *arg
, int from_tty
)
1705 int level
= value_as_long (parse_and_eval (arg
));
1706 struct frame_info
*fid
1707 = find_relative_frame (get_current_frame (), &level
);
1709 error (_("No frame at level %s."), arg
);
1713 /* The "frame address" family of commands. ARG is a stack-pointer
1714 address for an existing frame. This command does not allow new
1715 frames to be created. */
1718 address (const char *arg
, int from_tty
)
1720 CORE_ADDR addr
= value_as_address (parse_and_eval (arg
));
1721 struct frame_info
*fid
= find_frame_for_address (addr
);
1723 error (_("No frame at address %s."), arg
);
1727 /* The "frame view" family of commands. ARG is one or two addresses and
1728 is used to view a frame that might be outside the current backtrace.
1729 The addresses are stack-pointer address, and (optional) pc-address. */
1732 view (const char *args
, int from_tty
)
1734 struct frame_info
*fid
;
1737 error (_("Missing address argument to view a frame"));
1739 gdb_argv
argv (args
);
1741 if (argv
.count () == 2)
1745 addr
[0] = value_as_address (parse_and_eval (argv
[0]));
1746 addr
[1] = value_as_address (parse_and_eval (argv
[1]));
1747 fid
= create_new_frame (addr
[0], addr
[1]);
1751 CORE_ADDR addr
= value_as_address (parse_and_eval (argv
[0]));
1752 fid
= create_new_frame (addr
, false);
1757 /* The "frame function" family of commands. ARG is the name of a
1758 function within the stack, the first function (searching from frame
1759 0) with that name will be selected. */
1762 function (const char *arg
, int from_tty
)
1765 error (_("Missing function name argument"));
1766 struct frame_info
*fid
= find_frame_for_function (arg
);
1768 error (_("No frame for function \"%s\"."), arg
);
1772 /* The "frame" base command, that is, when no sub-command is specified.
1773 If one argument is provided then we assume that this is a frame's
1774 level as historically, this was the supported command syntax that was
1777 If no argument is provided, then the current frame is selected. */
1780 base_command (const char *arg
, int from_tty
)
1783 FPTR (get_selected_frame (_("No stack.")), true);
1785 level (arg
, from_tty
);
1789 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1790 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1792 static frame_command_helper
<info_frame_command_core
> info_frame_cmd
;
1793 static frame_command_helper
<frame_command_core
> frame_cmd
;
1794 static frame_command_helper
<select_frame_command_core
> select_frame_cmd
;
1796 /* Print briefly all stack frames or just the innermost COUNT_EXP
1800 backtrace_command_1 (const char *count_exp
, frame_filter_flags flags
,
1801 int no_filters
, int from_tty
)
1803 struct frame_info
*fi
;
1805 int py_start
= 0, py_end
= 0;
1806 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1808 if (!target_has_stack
)
1809 error (_("No stack."));
1813 count
= parse_and_eval_long (count_exp
);
1819 /* The argument to apply_ext_lang_frame_filter is the number
1820 of the final frame to print, and frames start at 0. */
1832 enum ext_lang_frame_args arg_type
;
1834 flags
|= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1836 flags
|= PRINT_MORE_FRAMES
;
1838 if (!strcmp (print_frame_arguments
, "scalars"))
1839 arg_type
= CLI_SCALAR_VALUES
;
1840 else if (!strcmp (print_frame_arguments
, "all"))
1841 arg_type
= CLI_ALL_VALUES
;
1843 arg_type
= NO_VALUES
;
1845 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1846 arg_type
, current_uiout
,
1850 /* Run the inbuilt backtrace if there are no filters registered, or
1851 "no-filters" has been specified from the command. */
1852 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1854 struct frame_info
*trailing
;
1856 /* The following code must do two things. First, it must set the
1857 variable TRAILING to the frame from which we should start
1858 printing. Second, it must set the variable count to the number
1859 of frames which we should print, or -1 if all of them. */
1861 if (count_exp
!= NULL
&& count
< 0)
1863 trailing
= trailing_outermost_frame (-count
);
1867 trailing
= get_current_frame ();
1869 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
1873 /* Don't use print_stack_frame; if an error() occurs it probably
1874 means further attempts to backtrace would fail (on the other
1875 hand, perhaps the code does or could be fixed to make sure
1876 the frame->prev field gets set to NULL in that case). */
1878 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1879 if ((flags
& PRINT_LOCALS
) != 0)
1881 struct frame_id frame_id
= get_frame_id (fi
);
1883 print_frame_local_vars (fi
, 1, gdb_stdout
);
1885 /* print_frame_local_vars invalidates FI. */
1886 fi
= frame_find_by_id (frame_id
);
1890 warning (_("Unable to restore previously selected frame."));
1895 /* Save the last frame to check for error conditions. */
1899 /* If we've stopped before the end, mention that. */
1901 printf_filtered (_("(More stack frames follow...)\n"));
1903 /* If we've run out of frames, and the reason appears to be an error
1904 condition, print it. */
1905 if (fi
== NULL
&& trailing
!= NULL
)
1907 enum unwind_stop_reason reason
;
1909 reason
= get_frame_unwind_stop_reason (trailing
);
1910 if (reason
>= UNWIND_FIRST_ERROR
)
1911 printf_filtered (_("Backtrace stopped: %s\n"),
1912 frame_stop_reason_string (trailing
));
1918 backtrace_command (const char *arg
, int from_tty
)
1920 bool filters
= true;
1921 frame_filter_flags flags
= 0;
1929 const char *save_arg
= arg
;
1930 std::string this_arg
= extract_arg (&arg
);
1932 if (this_arg
.empty ())
1935 if (subset_compare (this_arg
.c_str (), "no-filters"))
1937 else if (subset_compare (this_arg
.c_str (), "full"))
1938 flags
|= PRINT_LOCALS
;
1939 else if (subset_compare (this_arg
.c_str (), "hide"))
1940 flags
|= PRINT_HIDE
;
1943 /* Not a recognized argument, so stop. */
1953 backtrace_command_1 (arg
, flags
, !filters
/* no frame-filters */, from_tty
);
1956 /* Iterate over the local variables of a block B, calling CB with
1960 iterate_over_block_locals (const struct block
*b
,
1961 iterate_over_block_arg_local_vars_cb cb
,
1964 struct block_iterator iter
;
1967 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1969 switch (SYMBOL_CLASS (sym
))
1975 case LOC_OPTIMIZED_OUT
:
1976 if (SYMBOL_IS_ARGUMENT (sym
))
1978 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1980 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1984 /* Ignore symbols which are not locals. */
1991 /* Same, but print labels. */
1994 /* Commented out, as the code using this function has also been
1995 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1996 was commented out in the first place. The discussion introducing
1997 this change (2007-12-04: Support lexical blocks and function bodies
1998 that occupy non-contiguous address ranges) did not explain why
1999 this change was made. */
2001 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
2002 int *have_default
, struct ui_file
*stream
)
2004 struct block_iterator iter
;
2006 int values_printed
= 0;
2008 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2010 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2016 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2018 struct symtab_and_line sal
;
2019 struct value_print_options opts
;
2021 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2023 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2024 get_user_print_options (&opts
);
2025 if (opts
.addressprint
)
2027 fprintf_filtered (stream
, " ");
2028 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2031 fprintf_filtered (stream
, " in file %s, line %d\n",
2032 sal
.symtab
->filename
, sal
.line
);
2036 return values_printed
;
2040 /* Iterate over all the local variables in block B, including all its
2041 superblocks, stopping when the top-level block is reached. */
2044 iterate_over_block_local_vars (const struct block
*block
,
2045 iterate_over_block_arg_local_vars_cb cb
,
2050 iterate_over_block_locals (block
, cb
, cb_data
);
2051 /* After handling the function's top-level block, stop. Don't
2052 continue to its superblock, the block of per-file
2054 if (BLOCK_FUNCTION (block
))
2056 block
= BLOCK_SUPERBLOCK (block
);
2060 /* Data to be passed around in the calls to the locals and args
2063 struct print_variable_and_value_data
2065 struct frame_id frame_id
;
2067 struct ui_file
*stream
;
2071 /* The callback for the locals and args iterators. */
2074 do_print_variable_and_value (const char *print_name
,
2078 struct print_variable_and_value_data
*p
2079 = (struct print_variable_and_value_data
*) cb_data
;
2080 struct frame_info
*frame
;
2082 frame
= frame_find_by_id (p
->frame_id
);
2085 warning (_("Unable to restore previously selected frame."));
2089 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2091 /* print_variable_and_value invalidates FRAME. */
2094 p
->values_printed
= 1;
2097 /* Print all variables from the innermost up to the function block of FRAME.
2098 Print them with values to STREAM indented by NUM_TABS.
2100 This function will invalidate FRAME. */
2103 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2104 struct ui_file
*stream
)
2106 struct print_variable_and_value_data cb_data
;
2107 const struct block
*block
;
2110 if (!get_frame_pc_if_available (frame
, &pc
))
2112 fprintf_filtered (stream
,
2113 _("PC unavailable, cannot determine locals.\n"));
2117 block
= get_frame_block (frame
, 0);
2120 fprintf_filtered (stream
, "No symbol table info available.\n");
2124 cb_data
.frame_id
= get_frame_id (frame
);
2125 cb_data
.num_tabs
= 4 * num_tabs
;
2126 cb_data
.stream
= stream
;
2127 cb_data
.values_printed
= 0;
2129 /* Temporarily change the selected frame to the given FRAME.
2130 This allows routines that rely on the selected frame instead
2131 of being given a frame as parameter to use the correct frame. */
2132 scoped_restore_selected_frame restore_selected_frame
;
2133 select_frame (frame
);
2135 iterate_over_block_local_vars (block
,
2136 do_print_variable_and_value
,
2139 if (!cb_data
.values_printed
)
2140 fprintf_filtered (stream
, _("No locals.\n"));
2144 info_locals_command (const char *args
, int from_tty
)
2146 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2150 /* Iterate over all the argument variables in block B. */
2153 iterate_over_block_arg_vars (const struct block
*b
,
2154 iterate_over_block_arg_local_vars_cb cb
,
2157 struct block_iterator iter
;
2158 struct symbol
*sym
, *sym2
;
2160 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2162 /* Don't worry about things which aren't arguments. */
2163 if (SYMBOL_IS_ARGUMENT (sym
))
2165 /* We have to look up the symbol because arguments can have
2166 two entries (one a parameter, one a local) and the one we
2167 want is the local, which lookup_symbol will find for us.
2168 This includes gcc1 (not gcc2) on the sparc when passing a
2169 small structure and gcc2 when the argument type is float
2170 and it is passed as a double and converted to float by
2171 the prologue (in the latter case the type of the LOC_ARG
2172 symbol is double and the type of the LOC_LOCAL symbol is
2173 float). There are also LOC_ARG/LOC_REGISTER pairs which
2174 are not combined in symbol-reading. */
2176 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2177 b
, VAR_DOMAIN
).symbol
;
2178 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2183 /* Print all argument variables of the function of FRAME.
2184 Print them with values to STREAM.
2186 This function will invalidate FRAME. */
2189 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2191 struct print_variable_and_value_data cb_data
;
2192 struct symbol
*func
;
2195 if (!get_frame_pc_if_available (frame
, &pc
))
2197 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2201 func
= get_frame_function (frame
);
2204 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2208 cb_data
.frame_id
= get_frame_id (frame
);
2209 cb_data
.num_tabs
= 0;
2210 cb_data
.stream
= stream
;
2211 cb_data
.values_printed
= 0;
2213 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2214 do_print_variable_and_value
, &cb_data
);
2216 /* do_print_variable_and_value invalidates FRAME. */
2219 if (!cb_data
.values_printed
)
2220 fprintf_filtered (stream
, _("No arguments.\n"));
2224 info_args_command (const char *ignore
, int from_tty
)
2226 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2230 /* Return the symbol-block in which the selected frame is executing.
2231 Can return zero under various legitimate circumstances.
2233 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2234 code address within the block returned. We use this to decide
2235 which macros are in scope. */
2237 const struct block
*
2238 get_selected_block (CORE_ADDR
*addr_in_block
)
2240 if (!has_stack_frames ())
2243 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2246 /* Find a frame a certain number of levels away from FRAME.
2247 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2248 Positive means go to earlier frames (up); negative, the reverse.
2249 The int that contains the number of levels is counted toward
2250 zero as the frames for those levels are found.
2251 If the top or bottom frame is reached, that frame is returned,
2252 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2253 how much farther the original request asked to go. */
2256 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2258 /* Going up is simple: just call get_prev_frame enough times or
2259 until the initial frame is reached. */
2260 while (*level_offset_ptr
> 0)
2262 struct frame_info
*prev
= get_prev_frame (frame
);
2266 (*level_offset_ptr
)--;
2270 /* Going down is just as simple. */
2271 while (*level_offset_ptr
< 0)
2273 struct frame_info
*next
= get_next_frame (frame
);
2277 (*level_offset_ptr
)++;
2284 /* Select the frame up one or COUNT_EXP stack levels from the
2285 previously selected frame, and print it briefly. */
2288 up_silently_base (const char *count_exp
)
2290 struct frame_info
*frame
;
2294 count
= parse_and_eval_long (count_exp
);
2296 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2297 if (count
!= 0 && count_exp
== NULL
)
2298 error (_("Initial frame selected; you cannot go up."));
2299 select_frame (frame
);
2303 up_silently_command (const char *count_exp
, int from_tty
)
2305 up_silently_base (count_exp
);
2309 up_command (const char *count_exp
, int from_tty
)
2311 up_silently_base (count_exp
);
2312 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2315 /* Select the frame down one or COUNT_EXP stack levels from the previously
2316 selected frame, and print it briefly. */
2319 down_silently_base (const char *count_exp
)
2321 struct frame_info
*frame
;
2325 count
= -parse_and_eval_long (count_exp
);
2327 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2328 if (count
!= 0 && count_exp
== NULL
)
2330 /* We only do this if COUNT_EXP is not specified. That way
2331 "down" means to really go down (and let me know if that is
2332 impossible), but "down 9999" can be used to mean go all the
2333 way down without getting an error. */
2335 error (_("Bottom (innermost) frame selected; you cannot go down."));
2338 select_frame (frame
);
2342 down_silently_command (const char *count_exp
, int from_tty
)
2344 down_silently_base (count_exp
);
2348 down_command (const char *count_exp
, int from_tty
)
2350 down_silently_base (count_exp
);
2351 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2355 return_command (const char *retval_exp
, int from_tty
)
2357 /* Initialize it just to avoid a GCC false warning. */
2358 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2359 struct frame_info
*thisframe
;
2360 struct gdbarch
*gdbarch
;
2361 struct symbol
*thisfun
;
2362 struct value
*return_value
= NULL
;
2363 struct value
*function
= NULL
;
2364 const char *query_prefix
= "";
2366 thisframe
= get_selected_frame ("No selected frame.");
2367 thisfun
= get_frame_function (thisframe
);
2368 gdbarch
= get_frame_arch (thisframe
);
2370 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2371 error (_("Can not force return from an inlined function."));
2373 /* Compute the return value. If the computation triggers an error,
2374 let it bail. If the return type can't be handled, set
2375 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2379 expression_up retval_expr
= parse_expression (retval_exp
);
2380 struct type
*return_type
= NULL
;
2382 /* Compute the return value. Should the computation fail, this
2383 call throws an error. */
2384 return_value
= evaluate_expression (retval_expr
.get ());
2386 /* Cast return value to the return type of the function. Should
2387 the cast fail, this call throws an error. */
2388 if (thisfun
!= NULL
)
2389 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2390 if (return_type
== NULL
)
2392 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2393 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2394 error (_("Return value type not available for selected "
2396 "Please use an explicit cast of the value to return."));
2397 return_type
= value_type (return_value
);
2399 return_type
= check_typedef (return_type
);
2400 return_value
= value_cast (return_type
, return_value
);
2402 /* Make sure the value is fully evaluated. It may live in the
2403 stack frame we're about to pop. */
2404 if (value_lazy (return_value
))
2405 value_fetch_lazy (return_value
);
2407 if (thisfun
!= NULL
)
2408 function
= read_var_value (thisfun
, NULL
, thisframe
);
2410 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2411 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2412 /* If the return-type is "void", don't try to find the
2413 return-value's location. However, do still evaluate the
2414 return expression so that, even when the expression result
2415 is discarded, side effects such as "return i++" still
2417 return_value
= NULL
;
2418 else if (thisfun
!= NULL
)
2420 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2421 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2422 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2424 query_prefix
= "The location at which to store the "
2425 "function's return value is unknown.\n"
2426 "If you continue, the return value "
2427 "that you specified will be ignored.\n";
2428 return_value
= NULL
;
2433 /* Does an interactive user really want to do this? Include
2434 information, such as how well GDB can handle the return value, in
2435 the query message. */
2440 if (thisfun
== NULL
)
2441 confirmed
= query (_("%sMake selected stack frame return now? "),
2445 if (TYPE_NO_RETURN (thisfun
->type
))
2446 warning (_("Function does not return normally to caller."));
2447 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2448 SYMBOL_PRINT_NAME (thisfun
));
2451 error (_("Not confirmed"));
2454 /* Discard the selected frame and all frames inner-to it. */
2455 frame_pop (get_selected_frame (NULL
));
2457 /* Store RETURN_VALUE in the just-returned register set. */
2458 if (return_value
!= NULL
)
2460 struct type
*return_type
= value_type (return_value
);
2461 struct gdbarch
*gdbarch
= get_current_regcache ()->arch ();
2463 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2464 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2465 gdbarch_return_value (gdbarch
, function
, return_type
,
2466 get_current_regcache (), NULL
/*read*/,
2467 value_contents (return_value
) /*write*/);
2470 /* If we are at the end of a call dummy now, pop the dummy frame
2472 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2473 frame_pop (get_current_frame ());
2475 select_frame (get_current_frame ());
2476 /* If interactive, print the frame that is now current. */
2478 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2481 /* Find the most inner frame in the current stack for a function called
2482 FUNCTION_NAME. If no matching frame is found return NULL. */
2484 static struct frame_info
*
2485 find_frame_for_function (const char *function_name
)
2487 /* Used to hold the lower and upper addresses for each of the
2488 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2489 struct function_bounds
2491 CORE_ADDR low
, high
;
2493 struct frame_info
*frame
;
2497 gdb_assert (function_name
!= NULL
);
2499 frame
= get_current_frame ();
2500 std::vector
<symtab_and_line
> sals
2501 = decode_line_with_current_source (function_name
,
2502 DECODE_LINE_FUNFIRSTLINE
);
2503 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2504 for (size_t i
= 0; i
< sals
.size (); i
++)
2506 if (sals
[i
].pspace
!= current_program_space
)
2507 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2508 else if (sals
[i
].pc
== 0
2509 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2510 &func_bounds
[i
].low
,
2511 &func_bounds
[i
].high
) == 0)
2512 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2517 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2518 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2519 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2523 frame
= find_relative_frame (frame
, &level
);
2526 while (!found
&& level
== 0);
2534 /* Implements the dbx 'func' command. */
2537 func_command (const char *arg
, int from_tty
)
2542 struct frame_info
*frame
= find_frame_for_function (arg
);
2544 error (_("'%s' not within current stack frame."), arg
);
2545 if (frame
!= get_selected_frame (NULL
))
2547 select_frame (frame
);
2548 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2552 /* Apply a GDB command to all stack frames, or a set of identified frames,
2553 or innermost COUNT frames.
2554 With a negative COUNT, apply command on outermost -COUNT frames.
2556 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2557 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2558 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2559 frame apply all -s p local_var_no_idea_in_which_frame
2560 If a frame has a local variable called
2561 local_var_no_idea_in_which_frame, print frame
2562 and value of local_var_no_idea_in_which_frame.
2563 frame apply all -s -q p local_var_no_idea_in_which_frame
2564 Same as before, but only print the variable value.
2565 frame apply level 2-5 0 4-7 -s p i = i + 1
2566 Adds 1 to the variable i in the specified frames.
2567 Note that i will be incremented twice in
2570 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2571 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2572 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2573 for error messages. */
2576 frame_apply_command_count (const char *which_command
,
2577 const char *cmd
, int from_tty
,
2578 struct frame_info
*trailing
, int count
)
2581 struct frame_info
*fi
;
2583 while (cmd
!= NULL
&& parse_flags_qcs (which_command
, &cmd
, &flags
))
2586 if (cmd
== NULL
|| *cmd
== '\0')
2587 error (_("Please specify a command to apply on the selected frames"));
2589 /* The below will restore the current inferior/thread/frame.
2590 Usually, only the frame is effectively to be restored.
2591 But in case CMD switches of inferior/thread, better restore
2593 scoped_restore_current_thread restore_thread
;
2595 for (fi
= trailing
; fi
&& count
--; fi
= get_prev_frame (fi
))
2602 std::string cmd_result
;
2604 /* In case CMD switches of inferior/thread/frame, the below
2605 restores the inferior/thread/frame. FI can then be
2606 set to the selected frame. */
2607 scoped_restore_current_thread restore_fi_current_frame
;
2609 cmd_result
= execute_command_to_string (cmd
, from_tty
);
2611 fi
= get_selected_frame (_("frame apply "
2612 "unable to get selected frame."));
2613 if (!flags
.silent
|| cmd_result
.length () > 0)
2616 print_stack_frame (fi
, 1, LOCATION
, 0);
2617 printf_filtered ("%s", cmd_result
.c_str ());
2620 CATCH (ex
, RETURN_MASK_ERROR
)
2622 fi
= get_selected_frame (_("frame apply "
2623 "unable to get selected frame."));
2627 print_stack_frame (fi
, 1, LOCATION
, 0);
2629 printf_filtered ("%s\n", ex
.message
);
2631 throw_exception (ex
);
2638 /* Implementation of the "frame apply level" command. */
2641 frame_apply_level_command (const char *cmd
, int from_tty
)
2643 if (!target_has_stack
)
2644 error (_("No stack."));
2646 bool level_found
= false;
2647 const char *levels_str
= cmd
;
2648 number_or_range_parser
levels (levels_str
);
2650 /* Skip the LEVEL list to find the flags and command args. */
2651 while (!levels
.finished ())
2653 /* Call for effect. */
2654 levels
.get_number ();
2657 if (levels
.in_range ())
2658 levels
.skip_range ();
2662 error (_("Missing or invalid LEVEL... argument"));
2664 cmd
= levels
.cur_tok ();
2666 /* Redo the LEVELS parsing, but applying COMMAND. */
2667 levels
.init (levels_str
);
2668 while (!levels
.finished ())
2670 const int level_beg
= levels
.get_number ();
2673 if (levels
.in_range ())
2675 n_frames
= levels
.end_value () - level_beg
+ 1;
2676 levels
.skip_range ();
2681 frame_apply_command_count ("frame apply level", cmd
, from_tty
,
2682 leading_innermost_frame (level_beg
), n_frames
);
2686 /* Implementation of the "frame apply all" command. */
2689 frame_apply_all_command (const char *cmd
, int from_tty
)
2691 if (!target_has_stack
)
2692 error (_("No stack."));
2694 frame_apply_command_count ("frame apply all", cmd
, from_tty
,
2695 get_current_frame (), INT_MAX
);
2698 /* Implementation of the "frame apply" command. */
2701 frame_apply_command (const char* cmd
, int from_tty
)
2704 struct frame_info
*trailing
;
2706 if (!target_has_stack
)
2707 error (_("No stack."));
2710 error (_("Missing COUNT argument."));
2711 count
= get_number_trailer (&cmd
, 0);
2713 error (_("Invalid COUNT argument."));
2717 trailing
= trailing_outermost_frame (-count
);
2721 trailing
= get_current_frame ();
2723 frame_apply_command_count ("frame apply", cmd
, from_tty
,
2727 /* Implementation of the "faas" command. */
2730 faas_command (const char *cmd
, int from_tty
)
2732 std::string expanded
= std::string ("frame apply all -s ") + cmd
;
2733 execute_command (expanded
.c_str (), from_tty
);
2737 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
2738 matching frame can be found. */
2740 static struct frame_info
*
2741 find_frame_for_address (CORE_ADDR address
)
2744 struct frame_info
*fid
;
2746 id
= frame_id_build_wild (address
);
2748 /* If (s)he specifies the frame with an address, he deserves
2749 what (s)he gets. Still, give the highest one that matches.
2750 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
2752 for (fid
= get_current_frame ();
2754 fid
= get_prev_frame (fid
))
2756 if (frame_id_eq (id
, get_frame_id (fid
)))
2758 struct frame_info
*prev_frame
;
2762 prev_frame
= get_prev_frame (fid
);
2764 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
2776 /* Commands with a prefix of `frame apply'. */
2777 static struct cmd_list_element
*frame_apply_cmd_list
= NULL
;
2779 /* Commands with a prefix of `frame'. */
2780 static struct cmd_list_element
*frame_cmd_list
= NULL
;
2782 /* Commands with a prefix of `select frame'. */
2783 static struct cmd_list_element
*select_frame_cmd_list
= NULL
;
2785 /* Commands with a prefix of `info frame'. */
2786 static struct cmd_list_element
*info_frame_cmd_list
= NULL
;
2789 _initialize_stack (void)
2791 struct cmd_list_element
*cmd
;
2793 add_com ("return", class_stack
, return_command
, _("\
2794 Make selected stack frame return to its caller.\n\
2795 Control remains in the debugger, but when you continue\n\
2796 execution will resume in the frame above the one now selected.\n\
2797 If an argument is given, it is an expression for the value to return."));
2799 add_com ("up", class_stack
, up_command
, _("\
2800 Select and print stack frame that called this one.\n\
2801 An argument says how many frames up to go."));
2802 add_com ("up-silently", class_support
, up_silently_command
, _("\
2803 Same as the `up' command, but does not print anything.\n\
2804 This is useful in command scripts."));
2806 add_com ("down", class_stack
, down_command
, _("\
2807 Select and print stack frame called by this one.\n\
2808 An argument says how many frames down to go."));
2809 add_com_alias ("do", "down", class_stack
, 1);
2810 add_com_alias ("dow", "down", class_stack
, 1);
2811 add_com ("down-silently", class_support
, down_silently_command
, _("\
2812 Same as the `down' command, but does not print anything.\n\
2813 This is useful in command scripts."));
2815 add_prefix_cmd ("frame", class_stack
,
2816 &frame_cmd
.base_command
, _("\
2817 Select and print a stack frame.\n\
2818 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2819 A single numerical argument specifies the frame to select."),
2820 &frame_cmd_list
, "frame ", 1, &cmdlist
);
2822 add_com_alias ("f", "frame", class_stack
, 1);
2824 #define FRAME_APPLY_FLAGS_HELP "\
2825 Prints the frame location information followed by COMMAND output.\n\
2826 FLAG arguments are -q (quiet), -c (continue), -s (silent).\n\
2827 Flag -q disables printing the frame location information.\n\
2828 By default, if a COMMAND raises an error, frame apply is aborted.\n\
2829 Flag -c indicates to print the error and continue.\n\
2830 Flag -s indicates to silently ignore a COMMAND that raises an error\n\
2831 or produces no output."
2833 add_prefix_cmd ("apply", class_stack
, frame_apply_command
,
2834 _("Apply a command to a number of frames.\n\
2835 Usage: frame apply COUNT [FLAG]... COMMAND\n\
2836 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
2837 FRAME_APPLY_FLAGS_HELP
),
2838 &frame_apply_cmd_list
, "frame apply ", 1, &frame_cmd_list
);
2840 add_cmd ("all", class_stack
, frame_apply_all_command
,
2842 Apply a command to all frames.\n\
2844 Usage: frame apply all [FLAG]... COMMAND\n"
2845 FRAME_APPLY_FLAGS_HELP
),
2846 &frame_apply_cmd_list
);
2848 add_cmd ("level", class_stack
, frame_apply_level_command
,
2850 Apply a command to a list of frames.\n\
2852 Usage: frame apply level LEVEL... [FLAG]... COMMAND\n\
2853 ID is a space-separated list of LEVELs of frames to apply COMMAND on.\n"
2854 FRAME_APPLY_FLAGS_HELP
),
2855 &frame_apply_cmd_list
);
2857 add_com ("faas", class_stack
, faas_command
, _("\
2858 Apply a command to all frames (ignoring errors and empty output).\n\
2859 Usage: faas COMMAND\n\
2860 shortcut for 'frame apply all -s COMMAND'"));
2863 add_prefix_cmd ("frame", class_stack
,
2864 &frame_cmd
.base_command
, _("\
2865 Select and print a stack frame.\n\
2866 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2867 A single numerical argument specifies the frame to select."),
2868 &frame_cmd_list
, "frame ", 1, &cmdlist
);
2869 add_com_alias ("f", "frame", class_stack
, 1);
2871 add_cmd ("address", class_stack
, &frame_cmd
.address
,
2873 Select and print a stack frame by stack address\n\
2875 Usage: frame address STACK-ADDRESS"),
2878 add_cmd ("view", class_stack
, &frame_cmd
.view
,
2880 View a stack frame that might be outside the current backtrace.\n\
2882 Usage: frame view STACK-ADDRESS\n\
2883 frame view STACK-ADDRESS PC-ADDRESS"),
2886 cmd
= add_cmd ("function", class_stack
, &frame_cmd
.function
,
2888 Select and print a stack frame by function name.\n\
2890 Usage: frame function NAME\n\
2892 The innermost frame that visited function NAME is selected."),
2894 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
2897 add_cmd ("level", class_stack
, &frame_cmd
.level
,
2899 Select and print a stack frame by level.\n\
2901 Usage: frame level LEVEL"),
2904 cmd
= add_prefix_cmd_suppress_notification ("select-frame", class_stack
,
2905 &select_frame_cmd
.base_command
, _("\
2906 Select a stack frame without printing anything.\n\
2907 A single numerical argument specifies the frame to select."),
2908 &select_frame_cmd_list
, "select-frame ", 1, &cmdlist
,
2909 &cli_suppress_notification
.user_selected_context
);
2911 add_cmd_suppress_notification ("address", class_stack
,
2912 &select_frame_cmd
.address
, _("\
2913 Select a stack frame by stack address.\n\
2915 Usage: select-frame address STACK-ADDRESS"),
2916 &select_frame_cmd_list
,
2917 &cli_suppress_notification
.user_selected_context
);
2920 add_cmd_suppress_notification ("view", class_stack
,
2921 &select_frame_cmd
.view
, _("\
2922 Select a stack frame that might be outside the current backtrace.\n\
2924 Usage: select-frame view STACK-ADDRESS\n\
2925 select-frame view STACK-ADDRESS PC-ADDRESS"),
2926 &select_frame_cmd_list
,
2927 &cli_suppress_notification
.user_selected_context
);
2929 cmd
= add_cmd_suppress_notification ("function", class_stack
,
2930 &select_frame_cmd
.function
, _("\
2931 Select a stack frame by function name.\n\
2933 Usage: select-frame function NAME"),
2934 &select_frame_cmd_list
,
2935 &cli_suppress_notification
.user_selected_context
);
2936 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
2938 add_cmd_suppress_notification ("level", class_stack
,
2939 &select_frame_cmd
.level
, _("\
2940 Select a stack frame by level.\n\
2942 Usage: select-frame level LEVEL"),
2943 &select_frame_cmd_list
,
2944 &cli_suppress_notification
.user_selected_context
);
2946 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2947 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2948 Usage: backtrace [QUALIFIERS]... [COUNT]\n\
2949 With a negative argument, print outermost -COUNT frames.\n\
2950 Use of the 'full' qualifier also prints the values of the local variables.\n\
2951 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2952 on this backtrace."));
2953 add_com_alias ("bt", "backtrace", class_stack
, 0);
2955 add_com_alias ("where", "backtrace", class_alias
, 0);
2956 add_info ("stack", backtrace_command
,
2957 _("Backtrace of the stack, or innermost COUNT frames."));
2958 add_info_alias ("s", "stack", 1);
2960 add_prefix_cmd ("frame", class_info
, &info_frame_cmd
.base_command
,
2961 _("All about the selected stack frame.\n\
2962 With no arguments, displays information about the currently selected stack\n\
2963 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
2964 the information is then printed about the specified frame."),
2965 &info_frame_cmd_list
, "info frame ", 1, &infolist
);
2966 add_info_alias ("f", "frame", 1);
2968 add_cmd ("address", class_stack
, &info_frame_cmd
.address
,
2970 Print information about a stack frame selected by stack address.\n\
2972 Usage: info frame address STACK-ADDRESS"),
2973 &info_frame_cmd_list
);
2975 add_cmd ("view", class_stack
, &info_frame_cmd
.view
,
2977 Print information about a stack frame outside the current backtrace.\n\
2979 Usage: info frame view STACK-ADDRESS\n\
2980 info frame view STACK-ADDRESS PC-ADDRESS"),
2981 &info_frame_cmd_list
);
2983 cmd
= add_cmd ("function", class_stack
, &info_frame_cmd
.function
,
2985 Print information about a stack frame selected by function name.\n\
2987 Usage: info frame function NAME"),
2988 &info_frame_cmd_list
);
2989 set_cmd_completer (cmd
, frame_selection_by_function_completer
);
2991 add_cmd ("level", class_stack
, &info_frame_cmd
.level
,
2993 Print information about a stack frame selected by level.\n\
2995 Usage: info frame level LEVEL"),
2996 &info_frame_cmd_list
);
2998 add_info ("locals", info_locals_command
,
2999 _("Local variables of current stack frame."));
3000 add_info ("args", info_args_command
,
3001 _("Argument variables of current stack frame."));
3004 add_com ("func", class_stack
, func_command
, _("\
3005 Select the stack frame that contains NAME.\n\
3006 Usage: func NAME"));
3008 add_setshow_enum_cmd ("frame-arguments", class_stack
,
3009 print_frame_arguments_choices
, &print_frame_arguments
,
3010 _("Set printing of non-scalar frame arguments"),
3011 _("Show printing of non-scalar frame arguments"),
3012 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
3014 add_setshow_boolean_cmd ("frame-arguments", no_class
,
3015 &print_raw_frame_arguments
, _("\
3016 Set whether to print frame arguments in raw form."), _("\
3017 Show whether to print frame arguments in raw form."), _("\
3018 If set, frame arguments are printed in raw form, bypassing any\n\
3019 pretty-printers for that value."),
3021 &setprintrawlist
, &showprintrawlist
);
3023 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
3024 &disassemble_next_line
, _("\
3025 Set whether to disassemble next source line or insn when execution stops."),
3027 Show whether to disassemble next source line or insn when execution stops."),
3029 If ON, GDB will display disassembly of the next source line, in addition\n\
3030 to displaying the source line itself. If the next source line cannot\n\
3031 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3032 will display disassembly of next instruction instead of showing the\n\
3034 If AUTO, display disassembly of next instruction only if the source line\n\
3035 cannot be displayed.\n\
3036 If OFF (which is the default), never display the disassembly of the next\n\
3039 show_disassemble_next_line
,
3040 &setlist
, &showlist
);
3041 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
3043 add_setshow_enum_cmd ("entry-values", class_stack
,
3044 print_entry_values_choices
, &print_entry_values
,
3045 _("Set printing of function arguments at function "
3047 _("Show printing of function arguments at function "
3050 GDB can sometimes determine the values of function arguments at entry,\n\
3051 in addition to their current values. This option tells GDB whether\n\
3052 to print the current value, the value at entry (marked as val@entry),\n\
3053 or both. Note that one or both of these values may be <optimized out>."),
3054 NULL
, NULL
, &setprintlist
, &showprintlist
);