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 struct cleanup
*old_chain
;
558 /* True if we should print arguments, false otherwise. */
559 int print_args
= strcmp (print_frame_arguments
, "none");
561 stb
= mem_fileopen ();
562 old_chain
= make_cleanup_ui_file_delete (stb
);
566 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
567 struct block_iterator iter
;
570 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
572 struct frame_arg arg
, entryarg
;
576 /* Keep track of the highest stack argument offset seen, and
577 skip over any kinds of symbols we don't care about. */
579 if (!SYMBOL_IS_ARGUMENT (sym
))
582 switch (SYMBOL_CLASS (sym
))
587 long current_offset
= SYMBOL_VALUE (sym
);
588 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
590 /* Compute address of next argument by adding the size of
591 this argument and rounding to an int boundary. */
593 ((current_offset
+ arg_size
+ sizeof (int) - 1)
594 & ~(sizeof (int) - 1));
596 /* If this is the highest offset seen yet, set
598 if (highest_offset
== -1
599 || (current_offset
> highest_offset
))
600 highest_offset
= current_offset
;
602 /* Add the number of ints we're about to print to
604 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
607 /* We care about types of symbols, but don't need to
608 keep track of stack offsets in them. */
610 case LOC_REGPARM_ADDR
:
612 case LOC_OPTIMIZED_OUT
:
617 /* We have to look up the symbol because arguments can have
618 two entries (one a parameter, one a local) and the one we
619 want is the local, which lookup_symbol will find for us.
620 This includes gcc1 (not gcc2) on SPARC when passing a
621 small structure and gcc2 when the argument type is float
622 and it is passed as a double and converted to float by
623 the prologue (in the latter case the type of the LOC_ARG
624 symbol is double and the type of the LOC_LOCAL symbol is
626 /* But if the parameter name is null, don't try it. Null
627 parameter names occur on the RS/6000, for traceback
628 tables. FIXME, should we even print them? */
630 if (*SYMBOL_LINKAGE_NAME (sym
))
634 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
635 b
, VAR_DOMAIN
, NULL
).symbol
;
636 gdb_assert (nsym
!= NULL
);
637 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
638 && !SYMBOL_IS_ARGUMENT (nsym
))
640 /* There is a LOC_ARG/LOC_REGISTER pair. This means
641 that it was passed on the stack and loaded into a
642 register, or passed in a register and stored in a
643 stack slot. GDB 3.x used the LOC_ARG; GDB
644 4.0-4.11 used the LOC_REGISTER.
646 Reasons for using the LOC_ARG:
648 (1) Because find_saved_registers may be slow for
651 (2) Because registers are often re-used and stack
652 slots rarely (never?) are. Therefore using
653 the stack slot is much less likely to print
656 Reasons why we might want to use the LOC_REGISTER:
658 (1) So that the backtrace prints the same value
659 as "print foo". I see no compelling reason
660 why this needs to be the case; having the
661 backtrace print the value which was passed
662 in, and "print foo" print the value as
663 modified within the called function, makes
666 Additional note: It might be nice if "info args"
667 displayed both values.
669 One more note: There is a case with SPARC
670 structure passing where we need to use the
671 LOC_REGISTER, but this is dealt with by creating
672 a single LOC_REGPARM in symbol reading. */
674 /* Leave sym (the LOC_ARG) alone. */
681 /* Print the current arg. */
684 uiout
->wrap_hint (" ");
688 memset (&arg
, 0, sizeof (arg
));
690 arg
.entry_kind
= print_entry_values_no
;
691 memset (&entryarg
, 0, sizeof (entryarg
));
693 entryarg
.entry_kind
= print_entry_values_no
;
696 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
698 if (arg
.entry_kind
!= print_entry_values_only
)
699 print_frame_arg (&arg
);
701 if (entryarg
.entry_kind
!= print_entry_values_no
)
703 if (arg
.entry_kind
!= print_entry_values_only
)
706 uiout
->wrap_hint (" ");
709 print_frame_arg (&entryarg
);
713 xfree (entryarg
.error
);
719 /* Don't print nameless args in situations where we don't know
720 enough about the stack to find them. */
725 if (highest_offset
== -1)
726 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
728 start
= highest_offset
;
730 print_frame_nameless_args (frame
, start
, num
- args_printed
,
734 do_cleanups (old_chain
);
737 /* Set the current source and line to the location given by frame
738 FRAME, if possible. When CENTER is true, adjust so the relevant
739 line is in the center of the next 'list'. */
742 set_current_sal_from_frame (struct frame_info
*frame
)
744 struct symtab_and_line sal
;
746 find_frame_sal (frame
, &sal
);
747 if (sal
.symtab
!= NULL
)
748 set_current_source_symtab_and_line (&sal
);
751 /* If ON, GDB will display disassembly of the next source line when
752 execution of the program being debugged stops.
753 If AUTO (which is the default), or there's no line info to determine
754 the source line of the next instruction, display disassembly of next
755 instruction instead. */
757 static enum auto_boolean disassemble_next_line
;
760 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
761 struct cmd_list_element
*c
,
764 fprintf_filtered (file
,
765 _("Debugger's willingness to use "
766 "disassemble-next-line is %s.\n"),
770 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
771 because it will be broken by filter sometime. */
774 do_gdb_disassembly (struct gdbarch
*gdbarch
,
775 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
780 gdb_disassembly (gdbarch
, current_uiout
, 0,
781 DISASSEMBLY_RAW_INSN
, how_many
,
784 CATCH (exception
, RETURN_MASK_ERROR
)
786 /* If an exception was thrown while doing the disassembly, print
787 the error message, to give the user a clue of what happened. */
788 exception_print (gdb_stderr
, exception
);
793 /* Print information about frame FRAME. The output is format according
794 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
797 SRC_LINE: Print only source line.
798 LOCATION: Print only location.
799 LOC_AND_SRC: Print location and source line.
801 Used in "where" output, and to emit breakpoint or step
805 print_frame_info (struct frame_info
*frame
, int print_level
,
806 enum print_what print_what
, int print_args
,
809 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
810 struct symtab_and_line sal
;
813 struct ui_out
*uiout
= current_uiout
;
815 if (get_frame_type (frame
) == DUMMY_FRAME
816 || get_frame_type (frame
) == SIGTRAMP_FRAME
817 || get_frame_type (frame
) == ARCH_FRAME
)
819 struct cleanup
*uiout_cleanup
820 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
822 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
823 gdbarch
, get_frame_pc (frame
));
825 /* Do this regardless of SOURCE because we don't have any source
826 to list for this frame. */
830 uiout
->field_fmt_int (2, ui_left
, "level",
831 frame_relative_level (frame
));
833 if (uiout
->is_mi_like_p ())
835 annotate_frame_address ();
836 uiout
->field_core_addr ("addr",
837 gdbarch
, get_frame_pc (frame
));
838 annotate_frame_address_end ();
841 if (get_frame_type (frame
) == DUMMY_FRAME
)
843 annotate_function_call ();
844 uiout
->field_string ("func", "<function called from gdb>");
846 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
848 annotate_signal_handler_caller ();
849 uiout
->field_string ("func", "<signal handler called>");
851 else if (get_frame_type (frame
) == ARCH_FRAME
)
853 uiout
->field_string ("func", "<cross-architecture call>");
856 annotate_frame_end ();
858 /* If disassemble-next-line is set to auto or on output the next
860 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
861 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
862 do_gdb_disassembly (get_frame_arch (frame
), 1,
863 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
865 do_cleanups (uiout_cleanup
);
869 /* If FRAME is not the innermost frame, that normally means that
870 FRAME->pc points to *after* the call instruction, and we want to
871 get the line containing the call, never the next line. But if
872 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
873 next frame was not entered as the result of a call, and we want
874 to get the line containing FRAME->pc. */
875 find_frame_sal (frame
, &sal
);
877 location_print
= (print_what
== LOCATION
878 || print_what
== LOC_AND_ADDRESS
879 || print_what
== SRC_AND_LOC
);
881 if (location_print
|| !sal
.symtab
)
882 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
884 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
886 /* If disassemble-next-line is set to auto or on and doesn't have
887 the line debug messages for $pc, output the next instruction. */
888 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
889 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
890 && source_print
&& !sal
.symtab
)
891 do_gdb_disassembly (get_frame_arch (frame
), 1,
892 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
894 if (source_print
&& sal
.symtab
)
897 int mid_statement
= ((print_what
== SRC_LINE
)
898 && frame_show_address (frame
, sal
));
900 if (annotation_level
)
901 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
902 get_frame_pc (frame
));
905 if (deprecated_print_frame_info_listing_hook
)
906 deprecated_print_frame_info_listing_hook (sal
.symtab
,
911 struct value_print_options opts
;
913 get_user_print_options (&opts
);
914 /* We used to do this earlier, but that is clearly
915 wrong. This function is used by many different
916 parts of gdb, including normal_stop in infrun.c,
917 which uses this to print out the current PC
918 when we stepi/nexti into the middle of a source
919 line. Only the command line really wants this
920 behavior. Other UIs probably would like the
921 ability to decide for themselves if it is desired. */
922 if (opts
.addressprint
&& mid_statement
)
924 uiout
->field_core_addr ("addr",
925 gdbarch
, get_frame_pc (frame
));
929 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
933 /* If disassemble-next-line is set to on and there is line debug
934 messages, output assembly codes for next line. */
935 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
936 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
943 if (get_frame_pc_if_available (frame
, &pc
))
944 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
946 set_last_displayed_sal (0, 0, 0, 0, 0);
949 annotate_frame_end ();
951 gdb_flush (gdb_stdout
);
954 /* Remember the last symtab and line we displayed, which we use e.g.
955 * as the place to put a breakpoint when the `break' command is
956 * invoked with no arguments. */
959 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
960 CORE_ADDR addr
, struct symtab
*symtab
,
963 last_displayed_sal_valid
= valid
;
964 last_displayed_pspace
= pspace
;
965 last_displayed_addr
= addr
;
966 last_displayed_symtab
= symtab
;
967 last_displayed_line
= line
;
968 if (valid
&& pspace
== NULL
)
970 clear_last_displayed_sal ();
971 internal_error (__FILE__
, __LINE__
,
972 _("Trying to set NULL pspace."));
976 /* Forget the last sal we displayed. */
979 clear_last_displayed_sal (void)
981 last_displayed_sal_valid
= 0;
982 last_displayed_pspace
= 0;
983 last_displayed_addr
= 0;
984 last_displayed_symtab
= 0;
985 last_displayed_line
= 0;
988 /* Is our record of the last sal we displayed valid? If not,
989 * the get_last_displayed_* functions will return NULL or 0, as
993 last_displayed_sal_is_valid (void)
995 return last_displayed_sal_valid
;
998 /* Get the pspace of the last sal we displayed, if it's valid. */
1000 struct program_space
*
1001 get_last_displayed_pspace (void)
1003 if (last_displayed_sal_valid
)
1004 return last_displayed_pspace
;
1008 /* Get the address of the last sal we displayed, if it's valid. */
1011 get_last_displayed_addr (void)
1013 if (last_displayed_sal_valid
)
1014 return last_displayed_addr
;
1018 /* Get the symtab of the last sal we displayed, if it's valid. */
1021 get_last_displayed_symtab (void)
1023 if (last_displayed_sal_valid
)
1024 return last_displayed_symtab
;
1028 /* Get the line of the last sal we displayed, if it's valid. */
1031 get_last_displayed_line (void)
1033 if (last_displayed_sal_valid
)
1034 return last_displayed_line
;
1038 /* Get the last sal we displayed, if it's valid. */
1041 get_last_displayed_sal (struct symtab_and_line
*sal
)
1043 if (last_displayed_sal_valid
)
1045 sal
->pspace
= last_displayed_pspace
;
1046 sal
->pc
= last_displayed_addr
;
1047 sal
->symtab
= last_displayed_symtab
;
1048 sal
->line
= last_displayed_line
;
1060 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1061 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1064 find_frame_funname (struct frame_info
*frame
, char **funname
,
1065 enum language
*funlang
, struct symbol
**funcp
)
1067 struct symbol
*func
;
1070 *funlang
= language_unknown
;
1074 func
= get_frame_function (frame
);
1077 /* In certain pathological cases, the symtabs give the wrong
1078 function (when we are in the first function in a file which
1079 is compiled without debugging symbols, the previous function
1080 is compiled with debugging symbols, and the "foo.o" symbol
1081 that is supposed to tell us where the file with debugging
1082 symbols ends has been truncated by ar because it is longer
1083 than 15 characters). This also occurs if the user uses asm()
1084 to create a function but not stabs for it (in a file compiled
1087 So look in the minimal symbol tables as well, and if it comes
1088 up with a larger address for the function use that instead.
1089 I don't think this can ever cause any problems; there
1090 shouldn't be any minimal symbols in the middle of a function;
1091 if this is ever changed many parts of GDB will need to be
1092 changed (and we'll create a find_pc_minimal_function or some
1095 struct bound_minimal_symbol msymbol
;
1097 /* Don't attempt to do this for inlined functions, which do not
1098 have a corresponding minimal symbol. */
1099 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1101 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1103 memset (&msymbol
, 0, sizeof (msymbol
));
1105 if (msymbol
.minsym
!= NULL
1106 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1107 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1109 /* We also don't know anything about the function besides
1110 its address and name. */
1112 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1113 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1117 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1119 *funlang
= SYMBOL_LANGUAGE (func
);
1122 if (*funlang
== language_cplus
)
1124 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1125 to display the demangled name that we already have
1126 stored in the symbol table, but we stored a version
1127 with DMGL_PARAMS turned on, and here we don't want to
1128 display parameters. So remove the parameters. */
1129 char *func_only
= cp_remove_params (print_name
);
1132 *funname
= func_only
;
1135 /* If we didn't hit the C++ case above, set *funname here.
1136 This approach is taken to avoid having to install a
1137 cleanup in case cp_remove_params can throw. */
1138 if (*funname
== NULL
)
1139 *funname
= xstrdup (print_name
);
1144 struct bound_minimal_symbol msymbol
;
1147 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1150 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1151 if (msymbol
.minsym
!= NULL
)
1153 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1154 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1160 print_frame (struct frame_info
*frame
, int print_level
,
1161 enum print_what print_what
, int print_args
,
1162 struct symtab_and_line sal
)
1164 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1165 struct ui_out
*uiout
= current_uiout
;
1166 char *funname
= NULL
;
1167 enum language funlang
= language_unknown
;
1168 struct ui_file
*stb
;
1169 struct cleanup
*old_chain
, *list_chain
;
1170 struct value_print_options opts
;
1171 struct symbol
*func
;
1175 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1177 stb
= mem_fileopen ();
1178 old_chain
= make_cleanup_ui_file_delete (stb
);
1180 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1181 make_cleanup (xfree
, funname
);
1183 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1186 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1191 uiout
->field_fmt_int (2, ui_left
, "level",
1192 frame_relative_level (frame
));
1194 get_user_print_options (&opts
);
1195 if (opts
.addressprint
)
1197 || frame_show_address (frame
, sal
)
1198 || print_what
== LOC_AND_ADDRESS
)
1200 annotate_frame_address ();
1202 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1204 uiout
->field_string ("addr", "<unavailable>");
1205 annotate_frame_address_end ();
1206 uiout
->text (" in ");
1208 annotate_frame_function_name ();
1209 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1210 funlang
, DMGL_ANSI
);
1211 uiout
->field_stream ("func", stb
);
1212 uiout
->wrap_hint (" ");
1213 annotate_frame_args ();
1218 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1220 struct cleanup
*args_list_chain
;
1222 if (gdbarch_frame_num_args_p (gdbarch
))
1224 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1225 gdb_assert (numargs
>= 0);
1230 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1233 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1235 CATCH (e
, RETURN_MASK_ERROR
)
1240 /* FIXME: ARGS must be a list. If one argument is a string it
1241 will have " that will not be properly escaped. */
1242 /* Invoke ui_out_tuple_end. */
1243 do_cleanups (args_list_chain
);
1249 const char *filename_display
;
1251 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1252 annotate_frame_source_begin ();
1253 uiout
->wrap_hint (" ");
1254 uiout
->text (" at ");
1255 annotate_frame_source_file ();
1256 uiout
->field_string ("file", filename_display
);
1257 if (uiout
->is_mi_like_p ())
1259 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1261 uiout
->field_string ("fullname", fullname
);
1263 annotate_frame_source_file_end ();
1265 annotate_frame_source_line ();
1266 uiout
->field_int ("line", sal
.line
);
1267 annotate_frame_source_end ();
1270 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1272 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1273 get_frame_pc (frame
));
1277 annotate_frame_where ();
1278 uiout
->wrap_hint (" ");
1279 uiout
->text (" from ");
1280 uiout
->field_string ("from", lib
);
1284 /* do_cleanups will call ui_out_tuple_end() for us. */
1285 do_cleanups (list_chain
);
1287 do_cleanups (old_chain
);
1291 /* Read a frame specification in whatever the appropriate format is from
1292 FRAME_EXP. Call error() if the specification is in any way invalid (so
1293 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1294 set its target to indicate that the default selected frame was used. */
1296 static struct frame_info
*
1297 parse_frame_specification (const char *frame_exp
, int *selected_frame_p
)
1300 struct value
*args
[4];
1301 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1303 if (frame_exp
== NULL
)
1311 struct cleanup
*cleanup
;
1314 /* Skip leading white space, bail of EOL. */
1315 frame_exp
= skip_spaces_const (frame_exp
);
1319 /* Parse the argument, extract it, save it. */
1321 *p
&& !ISSPACE (*p
);
1323 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1325 cleanup
= make_cleanup (xfree
, addr_string
);
1327 /* NOTE: Parse and evaluate expression, but do not use
1328 functions such as parse_and_eval_long or
1329 parse_and_eval_address to also extract the value.
1330 Instead value_as_long and value_as_address are used.
1331 This avoids problems with expressions that contain
1333 if (numargs
>= ARRAY_SIZE (args
))
1334 error (_("Too many args in frame specification"));
1335 args
[numargs
++] = parse_and_eval (addr_string
);
1337 do_cleanups (cleanup
);
1341 /* If no args, default to the selected frame. */
1344 if (selected_frame_p
!= NULL
)
1345 (*selected_frame_p
) = 1;
1346 return get_selected_frame (_("No stack."));
1349 /* None of the remaining use the selected frame. */
1350 if (selected_frame_p
!= NULL
)
1351 (*selected_frame_p
) = 0;
1353 /* Assume the single arg[0] is an integer, and try using that to
1354 select a frame relative to current. */
1357 struct frame_info
*fid
;
1358 int level
= value_as_long (args
[0]);
1360 fid
= find_relative_frame (get_current_frame (), &level
);
1362 /* find_relative_frame was successful. */
1366 /* Convert each value into a corresponding address. */
1370 for (i
= 0; i
< numargs
; i
++)
1371 addrs
[i
] = value_as_address (args
[i
]);
1374 /* Assume that the single arg[0] is an address, use that to identify
1375 a frame with a matching ID. Should this also accept stack/pc or
1376 stack/pc/special. */
1379 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1380 struct frame_info
*fid
;
1382 /* If (s)he specifies the frame with an address, he deserves
1383 what (s)he gets. Still, give the highest one that matches.
1384 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1386 for (fid
= get_current_frame ();
1388 fid
= get_prev_frame (fid
))
1390 if (frame_id_eq (id
, get_frame_id (fid
)))
1392 struct frame_info
*prev_frame
;
1396 prev_frame
= get_prev_frame (fid
);
1398 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1407 /* We couldn't identify the frame as an existing frame, but
1408 perhaps we can create one with a single argument. */
1410 return create_new_frame (addrs
[0], 0);
1411 else if (numargs
== 2)
1412 return create_new_frame (addrs
[0], addrs
[1]);
1414 error (_("Too many args in frame specification"));
1417 /* Print verbosely the selected frame or the frame at address
1418 ADDR_EXP. Absolutely all information in the frame is printed. */
1421 frame_info (char *addr_exp
, int from_tty
)
1423 struct frame_info
*fi
;
1424 struct symtab_and_line sal
;
1425 struct symbol
*func
;
1427 struct frame_info
*calling_frame_info
;
1429 const char *funname
= 0;
1430 enum language funlang
= language_unknown
;
1431 const char *pc_regname
;
1432 int selected_frame_p
;
1433 struct gdbarch
*gdbarch
;
1434 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1437 /* Initialize it to avoid "may be used uninitialized" warning. */
1438 CORE_ADDR caller_pc
= 0;
1439 int caller_pc_p
= 0;
1441 fi
= parse_frame_specification (addr_exp
, &selected_frame_p
);
1442 gdbarch
= get_frame_arch (fi
);
1444 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1445 is not a good name. */
1446 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1447 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1448 easily not match that of the internal value returned by
1450 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1452 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1453 architectures will often have a hardware register called "pc",
1454 and that register's value, again, can easily not match
1458 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1459 find_frame_sal (fi
, &sal
);
1460 func
= get_frame_function (fi
);
1464 funname
= SYMBOL_PRINT_NAME (func
);
1465 funlang
= SYMBOL_LANGUAGE (func
);
1466 if (funlang
== language_cplus
)
1468 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1469 to display the demangled name that we already have
1470 stored in the symbol table, but we stored a version
1471 with DMGL_PARAMS turned on, and here we don't want to
1472 display parameters. So remove the parameters. */
1473 char *func_only
= cp_remove_params (funname
);
1477 funname
= func_only
;
1478 make_cleanup (xfree
, func_only
);
1482 else if (frame_pc_p
)
1484 struct bound_minimal_symbol msymbol
;
1486 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1487 if (msymbol
.minsym
!= NULL
)
1489 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1490 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1493 calling_frame_info
= get_prev_frame (fi
);
1495 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1497 printf_filtered (_("Stack level %d, frame at "),
1498 frame_relative_level (fi
));
1502 printf_filtered (_("Stack frame at "));
1504 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1505 printf_filtered (":\n");
1506 printf_filtered (" %s = ", pc_regname
);
1508 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1510 fputs_filtered ("<unavailable>", gdb_stdout
);
1515 printf_filtered (" in ");
1516 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1517 DMGL_ANSI
| DMGL_PARAMS
);
1521 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1523 puts_filtered ("; ");
1525 printf_filtered ("saved %s = ", pc_regname
);
1527 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1528 val_print_not_saved (gdb_stdout
);
1533 caller_pc
= frame_unwind_caller_pc (fi
);
1536 CATCH (ex
, RETURN_MASK_ERROR
)
1540 case NOT_AVAILABLE_ERROR
:
1541 val_print_unavailable (gdb_stdout
);
1543 case OPTIMIZED_OUT_ERROR
:
1544 val_print_not_saved (gdb_stdout
);
1547 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1555 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1556 printf_filtered ("\n");
1558 if (calling_frame_info
== NULL
)
1560 enum unwind_stop_reason reason
;
1562 reason
= get_frame_unwind_stop_reason (fi
);
1563 if (reason
!= UNWIND_NO_REASON
)
1564 printf_filtered (_(" Outermost frame: %s\n"),
1565 frame_stop_reason_string (fi
));
1567 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1568 puts_filtered (" tail call frame");
1569 else if (get_frame_type (fi
) == INLINE_FRAME
)
1570 printf_filtered (" inlined into frame %d",
1571 frame_relative_level (get_prev_frame (fi
)));
1574 printf_filtered (" called by frame at ");
1575 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1578 if (get_next_frame (fi
) && calling_frame_info
)
1579 puts_filtered (",");
1581 if (get_next_frame (fi
))
1583 printf_filtered (" caller of frame at ");
1584 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1587 if (get_next_frame (fi
) || calling_frame_info
)
1588 puts_filtered ("\n");
1591 printf_filtered (" source language %s.\n",
1592 language_str (s
->language
));
1595 /* Address of the argument list for this frame, or 0. */
1596 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1597 /* Number of args for this frame, or -1 if unknown. */
1601 printf_filtered (" Arglist at unknown address.\n");
1604 printf_filtered (" Arglist at ");
1605 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1606 printf_filtered (",");
1608 if (!gdbarch_frame_num_args_p (gdbarch
))
1611 puts_filtered (" args: ");
1615 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1616 gdb_assert (numargs
>= 0);
1618 puts_filtered (" no args.");
1619 else if (numargs
== 1)
1620 puts_filtered (" 1 arg: ");
1622 printf_filtered (" %d args: ", numargs
);
1624 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1625 puts_filtered ("\n");
1629 /* Address of the local variables for this frame, or 0. */
1630 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1633 printf_filtered (" Locals at unknown address,");
1636 printf_filtered (" Locals at ");
1637 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1638 printf_filtered (",");
1642 /* Print as much information as possible on the location of all the
1645 enum lval_type lval
;
1654 /* The sp is special; what's displayed isn't the save address, but
1655 the value of the previous frame's sp. This is a legacy thing,
1656 at one stage the frame cached the previous frame's SP instead
1657 of its address, hence it was easiest to just display the cached
1659 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1661 /* Find out the location of the saved stack pointer with out
1662 actually evaluating it. */
1663 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1664 &optimized
, &unavailable
, &lval
, &addr
,
1666 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1668 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1669 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1670 gdb_byte value
[MAX_REGISTER_SIZE
];
1673 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1674 &optimized
, &unavailable
, &lval
, &addr
,
1676 /* NOTE: cagney/2003-05-22: This is assuming that the
1677 stack pointer was packed as an unsigned integer. That
1678 may or may not be valid. */
1679 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1680 printf_filtered (" Previous frame's sp is ");
1681 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1682 printf_filtered ("\n");
1685 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1687 printf_filtered (" Previous frame's sp at ");
1688 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1689 printf_filtered ("\n");
1692 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1694 printf_filtered (" Previous frame's sp in %s\n",
1695 gdbarch_register_name (gdbarch
, realnum
));
1698 /* else keep quiet. */
1702 numregs
= gdbarch_num_regs (gdbarch
)
1703 + gdbarch_num_pseudo_regs (gdbarch
);
1704 for (i
= 0; i
< numregs
; i
++)
1705 if (i
!= gdbarch_sp_regnum (gdbarch
)
1706 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1708 /* Find out the location of the saved register without
1709 fetching the corresponding value. */
1710 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1711 &lval
, &addr
, &realnum
, NULL
);
1712 /* For moment, only display registers that were saved on the
1714 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1717 puts_filtered (" Saved registers:\n ");
1719 puts_filtered (",");
1721 printf_filtered (" %s at ",
1722 gdbarch_register_name (gdbarch
, i
));
1723 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1727 if (count
|| need_nl
)
1728 puts_filtered ("\n");
1731 do_cleanups (back_to
);
1734 /* Print briefly all stack frames or just the innermost COUNT_EXP
1738 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1741 struct frame_info
*fi
;
1744 struct frame_info
*trailing
;
1745 int trailing_level
, py_start
= 0, py_end
= 0;
1746 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1748 if (!target_has_stack
)
1749 error (_("No stack."));
1751 /* The following code must do two things. First, it must set the
1752 variable TRAILING to the frame from which we should start
1753 printing. Second, it must set the variable count to the number
1754 of frames which we should print, or -1 if all of them. */
1755 trailing
= get_current_frame ();
1760 count
= parse_and_eval_long (count_exp
);
1763 struct frame_info
*current
;
1769 while (current
&& count
--)
1772 current
= get_prev_frame (current
);
1775 /* Will stop when CURRENT reaches the top of the stack.
1776 TRAILING will be COUNT below it. */
1780 trailing
= get_prev_frame (trailing
);
1781 current
= get_prev_frame (current
);
1801 /* Read in symbols for all of the frames. Need to do this in a
1802 separate pass so that "Reading in symbols for xxx" messages
1803 don't screw up the appearance of the backtrace. Also if
1804 people have strong opinions against reading symbols for
1805 backtrace this may have to be an option. */
1807 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1812 pc
= get_frame_address_in_block (fi
);
1813 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1819 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1820 enum ext_lang_frame_args arg_type
;
1823 flags
|= PRINT_LOCALS
;
1825 if (!strcmp (print_frame_arguments
, "scalars"))
1826 arg_type
= CLI_SCALAR_VALUES
;
1827 else if (!strcmp (print_frame_arguments
, "all"))
1828 arg_type
= CLI_ALL_VALUES
;
1830 arg_type
= NO_VALUES
;
1832 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1833 arg_type
, current_uiout
,
1837 /* Run the inbuilt backtrace if there are no filters registered, or
1838 "no-filters" has been specified from the command. */
1839 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1841 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1845 /* Don't use print_stack_frame; if an error() occurs it probably
1846 means further attempts to backtrace would fail (on the other
1847 hand, perhaps the code does or could be fixed to make sure
1848 the frame->prev field gets set to NULL in that case). */
1850 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1853 struct frame_id frame_id
= get_frame_id (fi
);
1855 print_frame_local_vars (fi
, 1, gdb_stdout
);
1857 /* print_frame_local_vars invalidates FI. */
1858 fi
= frame_find_by_id (frame_id
);
1862 warning (_("Unable to restore previously selected frame."));
1867 /* Save the last frame to check for error conditions. */
1871 /* If we've stopped before the end, mention that. */
1873 printf_filtered (_("(More stack frames follow...)\n"));
1875 /* If we've run out of frames, and the reason appears to be an error
1876 condition, print it. */
1877 if (fi
== NULL
&& trailing
!= NULL
)
1879 enum unwind_stop_reason reason
;
1881 reason
= get_frame_unwind_stop_reason (trailing
);
1882 if (reason
>= UNWIND_FIRST_ERROR
)
1883 printf_filtered (_("Backtrace stopped: %s\n"),
1884 frame_stop_reason_string (trailing
));
1890 backtrace_command (char *arg
, int from_tty
)
1892 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1893 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1901 argv
= gdb_buildargv (arg
);
1902 make_cleanup_freeargv (argv
);
1904 for (i
= 0; argv
[i
]; i
++)
1908 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1909 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1911 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1915 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1916 fulltrace_arg
= argc
;
1920 arglen
+= strlen (argv
[i
]);
1926 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1930 arg
= (char *) xmalloc (arglen
+ 1);
1931 make_cleanup (xfree
, arg
);
1933 for (i
= 0; i
< argc
; i
++)
1935 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1937 strcat (arg
, argv
[i
]);
1947 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1948 no_filters
>= 0 /* no frame-filters */, from_tty
);
1950 do_cleanups (old_chain
);
1953 /* Iterate over the local variables of a block B, calling CB with
1957 iterate_over_block_locals (const struct block
*b
,
1958 iterate_over_block_arg_local_vars_cb cb
,
1961 struct block_iterator iter
;
1964 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1966 switch (SYMBOL_CLASS (sym
))
1972 if (SYMBOL_IS_ARGUMENT (sym
))
1974 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1976 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1980 /* Ignore symbols which are not locals. */
1987 /* Same, but print labels. */
1990 /* Commented out, as the code using this function has also been
1991 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1992 was commented out in the first place. The discussion introducing
1993 this change (2007-12-04: Support lexical blocks and function bodies
1994 that occupy non-contiguous address ranges) did not explain why
1995 this change was made. */
1997 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1998 int *have_default
, struct ui_file
*stream
)
2000 struct block_iterator iter
;
2002 int values_printed
= 0;
2004 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2006 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
2012 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
2014 struct symtab_and_line sal
;
2015 struct value_print_options opts
;
2017 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2019 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2020 get_user_print_options (&opts
);
2021 if (opts
.addressprint
)
2023 fprintf_filtered (stream
, " ");
2024 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2027 fprintf_filtered (stream
, " in file %s, line %d\n",
2028 sal
.symtab
->filename
, sal
.line
);
2032 return values_printed
;
2036 /* Iterate over all the local variables in block B, including all its
2037 superblocks, stopping when the top-level block is reached. */
2040 iterate_over_block_local_vars (const struct block
*block
,
2041 iterate_over_block_arg_local_vars_cb cb
,
2046 iterate_over_block_locals (block
, cb
, cb_data
);
2047 /* After handling the function's top-level block, stop. Don't
2048 continue to its superblock, the block of per-file
2050 if (BLOCK_FUNCTION (block
))
2052 block
= BLOCK_SUPERBLOCK (block
);
2056 /* Data to be passed around in the calls to the locals and args
2059 struct print_variable_and_value_data
2061 struct frame_id frame_id
;
2063 struct ui_file
*stream
;
2067 /* The callback for the locals and args iterators. */
2070 do_print_variable_and_value (const char *print_name
,
2074 struct print_variable_and_value_data
*p
2075 = (struct print_variable_and_value_data
*) cb_data
;
2076 struct frame_info
*frame
;
2078 frame
= frame_find_by_id (p
->frame_id
);
2081 warning (_("Unable to restore previously selected frame."));
2085 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2087 /* print_variable_and_value invalidates FRAME. */
2090 p
->values_printed
= 1;
2093 /* Print all variables from the innermost up to the function block of FRAME.
2094 Print them with values to STREAM indented by NUM_TABS.
2096 This function will invalidate FRAME. */
2099 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2100 struct ui_file
*stream
)
2102 struct print_variable_and_value_data cb_data
;
2103 const struct block
*block
;
2105 struct gdb_exception except
= exception_none
;
2107 if (!get_frame_pc_if_available (frame
, &pc
))
2109 fprintf_filtered (stream
,
2110 _("PC unavailable, cannot determine locals.\n"));
2114 block
= get_frame_block (frame
, 0);
2117 fprintf_filtered (stream
, "No symbol table info available.\n");
2121 cb_data
.frame_id
= get_frame_id (frame
);
2122 cb_data
.num_tabs
= 4 * num_tabs
;
2123 cb_data
.stream
= stream
;
2124 cb_data
.values_printed
= 0;
2126 /* Temporarily change the selected frame to the given FRAME.
2127 This allows routines that rely on the selected frame instead
2128 of being given a frame as parameter to use the correct frame. */
2129 select_frame (frame
);
2133 iterate_over_block_local_vars (block
,
2134 do_print_variable_and_value
,
2137 CATCH (ex
, RETURN_MASK_ALL
)
2143 /* Restore the selected frame, and then rethrow if there was a problem. */
2144 select_frame (frame_find_by_id (cb_data
.frame_id
));
2145 if (except
.reason
< 0)
2146 throw_exception (except
);
2148 /* do_print_variable_and_value invalidates FRAME. */
2151 if (!cb_data
.values_printed
)
2152 fprintf_filtered (stream
, _("No locals.\n"));
2156 locals_info (char *args
, int from_tty
)
2158 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2162 /* Iterate over all the argument variables in block B.
2164 Returns 1 if any argument was walked; 0 otherwise. */
2167 iterate_over_block_arg_vars (const struct block
*b
,
2168 iterate_over_block_arg_local_vars_cb cb
,
2171 struct block_iterator iter
;
2172 struct symbol
*sym
, *sym2
;
2174 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2176 /* Don't worry about things which aren't arguments. */
2177 if (SYMBOL_IS_ARGUMENT (sym
))
2179 /* We have to look up the symbol because arguments can have
2180 two entries (one a parameter, one a local) and the one we
2181 want is the local, which lookup_symbol will find for us.
2182 This includes gcc1 (not gcc2) on the sparc when passing a
2183 small structure and gcc2 when the argument type is float
2184 and it is passed as a double and converted to float by
2185 the prologue (in the latter case the type of the LOC_ARG
2186 symbol is double and the type of the LOC_LOCAL symbol is
2187 float). There are also LOC_ARG/LOC_REGISTER pairs which
2188 are not combined in symbol-reading. */
2190 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2191 b
, VAR_DOMAIN
, NULL
).symbol
;
2192 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2197 /* Print all argument variables of the function of FRAME.
2198 Print them with values to STREAM.
2200 This function will invalidate FRAME. */
2203 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2205 struct print_variable_and_value_data cb_data
;
2206 struct symbol
*func
;
2209 if (!get_frame_pc_if_available (frame
, &pc
))
2211 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2215 func
= get_frame_function (frame
);
2218 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2222 cb_data
.frame_id
= get_frame_id (frame
);
2223 cb_data
.num_tabs
= 0;
2224 cb_data
.stream
= gdb_stdout
;
2225 cb_data
.values_printed
= 0;
2227 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2228 do_print_variable_and_value
, &cb_data
);
2230 /* do_print_variable_and_value invalidates FRAME. */
2233 if (!cb_data
.values_printed
)
2234 fprintf_filtered (stream
, _("No arguments.\n"));
2238 args_info (char *ignore
, int from_tty
)
2240 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2244 /* Select frame FRAME. Also print the stack frame and show the source
2245 if this is the tui version. */
2247 select_and_print_frame (struct frame_info
*frame
)
2249 select_frame (frame
);
2251 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2254 /* Return the symbol-block in which the selected frame is executing.
2255 Can return zero under various legitimate circumstances.
2257 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2258 code address within the block returned. We use this to decide
2259 which macros are in scope. */
2261 const struct block
*
2262 get_selected_block (CORE_ADDR
*addr_in_block
)
2264 if (!has_stack_frames ())
2267 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2270 /* Find a frame a certain number of levels away from FRAME.
2271 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2272 Positive means go to earlier frames (up); negative, the reverse.
2273 The int that contains the number of levels is counted toward
2274 zero as the frames for those levels are found.
2275 If the top or bottom frame is reached, that frame is returned,
2276 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2277 how much farther the original request asked to go. */
2280 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2282 /* Going up is simple: just call get_prev_frame enough times or
2283 until the initial frame is reached. */
2284 while (*level_offset_ptr
> 0)
2286 struct frame_info
*prev
= get_prev_frame (frame
);
2290 (*level_offset_ptr
)--;
2294 /* Going down is just as simple. */
2295 while (*level_offset_ptr
< 0)
2297 struct frame_info
*next
= get_next_frame (frame
);
2301 (*level_offset_ptr
)++;
2308 /* The "select_frame" command. With no argument this is a NOP.
2309 Select the frame at level LEVEL_EXP if it is a valid level.
2310 Otherwise, treat LEVEL_EXP as an address expression and select it.
2312 See parse_frame_specification for more info on proper frame
2316 select_frame_command (char *level_exp
, int from_tty
)
2318 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2320 select_frame (parse_frame_specification (level_exp
, NULL
));
2321 if (get_selected_frame_if_set () != prev_frame
)
2322 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2325 /* The "frame" command. With no argument, print the selected frame
2326 briefly. With an argument, behave like select_frame and then print
2327 the selected frame. */
2330 frame_command (char *level_exp
, int from_tty
)
2332 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2334 select_frame (parse_frame_specification (level_exp
, NULL
));
2335 if (get_selected_frame_if_set () != prev_frame
)
2336 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2338 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
2341 /* Select the frame up one or COUNT_EXP stack levels from the
2342 previously selected frame, and print it briefly. */
2345 up_silently_base (const char *count_exp
)
2347 struct frame_info
*frame
;
2351 count
= parse_and_eval_long (count_exp
);
2353 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2354 if (count
!= 0 && count_exp
== NULL
)
2355 error (_("Initial frame selected; you cannot go up."));
2356 select_frame (frame
);
2360 up_silently_command (char *count_exp
, int from_tty
)
2362 up_silently_base (count_exp
);
2366 up_command (char *count_exp
, int from_tty
)
2368 up_silently_base (count_exp
);
2369 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2372 /* Select the frame down one or COUNT_EXP stack levels from the previously
2373 selected frame, and print it briefly. */
2376 down_silently_base (const char *count_exp
)
2378 struct frame_info
*frame
;
2382 count
= -parse_and_eval_long (count_exp
);
2384 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2385 if (count
!= 0 && count_exp
== NULL
)
2387 /* We only do this if COUNT_EXP is not specified. That way
2388 "down" means to really go down (and let me know if that is
2389 impossible), but "down 9999" can be used to mean go all the
2390 way down without getting an error. */
2392 error (_("Bottom (innermost) frame selected; you cannot go down."));
2395 select_frame (frame
);
2399 down_silently_command (char *count_exp
, int from_tty
)
2401 down_silently_base (count_exp
);
2405 down_command (char *count_exp
, int from_tty
)
2407 down_silently_base (count_exp
);
2408 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2412 return_command (char *retval_exp
, int from_tty
)
2414 /* Initialize it just to avoid a GCC false warning. */
2415 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2416 struct frame_info
*thisframe
;
2417 struct gdbarch
*gdbarch
;
2418 struct symbol
*thisfun
;
2419 struct value
*return_value
= NULL
;
2420 struct value
*function
= NULL
;
2421 const char *query_prefix
= "";
2423 thisframe
= get_selected_frame ("No selected frame.");
2424 thisfun
= get_frame_function (thisframe
);
2425 gdbarch
= get_frame_arch (thisframe
);
2427 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2428 error (_("Can not force return from an inlined function."));
2430 /* Compute the return value. If the computation triggers an error,
2431 let it bail. If the return type can't be handled, set
2432 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2436 expression_up retval_expr
= parse_expression (retval_exp
);
2437 struct type
*return_type
= NULL
;
2439 /* Compute the return value. Should the computation fail, this
2440 call throws an error. */
2441 return_value
= evaluate_expression (retval_expr
.get ());
2443 /* Cast return value to the return type of the function. Should
2444 the cast fail, this call throws an error. */
2445 if (thisfun
!= NULL
)
2446 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2447 if (return_type
== NULL
)
2449 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2450 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2451 error (_("Return value type not available for selected "
2453 "Please use an explicit cast of the value to return."));
2454 return_type
= value_type (return_value
);
2456 return_type
= check_typedef (return_type
);
2457 return_value
= value_cast (return_type
, return_value
);
2459 /* Make sure the value is fully evaluated. It may live in the
2460 stack frame we're about to pop. */
2461 if (value_lazy (return_value
))
2462 value_fetch_lazy (return_value
);
2464 if (thisfun
!= NULL
)
2465 function
= read_var_value (thisfun
, NULL
, thisframe
);
2467 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2468 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2469 /* If the return-type is "void", don't try to find the
2470 return-value's location. However, do still evaluate the
2471 return expression so that, even when the expression result
2472 is discarded, side effects such as "return i++" still
2474 return_value
= NULL
;
2475 else if (thisfun
!= NULL
)
2477 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2478 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2479 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2481 query_prefix
= "The location at which to store the "
2482 "function's return value is unknown.\n"
2483 "If you continue, the return value "
2484 "that you specified will be ignored.\n";
2485 return_value
= NULL
;
2490 /* Does an interactive user really want to do this? Include
2491 information, such as how well GDB can handle the return value, in
2492 the query message. */
2497 if (thisfun
== NULL
)
2498 confirmed
= query (_("%sMake selected stack frame return now? "),
2502 if (TYPE_NO_RETURN (thisfun
->type
))
2503 warning (_("Function does not return normally to caller."));
2504 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2505 SYMBOL_PRINT_NAME (thisfun
));
2508 error (_("Not confirmed"));
2511 /* Discard the selected frame and all frames inner-to it. */
2512 frame_pop (get_selected_frame (NULL
));
2514 /* Store RETURN_VALUE in the just-returned register set. */
2515 if (return_value
!= NULL
)
2517 struct type
*return_type
= value_type (return_value
);
2518 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2520 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2521 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2522 gdbarch_return_value (gdbarch
, function
, return_type
,
2523 get_current_regcache (), NULL
/*read*/,
2524 value_contents (return_value
) /*write*/);
2527 /* If we are at the end of a call dummy now, pop the dummy frame
2529 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2530 frame_pop (get_current_frame ());
2532 select_frame (get_current_frame ());
2533 /* If interactive, print the frame that is now current. */
2535 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2538 /* Sets the scope to input function name, provided that the function
2539 is within the current stack frame. */
2541 struct function_bounds
2543 CORE_ADDR low
, high
;
2547 func_command (char *arg
, int from_tty
)
2549 struct frame_info
*frame
;
2551 struct symtabs_and_lines sals
;
2554 struct function_bounds
*func_bounds
= NULL
;
2555 struct cleanup
*cleanups
;
2560 frame
= get_current_frame ();
2561 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2562 cleanups
= make_cleanup (xfree
, sals
.sals
);
2563 func_bounds
= XNEWVEC (struct function_bounds
, sals
.nelts
);
2564 make_cleanup (xfree
, func_bounds
);
2565 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2567 if (sals
.sals
[i
].pspace
!= current_program_space
)
2568 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2569 else if (sals
.sals
[i
].pc
== 0
2570 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2571 &func_bounds
[i
].low
,
2572 &func_bounds
[i
].high
) == 0)
2574 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2580 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2581 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2582 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2586 frame
= find_relative_frame (frame
, &level
);
2589 while (!found
&& level
== 0);
2591 do_cleanups (cleanups
);
2594 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2595 else if (frame
!= get_selected_frame (NULL
))
2596 select_and_print_frame (frame
);
2600 /* Provide a prototype to silence -Wmissing-prototypes. */
2601 void _initialize_stack (void);
2604 _initialize_stack (void)
2606 add_com ("return", class_stack
, return_command
, _("\
2607 Make selected stack frame return to its caller.\n\
2608 Control remains in the debugger, but when you continue\n\
2609 execution will resume in the frame above the one now selected.\n\
2610 If an argument is given, it is an expression for the value to return."));
2612 add_com ("up", class_stack
, up_command
, _("\
2613 Select and print stack frame that called this one.\n\
2614 An argument says how many frames up to go."));
2615 add_com ("up-silently", class_support
, up_silently_command
, _("\
2616 Same as the `up' command, but does not print anything.\n\
2617 This is useful in command scripts."));
2619 add_com ("down", class_stack
, down_command
, _("\
2620 Select and print stack frame called by this one.\n\
2621 An argument says how many frames down to go."));
2622 add_com_alias ("do", "down", class_stack
, 1);
2623 add_com_alias ("dow", "down", class_stack
, 1);
2624 add_com ("down-silently", class_support
, down_silently_command
, _("\
2625 Same as the `down' command, but does not print anything.\n\
2626 This is useful in command scripts."));
2628 add_com ("frame", class_stack
, frame_command
, _("\
2629 Select and print a stack frame.\nWith no argument, \
2630 print the selected stack frame. (See also \"info frame\").\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"));
2634 add_com_alias ("f", "frame", class_stack
, 1);
2636 add_com_suppress_notification ("select-frame", class_stack
, select_frame_command
, _("\
2637 Select a stack frame without printing anything.\n\
2638 An argument specifies the frame to select.\n\
2639 It can be a stack frame number or the address of the frame.\n"),
2640 &cli_suppress_notification
.user_selected_context
);
2642 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2643 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2644 With a negative argument, print outermost -COUNT frames.\nUse of the \
2645 'full' qualifier also prints the values of the local variables.\n\
2646 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2647 on this backtrace.\n"));
2648 add_com_alias ("bt", "backtrace", class_stack
, 0);
2650 add_com_alias ("where", "backtrace", class_alias
, 0);
2651 add_info ("stack", backtrace_command
,
2652 _("Backtrace of the stack, or innermost COUNT frames."));
2653 add_info_alias ("s", "stack", 1);
2654 add_info ("frame", frame_info
,
2655 _("All about selected stack frame, or frame at ADDR."));
2656 add_info_alias ("f", "frame", 1);
2657 add_info ("locals", locals_info
,
2658 _("Local variables of current stack frame."));
2659 add_info ("args", args_info
,
2660 _("Argument variables of current stack frame."));
2663 add_com ("func", class_stack
, func_command
, _("\
2664 Select the stack frame that contains <func>.\n\
2665 Usage: func <name>\n"));
2667 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2668 print_frame_arguments_choices
, &print_frame_arguments
,
2669 _("Set printing of non-scalar frame arguments"),
2670 _("Show printing of non-scalar frame arguments"),
2671 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2673 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2674 &print_raw_frame_arguments
, _("\
2675 Set whether to print frame arguments in raw form."), _("\
2676 Show whether to print frame arguments in raw form."), _("\
2677 If set, frame arguments are printed in raw form, bypassing any\n\
2678 pretty-printers for that value."),
2680 &setprintrawlist
, &showprintrawlist
);
2682 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2683 &disassemble_next_line
, _("\
2684 Set whether to disassemble next source line or insn when execution stops."),
2686 Show whether to disassemble next source line or insn when execution stops."),
2688 If ON, GDB will display disassembly of the next source line, in addition\n\
2689 to displaying the source line itself. If the next source line cannot\n\
2690 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2691 will display disassembly of next instruction instead of showing the\n\
2693 If AUTO, display disassembly of next instruction only if the source line\n\
2694 cannot be displayed.\n\
2695 If OFF (which is the default), never display the disassembly of the next\n\
2698 show_disassemble_next_line
,
2699 &setlist
, &showlist
);
2700 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2702 add_setshow_enum_cmd ("entry-values", class_stack
,
2703 print_entry_values_choices
, &print_entry_values
,
2704 _("Set printing of function arguments at function "
2706 _("Show printing of function arguments at function "
2709 GDB can sometimes determine the values of function arguments at entry,\n\
2710 in addition to their current values. This option tells GDB whether\n\
2711 to print the current value, the value at entry (marked as val@entry),\n\
2712 or both. Note that one or both of these values may be <optimized out>."),
2713 NULL
, NULL
, &setprintlist
, &showprintlist
);