1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
51 #include "safe-ctype.h"
53 #include "extension.h"
55 /* The possible choices of "set print frame-arguments", and the value
58 static const char *const print_frame_arguments_choices
[] =
59 {"all", "scalars", "none", NULL
};
60 static const char *print_frame_arguments
= "scalars";
62 /* If non-zero, don't invoke pretty-printers for frame arguments. */
63 static int print_raw_frame_arguments
;
65 /* The possible choices of "set print entry-values", and the value
68 const char print_entry_values_no
[] = "no";
69 const char print_entry_values_only
[] = "only";
70 const char print_entry_values_preferred
[] = "preferred";
71 const char print_entry_values_if_needed
[] = "if-needed";
72 const char print_entry_values_both
[] = "both";
73 const char print_entry_values_compact
[] = "compact";
74 const char print_entry_values_default
[] = "default";
75 static const char *const print_entry_values_choices
[] =
77 print_entry_values_no
,
78 print_entry_values_only
,
79 print_entry_values_preferred
,
80 print_entry_values_if_needed
,
81 print_entry_values_both
,
82 print_entry_values_compact
,
83 print_entry_values_default
,
86 const char *print_entry_values
= print_entry_values_default
;
88 /* Prototypes for local functions. */
90 static void print_frame_local_vars (struct frame_info
*, int,
93 static void print_frame (struct frame_info
*frame
, int print_level
,
94 enum print_what print_what
, int print_args
,
95 struct symtab_and_line sal
);
97 static void set_last_displayed_sal (int valid
,
98 struct program_space
*pspace
,
100 struct symtab
*symtab
,
103 /* Zero means do things normally; we are interacting directly with the
104 user. One means print the full filename and linenumber when a
105 frame is printed, and do so in a format emacs18/emacs19.22 can
106 parse. Two means print similar annotations, but in many more
107 cases and in a slightly different syntax. */
109 int annotation_level
= 0;
111 /* These variables hold the last symtab and line we displayed to the user.
112 * This is where we insert a breakpoint or a skiplist entry by default. */
113 static int last_displayed_sal_valid
= 0;
114 static struct program_space
*last_displayed_pspace
= 0;
115 static CORE_ADDR last_displayed_addr
= 0;
116 static struct symtab
*last_displayed_symtab
= 0;
117 static int last_displayed_line
= 0;
120 /* Return 1 if we should display the address in addition to the location,
121 because we are in the middle of a statement. */
124 frame_show_address (struct frame_info
*frame
,
125 struct symtab_and_line sal
)
127 /* If there is a line number, but no PC, then there is no location
128 information associated with this sal. The only way that should
129 happen is for the call sites of inlined functions (SAL comes from
130 find_frame_sal). Otherwise, we would have some PC range if the
131 SAL came from a line table. */
132 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
134 if (get_next_frame (frame
) == NULL
)
135 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
137 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
141 return get_frame_pc (frame
) != sal
.pc
;
144 /* Show or print a stack frame FRAME briefly. The output is formatted
145 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
146 relative level, function name, argument list, and file name and
147 line number. If the frame's PC is not at the beginning of the
148 source line, the actual PC is printed at the beginning. */
151 print_stack_frame (struct frame_info
*frame
, int print_level
,
152 enum print_what print_what
,
156 /* For mi, alway print location and address. */
157 if (ui_out_is_mi_like_p (current_uiout
))
158 print_what
= LOC_AND_ADDRESS
;
162 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
165 set_current_sal_from_frame (frame
);
167 CATCH (e
, RETURN_MASK_ERROR
)
173 /* Print nameless arguments of frame FRAME on STREAM, where START is
174 the offset of the first nameless argument, and NUM is the number of
175 nameless arguments to print. FIRST is nonzero if this is the first
176 argument (not just the first nameless argument). */
179 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
180 int first
, struct ui_file
*stream
)
182 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
183 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
188 for (i
= 0; i
< num
; i
++)
191 argsaddr
= get_frame_args_address (frame
);
194 arg_value
= read_memory_integer (argsaddr
+ start
,
195 sizeof (int), byte_order
);
197 fprintf_filtered (stream
, ", ");
198 fprintf_filtered (stream
, "%ld", arg_value
);
200 start
+= sizeof (int);
204 /* Print single argument of inferior function. ARG must be already
207 Errors are printed as if they would be the parameter value. Use zeroed ARG
208 iff it should not be printed accoring to user settings. */
211 print_frame_arg (const struct frame_arg
*arg
)
213 struct ui_out
*uiout
= current_uiout
;
214 struct cleanup
*old_chain
;
216 const char *error_message
= NULL
;
218 stb
= mem_fileopen ();
219 old_chain
= make_cleanup_ui_file_delete (stb
);
221 gdb_assert (!arg
->val
|| !arg
->error
);
222 gdb_assert (arg
->entry_kind
== print_entry_values_no
223 || arg
->entry_kind
== print_entry_values_only
224 || (!ui_out_is_mi_like_p (uiout
)
225 && arg
->entry_kind
== print_entry_values_compact
));
227 annotate_arg_begin ();
229 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
230 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
231 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
232 if (arg
->entry_kind
== print_entry_values_compact
)
234 /* It is OK to provide invalid MI-like stream as with
235 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
236 fputs_filtered ("=", stb
);
238 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
239 SYMBOL_LANGUAGE (arg
->sym
),
240 DMGL_PARAMS
| DMGL_ANSI
);
242 if (arg
->entry_kind
== print_entry_values_only
243 || arg
->entry_kind
== print_entry_values_compact
)
244 fputs_filtered ("@entry", stb
);
245 ui_out_field_stream (uiout
, "name", stb
);
246 annotate_arg_name_end ();
247 ui_out_text (uiout
, "=");
249 if (!arg
->val
&& !arg
->error
)
250 ui_out_text (uiout
, "...");
254 error_message
= arg
->error
;
259 const struct language_defn
*language
;
260 struct value_print_options opts
;
262 /* Avoid value_print because it will deref ref parameters. We
263 just want to print their addresses. Print ??? for args whose
264 address we do not know. We pass 2 as "recurse" to val_print
265 because our standard indentation here is 4 spaces, and
266 val_print indents 2 for each recurse. */
268 annotate_arg_value (value_type (arg
->val
));
270 /* Use the appropriate language to display our symbol, unless the
271 user forced the language to a specific language. */
272 if (language_mode
== language_mode_auto
)
273 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
275 language
= current_language
;
277 get_no_prettyformat_print_options (&opts
);
279 opts
.raw
= print_raw_frame_arguments
;
281 /* True in "summary" mode, false otherwise. */
282 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
284 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
286 CATCH (except
, RETURN_MASK_ERROR
)
288 error_message
= except
.message
;
292 if (error_message
!= NULL
)
293 fprintf_filtered (stb
, _("<error reading variable: %s>"),
297 ui_out_field_stream (uiout
, "value", stb
);
299 /* Also invoke ui_out_tuple_end. */
300 do_cleanups (old_chain
);
305 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
306 responsible for xfree of ARGP->ERROR. This function never throws an
310 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
311 struct frame_arg
*argp
)
313 struct value
*val
= NULL
;
321 argp
->val
= read_var_value (sym
, NULL
, frame
);
323 CATCH (except
, RETURN_MASK_ERROR
)
325 argp
->error
= xstrdup (except
.message
);
330 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
331 responsible for xfree of ARGP->ERROR. This function never throws an
335 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
336 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
338 struct value
*val
= NULL
, *entryval
= NULL
;
339 char *val_error
= NULL
, *entryval_error
= NULL
;
342 if (print_entry_values
!= print_entry_values_only
343 && print_entry_values
!= print_entry_values_preferred
)
347 val
= read_var_value (sym
, NULL
, frame
);
349 CATCH (except
, RETURN_MASK_ERROR
)
351 val_error
= (char *) alloca (strlen (except
.message
) + 1);
352 strcpy (val_error
, except
.message
);
357 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
358 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
359 && print_entry_values
!= print_entry_values_no
360 && (print_entry_values
!= print_entry_values_if_needed
361 || !val
|| value_optimized_out (val
)))
365 const struct symbol_computed_ops
*ops
;
367 ops
= SYMBOL_COMPUTED_OPS (sym
);
368 entryval
= ops
->read_variable_at_entry (sym
, frame
);
370 CATCH (except
, RETURN_MASK_ERROR
)
372 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
374 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
375 strcpy (entryval_error
, except
.message
);
380 if (entryval
!= NULL
&& value_optimized_out (entryval
))
383 if (print_entry_values
== print_entry_values_compact
384 || print_entry_values
== print_entry_values_default
)
386 /* For MI do not try to use print_entry_values_compact for ARGP. */
388 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
390 struct type
*type
= value_type (val
);
392 if (value_lazy (val
))
393 value_fetch_lazy (val
);
394 if (value_lazy (entryval
))
395 value_fetch_lazy (entryval
);
397 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
399 /* Initialize it just to avoid a GCC false warning. */
400 struct value
*val_deref
= NULL
, *entryval_deref
;
402 /* DW_AT_GNU_call_site_value does match with the current
403 value. If it is a reference still try to verify if
404 dereferenced DW_AT_GNU_call_site_data_value does not
409 struct type
*type_deref
;
411 val_deref
= coerce_ref (val
);
412 if (value_lazy (val_deref
))
413 value_fetch_lazy (val_deref
);
414 type_deref
= value_type (val_deref
);
416 entryval_deref
= coerce_ref (entryval
);
417 if (value_lazy (entryval_deref
))
418 value_fetch_lazy (entryval_deref
);
420 /* If the reference addresses match but dereferenced
421 content does not match print them. */
423 && value_contents_eq (val_deref
, 0,
425 TYPE_LENGTH (type_deref
)))
428 CATCH (except
, RETURN_MASK_ERROR
)
430 /* If the dereferenced content could not be
431 fetched do not display anything. */
432 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
434 else if (except
.message
!= NULL
)
436 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
437 strcpy (entryval_error
, except
.message
);
442 /* Value was not a reference; and its content matches. */
443 if (val
== val_deref
)
451 /* Try to remove possibly duplicate error message for ENTRYARGP even
454 if (val_error
&& entryval_error
455 && strcmp (val_error
, entryval_error
) == 0)
457 entryval_error
= NULL
;
459 /* Do not se VAL_EQUAL as the same error message may be shown for
460 the entry value even if no entry values are present in the
466 if (entryval
== NULL
)
468 if (print_entry_values
== print_entry_values_preferred
)
470 gdb_assert (val
== NULL
);
474 val
= read_var_value (sym
, NULL
, frame
);
476 CATCH (except
, RETURN_MASK_ERROR
)
478 val_error
= (char *) alloca (strlen (except
.message
) + 1);
479 strcpy (val_error
, except
.message
);
483 if (print_entry_values
== print_entry_values_only
484 || print_entry_values
== print_entry_values_both
485 || (print_entry_values
== print_entry_values_preferred
486 && (!val
|| value_optimized_out (val
))))
488 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
489 entryval_error
= NULL
;
492 if ((print_entry_values
== print_entry_values_compact
493 || print_entry_values
== print_entry_values_if_needed
494 || print_entry_values
== print_entry_values_preferred
)
495 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
503 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
504 if (!val
&& !val_error
)
505 argp
->entry_kind
= print_entry_values_only
;
506 else if ((print_entry_values
== print_entry_values_compact
507 || print_entry_values
== print_entry_values_default
) && val_equal
)
509 argp
->entry_kind
= print_entry_values_compact
;
510 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
513 argp
->entry_kind
= print_entry_values_no
;
515 entryargp
->sym
= sym
;
516 entryargp
->val
= entryval
;
517 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
518 if (!entryval
&& !entryval_error
)
519 entryargp
->entry_kind
= print_entry_values_no
;
521 entryargp
->entry_kind
= print_entry_values_only
;
524 /* Print the arguments of frame FRAME on STREAM, given the function
525 FUNC running in that frame (as a symbol), where NUM is the number
526 of arguments according to the stack frame (or -1 if the number of
527 arguments is unknown). */
529 /* Note that currently the "number of arguments according to the
530 stack frame" is only known on VAX where i refers to the "number of
531 ints of arguments according to the stack frame". */
534 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
535 int num
, struct ui_file
*stream
)
537 struct ui_out
*uiout
= current_uiout
;
539 /* Offset of next stack argument beyond the one we have seen that is
540 at the highest offset, or -1 if we haven't come to a stack
542 long highest_offset
= -1;
543 /* Number of ints of arguments that we have printed so far. */
544 int args_printed
= 0;
545 struct cleanup
*old_chain
;
547 /* True if we should print arguments, false otherwise. */
548 int print_args
= strcmp (print_frame_arguments
, "none");
550 stb
= mem_fileopen ();
551 old_chain
= make_cleanup_ui_file_delete (stb
);
555 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
556 struct block_iterator iter
;
559 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
561 struct frame_arg arg
, entryarg
;
565 /* Keep track of the highest stack argument offset seen, and
566 skip over any kinds of symbols we don't care about. */
568 if (!SYMBOL_IS_ARGUMENT (sym
))
571 switch (SYMBOL_CLASS (sym
))
576 long current_offset
= SYMBOL_VALUE (sym
);
577 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
579 /* Compute address of next argument by adding the size of
580 this argument and rounding to an int boundary. */
582 ((current_offset
+ arg_size
+ sizeof (int) - 1)
583 & ~(sizeof (int) - 1));
585 /* If this is the highest offset seen yet, set
587 if (highest_offset
== -1
588 || (current_offset
> highest_offset
))
589 highest_offset
= current_offset
;
591 /* Add the number of ints we're about to print to
593 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
596 /* We care about types of symbols, but don't need to
597 keep track of stack offsets in them. */
599 case LOC_REGPARM_ADDR
:
601 case LOC_OPTIMIZED_OUT
:
606 /* We have to look up the symbol because arguments can have
607 two entries (one a parameter, one a local) and the one we
608 want is the local, which lookup_symbol will find for us.
609 This includes gcc1 (not gcc2) on SPARC when passing a
610 small structure and gcc2 when the argument type is float
611 and it is passed as a double and converted to float by
612 the prologue (in the latter case the type of the LOC_ARG
613 symbol is double and the type of the LOC_LOCAL symbol is
615 /* But if the parameter name is null, don't try it. Null
616 parameter names occur on the RS/6000, for traceback
617 tables. FIXME, should we even print them? */
619 if (*SYMBOL_LINKAGE_NAME (sym
))
623 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
624 b
, VAR_DOMAIN
, NULL
).symbol
;
625 gdb_assert (nsym
!= NULL
);
626 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
627 && !SYMBOL_IS_ARGUMENT (nsym
))
629 /* There is a LOC_ARG/LOC_REGISTER pair. This means
630 that it was passed on the stack and loaded into a
631 register, or passed in a register and stored in a
632 stack slot. GDB 3.x used the LOC_ARG; GDB
633 4.0-4.11 used the LOC_REGISTER.
635 Reasons for using the LOC_ARG:
637 (1) Because find_saved_registers may be slow for
640 (2) Because registers are often re-used and stack
641 slots rarely (never?) are. Therefore using
642 the stack slot is much less likely to print
645 Reasons why we might want to use the LOC_REGISTER:
647 (1) So that the backtrace prints the same value
648 as "print foo". I see no compelling reason
649 why this needs to be the case; having the
650 backtrace print the value which was passed
651 in, and "print foo" print the value as
652 modified within the called function, makes
655 Additional note: It might be nice if "info args"
656 displayed both values.
658 One more note: There is a case with SPARC
659 structure passing where we need to use the
660 LOC_REGISTER, but this is dealt with by creating
661 a single LOC_REGPARM in symbol reading. */
663 /* Leave sym (the LOC_ARG) alone. */
670 /* Print the current arg. */
672 ui_out_text (uiout
, ", ");
673 ui_out_wrap_hint (uiout
, " ");
677 memset (&arg
, 0, sizeof (arg
));
679 arg
.entry_kind
= print_entry_values_no
;
680 memset (&entryarg
, 0, sizeof (entryarg
));
682 entryarg
.entry_kind
= print_entry_values_no
;
685 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
687 if (arg
.entry_kind
!= print_entry_values_only
)
688 print_frame_arg (&arg
);
690 if (entryarg
.entry_kind
!= print_entry_values_no
)
692 if (arg
.entry_kind
!= print_entry_values_only
)
694 ui_out_text (uiout
, ", ");
695 ui_out_wrap_hint (uiout
, " ");
698 print_frame_arg (&entryarg
);
702 xfree (entryarg
.error
);
708 /* Don't print nameless args in situations where we don't know
709 enough about the stack to find them. */
714 if (highest_offset
== -1)
715 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
717 start
= highest_offset
;
719 print_frame_nameless_args (frame
, start
, num
- args_printed
,
723 do_cleanups (old_chain
);
726 /* Set the current source and line to the location given by frame
727 FRAME, if possible. When CENTER is true, adjust so the relevant
728 line is in the center of the next 'list'. */
731 set_current_sal_from_frame (struct frame_info
*frame
)
733 struct symtab_and_line sal
;
735 find_frame_sal (frame
, &sal
);
736 if (sal
.symtab
!= NULL
)
737 set_current_source_symtab_and_line (&sal
);
740 /* If ON, GDB will display disassembly of the next source line when
741 execution of the program being debugged stops.
742 If AUTO (which is the default), or there's no line info to determine
743 the source line of the next instruction, display disassembly of next
744 instruction instead. */
746 static enum auto_boolean disassemble_next_line
;
749 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
750 struct cmd_list_element
*c
,
753 fprintf_filtered (file
,
754 _("Debugger's willingness to use "
755 "disassemble-next-line is %s.\n"),
759 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
760 because it will be broken by filter sometime. */
763 do_gdb_disassembly (struct gdbarch
*gdbarch
,
764 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
769 gdb_disassembly (gdbarch
, current_uiout
, 0,
770 DISASSEMBLY_RAW_INSN
, how_many
,
773 CATCH (exception
, RETURN_MASK_ERROR
)
775 /* If an exception was thrown while doing the disassembly, print
776 the error message, to give the user a clue of what happened. */
777 exception_print (gdb_stderr
, exception
);
782 /* Print information about frame FRAME. The output is format according
783 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
786 SRC_LINE: Print only source line.
787 LOCATION: Print only location.
788 LOC_AND_SRC: Print location and source line.
790 Used in "where" output, and to emit breakpoint or step
794 print_frame_info (struct frame_info
*frame
, int print_level
,
795 enum print_what print_what
, int print_args
,
798 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
799 struct symtab_and_line sal
;
802 struct ui_out
*uiout
= current_uiout
;
804 if (get_frame_type (frame
) == DUMMY_FRAME
805 || get_frame_type (frame
) == SIGTRAMP_FRAME
806 || get_frame_type (frame
) == ARCH_FRAME
)
808 struct cleanup
*uiout_cleanup
809 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
811 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
812 gdbarch
, get_frame_pc (frame
));
814 /* Do this regardless of SOURCE because we don't have any source
815 to list for this frame. */
818 ui_out_text (uiout
, "#");
819 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
820 frame_relative_level (frame
));
822 if (ui_out_is_mi_like_p (uiout
))
824 annotate_frame_address ();
825 ui_out_field_core_addr (uiout
, "addr",
826 gdbarch
, get_frame_pc (frame
));
827 annotate_frame_address_end ();
830 if (get_frame_type (frame
) == DUMMY_FRAME
)
832 annotate_function_call ();
833 ui_out_field_string (uiout
, "func", "<function called from gdb>");
835 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
837 annotate_signal_handler_caller ();
838 ui_out_field_string (uiout
, "func", "<signal handler called>");
840 else if (get_frame_type (frame
) == ARCH_FRAME
)
842 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
844 ui_out_text (uiout
, "\n");
845 annotate_frame_end ();
847 /* If disassemble-next-line is set to auto or on output the next
849 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
850 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
851 do_gdb_disassembly (get_frame_arch (frame
), 1,
852 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
854 do_cleanups (uiout_cleanup
);
858 /* If FRAME is not the innermost frame, that normally means that
859 FRAME->pc points to *after* the call instruction, and we want to
860 get the line containing the call, never the next line. But if
861 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
862 next frame was not entered as the result of a call, and we want
863 to get the line containing FRAME->pc. */
864 find_frame_sal (frame
, &sal
);
866 location_print
= (print_what
== LOCATION
867 || print_what
== LOC_AND_ADDRESS
868 || print_what
== SRC_AND_LOC
);
870 if (location_print
|| !sal
.symtab
)
871 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
873 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
875 /* If disassemble-next-line is set to auto or on and doesn't have
876 the line debug messages for $pc, output the next instruction. */
877 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
878 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
879 && source_print
&& !sal
.symtab
)
880 do_gdb_disassembly (get_frame_arch (frame
), 1,
881 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
883 if (source_print
&& sal
.symtab
)
886 int mid_statement
= ((print_what
== SRC_LINE
)
887 && frame_show_address (frame
, sal
));
889 if (annotation_level
)
890 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
891 get_frame_pc (frame
));
894 if (deprecated_print_frame_info_listing_hook
)
895 deprecated_print_frame_info_listing_hook (sal
.symtab
,
900 struct value_print_options opts
;
902 get_user_print_options (&opts
);
903 /* We used to do this earlier, but that is clearly
904 wrong. This function is used by many different
905 parts of gdb, including normal_stop in infrun.c,
906 which uses this to print out the current PC
907 when we stepi/nexti into the middle of a source
908 line. Only the command line really wants this
909 behavior. Other UIs probably would like the
910 ability to decide for themselves if it is desired. */
911 if (opts
.addressprint
&& mid_statement
)
913 ui_out_field_core_addr (uiout
, "addr",
914 gdbarch
, get_frame_pc (frame
));
915 ui_out_text (uiout
, "\t");
918 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
922 /* If disassemble-next-line is set to on and there is line debug
923 messages, output assembly codes for next line. */
924 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
925 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
932 if (get_frame_pc_if_available (frame
, &pc
))
933 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
935 set_last_displayed_sal (0, 0, 0, 0, 0);
938 annotate_frame_end ();
940 gdb_flush (gdb_stdout
);
943 /* Remember the last symtab and line we displayed, which we use e.g.
944 * as the place to put a breakpoint when the `break' command is
945 * invoked with no arguments. */
948 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
949 CORE_ADDR addr
, struct symtab
*symtab
,
952 last_displayed_sal_valid
= valid
;
953 last_displayed_pspace
= pspace
;
954 last_displayed_addr
= addr
;
955 last_displayed_symtab
= symtab
;
956 last_displayed_line
= line
;
957 if (valid
&& pspace
== NULL
)
959 clear_last_displayed_sal ();
960 internal_error (__FILE__
, __LINE__
,
961 _("Trying to set NULL pspace."));
965 /* Forget the last sal we displayed. */
968 clear_last_displayed_sal (void)
970 last_displayed_sal_valid
= 0;
971 last_displayed_pspace
= 0;
972 last_displayed_addr
= 0;
973 last_displayed_symtab
= 0;
974 last_displayed_line
= 0;
977 /* Is our record of the last sal we displayed valid? If not,
978 * the get_last_displayed_* functions will return NULL or 0, as
982 last_displayed_sal_is_valid (void)
984 return last_displayed_sal_valid
;
987 /* Get the pspace of the last sal we displayed, if it's valid. */
989 struct program_space
*
990 get_last_displayed_pspace (void)
992 if (last_displayed_sal_valid
)
993 return last_displayed_pspace
;
997 /* Get the address of the last sal we displayed, if it's valid. */
1000 get_last_displayed_addr (void)
1002 if (last_displayed_sal_valid
)
1003 return last_displayed_addr
;
1007 /* Get the symtab of the last sal we displayed, if it's valid. */
1010 get_last_displayed_symtab (void)
1012 if (last_displayed_sal_valid
)
1013 return last_displayed_symtab
;
1017 /* Get the line of the last sal we displayed, if it's valid. */
1020 get_last_displayed_line (void)
1022 if (last_displayed_sal_valid
)
1023 return last_displayed_line
;
1027 /* Get the last sal we displayed, if it's valid. */
1030 get_last_displayed_sal (struct symtab_and_line
*sal
)
1032 if (last_displayed_sal_valid
)
1034 sal
->pspace
= last_displayed_pspace
;
1035 sal
->pc
= last_displayed_addr
;
1036 sal
->symtab
= last_displayed_symtab
;
1037 sal
->line
= last_displayed_line
;
1049 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1050 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1053 find_frame_funname (struct frame_info
*frame
, char **funname
,
1054 enum language
*funlang
, struct symbol
**funcp
)
1056 struct symbol
*func
;
1059 *funlang
= language_unknown
;
1063 func
= get_frame_function (frame
);
1066 /* In certain pathological cases, the symtabs give the wrong
1067 function (when we are in the first function in a file which
1068 is compiled without debugging symbols, the previous function
1069 is compiled with debugging symbols, and the "foo.o" symbol
1070 that is supposed to tell us where the file with debugging
1071 symbols ends has been truncated by ar because it is longer
1072 than 15 characters). This also occurs if the user uses asm()
1073 to create a function but not stabs for it (in a file compiled
1076 So look in the minimal symbol tables as well, and if it comes
1077 up with a larger address for the function use that instead.
1078 I don't think this can ever cause any problems; there
1079 shouldn't be any minimal symbols in the middle of a function;
1080 if this is ever changed many parts of GDB will need to be
1081 changed (and we'll create a find_pc_minimal_function or some
1084 struct bound_minimal_symbol msymbol
;
1086 /* Don't attempt to do this for inlined functions, which do not
1087 have a corresponding minimal symbol. */
1088 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1090 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1092 memset (&msymbol
, 0, sizeof (msymbol
));
1094 if (msymbol
.minsym
!= NULL
1095 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1096 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1098 /* We also don't know anything about the function besides
1099 its address and name. */
1101 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1102 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1106 *funname
= xstrdup (SYMBOL_PRINT_NAME (func
));
1107 *funlang
= SYMBOL_LANGUAGE (func
);
1110 if (*funlang
== language_cplus
)
1112 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1113 to display the demangled name that we already have
1114 stored in the symbol table, but we stored a version
1115 with DMGL_PARAMS turned on, and here we don't want to
1116 display parameters. So remove the parameters. */
1117 char *func_only
= cp_remove_params (*funname
);
1122 *funname
= func_only
;
1129 struct bound_minimal_symbol msymbol
;
1132 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1135 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1136 if (msymbol
.minsym
!= NULL
)
1138 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1139 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1145 print_frame (struct frame_info
*frame
, int print_level
,
1146 enum print_what print_what
, int print_args
,
1147 struct symtab_and_line sal
)
1149 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1150 struct ui_out
*uiout
= current_uiout
;
1151 char *funname
= NULL
;
1152 enum language funlang
= language_unknown
;
1153 struct ui_file
*stb
;
1154 struct cleanup
*old_chain
, *list_chain
;
1155 struct value_print_options opts
;
1156 struct symbol
*func
;
1160 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1162 stb
= mem_fileopen ();
1163 old_chain
= make_cleanup_ui_file_delete (stb
);
1165 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1166 make_cleanup (xfree
, funname
);
1168 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1171 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1175 ui_out_text (uiout
, "#");
1176 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1177 frame_relative_level (frame
));
1179 get_user_print_options (&opts
);
1180 if (opts
.addressprint
)
1182 || frame_show_address (frame
, sal
)
1183 || print_what
== LOC_AND_ADDRESS
)
1185 annotate_frame_address ();
1187 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1189 ui_out_field_string (uiout
, "addr", "<unavailable>");
1190 annotate_frame_address_end ();
1191 ui_out_text (uiout
, " in ");
1193 annotate_frame_function_name ();
1194 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1195 funlang
, DMGL_ANSI
);
1196 ui_out_field_stream (uiout
, "func", stb
);
1197 ui_out_wrap_hint (uiout
, " ");
1198 annotate_frame_args ();
1200 ui_out_text (uiout
, " (");
1203 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1205 struct cleanup
*args_list_chain
;
1207 if (gdbarch_frame_num_args_p (gdbarch
))
1209 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1210 gdb_assert (numargs
>= 0);
1215 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1218 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1220 CATCH (e
, RETURN_MASK_ERROR
)
1225 /* FIXME: ARGS must be a list. If one argument is a string it
1226 will have " that will not be properly escaped. */
1227 /* Invoke ui_out_tuple_end. */
1228 do_cleanups (args_list_chain
);
1231 ui_out_text (uiout
, ")");
1234 const char *filename_display
;
1236 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1237 annotate_frame_source_begin ();
1238 ui_out_wrap_hint (uiout
, " ");
1239 ui_out_text (uiout
, " at ");
1240 annotate_frame_source_file ();
1241 ui_out_field_string (uiout
, "file", filename_display
);
1242 if (ui_out_is_mi_like_p (uiout
))
1244 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1246 ui_out_field_string (uiout
, "fullname", fullname
);
1248 annotate_frame_source_file_end ();
1249 ui_out_text (uiout
, ":");
1250 annotate_frame_source_line ();
1251 ui_out_field_int (uiout
, "line", sal
.line
);
1252 annotate_frame_source_end ();
1255 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1257 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1258 get_frame_pc (frame
));
1262 annotate_frame_where ();
1263 ui_out_wrap_hint (uiout
, " ");
1264 ui_out_text (uiout
, " from ");
1265 ui_out_field_string (uiout
, "from", lib
);
1269 /* do_cleanups will call ui_out_tuple_end() for us. */
1270 do_cleanups (list_chain
);
1271 ui_out_text (uiout
, "\n");
1272 do_cleanups (old_chain
);
1276 /* Read a frame specification in whatever the appropriate format is
1277 from FRAME_EXP. Call error(), printing MESSAGE, if the
1278 specification is in any way invalid (so this function never returns
1279 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1280 the default selected frame was used. */
1282 static struct frame_info
*
1283 parse_frame_specification (const char *frame_exp
, const char *message
,
1284 int *selected_frame_p
)
1287 struct value
*args
[4];
1288 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1290 if (frame_exp
== NULL
)
1298 struct cleanup
*cleanup
;
1301 /* Skip leading white space, bail of EOL. */
1302 frame_exp
= skip_spaces_const (frame_exp
);
1306 /* Parse the argument, extract it, save it. */
1308 *p
&& !ISSPACE (*p
);
1310 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1312 cleanup
= make_cleanup (xfree
, addr_string
);
1314 /* NOTE: Parse and evaluate expression, but do not use
1315 functions such as parse_and_eval_long or
1316 parse_and_eval_address to also extract the value.
1317 Instead value_as_long and value_as_address are used.
1318 This avoids problems with expressions that contain
1320 if (numargs
>= ARRAY_SIZE (args
))
1321 error (_("Too many args in frame specification"));
1322 args
[numargs
++] = parse_and_eval (addr_string
);
1324 do_cleanups (cleanup
);
1328 /* If no args, default to the selected frame. */
1331 if (selected_frame_p
!= NULL
)
1332 (*selected_frame_p
) = 1;
1333 return get_selected_frame (message
);
1336 /* None of the remaining use the selected frame. */
1337 if (selected_frame_p
!= NULL
)
1338 (*selected_frame_p
) = 0;
1340 /* Assume the single arg[0] is an integer, and try using that to
1341 select a frame relative to current. */
1344 struct frame_info
*fid
;
1345 int level
= value_as_long (args
[0]);
1347 fid
= find_relative_frame (get_current_frame (), &level
);
1349 /* find_relative_frame was successful. */
1353 /* Convert each value into a corresponding address. */
1357 for (i
= 0; i
< numargs
; i
++)
1358 addrs
[i
] = value_as_address (args
[i
]);
1361 /* Assume that the single arg[0] is an address, use that to identify
1362 a frame with a matching ID. Should this also accept stack/pc or
1363 stack/pc/special. */
1366 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1367 struct frame_info
*fid
;
1369 /* If (s)he specifies the frame with an address, he deserves
1370 what (s)he gets. Still, give the highest one that matches.
1371 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1373 for (fid
= get_current_frame ();
1375 fid
= get_prev_frame (fid
))
1377 if (frame_id_eq (id
, get_frame_id (fid
)))
1379 struct frame_info
*prev_frame
;
1383 prev_frame
= get_prev_frame (fid
);
1385 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1394 /* We couldn't identify the frame as an existing frame, but
1395 perhaps we can create one with a single argument. */
1397 return create_new_frame (addrs
[0], 0);
1398 else if (numargs
== 2)
1399 return create_new_frame (addrs
[0], addrs
[1]);
1401 error (_("Too many args in frame specification"));
1404 /* Print verbosely the selected frame or the frame at address
1405 ADDR_EXP. Absolutely all information in the frame is printed. */
1408 frame_info (char *addr_exp
, int from_tty
)
1410 struct frame_info
*fi
;
1411 struct symtab_and_line sal
;
1412 struct symbol
*func
;
1414 struct frame_info
*calling_frame_info
;
1416 const char *funname
= 0;
1417 enum language funlang
= language_unknown
;
1418 const char *pc_regname
;
1419 int selected_frame_p
;
1420 struct gdbarch
*gdbarch
;
1421 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1424 /* Initialize it to avoid "may be used uninitialized" warning. */
1425 CORE_ADDR caller_pc
= 0;
1426 int caller_pc_p
= 0;
1428 fi
= parse_frame_specification (addr_exp
, "No stack.", &selected_frame_p
);
1429 gdbarch
= get_frame_arch (fi
);
1431 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1432 is not a good name. */
1433 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1434 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1435 easily not match that of the internal value returned by
1437 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1439 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1440 architectures will often have a hardware register called "pc",
1441 and that register's value, again, can easily not match
1445 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1446 find_frame_sal (fi
, &sal
);
1447 func
= get_frame_function (fi
);
1451 funname
= SYMBOL_PRINT_NAME (func
);
1452 funlang
= SYMBOL_LANGUAGE (func
);
1453 if (funlang
== language_cplus
)
1455 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1456 to display the demangled name that we already have
1457 stored in the symbol table, but we stored a version
1458 with DMGL_PARAMS turned on, and here we don't want to
1459 display parameters. So remove the parameters. */
1460 char *func_only
= cp_remove_params (funname
);
1464 funname
= func_only
;
1465 make_cleanup (xfree
, func_only
);
1469 else if (frame_pc_p
)
1471 struct bound_minimal_symbol msymbol
;
1473 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1474 if (msymbol
.minsym
!= NULL
)
1476 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1477 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1480 calling_frame_info
= get_prev_frame (fi
);
1482 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1484 printf_filtered (_("Stack level %d, frame at "),
1485 frame_relative_level (fi
));
1489 printf_filtered (_("Stack frame at "));
1491 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1492 printf_filtered (":\n");
1493 printf_filtered (" %s = ", pc_regname
);
1495 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1497 fputs_filtered ("<unavailable>", gdb_stdout
);
1502 printf_filtered (" in ");
1503 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1504 DMGL_ANSI
| DMGL_PARAMS
);
1508 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1510 puts_filtered ("; ");
1512 printf_filtered ("saved %s = ", pc_regname
);
1516 caller_pc
= frame_unwind_caller_pc (fi
);
1519 CATCH (ex
, RETURN_MASK_ERROR
)
1523 case NOT_AVAILABLE_ERROR
:
1524 val_print_unavailable (gdb_stdout
);
1526 case OPTIMIZED_OUT_ERROR
:
1527 val_print_not_saved (gdb_stdout
);
1530 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1537 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1538 printf_filtered ("\n");
1540 if (calling_frame_info
== NULL
)
1542 enum unwind_stop_reason reason
;
1544 reason
= get_frame_unwind_stop_reason (fi
);
1545 if (reason
!= UNWIND_NO_REASON
)
1546 printf_filtered (_(" Outermost frame: %s\n"),
1547 frame_stop_reason_string (fi
));
1549 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1550 puts_filtered (" tail call frame");
1551 else if (get_frame_type (fi
) == INLINE_FRAME
)
1552 printf_filtered (" inlined into frame %d",
1553 frame_relative_level (get_prev_frame (fi
)));
1556 printf_filtered (" called by frame at ");
1557 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1560 if (get_next_frame (fi
) && calling_frame_info
)
1561 puts_filtered (",");
1563 if (get_next_frame (fi
))
1565 printf_filtered (" caller of frame at ");
1566 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1569 if (get_next_frame (fi
) || calling_frame_info
)
1570 puts_filtered ("\n");
1573 printf_filtered (" source language %s.\n",
1574 language_str (s
->language
));
1577 /* Address of the argument list for this frame, or 0. */
1578 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1579 /* Number of args for this frame, or -1 if unknown. */
1583 printf_filtered (" Arglist at unknown address.\n");
1586 printf_filtered (" Arglist at ");
1587 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1588 printf_filtered (",");
1590 if (!gdbarch_frame_num_args_p (gdbarch
))
1593 puts_filtered (" args: ");
1597 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1598 gdb_assert (numargs
>= 0);
1600 puts_filtered (" no args.");
1601 else if (numargs
== 1)
1602 puts_filtered (" 1 arg: ");
1604 printf_filtered (" %d args: ", numargs
);
1606 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1607 puts_filtered ("\n");
1611 /* Address of the local variables for this frame, or 0. */
1612 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1615 printf_filtered (" Locals at unknown address,");
1618 printf_filtered (" Locals at ");
1619 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1620 printf_filtered (",");
1624 /* Print as much information as possible on the location of all the
1627 enum lval_type lval
;
1636 /* The sp is special; what's displayed isn't the save address, but
1637 the value of the previous frame's sp. This is a legacy thing,
1638 at one stage the frame cached the previous frame's SP instead
1639 of its address, hence it was easiest to just display the cached
1641 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1643 /* Find out the location of the saved stack pointer with out
1644 actually evaluating it. */
1645 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1646 &optimized
, &unavailable
, &lval
, &addr
,
1648 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1650 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1651 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1652 gdb_byte value
[MAX_REGISTER_SIZE
];
1655 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1656 &optimized
, &unavailable
, &lval
, &addr
,
1658 /* NOTE: cagney/2003-05-22: This is assuming that the
1659 stack pointer was packed as an unsigned integer. That
1660 may or may not be valid. */
1661 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1662 printf_filtered (" Previous frame's sp is ");
1663 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1664 printf_filtered ("\n");
1667 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1669 printf_filtered (" Previous frame's sp at ");
1670 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1671 printf_filtered ("\n");
1674 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1676 printf_filtered (" Previous frame's sp in %s\n",
1677 gdbarch_register_name (gdbarch
, realnum
));
1680 /* else keep quiet. */
1684 numregs
= gdbarch_num_regs (gdbarch
)
1685 + gdbarch_num_pseudo_regs (gdbarch
);
1686 for (i
= 0; i
< numregs
; i
++)
1687 if (i
!= gdbarch_sp_regnum (gdbarch
)
1688 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1690 /* Find out the location of the saved register without
1691 fetching the corresponding value. */
1692 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1693 &lval
, &addr
, &realnum
, NULL
);
1694 /* For moment, only display registers that were saved on the
1696 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1699 puts_filtered (" Saved registers:\n ");
1701 puts_filtered (",");
1703 printf_filtered (" %s at ",
1704 gdbarch_register_name (gdbarch
, i
));
1705 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1709 if (count
|| need_nl
)
1710 puts_filtered ("\n");
1713 do_cleanups (back_to
);
1716 /* Print briefly all stack frames or just the innermost COUNT_EXP
1720 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1723 struct frame_info
*fi
;
1726 struct frame_info
*trailing
;
1727 int trailing_level
, py_start
= 0, py_end
= 0;
1728 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1730 if (!target_has_stack
)
1731 error (_("No stack."));
1733 /* The following code must do two things. First, it must set the
1734 variable TRAILING to the frame from which we should start
1735 printing. Second, it must set the variable count to the number
1736 of frames which we should print, or -1 if all of them. */
1737 trailing
= get_current_frame ();
1742 count
= parse_and_eval_long (count_exp
);
1745 struct frame_info
*current
;
1751 while (current
&& count
--)
1754 current
= get_prev_frame (current
);
1757 /* Will stop when CURRENT reaches the top of the stack.
1758 TRAILING will be COUNT below it. */
1762 trailing
= get_prev_frame (trailing
);
1763 current
= get_prev_frame (current
);
1783 /* Read in symbols for all of the frames. Need to do this in a
1784 separate pass so that "Reading in symbols for xxx" messages
1785 don't screw up the appearance of the backtrace. Also if
1786 people have strong opinions against reading symbols for
1787 backtrace this may have to be an option. */
1789 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1794 pc
= get_frame_address_in_block (fi
);
1795 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1801 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1802 enum ext_lang_frame_args arg_type
;
1805 flags
|= PRINT_LOCALS
;
1807 if (!strcmp (print_frame_arguments
, "scalars"))
1808 arg_type
= CLI_SCALAR_VALUES
;
1809 else if (!strcmp (print_frame_arguments
, "all"))
1810 arg_type
= CLI_ALL_VALUES
;
1812 arg_type
= NO_VALUES
;
1814 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1815 arg_type
, current_uiout
,
1819 /* Run the inbuilt backtrace if there are no filters registered, or
1820 "no-filters" has been specified from the command. */
1821 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1823 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1827 /* Don't use print_stack_frame; if an error() occurs it probably
1828 means further attempts to backtrace would fail (on the other
1829 hand, perhaps the code does or could be fixed to make sure
1830 the frame->prev field gets set to NULL in that case). */
1832 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1835 struct frame_id frame_id
= get_frame_id (fi
);
1837 print_frame_local_vars (fi
, 1, gdb_stdout
);
1839 /* print_frame_local_vars invalidates FI. */
1840 fi
= frame_find_by_id (frame_id
);
1844 warning (_("Unable to restore previously selected frame."));
1849 /* Save the last frame to check for error conditions. */
1853 /* If we've stopped before the end, mention that. */
1855 printf_filtered (_("(More stack frames follow...)\n"));
1857 /* If we've run out of frames, and the reason appears to be an error
1858 condition, print it. */
1859 if (fi
== NULL
&& trailing
!= NULL
)
1861 enum unwind_stop_reason reason
;
1863 reason
= get_frame_unwind_stop_reason (trailing
);
1864 if (reason
>= UNWIND_FIRST_ERROR
)
1865 printf_filtered (_("Backtrace stopped: %s\n"),
1866 frame_stop_reason_string (trailing
));
1872 backtrace_command (char *arg
, int from_tty
)
1874 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1875 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1883 argv
= gdb_buildargv (arg
);
1884 make_cleanup_freeargv (argv
);
1886 for (i
= 0; argv
[i
]; i
++)
1890 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1891 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1893 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1897 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1898 fulltrace_arg
= argc
;
1902 arglen
+= strlen (argv
[i
]);
1908 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1912 arg
= (char *) xmalloc (arglen
+ 1);
1913 make_cleanup (xfree
, arg
);
1915 for (i
= 0; i
< argc
; i
++)
1917 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1919 strcat (arg
, argv
[i
]);
1929 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1930 no_filters
>= 0 /* no frame-filters */, from_tty
);
1932 do_cleanups (old_chain
);
1935 /* Iterate over the local variables of a block B, calling CB with
1939 iterate_over_block_locals (const struct block
*b
,
1940 iterate_over_block_arg_local_vars_cb cb
,
1943 struct block_iterator iter
;
1946 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1948 switch (SYMBOL_CLASS (sym
))
1954 if (SYMBOL_IS_ARGUMENT (sym
))
1956 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1958 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1962 /* Ignore symbols which are not locals. */
1969 /* Same, but print labels. */
1972 /* Commented out, as the code using this function has also been
1973 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1974 was commented out in the first place. The discussion introducing
1975 this change (2007-12-04: Support lexical blocks and function bodies
1976 that occupy non-contiguous address ranges) did not explain why
1977 this change was made. */
1979 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1980 int *have_default
, struct ui_file
*stream
)
1982 struct block_iterator iter
;
1984 int values_printed
= 0;
1986 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1988 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1994 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1996 struct symtab_and_line sal
;
1997 struct value_print_options opts
;
1999 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2001 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2002 get_user_print_options (&opts
);
2003 if (opts
.addressprint
)
2005 fprintf_filtered (stream
, " ");
2006 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2009 fprintf_filtered (stream
, " in file %s, line %d\n",
2010 sal
.symtab
->filename
, sal
.line
);
2014 return values_printed
;
2018 /* Iterate over all the local variables in block B, including all its
2019 superblocks, stopping when the top-level block is reached. */
2022 iterate_over_block_local_vars (const struct block
*block
,
2023 iterate_over_block_arg_local_vars_cb cb
,
2028 iterate_over_block_locals (block
, cb
, cb_data
);
2029 /* After handling the function's top-level block, stop. Don't
2030 continue to its superblock, the block of per-file
2032 if (BLOCK_FUNCTION (block
))
2034 block
= BLOCK_SUPERBLOCK (block
);
2038 /* Data to be passed around in the calls to the locals and args
2041 struct print_variable_and_value_data
2043 struct frame_id frame_id
;
2045 struct ui_file
*stream
;
2049 /* The callback for the locals and args iterators. */
2052 do_print_variable_and_value (const char *print_name
,
2056 struct print_variable_and_value_data
*p
2057 = (struct print_variable_and_value_data
*) cb_data
;
2058 struct frame_info
*frame
;
2060 frame
= frame_find_by_id (p
->frame_id
);
2063 warning (_("Unable to restore previously selected frame."));
2067 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2069 /* print_variable_and_value invalidates FRAME. */
2072 p
->values_printed
= 1;
2075 /* Print all variables from the innermost up to the function block of FRAME.
2076 Print them with values to STREAM indented by NUM_TABS.
2078 This function will invalidate FRAME. */
2081 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2082 struct ui_file
*stream
)
2084 struct print_variable_and_value_data cb_data
;
2085 const struct block
*block
;
2088 if (!get_frame_pc_if_available (frame
, &pc
))
2090 fprintf_filtered (stream
,
2091 _("PC unavailable, cannot determine locals.\n"));
2095 block
= get_frame_block (frame
, 0);
2098 fprintf_filtered (stream
, "No symbol table info available.\n");
2102 cb_data
.frame_id
= get_frame_id (frame
);
2103 cb_data
.num_tabs
= 4 * num_tabs
;
2104 cb_data
.stream
= stream
;
2105 cb_data
.values_printed
= 0;
2107 iterate_over_block_local_vars (block
,
2108 do_print_variable_and_value
,
2111 /* do_print_variable_and_value invalidates FRAME. */
2114 if (!cb_data
.values_printed
)
2115 fprintf_filtered (stream
, _("No locals.\n"));
2119 locals_info (char *args
, int from_tty
)
2121 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2125 /* Iterate over all the argument variables in block B.
2127 Returns 1 if any argument was walked; 0 otherwise. */
2130 iterate_over_block_arg_vars (const struct block
*b
,
2131 iterate_over_block_arg_local_vars_cb cb
,
2134 struct block_iterator iter
;
2135 struct symbol
*sym
, *sym2
;
2137 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2139 /* Don't worry about things which aren't arguments. */
2140 if (SYMBOL_IS_ARGUMENT (sym
))
2142 /* We have to look up the symbol because arguments can have
2143 two entries (one a parameter, one a local) and the one we
2144 want is the local, which lookup_symbol will find for us.
2145 This includes gcc1 (not gcc2) on the sparc when passing a
2146 small structure and gcc2 when the argument type is float
2147 and it is passed as a double and converted to float by
2148 the prologue (in the latter case the type of the LOC_ARG
2149 symbol is double and the type of the LOC_LOCAL symbol is
2150 float). There are also LOC_ARG/LOC_REGISTER pairs which
2151 are not combined in symbol-reading. */
2153 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2154 b
, VAR_DOMAIN
, NULL
).symbol
;
2155 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2160 /* Print all argument variables of the function of FRAME.
2161 Print them with values to STREAM.
2163 This function will invalidate FRAME. */
2166 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2168 struct print_variable_and_value_data cb_data
;
2169 struct symbol
*func
;
2172 if (!get_frame_pc_if_available (frame
, &pc
))
2174 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2178 func
= get_frame_function (frame
);
2181 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2185 cb_data
.frame_id
= get_frame_id (frame
);
2186 cb_data
.num_tabs
= 0;
2187 cb_data
.stream
= gdb_stdout
;
2188 cb_data
.values_printed
= 0;
2190 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2191 do_print_variable_and_value
, &cb_data
);
2193 /* do_print_variable_and_value invalidates FRAME. */
2196 if (!cb_data
.values_printed
)
2197 fprintf_filtered (stream
, _("No arguments.\n"));
2201 args_info (char *ignore
, int from_tty
)
2203 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2207 /* Select frame FRAME. Also print the stack frame and show the source
2208 if this is the tui version. */
2210 select_and_print_frame (struct frame_info
*frame
)
2212 select_frame (frame
);
2214 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2217 /* Return the symbol-block in which the selected frame is executing.
2218 Can return zero under various legitimate circumstances.
2220 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2221 code address within the block returned. We use this to decide
2222 which macros are in scope. */
2224 const struct block
*
2225 get_selected_block (CORE_ADDR
*addr_in_block
)
2227 if (!has_stack_frames ())
2230 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2233 /* Find a frame a certain number of levels away from FRAME.
2234 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2235 Positive means go to earlier frames (up); negative, the reverse.
2236 The int that contains the number of levels is counted toward
2237 zero as the frames for those levels are found.
2238 If the top or bottom frame is reached, that frame is returned,
2239 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2240 how much farther the original request asked to go. */
2243 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2245 /* Going up is simple: just call get_prev_frame enough times or
2246 until the initial frame is reached. */
2247 while (*level_offset_ptr
> 0)
2249 struct frame_info
*prev
= get_prev_frame (frame
);
2253 (*level_offset_ptr
)--;
2257 /* Going down is just as simple. */
2258 while (*level_offset_ptr
< 0)
2260 struct frame_info
*next
= get_next_frame (frame
);
2264 (*level_offset_ptr
)++;
2271 /* The "select_frame" command. With no argument this is a NOP.
2272 Select the frame at level LEVEL_EXP if it is a valid level.
2273 Otherwise, treat LEVEL_EXP as an address expression and select it.
2275 See parse_frame_specification for more info on proper frame
2279 select_frame_command (char *level_exp
, int from_tty
)
2281 select_frame (parse_frame_specification (level_exp
, "No stack.", NULL
));
2284 /* The "frame" command. With no argument, print the selected frame
2285 briefly. With an argument, behave like select_frame and then print
2286 the selected frame. */
2289 frame_command (char *level_exp
, int from_tty
)
2291 select_frame_command (level_exp
, from_tty
);
2292 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2295 /* Select the frame up one or COUNT_EXP stack levels from the
2296 previously selected frame, and print it briefly. */
2299 up_silently_base (const char *count_exp
)
2301 struct frame_info
*frame
;
2305 count
= parse_and_eval_long (count_exp
);
2307 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2308 if (count
!= 0 && count_exp
== NULL
)
2309 error (_("Initial frame selected; you cannot go up."));
2310 select_frame (frame
);
2314 up_silently_command (char *count_exp
, int from_tty
)
2316 up_silently_base (count_exp
);
2320 up_command (char *count_exp
, int from_tty
)
2322 up_silently_base (count_exp
);
2323 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2326 /* Select the frame down one or COUNT_EXP stack levels from the previously
2327 selected frame, and print it briefly. */
2330 down_silently_base (const char *count_exp
)
2332 struct frame_info
*frame
;
2336 count
= -parse_and_eval_long (count_exp
);
2338 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2339 if (count
!= 0 && count_exp
== NULL
)
2341 /* We only do this if COUNT_EXP is not specified. That way
2342 "down" means to really go down (and let me know if that is
2343 impossible), but "down 9999" can be used to mean go all the
2344 way down without getting an error. */
2346 error (_("Bottom (innermost) frame selected; you cannot go down."));
2349 select_frame (frame
);
2353 down_silently_command (char *count_exp
, int from_tty
)
2355 down_silently_base (count_exp
);
2359 down_command (char *count_exp
, int from_tty
)
2361 down_silently_base (count_exp
);
2362 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2367 return_command (char *retval_exp
, int from_tty
)
2369 /* Initialize it just to avoid a GCC false warning. */
2370 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2371 struct frame_info
*thisframe
;
2372 struct gdbarch
*gdbarch
;
2373 struct symbol
*thisfun
;
2374 struct value
*return_value
= NULL
;
2375 struct value
*function
= NULL
;
2376 const char *query_prefix
= "";
2378 thisframe
= get_selected_frame ("No selected frame.");
2379 thisfun
= get_frame_function (thisframe
);
2380 gdbarch
= get_frame_arch (thisframe
);
2382 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2383 error (_("Can not force return from an inlined function."));
2385 /* Compute the return value. If the computation triggers an error,
2386 let it bail. If the return type can't be handled, set
2387 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2391 struct expression
*retval_expr
= parse_expression (retval_exp
);
2392 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2393 struct type
*return_type
= NULL
;
2395 /* Compute the return value. Should the computation fail, this
2396 call throws an error. */
2397 return_value
= evaluate_expression (retval_expr
);
2399 /* Cast return value to the return type of the function. Should
2400 the cast fail, this call throws an error. */
2401 if (thisfun
!= NULL
)
2402 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2403 if (return_type
== NULL
)
2405 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2406 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2407 error (_("Return value type not available for selected "
2409 "Please use an explicit cast of the value to return."));
2410 return_type
= value_type (return_value
);
2412 do_cleanups (old_chain
);
2413 return_type
= check_typedef (return_type
);
2414 return_value
= value_cast (return_type
, return_value
);
2416 /* Make sure the value is fully evaluated. It may live in the
2417 stack frame we're about to pop. */
2418 if (value_lazy (return_value
))
2419 value_fetch_lazy (return_value
);
2421 if (thisfun
!= NULL
)
2422 function
= read_var_value (thisfun
, NULL
, thisframe
);
2424 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2425 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2426 /* If the return-type is "void", don't try to find the
2427 return-value's location. However, do still evaluate the
2428 return expression so that, even when the expression result
2429 is discarded, side effects such as "return i++" still
2431 return_value
= NULL
;
2432 else if (thisfun
!= NULL
)
2434 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2435 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2436 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2438 query_prefix
= "The location at which to store the "
2439 "function's return value is unknown.\n"
2440 "If you continue, the return value "
2441 "that you specified will be ignored.\n";
2442 return_value
= NULL
;
2447 /* Does an interactive user really want to do this? Include
2448 information, such as how well GDB can handle the return value, in
2449 the query message. */
2454 if (thisfun
== NULL
)
2455 confirmed
= query (_("%sMake selected stack frame return now? "),
2459 if (TYPE_NO_RETURN (thisfun
->type
))
2460 warning (_("Function does not return normally to caller."));
2461 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2462 SYMBOL_PRINT_NAME (thisfun
));
2465 error (_("Not confirmed"));
2468 /* Discard the selected frame and all frames inner-to it. */
2469 frame_pop (get_selected_frame (NULL
));
2471 /* Store RETURN_VALUE in the just-returned register set. */
2472 if (return_value
!= NULL
)
2474 struct type
*return_type
= value_type (return_value
);
2475 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2477 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2478 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2479 gdbarch_return_value (gdbarch
, function
, return_type
,
2480 get_current_regcache (), NULL
/*read*/,
2481 value_contents (return_value
) /*write*/);
2484 /* If we are at the end of a call dummy now, pop the dummy frame
2486 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2487 frame_pop (get_current_frame ());
2489 select_frame (get_current_frame ());
2490 /* If interactive, print the frame that is now current. */
2492 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2495 /* Sets the scope to input function name, provided that the function
2496 is within the current stack frame. */
2498 struct function_bounds
2500 CORE_ADDR low
, high
;
2504 func_command (char *arg
, int from_tty
)
2506 struct frame_info
*frame
;
2508 struct symtabs_and_lines sals
;
2511 struct function_bounds
*func_bounds
= NULL
;
2512 struct cleanup
*cleanups
;
2517 frame
= get_current_frame ();
2518 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2519 cleanups
= make_cleanup (xfree
, sals
.sals
);
2520 func_bounds
= XNEWVEC (struct function_bounds
, sals
.nelts
);
2521 make_cleanup (xfree
, func_bounds
);
2522 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2524 if (sals
.sals
[i
].pspace
!= current_program_space
)
2525 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2526 else if (sals
.sals
[i
].pc
== 0
2527 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2528 &func_bounds
[i
].low
,
2529 &func_bounds
[i
].high
) == 0)
2531 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2537 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2538 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2539 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2543 frame
= find_relative_frame (frame
, &level
);
2546 while (!found
&& level
== 0);
2548 do_cleanups (cleanups
);
2551 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2552 else if (frame
!= get_selected_frame (NULL
))
2553 select_and_print_frame (frame
);
2557 /* Provide a prototype to silence -Wmissing-prototypes. */
2558 void _initialize_stack (void);
2561 _initialize_stack (void)
2563 add_com ("return", class_stack
, return_command
, _("\
2564 Make selected stack frame return to its caller.\n\
2565 Control remains in the debugger, but when you continue\n\
2566 execution will resume in the frame above the one now selected.\n\
2567 If an argument is given, it is an expression for the value to return."));
2569 add_com ("up", class_stack
, up_command
, _("\
2570 Select and print stack frame that called this one.\n\
2571 An argument says how many frames up to go."));
2572 add_com ("up-silently", class_support
, up_silently_command
, _("\
2573 Same as the `up' command, but does not print anything.\n\
2574 This is useful in command scripts."));
2576 add_com ("down", class_stack
, down_command
, _("\
2577 Select and print stack frame called by this one.\n\
2578 An argument says how many frames down to go."));
2579 add_com_alias ("do", "down", class_stack
, 1);
2580 add_com_alias ("dow", "down", class_stack
, 1);
2581 add_com ("down-silently", class_support
, down_silently_command
, _("\
2582 Same as the `down' command, but does not print anything.\n\
2583 This is useful in command scripts."));
2585 add_com ("frame", class_stack
, frame_command
, _("\
2586 Select and print a stack frame.\nWith no argument, \
2587 print the selected stack frame. (See also \"info frame\").\n\
2588 An argument specifies the frame to select.\n\
2589 It can be a stack frame number or the address of the frame.\n\
2590 With argument, nothing is printed if input is coming from\n\
2591 a command file or a user-defined command."));
2593 add_com_alias ("f", "frame", class_stack
, 1);
2595 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2596 Select a stack frame without printing anything.\n\
2597 An argument specifies the frame to select.\n\
2598 It can be a stack frame number or the address of the frame.\n"));
2600 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2601 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2602 With a negative argument, print outermost -COUNT frames.\nUse of the \
2603 'full' qualifier also prints the values of the local variables.\n\
2604 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2605 on this backtrace.\n"));
2606 add_com_alias ("bt", "backtrace", class_stack
, 0);
2608 add_com_alias ("where", "backtrace", class_alias
, 0);
2609 add_info ("stack", backtrace_command
,
2610 _("Backtrace of the stack, or innermost COUNT frames."));
2611 add_info_alias ("s", "stack", 1);
2612 add_info ("frame", frame_info
,
2613 _("All about selected stack frame, or frame at ADDR."));
2614 add_info_alias ("f", "frame", 1);
2615 add_info ("locals", locals_info
,
2616 _("Local variables of current stack frame."));
2617 add_info ("args", args_info
,
2618 _("Argument variables of current stack frame."));
2621 add_com ("func", class_stack
, func_command
, _("\
2622 Select the stack frame that contains <func>.\n\
2623 Usage: func <name>\n"));
2625 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2626 print_frame_arguments_choices
, &print_frame_arguments
,
2627 _("Set printing of non-scalar frame arguments"),
2628 _("Show printing of non-scalar frame arguments"),
2629 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2631 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2632 &print_raw_frame_arguments
, _("\
2633 Set whether to print frame arguments in raw form."), _("\
2634 Show whether to print frame arguments in raw form."), _("\
2635 If set, frame arguments are printed in raw form, bypassing any\n\
2636 pretty-printers for that value."),
2638 &setprintrawlist
, &showprintrawlist
);
2640 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2641 &disassemble_next_line
, _("\
2642 Set whether to disassemble next source line or insn when execution stops."),
2644 Show whether to disassemble next source line or insn when execution stops."),
2646 If ON, GDB will display disassembly of the next source line, in addition\n\
2647 to displaying the source line itself. If the next source line cannot\n\
2648 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2649 will display disassembly of next instruction instead of showing the\n\
2651 If AUTO, display disassembly of next instruction only if the source line\n\
2652 cannot be displayed.\n\
2653 If OFF (which is the default), never display the disassembly of the next\n\
2656 show_disassemble_next_line
,
2657 &setlist
, &showlist
);
2658 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2660 add_setshow_enum_cmd ("entry-values", class_stack
,
2661 print_entry_values_choices
, &print_entry_values
,
2662 _("Set printing of function arguments at function "
2664 _("Show printing of function arguments at function "
2667 GDB can sometimes determine the values of function arguments at entry,\n\
2668 in addition to their current values. This option tells GDB whether\n\
2669 to print the current value, the value at entry (marked as val@entry),\n\
2670 or both. Note that one or both of these values may be <optimized out>."),
2671 NULL
, NULL
, &setprintlist
, &showprintlist
);