1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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 "exceptions.h"
40 #include "reggroups.h"
44 #include "gdbthread.h"
45 #include "cp-support.h"
47 #include "inline-frame.h"
49 #include "cli/cli-utils.h"
52 #include "gdb_assert.h"
57 #include "extension.h"
59 void (*deprecated_selected_frame_level_changed_hook
) (int);
61 /* The possible choices of "set print frame-arguments", and the value
64 static const char *const print_frame_arguments_choices
[] =
65 {"all", "scalars", "none", NULL
};
66 static const char *print_frame_arguments
= "scalars";
68 /* If non-zero, don't invoke pretty-printers for frame arguments. */
69 static int print_raw_frame_arguments
;
71 /* The possible choices of "set print entry-values", and the value
74 const char print_entry_values_no
[] = "no";
75 const char print_entry_values_only
[] = "only";
76 const char print_entry_values_preferred
[] = "preferred";
77 const char print_entry_values_if_needed
[] = "if-needed";
78 const char print_entry_values_both
[] = "both";
79 const char print_entry_values_compact
[] = "compact";
80 const char print_entry_values_default
[] = "default";
81 static const char *const print_entry_values_choices
[] =
83 print_entry_values_no
,
84 print_entry_values_only
,
85 print_entry_values_preferred
,
86 print_entry_values_if_needed
,
87 print_entry_values_both
,
88 print_entry_values_compact
,
89 print_entry_values_default
,
92 const char *print_entry_values
= print_entry_values_default
;
94 /* Prototypes for local functions. */
96 static void print_frame_local_vars (struct frame_info
*, int,
99 static void print_frame (struct frame_info
*frame
, int print_level
,
100 enum print_what print_what
, int print_args
,
101 struct symtab_and_line sal
);
103 static void set_last_displayed_sal (int valid
,
104 struct program_space
*pspace
,
106 struct symtab
*symtab
,
109 /* Zero means do things normally; we are interacting directly with the
110 user. One means print the full filename and linenumber when a
111 frame is printed, and do so in a format emacs18/emacs19.22 can
112 parse. Two means print similar annotations, but in many more
113 cases and in a slightly different syntax. */
115 int annotation_level
= 0;
117 /* These variables hold the last symtab and line we displayed to the user.
118 * This is where we insert a breakpoint or a skiplist entry by default. */
119 static int last_displayed_sal_valid
= 0;
120 static struct program_space
*last_displayed_pspace
= 0;
121 static CORE_ADDR last_displayed_addr
= 0;
122 static struct symtab
*last_displayed_symtab
= 0;
123 static int last_displayed_line
= 0;
126 /* Return 1 if we should display the address in addition to the location,
127 because we are in the middle of a statement. */
130 frame_show_address (struct frame_info
*frame
,
131 struct symtab_and_line sal
)
133 /* If there is a line number, but no PC, then there is no location
134 information associated with this sal. The only way that should
135 happen is for the call sites of inlined functions (SAL comes from
136 find_frame_sal). Otherwise, we would have some PC range if the
137 SAL came from a line table. */
138 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
140 if (get_next_frame (frame
) == NULL
)
141 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
143 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
147 return get_frame_pc (frame
) != sal
.pc
;
150 /* Show or print a stack frame FRAME briefly. The output is format
151 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
152 relative level, function name, argument list, and file name and
153 line number. If the frame's PC is not at the beginning of the
154 source line, the actual PC is printed at the beginning. */
157 print_stack_frame (struct frame_info
*frame
, int print_level
,
158 enum print_what print_what
,
161 volatile struct gdb_exception e
;
163 /* For mi, alway print location and address. */
164 if (ui_out_is_mi_like_p (current_uiout
))
165 print_what
= LOC_AND_ADDRESS
;
167 TRY_CATCH (e
, RETURN_MASK_ERROR
)
169 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
171 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
174 set_current_sal_from_frame (frame
, center
);
178 /* Print nameless arguments of frame FRAME on STREAM, where START is
179 the offset of the first nameless argument, and NUM is the number of
180 nameless arguments to print. FIRST is nonzero if this is the first
181 argument (not just the first nameless argument). */
184 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
185 int first
, struct ui_file
*stream
)
187 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
188 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
193 for (i
= 0; i
< num
; i
++)
196 argsaddr
= get_frame_args_address (frame
);
199 arg_value
= read_memory_integer (argsaddr
+ start
,
200 sizeof (int), byte_order
);
202 fprintf_filtered (stream
, ", ");
203 fprintf_filtered (stream
, "%ld", arg_value
);
205 start
+= sizeof (int);
209 /* Print single argument of inferior function. ARG must be already
212 Errors are printed as if they would be the parameter value. Use zeroed ARG
213 iff it should not be printed accoring to user settings. */
216 print_frame_arg (const struct frame_arg
*arg
)
218 struct ui_out
*uiout
= current_uiout
;
219 volatile struct gdb_exception except
;
220 struct cleanup
*old_chain
;
223 stb
= mem_fileopen ();
224 old_chain
= make_cleanup_ui_file_delete (stb
);
226 gdb_assert (!arg
->val
|| !arg
->error
);
227 gdb_assert (arg
->entry_kind
== print_entry_values_no
228 || arg
->entry_kind
== print_entry_values_only
229 || (!ui_out_is_mi_like_p (uiout
)
230 && arg
->entry_kind
== print_entry_values_compact
));
232 annotate_arg_begin ();
234 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
235 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
236 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
237 if (arg
->entry_kind
== print_entry_values_compact
)
239 /* It is OK to provide invalid MI-like stream as with
240 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
241 fputs_filtered ("=", stb
);
243 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
244 SYMBOL_LANGUAGE (arg
->sym
),
245 DMGL_PARAMS
| DMGL_ANSI
);
247 if (arg
->entry_kind
== print_entry_values_only
248 || arg
->entry_kind
== print_entry_values_compact
)
249 fputs_filtered ("@entry", stb
);
250 ui_out_field_stream (uiout
, "name", stb
);
251 annotate_arg_name_end ();
252 ui_out_text (uiout
, "=");
254 if (!arg
->val
&& !arg
->error
)
255 ui_out_text (uiout
, "...");
259 except
.message
= arg
->error
;
262 /* TRY_CATCH has two statements, wrap it in a block. */
264 TRY_CATCH (except
, RETURN_MASK_ERROR
)
266 const struct language_defn
*language
;
267 struct value_print_options opts
;
269 /* Avoid value_print because it will deref ref parameters. We
270 just want to print their addresses. Print ??? for args whose
271 address we do not know. We pass 2 as "recurse" to val_print
272 because our standard indentation here is 4 spaces, and
273 val_print indents 2 for each recurse. */
275 annotate_arg_value (value_type (arg
->val
));
277 /* Use the appropriate language to display our symbol, unless the
278 user forced the language to a specific language. */
279 if (language_mode
== language_mode_auto
)
280 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
282 language
= current_language
;
284 get_no_prettyformat_print_options (&opts
);
286 opts
.raw
= print_raw_frame_arguments
;
288 /* True in "summary" mode, false otherwise. */
289 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
291 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
295 fprintf_filtered (stb
, _("<error reading variable: %s>"),
299 ui_out_field_stream (uiout
, "value", stb
);
301 /* Also invoke ui_out_tuple_end. */
302 do_cleanups (old_chain
);
307 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
308 responsible for xfree of ARGP->ERROR. This function never throws an
312 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
313 struct frame_arg
*argp
)
315 volatile struct gdb_exception except
;
316 struct value
*val
= NULL
;
318 TRY_CATCH (except
, RETURN_MASK_ERROR
)
320 val
= read_var_value (sym
, frame
);
323 argp
->error
= (val
== NULL
) ? xstrdup (except
.message
) : NULL
;
328 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
329 responsible for xfree of ARGP->ERROR. This function never throws an
333 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
334 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
336 struct value
*val
= NULL
, *entryval
= NULL
;
337 char *val_error
= NULL
, *entryval_error
= NULL
;
339 volatile struct gdb_exception except
;
341 if (print_entry_values
!= print_entry_values_only
342 && print_entry_values
!= print_entry_values_preferred
)
344 TRY_CATCH (except
, RETURN_MASK_ERROR
)
346 val
= read_var_value (sym
, frame
);
350 val_error
= alloca (strlen (except
.message
) + 1);
351 strcpy (val_error
, except
.message
);
355 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
356 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
357 && print_entry_values
!= print_entry_values_no
358 && (print_entry_values
!= print_entry_values_if_needed
359 || !val
|| value_optimized_out (val
)))
361 TRY_CATCH (except
, RETURN_MASK_ERROR
)
363 const struct symbol_computed_ops
*ops
;
365 ops
= SYMBOL_COMPUTED_OPS (sym
);
366 entryval
= ops
->read_variable_at_entry (sym
, frame
);
370 entryval_error
= alloca (strlen (except
.message
) + 1);
371 strcpy (entryval_error
, except
.message
);
374 if (except
.error
== NO_ENTRY_VALUE_ERROR
375 || (entryval
&& value_optimized_out (entryval
)))
378 entryval_error
= NULL
;
381 if (print_entry_values
== print_entry_values_compact
382 || print_entry_values
== print_entry_values_default
)
384 /* For MI do not try to use print_entry_values_compact for ARGP. */
386 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
388 struct type
*type
= value_type (val
);
390 if (!value_optimized_out (val
)
391 && value_available_contents_eq (val
, 0, entryval
, 0,
394 /* Initialize it just to avoid a GCC false warning. */
395 struct value
*val_deref
= NULL
, *entryval_deref
;
397 /* DW_AT_GNU_call_site_value does match with the current
398 value. If it is a reference still try to verify if
399 dereferenced DW_AT_GNU_call_site_data_value does not
402 TRY_CATCH (except
, RETURN_MASK_ERROR
)
404 struct type
*type_deref
;
406 val_deref
= coerce_ref (val
);
407 if (value_lazy (val_deref
))
408 value_fetch_lazy (val_deref
);
409 type_deref
= value_type (val_deref
);
411 entryval_deref
= coerce_ref (entryval
);
412 if (value_lazy (entryval_deref
))
413 value_fetch_lazy (entryval_deref
);
415 /* If the reference addresses match but dereferenced
416 content does not match print them. */
418 && value_available_contents_eq (val_deref
, 0,
420 TYPE_LENGTH (type_deref
)))
424 /* Value was not a reference; and its content matches. */
425 if (val
== val_deref
)
427 /* If the dereferenced content could not be fetched do not
429 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
431 else if (except
.message
)
433 entryval_error
= alloca (strlen (except
.message
) + 1);
434 strcpy (entryval_error
, except
.message
);
442 /* Try to remove possibly duplicate error message for ENTRYARGP even
445 if (val_error
&& entryval_error
446 && strcmp (val_error
, entryval_error
) == 0)
448 entryval_error
= NULL
;
450 /* Do not se VAL_EQUAL as the same error message may be shown for
451 the entry value even if no entry values are present in the
457 if (entryval
== NULL
)
459 if (print_entry_values
== print_entry_values_preferred
)
461 TRY_CATCH (except
, RETURN_MASK_ERROR
)
463 val
= read_var_value (sym
, frame
);
467 val_error
= alloca (strlen (except
.message
) + 1);
468 strcpy (val_error
, except
.message
);
471 if (print_entry_values
== print_entry_values_only
472 || print_entry_values
== print_entry_values_both
473 || (print_entry_values
== print_entry_values_preferred
474 && (!val
|| value_optimized_out (val
))))
476 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
477 entryval_error
= NULL
;
480 if ((print_entry_values
== print_entry_values_compact
481 || print_entry_values
== print_entry_values_if_needed
482 || print_entry_values
== print_entry_values_preferred
)
483 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
491 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
492 if (!val
&& !val_error
)
493 argp
->entry_kind
= print_entry_values_only
;
494 else if ((print_entry_values
== print_entry_values_compact
495 || print_entry_values
== print_entry_values_default
) && val_equal
)
497 argp
->entry_kind
= print_entry_values_compact
;
498 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
501 argp
->entry_kind
= print_entry_values_no
;
503 entryargp
->sym
= sym
;
504 entryargp
->val
= entryval
;
505 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
506 if (!entryval
&& !entryval_error
)
507 entryargp
->entry_kind
= print_entry_values_no
;
509 entryargp
->entry_kind
= print_entry_values_only
;
512 /* Print the arguments of frame FRAME on STREAM, given the function
513 FUNC running in that frame (as a symbol), where NUM is the number
514 of arguments according to the stack frame (or -1 if the number of
515 arguments is unknown). */
517 /* Note that currently the "number of arguments according to the
518 stack frame" is only known on VAX where i refers to the "number of
519 ints of arguments according to the stack frame". */
522 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
523 int num
, struct ui_file
*stream
)
525 struct ui_out
*uiout
= current_uiout
;
527 /* Offset of next stack argument beyond the one we have seen that is
528 at the highest offset, or -1 if we haven't come to a stack
530 long highest_offset
= -1;
531 /* Number of ints of arguments that we have printed so far. */
532 int args_printed
= 0;
533 struct cleanup
*old_chain
;
535 /* True if we should print arguments, false otherwise. */
536 int print_args
= strcmp (print_frame_arguments
, "none");
538 stb
= mem_fileopen ();
539 old_chain
= make_cleanup_ui_file_delete (stb
);
543 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
544 struct block_iterator iter
;
547 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
549 struct frame_arg arg
, entryarg
;
553 /* Keep track of the highest stack argument offset seen, and
554 skip over any kinds of symbols we don't care about. */
556 if (!SYMBOL_IS_ARGUMENT (sym
))
559 switch (SYMBOL_CLASS (sym
))
564 long current_offset
= SYMBOL_VALUE (sym
);
565 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
567 /* Compute address of next argument by adding the size of
568 this argument and rounding to an int boundary. */
570 ((current_offset
+ arg_size
+ sizeof (int) - 1)
571 & ~(sizeof (int) - 1));
573 /* If this is the highest offset seen yet, set
575 if (highest_offset
== -1
576 || (current_offset
> highest_offset
))
577 highest_offset
= current_offset
;
579 /* Add the number of ints we're about to print to
581 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
584 /* We care about types of symbols, but don't need to
585 keep track of stack offsets in them. */
587 case LOC_REGPARM_ADDR
:
589 case LOC_OPTIMIZED_OUT
:
594 /* We have to look up the symbol because arguments can have
595 two entries (one a parameter, one a local) and the one we
596 want is the local, which lookup_symbol will find for us.
597 This includes gcc1 (not gcc2) on SPARC when passing a
598 small structure and gcc2 when the argument type is float
599 and it is passed as a double and converted to float by
600 the prologue (in the latter case the type of the LOC_ARG
601 symbol is double and the type of the LOC_LOCAL symbol is
603 /* But if the parameter name is null, don't try it. Null
604 parameter names occur on the RS/6000, for traceback
605 tables. FIXME, should we even print them? */
607 if (*SYMBOL_LINKAGE_NAME (sym
))
611 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
612 b
, VAR_DOMAIN
, NULL
);
613 gdb_assert (nsym
!= NULL
);
614 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
615 && !SYMBOL_IS_ARGUMENT (nsym
))
617 /* There is a LOC_ARG/LOC_REGISTER pair. This means
618 that it was passed on the stack and loaded into a
619 register, or passed in a register and stored in a
620 stack slot. GDB 3.x used the LOC_ARG; GDB
621 4.0-4.11 used the LOC_REGISTER.
623 Reasons for using the LOC_ARG:
625 (1) Because find_saved_registers may be slow for
628 (2) Because registers are often re-used and stack
629 slots rarely (never?) are. Therefore using
630 the stack slot is much less likely to print
633 Reasons why we might want to use the LOC_REGISTER:
635 (1) So that the backtrace prints the same value
636 as "print foo". I see no compelling reason
637 why this needs to be the case; having the
638 backtrace print the value which was passed
639 in, and "print foo" print the value as
640 modified within the called function, makes
643 Additional note: It might be nice if "info args"
644 displayed both values.
646 One more note: There is a case with SPARC
647 structure passing where we need to use the
648 LOC_REGISTER, but this is dealt with by creating
649 a single LOC_REGPARM in symbol reading. */
651 /* Leave sym (the LOC_ARG) alone. */
658 /* Print the current arg. */
660 ui_out_text (uiout
, ", ");
661 ui_out_wrap_hint (uiout
, " ");
665 memset (&arg
, 0, sizeof (arg
));
667 arg
.entry_kind
= print_entry_values_no
;
668 memset (&entryarg
, 0, sizeof (entryarg
));
670 entryarg
.entry_kind
= print_entry_values_no
;
673 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
675 if (arg
.entry_kind
!= print_entry_values_only
)
676 print_frame_arg (&arg
);
678 if (entryarg
.entry_kind
!= print_entry_values_no
)
680 if (arg
.entry_kind
!= print_entry_values_only
)
682 ui_out_text (uiout
, ", ");
683 ui_out_wrap_hint (uiout
, " ");
686 print_frame_arg (&entryarg
);
690 xfree (entryarg
.error
);
696 /* Don't print nameless args in situations where we don't know
697 enough about the stack to find them. */
702 if (highest_offset
== -1)
703 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
705 start
= highest_offset
;
707 print_frame_nameless_args (frame
, start
, num
- args_printed
,
711 do_cleanups (old_chain
);
714 /* Set the current source and line to the location given by frame
715 FRAME, if possible. When CENTER is true, adjust so the relevant
716 line is in the center of the next 'list'. */
719 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
721 struct symtab_and_line sal
;
723 find_frame_sal (frame
, &sal
);
727 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
728 set_current_source_symtab_and_line (&sal
);
732 /* If ON, GDB will display disassembly of the next source line when
733 execution of the program being debugged stops.
734 If AUTO (which is the default), or there's no line info to determine
735 the source line of the next instruction, display disassembly of next
736 instruction instead. */
738 static enum auto_boolean disassemble_next_line
;
741 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
742 struct cmd_list_element
*c
,
745 fprintf_filtered (file
,
746 _("Debugger's willingness to use "
747 "disassemble-next-line is %s.\n"),
751 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
752 because it will be broken by filter sometime. */
755 do_gdb_disassembly (struct gdbarch
*gdbarch
,
756 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
758 volatile struct gdb_exception exception
;
760 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
762 gdb_disassembly (gdbarch
, current_uiout
, 0,
763 DISASSEMBLY_RAW_INSN
, how_many
,
766 if (exception
.reason
< 0)
768 /* If an exception was thrown while doing the disassembly, print
769 the error message, to give the user a clue of what happened. */
770 exception_print (gdb_stderr
, exception
);
774 /* Print information about frame FRAME. The output is format according
775 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
778 SRC_LINE: Print only source line.
779 LOCATION: Print only location.
780 LOC_AND_SRC: Print location and source line.
782 Used in "where" output, and to emit breakpoint or step
786 print_frame_info (struct frame_info
*frame
, int print_level
,
787 enum print_what print_what
, int print_args
,
790 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
791 struct symtab_and_line sal
;
794 struct ui_out
*uiout
= current_uiout
;
796 if (get_frame_type (frame
) == DUMMY_FRAME
797 || get_frame_type (frame
) == SIGTRAMP_FRAME
798 || get_frame_type (frame
) == ARCH_FRAME
)
800 struct cleanup
*uiout_cleanup
801 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
803 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
804 gdbarch
, get_frame_pc (frame
));
806 /* Do this regardless of SOURCE because we don't have any source
807 to list for this frame. */
810 ui_out_text (uiout
, "#");
811 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
812 frame_relative_level (frame
));
814 if (ui_out_is_mi_like_p (uiout
))
816 annotate_frame_address ();
817 ui_out_field_core_addr (uiout
, "addr",
818 gdbarch
, get_frame_pc (frame
));
819 annotate_frame_address_end ();
822 if (get_frame_type (frame
) == DUMMY_FRAME
)
824 annotate_function_call ();
825 ui_out_field_string (uiout
, "func", "<function called from gdb>");
827 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
829 annotate_signal_handler_caller ();
830 ui_out_field_string (uiout
, "func", "<signal handler called>");
832 else if (get_frame_type (frame
) == ARCH_FRAME
)
834 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
836 ui_out_text (uiout
, "\n");
837 annotate_frame_end ();
839 do_cleanups (uiout_cleanup
);
843 /* If FRAME is not the innermost frame, that normally means that
844 FRAME->pc points to *after* the call instruction, and we want to
845 get the line containing the call, never the next line. But if
846 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
847 next frame was not entered as the result of a call, and we want
848 to get the line containing FRAME->pc. */
849 find_frame_sal (frame
, &sal
);
851 location_print
= (print_what
== LOCATION
852 || print_what
== LOC_AND_ADDRESS
853 || print_what
== SRC_AND_LOC
);
855 if (location_print
|| !sal
.symtab
)
856 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
858 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
860 /* If disassemble-next-line is set to auto or on and doesn't have
861 the line debug messages for $pc, output the next instruction. */
862 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
863 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
864 && source_print
&& !sal
.symtab
)
865 do_gdb_disassembly (get_frame_arch (frame
), 1,
866 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
868 if (source_print
&& sal
.symtab
)
871 int mid_statement
= ((print_what
== SRC_LINE
)
872 && frame_show_address (frame
, sal
));
874 if (annotation_level
)
875 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
876 get_frame_pc (frame
));
879 if (deprecated_print_frame_info_listing_hook
)
880 deprecated_print_frame_info_listing_hook (sal
.symtab
,
885 struct value_print_options opts
;
887 get_user_print_options (&opts
);
888 /* We used to do this earlier, but that is clearly
889 wrong. This function is used by many different
890 parts of gdb, including normal_stop in infrun.c,
891 which uses this to print out the current PC
892 when we stepi/nexti into the middle of a source
893 line. Only the command line really wants this
894 behavior. Other UIs probably would like the
895 ability to decide for themselves if it is desired. */
896 if (opts
.addressprint
&& mid_statement
)
898 ui_out_field_core_addr (uiout
, "addr",
899 gdbarch
, get_frame_pc (frame
));
900 ui_out_text (uiout
, "\t");
903 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
907 /* If disassemble-next-line is set to on and there is line debug
908 messages, output assembly codes for next line. */
909 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
910 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
917 if (get_frame_pc_if_available (frame
, &pc
))
918 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
920 set_last_displayed_sal (0, 0, 0, 0, 0);
923 annotate_frame_end ();
925 gdb_flush (gdb_stdout
);
928 /* Remember the last symtab and line we displayed, which we use e.g.
929 * as the place to put a breakpoint when the `break' command is
930 * invoked with no arguments. */
933 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
934 CORE_ADDR addr
, struct symtab
*symtab
,
937 last_displayed_sal_valid
= valid
;
938 last_displayed_pspace
= pspace
;
939 last_displayed_addr
= addr
;
940 last_displayed_symtab
= symtab
;
941 last_displayed_line
= line
;
942 if (valid
&& pspace
== NULL
)
944 clear_last_displayed_sal ();
945 internal_error (__FILE__
, __LINE__
,
946 _("Trying to set NULL pspace."));
950 /* Forget the last sal we displayed. */
953 clear_last_displayed_sal (void)
955 last_displayed_sal_valid
= 0;
956 last_displayed_pspace
= 0;
957 last_displayed_addr
= 0;
958 last_displayed_symtab
= 0;
959 last_displayed_line
= 0;
962 /* Is our record of the last sal we displayed valid? If not,
963 * the get_last_displayed_* functions will return NULL or 0, as
967 last_displayed_sal_is_valid (void)
969 return last_displayed_sal_valid
;
972 /* Get the pspace of the last sal we displayed, if it's valid. */
974 struct program_space
*
975 get_last_displayed_pspace (void)
977 if (last_displayed_sal_valid
)
978 return last_displayed_pspace
;
982 /* Get the address of the last sal we displayed, if it's valid. */
985 get_last_displayed_addr (void)
987 if (last_displayed_sal_valid
)
988 return last_displayed_addr
;
992 /* Get the symtab of the last sal we displayed, if it's valid. */
995 get_last_displayed_symtab (void)
997 if (last_displayed_sal_valid
)
998 return last_displayed_symtab
;
1002 /* Get the line of the last sal we displayed, if it's valid. */
1005 get_last_displayed_line (void)
1007 if (last_displayed_sal_valid
)
1008 return last_displayed_line
;
1012 /* Get the last sal we displayed, if it's valid. */
1015 get_last_displayed_sal (struct symtab_and_line
*sal
)
1017 if (last_displayed_sal_valid
)
1019 sal
->pspace
= last_displayed_pspace
;
1020 sal
->pc
= last_displayed_addr
;
1021 sal
->symtab
= last_displayed_symtab
;
1022 sal
->line
= last_displayed_line
;
1034 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1035 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1038 find_frame_funname (struct frame_info
*frame
, char **funname
,
1039 enum language
*funlang
, struct symbol
**funcp
)
1041 struct symbol
*func
;
1044 *funlang
= language_unknown
;
1048 func
= get_frame_function (frame
);
1051 /* In certain pathological cases, the symtabs give the wrong
1052 function (when we are in the first function in a file which
1053 is compiled without debugging symbols, the previous function
1054 is compiled with debugging symbols, and the "foo.o" symbol
1055 that is supposed to tell us where the file with debugging
1056 symbols ends has been truncated by ar because it is longer
1057 than 15 characters). This also occurs if the user uses asm()
1058 to create a function but not stabs for it (in a file compiled
1061 So look in the minimal symbol tables as well, and if it comes
1062 up with a larger address for the function use that instead.
1063 I don't think this can ever cause any problems; there
1064 shouldn't be any minimal symbols in the middle of a function;
1065 if this is ever changed many parts of GDB will need to be
1066 changed (and we'll create a find_pc_minimal_function or some
1069 struct bound_minimal_symbol msymbol
;
1071 /* Don't attempt to do this for inlined functions, which do not
1072 have a corresponding minimal symbol. */
1073 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1075 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1077 memset (&msymbol
, 0, sizeof (msymbol
));
1079 if (msymbol
.minsym
!= NULL
1080 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1081 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1083 /* We also don't know anything about the function besides
1084 its address and name. */
1086 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1087 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1091 *funname
= xstrdup (SYMBOL_PRINT_NAME (func
));
1092 *funlang
= SYMBOL_LANGUAGE (func
);
1095 if (*funlang
== language_cplus
)
1097 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1098 to display the demangled name that we already have
1099 stored in the symbol table, but we stored a version
1100 with DMGL_PARAMS turned on, and here we don't want to
1101 display parameters. So remove the parameters. */
1102 char *func_only
= cp_remove_params (*funname
);
1107 *funname
= func_only
;
1114 struct bound_minimal_symbol msymbol
;
1117 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1120 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1121 if (msymbol
.minsym
!= NULL
)
1123 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1124 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1130 print_frame (struct frame_info
*frame
, int print_level
,
1131 enum print_what print_what
, int print_args
,
1132 struct symtab_and_line sal
)
1134 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1135 struct ui_out
*uiout
= current_uiout
;
1136 char *funname
= NULL
;
1137 enum language funlang
= language_unknown
;
1138 struct ui_file
*stb
;
1139 struct cleanup
*old_chain
, *list_chain
;
1140 struct value_print_options opts
;
1141 struct symbol
*func
;
1145 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1147 stb
= mem_fileopen ();
1148 old_chain
= make_cleanup_ui_file_delete (stb
);
1150 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1151 make_cleanup (xfree
, funname
);
1153 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1156 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1160 ui_out_text (uiout
, "#");
1161 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1162 frame_relative_level (frame
));
1164 get_user_print_options (&opts
);
1165 if (opts
.addressprint
)
1167 || frame_show_address (frame
, sal
)
1168 || print_what
== LOC_AND_ADDRESS
)
1170 annotate_frame_address ();
1172 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1174 ui_out_field_string (uiout
, "addr", "<unavailable>");
1175 annotate_frame_address_end ();
1176 ui_out_text (uiout
, " in ");
1178 annotate_frame_function_name ();
1179 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1180 funlang
, DMGL_ANSI
);
1181 ui_out_field_stream (uiout
, "func", stb
);
1182 ui_out_wrap_hint (uiout
, " ");
1183 annotate_frame_args ();
1185 ui_out_text (uiout
, " (");
1188 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1190 struct cleanup
*args_list_chain
;
1191 volatile struct gdb_exception e
;
1193 if (gdbarch_frame_num_args_p (gdbarch
))
1195 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1196 gdb_assert (numargs
>= 0);
1201 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1202 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1204 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1206 /* FIXME: ARGS must be a list. If one argument is a string it
1207 will have " that will not be properly escaped. */
1208 /* Invoke ui_out_tuple_end. */
1209 do_cleanups (args_list_chain
);
1212 ui_out_text (uiout
, ")");
1215 const char *filename_display
;
1217 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1218 annotate_frame_source_begin ();
1219 ui_out_wrap_hint (uiout
, " ");
1220 ui_out_text (uiout
, " at ");
1221 annotate_frame_source_file ();
1222 ui_out_field_string (uiout
, "file", filename_display
);
1223 if (ui_out_is_mi_like_p (uiout
))
1225 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1227 ui_out_field_string (uiout
, "fullname", fullname
);
1229 annotate_frame_source_file_end ();
1230 ui_out_text (uiout
, ":");
1231 annotate_frame_source_line ();
1232 ui_out_field_int (uiout
, "line", sal
.line
);
1233 annotate_frame_source_end ();
1236 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1238 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1239 get_frame_pc (frame
));
1243 annotate_frame_where ();
1244 ui_out_wrap_hint (uiout
, " ");
1245 ui_out_text (uiout
, " from ");
1246 ui_out_field_string (uiout
, "from", lib
);
1250 /* do_cleanups will call ui_out_tuple_end() for us. */
1251 do_cleanups (list_chain
);
1252 ui_out_text (uiout
, "\n");
1253 do_cleanups (old_chain
);
1257 /* Read a frame specification in whatever the appropriate format is
1258 from FRAME_EXP. Call error(), printing MESSAGE, if the
1259 specification is in any way invalid (so this function never returns
1260 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1261 the default selected frame was used. */
1263 static struct frame_info
*
1264 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1265 int *selected_frame_p
)
1268 struct value
*args
[4];
1269 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1271 if (frame_exp
== NULL
)
1279 struct cleanup
*cleanup
;
1282 /* Skip leading white space, bail of EOL. */
1283 frame_exp
= skip_spaces_const (frame_exp
);
1287 /* Parse the argument, extract it, save it. */
1289 *p
&& !isspace (*p
);
1291 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1293 cleanup
= make_cleanup (xfree
, addr_string
);
1295 /* NOTE: Parse and evaluate expression, but do not use
1296 functions such as parse_and_eval_long or
1297 parse_and_eval_address to also extract the value.
1298 Instead value_as_long and value_as_address are used.
1299 This avoids problems with expressions that contain
1301 if (numargs
>= ARRAY_SIZE (args
))
1302 error (_("Too many args in frame specification"));
1303 args
[numargs
++] = parse_and_eval (addr_string
);
1305 do_cleanups (cleanup
);
1309 /* If no args, default to the selected frame. */
1312 if (selected_frame_p
!= NULL
)
1313 (*selected_frame_p
) = 1;
1314 return get_selected_frame (message
);
1317 /* None of the remaining use the selected frame. */
1318 if (selected_frame_p
!= NULL
)
1319 (*selected_frame_p
) = 0;
1321 /* Assume the single arg[0] is an integer, and try using that to
1322 select a frame relative to current. */
1325 struct frame_info
*fid
;
1326 int level
= value_as_long (args
[0]);
1328 fid
= find_relative_frame (get_current_frame (), &level
);
1330 /* find_relative_frame was successful. */
1334 /* Convert each value into a corresponding address. */
1338 for (i
= 0; i
< numargs
; i
++)
1339 addrs
[i
] = value_as_address (args
[i
]);
1342 /* Assume that the single arg[0] is an address, use that to identify
1343 a frame with a matching ID. Should this also accept stack/pc or
1344 stack/pc/special. */
1347 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1348 struct frame_info
*fid
;
1350 /* If (s)he specifies the frame with an address, he deserves
1351 what (s)he gets. Still, give the highest one that matches.
1352 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1354 for (fid
= get_current_frame ();
1356 fid
= get_prev_frame (fid
))
1358 if (frame_id_eq (id
, get_frame_id (fid
)))
1360 struct frame_info
*prev_frame
;
1364 prev_frame
= get_prev_frame (fid
);
1366 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1375 /* We couldn't identify the frame as an existing frame, but
1376 perhaps we can create one with a single argument. */
1378 return create_new_frame (addrs
[0], 0);
1379 else if (numargs
== 2)
1380 return create_new_frame (addrs
[0], addrs
[1]);
1382 error (_("Too many args in frame specification"));
1385 static struct frame_info
*
1386 parse_frame_specification (char *frame_exp
)
1388 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1391 /* Print verbosely the selected frame or the frame at address
1392 ADDR_EXP. Absolutely all information in the frame is printed. */
1395 frame_info (char *addr_exp
, int from_tty
)
1397 struct frame_info
*fi
;
1398 struct symtab_and_line sal
;
1399 struct symbol
*func
;
1401 struct frame_info
*calling_frame_info
;
1403 const char *funname
= 0;
1404 enum language funlang
= language_unknown
;
1405 const char *pc_regname
;
1406 int selected_frame_p
;
1407 struct gdbarch
*gdbarch
;
1408 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1411 /* Initialize it to avoid "may be used uninitialized" warning. */
1412 CORE_ADDR caller_pc
= 0;
1413 volatile struct gdb_exception ex
;
1415 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1416 gdbarch
= get_frame_arch (fi
);
1418 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1419 is not a good name. */
1420 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1421 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1422 easily not match that of the internal value returned by
1424 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1426 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1427 architectures will often have a hardware register called "pc",
1428 and that register's value, again, can easily not match
1432 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1433 find_frame_sal (fi
, &sal
);
1434 func
= get_frame_function (fi
);
1438 funname
= SYMBOL_PRINT_NAME (func
);
1439 funlang
= SYMBOL_LANGUAGE (func
);
1440 if (funlang
== language_cplus
)
1442 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1443 to display the demangled name that we already have
1444 stored in the symbol table, but we stored a version
1445 with DMGL_PARAMS turned on, and here we don't want to
1446 display parameters. So remove the parameters. */
1447 char *func_only
= cp_remove_params (funname
);
1451 funname
= func_only
;
1452 make_cleanup (xfree
, func_only
);
1456 else if (frame_pc_p
)
1458 struct bound_minimal_symbol msymbol
;
1460 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1461 if (msymbol
.minsym
!= NULL
)
1463 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1464 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1467 calling_frame_info
= get_prev_frame (fi
);
1469 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1471 printf_filtered (_("Stack level %d, frame at "),
1472 frame_relative_level (fi
));
1476 printf_filtered (_("Stack frame at "));
1478 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1479 printf_filtered (":\n");
1480 printf_filtered (" %s = ", pc_regname
);
1482 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1484 fputs_filtered ("<unavailable>", gdb_stdout
);
1489 printf_filtered (" in ");
1490 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1491 DMGL_ANSI
| DMGL_PARAMS
);
1495 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1497 puts_filtered ("; ");
1499 printf_filtered ("saved %s = ", pc_regname
);
1501 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
1503 caller_pc
= frame_unwind_caller_pc (fi
);
1509 case NOT_AVAILABLE_ERROR
:
1510 val_print_unavailable (gdb_stdout
);
1512 case OPTIMIZED_OUT_ERROR
:
1513 val_print_not_saved (gdb_stdout
);
1516 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1521 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1522 printf_filtered ("\n");
1524 if (calling_frame_info
== NULL
)
1526 enum unwind_stop_reason reason
;
1528 reason
= get_frame_unwind_stop_reason (fi
);
1529 if (reason
!= UNWIND_NO_REASON
)
1530 printf_filtered (_(" Outermost frame: %s\n"),
1531 frame_stop_reason_string (reason
));
1533 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1534 puts_filtered (" tail call frame");
1535 else if (get_frame_type (fi
) == INLINE_FRAME
)
1536 printf_filtered (" inlined into frame %d",
1537 frame_relative_level (get_prev_frame (fi
)));
1540 printf_filtered (" called by frame at ");
1541 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1544 if (get_next_frame (fi
) && calling_frame_info
)
1545 puts_filtered (",");
1547 if (get_next_frame (fi
))
1549 printf_filtered (" caller of frame at ");
1550 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1553 if (get_next_frame (fi
) || calling_frame_info
)
1554 puts_filtered ("\n");
1557 printf_filtered (" source language %s.\n",
1558 language_str (s
->language
));
1561 /* Address of the argument list for this frame, or 0. */
1562 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1563 /* Number of args for this frame, or -1 if unknown. */
1567 printf_filtered (" Arglist at unknown address.\n");
1570 printf_filtered (" Arglist at ");
1571 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1572 printf_filtered (",");
1574 if (!gdbarch_frame_num_args_p (gdbarch
))
1577 puts_filtered (" args: ");
1581 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1582 gdb_assert (numargs
>= 0);
1584 puts_filtered (" no args.");
1585 else if (numargs
== 1)
1586 puts_filtered (" 1 arg: ");
1588 printf_filtered (" %d args: ", numargs
);
1590 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1591 puts_filtered ("\n");
1595 /* Address of the local variables for this frame, or 0. */
1596 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1599 printf_filtered (" Locals at unknown address,");
1602 printf_filtered (" Locals at ");
1603 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1604 printf_filtered (",");
1608 /* Print as much information as possible on the location of all the
1611 enum lval_type lval
;
1620 /* The sp is special; what's displayed isn't the save address, but
1621 the value of the previous frame's sp. This is a legacy thing,
1622 at one stage the frame cached the previous frame's SP instead
1623 of its address, hence it was easiest to just display the cached
1625 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1627 /* Find out the location of the saved stack pointer with out
1628 actually evaluating it. */
1629 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1630 &optimized
, &unavailable
, &lval
, &addr
,
1632 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1634 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1635 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1636 gdb_byte value
[MAX_REGISTER_SIZE
];
1639 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1640 &optimized
, &unavailable
, &lval
, &addr
,
1642 /* NOTE: cagney/2003-05-22: This is assuming that the
1643 stack pointer was packed as an unsigned integer. That
1644 may or may not be valid. */
1645 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1646 printf_filtered (" Previous frame's sp is ");
1647 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1648 printf_filtered ("\n");
1651 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1653 printf_filtered (" Previous frame's sp at ");
1654 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1655 printf_filtered ("\n");
1658 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1660 printf_filtered (" Previous frame's sp in %s\n",
1661 gdbarch_register_name (gdbarch
, realnum
));
1664 /* else keep quiet. */
1668 numregs
= gdbarch_num_regs (gdbarch
)
1669 + gdbarch_num_pseudo_regs (gdbarch
);
1670 for (i
= 0; i
< numregs
; i
++)
1671 if (i
!= gdbarch_sp_regnum (gdbarch
)
1672 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1674 /* Find out the location of the saved register without
1675 fetching the corresponding value. */
1676 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1677 &lval
, &addr
, &realnum
, NULL
);
1678 /* For moment, only display registers that were saved on the
1680 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1683 puts_filtered (" Saved registers:\n ");
1685 puts_filtered (",");
1687 printf_filtered (" %s at ",
1688 gdbarch_register_name (gdbarch
, i
));
1689 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1693 if (count
|| need_nl
)
1694 puts_filtered ("\n");
1697 do_cleanups (back_to
);
1700 /* Print briefly all stack frames or just the innermost COUNT_EXP
1704 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1707 struct frame_info
*fi
;
1710 struct frame_info
*trailing
;
1711 int trailing_level
, py_start
= 0, py_end
= 0;
1712 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1714 if (!target_has_stack
)
1715 error (_("No stack."));
1717 /* The following code must do two things. First, it must set the
1718 variable TRAILING to the frame from which we should start
1719 printing. Second, it must set the variable count to the number
1720 of frames which we should print, or -1 if all of them. */
1721 trailing
= get_current_frame ();
1726 count
= parse_and_eval_long (count_exp
);
1729 struct frame_info
*current
;
1735 while (current
&& count
--)
1738 current
= get_prev_frame (current
);
1741 /* Will stop when CURRENT reaches the top of the stack.
1742 TRAILING will be COUNT below it. */
1746 trailing
= get_prev_frame (trailing
);
1747 current
= get_prev_frame (current
);
1767 /* Read in symbols for all of the frames. Need to do this in a
1768 separate pass so that "Reading in symbols for xxx" messages
1769 don't screw up the appearance of the backtrace. Also if
1770 people have strong opinions against reading symbols for
1771 backtrace this may have to be an option. */
1773 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1778 pc
= get_frame_address_in_block (fi
);
1779 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1785 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1786 enum ext_lang_frame_args arg_type
;
1789 flags
|= PRINT_LOCALS
;
1791 if (!strcmp (print_frame_arguments
, "scalars"))
1792 arg_type
= CLI_SCALAR_VALUES
;
1793 else if (!strcmp (print_frame_arguments
, "all"))
1794 arg_type
= CLI_ALL_VALUES
;
1796 arg_type
= NO_VALUES
;
1798 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1799 arg_type
, current_uiout
,
1803 /* Run the inbuilt backtrace if there are no filters registered, or
1804 "no-filters" has been specified from the command. */
1805 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1807 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1811 /* Don't use print_stack_frame; if an error() occurs it probably
1812 means further attempts to backtrace would fail (on the other
1813 hand, perhaps the code does or could be fixed to make sure
1814 the frame->prev field gets set to NULL in that case). */
1816 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1819 struct frame_id frame_id
= get_frame_id (fi
);
1821 print_frame_local_vars (fi
, 1, gdb_stdout
);
1823 /* print_frame_local_vars invalidates FI. */
1824 fi
= frame_find_by_id (frame_id
);
1828 warning (_("Unable to restore previously selected frame."));
1833 /* Save the last frame to check for error conditions. */
1837 /* If we've stopped before the end, mention that. */
1839 printf_filtered (_("(More stack frames follow...)\n"));
1841 /* If we've run out of frames, and the reason appears to be an error
1842 condition, print it. */
1843 if (fi
== NULL
&& trailing
!= NULL
)
1845 enum unwind_stop_reason reason
;
1847 reason
= get_frame_unwind_stop_reason (trailing
);
1848 if (reason
>= UNWIND_FIRST_ERROR
)
1849 printf_filtered (_("Backtrace stopped: %s\n"),
1850 frame_stop_reason_string (reason
));
1856 backtrace_command (char *arg
, int from_tty
)
1858 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1859 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1867 argv
= gdb_buildargv (arg
);
1868 make_cleanup_freeargv (argv
);
1870 for (i
= 0; argv
[i
]; i
++)
1874 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1875 argv
[i
][j
] = tolower (argv
[i
][j
]);
1877 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1881 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1882 fulltrace_arg
= argc
;
1886 arglen
+= strlen (argv
[i
]);
1892 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1896 arg
= xmalloc (arglen
+ 1);
1897 make_cleanup (xfree
, arg
);
1899 for (i
= 0; i
< argc
; i
++)
1901 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1903 strcat (arg
, argv
[i
]);
1913 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1914 no_filters
>= 0 /* no frame-filters */, from_tty
);
1916 do_cleanups (old_chain
);
1920 backtrace_full_command (char *arg
, int from_tty
)
1922 backtrace_command_1 (arg
, 1 /* show_locals */, 0, from_tty
);
1926 /* Iterate over the local variables of a block B, calling CB with
1930 iterate_over_block_locals (struct block
*b
,
1931 iterate_over_block_arg_local_vars_cb cb
,
1934 struct block_iterator iter
;
1937 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1939 switch (SYMBOL_CLASS (sym
))
1945 if (SYMBOL_IS_ARGUMENT (sym
))
1947 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1949 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1953 /* Ignore symbols which are not locals. */
1960 /* Same, but print labels. */
1963 /* Commented out, as the code using this function has also been
1964 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1965 was commented out in the first place. The discussion introducing
1966 this change (2007-12-04: Support lexical blocks and function bodies
1967 that occupy non-contiguous address ranges) did not explain why
1968 this change was made. */
1970 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1971 int *have_default
, struct ui_file
*stream
)
1973 struct block_iterator iter
;
1975 int values_printed
= 0;
1977 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1979 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1985 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1987 struct symtab_and_line sal
;
1988 struct value_print_options opts
;
1990 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1992 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1993 get_user_print_options (&opts
);
1994 if (opts
.addressprint
)
1996 fprintf_filtered (stream
, " ");
1997 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
2000 fprintf_filtered (stream
, " in file %s, line %d\n",
2001 sal
.symtab
->filename
, sal
.line
);
2005 return values_printed
;
2009 /* Iterate over all the local variables in block B, including all its
2010 superblocks, stopping when the top-level block is reached. */
2013 iterate_over_block_local_vars (struct block
*block
,
2014 iterate_over_block_arg_local_vars_cb cb
,
2019 iterate_over_block_locals (block
, cb
, cb_data
);
2020 /* After handling the function's top-level block, stop. Don't
2021 continue to its superblock, the block of per-file
2023 if (BLOCK_FUNCTION (block
))
2025 block
= BLOCK_SUPERBLOCK (block
);
2029 /* Data to be passed around in the calls to the locals and args
2032 struct print_variable_and_value_data
2034 struct frame_id frame_id
;
2036 struct ui_file
*stream
;
2040 /* The callback for the locals and args iterators. */
2043 do_print_variable_and_value (const char *print_name
,
2047 struct print_variable_and_value_data
*p
= cb_data
;
2048 struct frame_info
*frame
;
2050 frame
= frame_find_by_id (p
->frame_id
);
2053 warning (_("Unable to restore previously selected frame."));
2057 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2059 /* print_variable_and_value invalidates FRAME. */
2062 p
->values_printed
= 1;
2065 /* Print all variables from the innermost up to the function block of FRAME.
2066 Print them with values to STREAM indented by NUM_TABS.
2068 This function will invalidate FRAME. */
2071 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2072 struct ui_file
*stream
)
2074 struct print_variable_and_value_data cb_data
;
2075 struct block
*block
;
2078 if (!get_frame_pc_if_available (frame
, &pc
))
2080 fprintf_filtered (stream
,
2081 _("PC unavailable, cannot determine locals.\n"));
2085 block
= get_frame_block (frame
, 0);
2088 fprintf_filtered (stream
, "No symbol table info available.\n");
2092 cb_data
.frame_id
= get_frame_id (frame
);
2093 cb_data
.num_tabs
= 4 * num_tabs
;
2094 cb_data
.stream
= stream
;
2095 cb_data
.values_printed
= 0;
2097 iterate_over_block_local_vars (block
,
2098 do_print_variable_and_value
,
2101 /* do_print_variable_and_value invalidates FRAME. */
2104 if (!cb_data
.values_printed
)
2105 fprintf_filtered (stream
, _("No locals.\n"));
2109 locals_info (char *args
, int from_tty
)
2111 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2115 /* Iterate over all the argument variables in block B.
2117 Returns 1 if any argument was walked; 0 otherwise. */
2120 iterate_over_block_arg_vars (struct block
*b
,
2121 iterate_over_block_arg_local_vars_cb cb
,
2124 struct block_iterator iter
;
2125 struct symbol
*sym
, *sym2
;
2127 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2129 /* Don't worry about things which aren't arguments. */
2130 if (SYMBOL_IS_ARGUMENT (sym
))
2132 /* We have to look up the symbol because arguments can have
2133 two entries (one a parameter, one a local) and the one we
2134 want is the local, which lookup_symbol will find for us.
2135 This includes gcc1 (not gcc2) on the sparc when passing a
2136 small structure and gcc2 when the argument type is float
2137 and it is passed as a double and converted to float by
2138 the prologue (in the latter case the type of the LOC_ARG
2139 symbol is double and the type of the LOC_LOCAL symbol is
2140 float). There are also LOC_ARG/LOC_REGISTER pairs which
2141 are not combined in symbol-reading. */
2143 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2144 b
, VAR_DOMAIN
, NULL
);
2145 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2150 /* Print all argument variables of the function of FRAME.
2151 Print them with values to STREAM.
2153 This function will invalidate FRAME. */
2156 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2158 struct print_variable_and_value_data cb_data
;
2159 struct symbol
*func
;
2162 if (!get_frame_pc_if_available (frame
, &pc
))
2164 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2168 func
= get_frame_function (frame
);
2171 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2175 cb_data
.frame_id
= get_frame_id (frame
);
2176 cb_data
.num_tabs
= 0;
2177 cb_data
.stream
= gdb_stdout
;
2178 cb_data
.values_printed
= 0;
2180 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2181 do_print_variable_and_value
, &cb_data
);
2183 /* do_print_variable_and_value invalidates FRAME. */
2186 if (!cb_data
.values_printed
)
2187 fprintf_filtered (stream
, _("No arguments.\n"));
2191 args_info (char *ignore
, int from_tty
)
2193 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2199 args_plus_locals_info (char *ignore
, int from_tty
)
2201 args_info (ignore
, from_tty
);
2202 locals_info (ignore
, from_tty
);
2206 /* Select frame FRAME. Also print the stack frame and show the source
2207 if this is the tui version. */
2209 select_and_print_frame (struct frame_info
*frame
)
2211 select_frame (frame
);
2213 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2216 /* Return the symbol-block in which the selected frame is executing.
2217 Can return zero under various legitimate circumstances.
2219 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2220 code address within the block returned. We use this to decide
2221 which macros are in scope. */
2224 get_selected_block (CORE_ADDR
*addr_in_block
)
2226 if (!has_stack_frames ())
2229 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2232 /* Find a frame a certain number of levels away from FRAME.
2233 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2234 Positive means go to earlier frames (up); negative, the reverse.
2235 The int that contains the number of levels is counted toward
2236 zero as the frames for those levels are found.
2237 If the top or bottom frame is reached, that frame is returned,
2238 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2239 how much farther the original request asked to go. */
2242 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2244 /* Going up is simple: just call get_prev_frame enough times or
2245 until the initial frame is reached. */
2246 while (*level_offset_ptr
> 0)
2248 struct frame_info
*prev
= get_prev_frame (frame
);
2252 (*level_offset_ptr
)--;
2256 /* Going down is just as simple. */
2257 while (*level_offset_ptr
< 0)
2259 struct frame_info
*next
= get_next_frame (frame
);
2263 (*level_offset_ptr
)++;
2270 /* The "select_frame" command. With no argument this is a NOP.
2271 Select the frame at level LEVEL_EXP if it is a valid level.
2272 Otherwise, treat LEVEL_EXP as an address expression and select it.
2274 See parse_frame_specification for more info on proper frame
2278 select_frame_command (char *level_exp
, int from_tty
)
2280 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2283 /* The "frame" command. With no argument, print the selected frame
2284 briefly. With an argument, behave like select_frame and then print
2285 the selected frame. */
2288 frame_command (char *level_exp
, int from_tty
)
2290 select_frame_command (level_exp
, from_tty
);
2291 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2294 /* The XDB Compatibility command to print the current frame. */
2297 current_frame_command (char *level_exp
, int from_tty
)
2299 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
, 1);
2302 /* Select the frame up one or COUNT_EXP stack levels from the
2303 previously selected frame, and print it briefly. */
2306 up_silently_base (char *count_exp
)
2308 struct frame_info
*frame
;
2312 count
= parse_and_eval_long (count_exp
);
2314 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2315 if (count
!= 0 && count_exp
== NULL
)
2316 error (_("Initial frame selected; you cannot go up."));
2317 select_frame (frame
);
2321 up_silently_command (char *count_exp
, int from_tty
)
2323 up_silently_base (count_exp
);
2327 up_command (char *count_exp
, int from_tty
)
2329 up_silently_base (count_exp
);
2330 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2333 /* Select the frame down one or COUNT_EXP stack levels from the previously
2334 selected frame, and print it briefly. */
2337 down_silently_base (char *count_exp
)
2339 struct frame_info
*frame
;
2343 count
= -parse_and_eval_long (count_exp
);
2345 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2346 if (count
!= 0 && count_exp
== NULL
)
2348 /* We only do this if COUNT_EXP is not specified. That way
2349 "down" means to really go down (and let me know if that is
2350 impossible), but "down 9999" can be used to mean go all the
2351 way down without getting an error. */
2353 error (_("Bottom (innermost) frame selected; you cannot go down."));
2356 select_frame (frame
);
2360 down_silently_command (char *count_exp
, int from_tty
)
2362 down_silently_base (count_exp
);
2366 down_command (char *count_exp
, int from_tty
)
2368 down_silently_base (count_exp
);
2369 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2374 return_command (char *retval_exp
, int from_tty
)
2376 /* Initialize it just to avoid a GCC false warning. */
2377 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2378 struct frame_info
*thisframe
;
2379 struct gdbarch
*gdbarch
;
2380 struct symbol
*thisfun
;
2381 struct value
*return_value
= NULL
;
2382 struct value
*function
= NULL
;
2383 const char *query_prefix
= "";
2385 thisframe
= get_selected_frame ("No selected frame.");
2386 thisfun
= get_frame_function (thisframe
);
2387 gdbarch
= get_frame_arch (thisframe
);
2389 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2390 error (_("Can not force return from an inlined function."));
2392 /* Compute the return value. If the computation triggers an error,
2393 let it bail. If the return type can't be handled, set
2394 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2398 struct expression
*retval_expr
= parse_expression (retval_exp
);
2399 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2400 struct type
*return_type
= NULL
;
2402 /* Compute the return value. Should the computation fail, this
2403 call throws an error. */
2404 return_value
= evaluate_expression (retval_expr
);
2406 /* Cast return value to the return type of the function. Should
2407 the cast fail, this call throws an error. */
2408 if (thisfun
!= NULL
)
2409 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2410 if (return_type
== NULL
)
2412 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2413 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2414 error (_("Return value type not available for selected "
2416 "Please use an explicit cast of the value to return."));
2417 return_type
= value_type (return_value
);
2419 do_cleanups (old_chain
);
2420 CHECK_TYPEDEF (return_type
);
2421 return_value
= value_cast (return_type
, return_value
);
2423 /* Make sure the value is fully evaluated. It may live in the
2424 stack frame we're about to pop. */
2425 if (value_lazy (return_value
))
2426 value_fetch_lazy (return_value
);
2428 if (thisfun
!= NULL
)
2429 function
= read_var_value (thisfun
, thisframe
);
2431 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2432 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2433 /* If the return-type is "void", don't try to find the
2434 return-value's location. However, do still evaluate the
2435 return expression so that, even when the expression result
2436 is discarded, side effects such as "return i++" still
2438 return_value
= NULL
;
2439 else if (thisfun
!= NULL
)
2441 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2442 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2443 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2445 query_prefix
= "The location at which to store the "
2446 "function's return value is unknown.\n"
2447 "If you continue, the return value "
2448 "that you specified will be ignored.\n";
2449 return_value
= NULL
;
2454 /* Does an interactive user really want to do this? Include
2455 information, such as how well GDB can handle the return value, in
2456 the query message. */
2461 if (thisfun
== NULL
)
2462 confirmed
= query (_("%sMake selected stack frame return now? "),
2465 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2466 SYMBOL_PRINT_NAME (thisfun
));
2468 error (_("Not confirmed"));
2471 /* Discard the selected frame and all frames inner-to it. */
2472 frame_pop (get_selected_frame (NULL
));
2474 /* Store RETURN_VALUE in the just-returned register set. */
2475 if (return_value
!= NULL
)
2477 struct type
*return_type
= value_type (return_value
);
2478 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2480 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2481 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2482 gdbarch_return_value (gdbarch
, function
, return_type
,
2483 get_current_regcache (), NULL
/*read*/,
2484 value_contents (return_value
) /*write*/);
2487 /* If we are at the end of a call dummy now, pop the dummy frame
2489 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2490 frame_pop (get_current_frame ());
2492 /* If interactive, print the frame that is now current. */
2494 frame_command ("0", 1);
2496 select_frame_command ("0", 0);
2499 /* Sets the scope to input function name, provided that the function
2500 is within the current stack frame. */
2502 struct function_bounds
2504 CORE_ADDR low
, high
;
2508 func_command (char *arg
, int from_tty
)
2510 struct frame_info
*frame
;
2512 struct symtabs_and_lines sals
;
2515 struct function_bounds
*func_bounds
= NULL
;
2516 struct cleanup
*cleanups
;
2521 frame
= parse_frame_specification ("0");
2522 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2523 cleanups
= make_cleanup (xfree
, sals
.sals
);
2524 func_bounds
= (struct function_bounds
*) xmalloc (
2525 sizeof (struct function_bounds
) * sals
.nelts
);
2526 make_cleanup (xfree
, func_bounds
);
2527 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2529 if (sals
.sals
[i
].pspace
!= current_program_space
)
2530 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2531 else if (sals
.sals
[i
].pc
== 0
2532 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2533 &func_bounds
[i
].low
,
2534 &func_bounds
[i
].high
) == 0)
2536 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2542 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2543 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2544 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2548 frame
= find_relative_frame (frame
, &level
);
2551 while (!found
&& level
== 0);
2553 do_cleanups (cleanups
);
2556 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2557 else if (frame
!= get_selected_frame (NULL
))
2558 select_and_print_frame (frame
);
2561 /* Gets the language of the current frame. */
2564 get_frame_language (void)
2566 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2570 volatile struct gdb_exception ex
;
2574 /* We determine the current frame language by looking up its
2575 associated symtab. To retrieve this symtab, we use the frame
2576 PC. However we cannot use the frame PC as is, because it
2577 usually points to the instruction following the "call", which
2578 is sometimes the first instruction of another function. So
2579 we rely on get_frame_address_in_block(), it provides us with
2580 a PC that is guaranteed to be inside the frame's code
2583 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2585 pc
= get_frame_address_in_block (frame
);
2589 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2590 throw_exception (ex
);
2594 s
= find_pc_symtab (pc
);
2600 return language_unknown
;
2604 /* Provide a prototype to silence -Wmissing-prototypes. */
2605 void _initialize_stack (void);
2608 _initialize_stack (void)
2610 add_com ("return", class_stack
, return_command
, _("\
2611 Make selected stack frame return to its caller.\n\
2612 Control remains in the debugger, but when you continue\n\
2613 execution will resume in the frame above the one now selected.\n\
2614 If an argument is given, it is an expression for the value to return."));
2616 add_com ("up", class_stack
, up_command
, _("\
2617 Select and print stack frame that called this one.\n\
2618 An argument says how many frames up to go."));
2619 add_com ("up-silently", class_support
, up_silently_command
, _("\
2620 Same as the `up' command, but does not print anything.\n\
2621 This is useful in command scripts."));
2623 add_com ("down", class_stack
, down_command
, _("\
2624 Select and print stack frame called by this one.\n\
2625 An argument says how many frames down to go."));
2626 add_com_alias ("do", "down", class_stack
, 1);
2627 add_com_alias ("dow", "down", class_stack
, 1);
2628 add_com ("down-silently", class_support
, down_silently_command
, _("\
2629 Same as the `down' command, but does not print anything.\n\
2630 This is useful in command scripts."));
2632 add_com ("frame", class_stack
, frame_command
, _("\
2633 Select and print a stack frame.\nWith no argument, \
2634 print the selected stack frame. (See also \"info frame\").\n\
2635 An argument specifies the frame to select.\n\
2636 It can be a stack frame number or the address of the frame.\n\
2637 With argument, nothing is printed if input is coming from\n\
2638 a command file or a user-defined command."));
2640 add_com_alias ("f", "frame", class_stack
, 1);
2644 add_com ("L", class_stack
, current_frame_command
,
2645 _("Print the current stack frame.\n"));
2646 add_com_alias ("V", "frame", class_stack
, 1);
2648 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2649 Select a stack frame without printing anything.\n\
2650 An argument specifies the frame to select.\n\
2651 It can be a stack frame number or the address of the frame.\n"));
2653 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2654 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2655 With a negative argument, print outermost -COUNT frames.\nUse of the \
2656 'full' qualifier also prints the values of the local variables.\n\
2657 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2658 on this backtrace.\n"));
2659 add_com_alias ("bt", "backtrace", class_stack
, 0);
2662 add_com_alias ("t", "backtrace", class_stack
, 0);
2663 add_com ("T", class_stack
, backtrace_full_command
, _("\
2664 Print backtrace of all stack frames, or innermost COUNT frames\n\
2665 and the values of the local variables.\n\
2666 With a negative argument, print outermost -COUNT frames.\n\
2667 Usage: T <count>\n"));
2670 add_com_alias ("where", "backtrace", class_alias
, 0);
2671 add_info ("stack", backtrace_command
,
2672 _("Backtrace of the stack, or innermost COUNT frames."));
2673 add_info_alias ("s", "stack", 1);
2674 add_info ("frame", frame_info
,
2675 _("All about selected stack frame, or frame at ADDR."));
2676 add_info_alias ("f", "frame", 1);
2677 add_info ("locals", locals_info
,
2678 _("Local variables of current stack frame."));
2679 add_info ("args", args_info
,
2680 _("Argument variables of current stack frame."));
2682 add_com ("l", class_info
, args_plus_locals_info
,
2683 _("Argument and local variables of current stack frame."));
2686 add_com ("func", class_stack
, func_command
, _("\
2687 Select the stack frame that contains <func>.\n\
2688 Usage: func <name>\n"));
2690 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2691 print_frame_arguments_choices
, &print_frame_arguments
,
2692 _("Set printing of non-scalar frame arguments"),
2693 _("Show printing of non-scalar frame arguments"),
2694 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2696 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2697 &print_raw_frame_arguments
, _("\
2698 Set whether to print frame arguments in raw form."), _("\
2699 Show whether to print frame arguments in raw form."), _("\
2700 If set, frame arguments are printed in raw form, bypassing any\n\
2701 pretty-printers for that value."),
2703 &setprintrawlist
, &showprintrawlist
);
2705 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2706 &disassemble_next_line
, _("\
2707 Set whether to disassemble next source line or insn when execution stops."),
2709 Show whether to disassemble next source line or insn when execution stops."),
2711 If ON, GDB will display disassembly of the next source line, in addition\n\
2712 to displaying the source line itself. If the next source line cannot\n\
2713 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2714 will display disassembly of next instruction instead of showing the\n\
2716 If AUTO, display disassembly of next instruction only if the source line\n\
2717 cannot be displayed.\n\
2718 If OFF (which is the default), never display the disassembly of the next\n\
2721 show_disassemble_next_line
,
2722 &setlist
, &showlist
);
2723 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2725 add_setshow_enum_cmd ("entry-values", class_stack
,
2726 print_entry_values_choices
, &print_entry_values
,
2727 _("Set printing of function arguments at function "
2729 _("Show printing of function arguments at function "
2732 GDB can sometimes determine the values of function arguments at entry,\n\
2733 in addition to their current values. This option tells GDB whether\n\
2734 to print the current value, the value at entry (marked as val@entry),\n\
2735 or both. Note that one or both of these values may be <optimized out>."),
2736 NULL
, NULL
, &setprintlist
, &showprintlist
);