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"
57 #include "python/python.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
)
160 volatile struct gdb_exception e
;
162 /* For mi, alway print location and address. */
163 if (ui_out_is_mi_like_p (current_uiout
))
164 print_what
= LOC_AND_ADDRESS
;
166 TRY_CATCH (e
, RETURN_MASK_ERROR
)
168 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
170 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
171 set_current_sal_from_frame (frame
, center
);
175 /* Print nameless arguments of frame FRAME on STREAM, where START is
176 the offset of the first nameless argument, and NUM is the number of
177 nameless arguments to print. FIRST is nonzero if this is the first
178 argument (not just the first nameless argument). */
181 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
182 int first
, struct ui_file
*stream
)
184 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
185 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
190 for (i
= 0; i
< num
; i
++)
193 argsaddr
= get_frame_args_address (frame
);
196 arg_value
= read_memory_integer (argsaddr
+ start
,
197 sizeof (int), byte_order
);
199 fprintf_filtered (stream
, ", ");
200 fprintf_filtered (stream
, "%ld", arg_value
);
202 start
+= sizeof (int);
206 /* Print single argument of inferior function. ARG must be already
209 Errors are printed as if they would be the parameter value. Use zeroed ARG
210 iff it should not be printed accoring to user settings. */
213 print_frame_arg (const struct frame_arg
*arg
)
215 struct ui_out
*uiout
= current_uiout
;
216 volatile struct gdb_exception except
;
217 struct cleanup
*old_chain
;
220 stb
= mem_fileopen ();
221 old_chain
= make_cleanup_ui_file_delete (stb
);
223 gdb_assert (!arg
->val
|| !arg
->error
);
224 gdb_assert (arg
->entry_kind
== print_entry_values_no
225 || arg
->entry_kind
== print_entry_values_only
226 || (!ui_out_is_mi_like_p (uiout
)
227 && arg
->entry_kind
== print_entry_values_compact
));
229 annotate_arg_begin ();
231 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
232 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
233 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
234 if (arg
->entry_kind
== print_entry_values_compact
)
236 /* It is OK to provide invalid MI-like stream as with
237 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
238 fputs_filtered ("=", stb
);
240 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
241 SYMBOL_LANGUAGE (arg
->sym
),
242 DMGL_PARAMS
| DMGL_ANSI
);
244 if (arg
->entry_kind
== print_entry_values_only
245 || arg
->entry_kind
== print_entry_values_compact
)
246 fputs_filtered ("@entry", stb
);
247 ui_out_field_stream (uiout
, "name", stb
);
248 annotate_arg_name_end ();
249 ui_out_text (uiout
, "=");
251 if (!arg
->val
&& !arg
->error
)
252 ui_out_text (uiout
, "...");
256 except
.message
= arg
->error
;
259 /* TRY_CATCH has two statements, wrap it in a block. */
261 TRY_CATCH (except
, RETURN_MASK_ERROR
)
263 const struct language_defn
*language
;
264 struct value_print_options opts
;
266 /* Avoid value_print because it will deref ref parameters. We
267 just want to print their addresses. Print ??? for args whose
268 address we do not know. We pass 2 as "recurse" to val_print
269 because our standard indentation here is 4 spaces, and
270 val_print indents 2 for each recurse. */
272 annotate_arg_value (value_type (arg
->val
));
274 /* Use the appropriate language to display our symbol, unless the
275 user forced the language to a specific language. */
276 if (language_mode
== language_mode_auto
)
277 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
279 language
= current_language
;
281 get_no_prettyformat_print_options (&opts
);
283 opts
.raw
= print_raw_frame_arguments
;
285 /* True in "summary" mode, false otherwise. */
286 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
288 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
292 fprintf_filtered (stb
, _("<error reading variable: %s>"),
296 ui_out_field_stream (uiout
, "value", stb
);
298 /* Also invoke ui_out_tuple_end. */
299 do_cleanups (old_chain
);
304 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
305 responsible for xfree of ARGP->ERROR. This function never throws an
309 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
310 struct frame_arg
*argp
)
312 volatile struct gdb_exception except
;
313 struct value
*val
= NULL
;
315 TRY_CATCH (except
, RETURN_MASK_ERROR
)
317 val
= read_var_value (sym
, frame
);
320 argp
->error
= (val
== NULL
) ? xstrdup (except
.message
) : NULL
;
325 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
326 responsible for xfree of ARGP->ERROR. This function never throws an
330 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
331 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
333 struct value
*val
= NULL
, *entryval
= NULL
;
334 char *val_error
= NULL
, *entryval_error
= NULL
;
336 volatile struct gdb_exception except
;
338 if (print_entry_values
!= print_entry_values_only
339 && print_entry_values
!= print_entry_values_preferred
)
341 TRY_CATCH (except
, RETURN_MASK_ERROR
)
343 val
= read_var_value (sym
, frame
);
347 val_error
= alloca (strlen (except
.message
) + 1);
348 strcpy (val_error
, except
.message
);
352 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
353 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
354 && print_entry_values
!= print_entry_values_no
355 && (print_entry_values
!= print_entry_values_if_needed
356 || !val
|| value_optimized_out (val
)))
358 TRY_CATCH (except
, RETURN_MASK_ERROR
)
360 const struct symbol_computed_ops
*ops
;
362 ops
= SYMBOL_COMPUTED_OPS (sym
);
363 entryval
= ops
->read_variable_at_entry (sym
, frame
);
367 entryval_error
= alloca (strlen (except
.message
) + 1);
368 strcpy (entryval_error
, except
.message
);
371 if (except
.error
== NO_ENTRY_VALUE_ERROR
372 || (entryval
&& value_optimized_out (entryval
)))
375 entryval_error
= NULL
;
378 if (print_entry_values
== print_entry_values_compact
379 || print_entry_values
== print_entry_values_default
)
381 /* For MI do not try to use print_entry_values_compact for ARGP. */
383 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
385 struct type
*type
= value_type (val
);
387 if (!value_optimized_out (val
)
388 && value_available_contents_eq (val
, 0, entryval
, 0,
391 /* Initialize it just to avoid a GCC false warning. */
392 struct value
*val_deref
= NULL
, *entryval_deref
;
394 /* DW_AT_GNU_call_site_value does match with the current
395 value. If it is a reference still try to verify if
396 dereferenced DW_AT_GNU_call_site_data_value does not
399 TRY_CATCH (except
, RETURN_MASK_ERROR
)
401 struct type
*type_deref
;
403 val_deref
= coerce_ref (val
);
404 if (value_lazy (val_deref
))
405 value_fetch_lazy (val_deref
);
406 type_deref
= value_type (val_deref
);
408 entryval_deref
= coerce_ref (entryval
);
409 if (value_lazy (entryval_deref
))
410 value_fetch_lazy (entryval_deref
);
412 /* If the reference addresses match but dereferenced
413 content does not match print them. */
415 && value_available_contents_eq (val_deref
, 0,
417 TYPE_LENGTH (type_deref
)))
421 /* Value was not a reference; and its content matches. */
422 if (val
== val_deref
)
424 /* If the dereferenced content could not be fetched do not
426 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
428 else if (except
.message
)
430 entryval_error
= alloca (strlen (except
.message
) + 1);
431 strcpy (entryval_error
, except
.message
);
439 /* Try to remove possibly duplicate error message for ENTRYARGP even
442 if (val_error
&& entryval_error
443 && strcmp (val_error
, entryval_error
) == 0)
445 entryval_error
= NULL
;
447 /* Do not se VAL_EQUAL as the same error message may be shown for
448 the entry value even if no entry values are present in the
454 if (entryval
== NULL
)
456 if (print_entry_values
== print_entry_values_preferred
)
458 TRY_CATCH (except
, RETURN_MASK_ERROR
)
460 val
= read_var_value (sym
, frame
);
464 val_error
= alloca (strlen (except
.message
) + 1);
465 strcpy (val_error
, except
.message
);
468 if (print_entry_values
== print_entry_values_only
469 || print_entry_values
== print_entry_values_both
470 || (print_entry_values
== print_entry_values_preferred
471 && (!val
|| value_optimized_out (val
))))
472 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
474 if ((print_entry_values
== print_entry_values_compact
475 || print_entry_values
== print_entry_values_if_needed
476 || print_entry_values
== print_entry_values_preferred
)
477 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
485 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
486 if (!val
&& !val_error
)
487 argp
->entry_kind
= print_entry_values_only
;
488 else if ((print_entry_values
== print_entry_values_compact
489 || print_entry_values
== print_entry_values_default
) && val_equal
)
491 argp
->entry_kind
= print_entry_values_compact
;
492 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
495 argp
->entry_kind
= print_entry_values_no
;
497 entryargp
->sym
= sym
;
498 entryargp
->val
= entryval
;
499 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
500 if (!entryval
&& !entryval_error
)
501 entryargp
->entry_kind
= print_entry_values_no
;
503 entryargp
->entry_kind
= print_entry_values_only
;
506 /* Print the arguments of frame FRAME on STREAM, given the function
507 FUNC running in that frame (as a symbol), where NUM is the number
508 of arguments according to the stack frame (or -1 if the number of
509 arguments is unknown). */
511 /* Note that currently the "number of arguments according to the
512 stack frame" is only known on VAX where i refers to the "number of
513 ints of arguments according to the stack frame". */
516 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
517 int num
, struct ui_file
*stream
)
519 struct ui_out
*uiout
= current_uiout
;
521 /* Offset of next stack argument beyond the one we have seen that is
522 at the highest offset, or -1 if we haven't come to a stack
524 long highest_offset
= -1;
525 /* Number of ints of arguments that we have printed so far. */
526 int args_printed
= 0;
527 struct cleanup
*old_chain
;
529 /* True if we should print arguments, false otherwise. */
530 int print_args
= strcmp (print_frame_arguments
, "none");
532 stb
= mem_fileopen ();
533 old_chain
= make_cleanup_ui_file_delete (stb
);
537 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
538 struct block_iterator iter
;
541 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
543 struct frame_arg arg
, entryarg
;
547 /* Keep track of the highest stack argument offset seen, and
548 skip over any kinds of symbols we don't care about. */
550 if (!SYMBOL_IS_ARGUMENT (sym
))
553 switch (SYMBOL_CLASS (sym
))
558 long current_offset
= SYMBOL_VALUE (sym
);
559 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
561 /* Compute address of next argument by adding the size of
562 this argument and rounding to an int boundary. */
564 ((current_offset
+ arg_size
+ sizeof (int) - 1)
565 & ~(sizeof (int) - 1));
567 /* If this is the highest offset seen yet, set
569 if (highest_offset
== -1
570 || (current_offset
> highest_offset
))
571 highest_offset
= current_offset
;
573 /* Add the number of ints we're about to print to
575 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
578 /* We care about types of symbols, but don't need to
579 keep track of stack offsets in them. */
581 case LOC_REGPARM_ADDR
:
583 case LOC_OPTIMIZED_OUT
:
588 /* We have to look up the symbol because arguments can have
589 two entries (one a parameter, one a local) and the one we
590 want is the local, which lookup_symbol will find for us.
591 This includes gcc1 (not gcc2) on SPARC when passing a
592 small structure and gcc2 when the argument type is float
593 and it is passed as a double and converted to float by
594 the prologue (in the latter case the type of the LOC_ARG
595 symbol is double and the type of the LOC_LOCAL symbol is
597 /* But if the parameter name is null, don't try it. Null
598 parameter names occur on the RS/6000, for traceback
599 tables. FIXME, should we even print them? */
601 if (*SYMBOL_LINKAGE_NAME (sym
))
605 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
606 b
, VAR_DOMAIN
, NULL
);
607 gdb_assert (nsym
!= NULL
);
608 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
609 && !SYMBOL_IS_ARGUMENT (nsym
))
611 /* There is a LOC_ARG/LOC_REGISTER pair. This means
612 that it was passed on the stack and loaded into a
613 register, or passed in a register and stored in a
614 stack slot. GDB 3.x used the LOC_ARG; GDB
615 4.0-4.11 used the LOC_REGISTER.
617 Reasons for using the LOC_ARG:
619 (1) Because find_saved_registers may be slow for
622 (2) Because registers are often re-used and stack
623 slots rarely (never?) are. Therefore using
624 the stack slot is much less likely to print
627 Reasons why we might want to use the LOC_REGISTER:
629 (1) So that the backtrace prints the same value
630 as "print foo". I see no compelling reason
631 why this needs to be the case; having the
632 backtrace print the value which was passed
633 in, and "print foo" print the value as
634 modified within the called function, makes
637 Additional note: It might be nice if "info args"
638 displayed both values.
640 One more note: There is a case with SPARC
641 structure passing where we need to use the
642 LOC_REGISTER, but this is dealt with by creating
643 a single LOC_REGPARM in symbol reading. */
645 /* Leave sym (the LOC_ARG) alone. */
652 /* Print the current arg. */
654 ui_out_text (uiout
, ", ");
655 ui_out_wrap_hint (uiout
, " ");
659 memset (&arg
, 0, sizeof (arg
));
661 arg
.entry_kind
= print_entry_values_no
;
662 memset (&entryarg
, 0, sizeof (entryarg
));
664 entryarg
.entry_kind
= print_entry_values_no
;
667 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
669 if (arg
.entry_kind
!= print_entry_values_only
)
670 print_frame_arg (&arg
);
672 if (entryarg
.entry_kind
!= print_entry_values_no
)
674 if (arg
.entry_kind
!= print_entry_values_only
)
676 ui_out_text (uiout
, ", ");
677 ui_out_wrap_hint (uiout
, " ");
680 print_frame_arg (&entryarg
);
684 xfree (entryarg
.error
);
690 /* Don't print nameless args in situations where we don't know
691 enough about the stack to find them. */
696 if (highest_offset
== -1)
697 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
699 start
= highest_offset
;
701 print_frame_nameless_args (frame
, start
, num
- args_printed
,
705 do_cleanups (old_chain
);
708 /* Set the current source and line to the location given by frame
709 FRAME, if possible. When CENTER is true, adjust so the relevant
710 line is in the center of the next 'list'. */
713 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
715 struct symtab_and_line sal
;
717 find_frame_sal (frame
, &sal
);
721 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
722 set_current_source_symtab_and_line (&sal
);
726 /* If ON, GDB will display disassembly of the next source line when
727 execution of the program being debugged stops.
728 If AUTO (which is the default), or there's no line info to determine
729 the source line of the next instruction, display disassembly of next
730 instruction instead. */
732 static enum auto_boolean disassemble_next_line
;
735 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
736 struct cmd_list_element
*c
,
739 fprintf_filtered (file
,
740 _("Debugger's willingness to use "
741 "disassemble-next-line is %s.\n"),
745 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
746 because it will be broken by filter sometime. */
749 do_gdb_disassembly (struct gdbarch
*gdbarch
,
750 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
752 volatile struct gdb_exception exception
;
754 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
756 gdb_disassembly (gdbarch
, current_uiout
, 0,
757 DISASSEMBLY_RAW_INSN
, how_many
,
760 if (exception
.reason
< 0)
762 /* If an exception was thrown while doing the disassembly, print
763 the error message, to give the user a clue of what happened. */
764 exception_print (gdb_stderr
, exception
);
768 /* Print information about frame FRAME. The output is format according
769 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
772 SRC_LINE: Print only source line.
773 LOCATION: Print only location.
774 LOC_AND_SRC: Print location and source line.
776 Used in "where" output, and to emit breakpoint or step
780 print_frame_info (struct frame_info
*frame
, int print_level
,
781 enum print_what print_what
, int print_args
)
783 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
784 struct symtab_and_line sal
;
787 struct ui_out
*uiout
= current_uiout
;
789 if (get_frame_type (frame
) == DUMMY_FRAME
790 || get_frame_type (frame
) == SIGTRAMP_FRAME
791 || get_frame_type (frame
) == ARCH_FRAME
)
793 struct cleanup
*uiout_cleanup
794 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
796 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
797 gdbarch
, get_frame_pc (frame
));
799 /* Do this regardless of SOURCE because we don't have any source
800 to list for this frame. */
803 ui_out_text (uiout
, "#");
804 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
805 frame_relative_level (frame
));
807 if (ui_out_is_mi_like_p (uiout
))
809 annotate_frame_address ();
810 ui_out_field_core_addr (uiout
, "addr",
811 gdbarch
, get_frame_pc (frame
));
812 annotate_frame_address_end ();
815 if (get_frame_type (frame
) == DUMMY_FRAME
)
817 annotate_function_call ();
818 ui_out_field_string (uiout
, "func", "<function called from gdb>");
820 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
822 annotate_signal_handler_caller ();
823 ui_out_field_string (uiout
, "func", "<signal handler called>");
825 else if (get_frame_type (frame
) == ARCH_FRAME
)
827 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
829 ui_out_text (uiout
, "\n");
830 annotate_frame_end ();
832 do_cleanups (uiout_cleanup
);
836 /* If FRAME is not the innermost frame, that normally means that
837 FRAME->pc points to *after* the call instruction, and we want to
838 get the line containing the call, never the next line. But if
839 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
840 next frame was not entered as the result of a call, and we want
841 to get the line containing FRAME->pc. */
842 find_frame_sal (frame
, &sal
);
844 location_print
= (print_what
== LOCATION
845 || print_what
== LOC_AND_ADDRESS
846 || print_what
== SRC_AND_LOC
);
848 if (location_print
|| !sal
.symtab
)
849 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
851 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
853 /* If disassemble-next-line is set to auto or on and doesn't have
854 the line debug messages for $pc, output the next instruction. */
855 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
856 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
857 && source_print
&& !sal
.symtab
)
858 do_gdb_disassembly (get_frame_arch (frame
), 1,
859 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
861 if (source_print
&& sal
.symtab
)
864 int mid_statement
= ((print_what
== SRC_LINE
)
865 && frame_show_address (frame
, sal
));
867 if (annotation_level
)
868 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
869 get_frame_pc (frame
));
872 if (deprecated_print_frame_info_listing_hook
)
873 deprecated_print_frame_info_listing_hook (sal
.symtab
,
878 struct value_print_options opts
;
880 get_user_print_options (&opts
);
881 /* We used to do this earlier, but that is clearly
882 wrong. This function is used by many different
883 parts of gdb, including normal_stop in infrun.c,
884 which uses this to print out the current PC
885 when we stepi/nexti into the middle of a source
886 line. Only the command line really wants this
887 behavior. Other UIs probably would like the
888 ability to decide for themselves if it is desired. */
889 if (opts
.addressprint
&& mid_statement
)
891 ui_out_field_core_addr (uiout
, "addr",
892 gdbarch
, get_frame_pc (frame
));
893 ui_out_text (uiout
, "\t");
896 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
900 /* If disassemble-next-line is set to on and there is line debug
901 messages, output assembly codes for next line. */
902 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
903 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
906 if (print_what
!= LOCATION
)
910 if (get_frame_pc_if_available (frame
, &pc
))
911 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
913 set_last_displayed_sal (0, 0, 0, 0, 0);
916 annotate_frame_end ();
918 gdb_flush (gdb_stdout
);
921 /* Remember the last symtab and line we displayed, which we use e.g.
922 * as the place to put a breakpoint when the `break' command is
923 * invoked with no arguments. */
926 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
927 CORE_ADDR addr
, struct symtab
*symtab
,
930 last_displayed_sal_valid
= valid
;
931 last_displayed_pspace
= pspace
;
932 last_displayed_addr
= addr
;
933 last_displayed_symtab
= symtab
;
934 last_displayed_line
= line
;
935 if (valid
&& pspace
== NULL
)
937 clear_last_displayed_sal ();
938 internal_error (__FILE__
, __LINE__
,
939 _("Trying to set NULL pspace."));
943 /* Forget the last sal we displayed. */
946 clear_last_displayed_sal (void)
948 last_displayed_sal_valid
= 0;
949 last_displayed_pspace
= 0;
950 last_displayed_addr
= 0;
951 last_displayed_symtab
= 0;
952 last_displayed_line
= 0;
955 /* Is our record of the last sal we displayed valid? If not,
956 * the get_last_displayed_* functions will return NULL or 0, as
960 last_displayed_sal_is_valid (void)
962 return last_displayed_sal_valid
;
965 /* Get the pspace of the last sal we displayed, if it's valid. */
967 struct program_space
*
968 get_last_displayed_pspace (void)
970 if (last_displayed_sal_valid
)
971 return last_displayed_pspace
;
975 /* Get the address of the last sal we displayed, if it's valid. */
978 get_last_displayed_addr (void)
980 if (last_displayed_sal_valid
)
981 return last_displayed_addr
;
985 /* Get the symtab of the last sal we displayed, if it's valid. */
988 get_last_displayed_symtab (void)
990 if (last_displayed_sal_valid
)
991 return last_displayed_symtab
;
995 /* Get the line of the last sal we displayed, if it's valid. */
998 get_last_displayed_line (void)
1000 if (last_displayed_sal_valid
)
1001 return last_displayed_line
;
1005 /* Get the last sal we displayed, if it's valid. */
1008 get_last_displayed_sal (struct symtab_and_line
*sal
)
1010 if (last_displayed_sal_valid
)
1012 sal
->pspace
= last_displayed_pspace
;
1013 sal
->pc
= last_displayed_addr
;
1014 sal
->symtab
= last_displayed_symtab
;
1015 sal
->line
= last_displayed_line
;
1027 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1028 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1031 find_frame_funname (struct frame_info
*frame
, char **funname
,
1032 enum language
*funlang
, struct symbol
**funcp
)
1034 struct symbol
*func
;
1037 *funlang
= language_unknown
;
1041 func
= get_frame_function (frame
);
1044 /* In certain pathological cases, the symtabs give the wrong
1045 function (when we are in the first function in a file which
1046 is compiled without debugging symbols, the previous function
1047 is compiled with debugging symbols, and the "foo.o" symbol
1048 that is supposed to tell us where the file with debugging
1049 symbols ends has been truncated by ar because it is longer
1050 than 15 characters). This also occurs if the user uses asm()
1051 to create a function but not stabs for it (in a file compiled
1054 So look in the minimal symbol tables as well, and if it comes
1055 up with a larger address for the function use that instead.
1056 I don't think this can ever cause any problems; there
1057 shouldn't be any minimal symbols in the middle of a function;
1058 if this is ever changed many parts of GDB will need to be
1059 changed (and we'll create a find_pc_minimal_function or some
1062 struct bound_minimal_symbol msymbol
;
1064 /* Don't attempt to do this for inlined functions, which do not
1065 have a corresponding minimal symbol. */
1066 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1068 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1070 memset (&msymbol
, 0, sizeof (msymbol
));
1072 if (msymbol
.minsym
!= NULL
1073 && (SYMBOL_VALUE_ADDRESS (msymbol
.minsym
)
1074 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1076 /* We also don't know anything about the function besides
1077 its address and name. */
1079 *funname
= xstrdup (SYMBOL_PRINT_NAME (msymbol
.minsym
));
1080 *funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1084 *funname
= xstrdup (SYMBOL_PRINT_NAME (func
));
1085 *funlang
= SYMBOL_LANGUAGE (func
);
1088 if (*funlang
== language_cplus
)
1090 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1091 to display the demangled name that we already have
1092 stored in the symbol table, but we stored a version
1093 with DMGL_PARAMS turned on, and here we don't want to
1094 display parameters. So remove the parameters. */
1095 char *func_only
= cp_remove_params (*funname
);
1100 *funname
= func_only
;
1107 struct bound_minimal_symbol msymbol
;
1110 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1113 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1114 if (msymbol
.minsym
!= NULL
)
1116 *funname
= xstrdup (SYMBOL_PRINT_NAME (msymbol
.minsym
));
1117 *funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1123 print_frame (struct frame_info
*frame
, int print_level
,
1124 enum print_what print_what
, int print_args
,
1125 struct symtab_and_line sal
)
1127 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1128 struct ui_out
*uiout
= current_uiout
;
1129 char *funname
= NULL
;
1130 enum language funlang
= language_unknown
;
1131 struct ui_file
*stb
;
1132 struct cleanup
*old_chain
, *list_chain
;
1133 struct value_print_options opts
;
1134 struct symbol
*func
;
1138 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1140 stb
= mem_fileopen ();
1141 old_chain
= make_cleanup_ui_file_delete (stb
);
1143 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1144 make_cleanup (xfree
, funname
);
1146 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1149 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1153 ui_out_text (uiout
, "#");
1154 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1155 frame_relative_level (frame
));
1157 get_user_print_options (&opts
);
1158 if (opts
.addressprint
)
1160 || frame_show_address (frame
, sal
)
1161 || print_what
== LOC_AND_ADDRESS
)
1163 annotate_frame_address ();
1165 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1167 ui_out_field_string (uiout
, "addr", "<unavailable>");
1168 annotate_frame_address_end ();
1169 ui_out_text (uiout
, " in ");
1171 annotate_frame_function_name ();
1172 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1173 funlang
, DMGL_ANSI
);
1174 ui_out_field_stream (uiout
, "func", stb
);
1175 ui_out_wrap_hint (uiout
, " ");
1176 annotate_frame_args ();
1178 ui_out_text (uiout
, " (");
1181 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1183 struct cleanup
*args_list_chain
;
1184 volatile struct gdb_exception e
;
1186 if (gdbarch_frame_num_args_p (gdbarch
))
1188 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1189 gdb_assert (numargs
>= 0);
1194 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1195 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1197 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1199 /* FIXME: ARGS must be a list. If one argument is a string it
1200 will have " that will not be properly escaped. */
1201 /* Invoke ui_out_tuple_end. */
1202 do_cleanups (args_list_chain
);
1205 ui_out_text (uiout
, ")");
1208 const char *filename_display
;
1210 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1211 annotate_frame_source_begin ();
1212 ui_out_wrap_hint (uiout
, " ");
1213 ui_out_text (uiout
, " at ");
1214 annotate_frame_source_file ();
1215 ui_out_field_string (uiout
, "file", filename_display
);
1216 if (ui_out_is_mi_like_p (uiout
))
1218 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1220 ui_out_field_string (uiout
, "fullname", fullname
);
1222 annotate_frame_source_file_end ();
1223 ui_out_text (uiout
, ":");
1224 annotate_frame_source_line ();
1225 ui_out_field_int (uiout
, "line", sal
.line
);
1226 annotate_frame_source_end ();
1229 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1231 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1232 get_frame_pc (frame
));
1236 annotate_frame_where ();
1237 ui_out_wrap_hint (uiout
, " ");
1238 ui_out_text (uiout
, " from ");
1239 ui_out_field_string (uiout
, "from", lib
);
1243 /* do_cleanups will call ui_out_tuple_end() for us. */
1244 do_cleanups (list_chain
);
1245 ui_out_text (uiout
, "\n");
1246 do_cleanups (old_chain
);
1250 /* Read a frame specification in whatever the appropriate format is
1251 from FRAME_EXP. Call error(), printing MESSAGE, if the
1252 specification is in any way invalid (so this function never returns
1253 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1254 the default selected frame was used. */
1256 static struct frame_info
*
1257 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1258 int *selected_frame_p
)
1261 struct value
*args
[4];
1262 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1264 if (frame_exp
== NULL
)
1272 struct cleanup
*cleanup
;
1275 /* Skip leading white space, bail of EOL. */
1276 frame_exp
= skip_spaces_const (frame_exp
);
1280 /* Parse the argument, extract it, save it. */
1282 *p
&& !isspace (*p
);
1284 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1286 cleanup
= make_cleanup (xfree
, addr_string
);
1288 /* NOTE: Parse and evaluate expression, but do not use
1289 functions such as parse_and_eval_long or
1290 parse_and_eval_address to also extract the value.
1291 Instead value_as_long and value_as_address are used.
1292 This avoids problems with expressions that contain
1294 if (numargs
>= ARRAY_SIZE (args
))
1295 error (_("Too many args in frame specification"));
1296 args
[numargs
++] = parse_and_eval (addr_string
);
1298 do_cleanups (cleanup
);
1302 /* If no args, default to the selected frame. */
1305 if (selected_frame_p
!= NULL
)
1306 (*selected_frame_p
) = 1;
1307 return get_selected_frame (message
);
1310 /* None of the remaining use the selected frame. */
1311 if (selected_frame_p
!= NULL
)
1312 (*selected_frame_p
) = 0;
1314 /* Assume the single arg[0] is an integer, and try using that to
1315 select a frame relative to current. */
1318 struct frame_info
*fid
;
1319 int level
= value_as_long (args
[0]);
1321 fid
= find_relative_frame (get_current_frame (), &level
);
1323 /* find_relative_frame was successful. */
1327 /* Convert each value into a corresponding address. */
1331 for (i
= 0; i
< numargs
; i
++)
1332 addrs
[i
] = value_as_address (args
[i
]);
1335 /* Assume that the single arg[0] is an address, use that to identify
1336 a frame with a matching ID. Should this also accept stack/pc or
1337 stack/pc/special. */
1340 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1341 struct frame_info
*fid
;
1343 /* If (s)he specifies the frame with an address, he deserves
1344 what (s)he gets. Still, give the highest one that matches.
1345 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1347 for (fid
= get_current_frame ();
1349 fid
= get_prev_frame (fid
))
1351 if (frame_id_eq (id
, get_frame_id (fid
)))
1353 struct frame_info
*prev_frame
;
1357 prev_frame
= get_prev_frame (fid
);
1359 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1368 /* We couldn't identify the frame as an existing frame, but
1369 perhaps we can create one with a single argument. */
1371 return create_new_frame (addrs
[0], 0);
1372 else if (numargs
== 2)
1373 return create_new_frame (addrs
[0], addrs
[1]);
1375 error (_("Too many args in frame specification"));
1378 static struct frame_info
*
1379 parse_frame_specification (char *frame_exp
)
1381 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1384 /* Print verbosely the selected frame or the frame at address
1385 ADDR_EXP. Absolutely all information in the frame is printed. */
1388 frame_info (char *addr_exp
, int from_tty
)
1390 struct frame_info
*fi
;
1391 struct symtab_and_line sal
;
1392 struct symbol
*func
;
1394 struct frame_info
*calling_frame_info
;
1396 const char *funname
= 0;
1397 enum language funlang
= language_unknown
;
1398 const char *pc_regname
;
1399 int selected_frame_p
;
1400 struct gdbarch
*gdbarch
;
1401 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1404 CORE_ADDR caller_pc
;
1406 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1407 gdbarch
= get_frame_arch (fi
);
1409 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1410 is not a good name. */
1411 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1412 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1413 easily not match that of the internal value returned by
1415 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1417 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1418 architectures will often have a hardware register called "pc",
1419 and that register's value, again, can easily not match
1423 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1424 find_frame_sal (fi
, &sal
);
1425 func
= get_frame_function (fi
);
1429 funname
= SYMBOL_PRINT_NAME (func
);
1430 funlang
= SYMBOL_LANGUAGE (func
);
1431 if (funlang
== language_cplus
)
1433 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1434 to display the demangled name that we already have
1435 stored in the symbol table, but we stored a version
1436 with DMGL_PARAMS turned on, and here we don't want to
1437 display parameters. So remove the parameters. */
1438 char *func_only
= cp_remove_params (funname
);
1442 funname
= func_only
;
1443 make_cleanup (xfree
, func_only
);
1447 else if (frame_pc_p
)
1449 struct bound_minimal_symbol msymbol
;
1451 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1452 if (msymbol
.minsym
!= NULL
)
1454 funname
= SYMBOL_PRINT_NAME (msymbol
.minsym
);
1455 funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1458 calling_frame_info
= get_prev_frame (fi
);
1460 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1462 printf_filtered (_("Stack level %d, frame at "),
1463 frame_relative_level (fi
));
1467 printf_filtered (_("Stack frame at "));
1469 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1470 printf_filtered (":\n");
1471 printf_filtered (" %s = ", pc_regname
);
1473 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1475 fputs_filtered ("<unavailable>", gdb_stdout
);
1480 printf_filtered (" in ");
1481 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1482 DMGL_ANSI
| DMGL_PARAMS
);
1486 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1488 puts_filtered ("; ");
1490 printf_filtered ("saved %s ", pc_regname
);
1491 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1492 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1494 fputs_filtered ("<unavailable>", gdb_stdout
);
1495 printf_filtered ("\n");
1497 if (calling_frame_info
== NULL
)
1499 enum unwind_stop_reason reason
;
1501 reason
= get_frame_unwind_stop_reason (fi
);
1502 if (reason
!= UNWIND_NO_REASON
)
1503 printf_filtered (_(" Outermost frame: %s\n"),
1504 frame_stop_reason_string (reason
));
1506 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1507 puts_filtered (" tail call frame");
1508 else if (get_frame_type (fi
) == INLINE_FRAME
)
1509 printf_filtered (" inlined into frame %d",
1510 frame_relative_level (get_prev_frame (fi
)));
1513 printf_filtered (" called by frame at ");
1514 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1517 if (get_next_frame (fi
) && calling_frame_info
)
1518 puts_filtered (",");
1520 if (get_next_frame (fi
))
1522 printf_filtered (" caller of frame at ");
1523 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1526 if (get_next_frame (fi
) || calling_frame_info
)
1527 puts_filtered ("\n");
1530 printf_filtered (" source language %s.\n",
1531 language_str (s
->language
));
1534 /* Address of the argument list for this frame, or 0. */
1535 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1536 /* Number of args for this frame, or -1 if unknown. */
1540 printf_filtered (" Arglist at unknown address.\n");
1543 printf_filtered (" Arglist at ");
1544 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1545 printf_filtered (",");
1547 if (!gdbarch_frame_num_args_p (gdbarch
))
1550 puts_filtered (" args: ");
1554 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1555 gdb_assert (numargs
>= 0);
1557 puts_filtered (" no args.");
1558 else if (numargs
== 1)
1559 puts_filtered (" 1 arg: ");
1561 printf_filtered (" %d args: ", numargs
);
1563 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1564 puts_filtered ("\n");
1568 /* Address of the local variables for this frame, or 0. */
1569 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1572 printf_filtered (" Locals at unknown address,");
1575 printf_filtered (" Locals at ");
1576 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1577 printf_filtered (",");
1581 /* Print as much information as possible on the location of all the
1584 enum lval_type lval
;
1593 /* The sp is special; what's displayed isn't the save address, but
1594 the value of the previous frame's sp. This is a legacy thing,
1595 at one stage the frame cached the previous frame's SP instead
1596 of its address, hence it was easiest to just display the cached
1598 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1600 /* Find out the location of the saved stack pointer with out
1601 actually evaluating it. */
1602 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1603 &optimized
, &unavailable
, &lval
, &addr
,
1605 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1607 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1608 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1609 gdb_byte value
[MAX_REGISTER_SIZE
];
1612 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1613 &optimized
, &unavailable
, &lval
, &addr
,
1615 /* NOTE: cagney/2003-05-22: This is assuming that the
1616 stack pointer was packed as an unsigned integer. That
1617 may or may not be valid. */
1618 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1619 printf_filtered (" Previous frame's sp is ");
1620 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1621 printf_filtered ("\n");
1624 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1626 printf_filtered (" Previous frame's sp at ");
1627 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1628 printf_filtered ("\n");
1631 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1633 printf_filtered (" Previous frame's sp in %s\n",
1634 gdbarch_register_name (gdbarch
, realnum
));
1637 /* else keep quiet. */
1641 numregs
= gdbarch_num_regs (gdbarch
)
1642 + gdbarch_num_pseudo_regs (gdbarch
);
1643 for (i
= 0; i
< numregs
; i
++)
1644 if (i
!= gdbarch_sp_regnum (gdbarch
)
1645 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1647 /* Find out the location of the saved register without
1648 fetching the corresponding value. */
1649 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1650 &lval
, &addr
, &realnum
, NULL
);
1651 /* For moment, only display registers that were saved on the
1653 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1656 puts_filtered (" Saved registers:\n ");
1658 puts_filtered (",");
1660 printf_filtered (" %s at ",
1661 gdbarch_register_name (gdbarch
, i
));
1662 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1666 if (count
|| need_nl
)
1667 puts_filtered ("\n");
1670 do_cleanups (back_to
);
1673 /* Print briefly all stack frames or just the innermost COUNT_EXP
1677 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1680 struct frame_info
*fi
;
1683 struct frame_info
*trailing
;
1684 int trailing_level
, py_start
= 0, py_end
= 0;
1685 enum py_bt_status result
= PY_BT_ERROR
;
1687 if (!target_has_stack
)
1688 error (_("No stack."));
1690 /* The following code must do two things. First, it must set the
1691 variable TRAILING to the frame from which we should start
1692 printing. Second, it must set the variable count to the number
1693 of frames which we should print, or -1 if all of them. */
1694 trailing
= get_current_frame ();
1699 count
= parse_and_eval_long (count_exp
);
1702 struct frame_info
*current
;
1708 while (current
&& count
--)
1711 current
= get_prev_frame (current
);
1714 /* Will stop when CURRENT reaches the top of the stack.
1715 TRAILING will be COUNT below it. */
1719 trailing
= get_prev_frame (trailing
);
1720 current
= get_prev_frame (current
);
1740 /* Read in symbols for all of the frames. Need to do this in a
1741 separate pass so that "Reading in symbols for xxx" messages
1742 don't screw up the appearance of the backtrace. Also if
1743 people have strong opinions against reading symbols for
1744 backtrace this may have to be an option. */
1746 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1751 pc
= get_frame_address_in_block (fi
);
1752 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1758 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1759 enum py_frame_args arg_type
;
1762 flags
|= PRINT_LOCALS
;
1764 if (!strcmp (print_frame_arguments
, "scalars"))
1765 arg_type
= CLI_SCALAR_VALUES
;
1766 else if (!strcmp (print_frame_arguments
, "all"))
1767 arg_type
= CLI_ALL_VALUES
;
1769 arg_type
= NO_VALUES
;
1771 result
= apply_frame_filter (get_current_frame (), flags
, arg_type
,
1772 current_uiout
, py_start
, py_end
);
1775 /* Run the inbuilt backtrace if there are no filters registered, or
1776 "no-filters" has been specified from the command. */
1777 if (no_filters
|| result
== PY_BT_NO_FILTERS
)
1779 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1783 /* Don't use print_stack_frame; if an error() occurs it probably
1784 means further attempts to backtrace would fail (on the other
1785 hand, perhaps the code does or could be fixed to make sure
1786 the frame->prev field gets set to NULL in that case). */
1788 print_frame_info (fi
, 1, LOCATION
, 1);
1791 struct frame_id frame_id
= get_frame_id (fi
);
1793 print_frame_local_vars (fi
, 1, gdb_stdout
);
1795 /* print_frame_local_vars invalidates FI. */
1796 fi
= frame_find_by_id (frame_id
);
1800 warning (_("Unable to restore previously selected frame."));
1805 /* Save the last frame to check for error conditions. */
1809 /* If we've stopped before the end, mention that. */
1811 printf_filtered (_("(More stack frames follow...)\n"));
1813 /* If we've run out of frames, and the reason appears to be an error
1814 condition, print it. */
1815 if (fi
== NULL
&& trailing
!= NULL
)
1817 enum unwind_stop_reason reason
;
1819 reason
= get_frame_unwind_stop_reason (trailing
);
1820 if (reason
>= UNWIND_FIRST_ERROR
)
1821 printf_filtered (_("Backtrace stopped: %s\n"),
1822 frame_stop_reason_string (reason
));
1828 backtrace_command (char *arg
, int from_tty
)
1830 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1831 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1839 argv
= gdb_buildargv (arg
);
1840 make_cleanup_freeargv (argv
);
1842 for (i
= 0; argv
[i
]; i
++)
1846 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1847 argv
[i
][j
] = tolower (argv
[i
][j
]);
1849 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1853 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1854 fulltrace_arg
= argc
;
1858 arglen
+= strlen (argv
[i
]);
1864 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1868 arg
= xmalloc (arglen
+ 1);
1869 make_cleanup (xfree
, arg
);
1871 for (i
= 0; i
< argc
; i
++)
1873 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1875 strcat (arg
, argv
[i
]);
1885 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1886 no_filters
>= 0 /* no frame-filters */, from_tty
);
1888 do_cleanups (old_chain
);
1892 backtrace_full_command (char *arg
, int from_tty
)
1894 backtrace_command_1 (arg
, 1 /* show_locals */, 0, from_tty
);
1898 /* Iterate over the local variables of a block B, calling CB with
1902 iterate_over_block_locals (struct block
*b
,
1903 iterate_over_block_arg_local_vars_cb cb
,
1906 struct block_iterator iter
;
1909 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1911 switch (SYMBOL_CLASS (sym
))
1917 if (SYMBOL_IS_ARGUMENT (sym
))
1919 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1921 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1925 /* Ignore symbols which are not locals. */
1932 /* Same, but print labels. */
1935 /* Commented out, as the code using this function has also been
1936 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1937 was commented out in the first place. The discussion introducing
1938 this change (2007-12-04: Support lexical blocks and function bodies
1939 that occupy non-contiguous address ranges) did not explain why
1940 this change was made. */
1942 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1943 int *have_default
, struct ui_file
*stream
)
1945 struct block_iterator iter
;
1947 int values_printed
= 0;
1949 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1951 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1957 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1959 struct symtab_and_line sal
;
1960 struct value_print_options opts
;
1962 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1964 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1965 get_user_print_options (&opts
);
1966 if (opts
.addressprint
)
1968 fprintf_filtered (stream
, " ");
1969 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1972 fprintf_filtered (stream
, " in file %s, line %d\n",
1973 sal
.symtab
->filename
, sal
.line
);
1977 return values_printed
;
1981 /* Iterate over all the local variables in block B, including all its
1982 superblocks, stopping when the top-level block is reached. */
1985 iterate_over_block_local_vars (struct block
*block
,
1986 iterate_over_block_arg_local_vars_cb cb
,
1991 iterate_over_block_locals (block
, cb
, cb_data
);
1992 /* After handling the function's top-level block, stop. Don't
1993 continue to its superblock, the block of per-file
1995 if (BLOCK_FUNCTION (block
))
1997 block
= BLOCK_SUPERBLOCK (block
);
2001 /* Data to be passed around in the calls to the locals and args
2004 struct print_variable_and_value_data
2006 struct frame_id frame_id
;
2008 struct ui_file
*stream
;
2012 /* The callback for the locals and args iterators. */
2015 do_print_variable_and_value (const char *print_name
,
2019 struct print_variable_and_value_data
*p
= cb_data
;
2020 struct frame_info
*frame
;
2022 frame
= frame_find_by_id (p
->frame_id
);
2025 warning (_("Unable to restore previously selected frame."));
2029 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2031 /* print_variable_and_value invalidates FRAME. */
2034 p
->values_printed
= 1;
2037 /* Print all variables from the innermost up to the function block of FRAME.
2038 Print them with values to STREAM indented by NUM_TABS.
2040 This function will invalidate FRAME. */
2043 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2044 struct ui_file
*stream
)
2046 struct print_variable_and_value_data cb_data
;
2047 struct block
*block
;
2050 if (!get_frame_pc_if_available (frame
, &pc
))
2052 fprintf_filtered (stream
,
2053 _("PC unavailable, cannot determine locals.\n"));
2057 block
= get_frame_block (frame
, 0);
2060 fprintf_filtered (stream
, "No symbol table info available.\n");
2064 cb_data
.frame_id
= get_frame_id (frame
);
2065 cb_data
.num_tabs
= 4 * num_tabs
;
2066 cb_data
.stream
= stream
;
2067 cb_data
.values_printed
= 0;
2069 iterate_over_block_local_vars (block
,
2070 do_print_variable_and_value
,
2073 /* do_print_variable_and_value invalidates FRAME. */
2076 if (!cb_data
.values_printed
)
2077 fprintf_filtered (stream
, _("No locals.\n"));
2081 locals_info (char *args
, int from_tty
)
2083 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2087 /* Iterate over all the argument variables in block B.
2089 Returns 1 if any argument was walked; 0 otherwise. */
2092 iterate_over_block_arg_vars (struct block
*b
,
2093 iterate_over_block_arg_local_vars_cb cb
,
2096 struct block_iterator iter
;
2097 struct symbol
*sym
, *sym2
;
2099 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2101 /* Don't worry about things which aren't arguments. */
2102 if (SYMBOL_IS_ARGUMENT (sym
))
2104 /* We have to look up the symbol because arguments can have
2105 two entries (one a parameter, one a local) and the one we
2106 want is the local, which lookup_symbol will find for us.
2107 This includes gcc1 (not gcc2) on the sparc when passing a
2108 small structure and gcc2 when the argument type is float
2109 and it is passed as a double and converted to float by
2110 the prologue (in the latter case the type of the LOC_ARG
2111 symbol is double and the type of the LOC_LOCAL symbol is
2112 float). There are also LOC_ARG/LOC_REGISTER pairs which
2113 are not combined in symbol-reading. */
2115 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2116 b
, VAR_DOMAIN
, NULL
);
2117 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2122 /* Print all argument variables of the function of FRAME.
2123 Print them with values to STREAM.
2125 This function will invalidate FRAME. */
2128 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2130 struct print_variable_and_value_data cb_data
;
2131 struct symbol
*func
;
2134 if (!get_frame_pc_if_available (frame
, &pc
))
2136 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2140 func
= get_frame_function (frame
);
2143 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2147 cb_data
.frame_id
= get_frame_id (frame
);
2148 cb_data
.num_tabs
= 0;
2149 cb_data
.stream
= gdb_stdout
;
2150 cb_data
.values_printed
= 0;
2152 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2153 do_print_variable_and_value
, &cb_data
);
2155 /* do_print_variable_and_value invalidates FRAME. */
2158 if (!cb_data
.values_printed
)
2159 fprintf_filtered (stream
, _("No arguments.\n"));
2163 args_info (char *ignore
, int from_tty
)
2165 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2171 args_plus_locals_info (char *ignore
, int from_tty
)
2173 args_info (ignore
, from_tty
);
2174 locals_info (ignore
, from_tty
);
2178 /* Select frame FRAME. Also print the stack frame and show the source
2179 if this is the tui version. */
2181 select_and_print_frame (struct frame_info
*frame
)
2183 select_frame (frame
);
2185 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2188 /* Return the symbol-block in which the selected frame is executing.
2189 Can return zero under various legitimate circumstances.
2191 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2192 code address within the block returned. We use this to decide
2193 which macros are in scope. */
2196 get_selected_block (CORE_ADDR
*addr_in_block
)
2198 if (!has_stack_frames ())
2201 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2204 /* Find a frame a certain number of levels away from FRAME.
2205 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2206 Positive means go to earlier frames (up); negative, the reverse.
2207 The int that contains the number of levels is counted toward
2208 zero as the frames for those levels are found.
2209 If the top or bottom frame is reached, that frame is returned,
2210 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2211 how much farther the original request asked to go. */
2214 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2216 /* Going up is simple: just call get_prev_frame enough times or
2217 until the initial frame is reached. */
2218 while (*level_offset_ptr
> 0)
2220 struct frame_info
*prev
= get_prev_frame (frame
);
2224 (*level_offset_ptr
)--;
2228 /* Going down is just as simple. */
2229 while (*level_offset_ptr
< 0)
2231 struct frame_info
*next
= get_next_frame (frame
);
2235 (*level_offset_ptr
)++;
2242 /* The "select_frame" command. With no argument this is a NOP.
2243 Select the frame at level LEVEL_EXP if it is a valid level.
2244 Otherwise, treat LEVEL_EXP as an address expression and select it.
2246 See parse_frame_specification for more info on proper frame
2250 select_frame_command (char *level_exp
, int from_tty
)
2252 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2255 /* The "frame" command. With no argument, print the selected frame
2256 briefly. With an argument, behave like select_frame and then print
2257 the selected frame. */
2260 frame_command (char *level_exp
, int from_tty
)
2262 select_frame_command (level_exp
, from_tty
);
2263 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2266 /* The XDB Compatibility command to print the current frame. */
2269 current_frame_command (char *level_exp
, int from_tty
)
2271 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2274 /* Select the frame up one or COUNT_EXP stack levels from the
2275 previously selected frame, and print it briefly. */
2278 up_silently_base (char *count_exp
)
2280 struct frame_info
*frame
;
2284 count
= parse_and_eval_long (count_exp
);
2286 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2287 if (count
!= 0 && count_exp
== NULL
)
2288 error (_("Initial frame selected; you cannot go up."));
2289 select_frame (frame
);
2293 up_silently_command (char *count_exp
, int from_tty
)
2295 up_silently_base (count_exp
);
2299 up_command (char *count_exp
, int from_tty
)
2301 up_silently_base (count_exp
);
2302 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2305 /* Select the frame down one or COUNT_EXP stack levels from the previously
2306 selected frame, and print it briefly. */
2309 down_silently_base (char *count_exp
)
2311 struct frame_info
*frame
;
2315 count
= -parse_and_eval_long (count_exp
);
2317 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2318 if (count
!= 0 && count_exp
== NULL
)
2320 /* We only do this if COUNT_EXP is not specified. That way
2321 "down" means to really go down (and let me know if that is
2322 impossible), but "down 9999" can be used to mean go all the
2323 way down without getting an error. */
2325 error (_("Bottom (innermost) frame selected; you cannot go down."));
2328 select_frame (frame
);
2332 down_silently_command (char *count_exp
, int from_tty
)
2334 down_silently_base (count_exp
);
2338 down_command (char *count_exp
, int from_tty
)
2340 down_silently_base (count_exp
);
2341 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2346 return_command (char *retval_exp
, int from_tty
)
2348 /* Initialize it just to avoid a GCC false warning. */
2349 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2350 struct frame_info
*thisframe
;
2351 struct gdbarch
*gdbarch
;
2352 struct symbol
*thisfun
;
2353 struct value
*return_value
= NULL
;
2354 struct value
*function
= NULL
;
2355 const char *query_prefix
= "";
2357 thisframe
= get_selected_frame ("No selected frame.");
2358 thisfun
= get_frame_function (thisframe
);
2359 gdbarch
= get_frame_arch (thisframe
);
2361 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2362 error (_("Can not force return from an inlined function."));
2364 /* Compute the return value. If the computation triggers an error,
2365 let it bail. If the return type can't be handled, set
2366 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2370 struct expression
*retval_expr
= parse_expression (retval_exp
);
2371 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2372 struct type
*return_type
= NULL
;
2374 /* Compute the return value. Should the computation fail, this
2375 call throws an error. */
2376 return_value
= evaluate_expression (retval_expr
);
2378 /* Cast return value to the return type of the function. Should
2379 the cast fail, this call throws an error. */
2380 if (thisfun
!= NULL
)
2381 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2382 if (return_type
== NULL
)
2384 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2385 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2386 error (_("Return value type not available for selected "
2388 "Please use an explicit cast of the value to return."));
2389 return_type
= value_type (return_value
);
2391 do_cleanups (old_chain
);
2392 CHECK_TYPEDEF (return_type
);
2393 return_value
= value_cast (return_type
, return_value
);
2395 /* Make sure the value is fully evaluated. It may live in the
2396 stack frame we're about to pop. */
2397 if (value_lazy (return_value
))
2398 value_fetch_lazy (return_value
);
2400 if (thisfun
!= NULL
)
2401 function
= read_var_value (thisfun
, thisframe
);
2403 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2404 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2405 /* If the return-type is "void", don't try to find the
2406 return-value's location. However, do still evaluate the
2407 return expression so that, even when the expression result
2408 is discarded, side effects such as "return i++" still
2410 return_value
= NULL
;
2411 else if (thisfun
!= NULL
)
2413 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2414 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2415 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2417 query_prefix
= "The location at which to store the "
2418 "function's return value is unknown.\n"
2419 "If you continue, the return value "
2420 "that you specified will be ignored.\n";
2421 return_value
= NULL
;
2426 /* Does an interactive user really want to do this? Include
2427 information, such as how well GDB can handle the return value, in
2428 the query message. */
2433 if (thisfun
== NULL
)
2434 confirmed
= query (_("%sMake selected stack frame return now? "),
2437 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2438 SYMBOL_PRINT_NAME (thisfun
));
2440 error (_("Not confirmed"));
2443 /* Discard the selected frame and all frames inner-to it. */
2444 frame_pop (get_selected_frame (NULL
));
2446 /* Store RETURN_VALUE in the just-returned register set. */
2447 if (return_value
!= NULL
)
2449 struct type
*return_type
= value_type (return_value
);
2450 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2452 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2453 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2454 gdbarch_return_value (gdbarch
, function
, return_type
,
2455 get_current_regcache (), NULL
/*read*/,
2456 value_contents (return_value
) /*write*/);
2459 /* If we are at the end of a call dummy now, pop the dummy frame
2461 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2462 frame_pop (get_current_frame ());
2464 /* If interactive, print the frame that is now current. */
2466 frame_command ("0", 1);
2468 select_frame_command ("0", 0);
2471 /* Sets the scope to input function name, provided that the function
2472 is within the current stack frame. */
2474 struct function_bounds
2476 CORE_ADDR low
, high
;
2480 func_command (char *arg
, int from_tty
)
2482 struct frame_info
*frame
;
2484 struct symtabs_and_lines sals
;
2487 struct function_bounds
*func_bounds
= NULL
;
2488 struct cleanup
*cleanups
;
2493 frame
= parse_frame_specification ("0");
2494 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2495 cleanups
= make_cleanup (xfree
, sals
.sals
);
2496 func_bounds
= (struct function_bounds
*) xmalloc (
2497 sizeof (struct function_bounds
) * sals
.nelts
);
2498 make_cleanup (xfree
, func_bounds
);
2499 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2501 if (sals
.sals
[i
].pspace
!= current_program_space
)
2502 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2503 else if (sals
.sals
[i
].pc
== 0
2504 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2505 &func_bounds
[i
].low
,
2506 &func_bounds
[i
].high
) == 0)
2508 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2514 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2515 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2516 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2520 frame
= find_relative_frame (frame
, &level
);
2523 while (!found
&& level
== 0);
2525 do_cleanups (cleanups
);
2528 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2529 else if (frame
!= get_selected_frame (NULL
))
2530 select_and_print_frame (frame
);
2533 /* Gets the language of the current frame. */
2536 get_frame_language (void)
2538 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2542 volatile struct gdb_exception ex
;
2546 /* We determine the current frame language by looking up its
2547 associated symtab. To retrieve this symtab, we use the frame
2548 PC. However we cannot use the frame PC as is, because it
2549 usually points to the instruction following the "call", which
2550 is sometimes the first instruction of another function. So
2551 we rely on get_frame_address_in_block(), it provides us with
2552 a PC that is guaranteed to be inside the frame's code
2555 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2557 pc
= get_frame_address_in_block (frame
);
2561 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2562 throw_exception (ex
);
2566 s
= find_pc_symtab (pc
);
2572 return language_unknown
;
2576 /* Provide a prototype to silence -Wmissing-prototypes. */
2577 void _initialize_stack (void);
2580 _initialize_stack (void)
2582 add_com ("return", class_stack
, return_command
, _("\
2583 Make selected stack frame return to its caller.\n\
2584 Control remains in the debugger, but when you continue\n\
2585 execution will resume in the frame above the one now selected.\n\
2586 If an argument is given, it is an expression for the value to return."));
2588 add_com ("up", class_stack
, up_command
, _("\
2589 Select and print stack frame that called this one.\n\
2590 An argument says how many frames up to go."));
2591 add_com ("up-silently", class_support
, up_silently_command
, _("\
2592 Same as the `up' command, but does not print anything.\n\
2593 This is useful in command scripts."));
2595 add_com ("down", class_stack
, down_command
, _("\
2596 Select and print stack frame called by this one.\n\
2597 An argument says how many frames down to go."));
2598 add_com_alias ("do", "down", class_stack
, 1);
2599 add_com_alias ("dow", "down", class_stack
, 1);
2600 add_com ("down-silently", class_support
, down_silently_command
, _("\
2601 Same as the `down' command, but does not print anything.\n\
2602 This is useful in command scripts."));
2604 add_com ("frame", class_stack
, frame_command
, _("\
2605 Select and print a stack frame.\nWith no argument, \
2606 print the selected stack frame. (See also \"info frame\").\n\
2607 An argument specifies the frame to select.\n\
2608 It can be a stack frame number or the address of the frame.\n\
2609 With argument, nothing is printed if input is coming from\n\
2610 a command file or a user-defined command."));
2612 add_com_alias ("f", "frame", class_stack
, 1);
2616 add_com ("L", class_stack
, current_frame_command
,
2617 _("Print the current stack frame.\n"));
2618 add_com_alias ("V", "frame", class_stack
, 1);
2620 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2621 Select a stack frame without printing anything.\n\
2622 An argument specifies the frame to select.\n\
2623 It can be a stack frame number or the address of the frame.\n"));
2625 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2626 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2627 With a negative argument, print outermost -COUNT frames.\nUse of the \
2628 'full' qualifier also prints the values of the local variables.\n\
2629 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2630 on this backtrace.\n"));
2631 add_com_alias ("bt", "backtrace", class_stack
, 0);
2634 add_com_alias ("t", "backtrace", class_stack
, 0);
2635 add_com ("T", class_stack
, backtrace_full_command
, _("\
2636 Print backtrace of all stack frames, or innermost COUNT frames\n\
2637 and the values of the local variables.\n\
2638 With a negative argument, print outermost -COUNT frames.\n\
2639 Usage: T <count>\n"));
2642 add_com_alias ("where", "backtrace", class_alias
, 0);
2643 add_info ("stack", backtrace_command
,
2644 _("Backtrace of the stack, or innermost COUNT frames."));
2645 add_info_alias ("s", "stack", 1);
2646 add_info ("frame", frame_info
,
2647 _("All about selected stack frame, or frame at ADDR."));
2648 add_info_alias ("f", "frame", 1);
2649 add_info ("locals", locals_info
,
2650 _("Local variables of current stack frame."));
2651 add_info ("args", args_info
,
2652 _("Argument variables of current stack frame."));
2654 add_com ("l", class_info
, args_plus_locals_info
,
2655 _("Argument and local variables of current stack frame."));
2658 add_com ("func", class_stack
, func_command
, _("\
2659 Select the stack frame that contains <func>.\n\
2660 Usage: func <name>\n"));
2662 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2663 print_frame_arguments_choices
, &print_frame_arguments
,
2664 _("Set printing of non-scalar frame arguments"),
2665 _("Show printing of non-scalar frame arguments"),
2666 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2668 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2669 &print_raw_frame_arguments
, _("\
2670 Set whether to print frame arguments in raw form."), _("\
2671 Show whether to print frame arguments in raw form."), _("\
2672 If set, frame arguments are printed in raw form, bypassing any\n\
2673 pretty-printers for that value."),
2675 &setprintrawlist
, &showprintrawlist
);
2677 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2678 &disassemble_next_line
, _("\
2679 Set whether to disassemble next source line or insn when execution stops."),
2681 Show whether to disassemble next source line or insn when execution stops."),
2683 If ON, GDB will display disassembly of the next source line, in addition\n\
2684 to displaying the source line itself. If the next source line cannot\n\
2685 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2686 will display disassembly of next instruction instead of showing the\n\
2688 If AUTO, display disassembly of next instruction only if the source line\n\
2689 cannot be displayed.\n\
2690 If OFF (which is the default), never display the disassembly of the next\n\
2693 show_disassemble_next_line
,
2694 &setlist
, &showlist
);
2695 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2697 add_setshow_enum_cmd ("entry-values", class_stack
,
2698 print_entry_values_choices
, &print_entry_values
,
2699 _("Set printing of function arguments at function "
2701 _("Show printing of function arguments at function "
2704 GDB can sometimes determine the values of function arguments at entry,\n\
2705 in addition to their current values. This option tells GDB whether\n\
2706 to print the current value, the value at entry (marked as val@entry),\n\
2707 or both. Note that one or both of these values may be <optimized out>."),
2708 NULL
, NULL
, &setprintlist
, &showprintlist
);