1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2015 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)
313 struct value *val = NULL;
321 argp->val = read_var_value (sym, NULL, frame);
323 CATCH (except, RETURN_MASK_ERROR)
325 argp->error = xstrdup (except.message);
330 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
331 responsible for xfree of ARGP->ERROR. This function never throws an
335 read_frame_arg (struct symbol *sym, struct frame_info *frame,
336 struct frame_arg *argp, struct frame_arg *entryargp)
338 struct value *val = NULL, *entryval = NULL;
339 char *val_error = NULL, *entryval_error = NULL;
342 if (print_entry_values != print_entry_values_only
343 && print_entry_values != print_entry_values_preferred)
347 val = read_var_value (sym, NULL, frame);
349 CATCH (except, RETURN_MASK_ERROR)
351 val_error = (char *) alloca (strlen (except.message) + 1);
352 strcpy (val_error, except.message);
357 if (SYMBOL_COMPUTED_OPS (sym) != NULL
358 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
359 && print_entry_values != print_entry_values_no
360 && (print_entry_values != print_entry_values_if_needed
361 || !val || value_optimized_out (val)))
365 const struct symbol_computed_ops *ops;
367 ops = SYMBOL_COMPUTED_OPS (sym);
368 entryval = ops->read_variable_at_entry (sym, frame);
370 CATCH (except, RETURN_MASK_ERROR)
372 if (except.error != NO_ENTRY_VALUE_ERROR)
374 entryval_error = (char *) alloca (strlen (except.message) + 1);
375 strcpy (entryval_error, except.message);
380 if (entryval != NULL && value_optimized_out (entryval))
383 if (print_entry_values == print_entry_values_compact
384 || print_entry_values == print_entry_values_default)
386 /* For MI do not try to use print_entry_values_compact for ARGP. */
388 if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
390 struct type *type = value_type (val);
392 if (value_lazy (val))
393 value_fetch_lazy (val);
394 if (value_lazy (entryval))
395 value_fetch_lazy (entryval);
397 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
399 /* Initialize it just to avoid a GCC false warning. */
400 struct value *val_deref = NULL, *entryval_deref;
402 /* DW_AT_GNU_call_site_value does match with the current
403 value. If it is a reference still try to verify if
404 dereferenced DW_AT_GNU_call_site_data_value does not
409 struct type *type_deref;
411 val_deref = coerce_ref (val);
412 if (value_lazy (val_deref))
413 value_fetch_lazy (val_deref);
414 type_deref = value_type (val_deref);
416 entryval_deref = coerce_ref (entryval);
417 if (value_lazy (entryval_deref))
418 value_fetch_lazy (entryval_deref);
420 /* If the reference addresses match but dereferenced
421 content does not match print them. */
423 && value_contents_eq (val_deref, 0,
425 TYPE_LENGTH (type_deref)))
428 CATCH (except, RETURN_MASK_ERROR)
430 /* If the dereferenced content could not be
431 fetched do not display anything. */
432 if (except.error == NO_ENTRY_VALUE_ERROR)
434 else if (except.message != NULL)
436 entryval_error = (char *) alloca (strlen (except.message) + 1);
437 strcpy (entryval_error, except.message);
442 /* Value was not a reference; and its content matches. */
443 if (val == val_deref)
451 /* Try to remove possibly duplicate error message for ENTRYARGP even
454 if (val_error && entryval_error
455 && strcmp (val_error, entryval_error) == 0)
457 entryval_error = NULL;
459 /* Do not se VAL_EQUAL as the same error message may be shown for
460 the entry value even if no entry values are present in the
466 if (entryval == NULL)
468 if (print_entry_values == print_entry_values_preferred)
470 gdb_assert (val == NULL);
474 val = read_var_value (sym, NULL, frame);
476 CATCH (except, RETURN_MASK_ERROR)
478 val_error = (char *) alloca (strlen (except.message) + 1);
479 strcpy (val_error, except.message);
483 if (print_entry_values == print_entry_values_only
484 || print_entry_values == print_entry_values_both
485 || (print_entry_values == print_entry_values_preferred
486 && (!val || value_optimized_out (val))))
488 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
489 entryval_error = NULL;
492 if ((print_entry_values == print_entry_values_compact
493 || print_entry_values == print_entry_values_if_needed
494 || print_entry_values == print_entry_values_preferred)
495 && (!val || value_optimized_out (val)) && entryval != NULL)
503 argp->error = val_error ? xstrdup (val_error) : NULL;
504 if (!val && !val_error)
505 argp->entry_kind = print_entry_values_only;
506 else if ((print_entry_values == print_entry_values_compact
507 || print_entry_values == print_entry_values_default) && val_equal)
509 argp->entry_kind = print_entry_values_compact;
510 gdb_assert (!ui_out_is_mi_like_p (current_uiout));
513 argp->entry_kind = print_entry_values_no;
515 entryargp->sym = sym;
516 entryargp->val = entryval;
517 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
518 if (!entryval && !entryval_error)
519 entryargp->entry_kind = print_entry_values_no;
521 entryargp->entry_kind = print_entry_values_only;
524 /* Print the arguments of frame FRAME on STREAM, given the function
525 FUNC running in that frame (as a symbol), where NUM is the number
526 of arguments according to the stack frame (or -1 if the number of
527 arguments is unknown). */
529 /* Note that currently the "number of arguments according to the
530 stack frame" is only known on VAX where i refers to the "number of
531 ints of arguments according to the stack frame". */
534 print_frame_args (struct symbol *func, struct frame_info *frame,
535 int num, struct ui_file *stream)
537 struct ui_out *uiout = current_uiout;
539 /* Offset of next stack argument beyond the one we have seen that is
540 at the highest offset, or -1 if we haven't come to a stack
542 long highest_offset = -1;
543 /* Number of ints of arguments that we have printed so far. */
544 int args_printed = 0;
545 struct cleanup *old_chain;
547 /* True if we should print arguments, false otherwise. */
548 int print_args = strcmp (print_frame_arguments, "none");
550 stb = mem_fileopen ();
551 old_chain = make_cleanup_ui_file_delete (stb);
555 const struct block *b = SYMBOL_BLOCK_VALUE (func);
556 struct block_iterator iter;
559 ALL_BLOCK_SYMBOLS (b, iter, sym)
561 struct frame_arg arg, entryarg;
565 /* Keep track of the highest stack argument offset seen, and
566 skip over any kinds of symbols we don't care about. */
568 if (!SYMBOL_IS_ARGUMENT (sym))
571 switch (SYMBOL_CLASS (sym))
576 long current_offset = SYMBOL_VALUE (sym);
577 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
579 /* Compute address of next argument by adding the size of
580 this argument and rounding to an int boundary. */
582 ((current_offset + arg_size + sizeof (int) - 1)
583 & ~(sizeof (int) - 1));
585 /* If this is the highest offset seen yet, set
587 if (highest_offset == -1
588 || (current_offset > highest_offset))
589 highest_offset = current_offset;
591 /* Add the number of ints we're about to print to
593 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
596 /* We care about types of symbols, but don't need to
597 keep track of stack offsets in them. */
599 case LOC_REGPARM_ADDR:
601 case LOC_OPTIMIZED_OUT:
606 /* We have to look up the symbol because arguments can have
607 two entries (one a parameter, one a local) and the one we
608 want is the local, which lookup_symbol will find for us.
609 This includes gcc1 (not gcc2) on SPARC when passing a
610 small structure and gcc2 when the argument type is float
611 and it is passed as a double and converted to float by
612 the prologue (in the latter case the type of the LOC_ARG
613 symbol is double and the type of the LOC_LOCAL symbol is
615 /* But if the parameter name is null, don't try it. Null
616 parameter names occur on the RS/6000, for traceback
617 tables. FIXME, should we even print them? */
619 if (*SYMBOL_LINKAGE_NAME (sym))
623 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
624 b, VAR_DOMAIN, NULL).symbol;
625 gdb_assert (nsym != NULL);
626 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
627 && !SYMBOL_IS_ARGUMENT (nsym))
629 /* There is a LOC_ARG/LOC_REGISTER pair. This means
630 that it was passed on the stack and loaded into a
631 register, or passed in a register and stored in a
632 stack slot. GDB 3.x used the LOC_ARG; GDB
633 4.0-4.11 used the LOC_REGISTER.
635 Reasons for using the LOC_ARG:
637 (1) Because find_saved_registers may be slow for
640 (2) Because registers are often re-used and stack
641 slots rarely (never?) are. Therefore using
642 the stack slot is much less likely to print
645 Reasons why we might want to use the LOC_REGISTER:
647 (1) So that the backtrace prints the same value
648 as "print foo". I see no compelling reason
649 why this needs to be the case; having the
650 backtrace print the value which was passed
651 in, and "print foo" print the value as
652 modified within the called function, makes
655 Additional note: It might be nice if "info args"
656 displayed both values.
658 One more note: There is a case with SPARC
659 structure passing where we need to use the
660 LOC_REGISTER, but this is dealt with by creating
661 a single LOC_REGPARM in symbol reading. */
663 /* Leave sym (the LOC_ARG) alone. */
670 /* Print the current arg. */
672 ui_out_text (uiout, ", ");
673 ui_out_wrap_hint (uiout, " ");
677 memset (&arg, 0, sizeof (arg));
679 arg.entry_kind = print_entry_values_no;
680 memset (&entryarg, 0, sizeof (entryarg));
682 entryarg.entry_kind = print_entry_values_no;
685 read_frame_arg (sym, frame, &arg, &entryarg);
687 if (arg.entry_kind != print_entry_values_only)
688 print_frame_arg (&arg);
690 if (entryarg.entry_kind != print_entry_values_no)
692 if (arg.entry_kind != print_entry_values_only)
694 ui_out_text (uiout, ", ");
695 ui_out_wrap_hint (uiout, " ");
698 print_frame_arg (&entryarg);
702 xfree (entryarg.error);
708 /* Don't print nameless args in situations where we don't know
709 enough about the stack to find them. */
714 if (highest_offset == -1)
715 start = gdbarch_frame_args_skip (get_frame_arch (frame));
717 start = highest_offset;
719 print_frame_nameless_args (frame, start, num - args_printed,
723 do_cleanups (old_chain);
726 /* Set the current source and line to the location given by frame
727 FRAME, if possible. When CENTER is true, adjust so the relevant
728 line is in the center of the next 'list'. */
731 set_current_sal_from_frame (struct frame_info *frame)
733 struct symtab_and_line sal;
735 find_frame_sal (frame, &sal);
736 if (sal.symtab != NULL)
737 set_current_source_symtab_and_line (&sal);
740 /* If ON, GDB will display disassembly of the next source line when
741 execution of the program being debugged stops.
742 If AUTO (which is the default), or there's no line info to determine
743 the source line of the next instruction, display disassembly of next
744 instruction instead. */
746 static enum auto_boolean disassemble_next_line;
749 show_disassemble_next_line (struct ui_file *file, int from_tty,
750 struct cmd_list_element *c,
753 fprintf_filtered (file,
754 _("Debugger's willingness to use "
755 "disassemble-next-line is %s.\n"),
759 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
760 because it will be broken by filter sometime. */
763 do_gdb_disassembly (struct gdbarch *gdbarch,
764 int how_many, CORE_ADDR low, CORE_ADDR high)
769 gdb_disassembly (gdbarch, current_uiout, 0,
770 DISASSEMBLY_RAW_INSN, how_many,
773 CATCH (exception, RETURN_MASK_ERROR)
775 /* If an exception was thrown while doing the disassembly, print
776 the error message, to give the user a clue of what happened. */
777 exception_print (gdb_stderr, exception);
782 /* Print information about frame FRAME. The output is format according
783 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
786 SRC_LINE: Print only source line.
787 LOCATION: Print only location.
788 LOC_AND_SRC: Print location and source line.
790 Used in "where" output, and to emit breakpoint or step
794 print_frame_info (struct frame_info *frame, int print_level,
795 enum print_what print_what, int print_args,
798 struct gdbarch *gdbarch = get_frame_arch (frame);
799 struct symtab_and_line sal;
802 struct ui_out *uiout = current_uiout;
804 if (get_frame_type (frame) == DUMMY_FRAME
805 || get_frame_type (frame) == SIGTRAMP_FRAME
806 || get_frame_type (frame) == ARCH_FRAME)
808 struct cleanup *uiout_cleanup
809 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
811 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
812 gdbarch, get_frame_pc (frame));
814 /* Do this regardless of SOURCE because we don't have any source
815 to list for this frame. */
818 ui_out_text (uiout, "#");
819 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
820 frame_relative_level (frame));
822 if (ui_out_is_mi_like_p (uiout))
824 annotate_frame_address ();
825 ui_out_field_core_addr (uiout, "addr",
826 gdbarch, get_frame_pc (frame));
827 annotate_frame_address_end ();
830 if (get_frame_type (frame) == DUMMY_FRAME)
832 annotate_function_call ();
833 ui_out_field_string (uiout, "func", "<function called from gdb>");
835 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
837 annotate_signal_handler_caller ();
838 ui_out_field_string (uiout, "func", "<signal handler called>");
840 else if (get_frame_type (frame) == ARCH_FRAME)
842 ui_out_field_string (uiout, "func", "<cross-architecture call>");
844 ui_out_text (uiout, "\n");
845 annotate_frame_end ();
847 /* If disassemble-next-line is set to auto or on output the next
849 if (disassemble_next_line == AUTO_BOOLEAN_AUTO
850 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
851 do_gdb_disassembly (get_frame_arch (frame), 1,
852 get_frame_pc (frame), get_frame_pc (frame) + 1);
854 do_cleanups (uiout_cleanup);
858 /* If FRAME is not the innermost frame, that normally means that
859 FRAME->pc points to *after* the call instruction, and we want to
860 get the line containing the call, never the next line. But if
861 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
862 next frame was not entered as the result of a call, and we want
863 to get the line containing FRAME->pc. */
864 find_frame_sal (frame, &sal);
866 location_print = (print_what == LOCATION
867 || print_what == LOC_AND_ADDRESS
868 || print_what == SRC_AND_LOC);
870 if (location_print || !sal.symtab)
871 print_frame (frame, print_level, print_what, print_args, sal);
873 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
875 /* If disassemble-next-line is set to auto or on and doesn't have
876 the line debug messages for $pc, output the next instruction. */
877 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
878 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
879 && source_print && !sal.symtab)
880 do_gdb_disassembly (get_frame_arch (frame), 1,
881 get_frame_pc (frame), get_frame_pc (frame) + 1);
883 if (source_print && sal.symtab)
886 int mid_statement = ((print_what == SRC_LINE)
887 && frame_show_address (frame, sal));
889 if (annotation_level)
890 done = identify_source_line (sal.symtab, sal.line, mid_statement,
891 get_frame_pc (frame));
894 if (deprecated_print_frame_info_listing_hook)
895 deprecated_print_frame_info_listing_hook (sal.symtab,
900 struct value_print_options opts;
902 get_user_print_options (&opts);
903 /* We used to do this earlier, but that is clearly
904 wrong. This function is used by many different
905 parts of gdb, including normal_stop in infrun.c,
906 which uses this to print out the current PC
907 when we stepi/nexti into the middle of a source
908 line. Only the command line really wants this
909 behavior. Other UIs probably would like the
910 ability to decide for themselves if it is desired. */
911 if (opts.addressprint && mid_statement)
913 ui_out_field_core_addr (uiout, "addr",
914 gdbarch, get_frame_pc (frame));
915 ui_out_text (uiout, "\t");
918 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
922 /* If disassemble-next-line is set to on and there is line debug
923 messages, output assembly codes for next line. */
924 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
925 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
932 if (get_frame_pc_if_available (frame, &pc))
933 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
935 set_last_displayed_sal (0, 0, 0, 0, 0);
938 annotate_frame_end ();
940 gdb_flush (gdb_stdout);
943 /* Remember the last symtab and line we displayed, which we use e.g.
944 * as the place to put a breakpoint when the `break' command is
945 * invoked with no arguments. */
948 set_last_displayed_sal (int valid, struct program_space *pspace,
949 CORE_ADDR addr, struct symtab *symtab,
952 last_displayed_sal_valid = valid;
953 last_displayed_pspace = pspace;
954 last_displayed_addr = addr;
955 last_displayed_symtab = symtab;
956 last_displayed_line = line;
957 if (valid && pspace == NULL)
959 clear_last_displayed_sal ();
960 internal_error (__FILE__, __LINE__,
961 _("Trying to set NULL pspace."));
965 /* Forget the last sal we displayed. */
968 clear_last_displayed_sal (void)
970 last_displayed_sal_valid = 0;
971 last_displayed_pspace = 0;
972 last_displayed_addr = 0;
973 last_displayed_symtab = 0;
974 last_displayed_line = 0;
977 /* Is our record of the last sal we displayed valid? If not,
978 * the get_last_displayed_* functions will return NULL or 0, as
982 last_displayed_sal_is_valid (void)
984 return last_displayed_sal_valid;
987 /* Get the pspace of the last sal we displayed, if it's valid. */
989 struct program_space *
990 get_last_displayed_pspace (void)
992 if (last_displayed_sal_valid)
993 return last_displayed_pspace;
997 /* Get the address of the last sal we displayed, if it's valid. */
1000 get_last_displayed_addr (void)
1002 if (last_displayed_sal_valid)
1003 return last_displayed_addr;
1007 /* Get the symtab of the last sal we displayed, if it's valid. */
1010 get_last_displayed_symtab (void)
1012 if (last_displayed_sal_valid)
1013 return last_displayed_symtab;
1017 /* Get the line of the last sal we displayed, if it's valid. */
1020 get_last_displayed_line (void)
1022 if (last_displayed_sal_valid)
1023 return last_displayed_line;
1027 /* Get the last sal we displayed, if it's valid. */
1030 get_last_displayed_sal (struct symtab_and_line *sal)
1032 if (last_displayed_sal_valid)
1034 sal->pspace = last_displayed_pspace;
1035 sal->pc = last_displayed_addr;
1036 sal->symtab = last_displayed_symtab;
1037 sal->line = last_displayed_line;
1049 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1050 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1053 find_frame_funname (struct frame_info *frame, char **funname,
1054 enum language *funlang, struct symbol **funcp)
1056 struct symbol *func;
1059 *funlang = language_unknown;
1063 func = get_frame_function (frame);
1066 /* In certain pathological cases, the symtabs give the wrong
1067 function (when we are in the first function in a file which
1068 is compiled without debugging symbols, the previous function
1069 is compiled with debugging symbols, and the "foo.o" symbol
1070 that is supposed to tell us where the file with debugging
1071 symbols ends has been truncated by ar because it is longer
1072 than 15 characters). This also occurs if the user uses asm()
1073 to create a function but not stabs for it (in a file compiled
1076 So look in the minimal symbol tables as well, and if it comes
1077 up with a larger address for the function use that instead.
1078 I don't think this can ever cause any problems; there
1079 shouldn't be any minimal symbols in the middle of a function;
1080 if this is ever changed many parts of GDB will need to be
1081 changed (and we'll create a find_pc_minimal_function or some
1084 struct bound_minimal_symbol msymbol;
1086 /* Don't attempt to do this for inlined functions, which do not
1087 have a corresponding minimal symbol. */
1088 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1090 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1092 memset (&msymbol, 0, sizeof (msymbol));
1094 if (msymbol.minsym != NULL
1095 && (BMSYMBOL_VALUE_ADDRESS (msymbol)
1096 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
1098 /* We also don't know anything about the function besides
1099 its address and name. */
1101 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1102 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1106 *funname = xstrdup (SYMBOL_PRINT_NAME (func));
1107 *funlang = SYMBOL_LANGUAGE (func);
1110 if (*funlang == language_cplus)
1112 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1113 to display the demangled name that we already have
1114 stored in the symbol table, but we stored a version
1115 with DMGL_PARAMS turned on, and here we don't want to
1116 display parameters. So remove the parameters. */
1117 char *func_only = cp_remove_params (*funname);
1122 *funname = func_only;
1129 struct bound_minimal_symbol msymbol;
1132 if (!get_frame_address_in_block_if_available (frame, &pc))
1135 msymbol = lookup_minimal_symbol_by_pc (pc);
1136 if (msymbol.minsym != NULL)
1138 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1139 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1145 print_frame (struct frame_info *frame, int print_level,
1146 enum print_what print_what, int print_args,
1147 struct symtab_and_line sal)
1149 struct gdbarch *gdbarch = get_frame_arch (frame);
1150 struct ui_out *uiout = current_uiout;
1151 char *funname = NULL;
1152 enum language funlang = language_unknown;
1153 struct ui_file *stb;
1154 struct cleanup *old_chain, *list_chain;
1155 struct value_print_options opts;
1156 struct symbol *func;
1160 pc_p = get_frame_pc_if_available (frame, &pc);
1162 stb = mem_fileopen ();
1163 old_chain = make_cleanup_ui_file_delete (stb);
1165 find_frame_funname (frame, &funname, &funlang, &func);
1166 make_cleanup (xfree, funname);
1168 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1171 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
1175 ui_out_text (uiout, "#");
1176 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
1177 frame_relative_level (frame));
1179 get_user_print_options (&opts);
1180 if (opts.addressprint)
1182 || frame_show_address (frame, sal)
1183 || print_what == LOC_AND_ADDRESS)
1185 annotate_frame_address ();
1187 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
1189 ui_out_field_string (uiout, "addr", "<unavailable>");
1190 annotate_frame_address_end ();
1191 ui_out_text (uiout, " in ");
1193 annotate_frame_function_name ();
1194 fprintf_symbol_filtered (stb, funname ? funname : "??",
1195 funlang, DMGL_ANSI);
1196 ui_out_field_stream (uiout, "func", stb);
1197 ui_out_wrap_hint (uiout, " ");
1198 annotate_frame_args ();
1200 ui_out_text (uiout, " (");
1203 struct gdbarch *gdbarch = get_frame_arch (frame);
1205 struct cleanup *args_list_chain;
1207 if (gdbarch_frame_num_args_p (gdbarch))
1209 numargs = gdbarch_frame_num_args (gdbarch, frame);
1210 gdb_assert (numargs >= 0);
1215 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
1218 print_frame_args (func, frame, numargs, gdb_stdout);
1220 CATCH (e, RETURN_MASK_ERROR)
1225 /* FIXME: ARGS must be a list. If one argument is a string it
1226 will have " that will not be properly escaped. */
1227 /* Invoke ui_out_tuple_end. */
1228 do_cleanups (args_list_chain);
1231 ui_out_text (uiout, ")");
1234 const char *filename_display;
1236 filename_display = symtab_to_filename_for_display (sal.symtab);
1237 annotate_frame_source_begin ();
1238 ui_out_wrap_hint (uiout, " ");
1239 ui_out_text (uiout, " at ");
1240 annotate_frame_source_file ();
1241 ui_out_field_string (uiout, "file", filename_display);
1242 if (ui_out_is_mi_like_p (uiout))
1244 const char *fullname = symtab_to_fullname (sal.symtab);
1246 ui_out_field_string (uiout, "fullname", fullname);
1248 annotate_frame_source_file_end ();
1249 ui_out_text (uiout, ":");
1250 annotate_frame_source_line ();
1251 ui_out_field_int (uiout, "line", sal.line);
1252 annotate_frame_source_end ();
1255 if (pc_p && (funname == NULL || sal.symtab == NULL))
1257 char *lib = solib_name_from_address (get_frame_program_space (frame),
1258 get_frame_pc (frame));
1262 annotate_frame_where ();
1263 ui_out_wrap_hint (uiout, " ");
1264 ui_out_text (uiout, " from ");
1265 ui_out_field_string (uiout, "from", lib);
1269 /* do_cleanups will call ui_out_tuple_end() for us. */
1270 do_cleanups (list_chain);
1271 ui_out_text (uiout, "\n");
1272 do_cleanups (old_chain);
1276 /* Read a frame specification in whatever the appropriate format is from
1277 FRAME_EXP. Call error() if the specification is in any way invalid (so
1278 this function never returns NULL). When SEPECTED_P is non-NULL set its
1279 target to indicate that the default selected frame was used. */
1281 static struct frame_info *
1282 parse_frame_specification (const char *frame_exp, int *selected_frame_p)
1285 struct value *args[4];
1286 CORE_ADDR addrs[ARRAY_SIZE (args)];
1288 if (frame_exp == NULL)
1296 struct cleanup *cleanup;
1299 /* Skip leading white space, bail of EOL. */
1300 frame_exp = skip_spaces_const (frame_exp);
1304 /* Parse the argument, extract it, save it. */
1306 *p && !ISSPACE (*p);
1308 addr_string = savestring (frame_exp, p - frame_exp);
1310 cleanup = make_cleanup (xfree, addr_string);
1312 /* NOTE: Parse and evaluate expression, but do not use
1313 functions such as parse_and_eval_long or
1314 parse_and_eval_address to also extract the value.
1315 Instead value_as_long and value_as_address are used.
1316 This avoids problems with expressions that contain
1318 if (numargs >= ARRAY_SIZE (args))
1319 error (_("Too many args in frame specification"));
1320 args[numargs++] = parse_and_eval (addr_string);
1322 do_cleanups (cleanup);
1326 /* If no args, default to the selected frame. */
1329 if (selected_frame_p != NULL)
1330 (*selected_frame_p) = 1;
1331 return get_selected_frame (_("No stack."));
1334 /* None of the remaining use the selected frame. */
1335 if (selected_frame_p != NULL)
1336 (*selected_frame_p) = 0;
1338 /* Assume the single arg[0] is an integer, and try using that to
1339 select a frame relative to current. */
1342 struct frame_info *fid;
1343 int level = value_as_long (args[0]);
1345 fid = find_relative_frame (get_current_frame (), &level);
1347 /* find_relative_frame was successful. */
1351 /* Convert each value into a corresponding address. */
1355 for (i = 0; i < numargs; i++)
1356 addrs[i] = value_as_address (args[i]);
1359 /* Assume that the single arg[0] is an address, use that to identify
1360 a frame with a matching ID. Should this also accept stack/pc or
1361 stack/pc/special. */
1364 struct frame_id id = frame_id_build_wild (addrs[0]);
1365 struct frame_info *fid;
1367 /* If (s)he specifies the frame with an address, he deserves
1368 what (s)he gets. Still, give the highest one that matches.
1369 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1371 for (fid = get_current_frame ();
1373 fid = get_prev_frame (fid))
1375 if (frame_id_eq (id, get_frame_id (fid)))
1377 struct frame_info *prev_frame;
1381 prev_frame = get_prev_frame (fid);
1383 || !frame_id_eq (id, get_frame_id (prev_frame)))
1392 /* We couldn't identify the frame as an existing frame, but
1393 perhaps we can create one with a single argument. */
1395 return create_new_frame (addrs[0], 0);
1396 else if (numargs == 2)
1397 return create_new_frame (addrs[0], addrs[1]);
1399 error (_("Too many args in frame specification"));
1402 /* Print verbosely the selected frame or the frame at address
1403 ADDR_EXP. Absolutely all information in the frame is printed. */
1406 frame_info (char *addr_exp, int from_tty)
1408 struct frame_info *fi;
1409 struct symtab_and_line sal;
1410 struct symbol *func;
1412 struct frame_info *calling_frame_info;
1414 const char *funname = 0;
1415 enum language funlang = language_unknown;
1416 const char *pc_regname;
1417 int selected_frame_p;
1418 struct gdbarch *gdbarch;
1419 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
1422 /* Initialize it to avoid "may be used uninitialized" warning. */
1423 CORE_ADDR caller_pc = 0;
1424 int caller_pc_p = 0;
1426 fi = parse_frame_specification (addr_exp, &selected_frame_p);
1427 gdbarch = get_frame_arch (fi);
1429 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1430 is not a good name. */
1431 if (gdbarch_pc_regnum (gdbarch) >= 0)
1432 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1433 easily not match that of the internal value returned by
1435 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1437 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1438 architectures will often have a hardware register called "pc",
1439 and that register's value, again, can easily not match
1443 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1444 find_frame_sal (fi, &sal);
1445 func = get_frame_function (fi);
1449 funname = SYMBOL_PRINT_NAME (func);
1450 funlang = SYMBOL_LANGUAGE (func);
1451 if (funlang == language_cplus)
1453 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1454 to display the demangled name that we already have
1455 stored in the symbol table, but we stored a version
1456 with DMGL_PARAMS turned on, and here we don't want to
1457 display parameters. So remove the parameters. */
1458 char *func_only = cp_remove_params (funname);
1462 funname = func_only;
1463 make_cleanup (xfree, func_only);
1467 else if (frame_pc_p)
1469 struct bound_minimal_symbol msymbol;
1471 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1472 if (msymbol.minsym != NULL)
1474 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1475 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1478 calling_frame_info = get_prev_frame (fi);
1480 if (selected_frame_p && frame_relative_level (fi) >= 0)
1482 printf_filtered (_("Stack level %d, frame at "),
1483 frame_relative_level (fi));
1487 printf_filtered (_("Stack frame at "));
1489 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1490 printf_filtered (":\n");
1491 printf_filtered (" %s = ", pc_regname);
1493 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1495 fputs_filtered ("<unavailable>", gdb_stdout);
1500 printf_filtered (" in ");
1501 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1502 DMGL_ANSI | DMGL_PARAMS);
1506 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1508 puts_filtered ("; ");
1510 printf_filtered ("saved %s = ", pc_regname);
1514 caller_pc = frame_unwind_caller_pc (fi);
1517 CATCH (ex, RETURN_MASK_ERROR)
1521 case NOT_AVAILABLE_ERROR:
1522 val_print_unavailable (gdb_stdout);
1524 case OPTIMIZED_OUT_ERROR:
1525 val_print_not_saved (gdb_stdout);
1528 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1535 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1536 printf_filtered ("\n");
1538 if (calling_frame_info == NULL)
1540 enum unwind_stop_reason reason;
1542 reason = get_frame_unwind_stop_reason (fi);
1543 if (reason != UNWIND_NO_REASON)
1544 printf_filtered (_(" Outermost frame: %s\n"),
1545 frame_stop_reason_string (fi));
1547 else if (get_frame_type (fi) == TAILCALL_FRAME)
1548 puts_filtered (" tail call frame");
1549 else if (get_frame_type (fi) == INLINE_FRAME)
1550 printf_filtered (" inlined into frame %d",
1551 frame_relative_level (get_prev_frame (fi)));
1554 printf_filtered (" called by frame at ");
1555 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1558 if (get_next_frame (fi) && calling_frame_info)
1559 puts_filtered (",");
1561 if (get_next_frame (fi))
1563 printf_filtered (" caller of frame at ");
1564 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1567 if (get_next_frame (fi) || calling_frame_info)
1568 puts_filtered ("\n");
1571 printf_filtered (" source language %s.\n",
1572 language_str (s->language));
1575 /* Address of the argument list for this frame, or 0. */
1576 CORE_ADDR arg_list = get_frame_args_address (fi);
1577 /* Number of args for this frame, or -1 if unknown. */
1581 printf_filtered (" Arglist at unknown address.\n");
1584 printf_filtered (" Arglist at ");
1585 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1586 printf_filtered (",");
1588 if (!gdbarch_frame_num_args_p (gdbarch))
1591 puts_filtered (" args: ");
1595 numargs = gdbarch_frame_num_args (gdbarch, fi);
1596 gdb_assert (numargs >= 0);
1598 puts_filtered (" no args.");
1599 else if (numargs == 1)
1600 puts_filtered (" 1 arg: ");
1602 printf_filtered (" %d args: ", numargs);
1604 print_frame_args (func, fi, numargs, gdb_stdout);
1605 puts_filtered ("\n");
1609 /* Address of the local variables for this frame, or 0. */
1610 CORE_ADDR arg_list = get_frame_locals_address (fi);
1613 printf_filtered (" Locals at unknown address,");
1616 printf_filtered (" Locals at ");
1617 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1618 printf_filtered (",");
1622 /* Print as much information as possible on the location of all the
1625 enum lval_type lval;
1634 /* The sp is special; what's displayed isn't the save address, but
1635 the value of the previous frame's sp. This is a legacy thing,
1636 at one stage the frame cached the previous frame's SP instead
1637 of its address, hence it was easiest to just display the cached
1639 if (gdbarch_sp_regnum (gdbarch) >= 0)
1641 /* Find out the location of the saved stack pointer with out
1642 actually evaluating it. */
1643 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1644 &optimized, &unavailable, &lval, &addr,
1646 if (!optimized && !unavailable && lval == not_lval)
1648 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1649 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1650 gdb_byte value[MAX_REGISTER_SIZE];
1653 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1654 &optimized, &unavailable, &lval, &addr,
1656 /* NOTE: cagney/2003-05-22: This is assuming that the
1657 stack pointer was packed as an unsigned integer. That
1658 may or may not be valid. */
1659 sp = extract_unsigned_integer (value, sp_size, byte_order);
1660 printf_filtered (" Previous frame's sp is ");
1661 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1662 printf_filtered ("\n");
1665 else if (!optimized && !unavailable && lval == lval_memory)
1667 printf_filtered (" Previous frame's sp at ");
1668 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1669 printf_filtered ("\n");
1672 else if (!optimized && !unavailable && lval == lval_register)
1674 printf_filtered (" Previous frame's sp in %s\n",
1675 gdbarch_register_name (gdbarch, realnum));
1678 /* else keep quiet. */
1682 numregs = gdbarch_num_regs (gdbarch)
1683 + gdbarch_num_pseudo_regs (gdbarch);
1684 for (i = 0; i < numregs; i++)
1685 if (i != gdbarch_sp_regnum (gdbarch)
1686 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1688 /* Find out the location of the saved register without
1689 fetching the corresponding value. */
1690 frame_register_unwind (fi, i, &optimized, &unavailable,
1691 &lval, &addr, &realnum, NULL);
1692 /* For moment, only display registers that were saved on the
1694 if (!optimized && !unavailable && lval == lval_memory)
1697 puts_filtered (" Saved registers:\n ");
1699 puts_filtered (",");
1701 printf_filtered (" %s at ",
1702 gdbarch_register_name (gdbarch, i));
1703 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1707 if (count || need_nl)
1708 puts_filtered ("\n");
1711 do_cleanups (back_to);
1714 /* Print briefly all stack frames or just the innermost COUNT_EXP
1718 backtrace_command_1 (char *count_exp, int show_locals, int no_filters,
1721 struct frame_info *fi;
1724 struct frame_info *trailing;
1725 int trailing_level, py_start = 0, py_end = 0;
1726 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1728 if (!target_has_stack)
1729 error (_("No stack."));
1731 /* The following code must do two things. First, it must set the
1732 variable TRAILING to the frame from which we should start
1733 printing. Second, it must set the variable count to the number
1734 of frames which we should print, or -1 if all of them. */
1735 trailing = get_current_frame ();
1740 count = parse_and_eval_long (count_exp);
1743 struct frame_info *current;
1749 while (current && count--)
1752 current = get_prev_frame (current);
1755 /* Will stop when CURRENT reaches the top of the stack.
1756 TRAILING will be COUNT below it. */
1760 trailing = get_prev_frame (trailing);
1761 current = get_prev_frame (current);
1781 /* Read in symbols for all of the frames. Need to do this in a
1782 separate pass so that "Reading in symbols for xxx" messages
1783 don't screw up the appearance of the backtrace. Also if
1784 people have strong opinions against reading symbols for
1785 backtrace this may have to be an option. */
1787 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1792 pc = get_frame_address_in_block (fi);
1793 expand_symtab_containing_pc (pc, find_pc_mapped_section (pc));
1799 int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1800 enum ext_lang_frame_args arg_type;
1803 flags |= PRINT_LOCALS;
1805 if (!strcmp (print_frame_arguments, "scalars"))
1806 arg_type = CLI_SCALAR_VALUES;
1807 else if (!strcmp (print_frame_arguments, "all"))
1808 arg_type = CLI_ALL_VALUES;
1810 arg_type = NO_VALUES;
1812 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1813 arg_type, current_uiout,
1817 /* Run the inbuilt backtrace if there are no filters registered, or
1818 "no-filters" has been specified from the command. */
1819 if (no_filters || result == EXT_LANG_BT_NO_FILTERS)
1821 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1825 /* Don't use print_stack_frame; if an error() occurs it probably
1826 means further attempts to backtrace would fail (on the other
1827 hand, perhaps the code does or could be fixed to make sure
1828 the frame->prev field gets set to NULL in that case). */
1830 print_frame_info (fi, 1, LOCATION, 1, 0);
1833 struct frame_id frame_id = get_frame_id (fi);
1835 print_frame_local_vars (fi, 1, gdb_stdout);
1837 /* print_frame_local_vars invalidates FI. */
1838 fi = frame_find_by_id (frame_id);
1842 warning (_("Unable to restore previously selected frame."));
1847 /* Save the last frame to check for error conditions. */
1851 /* If we've stopped before the end, mention that. */
1853 printf_filtered (_("(More stack frames follow...)\n"));
1855 /* If we've run out of frames, and the reason appears to be an error
1856 condition, print it. */
1857 if (fi == NULL && trailing != NULL)
1859 enum unwind_stop_reason reason;
1861 reason = get_frame_unwind_stop_reason (trailing);
1862 if (reason >= UNWIND_FIRST_ERROR)
1863 printf_filtered (_("Backtrace stopped: %s\n"),
1864 frame_stop_reason_string (trailing));
1870 backtrace_command (char *arg, int from_tty)
1872 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1873 int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1;
1881 argv = gdb_buildargv (arg);
1882 make_cleanup_freeargv (argv);
1884 for (i = 0; argv[i]; i++)
1888 for (j = 0; j < strlen (argv[i]); j++)
1889 argv[i][j] = TOLOWER (argv[i][j]);
1891 if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
1895 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1896 fulltrace_arg = argc;
1900 arglen += strlen (argv[i]);
1906 if (fulltrace_arg >= 0 || no_filters >= 0)
1910 arg = (char *) xmalloc (arglen + 1);
1911 make_cleanup (xfree, arg);
1913 for (i = 0; i < argc; i++)
1915 if (i != fulltrace_arg && i != no_filters)
1917 strcat (arg, argv[i]);
1927 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
1928 no_filters >= 0 /* no frame-filters */, from_tty);
1930 do_cleanups (old_chain);
1933 /* Iterate over the local variables of a block B, calling CB with
1937 iterate_over_block_locals (const struct block *b,
1938 iterate_over_block_arg_local_vars_cb cb,
1941 struct block_iterator iter;
1944 ALL_BLOCK_SYMBOLS (b, iter, sym)
1946 switch (SYMBOL_CLASS (sym))
1952 if (SYMBOL_IS_ARGUMENT (sym))
1954 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1956 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1960 /* Ignore symbols which are not locals. */
1967 /* Same, but print labels. */
1970 /* Commented out, as the code using this function has also been
1971 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1972 was commented out in the first place. The discussion introducing
1973 this change (2007-12-04: Support lexical blocks and function bodies
1974 that occupy non-contiguous address ranges) did not explain why
1975 this change was made. */
1977 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1978 int *have_default, struct ui_file *stream)
1980 struct block_iterator iter;
1982 int values_printed = 0;
1984 ALL_BLOCK_SYMBOLS (b, iter, sym)
1986 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1992 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1994 struct symtab_and_line sal;
1995 struct value_print_options opts;
1997 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1999 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
2000 get_user_print_options (&opts);
2001 if (opts.addressprint)
2003 fprintf_filtered (stream, " ");
2004 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2007 fprintf_filtered (stream, " in file %s, line %d\n",
2008 sal.symtab->filename, sal.line);
2012 return values_printed;
2016 /* Iterate over all the local variables in block B, including all its
2017 superblocks, stopping when the top-level block is reached. */
2020 iterate_over_block_local_vars (const struct block *block,
2021 iterate_over_block_arg_local_vars_cb cb,
2026 iterate_over_block_locals (block, cb, cb_data);
2027 /* After handling the function's top-level block, stop. Don't
2028 continue to its superblock, the block of per-file
2030 if (BLOCK_FUNCTION (block))
2032 block = BLOCK_SUPERBLOCK (block);
2036 /* Data to be passed around in the calls to the locals and args
2039 struct print_variable_and_value_data
2041 struct frame_id frame_id;
2043 struct ui_file *stream;
2047 /* The callback for the locals and args iterators. */
2050 do_print_variable_and_value (const char *print_name,
2054 struct print_variable_and_value_data *p
2055 = (struct print_variable_and_value_data *) cb_data;
2056 struct frame_info *frame;
2058 frame = frame_find_by_id (p->frame_id);
2061 warning (_("Unable to restore previously selected frame."));
2065 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2067 /* print_variable_and_value invalidates FRAME. */
2070 p->values_printed = 1;
2073 /* Print all variables from the innermost up to the function block of FRAME.
2074 Print them with values to STREAM indented by NUM_TABS.
2076 This function will invalidate FRAME. */
2079 print_frame_local_vars (struct frame_info *frame, int num_tabs,
2080 struct ui_file *stream)
2082 struct print_variable_and_value_data cb_data;
2083 const struct block *block;
2086 if (!get_frame_pc_if_available (frame, &pc))
2088 fprintf_filtered (stream,
2089 _("PC unavailable, cannot determine locals.\n"));
2093 block = get_frame_block (frame, 0);
2096 fprintf_filtered (stream, "No symbol table info available.\n");
2100 cb_data.frame_id = get_frame_id (frame);
2101 cb_data.num_tabs = 4 * num_tabs;
2102 cb_data.stream = stream;
2103 cb_data.values_printed = 0;
2105 iterate_over_block_local_vars (block,
2106 do_print_variable_and_value,
2109 /* do_print_variable_and_value invalidates FRAME. */
2112 if (!cb_data.values_printed)
2113 fprintf_filtered (stream, _("No locals.\n"));
2117 locals_info (char *args, int from_tty)
2119 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2123 /* Iterate over all the argument variables in block B.
2125 Returns 1 if any argument was walked; 0 otherwise. */
2128 iterate_over_block_arg_vars (const struct block *b,
2129 iterate_over_block_arg_local_vars_cb cb,
2132 struct block_iterator iter;
2133 struct symbol *sym, *sym2;
2135 ALL_BLOCK_SYMBOLS (b, iter, sym)
2137 /* Don't worry about things which aren't arguments. */
2138 if (SYMBOL_IS_ARGUMENT (sym))
2140 /* We have to look up the symbol because arguments can have
2141 two entries (one a parameter, one a local) and the one we
2142 want is the local, which lookup_symbol will find for us.
2143 This includes gcc1 (not gcc2) on the sparc when passing a
2144 small structure and gcc2 when the argument type is float
2145 and it is passed as a double and converted to float by
2146 the prologue (in the latter case the type of the LOC_ARG
2147 symbol is double and the type of the LOC_LOCAL symbol is
2148 float). There are also LOC_ARG/LOC_REGISTER pairs which
2149 are not combined in symbol-reading. */
2151 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
2152 b, VAR_DOMAIN, NULL).symbol;
2153 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2158 /* Print all argument variables of the function of FRAME.
2159 Print them with values to STREAM.
2161 This function will invalidate FRAME. */
2164 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2166 struct print_variable_and_value_data cb_data;
2167 struct symbol *func;
2170 if (!get_frame_pc_if_available (frame, &pc))
2172 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2176 func = get_frame_function (frame);
2179 fprintf_filtered (stream, _("No symbol table info available.\n"));
2183 cb_data.frame_id = get_frame_id (frame);
2184 cb_data.num_tabs = 0;
2185 cb_data.stream = gdb_stdout;
2186 cb_data.values_printed = 0;
2188 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2189 do_print_variable_and_value, &cb_data);
2191 /* do_print_variable_and_value invalidates FRAME. */
2194 if (!cb_data.values_printed)
2195 fprintf_filtered (stream, _("No arguments.\n"));
2199 args_info (char *ignore, int from_tty)
2201 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2205 /* Select frame FRAME. Also print the stack frame and show the source
2206 if this is the tui version. */
2208 select_and_print_frame (struct frame_info *frame)
2210 select_frame (frame);
2212 print_stack_frame (frame, 1, SRC_AND_LOC, 1);
2215 /* Return the symbol-block in which the selected frame is executing.
2216 Can return zero under various legitimate circumstances.
2218 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2219 code address within the block returned. We use this to decide
2220 which macros are in scope. */
2222 const struct block *
2223 get_selected_block (CORE_ADDR *addr_in_block)
2225 if (!has_stack_frames ())
2228 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2231 /* Find a frame a certain number of levels away from FRAME.
2232 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2233 Positive means go to earlier frames (up); negative, the reverse.
2234 The int that contains the number of levels is counted toward
2235 zero as the frames for those levels are found.
2236 If the top or bottom frame is reached, that frame is returned,
2237 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2238 how much farther the original request asked to go. */
2241 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2243 /* Going up is simple: just call get_prev_frame enough times or
2244 until the initial frame is reached. */
2245 while (*level_offset_ptr > 0)
2247 struct frame_info *prev = get_prev_frame (frame);
2251 (*level_offset_ptr)--;
2255 /* Going down is just as simple. */
2256 while (*level_offset_ptr < 0)
2258 struct frame_info *next = get_next_frame (frame);
2262 (*level_offset_ptr)++;
2269 /* The "select_frame" command. With no argument this is a NOP.
2270 Select the frame at level LEVEL_EXP if it is a valid level.
2271 Otherwise, treat LEVEL_EXP as an address expression and select it.
2273 See parse_frame_specification for more info on proper frame
2277 select_frame_command (char *level_exp, int from_tty)
2279 select_frame (parse_frame_specification (level_exp, NULL));
2282 /* The "frame" command. With no argument, print the selected frame
2283 briefly. With an argument, behave like select_frame and then print
2284 the selected frame. */
2287 frame_command (char *level_exp, int from_tty)
2289 select_frame_command (level_exp, from_tty);
2290 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2293 /* Select the frame up one or COUNT_EXP stack levels from the
2294 previously selected frame, and print it briefly. */
2297 up_silently_base (const char *count_exp)
2299 struct frame_info *frame;
2303 count = parse_and_eval_long (count_exp);
2305 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2306 if (count != 0 && count_exp == NULL)
2307 error (_("Initial frame selected; you cannot go up."));
2308 select_frame (frame);
2312 up_silently_command (char *count_exp, int from_tty)
2314 up_silently_base (count_exp);
2318 up_command (char *count_exp, int from_tty)
2320 up_silently_base (count_exp);
2321 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2324 /* Select the frame down one or COUNT_EXP stack levels from the previously
2325 selected frame, and print it briefly. */
2328 down_silently_base (const char *count_exp)
2330 struct frame_info *frame;
2334 count = -parse_and_eval_long (count_exp);
2336 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2337 if (count != 0 && count_exp == NULL)
2339 /* We only do this if COUNT_EXP is not specified. That way
2340 "down" means to really go down (and let me know if that is
2341 impossible), but "down 9999" can be used to mean go all the
2342 way down without getting an error. */
2344 error (_("Bottom (innermost) frame selected; you cannot go down."));
2347 select_frame (frame);
2351 down_silently_command (char *count_exp, int from_tty)
2353 down_silently_base (count_exp);
2357 down_command (char *count_exp, int from_tty)
2359 down_silently_base (count_exp);
2360 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2365 return_command (char *retval_exp, int from_tty)
2367 /* Initialize it just to avoid a GCC false warning. */
2368 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2369 struct frame_info *thisframe;
2370 struct gdbarch *gdbarch;
2371 struct symbol *thisfun;
2372 struct value *return_value = NULL;
2373 struct value *function = NULL;
2374 const char *query_prefix = "";
2376 thisframe = get_selected_frame ("No selected frame.");
2377 thisfun = get_frame_function (thisframe);
2378 gdbarch = get_frame_arch (thisframe);
2380 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2381 error (_("Can not force return from an inlined function."));
2383 /* Compute the return value. If the computation triggers an error,
2384 let it bail. If the return type can't be handled, set
2385 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2389 struct expression *retval_expr = parse_expression (retval_exp);
2390 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
2391 struct type *return_type = NULL;
2393 /* Compute the return value. Should the computation fail, this
2394 call throws an error. */
2395 return_value = evaluate_expression (retval_expr);
2397 /* Cast return value to the return type of the function. Should
2398 the cast fail, this call throws an error. */
2399 if (thisfun != NULL)
2400 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2401 if (return_type == NULL)
2403 if (retval_expr->elts[0].opcode != UNOP_CAST
2404 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2405 error (_("Return value type not available for selected "
2407 "Please use an explicit cast of the value to return."));
2408 return_type = value_type (return_value);
2410 do_cleanups (old_chain);
2411 return_type = check_typedef (return_type);
2412 return_value = value_cast (return_type, return_value);
2414 /* Make sure the value is fully evaluated. It may live in the
2415 stack frame we're about to pop. */
2416 if (value_lazy (return_value))
2417 value_fetch_lazy (return_value);
2419 if (thisfun != NULL)
2420 function = read_var_value (thisfun, NULL, thisframe);
2422 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2423 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2424 /* If the return-type is "void", don't try to find the
2425 return-value's location. However, do still evaluate the
2426 return expression so that, even when the expression result
2427 is discarded, side effects such as "return i++" still
2429 return_value = NULL;
2430 else if (thisfun != NULL)
2432 rv_conv = struct_return_convention (gdbarch, function, return_type);
2433 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2434 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2436 query_prefix = "The location at which to store the "
2437 "function's return value is unknown.\n"
2438 "If you continue, the return value "
2439 "that you specified will be ignored.\n";
2440 return_value = NULL;
2445 /* Does an interactive user really want to do this? Include
2446 information, such as how well GDB can handle the return value, in
2447 the query message. */
2452 if (thisfun == NULL)
2453 confirmed = query (_("%sMake selected stack frame return now? "),
2457 if (TYPE_NO_RETURN (thisfun->type))
2458 warning (_("Function does not return normally to caller."));
2459 confirmed = query (_("%sMake %s return now? "), query_prefix,
2460 SYMBOL_PRINT_NAME (thisfun));
2463 error (_("Not confirmed"));
2466 /* Discard the selected frame and all frames inner-to it. */
2467 frame_pop (get_selected_frame (NULL));
2469 /* Store RETURN_VALUE in the just-returned register set. */
2470 if (return_value != NULL)
2472 struct type *return_type = value_type (return_value);
2473 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2475 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2476 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2477 gdbarch_return_value (gdbarch, function, return_type,
2478 get_current_regcache (), NULL /*read*/,
2479 value_contents (return_value) /*write*/);
2482 /* If we are at the end of a call dummy now, pop the dummy frame
2484 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2485 frame_pop (get_current_frame ());
2487 select_frame (get_current_frame ());
2488 /* If interactive, print the frame that is now current. */
2490 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2493 /* Sets the scope to input function name, provided that the function
2494 is within the current stack frame. */
2496 struct function_bounds
2498 CORE_ADDR low, high;
2502 func_command (char *arg, int from_tty)
2504 struct frame_info *frame;
2506 struct symtabs_and_lines sals;
2509 struct function_bounds *func_bounds = NULL;
2510 struct cleanup *cleanups;
2515 frame = get_current_frame ();
2516 sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
2517 cleanups = make_cleanup (xfree, sals.sals);
2518 func_bounds = XNEWVEC (struct function_bounds, sals.nelts);
2519 make_cleanup (xfree, func_bounds);
2520 for (i = 0; (i < sals.nelts && !found); i++)
2522 if (sals.sals[i].pspace != current_program_space)
2523 func_bounds[i].low = func_bounds[i].high = 0;
2524 else if (sals.sals[i].pc == 0
2525 || find_pc_partial_function (sals.sals[i].pc, NULL,
2526 &func_bounds[i].low,
2527 &func_bounds[i].high) == 0)
2529 func_bounds[i].low = func_bounds[i].high = 0;
2535 for (i = 0; (i < sals.nelts && !found); i++)
2536 found = (get_frame_pc (frame) >= func_bounds[i].low
2537 && get_frame_pc (frame) < func_bounds[i].high);
2541 frame = find_relative_frame (frame, &level);
2544 while (!found && level == 0);
2546 do_cleanups (cleanups);
2549 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2550 else if (frame != get_selected_frame (NULL))
2551 select_and_print_frame (frame);
2555 /* Provide a prototype to silence -Wmissing-prototypes. */
2556 void _initialize_stack (void);
2559 _initialize_stack (void)
2561 add_com ("return", class_stack, return_command, _("\
2562 Make selected stack frame return to its caller.\n\
2563 Control remains in the debugger, but when you continue\n\
2564 execution will resume in the frame above the one now selected.\n\
2565 If an argument is given, it is an expression for the value to return."));
2567 add_com ("up", class_stack, up_command, _("\
2568 Select and print stack frame that called this one.\n\
2569 An argument says how many frames up to go."));
2570 add_com ("up-silently", class_support, up_silently_command, _("\
2571 Same as the `up' command, but does not print anything.\n\
2572 This is useful in command scripts."));
2574 add_com ("down", class_stack, down_command, _("\
2575 Select and print stack frame called by this one.\n\
2576 An argument says how many frames down to go."));
2577 add_com_alias ("do", "down", class_stack, 1);
2578 add_com_alias ("dow", "down", class_stack, 1);
2579 add_com ("down-silently", class_support, down_silently_command, _("\
2580 Same as the `down' command, but does not print anything.\n\
2581 This is useful in command scripts."));
2583 add_com ("frame", class_stack, frame_command, _("\
2584 Select and print a stack frame.\nWith no argument, \
2585 print the selected stack frame. (See also \"info frame\").\n\
2586 An argument specifies the frame to select.\n\
2587 It can be a stack frame number or the address of the frame.\n\
2588 With argument, nothing is printed if input is coming from\n\
2589 a command file or a user-defined command."));
2591 add_com_alias ("f", "frame", class_stack, 1);
2593 add_com ("select-frame", class_stack, select_frame_command, _("\
2594 Select a stack frame without printing anything.\n\
2595 An argument specifies the frame to select.\n\
2596 It can be a stack frame number or the address of the frame.\n"));
2598 add_com ("backtrace", class_stack, backtrace_command, _("\
2599 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2600 With a negative argument, print outermost -COUNT frames.\nUse of the \
2601 'full' qualifier also prints the values of the local variables.\n\
2602 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2603 on this backtrace.\n"));
2604 add_com_alias ("bt", "backtrace", class_stack, 0);
2606 add_com_alias ("where", "backtrace", class_alias, 0);
2607 add_info ("stack", backtrace_command,
2608 _("Backtrace of the stack, or innermost COUNT frames."));
2609 add_info_alias ("s", "stack", 1);
2610 add_info ("frame", frame_info,
2611 _("All about selected stack frame, or frame at ADDR."));
2612 add_info_alias ("f", "frame", 1);
2613 add_info ("locals", locals_info,
2614 _("Local variables of current stack frame."));
2615 add_info ("args", args_info,
2616 _("Argument variables of current stack frame."));
2619 add_com ("func", class_stack, func_command, _("\
2620 Select the stack frame that contains <func>.\n\
2621 Usage: func <name>\n"));
2623 add_setshow_enum_cmd ("frame-arguments", class_stack,
2624 print_frame_arguments_choices, &print_frame_arguments,
2625 _("Set printing of non-scalar frame arguments"),
2626 _("Show printing of non-scalar frame arguments"),
2627 NULL, NULL, NULL, &setprintlist, &showprintlist);
2629 add_setshow_boolean_cmd ("frame-arguments", no_class,
2630 &print_raw_frame_arguments, _("\
2631 Set whether to print frame arguments in raw form."), _("\
2632 Show whether to print frame arguments in raw form."), _("\
2633 If set, frame arguments are printed in raw form, bypassing any\n\
2634 pretty-printers for that value."),
2636 &setprintrawlist, &showprintrawlist);
2638 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2639 &disassemble_next_line, _("\
2640 Set whether to disassemble next source line or insn when execution stops."),
2642 Show whether to disassemble next source line or insn when execution stops."),
2644 If ON, GDB will display disassembly of the next source line, in addition\n\
2645 to displaying the source line itself. If the next source line cannot\n\
2646 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2647 will display disassembly of next instruction instead of showing the\n\
2649 If AUTO, display disassembly of next instruction only if the source line\n\
2650 cannot be displayed.\n\
2651 If OFF (which is the default), never display the disassembly of the next\n\
2654 show_disassemble_next_line,
2655 &setlist, &showlist);
2656 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2658 add_setshow_enum_cmd ("entry-values", class_stack,
2659 print_entry_values_choices, &print_entry_values,
2660 _("Set printing of function arguments at function "
2662 _("Show printing of function arguments at function "
2665 GDB can sometimes determine the values of function arguments at entry,\n\
2666 in addition to their current values. This option tells GDB whether\n\
2667 to print the current value, the value at entry (marked as val@entry),\n\
2668 or both. Note that one or both of these values may be <optimized out>."),
2669 NULL, NULL, &setprintlist, &showprintlist);