1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
51 #include "safe-ctype.h"
53 #include "extension.h"
56 /* The possible choices of "set print frame-arguments", and the value
59 static const char *const print_frame_arguments_choices
[] =
60 {"all", "scalars", "none", NULL
};
61 static const char *print_frame_arguments
= "scalars";
63 /* If non-zero, don't invoke pretty-printers for frame arguments. */
64 static int print_raw_frame_arguments
;
66 /* The possible choices of "set print entry-values", and the value
69 const char print_entry_values_no
[] = "no";
70 const char print_entry_values_only
[] = "only";
71 const char print_entry_values_preferred
[] = "preferred";
72 const char print_entry_values_if_needed
[] = "if-needed";
73 const char print_entry_values_both
[] = "both";
74 const char print_entry_values_compact
[] = "compact";
75 const char print_entry_values_default
[] = "default";
76 static const char *const print_entry_values_choices
[] =
78 print_entry_values_no
,
79 print_entry_values_only
,
80 print_entry_values_preferred
,
81 print_entry_values_if_needed
,
82 print_entry_values_both
,
83 print_entry_values_compact
,
84 print_entry_values_default
,
87 const char *print_entry_values
= print_entry_values_default
;
89 /* Prototypes for local functions. */
91 static void print_frame_local_vars (struct frame_info
*, int,
94 static void print_frame (struct frame_info
*frame
, int print_level
,
95 enum print_what print_what
, int print_args
,
96 struct symtab_and_line sal
);
98 static void set_last_displayed_sal (int valid
,
99 struct program_space
*pspace
,
101 struct symtab
*symtab
,
104 /* Zero means do things normally; we are interacting directly with the
105 user. One means print the full filename and linenumber when a
106 frame is printed, and do so in a format emacs18/emacs19.22 can
107 parse. Two means print similar annotations, but in many more
108 cases and in a slightly different syntax. */
110 int annotation_level
= 0;
112 /* These variables hold the last symtab and line we displayed to the user.
113 * This is where we insert a breakpoint or a skiplist entry by default. */
114 static int last_displayed_sal_valid
= 0;
115 static struct program_space
*last_displayed_pspace
= 0;
116 static CORE_ADDR last_displayed_addr
= 0;
117 static struct symtab
*last_displayed_symtab
= 0;
118 static int last_displayed_line
= 0;
121 /* Return 1 if we should display the address in addition to the location,
122 because we are in the middle of a statement. */
125 frame_show_address (struct frame_info
*frame
,
126 struct symtab_and_line sal
)
128 /* If there is a line number, but no PC, then there is no location
129 information associated with this sal. The only way that should
130 happen is for the call sites of inlined functions (SAL comes from
131 find_frame_sal). Otherwise, we would have some PC range if the
132 SAL came from a line table. */
133 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
135 if (get_next_frame (frame
) == NULL
)
136 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
138 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
142 return get_frame_pc (frame
) != sal
.pc
;
148 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
149 int print_level
, enum print_what print_what
,
152 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
154 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
157 /* Show or print a stack frame FRAME briefly. The output is formatted
158 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
159 relative level, function name, argument list, and file name and
160 line number. If the frame's PC is not at the beginning of the
161 source line, the actual PC is printed at the beginning. */
164 print_stack_frame (struct frame_info
*frame
, int print_level
,
165 enum print_what print_what
,
169 /* For mi, alway print location and address. */
170 if (current_uiout
->is_mi_like_p ())
171 print_what
= LOC_AND_ADDRESS
;
175 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
178 set_current_sal_from_frame (frame
);
180 CATCH (e
, RETURN_MASK_ERROR
)
186 /* Print nameless arguments of frame FRAME on STREAM, where START is
187 the offset of the first nameless argument, and NUM is the number of
188 nameless arguments to print. FIRST is nonzero if this is the first
189 argument (not just the first nameless argument). */
192 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
193 int first
, struct ui_file
*stream
)
195 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
196 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
201 for (i
= 0; i
< num
; i
++)
204 argsaddr
= get_frame_args_address (frame
);
207 arg_value
= read_memory_integer (argsaddr
+ start
,
208 sizeof (int), byte_order
);
210 fprintf_filtered (stream
, ", ");
211 fprintf_filtered (stream
, "%ld", arg_value
);
213 start
+= sizeof (int);
217 /* Print single argument of inferior function. ARG must be already
220 Errors are printed as if they would be the parameter value. Use zeroed ARG
221 iff it should not be printed accoring to user settings. */
224 print_frame_arg (const struct frame_arg
*arg
)
226 struct ui_out
*uiout
= current_uiout
;
227 struct cleanup
*old_chain
;
228 const char *error_message
= NULL
;
232 gdb_assert (!arg
->val
|| !arg
->error
);
233 gdb_assert (arg
->entry_kind
== print_entry_values_no
234 || arg
->entry_kind
== print_entry_values_only
235 || (!uiout
->is_mi_like_p ()
236 && arg
->entry_kind
== print_entry_values_compact
));
238 annotate_arg_begin ();
240 old_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
241 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
242 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
243 if (arg
->entry_kind
== print_entry_values_compact
)
245 /* It is OK to provide invalid MI-like stream as with
246 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
249 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
250 SYMBOL_LANGUAGE (arg
->sym
),
251 DMGL_PARAMS
| DMGL_ANSI
);
253 if (arg
->entry_kind
== print_entry_values_only
254 || arg
->entry_kind
== print_entry_values_compact
)
256 uiout
->field_stream ("name", stb
);
257 annotate_arg_name_end ();
260 if (!arg
->val
&& !arg
->error
)
265 error_message
= arg
->error
;
270 const struct language_defn
*language
;
271 struct value_print_options opts
;
273 /* Avoid value_print because it will deref ref parameters. We
274 just want to print their addresses. Print ??? for args whose
275 address we do not know. We pass 2 as "recurse" to val_print
276 because our standard indentation here is 4 spaces, and
277 val_print indents 2 for each recurse. */
279 annotate_arg_value (value_type (arg
->val
));
281 /* Use the appropriate language to display our symbol, unless the
282 user forced the language to a specific language. */
283 if (language_mode
== language_mode_auto
)
284 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
286 language
= current_language
;
288 get_no_prettyformat_print_options (&opts
);
290 opts
.raw
= print_raw_frame_arguments
;
292 /* True in "summary" mode, false otherwise. */
293 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
295 common_val_print (arg
->val
, &stb
, 2, &opts
, language
);
297 CATCH (except
, RETURN_MASK_ERROR
)
299 error_message
= except
.message
;
303 if (error_message
!= NULL
)
304 stb
.printf (_("<error reading variable: %s>"), error_message
);
307 uiout
->field_stream ("value", stb
);
309 /* Also invoke ui_out_tuple_end. */
310 do_cleanups (old_chain
);
315 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
316 responsible for xfree of ARGP->ERROR. This function never throws an
320 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
321 struct frame_arg
*argp
)
329 argp
->val
= read_var_value (sym
, NULL
, frame
);
331 CATCH (except
, RETURN_MASK_ERROR
)
333 argp
->error
= xstrdup (except
.message
);
338 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
339 responsible for xfree of ARGP->ERROR. This function never throws an
343 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
344 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
346 struct value
*val
= NULL
, *entryval
= NULL
;
347 char *val_error
= NULL
, *entryval_error
= NULL
;
350 if (print_entry_values
!= print_entry_values_only
351 && print_entry_values
!= print_entry_values_preferred
)
355 val
= read_var_value (sym
, NULL
, frame
);
357 CATCH (except
, RETURN_MASK_ERROR
)
359 val_error
= (char *) alloca (strlen (except
.message
) + 1);
360 strcpy (val_error
, except
.message
);
365 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
366 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
367 && print_entry_values
!= print_entry_values_no
368 && (print_entry_values
!= print_entry_values_if_needed
369 || !val
|| value_optimized_out (val
)))
373 const struct symbol_computed_ops
*ops
;
375 ops
= SYMBOL_COMPUTED_OPS (sym
);
376 entryval
= ops
->read_variable_at_entry (sym
, frame
);
378 CATCH (except
, RETURN_MASK_ERROR
)
380 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
382 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
383 strcpy (entryval_error
, except
.message
);
388 if (entryval
!= NULL
&& value_optimized_out (entryval
))
391 if (print_entry_values
== print_entry_values_compact
392 || print_entry_values
== print_entry_values_default
)
394 /* For MI do not try to use print_entry_values_compact for ARGP. */
396 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
398 struct type
*type
= value_type (val
);
400 if (value_lazy (val
))
401 value_fetch_lazy (val
);
402 if (value_lazy (entryval
))
403 value_fetch_lazy (entryval
);
405 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
407 /* Initialize it just to avoid a GCC false warning. */
408 struct value
*val_deref
= NULL
, *entryval_deref
;
410 /* DW_AT_GNU_call_site_value does match with the current
411 value. If it is a reference still try to verify if
412 dereferenced DW_AT_GNU_call_site_data_value does not
417 struct type
*type_deref
;
419 val_deref
= coerce_ref (val
);
420 if (value_lazy (val_deref
))
421 value_fetch_lazy (val_deref
);
422 type_deref
= value_type (val_deref
);
424 entryval_deref
= coerce_ref (entryval
);
425 if (value_lazy (entryval_deref
))
426 value_fetch_lazy (entryval_deref
);
428 /* If the reference addresses match but dereferenced
429 content does not match print them. */
431 && value_contents_eq (val_deref
, 0,
433 TYPE_LENGTH (type_deref
)))
436 CATCH (except
, RETURN_MASK_ERROR
)
438 /* If the dereferenced content could not be
439 fetched do not display anything. */
440 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
442 else if (except
.message
!= NULL
)
444 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
445 strcpy (entryval_error
, except
.message
);
450 /* Value was not a reference; and its content matches. */
451 if (val
== val_deref
)
459 /* Try to remove possibly duplicate error message for ENTRYARGP even
462 if (val_error
&& entryval_error
463 && strcmp (val_error
, entryval_error
) == 0)
465 entryval_error
= NULL
;
467 /* Do not se VAL_EQUAL as the same error message may be shown for
468 the entry value even if no entry values are present in the
474 if (entryval
== NULL
)
476 if (print_entry_values
== print_entry_values_preferred
)
478 gdb_assert (val
== NULL
);
482 val
= read_var_value (sym
, NULL
, frame
);
484 CATCH (except
, RETURN_MASK_ERROR
)
486 val_error
= (char *) alloca (strlen (except
.message
) + 1);
487 strcpy (val_error
, except
.message
);
491 if (print_entry_values
== print_entry_values_only
492 || print_entry_values
== print_entry_values_both
493 || (print_entry_values
== print_entry_values_preferred
494 && (!val
|| value_optimized_out (val
))))
496 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
497 entryval_error
= NULL
;
500 if ((print_entry_values
== print_entry_values_compact
501 || print_entry_values
== print_entry_values_if_needed
502 || print_entry_values
== print_entry_values_preferred
)
503 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
511 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
512 if (!val
&& !val_error
)
513 argp
->entry_kind
= print_entry_values_only
;
514 else if ((print_entry_values
== print_entry_values_compact
515 || print_entry_values
== print_entry_values_default
) && val_equal
)
517 argp
->entry_kind
= print_entry_values_compact
;
518 gdb_assert (!current_uiout
->is_mi_like_p ());
521 argp
->entry_kind
= print_entry_values_no
;
523 entryargp
->sym
= sym
;
524 entryargp
->val
= entryval
;
525 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
526 if (!entryval
&& !entryval_error
)
527 entryargp
->entry_kind
= print_entry_values_no
;
529 entryargp
->entry_kind
= print_entry_values_only
;
532 /* Print the arguments of frame FRAME on STREAM, given the function
533 FUNC running in that frame (as a symbol), where NUM is the number
534 of arguments according to the stack frame (or -1 if the number of
535 arguments is unknown). */
537 /* Note that currently the "number of arguments according to the
538 stack frame" is only known on VAX where i refers to the "number of
539 ints of arguments according to the stack frame". */
542 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
543 int num
, struct ui_file
*stream
)
545 struct ui_out
*uiout
= current_uiout
;
547 /* Offset of next stack argument beyond the one we have seen that is
548 at the highest offset, or -1 if we haven't come to a stack
550 long highest_offset
= -1;
551 /* Number of ints of arguments that we have printed so far. */
552 int args_printed
= 0;
553 /* True if we should print arguments, false otherwise. */
554 int print_args
= strcmp (print_frame_arguments
, "none");
558 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
559 struct block_iterator iter
;
562 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
564 struct frame_arg arg
, entryarg
;
568 /* Keep track of the highest stack argument offset seen, and
569 skip over any kinds of symbols we don't care about. */
571 if (!SYMBOL_IS_ARGUMENT (sym
))
574 switch (SYMBOL_CLASS (sym
))
579 long current_offset
= SYMBOL_VALUE (sym
);
580 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
582 /* Compute address of next argument by adding the size of
583 this argument and rounding to an int boundary. */
585 ((current_offset
+ arg_size
+ sizeof (int) - 1)
586 & ~(sizeof (int) - 1));
588 /* If this is the highest offset seen yet, set
590 if (highest_offset
== -1
591 || (current_offset
> highest_offset
))
592 highest_offset
= current_offset
;
594 /* Add the number of ints we're about to print to
596 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
599 /* We care about types of symbols, but don't need to
600 keep track of stack offsets in them. */
602 case LOC_REGPARM_ADDR
:
604 case LOC_OPTIMIZED_OUT
:
609 /* We have to look up the symbol because arguments can have
610 two entries (one a parameter, one a local) and the one we
611 want is the local, which lookup_symbol will find for us.
612 This includes gcc1 (not gcc2) on SPARC when passing a
613 small structure and gcc2 when the argument type is float
614 and it is passed as a double and converted to float by
615 the prologue (in the latter case the type of the LOC_ARG
616 symbol is double and the type of the LOC_LOCAL symbol is
618 /* But if the parameter name is null, don't try it. Null
619 parameter names occur on the RS/6000, for traceback
620 tables. FIXME, should we even print them? */
622 if (*SYMBOL_LINKAGE_NAME (sym
))
626 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
627 b
, VAR_DOMAIN
, NULL
).symbol
;
628 gdb_assert (nsym
!= NULL
);
629 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
630 && !SYMBOL_IS_ARGUMENT (nsym
))
632 /* There is a LOC_ARG/LOC_REGISTER pair. This means
633 that it was passed on the stack and loaded into a
634 register, or passed in a register and stored in a
635 stack slot. GDB 3.x used the LOC_ARG; GDB
636 4.0-4.11 used the LOC_REGISTER.
638 Reasons for using the LOC_ARG:
640 (1) Because find_saved_registers may be slow for
643 (2) Because registers are often re-used and stack
644 slots rarely (never?) are. Therefore using
645 the stack slot is much less likely to print
648 Reasons why we might want to use the LOC_REGISTER:
650 (1) So that the backtrace prints the same value
651 as "print foo". I see no compelling reason
652 why this needs to be the case; having the
653 backtrace print the value which was passed
654 in, and "print foo" print the value as
655 modified within the called function, makes
658 Additional note: It might be nice if "info args"
659 displayed both values.
661 One more note: There is a case with SPARC
662 structure passing where we need to use the
663 LOC_REGISTER, but this is dealt with by creating
664 a single LOC_REGPARM in symbol reading. */
666 /* Leave sym (the LOC_ARG) alone. */
673 /* Print the current arg. */
676 uiout
->wrap_hint (" ");
680 memset (&arg
, 0, sizeof (arg
));
682 arg
.entry_kind
= print_entry_values_no
;
683 memset (&entryarg
, 0, sizeof (entryarg
));
685 entryarg
.entry_kind
= print_entry_values_no
;
688 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
690 if (arg
.entry_kind
!= print_entry_values_only
)
691 print_frame_arg (&arg
);
693 if (entryarg
.entry_kind
!= print_entry_values_no
)
695 if (arg
.entry_kind
!= print_entry_values_only
)
698 uiout
->wrap_hint (" ");
701 print_frame_arg (&entryarg
);
705 xfree (entryarg
.error
);
711 /* Don't print nameless args in situations where we don't know
712 enough about the stack to find them. */
717 if (highest_offset
== -1)
718 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
720 start
= highest_offset
;
722 print_frame_nameless_args (frame
, start
, num
- args_printed
,
727 /* Set the current source and line to the location given by frame
728 FRAME, if possible. When CENTER is true, adjust so the relevant
729 line is in the center of the next 'list'. */
732 set_current_sal_from_frame (struct frame_info
*frame
)
734 struct symtab_and_line sal
;
736 find_frame_sal (frame
, &sal
);
737 if (sal
.symtab
!= NULL
)
738 set_current_source_symtab_and_line (&sal
);
741 /* If ON, GDB will display disassembly of the next source line when
742 execution of the program being debugged stops.
743 If AUTO (which is the default), or there's no line info to determine
744 the source line of the next instruction, display disassembly of next
745 instruction instead. */
747 static enum auto_boolean disassemble_next_line
;
750 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
751 struct cmd_list_element
*c
,
754 fprintf_filtered (file
,
755 _("Debugger's willingness to use "
756 "disassemble-next-line is %s.\n"),
760 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
761 because it will be broken by filter sometime. */
764 do_gdb_disassembly (struct gdbarch
*gdbarch
,
765 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
770 gdb_disassembly (gdbarch
, current_uiout
,
771 DISASSEMBLY_RAW_INSN
, how_many
,
774 CATCH (exception
, RETURN_MASK_ERROR
)
776 /* If an exception was thrown while doing the disassembly, print
777 the error message, to give the user a clue of what happened. */
778 exception_print (gdb_stderr
, exception
);
783 /* Print information about frame FRAME. The output is format according
784 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
787 SRC_LINE: Print only source line.
788 LOCATION: Print only location.
789 LOC_AND_SRC: Print location and source line.
791 Used in "where" output, and to emit breakpoint or step
795 print_frame_info (struct frame_info
*frame
, int print_level
,
796 enum print_what print_what
, int print_args
,
799 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
800 struct symtab_and_line sal
;
803 struct ui_out
*uiout
= current_uiout
;
805 if (get_frame_type (frame
) == DUMMY_FRAME
806 || get_frame_type (frame
) == SIGTRAMP_FRAME
807 || get_frame_type (frame
) == ARCH_FRAME
)
809 struct cleanup
*uiout_cleanup
810 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
812 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
813 gdbarch
, get_frame_pc (frame
));
815 /* Do this regardless of SOURCE because we don't have any source
816 to list for this frame. */
820 uiout
->field_fmt_int (2, ui_left
, "level",
821 frame_relative_level (frame
));
823 if (uiout
->is_mi_like_p ())
825 annotate_frame_address ();
826 uiout
->field_core_addr ("addr",
827 gdbarch
, get_frame_pc (frame
));
828 annotate_frame_address_end ();
831 if (get_frame_type (frame
) == DUMMY_FRAME
)
833 annotate_function_call ();
834 uiout
->field_string ("func", "<function called from gdb>");
836 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
838 annotate_signal_handler_caller ();
839 uiout
->field_string ("func", "<signal handler called>");
841 else if (get_frame_type (frame
) == ARCH_FRAME
)
843 uiout
->field_string ("func", "<cross-architecture call>");
846 annotate_frame_end ();
848 /* If disassemble-next-line is set to auto or on output the next
850 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
851 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
852 do_gdb_disassembly (get_frame_arch (frame
), 1,
853 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
855 do_cleanups (uiout_cleanup
);
859 /* If FRAME is not the innermost frame, that normally means that
860 FRAME->pc points to *after* the call instruction, and we want to
861 get the line containing the call, never the next line. But if
862 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
863 next frame was not entered as the result of a call, and we want
864 to get the line containing FRAME->pc. */
865 find_frame_sal (frame
, &sal
);
867 location_print
= (print_what
== LOCATION
868 || print_what
== LOC_AND_ADDRESS
869 || print_what
== SRC_AND_LOC
);
871 if (location_print
|| !sal
.symtab
)
872 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
874 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
876 /* If disassemble-next-line is set to auto or on and doesn't have
877 the line debug messages for $pc, output the next instruction. */
878 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
879 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
880 && source_print
&& !sal
.symtab
)
881 do_gdb_disassembly (get_frame_arch (frame
), 1,
882 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
884 if (source_print
&& sal
.symtab
)
887 int mid_statement
= ((print_what
== SRC_LINE
)
888 && frame_show_address (frame
, sal
));
890 if (annotation_level
)
891 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
892 get_frame_pc (frame
));
895 if (deprecated_print_frame_info_listing_hook
)
896 deprecated_print_frame_info_listing_hook (sal
.symtab
,
901 struct value_print_options opts
;
903 get_user_print_options (&opts
);
904 /* We used to do this earlier, but that is clearly
905 wrong. This function is used by many different
906 parts of gdb, including normal_stop in infrun.c,
907 which uses this to print out the current PC
908 when we stepi/nexti into the middle of a source
909 line. Only the command line really wants this
910 behavior. Other UIs probably would like the
911 ability to decide for themselves if it is desired. */
912 if (opts
.addressprint
&& mid_statement
)
914 uiout
->field_core_addr ("addr",
915 gdbarch
, get_frame_pc (frame
));
919 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
923 /* If disassemble-next-line is set to on and there is line debug
924 messages, output assembly codes for next line. */
925 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
926 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
933 if (get_frame_pc_if_available (frame
, &pc
))
934 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
936 set_last_displayed_sal (0, 0, 0, 0, 0);
939 annotate_frame_end ();
941 gdb_flush (gdb_stdout
);
944 /* Remember the last symtab and line we displayed, which we use e.g.
945 * as the place to put a breakpoint when the `break' command is
946 * invoked with no arguments. */
949 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
950 CORE_ADDR addr
, struct symtab
*symtab
,
953 last_displayed_sal_valid
= valid
;
954 last_displayed_pspace
= pspace
;
955 last_displayed_addr
= addr
;
956 last_displayed_symtab
= symtab
;
957 last_displayed_line
= line
;
958 if (valid
&& pspace
== NULL
)
960 clear_last_displayed_sal ();
961 internal_error (__FILE__
, __LINE__
,
962 _("Trying to set NULL pspace."));
966 /* Forget the last sal we displayed. */
969 clear_last_displayed_sal (void)
971 last_displayed_sal_valid
= 0;
972 last_displayed_pspace
= 0;
973 last_displayed_addr
= 0;
974 last_displayed_symtab
= 0;
975 last_displayed_line
= 0;
978 /* Is our record of the last sal we displayed valid? If not,
979 * the get_last_displayed_* functions will return NULL or 0, as
983 last_displayed_sal_is_valid (void)
985 return last_displayed_sal_valid
;
988 /* Get the pspace of the last sal we displayed, if it's valid. */
990 struct program_space
*
991 get_last_displayed_pspace (void)
993 if (last_displayed_sal_valid
)
994 return last_displayed_pspace
;
998 /* Get the address of the last sal we displayed, if it's valid. */
1001 get_last_displayed_addr (void)
1003 if (last_displayed_sal_valid
)
1004 return last_displayed_addr
;
1008 /* Get the symtab of the last sal we displayed, if it's valid. */
1011 get_last_displayed_symtab (void)
1013 if (last_displayed_sal_valid
)
1014 return last_displayed_symtab
;
1018 /* Get the line of the last sal we displayed, if it's valid. */
1021 get_last_displayed_line (void)
1023 if (last_displayed_sal_valid
)
1024 return last_displayed_line
;
1028 /* Get the last sal we displayed, if it's valid. */
1031 get_last_displayed_sal (struct symtab_and_line
*sal
)
1033 if (last_displayed_sal_valid
)
1035 sal
->pspace
= last_displayed_pspace
;
1036 sal
->pc
= last_displayed_addr
;
1037 sal
->symtab
= last_displayed_symtab
;
1038 sal
->line
= last_displayed_line
;
1050 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1051 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1054 find_frame_funname (struct frame_info
*frame
, char **funname
,
1055 enum language
*funlang
, struct symbol
**funcp
)
1057 struct symbol
*func
;
1060 *funlang
= language_unknown
;
1064 func
= get_frame_function (frame
);
1067 /* In certain pathological cases, the symtabs give the wrong
1068 function (when we are in the first function in a file which
1069 is compiled without debugging symbols, the previous function
1070 is compiled with debugging symbols, and the "foo.o" symbol
1071 that is supposed to tell us where the file with debugging
1072 symbols ends has been truncated by ar because it is longer
1073 than 15 characters). This also occurs if the user uses asm()
1074 to create a function but not stabs for it (in a file compiled
1077 So look in the minimal symbol tables as well, and if it comes
1078 up with a larger address for the function use that instead.
1079 I don't think this can ever cause any problems; there
1080 shouldn't be any minimal symbols in the middle of a function;
1081 if this is ever changed many parts of GDB will need to be
1082 changed (and we'll create a find_pc_minimal_function or some
1085 struct bound_minimal_symbol msymbol
;
1087 /* Don't attempt to do this for inlined functions, which do not
1088 have a corresponding minimal symbol. */
1089 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1091 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1093 memset (&msymbol
, 0, sizeof (msymbol
));
1095 if (msymbol
.minsym
!= NULL
1096 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1097 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1099 /* We also don't know anything about the function besides
1100 its address and name. */
1102 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1103 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1107 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1109 *funlang
= SYMBOL_LANGUAGE (func
);
1112 if (*funlang
== language_cplus
)
1114 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1115 to display the demangled name that we already have
1116 stored in the symbol table, but we stored a version
1117 with DMGL_PARAMS turned on, and here we don't want to
1118 display parameters. So remove the parameters. */
1119 char *func_only
= cp_remove_params (print_name
);
1122 *funname
= func_only
;
1125 /* If we didn't hit the C++ case above, set *funname here.
1126 This approach is taken to avoid having to install a
1127 cleanup in case cp_remove_params can throw. */
1128 if (*funname
== NULL
)
1129 *funname
= xstrdup (print_name
);
1134 struct bound_minimal_symbol msymbol
;
1137 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1140 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1141 if (msymbol
.minsym
!= NULL
)
1143 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1144 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1150 print_frame (struct frame_info
*frame
, int print_level
,
1151 enum print_what print_what
, int print_args
,
1152 struct symtab_and_line sal
)
1154 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1155 struct ui_out
*uiout
= current_uiout
;
1156 char *funname
= NULL
;
1157 enum language funlang
= language_unknown
;
1158 struct cleanup
*old_chain
, *list_chain
;
1159 struct value_print_options opts
;
1160 struct symbol
*func
;
1164 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1167 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1168 old_chain
= make_cleanup (xfree
, funname
);
1170 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1173 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1178 uiout
->field_fmt_int (2, ui_left
, "level",
1179 frame_relative_level (frame
));
1181 get_user_print_options (&opts
);
1182 if (opts
.addressprint
)
1184 || frame_show_address (frame
, sal
)
1185 || print_what
== LOC_AND_ADDRESS
)
1187 annotate_frame_address ();
1189 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1191 uiout
->field_string ("addr", "<unavailable>");
1192 annotate_frame_address_end ();
1193 uiout
->text (" in ");
1195 annotate_frame_function_name ();
1198 fprintf_symbol_filtered (&stb
, funname
? funname
: "??",
1199 funlang
, DMGL_ANSI
);
1200 uiout
->field_stream ("func", stb
);
1201 uiout
->wrap_hint (" ");
1202 annotate_frame_args ();
1207 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1209 struct cleanup
*args_list_chain
;
1211 if (gdbarch_frame_num_args_p (gdbarch
))
1213 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1214 gdb_assert (numargs
>= 0);
1219 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1222 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1224 CATCH (e
, RETURN_MASK_ERROR
)
1229 /* FIXME: ARGS must be a list. If one argument is a string it
1230 will have " that will not be properly escaped. */
1231 /* Invoke ui_out_tuple_end. */
1232 do_cleanups (args_list_chain
);
1238 const char *filename_display
;
1240 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1241 annotate_frame_source_begin ();
1242 uiout
->wrap_hint (" ");
1243 uiout
->text (" at ");
1244 annotate_frame_source_file ();
1245 uiout
->field_string ("file", filename_display
);
1246 if (uiout
->is_mi_like_p ())
1248 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1250 uiout
->field_string ("fullname", fullname
);
1252 annotate_frame_source_file_end ();
1254 annotate_frame_source_line ();
1255 uiout
->field_int ("line", sal
.line
);
1256 annotate_frame_source_end ();
1259 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1261 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1262 get_frame_pc (frame
));
1266 annotate_frame_where ();
1267 uiout
->wrap_hint (" ");
1268 uiout
->text (" from ");
1269 uiout
->field_string ("from", lib
);
1273 /* do_cleanups will call ui_out_tuple_end() for us. */
1274 do_cleanups (list_chain
);
1276 do_cleanups (old_chain
);
1280 /* Read a frame specification in whatever the appropriate format is from
1281 FRAME_EXP. Call error() if the specification is in any way invalid (so
1282 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1283 set its target to indicate that the default selected frame was used. */
1285 static struct frame_info
*
1286 parse_frame_specification (const char *frame_exp
, int *selected_frame_p
)
1289 struct value
*args
[4];
1290 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1292 if (frame_exp
== NULL
)
1300 struct cleanup
*cleanup
;
1303 /* Skip leading white space, bail of EOL. */
1304 frame_exp
= skip_spaces_const (frame_exp
);
1308 /* Parse the argument, extract it, save it. */
1310 *p
&& !ISSPACE (*p
);
1312 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1314 cleanup
= make_cleanup (xfree
, addr_string
);
1316 /* NOTE: Parse and evaluate expression, but do not use
1317 functions such as parse_and_eval_long or
1318 parse_and_eval_address to also extract the value.
1319 Instead value_as_long and value_as_address are used.
1320 This avoids problems with expressions that contain
1322 if (numargs
>= ARRAY_SIZE (args
))
1323 error (_("Too many args in frame specification"));
1324 args
[numargs
++] = parse_and_eval (addr_string
);
1326 do_cleanups (cleanup
);
1330 /* If no args, default to the selected frame. */
1333 if (selected_frame_p
!= NULL
)
1334 (*selected_frame_p
) = 1;
1335 return get_selected_frame (_("No stack."));
1338 /* None of the remaining use the selected frame. */
1339 if (selected_frame_p
!= NULL
)
1340 (*selected_frame_p
) = 0;
1342 /* Assume the single arg[0] is an integer, and try using that to
1343 select a frame relative to current. */
1346 struct frame_info
*fid
;
1347 int level
= value_as_long (args
[0]);
1349 fid
= find_relative_frame (get_current_frame (), &level
);
1351 /* find_relative_frame was successful. */
1355 /* Convert each value into a corresponding address. */
1359 for (i
= 0; i
< numargs
; i
++)
1360 addrs
[i
] = value_as_address (args
[i
]);
1363 /* Assume that the single arg[0] is an address, use that to identify
1364 a frame with a matching ID. Should this also accept stack/pc or
1365 stack/pc/special. */
1368 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1369 struct frame_info
*fid
;
1371 /* If (s)he specifies the frame with an address, he deserves
1372 what (s)he gets. Still, give the highest one that matches.
1373 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1375 for (fid
= get_current_frame ();
1377 fid
= get_prev_frame (fid
))
1379 if (frame_id_eq (id
, get_frame_id (fid
)))
1381 struct frame_info
*prev_frame
;
1385 prev_frame
= get_prev_frame (fid
);
1387 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1396 /* We couldn't identify the frame as an existing frame, but
1397 perhaps we can create one with a single argument. */
1399 return create_new_frame (addrs
[0], 0);
1400 else if (numargs
== 2)
1401 return create_new_frame (addrs
[0], addrs
[1]);
1403 error (_("Too many args in frame specification"));
1406 /* Print verbosely the selected frame or the frame at address
1407 ADDR_EXP. Absolutely all information in the frame is printed. */
1410 frame_info (char *addr_exp
, int from_tty
)
1412 struct frame_info
*fi
;
1413 struct symtab_and_line sal
;
1414 struct symbol
*func
;
1416 struct frame_info
*calling_frame_info
;
1418 const char *funname
= 0;
1419 enum language funlang
= language_unknown
;
1420 const char *pc_regname
;
1421 int selected_frame_p
;
1422 struct gdbarch
*gdbarch
;
1423 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1426 /* Initialize it to avoid "may be used uninitialized" warning. */
1427 CORE_ADDR caller_pc
= 0;
1428 int caller_pc_p
= 0;
1430 fi
= parse_frame_specification (addr_exp
, &selected_frame_p
);
1431 gdbarch
= get_frame_arch (fi
);
1433 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1434 is not a good name. */
1435 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1436 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1437 easily not match that of the internal value returned by
1439 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1441 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1442 architectures will often have a hardware register called "pc",
1443 and that register's value, again, can easily not match
1447 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1448 find_frame_sal (fi
, &sal
);
1449 func
= get_frame_function (fi
);
1453 funname
= SYMBOL_PRINT_NAME (func
);
1454 funlang
= SYMBOL_LANGUAGE (func
);
1455 if (funlang
== language_cplus
)
1457 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1458 to display the demangled name that we already have
1459 stored in the symbol table, but we stored a version
1460 with DMGL_PARAMS turned on, and here we don't want to
1461 display parameters. So remove the parameters. */
1462 char *func_only
= cp_remove_params (funname
);
1466 funname
= func_only
;
1467 make_cleanup (xfree
, func_only
);
1471 else if (frame_pc_p
)
1473 struct bound_minimal_symbol msymbol
;
1475 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1476 if (msymbol
.minsym
!= NULL
)
1478 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1479 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1482 calling_frame_info
= get_prev_frame (fi
);
1484 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1486 printf_filtered (_("Stack level %d, frame at "),
1487 frame_relative_level (fi
));
1491 printf_filtered (_("Stack frame at "));
1493 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1494 printf_filtered (":\n");
1495 printf_filtered (" %s = ", pc_regname
);
1497 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1499 fputs_filtered ("<unavailable>", gdb_stdout
);
1504 printf_filtered (" in ");
1505 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1506 DMGL_ANSI
| DMGL_PARAMS
);
1510 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1512 puts_filtered ("; ");
1514 printf_filtered ("saved %s = ", pc_regname
);
1516 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1517 val_print_not_saved (gdb_stdout
);
1522 caller_pc
= frame_unwind_caller_pc (fi
);
1525 CATCH (ex
, RETURN_MASK_ERROR
)
1529 case NOT_AVAILABLE_ERROR
:
1530 val_print_unavailable (gdb_stdout
);
1532 case OPTIMIZED_OUT_ERROR
:
1533 val_print_not_saved (gdb_stdout
);
1536 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1544 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1545 printf_filtered ("\n");
1547 if (calling_frame_info
== NULL
)
1549 enum unwind_stop_reason reason
;
1551 reason
= get_frame_unwind_stop_reason (fi
);
1552 if (reason
!= UNWIND_NO_REASON
)
1553 printf_filtered (_(" Outermost frame: %s\n"),
1554 frame_stop_reason_string (fi
));
1556 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1557 puts_filtered (" tail call frame");
1558 else if (get_frame_type (fi
) == INLINE_FRAME
)
1559 printf_filtered (" inlined into frame %d",
1560 frame_relative_level (get_prev_frame (fi
)));
1563 printf_filtered (" called by frame at ");
1564 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1567 if (get_next_frame (fi
) && calling_frame_info
)
1568 puts_filtered (",");
1570 if (get_next_frame (fi
))
1572 printf_filtered (" caller of frame at ");
1573 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1576 if (get_next_frame (fi
) || calling_frame_info
)
1577 puts_filtered ("\n");
1580 printf_filtered (" source language %s.\n",
1581 language_str (s
->language
));
1584 /* Address of the argument list for this frame, or 0. */
1585 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1586 /* Number of args for this frame, or -1 if unknown. */
1590 printf_filtered (" Arglist at unknown address.\n");
1593 printf_filtered (" Arglist at ");
1594 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1595 printf_filtered (",");
1597 if (!gdbarch_frame_num_args_p (gdbarch
))
1600 puts_filtered (" args: ");
1604 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1605 gdb_assert (numargs
>= 0);
1607 puts_filtered (" no args.");
1608 else if (numargs
== 1)
1609 puts_filtered (" 1 arg: ");
1611 printf_filtered (" %d args: ", numargs
);
1613 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1614 puts_filtered ("\n");
1618 /* Address of the local variables for this frame, or 0. */
1619 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1622 printf_filtered (" Locals at unknown address,");
1625 printf_filtered (" Locals at ");
1626 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1627 printf_filtered (",");
1631 /* Print as much information as possible on the location of all the
1634 enum lval_type lval
;
1643 /* The sp is special; what's displayed isn't the save address, but
1644 the value of the previous frame's sp. This is a legacy thing,
1645 at one stage the frame cached the previous frame's SP instead
1646 of its address, hence it was easiest to just display the cached
1648 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1650 /* Find out the location of the saved stack pointer with out
1651 actually evaluating it. */
1652 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1653 &optimized
, &unavailable
, &lval
, &addr
,
1655 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1657 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1658 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1659 gdb_byte value
[MAX_REGISTER_SIZE
];
1662 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1663 &optimized
, &unavailable
, &lval
, &addr
,
1665 /* NOTE: cagney/2003-05-22: This is assuming that the
1666 stack pointer was packed as an unsigned integer. That
1667 may or may not be valid. */
1668 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1669 printf_filtered (" Previous frame's sp is ");
1670 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1671 printf_filtered ("\n");
1674 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1676 printf_filtered (" Previous frame's sp at ");
1677 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1678 printf_filtered ("\n");
1681 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1683 printf_filtered (" Previous frame's sp in %s\n",
1684 gdbarch_register_name (gdbarch
, realnum
));
1687 /* else keep quiet. */
1691 numregs
= gdbarch_num_regs (gdbarch
)
1692 + gdbarch_num_pseudo_regs (gdbarch
);
1693 for (i
= 0; i
< numregs
; i
++)
1694 if (i
!= gdbarch_sp_regnum (gdbarch
)
1695 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1697 /* Find out the location of the saved register without
1698 fetching the corresponding value. */
1699 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1700 &lval
, &addr
, &realnum
, NULL
);
1701 /* For moment, only display registers that were saved on the
1703 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1706 puts_filtered (" Saved registers:\n ");
1708 puts_filtered (",");
1710 printf_filtered (" %s at ",
1711 gdbarch_register_name (gdbarch
, i
));
1712 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1716 if (count
|| need_nl
)
1717 puts_filtered ("\n");
1720 do_cleanups (back_to
);
1723 /* Print briefly all stack frames or just the innermost COUNT_EXP
1727 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1730 struct frame_info
*fi
;
1733 struct frame_info
*trailing
;
1734 int trailing_level
, py_start
= 0, py_end
= 0;
1735 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1737 if (!target_has_stack
)
1738 error (_("No stack."));
1740 /* The following code must do two things. First, it must set the
1741 variable TRAILING to the frame from which we should start
1742 printing. Second, it must set the variable count to the number
1743 of frames which we should print, or -1 if all of them. */
1744 trailing
= get_current_frame ();
1749 count
= parse_and_eval_long (count_exp
);
1752 struct frame_info
*current
;
1758 while (current
&& count
--)
1761 current
= get_prev_frame (current
);
1764 /* Will stop when CURRENT reaches the top of the stack.
1765 TRAILING will be COUNT below it. */
1769 trailing
= get_prev_frame (trailing
);
1770 current
= get_prev_frame (current
);
1790 /* Read in symbols for all of the frames. Need to do this in a
1791 separate pass so that "Reading in symbols for xxx" messages
1792 don't screw up the appearance of the backtrace. Also if
1793 people have strong opinions against reading symbols for
1794 backtrace this may have to be an option. */
1796 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1801 pc
= get_frame_address_in_block (fi
);
1802 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1808 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1809 enum ext_lang_frame_args arg_type
;
1812 flags
|= PRINT_LOCALS
;
1814 if (!strcmp (print_frame_arguments
, "scalars"))
1815 arg_type
= CLI_SCALAR_VALUES
;
1816 else if (!strcmp (print_frame_arguments
, "all"))
1817 arg_type
= CLI_ALL_VALUES
;
1819 arg_type
= NO_VALUES
;
1821 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1822 arg_type
, current_uiout
,
1826 /* Run the inbuilt backtrace if there are no filters registered, or
1827 "no-filters" has been specified from the command. */
1828 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1830 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1834 /* Don't use print_stack_frame; if an error() occurs it probably
1835 means further attempts to backtrace would fail (on the other
1836 hand, perhaps the code does or could be fixed to make sure
1837 the frame->prev field gets set to NULL in that case). */
1839 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1842 struct frame_id frame_id
= get_frame_id (fi
);
1844 print_frame_local_vars (fi
, 1, gdb_stdout
);
1846 /* print_frame_local_vars invalidates FI. */
1847 fi
= frame_find_by_id (frame_id
);
1851 warning (_("Unable to restore previously selected frame."));
1856 /* Save the last frame to check for error conditions. */
1860 /* If we've stopped before the end, mention that. */
1862 printf_filtered (_("(More stack frames follow...)\n"));
1864 /* If we've run out of frames, and the reason appears to be an error
1865 condition, print it. */
1866 if (fi
== NULL
&& trailing
!= NULL
)
1868 enum unwind_stop_reason reason
;
1870 reason
= get_frame_unwind_stop_reason (trailing
);
1871 if (reason
>= UNWIND_FIRST_ERROR
)
1872 printf_filtered (_("Backtrace stopped: %s\n"),
1873 frame_stop_reason_string (trailing
));
1879 backtrace_command (char *arg
, int from_tty
)
1881 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1882 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1890 argv
= gdb_buildargv (arg
);
1891 make_cleanup_freeargv (argv
);
1893 for (i
= 0; argv
[i
]; i
++)
1897 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1898 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1900 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1904 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1905 fulltrace_arg
= argc
;
1909 arglen
+= strlen (argv
[i
]);
1915 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1919 arg
= (char *) xmalloc (arglen
+ 1);
1920 make_cleanup (xfree
, arg
);
1922 for (i
= 0; i
< argc
; i
++)
1924 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1926 strcat (arg
, argv
[i
]);
1936 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1937 no_filters
>= 0 /* no frame-filters */, from_tty
);
1939 do_cleanups (old_chain
);
1942 /* Iterate over the local variables of a block B, calling CB with
1946 iterate_over_block_locals (const struct block
*b
,
1947 iterate_over_block_arg_local_vars_cb cb
,
1950 struct block_iterator iter
;
1953 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1955 switch (SYMBOL_CLASS (sym
))
1961 if (SYMBOL_IS_ARGUMENT (sym
))
1963 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1965 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1969 /* Ignore symbols which are not locals. */
1976 /* Same, but print labels. */
1979 /* Commented out, as the code using this function has also been
1980 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1981 was commented out in the first place. The discussion introducing
1982 this change (2007-12-04: Support lexical blocks and function bodies
1983 that occupy non-contiguous address ranges) did not explain why
1984 this change was made. */
1986 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1987 int *have_default
, struct ui_file
*stream
)
1989 struct block_iterator iter
;
1991 int values_printed
= 0;
1993 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1995 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2001 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2003 struct symtab_and_line sal
;
2004 struct value_print_options opts
;
2006 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2008 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2009 get_user_print_options (&opts
);
2010 if (opts
.addressprint
)
2012 fprintf_filtered (stream
, " ");
2013 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2016 fprintf_filtered (stream
, " in file %s, line %d\n",
2017 sal
.symtab
->filename
, sal
.line
);
2021 return values_printed
;
2025 /* Iterate over all the local variables in block B, including all its
2026 superblocks, stopping when the top-level block is reached. */
2029 iterate_over_block_local_vars (const struct block
*block
,
2030 iterate_over_block_arg_local_vars_cb cb
,
2035 iterate_over_block_locals (block
, cb
, cb_data
);
2036 /* After handling the function's top-level block, stop. Don't
2037 continue to its superblock, the block of per-file
2039 if (BLOCK_FUNCTION (block
))
2041 block
= BLOCK_SUPERBLOCK (block
);
2045 /* Data to be passed around in the calls to the locals and args
2048 struct print_variable_and_value_data
2050 struct frame_id frame_id
;
2052 struct ui_file
*stream
;
2056 /* The callback for the locals and args iterators. */
2059 do_print_variable_and_value (const char *print_name
,
2063 struct print_variable_and_value_data
*p
2064 = (struct print_variable_and_value_data
*) cb_data
;
2065 struct frame_info
*frame
;
2067 frame
= frame_find_by_id (p
->frame_id
);
2070 warning (_("Unable to restore previously selected frame."));
2074 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2076 /* print_variable_and_value invalidates FRAME. */
2079 p
->values_printed
= 1;
2082 /* Print all variables from the innermost up to the function block of FRAME.
2083 Print them with values to STREAM indented by NUM_TABS.
2085 This function will invalidate FRAME. */
2088 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2089 struct ui_file
*stream
)
2091 struct print_variable_and_value_data cb_data
;
2092 const struct block
*block
;
2094 struct gdb_exception except
= exception_none
;
2096 if (!get_frame_pc_if_available (frame
, &pc
))
2098 fprintf_filtered (stream
,
2099 _("PC unavailable, cannot determine locals.\n"));
2103 block
= get_frame_block (frame
, 0);
2106 fprintf_filtered (stream
, "No symbol table info available.\n");
2110 cb_data
.frame_id
= get_frame_id (frame
);
2111 cb_data
.num_tabs
= 4 * num_tabs
;
2112 cb_data
.stream
= stream
;
2113 cb_data
.values_printed
= 0;
2115 /* Temporarily change the selected frame to the given FRAME.
2116 This allows routines that rely on the selected frame instead
2117 of being given a frame as parameter to use the correct frame. */
2118 select_frame (frame
);
2122 iterate_over_block_local_vars (block
,
2123 do_print_variable_and_value
,
2126 CATCH (ex
, RETURN_MASK_ALL
)
2132 /* Restore the selected frame, and then rethrow if there was a problem. */
2133 select_frame (frame_find_by_id (cb_data
.frame_id
));
2134 if (except
.reason
< 0)
2135 throw_exception (except
);
2137 /* do_print_variable_and_value invalidates FRAME. */
2140 if (!cb_data
.values_printed
)
2141 fprintf_filtered (stream
, _("No locals.\n"));
2145 locals_info (char *args
, int from_tty
)
2147 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2151 /* Iterate over all the argument variables in block B.
2153 Returns 1 if any argument was walked; 0 otherwise. */
2156 iterate_over_block_arg_vars (const struct block
*b
,
2157 iterate_over_block_arg_local_vars_cb cb
,
2160 struct block_iterator iter
;
2161 struct symbol
*sym
, *sym2
;
2163 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2165 /* Don't worry about things which aren't arguments. */
2166 if (SYMBOL_IS_ARGUMENT (sym
))
2168 /* We have to look up the symbol because arguments can have
2169 two entries (one a parameter, one a local) and the one we
2170 want is the local, which lookup_symbol will find for us.
2171 This includes gcc1 (not gcc2) on the sparc when passing a
2172 small structure and gcc2 when the argument type is float
2173 and it is passed as a double and converted to float by
2174 the prologue (in the latter case the type of the LOC_ARG
2175 symbol is double and the type of the LOC_LOCAL symbol is
2176 float). There are also LOC_ARG/LOC_REGISTER pairs which
2177 are not combined in symbol-reading. */
2179 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2180 b
, VAR_DOMAIN
, NULL
).symbol
;
2181 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2186 /* Print all argument variables of the function of FRAME.
2187 Print them with values to STREAM.
2189 This function will invalidate FRAME. */
2192 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2194 struct print_variable_and_value_data cb_data
;
2195 struct symbol
*func
;
2198 if (!get_frame_pc_if_available (frame
, &pc
))
2200 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2204 func
= get_frame_function (frame
);
2207 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2211 cb_data
.frame_id
= get_frame_id (frame
);
2212 cb_data
.num_tabs
= 0;
2213 cb_data
.stream
= gdb_stdout
;
2214 cb_data
.values_printed
= 0;
2216 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2217 do_print_variable_and_value
, &cb_data
);
2219 /* do_print_variable_and_value invalidates FRAME. */
2222 if (!cb_data
.values_printed
)
2223 fprintf_filtered (stream
, _("No arguments.\n"));
2227 args_info (char *ignore
, int from_tty
)
2229 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2233 /* Select frame FRAME. Also print the stack frame and show the source
2234 if this is the tui version. */
2236 select_and_print_frame (struct frame_info
*frame
)
2238 select_frame (frame
);
2240 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2243 /* Return the symbol-block in which the selected frame is executing.
2244 Can return zero under various legitimate circumstances.
2246 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2247 code address within the block returned. We use this to decide
2248 which macros are in scope. */
2250 const struct block
*
2251 get_selected_block (CORE_ADDR
*addr_in_block
)
2253 if (!has_stack_frames ())
2256 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2259 /* Find a frame a certain number of levels away from FRAME.
2260 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2261 Positive means go to earlier frames (up); negative, the reverse.
2262 The int that contains the number of levels is counted toward
2263 zero as the frames for those levels are found.
2264 If the top or bottom frame is reached, that frame is returned,
2265 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2266 how much farther the original request asked to go. */
2269 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2271 /* Going up is simple: just call get_prev_frame enough times or
2272 until the initial frame is reached. */
2273 while (*level_offset_ptr
> 0)
2275 struct frame_info
*prev
= get_prev_frame (frame
);
2279 (*level_offset_ptr
)--;
2283 /* Going down is just as simple. */
2284 while (*level_offset_ptr
< 0)
2286 struct frame_info
*next
= get_next_frame (frame
);
2290 (*level_offset_ptr
)++;
2297 /* The "select_frame" command. With no argument this is a NOP.
2298 Select the frame at level LEVEL_EXP if it is a valid level.
2299 Otherwise, treat LEVEL_EXP as an address expression and select it.
2301 See parse_frame_specification for more info on proper frame
2305 select_frame_command (char *level_exp
, int from_tty
)
2307 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2309 select_frame (parse_frame_specification (level_exp
, NULL
));
2310 if (get_selected_frame_if_set () != prev_frame
)
2311 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2314 /* The "frame" command. With no argument, print the selected frame
2315 briefly. With an argument, behave like select_frame and then print
2316 the selected frame. */
2319 frame_command (char *level_exp
, int from_tty
)
2321 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2323 select_frame (parse_frame_specification (level_exp
, NULL
));
2324 if (get_selected_frame_if_set () != prev_frame
)
2325 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2327 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
2330 /* Select the frame up one or COUNT_EXP stack levels from the
2331 previously selected frame, and print it briefly. */
2334 up_silently_base (const char *count_exp
)
2336 struct frame_info
*frame
;
2340 count
= parse_and_eval_long (count_exp
);
2342 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2343 if (count
!= 0 && count_exp
== NULL
)
2344 error (_("Initial frame selected; you cannot go up."));
2345 select_frame (frame
);
2349 up_silently_command (char *count_exp
, int from_tty
)
2351 up_silently_base (count_exp
);
2355 up_command (char *count_exp
, int from_tty
)
2357 up_silently_base (count_exp
);
2358 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2361 /* Select the frame down one or COUNT_EXP stack levels from the previously
2362 selected frame, and print it briefly. */
2365 down_silently_base (const char *count_exp
)
2367 struct frame_info
*frame
;
2371 count
= -parse_and_eval_long (count_exp
);
2373 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2374 if (count
!= 0 && count_exp
== NULL
)
2376 /* We only do this if COUNT_EXP is not specified. That way
2377 "down" means to really go down (and let me know if that is
2378 impossible), but "down 9999" can be used to mean go all the
2379 way down without getting an error. */
2381 error (_("Bottom (innermost) frame selected; you cannot go down."));
2384 select_frame (frame
);
2388 down_silently_command (char *count_exp
, int from_tty
)
2390 down_silently_base (count_exp
);
2394 down_command (char *count_exp
, int from_tty
)
2396 down_silently_base (count_exp
);
2397 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2401 return_command (char *retval_exp
, int from_tty
)
2403 /* Initialize it just to avoid a GCC false warning. */
2404 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2405 struct frame_info
*thisframe
;
2406 struct gdbarch
*gdbarch
;
2407 struct symbol
*thisfun
;
2408 struct value
*return_value
= NULL
;
2409 struct value
*function
= NULL
;
2410 const char *query_prefix
= "";
2412 thisframe
= get_selected_frame ("No selected frame.");
2413 thisfun
= get_frame_function (thisframe
);
2414 gdbarch
= get_frame_arch (thisframe
);
2416 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2417 error (_("Can not force return from an inlined function."));
2419 /* Compute the return value. If the computation triggers an error,
2420 let it bail. If the return type can't be handled, set
2421 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2425 expression_up retval_expr
= parse_expression (retval_exp
);
2426 struct type
*return_type
= NULL
;
2428 /* Compute the return value. Should the computation fail, this
2429 call throws an error. */
2430 return_value
= evaluate_expression (retval_expr
.get ());
2432 /* Cast return value to the return type of the function. Should
2433 the cast fail, this call throws an error. */
2434 if (thisfun
!= NULL
)
2435 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2436 if (return_type
== NULL
)
2438 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2439 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2440 error (_("Return value type not available for selected "
2442 "Please use an explicit cast of the value to return."));
2443 return_type
= value_type (return_value
);
2445 return_type
= check_typedef (return_type
);
2446 return_value
= value_cast (return_type
, return_value
);
2448 /* Make sure the value is fully evaluated. It may live in the
2449 stack frame we're about to pop. */
2450 if (value_lazy (return_value
))
2451 value_fetch_lazy (return_value
);
2453 if (thisfun
!= NULL
)
2454 function
= read_var_value (thisfun
, NULL
, thisframe
);
2456 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2457 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2458 /* If the return-type is "void", don't try to find the
2459 return-value's location. However, do still evaluate the
2460 return expression so that, even when the expression result
2461 is discarded, side effects such as "return i++" still
2463 return_value
= NULL
;
2464 else if (thisfun
!= NULL
)
2466 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2467 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2468 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2470 query_prefix
= "The location at which to store the "
2471 "function's return value is unknown.\n"
2472 "If you continue, the return value "
2473 "that you specified will be ignored.\n";
2474 return_value
= NULL
;
2479 /* Does an interactive user really want to do this? Include
2480 information, such as how well GDB can handle the return value, in
2481 the query message. */
2486 if (thisfun
== NULL
)
2487 confirmed
= query (_("%sMake selected stack frame return now? "),
2491 if (TYPE_NO_RETURN (thisfun
->type
))
2492 warning (_("Function does not return normally to caller."));
2493 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2494 SYMBOL_PRINT_NAME (thisfun
));
2497 error (_("Not confirmed"));
2500 /* Discard the selected frame and all frames inner-to it. */
2501 frame_pop (get_selected_frame (NULL
));
2503 /* Store RETURN_VALUE in the just-returned register set. */
2504 if (return_value
!= NULL
)
2506 struct type
*return_type
= value_type (return_value
);
2507 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2509 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2510 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2511 gdbarch_return_value (gdbarch
, function
, return_type
,
2512 get_current_regcache (), NULL
/*read*/,
2513 value_contents (return_value
) /*write*/);
2516 /* If we are at the end of a call dummy now, pop the dummy frame
2518 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2519 frame_pop (get_current_frame ());
2521 select_frame (get_current_frame ());
2522 /* If interactive, print the frame that is now current. */
2524 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2527 /* Sets the scope to input function name, provided that the function
2528 is within the current stack frame. */
2530 struct function_bounds
2532 CORE_ADDR low
, high
;
2536 func_command (char *arg
, int from_tty
)
2538 struct frame_info
*frame
;
2540 struct symtabs_and_lines sals
;
2543 struct function_bounds
*func_bounds
= NULL
;
2544 struct cleanup
*cleanups
;
2549 frame
= get_current_frame ();
2550 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2551 cleanups
= make_cleanup (xfree
, sals
.sals
);
2552 func_bounds
= XNEWVEC (struct function_bounds
, sals
.nelts
);
2553 make_cleanup (xfree
, func_bounds
);
2554 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2556 if (sals
.sals
[i
].pspace
!= current_program_space
)
2557 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2558 else if (sals
.sals
[i
].pc
== 0
2559 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2560 &func_bounds
[i
].low
,
2561 &func_bounds
[i
].high
) == 0)
2563 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2569 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2570 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2571 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2575 frame
= find_relative_frame (frame
, &level
);
2578 while (!found
&& level
== 0);
2580 do_cleanups (cleanups
);
2583 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2584 else if (frame
!= get_selected_frame (NULL
))
2585 select_and_print_frame (frame
);
2589 /* Provide a prototype to silence -Wmissing-prototypes. */
2590 void _initialize_stack (void);
2593 _initialize_stack (void)
2595 add_com ("return", class_stack
, return_command
, _("\
2596 Make selected stack frame return to its caller.\n\
2597 Control remains in the debugger, but when you continue\n\
2598 execution will resume in the frame above the one now selected.\n\
2599 If an argument is given, it is an expression for the value to return."));
2601 add_com ("up", class_stack
, up_command
, _("\
2602 Select and print stack frame that called this one.\n\
2603 An argument says how many frames up to go."));
2604 add_com ("up-silently", class_support
, up_silently_command
, _("\
2605 Same as the `up' command, but does not print anything.\n\
2606 This is useful in command scripts."));
2608 add_com ("down", class_stack
, down_command
, _("\
2609 Select and print stack frame called by this one.\n\
2610 An argument says how many frames down to go."));
2611 add_com_alias ("do", "down", class_stack
, 1);
2612 add_com_alias ("dow", "down", class_stack
, 1);
2613 add_com ("down-silently", class_support
, down_silently_command
, _("\
2614 Same as the `down' command, but does not print anything.\n\
2615 This is useful in command scripts."));
2617 add_com ("frame", class_stack
, frame_command
, _("\
2618 Select and print a stack frame.\nWith no argument, \
2619 print the selected stack frame. (See also \"info frame\").\n\
2620 An argument specifies the frame to select.\n\
2621 It can be a stack frame number or the address of the frame.\n"));
2623 add_com_alias ("f", "frame", class_stack
, 1);
2625 add_com_suppress_notification ("select-frame", class_stack
, select_frame_command
, _("\
2626 Select a stack frame without printing anything.\n\
2627 An argument specifies the frame to select.\n\
2628 It can be a stack frame number or the address of the frame.\n"),
2629 &cli_suppress_notification
.user_selected_context
);
2631 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2632 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2633 With a negative argument, print outermost -COUNT frames.\nUse of the \
2634 'full' qualifier also prints the values of the local variables.\n\
2635 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2636 on this backtrace.\n"));
2637 add_com_alias ("bt", "backtrace", class_stack
, 0);
2639 add_com_alias ("where", "backtrace", class_alias
, 0);
2640 add_info ("stack", backtrace_command
,
2641 _("Backtrace of the stack, or innermost COUNT frames."));
2642 add_info_alias ("s", "stack", 1);
2643 add_info ("frame", frame_info
,
2644 _("All about selected stack frame, or frame at ADDR."));
2645 add_info_alias ("f", "frame", 1);
2646 add_info ("locals", locals_info
,
2647 _("Local variables of current stack frame."));
2648 add_info ("args", args_info
,
2649 _("Argument variables of current stack frame."));
2652 add_com ("func", class_stack
, func_command
, _("\
2653 Select the stack frame that contains <func>.\n\
2654 Usage: func <name>\n"));
2656 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2657 print_frame_arguments_choices
, &print_frame_arguments
,
2658 _("Set printing of non-scalar frame arguments"),
2659 _("Show printing of non-scalar frame arguments"),
2660 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2662 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2663 &print_raw_frame_arguments
, _("\
2664 Set whether to print frame arguments in raw form."), _("\
2665 Show whether to print frame arguments in raw form."), _("\
2666 If set, frame arguments are printed in raw form, bypassing any\n\
2667 pretty-printers for that value."),
2669 &setprintrawlist
, &showprintrawlist
);
2671 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2672 &disassemble_next_line
, _("\
2673 Set whether to disassemble next source line or insn when execution stops."),
2675 Show whether to disassemble next source line or insn when execution stops."),
2677 If ON, GDB will display disassembly of the next source line, in addition\n\
2678 to displaying the source line itself. If the next source line cannot\n\
2679 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2680 will display disassembly of next instruction instead of showing the\n\
2682 If AUTO, display disassembly of next instruction only if the source line\n\
2683 cannot be displayed.\n\
2684 If OFF (which is the default), never display the disassembly of the next\n\
2687 show_disassemble_next_line
,
2688 &setlist
, &showlist
);
2689 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2691 add_setshow_enum_cmd ("entry-values", class_stack
,
2692 print_entry_values_choices
, &print_entry_values
,
2693 _("Set printing of function arguments at function "
2695 _("Show printing of function arguments at function "
2698 GDB can sometimes determine the values of function arguments at entry,\n\
2699 in addition to their current values. This option tells GDB whether\n\
2700 to print the current value, the value at entry (marked as val@entry),\n\
2701 or both. Note that one or both of these values may be <optimized out>."),
2702 NULL
, NULL
, &setprintlist
, &showprintlist
);