1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2005, 2007-2012 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 "exceptions.h"
40 #include "reggroups.h"
44 #include "gdbthread.h"
45 #include "cp-support.h"
47 #include "inline-frame.h"
50 #include "gdb_assert.h"
52 #include "gdb_string.h"
57 void (*deprecated_selected_frame_level_changed_hook
) (int);
59 /* The possible choices of "set print frame-arguments", and the value
62 static const char *const print_frame_arguments_choices
[] =
63 {"all", "scalars", "none", NULL
};
64 static const char *print_frame_arguments
= "scalars";
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 /* Zero means do things normally; we are interacting directly with the
105 user. One means print the full filename and linenumber when a
106 frame is printed, and do so in a format emacs18/emacs19.22 can
107 parse. Two means print similar annotations, but in many more
108 cases and in a slightly different syntax. */
110 int annotation_level
= 0;
112 /* These variables hold the last symtab and line we displayed to the user.
113 * This is where we insert a breakpoint or a skiplist entry by default. */
114 static int last_displayed_sal_valid
= 0;
115 static struct program_space
*last_displayed_pspace
= 0;
116 static CORE_ADDR last_displayed_addr
= 0;
117 static struct symtab
*last_displayed_symtab
= 0;
118 static int last_displayed_line
= 0;
121 /* Return 1 if we should display the address in addition to the location,
122 because we are in the middle of a statement. */
125 frame_show_address (struct frame_info
*frame
,
126 struct symtab_and_line sal
)
128 /* If there is a line number, but no PC, then there is no location
129 information associated with this sal. The only way that should
130 happen is for the call sites of inlined functions (SAL comes from
131 find_frame_sal). Otherwise, we would have some PC range if the
132 SAL came from a line table. */
133 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
135 if (get_next_frame (frame
) == NULL
)
136 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
138 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
142 return get_frame_pc (frame
) != sal
.pc
;
145 /* Show or print a stack frame FRAME briefly. The output is format
146 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
147 relative level, function name, argument list, and file name and
148 line number. If the frame's PC is not at the beginning of the
149 source line, the actual PC is printed at the beginning. */
152 print_stack_frame (struct frame_info
*frame
, int print_level
,
153 enum print_what print_what
)
155 volatile struct gdb_exception e
;
157 /* For mi, alway print location and address. */
158 if (ui_out_is_mi_like_p (current_uiout
))
159 print_what
= LOC_AND_ADDRESS
;
161 TRY_CATCH (e
, RETURN_MASK_ERROR
)
163 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
165 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
166 set_current_sal_from_frame (frame
, center
);
170 /* Print nameless arguments of frame FRAME on STREAM, where START is
171 the offset of the first nameless argument, and NUM is the number of
172 nameless arguments to print. FIRST is nonzero if this is the first
173 argument (not just the first nameless argument). */
176 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
177 int first
, struct ui_file
*stream
)
179 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
180 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
185 for (i
= 0; i
< num
; i
++)
188 argsaddr
= get_frame_args_address (frame
);
191 arg_value
= read_memory_integer (argsaddr
+ start
,
192 sizeof (int), byte_order
);
194 fprintf_filtered (stream
, ", ");
195 fprintf_filtered (stream
, "%ld", arg_value
);
197 start
+= sizeof (int);
201 /* Print single argument of inferior function. ARG must be already
204 Errors are printed as if they would be the parameter value. Use zeroed ARG
205 iff it should not be printed accoring to user settings. */
208 print_frame_arg (const struct frame_arg
*arg
)
210 struct ui_out
*uiout
= current_uiout
;
211 volatile struct gdb_exception except
;
212 struct cleanup
*old_chain
;
213 struct ui_stream
*stb
;
215 stb
= ui_out_stream_new (uiout
);
216 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
218 gdb_assert (!arg
->val
|| !arg
->error
);
219 gdb_assert (arg
->entry_kind
== print_entry_values_no
220 || arg
->entry_kind
== print_entry_values_only
221 || (!ui_out_is_mi_like_p (uiout
)
222 && arg
->entry_kind
== print_entry_values_compact
));
224 annotate_arg_begin ();
226 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
227 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
228 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
229 if (arg
->entry_kind
== print_entry_values_compact
)
231 /* It is OK to provide invalid MI-like stream as with
232 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
233 fputs_filtered ("=", stb
->stream
);
235 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
236 SYMBOL_LANGUAGE (arg
->sym
),
237 DMGL_PARAMS
| DMGL_ANSI
);
239 if (arg
->entry_kind
== print_entry_values_only
240 || arg
->entry_kind
== print_entry_values_compact
)
241 fputs_filtered ("@entry", stb
->stream
);
242 ui_out_field_stream (uiout
, "name", stb
);
243 annotate_arg_name_end ();
244 ui_out_text (uiout
, "=");
246 if (!arg
->val
&& !arg
->error
)
247 ui_out_text (uiout
, "...");
251 except
.message
= arg
->error
;
254 /* TRY_CATCH has two statements, wrap it in a block. */
256 TRY_CATCH (except
, RETURN_MASK_ERROR
)
258 const struct language_defn
*language
;
259 struct value_print_options opts
;
261 /* Avoid value_print because it will deref ref parameters. We
262 just want to print their addresses. Print ??? for args whose
263 address we do not know. We pass 2 as "recurse" to val_print
264 because our standard indentation here is 4 spaces, and
265 val_print indents 2 for each recurse. */
267 annotate_arg_value (value_type (arg
->val
));
269 /* Use the appropriate language to display our symbol, unless the
270 user forced the language to a specific language. */
271 if (language_mode
== language_mode_auto
)
272 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
274 language
= current_language
;
276 get_raw_print_options (&opts
);
279 /* True in "summary" mode, false otherwise. */
280 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
282 common_val_print (arg
->val
, stb
->stream
, 2, &opts
, language
);
286 fprintf_filtered (stb
->stream
, _("<error reading variable: %s>"),
290 ui_out_field_stream (uiout
, "value", stb
);
292 /* Aleo invoke ui_out_tuple_end. */
293 do_cleanups (old_chain
);
298 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
299 responsible for xfree of ARGP->ERROR. This function never throws an
303 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
304 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
306 struct value
*val
= NULL
, *entryval
= NULL
;
307 char *val_error
= NULL
, *entryval_error
= NULL
;
309 volatile struct gdb_exception except
;
311 if (print_entry_values
!= print_entry_values_only
312 && print_entry_values
!= print_entry_values_preferred
)
314 TRY_CATCH (except
, RETURN_MASK_ERROR
)
316 val
= read_var_value (sym
, frame
);
320 val_error
= alloca (strlen (except
.message
) + 1);
321 strcpy (val_error
, except
.message
);
325 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
326 && print_entry_values
!= print_entry_values_no
327 && (print_entry_values
!= print_entry_values_if_needed
328 || !val
|| value_optimized_out (val
)))
330 TRY_CATCH (except
, RETURN_MASK_ERROR
)
332 const struct symbol_computed_ops
*ops
;
334 ops
= SYMBOL_COMPUTED_OPS (sym
);
335 entryval
= ops
->read_variable_at_entry (sym
, frame
);
339 entryval_error
= alloca (strlen (except
.message
) + 1);
340 strcpy (entryval_error
, except
.message
);
343 if (except
.error
== NO_ENTRY_VALUE_ERROR
344 || (entryval
&& value_optimized_out (entryval
)))
347 entryval_error
= NULL
;
350 if (print_entry_values
== print_entry_values_compact
351 || print_entry_values
== print_entry_values_default
)
353 /* For MI do not try to use print_entry_values_compact for ARGP. */
355 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
357 unsigned len
= TYPE_LENGTH (value_type (val
));
359 if (!value_optimized_out (val
) && value_lazy (val
))
360 value_fetch_lazy (val
);
361 if (!value_optimized_out (val
) && value_lazy (entryval
))
362 value_fetch_lazy (entryval
);
363 if (!value_optimized_out (val
)
364 && value_available_contents_eq (val
, 0, entryval
, 0, len
))
366 /* Initialize it just to avoid a GCC false warning. */
367 struct value
*val_deref
= NULL
, *entryval_deref
;
369 /* DW_AT_GNU_call_site_value does match with the current
370 value. If it is a reference still try to verify if
371 dereferenced DW_AT_GNU_call_site_data_value does not
374 TRY_CATCH (except
, RETURN_MASK_ERROR
)
378 val_deref
= coerce_ref (val
);
379 if (value_lazy (val_deref
))
380 value_fetch_lazy (val_deref
);
381 len_deref
= TYPE_LENGTH (value_type (val_deref
));
383 entryval_deref
= coerce_ref (entryval
);
384 if (value_lazy (entryval_deref
))
385 value_fetch_lazy (entryval_deref
);
387 /* If the reference addresses match but dereferenced
388 content does not match print them. */
390 && value_available_contents_eq (val_deref
, 0,
396 /* Value was not a reference; and its content matches. */
397 if (val
== val_deref
)
399 /* If the dereferenced content could not be fetched do not
401 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
403 else if (except
.message
)
405 entryval_error
= alloca (strlen (except
.message
) + 1);
406 strcpy (entryval_error
, except
.message
);
414 /* Try to remove possibly duplicate error message for ENTRYARGP even
417 if (val_error
&& entryval_error
418 && strcmp (val_error
, entryval_error
) == 0)
420 entryval_error
= NULL
;
422 /* Do not se VAL_EQUAL as the same error message may be shown for
423 the entry value even if no entry values are present in the
429 if (entryval
== NULL
)
431 if (print_entry_values
== print_entry_values_preferred
)
433 TRY_CATCH (except
, RETURN_MASK_ERROR
)
435 val
= read_var_value (sym
, frame
);
439 val_error
= alloca (strlen (except
.message
) + 1);
440 strcpy (val_error
, except
.message
);
443 if (print_entry_values
== print_entry_values_only
444 || print_entry_values
== print_entry_values_both
445 || (print_entry_values
== print_entry_values_preferred
446 && (!val
|| value_optimized_out (val
))))
447 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
449 if ((print_entry_values
== print_entry_values_compact
450 || print_entry_values
== print_entry_values_if_needed
451 || print_entry_values
== print_entry_values_preferred
)
452 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
460 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
461 if (!val
&& !val_error
)
462 argp
->entry_kind
= print_entry_values_only
;
463 else if ((print_entry_values
== print_entry_values_compact
464 || print_entry_values
== print_entry_values_default
) && val_equal
)
466 argp
->entry_kind
= print_entry_values_compact
;
467 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
470 argp
->entry_kind
= print_entry_values_no
;
472 entryargp
->sym
= sym
;
473 entryargp
->val
= entryval
;
474 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
475 if (!entryval
&& !entryval_error
)
476 entryargp
->entry_kind
= print_entry_values_no
;
478 entryargp
->entry_kind
= print_entry_values_only
;
481 /* Print the arguments of frame FRAME on STREAM, given the function
482 FUNC running in that frame (as a symbol), where NUM is the number
483 of arguments according to the stack frame (or -1 if the number of
484 arguments is unknown). */
486 /* Note that currently the "number of arguments according to the
487 stack frame" is only known on VAX where i refers to the "number of
488 ints of arguments according to the stack frame". */
491 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
492 int num
, struct ui_file
*stream
)
494 struct ui_out
*uiout
= current_uiout
;
496 /* Offset of next stack argument beyond the one we have seen that is
497 at the highest offset, or -1 if we haven't come to a stack
499 long highest_offset
= -1;
500 /* Number of ints of arguments that we have printed so far. */
501 int args_printed
= 0;
502 struct cleanup
*old_chain
, *list_chain
;
503 struct ui_stream
*stb
;
504 /* True if we should print arguments, false otherwise. */
505 int print_args
= strcmp (print_frame_arguments
, "none");
506 /* True in "summary" mode, false otherwise. */
507 int summary
= !strcmp (print_frame_arguments
, "scalars");
509 stb
= ui_out_stream_new (uiout
);
510 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
514 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
515 struct dict_iterator iter
;
518 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
520 struct frame_arg arg
, entryarg
;
524 /* Keep track of the highest stack argument offset seen, and
525 skip over any kinds of symbols we don't care about. */
527 if (!SYMBOL_IS_ARGUMENT (sym
))
530 switch (SYMBOL_CLASS (sym
))
535 long current_offset
= SYMBOL_VALUE (sym
);
536 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
538 /* Compute address of next argument by adding the size of
539 this argument and rounding to an int boundary. */
541 ((current_offset
+ arg_size
+ sizeof (int) - 1)
542 & ~(sizeof (int) - 1));
544 /* If this is the highest offset seen yet, set
546 if (highest_offset
== -1
547 || (current_offset
> highest_offset
))
548 highest_offset
= current_offset
;
550 /* Add the number of ints we're about to print to
552 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
555 /* We care about types of symbols, but don't need to
556 keep track of stack offsets in them. */
558 case LOC_REGPARM_ADDR
:
560 case LOC_OPTIMIZED_OUT
:
565 /* We have to look up the symbol because arguments can have
566 two entries (one a parameter, one a local) and the one we
567 want is the local, which lookup_symbol will find for us.
568 This includes gcc1 (not gcc2) on SPARC when passing a
569 small structure and gcc2 when the argument type is float
570 and it is passed as a double and converted to float by
571 the prologue (in the latter case the type of the LOC_ARG
572 symbol is double and the type of the LOC_LOCAL symbol is
574 /* But if the parameter name is null, don't try it. Null
575 parameter names occur on the RS/6000, for traceback
576 tables. FIXME, should we even print them? */
578 if (*SYMBOL_LINKAGE_NAME (sym
))
582 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
583 b
, VAR_DOMAIN
, NULL
);
584 gdb_assert (nsym
!= NULL
);
585 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
586 && !SYMBOL_IS_ARGUMENT (nsym
))
588 /* There is a LOC_ARG/LOC_REGISTER pair. This means
589 that it was passed on the stack and loaded into a
590 register, or passed in a register and stored in a
591 stack slot. GDB 3.x used the LOC_ARG; GDB
592 4.0-4.11 used the LOC_REGISTER.
594 Reasons for using the LOC_ARG:
596 (1) Because find_saved_registers may be slow for
599 (2) Because registers are often re-used and stack
600 slots rarely (never?) are. Therefore using
601 the stack slot is much less likely to print
604 Reasons why we might want to use the LOC_REGISTER:
606 (1) So that the backtrace prints the same value
607 as "print foo". I see no compelling reason
608 why this needs to be the case; having the
609 backtrace print the value which was passed
610 in, and "print foo" print the value as
611 modified within the called function, makes
614 Additional note: It might be nice if "info args"
615 displayed both values.
617 One more note: There is a case with SPARC
618 structure passing where we need to use the
619 LOC_REGISTER, but this is dealt with by creating
620 a single LOC_REGPARM in symbol reading. */
622 /* Leave sym (the LOC_ARG) alone. */
629 /* Print the current arg. */
631 ui_out_text (uiout
, ", ");
632 ui_out_wrap_hint (uiout
, " ");
636 memset (&arg
, 0, sizeof (arg
));
638 arg
.entry_kind
= print_entry_values_no
;
639 memset (&entryarg
, 0, sizeof (entryarg
));
641 entryarg
.entry_kind
= print_entry_values_no
;
644 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
646 if (arg
.entry_kind
!= print_entry_values_only
)
647 print_frame_arg (&arg
);
649 if (entryarg
.entry_kind
!= print_entry_values_no
)
651 if (arg
.entry_kind
!= print_entry_values_only
)
653 ui_out_text (uiout
, ", ");
654 ui_out_wrap_hint (uiout
, " ");
657 print_frame_arg (&entryarg
);
661 xfree (entryarg
.error
);
667 /* Don't print nameless args in situations where we don't know
668 enough about the stack to find them. */
673 if (highest_offset
== -1)
674 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
676 start
= highest_offset
;
678 print_frame_nameless_args (frame
, start
, num
- args_printed
,
682 do_cleanups (old_chain
);
685 /* Set the current source and line to the location given by frame
686 FRAME, if possible. When CENTER is true, adjust so the relevant
687 line is in the center of the next 'list'. */
690 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
692 struct symtab_and_line sal
;
694 find_frame_sal (frame
, &sal
);
698 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
699 set_current_source_symtab_and_line (&sal
);
703 /* If ON, GDB will display disassembly of the next source line when
704 execution of the program being debugged stops.
705 If AUTO (which is the default), or there's no line info to determine
706 the source line of the next instruction, display disassembly of next
707 instruction instead. */
709 static enum auto_boolean disassemble_next_line
;
712 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
713 struct cmd_list_element
*c
,
716 fprintf_filtered (file
,
717 _("Debugger's willingness to use "
718 "disassemble-next-line is %s.\n"),
722 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
723 because it will be broken by filter sometime. */
726 do_gdb_disassembly (struct gdbarch
*gdbarch
,
727 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
729 volatile struct gdb_exception exception
;
731 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
733 gdb_disassembly (gdbarch
, current_uiout
, 0,
734 DISASSEMBLY_RAW_INSN
, how_many
,
737 if (exception
.reason
< 0)
739 /* If an exception was thrown while doing the disassembly, print
740 the error message, to give the user a clue of what happened. */
741 exception_print (gdb_stderr
, exception
);
745 /* Print information about frame FRAME. The output is format according
746 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
749 SRC_LINE: Print only source line.
750 LOCATION: Print only location.
751 LOC_AND_SRC: Print location and source line.
753 Used in "where" output, and to emit breakpoint or step
757 print_frame_info (struct frame_info
*frame
, int print_level
,
758 enum print_what print_what
, int print_args
)
760 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
761 struct symtab_and_line sal
;
764 struct ui_out
*uiout
= current_uiout
;
766 if (get_frame_type (frame
) == DUMMY_FRAME
767 || get_frame_type (frame
) == SIGTRAMP_FRAME
768 || get_frame_type (frame
) == ARCH_FRAME
)
770 struct cleanup
*uiout_cleanup
771 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
773 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
774 gdbarch
, get_frame_pc (frame
));
776 /* Do this regardless of SOURCE because we don't have any source
777 to list for this frame. */
780 ui_out_text (uiout
, "#");
781 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
782 frame_relative_level (frame
));
784 if (ui_out_is_mi_like_p (uiout
))
786 annotate_frame_address ();
787 ui_out_field_core_addr (uiout
, "addr",
788 gdbarch
, get_frame_pc (frame
));
789 annotate_frame_address_end ();
792 if (get_frame_type (frame
) == DUMMY_FRAME
)
794 annotate_function_call ();
795 ui_out_field_string (uiout
, "func", "<function called from gdb>");
797 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
799 annotate_signal_handler_caller ();
800 ui_out_field_string (uiout
, "func", "<signal handler called>");
802 else if (get_frame_type (frame
) == ARCH_FRAME
)
804 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
806 ui_out_text (uiout
, "\n");
807 annotate_frame_end ();
809 do_cleanups (uiout_cleanup
);
813 /* If FRAME is not the innermost frame, that normally means that
814 FRAME->pc points to *after* the call instruction, and we want to
815 get the line containing the call, never the next line. But if
816 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
817 next frame was not entered as the result of a call, and we want
818 to get the line containing FRAME->pc. */
819 find_frame_sal (frame
, &sal
);
821 location_print
= (print_what
== LOCATION
822 || print_what
== LOC_AND_ADDRESS
823 || print_what
== SRC_AND_LOC
);
825 if (location_print
|| !sal
.symtab
)
826 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
828 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
830 /* If disassemble-next-line is set to auto or on and doesn't have
831 the line debug messages for $pc, output the next instruction. */
832 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
833 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
834 && source_print
&& !sal
.symtab
)
835 do_gdb_disassembly (get_frame_arch (frame
), 1,
836 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
838 if (source_print
&& sal
.symtab
)
841 int mid_statement
= ((print_what
== SRC_LINE
)
842 && frame_show_address (frame
, sal
));
844 if (annotation_level
)
845 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
846 get_frame_pc (frame
));
849 if (deprecated_print_frame_info_listing_hook
)
850 deprecated_print_frame_info_listing_hook (sal
.symtab
,
855 struct value_print_options opts
;
857 get_user_print_options (&opts
);
858 /* We used to do this earlier, but that is clearly
859 wrong. This function is used by many different
860 parts of gdb, including normal_stop in infrun.c,
861 which uses this to print out the current PC
862 when we stepi/nexti into the middle of a source
863 line. Only the command line really wants this
864 behavior. Other UIs probably would like the
865 ability to decide for themselves if it is desired. */
866 if (opts
.addressprint
&& mid_statement
)
868 ui_out_field_core_addr (uiout
, "addr",
869 gdbarch
, get_frame_pc (frame
));
870 ui_out_text (uiout
, "\t");
873 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
877 /* If disassemble-next-line is set to on and there is line debug
878 messages, output assembly codes for next line. */
879 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
880 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
883 if (print_what
!= LOCATION
)
887 if (get_frame_pc_if_available (frame
, &pc
))
888 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
890 set_last_displayed_sal (0, 0, 0, 0, 0);
893 annotate_frame_end ();
895 gdb_flush (gdb_stdout
);
898 /* Remember the last symtab and line we displayed, which we use e.g.
899 * as the place to put a breakpoint when the `break' command is
900 * invoked with no arguments. */
903 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
904 CORE_ADDR addr
, struct symtab
*symtab
,
907 last_displayed_sal_valid
= valid
;
908 last_displayed_pspace
= pspace
;
909 last_displayed_addr
= addr
;
910 last_displayed_symtab
= symtab
;
911 last_displayed_line
= line
;
912 if (valid
&& pspace
== NULL
)
914 warning (_("Trying to set NULL pspace."));
915 clear_last_displayed_sal ();
919 /* Forget the last sal we displayed. */
922 clear_last_displayed_sal (void)
924 last_displayed_sal_valid
= 0;
925 last_displayed_pspace
= 0;
926 last_displayed_addr
= 0;
927 last_displayed_symtab
= 0;
928 last_displayed_line
= 0;
931 /* Is our record of the last sal we displayed valid? If not,
932 * the get_last_displayed_* functions will return NULL or 0, as
936 last_displayed_sal_is_valid (void)
938 return last_displayed_sal_valid
;
941 /* Get the pspace of the last sal we displayed, if it's valid. */
943 struct program_space
*
944 get_last_displayed_pspace (void)
946 if (last_displayed_sal_valid
)
947 return last_displayed_pspace
;
951 /* Get the address of the last sal we displayed, if it's valid. */
954 get_last_displayed_addr (void)
956 if (last_displayed_sal_valid
)
957 return last_displayed_addr
;
961 /* Get the symtab of the last sal we displayed, if it's valid. */
964 get_last_displayed_symtab (void)
966 if (last_displayed_sal_valid
)
967 return last_displayed_symtab
;
971 /* Get the line of the last sal we displayed, if it's valid. */
974 get_last_displayed_line (void)
976 if (last_displayed_sal_valid
)
977 return last_displayed_line
;
981 /* Get the last sal we displayed, if it's valid. */
984 get_last_displayed_sal (struct symtab_and_line
*sal
)
986 if (last_displayed_sal_valid
)
988 sal
->pspace
= last_displayed_pspace
;
989 sal
->pc
= last_displayed_addr
;
990 sal
->symtab
= last_displayed_symtab
;
991 sal
->line
= last_displayed_line
;
1003 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1004 corresponding to FRAME. */
1007 find_frame_funname (struct frame_info
*frame
, const char **funname
,
1008 enum language
*funlang
, struct symbol
**funcp
)
1010 struct symbol
*func
;
1013 *funlang
= language_unknown
;
1017 func
= get_frame_function (frame
);
1020 /* In certain pathological cases, the symtabs give the wrong
1021 function (when we are in the first function in a file which
1022 is compiled without debugging symbols, the previous function
1023 is compiled with debugging symbols, and the "foo.o" symbol
1024 that is supposed to tell us where the file with debugging
1025 symbols ends has been truncated by ar because it is longer
1026 than 15 characters). This also occurs if the user uses asm()
1027 to create a function but not stabs for it (in a file compiled
1030 So look in the minimal symbol tables as well, and if it comes
1031 up with a larger address for the function use that instead.
1032 I don't think this can ever cause any problems; there
1033 shouldn't be any minimal symbols in the middle of a function;
1034 if this is ever changed many parts of GDB will need to be
1035 changed (and we'll create a find_pc_minimal_function or some
1038 struct minimal_symbol
*msymbol
= NULL
;
1040 /* Don't attempt to do this for inlined functions, which do not
1041 have a corresponding minimal symbol. */
1042 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1044 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1047 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1048 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1050 /* We also don't know anything about the function besides
1051 its address and name. */
1053 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1054 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1058 *funname
= SYMBOL_PRINT_NAME (func
);
1059 *funlang
= SYMBOL_LANGUAGE (func
);
1062 if (*funlang
== language_cplus
)
1064 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1065 to display the demangled name that we already have
1066 stored in the symbol table, but we stored a version
1067 with DMGL_PARAMS turned on, and here we don't want to
1068 display parameters. So remove the parameters. */
1069 char *func_only
= cp_remove_params (*funname
);
1073 *funname
= func_only
;
1074 make_cleanup (xfree
, func_only
);
1081 struct minimal_symbol
*msymbol
;
1084 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1087 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1088 if (msymbol
!= NULL
)
1090 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1091 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1097 print_frame (struct frame_info
*frame
, int print_level
,
1098 enum print_what print_what
, int print_args
,
1099 struct symtab_and_line sal
)
1101 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1102 struct ui_out
*uiout
= current_uiout
;
1103 const char *funname
= NULL
;
1104 enum language funlang
= language_unknown
;
1105 struct ui_stream
*stb
;
1106 struct cleanup
*old_chain
, *list_chain
;
1107 struct value_print_options opts
;
1108 struct symbol
*func
;
1112 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1114 stb
= ui_out_stream_new (uiout
);
1115 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1117 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1119 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1122 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1126 ui_out_text (uiout
, "#");
1127 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1128 frame_relative_level (frame
));
1130 get_user_print_options (&opts
);
1131 if (opts
.addressprint
)
1133 || frame_show_address (frame
, sal
)
1134 || print_what
== LOC_AND_ADDRESS
)
1136 annotate_frame_address ();
1138 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1140 ui_out_field_string (uiout
, "addr", "<unavailable>");
1141 annotate_frame_address_end ();
1142 ui_out_text (uiout
, " in ");
1144 annotate_frame_function_name ();
1145 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
1146 funlang
, DMGL_ANSI
);
1147 ui_out_field_stream (uiout
, "func", stb
);
1148 ui_out_wrap_hint (uiout
, " ");
1149 annotate_frame_args ();
1151 ui_out_text (uiout
, " (");
1154 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1156 struct cleanup
*args_list_chain
;
1157 volatile struct gdb_exception e
;
1159 if (gdbarch_frame_num_args_p (gdbarch
))
1161 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1162 gdb_assert (numargs
>= 0);
1167 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1168 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1170 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1172 /* FIXME: ARGS must be a list. If one argument is a string it
1173 will have " that will not be properly escaped. */
1174 /* Invoke ui_out_tuple_end. */
1175 do_cleanups (args_list_chain
);
1178 ui_out_text (uiout
, ")");
1179 if (sal
.symtab
&& sal
.symtab
->filename
)
1181 annotate_frame_source_begin ();
1182 ui_out_wrap_hint (uiout
, " ");
1183 ui_out_text (uiout
, " at ");
1184 annotate_frame_source_file ();
1185 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1186 if (ui_out_is_mi_like_p (uiout
))
1188 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1190 if (fullname
!= NULL
)
1191 ui_out_field_string (uiout
, "fullname", fullname
);
1193 annotate_frame_source_file_end ();
1194 ui_out_text (uiout
, ":");
1195 annotate_frame_source_line ();
1196 ui_out_field_int (uiout
, "line", sal
.line
);
1197 annotate_frame_source_end ();
1200 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
1203 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1205 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1206 get_frame_pc (frame
));
1210 annotate_frame_where ();
1211 ui_out_wrap_hint (uiout
, " ");
1212 ui_out_text (uiout
, " from ");
1213 ui_out_field_string (uiout
, "from", lib
);
1217 /* do_cleanups will call ui_out_tuple_end() for us. */
1218 do_cleanups (list_chain
);
1219 ui_out_text (uiout
, "\n");
1220 do_cleanups (old_chain
);
1224 /* Read a frame specification in whatever the appropriate format is
1225 from FRAME_EXP. Call error(), printing MESSAGE, if the
1226 specification is in any way invalid (so this function never returns
1227 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1228 the default selected frame was used. */
1230 static struct frame_info
*
1231 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1232 int *selected_frame_p
)
1235 struct value
*args
[4];
1236 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1238 if (frame_exp
== NULL
)
1246 struct cleanup
*cleanup
;
1249 /* Skip leading white space, bail of EOL. */
1250 while (isspace (*frame_exp
))
1255 /* Parse the argument, extract it, save it. */
1257 *p
&& !isspace (*p
);
1259 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1261 cleanup
= make_cleanup (xfree
, addr_string
);
1263 /* NOTE: Parse and evaluate expression, but do not use
1264 functions such as parse_and_eval_long or
1265 parse_and_eval_address to also extract the value.
1266 Instead value_as_long and value_as_address are used.
1267 This avoids problems with expressions that contain
1269 if (numargs
>= ARRAY_SIZE (args
))
1270 error (_("Too many args in frame specification"));
1271 args
[numargs
++] = parse_and_eval (addr_string
);
1273 do_cleanups (cleanup
);
1277 /* If no args, default to the selected frame. */
1280 if (selected_frame_p
!= NULL
)
1281 (*selected_frame_p
) = 1;
1282 return get_selected_frame (message
);
1285 /* None of the remaining use the selected frame. */
1286 if (selected_frame_p
!= NULL
)
1287 (*selected_frame_p
) = 0;
1289 /* Assume the single arg[0] is an integer, and try using that to
1290 select a frame relative to current. */
1293 struct frame_info
*fid
;
1294 int level
= value_as_long (args
[0]);
1296 fid
= find_relative_frame (get_current_frame (), &level
);
1298 /* find_relative_frame was successful. */
1302 /* Convert each value into a corresponding address. */
1306 for (i
= 0; i
< numargs
; i
++)
1307 addrs
[i
] = value_as_address (args
[i
]);
1310 /* Assume that the single arg[0] is an address, use that to identify
1311 a frame with a matching ID. Should this also accept stack/pc or
1312 stack/pc/special. */
1315 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1316 struct frame_info
*fid
;
1318 /* If (s)he specifies the frame with an address, he deserves
1319 what (s)he gets. Still, give the highest one that matches.
1320 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1322 for (fid
= get_current_frame ();
1324 fid
= get_prev_frame (fid
))
1326 if (frame_id_eq (id
, get_frame_id (fid
)))
1328 struct frame_info
*prev_frame
;
1332 prev_frame
= get_prev_frame (fid
);
1334 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1343 /* We couldn't identify the frame as an existing frame, but
1344 perhaps we can create one with a single argument. */
1346 return create_new_frame (addrs
[0], 0);
1347 else if (numargs
== 2)
1348 return create_new_frame (addrs
[0], addrs
[1]);
1350 error (_("Too many args in frame specification"));
1353 static struct frame_info
*
1354 parse_frame_specification (char *frame_exp
)
1356 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1359 /* Print verbosely the selected frame or the frame at address
1360 ADDR_EXP. Absolutely all information in the frame is printed. */
1363 frame_info (char *addr_exp
, int from_tty
)
1365 struct frame_info
*fi
;
1366 struct symtab_and_line sal
;
1367 struct symbol
*func
;
1369 struct frame_info
*calling_frame_info
;
1371 const char *funname
= 0;
1372 enum language funlang
= language_unknown
;
1373 const char *pc_regname
;
1374 int selected_frame_p
;
1375 struct gdbarch
*gdbarch
;
1376 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1379 CORE_ADDR caller_pc
;
1381 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1382 gdbarch
= get_frame_arch (fi
);
1384 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1385 is not a good name. */
1386 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1387 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1388 easily not match that of the internal value returned by
1390 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1392 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1393 architectures will often have a hardware register called "pc",
1394 and that register's value, again, can easily not match
1398 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1399 find_frame_sal (fi
, &sal
);
1400 func
= get_frame_function (fi
);
1404 funname
= SYMBOL_PRINT_NAME (func
);
1405 funlang
= SYMBOL_LANGUAGE (func
);
1406 if (funlang
== language_cplus
)
1408 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1409 to display the demangled name that we already have
1410 stored in the symbol table, but we stored a version
1411 with DMGL_PARAMS turned on, and here we don't want to
1412 display parameters. So remove the parameters. */
1413 char *func_only
= cp_remove_params (funname
);
1417 funname
= func_only
;
1418 make_cleanup (xfree
, func_only
);
1422 else if (frame_pc_p
)
1424 struct minimal_symbol
*msymbol
;
1426 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1427 if (msymbol
!= NULL
)
1429 funname
= SYMBOL_PRINT_NAME (msymbol
);
1430 funlang
= SYMBOL_LANGUAGE (msymbol
);
1433 calling_frame_info
= get_prev_frame (fi
);
1435 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1437 printf_filtered (_("Stack level %d, frame at "),
1438 frame_relative_level (fi
));
1442 printf_filtered (_("Stack frame at "));
1444 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1445 printf_filtered (":\n");
1446 printf_filtered (" %s = ", pc_regname
);
1448 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1450 fputs_filtered ("<unavailable>", gdb_stdout
);
1455 printf_filtered (" in ");
1456 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1457 DMGL_ANSI
| DMGL_PARAMS
);
1461 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1462 puts_filtered ("; ");
1464 printf_filtered ("saved %s ", pc_regname
);
1465 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1466 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1468 fputs_filtered ("<unavailable>", gdb_stdout
);
1469 printf_filtered ("\n");
1471 if (calling_frame_info
== NULL
)
1473 enum unwind_stop_reason reason
;
1475 reason
= get_frame_unwind_stop_reason (fi
);
1476 if (reason
!= UNWIND_NO_REASON
)
1477 printf_filtered (_(" Outermost frame: %s\n"),
1478 frame_stop_reason_string (reason
));
1480 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1481 puts_filtered (" tail call frame");
1482 else if (get_frame_type (fi
) == INLINE_FRAME
)
1483 printf_filtered (" inlined into frame %d",
1484 frame_relative_level (get_prev_frame (fi
)));
1487 printf_filtered (" called by frame at ");
1488 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1491 if (get_next_frame (fi
) && calling_frame_info
)
1492 puts_filtered (",");
1494 if (get_next_frame (fi
))
1496 printf_filtered (" caller of frame at ");
1497 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1500 if (get_next_frame (fi
) || calling_frame_info
)
1501 puts_filtered ("\n");
1504 printf_filtered (" source language %s.\n",
1505 language_str (s
->language
));
1508 /* Address of the argument list for this frame, or 0. */
1509 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1510 /* Number of args for this frame, or -1 if unknown. */
1514 printf_filtered (" Arglist at unknown address.\n");
1517 printf_filtered (" Arglist at ");
1518 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1519 printf_filtered (",");
1521 if (!gdbarch_frame_num_args_p (gdbarch
))
1524 puts_filtered (" args: ");
1528 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1529 gdb_assert (numargs
>= 0);
1531 puts_filtered (" no args.");
1532 else if (numargs
== 1)
1533 puts_filtered (" 1 arg: ");
1535 printf_filtered (" %d args: ", numargs
);
1537 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1538 puts_filtered ("\n");
1542 /* Address of the local variables for this frame, or 0. */
1543 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1546 printf_filtered (" Locals at unknown address,");
1549 printf_filtered (" Locals at ");
1550 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1551 printf_filtered (",");
1555 /* Print as much information as possible on the location of all the
1558 enum lval_type lval
;
1567 /* The sp is special; what's displayed isn't the save address, but
1568 the value of the previous frame's sp. This is a legacy thing,
1569 at one stage the frame cached the previous frame's SP instead
1570 of its address, hence it was easiest to just display the cached
1572 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1574 /* Find out the location of the saved stack pointer with out
1575 actually evaluating it. */
1576 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1577 &optimized
, &unavailable
, &lval
, &addr
,
1579 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1581 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1582 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1583 gdb_byte value
[MAX_REGISTER_SIZE
];
1586 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1587 &optimized
, &unavailable
, &lval
, &addr
,
1589 /* NOTE: cagney/2003-05-22: This is assuming that the
1590 stack pointer was packed as an unsigned integer. That
1591 may or may not be valid. */
1592 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1593 printf_filtered (" Previous frame's sp is ");
1594 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1595 printf_filtered ("\n");
1598 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1600 printf_filtered (" Previous frame's sp at ");
1601 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1602 printf_filtered ("\n");
1605 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1607 printf_filtered (" Previous frame's sp in %s\n",
1608 gdbarch_register_name (gdbarch
, realnum
));
1611 /* else keep quiet. */
1615 numregs
= gdbarch_num_regs (gdbarch
)
1616 + gdbarch_num_pseudo_regs (gdbarch
);
1617 for (i
= 0; i
< numregs
; i
++)
1618 if (i
!= gdbarch_sp_regnum (gdbarch
)
1619 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1621 /* Find out the location of the saved register without
1622 fetching the corresponding value. */
1623 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1624 &lval
, &addr
, &realnum
, NULL
);
1625 /* For moment, only display registers that were saved on the
1627 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1630 puts_filtered (" Saved registers:\n ");
1632 puts_filtered (",");
1634 printf_filtered (" %s at ",
1635 gdbarch_register_name (gdbarch
, i
));
1636 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1640 if (count
|| need_nl
)
1641 puts_filtered ("\n");
1644 do_cleanups (back_to
);
1647 /* Print briefly all stack frames or just the innermost COUNT_EXP
1651 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1653 struct frame_info
*fi
;
1656 struct frame_info
*trailing
;
1659 if (!target_has_stack
)
1660 error (_("No stack."));
1662 /* The following code must do two things. First, it must set the
1663 variable TRAILING to the frame from which we should start
1664 printing. Second, it must set the variable count to the number
1665 of frames which we should print, or -1 if all of them. */
1666 trailing
= get_current_frame ();
1671 count
= parse_and_eval_long (count_exp
);
1674 struct frame_info
*current
;
1679 while (current
&& count
--)
1682 current
= get_prev_frame (current
);
1685 /* Will stop when CURRENT reaches the top of the stack.
1686 TRAILING will be COUNT below it. */
1690 trailing
= get_prev_frame (trailing
);
1691 current
= get_prev_frame (current
);
1703 /* Read in symbols for all of the frames. Need to do this in a
1704 separate pass so that "Reading in symbols for xxx" messages
1705 don't screw up the appearance of the backtrace. Also if
1706 people have strong opinions against reading symbols for
1707 backtrace this may have to be an option. */
1709 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1714 pc
= get_frame_address_in_block (fi
);
1715 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1719 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1723 /* Don't use print_stack_frame; if an error() occurs it probably
1724 means further attempts to backtrace would fail (on the other
1725 hand, perhaps the code does or could be fixed to make sure
1726 the frame->prev field gets set to NULL in that case). */
1727 print_frame_info (fi
, 1, LOCATION
, 1);
1729 print_frame_local_vars (fi
, 1, gdb_stdout
);
1731 /* Save the last frame to check for error conditions. */
1735 /* If we've stopped before the end, mention that. */
1737 printf_filtered (_("(More stack frames follow...)\n"));
1739 /* If we've run out of frames, and the reason appears to be an error
1740 condition, print it. */
1741 if (fi
== NULL
&& trailing
!= NULL
)
1743 enum unwind_stop_reason reason
;
1745 reason
= get_frame_unwind_stop_reason (trailing
);
1746 if (reason
>= UNWIND_FIRST_ERROR
)
1747 printf_filtered (_("Backtrace stopped: %s\n"),
1748 frame_stop_reason_string (reason
));
1753 backtrace_command (char *arg
, int from_tty
)
1755 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1756 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1763 argv
= gdb_buildargv (arg
);
1764 make_cleanup_freeargv (argv
);
1766 for (i
= 0; argv
[i
]; i
++)
1770 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1771 argv
[i
][j
] = tolower (argv
[i
][j
]);
1773 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1774 fulltrace_arg
= argc
;
1777 arglen
+= strlen (argv
[i
]);
1782 if (fulltrace_arg
>= 0)
1786 arg
= xmalloc (arglen
+ 1);
1787 make_cleanup (xfree
, arg
);
1789 for (i
= 0; i
< (argc
+ 1); i
++)
1791 if (i
!= fulltrace_arg
)
1793 strcat (arg
, argv
[i
]);
1803 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1805 do_cleanups (old_chain
);
1809 backtrace_full_command (char *arg
, int from_tty
)
1811 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1815 /* Iterate over the local variables of a block B, calling CB with
1819 iterate_over_block_locals (struct block
*b
,
1820 iterate_over_block_arg_local_vars_cb cb
,
1823 struct dict_iterator iter
;
1826 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1828 switch (SYMBOL_CLASS (sym
))
1834 if (SYMBOL_IS_ARGUMENT (sym
))
1836 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1840 /* Ignore symbols which are not locals. */
1847 /* Same, but print labels. */
1850 /* Commented out, as the code using this function has also been
1851 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1852 was commented out in the first place. The discussion introducing
1853 this change (2007-12-04: Support lexical blocks and function bodies
1854 that occupy non-contiguous address ranges) did not explain why
1855 this change was made. */
1857 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1858 int *have_default
, struct ui_file
*stream
)
1860 struct dict_iterator iter
;
1862 int values_printed
= 0;
1864 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1866 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1872 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1874 struct symtab_and_line sal
;
1875 struct value_print_options opts
;
1877 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1879 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1880 get_user_print_options (&opts
);
1881 if (opts
.addressprint
)
1883 fprintf_filtered (stream
, " ");
1884 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1887 fprintf_filtered (stream
, " in file %s, line %d\n",
1888 sal
.symtab
->filename
, sal
.line
);
1892 return values_printed
;
1896 /* Iterate over all the local variables in block B, including all its
1897 superblocks, stopping when the top-level block is reached. */
1900 iterate_over_block_local_vars (struct block
*block
,
1901 iterate_over_block_arg_local_vars_cb cb
,
1906 iterate_over_block_locals (block
, cb
, cb_data
);
1907 /* After handling the function's top-level block, stop. Don't
1908 continue to its superblock, the block of per-file
1910 if (BLOCK_FUNCTION (block
))
1912 block
= BLOCK_SUPERBLOCK (block
);
1916 /* Data to be passed around in the calls to the locals and args
1919 struct print_variable_and_value_data
1921 struct frame_info
*frame
;
1923 struct ui_file
*stream
;
1927 /* The callback for the locals and args iterators. */
1930 do_print_variable_and_value (const char *print_name
,
1934 struct print_variable_and_value_data
*p
= cb_data
;
1936 print_variable_and_value (print_name
, sym
,
1937 p
->frame
, p
->stream
, p
->num_tabs
);
1938 p
->values_printed
= 1;
1942 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1943 struct ui_file
*stream
)
1945 struct print_variable_and_value_data cb_data
;
1946 struct block
*block
;
1949 if (!get_frame_pc_if_available (frame
, &pc
))
1951 fprintf_filtered (stream
,
1952 _("PC unavailable, cannot determine locals.\n"));
1956 block
= get_frame_block (frame
, 0);
1959 fprintf_filtered (stream
, "No symbol table info available.\n");
1963 cb_data
.frame
= frame
;
1964 cb_data
.num_tabs
= 4 * num_tabs
;
1965 cb_data
.stream
= stream
;
1966 cb_data
.values_printed
= 0;
1968 iterate_over_block_local_vars (block
,
1969 do_print_variable_and_value
,
1972 if (!cb_data
.values_printed
)
1973 fprintf_filtered (stream
, _("No locals.\n"));
1977 locals_info (char *args
, int from_tty
)
1979 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1983 /* Iterate over all the argument variables in block B.
1985 Returns 1 if any argument was walked; 0 otherwise. */
1988 iterate_over_block_arg_vars (struct block
*b
,
1989 iterate_over_block_arg_local_vars_cb cb
,
1992 struct dict_iterator iter
;
1993 struct symbol
*sym
, *sym2
;
1995 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1997 /* Don't worry about things which aren't arguments. */
1998 if (SYMBOL_IS_ARGUMENT (sym
))
2000 /* We have to look up the symbol because arguments can have
2001 two entries (one a parameter, one a local) and the one we
2002 want is the local, which lookup_symbol will find for us.
2003 This includes gcc1 (not gcc2) on the sparc when passing a
2004 small structure and gcc2 when the argument type is float
2005 and it is passed as a double and converted to float by
2006 the prologue (in the latter case the type of the LOC_ARG
2007 symbol is double and the type of the LOC_LOCAL symbol is
2008 float). There are also LOC_ARG/LOC_REGISTER pairs which
2009 are not combined in symbol-reading. */
2011 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2012 b
, VAR_DOMAIN
, NULL
);
2013 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2019 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2021 struct print_variable_and_value_data cb_data
;
2022 struct symbol
*func
;
2025 if (!get_frame_pc_if_available (frame
, &pc
))
2027 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2031 func
= get_frame_function (frame
);
2034 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2038 cb_data
.frame
= frame
;
2039 cb_data
.num_tabs
= 0;
2040 cb_data
.stream
= gdb_stdout
;
2041 cb_data
.values_printed
= 0;
2043 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2044 do_print_variable_and_value
, &cb_data
);
2046 if (!cb_data
.values_printed
)
2047 fprintf_filtered (stream
, _("No arguments.\n"));
2051 args_info (char *ignore
, int from_tty
)
2053 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2059 args_plus_locals_info (char *ignore
, int from_tty
)
2061 args_info (ignore
, from_tty
);
2062 locals_info (ignore
, from_tty
);
2066 /* Select frame FRAME. Also print the stack frame and show the source
2067 if this is the tui version. */
2069 select_and_print_frame (struct frame_info
*frame
)
2071 select_frame (frame
);
2073 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2076 /* Return the symbol-block in which the selected frame is executing.
2077 Can return zero under various legitimate circumstances.
2079 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2080 code address within the block returned. We use this to decide
2081 which macros are in scope. */
2084 get_selected_block (CORE_ADDR
*addr_in_block
)
2086 if (!has_stack_frames ())
2089 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2092 /* Find a frame a certain number of levels away from FRAME.
2093 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2094 Positive means go to earlier frames (up); negative, the reverse.
2095 The int that contains the number of levels is counted toward
2096 zero as the frames for those levels are found.
2097 If the top or bottom frame is reached, that frame is returned,
2098 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2099 how much farther the original request asked to go. */
2102 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2104 /* Going up is simple: just call get_prev_frame enough times or
2105 until the initial frame is reached. */
2106 while (*level_offset_ptr
> 0)
2108 struct frame_info
*prev
= get_prev_frame (frame
);
2112 (*level_offset_ptr
)--;
2116 /* Going down is just as simple. */
2117 while (*level_offset_ptr
< 0)
2119 struct frame_info
*next
= get_next_frame (frame
);
2123 (*level_offset_ptr
)++;
2130 /* The "select_frame" command. With no argument this is a NOP.
2131 Select the frame at level LEVEL_EXP if it is a valid level.
2132 Otherwise, treat LEVEL_EXP as an address expression and select it.
2134 See parse_frame_specification for more info on proper frame
2138 select_frame_command (char *level_exp
, int from_tty
)
2140 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2143 /* The "frame" command. With no argument, print the selected frame
2144 briefly. With an argument, behave like select_frame and then print
2145 the selected frame. */
2148 frame_command (char *level_exp
, int from_tty
)
2150 select_frame_command (level_exp
, from_tty
);
2151 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2154 /* The XDB Compatibility command to print the current frame. */
2157 current_frame_command (char *level_exp
, int from_tty
)
2159 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2162 /* Select the frame up one or COUNT_EXP stack levels from the
2163 previously selected frame, and print it briefly. */
2166 up_silently_base (char *count_exp
)
2168 struct frame_info
*frame
;
2172 count
= parse_and_eval_long (count_exp
);
2174 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2175 if (count
!= 0 && count_exp
== NULL
)
2176 error (_("Initial frame selected; you cannot go up."));
2177 select_frame (frame
);
2181 up_silently_command (char *count_exp
, int from_tty
)
2183 up_silently_base (count_exp
);
2187 up_command (char *count_exp
, int from_tty
)
2189 up_silently_base (count_exp
);
2190 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2193 /* Select the frame down one or COUNT_EXP stack levels from the previously
2194 selected frame, and print it briefly. */
2197 down_silently_base (char *count_exp
)
2199 struct frame_info
*frame
;
2203 count
= -parse_and_eval_long (count_exp
);
2205 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2206 if (count
!= 0 && count_exp
== NULL
)
2208 /* We only do this if COUNT_EXP is not specified. That way
2209 "down" means to really go down (and let me know if that is
2210 impossible), but "down 9999" can be used to mean go all the
2211 way down without getting an error. */
2213 error (_("Bottom (innermost) frame selected; you cannot go down."));
2216 select_frame (frame
);
2220 down_silently_command (char *count_exp
, int from_tty
)
2222 down_silently_base (count_exp
);
2226 down_command (char *count_exp
, int from_tty
)
2228 down_silently_base (count_exp
);
2229 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2234 return_command (char *retval_exp
, int from_tty
)
2236 struct frame_info
*thisframe
;
2237 struct gdbarch
*gdbarch
;
2238 struct symbol
*thisfun
;
2239 struct value
*return_value
= NULL
;
2240 const char *query_prefix
= "";
2242 thisframe
= get_selected_frame ("No selected frame.");
2243 thisfun
= get_frame_function (thisframe
);
2244 gdbarch
= get_frame_arch (thisframe
);
2246 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2247 error (_("Can not force return from an inlined function."));
2249 /* Compute the return value. If the computation triggers an error,
2250 let it bail. If the return type can't be handled, set
2251 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2255 struct expression
*retval_expr
= parse_expression (retval_exp
);
2256 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2257 struct type
*return_type
= NULL
;
2259 /* Compute the return value. Should the computation fail, this
2260 call throws an error. */
2261 return_value
= evaluate_expression (retval_expr
);
2263 /* Cast return value to the return type of the function. Should
2264 the cast fail, this call throws an error. */
2265 if (thisfun
!= NULL
)
2266 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2267 if (return_type
== NULL
)
2269 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2270 error (_("Return value type not available for selected "
2272 "Please use an explicit cast of the value to return."));
2273 return_type
= value_type (return_value
);
2275 do_cleanups (old_chain
);
2276 CHECK_TYPEDEF (return_type
);
2277 return_value
= value_cast (return_type
, return_value
);
2279 /* Make sure the value is fully evaluated. It may live in the
2280 stack frame we're about to pop. */
2281 if (value_lazy (return_value
))
2282 value_fetch_lazy (return_value
);
2284 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2285 /* If the return-type is "void", don't try to find the
2286 return-value's location. However, do still evaluate the
2287 return expression so that, even when the expression result
2288 is discarded, side effects such as "return i++" still
2290 return_value
= NULL
;
2291 else if (thisfun
!= NULL
2292 && using_struct_return (gdbarch
,
2293 SYMBOL_TYPE (thisfun
), return_type
))
2295 query_prefix
= "The location at which to store the "
2296 "function's return value is unknown.\n"
2297 "If you continue, the return value "
2298 "that you specified will be ignored.\n";
2299 return_value
= NULL
;
2303 /* Does an interactive user really want to do this? Include
2304 information, such as how well GDB can handle the return value, in
2305 the query message. */
2310 if (thisfun
== NULL
)
2311 confirmed
= query (_("%sMake selected stack frame return now? "),
2314 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2315 SYMBOL_PRINT_NAME (thisfun
));
2317 error (_("Not confirmed"));
2320 /* Discard the selected frame and all frames inner-to it. */
2321 frame_pop (get_selected_frame (NULL
));
2323 /* Store RETURN_VALUE in the just-returned register set. */
2324 if (return_value
!= NULL
)
2326 struct type
*return_type
= value_type (return_value
);
2327 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2328 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2330 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2332 == RETURN_VALUE_REGISTER_CONVENTION
);
2333 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2334 get_current_regcache (), NULL
/*read*/,
2335 value_contents (return_value
) /*write*/);
2338 /* If we are at the end of a call dummy now, pop the dummy frame
2340 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2341 frame_pop (get_current_frame ());
2343 /* If interactive, print the frame that is now current. */
2345 frame_command ("0", 1);
2347 select_frame_command ("0", 0);
2350 /* Sets the scope to input function name, provided that the function
2351 is within the current stack frame. */
2353 struct function_bounds
2355 CORE_ADDR low
, high
;
2359 func_command (char *arg
, int from_tty
)
2361 struct frame_info
*frame
;
2363 struct symtabs_and_lines sals
;
2366 struct function_bounds
*func_bounds
= NULL
;
2367 struct cleanup
*cleanups
;
2372 frame
= parse_frame_specification ("0");
2373 sals
= decode_line_spec (arg
, DECODE_LINE_FUNFIRSTLINE
);
2374 cleanups
= make_cleanup (xfree
, sals
.sals
);
2375 func_bounds
= (struct function_bounds
*) xmalloc (
2376 sizeof (struct function_bounds
) * sals
.nelts
);
2377 make_cleanup (xfree
, func_bounds
);
2378 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2380 if (sals
.sals
[i
].pspace
!= current_program_space
)
2381 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2382 else if (sals
.sals
[i
].pc
== 0
2383 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2384 &func_bounds
[i
].low
,
2385 &func_bounds
[i
].high
) == 0)
2387 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2393 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2394 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2395 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2399 frame
= find_relative_frame (frame
, &level
);
2402 while (!found
&& level
== 0);
2404 do_cleanups (cleanups
);
2407 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2408 else if (frame
!= get_selected_frame (NULL
))
2409 select_and_print_frame (frame
);
2412 /* Gets the language of the current frame. */
2415 get_frame_language (void)
2417 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2421 volatile struct gdb_exception ex
;
2425 /* We determine the current frame language by looking up its
2426 associated symtab. To retrieve this symtab, we use the frame
2427 PC. However we cannot use the frame PC as is, because it
2428 usually points to the instruction following the "call", which
2429 is sometimes the first instruction of another function. So
2430 we rely on get_frame_address_in_block(), it provides us with
2431 a PC that is guaranteed to be inside the frame's code
2434 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2436 pc
= get_frame_address_in_block (frame
);
2440 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2441 throw_exception (ex
);
2445 s
= find_pc_symtab (pc
);
2451 return language_unknown
;
2455 /* Provide a prototype to silence -Wmissing-prototypes. */
2456 void _initialize_stack (void);
2459 _initialize_stack (void)
2461 add_com ("return", class_stack
, return_command
, _("\
2462 Make selected stack frame return to its caller.\n\
2463 Control remains in the debugger, but when you continue\n\
2464 execution will resume in the frame above the one now selected.\n\
2465 If an argument is given, it is an expression for the value to return."));
2467 add_com ("up", class_stack
, up_command
, _("\
2468 Select and print stack frame that called this one.\n\
2469 An argument says how many frames up to go."));
2470 add_com ("up-silently", class_support
, up_silently_command
, _("\
2471 Same as the `up' command, but does not print anything.\n\
2472 This is useful in command scripts."));
2474 add_com ("down", class_stack
, down_command
, _("\
2475 Select and print stack frame called by this one.\n\
2476 An argument says how many frames down to go."));
2477 add_com_alias ("do", "down", class_stack
, 1);
2478 add_com_alias ("dow", "down", class_stack
, 1);
2479 add_com ("down-silently", class_support
, down_silently_command
, _("\
2480 Same as the `down' command, but does not print anything.\n\
2481 This is useful in command scripts."));
2483 add_com ("frame", class_stack
, frame_command
, _("\
2484 Select and print a stack frame.\nWith no argument, \
2485 print the selected stack frame. (See also \"info frame\").\n\
2486 An argument specifies the frame to select.\n\
2487 It can be a stack frame number or the address of the frame.\n\
2488 With argument, nothing is printed if input is coming from\n\
2489 a command file or a user-defined command."));
2491 add_com_alias ("f", "frame", class_stack
, 1);
2495 add_com ("L", class_stack
, current_frame_command
,
2496 _("Print the current stack frame.\n"));
2497 add_com_alias ("V", "frame", class_stack
, 1);
2499 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2500 Select a stack frame without printing anything.\n\
2501 An argument specifies the frame to select.\n\
2502 It can be a stack frame number or the address of the frame.\n"));
2504 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2505 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2506 With a negative argument, print outermost -COUNT frames.\nUse of the \
2507 'full' qualifier also prints the values of the local variables.\n"));
2508 add_com_alias ("bt", "backtrace", class_stack
, 0);
2511 add_com_alias ("t", "backtrace", class_stack
, 0);
2512 add_com ("T", class_stack
, backtrace_full_command
, _("\
2513 Print backtrace of all stack frames, or innermost COUNT frames\n\
2514 and the values of the local variables.\n\
2515 With a negative argument, print outermost -COUNT frames.\n\
2516 Usage: T <count>\n"));
2519 add_com_alias ("where", "backtrace", class_alias
, 0);
2520 add_info ("stack", backtrace_command
,
2521 _("Backtrace of the stack, or innermost COUNT frames."));
2522 add_info_alias ("s", "stack", 1);
2523 add_info ("frame", frame_info
,
2524 _("All about selected stack frame, or frame at ADDR."));
2525 add_info_alias ("f", "frame", 1);
2526 add_info ("locals", locals_info
,
2527 _("Local variables of current stack frame."));
2528 add_info ("args", args_info
,
2529 _("Argument variables of current stack frame."));
2531 add_com ("l", class_info
, args_plus_locals_info
,
2532 _("Argument and local variables of current stack frame."));
2535 add_com ("func", class_stack
, func_command
, _("\
2536 Select the stack frame that contains <func>.\n\
2537 Usage: func <name>\n"));
2539 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2540 print_frame_arguments_choices
, &print_frame_arguments
,
2541 _("Set printing of non-scalar frame arguments"),
2542 _("Show printing of non-scalar frame arguments"),
2543 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2545 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2546 &disassemble_next_line
, _("\
2547 Set whether to disassemble next source line or insn when execution stops."),
2549 Show whether to disassemble next source line or insn when execution stops."),
2551 If ON, GDB will display disassembly of the next source line, in addition\n\
2552 to displaying the source line itself. If the next source line cannot\n\
2553 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2554 will display disassembly of next instruction instead of showing the\n\
2556 If AUTO, display disassembly of next instruction only if the source line\n\
2557 cannot be displayed.\n\
2558 If OFF (which is the default), never display the disassembly of the next\n\
2561 show_disassemble_next_line
,
2562 &setlist
, &showlist
);
2563 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2565 add_setshow_enum_cmd ("entry-values", class_stack
,
2566 print_entry_values_choices
, &print_entry_values
,
2567 _("Set printing of function arguments at function "
2569 _("Show printing of function arguments at function "
2572 GDB can sometimes determine the values of function arguments at entry,\n\
2573 in addition to their current values. This option tells GDB whether\n\
2574 to print the current value, the value at entry (marked as val@entry),\n\
2575 or both. Note that one or both of these values may be <optimized out>."),
2576 NULL
, NULL
, &setprintlist
, &showprintlist
);