1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
51 #include "safe-ctype.h"
53 #include "extension.h"
55 /* The possible choices of "set print frame-arguments", and the value
58 static const char *const print_frame_arguments_choices[] =
59 {"all", "scalars", "none", NULL};
60 static const char *print_frame_arguments = "scalars";
62 /* If non-zero, don't invoke pretty-printers for frame arguments. */
63 static int print_raw_frame_arguments;
65 /* The possible choices of "set print entry-values", and the value
68 const char print_entry_values_no[] = "no";
69 const char print_entry_values_only[] = "only";
70 const char print_entry_values_preferred[] = "preferred";
71 const char print_entry_values_if_needed[] = "if-needed";
72 const char print_entry_values_both[] = "both";
73 const char print_entry_values_compact[] = "compact";
74 const char print_entry_values_default[] = "default";
75 static const char *const print_entry_values_choices[] =
77 print_entry_values_no,
78 print_entry_values_only,
79 print_entry_values_preferred,
80 print_entry_values_if_needed,
81 print_entry_values_both,
82 print_entry_values_compact,
83 print_entry_values_default,
86 const char *print_entry_values = print_entry_values_default;
88 /* Prototypes for local functions. */
90 static void print_frame_local_vars (struct frame_info *, int,
93 static void print_frame (struct frame_info *frame, int print_level,
94 enum print_what print_what, int print_args,
95 struct symtab_and_line sal);
97 static void set_last_displayed_sal (int valid,
98 struct program_space *pspace,
100 struct symtab *symtab,
103 /* Zero means do things normally; we are interacting directly with the
104 user. One means print the full filename and linenumber when a
105 frame is printed, and do so in a format emacs18/emacs19.22 can
106 parse. Two means print similar annotations, but in many more
107 cases and in a slightly different syntax. */
109 int annotation_level = 0;
111 /* These variables hold the last symtab and line we displayed to the user.
112 * This is where we insert a breakpoint or a skiplist entry by default. */
113 static int last_displayed_sal_valid = 0;
114 static struct program_space *last_displayed_pspace = 0;
115 static CORE_ADDR last_displayed_addr = 0;
116 static struct symtab *last_displayed_symtab = 0;
117 static int last_displayed_line = 0;
120 /* Return 1 if we should display the address in addition to the location,
121 because we are in the middle of a statement. */
124 frame_show_address (struct frame_info *frame,
125 struct symtab_and_line sal)
127 /* If there is a line number, but no PC, then there is no location
128 information associated with this sal. The only way that should
129 happen is for the call sites of inlined functions (SAL comes from
130 find_frame_sal). Otherwise, we would have some PC range if the
131 SAL came from a line table. */
132 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
134 if (get_next_frame (frame) == NULL)
135 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
137 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
141 return get_frame_pc (frame) != sal.pc;
144 /* Show or print a stack frame FRAME briefly. The output is formatted
145 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
146 relative level, function name, argument list, and file name and
147 line number. If the frame's PC is not at the beginning of the
148 source line, the actual PC is printed at the beginning. */
151 print_stack_frame (struct frame_info *frame, int print_level,
152 enum print_what print_what,
156 /* For mi, alway print location and address. */
157 if (ui_out_is_mi_like_p (current_uiout))
158 print_what = LOC_AND_ADDRESS;
162 print_frame_info (frame, print_level, print_what, 1 /* print_args */,
165 set_current_sal_from_frame (frame);
167 CATCH (e, RETURN_MASK_ERROR)
173 /* Print nameless arguments of frame FRAME on STREAM, where START is
174 the offset of the first nameless argument, and NUM is the number of
175 nameless arguments to print. FIRST is nonzero if this is the first
176 argument (not just the first nameless argument). */
179 print_frame_nameless_args (struct frame_info *frame, long start, int num,
180 int first, struct ui_file *stream)
182 struct gdbarch *gdbarch = get_frame_arch (frame);
183 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
188 for (i = 0; i < num; i++)
191 argsaddr = get_frame_args_address (frame);
194 arg_value = read_memory_integer (argsaddr + start,
195 sizeof (int), byte_order);
197 fprintf_filtered (stream, ", ");
198 fprintf_filtered (stream, "%ld", arg_value);
200 start += sizeof (int);
204 /* Print single argument of inferior function. ARG must be already
207 Errors are printed as if they would be the parameter value. Use zeroed ARG
208 iff it should not be printed accoring to user settings. */
211 print_frame_arg (const struct frame_arg *arg)
213 struct ui_out *uiout = current_uiout;
214 struct cleanup *old_chain;
216 const char *error_message = NULL;
218 stb = mem_fileopen ();
219 old_chain = make_cleanup_ui_file_delete (stb);
221 gdb_assert (!arg->val || !arg->error);
222 gdb_assert (arg->entry_kind == print_entry_values_no
223 || arg->entry_kind == print_entry_values_only
224 || (!ui_out_is_mi_like_p (uiout)
225 && arg->entry_kind == print_entry_values_compact));
227 annotate_arg_begin ();
229 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
230 fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
231 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
232 if (arg->entry_kind == print_entry_values_compact)
234 /* It is OK to provide invalid MI-like stream as with
235 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
236 fputs_filtered ("=", stb);
238 fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
239 SYMBOL_LANGUAGE (arg->sym),
240 DMGL_PARAMS | DMGL_ANSI);
242 if (arg->entry_kind == print_entry_values_only
243 || arg->entry_kind == print_entry_values_compact)
244 fputs_filtered ("@entry", stb);
245 ui_out_field_stream (uiout, "name", stb);
246 annotate_arg_name_end ();
247 ui_out_text (uiout, "=");
249 if (!arg->val && !arg->error)
250 ui_out_text (uiout, "...");
254 error_message = arg->error;
259 const struct language_defn *language;
260 struct value_print_options opts;
262 /* Avoid value_print because it will deref ref parameters. We
263 just want to print their addresses. Print ??? for args whose
264 address we do not know. We pass 2 as "recurse" to val_print
265 because our standard indentation here is 4 spaces, and
266 val_print indents 2 for each recurse. */
268 annotate_arg_value (value_type (arg->val));
270 /* Use the appropriate language to display our symbol, unless the
271 user forced the language to a specific language. */
272 if (language_mode == language_mode_auto)
273 language = language_def (SYMBOL_LANGUAGE (arg->sym));
275 language = current_language;
277 get_no_prettyformat_print_options (&opts);
279 opts.raw = print_raw_frame_arguments;
281 /* True in "summary" mode, false otherwise. */
282 opts.summary = !strcmp (print_frame_arguments, "scalars");
284 common_val_print (arg->val, stb, 2, &opts, language);
286 CATCH (except, RETURN_MASK_ERROR)
288 error_message = except.message;
292 if (error_message != NULL)
293 fprintf_filtered (stb, _("<error reading variable: %s>"),
297 ui_out_field_stream (uiout, "value", stb);
299 /* Also invoke ui_out_tuple_end. */
300 do_cleanups (old_chain);
305 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
306 responsible for xfree of ARGP->ERROR. This function never throws an
310 read_frame_local (struct symbol *sym, struct frame_info *frame,
311 struct frame_arg *argp)
319 argp->val = read_var_value (sym, NULL, frame);
321 CATCH (except, RETURN_MASK_ERROR)
323 argp->error = xstrdup (except.message);
328 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
329 responsible for xfree of ARGP->ERROR. This function never throws an
333 read_frame_arg (struct symbol *sym, struct frame_info *frame,
334 struct frame_arg *argp, struct frame_arg *entryargp)
336 struct value *val = NULL, *entryval = NULL;
337 char *val_error = NULL, *entryval_error = NULL;
340 if (print_entry_values != print_entry_values_only
341 && print_entry_values != print_entry_values_preferred)
345 val = read_var_value (sym, NULL, frame);
347 CATCH (except, RETURN_MASK_ERROR)
349 val_error = (char *) alloca (strlen (except.message) + 1);
350 strcpy (val_error, except.message);
355 if (SYMBOL_COMPUTED_OPS (sym) != NULL
356 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
357 && print_entry_values != print_entry_values_no
358 && (print_entry_values != print_entry_values_if_needed
359 || !val || value_optimized_out (val)))
363 const struct symbol_computed_ops *ops;
365 ops = SYMBOL_COMPUTED_OPS (sym);
366 entryval = ops->read_variable_at_entry (sym, frame);
368 CATCH (except, RETURN_MASK_ERROR)
370 if (except.error != NO_ENTRY_VALUE_ERROR)
372 entryval_error = (char *) alloca (strlen (except.message) + 1);
373 strcpy (entryval_error, except.message);
378 if (entryval != NULL && value_optimized_out (entryval))
381 if (print_entry_values == print_entry_values_compact
382 || print_entry_values == print_entry_values_default)
384 /* For MI do not try to use print_entry_values_compact for ARGP. */
386 if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
388 struct type *type = value_type (val);
390 if (value_lazy (val))
391 value_fetch_lazy (val);
392 if (value_lazy (entryval))
393 value_fetch_lazy (entryval);
395 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
397 /* Initialize it just to avoid a GCC false warning. */
398 struct value *val_deref = NULL, *entryval_deref;
400 /* DW_AT_GNU_call_site_value does match with the current
401 value. If it is a reference still try to verify if
402 dereferenced DW_AT_GNU_call_site_data_value does not
407 struct type *type_deref;
409 val_deref = coerce_ref (val);
410 if (value_lazy (val_deref))
411 value_fetch_lazy (val_deref);
412 type_deref = value_type (val_deref);
414 entryval_deref = coerce_ref (entryval);
415 if (value_lazy (entryval_deref))
416 value_fetch_lazy (entryval_deref);
418 /* If the reference addresses match but dereferenced
419 content does not match print them. */
421 && value_contents_eq (val_deref, 0,
423 TYPE_LENGTH (type_deref)))
426 CATCH (except, RETURN_MASK_ERROR)
428 /* If the dereferenced content could not be
429 fetched do not display anything. */
430 if (except.error == NO_ENTRY_VALUE_ERROR)
432 else if (except.message != NULL)
434 entryval_error = (char *) alloca (strlen (except.message) + 1);
435 strcpy (entryval_error, except.message);
440 /* Value was not a reference; and its content matches. */
441 if (val == val_deref)
449 /* Try to remove possibly duplicate error message for ENTRYARGP even
452 if (val_error && entryval_error
453 && strcmp (val_error, entryval_error) == 0)
455 entryval_error = NULL;
457 /* Do not se VAL_EQUAL as the same error message may be shown for
458 the entry value even if no entry values are present in the
464 if (entryval == NULL)
466 if (print_entry_values == print_entry_values_preferred)
468 gdb_assert (val == NULL);
472 val = read_var_value (sym, NULL, frame);
474 CATCH (except, RETURN_MASK_ERROR)
476 val_error = (char *) alloca (strlen (except.message) + 1);
477 strcpy (val_error, except.message);
481 if (print_entry_values == print_entry_values_only
482 || print_entry_values == print_entry_values_both
483 || (print_entry_values == print_entry_values_preferred
484 && (!val || value_optimized_out (val))))
486 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
487 entryval_error = NULL;
490 if ((print_entry_values == print_entry_values_compact
491 || print_entry_values == print_entry_values_if_needed
492 || print_entry_values == print_entry_values_preferred)
493 && (!val || value_optimized_out (val)) && entryval != NULL)
501 argp->error = val_error ? xstrdup (val_error) : NULL;
502 if (!val && !val_error)
503 argp->entry_kind = print_entry_values_only;
504 else if ((print_entry_values == print_entry_values_compact
505 || print_entry_values == print_entry_values_default) && val_equal)
507 argp->entry_kind = print_entry_values_compact;
508 gdb_assert (!ui_out_is_mi_like_p (current_uiout));
511 argp->entry_kind = print_entry_values_no;
513 entryargp->sym = sym;
514 entryargp->val = entryval;
515 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
516 if (!entryval && !entryval_error)
517 entryargp->entry_kind = print_entry_values_no;
519 entryargp->entry_kind = print_entry_values_only;
522 /* Print the arguments of frame FRAME on STREAM, given the function
523 FUNC running in that frame (as a symbol), where NUM is the number
524 of arguments according to the stack frame (or -1 if the number of
525 arguments is unknown). */
527 /* Note that currently the "number of arguments according to the
528 stack frame" is only known on VAX where i refers to the "number of
529 ints of arguments according to the stack frame". */
532 print_frame_args (struct symbol *func, struct frame_info *frame,
533 int num, struct ui_file *stream)
535 struct ui_out *uiout = current_uiout;
537 /* Offset of next stack argument beyond the one we have seen that is
538 at the highest offset, or -1 if we haven't come to a stack
540 long highest_offset = -1;
541 /* Number of ints of arguments that we have printed so far. */
542 int args_printed = 0;
543 struct cleanup *old_chain;
545 /* True if we should print arguments, false otherwise. */
546 int print_args = strcmp (print_frame_arguments, "none");
548 stb = mem_fileopen ();
549 old_chain = make_cleanup_ui_file_delete (stb);
553 const struct block *b = SYMBOL_BLOCK_VALUE (func);
554 struct block_iterator iter;
557 ALL_BLOCK_SYMBOLS (b, iter, sym)
559 struct frame_arg arg, entryarg;
563 /* Keep track of the highest stack argument offset seen, and
564 skip over any kinds of symbols we don't care about. */
566 if (!SYMBOL_IS_ARGUMENT (sym))
569 switch (SYMBOL_CLASS (sym))
574 long current_offset = SYMBOL_VALUE (sym);
575 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
577 /* Compute address of next argument by adding the size of
578 this argument and rounding to an int boundary. */
580 ((current_offset + arg_size + sizeof (int) - 1)
581 & ~(sizeof (int) - 1));
583 /* If this is the highest offset seen yet, set
585 if (highest_offset == -1
586 || (current_offset > highest_offset))
587 highest_offset = current_offset;
589 /* Add the number of ints we're about to print to
591 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
594 /* We care about types of symbols, but don't need to
595 keep track of stack offsets in them. */
597 case LOC_REGPARM_ADDR:
599 case LOC_OPTIMIZED_OUT:
604 /* We have to look up the symbol because arguments can have
605 two entries (one a parameter, one a local) and the one we
606 want is the local, which lookup_symbol will find for us.
607 This includes gcc1 (not gcc2) on SPARC when passing a
608 small structure and gcc2 when the argument type is float
609 and it is passed as a double and converted to float by
610 the prologue (in the latter case the type of the LOC_ARG
611 symbol is double and the type of the LOC_LOCAL symbol is
613 /* But if the parameter name is null, don't try it. Null
614 parameter names occur on the RS/6000, for traceback
615 tables. FIXME, should we even print them? */
617 if (*SYMBOL_LINKAGE_NAME (sym))
621 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
622 b, VAR_DOMAIN, NULL).symbol;
623 gdb_assert (nsym != NULL);
624 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
625 && !SYMBOL_IS_ARGUMENT (nsym))
627 /* There is a LOC_ARG/LOC_REGISTER pair. This means
628 that it was passed on the stack and loaded into a
629 register, or passed in a register and stored in a
630 stack slot. GDB 3.x used the LOC_ARG; GDB
631 4.0-4.11 used the LOC_REGISTER.
633 Reasons for using the LOC_ARG:
635 (1) Because find_saved_registers may be slow for
638 (2) Because registers are often re-used and stack
639 slots rarely (never?) are. Therefore using
640 the stack slot is much less likely to print
643 Reasons why we might want to use the LOC_REGISTER:
645 (1) So that the backtrace prints the same value
646 as "print foo". I see no compelling reason
647 why this needs to be the case; having the
648 backtrace print the value which was passed
649 in, and "print foo" print the value as
650 modified within the called function, makes
653 Additional note: It might be nice if "info args"
654 displayed both values.
656 One more note: There is a case with SPARC
657 structure passing where we need to use the
658 LOC_REGISTER, but this is dealt with by creating
659 a single LOC_REGPARM in symbol reading. */
661 /* Leave sym (the LOC_ARG) alone. */
668 /* Print the current arg. */
670 ui_out_text (uiout, ", ");
671 ui_out_wrap_hint (uiout, " ");
675 memset (&arg, 0, sizeof (arg));
677 arg.entry_kind = print_entry_values_no;
678 memset (&entryarg, 0, sizeof (entryarg));
680 entryarg.entry_kind = print_entry_values_no;
683 read_frame_arg (sym, frame, &arg, &entryarg);
685 if (arg.entry_kind != print_entry_values_only)
686 print_frame_arg (&arg);
688 if (entryarg.entry_kind != print_entry_values_no)
690 if (arg.entry_kind != print_entry_values_only)
692 ui_out_text (uiout, ", ");
693 ui_out_wrap_hint (uiout, " ");
696 print_frame_arg (&entryarg);
700 xfree (entryarg.error);
706 /* Don't print nameless args in situations where we don't know
707 enough about the stack to find them. */
712 if (highest_offset == -1)
713 start = gdbarch_frame_args_skip (get_frame_arch (frame));
715 start = highest_offset;
717 print_frame_nameless_args (frame, start, num - args_printed,
721 do_cleanups (old_chain);
724 /* Set the current source and line to the location given by frame
725 FRAME, if possible. When CENTER is true, adjust so the relevant
726 line is in the center of the next 'list'. */
729 set_current_sal_from_frame (struct frame_info *frame)
731 struct symtab_and_line sal;
733 find_frame_sal (frame, &sal);
734 if (sal.symtab != NULL)
735 set_current_source_symtab_and_line (&sal);
738 /* If ON, GDB will display disassembly of the next source line when
739 execution of the program being debugged stops.
740 If AUTO (which is the default), or there's no line info to determine
741 the source line of the next instruction, display disassembly of next
742 instruction instead. */
744 static enum auto_boolean disassemble_next_line;
747 show_disassemble_next_line (struct ui_file *file, int from_tty,
748 struct cmd_list_element *c,
751 fprintf_filtered (file,
752 _("Debugger's willingness to use "
753 "disassemble-next-line is %s.\n"),
757 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
758 because it will be broken by filter sometime. */
761 do_gdb_disassembly (struct gdbarch *gdbarch,
762 int how_many, CORE_ADDR low, CORE_ADDR high)
767 gdb_disassembly (gdbarch, current_uiout, 0,
768 DISASSEMBLY_RAW_INSN, how_many,
771 CATCH (exception, RETURN_MASK_ERROR)
773 /* If an exception was thrown while doing the disassembly, print
774 the error message, to give the user a clue of what happened. */
775 exception_print (gdb_stderr, exception);
780 /* Print information about frame FRAME. The output is format according
781 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
784 SRC_LINE: Print only source line.
785 LOCATION: Print only location.
786 LOC_AND_SRC: Print location and source line.
788 Used in "where" output, and to emit breakpoint or step
792 print_frame_info (struct frame_info *frame, int print_level,
793 enum print_what print_what, int print_args,
796 struct gdbarch *gdbarch = get_frame_arch (frame);
797 struct symtab_and_line sal;
800 struct ui_out *uiout = current_uiout;
802 if (get_frame_type (frame) == DUMMY_FRAME
803 || get_frame_type (frame) == SIGTRAMP_FRAME
804 || get_frame_type (frame) == ARCH_FRAME)
806 struct cleanup *uiout_cleanup
807 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
809 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
810 gdbarch, get_frame_pc (frame));
812 /* Do this regardless of SOURCE because we don't have any source
813 to list for this frame. */
816 ui_out_text (uiout, "#");
817 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
818 frame_relative_level (frame));
820 if (ui_out_is_mi_like_p (uiout))
822 annotate_frame_address ();
823 ui_out_field_core_addr (uiout, "addr",
824 gdbarch, get_frame_pc (frame));
825 annotate_frame_address_end ();
828 if (get_frame_type (frame) == DUMMY_FRAME)
830 annotate_function_call ();
831 ui_out_field_string (uiout, "func", "<function called from gdb>");
833 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
835 annotate_signal_handler_caller ();
836 ui_out_field_string (uiout, "func", "<signal handler called>");
838 else if (get_frame_type (frame) == ARCH_FRAME)
840 ui_out_field_string (uiout, "func", "<cross-architecture call>");
842 ui_out_text (uiout, "\n");
843 annotate_frame_end ();
845 /* If disassemble-next-line is set to auto or on output the next
847 if (disassemble_next_line == AUTO_BOOLEAN_AUTO
848 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
849 do_gdb_disassembly (get_frame_arch (frame), 1,
850 get_frame_pc (frame), get_frame_pc (frame) + 1);
852 do_cleanups (uiout_cleanup);
856 /* If FRAME is not the innermost frame, that normally means that
857 FRAME->pc points to *after* the call instruction, and we want to
858 get the line containing the call, never the next line. But if
859 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
860 next frame was not entered as the result of a call, and we want
861 to get the line containing FRAME->pc. */
862 find_frame_sal (frame, &sal);
864 location_print = (print_what == LOCATION
865 || print_what == LOC_AND_ADDRESS
866 || print_what == SRC_AND_LOC);
868 if (location_print || !sal.symtab)
869 print_frame (frame, print_level, print_what, print_args, sal);
871 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
873 /* If disassemble-next-line is set to auto or on and doesn't have
874 the line debug messages for $pc, output the next instruction. */
875 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
876 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
877 && source_print && !sal.symtab)
878 do_gdb_disassembly (get_frame_arch (frame), 1,
879 get_frame_pc (frame), get_frame_pc (frame) + 1);
881 if (source_print && sal.symtab)
884 int mid_statement = ((print_what == SRC_LINE)
885 && frame_show_address (frame, sal));
887 if (annotation_level)
888 done = identify_source_line (sal.symtab, sal.line, mid_statement,
889 get_frame_pc (frame));
892 if (deprecated_print_frame_info_listing_hook)
893 deprecated_print_frame_info_listing_hook (sal.symtab,
898 struct value_print_options opts;
900 get_user_print_options (&opts);
901 /* We used to do this earlier, but that is clearly
902 wrong. This function is used by many different
903 parts of gdb, including normal_stop in infrun.c,
904 which uses this to print out the current PC
905 when we stepi/nexti into the middle of a source
906 line. Only the command line really wants this
907 behavior. Other UIs probably would like the
908 ability to decide for themselves if it is desired. */
909 if (opts.addressprint && mid_statement)
911 ui_out_field_core_addr (uiout, "addr",
912 gdbarch, get_frame_pc (frame));
913 ui_out_text (uiout, "\t");
916 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
920 /* If disassemble-next-line is set to on and there is line debug
921 messages, output assembly codes for next line. */
922 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
923 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
930 if (get_frame_pc_if_available (frame, &pc))
931 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
933 set_last_displayed_sal (0, 0, 0, 0, 0);
936 annotate_frame_end ();
938 gdb_flush (gdb_stdout);
941 /* Remember the last symtab and line we displayed, which we use e.g.
942 * as the place to put a breakpoint when the `break' command is
943 * invoked with no arguments. */
946 set_last_displayed_sal (int valid, struct program_space *pspace,
947 CORE_ADDR addr, struct symtab *symtab,
950 last_displayed_sal_valid = valid;
951 last_displayed_pspace = pspace;
952 last_displayed_addr = addr;
953 last_displayed_symtab = symtab;
954 last_displayed_line = line;
955 if (valid && pspace == NULL)
957 clear_last_displayed_sal ();
958 internal_error (__FILE__, __LINE__,
959 _("Trying to set NULL pspace."));
963 /* Forget the last sal we displayed. */
966 clear_last_displayed_sal (void)
968 last_displayed_sal_valid = 0;
969 last_displayed_pspace = 0;
970 last_displayed_addr = 0;
971 last_displayed_symtab = 0;
972 last_displayed_line = 0;
975 /* Is our record of the last sal we displayed valid? If not,
976 * the get_last_displayed_* functions will return NULL or 0, as
980 last_displayed_sal_is_valid (void)
982 return last_displayed_sal_valid;
985 /* Get the pspace of the last sal we displayed, if it's valid. */
987 struct program_space *
988 get_last_displayed_pspace (void)
990 if (last_displayed_sal_valid)
991 return last_displayed_pspace;
995 /* Get the address of the last sal we displayed, if it's valid. */
998 get_last_displayed_addr (void)
1000 if (last_displayed_sal_valid)
1001 return last_displayed_addr;
1005 /* Get the symtab of the last sal we displayed, if it's valid. */
1008 get_last_displayed_symtab (void)
1010 if (last_displayed_sal_valid)
1011 return last_displayed_symtab;
1015 /* Get the line of the last sal we displayed, if it's valid. */
1018 get_last_displayed_line (void)
1020 if (last_displayed_sal_valid)
1021 return last_displayed_line;
1025 /* Get the last sal we displayed, if it's valid. */
1028 get_last_displayed_sal (struct symtab_and_line *sal)
1030 if (last_displayed_sal_valid)
1032 sal->pspace = last_displayed_pspace;
1033 sal->pc = last_displayed_addr;
1034 sal->symtab = last_displayed_symtab;
1035 sal->line = last_displayed_line;
1047 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1048 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1051 find_frame_funname (struct frame_info *frame, char **funname,
1052 enum language *funlang, struct symbol **funcp)
1054 struct symbol *func;
1057 *funlang = language_unknown;
1061 func = get_frame_function (frame);
1064 /* In certain pathological cases, the symtabs give the wrong
1065 function (when we are in the first function in a file which
1066 is compiled without debugging symbols, the previous function
1067 is compiled with debugging symbols, and the "foo.o" symbol
1068 that is supposed to tell us where the file with debugging
1069 symbols ends has been truncated by ar because it is longer
1070 than 15 characters). This also occurs if the user uses asm()
1071 to create a function but not stabs for it (in a file compiled
1074 So look in the minimal symbol tables as well, and if it comes
1075 up with a larger address for the function use that instead.
1076 I don't think this can ever cause any problems; there
1077 shouldn't be any minimal symbols in the middle of a function;
1078 if this is ever changed many parts of GDB will need to be
1079 changed (and we'll create a find_pc_minimal_function or some
1082 struct bound_minimal_symbol msymbol;
1084 /* Don't attempt to do this for inlined functions, which do not
1085 have a corresponding minimal symbol. */
1086 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1088 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1090 memset (&msymbol, 0, sizeof (msymbol));
1092 if (msymbol.minsym != NULL
1093 && (BMSYMBOL_VALUE_ADDRESS (msymbol)
1094 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
1096 /* We also don't know anything about the function besides
1097 its address and name. */
1099 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1100 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1104 const char *print_name = SYMBOL_PRINT_NAME (func);
1106 *funlang = SYMBOL_LANGUAGE (func);
1109 if (*funlang == language_cplus)
1111 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1112 to display the demangled name that we already have
1113 stored in the symbol table, but we stored a version
1114 with DMGL_PARAMS turned on, and here we don't want to
1115 display parameters. So remove the parameters. */
1116 char *func_only = cp_remove_params (print_name);
1119 *funname = func_only;
1122 /* If we didn't hit the C++ case above, set *funname here.
1123 This approach is taken to avoid having to install a
1124 cleanup in case cp_remove_params can throw. */
1125 if (*funname == NULL)
1126 *funname = xstrdup (print_name);
1131 struct bound_minimal_symbol msymbol;
1134 if (!get_frame_address_in_block_if_available (frame, &pc))
1137 msymbol = lookup_minimal_symbol_by_pc (pc);
1138 if (msymbol.minsym != NULL)
1140 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1141 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1147 print_frame (struct frame_info *frame, int print_level,
1148 enum print_what print_what, int print_args,
1149 struct symtab_and_line sal)
1151 struct gdbarch *gdbarch = get_frame_arch (frame);
1152 struct ui_out *uiout = current_uiout;
1153 char *funname = NULL;
1154 enum language funlang = language_unknown;
1155 struct ui_file *stb;
1156 struct cleanup *old_chain, *list_chain;
1157 struct value_print_options opts;
1158 struct symbol *func;
1162 pc_p = get_frame_pc_if_available (frame, &pc);
1164 stb = mem_fileopen ();
1165 old_chain = make_cleanup_ui_file_delete (stb);
1167 find_frame_funname (frame, &funname, &funlang, &func);
1168 make_cleanup (xfree, funname);
1170 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1173 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
1177 ui_out_text (uiout, "#");
1178 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
1179 frame_relative_level (frame));
1181 get_user_print_options (&opts);
1182 if (opts.addressprint)
1184 || frame_show_address (frame, sal)
1185 || print_what == LOC_AND_ADDRESS)
1187 annotate_frame_address ();
1189 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
1191 ui_out_field_string (uiout, "addr", "<unavailable>");
1192 annotate_frame_address_end ();
1193 ui_out_text (uiout, " in ");
1195 annotate_frame_function_name ();
1196 fprintf_symbol_filtered (stb, funname ? funname : "??",
1197 funlang, DMGL_ANSI);
1198 ui_out_field_stream (uiout, "func", stb);
1199 ui_out_wrap_hint (uiout, " ");
1200 annotate_frame_args ();
1202 ui_out_text (uiout, " (");
1205 struct gdbarch *gdbarch = get_frame_arch (frame);
1207 struct cleanup *args_list_chain;
1209 if (gdbarch_frame_num_args_p (gdbarch))
1211 numargs = gdbarch_frame_num_args (gdbarch, frame);
1212 gdb_assert (numargs >= 0);
1217 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
1220 print_frame_args (func, frame, numargs, gdb_stdout);
1222 CATCH (e, RETURN_MASK_ERROR)
1227 /* FIXME: ARGS must be a list. If one argument is a string it
1228 will have " that will not be properly escaped. */
1229 /* Invoke ui_out_tuple_end. */
1230 do_cleanups (args_list_chain);
1233 ui_out_text (uiout, ")");
1236 const char *filename_display;
1238 filename_display = symtab_to_filename_for_display (sal.symtab);
1239 annotate_frame_source_begin ();
1240 ui_out_wrap_hint (uiout, " ");
1241 ui_out_text (uiout, " at ");
1242 annotate_frame_source_file ();
1243 ui_out_field_string (uiout, "file", filename_display);
1244 if (ui_out_is_mi_like_p (uiout))
1246 const char *fullname = symtab_to_fullname (sal.symtab);
1248 ui_out_field_string (uiout, "fullname", fullname);
1250 annotate_frame_source_file_end ();
1251 ui_out_text (uiout, ":");
1252 annotate_frame_source_line ();
1253 ui_out_field_int (uiout, "line", sal.line);
1254 annotate_frame_source_end ();
1257 if (pc_p && (funname == NULL || sal.symtab == NULL))
1259 char *lib = solib_name_from_address (get_frame_program_space (frame),
1260 get_frame_pc (frame));
1264 annotate_frame_where ();
1265 ui_out_wrap_hint (uiout, " ");
1266 ui_out_text (uiout, " from ");
1267 ui_out_field_string (uiout, "from", lib);
1271 /* do_cleanups will call ui_out_tuple_end() for us. */
1272 do_cleanups (list_chain);
1273 ui_out_text (uiout, "\n");
1274 do_cleanups (old_chain);
1278 /* Read a frame specification in whatever the appropriate format is from
1279 FRAME_EXP. Call error() if the specification is in any way invalid (so
1280 this function never returns NULL). When SEPECTED_P is non-NULL set its
1281 target to indicate that the default selected frame was used. */
1283 static struct frame_info *
1284 parse_frame_specification (const char *frame_exp, int *selected_frame_p)
1287 struct value *args[4];
1288 CORE_ADDR addrs[ARRAY_SIZE (args)];
1290 if (frame_exp == NULL)
1298 struct cleanup *cleanup;
1301 /* Skip leading white space, bail of EOL. */
1302 frame_exp = skip_spaces_const (frame_exp);
1306 /* Parse the argument, extract it, save it. */
1308 *p && !ISSPACE (*p);
1310 addr_string = savestring (frame_exp, p - frame_exp);
1312 cleanup = make_cleanup (xfree, addr_string);
1314 /* NOTE: Parse and evaluate expression, but do not use
1315 functions such as parse_and_eval_long or
1316 parse_and_eval_address to also extract the value.
1317 Instead value_as_long and value_as_address are used.
1318 This avoids problems with expressions that contain
1320 if (numargs >= ARRAY_SIZE (args))
1321 error (_("Too many args in frame specification"));
1322 args[numargs++] = parse_and_eval (addr_string);
1324 do_cleanups (cleanup);
1328 /* If no args, default to the selected frame. */
1331 if (selected_frame_p != NULL)
1332 (*selected_frame_p) = 1;
1333 return get_selected_frame (_("No stack."));
1336 /* None of the remaining use the selected frame. */
1337 if (selected_frame_p != NULL)
1338 (*selected_frame_p) = 0;
1340 /* Assume the single arg[0] is an integer, and try using that to
1341 select a frame relative to current. */
1344 struct frame_info *fid;
1345 int level = value_as_long (args[0]);
1347 fid = find_relative_frame (get_current_frame (), &level);
1349 /* find_relative_frame was successful. */
1353 /* Convert each value into a corresponding address. */
1357 for (i = 0; i < numargs; i++)
1358 addrs[i] = value_as_address (args[i]);
1361 /* Assume that the single arg[0] is an address, use that to identify
1362 a frame with a matching ID. Should this also accept stack/pc or
1363 stack/pc/special. */
1366 struct frame_id id = frame_id_build_wild (addrs[0]);
1367 struct frame_info *fid;
1369 /* If (s)he specifies the frame with an address, he deserves
1370 what (s)he gets. Still, give the highest one that matches.
1371 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1373 for (fid = get_current_frame ();
1375 fid = get_prev_frame (fid))
1377 if (frame_id_eq (id, get_frame_id (fid)))
1379 struct frame_info *prev_frame;
1383 prev_frame = get_prev_frame (fid);
1385 || !frame_id_eq (id, get_frame_id (prev_frame)))
1394 /* We couldn't identify the frame as an existing frame, but
1395 perhaps we can create one with a single argument. */
1397 return create_new_frame (addrs[0], 0);
1398 else if (numargs == 2)
1399 return create_new_frame (addrs[0], addrs[1]);
1401 error (_("Too many args in frame specification"));
1404 /* Print verbosely the selected frame or the frame at address
1405 ADDR_EXP. Absolutely all information in the frame is printed. */
1408 frame_info (char *addr_exp, int from_tty)
1410 struct frame_info *fi;
1411 struct symtab_and_line sal;
1412 struct symbol *func;
1414 struct frame_info *calling_frame_info;
1416 const char *funname = 0;
1417 enum language funlang = language_unknown;
1418 const char *pc_regname;
1419 int selected_frame_p;
1420 struct gdbarch *gdbarch;
1421 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
1424 /* Initialize it to avoid "may be used uninitialized" warning. */
1425 CORE_ADDR caller_pc = 0;
1426 int caller_pc_p = 0;
1428 fi = parse_frame_specification (addr_exp, &selected_frame_p);
1429 gdbarch = get_frame_arch (fi);
1431 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1432 is not a good name. */
1433 if (gdbarch_pc_regnum (gdbarch) >= 0)
1434 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1435 easily not match that of the internal value returned by
1437 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1439 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1440 architectures will often have a hardware register called "pc",
1441 and that register's value, again, can easily not match
1445 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1446 find_frame_sal (fi, &sal);
1447 func = get_frame_function (fi);
1451 funname = SYMBOL_PRINT_NAME (func);
1452 funlang = SYMBOL_LANGUAGE (func);
1453 if (funlang == language_cplus)
1455 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1456 to display the demangled name that we already have
1457 stored in the symbol table, but we stored a version
1458 with DMGL_PARAMS turned on, and here we don't want to
1459 display parameters. So remove the parameters. */
1460 char *func_only = cp_remove_params (funname);
1464 funname = func_only;
1465 make_cleanup (xfree, func_only);
1469 else if (frame_pc_p)
1471 struct bound_minimal_symbol msymbol;
1473 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1474 if (msymbol.minsym != NULL)
1476 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1477 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1480 calling_frame_info = get_prev_frame (fi);
1482 if (selected_frame_p && frame_relative_level (fi) >= 0)
1484 printf_filtered (_("Stack level %d, frame at "),
1485 frame_relative_level (fi));
1489 printf_filtered (_("Stack frame at "));
1491 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1492 printf_filtered (":\n");
1493 printf_filtered (" %s = ", pc_regname);
1495 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1497 fputs_filtered ("<unavailable>", gdb_stdout);
1502 printf_filtered (" in ");
1503 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1504 DMGL_ANSI | DMGL_PARAMS);
1508 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1510 puts_filtered ("; ");
1512 printf_filtered ("saved %s = ", pc_regname);
1514 if (!frame_id_p (frame_unwind_caller_id (fi)))
1515 val_print_unavailable (gdb_stdout);
1520 caller_pc = frame_unwind_caller_pc (fi);
1523 CATCH (ex, RETURN_MASK_ERROR)
1527 case NOT_AVAILABLE_ERROR:
1528 val_print_unavailable (gdb_stdout);
1530 case OPTIMIZED_OUT_ERROR:
1531 val_print_not_saved (gdb_stdout);
1534 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1542 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1543 printf_filtered ("\n");
1545 if (calling_frame_info == NULL)
1547 enum unwind_stop_reason reason;
1549 reason = get_frame_unwind_stop_reason (fi);
1550 if (reason != UNWIND_NO_REASON)
1551 printf_filtered (_(" Outermost frame: %s\n"),
1552 frame_stop_reason_string (fi));
1554 else if (get_frame_type (fi) == TAILCALL_FRAME)
1555 puts_filtered (" tail call frame");
1556 else if (get_frame_type (fi) == INLINE_FRAME)
1557 printf_filtered (" inlined into frame %d",
1558 frame_relative_level (get_prev_frame (fi)));
1561 printf_filtered (" called by frame at ");
1562 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1565 if (get_next_frame (fi) && calling_frame_info)
1566 puts_filtered (",");
1568 if (get_next_frame (fi))
1570 printf_filtered (" caller of frame at ");
1571 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1574 if (get_next_frame (fi) || calling_frame_info)
1575 puts_filtered ("\n");
1578 printf_filtered (" source language %s.\n",
1579 language_str (s->language));
1582 /* Address of the argument list for this frame, or 0. */
1583 CORE_ADDR arg_list = get_frame_args_address (fi);
1584 /* Number of args for this frame, or -1 if unknown. */
1588 printf_filtered (" Arglist at unknown address.\n");
1591 printf_filtered (" Arglist at ");
1592 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1593 printf_filtered (",");
1595 if (!gdbarch_frame_num_args_p (gdbarch))
1598 puts_filtered (" args: ");
1602 numargs = gdbarch_frame_num_args (gdbarch, fi);
1603 gdb_assert (numargs >= 0);
1605 puts_filtered (" no args.");
1606 else if (numargs == 1)
1607 puts_filtered (" 1 arg: ");
1609 printf_filtered (" %d args: ", numargs);
1611 print_frame_args (func, fi, numargs, gdb_stdout);
1612 puts_filtered ("\n");
1616 /* Address of the local variables for this frame, or 0. */
1617 CORE_ADDR arg_list = get_frame_locals_address (fi);
1620 printf_filtered (" Locals at unknown address,");
1623 printf_filtered (" Locals at ");
1624 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1625 printf_filtered (",");
1629 /* Print as much information as possible on the location of all the
1632 enum lval_type lval;
1641 /* The sp is special; what's displayed isn't the save address, but
1642 the value of the previous frame's sp. This is a legacy thing,
1643 at one stage the frame cached the previous frame's SP instead
1644 of its address, hence it was easiest to just display the cached
1646 if (gdbarch_sp_regnum (gdbarch) >= 0)
1648 /* Find out the location of the saved stack pointer with out
1649 actually evaluating it. */
1650 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1651 &optimized, &unavailable, &lval, &addr,
1653 if (!optimized && !unavailable && lval == not_lval)
1655 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1656 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1657 gdb_byte value[MAX_REGISTER_SIZE];
1660 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1661 &optimized, &unavailable, &lval, &addr,
1663 /* NOTE: cagney/2003-05-22: This is assuming that the
1664 stack pointer was packed as an unsigned integer. That
1665 may or may not be valid. */
1666 sp = extract_unsigned_integer (value, sp_size, byte_order);
1667 printf_filtered (" Previous frame's sp is ");
1668 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1669 printf_filtered ("\n");
1672 else if (!optimized && !unavailable && lval == lval_memory)
1674 printf_filtered (" Previous frame's sp at ");
1675 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1676 printf_filtered ("\n");
1679 else if (!optimized && !unavailable && lval == lval_register)
1681 printf_filtered (" Previous frame's sp in %s\n",
1682 gdbarch_register_name (gdbarch, realnum));
1685 /* else keep quiet. */
1689 numregs = gdbarch_num_regs (gdbarch)
1690 + gdbarch_num_pseudo_regs (gdbarch);
1691 for (i = 0; i < numregs; i++)
1692 if (i != gdbarch_sp_regnum (gdbarch)
1693 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1695 /* Find out the location of the saved register without
1696 fetching the corresponding value. */
1697 frame_register_unwind (fi, i, &optimized, &unavailable,
1698 &lval, &addr, &realnum, NULL);
1699 /* For moment, only display registers that were saved on the
1701 if (!optimized && !unavailable && lval == lval_memory)
1704 puts_filtered (" Saved registers:\n ");
1706 puts_filtered (",");
1708 printf_filtered (" %s at ",
1709 gdbarch_register_name (gdbarch, i));
1710 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1714 if (count || need_nl)
1715 puts_filtered ("\n");
1718 do_cleanups (back_to);
1721 /* Print briefly all stack frames or just the innermost COUNT_EXP
1725 backtrace_command_1 (char *count_exp, int show_locals, int no_filters,
1728 struct frame_info *fi;
1731 struct frame_info *trailing;
1732 int trailing_level, py_start = 0, py_end = 0;
1733 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1735 if (!target_has_stack)
1736 error (_("No stack."));
1738 /* The following code must do two things. First, it must set the
1739 variable TRAILING to the frame from which we should start
1740 printing. Second, it must set the variable count to the number
1741 of frames which we should print, or -1 if all of them. */
1742 trailing = get_current_frame ();
1747 count = parse_and_eval_long (count_exp);
1750 struct frame_info *current;
1756 while (current && count--)
1759 current = get_prev_frame (current);
1762 /* Will stop when CURRENT reaches the top of the stack.
1763 TRAILING will be COUNT below it. */
1767 trailing = get_prev_frame (trailing);
1768 current = get_prev_frame (current);
1788 /* Read in symbols for all of the frames. Need to do this in a
1789 separate pass so that "Reading in symbols for xxx" messages
1790 don't screw up the appearance of the backtrace. Also if
1791 people have strong opinions against reading symbols for
1792 backtrace this may have to be an option. */
1794 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1799 pc = get_frame_address_in_block (fi);
1800 expand_symtab_containing_pc (pc, find_pc_mapped_section (pc));
1806 int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1807 enum ext_lang_frame_args arg_type;
1810 flags |= PRINT_LOCALS;
1812 if (!strcmp (print_frame_arguments, "scalars"))
1813 arg_type = CLI_SCALAR_VALUES;
1814 else if (!strcmp (print_frame_arguments, "all"))
1815 arg_type = CLI_ALL_VALUES;
1817 arg_type = NO_VALUES;
1819 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1820 arg_type, current_uiout,
1824 /* Run the inbuilt backtrace if there are no filters registered, or
1825 "no-filters" has been specified from the command. */
1826 if (no_filters || result == EXT_LANG_BT_NO_FILTERS)
1828 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1832 /* Don't use print_stack_frame; if an error() occurs it probably
1833 means further attempts to backtrace would fail (on the other
1834 hand, perhaps the code does or could be fixed to make sure
1835 the frame->prev field gets set to NULL in that case). */
1837 print_frame_info (fi, 1, LOCATION, 1, 0);
1840 struct frame_id frame_id = get_frame_id (fi);
1842 print_frame_local_vars (fi, 1, gdb_stdout);
1844 /* print_frame_local_vars invalidates FI. */
1845 fi = frame_find_by_id (frame_id);
1849 warning (_("Unable to restore previously selected frame."));
1854 /* Save the last frame to check for error conditions. */
1858 /* If we've stopped before the end, mention that. */
1860 printf_filtered (_("(More stack frames follow...)\n"));
1862 /* If we've run out of frames, and the reason appears to be an error
1863 condition, print it. */
1864 if (fi == NULL && trailing != NULL)
1866 enum unwind_stop_reason reason;
1868 reason = get_frame_unwind_stop_reason (trailing);
1869 if (reason >= UNWIND_FIRST_ERROR)
1870 printf_filtered (_("Backtrace stopped: %s\n"),
1871 frame_stop_reason_string (trailing));
1877 backtrace_command (char *arg, int from_tty)
1879 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1880 int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1;
1888 argv = gdb_buildargv (arg);
1889 make_cleanup_freeargv (argv);
1891 for (i = 0; argv[i]; i++)
1895 for (j = 0; j < strlen (argv[i]); j++)
1896 argv[i][j] = TOLOWER (argv[i][j]);
1898 if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
1902 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1903 fulltrace_arg = argc;
1907 arglen += strlen (argv[i]);
1913 if (fulltrace_arg >= 0 || no_filters >= 0)
1917 arg = (char *) xmalloc (arglen + 1);
1918 make_cleanup (xfree, arg);
1920 for (i = 0; i < argc; i++)
1922 if (i != fulltrace_arg && i != no_filters)
1924 strcat (arg, argv[i]);
1934 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
1935 no_filters >= 0 /* no frame-filters */, from_tty);
1937 do_cleanups (old_chain);
1940 /* Iterate over the local variables of a block B, calling CB with
1944 iterate_over_block_locals (const struct block *b,
1945 iterate_over_block_arg_local_vars_cb cb,
1948 struct block_iterator iter;
1951 ALL_BLOCK_SYMBOLS (b, iter, sym)
1953 switch (SYMBOL_CLASS (sym))
1959 if (SYMBOL_IS_ARGUMENT (sym))
1961 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1963 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1967 /* Ignore symbols which are not locals. */
1974 /* Same, but print labels. */
1977 /* Commented out, as the code using this function has also been
1978 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1979 was commented out in the first place. The discussion introducing
1980 this change (2007-12-04: Support lexical blocks and function bodies
1981 that occupy non-contiguous address ranges) did not explain why
1982 this change was made. */
1984 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1985 int *have_default, struct ui_file *stream)
1987 struct block_iterator iter;
1989 int values_printed = 0;
1991 ALL_BLOCK_SYMBOLS (b, iter, sym)
1993 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1999 if (SYMBOL_CLASS (sym) == LOC_LABEL)
2001 struct symtab_and_line sal;
2002 struct value_print_options opts;
2004 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2006 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
2007 get_user_print_options (&opts);
2008 if (opts.addressprint)
2010 fprintf_filtered (stream, " ");
2011 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2014 fprintf_filtered (stream, " in file %s, line %d\n",
2015 sal.symtab->filename, sal.line);
2019 return values_printed;
2023 /* Iterate over all the local variables in block B, including all its
2024 superblocks, stopping when the top-level block is reached. */
2027 iterate_over_block_local_vars (const struct block *block,
2028 iterate_over_block_arg_local_vars_cb cb,
2033 iterate_over_block_locals (block, cb, cb_data);
2034 /* After handling the function's top-level block, stop. Don't
2035 continue to its superblock, the block of per-file
2037 if (BLOCK_FUNCTION (block))
2039 block = BLOCK_SUPERBLOCK (block);
2043 /* Data to be passed around in the calls to the locals and args
2046 struct print_variable_and_value_data
2048 struct frame_id frame_id;
2050 struct ui_file *stream;
2054 /* The callback for the locals and args iterators. */
2057 do_print_variable_and_value (const char *print_name,
2061 struct print_variable_and_value_data *p
2062 = (struct print_variable_and_value_data *) cb_data;
2063 struct frame_info *frame;
2065 frame = frame_find_by_id (p->frame_id);
2068 warning (_("Unable to restore previously selected frame."));
2072 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2074 /* print_variable_and_value invalidates FRAME. */
2077 p->values_printed = 1;
2080 /* Print all variables from the innermost up to the function block of FRAME.
2081 Print them with values to STREAM indented by NUM_TABS.
2083 This function will invalidate FRAME. */
2086 print_frame_local_vars (struct frame_info *frame, int num_tabs,
2087 struct ui_file *stream)
2089 struct print_variable_and_value_data cb_data;
2090 const struct block *block;
2092 struct gdb_exception except = exception_none;
2094 if (!get_frame_pc_if_available (frame, &pc))
2096 fprintf_filtered (stream,
2097 _("PC unavailable, cannot determine locals.\n"));
2101 block = get_frame_block (frame, 0);
2104 fprintf_filtered (stream, "No symbol table info available.\n");
2108 cb_data.frame_id = get_frame_id (frame);
2109 cb_data.num_tabs = 4 * num_tabs;
2110 cb_data.stream = stream;
2111 cb_data.values_printed = 0;
2113 /* Temporarily change the selected frame to the given FRAME.
2114 This allows routines that rely on the selected frame instead
2115 of being given a frame as parameter to use the correct frame. */
2116 select_frame (frame);
2120 iterate_over_block_local_vars (block,
2121 do_print_variable_and_value,
2124 CATCH (ex, RETURN_MASK_ALL)
2130 /* Restore the selected frame, and then rethrow if there was a problem. */
2131 select_frame (frame_find_by_id (cb_data.frame_id));
2132 if (except.reason < 0)
2133 throw_exception (except);
2135 /* do_print_variable_and_value invalidates FRAME. */
2138 if (!cb_data.values_printed)
2139 fprintf_filtered (stream, _("No locals.\n"));
2143 locals_info (char *args, int from_tty)
2145 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2149 /* Iterate over all the argument variables in block B.
2151 Returns 1 if any argument was walked; 0 otherwise. */
2154 iterate_over_block_arg_vars (const struct block *b,
2155 iterate_over_block_arg_local_vars_cb cb,
2158 struct block_iterator iter;
2159 struct symbol *sym, *sym2;
2161 ALL_BLOCK_SYMBOLS (b, iter, sym)
2163 /* Don't worry about things which aren't arguments. */
2164 if (SYMBOL_IS_ARGUMENT (sym))
2166 /* We have to look up the symbol because arguments can have
2167 two entries (one a parameter, one a local) and the one we
2168 want is the local, which lookup_symbol will find for us.
2169 This includes gcc1 (not gcc2) on the sparc when passing a
2170 small structure and gcc2 when the argument type is float
2171 and it is passed as a double and converted to float by
2172 the prologue (in the latter case the type of the LOC_ARG
2173 symbol is double and the type of the LOC_LOCAL symbol is
2174 float). There are also LOC_ARG/LOC_REGISTER pairs which
2175 are not combined in symbol-reading. */
2177 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
2178 b, VAR_DOMAIN, NULL).symbol;
2179 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2184 /* Print all argument variables of the function of FRAME.
2185 Print them with values to STREAM.
2187 This function will invalidate FRAME. */
2190 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2192 struct print_variable_and_value_data cb_data;
2193 struct symbol *func;
2196 if (!get_frame_pc_if_available (frame, &pc))
2198 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2202 func = get_frame_function (frame);
2205 fprintf_filtered (stream, _("No symbol table info available.\n"));
2209 cb_data.frame_id = get_frame_id (frame);
2210 cb_data.num_tabs = 0;
2211 cb_data.stream = gdb_stdout;
2212 cb_data.values_printed = 0;
2214 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2215 do_print_variable_and_value, &cb_data);
2217 /* do_print_variable_and_value invalidates FRAME. */
2220 if (!cb_data.values_printed)
2221 fprintf_filtered (stream, _("No arguments.\n"));
2225 args_info (char *ignore, int from_tty)
2227 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2231 /* Select frame FRAME. Also print the stack frame and show the source
2232 if this is the tui version. */
2234 select_and_print_frame (struct frame_info *frame)
2236 select_frame (frame);
2238 print_stack_frame (frame, 1, SRC_AND_LOC, 1);
2241 /* Return the symbol-block in which the selected frame is executing.
2242 Can return zero under various legitimate circumstances.
2244 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2245 code address within the block returned. We use this to decide
2246 which macros are in scope. */
2248 const struct block *
2249 get_selected_block (CORE_ADDR *addr_in_block)
2251 if (!has_stack_frames ())
2254 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2257 /* Find a frame a certain number of levels away from FRAME.
2258 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2259 Positive means go to earlier frames (up); negative, the reverse.
2260 The int that contains the number of levels is counted toward
2261 zero as the frames for those levels are found.
2262 If the top or bottom frame is reached, that frame is returned,
2263 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2264 how much farther the original request asked to go. */
2267 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2269 /* Going up is simple: just call get_prev_frame enough times or
2270 until the initial frame is reached. */
2271 while (*level_offset_ptr > 0)
2273 struct frame_info *prev = get_prev_frame (frame);
2277 (*level_offset_ptr)--;
2281 /* Going down is just as simple. */
2282 while (*level_offset_ptr < 0)
2284 struct frame_info *next = get_next_frame (frame);
2288 (*level_offset_ptr)++;
2295 /* The "select_frame" command. With no argument this is a NOP.
2296 Select the frame at level LEVEL_EXP if it is a valid level.
2297 Otherwise, treat LEVEL_EXP as an address expression and select it.
2299 See parse_frame_specification for more info on proper frame
2303 select_frame_command (char *level_exp, int from_tty)
2305 select_frame (parse_frame_specification (level_exp, NULL));
2308 /* The "frame" command. With no argument, print the selected frame
2309 briefly. With an argument, behave like select_frame and then print
2310 the selected frame. */
2313 frame_command (char *level_exp, int from_tty)
2315 select_frame_command (level_exp, from_tty);
2316 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2319 /* Select the frame up one or COUNT_EXP stack levels from the
2320 previously selected frame, and print it briefly. */
2323 up_silently_base (const char *count_exp)
2325 struct frame_info *frame;
2329 count = parse_and_eval_long (count_exp);
2331 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2332 if (count != 0 && count_exp == NULL)
2333 error (_("Initial frame selected; you cannot go up."));
2334 select_frame (frame);
2338 up_silently_command (char *count_exp, int from_tty)
2340 up_silently_base (count_exp);
2344 up_command (char *count_exp, int from_tty)
2346 up_silently_base (count_exp);
2347 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2350 /* Select the frame down one or COUNT_EXP stack levels from the previously
2351 selected frame, and print it briefly. */
2354 down_silently_base (const char *count_exp)
2356 struct frame_info *frame;
2360 count = -parse_and_eval_long (count_exp);
2362 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2363 if (count != 0 && count_exp == NULL)
2365 /* We only do this if COUNT_EXP is not specified. That way
2366 "down" means to really go down (and let me know if that is
2367 impossible), but "down 9999" can be used to mean go all the
2368 way down without getting an error. */
2370 error (_("Bottom (innermost) frame selected; you cannot go down."));
2373 select_frame (frame);
2377 down_silently_command (char *count_exp, int from_tty)
2379 down_silently_base (count_exp);
2383 down_command (char *count_exp, int from_tty)
2385 down_silently_base (count_exp);
2386 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2391 return_command (char *retval_exp, int from_tty)
2393 /* Initialize it just to avoid a GCC false warning. */
2394 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2395 struct frame_info *thisframe;
2396 struct gdbarch *gdbarch;
2397 struct symbol *thisfun;
2398 struct value *return_value = NULL;
2399 struct value *function = NULL;
2400 const char *query_prefix = "";
2402 thisframe = get_selected_frame ("No selected frame.");
2403 thisfun = get_frame_function (thisframe);
2404 gdbarch = get_frame_arch (thisframe);
2406 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2407 error (_("Can not force return from an inlined function."));
2409 /* Compute the return value. If the computation triggers an error,
2410 let it bail. If the return type can't be handled, set
2411 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2415 struct expression *retval_expr = parse_expression (retval_exp);
2416 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
2417 struct type *return_type = NULL;
2419 /* Compute the return value. Should the computation fail, this
2420 call throws an error. */
2421 return_value = evaluate_expression (retval_expr);
2423 /* Cast return value to the return type of the function. Should
2424 the cast fail, this call throws an error. */
2425 if (thisfun != NULL)
2426 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2427 if (return_type == NULL)
2429 if (retval_expr->elts[0].opcode != UNOP_CAST
2430 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2431 error (_("Return value type not available for selected "
2433 "Please use an explicit cast of the value to return."));
2434 return_type = value_type (return_value);
2436 do_cleanups (old_chain);
2437 return_type = check_typedef (return_type);
2438 return_value = value_cast (return_type, return_value);
2440 /* Make sure the value is fully evaluated. It may live in the
2441 stack frame we're about to pop. */
2442 if (value_lazy (return_value))
2443 value_fetch_lazy (return_value);
2445 if (thisfun != NULL)
2446 function = read_var_value (thisfun, NULL, thisframe);
2448 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2449 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2450 /* If the return-type is "void", don't try to find the
2451 return-value's location. However, do still evaluate the
2452 return expression so that, even when the expression result
2453 is discarded, side effects such as "return i++" still
2455 return_value = NULL;
2456 else if (thisfun != NULL)
2458 rv_conv = struct_return_convention (gdbarch, function, return_type);
2459 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2460 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2462 query_prefix = "The location at which to store the "
2463 "function's return value is unknown.\n"
2464 "If you continue, the return value "
2465 "that you specified will be ignored.\n";
2466 return_value = NULL;
2471 /* Does an interactive user really want to do this? Include
2472 information, such as how well GDB can handle the return value, in
2473 the query message. */
2478 if (thisfun == NULL)
2479 confirmed = query (_("%sMake selected stack frame return now? "),
2483 if (TYPE_NO_RETURN (thisfun->type))
2484 warning (_("Function does not return normally to caller."));
2485 confirmed = query (_("%sMake %s return now? "), query_prefix,
2486 SYMBOL_PRINT_NAME (thisfun));
2489 error (_("Not confirmed"));
2492 /* Discard the selected frame and all frames inner-to it. */
2493 frame_pop (get_selected_frame (NULL));
2495 /* Store RETURN_VALUE in the just-returned register set. */
2496 if (return_value != NULL)
2498 struct type *return_type = value_type (return_value);
2499 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2501 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2502 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2503 gdbarch_return_value (gdbarch, function, return_type,
2504 get_current_regcache (), NULL /*read*/,
2505 value_contents (return_value) /*write*/);
2508 /* If we are at the end of a call dummy now, pop the dummy frame
2510 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2511 frame_pop (get_current_frame ());
2513 select_frame (get_current_frame ());
2514 /* If interactive, print the frame that is now current. */
2516 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2519 /* Sets the scope to input function name, provided that the function
2520 is within the current stack frame. */
2522 struct function_bounds
2524 CORE_ADDR low, high;
2528 func_command (char *arg, int from_tty)
2530 struct frame_info *frame;
2532 struct symtabs_and_lines sals;
2535 struct function_bounds *func_bounds = NULL;
2536 struct cleanup *cleanups;
2541 frame = get_current_frame ();
2542 sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
2543 cleanups = make_cleanup (xfree, sals.sals);
2544 func_bounds = XNEWVEC (struct function_bounds, sals.nelts);
2545 make_cleanup (xfree, func_bounds);
2546 for (i = 0; (i < sals.nelts && !found); i++)
2548 if (sals.sals[i].pspace != current_program_space)
2549 func_bounds[i].low = func_bounds[i].high = 0;
2550 else if (sals.sals[i].pc == 0
2551 || find_pc_partial_function (sals.sals[i].pc, NULL,
2552 &func_bounds[i].low,
2553 &func_bounds[i].high) == 0)
2555 func_bounds[i].low = func_bounds[i].high = 0;
2561 for (i = 0; (i < sals.nelts && !found); i++)
2562 found = (get_frame_pc (frame) >= func_bounds[i].low
2563 && get_frame_pc (frame) < func_bounds[i].high);
2567 frame = find_relative_frame (frame, &level);
2570 while (!found && level == 0);
2572 do_cleanups (cleanups);
2575 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2576 else if (frame != get_selected_frame (NULL))
2577 select_and_print_frame (frame);
2581 /* Provide a prototype to silence -Wmissing-prototypes. */
2582 void _initialize_stack (void);
2585 _initialize_stack (void)
2587 add_com ("return", class_stack, return_command, _("\
2588 Make selected stack frame return to its caller.\n\
2589 Control remains in the debugger, but when you continue\n\
2590 execution will resume in the frame above the one now selected.\n\
2591 If an argument is given, it is an expression for the value to return."));
2593 add_com ("up", class_stack, up_command, _("\
2594 Select and print stack frame that called this one.\n\
2595 An argument says how many frames up to go."));
2596 add_com ("up-silently", class_support, up_silently_command, _("\
2597 Same as the `up' command, but does not print anything.\n\
2598 This is useful in command scripts."));
2600 add_com ("down", class_stack, down_command, _("\
2601 Select and print stack frame called by this one.\n\
2602 An argument says how many frames down to go."));
2603 add_com_alias ("do", "down", class_stack, 1);
2604 add_com_alias ("dow", "down", class_stack, 1);
2605 add_com ("down-silently", class_support, down_silently_command, _("\
2606 Same as the `down' command, but does not print anything.\n\
2607 This is useful in command scripts."));
2609 add_com ("frame", class_stack, frame_command, _("\
2610 Select and print a stack frame.\nWith no argument, \
2611 print the selected stack frame. (See also \"info frame\").\n\
2612 An argument specifies the frame to select.\n\
2613 It can be a stack frame number or the address of the frame.\n\
2614 With argument, nothing is printed if input is coming from\n\
2615 a command file or a user-defined command."));
2617 add_com_alias ("f", "frame", class_stack, 1);
2619 add_com ("select-frame", class_stack, select_frame_command, _("\
2620 Select a stack frame without printing anything.\n\
2621 An argument specifies the frame to select.\n\
2622 It can be a stack frame number or the address of the frame.\n"));
2624 add_com ("backtrace", class_stack, backtrace_command, _("\
2625 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2626 With a negative argument, print outermost -COUNT frames.\nUse of the \
2627 'full' qualifier also prints the values of the local variables.\n\
2628 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2629 on this backtrace.\n"));
2630 add_com_alias ("bt", "backtrace", class_stack, 0);
2632 add_com_alias ("where", "backtrace", class_alias, 0);
2633 add_info ("stack", backtrace_command,
2634 _("Backtrace of the stack, or innermost COUNT frames."));
2635 add_info_alias ("s", "stack", 1);
2636 add_info ("frame", frame_info,
2637 _("All about selected stack frame, or frame at ADDR."));
2638 add_info_alias ("f", "frame", 1);
2639 add_info ("locals", locals_info,
2640 _("Local variables of current stack frame."));
2641 add_info ("args", args_info,
2642 _("Argument variables of current stack frame."));
2645 add_com ("func", class_stack, func_command, _("\
2646 Select the stack frame that contains <func>.\n\
2647 Usage: func <name>\n"));
2649 add_setshow_enum_cmd ("frame-arguments", class_stack,
2650 print_frame_arguments_choices, &print_frame_arguments,
2651 _("Set printing of non-scalar frame arguments"),
2652 _("Show printing of non-scalar frame arguments"),
2653 NULL, NULL, NULL, &setprintlist, &showprintlist);
2655 add_setshow_boolean_cmd ("frame-arguments", no_class,
2656 &print_raw_frame_arguments, _("\
2657 Set whether to print frame arguments in raw form."), _("\
2658 Show whether to print frame arguments in raw form."), _("\
2659 If set, frame arguments are printed in raw form, bypassing any\n\
2660 pretty-printers for that value."),
2662 &setprintrawlist, &showprintrawlist);
2664 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2665 &disassemble_next_line, _("\
2666 Set whether to disassemble next source line or insn when execution stops."),
2668 Show whether to disassemble next source line or insn when execution stops."),
2670 If ON, GDB will display disassembly of the next source line, in addition\n\
2671 to displaying the source line itself. If the next source line cannot\n\
2672 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2673 will display disassembly of next instruction instead of showing the\n\
2675 If AUTO, display disassembly of next instruction only if the source line\n\
2676 cannot be displayed.\n\
2677 If OFF (which is the default), never display the disassembly of the next\n\
2680 show_disassemble_next_line,
2681 &setlist, &showlist);
2682 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2684 add_setshow_enum_cmd ("entry-values", class_stack,
2685 print_entry_values_choices, &print_entry_values,
2686 _("Set printing of function arguments at function "
2688 _("Show printing of function arguments at function "
2691 GDB can sometimes determine the values of function arguments at entry,\n\
2692 in addition to their current values. This option tells GDB whether\n\
2693 to print the current value, the value at entry (marked as val@entry),\n\
2694 or both. Note that one or both of these values may be <optimized out>."),
2695 NULL, NULL, &setprintlist, &showprintlist);