1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
57 #include "python/python.h"
59 void (*deprecated_selected_frame_level_changed_hook) (int);
61 /* The possible choices of "set print frame-arguments", and the value
64 static const char *const print_frame_arguments_choices[] =
65 {"all", "scalars", "none", NULL};
66 static const char *print_frame_arguments = "scalars";
68 /* If non-zero, don't invoke pretty-printers for frame arguments. */
69 static int print_raw_frame_arguments;
71 /* The possible choices of "set print entry-values", and the value
74 const char print_entry_values_no[] = "no";
75 const char print_entry_values_only[] = "only";
76 const char print_entry_values_preferred[] = "preferred";
77 const char print_entry_values_if_needed[] = "if-needed";
78 const char print_entry_values_both[] = "both";
79 const char print_entry_values_compact[] = "compact";
80 const char print_entry_values_default[] = "default";
81 static const char *const print_entry_values_choices[] =
83 print_entry_values_no,
84 print_entry_values_only,
85 print_entry_values_preferred,
86 print_entry_values_if_needed,
87 print_entry_values_both,
88 print_entry_values_compact,
89 print_entry_values_default,
92 const char *print_entry_values = print_entry_values_default;
94 /* Prototypes for local functions. */
96 static void print_frame_local_vars (struct frame_info *, int,
99 static void print_frame (struct frame_info *frame, int print_level,
100 enum print_what print_what, int print_args,
101 struct symtab_and_line sal);
103 static void set_last_displayed_sal (int valid,
104 struct program_space *pspace,
106 struct symtab *symtab,
109 /* Zero means do things normally; we are interacting directly with the
110 user. One means print the full filename and linenumber when a
111 frame is printed, and do so in a format emacs18/emacs19.22 can
112 parse. Two means print similar annotations, but in many more
113 cases and in a slightly different syntax. */
115 int annotation_level = 0;
117 /* These variables hold the last symtab and line we displayed to the user.
118 * This is where we insert a breakpoint or a skiplist entry by default. */
119 static int last_displayed_sal_valid = 0;
120 static struct program_space *last_displayed_pspace = 0;
121 static CORE_ADDR last_displayed_addr = 0;
122 static struct symtab *last_displayed_symtab = 0;
123 static int last_displayed_line = 0;
126 /* Return 1 if we should display the address in addition to the location,
127 because we are in the middle of a statement. */
130 frame_show_address (struct frame_info *frame,
131 struct symtab_and_line sal)
133 /* If there is a line number, but no PC, then there is no location
134 information associated with this sal. The only way that should
135 happen is for the call sites of inlined functions (SAL comes from
136 find_frame_sal). Otherwise, we would have some PC range if the
137 SAL came from a line table. */
138 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
140 if (get_next_frame (frame) == NULL)
141 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
143 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
147 return get_frame_pc (frame) != sal.pc;
150 /* Show or print a stack frame FRAME briefly. The output is format
151 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
152 relative level, function name, argument list, and file name and
153 line number. If the frame's PC is not at the beginning of the
154 source line, the actual PC is printed at the beginning. */
157 print_stack_frame (struct frame_info *frame, int print_level,
158 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 int center = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
170 print_frame_info (frame, print_level, print_what, 1 /* print_args */);
171 set_current_sal_from_frame (frame, center);
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_available_contents_eq (val_deref, 0,
417 TYPE_LENGTH (type_deref)))
421 /* Value was not a reference; and its content matches. */
422 if (val == val_deref)
424 /* If the dereferenced content could not be fetched do not
426 else if (except.error == NO_ENTRY_VALUE_ERROR)
428 else if (except.message)
430 entryval_error = alloca (strlen (except.message) + 1);
431 strcpy (entryval_error, except.message);
439 /* Try to remove possibly duplicate error message for ENTRYARGP even
442 if (val_error && entryval_error
443 && strcmp (val_error, entryval_error) == 0)
445 entryval_error = NULL;
447 /* Do not se VAL_EQUAL as the same error message may be shown for
448 the entry value even if no entry values are present in the
454 if (entryval == NULL)
456 if (print_entry_values == print_entry_values_preferred)
458 TRY_CATCH (except, RETURN_MASK_ERROR)
460 val = read_var_value (sym, frame);
464 val_error = alloca (strlen (except.message) + 1);
465 strcpy (val_error, except.message);
468 if (print_entry_values == print_entry_values_only
469 || print_entry_values == print_entry_values_both
470 || (print_entry_values == print_entry_values_preferred
471 && (!val || value_optimized_out (val))))
473 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
474 entryval_error = NULL;
477 if ((print_entry_values == print_entry_values_compact
478 || print_entry_values == print_entry_values_if_needed
479 || print_entry_values == print_entry_values_preferred)
480 && (!val || value_optimized_out (val)) && entryval != NULL)
488 argp->error = val_error ? xstrdup (val_error) : NULL;
489 if (!val && !val_error)
490 argp->entry_kind = print_entry_values_only;
491 else if ((print_entry_values == print_entry_values_compact
492 || print_entry_values == print_entry_values_default) && val_equal)
494 argp->entry_kind = print_entry_values_compact;
495 gdb_assert (!ui_out_is_mi_like_p (current_uiout));
498 argp->entry_kind = print_entry_values_no;
500 entryargp->sym = sym;
501 entryargp->val = entryval;
502 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
503 if (!entryval && !entryval_error)
504 entryargp->entry_kind = print_entry_values_no;
506 entryargp->entry_kind = print_entry_values_only;
509 /* Print the arguments of frame FRAME on STREAM, given the function
510 FUNC running in that frame (as a symbol), where NUM is the number
511 of arguments according to the stack frame (or -1 if the number of
512 arguments is unknown). */
514 /* Note that currently the "number of arguments according to the
515 stack frame" is only known on VAX where i refers to the "number of
516 ints of arguments according to the stack frame". */
519 print_frame_args (struct symbol *func, struct frame_info *frame,
520 int num, struct ui_file *stream)
522 struct ui_out *uiout = current_uiout;
524 /* Offset of next stack argument beyond the one we have seen that is
525 at the highest offset, or -1 if we haven't come to a stack
527 long highest_offset = -1;
528 /* Number of ints of arguments that we have printed so far. */
529 int args_printed = 0;
530 struct cleanup *old_chain;
532 /* True if we should print arguments, false otherwise. */
533 int print_args = strcmp (print_frame_arguments, "none");
535 stb = mem_fileopen ();
536 old_chain = make_cleanup_ui_file_delete (stb);
540 struct block *b = SYMBOL_BLOCK_VALUE (func);
541 struct block_iterator iter;
544 ALL_BLOCK_SYMBOLS (b, iter, sym)
546 struct frame_arg arg, entryarg;
550 /* Keep track of the highest stack argument offset seen, and
551 skip over any kinds of symbols we don't care about. */
553 if (!SYMBOL_IS_ARGUMENT (sym))
556 switch (SYMBOL_CLASS (sym))
561 long current_offset = SYMBOL_VALUE (sym);
562 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
564 /* Compute address of next argument by adding the size of
565 this argument and rounding to an int boundary. */
567 ((current_offset + arg_size + sizeof (int) - 1)
568 & ~(sizeof (int) - 1));
570 /* If this is the highest offset seen yet, set
572 if (highest_offset == -1
573 || (current_offset > highest_offset))
574 highest_offset = current_offset;
576 /* Add the number of ints we're about to print to
578 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
581 /* We care about types of symbols, but don't need to
582 keep track of stack offsets in them. */
584 case LOC_REGPARM_ADDR:
586 case LOC_OPTIMIZED_OUT:
591 /* We have to look up the symbol because arguments can have
592 two entries (one a parameter, one a local) and the one we
593 want is the local, which lookup_symbol will find for us.
594 This includes gcc1 (not gcc2) on SPARC when passing a
595 small structure and gcc2 when the argument type is float
596 and it is passed as a double and converted to float by
597 the prologue (in the latter case the type of the LOC_ARG
598 symbol is double and the type of the LOC_LOCAL symbol is
600 /* But if the parameter name is null, don't try it. Null
601 parameter names occur on the RS/6000, for traceback
602 tables. FIXME, should we even print them? */
604 if (*SYMBOL_LINKAGE_NAME (sym))
608 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
609 b, VAR_DOMAIN, NULL);
610 gdb_assert (nsym != NULL);
611 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
612 && !SYMBOL_IS_ARGUMENT (nsym))
614 /* There is a LOC_ARG/LOC_REGISTER pair. This means
615 that it was passed on the stack and loaded into a
616 register, or passed in a register and stored in a
617 stack slot. GDB 3.x used the LOC_ARG; GDB
618 4.0-4.11 used the LOC_REGISTER.
620 Reasons for using the LOC_ARG:
622 (1) Because find_saved_registers may be slow for
625 (2) Because registers are often re-used and stack
626 slots rarely (never?) are. Therefore using
627 the stack slot is much less likely to print
630 Reasons why we might want to use the LOC_REGISTER:
632 (1) So that the backtrace prints the same value
633 as "print foo". I see no compelling reason
634 why this needs to be the case; having the
635 backtrace print the value which was passed
636 in, and "print foo" print the value as
637 modified within the called function, makes
640 Additional note: It might be nice if "info args"
641 displayed both values.
643 One more note: There is a case with SPARC
644 structure passing where we need to use the
645 LOC_REGISTER, but this is dealt with by creating
646 a single LOC_REGPARM in symbol reading. */
648 /* Leave sym (the LOC_ARG) alone. */
655 /* Print the current arg. */
657 ui_out_text (uiout, ", ");
658 ui_out_wrap_hint (uiout, " ");
662 memset (&arg, 0, sizeof (arg));
664 arg.entry_kind = print_entry_values_no;
665 memset (&entryarg, 0, sizeof (entryarg));
667 entryarg.entry_kind = print_entry_values_no;
670 read_frame_arg (sym, frame, &arg, &entryarg);
672 if (arg.entry_kind != print_entry_values_only)
673 print_frame_arg (&arg);
675 if (entryarg.entry_kind != print_entry_values_no)
677 if (arg.entry_kind != print_entry_values_only)
679 ui_out_text (uiout, ", ");
680 ui_out_wrap_hint (uiout, " ");
683 print_frame_arg (&entryarg);
687 xfree (entryarg.error);
693 /* Don't print nameless args in situations where we don't know
694 enough about the stack to find them. */
699 if (highest_offset == -1)
700 start = gdbarch_frame_args_skip (get_frame_arch (frame));
702 start = highest_offset;
704 print_frame_nameless_args (frame, start, num - args_printed,
708 do_cleanups (old_chain);
711 /* Set the current source and line to the location given by frame
712 FRAME, if possible. When CENTER is true, adjust so the relevant
713 line is in the center of the next 'list'. */
716 set_current_sal_from_frame (struct frame_info *frame, int center)
718 struct symtab_and_line sal;
720 find_frame_sal (frame, &sal);
724 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
725 set_current_source_symtab_and_line (&sal);
729 /* If ON, GDB will display disassembly of the next source line when
730 execution of the program being debugged stops.
731 If AUTO (which is the default), or there's no line info to determine
732 the source line of the next instruction, display disassembly of next
733 instruction instead. */
735 static enum auto_boolean disassemble_next_line;
738 show_disassemble_next_line (struct ui_file *file, int from_tty,
739 struct cmd_list_element *c,
742 fprintf_filtered (file,
743 _("Debugger's willingness to use "
744 "disassemble-next-line is %s.\n"),
748 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
749 because it will be broken by filter sometime. */
752 do_gdb_disassembly (struct gdbarch *gdbarch,
753 int how_many, CORE_ADDR low, CORE_ADDR high)
755 volatile struct gdb_exception exception;
757 TRY_CATCH (exception, RETURN_MASK_ERROR)
759 gdb_disassembly (gdbarch, current_uiout, 0,
760 DISASSEMBLY_RAW_INSN, how_many,
763 if (exception.reason < 0)
765 /* If an exception was thrown while doing the disassembly, print
766 the error message, to give the user a clue of what happened. */
767 exception_print (gdb_stderr, exception);
771 /* Print information about frame FRAME. The output is format according
772 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
775 SRC_LINE: Print only source line.
776 LOCATION: Print only location.
777 LOC_AND_SRC: Print location and source line.
779 Used in "where" output, and to emit breakpoint or step
783 print_frame_info (struct frame_info *frame, int print_level,
784 enum print_what print_what, int print_args)
786 struct gdbarch *gdbarch = get_frame_arch (frame);
787 struct symtab_and_line sal;
790 struct ui_out *uiout = current_uiout;
792 if (get_frame_type (frame) == DUMMY_FRAME
793 || get_frame_type (frame) == SIGTRAMP_FRAME
794 || get_frame_type (frame) == ARCH_FRAME)
796 struct cleanup *uiout_cleanup
797 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
799 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
800 gdbarch, get_frame_pc (frame));
802 /* Do this regardless of SOURCE because we don't have any source
803 to list for this frame. */
806 ui_out_text (uiout, "#");
807 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
808 frame_relative_level (frame));
810 if (ui_out_is_mi_like_p (uiout))
812 annotate_frame_address ();
813 ui_out_field_core_addr (uiout, "addr",
814 gdbarch, get_frame_pc (frame));
815 annotate_frame_address_end ();
818 if (get_frame_type (frame) == DUMMY_FRAME)
820 annotate_function_call ();
821 ui_out_field_string (uiout, "func", "<function called from gdb>");
823 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
825 annotate_signal_handler_caller ();
826 ui_out_field_string (uiout, "func", "<signal handler called>");
828 else if (get_frame_type (frame) == ARCH_FRAME)
830 ui_out_field_string (uiout, "func", "<cross-architecture call>");
832 ui_out_text (uiout, "\n");
833 annotate_frame_end ();
835 do_cleanups (uiout_cleanup);
839 /* If FRAME is not the innermost frame, that normally means that
840 FRAME->pc points to *after* the call instruction, and we want to
841 get the line containing the call, never the next line. But if
842 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
843 next frame was not entered as the result of a call, and we want
844 to get the line containing FRAME->pc. */
845 find_frame_sal (frame, &sal);
847 location_print = (print_what == LOCATION
848 || print_what == LOC_AND_ADDRESS
849 || print_what == SRC_AND_LOC);
851 if (location_print || !sal.symtab)
852 print_frame (frame, print_level, print_what, print_args, sal);
854 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
856 /* If disassemble-next-line is set to auto or on and doesn't have
857 the line debug messages for $pc, output the next instruction. */
858 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
859 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
860 && source_print && !sal.symtab)
861 do_gdb_disassembly (get_frame_arch (frame), 1,
862 get_frame_pc (frame), get_frame_pc (frame) + 1);
864 if (source_print && sal.symtab)
867 int mid_statement = ((print_what == SRC_LINE)
868 && frame_show_address (frame, sal));
870 if (annotation_level)
871 done = identify_source_line (sal.symtab, sal.line, mid_statement,
872 get_frame_pc (frame));
875 if (deprecated_print_frame_info_listing_hook)
876 deprecated_print_frame_info_listing_hook (sal.symtab,
881 struct value_print_options opts;
883 get_user_print_options (&opts);
884 /* We used to do this earlier, but that is clearly
885 wrong. This function is used by many different
886 parts of gdb, including normal_stop in infrun.c,
887 which uses this to print out the current PC
888 when we stepi/nexti into the middle of a source
889 line. Only the command line really wants this
890 behavior. Other UIs probably would like the
891 ability to decide for themselves if it is desired. */
892 if (opts.addressprint && mid_statement)
894 ui_out_field_core_addr (uiout, "addr",
895 gdbarch, get_frame_pc (frame));
896 ui_out_text (uiout, "\t");
899 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
903 /* If disassemble-next-line is set to on and there is line debug
904 messages, output assembly codes for next line. */
905 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
906 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
909 if (print_what != LOCATION)
913 if (get_frame_pc_if_available (frame, &pc))
914 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
916 set_last_displayed_sal (0, 0, 0, 0, 0);
919 annotate_frame_end ();
921 gdb_flush (gdb_stdout);
924 /* Remember the last symtab and line we displayed, which we use e.g.
925 * as the place to put a breakpoint when the `break' command is
926 * invoked with no arguments. */
929 set_last_displayed_sal (int valid, struct program_space *pspace,
930 CORE_ADDR addr, struct symtab *symtab,
933 last_displayed_sal_valid = valid;
934 last_displayed_pspace = pspace;
935 last_displayed_addr = addr;
936 last_displayed_symtab = symtab;
937 last_displayed_line = line;
938 if (valid && pspace == NULL)
940 clear_last_displayed_sal ();
941 internal_error (__FILE__, __LINE__,
942 _("Trying to set NULL pspace."));
946 /* Forget the last sal we displayed. */
949 clear_last_displayed_sal (void)
951 last_displayed_sal_valid = 0;
952 last_displayed_pspace = 0;
953 last_displayed_addr = 0;
954 last_displayed_symtab = 0;
955 last_displayed_line = 0;
958 /* Is our record of the last sal we displayed valid? If not,
959 * the get_last_displayed_* functions will return NULL or 0, as
963 last_displayed_sal_is_valid (void)
965 return last_displayed_sal_valid;
968 /* Get the pspace of the last sal we displayed, if it's valid. */
970 struct program_space *
971 get_last_displayed_pspace (void)
973 if (last_displayed_sal_valid)
974 return last_displayed_pspace;
978 /* Get the address of the last sal we displayed, if it's valid. */
981 get_last_displayed_addr (void)
983 if (last_displayed_sal_valid)
984 return last_displayed_addr;
988 /* Get the symtab of the last sal we displayed, if it's valid. */
991 get_last_displayed_symtab (void)
993 if (last_displayed_sal_valid)
994 return last_displayed_symtab;
998 /* Get the line of the last sal we displayed, if it's valid. */
1001 get_last_displayed_line (void)
1003 if (last_displayed_sal_valid)
1004 return last_displayed_line;
1008 /* Get the last sal we displayed, if it's valid. */
1011 get_last_displayed_sal (struct symtab_and_line *sal)
1013 if (last_displayed_sal_valid)
1015 sal->pspace = last_displayed_pspace;
1016 sal->pc = last_displayed_addr;
1017 sal->symtab = last_displayed_symtab;
1018 sal->line = last_displayed_line;
1030 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1031 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1034 find_frame_funname (struct frame_info *frame, char **funname,
1035 enum language *funlang, struct symbol **funcp)
1037 struct symbol *func;
1040 *funlang = language_unknown;
1044 func = get_frame_function (frame);
1047 /* In certain pathological cases, the symtabs give the wrong
1048 function (when we are in the first function in a file which
1049 is compiled without debugging symbols, the previous function
1050 is compiled with debugging symbols, and the "foo.o" symbol
1051 that is supposed to tell us where the file with debugging
1052 symbols ends has been truncated by ar because it is longer
1053 than 15 characters). This also occurs if the user uses asm()
1054 to create a function but not stabs for it (in a file compiled
1057 So look in the minimal symbol tables as well, and if it comes
1058 up with a larger address for the function use that instead.
1059 I don't think this can ever cause any problems; there
1060 shouldn't be any minimal symbols in the middle of a function;
1061 if this is ever changed many parts of GDB will need to be
1062 changed (and we'll create a find_pc_minimal_function or some
1065 struct bound_minimal_symbol msymbol;
1067 /* Don't attempt to do this for inlined functions, which do not
1068 have a corresponding minimal symbol. */
1069 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1071 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1073 memset (&msymbol, 0, sizeof (msymbol));
1075 if (msymbol.minsym != NULL
1076 && (SYMBOL_VALUE_ADDRESS (msymbol.minsym)
1077 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
1079 /* We also don't know anything about the function besides
1080 its address and name. */
1082 *funname = xstrdup (SYMBOL_PRINT_NAME (msymbol.minsym));
1083 *funlang = SYMBOL_LANGUAGE (msymbol.minsym);
1087 *funname = xstrdup (SYMBOL_PRINT_NAME (func));
1088 *funlang = SYMBOL_LANGUAGE (func);
1091 if (*funlang == language_cplus)
1093 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1094 to display the demangled name that we already have
1095 stored in the symbol table, but we stored a version
1096 with DMGL_PARAMS turned on, and here we don't want to
1097 display parameters. So remove the parameters. */
1098 char *func_only = cp_remove_params (*funname);
1103 *funname = func_only;
1110 struct bound_minimal_symbol msymbol;
1113 if (!get_frame_address_in_block_if_available (frame, &pc))
1116 msymbol = lookup_minimal_symbol_by_pc (pc);
1117 if (msymbol.minsym != NULL)
1119 *funname = xstrdup (SYMBOL_PRINT_NAME (msymbol.minsym));
1120 *funlang = SYMBOL_LANGUAGE (msymbol.minsym);
1126 print_frame (struct frame_info *frame, int print_level,
1127 enum print_what print_what, int print_args,
1128 struct symtab_and_line sal)
1130 struct gdbarch *gdbarch = get_frame_arch (frame);
1131 struct ui_out *uiout = current_uiout;
1132 char *funname = NULL;
1133 enum language funlang = language_unknown;
1134 struct ui_file *stb;
1135 struct cleanup *old_chain, *list_chain;
1136 struct value_print_options opts;
1137 struct symbol *func;
1141 pc_p = get_frame_pc_if_available (frame, &pc);
1143 stb = mem_fileopen ();
1144 old_chain = make_cleanup_ui_file_delete (stb);
1146 find_frame_funname (frame, &funname, &funlang, &func);
1147 make_cleanup (xfree, funname);
1149 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1152 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
1156 ui_out_text (uiout, "#");
1157 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
1158 frame_relative_level (frame));
1160 get_user_print_options (&opts);
1161 if (opts.addressprint)
1163 || frame_show_address (frame, sal)
1164 || print_what == LOC_AND_ADDRESS)
1166 annotate_frame_address ();
1168 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
1170 ui_out_field_string (uiout, "addr", "<unavailable>");
1171 annotate_frame_address_end ();
1172 ui_out_text (uiout, " in ");
1174 annotate_frame_function_name ();
1175 fprintf_symbol_filtered (stb, funname ? funname : "??",
1176 funlang, DMGL_ANSI);
1177 ui_out_field_stream (uiout, "func", stb);
1178 ui_out_wrap_hint (uiout, " ");
1179 annotate_frame_args ();
1181 ui_out_text (uiout, " (");
1184 struct gdbarch *gdbarch = get_frame_arch (frame);
1186 struct cleanup *args_list_chain;
1187 volatile struct gdb_exception e;
1189 if (gdbarch_frame_num_args_p (gdbarch))
1191 numargs = gdbarch_frame_num_args (gdbarch, frame);
1192 gdb_assert (numargs >= 0);
1197 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
1198 TRY_CATCH (e, RETURN_MASK_ERROR)
1200 print_frame_args (func, frame, numargs, gdb_stdout);
1202 /* FIXME: ARGS must be a list. If one argument is a string it
1203 will have " that will not be properly escaped. */
1204 /* Invoke ui_out_tuple_end. */
1205 do_cleanups (args_list_chain);
1208 ui_out_text (uiout, ")");
1211 const char *filename_display;
1213 filename_display = symtab_to_filename_for_display (sal.symtab);
1214 annotate_frame_source_begin ();
1215 ui_out_wrap_hint (uiout, " ");
1216 ui_out_text (uiout, " at ");
1217 annotate_frame_source_file ();
1218 ui_out_field_string (uiout, "file", filename_display);
1219 if (ui_out_is_mi_like_p (uiout))
1221 const char *fullname = symtab_to_fullname (sal.symtab);
1223 ui_out_field_string (uiout, "fullname", fullname);
1225 annotate_frame_source_file_end ();
1226 ui_out_text (uiout, ":");
1227 annotate_frame_source_line ();
1228 ui_out_field_int (uiout, "line", sal.line);
1229 annotate_frame_source_end ();
1232 if (pc_p && (funname == NULL || sal.symtab == NULL))
1234 char *lib = solib_name_from_address (get_frame_program_space (frame),
1235 get_frame_pc (frame));
1239 annotate_frame_where ();
1240 ui_out_wrap_hint (uiout, " ");
1241 ui_out_text (uiout, " from ");
1242 ui_out_field_string (uiout, "from", lib);
1246 /* do_cleanups will call ui_out_tuple_end() for us. */
1247 do_cleanups (list_chain);
1248 ui_out_text (uiout, "\n");
1249 do_cleanups (old_chain);
1253 /* Read a frame specification in whatever the appropriate format is
1254 from FRAME_EXP. Call error(), printing MESSAGE, if the
1255 specification is in any way invalid (so this function never returns
1256 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1257 the default selected frame was used. */
1259 static struct frame_info *
1260 parse_frame_specification_1 (const char *frame_exp, const char *message,
1261 int *selected_frame_p)
1264 struct value *args[4];
1265 CORE_ADDR addrs[ARRAY_SIZE (args)];
1267 if (frame_exp == NULL)
1275 struct cleanup *cleanup;
1278 /* Skip leading white space, bail of EOL. */
1279 frame_exp = skip_spaces_const (frame_exp);
1283 /* Parse the argument, extract it, save it. */
1285 *p && !isspace (*p);
1287 addr_string = savestring (frame_exp, p - frame_exp);
1289 cleanup = make_cleanup (xfree, addr_string);
1291 /* NOTE: Parse and evaluate expression, but do not use
1292 functions such as parse_and_eval_long or
1293 parse_and_eval_address to also extract the value.
1294 Instead value_as_long and value_as_address are used.
1295 This avoids problems with expressions that contain
1297 if (numargs >= ARRAY_SIZE (args))
1298 error (_("Too many args in frame specification"));
1299 args[numargs++] = parse_and_eval (addr_string);
1301 do_cleanups (cleanup);
1305 /* If no args, default to the selected frame. */
1308 if (selected_frame_p != NULL)
1309 (*selected_frame_p) = 1;
1310 return get_selected_frame (message);
1313 /* None of the remaining use the selected frame. */
1314 if (selected_frame_p != NULL)
1315 (*selected_frame_p) = 0;
1317 /* Assume the single arg[0] is an integer, and try using that to
1318 select a frame relative to current. */
1321 struct frame_info *fid;
1322 int level = value_as_long (args[0]);
1324 fid = find_relative_frame (get_current_frame (), &level);
1326 /* find_relative_frame was successful. */
1330 /* Convert each value into a corresponding address. */
1334 for (i = 0; i < numargs; i++)
1335 addrs[i] = value_as_address (args[i]);
1338 /* Assume that the single arg[0] is an address, use that to identify
1339 a frame with a matching ID. Should this also accept stack/pc or
1340 stack/pc/special. */
1343 struct frame_id id = frame_id_build_wild (addrs[0]);
1344 struct frame_info *fid;
1346 /* If (s)he specifies the frame with an address, he deserves
1347 what (s)he gets. Still, give the highest one that matches.
1348 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1350 for (fid = get_current_frame ();
1352 fid = get_prev_frame (fid))
1354 if (frame_id_eq (id, get_frame_id (fid)))
1356 struct frame_info *prev_frame;
1360 prev_frame = get_prev_frame (fid);
1362 || !frame_id_eq (id, get_frame_id (prev_frame)))
1371 /* We couldn't identify the frame as an existing frame, but
1372 perhaps we can create one with a single argument. */
1374 return create_new_frame (addrs[0], 0);
1375 else if (numargs == 2)
1376 return create_new_frame (addrs[0], addrs[1]);
1378 error (_("Too many args in frame specification"));
1381 static struct frame_info *
1382 parse_frame_specification (char *frame_exp)
1384 return parse_frame_specification_1 (frame_exp, NULL, NULL);
1387 /* Print verbosely the selected frame or the frame at address
1388 ADDR_EXP. Absolutely all information in the frame is printed. */
1391 frame_info (char *addr_exp, int from_tty)
1393 struct frame_info *fi;
1394 struct symtab_and_line sal;
1395 struct symbol *func;
1397 struct frame_info *calling_frame_info;
1399 const char *funname = 0;
1400 enum language funlang = language_unknown;
1401 const char *pc_regname;
1402 int selected_frame_p;
1403 struct gdbarch *gdbarch;
1404 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
1407 CORE_ADDR caller_pc;
1409 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
1410 gdbarch = get_frame_arch (fi);
1412 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1413 is not a good name. */
1414 if (gdbarch_pc_regnum (gdbarch) >= 0)
1415 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1416 easily not match that of the internal value returned by
1418 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1420 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1421 architectures will often have a hardware register called "pc",
1422 and that register's value, again, can easily not match
1426 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1427 find_frame_sal (fi, &sal);
1428 func = get_frame_function (fi);
1432 funname = SYMBOL_PRINT_NAME (func);
1433 funlang = SYMBOL_LANGUAGE (func);
1434 if (funlang == language_cplus)
1436 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1437 to display the demangled name that we already have
1438 stored in the symbol table, but we stored a version
1439 with DMGL_PARAMS turned on, and here we don't want to
1440 display parameters. So remove the parameters. */
1441 char *func_only = cp_remove_params (funname);
1445 funname = func_only;
1446 make_cleanup (xfree, func_only);
1450 else if (frame_pc_p)
1452 struct bound_minimal_symbol msymbol;
1454 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1455 if (msymbol.minsym != NULL)
1457 funname = SYMBOL_PRINT_NAME (msymbol.minsym);
1458 funlang = SYMBOL_LANGUAGE (msymbol.minsym);
1461 calling_frame_info = get_prev_frame (fi);
1463 if (selected_frame_p && frame_relative_level (fi) >= 0)
1465 printf_filtered (_("Stack level %d, frame at "),
1466 frame_relative_level (fi));
1470 printf_filtered (_("Stack frame at "));
1472 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1473 printf_filtered (":\n");
1474 printf_filtered (" %s = ", pc_regname);
1476 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1478 fputs_filtered ("<unavailable>", gdb_stdout);
1483 printf_filtered (" in ");
1484 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1485 DMGL_ANSI | DMGL_PARAMS);
1489 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1491 puts_filtered ("; ");
1493 printf_filtered ("saved %s ", pc_regname);
1494 if (frame_unwind_caller_pc_if_available (fi, &caller_pc))
1495 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1497 fputs_filtered ("<unavailable>", gdb_stdout);
1498 printf_filtered ("\n");
1500 if (calling_frame_info == NULL)
1502 enum unwind_stop_reason reason;
1504 reason = get_frame_unwind_stop_reason (fi);
1505 if (reason != UNWIND_NO_REASON)
1506 printf_filtered (_(" Outermost frame: %s\n"),
1507 frame_stop_reason_string (reason));
1509 else if (get_frame_type (fi) == TAILCALL_FRAME)
1510 puts_filtered (" tail call frame");
1511 else if (get_frame_type (fi) == INLINE_FRAME)
1512 printf_filtered (" inlined into frame %d",
1513 frame_relative_level (get_prev_frame (fi)));
1516 printf_filtered (" called by frame at ");
1517 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1520 if (get_next_frame (fi) && calling_frame_info)
1521 puts_filtered (",");
1523 if (get_next_frame (fi))
1525 printf_filtered (" caller of frame at ");
1526 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1529 if (get_next_frame (fi) || calling_frame_info)
1530 puts_filtered ("\n");
1533 printf_filtered (" source language %s.\n",
1534 language_str (s->language));
1537 /* Address of the argument list for this frame, or 0. */
1538 CORE_ADDR arg_list = get_frame_args_address (fi);
1539 /* Number of args for this frame, or -1 if unknown. */
1543 printf_filtered (" Arglist at unknown address.\n");
1546 printf_filtered (" Arglist at ");
1547 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1548 printf_filtered (",");
1550 if (!gdbarch_frame_num_args_p (gdbarch))
1553 puts_filtered (" args: ");
1557 numargs = gdbarch_frame_num_args (gdbarch, fi);
1558 gdb_assert (numargs >= 0);
1560 puts_filtered (" no args.");
1561 else if (numargs == 1)
1562 puts_filtered (" 1 arg: ");
1564 printf_filtered (" %d args: ", numargs);
1566 print_frame_args (func, fi, numargs, gdb_stdout);
1567 puts_filtered ("\n");
1571 /* Address of the local variables for this frame, or 0. */
1572 CORE_ADDR arg_list = get_frame_locals_address (fi);
1575 printf_filtered (" Locals at unknown address,");
1578 printf_filtered (" Locals at ");
1579 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1580 printf_filtered (",");
1584 /* Print as much information as possible on the location of all the
1587 enum lval_type lval;
1596 /* The sp is special; what's displayed isn't the save address, but
1597 the value of the previous frame's sp. This is a legacy thing,
1598 at one stage the frame cached the previous frame's SP instead
1599 of its address, hence it was easiest to just display the cached
1601 if (gdbarch_sp_regnum (gdbarch) >= 0)
1603 /* Find out the location of the saved stack pointer with out
1604 actually evaluating it. */
1605 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1606 &optimized, &unavailable, &lval, &addr,
1608 if (!optimized && !unavailable && lval == not_lval)
1610 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1611 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1612 gdb_byte value[MAX_REGISTER_SIZE];
1615 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1616 &optimized, &unavailable, &lval, &addr,
1618 /* NOTE: cagney/2003-05-22: This is assuming that the
1619 stack pointer was packed as an unsigned integer. That
1620 may or may not be valid. */
1621 sp = extract_unsigned_integer (value, sp_size, byte_order);
1622 printf_filtered (" Previous frame's sp is ");
1623 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1624 printf_filtered ("\n");
1627 else if (!optimized && !unavailable && lval == lval_memory)
1629 printf_filtered (" Previous frame's sp at ");
1630 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1631 printf_filtered ("\n");
1634 else if (!optimized && !unavailable && lval == lval_register)
1636 printf_filtered (" Previous frame's sp in %s\n",
1637 gdbarch_register_name (gdbarch, realnum));
1640 /* else keep quiet. */
1644 numregs = gdbarch_num_regs (gdbarch)
1645 + gdbarch_num_pseudo_regs (gdbarch);
1646 for (i = 0; i < numregs; i++)
1647 if (i != gdbarch_sp_regnum (gdbarch)
1648 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1650 /* Find out the location of the saved register without
1651 fetching the corresponding value. */
1652 frame_register_unwind (fi, i, &optimized, &unavailable,
1653 &lval, &addr, &realnum, NULL);
1654 /* For moment, only display registers that were saved on the
1656 if (!optimized && !unavailable && lval == lval_memory)
1659 puts_filtered (" Saved registers:\n ");
1661 puts_filtered (",");
1663 printf_filtered (" %s at ",
1664 gdbarch_register_name (gdbarch, i));
1665 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1669 if (count || need_nl)
1670 puts_filtered ("\n");
1673 do_cleanups (back_to);
1676 /* Print briefly all stack frames or just the innermost COUNT_EXP
1680 backtrace_command_1 (char *count_exp, int show_locals, int no_filters,
1683 struct frame_info *fi;
1686 struct frame_info *trailing;
1687 int trailing_level, py_start = 0, py_end = 0;
1688 enum py_bt_status result = PY_BT_ERROR;
1690 if (!target_has_stack)
1691 error (_("No stack."));
1693 /* The following code must do two things. First, it must set the
1694 variable TRAILING to the frame from which we should start
1695 printing. Second, it must set the variable count to the number
1696 of frames which we should print, or -1 if all of them. */
1697 trailing = get_current_frame ();
1702 count = parse_and_eval_long (count_exp);
1705 struct frame_info *current;
1711 while (current && count--)
1714 current = get_prev_frame (current);
1717 /* Will stop when CURRENT reaches the top of the stack.
1718 TRAILING will be COUNT below it. */
1722 trailing = get_prev_frame (trailing);
1723 current = get_prev_frame (current);
1743 /* Read in symbols for all of the frames. Need to do this in a
1744 separate pass so that "Reading in symbols for xxx" messages
1745 don't screw up the appearance of the backtrace. Also if
1746 people have strong opinions against reading symbols for
1747 backtrace this may have to be an option. */
1749 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1754 pc = get_frame_address_in_block (fi);
1755 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc));
1761 int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1762 enum py_frame_args arg_type;
1765 flags |= PRINT_LOCALS;
1767 if (!strcmp (print_frame_arguments, "scalars"))
1768 arg_type = CLI_SCALAR_VALUES;
1769 else if (!strcmp (print_frame_arguments, "all"))
1770 arg_type = CLI_ALL_VALUES;
1772 arg_type = NO_VALUES;
1774 result = apply_frame_filter (get_current_frame (), flags, arg_type,
1775 current_uiout, py_start, py_end);
1778 /* Run the inbuilt backtrace if there are no filters registered, or
1779 "no-filters" has been specified from the command. */
1780 if (no_filters || result == PY_BT_NO_FILTERS)
1782 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1786 /* Don't use print_stack_frame; if an error() occurs it probably
1787 means further attempts to backtrace would fail (on the other
1788 hand, perhaps the code does or could be fixed to make sure
1789 the frame->prev field gets set to NULL in that case). */
1791 print_frame_info (fi, 1, LOCATION, 1);
1794 struct frame_id frame_id = get_frame_id (fi);
1796 print_frame_local_vars (fi, 1, gdb_stdout);
1798 /* print_frame_local_vars invalidates FI. */
1799 fi = frame_find_by_id (frame_id);
1803 warning (_("Unable to restore previously selected frame."));
1808 /* Save the last frame to check for error conditions. */
1812 /* If we've stopped before the end, mention that. */
1814 printf_filtered (_("(More stack frames follow...)\n"));
1816 /* If we've run out of frames, and the reason appears to be an error
1817 condition, print it. */
1818 if (fi == NULL && trailing != NULL)
1820 enum unwind_stop_reason reason;
1822 reason = get_frame_unwind_stop_reason (trailing);
1823 if (reason >= UNWIND_FIRST_ERROR)
1824 printf_filtered (_("Backtrace stopped: %s\n"),
1825 frame_stop_reason_string (reason));
1831 backtrace_command (char *arg, int from_tty)
1833 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1834 int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1;
1842 argv = gdb_buildargv (arg);
1843 make_cleanup_freeargv (argv);
1845 for (i = 0; argv[i]; i++)
1849 for (j = 0; j < strlen (argv[i]); j++)
1850 argv[i][j] = tolower (argv[i][j]);
1852 if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
1856 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1857 fulltrace_arg = argc;
1861 arglen += strlen (argv[i]);
1867 if (fulltrace_arg >= 0 || no_filters >= 0)
1871 arg = xmalloc (arglen + 1);
1872 make_cleanup (xfree, arg);
1874 for (i = 0; i < argc; i++)
1876 if (i != fulltrace_arg && i != no_filters)
1878 strcat (arg, argv[i]);
1888 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
1889 no_filters >= 0 /* no frame-filters */, from_tty);
1891 do_cleanups (old_chain);
1895 backtrace_full_command (char *arg, int from_tty)
1897 backtrace_command_1 (arg, 1 /* show_locals */, 0, from_tty);
1901 /* Iterate over the local variables of a block B, calling CB with
1905 iterate_over_block_locals (struct block *b,
1906 iterate_over_block_arg_local_vars_cb cb,
1909 struct block_iterator iter;
1912 ALL_BLOCK_SYMBOLS (b, iter, sym)
1914 switch (SYMBOL_CLASS (sym))
1920 if (SYMBOL_IS_ARGUMENT (sym))
1922 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1924 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1928 /* Ignore symbols which are not locals. */
1935 /* Same, but print labels. */
1938 /* Commented out, as the code using this function has also been
1939 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1940 was commented out in the first place. The discussion introducing
1941 this change (2007-12-04: Support lexical blocks and function bodies
1942 that occupy non-contiguous address ranges) did not explain why
1943 this change was made. */
1945 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1946 int *have_default, struct ui_file *stream)
1948 struct block_iterator iter;
1950 int values_printed = 0;
1952 ALL_BLOCK_SYMBOLS (b, iter, sym)
1954 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1960 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1962 struct symtab_and_line sal;
1963 struct value_print_options opts;
1965 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1967 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1968 get_user_print_options (&opts);
1969 if (opts.addressprint)
1971 fprintf_filtered (stream, " ");
1972 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1975 fprintf_filtered (stream, " in file %s, line %d\n",
1976 sal.symtab->filename, sal.line);
1980 return values_printed;
1984 /* Iterate over all the local variables in block B, including all its
1985 superblocks, stopping when the top-level block is reached. */
1988 iterate_over_block_local_vars (struct block *block,
1989 iterate_over_block_arg_local_vars_cb cb,
1994 iterate_over_block_locals (block, cb, cb_data);
1995 /* After handling the function's top-level block, stop. Don't
1996 continue to its superblock, the block of per-file
1998 if (BLOCK_FUNCTION (block))
2000 block = BLOCK_SUPERBLOCK (block);
2004 /* Data to be passed around in the calls to the locals and args
2007 struct print_variable_and_value_data
2009 struct frame_id frame_id;
2011 struct ui_file *stream;
2015 /* The callback for the locals and args iterators. */
2018 do_print_variable_and_value (const char *print_name,
2022 struct print_variable_and_value_data *p = cb_data;
2023 struct frame_info *frame;
2025 frame = frame_find_by_id (p->frame_id);
2028 warning (_("Unable to restore previously selected frame."));
2032 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2034 /* print_variable_and_value invalidates FRAME. */
2037 p->values_printed = 1;
2040 /* Print all variables from the innermost up to the function block of FRAME.
2041 Print them with values to STREAM indented by NUM_TABS.
2043 This function will invalidate FRAME. */
2046 print_frame_local_vars (struct frame_info *frame, int num_tabs,
2047 struct ui_file *stream)
2049 struct print_variable_and_value_data cb_data;
2050 struct block *block;
2053 if (!get_frame_pc_if_available (frame, &pc))
2055 fprintf_filtered (stream,
2056 _("PC unavailable, cannot determine locals.\n"));
2060 block = get_frame_block (frame, 0);
2063 fprintf_filtered (stream, "No symbol table info available.\n");
2067 cb_data.frame_id = get_frame_id (frame);
2068 cb_data.num_tabs = 4 * num_tabs;
2069 cb_data.stream = stream;
2070 cb_data.values_printed = 0;
2072 iterate_over_block_local_vars (block,
2073 do_print_variable_and_value,
2076 /* do_print_variable_and_value invalidates FRAME. */
2079 if (!cb_data.values_printed)
2080 fprintf_filtered (stream, _("No locals.\n"));
2084 locals_info (char *args, int from_tty)
2086 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2090 /* Iterate over all the argument variables in block B.
2092 Returns 1 if any argument was walked; 0 otherwise. */
2095 iterate_over_block_arg_vars (struct block *b,
2096 iterate_over_block_arg_local_vars_cb cb,
2099 struct block_iterator iter;
2100 struct symbol *sym, *sym2;
2102 ALL_BLOCK_SYMBOLS (b, iter, sym)
2104 /* Don't worry about things which aren't arguments. */
2105 if (SYMBOL_IS_ARGUMENT (sym))
2107 /* We have to look up the symbol because arguments can have
2108 two entries (one a parameter, one a local) and the one we
2109 want is the local, which lookup_symbol will find for us.
2110 This includes gcc1 (not gcc2) on the sparc when passing a
2111 small structure and gcc2 when the argument type is float
2112 and it is passed as a double and converted to float by
2113 the prologue (in the latter case the type of the LOC_ARG
2114 symbol is double and the type of the LOC_LOCAL symbol is
2115 float). There are also LOC_ARG/LOC_REGISTER pairs which
2116 are not combined in symbol-reading. */
2118 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
2119 b, VAR_DOMAIN, NULL);
2120 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2125 /* Print all argument variables of the function of FRAME.
2126 Print them with values to STREAM.
2128 This function will invalidate FRAME. */
2131 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2133 struct print_variable_and_value_data cb_data;
2134 struct symbol *func;
2137 if (!get_frame_pc_if_available (frame, &pc))
2139 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2143 func = get_frame_function (frame);
2146 fprintf_filtered (stream, _("No symbol table info available.\n"));
2150 cb_data.frame_id = get_frame_id (frame);
2151 cb_data.num_tabs = 0;
2152 cb_data.stream = gdb_stdout;
2153 cb_data.values_printed = 0;
2155 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2156 do_print_variable_and_value, &cb_data);
2158 /* do_print_variable_and_value invalidates FRAME. */
2161 if (!cb_data.values_printed)
2162 fprintf_filtered (stream, _("No arguments.\n"));
2166 args_info (char *ignore, int from_tty)
2168 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2174 args_plus_locals_info (char *ignore, int from_tty)
2176 args_info (ignore, from_tty);
2177 locals_info (ignore, from_tty);
2181 /* Select frame FRAME. Also print the stack frame and show the source
2182 if this is the tui version. */
2184 select_and_print_frame (struct frame_info *frame)
2186 select_frame (frame);
2188 print_stack_frame (frame, 1, SRC_AND_LOC);
2191 /* Return the symbol-block in which the selected frame is executing.
2192 Can return zero under various legitimate circumstances.
2194 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2195 code address within the block returned. We use this to decide
2196 which macros are in scope. */
2199 get_selected_block (CORE_ADDR *addr_in_block)
2201 if (!has_stack_frames ())
2204 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2207 /* Find a frame a certain number of levels away from FRAME.
2208 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2209 Positive means go to earlier frames (up); negative, the reverse.
2210 The int that contains the number of levels is counted toward
2211 zero as the frames for those levels are found.
2212 If the top or bottom frame is reached, that frame is returned,
2213 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2214 how much farther the original request asked to go. */
2217 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2219 /* Going up is simple: just call get_prev_frame enough times or
2220 until the initial frame is reached. */
2221 while (*level_offset_ptr > 0)
2223 struct frame_info *prev = get_prev_frame (frame);
2227 (*level_offset_ptr)--;
2231 /* Going down is just as simple. */
2232 while (*level_offset_ptr < 0)
2234 struct frame_info *next = get_next_frame (frame);
2238 (*level_offset_ptr)++;
2245 /* The "select_frame" command. With no argument this is a NOP.
2246 Select the frame at level LEVEL_EXP if it is a valid level.
2247 Otherwise, treat LEVEL_EXP as an address expression and select it.
2249 See parse_frame_specification for more info on proper frame
2253 select_frame_command (char *level_exp, int from_tty)
2255 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
2258 /* The "frame" command. With no argument, print the selected frame
2259 briefly. With an argument, behave like select_frame and then print
2260 the selected frame. */
2263 frame_command (char *level_exp, int from_tty)
2265 select_frame_command (level_exp, from_tty);
2266 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2269 /* The XDB Compatibility command to print the current frame. */
2272 current_frame_command (char *level_exp, int from_tty)
2274 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
2277 /* Select the frame up one or COUNT_EXP stack levels from the
2278 previously selected frame, and print it briefly. */
2281 up_silently_base (char *count_exp)
2283 struct frame_info *frame;
2287 count = parse_and_eval_long (count_exp);
2289 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2290 if (count != 0 && count_exp == NULL)
2291 error (_("Initial frame selected; you cannot go up."));
2292 select_frame (frame);
2296 up_silently_command (char *count_exp, int from_tty)
2298 up_silently_base (count_exp);
2302 up_command (char *count_exp, int from_tty)
2304 up_silently_base (count_exp);
2305 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2308 /* Select the frame down one or COUNT_EXP stack levels from the previously
2309 selected frame, and print it briefly. */
2312 down_silently_base (char *count_exp)
2314 struct frame_info *frame;
2318 count = -parse_and_eval_long (count_exp);
2320 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2321 if (count != 0 && count_exp == NULL)
2323 /* We only do this if COUNT_EXP is not specified. That way
2324 "down" means to really go down (and let me know if that is
2325 impossible), but "down 9999" can be used to mean go all the
2326 way down without getting an error. */
2328 error (_("Bottom (innermost) frame selected; you cannot go down."));
2331 select_frame (frame);
2335 down_silently_command (char *count_exp, int from_tty)
2337 down_silently_base (count_exp);
2341 down_command (char *count_exp, int from_tty)
2343 down_silently_base (count_exp);
2344 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2349 return_command (char *retval_exp, int from_tty)
2351 /* Initialize it just to avoid a GCC false warning. */
2352 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2353 struct frame_info *thisframe;
2354 struct gdbarch *gdbarch;
2355 struct symbol *thisfun;
2356 struct value *return_value = NULL;
2357 struct value *function = NULL;
2358 const char *query_prefix = "";
2360 thisframe = get_selected_frame ("No selected frame.");
2361 thisfun = get_frame_function (thisframe);
2362 gdbarch = get_frame_arch (thisframe);
2364 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2365 error (_("Can not force return from an inlined function."));
2367 /* Compute the return value. If the computation triggers an error,
2368 let it bail. If the return type can't be handled, set
2369 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2373 struct expression *retval_expr = parse_expression (retval_exp);
2374 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
2375 struct type *return_type = NULL;
2377 /* Compute the return value. Should the computation fail, this
2378 call throws an error. */
2379 return_value = evaluate_expression (retval_expr);
2381 /* Cast return value to the return type of the function. Should
2382 the cast fail, this call throws an error. */
2383 if (thisfun != NULL)
2384 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2385 if (return_type == NULL)
2387 if (retval_expr->elts[0].opcode != UNOP_CAST
2388 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2389 error (_("Return value type not available for selected "
2391 "Please use an explicit cast of the value to return."));
2392 return_type = value_type (return_value);
2394 do_cleanups (old_chain);
2395 CHECK_TYPEDEF (return_type);
2396 return_value = value_cast (return_type, return_value);
2398 /* Make sure the value is fully evaluated. It may live in the
2399 stack frame we're about to pop. */
2400 if (value_lazy (return_value))
2401 value_fetch_lazy (return_value);
2403 if (thisfun != NULL)
2404 function = read_var_value (thisfun, thisframe);
2406 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2407 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2408 /* If the return-type is "void", don't try to find the
2409 return-value's location. However, do still evaluate the
2410 return expression so that, even when the expression result
2411 is discarded, side effects such as "return i++" still
2413 return_value = NULL;
2414 else if (thisfun != NULL)
2416 rv_conv = struct_return_convention (gdbarch, function, return_type);
2417 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2418 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2420 query_prefix = "The location at which to store the "
2421 "function's return value is unknown.\n"
2422 "If you continue, the return value "
2423 "that you specified will be ignored.\n";
2424 return_value = NULL;
2429 /* Does an interactive user really want to do this? Include
2430 information, such as how well GDB can handle the return value, in
2431 the query message. */
2436 if (thisfun == NULL)
2437 confirmed = query (_("%sMake selected stack frame return now? "),
2440 confirmed = query (_("%sMake %s return now? "), query_prefix,
2441 SYMBOL_PRINT_NAME (thisfun));
2443 error (_("Not confirmed"));
2446 /* Discard the selected frame and all frames inner-to it. */
2447 frame_pop (get_selected_frame (NULL));
2449 /* Store RETURN_VALUE in the just-returned register set. */
2450 if (return_value != NULL)
2452 struct type *return_type = value_type (return_value);
2453 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2455 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2456 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2457 gdbarch_return_value (gdbarch, function, return_type,
2458 get_current_regcache (), NULL /*read*/,
2459 value_contents (return_value) /*write*/);
2462 /* If we are at the end of a call dummy now, pop the dummy frame
2464 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2465 frame_pop (get_current_frame ());
2467 /* If interactive, print the frame that is now current. */
2469 frame_command ("0", 1);
2471 select_frame_command ("0", 0);
2474 /* Sets the scope to input function name, provided that the function
2475 is within the current stack frame. */
2477 struct function_bounds
2479 CORE_ADDR low, high;
2483 func_command (char *arg, int from_tty)
2485 struct frame_info *frame;
2487 struct symtabs_and_lines sals;
2490 struct function_bounds *func_bounds = NULL;
2491 struct cleanup *cleanups;
2496 frame = parse_frame_specification ("0");
2497 sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
2498 cleanups = make_cleanup (xfree, sals.sals);
2499 func_bounds = (struct function_bounds *) xmalloc (
2500 sizeof (struct function_bounds) * sals.nelts);
2501 make_cleanup (xfree, func_bounds);
2502 for (i = 0; (i < sals.nelts && !found); i++)
2504 if (sals.sals[i].pspace != current_program_space)
2505 func_bounds[i].low = func_bounds[i].high = 0;
2506 else if (sals.sals[i].pc == 0
2507 || find_pc_partial_function (sals.sals[i].pc, NULL,
2508 &func_bounds[i].low,
2509 &func_bounds[i].high) == 0)
2511 func_bounds[i].low = func_bounds[i].high = 0;
2517 for (i = 0; (i < sals.nelts && !found); i++)
2518 found = (get_frame_pc (frame) >= func_bounds[i].low
2519 && get_frame_pc (frame) < func_bounds[i].high);
2523 frame = find_relative_frame (frame, &level);
2526 while (!found && level == 0);
2528 do_cleanups (cleanups);
2531 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2532 else if (frame != get_selected_frame (NULL))
2533 select_and_print_frame (frame);
2536 /* Gets the language of the current frame. */
2539 get_frame_language (void)
2541 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2545 volatile struct gdb_exception ex;
2549 /* We determine the current frame language by looking up its
2550 associated symtab. To retrieve this symtab, we use the frame
2551 PC. However we cannot use the frame PC as is, because it
2552 usually points to the instruction following the "call", which
2553 is sometimes the first instruction of another function. So
2554 we rely on get_frame_address_in_block(), it provides us with
2555 a PC that is guaranteed to be inside the frame's code
2558 TRY_CATCH (ex, RETURN_MASK_ERROR)
2560 pc = get_frame_address_in_block (frame);
2564 if (ex.error != NOT_AVAILABLE_ERROR)
2565 throw_exception (ex);
2569 s = find_pc_symtab (pc);
2575 return language_unknown;
2579 /* Provide a prototype to silence -Wmissing-prototypes. */
2580 void _initialize_stack (void);
2583 _initialize_stack (void)
2585 add_com ("return", class_stack, return_command, _("\
2586 Make selected stack frame return to its caller.\n\
2587 Control remains in the debugger, but when you continue\n\
2588 execution will resume in the frame above the one now selected.\n\
2589 If an argument is given, it is an expression for the value to return."));
2591 add_com ("up", class_stack, up_command, _("\
2592 Select and print stack frame that called this one.\n\
2593 An argument says how many frames up to go."));
2594 add_com ("up-silently", class_support, up_silently_command, _("\
2595 Same as the `up' command, but does not print anything.\n\
2596 This is useful in command scripts."));
2598 add_com ("down", class_stack, down_command, _("\
2599 Select and print stack frame called by this one.\n\
2600 An argument says how many frames down to go."));
2601 add_com_alias ("do", "down", class_stack, 1);
2602 add_com_alias ("dow", "down", class_stack, 1);
2603 add_com ("down-silently", class_support, down_silently_command, _("\
2604 Same as the `down' command, but does not print anything.\n\
2605 This is useful in command scripts."));
2607 add_com ("frame", class_stack, frame_command, _("\
2608 Select and print a stack frame.\nWith no argument, \
2609 print the selected stack frame. (See also \"info frame\").\n\
2610 An argument specifies the frame to select.\n\
2611 It can be a stack frame number or the address of the frame.\n\
2612 With argument, nothing is printed if input is coming from\n\
2613 a command file or a user-defined command."));
2615 add_com_alias ("f", "frame", class_stack, 1);
2619 add_com ("L", class_stack, current_frame_command,
2620 _("Print the current stack frame.\n"));
2621 add_com_alias ("V", "frame", class_stack, 1);
2623 add_com ("select-frame", class_stack, select_frame_command, _("\
2624 Select a stack frame without printing anything.\n\
2625 An argument specifies the frame to select.\n\
2626 It can be a stack frame number or the address of the frame.\n"));
2628 add_com ("backtrace", class_stack, backtrace_command, _("\
2629 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2630 With a negative argument, print outermost -COUNT frames.\nUse of the \
2631 'full' qualifier also prints the values of the local variables.\n\
2632 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2633 on this backtrace.\n"));
2634 add_com_alias ("bt", "backtrace", class_stack, 0);
2637 add_com_alias ("t", "backtrace", class_stack, 0);
2638 add_com ("T", class_stack, backtrace_full_command, _("\
2639 Print backtrace of all stack frames, or innermost COUNT frames\n\
2640 and the values of the local variables.\n\
2641 With a negative argument, print outermost -COUNT frames.\n\
2642 Usage: T <count>\n"));
2645 add_com_alias ("where", "backtrace", class_alias, 0);
2646 add_info ("stack", backtrace_command,
2647 _("Backtrace of the stack, or innermost COUNT frames."));
2648 add_info_alias ("s", "stack", 1);
2649 add_info ("frame", frame_info,
2650 _("All about selected stack frame, or frame at ADDR."));
2651 add_info_alias ("f", "frame", 1);
2652 add_info ("locals", locals_info,
2653 _("Local variables of current stack frame."));
2654 add_info ("args", args_info,
2655 _("Argument variables of current stack frame."));
2657 add_com ("l", class_info, args_plus_locals_info,
2658 _("Argument and local variables of current stack frame."));
2661 add_com ("func", class_stack, func_command, _("\
2662 Select the stack frame that contains <func>.\n\
2663 Usage: func <name>\n"));
2665 add_setshow_enum_cmd ("frame-arguments", class_stack,
2666 print_frame_arguments_choices, &print_frame_arguments,
2667 _("Set printing of non-scalar frame arguments"),
2668 _("Show printing of non-scalar frame arguments"),
2669 NULL, NULL, NULL, &setprintlist, &showprintlist);
2671 add_setshow_boolean_cmd ("frame-arguments", no_class,
2672 &print_raw_frame_arguments, _("\
2673 Set whether to print frame arguments in raw form."), _("\
2674 Show whether to print frame arguments in raw form."), _("\
2675 If set, frame arguments are printed in raw form, bypassing any\n\
2676 pretty-printers for that value."),
2678 &setprintrawlist, &showprintrawlist);
2680 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2681 &disassemble_next_line, _("\
2682 Set whether to disassemble next source line or insn when execution stops."),
2684 Show whether to disassemble next source line or insn when execution stops."),
2686 If ON, GDB will display disassembly of the next source line, in addition\n\
2687 to displaying the source line itself. If the next source line cannot\n\
2688 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2689 will display disassembly of next instruction instead of showing the\n\
2691 If AUTO, display disassembly of next instruction only if the source line\n\
2692 cannot be displayed.\n\
2693 If OFF (which is the default), never display the disassembly of the next\n\
2696 show_disassemble_next_line,
2697 &setlist, &showlist);
2698 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2700 add_setshow_enum_cmd ("entry-values", class_stack,
2701 print_entry_values_choices, &print_entry_values,
2702 _("Set printing of function arguments at function "
2704 _("Show printing of function arguments at function "
2707 GDB can sometimes determine the values of function arguments at entry,\n\
2708 in addition to their current values. This option tells GDB whether\n\
2709 to print the current value, the value at entry (marked as val@entry),\n\
2710 or both. Note that one or both of these values may be <optimized out>."),
2711 NULL, NULL, &setprintlist, &showprintlist);