1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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"
49 #include "cli/cli-utils.h"
56 #include "extension.h"
58 void (*deprecated_selected_frame_level_changed_hook) (int);
60 /* The possible choices of "set print frame-arguments", and the value
63 static const char *const print_frame_arguments_choices[] =
64 {"all", "scalars", "none", NULL};
65 static const char *print_frame_arguments = "scalars";
67 /* If non-zero, don't invoke pretty-printers for frame arguments. */
68 static int print_raw_frame_arguments;
70 /* The possible choices of "set print entry-values", and the value
73 const char print_entry_values_no[] = "no";
74 const char print_entry_values_only[] = "only";
75 const char print_entry_values_preferred[] = "preferred";
76 const char print_entry_values_if_needed[] = "if-needed";
77 const char print_entry_values_both[] = "both";
78 const char print_entry_values_compact[] = "compact";
79 const char print_entry_values_default[] = "default";
80 static const char *const print_entry_values_choices[] =
82 print_entry_values_no,
83 print_entry_values_only,
84 print_entry_values_preferred,
85 print_entry_values_if_needed,
86 print_entry_values_both,
87 print_entry_values_compact,
88 print_entry_values_default,
91 const char *print_entry_values = print_entry_values_default;
93 /* Prototypes for local functions. */
95 static void print_frame_local_vars (struct frame_info *, int,
98 static void print_frame (struct frame_info *frame, int print_level,
99 enum print_what print_what, int print_args,
100 struct symtab_and_line sal);
102 static void set_last_displayed_sal (int valid,
103 struct program_space *pspace,
105 struct symtab *symtab,
108 /* Zero means do things normally; we are interacting directly with the
109 user. One means print the full filename and linenumber when a
110 frame is printed, and do so in a format emacs18/emacs19.22 can
111 parse. Two means print similar annotations, but in many more
112 cases and in a slightly different syntax. */
114 int annotation_level = 0;
116 /* These variables hold the last symtab and line we displayed to the user.
117 * This is where we insert a breakpoint or a skiplist entry by default. */
118 static int last_displayed_sal_valid = 0;
119 static struct program_space *last_displayed_pspace = 0;
120 static CORE_ADDR last_displayed_addr = 0;
121 static struct symtab *last_displayed_symtab = 0;
122 static int last_displayed_line = 0;
125 /* Return 1 if we should display the address in addition to the location,
126 because we are in the middle of a statement. */
129 frame_show_address (struct frame_info *frame,
130 struct symtab_and_line sal)
132 /* If there is a line number, but no PC, then there is no location
133 information associated with this sal. The only way that should
134 happen is for the call sites of inlined functions (SAL comes from
135 find_frame_sal). Otherwise, we would have some PC range if the
136 SAL came from a line table. */
137 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
139 if (get_next_frame (frame) == NULL)
140 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
142 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
146 return get_frame_pc (frame) != sal.pc;
149 /* Show or print a stack frame FRAME briefly. The output is format
150 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
151 relative level, function name, argument list, and file name and
152 line number. If the frame's PC is not at the beginning of the
153 source line, the actual PC is printed at the beginning. */
156 print_stack_frame (struct frame_info *frame, int print_level,
157 enum print_what print_what,
160 volatile struct gdb_exception e;
162 /* For mi, alway print location and address. */
163 if (ui_out_is_mi_like_p (current_uiout))
164 print_what = LOC_AND_ADDRESS;
166 TRY_CATCH (e, RETURN_MASK_ERROR)
168 print_frame_info (frame, print_level, print_what, 1 /* print_args */,
171 set_current_sal_from_frame (frame);
175 /* Print nameless arguments of frame FRAME on STREAM, where START is
176 the offset of the first nameless argument, and NUM is the number of
177 nameless arguments to print. FIRST is nonzero if this is the first
178 argument (not just the first nameless argument). */
181 print_frame_nameless_args (struct frame_info *frame, long start, int num,
182 int first, struct ui_file *stream)
184 struct gdbarch *gdbarch = get_frame_arch (frame);
185 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
190 for (i = 0; i < num; i++)
193 argsaddr = get_frame_args_address (frame);
196 arg_value = read_memory_integer (argsaddr + start,
197 sizeof (int), byte_order);
199 fprintf_filtered (stream, ", ");
200 fprintf_filtered (stream, "%ld", arg_value);
202 start += sizeof (int);
206 /* Print single argument of inferior function. ARG must be already
209 Errors are printed as if they would be the parameter value. Use zeroed ARG
210 iff it should not be printed accoring to user settings. */
213 print_frame_arg (const struct frame_arg *arg)
215 struct ui_out *uiout = current_uiout;
216 volatile struct gdb_exception except;
217 struct cleanup *old_chain;
220 stb = mem_fileopen ();
221 old_chain = make_cleanup_ui_file_delete (stb);
223 gdb_assert (!arg->val || !arg->error);
224 gdb_assert (arg->entry_kind == print_entry_values_no
225 || arg->entry_kind == print_entry_values_only
226 || (!ui_out_is_mi_like_p (uiout)
227 && arg->entry_kind == print_entry_values_compact));
229 annotate_arg_begin ();
231 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
232 fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
233 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
234 if (arg->entry_kind == print_entry_values_compact)
236 /* It is OK to provide invalid MI-like stream as with
237 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
238 fputs_filtered ("=", stb);
240 fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
241 SYMBOL_LANGUAGE (arg->sym),
242 DMGL_PARAMS | DMGL_ANSI);
244 if (arg->entry_kind == print_entry_values_only
245 || arg->entry_kind == print_entry_values_compact)
246 fputs_filtered ("@entry", stb);
247 ui_out_field_stream (uiout, "name", stb);
248 annotate_arg_name_end ();
249 ui_out_text (uiout, "=");
251 if (!arg->val && !arg->error)
252 ui_out_text (uiout, "...");
256 except.message = arg->error;
259 /* TRY_CATCH has two statements, wrap it in a block. */
261 TRY_CATCH (except, RETURN_MASK_ERROR)
263 const struct language_defn *language;
264 struct value_print_options opts;
266 /* Avoid value_print because it will deref ref parameters. We
267 just want to print their addresses. Print ??? for args whose
268 address we do not know. We pass 2 as "recurse" to val_print
269 because our standard indentation here is 4 spaces, and
270 val_print indents 2 for each recurse. */
272 annotate_arg_value (value_type (arg->val));
274 /* Use the appropriate language to display our symbol, unless the
275 user forced the language to a specific language. */
276 if (language_mode == language_mode_auto)
277 language = language_def (SYMBOL_LANGUAGE (arg->sym));
279 language = current_language;
281 get_no_prettyformat_print_options (&opts);
283 opts.raw = print_raw_frame_arguments;
285 /* True in "summary" mode, false otherwise. */
286 opts.summary = !strcmp (print_frame_arguments, "scalars");
288 common_val_print (arg->val, stb, 2, &opts, language);
292 fprintf_filtered (stb, _("<error reading variable: %s>"),
296 ui_out_field_stream (uiout, "value", stb);
298 /* Also invoke ui_out_tuple_end. */
299 do_cleanups (old_chain);
304 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
305 responsible for xfree of ARGP->ERROR. This function never throws an
309 read_frame_local (struct symbol *sym, struct frame_info *frame,
310 struct frame_arg *argp)
312 volatile struct gdb_exception except;
313 struct value *val = NULL;
315 TRY_CATCH (except, RETURN_MASK_ERROR)
317 val = read_var_value (sym, frame);
320 argp->error = (val == NULL) ? xstrdup (except.message) : NULL;
325 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
326 responsible for xfree of ARGP->ERROR. This function never throws an
330 read_frame_arg (struct symbol *sym, struct frame_info *frame,
331 struct frame_arg *argp, struct frame_arg *entryargp)
333 struct value *val = NULL, *entryval = NULL;
334 char *val_error = NULL, *entryval_error = NULL;
336 volatile struct gdb_exception except;
338 if (print_entry_values != print_entry_values_only
339 && print_entry_values != print_entry_values_preferred)
341 TRY_CATCH (except, RETURN_MASK_ERROR)
343 val = read_var_value (sym, frame);
347 val_error = alloca (strlen (except.message) + 1);
348 strcpy (val_error, except.message);
352 if (SYMBOL_COMPUTED_OPS (sym) != NULL
353 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
354 && print_entry_values != print_entry_values_no
355 && (print_entry_values != print_entry_values_if_needed
356 || !val || value_optimized_out (val)))
358 TRY_CATCH (except, RETURN_MASK_ERROR)
360 const struct symbol_computed_ops *ops;
362 ops = SYMBOL_COMPUTED_OPS (sym);
363 entryval = ops->read_variable_at_entry (sym, frame);
367 entryval_error = alloca (strlen (except.message) + 1);
368 strcpy (entryval_error, except.message);
371 if (except.error == NO_ENTRY_VALUE_ERROR
372 || (entryval && value_optimized_out (entryval)))
375 entryval_error = NULL;
378 if (print_entry_values == print_entry_values_compact
379 || print_entry_values == print_entry_values_default)
381 /* For MI do not try to use print_entry_values_compact for ARGP. */
383 if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
385 struct type *type = value_type (val);
387 if (!value_optimized_out (val)
388 && value_available_contents_eq (val, 0, entryval, 0,
391 /* Initialize it just to avoid a GCC false warning. */
392 struct value *val_deref = NULL, *entryval_deref;
394 /* DW_AT_GNU_call_site_value does match with the current
395 value. If it is a reference still try to verify if
396 dereferenced DW_AT_GNU_call_site_data_value does not
399 TRY_CATCH (except, RETURN_MASK_ERROR)
401 struct type *type_deref;
403 val_deref = coerce_ref (val);
404 if (value_lazy (val_deref))
405 value_fetch_lazy (val_deref);
406 type_deref = value_type (val_deref);
408 entryval_deref = coerce_ref (entryval);
409 if (value_lazy (entryval_deref))
410 value_fetch_lazy (entryval_deref);
412 /* If the reference addresses match but dereferenced
413 content does not match print them. */
415 && !value_optimized_out (val_deref)
416 && !value_optimized_out (entryval_deref)
417 && value_available_contents_eq (val_deref, 0,
419 TYPE_LENGTH (type_deref)))
423 /* Value was not a reference; and its content matches. */
424 if (val == val_deref)
426 /* If the dereferenced content could not be fetched do not
428 else if (except.error == NO_ENTRY_VALUE_ERROR)
430 else if (except.message)
432 entryval_error = alloca (strlen (except.message) + 1);
433 strcpy (entryval_error, except.message);
441 /* Try to remove possibly duplicate error message for ENTRYARGP even
444 if (val_error && entryval_error
445 && strcmp (val_error, entryval_error) == 0)
447 entryval_error = NULL;
449 /* Do not se VAL_EQUAL as the same error message may be shown for
450 the entry value even if no entry values are present in the
456 if (entryval == NULL)
458 if (print_entry_values == print_entry_values_preferred)
460 TRY_CATCH (except, RETURN_MASK_ERROR)
462 val = read_var_value (sym, frame);
466 val_error = alloca (strlen (except.message) + 1);
467 strcpy (val_error, except.message);
470 if (print_entry_values == print_entry_values_only
471 || print_entry_values == print_entry_values_both
472 || (print_entry_values == print_entry_values_preferred
473 && (!val || value_optimized_out (val))))
475 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
476 entryval_error = NULL;
479 if ((print_entry_values == print_entry_values_compact
480 || print_entry_values == print_entry_values_if_needed
481 || print_entry_values == print_entry_values_preferred)
482 && (!val || value_optimized_out (val)) && entryval != NULL)
490 argp->error = val_error ? xstrdup (val_error) : NULL;
491 if (!val && !val_error)
492 argp->entry_kind = print_entry_values_only;
493 else if ((print_entry_values == print_entry_values_compact
494 || print_entry_values == print_entry_values_default) && val_equal)
496 argp->entry_kind = print_entry_values_compact;
497 gdb_assert (!ui_out_is_mi_like_p (current_uiout));
500 argp->entry_kind = print_entry_values_no;
502 entryargp->sym = sym;
503 entryargp->val = entryval;
504 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
505 if (!entryval && !entryval_error)
506 entryargp->entry_kind = print_entry_values_no;
508 entryargp->entry_kind = print_entry_values_only;
511 /* Print the arguments of frame FRAME on STREAM, given the function
512 FUNC running in that frame (as a symbol), where NUM is the number
513 of arguments according to the stack frame (or -1 if the number of
514 arguments is unknown). */
516 /* Note that currently the "number of arguments according to the
517 stack frame" is only known on VAX where i refers to the "number of
518 ints of arguments according to the stack frame". */
521 print_frame_args (struct symbol *func, struct frame_info *frame,
522 int num, struct ui_file *stream)
524 struct ui_out *uiout = current_uiout;
526 /* Offset of next stack argument beyond the one we have seen that is
527 at the highest offset, or -1 if we haven't come to a stack
529 long highest_offset = -1;
530 /* Number of ints of arguments that we have printed so far. */
531 int args_printed = 0;
532 struct cleanup *old_chain;
534 /* True if we should print arguments, false otherwise. */
535 int print_args = strcmp (print_frame_arguments, "none");
537 stb = mem_fileopen ();
538 old_chain = make_cleanup_ui_file_delete (stb);
542 const struct block *b = SYMBOL_BLOCK_VALUE (func);
543 struct block_iterator iter;
546 ALL_BLOCK_SYMBOLS (b, iter, sym)
548 struct frame_arg arg, entryarg;
552 /* Keep track of the highest stack argument offset seen, and
553 skip over any kinds of symbols we don't care about. */
555 if (!SYMBOL_IS_ARGUMENT (sym))
558 switch (SYMBOL_CLASS (sym))
563 long current_offset = SYMBOL_VALUE (sym);
564 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
566 /* Compute address of next argument by adding the size of
567 this argument and rounding to an int boundary. */
569 ((current_offset + arg_size + sizeof (int) - 1)
570 & ~(sizeof (int) - 1));
572 /* If this is the highest offset seen yet, set
574 if (highest_offset == -1
575 || (current_offset > highest_offset))
576 highest_offset = current_offset;
578 /* Add the number of ints we're about to print to
580 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
583 /* We care about types of symbols, but don't need to
584 keep track of stack offsets in them. */
586 case LOC_REGPARM_ADDR:
588 case LOC_OPTIMIZED_OUT:
593 /* We have to look up the symbol because arguments can have
594 two entries (one a parameter, one a local) and the one we
595 want is the local, which lookup_symbol will find for us.
596 This includes gcc1 (not gcc2) on SPARC when passing a
597 small structure and gcc2 when the argument type is float
598 and it is passed as a double and converted to float by
599 the prologue (in the latter case the type of the LOC_ARG
600 symbol is double and the type of the LOC_LOCAL symbol is
602 /* But if the parameter name is null, don't try it. Null
603 parameter names occur on the RS/6000, for traceback
604 tables. FIXME, should we even print them? */
606 if (*SYMBOL_LINKAGE_NAME (sym))
610 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
611 b, VAR_DOMAIN, NULL);
612 gdb_assert (nsym != NULL);
613 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
614 && !SYMBOL_IS_ARGUMENT (nsym))
616 /* There is a LOC_ARG/LOC_REGISTER pair. This means
617 that it was passed on the stack and loaded into a
618 register, or passed in a register and stored in a
619 stack slot. GDB 3.x used the LOC_ARG; GDB
620 4.0-4.11 used the LOC_REGISTER.
622 Reasons for using the LOC_ARG:
624 (1) Because find_saved_registers may be slow for
627 (2) Because registers are often re-used and stack
628 slots rarely (never?) are. Therefore using
629 the stack slot is much less likely to print
632 Reasons why we might want to use the LOC_REGISTER:
634 (1) So that the backtrace prints the same value
635 as "print foo". I see no compelling reason
636 why this needs to be the case; having the
637 backtrace print the value which was passed
638 in, and "print foo" print the value as
639 modified within the called function, makes
642 Additional note: It might be nice if "info args"
643 displayed both values.
645 One more note: There is a case with SPARC
646 structure passing where we need to use the
647 LOC_REGISTER, but this is dealt with by creating
648 a single LOC_REGPARM in symbol reading. */
650 /* Leave sym (the LOC_ARG) alone. */
657 /* Print the current arg. */
659 ui_out_text (uiout, ", ");
660 ui_out_wrap_hint (uiout, " ");
664 memset (&arg, 0, sizeof (arg));
666 arg.entry_kind = print_entry_values_no;
667 memset (&entryarg, 0, sizeof (entryarg));
669 entryarg.entry_kind = print_entry_values_no;
672 read_frame_arg (sym, frame, &arg, &entryarg);
674 if (arg.entry_kind != print_entry_values_only)
675 print_frame_arg (&arg);
677 if (entryarg.entry_kind != print_entry_values_no)
679 if (arg.entry_kind != print_entry_values_only)
681 ui_out_text (uiout, ", ");
682 ui_out_wrap_hint (uiout, " ");
685 print_frame_arg (&entryarg);
689 xfree (entryarg.error);
695 /* Don't print nameless args in situations where we don't know
696 enough about the stack to find them. */
701 if (highest_offset == -1)
702 start = gdbarch_frame_args_skip (get_frame_arch (frame));
704 start = highest_offset;
706 print_frame_nameless_args (frame, start, num - args_printed,
710 do_cleanups (old_chain);
713 /* Set the current source and line to the location given by frame
714 FRAME, if possible. When CENTER is true, adjust so the relevant
715 line is in the center of the next 'list'. */
718 set_current_sal_from_frame (struct frame_info *frame)
720 struct symtab_and_line sal;
722 find_frame_sal (frame, &sal);
723 if (sal.symtab != NULL)
724 set_current_source_symtab_and_line (&sal);
727 /* If ON, GDB will display disassembly of the next source line when
728 execution of the program being debugged stops.
729 If AUTO (which is the default), or there's no line info to determine
730 the source line of the next instruction, display disassembly of next
731 instruction instead. */
733 static enum auto_boolean disassemble_next_line;
736 show_disassemble_next_line (struct ui_file *file, int from_tty,
737 struct cmd_list_element *c,
740 fprintf_filtered (file,
741 _("Debugger's willingness to use "
742 "disassemble-next-line is %s.\n"),
746 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
747 because it will be broken by filter sometime. */
750 do_gdb_disassembly (struct gdbarch *gdbarch,
751 int how_many, CORE_ADDR low, CORE_ADDR high)
753 volatile struct gdb_exception exception;
755 TRY_CATCH (exception, RETURN_MASK_ERROR)
757 gdb_disassembly (gdbarch, current_uiout, 0,
758 DISASSEMBLY_RAW_INSN, how_many,
761 if (exception.reason < 0)
763 /* If an exception was thrown while doing the disassembly, print
764 the error message, to give the user a clue of what happened. */
765 exception_print (gdb_stderr, exception);
769 /* Print information about frame FRAME. The output is format according
770 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
773 SRC_LINE: Print only source line.
774 LOCATION: Print only location.
775 LOC_AND_SRC: Print location and source line.
777 Used in "where" output, and to emit breakpoint or step
781 print_frame_info (struct frame_info *frame, int print_level,
782 enum print_what print_what, int print_args,
785 struct gdbarch *gdbarch = get_frame_arch (frame);
786 struct symtab_and_line sal;
789 struct ui_out *uiout = current_uiout;
791 if (get_frame_type (frame) == DUMMY_FRAME
792 || get_frame_type (frame) == SIGTRAMP_FRAME
793 || get_frame_type (frame) == ARCH_FRAME)
795 struct cleanup *uiout_cleanup
796 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
798 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
799 gdbarch, get_frame_pc (frame));
801 /* Do this regardless of SOURCE because we don't have any source
802 to list for this frame. */
805 ui_out_text (uiout, "#");
806 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
807 frame_relative_level (frame));
809 if (ui_out_is_mi_like_p (uiout))
811 annotate_frame_address ();
812 ui_out_field_core_addr (uiout, "addr",
813 gdbarch, get_frame_pc (frame));
814 annotate_frame_address_end ();
817 if (get_frame_type (frame) == DUMMY_FRAME)
819 annotate_function_call ();
820 ui_out_field_string (uiout, "func", "<function called from gdb>");
822 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
824 annotate_signal_handler_caller ();
825 ui_out_field_string (uiout, "func", "<signal handler called>");
827 else if (get_frame_type (frame) == ARCH_FRAME)
829 ui_out_field_string (uiout, "func", "<cross-architecture call>");
831 ui_out_text (uiout, "\n");
832 annotate_frame_end ();
834 /* If disassemble-next-line is set to auto or on output the next
836 if (disassemble_next_line == AUTO_BOOLEAN_AUTO
837 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
838 do_gdb_disassembly (get_frame_arch (frame), 1,
839 get_frame_pc (frame), get_frame_pc (frame) + 1);
841 do_cleanups (uiout_cleanup);
845 /* If FRAME is not the innermost frame, that normally means that
846 FRAME->pc points to *after* the call instruction, and we want to
847 get the line containing the call, never the next line. But if
848 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
849 next frame was not entered as the result of a call, and we want
850 to get the line containing FRAME->pc. */
851 find_frame_sal (frame, &sal);
853 location_print = (print_what == LOCATION
854 || print_what == LOC_AND_ADDRESS
855 || print_what == SRC_AND_LOC);
857 if (location_print || !sal.symtab)
858 print_frame (frame, print_level, print_what, print_args, sal);
860 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
862 /* If disassemble-next-line is set to auto or on and doesn't have
863 the line debug messages for $pc, output the next instruction. */
864 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
865 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
866 && source_print && !sal.symtab)
867 do_gdb_disassembly (get_frame_arch (frame), 1,
868 get_frame_pc (frame), get_frame_pc (frame) + 1);
870 if (source_print && sal.symtab)
873 int mid_statement = ((print_what == SRC_LINE)
874 && frame_show_address (frame, sal));
876 if (annotation_level)
877 done = identify_source_line (sal.symtab, sal.line, mid_statement,
878 get_frame_pc (frame));
881 if (deprecated_print_frame_info_listing_hook)
882 deprecated_print_frame_info_listing_hook (sal.symtab,
887 struct value_print_options opts;
889 get_user_print_options (&opts);
890 /* We used to do this earlier, but that is clearly
891 wrong. This function is used by many different
892 parts of gdb, including normal_stop in infrun.c,
893 which uses this to print out the current PC
894 when we stepi/nexti into the middle of a source
895 line. Only the command line really wants this
896 behavior. Other UIs probably would like the
897 ability to decide for themselves if it is desired. */
898 if (opts.addressprint && mid_statement)
900 ui_out_field_core_addr (uiout, "addr",
901 gdbarch, get_frame_pc (frame));
902 ui_out_text (uiout, "\t");
905 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
909 /* If disassemble-next-line is set to on and there is line debug
910 messages, output assembly codes for next line. */
911 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
912 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
919 if (get_frame_pc_if_available (frame, &pc))
920 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
922 set_last_displayed_sal (0, 0, 0, 0, 0);
925 annotate_frame_end ();
927 gdb_flush (gdb_stdout);
930 /* Remember the last symtab and line we displayed, which we use e.g.
931 * as the place to put a breakpoint when the `break' command is
932 * invoked with no arguments. */
935 set_last_displayed_sal (int valid, struct program_space *pspace,
936 CORE_ADDR addr, struct symtab *symtab,
939 last_displayed_sal_valid = valid;
940 last_displayed_pspace = pspace;
941 last_displayed_addr = addr;
942 last_displayed_symtab = symtab;
943 last_displayed_line = line;
944 if (valid && pspace == NULL)
946 clear_last_displayed_sal ();
947 internal_error (__FILE__, __LINE__,
948 _("Trying to set NULL pspace."));
952 /* Forget the last sal we displayed. */
955 clear_last_displayed_sal (void)
957 last_displayed_sal_valid = 0;
958 last_displayed_pspace = 0;
959 last_displayed_addr = 0;
960 last_displayed_symtab = 0;
961 last_displayed_line = 0;
964 /* Is our record of the last sal we displayed valid? If not,
965 * the get_last_displayed_* functions will return NULL or 0, as
969 last_displayed_sal_is_valid (void)
971 return last_displayed_sal_valid;
974 /* Get the pspace of the last sal we displayed, if it's valid. */
976 struct program_space *
977 get_last_displayed_pspace (void)
979 if (last_displayed_sal_valid)
980 return last_displayed_pspace;
984 /* Get the address of the last sal we displayed, if it's valid. */
987 get_last_displayed_addr (void)
989 if (last_displayed_sal_valid)
990 return last_displayed_addr;
994 /* Get the symtab of the last sal we displayed, if it's valid. */
997 get_last_displayed_symtab (void)
999 if (last_displayed_sal_valid)
1000 return last_displayed_symtab;
1004 /* Get the line of the last sal we displayed, if it's valid. */
1007 get_last_displayed_line (void)
1009 if (last_displayed_sal_valid)
1010 return last_displayed_line;
1014 /* Get the last sal we displayed, if it's valid. */
1017 get_last_displayed_sal (struct symtab_and_line *sal)
1019 if (last_displayed_sal_valid)
1021 sal->pspace = last_displayed_pspace;
1022 sal->pc = last_displayed_addr;
1023 sal->symtab = last_displayed_symtab;
1024 sal->line = last_displayed_line;
1036 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1037 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1040 find_frame_funname (struct frame_info *frame, char **funname,
1041 enum language *funlang, struct symbol **funcp)
1043 struct symbol *func;
1046 *funlang = language_unknown;
1050 func = get_frame_function (frame);
1053 /* In certain pathological cases, the symtabs give the wrong
1054 function (when we are in the first function in a file which
1055 is compiled without debugging symbols, the previous function
1056 is compiled with debugging symbols, and the "foo.o" symbol
1057 that is supposed to tell us where the file with debugging
1058 symbols ends has been truncated by ar because it is longer
1059 than 15 characters). This also occurs if the user uses asm()
1060 to create a function but not stabs for it (in a file compiled
1063 So look in the minimal symbol tables as well, and if it comes
1064 up with a larger address for the function use that instead.
1065 I don't think this can ever cause any problems; there
1066 shouldn't be any minimal symbols in the middle of a function;
1067 if this is ever changed many parts of GDB will need to be
1068 changed (and we'll create a find_pc_minimal_function or some
1071 struct bound_minimal_symbol msymbol;
1073 /* Don't attempt to do this for inlined functions, which do not
1074 have a corresponding minimal symbol. */
1075 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1077 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1079 memset (&msymbol, 0, sizeof (msymbol));
1081 if (msymbol.minsym != NULL
1082 && (BMSYMBOL_VALUE_ADDRESS (msymbol)
1083 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
1085 /* We also don't know anything about the function besides
1086 its address and name. */
1088 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1089 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1093 *funname = xstrdup (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 char *func_only = cp_remove_params (*funname);
1109 *funname = func_only;
1116 struct bound_minimal_symbol msymbol;
1119 if (!get_frame_address_in_block_if_available (frame, &pc))
1122 msymbol = lookup_minimal_symbol_by_pc (pc);
1123 if (msymbol.minsym != NULL)
1125 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1126 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1132 print_frame (struct frame_info *frame, int print_level,
1133 enum print_what print_what, int print_args,
1134 struct symtab_and_line sal)
1136 struct gdbarch *gdbarch = get_frame_arch (frame);
1137 struct ui_out *uiout = current_uiout;
1138 char *funname = NULL;
1139 enum language funlang = language_unknown;
1140 struct ui_file *stb;
1141 struct cleanup *old_chain, *list_chain;
1142 struct value_print_options opts;
1143 struct symbol *func;
1147 pc_p = get_frame_pc_if_available (frame, &pc);
1149 stb = mem_fileopen ();
1150 old_chain = make_cleanup_ui_file_delete (stb);
1152 find_frame_funname (frame, &funname, &funlang, &func);
1153 make_cleanup (xfree, funname);
1155 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1158 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
1162 ui_out_text (uiout, "#");
1163 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
1164 frame_relative_level (frame));
1166 get_user_print_options (&opts);
1167 if (opts.addressprint)
1169 || frame_show_address (frame, sal)
1170 || print_what == LOC_AND_ADDRESS)
1172 annotate_frame_address ();
1174 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
1176 ui_out_field_string (uiout, "addr", "<unavailable>");
1177 annotate_frame_address_end ();
1178 ui_out_text (uiout, " in ");
1180 annotate_frame_function_name ();
1181 fprintf_symbol_filtered (stb, funname ? funname : "??",
1182 funlang, DMGL_ANSI);
1183 ui_out_field_stream (uiout, "func", stb);
1184 ui_out_wrap_hint (uiout, " ");
1185 annotate_frame_args ();
1187 ui_out_text (uiout, " (");
1190 struct gdbarch *gdbarch = get_frame_arch (frame);
1192 struct cleanup *args_list_chain;
1193 volatile struct gdb_exception e;
1195 if (gdbarch_frame_num_args_p (gdbarch))
1197 numargs = gdbarch_frame_num_args (gdbarch, frame);
1198 gdb_assert (numargs >= 0);
1203 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
1204 TRY_CATCH (e, RETURN_MASK_ERROR)
1206 print_frame_args (func, frame, numargs, gdb_stdout);
1208 /* FIXME: ARGS must be a list. If one argument is a string it
1209 will have " that will not be properly escaped. */
1210 /* Invoke ui_out_tuple_end. */
1211 do_cleanups (args_list_chain);
1214 ui_out_text (uiout, ")");
1217 const char *filename_display;
1219 filename_display = symtab_to_filename_for_display (sal.symtab);
1220 annotate_frame_source_begin ();
1221 ui_out_wrap_hint (uiout, " ");
1222 ui_out_text (uiout, " at ");
1223 annotate_frame_source_file ();
1224 ui_out_field_string (uiout, "file", filename_display);
1225 if (ui_out_is_mi_like_p (uiout))
1227 const char *fullname = symtab_to_fullname (sal.symtab);
1229 ui_out_field_string (uiout, "fullname", fullname);
1231 annotate_frame_source_file_end ();
1232 ui_out_text (uiout, ":");
1233 annotate_frame_source_line ();
1234 ui_out_field_int (uiout, "line", sal.line);
1235 annotate_frame_source_end ();
1238 if (pc_p && (funname == NULL || sal.symtab == NULL))
1240 char *lib = solib_name_from_address (get_frame_program_space (frame),
1241 get_frame_pc (frame));
1245 annotate_frame_where ();
1246 ui_out_wrap_hint (uiout, " ");
1247 ui_out_text (uiout, " from ");
1248 ui_out_field_string (uiout, "from", lib);
1252 /* do_cleanups will call ui_out_tuple_end() for us. */
1253 do_cleanups (list_chain);
1254 ui_out_text (uiout, "\n");
1255 do_cleanups (old_chain);
1259 /* Read a frame specification in whatever the appropriate format is
1260 from FRAME_EXP. Call error(), printing MESSAGE, if the
1261 specification is in any way invalid (so this function never returns
1262 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1263 the default selected frame was used. */
1265 static struct frame_info *
1266 parse_frame_specification_1 (const char *frame_exp, const char *message,
1267 int *selected_frame_p)
1270 struct value *args[4];
1271 CORE_ADDR addrs[ARRAY_SIZE (args)];
1273 if (frame_exp == NULL)
1281 struct cleanup *cleanup;
1284 /* Skip leading white space, bail of EOL. */
1285 frame_exp = skip_spaces_const (frame_exp);
1289 /* Parse the argument, extract it, save it. */
1291 *p && !isspace (*p);
1293 addr_string = savestring (frame_exp, p - frame_exp);
1295 cleanup = make_cleanup (xfree, addr_string);
1297 /* NOTE: Parse and evaluate expression, but do not use
1298 functions such as parse_and_eval_long or
1299 parse_and_eval_address to also extract the value.
1300 Instead value_as_long and value_as_address are used.
1301 This avoids problems with expressions that contain
1303 if (numargs >= ARRAY_SIZE (args))
1304 error (_("Too many args in frame specification"));
1305 args[numargs++] = parse_and_eval (addr_string);
1307 do_cleanups (cleanup);
1311 /* If no args, default to the selected frame. */
1314 if (selected_frame_p != NULL)
1315 (*selected_frame_p) = 1;
1316 return get_selected_frame (message);
1319 /* None of the remaining use the selected frame. */
1320 if (selected_frame_p != NULL)
1321 (*selected_frame_p) = 0;
1323 /* Assume the single arg[0] is an integer, and try using that to
1324 select a frame relative to current. */
1327 struct frame_info *fid;
1328 int level = value_as_long (args[0]);
1330 fid = find_relative_frame (get_current_frame (), &level);
1332 /* find_relative_frame was successful. */
1336 /* Convert each value into a corresponding address. */
1340 for (i = 0; i < numargs; i++)
1341 addrs[i] = value_as_address (args[i]);
1344 /* Assume that the single arg[0] is an address, use that to identify
1345 a frame with a matching ID. Should this also accept stack/pc or
1346 stack/pc/special. */
1349 struct frame_id id = frame_id_build_wild (addrs[0]);
1350 struct frame_info *fid;
1352 /* If (s)he specifies the frame with an address, he deserves
1353 what (s)he gets. Still, give the highest one that matches.
1354 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1356 for (fid = get_current_frame ();
1358 fid = get_prev_frame (fid))
1360 if (frame_id_eq (id, get_frame_id (fid)))
1362 struct frame_info *prev_frame;
1366 prev_frame = get_prev_frame (fid);
1368 || !frame_id_eq (id, get_frame_id (prev_frame)))
1377 /* We couldn't identify the frame as an existing frame, but
1378 perhaps we can create one with a single argument. */
1380 return create_new_frame (addrs[0], 0);
1381 else if (numargs == 2)
1382 return create_new_frame (addrs[0], addrs[1]);
1384 error (_("Too many args in frame specification"));
1387 static struct frame_info *
1388 parse_frame_specification (char *frame_exp)
1390 return parse_frame_specification_1 (frame_exp, NULL, NULL);
1393 /* Print verbosely the selected frame or the frame at address
1394 ADDR_EXP. Absolutely all information in the frame is printed. */
1397 frame_info (char *addr_exp, int from_tty)
1399 struct frame_info *fi;
1400 struct symtab_and_line sal;
1401 struct symbol *func;
1403 struct frame_info *calling_frame_info;
1405 const char *funname = 0;
1406 enum language funlang = language_unknown;
1407 const char *pc_regname;
1408 int selected_frame_p;
1409 struct gdbarch *gdbarch;
1410 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
1413 /* Initialize it to avoid "may be used uninitialized" warning. */
1414 CORE_ADDR caller_pc = 0;
1415 volatile struct gdb_exception ex;
1417 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
1418 gdbarch = get_frame_arch (fi);
1420 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1421 is not a good name. */
1422 if (gdbarch_pc_regnum (gdbarch) >= 0)
1423 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1424 easily not match that of the internal value returned by
1426 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1428 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1429 architectures will often have a hardware register called "pc",
1430 and that register's value, again, can easily not match
1434 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1435 find_frame_sal (fi, &sal);
1436 func = get_frame_function (fi);
1440 funname = SYMBOL_PRINT_NAME (func);
1441 funlang = SYMBOL_LANGUAGE (func);
1442 if (funlang == language_cplus)
1444 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1445 to display the demangled name that we already have
1446 stored in the symbol table, but we stored a version
1447 with DMGL_PARAMS turned on, and here we don't want to
1448 display parameters. So remove the parameters. */
1449 char *func_only = cp_remove_params (funname);
1453 funname = func_only;
1454 make_cleanup (xfree, func_only);
1458 else if (frame_pc_p)
1460 struct bound_minimal_symbol msymbol;
1462 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1463 if (msymbol.minsym != NULL)
1465 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1466 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1469 calling_frame_info = get_prev_frame (fi);
1471 if (selected_frame_p && frame_relative_level (fi) >= 0)
1473 printf_filtered (_("Stack level %d, frame at "),
1474 frame_relative_level (fi));
1478 printf_filtered (_("Stack frame at "));
1480 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1481 printf_filtered (":\n");
1482 printf_filtered (" %s = ", pc_regname);
1484 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1486 fputs_filtered ("<unavailable>", gdb_stdout);
1491 printf_filtered (" in ");
1492 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1493 DMGL_ANSI | DMGL_PARAMS);
1497 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1499 puts_filtered ("; ");
1501 printf_filtered ("saved %s = ", pc_regname);
1503 TRY_CATCH (ex, RETURN_MASK_ERROR)
1505 caller_pc = frame_unwind_caller_pc (fi);
1511 case NOT_AVAILABLE_ERROR:
1512 val_print_unavailable (gdb_stdout);
1514 case OPTIMIZED_OUT_ERROR:
1515 val_print_not_saved (gdb_stdout);
1518 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1523 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1524 printf_filtered ("\n");
1526 if (calling_frame_info == NULL)
1528 enum unwind_stop_reason reason;
1530 reason = get_frame_unwind_stop_reason (fi);
1531 if (reason != UNWIND_NO_REASON)
1532 printf_filtered (_(" Outermost frame: %s\n"),
1533 frame_stop_reason_string (fi));
1535 else if (get_frame_type (fi) == TAILCALL_FRAME)
1536 puts_filtered (" tail call frame");
1537 else if (get_frame_type (fi) == INLINE_FRAME)
1538 printf_filtered (" inlined into frame %d",
1539 frame_relative_level (get_prev_frame (fi)));
1542 printf_filtered (" called by frame at ");
1543 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1546 if (get_next_frame (fi) && calling_frame_info)
1547 puts_filtered (",");
1549 if (get_next_frame (fi))
1551 printf_filtered (" caller of frame at ");
1552 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1555 if (get_next_frame (fi) || calling_frame_info)
1556 puts_filtered ("\n");
1559 printf_filtered (" source language %s.\n",
1560 language_str (s->language));
1563 /* Address of the argument list for this frame, or 0. */
1564 CORE_ADDR arg_list = get_frame_args_address (fi);
1565 /* Number of args for this frame, or -1 if unknown. */
1569 printf_filtered (" Arglist at unknown address.\n");
1572 printf_filtered (" Arglist at ");
1573 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1574 printf_filtered (",");
1576 if (!gdbarch_frame_num_args_p (gdbarch))
1579 puts_filtered (" args: ");
1583 numargs = gdbarch_frame_num_args (gdbarch, fi);
1584 gdb_assert (numargs >= 0);
1586 puts_filtered (" no args.");
1587 else if (numargs == 1)
1588 puts_filtered (" 1 arg: ");
1590 printf_filtered (" %d args: ", numargs);
1592 print_frame_args (func, fi, numargs, gdb_stdout);
1593 puts_filtered ("\n");
1597 /* Address of the local variables for this frame, or 0. */
1598 CORE_ADDR arg_list = get_frame_locals_address (fi);
1601 printf_filtered (" Locals at unknown address,");
1604 printf_filtered (" Locals at ");
1605 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1606 printf_filtered (",");
1610 /* Print as much information as possible on the location of all the
1613 enum lval_type lval;
1622 /* The sp is special; what's displayed isn't the save address, but
1623 the value of the previous frame's sp. This is a legacy thing,
1624 at one stage the frame cached the previous frame's SP instead
1625 of its address, hence it was easiest to just display the cached
1627 if (gdbarch_sp_regnum (gdbarch) >= 0)
1629 /* Find out the location of the saved stack pointer with out
1630 actually evaluating it. */
1631 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1632 &optimized, &unavailable, &lval, &addr,
1634 if (!optimized && !unavailable && lval == not_lval)
1636 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1637 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1638 gdb_byte value[MAX_REGISTER_SIZE];
1641 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1642 &optimized, &unavailable, &lval, &addr,
1644 /* NOTE: cagney/2003-05-22: This is assuming that the
1645 stack pointer was packed as an unsigned integer. That
1646 may or may not be valid. */
1647 sp = extract_unsigned_integer (value, sp_size, byte_order);
1648 printf_filtered (" Previous frame's sp is ");
1649 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1650 printf_filtered ("\n");
1653 else if (!optimized && !unavailable && lval == lval_memory)
1655 printf_filtered (" Previous frame's sp at ");
1656 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1657 printf_filtered ("\n");
1660 else if (!optimized && !unavailable && lval == lval_register)
1662 printf_filtered (" Previous frame's sp in %s\n",
1663 gdbarch_register_name (gdbarch, realnum));
1666 /* else keep quiet. */
1670 numregs = gdbarch_num_regs (gdbarch)
1671 + gdbarch_num_pseudo_regs (gdbarch);
1672 for (i = 0; i < numregs; i++)
1673 if (i != gdbarch_sp_regnum (gdbarch)
1674 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1676 /* Find out the location of the saved register without
1677 fetching the corresponding value. */
1678 frame_register_unwind (fi, i, &optimized, &unavailable,
1679 &lval, &addr, &realnum, NULL);
1680 /* For moment, only display registers that were saved on the
1682 if (!optimized && !unavailable && lval == lval_memory)
1685 puts_filtered (" Saved registers:\n ");
1687 puts_filtered (",");
1689 printf_filtered (" %s at ",
1690 gdbarch_register_name (gdbarch, i));
1691 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1695 if (count || need_nl)
1696 puts_filtered ("\n");
1699 do_cleanups (back_to);
1702 /* Print briefly all stack frames or just the innermost COUNT_EXP
1706 backtrace_command_1 (char *count_exp, int show_locals, int no_filters,
1709 struct frame_info *fi;
1712 struct frame_info *trailing;
1713 int trailing_level, py_start = 0, py_end = 0;
1714 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1716 if (!target_has_stack)
1717 error (_("No stack."));
1719 /* The following code must do two things. First, it must set the
1720 variable TRAILING to the frame from which we should start
1721 printing. Second, it must set the variable count to the number
1722 of frames which we should print, or -1 if all of them. */
1723 trailing = get_current_frame ();
1728 count = parse_and_eval_long (count_exp);
1731 struct frame_info *current;
1737 while (current && count--)
1740 current = get_prev_frame (current);
1743 /* Will stop when CURRENT reaches the top of the stack.
1744 TRAILING will be COUNT below it. */
1748 trailing = get_prev_frame (trailing);
1749 current = get_prev_frame (current);
1769 /* Read in symbols for all of the frames. Need to do this in a
1770 separate pass so that "Reading in symbols for xxx" messages
1771 don't screw up the appearance of the backtrace. Also if
1772 people have strong opinions against reading symbols for
1773 backtrace this may have to be an option. */
1775 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1780 pc = get_frame_address_in_block (fi);
1781 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc));
1787 int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1788 enum ext_lang_frame_args arg_type;
1791 flags |= PRINT_LOCALS;
1793 if (!strcmp (print_frame_arguments, "scalars"))
1794 arg_type = CLI_SCALAR_VALUES;
1795 else if (!strcmp (print_frame_arguments, "all"))
1796 arg_type = CLI_ALL_VALUES;
1798 arg_type = NO_VALUES;
1800 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1801 arg_type, current_uiout,
1805 /* Run the inbuilt backtrace if there are no filters registered, or
1806 "no-filters" has been specified from the command. */
1807 if (no_filters || result == EXT_LANG_BT_NO_FILTERS)
1809 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1813 /* Don't use print_stack_frame; if an error() occurs it probably
1814 means further attempts to backtrace would fail (on the other
1815 hand, perhaps the code does or could be fixed to make sure
1816 the frame->prev field gets set to NULL in that case). */
1818 print_frame_info (fi, 1, LOCATION, 1, 0);
1821 struct frame_id frame_id = get_frame_id (fi);
1823 print_frame_local_vars (fi, 1, gdb_stdout);
1825 /* print_frame_local_vars invalidates FI. */
1826 fi = frame_find_by_id (frame_id);
1830 warning (_("Unable to restore previously selected frame."));
1835 /* Save the last frame to check for error conditions. */
1839 /* If we've stopped before the end, mention that. */
1841 printf_filtered (_("(More stack frames follow...)\n"));
1843 /* If we've run out of frames, and the reason appears to be an error
1844 condition, print it. */
1845 if (fi == NULL && trailing != NULL)
1847 enum unwind_stop_reason reason;
1849 reason = get_frame_unwind_stop_reason (trailing);
1850 if (reason >= UNWIND_FIRST_ERROR)
1851 printf_filtered (_("Backtrace stopped: %s\n"),
1852 frame_stop_reason_string (trailing));
1858 backtrace_command (char *arg, int from_tty)
1860 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1861 int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1;
1869 argv = gdb_buildargv (arg);
1870 make_cleanup_freeargv (argv);
1872 for (i = 0; argv[i]; i++)
1876 for (j = 0; j < strlen (argv[i]); j++)
1877 argv[i][j] = tolower (argv[i][j]);
1879 if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
1883 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1884 fulltrace_arg = argc;
1888 arglen += strlen (argv[i]);
1894 if (fulltrace_arg >= 0 || no_filters >= 0)
1898 arg = xmalloc (arglen + 1);
1899 make_cleanup (xfree, arg);
1901 for (i = 0; i < argc; i++)
1903 if (i != fulltrace_arg && i != no_filters)
1905 strcat (arg, argv[i]);
1915 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
1916 no_filters >= 0 /* no frame-filters */, from_tty);
1918 do_cleanups (old_chain);
1922 backtrace_full_command (char *arg, int from_tty)
1924 backtrace_command_1 (arg, 1 /* show_locals */, 0, from_tty);
1928 /* Iterate over the local variables of a block B, calling CB with
1932 iterate_over_block_locals (const struct block *b,
1933 iterate_over_block_arg_local_vars_cb cb,
1936 struct block_iterator iter;
1939 ALL_BLOCK_SYMBOLS (b, iter, sym)
1941 switch (SYMBOL_CLASS (sym))
1947 if (SYMBOL_IS_ARGUMENT (sym))
1949 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1951 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1955 /* Ignore symbols which are not locals. */
1962 /* Same, but print labels. */
1965 /* Commented out, as the code using this function has also been
1966 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1967 was commented out in the first place. The discussion introducing
1968 this change (2007-12-04: Support lexical blocks and function bodies
1969 that occupy non-contiguous address ranges) did not explain why
1970 this change was made. */
1972 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1973 int *have_default, struct ui_file *stream)
1975 struct block_iterator iter;
1977 int values_printed = 0;
1979 ALL_BLOCK_SYMBOLS (b, iter, sym)
1981 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1987 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1989 struct symtab_and_line sal;
1990 struct value_print_options opts;
1992 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1994 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1995 get_user_print_options (&opts);
1996 if (opts.addressprint)
1998 fprintf_filtered (stream, " ");
1999 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2002 fprintf_filtered (stream, " in file %s, line %d\n",
2003 sal.symtab->filename, sal.line);
2007 return values_printed;
2011 /* Iterate over all the local variables in block B, including all its
2012 superblocks, stopping when the top-level block is reached. */
2015 iterate_over_block_local_vars (const struct block *block,
2016 iterate_over_block_arg_local_vars_cb cb,
2021 iterate_over_block_locals (block, cb, cb_data);
2022 /* After handling the function's top-level block, stop. Don't
2023 continue to its superblock, the block of per-file
2025 if (BLOCK_FUNCTION (block))
2027 block = BLOCK_SUPERBLOCK (block);
2031 /* Data to be passed around in the calls to the locals and args
2034 struct print_variable_and_value_data
2036 struct frame_id frame_id;
2038 struct ui_file *stream;
2042 /* The callback for the locals and args iterators. */
2045 do_print_variable_and_value (const char *print_name,
2049 struct print_variable_and_value_data *p = cb_data;
2050 struct frame_info *frame;
2052 frame = frame_find_by_id (p->frame_id);
2055 warning (_("Unable to restore previously selected frame."));
2059 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2061 /* print_variable_and_value invalidates FRAME. */
2064 p->values_printed = 1;
2067 /* Print all variables from the innermost up to the function block of FRAME.
2068 Print them with values to STREAM indented by NUM_TABS.
2070 This function will invalidate FRAME. */
2073 print_frame_local_vars (struct frame_info *frame, int num_tabs,
2074 struct ui_file *stream)
2076 struct print_variable_and_value_data cb_data;
2077 const struct block *block;
2080 if (!get_frame_pc_if_available (frame, &pc))
2082 fprintf_filtered (stream,
2083 _("PC unavailable, cannot determine locals.\n"));
2087 block = get_frame_block (frame, 0);
2090 fprintf_filtered (stream, "No symbol table info available.\n");
2094 cb_data.frame_id = get_frame_id (frame);
2095 cb_data.num_tabs = 4 * num_tabs;
2096 cb_data.stream = stream;
2097 cb_data.values_printed = 0;
2099 iterate_over_block_local_vars (block,
2100 do_print_variable_and_value,
2103 /* do_print_variable_and_value invalidates FRAME. */
2106 if (!cb_data.values_printed)
2107 fprintf_filtered (stream, _("No locals.\n"));
2111 locals_info (char *args, int from_tty)
2113 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2117 /* Iterate over all the argument variables in block B.
2119 Returns 1 if any argument was walked; 0 otherwise. */
2122 iterate_over_block_arg_vars (const struct block *b,
2123 iterate_over_block_arg_local_vars_cb cb,
2126 struct block_iterator iter;
2127 struct symbol *sym, *sym2;
2129 ALL_BLOCK_SYMBOLS (b, iter, sym)
2131 /* Don't worry about things which aren't arguments. */
2132 if (SYMBOL_IS_ARGUMENT (sym))
2134 /* We have to look up the symbol because arguments can have
2135 two entries (one a parameter, one a local) and the one we
2136 want is the local, which lookup_symbol will find for us.
2137 This includes gcc1 (not gcc2) on the sparc when passing a
2138 small structure and gcc2 when the argument type is float
2139 and it is passed as a double and converted to float by
2140 the prologue (in the latter case the type of the LOC_ARG
2141 symbol is double and the type of the LOC_LOCAL symbol is
2142 float). There are also LOC_ARG/LOC_REGISTER pairs which
2143 are not combined in symbol-reading. */
2145 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
2146 b, VAR_DOMAIN, NULL);
2147 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2152 /* Print all argument variables of the function of FRAME.
2153 Print them with values to STREAM.
2155 This function will invalidate FRAME. */
2158 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2160 struct print_variable_and_value_data cb_data;
2161 struct symbol *func;
2164 if (!get_frame_pc_if_available (frame, &pc))
2166 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2170 func = get_frame_function (frame);
2173 fprintf_filtered (stream, _("No symbol table info available.\n"));
2177 cb_data.frame_id = get_frame_id (frame);
2178 cb_data.num_tabs = 0;
2179 cb_data.stream = gdb_stdout;
2180 cb_data.values_printed = 0;
2182 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2183 do_print_variable_and_value, &cb_data);
2185 /* do_print_variable_and_value invalidates FRAME. */
2188 if (!cb_data.values_printed)
2189 fprintf_filtered (stream, _("No arguments.\n"));
2193 args_info (char *ignore, int from_tty)
2195 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2201 args_plus_locals_info (char *ignore, int from_tty)
2203 args_info (ignore, from_tty);
2204 locals_info (ignore, from_tty);
2208 /* Select frame FRAME. Also print the stack frame and show the source
2209 if this is the tui version. */
2211 select_and_print_frame (struct frame_info *frame)
2213 select_frame (frame);
2215 print_stack_frame (frame, 1, SRC_AND_LOC, 1);
2218 /* Return the symbol-block in which the selected frame is executing.
2219 Can return zero under various legitimate circumstances.
2221 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2222 code address within the block returned. We use this to decide
2223 which macros are in scope. */
2225 const struct block *
2226 get_selected_block (CORE_ADDR *addr_in_block)
2228 if (!has_stack_frames ())
2231 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2234 /* Find a frame a certain number of levels away from FRAME.
2235 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2236 Positive means go to earlier frames (up); negative, the reverse.
2237 The int that contains the number of levels is counted toward
2238 zero as the frames for those levels are found.
2239 If the top or bottom frame is reached, that frame is returned,
2240 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2241 how much farther the original request asked to go. */
2244 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2246 /* Going up is simple: just call get_prev_frame enough times or
2247 until the initial frame is reached. */
2248 while (*level_offset_ptr > 0)
2250 struct frame_info *prev = get_prev_frame (frame);
2254 (*level_offset_ptr)--;
2258 /* Going down is just as simple. */
2259 while (*level_offset_ptr < 0)
2261 struct frame_info *next = get_next_frame (frame);
2265 (*level_offset_ptr)++;
2272 /* The "select_frame" command. With no argument this is a NOP.
2273 Select the frame at level LEVEL_EXP if it is a valid level.
2274 Otherwise, treat LEVEL_EXP as an address expression and select it.
2276 See parse_frame_specification for more info on proper frame
2280 select_frame_command (char *level_exp, int from_tty)
2282 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
2285 /* The "frame" command. With no argument, print the selected frame
2286 briefly. With an argument, behave like select_frame and then print
2287 the selected frame. */
2290 frame_command (char *level_exp, int from_tty)
2292 select_frame_command (level_exp, from_tty);
2293 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2296 /* The XDB Compatibility command to print the current frame. */
2299 current_frame_command (char *level_exp, int from_tty)
2301 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC, 1);
2304 /* Select the frame up one or COUNT_EXP stack levels from the
2305 previously selected frame, and print it briefly. */
2308 up_silently_base (const char *count_exp)
2310 struct frame_info *frame;
2314 count = parse_and_eval_long (count_exp);
2316 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2317 if (count != 0 && count_exp == NULL)
2318 error (_("Initial frame selected; you cannot go up."));
2319 select_frame (frame);
2323 up_silently_command (char *count_exp, int from_tty)
2325 up_silently_base (count_exp);
2329 up_command (char *count_exp, int from_tty)
2331 up_silently_base (count_exp);
2332 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2335 /* Select the frame down one or COUNT_EXP stack levels from the previously
2336 selected frame, and print it briefly. */
2339 down_silently_base (const char *count_exp)
2341 struct frame_info *frame;
2345 count = -parse_and_eval_long (count_exp);
2347 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2348 if (count != 0 && count_exp == NULL)
2350 /* We only do this if COUNT_EXP is not specified. That way
2351 "down" means to really go down (and let me know if that is
2352 impossible), but "down 9999" can be used to mean go all the
2353 way down without getting an error. */
2355 error (_("Bottom (innermost) frame selected; you cannot go down."));
2358 select_frame (frame);
2362 down_silently_command (char *count_exp, int from_tty)
2364 down_silently_base (count_exp);
2368 down_command (char *count_exp, int from_tty)
2370 down_silently_base (count_exp);
2371 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2376 return_command (char *retval_exp, int from_tty)
2378 /* Initialize it just to avoid a GCC false warning. */
2379 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2380 struct frame_info *thisframe;
2381 struct gdbarch *gdbarch;
2382 struct symbol *thisfun;
2383 struct value *return_value = NULL;
2384 struct value *function = NULL;
2385 const char *query_prefix = "";
2387 thisframe = get_selected_frame ("No selected frame.");
2388 thisfun = get_frame_function (thisframe);
2389 gdbarch = get_frame_arch (thisframe);
2391 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2392 error (_("Can not force return from an inlined function."));
2394 /* Compute the return value. If the computation triggers an error,
2395 let it bail. If the return type can't be handled, set
2396 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2400 struct expression *retval_expr = parse_expression (retval_exp);
2401 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
2402 struct type *return_type = NULL;
2404 /* Compute the return value. Should the computation fail, this
2405 call throws an error. */
2406 return_value = evaluate_expression (retval_expr);
2408 /* Cast return value to the return type of the function. Should
2409 the cast fail, this call throws an error. */
2410 if (thisfun != NULL)
2411 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2412 if (return_type == NULL)
2414 if (retval_expr->elts[0].opcode != UNOP_CAST
2415 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2416 error (_("Return value type not available for selected "
2418 "Please use an explicit cast of the value to return."));
2419 return_type = value_type (return_value);
2421 do_cleanups (old_chain);
2422 CHECK_TYPEDEF (return_type);
2423 return_value = value_cast (return_type, return_value);
2425 /* Make sure the value is fully evaluated. It may live in the
2426 stack frame we're about to pop. */
2427 if (value_lazy (return_value))
2428 value_fetch_lazy (return_value);
2430 if (thisfun != NULL)
2431 function = read_var_value (thisfun, thisframe);
2433 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2434 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2435 /* If the return-type is "void", don't try to find the
2436 return-value's location. However, do still evaluate the
2437 return expression so that, even when the expression result
2438 is discarded, side effects such as "return i++" still
2440 return_value = NULL;
2441 else if (thisfun != NULL)
2443 rv_conv = struct_return_convention (gdbarch, function, return_type);
2444 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2445 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2447 query_prefix = "The location at which to store the "
2448 "function's return value is unknown.\n"
2449 "If you continue, the return value "
2450 "that you specified will be ignored.\n";
2451 return_value = NULL;
2456 /* Does an interactive user really want to do this? Include
2457 information, such as how well GDB can handle the return value, in
2458 the query message. */
2463 if (thisfun == NULL)
2464 confirmed = query (_("%sMake selected stack frame return now? "),
2467 confirmed = query (_("%sMake %s return now? "), query_prefix,
2468 SYMBOL_PRINT_NAME (thisfun));
2470 error (_("Not confirmed"));
2473 /* Discard the selected frame and all frames inner-to it. */
2474 frame_pop (get_selected_frame (NULL));
2476 /* Store RETURN_VALUE in the just-returned register set. */
2477 if (return_value != NULL)
2479 struct type *return_type = value_type (return_value);
2480 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2482 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2483 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2484 gdbarch_return_value (gdbarch, function, return_type,
2485 get_current_regcache (), NULL /*read*/,
2486 value_contents (return_value) /*write*/);
2489 /* If we are at the end of a call dummy now, pop the dummy frame
2491 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2492 frame_pop (get_current_frame ());
2494 /* If interactive, print the frame that is now current. */
2496 frame_command ("0", 1);
2498 select_frame_command ("0", 0);
2501 /* Sets the scope to input function name, provided that the function
2502 is within the current stack frame. */
2504 struct function_bounds
2506 CORE_ADDR low, high;
2510 func_command (char *arg, int from_tty)
2512 struct frame_info *frame;
2514 struct symtabs_and_lines sals;
2517 struct function_bounds *func_bounds = NULL;
2518 struct cleanup *cleanups;
2523 frame = parse_frame_specification ("0");
2524 sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
2525 cleanups = make_cleanup (xfree, sals.sals);
2526 func_bounds = (struct function_bounds *) xmalloc (
2527 sizeof (struct function_bounds) * sals.nelts);
2528 make_cleanup (xfree, func_bounds);
2529 for (i = 0; (i < sals.nelts && !found); i++)
2531 if (sals.sals[i].pspace != current_program_space)
2532 func_bounds[i].low = func_bounds[i].high = 0;
2533 else if (sals.sals[i].pc == 0
2534 || find_pc_partial_function (sals.sals[i].pc, NULL,
2535 &func_bounds[i].low,
2536 &func_bounds[i].high) == 0)
2538 func_bounds[i].low = func_bounds[i].high = 0;
2544 for (i = 0; (i < sals.nelts && !found); i++)
2545 found = (get_frame_pc (frame) >= func_bounds[i].low
2546 && get_frame_pc (frame) < func_bounds[i].high);
2550 frame = find_relative_frame (frame, &level);
2553 while (!found && level == 0);
2555 do_cleanups (cleanups);
2558 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2559 else if (frame != get_selected_frame (NULL))
2560 select_and_print_frame (frame);
2563 /* Gets the language of the current frame. */
2566 get_frame_language (void)
2568 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2572 volatile struct gdb_exception ex;
2576 /* We determine the current frame language by looking up its
2577 associated symtab. To retrieve this symtab, we use the frame
2578 PC. However we cannot use the frame PC as is, because it
2579 usually points to the instruction following the "call", which
2580 is sometimes the first instruction of another function. So
2581 we rely on get_frame_address_in_block(), it provides us with
2582 a PC that is guaranteed to be inside the frame's code
2585 TRY_CATCH (ex, RETURN_MASK_ERROR)
2587 pc = get_frame_address_in_block (frame);
2591 if (ex.error != NOT_AVAILABLE_ERROR)
2592 throw_exception (ex);
2596 s = find_pc_symtab (pc);
2602 return language_unknown;
2606 /* Provide a prototype to silence -Wmissing-prototypes. */
2607 void _initialize_stack (void);
2610 _initialize_stack (void)
2612 add_com ("return", class_stack, return_command, _("\
2613 Make selected stack frame return to its caller.\n\
2614 Control remains in the debugger, but when you continue\n\
2615 execution will resume in the frame above the one now selected.\n\
2616 If an argument is given, it is an expression for the value to return."));
2618 add_com ("up", class_stack, up_command, _("\
2619 Select and print stack frame that called this one.\n\
2620 An argument says how many frames up to go."));
2621 add_com ("up-silently", class_support, up_silently_command, _("\
2622 Same as the `up' command, but does not print anything.\n\
2623 This is useful in command scripts."));
2625 add_com ("down", class_stack, down_command, _("\
2626 Select and print stack frame called by this one.\n\
2627 An argument says how many frames down to go."));
2628 add_com_alias ("do", "down", class_stack, 1);
2629 add_com_alias ("dow", "down", class_stack, 1);
2630 add_com ("down-silently", class_support, down_silently_command, _("\
2631 Same as the `down' command, but does not print anything.\n\
2632 This is useful in command scripts."));
2634 add_com ("frame", class_stack, frame_command, _("\
2635 Select and print a stack frame.\nWith no argument, \
2636 print the selected stack frame. (See also \"info frame\").\n\
2637 An argument specifies the frame to select.\n\
2638 It can be a stack frame number or the address of the frame.\n\
2639 With argument, nothing is printed if input is coming from\n\
2640 a command file or a user-defined command."));
2642 add_com_alias ("f", "frame", class_stack, 1);
2646 add_com ("L", class_stack, current_frame_command,
2647 _("Print the current stack frame.\n"));
2648 add_com_alias ("V", "frame", class_stack, 1);
2650 add_com ("select-frame", class_stack, select_frame_command, _("\
2651 Select a stack frame without printing anything.\n\
2652 An argument specifies the frame to select.\n\
2653 It can be a stack frame number or the address of the frame.\n"));
2655 add_com ("backtrace", class_stack, backtrace_command, _("\
2656 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2657 With a negative argument, print outermost -COUNT frames.\nUse of the \
2658 'full' qualifier also prints the values of the local variables.\n\
2659 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2660 on this backtrace.\n"));
2661 add_com_alias ("bt", "backtrace", class_stack, 0);
2664 add_com_alias ("t", "backtrace", class_stack, 0);
2665 add_com ("T", class_stack, backtrace_full_command, _("\
2666 Print backtrace of all stack frames, or innermost COUNT frames\n\
2667 and the values of the local variables.\n\
2668 With a negative argument, print outermost -COUNT frames.\n\
2669 Usage: T <count>\n"));
2672 add_com_alias ("where", "backtrace", class_alias, 0);
2673 add_info ("stack", backtrace_command,
2674 _("Backtrace of the stack, or innermost COUNT frames."));
2675 add_info_alias ("s", "stack", 1);
2676 add_info ("frame", frame_info,
2677 _("All about selected stack frame, or frame at ADDR."));
2678 add_info_alias ("f", "frame", 1);
2679 add_info ("locals", locals_info,
2680 _("Local variables of current stack frame."));
2681 add_info ("args", args_info,
2682 _("Argument variables of current stack frame."));
2684 add_com ("l", class_info, args_plus_locals_info,
2685 _("Argument and local variables of current stack frame."));
2688 add_com ("func", class_stack, func_command, _("\
2689 Select the stack frame that contains <func>.\n\
2690 Usage: func <name>\n"));
2692 add_setshow_enum_cmd ("frame-arguments", class_stack,
2693 print_frame_arguments_choices, &print_frame_arguments,
2694 _("Set printing of non-scalar frame arguments"),
2695 _("Show printing of non-scalar frame arguments"),
2696 NULL, NULL, NULL, &setprintlist, &showprintlist);
2698 add_setshow_boolean_cmd ("frame-arguments", no_class,
2699 &print_raw_frame_arguments, _("\
2700 Set whether to print frame arguments in raw form."), _("\
2701 Show whether to print frame arguments in raw form."), _("\
2702 If set, frame arguments are printed in raw form, bypassing any\n\
2703 pretty-printers for that value."),
2705 &setprintrawlist, &showprintrawlist);
2707 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2708 &disassemble_next_line, _("\
2709 Set whether to disassemble next source line or insn when execution stops."),
2711 Show whether to disassemble next source line or insn when execution stops."),
2713 If ON, GDB will display disassembly of the next source line, in addition\n\
2714 to displaying the source line itself. If the next source line cannot\n\
2715 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2716 will display disassembly of next instruction instead of showing the\n\
2718 If AUTO, display disassembly of next instruction only if the source line\n\
2719 cannot be displayed.\n\
2720 If OFF (which is the default), never display the disassembly of the next\n\
2723 show_disassemble_next_line,
2724 &setlist, &showlist);
2725 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2727 add_setshow_enum_cmd ("entry-values", class_stack,
2728 print_entry_values_choices, &print_entry_values,
2729 _("Set printing of function arguments at function "
2731 _("Show printing of function arguments at function "
2734 GDB can sometimes determine the values of function arguments at entry,\n\
2735 in addition to their current values. This option tells GDB whether\n\
2736 to print the current value, the value at entry (marked as val@entry),\n\
2737 or both. Note that one or both of these values may be <optimized out>."),
2738 NULL, NULL, &setprintlist, &showprintlist);