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"
51 #include "safe-ctype.h"
53 #include "extension.h"
54 #include "observable.h"
55 #include "common/def-vector.h"
57 /* The possible choices of "set print frame-arguments", and the value
60 static const char *const print_frame_arguments_choices
[] =
61 {"all", "scalars", "none", NULL
};
62 static const char *print_frame_arguments
= "scalars";
64 /* If non-zero, don't invoke pretty-printers for frame arguments. */
65 static int print_raw_frame_arguments
;
67 /* The possible choices of "set print entry-values", and the value
70 const char print_entry_values_no
[] = "no";
71 const char print_entry_values_only
[] = "only";
72 const char print_entry_values_preferred
[] = "preferred";
73 const char print_entry_values_if_needed
[] = "if-needed";
74 const char print_entry_values_both
[] = "both";
75 const char print_entry_values_compact
[] = "compact";
76 const char print_entry_values_default
[] = "default";
77 static const char *const print_entry_values_choices
[] =
79 print_entry_values_no
,
80 print_entry_values_only
,
81 print_entry_values_preferred
,
82 print_entry_values_if_needed
,
83 print_entry_values_both
,
84 print_entry_values_compact
,
85 print_entry_values_default
,
88 const char *print_entry_values
= print_entry_values_default
;
90 /* Prototypes for local functions. */
92 static void print_frame_local_vars (struct frame_info
*, int,
95 static void print_frame (struct frame_info
*frame
, int print_level
,
96 enum print_what print_what
, int print_args
,
97 struct symtab_and_line sal
);
99 static void set_last_displayed_sal (int valid
,
100 struct program_space
*pspace
,
102 struct symtab
*symtab
,
105 /* Zero means do things normally; we are interacting directly with the
106 user. One means print the full filename and linenumber when a
107 frame is printed, and do so in a format emacs18/emacs19.22 can
108 parse. Two means print similar annotations, but in many more
109 cases and in a slightly different syntax. */
111 int annotation_level
= 0;
113 /* These variables hold the last symtab and line we displayed to the user.
114 * This is where we insert a breakpoint or a skiplist entry by default. */
115 static int last_displayed_sal_valid
= 0;
116 static struct program_space
*last_displayed_pspace
= 0;
117 static CORE_ADDR last_displayed_addr
= 0;
118 static struct symtab
*last_displayed_symtab
= 0;
119 static int last_displayed_line
= 0;
122 /* Return 1 if we should display the address in addition to the location,
123 because we are in the middle of a statement. */
126 frame_show_address (struct frame_info
*frame
,
127 struct symtab_and_line sal
)
129 /* If there is a line number, but no PC, then there is no location
130 information associated with this sal. The only way that should
131 happen is for the call sites of inlined functions (SAL comes from
132 find_frame_sal). Otherwise, we would have some PC range if the
133 SAL came from a line table. */
134 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
136 if (get_next_frame (frame
) == NULL
)
137 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
139 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
143 return get_frame_pc (frame
) != sal
.pc
;
149 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
150 int print_level
, enum print_what print_what
,
153 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
155 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
158 /* Show or print a stack frame FRAME briefly. The output is formatted
159 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
160 relative level, function name, argument list, and file name and
161 line number. If the frame's PC is not at the beginning of the
162 source line, the actual PC is printed at the beginning. */
165 print_stack_frame (struct frame_info
*frame
, int print_level
,
166 enum print_what print_what
,
170 /* For mi, alway print location and address. */
171 if (current_uiout
->is_mi_like_p ())
172 print_what
= LOC_AND_ADDRESS
;
176 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
179 set_current_sal_from_frame (frame
);
181 CATCH (e
, RETURN_MASK_ERROR
)
187 /* Print nameless arguments of frame FRAME on STREAM, where START is
188 the offset of the first nameless argument, and NUM is the number of
189 nameless arguments to print. FIRST is nonzero if this is the first
190 argument (not just the first nameless argument). */
193 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
194 int first
, struct ui_file
*stream
)
196 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
197 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
202 for (i
= 0; i
< num
; i
++)
205 argsaddr
= get_frame_args_address (frame
);
208 arg_value
= read_memory_integer (argsaddr
+ start
,
209 sizeof (int), byte_order
);
211 fprintf_filtered (stream
, ", ");
212 fprintf_filtered (stream
, "%ld", arg_value
);
214 start
+= sizeof (int);
218 /* Print single argument of inferior function. ARG must be already
221 Errors are printed as if they would be the parameter value. Use zeroed ARG
222 iff it should not be printed accoring to user settings. */
225 print_frame_arg (const struct frame_arg
*arg
)
227 struct ui_out
*uiout
= current_uiout
;
228 const char *error_message
= NULL
;
232 gdb_assert (!arg
->val
|| !arg
->error
);
233 gdb_assert (arg
->entry_kind
== print_entry_values_no
234 || arg
->entry_kind
== print_entry_values_only
235 || (!uiout
->is_mi_like_p ()
236 && arg
->entry_kind
== print_entry_values_compact
));
238 annotate_arg_emitter arg_emitter
;
239 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
240 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
241 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
242 if (arg
->entry_kind
== print_entry_values_compact
)
244 /* It is OK to provide invalid MI-like stream as with
245 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
248 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
249 SYMBOL_LANGUAGE (arg
->sym
),
250 DMGL_PARAMS
| DMGL_ANSI
);
252 if (arg
->entry_kind
== print_entry_values_only
253 || arg
->entry_kind
== print_entry_values_compact
)
255 uiout
->field_stream ("name", stb
);
256 annotate_arg_name_end ();
259 if (!arg
->val
&& !arg
->error
)
264 error_message
= arg
->error
;
269 const struct language_defn
*language
;
270 struct value_print_options opts
;
272 /* Avoid value_print because it will deref ref parameters. We
273 just want to print their addresses. Print ??? for args whose
274 address we do not know. We pass 2 as "recurse" to val_print
275 because our standard indentation here is 4 spaces, and
276 val_print indents 2 for each recurse. */
278 annotate_arg_value (value_type (arg
->val
));
280 /* Use the appropriate language to display our symbol, unless the
281 user forced the language to a specific language. */
282 if (language_mode
== language_mode_auto
)
283 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
285 language
= current_language
;
287 get_no_prettyformat_print_options (&opts
);
289 opts
.raw
= print_raw_frame_arguments
;
291 /* True in "summary" mode, false otherwise. */
292 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
294 common_val_print (arg
->val
, &stb
, 2, &opts
, language
);
296 CATCH (except
, RETURN_MASK_ERROR
)
298 error_message
= except
.message
;
302 if (error_message
!= NULL
)
303 stb
.printf (_("<error reading variable: %s>"), error_message
);
306 uiout
->field_stream ("value", stb
);
309 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
310 responsible for xfree of ARGP->ERROR. This function never throws an
314 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
315 struct frame_arg
*argp
)
323 argp
->val
= read_var_value (sym
, NULL
, frame
);
325 CATCH (except
, RETURN_MASK_ERROR
)
327 argp
->error
= xstrdup (except
.message
);
332 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
333 responsible for xfree of ARGP->ERROR. This function never throws an
337 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
338 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
340 struct value
*val
= NULL
, *entryval
= NULL
;
341 char *val_error
= NULL
, *entryval_error
= NULL
;
344 if (print_entry_values
!= print_entry_values_only
345 && print_entry_values
!= print_entry_values_preferred
)
349 val
= read_var_value (sym
, NULL
, frame
);
351 CATCH (except
, RETURN_MASK_ERROR
)
353 val_error
= (char *) alloca (strlen (except
.message
) + 1);
354 strcpy (val_error
, except
.message
);
359 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
360 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
361 && print_entry_values
!= print_entry_values_no
362 && (print_entry_values
!= print_entry_values_if_needed
363 || !val
|| value_optimized_out (val
)))
367 const struct symbol_computed_ops
*ops
;
369 ops
= SYMBOL_COMPUTED_OPS (sym
);
370 entryval
= ops
->read_variable_at_entry (sym
, frame
);
372 CATCH (except
, RETURN_MASK_ERROR
)
374 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
376 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
377 strcpy (entryval_error
, except
.message
);
382 if (entryval
!= NULL
&& value_optimized_out (entryval
))
385 if (print_entry_values
== print_entry_values_compact
386 || print_entry_values
== print_entry_values_default
)
388 /* For MI do not try to use print_entry_values_compact for ARGP. */
390 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
392 struct type
*type
= value_type (val
);
394 if (value_lazy (val
))
395 value_fetch_lazy (val
);
396 if (value_lazy (entryval
))
397 value_fetch_lazy (entryval
);
399 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
401 /* Initialize it just to avoid a GCC false warning. */
402 struct value
*val_deref
= NULL
, *entryval_deref
;
404 /* DW_AT_call_value does match with the current
405 value. If it is a reference still try to verify if
406 dereferenced DW_AT_call_data_value does not differ. */
410 struct type
*type_deref
;
412 val_deref
= coerce_ref (val
);
413 if (value_lazy (val_deref
))
414 value_fetch_lazy (val_deref
);
415 type_deref
= value_type (val_deref
);
417 entryval_deref
= coerce_ref (entryval
);
418 if (value_lazy (entryval_deref
))
419 value_fetch_lazy (entryval_deref
);
421 /* If the reference addresses match but dereferenced
422 content does not match print them. */
424 && value_contents_eq (val_deref
, 0,
426 TYPE_LENGTH (type_deref
)))
429 CATCH (except
, RETURN_MASK_ERROR
)
431 /* If the dereferenced content could not be
432 fetched do not display anything. */
433 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
435 else if (except
.message
!= NULL
)
437 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
438 strcpy (entryval_error
, except
.message
);
443 /* Value was not a reference; and its content matches. */
444 if (val
== val_deref
)
452 /* Try to remove possibly duplicate error message for ENTRYARGP even
455 if (val_error
&& entryval_error
456 && strcmp (val_error
, entryval_error
) == 0)
458 entryval_error
= NULL
;
460 /* Do not se VAL_EQUAL as the same error message may be shown for
461 the entry value even if no entry values are present in the
467 if (entryval
== NULL
)
469 if (print_entry_values
== print_entry_values_preferred
)
471 gdb_assert (val
== NULL
);
475 val
= read_var_value (sym
, NULL
, frame
);
477 CATCH (except
, RETURN_MASK_ERROR
)
479 val_error
= (char *) alloca (strlen (except
.message
) + 1);
480 strcpy (val_error
, except
.message
);
484 if (print_entry_values
== print_entry_values_only
485 || print_entry_values
== print_entry_values_both
486 || (print_entry_values
== print_entry_values_preferred
487 && (!val
|| value_optimized_out (val
))))
489 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
490 entryval_error
= NULL
;
493 if ((print_entry_values
== print_entry_values_compact
494 || print_entry_values
== print_entry_values_if_needed
495 || print_entry_values
== print_entry_values_preferred
)
496 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
504 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
505 if (!val
&& !val_error
)
506 argp
->entry_kind
= print_entry_values_only
;
507 else if ((print_entry_values
== print_entry_values_compact
508 || print_entry_values
== print_entry_values_default
) && val_equal
)
510 argp
->entry_kind
= print_entry_values_compact
;
511 gdb_assert (!current_uiout
->is_mi_like_p ());
514 argp
->entry_kind
= print_entry_values_no
;
516 entryargp
->sym
= sym
;
517 entryargp
->val
= entryval
;
518 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
519 if (!entryval
&& !entryval_error
)
520 entryargp
->entry_kind
= print_entry_values_no
;
522 entryargp
->entry_kind
= print_entry_values_only
;
525 /* Print the arguments of frame FRAME on STREAM, given the function
526 FUNC running in that frame (as a symbol), where NUM is the number
527 of arguments according to the stack frame (or -1 if the number of
528 arguments is unknown). */
530 /* Note that currently the "number of arguments according to the
531 stack frame" is only known on VAX where i refers to the "number of
532 ints of arguments according to the stack frame". */
535 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
536 int num
, struct ui_file
*stream
)
538 struct ui_out
*uiout
= current_uiout
;
540 /* Offset of next stack argument beyond the one we have seen that is
541 at the highest offset, or -1 if we haven't come to a stack
543 long highest_offset
= -1;
544 /* Number of ints of arguments that we have printed so far. */
545 int args_printed
= 0;
546 /* True if we should print arguments, false otherwise. */
547 int print_args
= strcmp (print_frame_arguments
, "none");
551 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
552 struct block_iterator iter
;
555 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
557 struct frame_arg arg
, entryarg
;
561 /* Keep track of the highest stack argument offset seen, and
562 skip over any kinds of symbols we don't care about. */
564 if (!SYMBOL_IS_ARGUMENT (sym
))
567 switch (SYMBOL_CLASS (sym
))
572 long current_offset
= SYMBOL_VALUE (sym
);
573 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
575 /* Compute address of next argument by adding the size of
576 this argument and rounding to an int boundary. */
578 ((current_offset
+ arg_size
+ sizeof (int) - 1)
579 & ~(sizeof (int) - 1));
581 /* If this is the highest offset seen yet, set
583 if (highest_offset
== -1
584 || (current_offset
> highest_offset
))
585 highest_offset
= current_offset
;
587 /* Add the number of ints we're about to print to
589 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
592 /* We care about types of symbols, but don't need to
593 keep track of stack offsets in them. */
595 case LOC_REGPARM_ADDR
:
597 case LOC_OPTIMIZED_OUT
:
602 /* We have to look up the symbol because arguments can have
603 two entries (one a parameter, one a local) and the one we
604 want is the local, which lookup_symbol will find for us.
605 This includes gcc1 (not gcc2) on SPARC when passing a
606 small structure and gcc2 when the argument type is float
607 and it is passed as a double and converted to float by
608 the prologue (in the latter case the type of the LOC_ARG
609 symbol is double and the type of the LOC_LOCAL symbol is
611 /* But if the parameter name is null, don't try it. Null
612 parameter names occur on the RS/6000, for traceback
613 tables. FIXME, should we even print them? */
615 if (*SYMBOL_LINKAGE_NAME (sym
))
619 nsym
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
620 b
, VAR_DOMAIN
).symbol
;
621 gdb_assert (nsym
!= NULL
);
622 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
623 && !SYMBOL_IS_ARGUMENT (nsym
))
625 /* There is a LOC_ARG/LOC_REGISTER pair. This means
626 that it was passed on the stack and loaded into a
627 register, or passed in a register and stored in a
628 stack slot. GDB 3.x used the LOC_ARG; GDB
629 4.0-4.11 used the LOC_REGISTER.
631 Reasons for using the LOC_ARG:
633 (1) Because find_saved_registers may be slow for
636 (2) Because registers are often re-used and stack
637 slots rarely (never?) are. Therefore using
638 the stack slot is much less likely to print
641 Reasons why we might want to use the LOC_REGISTER:
643 (1) So that the backtrace prints the same value
644 as "print foo". I see no compelling reason
645 why this needs to be the case; having the
646 backtrace print the value which was passed
647 in, and "print foo" print the value as
648 modified within the called function, makes
651 Additional note: It might be nice if "info args"
652 displayed both values.
654 One more note: There is a case with SPARC
655 structure passing where we need to use the
656 LOC_REGISTER, but this is dealt with by creating
657 a single LOC_REGPARM in symbol reading. */
659 /* Leave sym (the LOC_ARG) alone. */
666 /* Print the current arg. */
669 uiout
->wrap_hint (" ");
673 memset (&arg
, 0, sizeof (arg
));
675 arg
.entry_kind
= print_entry_values_no
;
676 memset (&entryarg
, 0, sizeof (entryarg
));
678 entryarg
.entry_kind
= print_entry_values_no
;
681 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
683 if (arg
.entry_kind
!= print_entry_values_only
)
684 print_frame_arg (&arg
);
686 if (entryarg
.entry_kind
!= print_entry_values_no
)
688 if (arg
.entry_kind
!= print_entry_values_only
)
691 uiout
->wrap_hint (" ");
694 print_frame_arg (&entryarg
);
698 xfree (entryarg
.error
);
704 /* Don't print nameless args in situations where we don't know
705 enough about the stack to find them. */
710 if (highest_offset
== -1)
711 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
713 start
= highest_offset
;
715 print_frame_nameless_args (frame
, start
, num
- args_printed
,
720 /* Set the current source and line to the location given by frame
721 FRAME, if possible. When CENTER is true, adjust so the relevant
722 line is in the center of the next 'list'. */
725 set_current_sal_from_frame (struct frame_info
*frame
)
727 symtab_and_line sal
= find_frame_sal (frame
);
728 if (sal
.symtab
!= NULL
)
729 set_current_source_symtab_and_line (sal
);
732 /* If ON, GDB will display disassembly of the next source line when
733 execution of the program being debugged stops.
734 If AUTO (which is the default), or there's no line info to determine
735 the source line of the next instruction, display disassembly of next
736 instruction instead. */
738 static enum auto_boolean disassemble_next_line
;
741 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
742 struct cmd_list_element
*c
,
745 fprintf_filtered (file
,
746 _("Debugger's willingness to use "
747 "disassemble-next-line is %s.\n"),
751 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
752 because it will be broken by filter sometime. */
755 do_gdb_disassembly (struct gdbarch
*gdbarch
,
756 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
761 gdb_disassembly (gdbarch
, current_uiout
,
762 DISASSEMBLY_RAW_INSN
, how_many
,
765 CATCH (exception
, RETURN_MASK_ERROR
)
767 /* If an exception was thrown while doing the disassembly, print
768 the error message, to give the user a clue of what happened. */
769 exception_print (gdb_stderr
, exception
);
774 /* Print information about frame FRAME. The output is format according
775 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
778 SRC_LINE: Print only source line.
779 LOCATION: Print only location.
780 LOC_AND_SRC: Print location and source line.
782 Used in "where" output, and to emit breakpoint or step
786 print_frame_info (struct frame_info
*frame
, int print_level
,
787 enum print_what print_what
, int print_args
,
790 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
793 struct ui_out
*uiout
= current_uiout
;
795 if (get_frame_type (frame
) == DUMMY_FRAME
796 || get_frame_type (frame
) == SIGTRAMP_FRAME
797 || get_frame_type (frame
) == ARCH_FRAME
)
799 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
801 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
802 gdbarch
, get_frame_pc (frame
));
804 /* Do this regardless of SOURCE because we don't have any source
805 to list for this frame. */
809 uiout
->field_fmt_int (2, ui_left
, "level",
810 frame_relative_level (frame
));
812 if (uiout
->is_mi_like_p ())
814 annotate_frame_address ();
815 uiout
->field_core_addr ("addr",
816 gdbarch
, get_frame_pc (frame
));
817 annotate_frame_address_end ();
820 if (get_frame_type (frame
) == DUMMY_FRAME
)
822 annotate_function_call ();
823 uiout
->field_string ("func", "<function called from gdb>");
825 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
827 annotate_signal_handler_caller ();
828 uiout
->field_string ("func", "<signal handler called>");
830 else if (get_frame_type (frame
) == ARCH_FRAME
)
832 uiout
->field_string ("func", "<cross-architecture call>");
835 annotate_frame_end ();
837 /* If disassemble-next-line is set to auto or on output the next
839 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
840 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
841 do_gdb_disassembly (get_frame_arch (frame
), 1,
842 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
847 /* If FRAME is not the innermost frame, that normally means that
848 FRAME->pc points to *after* the call instruction, and we want to
849 get the line containing the call, never the next line. But if
850 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
851 next frame was not entered as the result of a call, and we want
852 to get the line containing FRAME->pc. */
853 symtab_and_line sal
= find_frame_sal (frame
);
855 location_print
= (print_what
== LOCATION
856 || print_what
== LOC_AND_ADDRESS
857 || print_what
== SRC_AND_LOC
);
859 if (location_print
|| !sal
.symtab
)
860 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
862 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
864 /* If disassemble-next-line is set to auto or on and doesn't have
865 the line debug messages for $pc, output the next instruction. */
866 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
867 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
868 && source_print
&& !sal
.symtab
)
869 do_gdb_disassembly (get_frame_arch (frame
), 1,
870 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
872 if (source_print
&& sal
.symtab
)
875 int mid_statement
= ((print_what
== SRC_LINE
)
876 && frame_show_address (frame
, sal
));
878 if (annotation_level
)
879 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
880 get_frame_pc (frame
));
883 if (deprecated_print_frame_info_listing_hook
)
884 deprecated_print_frame_info_listing_hook (sal
.symtab
,
889 struct value_print_options opts
;
891 get_user_print_options (&opts
);
892 /* We used to do this earlier, but that is clearly
893 wrong. This function is used by many different
894 parts of gdb, including normal_stop in infrun.c,
895 which uses this to print out the current PC
896 when we stepi/nexti into the middle of a source
897 line. Only the command line really wants this
898 behavior. Other UIs probably would like the
899 ability to decide for themselves if it is desired. */
900 if (opts
.addressprint
&& mid_statement
)
902 uiout
->field_core_addr ("addr",
903 gdbarch
, get_frame_pc (frame
));
907 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
911 /* If disassemble-next-line is set to on and there is line debug
912 messages, output assembly codes for next line. */
913 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
914 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
921 if (get_frame_pc_if_available (frame
, &pc
))
922 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
924 set_last_displayed_sal (0, 0, 0, 0, 0);
927 annotate_frame_end ();
929 gdb_flush (gdb_stdout
);
932 /* Remember the last symtab and line we displayed, which we use e.g.
933 * as the place to put a breakpoint when the `break' command is
934 * invoked with no arguments. */
937 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
938 CORE_ADDR addr
, struct symtab
*symtab
,
941 last_displayed_sal_valid
= valid
;
942 last_displayed_pspace
= pspace
;
943 last_displayed_addr
= addr
;
944 last_displayed_symtab
= symtab
;
945 last_displayed_line
= line
;
946 if (valid
&& pspace
== NULL
)
948 clear_last_displayed_sal ();
949 internal_error (__FILE__
, __LINE__
,
950 _("Trying to set NULL pspace."));
954 /* Forget the last sal we displayed. */
957 clear_last_displayed_sal (void)
959 last_displayed_sal_valid
= 0;
960 last_displayed_pspace
= 0;
961 last_displayed_addr
= 0;
962 last_displayed_symtab
= 0;
963 last_displayed_line
= 0;
966 /* Is our record of the last sal we displayed valid? If not,
967 * the get_last_displayed_* functions will return NULL or 0, as
971 last_displayed_sal_is_valid (void)
973 return last_displayed_sal_valid
;
976 /* Get the pspace of the last sal we displayed, if it's valid. */
978 struct program_space
*
979 get_last_displayed_pspace (void)
981 if (last_displayed_sal_valid
)
982 return last_displayed_pspace
;
986 /* Get the address of the last sal we displayed, if it's valid. */
989 get_last_displayed_addr (void)
991 if (last_displayed_sal_valid
)
992 return last_displayed_addr
;
996 /* Get the symtab of the last sal we displayed, if it's valid. */
999 get_last_displayed_symtab (void)
1001 if (last_displayed_sal_valid
)
1002 return last_displayed_symtab
;
1006 /* Get the line of the last sal we displayed, if it's valid. */
1009 get_last_displayed_line (void)
1011 if (last_displayed_sal_valid
)
1012 return last_displayed_line
;
1016 /* Get the last sal we displayed, if it's valid. */
1019 get_last_displayed_sal ()
1021 symtab_and_line sal
;
1023 if (last_displayed_sal_valid
)
1025 sal
.pspace
= last_displayed_pspace
;
1026 sal
.pc
= last_displayed_addr
;
1027 sal
.symtab
= last_displayed_symtab
;
1028 sal
.line
= last_displayed_line
;
1035 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1036 corresponding to FRAME. */
1038 gdb::unique_xmalloc_ptr
<char>
1039 find_frame_funname (struct frame_info
*frame
, enum language
*funlang
,
1040 struct symbol
**funcp
)
1042 struct symbol
*func
;
1043 gdb::unique_xmalloc_ptr
<char> funname
;
1045 *funlang
= language_unknown
;
1049 func
= get_frame_function (frame
);
1052 /* In certain pathological cases, the symtabs give the wrong
1053 function (when we are in the first function in a file which
1054 is compiled without debugging symbols, the previous function
1055 is compiled with debugging symbols, and the "foo.o" symbol
1056 that is supposed to tell us where the file with debugging
1057 symbols ends has been truncated by ar because it is longer
1058 than 15 characters). This also occurs if the user uses asm()
1059 to create a function but not stabs for it (in a file compiled
1062 So look in the minimal symbol tables as well, and if it comes
1063 up with a larger address for the function use that instead.
1064 I don't think this can ever cause any problems; there
1065 shouldn't be any minimal symbols in the middle of a function;
1066 if this is ever changed many parts of GDB will need to be
1067 changed (and we'll create a find_pc_minimal_function or some
1070 struct bound_minimal_symbol msymbol
;
1072 /* Don't attempt to do this for inlined functions, which do not
1073 have a corresponding minimal symbol. */
1074 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1076 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1078 memset (&msymbol
, 0, sizeof (msymbol
));
1080 if (msymbol
.minsym
!= NULL
1081 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1082 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1084 /* We also don't know anything about the function besides
1085 its address and name. */
1087 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1088 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1092 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1094 *funlang
= SYMBOL_LANGUAGE (func
);
1097 if (*funlang
== language_cplus
)
1099 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1100 to display the demangled name that we already have
1101 stored in the symbol table, but we stored a version
1102 with DMGL_PARAMS turned on, and here we don't want to
1103 display parameters. So remove the parameters. */
1104 funname
= cp_remove_params (print_name
);
1107 /* If we didn't hit the C++ case above, set *funname
1109 if (funname
== NULL
)
1110 funname
.reset (xstrdup (print_name
));
1115 struct bound_minimal_symbol msymbol
;
1118 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1121 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1122 if (msymbol
.minsym
!= NULL
)
1124 funname
.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
)));
1125 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1133 print_frame (struct frame_info
*frame
, int print_level
,
1134 enum print_what print_what
, int print_args
,
1135 struct symtab_and_line sal
)
1137 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1138 struct ui_out
*uiout
= current_uiout
;
1139 enum language funlang
= language_unknown
;
1140 struct value_print_options opts
;
1141 struct symbol
*func
;
1145 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1147 gdb::unique_xmalloc_ptr
<char> funname
1148 = find_frame_funname (frame
, &funlang
, &func
);
1150 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1154 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
1159 uiout
->field_fmt_int (2, ui_left
, "level",
1160 frame_relative_level (frame
));
1162 get_user_print_options (&opts
);
1163 if (opts
.addressprint
)
1165 || frame_show_address (frame
, sal
)
1166 || print_what
== LOC_AND_ADDRESS
)
1168 annotate_frame_address ();
1170 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1172 uiout
->field_string ("addr", "<unavailable>");
1173 annotate_frame_address_end ();
1174 uiout
->text (" in ");
1176 annotate_frame_function_name ();
1179 fprintf_symbol_filtered (&stb
, funname
? funname
.get () : "??",
1180 funlang
, DMGL_ANSI
);
1181 uiout
->field_stream ("func", stb
);
1182 uiout
->wrap_hint (" ");
1183 annotate_frame_args ();
1188 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1191 if (gdbarch_frame_num_args_p (gdbarch
))
1193 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1194 gdb_assert (numargs
>= 0);
1200 ui_out_emit_list
list_emitter (uiout
, "args");
1203 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1205 CATCH (e
, RETURN_MASK_ERROR
)
1210 /* FIXME: ARGS must be a list. If one argument is a string it
1211 will have " that will not be properly escaped. */
1218 const char *filename_display
;
1220 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1221 annotate_frame_source_begin ();
1222 uiout
->wrap_hint (" ");
1223 uiout
->text (" at ");
1224 annotate_frame_source_file ();
1225 uiout
->field_string ("file", filename_display
);
1226 if (uiout
->is_mi_like_p ())
1228 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1230 uiout
->field_string ("fullname", fullname
);
1232 annotate_frame_source_file_end ();
1234 annotate_frame_source_line ();
1235 uiout
->field_int ("line", sal
.line
);
1236 annotate_frame_source_end ();
1239 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1241 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1242 get_frame_pc (frame
));
1246 annotate_frame_where ();
1247 uiout
->wrap_hint (" ");
1248 uiout
->text (" from ");
1249 uiout
->field_string ("from", lib
);
1258 /* Read a frame specification in whatever the appropriate format is from
1259 FRAME_EXP. Call error() if the specification is in any way invalid (so
1260 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1261 set its target to indicate that the default selected frame was used. */
1263 static struct frame_info
*
1264 parse_frame_specification (const char *frame_exp
, int *selected_frame_p
)
1267 struct value
*args
[4];
1268 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1270 if (frame_exp
== NULL
)
1279 /* Skip leading white space, bail of EOL. */
1280 frame_exp
= skip_spaces (frame_exp
);
1284 /* Parse the argument, extract it, save it. */
1286 *p
&& !ISSPACE (*p
);
1288 std::string
addr_string (frame_exp
, p
- frame_exp
);
1291 /* NOTE: Parse and evaluate expression, but do not use
1292 functions such as parse_and_eval_long or
1293 parse_and_eval_address to also extract the value.
1294 Instead value_as_long and value_as_address are used.
1295 This avoids problems with expressions that contain
1297 if (numargs
>= ARRAY_SIZE (args
))
1298 error (_("Too many args in frame specification"));
1299 args
[numargs
++] = parse_and_eval (addr_string
.c_str ());
1303 /* If no args, default to the selected frame. */
1306 if (selected_frame_p
!= NULL
)
1307 (*selected_frame_p
) = 1;
1308 return get_selected_frame (_("No stack."));
1311 /* None of the remaining use the selected frame. */
1312 if (selected_frame_p
!= NULL
)
1313 (*selected_frame_p
) = 0;
1315 /* Assume the single arg[0] is an integer, and try using that to
1316 select a frame relative to current. */
1319 struct frame_info
*fid
;
1320 int level
= value_as_long (args
[0]);
1322 fid
= find_relative_frame (get_current_frame (), &level
);
1324 /* find_relative_frame was successful. */
1328 /* Convert each value into a corresponding address. */
1332 for (i
= 0; i
< numargs
; i
++)
1333 addrs
[i
] = value_as_address (args
[i
]);
1336 /* Assume that the single arg[0] is an address, use that to identify
1337 a frame with a matching ID. Should this also accept stack/pc or
1338 stack/pc/special. */
1341 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1342 struct frame_info
*fid
;
1344 /* If (s)he specifies the frame with an address, he deserves
1345 what (s)he gets. Still, give the highest one that matches.
1346 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1348 for (fid
= get_current_frame ();
1350 fid
= get_prev_frame (fid
))
1352 if (frame_id_eq (id
, get_frame_id (fid
)))
1354 struct frame_info
*prev_frame
;
1358 prev_frame
= get_prev_frame (fid
);
1360 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1369 /* We couldn't identify the frame as an existing frame, but
1370 perhaps we can create one with a single argument. */
1372 return create_new_frame (addrs
[0], 0);
1373 else if (numargs
== 2)
1374 return create_new_frame (addrs
[0], addrs
[1]);
1376 error (_("Too many args in frame specification"));
1379 /* Print verbosely the selected frame or the frame at address
1380 ADDR_EXP. Absolutely all information in the frame is printed. */
1383 info_frame_command (const char *addr_exp
, int from_tty
)
1385 struct frame_info
*fi
;
1386 struct symbol
*func
;
1388 struct frame_info
*calling_frame_info
;
1390 const char *funname
= 0;
1391 enum language funlang
= language_unknown
;
1392 const char *pc_regname
;
1393 int selected_frame_p
;
1394 struct gdbarch
*gdbarch
;
1397 /* Initialize it to avoid "may be used uninitialized" warning. */
1398 CORE_ADDR caller_pc
= 0;
1399 int caller_pc_p
= 0;
1401 fi
= parse_frame_specification (addr_exp
, &selected_frame_p
);
1402 gdbarch
= get_frame_arch (fi
);
1404 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1405 is not a good name. */
1406 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1407 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1408 easily not match that of the internal value returned by
1410 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1412 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1413 architectures will often have a hardware register called "pc",
1414 and that register's value, again, can easily not match
1418 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1419 func
= get_frame_function (fi
);
1420 symtab_and_line sal
= find_frame_sal (fi
);
1422 gdb::unique_xmalloc_ptr
<char> func_only
;
1425 funname
= SYMBOL_PRINT_NAME (func
);
1426 funlang
= SYMBOL_LANGUAGE (func
);
1427 if (funlang
== language_cplus
)
1429 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1430 to display the demangled name that we already have
1431 stored in the symbol table, but we stored a version
1432 with DMGL_PARAMS turned on, and here we don't want to
1433 display parameters. So remove the parameters. */
1434 func_only
= cp_remove_params (funname
);
1437 funname
= func_only
.get ();
1440 else if (frame_pc_p
)
1442 struct bound_minimal_symbol msymbol
;
1444 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1445 if (msymbol
.minsym
!= NULL
)
1447 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1448 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1451 calling_frame_info
= get_prev_frame (fi
);
1453 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1455 printf_filtered (_("Stack level %d, frame at "),
1456 frame_relative_level (fi
));
1460 printf_filtered (_("Stack frame at "));
1462 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1463 printf_filtered (":\n");
1464 printf_filtered (" %s = ", pc_regname
);
1466 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1468 fputs_filtered ("<unavailable>", gdb_stdout
);
1473 printf_filtered (" in ");
1474 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1475 DMGL_ANSI
| DMGL_PARAMS
);
1479 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1481 puts_filtered ("; ");
1483 printf_filtered ("saved %s = ", pc_regname
);
1485 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1486 val_print_not_saved (gdb_stdout
);
1491 caller_pc
= frame_unwind_caller_pc (fi
);
1494 CATCH (ex
, RETURN_MASK_ERROR
)
1498 case NOT_AVAILABLE_ERROR
:
1499 val_print_unavailable (gdb_stdout
);
1501 case OPTIMIZED_OUT_ERROR
:
1502 val_print_not_saved (gdb_stdout
);
1505 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1513 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1514 printf_filtered ("\n");
1516 if (calling_frame_info
== NULL
)
1518 enum unwind_stop_reason reason
;
1520 reason
= get_frame_unwind_stop_reason (fi
);
1521 if (reason
!= UNWIND_NO_REASON
)
1522 printf_filtered (_(" Outermost frame: %s\n"),
1523 frame_stop_reason_string (fi
));
1525 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1526 puts_filtered (" tail call frame");
1527 else if (get_frame_type (fi
) == INLINE_FRAME
)
1528 printf_filtered (" inlined into frame %d",
1529 frame_relative_level (get_prev_frame (fi
)));
1532 printf_filtered (" called by frame at ");
1533 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1536 if (get_next_frame (fi
) && calling_frame_info
)
1537 puts_filtered (",");
1539 if (get_next_frame (fi
))
1541 printf_filtered (" caller of frame at ");
1542 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1545 if (get_next_frame (fi
) || calling_frame_info
)
1546 puts_filtered ("\n");
1549 printf_filtered (" source language %s.\n",
1550 language_str (s
->language
));
1553 /* Address of the argument list for this frame, or 0. */
1554 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1555 /* Number of args for this frame, or -1 if unknown. */
1559 printf_filtered (" Arglist at unknown address.\n");
1562 printf_filtered (" Arglist at ");
1563 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1564 printf_filtered (",");
1566 if (!gdbarch_frame_num_args_p (gdbarch
))
1569 puts_filtered (" args: ");
1573 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1574 gdb_assert (numargs
>= 0);
1576 puts_filtered (" no args.");
1577 else if (numargs
== 1)
1578 puts_filtered (" 1 arg: ");
1580 printf_filtered (" %d args: ", numargs
);
1582 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1583 puts_filtered ("\n");
1587 /* Address of the local variables for this frame, or 0. */
1588 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1591 printf_filtered (" Locals at unknown address,");
1594 printf_filtered (" Locals at ");
1595 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1596 printf_filtered (",");
1600 /* Print as much information as possible on the location of all the
1606 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1608 /* The sp is special; what's displayed isn't the save address, but
1609 the value of the previous frame's sp. This is a legacy thing,
1610 at one stage the frame cached the previous frame's SP instead
1611 of its address, hence it was easiest to just display the cached
1615 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1616 gdb_assert (value
!= NULL
);
1618 if (!value_optimized_out (value
) && value_entirely_available (value
))
1620 if (VALUE_LVAL (value
) == not_lval
)
1623 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1624 int sp_size
= register_size (gdbarch
, sp_regnum
);
1626 sp
= extract_unsigned_integer (value_contents_all (value
),
1627 sp_size
, byte_order
);
1629 printf_filtered (" Previous frame's sp is ");
1630 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1631 printf_filtered ("\n");
1633 else if (VALUE_LVAL (value
) == lval_memory
)
1635 printf_filtered (" Previous frame's sp at ");
1636 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1638 printf_filtered ("\n");
1640 else if (VALUE_LVAL (value
) == lval_register
)
1642 printf_filtered (" Previous frame's sp in %s\n",
1643 gdbarch_register_name (gdbarch
,
1644 VALUE_REGNUM (value
)));
1647 release_value (value
);
1651 /* else keep quiet. */
1655 numregs
= gdbarch_num_regs (gdbarch
)
1656 + gdbarch_num_pseudo_regs (gdbarch
);
1657 for (i
= 0; i
< numregs
; i
++)
1659 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1661 enum lval_type lval
;
1667 /* Find out the location of the saved register without
1668 fetching the corresponding value. */
1669 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1670 &lval
, &addr
, &realnum
, NULL
);
1671 /* For moment, only display registers that were saved on the
1673 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1676 puts_filtered (" Saved registers:\n ");
1678 puts_filtered (",");
1680 printf_filtered (" %s at ",
1681 gdbarch_register_name (gdbarch
, i
));
1682 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1686 if (count
|| need_nl
)
1687 puts_filtered ("\n");
1691 /* Print briefly all stack frames or just the innermost COUNT_EXP
1695 backtrace_command_1 (const char *count_exp
, int show_locals
, int no_filters
,
1698 struct frame_info
*fi
;
1701 struct frame_info
*trailing
;
1702 int trailing_level
, py_start
= 0, py_end
= 0;
1703 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1705 if (!target_has_stack
)
1706 error (_("No stack."));
1708 /* The following code must do two things. First, it must set the
1709 variable TRAILING to the frame from which we should start
1710 printing. Second, it must set the variable count to the number
1711 of frames which we should print, or -1 if all of them. */
1712 trailing
= get_current_frame ();
1717 count
= parse_and_eval_long (count_exp
);
1720 struct frame_info
*current
;
1726 while (current
&& count
--)
1729 current
= get_prev_frame (current
);
1732 /* Will stop when CURRENT reaches the top of the stack.
1733 TRAILING will be COUNT below it. */
1737 trailing
= get_prev_frame (trailing
);
1738 current
= get_prev_frame (current
);
1747 /* The argument to apply_ext_lang_frame_filter is the number
1748 of the final frame to print, and frames start at 0. */
1760 /* Read in symbols for all of the frames. Need to do this in a
1761 separate pass so that "Reading in symbols for xxx" messages
1762 don't screw up the appearance of the backtrace. Also if
1763 people have strong opinions against reading symbols for
1764 backtrace this may have to be an option. */
1766 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1771 pc
= get_frame_address_in_block (fi
);
1772 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1778 frame_filter_flags flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1779 enum ext_lang_frame_args arg_type
;
1782 flags
|= PRINT_LOCALS
;
1784 flags
|= PRINT_MORE_FRAMES
;
1786 if (!strcmp (print_frame_arguments
, "scalars"))
1787 arg_type
= CLI_SCALAR_VALUES
;
1788 else if (!strcmp (print_frame_arguments
, "all"))
1789 arg_type
= CLI_ALL_VALUES
;
1791 arg_type
= NO_VALUES
;
1793 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1794 arg_type
, current_uiout
,
1798 /* Run the inbuilt backtrace if there are no filters registered, or
1799 "no-filters" has been specified from the command. */
1800 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1802 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1806 /* Don't use print_stack_frame; if an error() occurs it probably
1807 means further attempts to backtrace would fail (on the other
1808 hand, perhaps the code does or could be fixed to make sure
1809 the frame->prev field gets set to NULL in that case). */
1811 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1814 struct frame_id frame_id
= get_frame_id (fi
);
1816 print_frame_local_vars (fi
, 1, gdb_stdout
);
1818 /* print_frame_local_vars invalidates FI. */
1819 fi
= frame_find_by_id (frame_id
);
1823 warning (_("Unable to restore previously selected frame."));
1828 /* Save the last frame to check for error conditions. */
1832 /* If we've stopped before the end, mention that. */
1834 printf_filtered (_("(More stack frames follow...)\n"));
1836 /* If we've run out of frames, and the reason appears to be an error
1837 condition, print it. */
1838 if (fi
== NULL
&& trailing
!= NULL
)
1840 enum unwind_stop_reason reason
;
1842 reason
= get_frame_unwind_stop_reason (trailing
);
1843 if (reason
>= UNWIND_FIRST_ERROR
)
1844 printf_filtered (_("Backtrace stopped: %s\n"),
1845 frame_stop_reason_string (trailing
));
1851 backtrace_command (const char *arg
, int from_tty
)
1853 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1856 std::string reconstructed_arg
;
1862 gdb_argv
built_argv (arg
);
1863 argv
= built_argv
.get ();
1865 for (i
= 0; argv
[i
]; i
++)
1869 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1870 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1872 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1876 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1877 fulltrace_arg
= argc
;
1881 arglen
+= strlen (argv
[i
]);
1887 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1891 for (i
= 0; i
< argc
; i
++)
1893 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1895 reconstructed_arg
+= argv
[i
];
1896 reconstructed_arg
+= " ";
1899 arg
= reconstructed_arg
.c_str ();
1906 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1907 no_filters
>= 0 /* no frame-filters */, from_tty
);
1910 /* Iterate over the local variables of a block B, calling CB with
1914 iterate_over_block_locals (const struct block
*b
,
1915 iterate_over_block_arg_local_vars_cb cb
,
1918 struct block_iterator iter
;
1921 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1923 switch (SYMBOL_CLASS (sym
))
1929 case LOC_OPTIMIZED_OUT
:
1930 if (SYMBOL_IS_ARGUMENT (sym
))
1932 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1934 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1938 /* Ignore symbols which are not locals. */
1945 /* Same, but print labels. */
1948 /* Commented out, as the code using this function has also been
1949 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1950 was commented out in the first place. The discussion introducing
1951 this change (2007-12-04: Support lexical blocks and function bodies
1952 that occupy non-contiguous address ranges) did not explain why
1953 this change was made. */
1955 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1956 int *have_default
, struct ui_file
*stream
)
1958 struct block_iterator iter
;
1960 int values_printed
= 0;
1962 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1964 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1970 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1972 struct symtab_and_line sal
;
1973 struct value_print_options opts
;
1975 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1977 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1978 get_user_print_options (&opts
);
1979 if (opts
.addressprint
)
1981 fprintf_filtered (stream
, " ");
1982 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1985 fprintf_filtered (stream
, " in file %s, line %d\n",
1986 sal
.symtab
->filename
, sal
.line
);
1990 return values_printed
;
1994 /* Iterate over all the local variables in block B, including all its
1995 superblocks, stopping when the top-level block is reached. */
1998 iterate_over_block_local_vars (const struct block
*block
,
1999 iterate_over_block_arg_local_vars_cb cb
,
2004 iterate_over_block_locals (block
, cb
, cb_data
);
2005 /* After handling the function's top-level block, stop. Don't
2006 continue to its superblock, the block of per-file
2008 if (BLOCK_FUNCTION (block
))
2010 block
= BLOCK_SUPERBLOCK (block
);
2014 /* Data to be passed around in the calls to the locals and args
2017 struct print_variable_and_value_data
2019 struct frame_id frame_id
;
2021 struct ui_file
*stream
;
2025 /* The callback for the locals and args iterators. */
2028 do_print_variable_and_value (const char *print_name
,
2032 struct print_variable_and_value_data
*p
2033 = (struct print_variable_and_value_data
*) cb_data
;
2034 struct frame_info
*frame
;
2036 frame
= frame_find_by_id (p
->frame_id
);
2039 warning (_("Unable to restore previously selected frame."));
2043 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2045 /* print_variable_and_value invalidates FRAME. */
2048 p
->values_printed
= 1;
2051 /* Print all variables from the innermost up to the function block of FRAME.
2052 Print them with values to STREAM indented by NUM_TABS.
2054 This function will invalidate FRAME. */
2057 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2058 struct ui_file
*stream
)
2060 struct print_variable_and_value_data cb_data
;
2061 const struct block
*block
;
2063 struct gdb_exception except
= exception_none
;
2065 if (!get_frame_pc_if_available (frame
, &pc
))
2067 fprintf_filtered (stream
,
2068 _("PC unavailable, cannot determine locals.\n"));
2072 block
= get_frame_block (frame
, 0);
2075 fprintf_filtered (stream
, "No symbol table info available.\n");
2079 cb_data
.frame_id
= get_frame_id (frame
);
2080 cb_data
.num_tabs
= 4 * num_tabs
;
2081 cb_data
.stream
= stream
;
2082 cb_data
.values_printed
= 0;
2084 /* Temporarily change the selected frame to the given FRAME.
2085 This allows routines that rely on the selected frame instead
2086 of being given a frame as parameter to use the correct frame. */
2087 select_frame (frame
);
2091 iterate_over_block_local_vars (block
,
2092 do_print_variable_and_value
,
2095 CATCH (ex
, RETURN_MASK_ALL
)
2101 /* Restore the selected frame, and then rethrow if there was a problem. */
2102 select_frame (frame_find_by_id (cb_data
.frame_id
));
2103 if (except
.reason
< 0)
2104 throw_exception (except
);
2106 /* do_print_variable_and_value invalidates FRAME. */
2109 if (!cb_data
.values_printed
)
2110 fprintf_filtered (stream
, _("No locals.\n"));
2114 info_locals_command (const char *args
, int from_tty
)
2116 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2120 /* Iterate over all the argument variables in block B.
2122 Returns 1 if any argument was walked; 0 otherwise. */
2125 iterate_over_block_arg_vars (const struct block
*b
,
2126 iterate_over_block_arg_local_vars_cb cb
,
2129 struct block_iterator iter
;
2130 struct symbol
*sym
, *sym2
;
2132 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2134 /* Don't worry about things which aren't arguments. */
2135 if (SYMBOL_IS_ARGUMENT (sym
))
2137 /* We have to look up the symbol because arguments can have
2138 two entries (one a parameter, one a local) and the one we
2139 want is the local, which lookup_symbol will find for us.
2140 This includes gcc1 (not gcc2) on the sparc when passing a
2141 small structure and gcc2 when the argument type is float
2142 and it is passed as a double and converted to float by
2143 the prologue (in the latter case the type of the LOC_ARG
2144 symbol is double and the type of the LOC_LOCAL symbol is
2145 float). There are also LOC_ARG/LOC_REGISTER pairs which
2146 are not combined in symbol-reading. */
2148 sym2
= lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym
),
2149 b
, VAR_DOMAIN
).symbol
;
2150 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2155 /* Print all argument variables of the function of FRAME.
2156 Print them with values to STREAM.
2158 This function will invalidate FRAME. */
2161 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2163 struct print_variable_and_value_data cb_data
;
2164 struct symbol
*func
;
2167 if (!get_frame_pc_if_available (frame
, &pc
))
2169 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2173 func
= get_frame_function (frame
);
2176 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2180 cb_data
.frame_id
= get_frame_id (frame
);
2181 cb_data
.num_tabs
= 0;
2182 cb_data
.stream
= gdb_stdout
;
2183 cb_data
.values_printed
= 0;
2185 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2186 do_print_variable_and_value
, &cb_data
);
2188 /* do_print_variable_and_value invalidates FRAME. */
2191 if (!cb_data
.values_printed
)
2192 fprintf_filtered (stream
, _("No arguments.\n"));
2196 info_args_command (const char *ignore
, int from_tty
)
2198 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2202 /* Select frame FRAME. Also print the stack frame and show the source
2203 if this is the tui version. */
2205 select_and_print_frame (struct frame_info
*frame
)
2207 select_frame (frame
);
2209 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2212 /* Return the symbol-block in which the selected frame is executing.
2213 Can return zero under various legitimate circumstances.
2215 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2216 code address within the block returned. We use this to decide
2217 which macros are in scope. */
2219 const struct block
*
2220 get_selected_block (CORE_ADDR
*addr_in_block
)
2222 if (!has_stack_frames ())
2225 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2228 /* Find a frame a certain number of levels away from FRAME.
2229 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2230 Positive means go to earlier frames (up); negative, the reverse.
2231 The int that contains the number of levels is counted toward
2232 zero as the frames for those levels are found.
2233 If the top or bottom frame is reached, that frame is returned,
2234 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2235 how much farther the original request asked to go. */
2238 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2240 /* Going up is simple: just call get_prev_frame enough times or
2241 until the initial frame is reached. */
2242 while (*level_offset_ptr
> 0)
2244 struct frame_info
*prev
= get_prev_frame (frame
);
2248 (*level_offset_ptr
)--;
2252 /* Going down is just as simple. */
2253 while (*level_offset_ptr
< 0)
2255 struct frame_info
*next
= get_next_frame (frame
);
2259 (*level_offset_ptr
)++;
2266 /* The "select_frame" command. With no argument this is a NOP.
2267 Select the frame at level LEVEL_EXP if it is a valid level.
2268 Otherwise, treat LEVEL_EXP as an address expression and select it.
2270 See parse_frame_specification for more info on proper frame
2274 select_frame_command (const char *level_exp
, int from_tty
)
2276 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2278 select_frame (parse_frame_specification (level_exp
, NULL
));
2279 if (get_selected_frame_if_set () != prev_frame
)
2280 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2283 /* The "frame" command. With no argument, print the selected frame
2284 briefly. With an argument, behave like select_frame and then print
2285 the selected frame. */
2288 frame_command (const char *level_exp
, int from_tty
)
2290 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2292 select_frame (parse_frame_specification (level_exp
, NULL
));
2293 if (get_selected_frame_if_set () != prev_frame
)
2294 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2296 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
2299 /* Select the frame up one or COUNT_EXP stack levels from the
2300 previously selected frame, and print it briefly. */
2303 up_silently_base (const char *count_exp
)
2305 struct frame_info
*frame
;
2309 count
= parse_and_eval_long (count_exp
);
2311 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2312 if (count
!= 0 && count_exp
== NULL
)
2313 error (_("Initial frame selected; you cannot go up."));
2314 select_frame (frame
);
2318 up_silently_command (const char *count_exp
, int from_tty
)
2320 up_silently_base (count_exp
);
2324 up_command (const char *count_exp
, int from_tty
)
2326 up_silently_base (count_exp
);
2327 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2330 /* Select the frame down one or COUNT_EXP stack levels from the previously
2331 selected frame, and print it briefly. */
2334 down_silently_base (const char *count_exp
)
2336 struct frame_info
*frame
;
2340 count
= -parse_and_eval_long (count_exp
);
2342 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2343 if (count
!= 0 && count_exp
== NULL
)
2345 /* We only do this if COUNT_EXP is not specified. That way
2346 "down" means to really go down (and let me know if that is
2347 impossible), but "down 9999" can be used to mean go all the
2348 way down without getting an error. */
2350 error (_("Bottom (innermost) frame selected; you cannot go down."));
2353 select_frame (frame
);
2357 down_silently_command (const char *count_exp
, int from_tty
)
2359 down_silently_base (count_exp
);
2363 down_command (const char *count_exp
, int from_tty
)
2365 down_silently_base (count_exp
);
2366 gdb::observers::user_selected_context_changed
.notify (USER_SELECTED_FRAME
);
2370 return_command (const char *retval_exp
, int from_tty
)
2372 /* Initialize it just to avoid a GCC false warning. */
2373 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2374 struct frame_info
*thisframe
;
2375 struct gdbarch
*gdbarch
;
2376 struct symbol
*thisfun
;
2377 struct value
*return_value
= NULL
;
2378 struct value
*function
= NULL
;
2379 const char *query_prefix
= "";
2381 thisframe
= get_selected_frame ("No selected frame.");
2382 thisfun
= get_frame_function (thisframe
);
2383 gdbarch
= get_frame_arch (thisframe
);
2385 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2386 error (_("Can not force return from an inlined function."));
2388 /* Compute the return value. If the computation triggers an error,
2389 let it bail. If the return type can't be handled, set
2390 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2394 expression_up retval_expr
= parse_expression (retval_exp
);
2395 struct type
*return_type
= NULL
;
2397 /* Compute the return value. Should the computation fail, this
2398 call throws an error. */
2399 return_value
= evaluate_expression (retval_expr
.get ());
2401 /* Cast return value to the return type of the function. Should
2402 the cast fail, this call throws an error. */
2403 if (thisfun
!= NULL
)
2404 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2405 if (return_type
== NULL
)
2407 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2408 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2409 error (_("Return value type not available for selected "
2411 "Please use an explicit cast of the value to return."));
2412 return_type
= value_type (return_value
);
2414 return_type
= check_typedef (return_type
);
2415 return_value
= value_cast (return_type
, return_value
);
2417 /* Make sure the value is fully evaluated. It may live in the
2418 stack frame we're about to pop. */
2419 if (value_lazy (return_value
))
2420 value_fetch_lazy (return_value
);
2422 if (thisfun
!= NULL
)
2423 function
= read_var_value (thisfun
, NULL
, thisframe
);
2425 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2426 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2427 /* If the return-type is "void", don't try to find the
2428 return-value's location. However, do still evaluate the
2429 return expression so that, even when the expression result
2430 is discarded, side effects such as "return i++" still
2432 return_value
= NULL
;
2433 else if (thisfun
!= NULL
)
2435 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2436 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2437 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2439 query_prefix
= "The location at which to store the "
2440 "function's return value is unknown.\n"
2441 "If you continue, the return value "
2442 "that you specified will be ignored.\n";
2443 return_value
= NULL
;
2448 /* Does an interactive user really want to do this? Include
2449 information, such as how well GDB can handle the return value, in
2450 the query message. */
2455 if (thisfun
== NULL
)
2456 confirmed
= query (_("%sMake selected stack frame return now? "),
2460 if (TYPE_NO_RETURN (thisfun
->type
))
2461 warning (_("Function does not return normally to caller."));
2462 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2463 SYMBOL_PRINT_NAME (thisfun
));
2466 error (_("Not confirmed"));
2469 /* Discard the selected frame and all frames inner-to it. */
2470 frame_pop (get_selected_frame (NULL
));
2472 /* Store RETURN_VALUE in the just-returned register set. */
2473 if (return_value
!= NULL
)
2475 struct type
*return_type
= value_type (return_value
);
2476 struct gdbarch
*gdbarch
= get_current_regcache ()->arch ();
2478 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2479 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2480 gdbarch_return_value (gdbarch
, function
, return_type
,
2481 get_current_regcache (), NULL
/*read*/,
2482 value_contents (return_value
) /*write*/);
2485 /* If we are at the end of a call dummy now, pop the dummy frame
2487 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2488 frame_pop (get_current_frame ());
2490 select_frame (get_current_frame ());
2491 /* If interactive, print the frame that is now current. */
2493 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2496 /* Sets the scope to input function name, provided that the function
2497 is within the current stack frame. */
2499 struct function_bounds
2501 CORE_ADDR low
, high
;
2505 func_command (const char *arg
, int from_tty
)
2507 struct frame_info
*frame
;
2514 frame
= get_current_frame ();
2515 std::vector
<symtab_and_line
> sals
2516 = decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2517 gdb::def_vector
<function_bounds
> func_bounds (sals
.size ());
2518 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2520 if (sals
[i
].pspace
!= current_program_space
)
2521 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2522 else if (sals
[i
].pc
== 0
2523 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2524 &func_bounds
[i
].low
,
2525 &func_bounds
[i
].high
) == 0)
2527 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2533 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2534 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2535 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2539 frame
= find_relative_frame (frame
, &level
);
2542 while (!found
&& level
== 0);
2545 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2546 else if (frame
!= get_selected_frame (NULL
))
2547 select_and_print_frame (frame
);
2551 _initialize_stack (void)
2553 add_com ("return", class_stack
, return_command
, _("\
2554 Make selected stack frame return to its caller.\n\
2555 Control remains in the debugger, but when you continue\n\
2556 execution will resume in the frame above the one now selected.\n\
2557 If an argument is given, it is an expression for the value to return."));
2559 add_com ("up", class_stack
, up_command
, _("\
2560 Select and print stack frame that called this one.\n\
2561 An argument says how many frames up to go."));
2562 add_com ("up-silently", class_support
, up_silently_command
, _("\
2563 Same as the `up' command, but does not print anything.\n\
2564 This is useful in command scripts."));
2566 add_com ("down", class_stack
, down_command
, _("\
2567 Select and print stack frame called by this one.\n\
2568 An argument says how many frames down to go."));
2569 add_com_alias ("do", "down", class_stack
, 1);
2570 add_com_alias ("dow", "down", class_stack
, 1);
2571 add_com ("down-silently", class_support
, down_silently_command
, _("\
2572 Same as the `down' command, but does not print anything.\n\
2573 This is useful in command scripts."));
2575 add_com ("frame", class_stack
, frame_command
, _("\
2576 Select and print a stack frame.\nWith no argument, \
2577 print the selected stack frame. (See also \"info frame\").\n\
2578 An argument specifies the frame to select.\n\
2579 It can be a stack frame number or the address of the frame.\n"));
2581 add_com_alias ("f", "frame", class_stack
, 1);
2583 add_com_suppress_notification ("select-frame", class_stack
, select_frame_command
, _("\
2584 Select a stack frame without printing anything.\n\
2585 An argument specifies the frame to select.\n\
2586 It can be a stack frame number or the address of the frame.\n"),
2587 &cli_suppress_notification
.user_selected_context
);
2589 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2590 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2591 With a negative argument, print outermost -COUNT frames.\nUse of the \
2592 'full' qualifier also prints the values of the local variables.\n\
2593 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2594 on this backtrace.\n"));
2595 add_com_alias ("bt", "backtrace", class_stack
, 0);
2597 add_com_alias ("where", "backtrace", class_alias
, 0);
2598 add_info ("stack", backtrace_command
,
2599 _("Backtrace of the stack, or innermost COUNT frames."));
2600 add_info_alias ("s", "stack", 1);
2601 add_info ("frame", info_frame_command
,
2602 _("All about selected stack frame, or frame at ADDR."));
2603 add_info_alias ("f", "frame", 1);
2604 add_info ("locals", info_locals_command
,
2605 _("Local variables of current stack frame."));
2606 add_info ("args", info_args_command
,
2607 _("Argument variables of current stack frame."));
2610 add_com ("func", class_stack
, func_command
, _("\
2611 Select the stack frame that contains <func>.\n\
2612 Usage: func <name>\n"));
2614 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2615 print_frame_arguments_choices
, &print_frame_arguments
,
2616 _("Set printing of non-scalar frame arguments"),
2617 _("Show printing of non-scalar frame arguments"),
2618 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2620 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2621 &print_raw_frame_arguments
, _("\
2622 Set whether to print frame arguments in raw form."), _("\
2623 Show whether to print frame arguments in raw form."), _("\
2624 If set, frame arguments are printed in raw form, bypassing any\n\
2625 pretty-printers for that value."),
2627 &setprintrawlist
, &showprintrawlist
);
2629 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2630 &disassemble_next_line
, _("\
2631 Set whether to disassemble next source line or insn when execution stops."),
2633 Show whether to disassemble next source line or insn when execution stops."),
2635 If ON, GDB will display disassembly of the next source line, in addition\n\
2636 to displaying the source line itself. If the next source line cannot\n\
2637 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2638 will display disassembly of next instruction instead of showing the\n\
2640 If AUTO, display disassembly of next instruction only if the source line\n\
2641 cannot be displayed.\n\
2642 If OFF (which is the default), never display the disassembly of the next\n\
2645 show_disassemble_next_line
,
2646 &setlist
, &showlist
);
2647 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2649 add_setshow_enum_cmd ("entry-values", class_stack
,
2650 print_entry_values_choices
, &print_entry_values
,
2651 _("Set printing of function arguments at function "
2653 _("Show printing of function arguments at function "
2656 GDB can sometimes determine the values of function arguments at entry,\n\
2657 in addition to their current values. This option tells GDB whether\n\
2658 to print the current value, the value at entry (marked as val@entry),\n\
2659 or both. Note that one or both of these values may be <optimized out>."),
2660 NULL
, NULL
, &setprintlist
, &showprintlist
);