1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 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"
56 /* The possible choices of "set print frame-arguments", and the value
59 static const char *const print_frame_arguments_choices[] =
60 {"all", "scalars", "none", NULL};
61 static const char *print_frame_arguments = "scalars";
63 /* If non-zero, don't invoke pretty-printers for frame arguments. */
64 static int print_raw_frame_arguments;
66 /* The possible choices of "set print entry-values", and the value
69 const char print_entry_values_no[] = "no";
70 const char print_entry_values_only[] = "only";
71 const char print_entry_values_preferred[] = "preferred";
72 const char print_entry_values_if_needed[] = "if-needed";
73 const char print_entry_values_both[] = "both";
74 const char print_entry_values_compact[] = "compact";
75 const char print_entry_values_default[] = "default";
76 static const char *const print_entry_values_choices[] =
78 print_entry_values_no,
79 print_entry_values_only,
80 print_entry_values_preferred,
81 print_entry_values_if_needed,
82 print_entry_values_both,
83 print_entry_values_compact,
84 print_entry_values_default,
87 const char *print_entry_values = print_entry_values_default;
89 /* Prototypes for local functions. */
91 static void print_frame_local_vars (struct frame_info *, int,
94 static void print_frame (struct frame_info *frame, int print_level,
95 enum print_what print_what, int print_args,
96 struct symtab_and_line sal);
98 static void set_last_displayed_sal (int valid,
99 struct program_space *pspace,
101 struct symtab *symtab,
104 /* Zero means do things normally; we are interacting directly with the
105 user. One means print the full filename and linenumber when a
106 frame is printed, and do so in a format emacs18/emacs19.22 can
107 parse. Two means print similar annotations, but in many more
108 cases and in a slightly different syntax. */
110 int annotation_level = 0;
112 /* These variables hold the last symtab and line we displayed to the user.
113 * This is where we insert a breakpoint or a skiplist entry by default. */
114 static int last_displayed_sal_valid = 0;
115 static struct program_space *last_displayed_pspace = 0;
116 static CORE_ADDR last_displayed_addr = 0;
117 static struct symtab *last_displayed_symtab = 0;
118 static int last_displayed_line = 0;
121 /* Return 1 if we should display the address in addition to the location,
122 because we are in the middle of a statement. */
125 frame_show_address (struct frame_info *frame,
126 struct symtab_and_line sal)
128 /* If there is a line number, but no PC, then there is no location
129 information associated with this sal. The only way that should
130 happen is for the call sites of inlined functions (SAL comes from
131 find_frame_sal). Otherwise, we would have some PC range if the
132 SAL came from a line table. */
133 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
135 if (get_next_frame (frame) == NULL)
136 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
138 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
142 return get_frame_pc (frame) != sal.pc;
148 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
149 int print_level, enum print_what print_what,
152 scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
154 print_stack_frame (frame, print_level, print_what, set_current_sal);
157 /* Show or print a stack frame FRAME briefly. The output is formatted
158 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
159 relative level, function name, argument list, and file name and
160 line number. If the frame's PC is not at the beginning of the
161 source line, the actual PC is printed at the beginning. */
164 print_stack_frame (struct frame_info *frame, int print_level,
165 enum print_what print_what,
169 /* For mi, alway print location and address. */
170 if (current_uiout->is_mi_like_p ())
171 print_what = LOC_AND_ADDRESS;
175 print_frame_info (frame, print_level, print_what, 1 /* print_args */,
178 set_current_sal_from_frame (frame);
180 CATCH (e, RETURN_MASK_ERROR)
186 /* Print nameless arguments of frame FRAME on STREAM, where START is
187 the offset of the first nameless argument, and NUM is the number of
188 nameless arguments to print. FIRST is nonzero if this is the first
189 argument (not just the first nameless argument). */
192 print_frame_nameless_args (struct frame_info *frame, long start, int num,
193 int first, struct ui_file *stream)
195 struct gdbarch *gdbarch = get_frame_arch (frame);
196 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
201 for (i = 0; i < num; i++)
204 argsaddr = get_frame_args_address (frame);
207 arg_value = read_memory_integer (argsaddr + start,
208 sizeof (int), byte_order);
210 fprintf_filtered (stream, ", ");
211 fprintf_filtered (stream, "%ld", arg_value);
213 start += sizeof (int);
217 /* Print single argument of inferior function. ARG must be already
220 Errors are printed as if they would be the parameter value. Use zeroed ARG
221 iff it should not be printed accoring to user settings. */
224 print_frame_arg (const struct frame_arg *arg)
226 struct ui_out *uiout = current_uiout;
227 struct cleanup *old_chain;
228 const char *error_message = NULL;
232 gdb_assert (!arg->val || !arg->error);
233 gdb_assert (arg->entry_kind == print_entry_values_no
234 || arg->entry_kind == print_entry_values_only
235 || (!uiout->is_mi_like_p ()
236 && arg->entry_kind == print_entry_values_compact));
238 annotate_arg_begin ();
240 old_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
241 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
242 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
243 if (arg->entry_kind == print_entry_values_compact)
245 /* It is OK to provide invalid MI-like stream as with
246 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
249 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
250 SYMBOL_LANGUAGE (arg->sym),
251 DMGL_PARAMS | DMGL_ANSI);
253 if (arg->entry_kind == print_entry_values_only
254 || arg->entry_kind == print_entry_values_compact)
256 uiout->field_stream ("name", stb);
257 annotate_arg_name_end ();
260 if (!arg->val && !arg->error)
265 error_message = arg->error;
270 const struct language_defn *language;
271 struct value_print_options opts;
273 /* Avoid value_print because it will deref ref parameters. We
274 just want to print their addresses. Print ??? for args whose
275 address we do not know. We pass 2 as "recurse" to val_print
276 because our standard indentation here is 4 spaces, and
277 val_print indents 2 for each recurse. */
279 annotate_arg_value (value_type (arg->val));
281 /* Use the appropriate language to display our symbol, unless the
282 user forced the language to a specific language. */
283 if (language_mode == language_mode_auto)
284 language = language_def (SYMBOL_LANGUAGE (arg->sym));
286 language = current_language;
288 get_no_prettyformat_print_options (&opts);
290 opts.raw = print_raw_frame_arguments;
292 /* True in "summary" mode, false otherwise. */
293 opts.summary = !strcmp (print_frame_arguments, "scalars");
295 common_val_print (arg->val, &stb, 2, &opts, language);
297 CATCH (except, RETURN_MASK_ERROR)
299 error_message = except.message;
303 if (error_message != NULL)
304 stb.printf (_("<error reading variable: %s>"), error_message);
307 uiout->field_stream ("value", stb);
309 /* Also invoke ui_out_tuple_end. */
310 do_cleanups (old_chain);
315 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
316 responsible for xfree of ARGP->ERROR. This function never throws an
320 read_frame_local (struct symbol *sym, struct frame_info *frame,
321 struct frame_arg *argp)
329 argp->val = read_var_value (sym, NULL, frame);
331 CATCH (except, RETURN_MASK_ERROR)
333 argp->error = xstrdup (except.message);
338 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
339 responsible for xfree of ARGP->ERROR. This function never throws an
343 read_frame_arg (struct symbol *sym, struct frame_info *frame,
344 struct frame_arg *argp, struct frame_arg *entryargp)
346 struct value *val = NULL, *entryval = NULL;
347 char *val_error = NULL, *entryval_error = NULL;
350 if (print_entry_values != print_entry_values_only
351 && print_entry_values != print_entry_values_preferred)
355 val = read_var_value (sym, NULL, frame);
357 CATCH (except, RETURN_MASK_ERROR)
359 val_error = (char *) alloca (strlen (except.message) + 1);
360 strcpy (val_error, except.message);
365 if (SYMBOL_COMPUTED_OPS (sym) != NULL
366 && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
367 && print_entry_values != print_entry_values_no
368 && (print_entry_values != print_entry_values_if_needed
369 || !val || value_optimized_out (val)))
373 const struct symbol_computed_ops *ops;
375 ops = SYMBOL_COMPUTED_OPS (sym);
376 entryval = ops->read_variable_at_entry (sym, frame);
378 CATCH (except, RETURN_MASK_ERROR)
380 if (except.error != NO_ENTRY_VALUE_ERROR)
382 entryval_error = (char *) alloca (strlen (except.message) + 1);
383 strcpy (entryval_error, except.message);
388 if (entryval != NULL && value_optimized_out (entryval))
391 if (print_entry_values == print_entry_values_compact
392 || print_entry_values == print_entry_values_default)
394 /* For MI do not try to use print_entry_values_compact for ARGP. */
396 if (val && entryval && !current_uiout->is_mi_like_p ())
398 struct type *type = value_type (val);
400 if (value_lazy (val))
401 value_fetch_lazy (val);
402 if (value_lazy (entryval))
403 value_fetch_lazy (entryval);
405 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
407 /* Initialize it just to avoid a GCC false warning. */
408 struct value *val_deref = NULL, *entryval_deref;
410 /* DW_AT_call_value does match with the current
411 value. If it is a reference still try to verify if
412 dereferenced DW_AT_call_data_value does not differ. */
416 struct type *type_deref;
418 val_deref = coerce_ref (val);
419 if (value_lazy (val_deref))
420 value_fetch_lazy (val_deref);
421 type_deref = value_type (val_deref);
423 entryval_deref = coerce_ref (entryval);
424 if (value_lazy (entryval_deref))
425 value_fetch_lazy (entryval_deref);
427 /* If the reference addresses match but dereferenced
428 content does not match print them. */
430 && value_contents_eq (val_deref, 0,
432 TYPE_LENGTH (type_deref)))
435 CATCH (except, RETURN_MASK_ERROR)
437 /* If the dereferenced content could not be
438 fetched do not display anything. */
439 if (except.error == NO_ENTRY_VALUE_ERROR)
441 else if (except.message != NULL)
443 entryval_error = (char *) alloca (strlen (except.message) + 1);
444 strcpy (entryval_error, except.message);
449 /* Value was not a reference; and its content matches. */
450 if (val == val_deref)
458 /* Try to remove possibly duplicate error message for ENTRYARGP even
461 if (val_error && entryval_error
462 && strcmp (val_error, entryval_error) == 0)
464 entryval_error = NULL;
466 /* Do not se VAL_EQUAL as the same error message may be shown for
467 the entry value even if no entry values are present in the
473 if (entryval == NULL)
475 if (print_entry_values == print_entry_values_preferred)
477 gdb_assert (val == NULL);
481 val = read_var_value (sym, NULL, frame);
483 CATCH (except, RETURN_MASK_ERROR)
485 val_error = (char *) alloca (strlen (except.message) + 1);
486 strcpy (val_error, except.message);
490 if (print_entry_values == print_entry_values_only
491 || print_entry_values == print_entry_values_both
492 || (print_entry_values == print_entry_values_preferred
493 && (!val || value_optimized_out (val))))
495 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
496 entryval_error = NULL;
499 if ((print_entry_values == print_entry_values_compact
500 || print_entry_values == print_entry_values_if_needed
501 || print_entry_values == print_entry_values_preferred)
502 && (!val || value_optimized_out (val)) && entryval != NULL)
510 argp->error = val_error ? xstrdup (val_error) : NULL;
511 if (!val && !val_error)
512 argp->entry_kind = print_entry_values_only;
513 else if ((print_entry_values == print_entry_values_compact
514 || print_entry_values == print_entry_values_default) && val_equal)
516 argp->entry_kind = print_entry_values_compact;
517 gdb_assert (!current_uiout->is_mi_like_p ());
520 argp->entry_kind = print_entry_values_no;
522 entryargp->sym = sym;
523 entryargp->val = entryval;
524 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
525 if (!entryval && !entryval_error)
526 entryargp->entry_kind = print_entry_values_no;
528 entryargp->entry_kind = print_entry_values_only;
531 /* Print the arguments of frame FRAME on STREAM, given the function
532 FUNC running in that frame (as a symbol), where NUM is the number
533 of arguments according to the stack frame (or -1 if the number of
534 arguments is unknown). */
536 /* Note that currently the "number of arguments according to the
537 stack frame" is only known on VAX where i refers to the "number of
538 ints of arguments according to the stack frame". */
541 print_frame_args (struct symbol *func, struct frame_info *frame,
542 int num, struct ui_file *stream)
544 struct ui_out *uiout = current_uiout;
546 /* Offset of next stack argument beyond the one we have seen that is
547 at the highest offset, or -1 if we haven't come to a stack
549 long highest_offset = -1;
550 /* Number of ints of arguments that we have printed so far. */
551 int args_printed = 0;
552 /* True if we should print arguments, false otherwise. */
553 int print_args = strcmp (print_frame_arguments, "none");
557 const struct block *b = SYMBOL_BLOCK_VALUE (func);
558 struct block_iterator iter;
561 ALL_BLOCK_SYMBOLS (b, iter, sym)
563 struct frame_arg arg, entryarg;
567 /* Keep track of the highest stack argument offset seen, and
568 skip over any kinds of symbols we don't care about. */
570 if (!SYMBOL_IS_ARGUMENT (sym))
573 switch (SYMBOL_CLASS (sym))
578 long current_offset = SYMBOL_VALUE (sym);
579 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
581 /* Compute address of next argument by adding the size of
582 this argument and rounding to an int boundary. */
584 ((current_offset + arg_size + sizeof (int) - 1)
585 & ~(sizeof (int) - 1));
587 /* If this is the highest offset seen yet, set
589 if (highest_offset == -1
590 || (current_offset > highest_offset))
591 highest_offset = current_offset;
593 /* Add the number of ints we're about to print to
595 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
598 /* We care about types of symbols, but don't need to
599 keep track of stack offsets in them. */
601 case LOC_REGPARM_ADDR:
603 case LOC_OPTIMIZED_OUT:
608 /* We have to look up the symbol because arguments can have
609 two entries (one a parameter, one a local) and the one we
610 want is the local, which lookup_symbol will find for us.
611 This includes gcc1 (not gcc2) on SPARC when passing a
612 small structure and gcc2 when the argument type is float
613 and it is passed as a double and converted to float by
614 the prologue (in the latter case the type of the LOC_ARG
615 symbol is double and the type of the LOC_LOCAL symbol is
617 /* But if the parameter name is null, don't try it. Null
618 parameter names occur on the RS/6000, for traceback
619 tables. FIXME, should we even print them? */
621 if (*SYMBOL_LINKAGE_NAME (sym))
625 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
626 b, VAR_DOMAIN, NULL).symbol;
627 gdb_assert (nsym != NULL);
628 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
629 && !SYMBOL_IS_ARGUMENT (nsym))
631 /* There is a LOC_ARG/LOC_REGISTER pair. This means
632 that it was passed on the stack and loaded into a
633 register, or passed in a register and stored in a
634 stack slot. GDB 3.x used the LOC_ARG; GDB
635 4.0-4.11 used the LOC_REGISTER.
637 Reasons for using the LOC_ARG:
639 (1) Because find_saved_registers may be slow for
642 (2) Because registers are often re-used and stack
643 slots rarely (never?) are. Therefore using
644 the stack slot is much less likely to print
647 Reasons why we might want to use the LOC_REGISTER:
649 (1) So that the backtrace prints the same value
650 as "print foo". I see no compelling reason
651 why this needs to be the case; having the
652 backtrace print the value which was passed
653 in, and "print foo" print the value as
654 modified within the called function, makes
657 Additional note: It might be nice if "info args"
658 displayed both values.
660 One more note: There is a case with SPARC
661 structure passing where we need to use the
662 LOC_REGISTER, but this is dealt with by creating
663 a single LOC_REGPARM in symbol reading. */
665 /* Leave sym (the LOC_ARG) alone. */
672 /* Print the current arg. */
675 uiout->wrap_hint (" ");
679 memset (&arg, 0, sizeof (arg));
681 arg.entry_kind = print_entry_values_no;
682 memset (&entryarg, 0, sizeof (entryarg));
684 entryarg.entry_kind = print_entry_values_no;
687 read_frame_arg (sym, frame, &arg, &entryarg);
689 if (arg.entry_kind != print_entry_values_only)
690 print_frame_arg (&arg);
692 if (entryarg.entry_kind != print_entry_values_no)
694 if (arg.entry_kind != print_entry_values_only)
697 uiout->wrap_hint (" ");
700 print_frame_arg (&entryarg);
704 xfree (entryarg.error);
710 /* Don't print nameless args in situations where we don't know
711 enough about the stack to find them. */
716 if (highest_offset == -1)
717 start = gdbarch_frame_args_skip (get_frame_arch (frame));
719 start = highest_offset;
721 print_frame_nameless_args (frame, start, num - args_printed,
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,
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. */
819 uiout->field_fmt_int (2, ui_left, "level",
820 frame_relative_level (frame));
822 if (uiout->is_mi_like_p ())
824 annotate_frame_address ();
825 uiout->field_core_addr ("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 uiout->field_string ("func", "<function called from gdb>");
835 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
837 annotate_signal_handler_caller ();
838 uiout->field_string ("func", "<signal handler called>");
840 else if (get_frame_type (frame) == ARCH_FRAME)
842 uiout->field_string ("func", "<cross-architecture call>");
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 uiout->field_core_addr ("addr",
914 gdbarch, get_frame_pc (frame));
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 const char *print_name = SYMBOL_PRINT_NAME (func);
1108 *funlang = SYMBOL_LANGUAGE (func);
1111 if (*funlang == language_cplus)
1113 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1114 to display the demangled name that we already have
1115 stored in the symbol table, but we stored a version
1116 with DMGL_PARAMS turned on, and here we don't want to
1117 display parameters. So remove the parameters. */
1118 char *func_only = cp_remove_params (print_name);
1121 *funname = func_only;
1124 /* If we didn't hit the C++ case above, set *funname here.
1125 This approach is taken to avoid having to install a
1126 cleanup in case cp_remove_params can throw. */
1127 if (*funname == NULL)
1128 *funname = xstrdup (print_name);
1133 struct bound_minimal_symbol msymbol;
1136 if (!get_frame_address_in_block_if_available (frame, &pc))
1139 msymbol = lookup_minimal_symbol_by_pc (pc);
1140 if (msymbol.minsym != NULL)
1142 *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym));
1143 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1149 print_frame (struct frame_info *frame, int print_level,
1150 enum print_what print_what, int print_args,
1151 struct symtab_and_line sal)
1153 struct gdbarch *gdbarch = get_frame_arch (frame);
1154 struct ui_out *uiout = current_uiout;
1155 char *funname = NULL;
1156 enum language funlang = language_unknown;
1157 struct cleanup *old_chain, *list_chain;
1158 struct value_print_options opts;
1159 struct symbol *func;
1163 pc_p = get_frame_pc_if_available (frame, &pc);
1166 find_frame_funname (frame, &funname, &funlang, &func);
1167 old_chain = make_cleanup (xfree, funname);
1169 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1172 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
1177 uiout->field_fmt_int (2, ui_left, "level",
1178 frame_relative_level (frame));
1180 get_user_print_options (&opts);
1181 if (opts.addressprint)
1183 || frame_show_address (frame, sal)
1184 || print_what == LOC_AND_ADDRESS)
1186 annotate_frame_address ();
1188 uiout->field_core_addr ("addr", gdbarch, pc);
1190 uiout->field_string ("addr", "<unavailable>");
1191 annotate_frame_address_end ();
1192 uiout->text (" in ");
1194 annotate_frame_function_name ();
1197 fprintf_symbol_filtered (&stb, funname ? funname : "??",
1198 funlang, DMGL_ANSI);
1199 uiout->field_stream ("func", stb);
1200 uiout->wrap_hint (" ");
1201 annotate_frame_args ();
1206 struct gdbarch *gdbarch = get_frame_arch (frame);
1208 struct cleanup *args_list_chain;
1210 if (gdbarch_frame_num_args_p (gdbarch))
1212 numargs = gdbarch_frame_num_args (gdbarch, frame);
1213 gdb_assert (numargs >= 0);
1218 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
1221 print_frame_args (func, frame, numargs, gdb_stdout);
1223 CATCH (e, RETURN_MASK_ERROR)
1228 /* FIXME: ARGS must be a list. If one argument is a string it
1229 will have " that will not be properly escaped. */
1230 /* Invoke ui_out_tuple_end. */
1231 do_cleanups (args_list_chain);
1237 const char *filename_display;
1239 filename_display = symtab_to_filename_for_display (sal.symtab);
1240 annotate_frame_source_begin ();
1241 uiout->wrap_hint (" ");
1242 uiout->text (" at ");
1243 annotate_frame_source_file ();
1244 uiout->field_string ("file", filename_display);
1245 if (uiout->is_mi_like_p ())
1247 const char *fullname = symtab_to_fullname (sal.symtab);
1249 uiout->field_string ("fullname", fullname);
1251 annotate_frame_source_file_end ();
1253 annotate_frame_source_line ();
1254 uiout->field_int ("line", sal.line);
1255 annotate_frame_source_end ();
1258 if (pc_p && (funname == NULL || sal.symtab == NULL))
1260 char *lib = solib_name_from_address (get_frame_program_space (frame),
1261 get_frame_pc (frame));
1265 annotate_frame_where ();
1266 uiout->wrap_hint (" ");
1267 uiout->text (" from ");
1268 uiout->field_string ("from", lib);
1272 /* do_cleanups will call ui_out_tuple_end() for us. */
1273 do_cleanups (list_chain);
1275 do_cleanups (old_chain);
1279 /* Read a frame specification in whatever the appropriate format is from
1280 FRAME_EXP. Call error() if the specification is in any way invalid (so
1281 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1282 set its target to indicate that the default selected frame was used. */
1284 static struct frame_info *
1285 parse_frame_specification (const char *frame_exp, int *selected_frame_p)
1288 struct value *args[4];
1289 CORE_ADDR addrs[ARRAY_SIZE (args)];
1291 if (frame_exp == NULL)
1299 struct cleanup *cleanup;
1302 /* Skip leading white space, bail of EOL. */
1303 frame_exp = skip_spaces_const (frame_exp);
1307 /* Parse the argument, extract it, save it. */
1309 *p && !ISSPACE (*p);
1311 addr_string = savestring (frame_exp, p - frame_exp);
1313 cleanup = make_cleanup (xfree, addr_string);
1315 /* NOTE: Parse and evaluate expression, but do not use
1316 functions such as parse_and_eval_long or
1317 parse_and_eval_address to also extract the value.
1318 Instead value_as_long and value_as_address are used.
1319 This avoids problems with expressions that contain
1321 if (numargs >= ARRAY_SIZE (args))
1322 error (_("Too many args in frame specification"));
1323 args[numargs++] = parse_and_eval (addr_string);
1325 do_cleanups (cleanup);
1329 /* If no args, default to the selected frame. */
1332 if (selected_frame_p != NULL)
1333 (*selected_frame_p) = 1;
1334 return get_selected_frame (_("No stack."));
1337 /* None of the remaining use the selected frame. */
1338 if (selected_frame_p != NULL)
1339 (*selected_frame_p) = 0;
1341 /* Assume the single arg[0] is an integer, and try using that to
1342 select a frame relative to current. */
1345 struct frame_info *fid;
1346 int level = value_as_long (args[0]);
1348 fid = find_relative_frame (get_current_frame (), &level);
1350 /* find_relative_frame was successful. */
1354 /* Convert each value into a corresponding address. */
1358 for (i = 0; i < numargs; i++)
1359 addrs[i] = value_as_address (args[i]);
1362 /* Assume that the single arg[0] is an address, use that to identify
1363 a frame with a matching ID. Should this also accept stack/pc or
1364 stack/pc/special. */
1367 struct frame_id id = frame_id_build_wild (addrs[0]);
1368 struct frame_info *fid;
1370 /* If (s)he specifies the frame with an address, he deserves
1371 what (s)he gets. Still, give the highest one that matches.
1372 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1374 for (fid = get_current_frame ();
1376 fid = get_prev_frame (fid))
1378 if (frame_id_eq (id, get_frame_id (fid)))
1380 struct frame_info *prev_frame;
1384 prev_frame = get_prev_frame (fid);
1386 || !frame_id_eq (id, get_frame_id (prev_frame)))
1395 /* We couldn't identify the frame as an existing frame, but
1396 perhaps we can create one with a single argument. */
1398 return create_new_frame (addrs[0], 0);
1399 else if (numargs == 2)
1400 return create_new_frame (addrs[0], addrs[1]);
1402 error (_("Too many args in frame specification"));
1405 /* Print verbosely the selected frame or the frame at address
1406 ADDR_EXP. Absolutely all information in the frame is printed. */
1409 frame_info (char *addr_exp, int from_tty)
1411 struct frame_info *fi;
1412 struct symtab_and_line sal;
1413 struct symbol *func;
1415 struct frame_info *calling_frame_info;
1417 const char *funname = 0;
1418 enum language funlang = language_unknown;
1419 const char *pc_regname;
1420 int selected_frame_p;
1421 struct gdbarch *gdbarch;
1422 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
1425 /* Initialize it to avoid "may be used uninitialized" warning. */
1426 CORE_ADDR caller_pc = 0;
1427 int caller_pc_p = 0;
1429 fi = parse_frame_specification (addr_exp, &selected_frame_p);
1430 gdbarch = get_frame_arch (fi);
1432 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1433 is not a good name. */
1434 if (gdbarch_pc_regnum (gdbarch) >= 0)
1435 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1436 easily not match that of the internal value returned by
1438 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1440 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1441 architectures will often have a hardware register called "pc",
1442 and that register's value, again, can easily not match
1446 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1447 find_frame_sal (fi, &sal);
1448 func = get_frame_function (fi);
1452 funname = SYMBOL_PRINT_NAME (func);
1453 funlang = SYMBOL_LANGUAGE (func);
1454 if (funlang == language_cplus)
1456 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1457 to display the demangled name that we already have
1458 stored in the symbol table, but we stored a version
1459 with DMGL_PARAMS turned on, and here we don't want to
1460 display parameters. So remove the parameters. */
1461 char *func_only = cp_remove_params (funname);
1465 funname = func_only;
1466 make_cleanup (xfree, func_only);
1470 else if (frame_pc_p)
1472 struct bound_minimal_symbol msymbol;
1474 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1475 if (msymbol.minsym != NULL)
1477 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1478 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1481 calling_frame_info = get_prev_frame (fi);
1483 if (selected_frame_p && frame_relative_level (fi) >= 0)
1485 printf_filtered (_("Stack level %d, frame at "),
1486 frame_relative_level (fi));
1490 printf_filtered (_("Stack frame at "));
1492 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1493 printf_filtered (":\n");
1494 printf_filtered (" %s = ", pc_regname);
1496 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1498 fputs_filtered ("<unavailable>", gdb_stdout);
1503 printf_filtered (" in ");
1504 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1505 DMGL_ANSI | DMGL_PARAMS);
1509 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1511 puts_filtered ("; ");
1513 printf_filtered ("saved %s = ", pc_regname);
1515 if (!frame_id_p (frame_unwind_caller_id (fi)))
1516 val_print_not_saved (gdb_stdout);
1521 caller_pc = frame_unwind_caller_pc (fi);
1524 CATCH (ex, RETURN_MASK_ERROR)
1528 case NOT_AVAILABLE_ERROR:
1529 val_print_unavailable (gdb_stdout);
1531 case OPTIMIZED_OUT_ERROR:
1532 val_print_not_saved (gdb_stdout);
1535 fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
1543 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1544 printf_filtered ("\n");
1546 if (calling_frame_info == NULL)
1548 enum unwind_stop_reason reason;
1550 reason = get_frame_unwind_stop_reason (fi);
1551 if (reason != UNWIND_NO_REASON)
1552 printf_filtered (_(" Outermost frame: %s\n"),
1553 frame_stop_reason_string (fi));
1555 else if (get_frame_type (fi) == TAILCALL_FRAME)
1556 puts_filtered (" tail call frame");
1557 else if (get_frame_type (fi) == INLINE_FRAME)
1558 printf_filtered (" inlined into frame %d",
1559 frame_relative_level (get_prev_frame (fi)));
1562 printf_filtered (" called by frame at ");
1563 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1566 if (get_next_frame (fi) && calling_frame_info)
1567 puts_filtered (",");
1569 if (get_next_frame (fi))
1571 printf_filtered (" caller of frame at ");
1572 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1575 if (get_next_frame (fi) || calling_frame_info)
1576 puts_filtered ("\n");
1579 printf_filtered (" source language %s.\n",
1580 language_str (s->language));
1583 /* Address of the argument list for this frame, or 0. */
1584 CORE_ADDR arg_list = get_frame_args_address (fi);
1585 /* Number of args for this frame, or -1 if unknown. */
1589 printf_filtered (" Arglist at unknown address.\n");
1592 printf_filtered (" Arglist at ");
1593 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1594 printf_filtered (",");
1596 if (!gdbarch_frame_num_args_p (gdbarch))
1599 puts_filtered (" args: ");
1603 numargs = gdbarch_frame_num_args (gdbarch, fi);
1604 gdb_assert (numargs >= 0);
1606 puts_filtered (" no args.");
1607 else if (numargs == 1)
1608 puts_filtered (" 1 arg: ");
1610 printf_filtered (" %d args: ", numargs);
1612 print_frame_args (func, fi, numargs, gdb_stdout);
1613 puts_filtered ("\n");
1617 /* Address of the local variables for this frame, or 0. */
1618 CORE_ADDR arg_list = get_frame_locals_address (fi);
1621 printf_filtered (" Locals at unknown address,");
1624 printf_filtered (" Locals at ");
1625 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1626 printf_filtered (",");
1630 /* Print as much information as possible on the location of all the
1636 int sp_regnum = gdbarch_sp_regnum (gdbarch);
1638 /* The sp is special; what's displayed isn't the save address, but
1639 the value of the previous frame's sp. This is a legacy thing,
1640 at one stage the frame cached the previous frame's SP instead
1641 of its address, hence it was easiest to just display the cached
1645 struct value *value = frame_unwind_register_value (fi, sp_regnum);
1646 gdb_assert (value != NULL);
1648 if (!value_optimized_out (value) && value_entirely_available (value))
1650 if (VALUE_LVAL (value) == not_lval)
1653 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1654 int sp_size = register_size (gdbarch, sp_regnum);
1656 sp = extract_unsigned_integer (value_contents_all (value),
1657 sp_size, byte_order);
1659 printf_filtered (" Previous frame's sp is ");
1660 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1661 printf_filtered ("\n");
1663 else if (VALUE_LVAL (value) == lval_memory)
1665 printf_filtered (" Previous frame's sp at ");
1666 fputs_filtered (paddress (gdbarch, value_address (value)),
1668 printf_filtered ("\n");
1670 else if (VALUE_LVAL (value) == lval_register)
1672 printf_filtered (" Previous frame's sp in %s\n",
1673 gdbarch_register_name (gdbarch,
1674 VALUE_REGNUM (value)));
1677 release_value (value);
1681 /* else keep quiet. */
1685 numregs = gdbarch_num_regs (gdbarch)
1686 + gdbarch_num_pseudo_regs (gdbarch);
1687 for (i = 0; i < numregs; i++)
1689 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1691 enum lval_type lval;
1697 /* Find out the location of the saved register without
1698 fetching the corresponding value. */
1699 frame_register_unwind (fi, i, &optimized, &unavailable,
1700 &lval, &addr, &realnum, NULL);
1701 /* For moment, only display registers that were saved on the
1703 if (!optimized && !unavailable && lval == lval_memory)
1706 puts_filtered (" Saved registers:\n ");
1708 puts_filtered (",");
1710 printf_filtered (" %s at ",
1711 gdbarch_register_name (gdbarch, i));
1712 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1716 if (count || need_nl)
1717 puts_filtered ("\n");
1720 do_cleanups (back_to);
1723 /* Print briefly all stack frames or just the innermost COUNT_EXP
1727 backtrace_command_1 (char *count_exp, int show_locals, int no_filters,
1730 struct frame_info *fi;
1733 struct frame_info *trailing;
1734 int trailing_level, py_start = 0, py_end = 0;
1735 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1737 if (!target_has_stack)
1738 error (_("No stack."));
1740 /* The following code must do two things. First, it must set the
1741 variable TRAILING to the frame from which we should start
1742 printing. Second, it must set the variable count to the number
1743 of frames which we should print, or -1 if all of them. */
1744 trailing = get_current_frame ();
1749 count = parse_and_eval_long (count_exp);
1752 struct frame_info *current;
1758 while (current && count--)
1761 current = get_prev_frame (current);
1764 /* Will stop when CURRENT reaches the top of the stack.
1765 TRAILING will be COUNT below it. */
1769 trailing = get_prev_frame (trailing);
1770 current = get_prev_frame (current);
1790 /* Read in symbols for all of the frames. Need to do this in a
1791 separate pass so that "Reading in symbols for xxx" messages
1792 don't screw up the appearance of the backtrace. Also if
1793 people have strong opinions against reading symbols for
1794 backtrace this may have to be an option. */
1796 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1801 pc = get_frame_address_in_block (fi);
1802 expand_symtab_containing_pc (pc, find_pc_mapped_section (pc));
1808 int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1809 enum ext_lang_frame_args arg_type;
1812 flags |= PRINT_LOCALS;
1814 if (!strcmp (print_frame_arguments, "scalars"))
1815 arg_type = CLI_SCALAR_VALUES;
1816 else if (!strcmp (print_frame_arguments, "all"))
1817 arg_type = CLI_ALL_VALUES;
1819 arg_type = NO_VALUES;
1821 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1822 arg_type, current_uiout,
1826 /* Run the inbuilt backtrace if there are no filters registered, or
1827 "no-filters" has been specified from the command. */
1828 if (no_filters || result == EXT_LANG_BT_NO_FILTERS)
1830 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1834 /* Don't use print_stack_frame; if an error() occurs it probably
1835 means further attempts to backtrace would fail (on the other
1836 hand, perhaps the code does or could be fixed to make sure
1837 the frame->prev field gets set to NULL in that case). */
1839 print_frame_info (fi, 1, LOCATION, 1, 0);
1842 struct frame_id frame_id = get_frame_id (fi);
1844 print_frame_local_vars (fi, 1, gdb_stdout);
1846 /* print_frame_local_vars invalidates FI. */
1847 fi = frame_find_by_id (frame_id);
1851 warning (_("Unable to restore previously selected frame."));
1856 /* Save the last frame to check for error conditions. */
1860 /* If we've stopped before the end, mention that. */
1862 printf_filtered (_("(More stack frames follow...)\n"));
1864 /* If we've run out of frames, and the reason appears to be an error
1865 condition, print it. */
1866 if (fi == NULL && trailing != NULL)
1868 enum unwind_stop_reason reason;
1870 reason = get_frame_unwind_stop_reason (trailing);
1871 if (reason >= UNWIND_FIRST_ERROR)
1872 printf_filtered (_("Backtrace stopped: %s\n"),
1873 frame_stop_reason_string (trailing));
1879 backtrace_command (char *arg, int from_tty)
1881 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1882 int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1;
1890 argv = gdb_buildargv (arg);
1891 make_cleanup_freeargv (argv);
1893 for (i = 0; argv[i]; i++)
1897 for (j = 0; j < strlen (argv[i]); j++)
1898 argv[i][j] = TOLOWER (argv[i][j]);
1900 if (no_filters < 0 && subset_compare (argv[i], "no-filters"))
1904 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1905 fulltrace_arg = argc;
1909 arglen += strlen (argv[i]);
1915 if (fulltrace_arg >= 0 || no_filters >= 0)
1919 arg = (char *) xmalloc (arglen + 1);
1920 make_cleanup (xfree, arg);
1922 for (i = 0; i < argc; i++)
1924 if (i != fulltrace_arg && i != no_filters)
1926 strcat (arg, argv[i]);
1936 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */,
1937 no_filters >= 0 /* no frame-filters */, from_tty);
1939 do_cleanups (old_chain);
1942 /* Iterate over the local variables of a block B, calling CB with
1946 iterate_over_block_locals (const struct block *b,
1947 iterate_over_block_arg_local_vars_cb cb,
1950 struct block_iterator iter;
1953 ALL_BLOCK_SYMBOLS (b, iter, sym)
1955 switch (SYMBOL_CLASS (sym))
1961 if (SYMBOL_IS_ARGUMENT (sym))
1963 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1965 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1969 /* Ignore symbols which are not locals. */
1976 /* Same, but print labels. */
1979 /* Commented out, as the code using this function has also been
1980 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1981 was commented out in the first place. The discussion introducing
1982 this change (2007-12-04: Support lexical blocks and function bodies
1983 that occupy non-contiguous address ranges) did not explain why
1984 this change was made. */
1986 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1987 int *have_default, struct ui_file *stream)
1989 struct block_iterator iter;
1991 int values_printed = 0;
1993 ALL_BLOCK_SYMBOLS (b, iter, sym)
1995 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
2001 if (SYMBOL_CLASS (sym) == LOC_LABEL)
2003 struct symtab_and_line sal;
2004 struct value_print_options opts;
2006 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2008 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
2009 get_user_print_options (&opts);
2010 if (opts.addressprint)
2012 fprintf_filtered (stream, " ");
2013 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2016 fprintf_filtered (stream, " in file %s, line %d\n",
2017 sal.symtab->filename, sal.line);
2021 return values_printed;
2025 /* Iterate over all the local variables in block B, including all its
2026 superblocks, stopping when the top-level block is reached. */
2029 iterate_over_block_local_vars (const struct block *block,
2030 iterate_over_block_arg_local_vars_cb cb,
2035 iterate_over_block_locals (block, cb, cb_data);
2036 /* After handling the function's top-level block, stop. Don't
2037 continue to its superblock, the block of per-file
2039 if (BLOCK_FUNCTION (block))
2041 block = BLOCK_SUPERBLOCK (block);
2045 /* Data to be passed around in the calls to the locals and args
2048 struct print_variable_and_value_data
2050 struct frame_id frame_id;
2052 struct ui_file *stream;
2056 /* The callback for the locals and args iterators. */
2059 do_print_variable_and_value (const char *print_name,
2063 struct print_variable_and_value_data *p
2064 = (struct print_variable_and_value_data *) cb_data;
2065 struct frame_info *frame;
2067 frame = frame_find_by_id (p->frame_id);
2070 warning (_("Unable to restore previously selected frame."));
2074 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2076 /* print_variable_and_value invalidates FRAME. */
2079 p->values_printed = 1;
2082 /* Print all variables from the innermost up to the function block of FRAME.
2083 Print them with values to STREAM indented by NUM_TABS.
2085 This function will invalidate FRAME. */
2088 print_frame_local_vars (struct frame_info *frame, int num_tabs,
2089 struct ui_file *stream)
2091 struct print_variable_and_value_data cb_data;
2092 const struct block *block;
2094 struct gdb_exception except = exception_none;
2096 if (!get_frame_pc_if_available (frame, &pc))
2098 fprintf_filtered (stream,
2099 _("PC unavailable, cannot determine locals.\n"));
2103 block = get_frame_block (frame, 0);
2106 fprintf_filtered (stream, "No symbol table info available.\n");
2110 cb_data.frame_id = get_frame_id (frame);
2111 cb_data.num_tabs = 4 * num_tabs;
2112 cb_data.stream = stream;
2113 cb_data.values_printed = 0;
2115 /* Temporarily change the selected frame to the given FRAME.
2116 This allows routines that rely on the selected frame instead
2117 of being given a frame as parameter to use the correct frame. */
2118 select_frame (frame);
2122 iterate_over_block_local_vars (block,
2123 do_print_variable_and_value,
2126 CATCH (ex, RETURN_MASK_ALL)
2132 /* Restore the selected frame, and then rethrow if there was a problem. */
2133 select_frame (frame_find_by_id (cb_data.frame_id));
2134 if (except.reason < 0)
2135 throw_exception (except);
2137 /* do_print_variable_and_value invalidates FRAME. */
2140 if (!cb_data.values_printed)
2141 fprintf_filtered (stream, _("No locals.\n"));
2145 locals_info (char *args, int from_tty)
2147 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2151 /* Iterate over all the argument variables in block B.
2153 Returns 1 if any argument was walked; 0 otherwise. */
2156 iterate_over_block_arg_vars (const struct block *b,
2157 iterate_over_block_arg_local_vars_cb cb,
2160 struct block_iterator iter;
2161 struct symbol *sym, *sym2;
2163 ALL_BLOCK_SYMBOLS (b, iter, sym)
2165 /* Don't worry about things which aren't arguments. */
2166 if (SYMBOL_IS_ARGUMENT (sym))
2168 /* We have to look up the symbol because arguments can have
2169 two entries (one a parameter, one a local) and the one we
2170 want is the local, which lookup_symbol will find for us.
2171 This includes gcc1 (not gcc2) on the sparc when passing a
2172 small structure and gcc2 when the argument type is float
2173 and it is passed as a double and converted to float by
2174 the prologue (in the latter case the type of the LOC_ARG
2175 symbol is double and the type of the LOC_LOCAL symbol is
2176 float). There are also LOC_ARG/LOC_REGISTER pairs which
2177 are not combined in symbol-reading. */
2179 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
2180 b, VAR_DOMAIN, NULL).symbol;
2181 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2186 /* Print all argument variables of the function of FRAME.
2187 Print them with values to STREAM.
2189 This function will invalidate FRAME. */
2192 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2194 struct print_variable_and_value_data cb_data;
2195 struct symbol *func;
2198 if (!get_frame_pc_if_available (frame, &pc))
2200 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2204 func = get_frame_function (frame);
2207 fprintf_filtered (stream, _("No symbol table info available.\n"));
2211 cb_data.frame_id = get_frame_id (frame);
2212 cb_data.num_tabs = 0;
2213 cb_data.stream = gdb_stdout;
2214 cb_data.values_printed = 0;
2216 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2217 do_print_variable_and_value, &cb_data);
2219 /* do_print_variable_and_value invalidates FRAME. */
2222 if (!cb_data.values_printed)
2223 fprintf_filtered (stream, _("No arguments.\n"));
2227 args_info (char *ignore, int from_tty)
2229 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2233 /* Select frame FRAME. Also print the stack frame and show the source
2234 if this is the tui version. */
2236 select_and_print_frame (struct frame_info *frame)
2238 select_frame (frame);
2240 print_stack_frame (frame, 1, SRC_AND_LOC, 1);
2243 /* Return the symbol-block in which the selected frame is executing.
2244 Can return zero under various legitimate circumstances.
2246 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2247 code address within the block returned. We use this to decide
2248 which macros are in scope. */
2250 const struct block *
2251 get_selected_block (CORE_ADDR *addr_in_block)
2253 if (!has_stack_frames ())
2256 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2259 /* Find a frame a certain number of levels away from FRAME.
2260 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2261 Positive means go to earlier frames (up); negative, the reverse.
2262 The int that contains the number of levels is counted toward
2263 zero as the frames for those levels are found.
2264 If the top or bottom frame is reached, that frame is returned,
2265 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2266 how much farther the original request asked to go. */
2269 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2271 /* Going up is simple: just call get_prev_frame enough times or
2272 until the initial frame is reached. */
2273 while (*level_offset_ptr > 0)
2275 struct frame_info *prev = get_prev_frame (frame);
2279 (*level_offset_ptr)--;
2283 /* Going down is just as simple. */
2284 while (*level_offset_ptr < 0)
2286 struct frame_info *next = get_next_frame (frame);
2290 (*level_offset_ptr)++;
2297 /* The "select_frame" command. With no argument this is a NOP.
2298 Select the frame at level LEVEL_EXP if it is a valid level.
2299 Otherwise, treat LEVEL_EXP as an address expression and select it.
2301 See parse_frame_specification for more info on proper frame
2305 select_frame_command (char *level_exp, int from_tty)
2307 struct frame_info *prev_frame = get_selected_frame_if_set ();
2309 select_frame (parse_frame_specification (level_exp, NULL));
2310 if (get_selected_frame_if_set () != prev_frame)
2311 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2314 /* The "frame" command. With no argument, print the selected frame
2315 briefly. With an argument, behave like select_frame and then print
2316 the selected frame. */
2319 frame_command (char *level_exp, int from_tty)
2321 struct frame_info *prev_frame = get_selected_frame_if_set ();
2323 select_frame (parse_frame_specification (level_exp, NULL));
2324 if (get_selected_frame_if_set () != prev_frame)
2325 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2327 print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
2330 /* Select the frame up one or COUNT_EXP stack levels from the
2331 previously selected frame, and print it briefly. */
2334 up_silently_base (const char *count_exp)
2336 struct frame_info *frame;
2340 count = parse_and_eval_long (count_exp);
2342 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2343 if (count != 0 && count_exp == NULL)
2344 error (_("Initial frame selected; you cannot go up."));
2345 select_frame (frame);
2349 up_silently_command (char *count_exp, int from_tty)
2351 up_silently_base (count_exp);
2355 up_command (char *count_exp, int from_tty)
2357 up_silently_base (count_exp);
2358 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2361 /* Select the frame down one or COUNT_EXP stack levels from the previously
2362 selected frame, and print it briefly. */
2365 down_silently_base (const char *count_exp)
2367 struct frame_info *frame;
2371 count = -parse_and_eval_long (count_exp);
2373 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2374 if (count != 0 && count_exp == NULL)
2376 /* We only do this if COUNT_EXP is not specified. That way
2377 "down" means to really go down (and let me know if that is
2378 impossible), but "down 9999" can be used to mean go all the
2379 way down without getting an error. */
2381 error (_("Bottom (innermost) frame selected; you cannot go down."));
2384 select_frame (frame);
2388 down_silently_command (char *count_exp, int from_tty)
2390 down_silently_base (count_exp);
2394 down_command (char *count_exp, int from_tty)
2396 down_silently_base (count_exp);
2397 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
2401 return_command (char *retval_exp, int from_tty)
2403 /* Initialize it just to avoid a GCC false warning. */
2404 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2405 struct frame_info *thisframe;
2406 struct gdbarch *gdbarch;
2407 struct symbol *thisfun;
2408 struct value *return_value = NULL;
2409 struct value *function = NULL;
2410 const char *query_prefix = "";
2412 thisframe = get_selected_frame ("No selected frame.");
2413 thisfun = get_frame_function (thisframe);
2414 gdbarch = get_frame_arch (thisframe);
2416 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2417 error (_("Can not force return from an inlined function."));
2419 /* Compute the return value. If the computation triggers an error,
2420 let it bail. If the return type can't be handled, set
2421 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2425 expression_up retval_expr = parse_expression (retval_exp);
2426 struct type *return_type = NULL;
2428 /* Compute the return value. Should the computation fail, this
2429 call throws an error. */
2430 return_value = evaluate_expression (retval_expr.get ());
2432 /* Cast return value to the return type of the function. Should
2433 the cast fail, this call throws an error. */
2434 if (thisfun != NULL)
2435 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2436 if (return_type == NULL)
2438 if (retval_expr->elts[0].opcode != UNOP_CAST
2439 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2440 error (_("Return value type not available for selected "
2442 "Please use an explicit cast of the value to return."));
2443 return_type = value_type (return_value);
2445 return_type = check_typedef (return_type);
2446 return_value = value_cast (return_type, return_value);
2448 /* Make sure the value is fully evaluated. It may live in the
2449 stack frame we're about to pop. */
2450 if (value_lazy (return_value))
2451 value_fetch_lazy (return_value);
2453 if (thisfun != NULL)
2454 function = read_var_value (thisfun, NULL, thisframe);
2456 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2457 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2458 /* If the return-type is "void", don't try to find the
2459 return-value's location. However, do still evaluate the
2460 return expression so that, even when the expression result
2461 is discarded, side effects such as "return i++" still
2463 return_value = NULL;
2464 else if (thisfun != NULL)
2466 rv_conv = struct_return_convention (gdbarch, function, return_type);
2467 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2468 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2470 query_prefix = "The location at which to store the "
2471 "function's return value is unknown.\n"
2472 "If you continue, the return value "
2473 "that you specified will be ignored.\n";
2474 return_value = NULL;
2479 /* Does an interactive user really want to do this? Include
2480 information, such as how well GDB can handle the return value, in
2481 the query message. */
2486 if (thisfun == NULL)
2487 confirmed = query (_("%sMake selected stack frame return now? "),
2491 if (TYPE_NO_RETURN (thisfun->type))
2492 warning (_("Function does not return normally to caller."));
2493 confirmed = query (_("%sMake %s return now? "), query_prefix,
2494 SYMBOL_PRINT_NAME (thisfun));
2497 error (_("Not confirmed"));
2500 /* Discard the selected frame and all frames inner-to it. */
2501 frame_pop (get_selected_frame (NULL));
2503 /* Store RETURN_VALUE in the just-returned register set. */
2504 if (return_value != NULL)
2506 struct type *return_type = value_type (return_value);
2507 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2509 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2510 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2511 gdbarch_return_value (gdbarch, function, return_type,
2512 get_current_regcache (), NULL /*read*/,
2513 value_contents (return_value) /*write*/);
2516 /* If we are at the end of a call dummy now, pop the dummy frame
2518 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2519 frame_pop (get_current_frame ());
2521 select_frame (get_current_frame ());
2522 /* If interactive, print the frame that is now current. */
2524 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2527 /* Sets the scope to input function name, provided that the function
2528 is within the current stack frame. */
2530 struct function_bounds
2532 CORE_ADDR low, high;
2536 func_command (char *arg, int from_tty)
2538 struct frame_info *frame;
2540 struct symtabs_and_lines sals;
2543 struct function_bounds *func_bounds = NULL;
2544 struct cleanup *cleanups;
2549 frame = get_current_frame ();
2550 sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
2551 cleanups = make_cleanup (xfree, sals.sals);
2552 func_bounds = XNEWVEC (struct function_bounds, sals.nelts);
2553 make_cleanup (xfree, func_bounds);
2554 for (i = 0; (i < sals.nelts && !found); i++)
2556 if (sals.sals[i].pspace != current_program_space)
2557 func_bounds[i].low = func_bounds[i].high = 0;
2558 else if (sals.sals[i].pc == 0
2559 || find_pc_partial_function (sals.sals[i].pc, NULL,
2560 &func_bounds[i].low,
2561 &func_bounds[i].high) == 0)
2563 func_bounds[i].low = func_bounds[i].high = 0;
2569 for (i = 0; (i < sals.nelts && !found); i++)
2570 found = (get_frame_pc (frame) >= func_bounds[i].low
2571 && get_frame_pc (frame) < func_bounds[i].high);
2575 frame = find_relative_frame (frame, &level);
2578 while (!found && level == 0);
2580 do_cleanups (cleanups);
2583 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2584 else if (frame != get_selected_frame (NULL))
2585 select_and_print_frame (frame);
2589 /* Provide a prototype to silence -Wmissing-prototypes. */
2590 void _initialize_stack (void);
2593 _initialize_stack (void)
2595 add_com ("return", class_stack, return_command, _("\
2596 Make selected stack frame return to its caller.\n\
2597 Control remains in the debugger, but when you continue\n\
2598 execution will resume in the frame above the one now selected.\n\
2599 If an argument is given, it is an expression for the value to return."));
2601 add_com ("up", class_stack, up_command, _("\
2602 Select and print stack frame that called this one.\n\
2603 An argument says how many frames up to go."));
2604 add_com ("up-silently", class_support, up_silently_command, _("\
2605 Same as the `up' command, but does not print anything.\n\
2606 This is useful in command scripts."));
2608 add_com ("down", class_stack, down_command, _("\
2609 Select and print stack frame called by this one.\n\
2610 An argument says how many frames down to go."));
2611 add_com_alias ("do", "down", class_stack, 1);
2612 add_com_alias ("dow", "down", class_stack, 1);
2613 add_com ("down-silently", class_support, down_silently_command, _("\
2614 Same as the `down' command, but does not print anything.\n\
2615 This is useful in command scripts."));
2617 add_com ("frame", class_stack, frame_command, _("\
2618 Select and print a stack frame.\nWith no argument, \
2619 print the selected stack frame. (See also \"info frame\").\n\
2620 An argument specifies the frame to select.\n\
2621 It can be a stack frame number or the address of the frame.\n"));
2623 add_com_alias ("f", "frame", class_stack, 1);
2625 add_com_suppress_notification ("select-frame", class_stack, select_frame_command, _("\
2626 Select a stack frame without printing anything.\n\
2627 An argument specifies the frame to select.\n\
2628 It can be a stack frame number or the address of the frame.\n"),
2629 &cli_suppress_notification.user_selected_context);
2631 add_com ("backtrace", class_stack, backtrace_command, _("\
2632 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2633 With a negative argument, print outermost -COUNT frames.\nUse of the \
2634 'full' qualifier also prints the values of the local variables.\n\
2635 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2636 on this backtrace.\n"));
2637 add_com_alias ("bt", "backtrace", class_stack, 0);
2639 add_com_alias ("where", "backtrace", class_alias, 0);
2640 add_info ("stack", backtrace_command,
2641 _("Backtrace of the stack, or innermost COUNT frames."));
2642 add_info_alias ("s", "stack", 1);
2643 add_info ("frame", frame_info,
2644 _("All about selected stack frame, or frame at ADDR."));
2645 add_info_alias ("f", "frame", 1);
2646 add_info ("locals", locals_info,
2647 _("Local variables of current stack frame."));
2648 add_info ("args", args_info,
2649 _("Argument variables of current stack frame."));
2652 add_com ("func", class_stack, func_command, _("\
2653 Select the stack frame that contains <func>.\n\
2654 Usage: func <name>\n"));
2656 add_setshow_enum_cmd ("frame-arguments", class_stack,
2657 print_frame_arguments_choices, &print_frame_arguments,
2658 _("Set printing of non-scalar frame arguments"),
2659 _("Show printing of non-scalar frame arguments"),
2660 NULL, NULL, NULL, &setprintlist, &showprintlist);
2662 add_setshow_boolean_cmd ("frame-arguments", no_class,
2663 &print_raw_frame_arguments, _("\
2664 Set whether to print frame arguments in raw form."), _("\
2665 Show whether to print frame arguments in raw form."), _("\
2666 If set, frame arguments are printed in raw form, bypassing any\n\
2667 pretty-printers for that value."),
2669 &setprintrawlist, &showprintrawlist);
2671 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2672 &disassemble_next_line, _("\
2673 Set whether to disassemble next source line or insn when execution stops."),
2675 Show whether to disassemble next source line or insn when execution stops."),
2677 If ON, GDB will display disassembly of the next source line, in addition\n\
2678 to displaying the source line itself. If the next source line cannot\n\
2679 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2680 will display disassembly of next instruction instead of showing the\n\
2682 If AUTO, display disassembly of next instruction only if the source line\n\
2683 cannot be displayed.\n\
2684 If OFF (which is the default), never display the disassembly of the next\n\
2687 show_disassemble_next_line,
2688 &setlist, &showlist);
2689 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2691 add_setshow_enum_cmd ("entry-values", class_stack,
2692 print_entry_values_choices, &print_entry_values,
2693 _("Set printing of function arguments at function "
2695 _("Show printing of function arguments at function "
2698 GDB can sometimes determine the values of function arguments at entry,\n\
2699 in addition to their current values. This option tells GDB whether\n\
2700 to print the current value, the value at entry (marked as val@entry),\n\
2701 or both. Note that one or both of these values may be <optimized out>."),
2702 NULL, NULL, &setprintlist, &showprintlist);