1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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"
52 #include "extension.h"
53 #include "observable.h"
54 #include "common/def-vector.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 *frame,
93 const char *regexp, const char *t_regexp,
94 int num_tabs, struct ui_file *stream);
96 static void print_frame (struct frame_info *frame, int print_level,
97 enum print_what print_what, int print_args,
98 struct symtab_and_line sal);
100 static void set_last_displayed_sal (int valid,
101 struct program_space *pspace,
103 struct symtab *symtab,
106 static struct frame_info *find_frame_for_function (const char *);
107 static struct frame_info *find_frame_for_address (CORE_ADDR);
109 /* Zero means do things normally; we are interacting directly with the
110 user. One means print the full filename and linenumber when a
111 frame is printed, and do so in a format emacs18/emacs19.22 can
112 parse. Two means print similar annotations, but in many more
113 cases and in a slightly different syntax. */
115 int annotation_level = 0;
117 /* These variables hold the last symtab and line we displayed to the user.
118 * This is where we insert a breakpoint or a skiplist entry by default. */
119 static int last_displayed_sal_valid = 0;
120 static struct program_space *last_displayed_pspace = 0;
121 static CORE_ADDR last_displayed_addr = 0;
122 static struct symtab *last_displayed_symtab = 0;
123 static int last_displayed_line = 0;
126 /* Return 1 if we should display the address in addition to the location,
127 because we are in the middle of a statement. */
130 frame_show_address (struct frame_info *frame,
131 struct symtab_and_line sal)
133 /* If there is a line number, but no PC, then there is no location
134 information associated with this sal. The only way that should
135 happen is for the call sites of inlined functions (SAL comes from
136 find_frame_sal). Otherwise, we would have some PC range if the
137 SAL came from a line table. */
138 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
140 if (get_next_frame (frame) == NULL)
141 gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
143 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
147 return get_frame_pc (frame) != sal.pc;
153 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
154 int print_level, enum print_what print_what,
157 scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
159 print_stack_frame (frame, print_level, print_what, set_current_sal);
162 /* Show or print a stack frame FRAME briefly. The output is formatted
163 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
164 relative level, function name, argument list, and file name and
165 line number. If the frame's PC is not at the beginning of the
166 source line, the actual PC is printed at the beginning. */
169 print_stack_frame (struct frame_info *frame, int print_level,
170 enum print_what print_what,
174 /* For mi, alway print location and address. */
175 if (current_uiout->is_mi_like_p ())
176 print_what = LOC_AND_ADDRESS;
180 print_frame_info (frame, print_level, print_what, 1 /* print_args */,
183 set_current_sal_from_frame (frame);
185 catch (const gdb_exception_error &e)
190 /* Print nameless arguments of frame FRAME on STREAM, where START is
191 the offset of the first nameless argument, and NUM is the number of
192 nameless arguments to print. FIRST is nonzero if this is the first
193 argument (not just the first nameless argument). */
196 print_frame_nameless_args (struct frame_info *frame, long start, int num,
197 int first, struct ui_file *stream)
199 struct gdbarch *gdbarch = get_frame_arch (frame);
200 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
205 for (i = 0; i < num; i++)
208 argsaddr = get_frame_args_address (frame);
211 arg_value = read_memory_integer (argsaddr + start,
212 sizeof (int), byte_order);
214 fprintf_filtered (stream, ", ");
215 fprintf_filtered (stream, "%ld", arg_value);
217 start += sizeof (int);
221 /* Print single argument of inferior function. ARG must be already
224 Errors are printed as if they would be the parameter value. Use zeroed ARG
225 iff it should not be printed accoring to user settings. */
228 print_frame_arg (const struct frame_arg *arg)
230 struct ui_out *uiout = current_uiout;
234 gdb_assert (!arg->val || !arg->error);
235 gdb_assert (arg->entry_kind == print_entry_values_no
236 || arg->entry_kind == print_entry_values_only
237 || (!uiout->is_mi_like_p ()
238 && arg->entry_kind == print_entry_values_compact));
240 annotate_arg_emitter arg_emitter;
241 ui_out_emit_tuple tuple_emitter (uiout, NULL);
242 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
243 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
244 if (arg->entry_kind == print_entry_values_compact)
246 /* It is OK to provide invalid MI-like stream as with
247 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
250 fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
251 SYMBOL_LANGUAGE (arg->sym),
252 DMGL_PARAMS | DMGL_ANSI);
254 if (arg->entry_kind == print_entry_values_only
255 || arg->entry_kind == print_entry_values_compact)
257 uiout->field_stream ("name", stb, ui_out_style_kind::VARIABLE);
258 annotate_arg_name_end ();
261 if (!arg->val && !arg->error)
266 stb.printf (_("<error reading variable: %s>"), arg->error);
271 const struct language_defn *language;
272 struct value_print_options opts;
274 /* Avoid value_print because it will deref ref parameters. We
275 just want to print their addresses. Print ??? for args whose
276 address we do not know. We pass 2 as "recurse" to val_print
277 because our standard indentation here is 4 spaces, and
278 val_print indents 2 for each recurse. */
280 annotate_arg_value (value_type (arg->val));
282 /* Use the appropriate language to display our symbol, unless the
283 user forced the language to a specific language. */
284 if (language_mode == language_mode_auto)
285 language = language_def (SYMBOL_LANGUAGE (arg->sym));
287 language = current_language;
289 get_no_prettyformat_print_options (&opts);
291 opts.raw = print_raw_frame_arguments;
293 /* True in "summary" mode, false otherwise. */
294 opts.summary = !strcmp (print_frame_arguments, "scalars");
296 common_val_print (arg->val, &stb, 2, &opts, language);
298 catch (const gdb_exception_error &except)
300 stb.printf (_("<error reading variable: %s>"),
306 uiout->field_stream ("value", stb);
309 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
310 responsible for xfree of ARGP->ERROR. This function never throws an
314 read_frame_local (struct symbol *sym, struct frame_info *frame,
315 struct frame_arg *argp)
323 argp->val = read_var_value (sym, NULL, frame);
325 catch (const gdb_exception_error &except)
327 argp->error = xstrdup (except.what ());
331 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
332 responsible for xfree of ARGP->ERROR. This function never throws an
336 read_frame_arg (struct symbol *sym, struct frame_info *frame,
337 struct frame_arg *argp, struct frame_arg *entryargp)
339 struct value *val = NULL, *entryval = NULL;
340 char *val_error = NULL, *entryval_error = NULL;
343 if (print_entry_values != print_entry_values_only
344 && print_entry_values != print_entry_values_preferred)
348 val = read_var_value (sym, NULL, frame);
350 catch (const gdb_exception_error &except)
352 val_error = (char *) alloca (except.message->size () + 1);
353 strcpy (val_error, except.what ());
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 (const gdb_exception_error &except)
372 if (except.error != NO_ENTRY_VALUE_ERROR)
374 entryval_error = (char *) alloca (except.message->size () + 1);
375 strcpy (entryval_error, except.what ());
379 if (entryval != NULL && value_optimized_out (entryval))
382 if (print_entry_values == print_entry_values_compact
383 || print_entry_values == print_entry_values_default)
385 /* For MI do not try to use print_entry_values_compact for ARGP. */
387 if (val && entryval && !current_uiout->is_mi_like_p ())
389 struct type *type = value_type (val);
391 if (value_lazy (val))
392 value_fetch_lazy (val);
393 if (value_lazy (entryval))
394 value_fetch_lazy (entryval);
396 if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
398 /* Initialize it just to avoid a GCC false warning. */
399 struct value *val_deref = NULL, *entryval_deref;
401 /* DW_AT_call_value does match with the current
402 value. If it is a reference still try to verify if
403 dereferenced DW_AT_call_data_value does not differ. */
407 struct type *type_deref;
409 val_deref = coerce_ref (val);
410 if (value_lazy (val_deref))
411 value_fetch_lazy (val_deref);
412 type_deref = value_type (val_deref);
414 entryval_deref = coerce_ref (entryval);
415 if (value_lazy (entryval_deref))
416 value_fetch_lazy (entryval_deref);
418 /* If the reference addresses match but dereferenced
419 content does not match print them. */
421 && value_contents_eq (val_deref, 0,
423 TYPE_LENGTH (type_deref)))
426 catch (const gdb_exception_error &except)
428 /* If the dereferenced content could not be
429 fetched do not display anything. */
430 if (except.error == NO_ENTRY_VALUE_ERROR)
432 else if (except.message != NULL)
435 = (char *) alloca (except.message->size () + 1);
436 strcpy (entryval_error, except.what ());
440 /* Value was not a reference; and its content matches. */
441 if (val == val_deref)
449 /* Try to remove possibly duplicate error message for ENTRYARGP even
452 if (val_error && entryval_error
453 && strcmp (val_error, entryval_error) == 0)
455 entryval_error = NULL;
457 /* Do not se VAL_EQUAL as the same error message may be shown for
458 the entry value even if no entry values are present in the
464 if (entryval == NULL)
466 if (print_entry_values == print_entry_values_preferred)
468 gdb_assert (val == NULL);
472 val = read_var_value (sym, NULL, frame);
474 catch (const gdb_exception_error &except)
476 val_error = (char *) alloca (except.message->size () + 1);
477 strcpy (val_error, except.what ());
480 if (print_entry_values == print_entry_values_only
481 || print_entry_values == print_entry_values_both
482 || (print_entry_values == print_entry_values_preferred
483 && (!val || value_optimized_out (val))))
485 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
486 entryval_error = NULL;
489 if ((print_entry_values == print_entry_values_compact
490 || print_entry_values == print_entry_values_if_needed
491 || print_entry_values == print_entry_values_preferred)
492 && (!val || value_optimized_out (val)) && entryval != NULL)
500 argp->error = val_error ? xstrdup (val_error) : NULL;
501 if (!val && !val_error)
502 argp->entry_kind = print_entry_values_only;
503 else if ((print_entry_values == print_entry_values_compact
504 || print_entry_values == print_entry_values_default) && val_equal)
506 argp->entry_kind = print_entry_values_compact;
507 gdb_assert (!current_uiout->is_mi_like_p ());
510 argp->entry_kind = print_entry_values_no;
512 entryargp->sym = sym;
513 entryargp->val = entryval;
514 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
515 if (!entryval && !entryval_error)
516 entryargp->entry_kind = print_entry_values_no;
518 entryargp->entry_kind = print_entry_values_only;
521 /* Print the arguments of frame FRAME on STREAM, given the function
522 FUNC running in that frame (as a symbol), where NUM is the number
523 of arguments according to the stack frame (or -1 if the number of
524 arguments is unknown). */
526 /* Note that currently the "number of arguments according to the
527 stack frame" is only known on VAX where i refers to the "number of
528 ints of arguments according to the stack frame". */
531 print_frame_args (struct symbol *func, struct frame_info *frame,
532 int num, struct ui_file *stream)
534 struct ui_out *uiout = current_uiout;
536 /* Offset of next stack argument beyond the one we have seen that is
537 at the highest offset, or -1 if we haven't come to a stack
539 long highest_offset = -1;
540 /* Number of ints of arguments that we have printed so far. */
541 int args_printed = 0;
542 /* True if we should print arguments, false otherwise. */
543 int print_args = strcmp (print_frame_arguments, "none");
547 const struct block *b = SYMBOL_BLOCK_VALUE (func);
548 struct block_iterator iter;
551 ALL_BLOCK_SYMBOLS (b, iter, sym)
553 struct frame_arg arg, entryarg;
557 /* Keep track of the highest stack argument offset seen, and
558 skip over any kinds of symbols we don't care about. */
560 if (!SYMBOL_IS_ARGUMENT (sym))
563 switch (SYMBOL_CLASS (sym))
568 long current_offset = SYMBOL_VALUE (sym);
569 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
571 /* Compute address of next argument by adding the size of
572 this argument and rounding to an int boundary. */
574 ((current_offset + arg_size + sizeof (int) - 1)
575 & ~(sizeof (int) - 1));
577 /* If this is the highest offset seen yet, set
579 if (highest_offset == -1
580 || (current_offset > highest_offset))
581 highest_offset = current_offset;
583 /* Add the number of ints we're about to print to
585 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
588 /* We care about types of symbols, but don't need to
589 keep track of stack offsets in them. */
591 case LOC_REGPARM_ADDR:
593 case LOC_OPTIMIZED_OUT:
598 /* We have to look up the symbol because arguments can have
599 two entries (one a parameter, one a local) and the one we
600 want is the local, which lookup_symbol will find for us.
601 This includes gcc1 (not gcc2) on SPARC when passing a
602 small structure and gcc2 when the argument type is float
603 and it is passed as a double and converted to float by
604 the prologue (in the latter case the type of the LOC_ARG
605 symbol is double and the type of the LOC_LOCAL symbol is
607 /* But if the parameter name is null, don't try it. Null
608 parameter names occur on the RS/6000, for traceback
609 tables. FIXME, should we even print them? */
611 if (*SYMBOL_LINKAGE_NAME (sym))
615 nsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
616 b, VAR_DOMAIN).symbol;
617 gdb_assert (nsym != NULL);
618 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
619 && !SYMBOL_IS_ARGUMENT (nsym))
621 /* There is a LOC_ARG/LOC_REGISTER pair. This means
622 that it was passed on the stack and loaded into a
623 register, or passed in a register and stored in a
624 stack slot. GDB 3.x used the LOC_ARG; GDB
625 4.0-4.11 used the LOC_REGISTER.
627 Reasons for using the LOC_ARG:
629 (1) Because find_saved_registers may be slow for
632 (2) Because registers are often re-used and stack
633 slots rarely (never?) are. Therefore using
634 the stack slot is much less likely to print
637 Reasons why we might want to use the LOC_REGISTER:
639 (1) So that the backtrace prints the same value
640 as "print foo". I see no compelling reason
641 why this needs to be the case; having the
642 backtrace print the value which was passed
643 in, and "print foo" print the value as
644 modified within the called function, makes
647 Additional note: It might be nice if "info args"
648 displayed both values.
650 One more note: There is a case with SPARC
651 structure passing where we need to use the
652 LOC_REGISTER, but this is dealt with by creating
653 a single LOC_REGPARM in symbol reading. */
655 /* Leave sym (the LOC_ARG) alone. */
662 /* Print the current arg. */
665 uiout->wrap_hint (" ");
669 memset (&arg, 0, sizeof (arg));
671 arg.entry_kind = print_entry_values_no;
672 memset (&entryarg, 0, sizeof (entryarg));
674 entryarg.entry_kind = print_entry_values_no;
677 read_frame_arg (sym, frame, &arg, &entryarg);
679 if (arg.entry_kind != print_entry_values_only)
680 print_frame_arg (&arg);
682 if (entryarg.entry_kind != print_entry_values_no)
684 if (arg.entry_kind != print_entry_values_only)
687 uiout->wrap_hint (" ");
690 print_frame_arg (&entryarg);
694 xfree (entryarg.error);
700 /* Don't print nameless args in situations where we don't know
701 enough about the stack to find them. */
706 if (highest_offset == -1)
707 start = gdbarch_frame_args_skip (get_frame_arch (frame));
709 start = highest_offset;
711 print_frame_nameless_args (frame, start, num - args_printed,
716 /* Set the current source and line to the location given by frame
717 FRAME, if possible. When CENTER is true, adjust so the relevant
718 line is in the center of the next 'list'. */
721 set_current_sal_from_frame (struct frame_info *frame)
723 symtab_and_line sal = find_frame_sal (frame);
724 if (sal.symtab != NULL)
725 set_current_source_symtab_and_line (sal);
728 /* If ON, GDB will display disassembly of the next source line when
729 execution of the program being debugged stops.
730 If AUTO (which is the default), or there's no line info to determine
731 the source line of the next instruction, display disassembly of next
732 instruction instead. */
734 static enum auto_boolean disassemble_next_line;
737 show_disassemble_next_line (struct ui_file *file, int from_tty,
738 struct cmd_list_element *c,
741 fprintf_filtered (file,
742 _("Debugger's willingness to use "
743 "disassemble-next-line is %s.\n"),
747 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
748 because it will be broken by filter sometime. */
751 do_gdb_disassembly (struct gdbarch *gdbarch,
752 int how_many, CORE_ADDR low, CORE_ADDR high)
757 gdb_disassembly (gdbarch, current_uiout,
758 DISASSEMBLY_RAW_INSN, how_many,
761 catch (const gdb_exception_error &exception)
763 /* If an exception was thrown while doing the disassembly, print
764 the error message, to give the user a clue of what happened. */
765 exception_print (gdb_stderr, exception);
769 /* Print information about frame FRAME. The output is format according
770 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
773 SRC_LINE: Print only source line.
774 LOCATION: Print only location.
775 SRC_AND_LOC: Print location and source line.
777 Used in "where" output, and to emit breakpoint or step
781 print_frame_info (struct frame_info *frame, int print_level,
782 enum print_what print_what, int print_args,
785 struct gdbarch *gdbarch = get_frame_arch (frame);
788 struct ui_out *uiout = current_uiout;
790 if (get_frame_type (frame) == DUMMY_FRAME
791 || get_frame_type (frame) == SIGTRAMP_FRAME
792 || get_frame_type (frame) == ARCH_FRAME)
794 ui_out_emit_tuple tuple_emitter (uiout, "frame");
796 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
797 gdbarch, get_frame_pc (frame));
799 /* Do this regardless of SOURCE because we don't have any source
800 to list for this frame. */
804 uiout->field_fmt_int (2, ui_left, "level",
805 frame_relative_level (frame));
807 if (uiout->is_mi_like_p ())
809 annotate_frame_address ();
810 uiout->field_core_addr ("addr",
811 gdbarch, get_frame_pc (frame));
812 annotate_frame_address_end ();
815 if (get_frame_type (frame) == DUMMY_FRAME)
817 annotate_function_call ();
818 uiout->field_string ("func", "<function called from gdb>",
819 ui_out_style_kind::FUNCTION);
821 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
823 annotate_signal_handler_caller ();
824 uiout->field_string ("func", "<signal handler called>",
825 ui_out_style_kind::FUNCTION);
827 else if (get_frame_type (frame) == ARCH_FRAME)
829 uiout->field_string ("func", "<cross-architecture call>",
830 ui_out_style_kind::FUNCTION);
833 annotate_frame_end ();
835 /* If disassemble-next-line is set to auto or on output the next
837 if (disassemble_next_line == AUTO_BOOLEAN_AUTO
838 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
839 do_gdb_disassembly (get_frame_arch (frame), 1,
840 get_frame_pc (frame), get_frame_pc (frame) + 1);
845 /* If FRAME is not the innermost frame, that normally means that
846 FRAME->pc points to *after* the call instruction, and we want to
847 get the line containing the call, never the next line. But if
848 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
849 next frame was not entered as the result of a call, and we want
850 to get the line containing FRAME->pc. */
851 symtab_and_line sal = find_frame_sal (frame);
853 location_print = (print_what == LOCATION
854 || print_what == LOC_AND_ADDRESS
855 || print_what == SRC_AND_LOC);
857 if (location_print || !sal.symtab)
858 print_frame (frame, print_level, print_what, print_args, sal);
860 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
862 /* If disassemble-next-line is set to auto or on and doesn't have
863 the line debug messages for $pc, output the next instruction. */
864 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
865 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
866 && source_print && !sal.symtab)
867 do_gdb_disassembly (get_frame_arch (frame), 1,
868 get_frame_pc (frame), get_frame_pc (frame) + 1);
870 if (source_print && sal.symtab)
873 int mid_statement = ((print_what == SRC_LINE)
874 && frame_show_address (frame, sal));
876 if (annotation_level)
877 done = identify_source_line (sal.symtab, sal.line, mid_statement,
878 get_frame_pc (frame));
881 if (deprecated_print_frame_info_listing_hook)
882 deprecated_print_frame_info_listing_hook (sal.symtab,
887 struct value_print_options opts;
889 get_user_print_options (&opts);
890 /* We used to do this earlier, but that is clearly
891 wrong. This function is used by many different
892 parts of gdb, including normal_stop in infrun.c,
893 which uses this to print out the current PC
894 when we stepi/nexti into the middle of a source
895 line. Only the command line really wants this
896 behavior. Other UIs probably would like the
897 ability to decide for themselves if it is desired. */
898 if (opts.addressprint && mid_statement)
900 uiout->field_core_addr ("addr",
901 gdbarch, get_frame_pc (frame));
905 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
909 /* If disassemble-next-line is set to on and there is line debug
910 messages, output assembly codes for next line. */
911 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
912 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
919 if (get_frame_pc_if_available (frame, &pc))
920 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
922 set_last_displayed_sal (0, 0, 0, 0, 0);
925 annotate_frame_end ();
927 gdb_flush (gdb_stdout);
930 /* Remember the last symtab and line we displayed, which we use e.g.
931 * as the place to put a breakpoint when the `break' command is
932 * invoked with no arguments. */
935 set_last_displayed_sal (int valid, struct program_space *pspace,
936 CORE_ADDR addr, struct symtab *symtab,
939 last_displayed_sal_valid = valid;
940 last_displayed_pspace = pspace;
941 last_displayed_addr = addr;
942 last_displayed_symtab = symtab;
943 last_displayed_line = line;
944 if (valid && pspace == NULL)
946 clear_last_displayed_sal ();
947 internal_error (__FILE__, __LINE__,
948 _("Trying to set NULL pspace."));
952 /* Forget the last sal we displayed. */
955 clear_last_displayed_sal (void)
957 last_displayed_sal_valid = 0;
958 last_displayed_pspace = 0;
959 last_displayed_addr = 0;
960 last_displayed_symtab = 0;
961 last_displayed_line = 0;
964 /* Is our record of the last sal we displayed valid? If not,
965 * the get_last_displayed_* functions will return NULL or 0, as
969 last_displayed_sal_is_valid (void)
971 return last_displayed_sal_valid;
974 /* Get the pspace of the last sal we displayed, if it's valid. */
976 struct program_space *
977 get_last_displayed_pspace (void)
979 if (last_displayed_sal_valid)
980 return last_displayed_pspace;
984 /* Get the address of the last sal we displayed, if it's valid. */
987 get_last_displayed_addr (void)
989 if (last_displayed_sal_valid)
990 return last_displayed_addr;
994 /* Get the symtab of the last sal we displayed, if it's valid. */
997 get_last_displayed_symtab (void)
999 if (last_displayed_sal_valid)
1000 return last_displayed_symtab;
1004 /* Get the line of the last sal we displayed, if it's valid. */
1007 get_last_displayed_line (void)
1009 if (last_displayed_sal_valid)
1010 return last_displayed_line;
1014 /* Get the last sal we displayed, if it's valid. */
1017 get_last_displayed_sal ()
1019 symtab_and_line sal;
1021 if (last_displayed_sal_valid)
1023 sal.pspace = last_displayed_pspace;
1024 sal.pc = last_displayed_addr;
1025 sal.symtab = last_displayed_symtab;
1026 sal.line = last_displayed_line;
1033 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1034 corresponding to FRAME. */
1036 gdb::unique_xmalloc_ptr<char>
1037 find_frame_funname (struct frame_info *frame, enum language *funlang,
1038 struct symbol **funcp)
1040 struct symbol *func;
1041 gdb::unique_xmalloc_ptr<char> funname;
1043 *funlang = language_unknown;
1047 func = get_frame_function (frame);
1050 /* In certain pathological cases, the symtabs give the wrong
1051 function (when we are in the first function in a file which
1052 is compiled without debugging symbols, the previous function
1053 is compiled with debugging symbols, and the "foo.o" symbol
1054 that is supposed to tell us where the file with debugging
1055 symbols ends has been truncated by ar because it is longer
1056 than 15 characters). This also occurs if the user uses asm()
1057 to create a function but not stabs for it (in a file compiled
1060 So look in the minimal symbol tables as well, and if it comes
1061 up with a larger address for the function use that instead.
1062 I don't think this can ever cause any problems; there
1063 shouldn't be any minimal symbols in the middle of a function;
1064 if this is ever changed many parts of GDB will need to be
1065 changed (and we'll create a find_pc_minimal_function or some
1068 struct bound_minimal_symbol msymbol;
1070 /* Don't attempt to do this for inlined functions, which do not
1071 have a corresponding minimal symbol. */
1072 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1074 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1076 memset (&msymbol, 0, sizeof (msymbol));
1078 if (msymbol.minsym != NULL
1079 && (BMSYMBOL_VALUE_ADDRESS (msymbol)
1080 > BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func))))
1082 /* We also don't know anything about the function besides
1083 its address and name. */
1085 funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1086 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1090 const char *print_name = SYMBOL_PRINT_NAME (func);
1092 *funlang = SYMBOL_LANGUAGE (func);
1095 if (*funlang == language_cplus)
1097 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1098 to display the demangled name that we already have
1099 stored in the symbol table, but we stored a version
1100 with DMGL_PARAMS turned on, and here we don't want to
1101 display parameters. So remove the parameters. */
1102 funname = cp_remove_params (print_name);
1105 /* If we didn't hit the C++ case above, set *funname
1107 if (funname == NULL)
1108 funname.reset (xstrdup (print_name));
1113 struct bound_minimal_symbol msymbol;
1116 if (!get_frame_address_in_block_if_available (frame, &pc))
1119 msymbol = lookup_minimal_symbol_by_pc (pc);
1120 if (msymbol.minsym != NULL)
1122 funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1123 *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1131 print_frame (struct frame_info *frame, int print_level,
1132 enum print_what print_what, int print_args,
1133 struct symtab_and_line sal)
1135 struct gdbarch *gdbarch = get_frame_arch (frame);
1136 struct ui_out *uiout = current_uiout;
1137 enum language funlang = language_unknown;
1138 struct value_print_options opts;
1139 struct symbol *func;
1143 pc_p = get_frame_pc_if_available (frame, &pc);
1145 gdb::unique_xmalloc_ptr<char> funname
1146 = find_frame_funname (frame, &funlang, &func);
1148 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1152 ui_out_emit_tuple tuple_emitter (uiout, "frame");
1157 uiout->field_fmt_int (2, ui_left, "level",
1158 frame_relative_level (frame));
1160 get_user_print_options (&opts);
1161 if (opts.addressprint)
1163 || frame_show_address (frame, sal)
1164 || print_what == LOC_AND_ADDRESS)
1166 annotate_frame_address ();
1168 uiout->field_core_addr ("addr", gdbarch, pc);
1170 uiout->field_string ("addr", "<unavailable>",
1171 ui_out_style_kind::ADDRESS);
1172 annotate_frame_address_end ();
1173 uiout->text (" in ");
1175 annotate_frame_function_name ();
1178 fprintf_symbol_filtered (&stb, funname ? funname.get () : "??",
1179 funlang, DMGL_ANSI);
1180 uiout->field_stream ("func", stb, ui_out_style_kind::FUNCTION);
1181 uiout->wrap_hint (" ");
1182 annotate_frame_args ();
1189 if (gdbarch_frame_num_args_p (gdbarch))
1191 numargs = gdbarch_frame_num_args (gdbarch, frame);
1192 gdb_assert (numargs >= 0);
1198 ui_out_emit_list list_emitter (uiout, "args");
1201 print_frame_args (func, frame, numargs, gdb_stdout);
1203 catch (const gdb_exception_error &e)
1207 /* FIXME: ARGS must be a list. If one argument is a string it
1208 will have " that will not be properly escaped. */
1215 const char *filename_display;
1217 filename_display = symtab_to_filename_for_display (sal.symtab);
1218 annotate_frame_source_begin ();
1219 uiout->wrap_hint (" ");
1220 uiout->text (" at ");
1221 annotate_frame_source_file ();
1222 uiout->field_string ("file", filename_display, ui_out_style_kind::FILE);
1223 if (uiout->is_mi_like_p ())
1225 const char *fullname = symtab_to_fullname (sal.symtab);
1227 uiout->field_string ("fullname", fullname);
1229 annotate_frame_source_file_end ();
1231 annotate_frame_source_line ();
1232 uiout->field_int ("line", sal.line);
1233 annotate_frame_source_end ();
1236 if (pc_p && (funname == NULL || sal.symtab == NULL))
1238 char *lib = solib_name_from_address (get_frame_program_space (frame),
1239 get_frame_pc (frame));
1243 annotate_frame_where ();
1244 uiout->wrap_hint (" ");
1245 uiout->text (" from ");
1246 uiout->field_string ("from", lib);
1249 if (uiout->is_mi_like_p ())
1250 uiout->field_string ("arch",
1251 (gdbarch_bfd_arch_info (gdbarch))->printable_name);
1258 /* Completion function for "frame function", "info frame function", and
1259 "select-frame function" commands. */
1262 frame_selection_by_function_completer (struct cmd_list_element *ignore,
1263 completion_tracker &tracker,
1264 const char *text, const char *word)
1266 /* This is used to complete function names within a stack. It would be
1267 nice if we only offered functions that were actually in the stack.
1268 However, this would mean unwinding the stack to completion, which
1269 could take too long, or on a corrupted stack, possibly not end.
1270 Instead, we offer all symbol names as a safer choice. */
1271 collect_symbol_completion_matches (tracker,
1272 complete_symbol_mode::EXPRESSION,
1273 symbol_name_match_type::EXPRESSION,
1277 /* Core of all the "info frame" sub-commands. Print information about a
1278 frame FI. If SELECTED_FRAME_P is true then the user didn't provide a
1279 frame specification, they just entered 'info frame'. If the user did
1280 provide a frame specification (for example 'info frame 0', 'info frame
1281 level 1') then SELECTED_FRAME_P will be false. */
1284 info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
1286 struct symbol *func;
1288 struct frame_info *calling_frame_info;
1290 const char *funname = 0;
1291 enum language funlang = language_unknown;
1292 const char *pc_regname;
1293 struct gdbarch *gdbarch;
1296 /* Initialize it to avoid "may be used uninitialized" warning. */
1297 CORE_ADDR caller_pc = 0;
1298 int caller_pc_p = 0;
1300 gdbarch = get_frame_arch (fi);
1302 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1303 is not a good name. */
1304 if (gdbarch_pc_regnum (gdbarch) >= 0)
1305 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1306 easily not match that of the internal value returned by
1308 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1310 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1311 architectures will often have a hardware register called "pc",
1312 and that register's value, again, can easily not match
1316 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1317 func = get_frame_function (fi);
1318 symtab_and_line sal = find_frame_sal (fi);
1320 gdb::unique_xmalloc_ptr<char> func_only;
1323 funname = SYMBOL_PRINT_NAME (func);
1324 funlang = SYMBOL_LANGUAGE (func);
1325 if (funlang == language_cplus)
1327 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1328 to display the demangled name that we already have
1329 stored in the symbol table, but we stored a version
1330 with DMGL_PARAMS turned on, and here we don't want to
1331 display parameters. So remove the parameters. */
1332 func_only = cp_remove_params (funname);
1335 funname = func_only.get ();
1338 else if (frame_pc_p)
1340 struct bound_minimal_symbol msymbol;
1342 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1343 if (msymbol.minsym != NULL)
1345 funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1346 funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1349 calling_frame_info = get_prev_frame (fi);
1351 if (selected_frame_p && frame_relative_level (fi) >= 0)
1353 printf_filtered (_("Stack level %d, frame at "),
1354 frame_relative_level (fi));
1358 printf_filtered (_("Stack frame at "));
1360 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1361 printf_filtered (":\n");
1362 printf_filtered (" %s = ", pc_regname);
1364 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1366 fputs_filtered ("<unavailable>", gdb_stdout);
1371 printf_filtered (" in ");
1372 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1373 DMGL_ANSI | DMGL_PARAMS);
1377 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1379 puts_filtered ("; ");
1381 printf_filtered ("saved %s = ", pc_regname);
1383 if (!frame_id_p (frame_unwind_caller_id (fi)))
1384 val_print_not_saved (gdb_stdout);
1389 caller_pc = frame_unwind_caller_pc (fi);
1392 catch (const gdb_exception_error &ex)
1396 case NOT_AVAILABLE_ERROR:
1397 val_print_unavailable (gdb_stdout);
1399 case OPTIMIZED_OUT_ERROR:
1400 val_print_not_saved (gdb_stdout);
1403 fprintf_filtered (gdb_stdout, _("<error: %s>"),
1411 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1412 printf_filtered ("\n");
1414 if (calling_frame_info == NULL)
1416 enum unwind_stop_reason reason;
1418 reason = get_frame_unwind_stop_reason (fi);
1419 if (reason != UNWIND_NO_REASON)
1420 printf_filtered (_(" Outermost frame: %s\n"),
1421 frame_stop_reason_string (fi));
1423 else if (get_frame_type (fi) == TAILCALL_FRAME)
1424 puts_filtered (" tail call frame");
1425 else if (get_frame_type (fi) == INLINE_FRAME)
1426 printf_filtered (" inlined into frame %d",
1427 frame_relative_level (get_prev_frame (fi)));
1430 printf_filtered (" called by frame at ");
1431 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1434 if (get_next_frame (fi) && calling_frame_info)
1435 puts_filtered (",");
1437 if (get_next_frame (fi))
1439 printf_filtered (" caller of frame at ");
1440 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1443 if (get_next_frame (fi) || calling_frame_info)
1444 puts_filtered ("\n");
1447 printf_filtered (" source language %s.\n",
1448 language_str (s->language));
1451 /* Address of the argument list for this frame, or 0. */
1452 CORE_ADDR arg_list = get_frame_args_address (fi);
1453 /* Number of args for this frame, or -1 if unknown. */
1457 printf_filtered (" Arglist at unknown address.\n");
1460 printf_filtered (" Arglist at ");
1461 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1462 printf_filtered (",");
1464 if (!gdbarch_frame_num_args_p (gdbarch))
1467 puts_filtered (" args: ");
1471 numargs = gdbarch_frame_num_args (gdbarch, fi);
1472 gdb_assert (numargs >= 0);
1474 puts_filtered (" no args.");
1475 else if (numargs == 1)
1476 puts_filtered (" 1 arg: ");
1478 printf_filtered (" %d args: ", numargs);
1480 print_frame_args (func, fi, numargs, gdb_stdout);
1481 puts_filtered ("\n");
1485 /* Address of the local variables for this frame, or 0. */
1486 CORE_ADDR arg_list = get_frame_locals_address (fi);
1489 printf_filtered (" Locals at unknown address,");
1492 printf_filtered (" Locals at ");
1493 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1494 printf_filtered (",");
1498 /* Print as much information as possible on the location of all the
1504 int sp_regnum = gdbarch_sp_regnum (gdbarch);
1506 /* The sp is special; what's displayed isn't the save address, but
1507 the value of the previous frame's sp. This is a legacy thing,
1508 at one stage the frame cached the previous frame's SP instead
1509 of its address, hence it was easiest to just display the cached
1513 struct value *value = frame_unwind_register_value (fi, sp_regnum);
1514 gdb_assert (value != NULL);
1516 if (!value_optimized_out (value) && value_entirely_available (value))
1518 if (VALUE_LVAL (value) == not_lval)
1521 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1522 int sp_size = register_size (gdbarch, sp_regnum);
1524 sp = extract_unsigned_integer (value_contents_all (value),
1525 sp_size, byte_order);
1527 printf_filtered (" Previous frame's sp is ");
1528 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1529 printf_filtered ("\n");
1531 else if (VALUE_LVAL (value) == lval_memory)
1533 printf_filtered (" Previous frame's sp at ");
1534 fputs_filtered (paddress (gdbarch, value_address (value)),
1536 printf_filtered ("\n");
1538 else if (VALUE_LVAL (value) == lval_register)
1540 printf_filtered (" Previous frame's sp in %s\n",
1541 gdbarch_register_name (gdbarch,
1542 VALUE_REGNUM (value)));
1545 release_value (value);
1548 /* else keep quiet. */
1552 numregs = gdbarch_num_cooked_regs (gdbarch);
1553 for (i = 0; i < numregs; i++)
1555 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1557 enum lval_type lval;
1563 /* Find out the location of the saved register without
1564 fetching the corresponding value. */
1565 frame_register_unwind (fi, i, &optimized, &unavailable,
1566 &lval, &addr, &realnum, NULL);
1567 /* For moment, only display registers that were saved on the
1569 if (!optimized && !unavailable && lval == lval_memory)
1572 puts_filtered (" Saved registers:\n ");
1574 puts_filtered (",");
1576 printf_filtered (" %s at ",
1577 gdbarch_register_name (gdbarch, i));
1578 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1582 if (count || need_nl)
1583 puts_filtered ("\n");
1587 /* Return the innermost frame at level LEVEL. */
1589 static struct frame_info *
1590 leading_innermost_frame (int level)
1592 struct frame_info *leading;
1594 leading = get_current_frame ();
1596 gdb_assert (level >= 0);
1598 while (leading != nullptr && level)
1601 leading = get_prev_frame (leading);
1608 /* Return the starting frame needed to handle COUNT outermost frames. */
1610 static struct frame_info *
1611 trailing_outermost_frame (int count)
1613 struct frame_info *current;
1614 struct frame_info *trailing;
1616 trailing = get_current_frame ();
1618 gdb_assert (count > 0);
1621 while (current != nullptr && count--)
1624 current = get_prev_frame (current);
1627 /* Will stop when CURRENT reaches the top of the stack.
1628 TRAILING will be COUNT below it. */
1629 while (current != nullptr)
1632 trailing = get_prev_frame (trailing);
1633 current = get_prev_frame (current);
1639 /* The core of all the "select-frame" sub-commands. Just wraps a call to
1643 select_frame_command_core (struct frame_info *fi, bool ignored)
1645 struct frame_info *prev_frame = get_selected_frame_if_set ();
1647 if (get_selected_frame_if_set () != prev_frame)
1648 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1654 select_frame_for_mi (struct frame_info *fi)
1656 select_frame_command_core (fi, FALSE /* Ignored. */);
1659 /* The core of all the "frame" sub-commands. Select frame FI, and if this
1660 means we change frame send out a change notification (otherwise, just
1661 reprint the current frame summary). */
1664 frame_command_core (struct frame_info *fi, bool ignored)
1666 struct frame_info *prev_frame = get_selected_frame_if_set ();
1669 if (get_selected_frame_if_set () != prev_frame)
1670 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1672 print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
1675 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1676 common set of sub-commands that allow a specific frame to be selected.
1677 All of the sub-command functions are static methods within this class
1678 template which is then instantiated below. The template parameter is a
1679 callback used to implement the functionality of the base command
1680 ('frame', 'select-frame', or 'info frame').
1682 In the template parameter FI is the frame being selected. The
1683 SELECTED_FRAME_P flag is true if the frame being selected was done by
1684 default, which happens when the user uses the base command with no
1685 arguments. For example the commands 'info frame', 'select-frame',
1686 'frame' will all cause SELECTED_FRAME_P to be true. In all other cases
1687 SELECTED_FRAME_P is false. */
1689 template <void (*FPTR) (struct frame_info *fi, bool selected_frame_p)>
1690 class frame_command_helper
1694 /* The "frame level" family of commands. The ARG is an integer that is
1695 the frame's level in the stack. */
1697 level (const char *arg, int from_tty)
1699 int level = value_as_long (parse_and_eval (arg));
1700 struct frame_info *fid
1701 = find_relative_frame (get_current_frame (), &level);
1703 error (_("No frame at level %s."), arg);
1707 /* The "frame address" family of commands. ARG is a stack-pointer
1708 address for an existing frame. This command does not allow new
1709 frames to be created. */
1712 address (const char *arg, int from_tty)
1714 CORE_ADDR addr = value_as_address (parse_and_eval (arg));
1715 struct frame_info *fid = find_frame_for_address (addr);
1717 error (_("No frame at address %s."), arg);
1721 /* The "frame view" family of commands. ARG is one or two addresses and
1722 is used to view a frame that might be outside the current backtrace.
1723 The addresses are stack-pointer address, and (optional) pc-address. */
1726 view (const char *args, int from_tty)
1728 struct frame_info *fid;
1731 error (_("Missing address argument to view a frame"));
1733 gdb_argv argv (args);
1735 if (argv.count () == 2)
1739 addr [0] = value_as_address (parse_and_eval (argv[0]));
1740 addr [1] = value_as_address (parse_and_eval (argv[1]));
1741 fid = create_new_frame (addr[0], addr[1]);
1745 CORE_ADDR addr = value_as_address (parse_and_eval (argv[0]));
1746 fid = create_new_frame (addr, false);
1751 /* The "frame function" family of commands. ARG is the name of a
1752 function within the stack, the first function (searching from frame
1753 0) with that name will be selected. */
1756 function (const char *arg, int from_tty)
1759 error (_("Missing function name argument"));
1760 struct frame_info *fid = find_frame_for_function (arg);
1762 error (_("No frame for function \"%s\"."), arg);
1766 /* The "frame" base command, that is, when no sub-command is specified.
1767 If one argument is provided then we assume that this is a frame's
1768 level as historically, this was the supported command syntax that was
1771 If no argument is provided, then the current frame is selected. */
1774 base_command (const char *arg, int from_tty)
1777 FPTR (get_selected_frame (_("No stack.")), true);
1779 level (arg, from_tty);
1783 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1784 sub-commands for 'info frame', 'frame', and 'select-frame' commands. */
1786 static frame_command_helper <info_frame_command_core> info_frame_cmd;
1787 static frame_command_helper <frame_command_core> frame_cmd;
1788 static frame_command_helper <select_frame_command_core> select_frame_cmd;
1790 /* Print briefly all stack frames or just the innermost COUNT_EXP
1794 backtrace_command_1 (const char *count_exp, frame_filter_flags flags,
1795 int no_filters, int from_tty)
1797 struct frame_info *fi;
1799 int py_start = 0, py_end = 0;
1800 enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1802 if (!target_has_stack)
1803 error (_("No stack."));
1807 count = parse_and_eval_long (count_exp);
1813 /* The argument to apply_ext_lang_frame_filter is the number
1814 of the final frame to print, and frames start at 0. */
1826 enum ext_lang_frame_args arg_type;
1828 flags |= PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1830 flags |= PRINT_MORE_FRAMES;
1832 if (!strcmp (print_frame_arguments, "scalars"))
1833 arg_type = CLI_SCALAR_VALUES;
1834 else if (!strcmp (print_frame_arguments, "all"))
1835 arg_type = CLI_ALL_VALUES;
1837 arg_type = NO_VALUES;
1839 result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1840 arg_type, current_uiout,
1844 /* Run the inbuilt backtrace if there are no filters registered, or
1845 "no-filters" has been specified from the command. */
1846 if (no_filters || result == EXT_LANG_BT_NO_FILTERS)
1848 struct frame_info *trailing;
1850 /* The following code must do two things. First, it must set the
1851 variable TRAILING to the frame from which we should start
1852 printing. Second, it must set the variable count to the number
1853 of frames which we should print, or -1 if all of them. */
1855 if (count_exp != NULL && count < 0)
1857 trailing = trailing_outermost_frame (-count);
1861 trailing = get_current_frame ();
1863 for (fi = trailing; fi && count--; fi = get_prev_frame (fi))
1867 /* Don't use print_stack_frame; if an error() occurs it probably
1868 means further attempts to backtrace would fail (on the other
1869 hand, perhaps the code does or could be fixed to make sure
1870 the frame->prev field gets set to NULL in that case). */
1872 print_frame_info (fi, 1, LOCATION, 1, 0);
1873 if ((flags & PRINT_LOCALS) != 0)
1875 struct frame_id frame_id = get_frame_id (fi);
1877 print_frame_local_vars (fi, false, NULL, NULL, 1, gdb_stdout);
1879 /* print_frame_local_vars invalidates FI. */
1880 fi = frame_find_by_id (frame_id);
1884 warning (_("Unable to restore previously selected frame."));
1889 /* Save the last frame to check for error conditions. */
1893 /* If we've stopped before the end, mention that. */
1895 printf_filtered (_("(More stack frames follow...)\n"));
1897 /* If we've run out of frames, and the reason appears to be an error
1898 condition, print it. */
1899 if (fi == NULL && trailing != NULL)
1901 enum unwind_stop_reason reason;
1903 reason = get_frame_unwind_stop_reason (trailing);
1904 if (reason >= UNWIND_FIRST_ERROR)
1905 printf_filtered (_("Backtrace stopped: %s\n"),
1906 frame_stop_reason_string (trailing));
1912 backtrace_command (const char *arg, int from_tty)
1914 bool filters = true;
1915 frame_filter_flags flags = 0;
1923 const char *save_arg = arg;
1924 std::string this_arg = extract_arg (&arg);
1926 if (this_arg.empty ())
1929 if (subset_compare (this_arg.c_str (), "no-filters"))
1931 else if (subset_compare (this_arg.c_str (), "full"))
1932 flags |= PRINT_LOCALS;
1933 else if (subset_compare (this_arg.c_str (), "hide"))
1934 flags |= PRINT_HIDE;
1937 /* Not a recognized argument, so stop. */
1947 backtrace_command_1 (arg, flags, !filters /* no frame-filters */, from_tty);
1950 /* Iterate over the local variables of a block B, calling CB with
1954 iterate_over_block_locals (const struct block *b,
1955 iterate_over_block_arg_local_vars_cb cb,
1958 struct block_iterator iter;
1961 ALL_BLOCK_SYMBOLS (b, iter, sym)
1963 switch (SYMBOL_CLASS (sym))
1969 case LOC_OPTIMIZED_OUT:
1970 if (SYMBOL_IS_ARGUMENT (sym))
1972 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1974 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1978 /* Ignore symbols which are not locals. */
1985 /* Same, but print labels. */
1988 /* Commented out, as the code using this function has also been
1989 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1990 was commented out in the first place. The discussion introducing
1991 this change (2007-12-04: Support lexical blocks and function bodies
1992 that occupy non-contiguous address ranges) did not explain why
1993 this change was made. */
1995 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1996 int *have_default, struct ui_file *stream)
1998 struct block_iterator iter;
2000 int values_printed = 0;
2002 ALL_BLOCK_SYMBOLS (b, iter, sym)
2004 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
2010 if (SYMBOL_CLASS (sym) == LOC_LABEL)
2012 struct symtab_and_line sal;
2013 struct value_print_options opts;
2015 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2017 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
2018 get_user_print_options (&opts);
2019 if (opts.addressprint)
2021 fprintf_filtered (stream, " ");
2022 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2025 fprintf_filtered (stream, " in file %s, line %d\n",
2026 sal.symtab->filename, sal.line);
2030 return values_printed;
2034 /* Iterate over all the local variables in block B, including all its
2035 superblocks, stopping when the top-level block is reached. */
2038 iterate_over_block_local_vars (const struct block *block,
2039 iterate_over_block_arg_local_vars_cb cb,
2044 iterate_over_block_locals (block, cb, cb_data);
2045 /* After handling the function's top-level block, stop. Don't
2046 continue to its superblock, the block of per-file
2048 if (BLOCK_FUNCTION (block))
2050 block = BLOCK_SUPERBLOCK (block);
2054 /* Data to be passed around in the calls to the locals and args
2057 struct print_variable_and_value_data
2059 gdb::optional<compiled_regex> preg;
2060 gdb::optional<compiled_regex> treg;
2061 struct frame_id frame_id;
2063 struct ui_file *stream;
2067 /* The callback for the locals and args iterators. */
2070 do_print_variable_and_value (const char *print_name,
2074 struct print_variable_and_value_data *p
2075 = (struct print_variable_and_value_data *) cb_data;
2076 struct frame_info *frame;
2078 if (p->preg.has_value ()
2079 && p->preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
2082 if (p->treg.has_value ()
2083 && !treg_matches_sym_type_name (*p->treg, sym))
2086 frame = frame_find_by_id (p->frame_id);
2089 warning (_("Unable to restore previously selected frame."));
2093 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2095 /* print_variable_and_value invalidates FRAME. */
2098 p->values_printed = 1;
2101 /* Prepares the regular expression REG from REGEXP.
2102 If REGEXP is NULL, it results in an empty regular expression. */
2105 prepare_reg (const char *regexp, gdb::optional<compiled_regex> *reg)
2109 int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
2111 reg->emplace (regexp, cflags, _("Invalid regexp"));
2117 /* Print all variables from the innermost up to the function block of FRAME.
2118 Print them with values to STREAM indented by NUM_TABS.
2119 If REGEXP is not NULL, only print local variables whose name
2121 If T_REGEXP is not NULL, only print local variables whose type
2123 If no local variables have been printed and !QUIET, prints a message
2124 explaining why no local variables could be printed.
2126 This function will invalidate FRAME. */
2129 print_frame_local_vars (struct frame_info *frame,
2131 const char *regexp, const char *t_regexp,
2132 int num_tabs, struct ui_file *stream)
2134 struct print_variable_and_value_data cb_data;
2135 const struct block *block;
2138 if (!get_frame_pc_if_available (frame, &pc))
2141 fprintf_filtered (stream,
2142 _("PC unavailable, cannot determine locals.\n"));
2146 block = get_frame_block (frame, 0);
2150 fprintf_filtered (stream, "No symbol table info available.\n");
2154 prepare_reg (regexp, &cb_data.preg);
2155 prepare_reg (t_regexp, &cb_data.treg);
2156 cb_data.frame_id = get_frame_id (frame);
2157 cb_data.num_tabs = 4 * num_tabs;
2158 cb_data.stream = stream;
2159 cb_data.values_printed = 0;
2161 /* Temporarily change the selected frame to the given FRAME.
2162 This allows routines that rely on the selected frame instead
2163 of being given a frame as parameter to use the correct frame. */
2164 scoped_restore_selected_frame restore_selected_frame;
2165 select_frame (frame);
2167 iterate_over_block_local_vars (block,
2168 do_print_variable_and_value,
2171 if (!cb_data.values_printed && !quiet)
2173 if (regexp == NULL && t_regexp == NULL)
2174 fprintf_filtered (stream, _("No locals.\n"));
2176 fprintf_filtered (stream, _("No matching locals.\n"));
2181 info_locals_command (const char *args, int from_tty)
2184 std::string t_regexp;
2188 && extract_info_print_args (&args, &quiet, ®exp, &t_regexp))
2192 report_unrecognized_option_error ("info locals", args);
2194 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2196 regexp.empty () ? NULL : regexp.c_str (),
2197 t_regexp.empty () ? NULL : t_regexp.c_str (),
2201 /* Iterate over all the argument variables in block B. */
2204 iterate_over_block_arg_vars (const struct block *b,
2205 iterate_over_block_arg_local_vars_cb cb,
2208 struct block_iterator iter;
2209 struct symbol *sym, *sym2;
2211 ALL_BLOCK_SYMBOLS (b, iter, sym)
2213 /* Don't worry about things which aren't arguments. */
2214 if (SYMBOL_IS_ARGUMENT (sym))
2216 /* We have to look up the symbol because arguments can have
2217 two entries (one a parameter, one a local) and the one we
2218 want is the local, which lookup_symbol will find for us.
2219 This includes gcc1 (not gcc2) on the sparc when passing a
2220 small structure and gcc2 when the argument type is float
2221 and it is passed as a double and converted to float by
2222 the prologue (in the latter case the type of the LOC_ARG
2223 symbol is double and the type of the LOC_LOCAL symbol is
2224 float). There are also LOC_ARG/LOC_REGISTER pairs which
2225 are not combined in symbol-reading. */
2227 sym2 = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
2228 b, VAR_DOMAIN).symbol;
2229 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2234 /* Print all argument variables of the function of FRAME.
2235 Print them with values to STREAM.
2236 If REGEXP is not NULL, only print argument variables whose name
2238 If T_REGEXP is not NULL, only print argument variables whose type
2240 If no argument variables have been printed and !QUIET, prints a message
2241 explaining why no argument variables could be printed.
2243 This function will invalidate FRAME. */
2246 print_frame_arg_vars (struct frame_info *frame,
2248 const char *regexp, const char *t_regexp,
2249 struct ui_file *stream)
2251 struct print_variable_and_value_data cb_data;
2252 struct symbol *func;
2254 gdb::optional<compiled_regex> preg;
2255 gdb::optional<compiled_regex> treg;
2257 if (!get_frame_pc_if_available (frame, &pc))
2260 fprintf_filtered (stream,
2261 _("PC unavailable, cannot determine args.\n"));
2265 func = get_frame_function (frame);
2269 fprintf_filtered (stream, _("No symbol table info available.\n"));
2273 prepare_reg (regexp, &cb_data.preg);
2274 prepare_reg (t_regexp, &cb_data.treg);
2275 cb_data.frame_id = get_frame_id (frame);
2276 cb_data.num_tabs = 0;
2277 cb_data.stream = stream;
2278 cb_data.values_printed = 0;
2280 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2281 do_print_variable_and_value, &cb_data);
2283 /* do_print_variable_and_value invalidates FRAME. */
2286 if (!cb_data.values_printed && !quiet)
2288 if (regexp == NULL && t_regexp == NULL)
2289 fprintf_filtered (stream, _("No arguments.\n"));
2291 fprintf_filtered (stream, _("No matching arguments.\n"));
2296 info_args_command (const char *args, int from_tty)
2299 std::string t_regexp;
2303 && extract_info_print_args (&args, &quiet, ®exp, &t_regexp))
2307 report_unrecognized_option_error ("info args", args);
2310 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2312 regexp.empty () ? NULL : regexp.c_str (),
2313 t_regexp.empty () ? NULL : t_regexp.c_str (),
2317 /* Return the symbol-block in which the selected frame is executing.
2318 Can return zero under various legitimate circumstances.
2320 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2321 code address within the block returned. We use this to decide
2322 which macros are in scope. */
2324 const struct block *
2325 get_selected_block (CORE_ADDR *addr_in_block)
2327 if (!has_stack_frames ())
2330 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2333 /* Find a frame a certain number of levels away from FRAME.
2334 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2335 Positive means go to earlier frames (up); negative, the reverse.
2336 The int that contains the number of levels is counted toward
2337 zero as the frames for those levels are found.
2338 If the top or bottom frame is reached, that frame is returned,
2339 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2340 how much farther the original request asked to go. */
2343 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2345 /* Going up is simple: just call get_prev_frame enough times or
2346 until the initial frame is reached. */
2347 while (*level_offset_ptr > 0)
2349 struct frame_info *prev = get_prev_frame (frame);
2353 (*level_offset_ptr)--;
2357 /* Going down is just as simple. */
2358 while (*level_offset_ptr < 0)
2360 struct frame_info *next = get_next_frame (frame);
2364 (*level_offset_ptr)++;
2371 /* Select the frame up one or COUNT_EXP stack levels from the
2372 previously selected frame, and print it briefly. */
2375 up_silently_base (const char *count_exp)
2377 struct frame_info *frame;
2381 count = parse_and_eval_long (count_exp);
2383 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2384 if (count != 0 && count_exp == NULL)
2385 error (_("Initial frame selected; you cannot go up."));
2386 select_frame (frame);
2390 up_silently_command (const char *count_exp, int from_tty)
2392 up_silently_base (count_exp);
2396 up_command (const char *count_exp, int from_tty)
2398 up_silently_base (count_exp);
2399 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
2402 /* Select the frame down one or COUNT_EXP stack levels from the previously
2403 selected frame, and print it briefly. */
2406 down_silently_base (const char *count_exp)
2408 struct frame_info *frame;
2412 count = -parse_and_eval_long (count_exp);
2414 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2415 if (count != 0 && count_exp == NULL)
2417 /* We only do this if COUNT_EXP is not specified. That way
2418 "down" means to really go down (and let me know if that is
2419 impossible), but "down 9999" can be used to mean go all the
2420 way down without getting an error. */
2422 error (_("Bottom (innermost) frame selected; you cannot go down."));
2425 select_frame (frame);
2429 down_silently_command (const char *count_exp, int from_tty)
2431 down_silently_base (count_exp);
2435 down_command (const char *count_exp, int from_tty)
2437 down_silently_base (count_exp);
2438 gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
2442 return_command (const char *retval_exp, int from_tty)
2444 /* Initialize it just to avoid a GCC false warning. */
2445 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2446 struct frame_info *thisframe;
2447 struct gdbarch *gdbarch;
2448 struct symbol *thisfun;
2449 struct value *return_value = NULL;
2450 struct value *function = NULL;
2451 const char *query_prefix = "";
2453 thisframe = get_selected_frame ("No selected frame.");
2454 thisfun = get_frame_function (thisframe);
2455 gdbarch = get_frame_arch (thisframe);
2457 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2458 error (_("Can not force return from an inlined function."));
2460 /* Compute the return value. If the computation triggers an error,
2461 let it bail. If the return type can't be handled, set
2462 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2466 expression_up retval_expr = parse_expression (retval_exp);
2467 struct type *return_type = NULL;
2469 /* Compute the return value. Should the computation fail, this
2470 call throws an error. */
2471 return_value = evaluate_expression (retval_expr.get ());
2473 /* Cast return value to the return type of the function. Should
2474 the cast fail, this call throws an error. */
2475 if (thisfun != NULL)
2476 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2477 if (return_type == NULL)
2479 if (retval_expr->elts[0].opcode != UNOP_CAST
2480 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2481 error (_("Return value type not available for selected "
2483 "Please use an explicit cast of the value to return."));
2484 return_type = value_type (return_value);
2486 return_type = check_typedef (return_type);
2487 return_value = value_cast (return_type, return_value);
2489 /* Make sure the value is fully evaluated. It may live in the
2490 stack frame we're about to pop. */
2491 if (value_lazy (return_value))
2492 value_fetch_lazy (return_value);
2494 if (thisfun != NULL)
2495 function = read_var_value (thisfun, NULL, thisframe);
2497 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2498 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2499 /* If the return-type is "void", don't try to find the
2500 return-value's location. However, do still evaluate the
2501 return expression so that, even when the expression result
2502 is discarded, side effects such as "return i++" still
2504 return_value = NULL;
2505 else if (thisfun != NULL)
2507 rv_conv = struct_return_convention (gdbarch, function, return_type);
2508 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2509 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2511 query_prefix = "The location at which to store the "
2512 "function's return value is unknown.\n"
2513 "If you continue, the return value "
2514 "that you specified will be ignored.\n";
2515 return_value = NULL;
2520 /* Does an interactive user really want to do this? Include
2521 information, such as how well GDB can handle the return value, in
2522 the query message. */
2527 if (thisfun == NULL)
2528 confirmed = query (_("%sMake selected stack frame return now? "),
2532 if (TYPE_NO_RETURN (thisfun->type))
2533 warning (_("Function does not return normally to caller."));
2534 confirmed = query (_("%sMake %s return now? "), query_prefix,
2535 SYMBOL_PRINT_NAME (thisfun));
2538 error (_("Not confirmed"));
2541 /* Discard the selected frame and all frames inner-to it. */
2542 frame_pop (get_selected_frame (NULL));
2544 /* Store RETURN_VALUE in the just-returned register set. */
2545 if (return_value != NULL)
2547 struct type *return_type = value_type (return_value);
2548 struct gdbarch *cache_arch = get_current_regcache ()->arch ();
2550 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2551 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2552 gdbarch_return_value (cache_arch, function, return_type,
2553 get_current_regcache (), NULL /*read*/,
2554 value_contents (return_value) /*write*/);
2557 /* If we are at the end of a call dummy now, pop the dummy frame
2559 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2560 frame_pop (get_current_frame ());
2562 select_frame (get_current_frame ());
2563 /* If interactive, print the frame that is now current. */
2565 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2568 /* Find the most inner frame in the current stack for a function called
2569 FUNCTION_NAME. If no matching frame is found return NULL. */
2571 static struct frame_info *
2572 find_frame_for_function (const char *function_name)
2574 /* Used to hold the lower and upper addresses for each of the
2575 SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME. */
2576 struct function_bounds
2578 CORE_ADDR low, high;
2580 struct frame_info *frame;
2584 gdb_assert (function_name != NULL);
2586 frame = get_current_frame ();
2587 std::vector<symtab_and_line> sals
2588 = decode_line_with_current_source (function_name,
2589 DECODE_LINE_FUNFIRSTLINE);
2590 gdb::def_vector<function_bounds> func_bounds (sals.size ());
2591 for (size_t i = 0; i < sals.size (); i++)
2593 if (sals[i].pspace != current_program_space)
2594 func_bounds[i].low = func_bounds[i].high = 0;
2595 else if (sals[i].pc == 0
2596 || find_pc_partial_function (sals[i].pc, NULL,
2597 &func_bounds[i].low,
2598 &func_bounds[i].high) == 0)
2599 func_bounds[i].low = func_bounds[i].high = 0;
2604 for (size_t i = 0; (i < sals.size () && !found); i++)
2605 found = (get_frame_pc (frame) >= func_bounds[i].low
2606 && get_frame_pc (frame) < func_bounds[i].high);
2610 frame = find_relative_frame (frame, &level);
2613 while (!found && level == 0);
2621 /* Implements the dbx 'func' command. */
2624 func_command (const char *arg, int from_tty)
2629 struct frame_info *frame = find_frame_for_function (arg);
2631 error (_("'%s' not within current stack frame."), arg);
2632 if (frame != get_selected_frame (NULL))
2634 select_frame (frame);
2635 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2639 /* Apply a GDB command to all stack frames, or a set of identified frames,
2640 or innermost COUNT frames.
2641 With a negative COUNT, apply command on outermost -COUNT frames.
2643 frame apply 3 info frame Apply 'info frame' to frames 0, 1, 2
2644 frame apply -3 info frame Apply 'info frame' to outermost 3 frames.
2645 frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames.
2646 frame apply all -s p local_var_no_idea_in_which_frame
2647 If a frame has a local variable called
2648 local_var_no_idea_in_which_frame, print frame
2649 and value of local_var_no_idea_in_which_frame.
2650 frame apply all -s -q p local_var_no_idea_in_which_frame
2651 Same as before, but only print the variable value.
2652 frame apply level 2-5 0 4-7 -s p i = i + 1
2653 Adds 1 to the variable i in the specified frames.
2654 Note that i will be incremented twice in
2657 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2658 CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2659 COUNT -1 means all frames starting at TRAILING. WHICH_COMMAND is used
2660 for error messages. */
2663 frame_apply_command_count (const char *which_command,
2664 const char *cmd, int from_tty,
2665 struct frame_info *trailing, int count)
2668 struct frame_info *fi;
2670 while (cmd != NULL && parse_flags_qcs (which_command, &cmd, &flags))
2673 if (cmd == NULL || *cmd == '\0')
2674 error (_("Please specify a command to apply on the selected frames"));
2676 /* The below will restore the current inferior/thread/frame.
2677 Usually, only the frame is effectively to be restored.
2678 But in case CMD switches of inferior/thread, better restore
2680 scoped_restore_current_thread restore_thread;
2682 for (fi = trailing; fi && count--; fi = get_prev_frame (fi))
2689 std::string cmd_result;
2691 /* In case CMD switches of inferior/thread/frame, the below
2692 restores the inferior/thread/frame. FI can then be
2693 set to the selected frame. */
2694 scoped_restore_current_thread restore_fi_current_frame;
2696 cmd_result = execute_command_to_string
2697 (cmd, from_tty, gdb_stdout->term_out ());
2699 fi = get_selected_frame (_("frame apply "
2700 "unable to get selected frame."));
2701 if (!flags.silent || cmd_result.length () > 0)
2704 print_stack_frame (fi, 1, LOCATION, 0);
2705 printf_filtered ("%s", cmd_result.c_str ());
2708 catch (const gdb_exception_error &ex)
2710 fi = get_selected_frame (_("frame apply "
2711 "unable to get selected frame."));
2715 print_stack_frame (fi, 1, LOCATION, 0);
2717 printf_filtered ("%s\n", ex.what ());
2725 /* Implementation of the "frame apply level" command. */
2728 frame_apply_level_command (const char *cmd, int from_tty)
2730 if (!target_has_stack)
2731 error (_("No stack."));
2733 bool level_found = false;
2734 const char *levels_str = cmd;
2735 number_or_range_parser levels (levels_str);
2737 /* Skip the LEVEL list to find the flags and command args. */
2738 while (!levels.finished ())
2740 /* Call for effect. */
2741 levels.get_number ();
2744 if (levels.in_range ())
2745 levels.skip_range ();
2749 error (_("Missing or invalid LEVEL... argument"));
2751 cmd = levels.cur_tok ();
2753 /* Redo the LEVELS parsing, but applying COMMAND. */
2754 levels.init (levels_str);
2755 while (!levels.finished ())
2757 const int level_beg = levels.get_number ();
2760 if (levels.in_range ())
2762 n_frames = levels.end_value () - level_beg + 1;
2763 levels.skip_range ();
2768 frame_apply_command_count ("frame apply level", cmd, from_tty,
2769 leading_innermost_frame (level_beg), n_frames);
2773 /* Implementation of the "frame apply all" command. */
2776 frame_apply_all_command (const char *cmd, int from_tty)
2778 if (!target_has_stack)
2779 error (_("No stack."));
2781 frame_apply_command_count ("frame apply all", cmd, from_tty,
2782 get_current_frame (), INT_MAX);
2785 /* Implementation of the "frame apply" command. */
2788 frame_apply_command (const char* cmd, int from_tty)
2791 struct frame_info *trailing;
2793 if (!target_has_stack)
2794 error (_("No stack."));
2797 error (_("Missing COUNT argument."));
2798 count = get_number_trailer (&cmd, 0);
2800 error (_("Invalid COUNT argument."));
2804 trailing = trailing_outermost_frame (-count);
2808 trailing = get_current_frame ();
2810 frame_apply_command_count ("frame apply", cmd, from_tty,
2814 /* Implementation of the "faas" command. */
2817 faas_command (const char *cmd, int from_tty)
2819 std::string expanded = std::string ("frame apply all -s ") + cmd;
2820 execute_command (expanded.c_str (), from_tty);
2824 /* Find inner-mode frame with frame address ADDRESS. Return NULL if no
2825 matching frame can be found. */
2827 static struct frame_info *
2828 find_frame_for_address (CORE_ADDR address)
2831 struct frame_info *fid;
2833 id = frame_id_build_wild (address);
2835 /* If (s)he specifies the frame with an address, he deserves
2836 what (s)he gets. Still, give the highest one that matches.
2837 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
2839 for (fid = get_current_frame ();
2841 fid = get_prev_frame (fid))
2843 if (frame_id_eq (id, get_frame_id (fid)))
2845 struct frame_info *prev_frame;
2849 prev_frame = get_prev_frame (fid);
2851 || !frame_id_eq (id, get_frame_id (prev_frame)))
2863 /* Commands with a prefix of `frame apply'. */
2864 static struct cmd_list_element *frame_apply_cmd_list = NULL;
2866 /* Commands with a prefix of `frame'. */
2867 static struct cmd_list_element *frame_cmd_list = NULL;
2869 /* Commands with a prefix of `select frame'. */
2870 static struct cmd_list_element *select_frame_cmd_list = NULL;
2872 /* Commands with a prefix of `info frame'. */
2873 static struct cmd_list_element *info_frame_cmd_list = NULL;
2876 _initialize_stack (void)
2878 struct cmd_list_element *cmd;
2880 add_com ("return", class_stack, return_command, _("\
2881 Make selected stack frame return to its caller.\n\
2882 Control remains in the debugger, but when you continue\n\
2883 execution will resume in the frame above the one now selected.\n\
2884 If an argument is given, it is an expression for the value to return."));
2886 add_com ("up", class_stack, up_command, _("\
2887 Select and print stack frame that called this one.\n\
2888 An argument says how many frames up to go."));
2889 add_com ("up-silently", class_support, up_silently_command, _("\
2890 Same as the `up' command, but does not print anything.\n\
2891 This is useful in command scripts."));
2893 add_com ("down", class_stack, down_command, _("\
2894 Select and print stack frame called by this one.\n\
2895 An argument says how many frames down to go."));
2896 add_com_alias ("do", "down", class_stack, 1);
2897 add_com_alias ("dow", "down", class_stack, 1);
2898 add_com ("down-silently", class_support, down_silently_command, _("\
2899 Same as the `down' command, but does not print anything.\n\
2900 This is useful in command scripts."));
2902 add_prefix_cmd ("frame", class_stack,
2903 &frame_cmd.base_command, _("\
2904 Select and print a stack frame.\n\
2905 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2906 A single numerical argument specifies the frame to select."),
2907 &frame_cmd_list, "frame ", 1, &cmdlist);
2909 add_com_alias ("f", "frame", class_stack, 1);
2911 #define FRAME_APPLY_FLAGS_HELP "\
2912 Prints the frame location information followed by COMMAND output.\n\
2913 FLAG arguments are -q (quiet), -c (continue), -s (silent).\n\
2914 Flag -q disables printing the frame location information.\n\
2915 By default, if a COMMAND raises an error, frame apply is aborted.\n\
2916 Flag -c indicates to print the error and continue.\n\
2917 Flag -s indicates to silently ignore a COMMAND that raises an error\n\
2918 or produces no output."
2920 add_prefix_cmd ("apply", class_stack, frame_apply_command,
2921 _("Apply a command to a number of frames.\n\
2922 Usage: frame apply COUNT [FLAG]... COMMAND\n\
2923 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
2924 FRAME_APPLY_FLAGS_HELP),
2925 &frame_apply_cmd_list, "frame apply ", 1, &frame_cmd_list);
2927 add_cmd ("all", class_stack, frame_apply_all_command,
2929 Apply a command to all frames.\n\
2931 Usage: frame apply all [FLAG]... COMMAND\n"
2932 FRAME_APPLY_FLAGS_HELP),
2933 &frame_apply_cmd_list);
2935 add_cmd ("level", class_stack, frame_apply_level_command,
2937 Apply a command to a list of frames.\n\
2939 Usage: frame apply level LEVEL... [FLAG]... COMMAND\n\
2940 ID is a space-separated list of LEVELs of frames to apply COMMAND on.\n"
2941 FRAME_APPLY_FLAGS_HELP),
2942 &frame_apply_cmd_list);
2944 add_com ("faas", class_stack, faas_command, _("\
2945 Apply a command to all frames (ignoring errors and empty output).\n\
2946 Usage: faas COMMAND\n\
2947 shortcut for 'frame apply all -s COMMAND'"));
2950 add_prefix_cmd ("frame", class_stack,
2951 &frame_cmd.base_command, _("\
2952 Select and print a stack frame.\n\
2953 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2954 A single numerical argument specifies the frame to select."),
2955 &frame_cmd_list, "frame ", 1, &cmdlist);
2956 add_com_alias ("f", "frame", class_stack, 1);
2958 add_cmd ("address", class_stack, &frame_cmd.address,
2960 Select and print a stack frame by stack address\n\
2962 Usage: frame address STACK-ADDRESS"),
2965 add_cmd ("view", class_stack, &frame_cmd.view,
2967 View a stack frame that might be outside the current backtrace.\n\
2969 Usage: frame view STACK-ADDRESS\n\
2970 frame view STACK-ADDRESS PC-ADDRESS"),
2973 cmd = add_cmd ("function", class_stack, &frame_cmd.function,
2975 Select and print a stack frame by function name.\n\
2977 Usage: frame function NAME\n\
2979 The innermost frame that visited function NAME is selected."),
2981 set_cmd_completer (cmd, frame_selection_by_function_completer);
2984 add_cmd ("level", class_stack, &frame_cmd.level,
2986 Select and print a stack frame by level.\n\
2988 Usage: frame level LEVEL"),
2991 cmd = add_prefix_cmd_suppress_notification ("select-frame", class_stack,
2992 &select_frame_cmd.base_command, _("\
2993 Select a stack frame without printing anything.\n\
2994 A single numerical argument specifies the frame to select."),
2995 &select_frame_cmd_list, "select-frame ", 1, &cmdlist,
2996 &cli_suppress_notification.user_selected_context);
2998 add_cmd_suppress_notification ("address", class_stack,
2999 &select_frame_cmd.address, _("\
3000 Select a stack frame by stack address.\n\
3002 Usage: select-frame address STACK-ADDRESS"),
3003 &select_frame_cmd_list,
3004 &cli_suppress_notification.user_selected_context);
3007 add_cmd_suppress_notification ("view", class_stack,
3008 &select_frame_cmd.view, _("\
3009 Select a stack frame that might be outside the current backtrace.\n\
3011 Usage: select-frame view STACK-ADDRESS\n\
3012 select-frame view STACK-ADDRESS PC-ADDRESS"),
3013 &select_frame_cmd_list,
3014 &cli_suppress_notification.user_selected_context);
3016 cmd = add_cmd_suppress_notification ("function", class_stack,
3017 &select_frame_cmd.function, _("\
3018 Select a stack frame by function name.\n\
3020 Usage: select-frame function NAME"),
3021 &select_frame_cmd_list,
3022 &cli_suppress_notification.user_selected_context);
3023 set_cmd_completer (cmd, frame_selection_by_function_completer);
3025 add_cmd_suppress_notification ("level", class_stack,
3026 &select_frame_cmd.level, _("\
3027 Select a stack frame by level.\n\
3029 Usage: select-frame level LEVEL"),
3030 &select_frame_cmd_list,
3031 &cli_suppress_notification.user_selected_context);
3033 add_com ("backtrace", class_stack, backtrace_command, _("\
3034 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3035 Usage: backtrace [QUALIFIERS]... [COUNT]\n\
3036 With a negative argument, print outermost -COUNT frames.\n\
3037 Use of the 'full' qualifier also prints the values of the local variables.\n\
3038 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
3039 on this backtrace."));
3040 add_com_alias ("bt", "backtrace", class_stack, 0);
3042 add_com_alias ("where", "backtrace", class_alias, 0);
3043 add_info ("stack", backtrace_command,
3044 _("Backtrace of the stack, or innermost COUNT frames."));
3045 add_info_alias ("s", "stack", 1);
3047 add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command,
3048 _("All about the selected stack frame.\n\
3049 With no arguments, displays information about the currently selected stack\n\
3050 frame. Alternatively a frame specification may be provided (See \"frame\")\n\
3051 the information is then printed about the specified frame."),
3052 &info_frame_cmd_list, "info frame ", 1, &infolist);
3053 add_info_alias ("f", "frame", 1);
3055 add_cmd ("address", class_stack, &info_frame_cmd.address,
3057 Print information about a stack frame selected by stack address.\n\
3059 Usage: info frame address STACK-ADDRESS"),
3060 &info_frame_cmd_list);
3062 add_cmd ("view", class_stack, &info_frame_cmd.view,
3064 Print information about a stack frame outside the current backtrace.\n\
3066 Usage: info frame view STACK-ADDRESS\n\
3067 info frame view STACK-ADDRESS PC-ADDRESS"),
3068 &info_frame_cmd_list);
3070 cmd = add_cmd ("function", class_stack, &info_frame_cmd.function,
3072 Print information about a stack frame selected by function name.\n\
3074 Usage: info frame function NAME"),
3075 &info_frame_cmd_list);
3076 set_cmd_completer (cmd, frame_selection_by_function_completer);
3078 add_cmd ("level", class_stack, &info_frame_cmd.level,
3080 Print information about a stack frame selected by level.\n\
3082 Usage: info frame level LEVEL"),
3083 &info_frame_cmd_list);
3085 add_info ("locals", info_locals_command,
3086 info_print_args_help (_("\
3087 All local variables of current stack frame or those matching REGEXPs.\n\
3088 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3089 Prints the local variables of the current stack frame.\n"),
3090 _("local variables")));
3091 add_info ("args", info_args_command,
3092 info_print_args_help (_("\
3093 All argument variables of current stack frame or those matching REGEXPs.\n\
3094 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3095 Prints the argument variables of the current stack frame.\n"),
3096 _("argument variables")));
3099 add_com ("func", class_stack, func_command, _("\
3100 Select the stack frame that contains NAME.\n\
3101 Usage: func NAME"));
3103 add_setshow_enum_cmd ("frame-arguments", class_stack,
3104 print_frame_arguments_choices, &print_frame_arguments,
3105 _("Set printing of non-scalar frame arguments"),
3106 _("Show printing of non-scalar frame arguments"),
3107 NULL, NULL, NULL, &setprintlist, &showprintlist);
3109 add_setshow_boolean_cmd ("frame-arguments", no_class,
3110 &print_raw_frame_arguments, _("\
3111 Set whether to print frame arguments in raw form."), _("\
3112 Show whether to print frame arguments in raw form."), _("\
3113 If set, frame arguments are printed in raw form, bypassing any\n\
3114 pretty-printers for that value."),
3116 &setprintrawlist, &showprintrawlist);
3118 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
3119 &disassemble_next_line, _("\
3120 Set whether to disassemble next source line or insn when execution stops."),
3122 Show whether to disassemble next source line or insn when execution stops."),
3124 If ON, GDB will display disassembly of the next source line, in addition\n\
3125 to displaying the source line itself. If the next source line cannot\n\
3126 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3127 will display disassembly of next instruction instead of showing the\n\
3129 If AUTO, display disassembly of next instruction only if the source line\n\
3130 cannot be displayed.\n\
3131 If OFF (which is the default), never display the disassembly of the next\n\
3134 show_disassemble_next_line,
3135 &setlist, &showlist);
3136 disassemble_next_line = AUTO_BOOLEAN_FALSE;
3138 add_setshow_enum_cmd ("entry-values", class_stack,
3139 print_entry_values_choices, &print_entry_values,
3140 _("Set printing of function arguments at function "
3142 _("Show printing of function arguments at function "
3145 GDB can sometimes determine the values of function arguments at entry,\n\
3146 in addition to their current values. This option tells GDB whether\n\
3147 to print the current value, the value at entry (marked as val@entry),\n\
3148 or both. Note that one or both of these values may be <optimized out>."),
3149 NULL, NULL, &setprintlist, &showprintlist);