1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
56 #include "python/python.h"
58 void (*deprecated_selected_frame_level_changed_hook
) (int);
60 /* The possible choices of "set print frame-arguments", and the value
63 static const char *const print_frame_arguments_choices
[] =
64 {"all", "scalars", "none", NULL
};
65 static const char *print_frame_arguments
= "scalars";
67 /* If non-zero, don't invoke pretty-printers for frame arguments. */
68 static int print_raw_frame_arguments
;
70 /* The possible choices of "set print entry-values", and the value
73 const char print_entry_values_no
[] = "no";
74 const char print_entry_values_only
[] = "only";
75 const char print_entry_values_preferred
[] = "preferred";
76 const char print_entry_values_if_needed
[] = "if-needed";
77 const char print_entry_values_both
[] = "both";
78 const char print_entry_values_compact
[] = "compact";
79 const char print_entry_values_default
[] = "default";
80 static const char *const print_entry_values_choices
[] =
82 print_entry_values_no
,
83 print_entry_values_only
,
84 print_entry_values_preferred
,
85 print_entry_values_if_needed
,
86 print_entry_values_both
,
87 print_entry_values_compact
,
88 print_entry_values_default
,
91 const char *print_entry_values
= print_entry_values_default
;
93 /* Prototypes for local functions. */
95 static void print_frame_local_vars (struct frame_info
*, int,
98 static void print_frame (struct frame_info
*frame
, int print_level
,
99 enum print_what print_what
, int print_args
,
100 struct symtab_and_line sal
);
102 static void set_last_displayed_sal (int valid
,
103 struct program_space
*pspace
,
105 struct symtab
*symtab
,
108 /* Zero means do things normally; we are interacting directly with the
109 user. One means print the full filename and linenumber when a
110 frame is printed, and do so in a format emacs18/emacs19.22 can
111 parse. Two means print similar annotations, but in many more
112 cases and in a slightly different syntax. */
114 int annotation_level
= 0;
116 /* These variables hold the last symtab and line we displayed to the user.
117 * This is where we insert a breakpoint or a skiplist entry by default. */
118 static int last_displayed_sal_valid
= 0;
119 static struct program_space
*last_displayed_pspace
= 0;
120 static CORE_ADDR last_displayed_addr
= 0;
121 static struct symtab
*last_displayed_symtab
= 0;
122 static int last_displayed_line
= 0;
125 /* Return 1 if we should display the address in addition to the location,
126 because we are in the middle of a statement. */
129 frame_show_address (struct frame_info
*frame
,
130 struct symtab_and_line sal
)
132 /* If there is a line number, but no PC, then there is no location
133 information associated with this sal. The only way that should
134 happen is for the call sites of inlined functions (SAL comes from
135 find_frame_sal). Otherwise, we would have some PC range if the
136 SAL came from a line table. */
137 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
139 if (get_next_frame (frame
) == NULL
)
140 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
142 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
146 return get_frame_pc (frame
) != sal
.pc
;
149 /* Show or print a stack frame FRAME briefly. The output is format
150 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
151 relative level, function name, argument list, and file name and
152 line number. If the frame's PC is not at the beginning of the
153 source line, the actual PC is printed at the beginning. */
156 print_stack_frame (struct frame_info
*frame
, int print_level
,
157 enum print_what print_what
)
159 volatile struct gdb_exception e
;
161 /* For mi, alway print location and address. */
162 if (ui_out_is_mi_like_p (current_uiout
))
163 print_what
= LOC_AND_ADDRESS
;
165 TRY_CATCH (e
, RETURN_MASK_ERROR
)
167 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
169 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
170 set_current_sal_from_frame (frame
, center
);
174 /* Print nameless arguments of frame FRAME on STREAM, where START is
175 the offset of the first nameless argument, and NUM is the number of
176 nameless arguments to print. FIRST is nonzero if this is the first
177 argument (not just the first nameless argument). */
180 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
181 int first
, struct ui_file
*stream
)
183 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
184 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
189 for (i
= 0; i
< num
; i
++)
192 argsaddr
= get_frame_args_address (frame
);
195 arg_value
= read_memory_integer (argsaddr
+ start
,
196 sizeof (int), byte_order
);
198 fprintf_filtered (stream
, ", ");
199 fprintf_filtered (stream
, "%ld", arg_value
);
201 start
+= sizeof (int);
205 /* Print single argument of inferior function. ARG must be already
208 Errors are printed as if they would be the parameter value. Use zeroed ARG
209 iff it should not be printed accoring to user settings. */
212 print_frame_arg (const struct frame_arg
*arg
)
214 struct ui_out
*uiout
= current_uiout
;
215 volatile struct gdb_exception except
;
216 struct cleanup
*old_chain
;
219 stb
= mem_fileopen ();
220 old_chain
= make_cleanup_ui_file_delete (stb
);
222 gdb_assert (!arg
->val
|| !arg
->error
);
223 gdb_assert (arg
->entry_kind
== print_entry_values_no
224 || arg
->entry_kind
== print_entry_values_only
225 || (!ui_out_is_mi_like_p (uiout
)
226 && arg
->entry_kind
== print_entry_values_compact
));
228 annotate_arg_begin ();
230 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
231 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
232 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
233 if (arg
->entry_kind
== print_entry_values_compact
)
235 /* It is OK to provide invalid MI-like stream as with
236 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
237 fputs_filtered ("=", stb
);
239 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
240 SYMBOL_LANGUAGE (arg
->sym
),
241 DMGL_PARAMS
| DMGL_ANSI
);
243 if (arg
->entry_kind
== print_entry_values_only
244 || arg
->entry_kind
== print_entry_values_compact
)
245 fputs_filtered ("@entry", stb
);
246 ui_out_field_stream (uiout
, "name", stb
);
247 annotate_arg_name_end ();
248 ui_out_text (uiout
, "=");
250 if (!arg
->val
&& !arg
->error
)
251 ui_out_text (uiout
, "...");
255 except
.message
= arg
->error
;
258 /* TRY_CATCH has two statements, wrap it in a block. */
260 TRY_CATCH (except
, RETURN_MASK_ERROR
)
262 const struct language_defn
*language
;
263 struct value_print_options opts
;
265 /* Avoid value_print because it will deref ref parameters. We
266 just want to print their addresses. Print ??? for args whose
267 address we do not know. We pass 2 as "recurse" to val_print
268 because our standard indentation here is 4 spaces, and
269 val_print indents 2 for each recurse. */
271 annotate_arg_value (value_type (arg
->val
));
273 /* Use the appropriate language to display our symbol, unless the
274 user forced the language to a specific language. */
275 if (language_mode
== language_mode_auto
)
276 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
278 language
= current_language
;
280 get_no_prettyformat_print_options (&opts
);
282 opts
.raw
= print_raw_frame_arguments
;
284 /* True in "summary" mode, false otherwise. */
285 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
287 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
291 fprintf_filtered (stb
, _("<error reading variable: %s>"),
295 ui_out_field_stream (uiout
, "value", stb
);
297 /* Also invoke ui_out_tuple_end. */
298 do_cleanups (old_chain
);
303 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
304 responsible for xfree of ARGP->ERROR. This function never throws an
308 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
309 struct frame_arg
*argp
)
311 volatile struct gdb_exception except
;
312 struct value
*val
= NULL
;
314 TRY_CATCH (except
, RETURN_MASK_ERROR
)
316 val
= read_var_value (sym
, frame
);
319 argp
->error
= (val
== NULL
) ? xstrdup (except
.message
) : NULL
;
324 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
325 responsible for xfree of ARGP->ERROR. This function never throws an
329 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
330 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
332 struct value
*val
= NULL
, *entryval
= NULL
;
333 char *val_error
= NULL
, *entryval_error
= NULL
;
335 volatile struct gdb_exception except
;
337 if (print_entry_values
!= print_entry_values_only
338 && print_entry_values
!= print_entry_values_preferred
)
340 TRY_CATCH (except
, RETURN_MASK_ERROR
)
342 val
= read_var_value (sym
, frame
);
346 val_error
= alloca (strlen (except
.message
) + 1);
347 strcpy (val_error
, except
.message
);
351 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
352 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
353 && print_entry_values
!= print_entry_values_no
354 && (print_entry_values
!= print_entry_values_if_needed
355 || !val
|| value_optimized_out (val
)))
357 TRY_CATCH (except
, RETURN_MASK_ERROR
)
359 const struct symbol_computed_ops
*ops
;
361 ops
= SYMBOL_COMPUTED_OPS (sym
);
362 entryval
= ops
->read_variable_at_entry (sym
, frame
);
366 entryval_error
= alloca (strlen (except
.message
) + 1);
367 strcpy (entryval_error
, except
.message
);
370 if (except
.error
== NO_ENTRY_VALUE_ERROR
371 || (entryval
&& value_optimized_out (entryval
)))
374 entryval_error
= NULL
;
377 if (print_entry_values
== print_entry_values_compact
378 || print_entry_values
== print_entry_values_default
)
380 /* For MI do not try to use print_entry_values_compact for ARGP. */
382 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
384 struct type
*type
= value_type (val
);
386 if (!value_optimized_out (val
)
387 && value_available_contents_eq (val
, 0, entryval
, 0,
390 /* Initialize it just to avoid a GCC false warning. */
391 struct value
*val_deref
= NULL
, *entryval_deref
;
393 /* DW_AT_GNU_call_site_value does match with the current
394 value. If it is a reference still try to verify if
395 dereferenced DW_AT_GNU_call_site_data_value does not
398 TRY_CATCH (except
, RETURN_MASK_ERROR
)
400 struct type
*type_deref
;
402 val_deref
= coerce_ref (val
);
403 if (value_lazy (val_deref
))
404 value_fetch_lazy (val_deref
);
405 type_deref
= value_type (val_deref
);
407 entryval_deref
= coerce_ref (entryval
);
408 if (value_lazy (entryval_deref
))
409 value_fetch_lazy (entryval_deref
);
411 /* If the reference addresses match but dereferenced
412 content does not match print them. */
414 && value_available_contents_eq (val_deref
, 0,
416 TYPE_LENGTH (type_deref
)))
420 /* Value was not a reference; and its content matches. */
421 if (val
== val_deref
)
423 /* If the dereferenced content could not be fetched do not
425 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
427 else if (except
.message
)
429 entryval_error
= alloca (strlen (except
.message
) + 1);
430 strcpy (entryval_error
, except
.message
);
438 /* Try to remove possibly duplicate error message for ENTRYARGP even
441 if (val_error
&& entryval_error
442 && strcmp (val_error
, entryval_error
) == 0)
444 entryval_error
= NULL
;
446 /* Do not se VAL_EQUAL as the same error message may be shown for
447 the entry value even if no entry values are present in the
453 if (entryval
== NULL
)
455 if (print_entry_values
== print_entry_values_preferred
)
457 TRY_CATCH (except
, RETURN_MASK_ERROR
)
459 val
= read_var_value (sym
, frame
);
463 val_error
= alloca (strlen (except
.message
) + 1);
464 strcpy (val_error
, except
.message
);
467 if (print_entry_values
== print_entry_values_only
468 || print_entry_values
== print_entry_values_both
469 || (print_entry_values
== print_entry_values_preferred
470 && (!val
|| value_optimized_out (val
))))
472 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
473 entryval_error
= NULL
;
476 if ((print_entry_values
== print_entry_values_compact
477 || print_entry_values
== print_entry_values_if_needed
478 || print_entry_values
== print_entry_values_preferred
)
479 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
487 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
488 if (!val
&& !val_error
)
489 argp
->entry_kind
= print_entry_values_only
;
490 else if ((print_entry_values
== print_entry_values_compact
491 || print_entry_values
== print_entry_values_default
) && val_equal
)
493 argp
->entry_kind
= print_entry_values_compact
;
494 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
497 argp
->entry_kind
= print_entry_values_no
;
499 entryargp
->sym
= sym
;
500 entryargp
->val
= entryval
;
501 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
502 if (!entryval
&& !entryval_error
)
503 entryargp
->entry_kind
= print_entry_values_no
;
505 entryargp
->entry_kind
= print_entry_values_only
;
508 /* Print the arguments of frame FRAME on STREAM, given the function
509 FUNC running in that frame (as a symbol), where NUM is the number
510 of arguments according to the stack frame (or -1 if the number of
511 arguments is unknown). */
513 /* Note that currently the "number of arguments according to the
514 stack frame" is only known on VAX where i refers to the "number of
515 ints of arguments according to the stack frame". */
518 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
519 int num
, struct ui_file
*stream
)
521 struct ui_out
*uiout
= current_uiout
;
523 /* Offset of next stack argument beyond the one we have seen that is
524 at the highest offset, or -1 if we haven't come to a stack
526 long highest_offset
= -1;
527 /* Number of ints of arguments that we have printed so far. */
528 int args_printed
= 0;
529 struct cleanup
*old_chain
;
531 /* True if we should print arguments, false otherwise. */
532 int print_args
= strcmp (print_frame_arguments
, "none");
534 stb
= mem_fileopen ();
535 old_chain
= make_cleanup_ui_file_delete (stb
);
539 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
540 struct block_iterator iter
;
543 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
545 struct frame_arg arg
, entryarg
;
549 /* Keep track of the highest stack argument offset seen, and
550 skip over any kinds of symbols we don't care about. */
552 if (!SYMBOL_IS_ARGUMENT (sym
))
555 switch (SYMBOL_CLASS (sym
))
560 long current_offset
= SYMBOL_VALUE (sym
);
561 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
563 /* Compute address of next argument by adding the size of
564 this argument and rounding to an int boundary. */
566 ((current_offset
+ arg_size
+ sizeof (int) - 1)
567 & ~(sizeof (int) - 1));
569 /* If this is the highest offset seen yet, set
571 if (highest_offset
== -1
572 || (current_offset
> highest_offset
))
573 highest_offset
= current_offset
;
575 /* Add the number of ints we're about to print to
577 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
580 /* We care about types of symbols, but don't need to
581 keep track of stack offsets in them. */
583 case LOC_REGPARM_ADDR
:
585 case LOC_OPTIMIZED_OUT
:
590 /* We have to look up the symbol because arguments can have
591 two entries (one a parameter, one a local) and the one we
592 want is the local, which lookup_symbol will find for us.
593 This includes gcc1 (not gcc2) on SPARC when passing a
594 small structure and gcc2 when the argument type is float
595 and it is passed as a double and converted to float by
596 the prologue (in the latter case the type of the LOC_ARG
597 symbol is double and the type of the LOC_LOCAL symbol is
599 /* But if the parameter name is null, don't try it. Null
600 parameter names occur on the RS/6000, for traceback
601 tables. FIXME, should we even print them? */
603 if (*SYMBOL_LINKAGE_NAME (sym
))
607 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
608 b
, VAR_DOMAIN
, NULL
);
609 gdb_assert (nsym
!= NULL
);
610 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
611 && !SYMBOL_IS_ARGUMENT (nsym
))
613 /* There is a LOC_ARG/LOC_REGISTER pair. This means
614 that it was passed on the stack and loaded into a
615 register, or passed in a register and stored in a
616 stack slot. GDB 3.x used the LOC_ARG; GDB
617 4.0-4.11 used the LOC_REGISTER.
619 Reasons for using the LOC_ARG:
621 (1) Because find_saved_registers may be slow for
624 (2) Because registers are often re-used and stack
625 slots rarely (never?) are. Therefore using
626 the stack slot is much less likely to print
629 Reasons why we might want to use the LOC_REGISTER:
631 (1) So that the backtrace prints the same value
632 as "print foo". I see no compelling reason
633 why this needs to be the case; having the
634 backtrace print the value which was passed
635 in, and "print foo" print the value as
636 modified within the called function, makes
639 Additional note: It might be nice if "info args"
640 displayed both values.
642 One more note: There is a case with SPARC
643 structure passing where we need to use the
644 LOC_REGISTER, but this is dealt with by creating
645 a single LOC_REGPARM in symbol reading. */
647 /* Leave sym (the LOC_ARG) alone. */
654 /* Print the current arg. */
656 ui_out_text (uiout
, ", ");
657 ui_out_wrap_hint (uiout
, " ");
661 memset (&arg
, 0, sizeof (arg
));
663 arg
.entry_kind
= print_entry_values_no
;
664 memset (&entryarg
, 0, sizeof (entryarg
));
666 entryarg
.entry_kind
= print_entry_values_no
;
669 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
671 if (arg
.entry_kind
!= print_entry_values_only
)
672 print_frame_arg (&arg
);
674 if (entryarg
.entry_kind
!= print_entry_values_no
)
676 if (arg
.entry_kind
!= print_entry_values_only
)
678 ui_out_text (uiout
, ", ");
679 ui_out_wrap_hint (uiout
, " ");
682 print_frame_arg (&entryarg
);
686 xfree (entryarg
.error
);
692 /* Don't print nameless args in situations where we don't know
693 enough about the stack to find them. */
698 if (highest_offset
== -1)
699 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
701 start
= highest_offset
;
703 print_frame_nameless_args (frame
, start
, num
- args_printed
,
707 do_cleanups (old_chain
);
710 /* Set the current source and line to the location given by frame
711 FRAME, if possible. When CENTER is true, adjust so the relevant
712 line is in the center of the next 'list'. */
715 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
717 struct symtab_and_line sal
;
719 find_frame_sal (frame
, &sal
);
723 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
724 set_current_source_symtab_and_line (&sal
);
728 /* If ON, GDB will display disassembly of the next source line when
729 execution of the program being debugged stops.
730 If AUTO (which is the default), or there's no line info to determine
731 the source line of the next instruction, display disassembly of next
732 instruction instead. */
734 static enum auto_boolean disassemble_next_line
;
737 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
738 struct cmd_list_element
*c
,
741 fprintf_filtered (file
,
742 _("Debugger's willingness to use "
743 "disassemble-next-line is %s.\n"),
747 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
748 because it will be broken by filter sometime. */
751 do_gdb_disassembly (struct gdbarch
*gdbarch
,
752 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
754 volatile struct gdb_exception exception
;
756 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
758 gdb_disassembly (gdbarch
, current_uiout
, 0,
759 DISASSEMBLY_RAW_INSN
, how_many
,
762 if (exception
.reason
< 0)
764 /* If an exception was thrown while doing the disassembly, print
765 the error message, to give the user a clue of what happened. */
766 exception_print (gdb_stderr
, exception
);
770 /* Print information about frame FRAME. The output is format according
771 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
774 SRC_LINE: Print only source line.
775 LOCATION: Print only location.
776 LOC_AND_SRC: Print location and source line.
778 Used in "where" output, and to emit breakpoint or step
782 print_frame_info (struct frame_info
*frame
, int print_level
,
783 enum print_what print_what
, int print_args
)
785 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
786 struct symtab_and_line sal
;
789 struct ui_out
*uiout
= current_uiout
;
791 if (get_frame_type (frame
) == DUMMY_FRAME
792 || get_frame_type (frame
) == SIGTRAMP_FRAME
793 || get_frame_type (frame
) == ARCH_FRAME
)
795 struct cleanup
*uiout_cleanup
796 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
798 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
799 gdbarch
, get_frame_pc (frame
));
801 /* Do this regardless of SOURCE because we don't have any source
802 to list for this frame. */
805 ui_out_text (uiout
, "#");
806 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
807 frame_relative_level (frame
));
809 if (ui_out_is_mi_like_p (uiout
))
811 annotate_frame_address ();
812 ui_out_field_core_addr (uiout
, "addr",
813 gdbarch
, get_frame_pc (frame
));
814 annotate_frame_address_end ();
817 if (get_frame_type (frame
) == DUMMY_FRAME
)
819 annotate_function_call ();
820 ui_out_field_string (uiout
, "func", "<function called from gdb>");
822 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
824 annotate_signal_handler_caller ();
825 ui_out_field_string (uiout
, "func", "<signal handler called>");
827 else if (get_frame_type (frame
) == ARCH_FRAME
)
829 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
831 ui_out_text (uiout
, "\n");
832 annotate_frame_end ();
834 do_cleanups (uiout_cleanup
);
838 /* If FRAME is not the innermost frame, that normally means that
839 FRAME->pc points to *after* the call instruction, and we want to
840 get the line containing the call, never the next line. But if
841 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
842 next frame was not entered as the result of a call, and we want
843 to get the line containing FRAME->pc. */
844 find_frame_sal (frame
, &sal
);
846 location_print
= (print_what
== LOCATION
847 || print_what
== LOC_AND_ADDRESS
848 || print_what
== SRC_AND_LOC
);
850 if (location_print
|| !sal
.symtab
)
851 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
853 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
855 /* If disassemble-next-line is set to auto or on and doesn't have
856 the line debug messages for $pc, output the next instruction. */
857 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
858 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
859 && source_print
&& !sal
.symtab
)
860 do_gdb_disassembly (get_frame_arch (frame
), 1,
861 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
863 if (source_print
&& sal
.symtab
)
866 int mid_statement
= ((print_what
== SRC_LINE
)
867 && frame_show_address (frame
, sal
));
869 if (annotation_level
)
870 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
871 get_frame_pc (frame
));
874 if (deprecated_print_frame_info_listing_hook
)
875 deprecated_print_frame_info_listing_hook (sal
.symtab
,
880 struct value_print_options opts
;
882 get_user_print_options (&opts
);
883 /* We used to do this earlier, but that is clearly
884 wrong. This function is used by many different
885 parts of gdb, including normal_stop in infrun.c,
886 which uses this to print out the current PC
887 when we stepi/nexti into the middle of a source
888 line. Only the command line really wants this
889 behavior. Other UIs probably would like the
890 ability to decide for themselves if it is desired. */
891 if (opts
.addressprint
&& mid_statement
)
893 ui_out_field_core_addr (uiout
, "addr",
894 gdbarch
, get_frame_pc (frame
));
895 ui_out_text (uiout
, "\t");
898 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
902 /* If disassemble-next-line is set to on and there is line debug
903 messages, output assembly codes for next line. */
904 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
905 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
908 if (print_what
!= LOCATION
)
912 if (get_frame_pc_if_available (frame
, &pc
))
913 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
915 set_last_displayed_sal (0, 0, 0, 0, 0);
918 annotate_frame_end ();
920 gdb_flush (gdb_stdout
);
923 /* Remember the last symtab and line we displayed, which we use e.g.
924 * as the place to put a breakpoint when the `break' command is
925 * invoked with no arguments. */
928 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
929 CORE_ADDR addr
, struct symtab
*symtab
,
932 last_displayed_sal_valid
= valid
;
933 last_displayed_pspace
= pspace
;
934 last_displayed_addr
= addr
;
935 last_displayed_symtab
= symtab
;
936 last_displayed_line
= line
;
937 if (valid
&& pspace
== NULL
)
939 clear_last_displayed_sal ();
940 internal_error (__FILE__
, __LINE__
,
941 _("Trying to set NULL pspace."));
945 /* Forget the last sal we displayed. */
948 clear_last_displayed_sal (void)
950 last_displayed_sal_valid
= 0;
951 last_displayed_pspace
= 0;
952 last_displayed_addr
= 0;
953 last_displayed_symtab
= 0;
954 last_displayed_line
= 0;
957 /* Is our record of the last sal we displayed valid? If not,
958 * the get_last_displayed_* functions will return NULL or 0, as
962 last_displayed_sal_is_valid (void)
964 return last_displayed_sal_valid
;
967 /* Get the pspace of the last sal we displayed, if it's valid. */
969 struct program_space
*
970 get_last_displayed_pspace (void)
972 if (last_displayed_sal_valid
)
973 return last_displayed_pspace
;
977 /* Get the address of the last sal we displayed, if it's valid. */
980 get_last_displayed_addr (void)
982 if (last_displayed_sal_valid
)
983 return last_displayed_addr
;
987 /* Get the symtab of the last sal we displayed, if it's valid. */
990 get_last_displayed_symtab (void)
992 if (last_displayed_sal_valid
)
993 return last_displayed_symtab
;
997 /* Get the line of the last sal we displayed, if it's valid. */
1000 get_last_displayed_line (void)
1002 if (last_displayed_sal_valid
)
1003 return last_displayed_line
;
1007 /* Get the last sal we displayed, if it's valid. */
1010 get_last_displayed_sal (struct symtab_and_line
*sal
)
1012 if (last_displayed_sal_valid
)
1014 sal
->pspace
= last_displayed_pspace
;
1015 sal
->pc
= last_displayed_addr
;
1016 sal
->symtab
= last_displayed_symtab
;
1017 sal
->line
= last_displayed_line
;
1029 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1030 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1033 find_frame_funname (struct frame_info
*frame
, char **funname
,
1034 enum language
*funlang
, struct symbol
**funcp
)
1036 struct symbol
*func
;
1039 *funlang
= language_unknown
;
1043 func
= get_frame_function (frame
);
1046 /* In certain pathological cases, the symtabs give the wrong
1047 function (when we are in the first function in a file which
1048 is compiled without debugging symbols, the previous function
1049 is compiled with debugging symbols, and the "foo.o" symbol
1050 that is supposed to tell us where the file with debugging
1051 symbols ends has been truncated by ar because it is longer
1052 than 15 characters). This also occurs if the user uses asm()
1053 to create a function but not stabs for it (in a file compiled
1056 So look in the minimal symbol tables as well, and if it comes
1057 up with a larger address for the function use that instead.
1058 I don't think this can ever cause any problems; there
1059 shouldn't be any minimal symbols in the middle of a function;
1060 if this is ever changed many parts of GDB will need to be
1061 changed (and we'll create a find_pc_minimal_function or some
1064 struct bound_minimal_symbol msymbol
;
1066 /* Don't attempt to do this for inlined functions, which do not
1067 have a corresponding minimal symbol. */
1068 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1070 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1072 memset (&msymbol
, 0, sizeof (msymbol
));
1074 if (msymbol
.minsym
!= NULL
1075 && (SYMBOL_VALUE_ADDRESS (msymbol
.minsym
)
1076 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1078 /* We also don't know anything about the function besides
1079 its address and name. */
1081 *funname
= xstrdup (SYMBOL_PRINT_NAME (msymbol
.minsym
));
1082 *funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1086 *funname
= xstrdup (SYMBOL_PRINT_NAME (func
));
1087 *funlang
= SYMBOL_LANGUAGE (func
);
1090 if (*funlang
== language_cplus
)
1092 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1093 to display the demangled name that we already have
1094 stored in the symbol table, but we stored a version
1095 with DMGL_PARAMS turned on, and here we don't want to
1096 display parameters. So remove the parameters. */
1097 char *func_only
= cp_remove_params (*funname
);
1102 *funname
= func_only
;
1109 struct bound_minimal_symbol msymbol
;
1112 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1115 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1116 if (msymbol
.minsym
!= NULL
)
1118 *funname
= xstrdup (SYMBOL_PRINT_NAME (msymbol
.minsym
));
1119 *funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1125 print_frame (struct frame_info
*frame
, int print_level
,
1126 enum print_what print_what
, int print_args
,
1127 struct symtab_and_line sal
)
1129 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1130 struct ui_out
*uiout
= current_uiout
;
1131 char *funname
= NULL
;
1132 enum language funlang
= language_unknown
;
1133 struct ui_file
*stb
;
1134 struct cleanup
*old_chain
, *list_chain
;
1135 struct value_print_options opts
;
1136 struct symbol
*func
;
1140 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1142 stb
= mem_fileopen ();
1143 old_chain
= make_cleanup_ui_file_delete (stb
);
1145 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1146 make_cleanup (xfree
, funname
);
1148 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1151 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1155 ui_out_text (uiout
, "#");
1156 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1157 frame_relative_level (frame
));
1159 get_user_print_options (&opts
);
1160 if (opts
.addressprint
)
1162 || frame_show_address (frame
, sal
)
1163 || print_what
== LOC_AND_ADDRESS
)
1165 annotate_frame_address ();
1167 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1169 ui_out_field_string (uiout
, "addr", "<unavailable>");
1170 annotate_frame_address_end ();
1171 ui_out_text (uiout
, " in ");
1173 annotate_frame_function_name ();
1174 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1175 funlang
, DMGL_ANSI
);
1176 ui_out_field_stream (uiout
, "func", stb
);
1177 ui_out_wrap_hint (uiout
, " ");
1178 annotate_frame_args ();
1180 ui_out_text (uiout
, " (");
1183 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1185 struct cleanup
*args_list_chain
;
1186 volatile struct gdb_exception e
;
1188 if (gdbarch_frame_num_args_p (gdbarch
))
1190 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1191 gdb_assert (numargs
>= 0);
1196 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1197 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1199 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1201 /* FIXME: ARGS must be a list. If one argument is a string it
1202 will have " that will not be properly escaped. */
1203 /* Invoke ui_out_tuple_end. */
1204 do_cleanups (args_list_chain
);
1207 ui_out_text (uiout
, ")");
1210 const char *filename_display
;
1212 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1213 annotate_frame_source_begin ();
1214 ui_out_wrap_hint (uiout
, " ");
1215 ui_out_text (uiout
, " at ");
1216 annotate_frame_source_file ();
1217 ui_out_field_string (uiout
, "file", filename_display
);
1218 if (ui_out_is_mi_like_p (uiout
))
1220 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1222 ui_out_field_string (uiout
, "fullname", fullname
);
1224 annotate_frame_source_file_end ();
1225 ui_out_text (uiout
, ":");
1226 annotate_frame_source_line ();
1227 ui_out_field_int (uiout
, "line", sal
.line
);
1228 annotate_frame_source_end ();
1231 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1233 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1234 get_frame_pc (frame
));
1238 annotate_frame_where ();
1239 ui_out_wrap_hint (uiout
, " ");
1240 ui_out_text (uiout
, " from ");
1241 ui_out_field_string (uiout
, "from", lib
);
1245 /* do_cleanups will call ui_out_tuple_end() for us. */
1246 do_cleanups (list_chain
);
1247 ui_out_text (uiout
, "\n");
1248 do_cleanups (old_chain
);
1252 /* Read a frame specification in whatever the appropriate format is
1253 from FRAME_EXP. Call error(), printing MESSAGE, if the
1254 specification is in any way invalid (so this function never returns
1255 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1256 the default selected frame was used. */
1258 static struct frame_info
*
1259 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1260 int *selected_frame_p
)
1263 struct value
*args
[4];
1264 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1266 if (frame_exp
== NULL
)
1274 struct cleanup
*cleanup
;
1277 /* Skip leading white space, bail of EOL. */
1278 frame_exp
= skip_spaces_const (frame_exp
);
1282 /* Parse the argument, extract it, save it. */
1284 *p
&& !isspace (*p
);
1286 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1288 cleanup
= make_cleanup (xfree
, addr_string
);
1290 /* NOTE: Parse and evaluate expression, but do not use
1291 functions such as parse_and_eval_long or
1292 parse_and_eval_address to also extract the value.
1293 Instead value_as_long and value_as_address are used.
1294 This avoids problems with expressions that contain
1296 if (numargs
>= ARRAY_SIZE (args
))
1297 error (_("Too many args in frame specification"));
1298 args
[numargs
++] = parse_and_eval (addr_string
);
1300 do_cleanups (cleanup
);
1304 /* If no args, default to the selected frame. */
1307 if (selected_frame_p
!= NULL
)
1308 (*selected_frame_p
) = 1;
1309 return get_selected_frame (message
);
1312 /* None of the remaining use the selected frame. */
1313 if (selected_frame_p
!= NULL
)
1314 (*selected_frame_p
) = 0;
1316 /* Assume the single arg[0] is an integer, and try using that to
1317 select a frame relative to current. */
1320 struct frame_info
*fid
;
1321 int level
= value_as_long (args
[0]);
1323 fid
= find_relative_frame (get_current_frame (), &level
);
1325 /* find_relative_frame was successful. */
1329 /* Convert each value into a corresponding address. */
1333 for (i
= 0; i
< numargs
; i
++)
1334 addrs
[i
] = value_as_address (args
[i
]);
1337 /* Assume that the single arg[0] is an address, use that to identify
1338 a frame with a matching ID. Should this also accept stack/pc or
1339 stack/pc/special. */
1342 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1343 struct frame_info
*fid
;
1345 /* If (s)he specifies the frame with an address, he deserves
1346 what (s)he gets. Still, give the highest one that matches.
1347 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1349 for (fid
= get_current_frame ();
1351 fid
= get_prev_frame (fid
))
1353 if (frame_id_eq (id
, get_frame_id (fid
)))
1355 struct frame_info
*prev_frame
;
1359 prev_frame
= get_prev_frame (fid
);
1361 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1370 /* We couldn't identify the frame as an existing frame, but
1371 perhaps we can create one with a single argument. */
1373 return create_new_frame (addrs
[0], 0);
1374 else if (numargs
== 2)
1375 return create_new_frame (addrs
[0], addrs
[1]);
1377 error (_("Too many args in frame specification"));
1380 static struct frame_info
*
1381 parse_frame_specification (char *frame_exp
)
1383 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1386 /* Print verbosely the selected frame or the frame at address
1387 ADDR_EXP. Absolutely all information in the frame is printed. */
1390 frame_info (char *addr_exp
, int from_tty
)
1392 struct frame_info
*fi
;
1393 struct symtab_and_line sal
;
1394 struct symbol
*func
;
1396 struct frame_info
*calling_frame_info
;
1398 const char *funname
= 0;
1399 enum language funlang
= language_unknown
;
1400 const char *pc_regname
;
1401 int selected_frame_p
;
1402 struct gdbarch
*gdbarch
;
1403 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1406 CORE_ADDR caller_pc
;
1408 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1409 gdbarch
= get_frame_arch (fi
);
1411 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1412 is not a good name. */
1413 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1414 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1415 easily not match that of the internal value returned by
1417 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1419 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1420 architectures will often have a hardware register called "pc",
1421 and that register's value, again, can easily not match
1425 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1426 find_frame_sal (fi
, &sal
);
1427 func
= get_frame_function (fi
);
1431 funname
= SYMBOL_PRINT_NAME (func
);
1432 funlang
= SYMBOL_LANGUAGE (func
);
1433 if (funlang
== language_cplus
)
1435 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1436 to display the demangled name that we already have
1437 stored in the symbol table, but we stored a version
1438 with DMGL_PARAMS turned on, and here we don't want to
1439 display parameters. So remove the parameters. */
1440 char *func_only
= cp_remove_params (funname
);
1444 funname
= func_only
;
1445 make_cleanup (xfree
, func_only
);
1449 else if (frame_pc_p
)
1451 struct bound_minimal_symbol msymbol
;
1453 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1454 if (msymbol
.minsym
!= NULL
)
1456 funname
= SYMBOL_PRINT_NAME (msymbol
.minsym
);
1457 funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1460 calling_frame_info
= get_prev_frame (fi
);
1462 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1464 printf_filtered (_("Stack level %d, frame at "),
1465 frame_relative_level (fi
));
1469 printf_filtered (_("Stack frame at "));
1471 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1472 printf_filtered (":\n");
1473 printf_filtered (" %s = ", pc_regname
);
1475 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1477 fputs_filtered ("<unavailable>", gdb_stdout
);
1482 printf_filtered (" in ");
1483 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1484 DMGL_ANSI
| DMGL_PARAMS
);
1488 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1490 puts_filtered ("; ");
1492 printf_filtered ("saved %s ", pc_regname
);
1493 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1494 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1496 fputs_filtered ("<unavailable>", gdb_stdout
);
1497 printf_filtered ("\n");
1499 if (calling_frame_info
== NULL
)
1501 enum unwind_stop_reason reason
;
1503 reason
= get_frame_unwind_stop_reason (fi
);
1504 if (reason
!= UNWIND_NO_REASON
)
1505 printf_filtered (_(" Outermost frame: %s\n"),
1506 frame_stop_reason_string (reason
));
1508 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1509 puts_filtered (" tail call frame");
1510 else if (get_frame_type (fi
) == INLINE_FRAME
)
1511 printf_filtered (" inlined into frame %d",
1512 frame_relative_level (get_prev_frame (fi
)));
1515 printf_filtered (" called by frame at ");
1516 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1519 if (get_next_frame (fi
) && calling_frame_info
)
1520 puts_filtered (",");
1522 if (get_next_frame (fi
))
1524 printf_filtered (" caller of frame at ");
1525 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1528 if (get_next_frame (fi
) || calling_frame_info
)
1529 puts_filtered ("\n");
1532 printf_filtered (" source language %s.\n",
1533 language_str (s
->language
));
1536 /* Address of the argument list for this frame, or 0. */
1537 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1538 /* Number of args for this frame, or -1 if unknown. */
1542 printf_filtered (" Arglist at unknown address.\n");
1545 printf_filtered (" Arglist at ");
1546 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1547 printf_filtered (",");
1549 if (!gdbarch_frame_num_args_p (gdbarch
))
1552 puts_filtered (" args: ");
1556 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1557 gdb_assert (numargs
>= 0);
1559 puts_filtered (" no args.");
1560 else if (numargs
== 1)
1561 puts_filtered (" 1 arg: ");
1563 printf_filtered (" %d args: ", numargs
);
1565 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1566 puts_filtered ("\n");
1570 /* Address of the local variables for this frame, or 0. */
1571 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1574 printf_filtered (" Locals at unknown address,");
1577 printf_filtered (" Locals at ");
1578 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1579 printf_filtered (",");
1583 /* Print as much information as possible on the location of all the
1586 enum lval_type lval
;
1595 /* The sp is special; what's displayed isn't the save address, but
1596 the value of the previous frame's sp. This is a legacy thing,
1597 at one stage the frame cached the previous frame's SP instead
1598 of its address, hence it was easiest to just display the cached
1600 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1602 /* Find out the location of the saved stack pointer with out
1603 actually evaluating it. */
1604 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1605 &optimized
, &unavailable
, &lval
, &addr
,
1607 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1609 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1610 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1611 gdb_byte value
[MAX_REGISTER_SIZE
];
1614 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1615 &optimized
, &unavailable
, &lval
, &addr
,
1617 /* NOTE: cagney/2003-05-22: This is assuming that the
1618 stack pointer was packed as an unsigned integer. That
1619 may or may not be valid. */
1620 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1621 printf_filtered (" Previous frame's sp is ");
1622 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1623 printf_filtered ("\n");
1626 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1628 printf_filtered (" Previous frame's sp at ");
1629 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1630 printf_filtered ("\n");
1633 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1635 printf_filtered (" Previous frame's sp in %s\n",
1636 gdbarch_register_name (gdbarch
, realnum
));
1639 /* else keep quiet. */
1643 numregs
= gdbarch_num_regs (gdbarch
)
1644 + gdbarch_num_pseudo_regs (gdbarch
);
1645 for (i
= 0; i
< numregs
; i
++)
1646 if (i
!= gdbarch_sp_regnum (gdbarch
)
1647 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1649 /* Find out the location of the saved register without
1650 fetching the corresponding value. */
1651 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1652 &lval
, &addr
, &realnum
, NULL
);
1653 /* For moment, only display registers that were saved on the
1655 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1658 puts_filtered (" Saved registers:\n ");
1660 puts_filtered (",");
1662 printf_filtered (" %s at ",
1663 gdbarch_register_name (gdbarch
, i
));
1664 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1668 if (count
|| need_nl
)
1669 puts_filtered ("\n");
1672 do_cleanups (back_to
);
1675 /* Print briefly all stack frames or just the innermost COUNT_EXP
1679 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1682 struct frame_info
*fi
;
1685 struct frame_info
*trailing
;
1686 int trailing_level
, py_start
= 0, py_end
= 0;
1687 enum py_bt_status result
= PY_BT_ERROR
;
1689 if (!target_has_stack
)
1690 error (_("No stack."));
1692 /* The following code must do two things. First, it must set the
1693 variable TRAILING to the frame from which we should start
1694 printing. Second, it must set the variable count to the number
1695 of frames which we should print, or -1 if all of them. */
1696 trailing
= get_current_frame ();
1701 count
= parse_and_eval_long (count_exp
);
1704 struct frame_info
*current
;
1710 while (current
&& count
--)
1713 current
= get_prev_frame (current
);
1716 /* Will stop when CURRENT reaches the top of the stack.
1717 TRAILING will be COUNT below it. */
1721 trailing
= get_prev_frame (trailing
);
1722 current
= get_prev_frame (current
);
1742 /* Read in symbols for all of the frames. Need to do this in a
1743 separate pass so that "Reading in symbols for xxx" messages
1744 don't screw up the appearance of the backtrace. Also if
1745 people have strong opinions against reading symbols for
1746 backtrace this may have to be an option. */
1748 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1753 pc
= get_frame_address_in_block (fi
);
1754 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1760 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1761 enum py_frame_args arg_type
;
1764 flags
|= PRINT_LOCALS
;
1766 if (!strcmp (print_frame_arguments
, "scalars"))
1767 arg_type
= CLI_SCALAR_VALUES
;
1768 else if (!strcmp (print_frame_arguments
, "all"))
1769 arg_type
= CLI_ALL_VALUES
;
1771 arg_type
= NO_VALUES
;
1773 result
= apply_frame_filter (get_current_frame (), flags
, arg_type
,
1774 current_uiout
, py_start
, py_end
);
1777 /* Run the inbuilt backtrace if there are no filters registered, or
1778 "no-filters" has been specified from the command. */
1779 if (no_filters
|| result
== PY_BT_NO_FILTERS
)
1781 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1785 /* Don't use print_stack_frame; if an error() occurs it probably
1786 means further attempts to backtrace would fail (on the other
1787 hand, perhaps the code does or could be fixed to make sure
1788 the frame->prev field gets set to NULL in that case). */
1790 print_frame_info (fi
, 1, LOCATION
, 1);
1793 struct frame_id frame_id
= get_frame_id (fi
);
1795 print_frame_local_vars (fi
, 1, gdb_stdout
);
1797 /* print_frame_local_vars invalidates FI. */
1798 fi
= frame_find_by_id (frame_id
);
1802 warning (_("Unable to restore previously selected frame."));
1807 /* Save the last frame to check for error conditions. */
1811 /* If we've stopped before the end, mention that. */
1813 printf_filtered (_("(More stack frames follow...)\n"));
1815 /* If we've run out of frames, and the reason appears to be an error
1816 condition, print it. */
1817 if (fi
== NULL
&& trailing
!= NULL
)
1819 enum unwind_stop_reason reason
;
1821 reason
= get_frame_unwind_stop_reason (trailing
);
1822 if (reason
>= UNWIND_FIRST_ERROR
)
1823 printf_filtered (_("Backtrace stopped: %s\n"),
1824 frame_stop_reason_string (reason
));
1830 backtrace_command (char *arg
, int from_tty
)
1832 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1833 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1841 argv
= gdb_buildargv (arg
);
1842 make_cleanup_freeargv (argv
);
1844 for (i
= 0; argv
[i
]; i
++)
1848 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1849 argv
[i
][j
] = tolower (argv
[i
][j
]);
1851 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1855 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1856 fulltrace_arg
= argc
;
1860 arglen
+= strlen (argv
[i
]);
1866 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1870 arg
= xmalloc (arglen
+ 1);
1871 make_cleanup (xfree
, arg
);
1873 for (i
= 0; i
< argc
; i
++)
1875 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1877 strcat (arg
, argv
[i
]);
1887 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1888 no_filters
>= 0 /* no frame-filters */, from_tty
);
1890 do_cleanups (old_chain
);
1894 backtrace_full_command (char *arg
, int from_tty
)
1896 backtrace_command_1 (arg
, 1 /* show_locals */, 0, from_tty
);
1900 /* Iterate over the local variables of a block B, calling CB with
1904 iterate_over_block_locals (struct block
*b
,
1905 iterate_over_block_arg_local_vars_cb cb
,
1908 struct block_iterator iter
;
1911 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1913 switch (SYMBOL_CLASS (sym
))
1919 if (SYMBOL_IS_ARGUMENT (sym
))
1921 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1923 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1927 /* Ignore symbols which are not locals. */
1934 /* Same, but print labels. */
1937 /* Commented out, as the code using this function has also been
1938 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1939 was commented out in the first place. The discussion introducing
1940 this change (2007-12-04: Support lexical blocks and function bodies
1941 that occupy non-contiguous address ranges) did not explain why
1942 this change was made. */
1944 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1945 int *have_default
, struct ui_file
*stream
)
1947 struct block_iterator iter
;
1949 int values_printed
= 0;
1951 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1953 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1959 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1961 struct symtab_and_line sal
;
1962 struct value_print_options opts
;
1964 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1966 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1967 get_user_print_options (&opts
);
1968 if (opts
.addressprint
)
1970 fprintf_filtered (stream
, " ");
1971 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1974 fprintf_filtered (stream
, " in file %s, line %d\n",
1975 sal
.symtab
->filename
, sal
.line
);
1979 return values_printed
;
1983 /* Iterate over all the local variables in block B, including all its
1984 superblocks, stopping when the top-level block is reached. */
1987 iterate_over_block_local_vars (struct block
*block
,
1988 iterate_over_block_arg_local_vars_cb cb
,
1993 iterate_over_block_locals (block
, cb
, cb_data
);
1994 /* After handling the function's top-level block, stop. Don't
1995 continue to its superblock, the block of per-file
1997 if (BLOCK_FUNCTION (block
))
1999 block
= BLOCK_SUPERBLOCK (block
);
2003 /* Data to be passed around in the calls to the locals and args
2006 struct print_variable_and_value_data
2008 struct frame_id frame_id
;
2010 struct ui_file
*stream
;
2014 /* The callback for the locals and args iterators. */
2017 do_print_variable_and_value (const char *print_name
,
2021 struct print_variable_and_value_data
*p
= cb_data
;
2022 struct frame_info
*frame
;
2024 frame
= frame_find_by_id (p
->frame_id
);
2027 warning (_("Unable to restore previously selected frame."));
2031 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2033 /* print_variable_and_value invalidates FRAME. */
2036 p
->values_printed
= 1;
2039 /* Print all variables from the innermost up to the function block of FRAME.
2040 Print them with values to STREAM indented by NUM_TABS.
2042 This function will invalidate FRAME. */
2045 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2046 struct ui_file
*stream
)
2048 struct print_variable_and_value_data cb_data
;
2049 struct block
*block
;
2052 if (!get_frame_pc_if_available (frame
, &pc
))
2054 fprintf_filtered (stream
,
2055 _("PC unavailable, cannot determine locals.\n"));
2059 block
= get_frame_block (frame
, 0);
2062 fprintf_filtered (stream
, "No symbol table info available.\n");
2066 cb_data
.frame_id
= get_frame_id (frame
);
2067 cb_data
.num_tabs
= 4 * num_tabs
;
2068 cb_data
.stream
= stream
;
2069 cb_data
.values_printed
= 0;
2071 iterate_over_block_local_vars (block
,
2072 do_print_variable_and_value
,
2075 /* do_print_variable_and_value invalidates FRAME. */
2078 if (!cb_data
.values_printed
)
2079 fprintf_filtered (stream
, _("No locals.\n"));
2083 locals_info (char *args
, int from_tty
)
2085 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2089 /* Iterate over all the argument variables in block B.
2091 Returns 1 if any argument was walked; 0 otherwise. */
2094 iterate_over_block_arg_vars (struct block
*b
,
2095 iterate_over_block_arg_local_vars_cb cb
,
2098 struct block_iterator iter
;
2099 struct symbol
*sym
, *sym2
;
2101 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2103 /* Don't worry about things which aren't arguments. */
2104 if (SYMBOL_IS_ARGUMENT (sym
))
2106 /* We have to look up the symbol because arguments can have
2107 two entries (one a parameter, one a local) and the one we
2108 want is the local, which lookup_symbol will find for us.
2109 This includes gcc1 (not gcc2) on the sparc when passing a
2110 small structure and gcc2 when the argument type is float
2111 and it is passed as a double and converted to float by
2112 the prologue (in the latter case the type of the LOC_ARG
2113 symbol is double and the type of the LOC_LOCAL symbol is
2114 float). There are also LOC_ARG/LOC_REGISTER pairs which
2115 are not combined in symbol-reading. */
2117 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2118 b
, VAR_DOMAIN
, NULL
);
2119 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2124 /* Print all argument variables of the function of FRAME.
2125 Print them with values to STREAM.
2127 This function will invalidate FRAME. */
2130 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2132 struct print_variable_and_value_data cb_data
;
2133 struct symbol
*func
;
2136 if (!get_frame_pc_if_available (frame
, &pc
))
2138 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2142 func
= get_frame_function (frame
);
2145 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2149 cb_data
.frame_id
= get_frame_id (frame
);
2150 cb_data
.num_tabs
= 0;
2151 cb_data
.stream
= gdb_stdout
;
2152 cb_data
.values_printed
= 0;
2154 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2155 do_print_variable_and_value
, &cb_data
);
2157 /* do_print_variable_and_value invalidates FRAME. */
2160 if (!cb_data
.values_printed
)
2161 fprintf_filtered (stream
, _("No arguments.\n"));
2165 args_info (char *ignore
, int from_tty
)
2167 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2173 args_plus_locals_info (char *ignore
, int from_tty
)
2175 args_info (ignore
, from_tty
);
2176 locals_info (ignore
, from_tty
);
2180 /* Select frame FRAME. Also print the stack frame and show the source
2181 if this is the tui version. */
2183 select_and_print_frame (struct frame_info
*frame
)
2185 select_frame (frame
);
2187 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2190 /* Return the symbol-block in which the selected frame is executing.
2191 Can return zero under various legitimate circumstances.
2193 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2194 code address within the block returned. We use this to decide
2195 which macros are in scope. */
2198 get_selected_block (CORE_ADDR
*addr_in_block
)
2200 if (!has_stack_frames ())
2203 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2206 /* Find a frame a certain number of levels away from FRAME.
2207 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2208 Positive means go to earlier frames (up); negative, the reverse.
2209 The int that contains the number of levels is counted toward
2210 zero as the frames for those levels are found.
2211 If the top or bottom frame is reached, that frame is returned,
2212 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2213 how much farther the original request asked to go. */
2216 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2218 /* Going up is simple: just call get_prev_frame enough times or
2219 until the initial frame is reached. */
2220 while (*level_offset_ptr
> 0)
2222 struct frame_info
*prev
= get_prev_frame (frame
);
2226 (*level_offset_ptr
)--;
2230 /* Going down is just as simple. */
2231 while (*level_offset_ptr
< 0)
2233 struct frame_info
*next
= get_next_frame (frame
);
2237 (*level_offset_ptr
)++;
2244 /* The "select_frame" command. With no argument this is a NOP.
2245 Select the frame at level LEVEL_EXP if it is a valid level.
2246 Otherwise, treat LEVEL_EXP as an address expression and select it.
2248 See parse_frame_specification for more info on proper frame
2252 select_frame_command (char *level_exp
, int from_tty
)
2254 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2257 /* The "frame" command. With no argument, print the selected frame
2258 briefly. With an argument, behave like select_frame and then print
2259 the selected frame. */
2262 frame_command (char *level_exp
, int from_tty
)
2264 select_frame_command (level_exp
, from_tty
);
2265 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2268 /* The XDB Compatibility command to print the current frame. */
2271 current_frame_command (char *level_exp
, int from_tty
)
2273 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2276 /* Select the frame up one or COUNT_EXP stack levels from the
2277 previously selected frame, and print it briefly. */
2280 up_silently_base (char *count_exp
)
2282 struct frame_info
*frame
;
2286 count
= parse_and_eval_long (count_exp
);
2288 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2289 if (count
!= 0 && count_exp
== NULL
)
2290 error (_("Initial frame selected; you cannot go up."));
2291 select_frame (frame
);
2295 up_silently_command (char *count_exp
, int from_tty
)
2297 up_silently_base (count_exp
);
2301 up_command (char *count_exp
, int from_tty
)
2303 up_silently_base (count_exp
);
2304 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2307 /* Select the frame down one or COUNT_EXP stack levels from the previously
2308 selected frame, and print it briefly. */
2311 down_silently_base (char *count_exp
)
2313 struct frame_info
*frame
;
2317 count
= -parse_and_eval_long (count_exp
);
2319 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2320 if (count
!= 0 && count_exp
== NULL
)
2322 /* We only do this if COUNT_EXP is not specified. That way
2323 "down" means to really go down (and let me know if that is
2324 impossible), but "down 9999" can be used to mean go all the
2325 way down without getting an error. */
2327 error (_("Bottom (innermost) frame selected; you cannot go down."));
2330 select_frame (frame
);
2334 down_silently_command (char *count_exp
, int from_tty
)
2336 down_silently_base (count_exp
);
2340 down_command (char *count_exp
, int from_tty
)
2342 down_silently_base (count_exp
);
2343 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2348 return_command (char *retval_exp
, int from_tty
)
2350 /* Initialize it just to avoid a GCC false warning. */
2351 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2352 struct frame_info
*thisframe
;
2353 struct gdbarch
*gdbarch
;
2354 struct symbol
*thisfun
;
2355 struct value
*return_value
= NULL
;
2356 struct value
*function
= NULL
;
2357 const char *query_prefix
= "";
2359 thisframe
= get_selected_frame ("No selected frame.");
2360 thisfun
= get_frame_function (thisframe
);
2361 gdbarch
= get_frame_arch (thisframe
);
2363 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2364 error (_("Can not force return from an inlined function."));
2366 /* Compute the return value. If the computation triggers an error,
2367 let it bail. If the return type can't be handled, set
2368 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2372 struct expression
*retval_expr
= parse_expression (retval_exp
);
2373 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2374 struct type
*return_type
= NULL
;
2376 /* Compute the return value. Should the computation fail, this
2377 call throws an error. */
2378 return_value
= evaluate_expression (retval_expr
);
2380 /* Cast return value to the return type of the function. Should
2381 the cast fail, this call throws an error. */
2382 if (thisfun
!= NULL
)
2383 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2384 if (return_type
== NULL
)
2386 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2387 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2388 error (_("Return value type not available for selected "
2390 "Please use an explicit cast of the value to return."));
2391 return_type
= value_type (return_value
);
2393 do_cleanups (old_chain
);
2394 CHECK_TYPEDEF (return_type
);
2395 return_value
= value_cast (return_type
, return_value
);
2397 /* Make sure the value is fully evaluated. It may live in the
2398 stack frame we're about to pop. */
2399 if (value_lazy (return_value
))
2400 value_fetch_lazy (return_value
);
2402 if (thisfun
!= NULL
)
2403 function
= read_var_value (thisfun
, thisframe
);
2405 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2406 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2407 /* If the return-type is "void", don't try to find the
2408 return-value's location. However, do still evaluate the
2409 return expression so that, even when the expression result
2410 is discarded, side effects such as "return i++" still
2412 return_value
= NULL
;
2413 else if (thisfun
!= NULL
)
2415 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2416 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2417 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2419 query_prefix
= "The location at which to store the "
2420 "function's return value is unknown.\n"
2421 "If you continue, the return value "
2422 "that you specified will be ignored.\n";
2423 return_value
= NULL
;
2428 /* Does an interactive user really want to do this? Include
2429 information, such as how well GDB can handle the return value, in
2430 the query message. */
2435 if (thisfun
== NULL
)
2436 confirmed
= query (_("%sMake selected stack frame return now? "),
2439 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2440 SYMBOL_PRINT_NAME (thisfun
));
2442 error (_("Not confirmed"));
2445 /* Discard the selected frame and all frames inner-to it. */
2446 frame_pop (get_selected_frame (NULL
));
2448 /* Store RETURN_VALUE in the just-returned register set. */
2449 if (return_value
!= NULL
)
2451 struct type
*return_type
= value_type (return_value
);
2452 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2454 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2455 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2456 gdbarch_return_value (gdbarch
, function
, return_type
,
2457 get_current_regcache (), NULL
/*read*/,
2458 value_contents (return_value
) /*write*/);
2461 /* If we are at the end of a call dummy now, pop the dummy frame
2463 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2464 frame_pop (get_current_frame ());
2466 /* If interactive, print the frame that is now current. */
2468 frame_command ("0", 1);
2470 select_frame_command ("0", 0);
2473 /* Sets the scope to input function name, provided that the function
2474 is within the current stack frame. */
2476 struct function_bounds
2478 CORE_ADDR low
, high
;
2482 func_command (char *arg
, int from_tty
)
2484 struct frame_info
*frame
;
2486 struct symtabs_and_lines sals
;
2489 struct function_bounds
*func_bounds
= NULL
;
2490 struct cleanup
*cleanups
;
2495 frame
= parse_frame_specification ("0");
2496 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2497 cleanups
= make_cleanup (xfree
, sals
.sals
);
2498 func_bounds
= (struct function_bounds
*) xmalloc (
2499 sizeof (struct function_bounds
) * sals
.nelts
);
2500 make_cleanup (xfree
, func_bounds
);
2501 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2503 if (sals
.sals
[i
].pspace
!= current_program_space
)
2504 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2505 else if (sals
.sals
[i
].pc
== 0
2506 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2507 &func_bounds
[i
].low
,
2508 &func_bounds
[i
].high
) == 0)
2510 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2516 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2517 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2518 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2522 frame
= find_relative_frame (frame
, &level
);
2525 while (!found
&& level
== 0);
2527 do_cleanups (cleanups
);
2530 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2531 else if (frame
!= get_selected_frame (NULL
))
2532 select_and_print_frame (frame
);
2535 /* Gets the language of the current frame. */
2538 get_frame_language (void)
2540 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2544 volatile struct gdb_exception ex
;
2548 /* We determine the current frame language by looking up its
2549 associated symtab. To retrieve this symtab, we use the frame
2550 PC. However we cannot use the frame PC as is, because it
2551 usually points to the instruction following the "call", which
2552 is sometimes the first instruction of another function. So
2553 we rely on get_frame_address_in_block(), it provides us with
2554 a PC that is guaranteed to be inside the frame's code
2557 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2559 pc
= get_frame_address_in_block (frame
);
2563 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2564 throw_exception (ex
);
2568 s
= find_pc_symtab (pc
);
2574 return language_unknown
;
2578 /* Provide a prototype to silence -Wmissing-prototypes. */
2579 void _initialize_stack (void);
2582 _initialize_stack (void)
2584 add_com ("return", class_stack
, return_command
, _("\
2585 Make selected stack frame return to its caller.\n\
2586 Control remains in the debugger, but when you continue\n\
2587 execution will resume in the frame above the one now selected.\n\
2588 If an argument is given, it is an expression for the value to return."));
2590 add_com ("up", class_stack
, up_command
, _("\
2591 Select and print stack frame that called this one.\n\
2592 An argument says how many frames up to go."));
2593 add_com ("up-silently", class_support
, up_silently_command
, _("\
2594 Same as the `up' command, but does not print anything.\n\
2595 This is useful in command scripts."));
2597 add_com ("down", class_stack
, down_command
, _("\
2598 Select and print stack frame called by this one.\n\
2599 An argument says how many frames down to go."));
2600 add_com_alias ("do", "down", class_stack
, 1);
2601 add_com_alias ("dow", "down", class_stack
, 1);
2602 add_com ("down-silently", class_support
, down_silently_command
, _("\
2603 Same as the `down' command, but does not print anything.\n\
2604 This is useful in command scripts."));
2606 add_com ("frame", class_stack
, frame_command
, _("\
2607 Select and print a stack frame.\nWith no argument, \
2608 print the selected stack frame. (See also \"info frame\").\n\
2609 An argument specifies the frame to select.\n\
2610 It can be a stack frame number or the address of the frame.\n\
2611 With argument, nothing is printed if input is coming from\n\
2612 a command file or a user-defined command."));
2614 add_com_alias ("f", "frame", class_stack
, 1);
2618 add_com ("L", class_stack
, current_frame_command
,
2619 _("Print the current stack frame.\n"));
2620 add_com_alias ("V", "frame", class_stack
, 1);
2622 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2623 Select a stack frame without printing anything.\n\
2624 An argument specifies the frame to select.\n\
2625 It can be a stack frame number or the address of the frame.\n"));
2627 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2628 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2629 With a negative argument, print outermost -COUNT frames.\nUse of the \
2630 'full' qualifier also prints the values of the local variables.\n\
2631 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2632 on this backtrace.\n"));
2633 add_com_alias ("bt", "backtrace", class_stack
, 0);
2636 add_com_alias ("t", "backtrace", class_stack
, 0);
2637 add_com ("T", class_stack
, backtrace_full_command
, _("\
2638 Print backtrace of all stack frames, or innermost COUNT frames\n\
2639 and the values of the local variables.\n\
2640 With a negative argument, print outermost -COUNT frames.\n\
2641 Usage: T <count>\n"));
2644 add_com_alias ("where", "backtrace", class_alias
, 0);
2645 add_info ("stack", backtrace_command
,
2646 _("Backtrace of the stack, or innermost COUNT frames."));
2647 add_info_alias ("s", "stack", 1);
2648 add_info ("frame", frame_info
,
2649 _("All about selected stack frame, or frame at ADDR."));
2650 add_info_alias ("f", "frame", 1);
2651 add_info ("locals", locals_info
,
2652 _("Local variables of current stack frame."));
2653 add_info ("args", args_info
,
2654 _("Argument variables of current stack frame."));
2656 add_com ("l", class_info
, args_plus_locals_info
,
2657 _("Argument and local variables of current stack frame."));
2660 add_com ("func", class_stack
, func_command
, _("\
2661 Select the stack frame that contains <func>.\n\
2662 Usage: func <name>\n"));
2664 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2665 print_frame_arguments_choices
, &print_frame_arguments
,
2666 _("Set printing of non-scalar frame arguments"),
2667 _("Show printing of non-scalar frame arguments"),
2668 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2670 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2671 &print_raw_frame_arguments
, _("\
2672 Set whether to print frame arguments in raw form."), _("\
2673 Show whether to print frame arguments in raw form."), _("\
2674 If set, frame arguments are printed in raw form, bypassing any\n\
2675 pretty-printers for that value."),
2677 &setprintrawlist
, &showprintrawlist
);
2679 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2680 &disassemble_next_line
, _("\
2681 Set whether to disassemble next source line or insn when execution stops."),
2683 Show whether to disassemble next source line or insn when execution stops."),
2685 If ON, GDB will display disassembly of the next source line, in addition\n\
2686 to displaying the source line itself. If the next source line cannot\n\
2687 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2688 will display disassembly of next instruction instead of showing the\n\
2690 If AUTO, display disassembly of next instruction only if the source line\n\
2691 cannot be displayed.\n\
2692 If OFF (which is the default), never display the disassembly of the next\n\
2695 show_disassemble_next_line
,
2696 &setlist
, &showlist
);
2697 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2699 add_setshow_enum_cmd ("entry-values", class_stack
,
2700 print_entry_values_choices
, &print_entry_values
,
2701 _("Set printing of function arguments at function "
2703 _("Show printing of function arguments at function "
2706 GDB can sometimes determine the values of function arguments at entry,\n\
2707 in addition to their current values. This option tells GDB whether\n\
2708 to print the current value, the value at entry (marked as val@entry),\n\
2709 or both. Note that one or both of these values may be <optimized out>."),
2710 NULL
, NULL
, &setprintlist
, &showprintlist
);