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
;
229 const char *error_message
= NULL
;
231 stb
= mem_fileopen ();
232 old_chain
= make_cleanup_ui_file_delete (stb
);
234 gdb_assert (!arg
->val
|| !arg
->error
);
235 gdb_assert (arg
->entry_kind
== print_entry_values_no
236 || arg
->entry_kind
== print_entry_values_only
237 || (!uiout
->is_mi_like_p ()
238 && arg
->entry_kind
== print_entry_values_compact
));
240 annotate_arg_begin ();
242 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
243 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
244 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
245 if (arg
->entry_kind
== print_entry_values_compact
)
247 /* It is OK to provide invalid MI-like stream as with
248 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
249 fputs_filtered ("=", stb
);
251 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
252 SYMBOL_LANGUAGE (arg
->sym
),
253 DMGL_PARAMS
| DMGL_ANSI
);
255 if (arg
->entry_kind
== print_entry_values_only
256 || arg
->entry_kind
== print_entry_values_compact
)
257 fputs_filtered ("@entry", stb
);
258 uiout
->field_stream ("name", stb
);
259 annotate_arg_name_end ();
262 if (!arg
->val
&& !arg
->error
)
267 error_message
= arg
->error
;
272 const struct language_defn
*language
;
273 struct value_print_options opts
;
275 /* Avoid value_print because it will deref ref parameters. We
276 just want to print their addresses. Print ??? for args whose
277 address we do not know. We pass 2 as "recurse" to val_print
278 because our standard indentation here is 4 spaces, and
279 val_print indents 2 for each recurse. */
281 annotate_arg_value (value_type (arg
->val
));
283 /* Use the appropriate language to display our symbol, unless the
284 user forced the language to a specific language. */
285 if (language_mode
== language_mode_auto
)
286 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
288 language
= current_language
;
290 get_no_prettyformat_print_options (&opts
);
292 opts
.raw
= print_raw_frame_arguments
;
294 /* True in "summary" mode, false otherwise. */
295 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
297 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
299 CATCH (except
, RETURN_MASK_ERROR
)
301 error_message
= except
.message
;
305 if (error_message
!= NULL
)
306 fprintf_filtered (stb
, _("<error reading variable: %s>"),
310 uiout
->field_stream ("value", stb
);
312 /* Also invoke ui_out_tuple_end. */
313 do_cleanups (old_chain
);
318 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
319 responsible for xfree of ARGP->ERROR. This function never throws an
323 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
324 struct frame_arg
*argp
)
332 argp
->val
= read_var_value (sym
, NULL
, frame
);
334 CATCH (except
, RETURN_MASK_ERROR
)
336 argp
->error
= xstrdup (except
.message
);
341 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
342 responsible for xfree of ARGP->ERROR. This function never throws an
346 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
347 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
349 struct value
*val
= NULL
, *entryval
= NULL
;
350 char *val_error
= NULL
, *entryval_error
= NULL
;
353 if (print_entry_values
!= print_entry_values_only
354 && print_entry_values
!= print_entry_values_preferred
)
358 val
= read_var_value (sym
, NULL
, frame
);
360 CATCH (except
, RETURN_MASK_ERROR
)
362 val_error
= (char *) alloca (strlen (except
.message
) + 1);
363 strcpy (val_error
, except
.message
);
368 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
369 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
370 && print_entry_values
!= print_entry_values_no
371 && (print_entry_values
!= print_entry_values_if_needed
372 || !val
|| value_optimized_out (val
)))
376 const struct symbol_computed_ops
*ops
;
378 ops
= SYMBOL_COMPUTED_OPS (sym
);
379 entryval
= ops
->read_variable_at_entry (sym
, frame
);
381 CATCH (except
, RETURN_MASK_ERROR
)
383 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
385 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
386 strcpy (entryval_error
, except
.message
);
391 if (entryval
!= NULL
&& value_optimized_out (entryval
))
394 if (print_entry_values
== print_entry_values_compact
395 || print_entry_values
== print_entry_values_default
)
397 /* For MI do not try to use print_entry_values_compact for ARGP. */
399 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
401 struct type
*type
= value_type (val
);
403 if (value_lazy (val
))
404 value_fetch_lazy (val
);
405 if (value_lazy (entryval
))
406 value_fetch_lazy (entryval
);
408 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
410 /* Initialize it just to avoid a GCC false warning. */
411 struct value
*val_deref
= NULL
, *entryval_deref
;
413 /* DW_AT_GNU_call_site_value does match with the current
414 value. If it is a reference still try to verify if
415 dereferenced DW_AT_GNU_call_site_data_value does not
420 struct type
*type_deref
;
422 val_deref
= coerce_ref (val
);
423 if (value_lazy (val_deref
))
424 value_fetch_lazy (val_deref
);
425 type_deref
= value_type (val_deref
);
427 entryval_deref
= coerce_ref (entryval
);
428 if (value_lazy (entryval_deref
))
429 value_fetch_lazy (entryval_deref
);
431 /* If the reference addresses match but dereferenced
432 content does not match print them. */
434 && value_contents_eq (val_deref
, 0,
436 TYPE_LENGTH (type_deref
)))
439 CATCH (except
, RETURN_MASK_ERROR
)
441 /* If the dereferenced content could not be
442 fetched do not display anything. */
443 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
445 else if (except
.message
!= NULL
)
447 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
448 strcpy (entryval_error
, except
.message
);
453 /* Value was not a reference; and its content matches. */
454 if (val
== val_deref
)
462 /* Try to remove possibly duplicate error message for ENTRYARGP even
465 if (val_error
&& entryval_error
466 && strcmp (val_error
, entryval_error
) == 0)
468 entryval_error
= NULL
;
470 /* Do not se VAL_EQUAL as the same error message may be shown for
471 the entry value even if no entry values are present in the
477 if (entryval
== NULL
)
479 if (print_entry_values
== print_entry_values_preferred
)
481 gdb_assert (val
== NULL
);
485 val
= read_var_value (sym
, NULL
, frame
);
487 CATCH (except
, RETURN_MASK_ERROR
)
489 val_error
= (char *) alloca (strlen (except
.message
) + 1);
490 strcpy (val_error
, except
.message
);
494 if (print_entry_values
== print_entry_values_only
495 || print_entry_values
== print_entry_values_both
496 || (print_entry_values
== print_entry_values_preferred
497 && (!val
|| value_optimized_out (val
))))
499 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
500 entryval_error
= NULL
;
503 if ((print_entry_values
== print_entry_values_compact
504 || print_entry_values
== print_entry_values_if_needed
505 || print_entry_values
== print_entry_values_preferred
)
506 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
514 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
515 if (!val
&& !val_error
)
516 argp
->entry_kind
= print_entry_values_only
;
517 else if ((print_entry_values
== print_entry_values_compact
518 || print_entry_values
== print_entry_values_default
) && val_equal
)
520 argp
->entry_kind
= print_entry_values_compact
;
521 gdb_assert (!current_uiout
->is_mi_like_p ());
524 argp
->entry_kind
= print_entry_values_no
;
526 entryargp
->sym
= sym
;
527 entryargp
->val
= entryval
;
528 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
529 if (!entryval
&& !entryval_error
)
530 entryargp
->entry_kind
= print_entry_values_no
;
532 entryargp
->entry_kind
= print_entry_values_only
;
535 /* Print the arguments of frame FRAME on STREAM, given the function
536 FUNC running in that frame (as a symbol), where NUM is the number
537 of arguments according to the stack frame (or -1 if the number of
538 arguments is unknown). */
540 /* Note that currently the "number of arguments according to the
541 stack frame" is only known on VAX where i refers to the "number of
542 ints of arguments according to the stack frame". */
545 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
546 int num
, struct ui_file
*stream
)
548 struct ui_out
*uiout
= current_uiout
;
550 /* Offset of next stack argument beyond the one we have seen that is
551 at the highest offset, or -1 if we haven't come to a stack
553 long highest_offset
= -1;
554 /* Number of ints of arguments that we have printed so far. */
555 int args_printed
= 0;
556 /* True if we should print arguments, false otherwise. */
557 int print_args
= strcmp (print_frame_arguments
, "none");
561 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
562 struct block_iterator iter
;
565 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
567 struct frame_arg arg
, entryarg
;
571 /* Keep track of the highest stack argument offset seen, and
572 skip over any kinds of symbols we don't care about. */
574 if (!SYMBOL_IS_ARGUMENT (sym
))
577 switch (SYMBOL_CLASS (sym
))
582 long current_offset
= SYMBOL_VALUE (sym
);
583 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
585 /* Compute address of next argument by adding the size of
586 this argument and rounding to an int boundary. */
588 ((current_offset
+ arg_size
+ sizeof (int) - 1)
589 & ~(sizeof (int) - 1));
591 /* If this is the highest offset seen yet, set
593 if (highest_offset
== -1
594 || (current_offset
> highest_offset
))
595 highest_offset
= current_offset
;
597 /* Add the number of ints we're about to print to
599 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
602 /* We care about types of symbols, but don't need to
603 keep track of stack offsets in them. */
605 case LOC_REGPARM_ADDR
:
607 case LOC_OPTIMIZED_OUT
:
612 /* We have to look up the symbol because arguments can have
613 two entries (one a parameter, one a local) and the one we
614 want is the local, which lookup_symbol will find for us.
615 This includes gcc1 (not gcc2) on SPARC when passing a
616 small structure and gcc2 when the argument type is float
617 and it is passed as a double and converted to float by
618 the prologue (in the latter case the type of the LOC_ARG
619 symbol is double and the type of the LOC_LOCAL symbol is
621 /* But if the parameter name is null, don't try it. Null
622 parameter names occur on the RS/6000, for traceback
623 tables. FIXME, should we even print them? */
625 if (*SYMBOL_LINKAGE_NAME (sym
))
629 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
630 b
, VAR_DOMAIN
, NULL
).symbol
;
631 gdb_assert (nsym
!= NULL
);
632 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
633 && !SYMBOL_IS_ARGUMENT (nsym
))
635 /* There is a LOC_ARG/LOC_REGISTER pair. This means
636 that it was passed on the stack and loaded into a
637 register, or passed in a register and stored in a
638 stack slot. GDB 3.x used the LOC_ARG; GDB
639 4.0-4.11 used the LOC_REGISTER.
641 Reasons for using the LOC_ARG:
643 (1) Because find_saved_registers may be slow for
646 (2) Because registers are often re-used and stack
647 slots rarely (never?) are. Therefore using
648 the stack slot is much less likely to print
651 Reasons why we might want to use the LOC_REGISTER:
653 (1) So that the backtrace prints the same value
654 as "print foo". I see no compelling reason
655 why this needs to be the case; having the
656 backtrace print the value which was passed
657 in, and "print foo" print the value as
658 modified within the called function, makes
661 Additional note: It might be nice if "info args"
662 displayed both values.
664 One more note: There is a case with SPARC
665 structure passing where we need to use the
666 LOC_REGISTER, but this is dealt with by creating
667 a single LOC_REGPARM in symbol reading. */
669 /* Leave sym (the LOC_ARG) alone. */
676 /* Print the current arg. */
679 uiout
->wrap_hint (" ");
683 memset (&arg
, 0, sizeof (arg
));
685 arg
.entry_kind
= print_entry_values_no
;
686 memset (&entryarg
, 0, sizeof (entryarg
));
688 entryarg
.entry_kind
= print_entry_values_no
;
691 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
693 if (arg
.entry_kind
!= print_entry_values_only
)
694 print_frame_arg (&arg
);
696 if (entryarg
.entry_kind
!= print_entry_values_no
)
698 if (arg
.entry_kind
!= print_entry_values_only
)
701 uiout
->wrap_hint (" ");
704 print_frame_arg (&entryarg
);
708 xfree (entryarg
.error
);
714 /* Don't print nameless args in situations where we don't know
715 enough about the stack to find them. */
720 if (highest_offset
== -1)
721 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
723 start
= highest_offset
;
725 print_frame_nameless_args (frame
, start
, num
- args_printed
,
730 /* Set the current source and line to the location given by frame
731 FRAME, if possible. When CENTER is true, adjust so the relevant
732 line is in the center of the next 'list'. */
735 set_current_sal_from_frame (struct frame_info
*frame
)
737 struct symtab_and_line sal
;
739 find_frame_sal (frame
, &sal
);
740 if (sal
.symtab
!= NULL
)
741 set_current_source_symtab_and_line (&sal
);
744 /* If ON, GDB will display disassembly of the next source line when
745 execution of the program being debugged stops.
746 If AUTO (which is the default), or there's no line info to determine
747 the source line of the next instruction, display disassembly of next
748 instruction instead. */
750 static enum auto_boolean disassemble_next_line
;
753 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
754 struct cmd_list_element
*c
,
757 fprintf_filtered (file
,
758 _("Debugger's willingness to use "
759 "disassemble-next-line is %s.\n"),
763 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
764 because it will be broken by filter sometime. */
767 do_gdb_disassembly (struct gdbarch
*gdbarch
,
768 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
773 gdb_disassembly (gdbarch
, current_uiout
, 0,
774 DISASSEMBLY_RAW_INSN
, how_many
,
777 CATCH (exception
, RETURN_MASK_ERROR
)
779 /* If an exception was thrown while doing the disassembly, print
780 the error message, to give the user a clue of what happened. */
781 exception_print (gdb_stderr
, exception
);
786 /* Print information about frame FRAME. The output is format according
787 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
790 SRC_LINE: Print only source line.
791 LOCATION: Print only location.
792 LOC_AND_SRC: Print location and source line.
794 Used in "where" output, and to emit breakpoint or step
798 print_frame_info (struct frame_info
*frame
, int print_level
,
799 enum print_what print_what
, int print_args
,
802 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
803 struct symtab_and_line sal
;
806 struct ui_out
*uiout
= current_uiout
;
808 if (get_frame_type (frame
) == DUMMY_FRAME
809 || get_frame_type (frame
) == SIGTRAMP_FRAME
810 || get_frame_type (frame
) == ARCH_FRAME
)
812 struct cleanup
*uiout_cleanup
813 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
815 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
816 gdbarch
, get_frame_pc (frame
));
818 /* Do this regardless of SOURCE because we don't have any source
819 to list for this frame. */
823 uiout
->field_fmt_int (2, ui_left
, "level",
824 frame_relative_level (frame
));
826 if (uiout
->is_mi_like_p ())
828 annotate_frame_address ();
829 uiout
->field_core_addr ("addr",
830 gdbarch
, get_frame_pc (frame
));
831 annotate_frame_address_end ();
834 if (get_frame_type (frame
) == DUMMY_FRAME
)
836 annotate_function_call ();
837 uiout
->field_string ("func", "<function called from gdb>");
839 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
841 annotate_signal_handler_caller ();
842 uiout
->field_string ("func", "<signal handler called>");
844 else if (get_frame_type (frame
) == ARCH_FRAME
)
846 uiout
->field_string ("func", "<cross-architecture call>");
849 annotate_frame_end ();
851 /* If disassemble-next-line is set to auto or on output the next
853 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
854 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
855 do_gdb_disassembly (get_frame_arch (frame
), 1,
856 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
858 do_cleanups (uiout_cleanup
);
862 /* If FRAME is not the innermost frame, that normally means that
863 FRAME->pc points to *after* the call instruction, and we want to
864 get the line containing the call, never the next line. But if
865 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
866 next frame was not entered as the result of a call, and we want
867 to get the line containing FRAME->pc. */
868 find_frame_sal (frame
, &sal
);
870 location_print
= (print_what
== LOCATION
871 || print_what
== LOC_AND_ADDRESS
872 || print_what
== SRC_AND_LOC
);
874 if (location_print
|| !sal
.symtab
)
875 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
877 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
879 /* If disassemble-next-line is set to auto or on and doesn't have
880 the line debug messages for $pc, output the next instruction. */
881 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
882 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
883 && source_print
&& !sal
.symtab
)
884 do_gdb_disassembly (get_frame_arch (frame
), 1,
885 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
887 if (source_print
&& sal
.symtab
)
890 int mid_statement
= ((print_what
== SRC_LINE
)
891 && frame_show_address (frame
, sal
));
893 if (annotation_level
)
894 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
895 get_frame_pc (frame
));
898 if (deprecated_print_frame_info_listing_hook
)
899 deprecated_print_frame_info_listing_hook (sal
.symtab
,
904 struct value_print_options opts
;
906 get_user_print_options (&opts
);
907 /* We used to do this earlier, but that is clearly
908 wrong. This function is used by many different
909 parts of gdb, including normal_stop in infrun.c,
910 which uses this to print out the current PC
911 when we stepi/nexti into the middle of a source
912 line. Only the command line really wants this
913 behavior. Other UIs probably would like the
914 ability to decide for themselves if it is desired. */
915 if (opts
.addressprint
&& mid_statement
)
917 uiout
->field_core_addr ("addr",
918 gdbarch
, get_frame_pc (frame
));
922 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
926 /* If disassemble-next-line is set to on and there is line debug
927 messages, output assembly codes for next line. */
928 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
929 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
936 if (get_frame_pc_if_available (frame
, &pc
))
937 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
939 set_last_displayed_sal (0, 0, 0, 0, 0);
942 annotate_frame_end ();
944 gdb_flush (gdb_stdout
);
947 /* Remember the last symtab and line we displayed, which we use e.g.
948 * as the place to put a breakpoint when the `break' command is
949 * invoked with no arguments. */
952 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
953 CORE_ADDR addr
, struct symtab
*symtab
,
956 last_displayed_sal_valid
= valid
;
957 last_displayed_pspace
= pspace
;
958 last_displayed_addr
= addr
;
959 last_displayed_symtab
= symtab
;
960 last_displayed_line
= line
;
961 if (valid
&& pspace
== NULL
)
963 clear_last_displayed_sal ();
964 internal_error (__FILE__
, __LINE__
,
965 _("Trying to set NULL pspace."));
969 /* Forget the last sal we displayed. */
972 clear_last_displayed_sal (void)
974 last_displayed_sal_valid
= 0;
975 last_displayed_pspace
= 0;
976 last_displayed_addr
= 0;
977 last_displayed_symtab
= 0;
978 last_displayed_line
= 0;
981 /* Is our record of the last sal we displayed valid? If not,
982 * the get_last_displayed_* functions will return NULL or 0, as
986 last_displayed_sal_is_valid (void)
988 return last_displayed_sal_valid
;
991 /* Get the pspace of the last sal we displayed, if it's valid. */
993 struct program_space
*
994 get_last_displayed_pspace (void)
996 if (last_displayed_sal_valid
)
997 return last_displayed_pspace
;
1001 /* Get the address of the last sal we displayed, if it's valid. */
1004 get_last_displayed_addr (void)
1006 if (last_displayed_sal_valid
)
1007 return last_displayed_addr
;
1011 /* Get the symtab of the last sal we displayed, if it's valid. */
1014 get_last_displayed_symtab (void)
1016 if (last_displayed_sal_valid
)
1017 return last_displayed_symtab
;
1021 /* Get the line of the last sal we displayed, if it's valid. */
1024 get_last_displayed_line (void)
1026 if (last_displayed_sal_valid
)
1027 return last_displayed_line
;
1031 /* Get the last sal we displayed, if it's valid. */
1034 get_last_displayed_sal (struct symtab_and_line
*sal
)
1036 if (last_displayed_sal_valid
)
1038 sal
->pspace
= last_displayed_pspace
;
1039 sal
->pc
= last_displayed_addr
;
1040 sal
->symtab
= last_displayed_symtab
;
1041 sal
->line
= last_displayed_line
;
1053 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1054 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1057 find_frame_funname (struct frame_info
*frame
, char **funname
,
1058 enum language
*funlang
, struct symbol
**funcp
)
1060 struct symbol
*func
;
1063 *funlang
= language_unknown
;
1067 func
= get_frame_function (frame
);
1070 /* In certain pathological cases, the symtabs give the wrong
1071 function (when we are in the first function in a file which
1072 is compiled without debugging symbols, the previous function
1073 is compiled with debugging symbols, and the "foo.o" symbol
1074 that is supposed to tell us where the file with debugging
1075 symbols ends has been truncated by ar because it is longer
1076 than 15 characters). This also occurs if the user uses asm()
1077 to create a function but not stabs for it (in a file compiled
1080 So look in the minimal symbol tables as well, and if it comes
1081 up with a larger address for the function use that instead.
1082 I don't think this can ever cause any problems; there
1083 shouldn't be any minimal symbols in the middle of a function;
1084 if this is ever changed many parts of GDB will need to be
1085 changed (and we'll create a find_pc_minimal_function or some
1088 struct bound_minimal_symbol msymbol
;
1090 /* Don't attempt to do this for inlined functions, which do not
1091 have a corresponding minimal symbol. */
1092 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1094 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1096 memset (&msymbol
, 0, sizeof (msymbol
));
1098 if (msymbol
.minsym
!= NULL
1099 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1100 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1102 /* We also don't know anything about the function besides
1103 its address and name. */
1105 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1106 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1110 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1112 *funlang
= SYMBOL_LANGUAGE (func
);
1115 if (*funlang
== language_cplus
)
1117 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1118 to display the demangled name that we already have
1119 stored in the symbol table, but we stored a version
1120 with DMGL_PARAMS turned on, and here we don't want to
1121 display parameters. So remove the parameters. */
1122 char *func_only
= cp_remove_params (print_name
);
1125 *funname
= func_only
;
1128 /* If we didn't hit the C++ case above, set *funname here.
1129 This approach is taken to avoid having to install a
1130 cleanup in case cp_remove_params can throw. */
1131 if (*funname
== NULL
)
1132 *funname
= xstrdup (print_name
);
1137 struct bound_minimal_symbol msymbol
;
1140 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1143 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1144 if (msymbol
.minsym
!= NULL
)
1146 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1147 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1153 print_frame (struct frame_info
*frame
, int print_level
,
1154 enum print_what print_what
, int print_args
,
1155 struct symtab_and_line sal
)
1157 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1158 struct ui_out
*uiout
= current_uiout
;
1159 char *funname
= NULL
;
1160 enum language funlang
= language_unknown
;
1161 struct ui_file
*stb
;
1162 struct cleanup
*old_chain
, *list_chain
;
1163 struct value_print_options opts
;
1164 struct symbol
*func
;
1168 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1170 stb
= mem_fileopen ();
1171 old_chain
= make_cleanup_ui_file_delete (stb
);
1173 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1174 make_cleanup (xfree
, funname
);
1176 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1179 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1184 uiout
->field_fmt_int (2, ui_left
, "level",
1185 frame_relative_level (frame
));
1187 get_user_print_options (&opts
);
1188 if (opts
.addressprint
)
1190 || frame_show_address (frame
, sal
)
1191 || print_what
== LOC_AND_ADDRESS
)
1193 annotate_frame_address ();
1195 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1197 uiout
->field_string ("addr", "<unavailable>");
1198 annotate_frame_address_end ();
1199 uiout
->text (" in ");
1201 annotate_frame_function_name ();
1202 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1203 funlang
, DMGL_ANSI
);
1204 uiout
->field_stream ("func", stb
);
1205 uiout
->wrap_hint (" ");
1206 annotate_frame_args ();
1211 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1213 struct cleanup
*args_list_chain
;
1215 if (gdbarch_frame_num_args_p (gdbarch
))
1217 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1218 gdb_assert (numargs
>= 0);
1223 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1226 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1228 CATCH (e
, RETURN_MASK_ERROR
)
1233 /* FIXME: ARGS must be a list. If one argument is a string it
1234 will have " that will not be properly escaped. */
1235 /* Invoke ui_out_tuple_end. */
1236 do_cleanups (args_list_chain
);
1242 const char *filename_display
;
1244 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1245 annotate_frame_source_begin ();
1246 uiout
->wrap_hint (" ");
1247 uiout
->text (" at ");
1248 annotate_frame_source_file ();
1249 uiout
->field_string ("file", filename_display
);
1250 if (uiout
->is_mi_like_p ())
1252 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1254 uiout
->field_string ("fullname", fullname
);
1256 annotate_frame_source_file_end ();
1258 annotate_frame_source_line ();
1259 uiout
->field_int ("line", sal
.line
);
1260 annotate_frame_source_end ();
1263 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1265 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1266 get_frame_pc (frame
));
1270 annotate_frame_where ();
1271 uiout
->wrap_hint (" ");
1272 uiout
->text (" from ");
1273 uiout
->field_string ("from", lib
);
1277 /* do_cleanups will call ui_out_tuple_end() for us. */
1278 do_cleanups (list_chain
);
1280 do_cleanups (old_chain
);
1284 /* Read a frame specification in whatever the appropriate format is from
1285 FRAME_EXP. Call error() if the specification is in any way invalid (so
1286 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1287 set its target to indicate that the default selected frame was used. */
1289 static struct frame_info
*
1290 parse_frame_specification (const char *frame_exp
, int *selected_frame_p
)
1293 struct value
*args
[4];
1294 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1296 if (frame_exp
== NULL
)
1304 struct cleanup
*cleanup
;
1307 /* Skip leading white space, bail of EOL. */
1308 frame_exp
= skip_spaces_const (frame_exp
);
1312 /* Parse the argument, extract it, save it. */
1314 *p
&& !ISSPACE (*p
);
1316 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1318 cleanup
= make_cleanup (xfree
, addr_string
);
1320 /* NOTE: Parse and evaluate expression, but do not use
1321 functions such as parse_and_eval_long or
1322 parse_and_eval_address to also extract the value.
1323 Instead value_as_long and value_as_address are used.
1324 This avoids problems with expressions that contain
1326 if (numargs
>= ARRAY_SIZE (args
))
1327 error (_("Too many args in frame specification"));
1328 args
[numargs
++] = parse_and_eval (addr_string
);
1330 do_cleanups (cleanup
);
1334 /* If no args, default to the selected frame. */
1337 if (selected_frame_p
!= NULL
)
1338 (*selected_frame_p
) = 1;
1339 return get_selected_frame (_("No stack."));
1342 /* None of the remaining use the selected frame. */
1343 if (selected_frame_p
!= NULL
)
1344 (*selected_frame_p
) = 0;
1346 /* Assume the single arg[0] is an integer, and try using that to
1347 select a frame relative to current. */
1350 struct frame_info
*fid
;
1351 int level
= value_as_long (args
[0]);
1353 fid
= find_relative_frame (get_current_frame (), &level
);
1355 /* find_relative_frame was successful. */
1359 /* Convert each value into a corresponding address. */
1363 for (i
= 0; i
< numargs
; i
++)
1364 addrs
[i
] = value_as_address (args
[i
]);
1367 /* Assume that the single arg[0] is an address, use that to identify
1368 a frame with a matching ID. Should this also accept stack/pc or
1369 stack/pc/special. */
1372 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1373 struct frame_info
*fid
;
1375 /* If (s)he specifies the frame with an address, he deserves
1376 what (s)he gets. Still, give the highest one that matches.
1377 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1379 for (fid
= get_current_frame ();
1381 fid
= get_prev_frame (fid
))
1383 if (frame_id_eq (id
, get_frame_id (fid
)))
1385 struct frame_info
*prev_frame
;
1389 prev_frame
= get_prev_frame (fid
);
1391 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1400 /* We couldn't identify the frame as an existing frame, but
1401 perhaps we can create one with a single argument. */
1403 return create_new_frame (addrs
[0], 0);
1404 else if (numargs
== 2)
1405 return create_new_frame (addrs
[0], addrs
[1]);
1407 error (_("Too many args in frame specification"));
1410 /* Print verbosely the selected frame or the frame at address
1411 ADDR_EXP. Absolutely all information in the frame is printed. */
1414 frame_info (char *addr_exp
, int from_tty
)
1416 struct frame_info
*fi
;
1417 struct symtab_and_line sal
;
1418 struct symbol
*func
;
1420 struct frame_info
*calling_frame_info
;
1422 const char *funname
= 0;
1423 enum language funlang
= language_unknown
;
1424 const char *pc_regname
;
1425 int selected_frame_p
;
1426 struct gdbarch
*gdbarch
;
1427 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1430 /* Initialize it to avoid "may be used uninitialized" warning. */
1431 CORE_ADDR caller_pc
= 0;
1432 int caller_pc_p
= 0;
1434 fi
= parse_frame_specification (addr_exp
, &selected_frame_p
);
1435 gdbarch
= get_frame_arch (fi
);
1437 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1438 is not a good name. */
1439 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1440 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1441 easily not match that of the internal value returned by
1443 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1445 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1446 architectures will often have a hardware register called "pc",
1447 and that register's value, again, can easily not match
1451 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1452 find_frame_sal (fi
, &sal
);
1453 func
= get_frame_function (fi
);
1457 funname
= SYMBOL_PRINT_NAME (func
);
1458 funlang
= SYMBOL_LANGUAGE (func
);
1459 if (funlang
== language_cplus
)
1461 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1462 to display the demangled name that we already have
1463 stored in the symbol table, but we stored a version
1464 with DMGL_PARAMS turned on, and here we don't want to
1465 display parameters. So remove the parameters. */
1466 char *func_only
= cp_remove_params (funname
);
1470 funname
= func_only
;
1471 make_cleanup (xfree
, func_only
);
1475 else if (frame_pc_p
)
1477 struct bound_minimal_symbol msymbol
;
1479 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1480 if (msymbol
.minsym
!= NULL
)
1482 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1483 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1486 calling_frame_info
= get_prev_frame (fi
);
1488 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1490 printf_filtered (_("Stack level %d, frame at "),
1491 frame_relative_level (fi
));
1495 printf_filtered (_("Stack frame at "));
1497 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1498 printf_filtered (":\n");
1499 printf_filtered (" %s = ", pc_regname
);
1501 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1503 fputs_filtered ("<unavailable>", gdb_stdout
);
1508 printf_filtered (" in ");
1509 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1510 DMGL_ANSI
| DMGL_PARAMS
);
1514 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1516 puts_filtered ("; ");
1518 printf_filtered ("saved %s = ", pc_regname
);
1520 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1521 val_print_not_saved (gdb_stdout
);
1526 caller_pc
= frame_unwind_caller_pc (fi
);
1529 CATCH (ex
, RETURN_MASK_ERROR
)
1533 case NOT_AVAILABLE_ERROR
:
1534 val_print_unavailable (gdb_stdout
);
1536 case OPTIMIZED_OUT_ERROR
:
1537 val_print_not_saved (gdb_stdout
);
1540 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1548 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1549 printf_filtered ("\n");
1551 if (calling_frame_info
== NULL
)
1553 enum unwind_stop_reason reason
;
1555 reason
= get_frame_unwind_stop_reason (fi
);
1556 if (reason
!= UNWIND_NO_REASON
)
1557 printf_filtered (_(" Outermost frame: %s\n"),
1558 frame_stop_reason_string (fi
));
1560 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1561 puts_filtered (" tail call frame");
1562 else if (get_frame_type (fi
) == INLINE_FRAME
)
1563 printf_filtered (" inlined into frame %d",
1564 frame_relative_level (get_prev_frame (fi
)));
1567 printf_filtered (" called by frame at ");
1568 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1571 if (get_next_frame (fi
) && calling_frame_info
)
1572 puts_filtered (",");
1574 if (get_next_frame (fi
))
1576 printf_filtered (" caller of frame at ");
1577 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1580 if (get_next_frame (fi
) || calling_frame_info
)
1581 puts_filtered ("\n");
1584 printf_filtered (" source language %s.\n",
1585 language_str (s
->language
));
1588 /* Address of the argument list for this frame, or 0. */
1589 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1590 /* Number of args for this frame, or -1 if unknown. */
1594 printf_filtered (" Arglist at unknown address.\n");
1597 printf_filtered (" Arglist at ");
1598 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1599 printf_filtered (",");
1601 if (!gdbarch_frame_num_args_p (gdbarch
))
1604 puts_filtered (" args: ");
1608 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1609 gdb_assert (numargs
>= 0);
1611 puts_filtered (" no args.");
1612 else if (numargs
== 1)
1613 puts_filtered (" 1 arg: ");
1615 printf_filtered (" %d args: ", numargs
);
1617 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1618 puts_filtered ("\n");
1622 /* Address of the local variables for this frame, or 0. */
1623 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1626 printf_filtered (" Locals at unknown address,");
1629 printf_filtered (" Locals at ");
1630 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1631 printf_filtered (",");
1635 /* Print as much information as possible on the location of all the
1638 enum lval_type lval
;
1647 /* The sp is special; what's displayed isn't the save address, but
1648 the value of the previous frame's sp. This is a legacy thing,
1649 at one stage the frame cached the previous frame's SP instead
1650 of its address, hence it was easiest to just display the cached
1652 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1654 /* Find out the location of the saved stack pointer with out
1655 actually evaluating it. */
1656 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1657 &optimized
, &unavailable
, &lval
, &addr
,
1659 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1661 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1662 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1663 gdb_byte value
[MAX_REGISTER_SIZE
];
1666 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1667 &optimized
, &unavailable
, &lval
, &addr
,
1669 /* NOTE: cagney/2003-05-22: This is assuming that the
1670 stack pointer was packed as an unsigned integer. That
1671 may or may not be valid. */
1672 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1673 printf_filtered (" Previous frame's sp is ");
1674 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1675 printf_filtered ("\n");
1678 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1680 printf_filtered (" Previous frame's sp at ");
1681 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1682 printf_filtered ("\n");
1685 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1687 printf_filtered (" Previous frame's sp in %s\n",
1688 gdbarch_register_name (gdbarch
, realnum
));
1691 /* else keep quiet. */
1695 numregs
= gdbarch_num_regs (gdbarch
)
1696 + gdbarch_num_pseudo_regs (gdbarch
);
1697 for (i
= 0; i
< numregs
; i
++)
1698 if (i
!= gdbarch_sp_regnum (gdbarch
)
1699 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1701 /* Find out the location of the saved register without
1702 fetching the corresponding value. */
1703 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1704 &lval
, &addr
, &realnum
, NULL
);
1705 /* For moment, only display registers that were saved on the
1707 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1710 puts_filtered (" Saved registers:\n ");
1712 puts_filtered (",");
1714 printf_filtered (" %s at ",
1715 gdbarch_register_name (gdbarch
, i
));
1716 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1720 if (count
|| need_nl
)
1721 puts_filtered ("\n");
1724 do_cleanups (back_to
);
1727 /* Print briefly all stack frames or just the innermost COUNT_EXP
1731 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1734 struct frame_info
*fi
;
1737 struct frame_info
*trailing
;
1738 int trailing_level
, py_start
= 0, py_end
= 0;
1739 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1741 if (!target_has_stack
)
1742 error (_("No stack."));
1744 /* The following code must do two things. First, it must set the
1745 variable TRAILING to the frame from which we should start
1746 printing. Second, it must set the variable count to the number
1747 of frames which we should print, or -1 if all of them. */
1748 trailing
= get_current_frame ();
1753 count
= parse_and_eval_long (count_exp
);
1756 struct frame_info
*current
;
1762 while (current
&& count
--)
1765 current
= get_prev_frame (current
);
1768 /* Will stop when CURRENT reaches the top of the stack.
1769 TRAILING will be COUNT below it. */
1773 trailing
= get_prev_frame (trailing
);
1774 current
= get_prev_frame (current
);
1794 /* Read in symbols for all of the frames. Need to do this in a
1795 separate pass so that "Reading in symbols for xxx" messages
1796 don't screw up the appearance of the backtrace. Also if
1797 people have strong opinions against reading symbols for
1798 backtrace this may have to be an option. */
1800 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1805 pc
= get_frame_address_in_block (fi
);
1806 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1812 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1813 enum ext_lang_frame_args arg_type
;
1816 flags
|= PRINT_LOCALS
;
1818 if (!strcmp (print_frame_arguments
, "scalars"))
1819 arg_type
= CLI_SCALAR_VALUES
;
1820 else if (!strcmp (print_frame_arguments
, "all"))
1821 arg_type
= CLI_ALL_VALUES
;
1823 arg_type
= NO_VALUES
;
1825 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1826 arg_type
, current_uiout
,
1830 /* Run the inbuilt backtrace if there are no filters registered, or
1831 "no-filters" has been specified from the command. */
1832 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1834 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1838 /* Don't use print_stack_frame; if an error() occurs it probably
1839 means further attempts to backtrace would fail (on the other
1840 hand, perhaps the code does or could be fixed to make sure
1841 the frame->prev field gets set to NULL in that case). */
1843 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1846 struct frame_id frame_id
= get_frame_id (fi
);
1848 print_frame_local_vars (fi
, 1, gdb_stdout
);
1850 /* print_frame_local_vars invalidates FI. */
1851 fi
= frame_find_by_id (frame_id
);
1855 warning (_("Unable to restore previously selected frame."));
1860 /* Save the last frame to check for error conditions. */
1864 /* If we've stopped before the end, mention that. */
1866 printf_filtered (_("(More stack frames follow...)\n"));
1868 /* If we've run out of frames, and the reason appears to be an error
1869 condition, print it. */
1870 if (fi
== NULL
&& trailing
!= NULL
)
1872 enum unwind_stop_reason reason
;
1874 reason
= get_frame_unwind_stop_reason (trailing
);
1875 if (reason
>= UNWIND_FIRST_ERROR
)
1876 printf_filtered (_("Backtrace stopped: %s\n"),
1877 frame_stop_reason_string (trailing
));
1883 backtrace_command (char *arg
, int from_tty
)
1885 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1886 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1894 argv
= gdb_buildargv (arg
);
1895 make_cleanup_freeargv (argv
);
1897 for (i
= 0; argv
[i
]; i
++)
1901 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1902 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1904 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1908 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1909 fulltrace_arg
= argc
;
1913 arglen
+= strlen (argv
[i
]);
1919 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1923 arg
= (char *) xmalloc (arglen
+ 1);
1924 make_cleanup (xfree
, arg
);
1926 for (i
= 0; i
< argc
; i
++)
1928 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1930 strcat (arg
, argv
[i
]);
1940 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1941 no_filters
>= 0 /* no frame-filters */, from_tty
);
1943 do_cleanups (old_chain
);
1946 /* Iterate over the local variables of a block B, calling CB with
1950 iterate_over_block_locals (const struct block
*b
,
1951 iterate_over_block_arg_local_vars_cb cb
,
1954 struct block_iterator iter
;
1957 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1959 switch (SYMBOL_CLASS (sym
))
1965 if (SYMBOL_IS_ARGUMENT (sym
))
1967 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1969 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1973 /* Ignore symbols which are not locals. */
1980 /* Same, but print labels. */
1983 /* Commented out, as the code using this function has also been
1984 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1985 was commented out in the first place. The discussion introducing
1986 this change (2007-12-04: Support lexical blocks and function bodies
1987 that occupy non-contiguous address ranges) did not explain why
1988 this change was made. */
1990 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1991 int *have_default
, struct ui_file
*stream
)
1993 struct block_iterator iter
;
1995 int values_printed
= 0;
1997 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1999 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2005 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2007 struct symtab_and_line sal
;
2008 struct value_print_options opts
;
2010 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2012 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2013 get_user_print_options (&opts
);
2014 if (opts
.addressprint
)
2016 fprintf_filtered (stream
, " ");
2017 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2020 fprintf_filtered (stream
, " in file %s, line %d\n",
2021 sal
.symtab
->filename
, sal
.line
);
2025 return values_printed
;
2029 /* Iterate over all the local variables in block B, including all its
2030 superblocks, stopping when the top-level block is reached. */
2033 iterate_over_block_local_vars (const struct block
*block
,
2034 iterate_over_block_arg_local_vars_cb cb
,
2039 iterate_over_block_locals (block
, cb
, cb_data
);
2040 /* After handling the function's top-level block, stop. Don't
2041 continue to its superblock, the block of per-file
2043 if (BLOCK_FUNCTION (block
))
2045 block
= BLOCK_SUPERBLOCK (block
);
2049 /* Data to be passed around in the calls to the locals and args
2052 struct print_variable_and_value_data
2054 struct frame_id frame_id
;
2056 struct ui_file
*stream
;
2060 /* The callback for the locals and args iterators. */
2063 do_print_variable_and_value (const char *print_name
,
2067 struct print_variable_and_value_data
*p
2068 = (struct print_variable_and_value_data
*) cb_data
;
2069 struct frame_info
*frame
;
2071 frame
= frame_find_by_id (p
->frame_id
);
2074 warning (_("Unable to restore previously selected frame."));
2078 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2080 /* print_variable_and_value invalidates FRAME. */
2083 p
->values_printed
= 1;
2086 /* Print all variables from the innermost up to the function block of FRAME.
2087 Print them with values to STREAM indented by NUM_TABS.
2089 This function will invalidate FRAME. */
2092 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2093 struct ui_file
*stream
)
2095 struct print_variable_and_value_data cb_data
;
2096 const struct block
*block
;
2098 struct gdb_exception except
= exception_none
;
2100 if (!get_frame_pc_if_available (frame
, &pc
))
2102 fprintf_filtered (stream
,
2103 _("PC unavailable, cannot determine locals.\n"));
2107 block
= get_frame_block (frame
, 0);
2110 fprintf_filtered (stream
, "No symbol table info available.\n");
2114 cb_data
.frame_id
= get_frame_id (frame
);
2115 cb_data
.num_tabs
= 4 * num_tabs
;
2116 cb_data
.stream
= stream
;
2117 cb_data
.values_printed
= 0;
2119 /* Temporarily change the selected frame to the given FRAME.
2120 This allows routines that rely on the selected frame instead
2121 of being given a frame as parameter to use the correct frame. */
2122 select_frame (frame
);
2126 iterate_over_block_local_vars (block
,
2127 do_print_variable_and_value
,
2130 CATCH (ex
, RETURN_MASK_ALL
)
2136 /* Restore the selected frame, and then rethrow if there was a problem. */
2137 select_frame (frame_find_by_id (cb_data
.frame_id
));
2138 if (except
.reason
< 0)
2139 throw_exception (except
);
2141 /* do_print_variable_and_value invalidates FRAME. */
2144 if (!cb_data
.values_printed
)
2145 fprintf_filtered (stream
, _("No locals.\n"));
2149 locals_info (char *args
, int from_tty
)
2151 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2155 /* Iterate over all the argument variables in block B.
2157 Returns 1 if any argument was walked; 0 otherwise. */
2160 iterate_over_block_arg_vars (const struct block
*b
,
2161 iterate_over_block_arg_local_vars_cb cb
,
2164 struct block_iterator iter
;
2165 struct symbol
*sym
, *sym2
;
2167 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2169 /* Don't worry about things which aren't arguments. */
2170 if (SYMBOL_IS_ARGUMENT (sym
))
2172 /* We have to look up the symbol because arguments can have
2173 two entries (one a parameter, one a local) and the one we
2174 want is the local, which lookup_symbol will find for us.
2175 This includes gcc1 (not gcc2) on the sparc when passing a
2176 small structure and gcc2 when the argument type is float
2177 and it is passed as a double and converted to float by
2178 the prologue (in the latter case the type of the LOC_ARG
2179 symbol is double and the type of the LOC_LOCAL symbol is
2180 float). There are also LOC_ARG/LOC_REGISTER pairs which
2181 are not combined in symbol-reading. */
2183 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2184 b
, VAR_DOMAIN
, NULL
).symbol
;
2185 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2190 /* Print all argument variables of the function of FRAME.
2191 Print them with values to STREAM.
2193 This function will invalidate FRAME. */
2196 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2198 struct print_variable_and_value_data cb_data
;
2199 struct symbol
*func
;
2202 if (!get_frame_pc_if_available (frame
, &pc
))
2204 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2208 func
= get_frame_function (frame
);
2211 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2215 cb_data
.frame_id
= get_frame_id (frame
);
2216 cb_data
.num_tabs
= 0;
2217 cb_data
.stream
= gdb_stdout
;
2218 cb_data
.values_printed
= 0;
2220 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2221 do_print_variable_and_value
, &cb_data
);
2223 /* do_print_variable_and_value invalidates FRAME. */
2226 if (!cb_data
.values_printed
)
2227 fprintf_filtered (stream
, _("No arguments.\n"));
2231 args_info (char *ignore
, int from_tty
)
2233 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2237 /* Select frame FRAME. Also print the stack frame and show the source
2238 if this is the tui version. */
2240 select_and_print_frame (struct frame_info
*frame
)
2242 select_frame (frame
);
2244 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2247 /* Return the symbol-block in which the selected frame is executing.
2248 Can return zero under various legitimate circumstances.
2250 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2251 code address within the block returned. We use this to decide
2252 which macros are in scope. */
2254 const struct block
*
2255 get_selected_block (CORE_ADDR
*addr_in_block
)
2257 if (!has_stack_frames ())
2260 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2263 /* Find a frame a certain number of levels away from FRAME.
2264 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2265 Positive means go to earlier frames (up); negative, the reverse.
2266 The int that contains the number of levels is counted toward
2267 zero as the frames for those levels are found.
2268 If the top or bottom frame is reached, that frame is returned,
2269 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2270 how much farther the original request asked to go. */
2273 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2275 /* Going up is simple: just call get_prev_frame enough times or
2276 until the initial frame is reached. */
2277 while (*level_offset_ptr
> 0)
2279 struct frame_info
*prev
= get_prev_frame (frame
);
2283 (*level_offset_ptr
)--;
2287 /* Going down is just as simple. */
2288 while (*level_offset_ptr
< 0)
2290 struct frame_info
*next
= get_next_frame (frame
);
2294 (*level_offset_ptr
)++;
2301 /* The "select_frame" command. With no argument this is a NOP.
2302 Select the frame at level LEVEL_EXP if it is a valid level.
2303 Otherwise, treat LEVEL_EXP as an address expression and select it.
2305 See parse_frame_specification for more info on proper frame
2309 select_frame_command (char *level_exp
, int from_tty
)
2311 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2313 select_frame (parse_frame_specification (level_exp
, NULL
));
2314 if (get_selected_frame_if_set () != prev_frame
)
2315 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2318 /* The "frame" command. With no argument, print the selected frame
2319 briefly. With an argument, behave like select_frame and then print
2320 the selected frame. */
2323 frame_command (char *level_exp
, int from_tty
)
2325 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2327 select_frame (parse_frame_specification (level_exp
, NULL
));
2328 if (get_selected_frame_if_set () != prev_frame
)
2329 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2331 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
2334 /* Select the frame up one or COUNT_EXP stack levels from the
2335 previously selected frame, and print it briefly. */
2338 up_silently_base (const char *count_exp
)
2340 struct frame_info
*frame
;
2344 count
= parse_and_eval_long (count_exp
);
2346 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2347 if (count
!= 0 && count_exp
== NULL
)
2348 error (_("Initial frame selected; you cannot go up."));
2349 select_frame (frame
);
2353 up_silently_command (char *count_exp
, int from_tty
)
2355 up_silently_base (count_exp
);
2359 up_command (char *count_exp
, int from_tty
)
2361 up_silently_base (count_exp
);
2362 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2365 /* Select the frame down one or COUNT_EXP stack levels from the previously
2366 selected frame, and print it briefly. */
2369 down_silently_base (const char *count_exp
)
2371 struct frame_info
*frame
;
2375 count
= -parse_and_eval_long (count_exp
);
2377 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2378 if (count
!= 0 && count_exp
== NULL
)
2380 /* We only do this if COUNT_EXP is not specified. That way
2381 "down" means to really go down (and let me know if that is
2382 impossible), but "down 9999" can be used to mean go all the
2383 way down without getting an error. */
2385 error (_("Bottom (innermost) frame selected; you cannot go down."));
2388 select_frame (frame
);
2392 down_silently_command (char *count_exp
, int from_tty
)
2394 down_silently_base (count_exp
);
2398 down_command (char *count_exp
, int from_tty
)
2400 down_silently_base (count_exp
);
2401 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2405 return_command (char *retval_exp
, int from_tty
)
2407 /* Initialize it just to avoid a GCC false warning. */
2408 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2409 struct frame_info
*thisframe
;
2410 struct gdbarch
*gdbarch
;
2411 struct symbol
*thisfun
;
2412 struct value
*return_value
= NULL
;
2413 struct value
*function
= NULL
;
2414 const char *query_prefix
= "";
2416 thisframe
= get_selected_frame ("No selected frame.");
2417 thisfun
= get_frame_function (thisframe
);
2418 gdbarch
= get_frame_arch (thisframe
);
2420 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2421 error (_("Can not force return from an inlined function."));
2423 /* Compute the return value. If the computation triggers an error,
2424 let it bail. If the return type can't be handled, set
2425 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2429 expression_up retval_expr
= parse_expression (retval_exp
);
2430 struct type
*return_type
= NULL
;
2432 /* Compute the return value. Should the computation fail, this
2433 call throws an error. */
2434 return_value
= evaluate_expression (retval_expr
.get ());
2436 /* Cast return value to the return type of the function. Should
2437 the cast fail, this call throws an error. */
2438 if (thisfun
!= NULL
)
2439 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2440 if (return_type
== NULL
)
2442 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2443 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2444 error (_("Return value type not available for selected "
2446 "Please use an explicit cast of the value to return."));
2447 return_type
= value_type (return_value
);
2449 return_type
= check_typedef (return_type
);
2450 return_value
= value_cast (return_type
, return_value
);
2452 /* Make sure the value is fully evaluated. It may live in the
2453 stack frame we're about to pop. */
2454 if (value_lazy (return_value
))
2455 value_fetch_lazy (return_value
);
2457 if (thisfun
!= NULL
)
2458 function
= read_var_value (thisfun
, NULL
, thisframe
);
2460 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2461 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2462 /* If the return-type is "void", don't try to find the
2463 return-value's location. However, do still evaluate the
2464 return expression so that, even when the expression result
2465 is discarded, side effects such as "return i++" still
2467 return_value
= NULL
;
2468 else if (thisfun
!= NULL
)
2470 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2471 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2472 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2474 query_prefix
= "The location at which to store the "
2475 "function's return value is unknown.\n"
2476 "If you continue, the return value "
2477 "that you specified will be ignored.\n";
2478 return_value
= NULL
;
2483 /* Does an interactive user really want to do this? Include
2484 information, such as how well GDB can handle the return value, in
2485 the query message. */
2490 if (thisfun
== NULL
)
2491 confirmed
= query (_("%sMake selected stack frame return now? "),
2495 if (TYPE_NO_RETURN (thisfun
->type
))
2496 warning (_("Function does not return normally to caller."));
2497 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2498 SYMBOL_PRINT_NAME (thisfun
));
2501 error (_("Not confirmed"));
2504 /* Discard the selected frame and all frames inner-to it. */
2505 frame_pop (get_selected_frame (NULL
));
2507 /* Store RETURN_VALUE in the just-returned register set. */
2508 if (return_value
!= NULL
)
2510 struct type
*return_type
= value_type (return_value
);
2511 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2513 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2514 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2515 gdbarch_return_value (gdbarch
, function
, return_type
,
2516 get_current_regcache (), NULL
/*read*/,
2517 value_contents (return_value
) /*write*/);
2520 /* If we are at the end of a call dummy now, pop the dummy frame
2522 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2523 frame_pop (get_current_frame ());
2525 select_frame (get_current_frame ());
2526 /* If interactive, print the frame that is now current. */
2528 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2531 /* Sets the scope to input function name, provided that the function
2532 is within the current stack frame. */
2534 struct function_bounds
2536 CORE_ADDR low
, high
;
2540 func_command (char *arg
, int from_tty
)
2542 struct frame_info
*frame
;
2544 struct symtabs_and_lines sals
;
2547 struct function_bounds
*func_bounds
= NULL
;
2548 struct cleanup
*cleanups
;
2553 frame
= get_current_frame ();
2554 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2555 cleanups
= make_cleanup (xfree
, sals
.sals
);
2556 func_bounds
= XNEWVEC (struct function_bounds
, sals
.nelts
);
2557 make_cleanup (xfree
, func_bounds
);
2558 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2560 if (sals
.sals
[i
].pspace
!= current_program_space
)
2561 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2562 else if (sals
.sals
[i
].pc
== 0
2563 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2564 &func_bounds
[i
].low
,
2565 &func_bounds
[i
].high
) == 0)
2567 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2573 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2574 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2575 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2579 frame
= find_relative_frame (frame
, &level
);
2582 while (!found
&& level
== 0);
2584 do_cleanups (cleanups
);
2587 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2588 else if (frame
!= get_selected_frame (NULL
))
2589 select_and_print_frame (frame
);
2593 /* Provide a prototype to silence -Wmissing-prototypes. */
2594 void _initialize_stack (void);
2597 _initialize_stack (void)
2599 add_com ("return", class_stack
, return_command
, _("\
2600 Make selected stack frame return to its caller.\n\
2601 Control remains in the debugger, but when you continue\n\
2602 execution will resume in the frame above the one now selected.\n\
2603 If an argument is given, it is an expression for the value to return."));
2605 add_com ("up", class_stack
, up_command
, _("\
2606 Select and print stack frame that called this one.\n\
2607 An argument says how many frames up to go."));
2608 add_com ("up-silently", class_support
, up_silently_command
, _("\
2609 Same as the `up' command, but does not print anything.\n\
2610 This is useful in command scripts."));
2612 add_com ("down", class_stack
, down_command
, _("\
2613 Select and print stack frame called by this one.\n\
2614 An argument says how many frames down to go."));
2615 add_com_alias ("do", "down", class_stack
, 1);
2616 add_com_alias ("dow", "down", class_stack
, 1);
2617 add_com ("down-silently", class_support
, down_silently_command
, _("\
2618 Same as the `down' command, but does not print anything.\n\
2619 This is useful in command scripts."));
2621 add_com ("frame", class_stack
, frame_command
, _("\
2622 Select and print a stack frame.\nWith no argument, \
2623 print the selected stack frame. (See also \"info frame\").\n\
2624 An argument specifies the frame to select.\n\
2625 It can be a stack frame number or the address of the frame.\n"));
2627 add_com_alias ("f", "frame", class_stack
, 1);
2629 add_com_suppress_notification ("select-frame", class_stack
, select_frame_command
, _("\
2630 Select a stack frame without printing anything.\n\
2631 An argument specifies the frame to select.\n\
2632 It can be a stack frame number or the address of the frame.\n"),
2633 &cli_suppress_notification
.user_selected_context
);
2635 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2636 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2637 With a negative argument, print outermost -COUNT frames.\nUse of the \
2638 'full' qualifier also prints the values of the local variables.\n\
2639 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2640 on this backtrace.\n"));
2641 add_com_alias ("bt", "backtrace", class_stack
, 0);
2643 add_com_alias ("where", "backtrace", class_alias
, 0);
2644 add_info ("stack", backtrace_command
,
2645 _("Backtrace of the stack, or innermost COUNT frames."));
2646 add_info_alias ("s", "stack", 1);
2647 add_info ("frame", frame_info
,
2648 _("All about selected stack frame, or frame at ADDR."));
2649 add_info_alias ("f", "frame", 1);
2650 add_info ("locals", locals_info
,
2651 _("Local variables of current stack frame."));
2652 add_info ("args", args_info
,
2653 _("Argument variables of current stack frame."));
2656 add_com ("func", class_stack
, func_command
, _("\
2657 Select the stack frame that contains <func>.\n\
2658 Usage: func <name>\n"));
2660 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2661 print_frame_arguments_choices
, &print_frame_arguments
,
2662 _("Set printing of non-scalar frame arguments"),
2663 _("Show printing of non-scalar frame arguments"),
2664 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2666 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2667 &print_raw_frame_arguments
, _("\
2668 Set whether to print frame arguments in raw form."), _("\
2669 Show whether to print frame arguments in raw form."), _("\
2670 If set, frame arguments are printed in raw form, bypassing any\n\
2671 pretty-printers for that value."),
2673 &setprintrawlist
, &showprintrawlist
);
2675 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2676 &disassemble_next_line
, _("\
2677 Set whether to disassemble next source line or insn when execution stops."),
2679 Show whether to disassemble next source line or insn when execution stops."),
2681 If ON, GDB will display disassembly of the next source line, in addition\n\
2682 to displaying the source line itself. If the next source line cannot\n\
2683 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2684 will display disassembly of next instruction instead of showing the\n\
2686 If AUTO, display disassembly of next instruction only if the source line\n\
2687 cannot be displayed.\n\
2688 If OFF (which is the default), never display the disassembly of the next\n\
2691 show_disassemble_next_line
,
2692 &setlist
, &showlist
);
2693 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2695 add_setshow_enum_cmd ("entry-values", class_stack
,
2696 print_entry_values_choices
, &print_entry_values
,
2697 _("Set printing of function arguments at function "
2699 _("Show printing of function arguments at function "
2702 GDB can sometimes determine the values of function arguments at entry,\n\
2703 in addition to their current values. This option tells GDB whether\n\
2704 to print the current value, the value at entry (marked as val@entry),\n\
2705 or both. Note that one or both of these values may be <optimized out>."),
2706 NULL
, NULL
, &setprintlist
, &showprintlist
);