1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
51 #include "safe-ctype.h"
53 #include "extension.h"
55 /* The possible choices of "set print frame-arguments", and the value
58 static const char *const print_frame_arguments_choices
[] =
59 {"all", "scalars", "none", NULL
};
60 static const char *print_frame_arguments
= "scalars";
62 /* If non-zero, don't invoke pretty-printers for frame arguments. */
63 static int print_raw_frame_arguments
;
65 /* The possible choices of "set print entry-values", and the value
68 const char print_entry_values_no
[] = "no";
69 const char print_entry_values_only
[] = "only";
70 const char print_entry_values_preferred
[] = "preferred";
71 const char print_entry_values_if_needed
[] = "if-needed";
72 const char print_entry_values_both
[] = "both";
73 const char print_entry_values_compact
[] = "compact";
74 const char print_entry_values_default
[] = "default";
75 static const char *const print_entry_values_choices
[] =
77 print_entry_values_no
,
78 print_entry_values_only
,
79 print_entry_values_preferred
,
80 print_entry_values_if_needed
,
81 print_entry_values_both
,
82 print_entry_values_compact
,
83 print_entry_values_default
,
86 const char *print_entry_values
= print_entry_values_default
;
88 /* Prototypes for local functions. */
90 static void print_frame_local_vars (struct frame_info
*, int,
93 static void print_frame (struct frame_info
*frame
, int print_level
,
94 enum print_what print_what
, int print_args
,
95 struct symtab_and_line sal
);
97 static void set_last_displayed_sal (int valid
,
98 struct program_space
*pspace
,
100 struct symtab
*symtab
,
103 /* Zero means do things normally; we are interacting directly with the
104 user. One means print the full filename and linenumber when a
105 frame is printed, and do so in a format emacs18/emacs19.22 can
106 parse. Two means print similar annotations, but in many more
107 cases and in a slightly different syntax. */
109 int annotation_level
= 0;
111 /* These variables hold the last symtab and line we displayed to the user.
112 * This is where we insert a breakpoint or a skiplist entry by default. */
113 static int last_displayed_sal_valid
= 0;
114 static struct program_space
*last_displayed_pspace
= 0;
115 static CORE_ADDR last_displayed_addr
= 0;
116 static struct symtab
*last_displayed_symtab
= 0;
117 static int last_displayed_line
= 0;
120 /* Return 1 if we should display the address in addition to the location,
121 because we are in the middle of a statement. */
124 frame_show_address (struct frame_info
*frame
,
125 struct symtab_and_line sal
)
127 /* If there is a line number, but no PC, then there is no location
128 information associated with this sal. The only way that should
129 happen is for the call sites of inlined functions (SAL comes from
130 find_frame_sal). Otherwise, we would have some PC range if the
131 SAL came from a line table. */
132 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
134 if (get_next_frame (frame
) == NULL
)
135 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
137 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
141 return get_frame_pc (frame
) != sal
.pc
;
144 /* Show or print a stack frame FRAME briefly. The output is formatted
145 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
146 relative level, function name, argument list, and file name and
147 line number. If the frame's PC is not at the beginning of the
148 source line, the actual PC is printed at the beginning. */
151 print_stack_frame (struct frame_info
*frame
, int print_level
,
152 enum print_what print_what
,
156 /* For mi, alway print location and address. */
157 if (ui_out_is_mi_like_p (current_uiout
))
158 print_what
= LOC_AND_ADDRESS
;
162 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
165 set_current_sal_from_frame (frame
);
167 CATCH (e
, RETURN_MASK_ERROR
)
173 /* Print nameless arguments of frame FRAME on STREAM, where START is
174 the offset of the first nameless argument, and NUM is the number of
175 nameless arguments to print. FIRST is nonzero if this is the first
176 argument (not just the first nameless argument). */
179 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
180 int first
, struct ui_file
*stream
)
182 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
183 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
188 for (i
= 0; i
< num
; i
++)
191 argsaddr
= get_frame_args_address (frame
);
194 arg_value
= read_memory_integer (argsaddr
+ start
,
195 sizeof (int), byte_order
);
197 fprintf_filtered (stream
, ", ");
198 fprintf_filtered (stream
, "%ld", arg_value
);
200 start
+= sizeof (int);
204 /* Print single argument of inferior function. ARG must be already
207 Errors are printed as if they would be the parameter value. Use zeroed ARG
208 iff it should not be printed accoring to user settings. */
211 print_frame_arg (const struct frame_arg
*arg
)
213 struct ui_out
*uiout
= current_uiout
;
214 struct cleanup
*old_chain
;
216 const char *error_message
= NULL
;
218 stb
= mem_fileopen ();
219 old_chain
= make_cleanup_ui_file_delete (stb
);
221 gdb_assert (!arg
->val
|| !arg
->error
);
222 gdb_assert (arg
->entry_kind
== print_entry_values_no
223 || arg
->entry_kind
== print_entry_values_only
224 || (!ui_out_is_mi_like_p (uiout
)
225 && arg
->entry_kind
== print_entry_values_compact
));
227 annotate_arg_begin ();
229 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
230 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
231 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
232 if (arg
->entry_kind
== print_entry_values_compact
)
234 /* It is OK to provide invalid MI-like stream as with
235 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
236 fputs_filtered ("=", stb
);
238 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
239 SYMBOL_LANGUAGE (arg
->sym
),
240 DMGL_PARAMS
| DMGL_ANSI
);
242 if (arg
->entry_kind
== print_entry_values_only
243 || arg
->entry_kind
== print_entry_values_compact
)
244 fputs_filtered ("@entry", stb
);
245 ui_out_field_stream (uiout
, "name", stb
);
246 annotate_arg_name_end ();
247 ui_out_text (uiout
, "=");
249 if (!arg
->val
&& !arg
->error
)
250 ui_out_text (uiout
, "...");
254 error_message
= arg
->error
;
259 const struct language_defn
*language
;
260 struct value_print_options opts
;
262 /* Avoid value_print because it will deref ref parameters. We
263 just want to print their addresses. Print ??? for args whose
264 address we do not know. We pass 2 as "recurse" to val_print
265 because our standard indentation here is 4 spaces, and
266 val_print indents 2 for each recurse. */
268 annotate_arg_value (value_type (arg
->val
));
270 /* Use the appropriate language to display our symbol, unless the
271 user forced the language to a specific language. */
272 if (language_mode
== language_mode_auto
)
273 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
275 language
= current_language
;
277 get_no_prettyformat_print_options (&opts
);
279 opts
.raw
= print_raw_frame_arguments
;
281 /* True in "summary" mode, false otherwise. */
282 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
284 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
286 CATCH (except
, RETURN_MASK_ERROR
)
288 error_message
= except
.message
;
292 if (error_message
!= NULL
)
293 fprintf_filtered (stb
, _("<error reading variable: %s>"),
297 ui_out_field_stream (uiout
, "value", stb
);
299 /* Also invoke ui_out_tuple_end. */
300 do_cleanups (old_chain
);
305 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
306 responsible for xfree of ARGP->ERROR. This function never throws an
310 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
311 struct frame_arg
*argp
)
313 struct value
*val
= NULL
;
321 argp
->val
= read_var_value (sym
, NULL
, frame
);
323 CATCH (except
, RETURN_MASK_ERROR
)
325 argp
->error
= xstrdup (except
.message
);
330 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
331 responsible for xfree of ARGP->ERROR. This function never throws an
335 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
336 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
338 struct value
*val
= NULL
, *entryval
= NULL
;
339 char *val_error
= NULL
, *entryval_error
= NULL
;
342 if (print_entry_values
!= print_entry_values_only
343 && print_entry_values
!= print_entry_values_preferred
)
347 val
= read_var_value (sym
, NULL
, frame
);
349 CATCH (except
, RETURN_MASK_ERROR
)
351 val_error
= (char *) alloca (strlen (except
.message
) + 1);
352 strcpy (val_error
, except
.message
);
357 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
358 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
359 && print_entry_values
!= print_entry_values_no
360 && (print_entry_values
!= print_entry_values_if_needed
361 || !val
|| value_optimized_out (val
)))
365 const struct symbol_computed_ops
*ops
;
367 ops
= SYMBOL_COMPUTED_OPS (sym
);
368 entryval
= ops
->read_variable_at_entry (sym
, frame
);
370 CATCH (except
, RETURN_MASK_ERROR
)
372 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
374 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
375 strcpy (entryval_error
, except
.message
);
380 if (entryval
!= NULL
&& value_optimized_out (entryval
))
383 if (print_entry_values
== print_entry_values_compact
384 || print_entry_values
== print_entry_values_default
)
386 /* For MI do not try to use print_entry_values_compact for ARGP. */
388 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
390 struct type
*type
= value_type (val
);
392 if (value_lazy (val
))
393 value_fetch_lazy (val
);
394 if (value_lazy (entryval
))
395 value_fetch_lazy (entryval
);
397 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
399 /* Initialize it just to avoid a GCC false warning. */
400 struct value
*val_deref
= NULL
, *entryval_deref
;
402 /* DW_AT_GNU_call_site_value does match with the current
403 value. If it is a reference still try to verify if
404 dereferenced DW_AT_GNU_call_site_data_value does not
409 struct type
*type_deref
;
411 val_deref
= coerce_ref (val
);
412 if (value_lazy (val_deref
))
413 value_fetch_lazy (val_deref
);
414 type_deref
= value_type (val_deref
);
416 entryval_deref
= coerce_ref (entryval
);
417 if (value_lazy (entryval_deref
))
418 value_fetch_lazy (entryval_deref
);
420 /* If the reference addresses match but dereferenced
421 content does not match print them. */
423 && value_contents_eq (val_deref
, 0,
425 TYPE_LENGTH (type_deref
)))
428 CATCH (except
, RETURN_MASK_ERROR
)
430 /* If the dereferenced content could not be
431 fetched do not display anything. */
432 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
434 else if (except
.message
!= NULL
)
436 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
437 strcpy (entryval_error
, except
.message
);
442 /* Value was not a reference; and its content matches. */
443 if (val
== val_deref
)
451 /* Try to remove possibly duplicate error message for ENTRYARGP even
454 if (val_error
&& entryval_error
455 && strcmp (val_error
, entryval_error
) == 0)
457 entryval_error
= NULL
;
459 /* Do not se VAL_EQUAL as the same error message may be shown for
460 the entry value even if no entry values are present in the
466 if (entryval
== NULL
)
468 if (print_entry_values
== print_entry_values_preferred
)
470 gdb_assert (val
== NULL
);
474 val
= read_var_value (sym
, NULL
, frame
);
476 CATCH (except
, RETURN_MASK_ERROR
)
478 val_error
= (char *) alloca (strlen (except
.message
) + 1);
479 strcpy (val_error
, except
.message
);
483 if (print_entry_values
== print_entry_values_only
484 || print_entry_values
== print_entry_values_both
485 || (print_entry_values
== print_entry_values_preferred
486 && (!val
|| value_optimized_out (val
))))
488 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
489 entryval_error
= NULL
;
492 if ((print_entry_values
== print_entry_values_compact
493 || print_entry_values
== print_entry_values_if_needed
494 || print_entry_values
== print_entry_values_preferred
)
495 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
503 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
504 if (!val
&& !val_error
)
505 argp
->entry_kind
= print_entry_values_only
;
506 else if ((print_entry_values
== print_entry_values_compact
507 || print_entry_values
== print_entry_values_default
) && val_equal
)
509 argp
->entry_kind
= print_entry_values_compact
;
510 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
513 argp
->entry_kind
= print_entry_values_no
;
515 entryargp
->sym
= sym
;
516 entryargp
->val
= entryval
;
517 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
518 if (!entryval
&& !entryval_error
)
519 entryargp
->entry_kind
= print_entry_values_no
;
521 entryargp
->entry_kind
= print_entry_values_only
;
524 /* Print the arguments of frame FRAME on STREAM, given the function
525 FUNC running in that frame (as a symbol), where NUM is the number
526 of arguments according to the stack frame (or -1 if the number of
527 arguments is unknown). */
529 /* Note that currently the "number of arguments according to the
530 stack frame" is only known on VAX where i refers to the "number of
531 ints of arguments according to the stack frame". */
534 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
535 int num
, struct ui_file
*stream
)
537 struct ui_out
*uiout
= current_uiout
;
539 /* Offset of next stack argument beyond the one we have seen that is
540 at the highest offset, or -1 if we haven't come to a stack
542 long highest_offset
= -1;
543 /* Number of ints of arguments that we have printed so far. */
544 int args_printed
= 0;
545 struct cleanup
*old_chain
;
547 /* True if we should print arguments, false otherwise. */
548 int print_args
= strcmp (print_frame_arguments
, "none");
550 stb
= mem_fileopen ();
551 old_chain
= make_cleanup_ui_file_delete (stb
);
555 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
556 struct block_iterator iter
;
559 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
561 struct frame_arg arg
, entryarg
;
565 /* Keep track of the highest stack argument offset seen, and
566 skip over any kinds of symbols we don't care about. */
568 if (!SYMBOL_IS_ARGUMENT (sym
))
571 switch (SYMBOL_CLASS (sym
))
576 long current_offset
= SYMBOL_VALUE (sym
);
577 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
579 /* Compute address of next argument by adding the size of
580 this argument and rounding to an int boundary. */
582 ((current_offset
+ arg_size
+ sizeof (int) - 1)
583 & ~(sizeof (int) - 1));
585 /* If this is the highest offset seen yet, set
587 if (highest_offset
== -1
588 || (current_offset
> highest_offset
))
589 highest_offset
= current_offset
;
591 /* Add the number of ints we're about to print to
593 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
596 /* We care about types of symbols, but don't need to
597 keep track of stack offsets in them. */
599 case LOC_REGPARM_ADDR
:
601 case LOC_OPTIMIZED_OUT
:
606 /* We have to look up the symbol because arguments can have
607 two entries (one a parameter, one a local) and the one we
608 want is the local, which lookup_symbol will find for us.
609 This includes gcc1 (not gcc2) on SPARC when passing a
610 small structure and gcc2 when the argument type is float
611 and it is passed as a double and converted to float by
612 the prologue (in the latter case the type of the LOC_ARG
613 symbol is double and the type of the LOC_LOCAL symbol is
615 /* But if the parameter name is null, don't try it. Null
616 parameter names occur on the RS/6000, for traceback
617 tables. FIXME, should we even print them? */
619 if (*SYMBOL_LINKAGE_NAME (sym
))
623 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
624 b
, VAR_DOMAIN
, NULL
).symbol
;
625 gdb_assert (nsym
!= NULL
);
626 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
627 && !SYMBOL_IS_ARGUMENT (nsym
))
629 /* There is a LOC_ARG/LOC_REGISTER pair. This means
630 that it was passed on the stack and loaded into a
631 register, or passed in a register and stored in a
632 stack slot. GDB 3.x used the LOC_ARG; GDB
633 4.0-4.11 used the LOC_REGISTER.
635 Reasons for using the LOC_ARG:
637 (1) Because find_saved_registers may be slow for
640 (2) Because registers are often re-used and stack
641 slots rarely (never?) are. Therefore using
642 the stack slot is much less likely to print
645 Reasons why we might want to use the LOC_REGISTER:
647 (1) So that the backtrace prints the same value
648 as "print foo". I see no compelling reason
649 why this needs to be the case; having the
650 backtrace print the value which was passed
651 in, and "print foo" print the value as
652 modified within the called function, makes
655 Additional note: It might be nice if "info args"
656 displayed both values.
658 One more note: There is a case with SPARC
659 structure passing where we need to use the
660 LOC_REGISTER, but this is dealt with by creating
661 a single LOC_REGPARM in symbol reading. */
663 /* Leave sym (the LOC_ARG) alone. */
670 /* Print the current arg. */
672 ui_out_text (uiout
, ", ");
673 ui_out_wrap_hint (uiout
, " ");
677 memset (&arg
, 0, sizeof (arg
));
679 arg
.entry_kind
= print_entry_values_no
;
680 memset (&entryarg
, 0, sizeof (entryarg
));
682 entryarg
.entry_kind
= print_entry_values_no
;
685 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
687 if (arg
.entry_kind
!= print_entry_values_only
)
688 print_frame_arg (&arg
);
690 if (entryarg
.entry_kind
!= print_entry_values_no
)
692 if (arg
.entry_kind
!= print_entry_values_only
)
694 ui_out_text (uiout
, ", ");
695 ui_out_wrap_hint (uiout
, " ");
698 print_frame_arg (&entryarg
);
702 xfree (entryarg
.error
);
708 /* Don't print nameless args in situations where we don't know
709 enough about the stack to find them. */
714 if (highest_offset
== -1)
715 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
717 start
= highest_offset
;
719 print_frame_nameless_args (frame
, start
, num
- args_printed
,
723 do_cleanups (old_chain
);
726 /* Set the current source and line to the location given by frame
727 FRAME, if possible. When CENTER is true, adjust so the relevant
728 line is in the center of the next 'list'. */
731 set_current_sal_from_frame (struct frame_info
*frame
)
733 struct symtab_and_line sal
;
735 find_frame_sal (frame
, &sal
);
736 if (sal
.symtab
!= NULL
)
737 set_current_source_symtab_and_line (&sal
);
740 /* If ON, GDB will display disassembly of the next source line when
741 execution of the program being debugged stops.
742 If AUTO (which is the default), or there's no line info to determine
743 the source line of the next instruction, display disassembly of next
744 instruction instead. */
746 static enum auto_boolean disassemble_next_line
;
749 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
750 struct cmd_list_element
*c
,
753 fprintf_filtered (file
,
754 _("Debugger's willingness to use "
755 "disassemble-next-line is %s.\n"),
759 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
760 because it will be broken by filter sometime. */
763 do_gdb_disassembly (struct gdbarch
*gdbarch
,
764 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
769 gdb_disassembly (gdbarch
, current_uiout
, 0,
770 DISASSEMBLY_RAW_INSN
, how_many
,
773 CATCH (exception
, RETURN_MASK_ERROR
)
775 /* If an exception was thrown while doing the disassembly, print
776 the error message, to give the user a clue of what happened. */
777 exception_print (gdb_stderr
, exception
);
782 /* Print information about frame FRAME. The output is format according
783 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
786 SRC_LINE: Print only source line.
787 LOCATION: Print only location.
788 LOC_AND_SRC: Print location and source line.
790 Used in "where" output, and to emit breakpoint or step
794 print_frame_info (struct frame_info
*frame
, int print_level
,
795 enum print_what print_what
, int print_args
,
798 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
799 struct symtab_and_line sal
;
802 struct ui_out
*uiout
= current_uiout
;
804 if (get_frame_type (frame
) == DUMMY_FRAME
805 || get_frame_type (frame
) == SIGTRAMP_FRAME
806 || get_frame_type (frame
) == ARCH_FRAME
)
808 struct cleanup
*uiout_cleanup
809 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
811 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
812 gdbarch
, get_frame_pc (frame
));
814 /* Do this regardless of SOURCE because we don't have any source
815 to list for this frame. */
818 ui_out_text (uiout
, "#");
819 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
820 frame_relative_level (frame
));
822 if (ui_out_is_mi_like_p (uiout
))
824 annotate_frame_address ();
825 ui_out_field_core_addr (uiout
, "addr",
826 gdbarch
, get_frame_pc (frame
));
827 annotate_frame_address_end ();
830 if (get_frame_type (frame
) == DUMMY_FRAME
)
832 annotate_function_call ();
833 ui_out_field_string (uiout
, "func", "<function called from gdb>");
835 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
837 annotate_signal_handler_caller ();
838 ui_out_field_string (uiout
, "func", "<signal handler called>");
840 else if (get_frame_type (frame
) == ARCH_FRAME
)
842 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
844 ui_out_text (uiout
, "\n");
845 annotate_frame_end ();
847 /* If disassemble-next-line is set to auto or on output the next
849 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
850 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
851 do_gdb_disassembly (get_frame_arch (frame
), 1,
852 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
854 do_cleanups (uiout_cleanup
);
858 /* If FRAME is not the innermost frame, that normally means that
859 FRAME->pc points to *after* the call instruction, and we want to
860 get the line containing the call, never the next line. But if
861 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
862 next frame was not entered as the result of a call, and we want
863 to get the line containing FRAME->pc. */
864 find_frame_sal (frame
, &sal
);
866 location_print
= (print_what
== LOCATION
867 || print_what
== LOC_AND_ADDRESS
868 || print_what
== SRC_AND_LOC
);
870 if (location_print
|| !sal
.symtab
)
871 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
873 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
875 /* If disassemble-next-line is set to auto or on and doesn't have
876 the line debug messages for $pc, output the next instruction. */
877 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
878 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
879 && source_print
&& !sal
.symtab
)
880 do_gdb_disassembly (get_frame_arch (frame
), 1,
881 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
883 if (source_print
&& sal
.symtab
)
886 int mid_statement
= ((print_what
== SRC_LINE
)
887 && frame_show_address (frame
, sal
));
889 if (annotation_level
)
890 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
891 get_frame_pc (frame
));
894 if (deprecated_print_frame_info_listing_hook
)
895 deprecated_print_frame_info_listing_hook (sal
.symtab
,
900 struct value_print_options opts
;
902 get_user_print_options (&opts
);
903 /* We used to do this earlier, but that is clearly
904 wrong. This function is used by many different
905 parts of gdb, including normal_stop in infrun.c,
906 which uses this to print out the current PC
907 when we stepi/nexti into the middle of a source
908 line. Only the command line really wants this
909 behavior. Other UIs probably would like the
910 ability to decide for themselves if it is desired. */
911 if (opts
.addressprint
&& mid_statement
)
913 ui_out_field_core_addr (uiout
, "addr",
914 gdbarch
, get_frame_pc (frame
));
915 ui_out_text (uiout
, "\t");
918 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
922 /* If disassemble-next-line is set to on and there is line debug
923 messages, output assembly codes for next line. */
924 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
925 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
932 if (get_frame_pc_if_available (frame
, &pc
))
933 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
935 set_last_displayed_sal (0, 0, 0, 0, 0);
938 annotate_frame_end ();
940 gdb_flush (gdb_stdout
);
943 /* Remember the last symtab and line we displayed, which we use e.g.
944 * as the place to put a breakpoint when the `break' command is
945 * invoked with no arguments. */
948 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
949 CORE_ADDR addr
, struct symtab
*symtab
,
952 last_displayed_sal_valid
= valid
;
953 last_displayed_pspace
= pspace
;
954 last_displayed_addr
= addr
;
955 last_displayed_symtab
= symtab
;
956 last_displayed_line
= line
;
957 if (valid
&& pspace
== NULL
)
959 clear_last_displayed_sal ();
960 internal_error (__FILE__
, __LINE__
,
961 _("Trying to set NULL pspace."));
965 /* Forget the last sal we displayed. */
968 clear_last_displayed_sal (void)
970 last_displayed_sal_valid
= 0;
971 last_displayed_pspace
= 0;
972 last_displayed_addr
= 0;
973 last_displayed_symtab
= 0;
974 last_displayed_line
= 0;
977 /* Is our record of the last sal we displayed valid? If not,
978 * the get_last_displayed_* functions will return NULL or 0, as
982 last_displayed_sal_is_valid (void)
984 return last_displayed_sal_valid
;
987 /* Get the pspace of the last sal we displayed, if it's valid. */
989 struct program_space
*
990 get_last_displayed_pspace (void)
992 if (last_displayed_sal_valid
)
993 return last_displayed_pspace
;
997 /* Get the address of the last sal we displayed, if it's valid. */
1000 get_last_displayed_addr (void)
1002 if (last_displayed_sal_valid
)
1003 return last_displayed_addr
;
1007 /* Get the symtab of the last sal we displayed, if it's valid. */
1010 get_last_displayed_symtab (void)
1012 if (last_displayed_sal_valid
)
1013 return last_displayed_symtab
;
1017 /* Get the line of the last sal we displayed, if it's valid. */
1020 get_last_displayed_line (void)
1022 if (last_displayed_sal_valid
)
1023 return last_displayed_line
;
1027 /* Get the last sal we displayed, if it's valid. */
1030 get_last_displayed_sal (struct symtab_and_line
*sal
)
1032 if (last_displayed_sal_valid
)
1034 sal
->pspace
= last_displayed_pspace
;
1035 sal
->pc
= last_displayed_addr
;
1036 sal
->symtab
= last_displayed_symtab
;
1037 sal
->line
= last_displayed_line
;
1049 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1050 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1053 find_frame_funname (struct frame_info
*frame
, char **funname
,
1054 enum language
*funlang
, struct symbol
**funcp
)
1056 struct symbol
*func
;
1059 *funlang
= language_unknown
;
1063 func
= get_frame_function (frame
);
1066 /* In certain pathological cases, the symtabs give the wrong
1067 function (when we are in the first function in a file which
1068 is compiled without debugging symbols, the previous function
1069 is compiled with debugging symbols, and the "foo.o" symbol
1070 that is supposed to tell us where the file with debugging
1071 symbols ends has been truncated by ar because it is longer
1072 than 15 characters). This also occurs if the user uses asm()
1073 to create a function but not stabs for it (in a file compiled
1076 So look in the minimal symbol tables as well, and if it comes
1077 up with a larger address for the function use that instead.
1078 I don't think this can ever cause any problems; there
1079 shouldn't be any minimal symbols in the middle of a function;
1080 if this is ever changed many parts of GDB will need to be
1081 changed (and we'll create a find_pc_minimal_function or some
1084 struct bound_minimal_symbol msymbol
;
1086 /* Don't attempt to do this for inlined functions, which do not
1087 have a corresponding minimal symbol. */
1088 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1090 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1092 memset (&msymbol
, 0, sizeof (msymbol
));
1094 if (msymbol
.minsym
!= NULL
1095 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1096 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1098 /* We also don't know anything about the function besides
1099 its address and name. */
1101 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1102 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1106 *funname
= xstrdup (SYMBOL_PRINT_NAME (func
));
1107 *funlang
= SYMBOL_LANGUAGE (func
);
1110 if (*funlang
== language_cplus
)
1112 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1113 to display the demangled name that we already have
1114 stored in the symbol table, but we stored a version
1115 with DMGL_PARAMS turned on, and here we don't want to
1116 display parameters. So remove the parameters. */
1117 char *func_only
= cp_remove_params (*funname
);
1122 *funname
= func_only
;
1129 struct bound_minimal_symbol msymbol
;
1132 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1135 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1136 if (msymbol
.minsym
!= NULL
)
1138 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1139 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1145 print_frame (struct frame_info
*frame
, int print_level
,
1146 enum print_what print_what
, int print_args
,
1147 struct symtab_and_line sal
)
1149 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1150 struct ui_out
*uiout
= current_uiout
;
1151 char *funname
= NULL
;
1152 enum language funlang
= language_unknown
;
1153 struct ui_file
*stb
;
1154 struct cleanup
*old_chain
, *list_chain
;
1155 struct value_print_options opts
;
1156 struct symbol
*func
;
1160 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1162 stb
= mem_fileopen ();
1163 old_chain
= make_cleanup_ui_file_delete (stb
);
1165 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1166 make_cleanup (xfree
, funname
);
1168 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1171 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1175 ui_out_text (uiout
, "#");
1176 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1177 frame_relative_level (frame
));
1179 get_user_print_options (&opts
);
1180 if (opts
.addressprint
)
1182 || frame_show_address (frame
, sal
)
1183 || print_what
== LOC_AND_ADDRESS
)
1185 annotate_frame_address ();
1187 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1189 ui_out_field_string (uiout
, "addr", "<unavailable>");
1190 annotate_frame_address_end ();
1191 ui_out_text (uiout
, " in ");
1193 annotate_frame_function_name ();
1194 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1195 funlang
, DMGL_ANSI
);
1196 ui_out_field_stream (uiout
, "func", stb
);
1197 ui_out_wrap_hint (uiout
, " ");
1198 annotate_frame_args ();
1200 ui_out_text (uiout
, " (");
1203 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1205 struct cleanup
*args_list_chain
;
1207 if (gdbarch_frame_num_args_p (gdbarch
))
1209 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1210 gdb_assert (numargs
>= 0);
1215 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1218 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1220 CATCH (e
, RETURN_MASK_ERROR
)
1225 /* FIXME: ARGS must be a list. If one argument is a string it
1226 will have " that will not be properly escaped. */
1227 /* Invoke ui_out_tuple_end. */
1228 do_cleanups (args_list_chain
);
1231 ui_out_text (uiout
, ")");
1234 const char *filename_display
;
1236 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1237 annotate_frame_source_begin ();
1238 ui_out_wrap_hint (uiout
, " ");
1239 ui_out_text (uiout
, " at ");
1240 annotate_frame_source_file ();
1241 ui_out_field_string (uiout
, "file", filename_display
);
1242 if (ui_out_is_mi_like_p (uiout
))
1244 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1246 ui_out_field_string (uiout
, "fullname", fullname
);
1248 annotate_frame_source_file_end ();
1249 ui_out_text (uiout
, ":");
1250 annotate_frame_source_line ();
1251 ui_out_field_int (uiout
, "line", sal
.line
);
1252 annotate_frame_source_end ();
1255 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1257 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1258 get_frame_pc (frame
));
1262 annotate_frame_where ();
1263 ui_out_wrap_hint (uiout
, " ");
1264 ui_out_text (uiout
, " from ");
1265 ui_out_field_string (uiout
, "from", lib
);
1269 /* do_cleanups will call ui_out_tuple_end() for us. */
1270 do_cleanups (list_chain
);
1271 ui_out_text (uiout
, "\n");
1272 do_cleanups (old_chain
);
1276 /* Read a frame specification in whatever the appropriate format is from
1277 FRAME_EXP. Call error() if the specification is in any way invalid (so
1278 this function never returns NULL). When SEPECTED_P is non-NULL set its
1279 target to indicate that the default selected frame was used. */
1281 static struct frame_info
*
1282 parse_frame_specification (const char *frame_exp
, int *selected_frame_p
)
1285 struct value
*args
[4];
1286 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1288 if (frame_exp
== NULL
)
1296 struct cleanup
*cleanup
;
1299 /* Skip leading white space, bail of EOL. */
1300 frame_exp
= skip_spaces_const (frame_exp
);
1304 /* Parse the argument, extract it, save it. */
1306 *p
&& !ISSPACE (*p
);
1308 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1310 cleanup
= make_cleanup (xfree
, addr_string
);
1312 /* NOTE: Parse and evaluate expression, but do not use
1313 functions such as parse_and_eval_long or
1314 parse_and_eval_address to also extract the value.
1315 Instead value_as_long and value_as_address are used.
1316 This avoids problems with expressions that contain
1318 if (numargs
>= ARRAY_SIZE (args
))
1319 error (_("Too many args in frame specification"));
1320 args
[numargs
++] = parse_and_eval (addr_string
);
1322 do_cleanups (cleanup
);
1326 /* If no args, default to the selected frame. */
1329 if (selected_frame_p
!= NULL
)
1330 (*selected_frame_p
) = 1;
1331 return get_selected_frame (_("No stack."));
1334 /* None of the remaining use the selected frame. */
1335 if (selected_frame_p
!= NULL
)
1336 (*selected_frame_p
) = 0;
1338 /* Assume the single arg[0] is an integer, and try using that to
1339 select a frame relative to current. */
1342 struct frame_info
*fid
;
1343 int level
= value_as_long (args
[0]);
1345 fid
= find_relative_frame (get_current_frame (), &level
);
1347 /* find_relative_frame was successful. */
1351 /* Convert each value into a corresponding address. */
1355 for (i
= 0; i
< numargs
; i
++)
1356 addrs
[i
] = value_as_address (args
[i
]);
1359 /* Assume that the single arg[0] is an address, use that to identify
1360 a frame with a matching ID. Should this also accept stack/pc or
1361 stack/pc/special. */
1364 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1365 struct frame_info
*fid
;
1367 /* If (s)he specifies the frame with an address, he deserves
1368 what (s)he gets. Still, give the highest one that matches.
1369 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1371 for (fid
= get_current_frame ();
1373 fid
= get_prev_frame (fid
))
1375 if (frame_id_eq (id
, get_frame_id (fid
)))
1377 struct frame_info
*prev_frame
;
1381 prev_frame
= get_prev_frame (fid
);
1383 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1392 /* We couldn't identify the frame as an existing frame, but
1393 perhaps we can create one with a single argument. */
1395 return create_new_frame (addrs
[0], 0);
1396 else if (numargs
== 2)
1397 return create_new_frame (addrs
[0], addrs
[1]);
1399 error (_("Too many args in frame specification"));
1402 /* Print verbosely the selected frame or the frame at address
1403 ADDR_EXP. Absolutely all information in the frame is printed. */
1406 frame_info (char *addr_exp
, int from_tty
)
1408 struct frame_info
*fi
;
1409 struct symtab_and_line sal
;
1410 struct symbol
*func
;
1412 struct frame_info
*calling_frame_info
;
1414 const char *funname
= 0;
1415 enum language funlang
= language_unknown
;
1416 const char *pc_regname
;
1417 int selected_frame_p
;
1418 struct gdbarch
*gdbarch
;
1419 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1422 /* Initialize it to avoid "may be used uninitialized" warning. */
1423 CORE_ADDR caller_pc
= 0;
1424 int caller_pc_p
= 0;
1426 fi
= parse_frame_specification (addr_exp
, &selected_frame_p
);
1427 gdbarch
= get_frame_arch (fi
);
1429 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1430 is not a good name. */
1431 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1432 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1433 easily not match that of the internal value returned by
1435 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1437 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1438 architectures will often have a hardware register called "pc",
1439 and that register's value, again, can easily not match
1443 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1444 find_frame_sal (fi
, &sal
);
1445 func
= get_frame_function (fi
);
1449 funname
= SYMBOL_PRINT_NAME (func
);
1450 funlang
= SYMBOL_LANGUAGE (func
);
1451 if (funlang
== language_cplus
)
1453 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1454 to display the demangled name that we already have
1455 stored in the symbol table, but we stored a version
1456 with DMGL_PARAMS turned on, and here we don't want to
1457 display parameters. So remove the parameters. */
1458 char *func_only
= cp_remove_params (funname
);
1462 funname
= func_only
;
1463 make_cleanup (xfree
, func_only
);
1467 else if (frame_pc_p
)
1469 struct bound_minimal_symbol msymbol
;
1471 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1472 if (msymbol
.minsym
!= NULL
)
1474 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1475 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1478 calling_frame_info
= get_prev_frame (fi
);
1480 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1482 printf_filtered (_("Stack level %d, frame at "),
1483 frame_relative_level (fi
));
1487 printf_filtered (_("Stack frame at "));
1489 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1490 printf_filtered (":\n");
1491 printf_filtered (" %s = ", pc_regname
);
1493 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1495 fputs_filtered ("<unavailable>", gdb_stdout
);
1500 printf_filtered (" in ");
1501 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1502 DMGL_ANSI
| DMGL_PARAMS
);
1506 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1508 puts_filtered ("; ");
1510 printf_filtered ("saved %s = ", pc_regname
);
1512 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1513 val_print_unavailable (gdb_stdout
);
1518 caller_pc
= frame_unwind_caller_pc (fi
);
1521 CATCH (ex
, RETURN_MASK_ERROR
)
1525 case NOT_AVAILABLE_ERROR
:
1526 val_print_unavailable (gdb_stdout
);
1528 case OPTIMIZED_OUT_ERROR
:
1529 val_print_not_saved (gdb_stdout
);
1532 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1540 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1541 printf_filtered ("\n");
1543 if (calling_frame_info
== NULL
)
1545 enum unwind_stop_reason reason
;
1547 reason
= get_frame_unwind_stop_reason (fi
);
1548 if (reason
!= UNWIND_NO_REASON
)
1549 printf_filtered (_(" Outermost frame: %s\n"),
1550 frame_stop_reason_string (fi
));
1552 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1553 puts_filtered (" tail call frame");
1554 else if (get_frame_type (fi
) == INLINE_FRAME
)
1555 printf_filtered (" inlined into frame %d",
1556 frame_relative_level (get_prev_frame (fi
)));
1559 printf_filtered (" called by frame at ");
1560 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1563 if (get_next_frame (fi
) && calling_frame_info
)
1564 puts_filtered (",");
1566 if (get_next_frame (fi
))
1568 printf_filtered (" caller of frame at ");
1569 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1572 if (get_next_frame (fi
) || calling_frame_info
)
1573 puts_filtered ("\n");
1576 printf_filtered (" source language %s.\n",
1577 language_str (s
->language
));
1580 /* Address of the argument list for this frame, or 0. */
1581 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1582 /* Number of args for this frame, or -1 if unknown. */
1586 printf_filtered (" Arglist at unknown address.\n");
1589 printf_filtered (" Arglist at ");
1590 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1591 printf_filtered (",");
1593 if (!gdbarch_frame_num_args_p (gdbarch
))
1596 puts_filtered (" args: ");
1600 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1601 gdb_assert (numargs
>= 0);
1603 puts_filtered (" no args.");
1604 else if (numargs
== 1)
1605 puts_filtered (" 1 arg: ");
1607 printf_filtered (" %d args: ", numargs
);
1609 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1610 puts_filtered ("\n");
1614 /* Address of the local variables for this frame, or 0. */
1615 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1618 printf_filtered (" Locals at unknown address,");
1621 printf_filtered (" Locals at ");
1622 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1623 printf_filtered (",");
1627 /* Print as much information as possible on the location of all the
1630 enum lval_type lval
;
1639 /* The sp is special; what's displayed isn't the save address, but
1640 the value of the previous frame's sp. This is a legacy thing,
1641 at one stage the frame cached the previous frame's SP instead
1642 of its address, hence it was easiest to just display the cached
1644 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1646 /* Find out the location of the saved stack pointer with out
1647 actually evaluating it. */
1648 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1649 &optimized
, &unavailable
, &lval
, &addr
,
1651 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1653 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1654 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1655 gdb_byte value
[MAX_REGISTER_SIZE
];
1658 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1659 &optimized
, &unavailable
, &lval
, &addr
,
1661 /* NOTE: cagney/2003-05-22: This is assuming that the
1662 stack pointer was packed as an unsigned integer. That
1663 may or may not be valid. */
1664 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1665 printf_filtered (" Previous frame's sp is ");
1666 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1667 printf_filtered ("\n");
1670 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1672 printf_filtered (" Previous frame's sp at ");
1673 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1674 printf_filtered ("\n");
1677 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1679 printf_filtered (" Previous frame's sp in %s\n",
1680 gdbarch_register_name (gdbarch
, realnum
));
1683 /* else keep quiet. */
1687 numregs
= gdbarch_num_regs (gdbarch
)
1688 + gdbarch_num_pseudo_regs (gdbarch
);
1689 for (i
= 0; i
< numregs
; i
++)
1690 if (i
!= gdbarch_sp_regnum (gdbarch
)
1691 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1693 /* Find out the location of the saved register without
1694 fetching the corresponding value. */
1695 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1696 &lval
, &addr
, &realnum
, NULL
);
1697 /* For moment, only display registers that were saved on the
1699 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1702 puts_filtered (" Saved registers:\n ");
1704 puts_filtered (",");
1706 printf_filtered (" %s at ",
1707 gdbarch_register_name (gdbarch
, i
));
1708 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1712 if (count
|| need_nl
)
1713 puts_filtered ("\n");
1716 do_cleanups (back_to
);
1719 /* Print briefly all stack frames or just the innermost COUNT_EXP
1723 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1726 struct frame_info
*fi
;
1729 struct frame_info
*trailing
;
1730 int trailing_level
, py_start
= 0, py_end
= 0;
1731 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1733 if (!target_has_stack
)
1734 error (_("No stack."));
1736 /* The following code must do two things. First, it must set the
1737 variable TRAILING to the frame from which we should start
1738 printing. Second, it must set the variable count to the number
1739 of frames which we should print, or -1 if all of them. */
1740 trailing
= get_current_frame ();
1745 count
= parse_and_eval_long (count_exp
);
1748 struct frame_info
*current
;
1754 while (current
&& count
--)
1757 current
= get_prev_frame (current
);
1760 /* Will stop when CURRENT reaches the top of the stack.
1761 TRAILING will be COUNT below it. */
1765 trailing
= get_prev_frame (trailing
);
1766 current
= get_prev_frame (current
);
1786 /* Read in symbols for all of the frames. Need to do this in a
1787 separate pass so that "Reading in symbols for xxx" messages
1788 don't screw up the appearance of the backtrace. Also if
1789 people have strong opinions against reading symbols for
1790 backtrace this may have to be an option. */
1792 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1797 pc
= get_frame_address_in_block (fi
);
1798 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1804 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1805 enum ext_lang_frame_args arg_type
;
1808 flags
|= PRINT_LOCALS
;
1810 if (!strcmp (print_frame_arguments
, "scalars"))
1811 arg_type
= CLI_SCALAR_VALUES
;
1812 else if (!strcmp (print_frame_arguments
, "all"))
1813 arg_type
= CLI_ALL_VALUES
;
1815 arg_type
= NO_VALUES
;
1817 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1818 arg_type
, current_uiout
,
1822 /* Run the inbuilt backtrace if there are no filters registered, or
1823 "no-filters" has been specified from the command. */
1824 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1826 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1830 /* Don't use print_stack_frame; if an error() occurs it probably
1831 means further attempts to backtrace would fail (on the other
1832 hand, perhaps the code does or could be fixed to make sure
1833 the frame->prev field gets set to NULL in that case). */
1835 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1838 struct frame_id frame_id
= get_frame_id (fi
);
1840 print_frame_local_vars (fi
, 1, gdb_stdout
);
1842 /* print_frame_local_vars invalidates FI. */
1843 fi
= frame_find_by_id (frame_id
);
1847 warning (_("Unable to restore previously selected frame."));
1852 /* Save the last frame to check for error conditions. */
1856 /* If we've stopped before the end, mention that. */
1858 printf_filtered (_("(More stack frames follow...)\n"));
1860 /* If we've run out of frames, and the reason appears to be an error
1861 condition, print it. */
1862 if (fi
== NULL
&& trailing
!= NULL
)
1864 enum unwind_stop_reason reason
;
1866 reason
= get_frame_unwind_stop_reason (trailing
);
1867 if (reason
>= UNWIND_FIRST_ERROR
)
1868 printf_filtered (_("Backtrace stopped: %s\n"),
1869 frame_stop_reason_string (trailing
));
1875 backtrace_command (char *arg
, int from_tty
)
1877 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1878 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1886 argv
= gdb_buildargv (arg
);
1887 make_cleanup_freeargv (argv
);
1889 for (i
= 0; argv
[i
]; i
++)
1893 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1894 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1896 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1900 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1901 fulltrace_arg
= argc
;
1905 arglen
+= strlen (argv
[i
]);
1911 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1915 arg
= (char *) xmalloc (arglen
+ 1);
1916 make_cleanup (xfree
, arg
);
1918 for (i
= 0; i
< argc
; i
++)
1920 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1922 strcat (arg
, argv
[i
]);
1932 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1933 no_filters
>= 0 /* no frame-filters */, from_tty
);
1935 do_cleanups (old_chain
);
1938 /* Iterate over the local variables of a block B, calling CB with
1942 iterate_over_block_locals (const struct block
*b
,
1943 iterate_over_block_arg_local_vars_cb cb
,
1946 struct block_iterator iter
;
1949 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1951 switch (SYMBOL_CLASS (sym
))
1957 if (SYMBOL_IS_ARGUMENT (sym
))
1959 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1961 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1965 /* Ignore symbols which are not locals. */
1972 /* Same, but print labels. */
1975 /* Commented out, as the code using this function has also been
1976 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1977 was commented out in the first place. The discussion introducing
1978 this change (2007-12-04: Support lexical blocks and function bodies
1979 that occupy non-contiguous address ranges) did not explain why
1980 this change was made. */
1982 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1983 int *have_default
, struct ui_file
*stream
)
1985 struct block_iterator iter
;
1987 int values_printed
= 0;
1989 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1991 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1997 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1999 struct symtab_and_line sal
;
2000 struct value_print_options opts
;
2002 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
2004 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
2005 get_user_print_options (&opts
);
2006 if (opts
.addressprint
)
2008 fprintf_filtered (stream
, " ");
2009 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2012 fprintf_filtered (stream
, " in file %s, line %d\n",
2013 sal
.symtab
->filename
, sal
.line
);
2017 return values_printed
;
2021 /* Iterate over all the local variables in block B, including all its
2022 superblocks, stopping when the top-level block is reached. */
2025 iterate_over_block_local_vars (const struct block
*block
,
2026 iterate_over_block_arg_local_vars_cb cb
,
2031 iterate_over_block_locals (block
, cb
, cb_data
);
2032 /* After handling the function's top-level block, stop. Don't
2033 continue to its superblock, the block of per-file
2035 if (BLOCK_FUNCTION (block
))
2037 block
= BLOCK_SUPERBLOCK (block
);
2041 /* Data to be passed around in the calls to the locals and args
2044 struct print_variable_and_value_data
2046 struct frame_id frame_id
;
2048 struct ui_file
*stream
;
2052 /* The callback for the locals and args iterators. */
2055 do_print_variable_and_value (const char *print_name
,
2059 struct print_variable_and_value_data
*p
2060 = (struct print_variable_and_value_data
*) cb_data
;
2061 struct frame_info
*frame
;
2063 frame
= frame_find_by_id (p
->frame_id
);
2066 warning (_("Unable to restore previously selected frame."));
2070 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2072 /* print_variable_and_value invalidates FRAME. */
2075 p
->values_printed
= 1;
2078 /* Print all variables from the innermost up to the function block of FRAME.
2079 Print them with values to STREAM indented by NUM_TABS.
2081 This function will invalidate FRAME. */
2084 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2085 struct ui_file
*stream
)
2087 struct print_variable_and_value_data cb_data
;
2088 const struct block
*block
;
2090 struct gdb_exception except
= exception_none
;
2092 if (!get_frame_pc_if_available (frame
, &pc
))
2094 fprintf_filtered (stream
,
2095 _("PC unavailable, cannot determine locals.\n"));
2099 block
= get_frame_block (frame
, 0);
2102 fprintf_filtered (stream
, "No symbol table info available.\n");
2106 cb_data
.frame_id
= get_frame_id (frame
);
2107 cb_data
.num_tabs
= 4 * num_tabs
;
2108 cb_data
.stream
= stream
;
2109 cb_data
.values_printed
= 0;
2111 /* Temporarily change the selected frame to the given FRAME.
2112 This allows routines that rely on the selected frame instead
2113 of being given a frame as parameter to use the correct frame. */
2114 select_frame (frame
);
2118 iterate_over_block_local_vars (block
,
2119 do_print_variable_and_value
,
2122 CATCH (ex
, RETURN_MASK_ALL
)
2128 /* Restore the selected frame, and then rethrow if there was a problem. */
2129 select_frame (frame_find_by_id (cb_data
.frame_id
));
2130 if (except
.reason
< 0)
2131 throw_exception (except
);
2133 /* do_print_variable_and_value invalidates FRAME. */
2136 if (!cb_data
.values_printed
)
2137 fprintf_filtered (stream
, _("No locals.\n"));
2141 locals_info (char *args
, int from_tty
)
2143 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2147 /* Iterate over all the argument variables in block B.
2149 Returns 1 if any argument was walked; 0 otherwise. */
2152 iterate_over_block_arg_vars (const struct block
*b
,
2153 iterate_over_block_arg_local_vars_cb cb
,
2156 struct block_iterator iter
;
2157 struct symbol
*sym
, *sym2
;
2159 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2161 /* Don't worry about things which aren't arguments. */
2162 if (SYMBOL_IS_ARGUMENT (sym
))
2164 /* We have to look up the symbol because arguments can have
2165 two entries (one a parameter, one a local) and the one we
2166 want is the local, which lookup_symbol will find for us.
2167 This includes gcc1 (not gcc2) on the sparc when passing a
2168 small structure and gcc2 when the argument type is float
2169 and it is passed as a double and converted to float by
2170 the prologue (in the latter case the type of the LOC_ARG
2171 symbol is double and the type of the LOC_LOCAL symbol is
2172 float). There are also LOC_ARG/LOC_REGISTER pairs which
2173 are not combined in symbol-reading. */
2175 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2176 b
, VAR_DOMAIN
, NULL
).symbol
;
2177 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2182 /* Print all argument variables of the function of FRAME.
2183 Print them with values to STREAM.
2185 This function will invalidate FRAME. */
2188 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2190 struct print_variable_and_value_data cb_data
;
2191 struct symbol
*func
;
2194 if (!get_frame_pc_if_available (frame
, &pc
))
2196 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2200 func
= get_frame_function (frame
);
2203 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2207 cb_data
.frame_id
= get_frame_id (frame
);
2208 cb_data
.num_tabs
= 0;
2209 cb_data
.stream
= gdb_stdout
;
2210 cb_data
.values_printed
= 0;
2212 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2213 do_print_variable_and_value
, &cb_data
);
2215 /* do_print_variable_and_value invalidates FRAME. */
2218 if (!cb_data
.values_printed
)
2219 fprintf_filtered (stream
, _("No arguments.\n"));
2223 args_info (char *ignore
, int from_tty
)
2225 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2229 /* Select frame FRAME. Also print the stack frame and show the source
2230 if this is the tui version. */
2232 select_and_print_frame (struct frame_info
*frame
)
2234 select_frame (frame
);
2236 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2239 /* Return the symbol-block in which the selected frame is executing.
2240 Can return zero under various legitimate circumstances.
2242 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2243 code address within the block returned. We use this to decide
2244 which macros are in scope. */
2246 const struct block
*
2247 get_selected_block (CORE_ADDR
*addr_in_block
)
2249 if (!has_stack_frames ())
2252 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2255 /* Find a frame a certain number of levels away from FRAME.
2256 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2257 Positive means go to earlier frames (up); negative, the reverse.
2258 The int that contains the number of levels is counted toward
2259 zero as the frames for those levels are found.
2260 If the top or bottom frame is reached, that frame is returned,
2261 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2262 how much farther the original request asked to go. */
2265 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2267 /* Going up is simple: just call get_prev_frame enough times or
2268 until the initial frame is reached. */
2269 while (*level_offset_ptr
> 0)
2271 struct frame_info
*prev
= get_prev_frame (frame
);
2275 (*level_offset_ptr
)--;
2279 /* Going down is just as simple. */
2280 while (*level_offset_ptr
< 0)
2282 struct frame_info
*next
= get_next_frame (frame
);
2286 (*level_offset_ptr
)++;
2293 /* The "select_frame" command. With no argument this is a NOP.
2294 Select the frame at level LEVEL_EXP if it is a valid level.
2295 Otherwise, treat LEVEL_EXP as an address expression and select it.
2297 See parse_frame_specification for more info on proper frame
2301 select_frame_command (char *level_exp
, int from_tty
)
2303 select_frame (parse_frame_specification (level_exp
, NULL
));
2306 /* The "frame" command. With no argument, print the selected frame
2307 briefly. With an argument, behave like select_frame and then print
2308 the selected frame. */
2311 frame_command (char *level_exp
, int from_tty
)
2313 select_frame_command (level_exp
, from_tty
);
2314 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2317 /* Select the frame up one or COUNT_EXP stack levels from the
2318 previously selected frame, and print it briefly. */
2321 up_silently_base (const char *count_exp
)
2323 struct frame_info
*frame
;
2327 count
= parse_and_eval_long (count_exp
);
2329 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2330 if (count
!= 0 && count_exp
== NULL
)
2331 error (_("Initial frame selected; you cannot go up."));
2332 select_frame (frame
);
2336 up_silently_command (char *count_exp
, int from_tty
)
2338 up_silently_base (count_exp
);
2342 up_command (char *count_exp
, int from_tty
)
2344 up_silently_base (count_exp
);
2345 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2348 /* Select the frame down one or COUNT_EXP stack levels from the previously
2349 selected frame, and print it briefly. */
2352 down_silently_base (const char *count_exp
)
2354 struct frame_info
*frame
;
2358 count
= -parse_and_eval_long (count_exp
);
2360 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2361 if (count
!= 0 && count_exp
== NULL
)
2363 /* We only do this if COUNT_EXP is not specified. That way
2364 "down" means to really go down (and let me know if that is
2365 impossible), but "down 9999" can be used to mean go all the
2366 way down without getting an error. */
2368 error (_("Bottom (innermost) frame selected; you cannot go down."));
2371 select_frame (frame
);
2375 down_silently_command (char *count_exp
, int from_tty
)
2377 down_silently_base (count_exp
);
2381 down_command (char *count_exp
, int from_tty
)
2383 down_silently_base (count_exp
);
2384 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2389 return_command (char *retval_exp
, int from_tty
)
2391 /* Initialize it just to avoid a GCC false warning. */
2392 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2393 struct frame_info
*thisframe
;
2394 struct gdbarch
*gdbarch
;
2395 struct symbol
*thisfun
;
2396 struct value
*return_value
= NULL
;
2397 struct value
*function
= NULL
;
2398 const char *query_prefix
= "";
2400 thisframe
= get_selected_frame ("No selected frame.");
2401 thisfun
= get_frame_function (thisframe
);
2402 gdbarch
= get_frame_arch (thisframe
);
2404 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2405 error (_("Can not force return from an inlined function."));
2407 /* Compute the return value. If the computation triggers an error,
2408 let it bail. If the return type can't be handled, set
2409 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2413 struct expression
*retval_expr
= parse_expression (retval_exp
);
2414 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2415 struct type
*return_type
= NULL
;
2417 /* Compute the return value. Should the computation fail, this
2418 call throws an error. */
2419 return_value
= evaluate_expression (retval_expr
);
2421 /* Cast return value to the return type of the function. Should
2422 the cast fail, this call throws an error. */
2423 if (thisfun
!= NULL
)
2424 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2425 if (return_type
== NULL
)
2427 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2428 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2429 error (_("Return value type not available for selected "
2431 "Please use an explicit cast of the value to return."));
2432 return_type
= value_type (return_value
);
2434 do_cleanups (old_chain
);
2435 return_type
= check_typedef (return_type
);
2436 return_value
= value_cast (return_type
, return_value
);
2438 /* Make sure the value is fully evaluated. It may live in the
2439 stack frame we're about to pop. */
2440 if (value_lazy (return_value
))
2441 value_fetch_lazy (return_value
);
2443 if (thisfun
!= NULL
)
2444 function
= read_var_value (thisfun
, NULL
, thisframe
);
2446 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2447 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2448 /* If the return-type is "void", don't try to find the
2449 return-value's location. However, do still evaluate the
2450 return expression so that, even when the expression result
2451 is discarded, side effects such as "return i++" still
2453 return_value
= NULL
;
2454 else if (thisfun
!= NULL
)
2456 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2457 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2458 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2460 query_prefix
= "The location at which to store the "
2461 "function's return value is unknown.\n"
2462 "If you continue, the return value "
2463 "that you specified will be ignored.\n";
2464 return_value
= NULL
;
2469 /* Does an interactive user really want to do this? Include
2470 information, such as how well GDB can handle the return value, in
2471 the query message. */
2476 if (thisfun
== NULL
)
2477 confirmed
= query (_("%sMake selected stack frame return now? "),
2481 if (TYPE_NO_RETURN (thisfun
->type
))
2482 warning (_("Function does not return normally to caller."));
2483 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2484 SYMBOL_PRINT_NAME (thisfun
));
2487 error (_("Not confirmed"));
2490 /* Discard the selected frame and all frames inner-to it. */
2491 frame_pop (get_selected_frame (NULL
));
2493 /* Store RETURN_VALUE in the just-returned register set. */
2494 if (return_value
!= NULL
)
2496 struct type
*return_type
= value_type (return_value
);
2497 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2499 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2500 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2501 gdbarch_return_value (gdbarch
, function
, return_type
,
2502 get_current_regcache (), NULL
/*read*/,
2503 value_contents (return_value
) /*write*/);
2506 /* If we are at the end of a call dummy now, pop the dummy frame
2508 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2509 frame_pop (get_current_frame ());
2511 select_frame (get_current_frame ());
2512 /* If interactive, print the frame that is now current. */
2514 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2517 /* Sets the scope to input function name, provided that the function
2518 is within the current stack frame. */
2520 struct function_bounds
2522 CORE_ADDR low
, high
;
2526 func_command (char *arg
, int from_tty
)
2528 struct frame_info
*frame
;
2530 struct symtabs_and_lines sals
;
2533 struct function_bounds
*func_bounds
= NULL
;
2534 struct cleanup
*cleanups
;
2539 frame
= get_current_frame ();
2540 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2541 cleanups
= make_cleanup (xfree
, sals
.sals
);
2542 func_bounds
= XNEWVEC (struct function_bounds
, sals
.nelts
);
2543 make_cleanup (xfree
, func_bounds
);
2544 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2546 if (sals
.sals
[i
].pspace
!= current_program_space
)
2547 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2548 else if (sals
.sals
[i
].pc
== 0
2549 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2550 &func_bounds
[i
].low
,
2551 &func_bounds
[i
].high
) == 0)
2553 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2559 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2560 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2561 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2565 frame
= find_relative_frame (frame
, &level
);
2568 while (!found
&& level
== 0);
2570 do_cleanups (cleanups
);
2573 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2574 else if (frame
!= get_selected_frame (NULL
))
2575 select_and_print_frame (frame
);
2579 /* Provide a prototype to silence -Wmissing-prototypes. */
2580 void _initialize_stack (void);
2583 _initialize_stack (void)
2585 add_com ("return", class_stack
, return_command
, _("\
2586 Make selected stack frame return to its caller.\n\
2587 Control remains in the debugger, but when you continue\n\
2588 execution will resume in the frame above the one now selected.\n\
2589 If an argument is given, it is an expression for the value to return."));
2591 add_com ("up", class_stack
, up_command
, _("\
2592 Select and print stack frame that called this one.\n\
2593 An argument says how many frames up to go."));
2594 add_com ("up-silently", class_support
, up_silently_command
, _("\
2595 Same as the `up' command, but does not print anything.\n\
2596 This is useful in command scripts."));
2598 add_com ("down", class_stack
, down_command
, _("\
2599 Select and print stack frame called by this one.\n\
2600 An argument says how many frames down to go."));
2601 add_com_alias ("do", "down", class_stack
, 1);
2602 add_com_alias ("dow", "down", class_stack
, 1);
2603 add_com ("down-silently", class_support
, down_silently_command
, _("\
2604 Same as the `down' command, but does not print anything.\n\
2605 This is useful in command scripts."));
2607 add_com ("frame", class_stack
, frame_command
, _("\
2608 Select and print a stack frame.\nWith no argument, \
2609 print the selected stack frame. (See also \"info frame\").\n\
2610 An argument specifies the frame to select.\n\
2611 It can be a stack frame number or the address of the frame.\n\
2612 With argument, nothing is printed if input is coming from\n\
2613 a command file or a user-defined command."));
2615 add_com_alias ("f", "frame", class_stack
, 1);
2617 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2618 Select a stack frame without printing anything.\n\
2619 An argument specifies the frame to select.\n\
2620 It can be a stack frame number or the address of the frame.\n"));
2622 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2623 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2624 With a negative argument, print outermost -COUNT frames.\nUse of the \
2625 'full' qualifier also prints the values of the local variables.\n\
2626 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2627 on this backtrace.\n"));
2628 add_com_alias ("bt", "backtrace", class_stack
, 0);
2630 add_com_alias ("where", "backtrace", class_alias
, 0);
2631 add_info ("stack", backtrace_command
,
2632 _("Backtrace of the stack, or innermost COUNT frames."));
2633 add_info_alias ("s", "stack", 1);
2634 add_info ("frame", frame_info
,
2635 _("All about selected stack frame, or frame at ADDR."));
2636 add_info_alias ("f", "frame", 1);
2637 add_info ("locals", locals_info
,
2638 _("Local variables of current stack frame."));
2639 add_info ("args", args_info
,
2640 _("Argument variables of current stack frame."));
2643 add_com ("func", class_stack
, func_command
, _("\
2644 Select the stack frame that contains <func>.\n\
2645 Usage: func <name>\n"));
2647 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2648 print_frame_arguments_choices
, &print_frame_arguments
,
2649 _("Set printing of non-scalar frame arguments"),
2650 _("Show printing of non-scalar frame arguments"),
2651 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2653 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2654 &print_raw_frame_arguments
, _("\
2655 Set whether to print frame arguments in raw form."), _("\
2656 Show whether to print frame arguments in raw form."), _("\
2657 If set, frame arguments are printed in raw form, bypassing any\n\
2658 pretty-printers for that value."),
2660 &setprintrawlist
, &showprintrawlist
);
2662 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2663 &disassemble_next_line
, _("\
2664 Set whether to disassemble next source line or insn when execution stops."),
2666 Show whether to disassemble next source line or insn when execution stops."),
2668 If ON, GDB will display disassembly of the next source line, in addition\n\
2669 to displaying the source line itself. If the next source line cannot\n\
2670 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2671 will display disassembly of next instruction instead of showing the\n\
2673 If AUTO, display disassembly of next instruction only if the source line\n\
2674 cannot be displayed.\n\
2675 If OFF (which is the default), never display the disassembly of the next\n\
2678 show_disassemble_next_line
,
2679 &setlist
, &showlist
);
2680 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2682 add_setshow_enum_cmd ("entry-values", class_stack
,
2683 print_entry_values_choices
, &print_entry_values
,
2684 _("Set printing of function arguments at function "
2686 _("Show printing of function arguments at function "
2689 GDB can sometimes determine the values of function arguments at entry,\n\
2690 in addition to their current values. This option tells GDB whether\n\
2691 to print the current value, the value at entry (marked as val@entry),\n\
2692 or both. Note that one or both of these values may be <optimized out>."),
2693 NULL
, NULL
, &setprintlist
, &showprintlist
);