1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
33 #include "breakpoint.h"
40 #include "dictionary.h"
41 #include "exceptions.h"
42 #include "reggroups.h"
46 #include "gdbthread.h"
47 #include "cp-support.h"
49 #include "inline-frame.h"
52 #include "gdb_assert.h"
54 #include "gdb_string.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 *print_frame_arguments_choices
[] =
65 {"all", "scalars", "none", NULL
};
66 static const char *print_frame_arguments
= "scalars";
68 /* The possible choices of "set print entry-values", and the value
71 const char print_entry_values_no
[] = "no";
72 const char print_entry_values_only
[] = "only";
73 const char print_entry_values_preferred
[] = "preferred";
74 const char print_entry_values_if_needed
[] = "if-needed";
75 const char print_entry_values_both
[] = "both";
76 const char print_entry_values_compact
[] = "compact";
77 const char print_entry_values_default
[] = "default";
78 static const char *print_entry_values_choices
[] =
80 print_entry_values_no
,
81 print_entry_values_only
,
82 print_entry_values_preferred
,
83 print_entry_values_if_needed
,
84 print_entry_values_both
,
85 print_entry_values_compact
,
86 print_entry_values_default
,
89 const char *print_entry_values
= print_entry_values_default
;
91 /* Prototypes for local functions. */
93 static void print_frame_local_vars (struct frame_info
*, int,
96 static void print_frame (struct frame_info
*frame
, int print_level
,
97 enum print_what print_what
, int print_args
,
98 struct symtab_and_line sal
);
100 static void set_last_displayed_sal (int valid
,
101 struct program_space
*pspace
,
103 struct symtab
*symtab
,
106 /* Zero means do things normally; we are interacting directly with the
107 user. One means print the full filename and linenumber when a
108 frame is printed, and do so in a format emacs18/emacs19.22 can
109 parse. Two means print similar annotations, but in many more
110 cases and in a slightly different syntax. */
112 int annotation_level
= 0;
114 /* These variables hold the last symtab and line we displayed to the user.
115 * This is where we insert a breakpoint or a skiplist entry by default. */
116 static int last_displayed_sal_valid
= 0;
117 static struct program_space
*last_displayed_pspace
= 0;
118 static CORE_ADDR last_displayed_addr
= 0;
119 static struct symtab
*last_displayed_symtab
= 0;
120 static int last_displayed_line
= 0;
123 /* Return 1 if we should display the address in addition to the location,
124 because we are in the middle of a statement. */
127 frame_show_address (struct frame_info
*frame
,
128 struct symtab_and_line sal
)
130 /* If there is a line number, but no PC, then there is no location
131 information associated with this sal. The only way that should
132 happen is for the call sites of inlined functions (SAL comes from
133 find_frame_sal). Otherwise, we would have some PC range if the
134 SAL came from a line table. */
135 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
137 if (get_next_frame (frame
) == NULL
)
138 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
140 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
144 return get_frame_pc (frame
) != sal
.pc
;
147 /* Show or print a stack frame FRAME briefly. The output is format
148 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
149 relative level, function name, argument list, and file name and
150 line number. If the frame's PC is not at the beginning of the
151 source line, the actual PC is printed at the beginning. */
154 print_stack_frame (struct frame_info
*frame
, int print_level
,
155 enum print_what print_what
)
157 volatile struct gdb_exception e
;
159 /* For mi, alway print location and address. */
160 if (ui_out_is_mi_like_p (current_uiout
))
161 print_what
= LOC_AND_ADDRESS
;
163 TRY_CATCH (e
, RETURN_MASK_ERROR
)
165 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
167 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
168 set_current_sal_from_frame (frame
, center
);
172 /* Print nameless arguments of frame FRAME on STREAM, where START is
173 the offset of the first nameless argument, and NUM is the number of
174 nameless arguments to print. FIRST is nonzero if this is the first
175 argument (not just the first nameless argument). */
178 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
179 int first
, struct ui_file
*stream
)
181 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
182 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
187 for (i
= 0; i
< num
; i
++)
190 argsaddr
= get_frame_args_address (frame
);
193 arg_value
= read_memory_integer (argsaddr
+ start
,
194 sizeof (int), byte_order
);
196 fprintf_filtered (stream
, ", ");
197 fprintf_filtered (stream
, "%ld", arg_value
);
199 start
+= sizeof (int);
203 /* Print single argument of inferior function. ARG must be already
206 Errors are printed as if they would be the parameter value. Use zeroed ARG
207 iff it should not be printed accoring to user settings. */
210 print_frame_arg (const struct frame_arg
*arg
)
212 struct ui_out
*uiout
= current_uiout
;
213 volatile struct gdb_exception except
;
214 struct cleanup
*old_chain
;
215 struct ui_stream
*stb
;
217 stb
= ui_out_stream_new (uiout
);
218 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
220 gdb_assert (!arg
->val
|| !arg
->error
);
221 gdb_assert (arg
->entry_kind
== print_entry_values_no
222 || arg
->entry_kind
== print_entry_values_only
223 || (!ui_out_is_mi_like_p (uiout
)
224 && arg
->entry_kind
== print_entry_values_compact
));
226 annotate_arg_begin ();
228 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
229 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
230 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
231 if (arg
->entry_kind
== print_entry_values_compact
)
233 /* It is OK to provide invalid MI-like stream as with
234 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
235 fputs_filtered ("=", stb
->stream
);
237 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
238 SYMBOL_LANGUAGE (arg
->sym
),
239 DMGL_PARAMS
| DMGL_ANSI
);
241 if (arg
->entry_kind
== print_entry_values_only
242 || arg
->entry_kind
== print_entry_values_compact
)
243 fputs_filtered ("@entry", stb
->stream
);
244 ui_out_field_stream (uiout
, "name", stb
);
245 annotate_arg_name_end ();
246 ui_out_text (uiout
, "=");
248 if (!arg
->val
&& !arg
->error
)
249 ui_out_text (uiout
, "...");
253 except
.message
= arg
->error
;
256 /* TRY_CATCH has two statements, wrap it in a block. */
258 TRY_CATCH (except
, RETURN_MASK_ERROR
)
260 const struct language_defn
*language
;
261 struct value_print_options opts
;
263 /* Avoid value_print because it will deref ref parameters. We
264 just want to print their addresses. Print ??? for args whose
265 address we do not know. We pass 2 as "recurse" to val_print
266 because our standard indentation here is 4 spaces, and
267 val_print indents 2 for each recurse. */
269 annotate_arg_value (value_type (arg
->val
));
271 /* Use the appropriate language to display our symbol, unless the
272 user forced the language to a specific language. */
273 if (language_mode
== language_mode_auto
)
274 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
276 language
= current_language
;
278 get_raw_print_options (&opts
);
281 /* True in "summary" mode, false otherwise. */
282 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
284 common_val_print (arg
->val
, stb
->stream
, 2, &opts
, language
);
288 fprintf_filtered (stb
->stream
, _("<error reading variable: %s>"),
292 ui_out_field_stream (uiout
, "value", stb
);
294 /* Aleo invoke ui_out_tuple_end. */
295 do_cleanups (old_chain
);
300 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
301 responsible for xfree of ARGP->ERROR. This function never throws an
305 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
306 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
308 struct value
*val
= NULL
, *entryval
= NULL
;
309 char *val_error
= NULL
, *entryval_error
= NULL
;
311 volatile struct gdb_exception except
;
313 if (print_entry_values
!= print_entry_values_only
314 && print_entry_values
!= print_entry_values_preferred
)
316 TRY_CATCH (except
, RETURN_MASK_ERROR
)
318 val
= read_var_value (sym
, frame
);
322 val_error
= alloca (strlen (except
.message
) + 1);
323 strcpy (val_error
, except
.message
);
327 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
328 && print_entry_values
!= print_entry_values_no
329 && (print_entry_values
!= print_entry_values_if_needed
330 || !val
|| value_optimized_out (val
)))
332 TRY_CATCH (except
, RETURN_MASK_ERROR
)
334 const struct symbol_computed_ops
*ops
;
336 ops
= SYMBOL_COMPUTED_OPS (sym
);
337 entryval
= ops
->read_variable_at_entry (sym
, frame
);
341 entryval_error
= alloca (strlen (except
.message
) + 1);
342 strcpy (entryval_error
, except
.message
);
345 if (except
.error
== NO_ENTRY_VALUE_ERROR
346 || (entryval
&& value_optimized_out (entryval
)))
349 entryval_error
= NULL
;
352 if (print_entry_values
== print_entry_values_compact
353 || print_entry_values
== print_entry_values_default
)
355 /* For MI do not try to use print_entry_values_compact for ARGP. */
357 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
359 unsigned len
= TYPE_LENGTH (value_type (val
));
361 if (!value_optimized_out (val
) && value_lazy (val
))
362 value_fetch_lazy (val
);
363 if (!value_optimized_out (val
) && value_lazy (entryval
))
364 value_fetch_lazy (entryval
);
365 if (!value_optimized_out (val
)
366 && value_available_contents_eq (val
, 0, entryval
, 0, len
))
368 /* Initialize it just to avoid a GCC false warning. */
369 struct value
*val_deref
= NULL
, *entryval_deref
;
371 /* DW_AT_GNU_call_site_value does match with the current
372 value. If it is a reference still try to verify if
373 dereferenced DW_AT_GNU_call_site_data_value does not
376 TRY_CATCH (except
, RETURN_MASK_ERROR
)
380 val_deref
= coerce_ref (val
);
381 if (value_lazy (val_deref
))
382 value_fetch_lazy (val_deref
);
383 len_deref
= TYPE_LENGTH (value_type (val_deref
));
385 entryval_deref
= coerce_ref (entryval
);
386 if (value_lazy (entryval_deref
))
387 value_fetch_lazy (entryval_deref
);
389 /* If the reference addresses match but dereferenced
390 content does not match print them. */
392 && value_available_contents_eq (val_deref
, 0,
398 /* Value was not a reference; and its content matches. */
399 if (val
== val_deref
)
401 /* If the dereferenced content could not be fetched do not
403 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
405 else if (except
.message
)
407 entryval_error
= alloca (strlen (except
.message
) + 1);
408 strcpy (entryval_error
, except
.message
);
416 /* Try to remove possibly duplicate error message for ENTRYARGP even
419 if (val_error
&& entryval_error
420 && strcmp (val_error
, entryval_error
) == 0)
422 entryval_error
= NULL
;
424 /* Do not se VAL_EQUAL as the same error message may be shown for
425 the entry value even if no entry values are present in the
431 if (entryval
== NULL
)
433 if (print_entry_values
== print_entry_values_preferred
)
435 TRY_CATCH (except
, RETURN_MASK_ERROR
)
437 val
= read_var_value (sym
, frame
);
441 val_error
= alloca (strlen (except
.message
) + 1);
442 strcpy (val_error
, except
.message
);
445 if (print_entry_values
== print_entry_values_only
446 || print_entry_values
== print_entry_values_both
447 || (print_entry_values
== print_entry_values_preferred
448 && (!val
|| value_optimized_out (val
))))
449 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
451 if ((print_entry_values
== print_entry_values_compact
452 || print_entry_values
== print_entry_values_if_needed
453 || print_entry_values
== print_entry_values_preferred
)
454 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
462 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
463 if (!val
&& !val_error
)
464 argp
->entry_kind
= print_entry_values_only
;
465 else if ((print_entry_values
== print_entry_values_compact
466 || print_entry_values
== print_entry_values_default
) && val_equal
)
468 argp
->entry_kind
= print_entry_values_compact
;
469 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
472 argp
->entry_kind
= print_entry_values_no
;
474 entryargp
->sym
= sym
;
475 entryargp
->val
= entryval
;
476 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
477 if (!entryval
&& !entryval_error
)
478 entryargp
->entry_kind
= print_entry_values_no
;
480 entryargp
->entry_kind
= print_entry_values_only
;
483 /* Print the arguments of frame FRAME on STREAM, given the function
484 FUNC running in that frame (as a symbol), where NUM is the number
485 of arguments according to the stack frame (or -1 if the number of
486 arguments is unknown). */
488 /* Note that currently the "number of arguments according to the
489 stack frame" is only known on VAX where i refers to the "number of
490 ints of arguments according to the stack frame". */
493 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
494 int num
, struct ui_file
*stream
)
496 struct ui_out
*uiout
= current_uiout
;
498 /* Offset of next stack argument beyond the one we have seen that is
499 at the highest offset, or -1 if we haven't come to a stack
501 long highest_offset
= -1;
502 /* Number of ints of arguments that we have printed so far. */
503 int args_printed
= 0;
504 struct cleanup
*old_chain
, *list_chain
;
505 struct ui_stream
*stb
;
506 /* True if we should print arguments, false otherwise. */
507 int print_args
= strcmp (print_frame_arguments
, "none");
508 /* True in "summary" mode, false otherwise. */
509 int summary
= !strcmp (print_frame_arguments
, "scalars");
511 stb
= ui_out_stream_new (uiout
);
512 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
516 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
517 struct dict_iterator iter
;
520 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
522 struct frame_arg arg
, entryarg
;
526 /* Keep track of the highest stack argument offset seen, and
527 skip over any kinds of symbols we don't care about. */
529 if (!SYMBOL_IS_ARGUMENT (sym
))
532 switch (SYMBOL_CLASS (sym
))
537 long current_offset
= SYMBOL_VALUE (sym
);
538 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
540 /* Compute address of next argument by adding the size of
541 this argument and rounding to an int boundary. */
543 ((current_offset
+ arg_size
+ sizeof (int) - 1)
544 & ~(sizeof (int) - 1));
546 /* If this is the highest offset seen yet, set
548 if (highest_offset
== -1
549 || (current_offset
> highest_offset
))
550 highest_offset
= current_offset
;
552 /* Add the number of ints we're about to print to
554 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
557 /* We care about types of symbols, but don't need to
558 keep track of stack offsets in them. */
560 case LOC_REGPARM_ADDR
:
562 case LOC_OPTIMIZED_OUT
:
567 /* We have to look up the symbol because arguments can have
568 two entries (one a parameter, one a local) and the one we
569 want is the local, which lookup_symbol will find for us.
570 This includes gcc1 (not gcc2) on SPARC when passing a
571 small structure and gcc2 when the argument type is float
572 and it is passed as a double and converted to float by
573 the prologue (in the latter case the type of the LOC_ARG
574 symbol is double and the type of the LOC_LOCAL symbol is
576 /* But if the parameter name is null, don't try it. Null
577 parameter names occur on the RS/6000, for traceback
578 tables. FIXME, should we even print them? */
580 if (*SYMBOL_LINKAGE_NAME (sym
))
584 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
585 b
, VAR_DOMAIN
, NULL
);
586 gdb_assert (nsym
!= NULL
);
587 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
588 && !SYMBOL_IS_ARGUMENT (nsym
))
590 /* There is a LOC_ARG/LOC_REGISTER pair. This means
591 that it was passed on the stack and loaded into a
592 register, or passed in a register and stored in a
593 stack slot. GDB 3.x used the LOC_ARG; GDB
594 4.0-4.11 used the LOC_REGISTER.
596 Reasons for using the LOC_ARG:
598 (1) Because find_saved_registers may be slow for
601 (2) Because registers are often re-used and stack
602 slots rarely (never?) are. Therefore using
603 the stack slot is much less likely to print
606 Reasons why we might want to use the LOC_REGISTER:
608 (1) So that the backtrace prints the same value
609 as "print foo". I see no compelling reason
610 why this needs to be the case; having the
611 backtrace print the value which was passed
612 in, and "print foo" print the value as
613 modified within the called function, makes
616 Additional note: It might be nice if "info args"
617 displayed both values.
619 One more note: There is a case with SPARC
620 structure passing where we need to use the
621 LOC_REGISTER, but this is dealt with by creating
622 a single LOC_REGPARM in symbol reading. */
624 /* Leave sym (the LOC_ARG) alone. */
631 /* Print the current arg. */
633 ui_out_text (uiout
, ", ");
634 ui_out_wrap_hint (uiout
, " ");
638 memset (&arg
, 0, sizeof (arg
));
640 arg
.entry_kind
= print_entry_values_no
;
641 memset (&entryarg
, 0, sizeof (entryarg
));
643 entryarg
.entry_kind
= print_entry_values_no
;
646 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
648 if (arg
.entry_kind
!= print_entry_values_only
)
649 print_frame_arg (&arg
);
651 if (entryarg
.entry_kind
!= print_entry_values_no
)
653 if (arg
.entry_kind
!= print_entry_values_only
)
655 ui_out_text (uiout
, ", ");
656 ui_out_wrap_hint (uiout
, " ");
659 print_frame_arg (&entryarg
);
663 xfree (entryarg
.error
);
669 /* Don't print nameless args in situations where we don't know
670 enough about the stack to find them. */
675 if (highest_offset
== -1)
676 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
678 start
= highest_offset
;
680 print_frame_nameless_args (frame
, start
, num
- args_printed
,
684 do_cleanups (old_chain
);
687 /* Set the current source and line to the location given by frame
688 FRAME, if possible. When CENTER is true, adjust so the relevant
689 line is in the center of the next 'list'. */
692 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
694 struct symtab_and_line sal
;
696 find_frame_sal (frame
, &sal
);
700 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
701 set_current_source_symtab_and_line (&sal
);
705 /* If ON, GDB will display disassembly of the next source line when
706 execution of the program being debugged stops.
707 If AUTO (which is the default), or there's no line info to determine
708 the source line of the next instruction, display disassembly of next
709 instruction instead. */
711 static enum auto_boolean disassemble_next_line
;
714 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
715 struct cmd_list_element
*c
,
718 fprintf_filtered (file
,
719 _("Debugger's willingness to use "
720 "disassemble-next-line is %s.\n"),
724 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
725 because it will be broken by filter sometime. */
728 do_gdb_disassembly (struct gdbarch
*gdbarch
,
729 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
731 volatile struct gdb_exception exception
;
733 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
735 gdb_disassembly (gdbarch
, current_uiout
, 0,
736 DISASSEMBLY_RAW_INSN
, how_many
,
739 if (exception
.reason
< 0)
741 /* If an exception was thrown while doing the disassembly, print
742 the error message, to give the user a clue of what happened. */
743 exception_print (gdb_stderr
, exception
);
747 /* Print information about frame FRAME. The output is format according
748 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
751 SRC_LINE: Print only source line.
752 LOCATION: Print only location.
753 LOC_AND_SRC: Print location and source line.
755 Used in "where" output, and to emit breakpoint or step
759 print_frame_info (struct frame_info
*frame
, int print_level
,
760 enum print_what print_what
, int print_args
)
762 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
763 struct symtab_and_line sal
;
766 struct ui_out
*uiout
= current_uiout
;
768 if (get_frame_type (frame
) == DUMMY_FRAME
769 || get_frame_type (frame
) == SIGTRAMP_FRAME
770 || get_frame_type (frame
) == ARCH_FRAME
)
772 struct cleanup
*uiout_cleanup
773 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
775 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
776 gdbarch
, get_frame_pc (frame
));
778 /* Do this regardless of SOURCE because we don't have any source
779 to list for this frame. */
782 ui_out_text (uiout
, "#");
783 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
784 frame_relative_level (frame
));
786 if (ui_out_is_mi_like_p (uiout
))
788 annotate_frame_address ();
789 ui_out_field_core_addr (uiout
, "addr",
790 gdbarch
, get_frame_pc (frame
));
791 annotate_frame_address_end ();
794 if (get_frame_type (frame
) == DUMMY_FRAME
)
796 annotate_function_call ();
797 ui_out_field_string (uiout
, "func", "<function called from gdb>");
799 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
801 annotate_signal_handler_caller ();
802 ui_out_field_string (uiout
, "func", "<signal handler called>");
804 else if (get_frame_type (frame
) == ARCH_FRAME
)
806 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
808 ui_out_text (uiout
, "\n");
809 annotate_frame_end ();
811 do_cleanups (uiout_cleanup
);
815 /* If FRAME is not the innermost frame, that normally means that
816 FRAME->pc points to *after* the call instruction, and we want to
817 get the line containing the call, never the next line. But if
818 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
819 next frame was not entered as the result of a call, and we want
820 to get the line containing FRAME->pc. */
821 find_frame_sal (frame
, &sal
);
823 location_print
= (print_what
== LOCATION
824 || print_what
== LOC_AND_ADDRESS
825 || print_what
== SRC_AND_LOC
);
827 if (location_print
|| !sal
.symtab
)
828 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
830 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
832 /* If disassemble-next-line is set to auto or on and doesn't have
833 the line debug messages for $pc, output the next instruction. */
834 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
835 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
836 && source_print
&& !sal
.symtab
)
837 do_gdb_disassembly (get_frame_arch (frame
), 1,
838 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
840 if (source_print
&& sal
.symtab
)
843 int mid_statement
= ((print_what
== SRC_LINE
)
844 && frame_show_address (frame
, sal
));
846 if (annotation_level
)
847 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
848 get_frame_pc (frame
));
851 if (deprecated_print_frame_info_listing_hook
)
852 deprecated_print_frame_info_listing_hook (sal
.symtab
,
857 struct value_print_options opts
;
859 get_user_print_options (&opts
);
860 /* We used to do this earlier, but that is clearly
861 wrong. This function is used by many different
862 parts of gdb, including normal_stop in infrun.c,
863 which uses this to print out the current PC
864 when we stepi/nexti into the middle of a source
865 line. Only the command line really wants this
866 behavior. Other UIs probably would like the
867 ability to decide for themselves if it is desired. */
868 if (opts
.addressprint
&& mid_statement
)
870 ui_out_field_core_addr (uiout
, "addr",
871 gdbarch
, get_frame_pc (frame
));
872 ui_out_text (uiout
, "\t");
875 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
879 /* If disassemble-next-line is set to on and there is line debug
880 messages, output assembly codes for next line. */
881 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
882 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
885 if (print_what
!= LOCATION
)
889 if (get_frame_pc_if_available (frame
, &pc
))
890 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
892 set_last_displayed_sal (0, 0, 0, 0, 0);
895 annotate_frame_end ();
897 gdb_flush (gdb_stdout
);
900 /* Remember the last symtab and line we displayed, which we use e.g.
901 * as the place to put a breakpoint when the `break' command is
902 * invoked with no arguments. */
905 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
906 CORE_ADDR addr
, struct symtab
*symtab
,
909 last_displayed_sal_valid
= valid
;
910 last_displayed_pspace
= pspace
;
911 last_displayed_addr
= addr
;
912 last_displayed_symtab
= symtab
;
913 last_displayed_line
= line
;
916 /* Forget the last sal we displayed. */
919 clear_last_displayed_sal (void)
921 last_displayed_sal_valid
= 0;
922 last_displayed_pspace
= 0;
923 last_displayed_addr
= 0;
924 last_displayed_symtab
= 0;
925 last_displayed_line
= 0;
928 /* Is our record of the last sal we displayed valid? If not,
929 * the get_last_displayed_* functions will return NULL or 0, as
933 last_displayed_sal_is_valid (void)
935 return last_displayed_sal_valid
;
938 /* Get the pspace of the last sal we displayed, if it's valid. */
940 struct program_space
*
941 get_last_displayed_pspace (void)
943 if (last_displayed_sal_valid
)
944 return last_displayed_pspace
;
948 /* Get the address of the last sal we displayed, if it's valid. */
951 get_last_displayed_addr (void)
953 if (last_displayed_sal_valid
)
954 return last_displayed_addr
;
958 /* Get the symtab of the last sal we displayed, if it's valid. */
961 get_last_displayed_symtab (void)
963 if (last_displayed_sal_valid
)
964 return last_displayed_symtab
;
968 /* Get the line of the last sal we displayed, if it's valid. */
971 get_last_displayed_line (void)
973 if (last_displayed_sal_valid
)
974 return last_displayed_line
;
978 /* Get the last sal we displayed, if it's valid. */
981 get_last_displayed_sal (struct symtab_and_line
*sal
)
983 if (last_displayed_sal_valid
)
985 sal
->pspace
= last_displayed_pspace
;
986 sal
->pc
= last_displayed_addr
;
987 sal
->symtab
= last_displayed_symtab
;
988 sal
->line
= last_displayed_line
;
1000 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1001 corresponding to FRAME. */
1004 find_frame_funname (struct frame_info
*frame
, char **funname
,
1005 enum language
*funlang
, struct symbol
**funcp
)
1007 struct symbol
*func
;
1010 *funlang
= language_unknown
;
1014 func
= get_frame_function (frame
);
1017 /* In certain pathological cases, the symtabs give the wrong
1018 function (when we are in the first function in a file which
1019 is compiled without debugging symbols, the previous function
1020 is compiled with debugging symbols, and the "foo.o" symbol
1021 that is supposed to tell us where the file with debugging
1022 symbols ends has been truncated by ar because it is longer
1023 than 15 characters). This also occurs if the user uses asm()
1024 to create a function but not stabs for it (in a file compiled
1027 So look in the minimal symbol tables as well, and if it comes
1028 up with a larger address for the function use that instead.
1029 I don't think this can ever cause any problems; there
1030 shouldn't be any minimal symbols in the middle of a function;
1031 if this is ever changed many parts of GDB will need to be
1032 changed (and we'll create a find_pc_minimal_function or some
1035 struct minimal_symbol
*msymbol
= NULL
;
1037 /* Don't attempt to do this for inlined functions, which do not
1038 have a corresponding minimal symbol. */
1039 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1041 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1044 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1045 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1047 /* We also don't know anything about the function besides
1048 its address and name. */
1050 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1051 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1055 *funname
= SYMBOL_PRINT_NAME (func
);
1056 *funlang
= SYMBOL_LANGUAGE (func
);
1059 if (*funlang
== language_cplus
)
1061 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1062 to display the demangled name that we already have
1063 stored in the symbol table, but we stored a version
1064 with DMGL_PARAMS turned on, and here we don't want to
1065 display parameters. So remove the parameters. */
1066 char *func_only
= cp_remove_params (*funname
);
1070 *funname
= func_only
;
1071 make_cleanup (xfree
, func_only
);
1078 struct minimal_symbol
*msymbol
;
1081 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1084 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1085 if (msymbol
!= NULL
)
1087 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1088 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1094 print_frame (struct frame_info
*frame
, int print_level
,
1095 enum print_what print_what
, int print_args
,
1096 struct symtab_and_line sal
)
1098 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1099 struct ui_out
*uiout
= current_uiout
;
1100 char *funname
= NULL
;
1101 enum language funlang
= language_unknown
;
1102 struct ui_stream
*stb
;
1103 struct cleanup
*old_chain
, *list_chain
;
1104 struct value_print_options opts
;
1105 struct symbol
*func
;
1109 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1111 stb
= ui_out_stream_new (uiout
);
1112 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1114 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1116 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1119 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1123 ui_out_text (uiout
, "#");
1124 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1125 frame_relative_level (frame
));
1127 get_user_print_options (&opts
);
1128 if (opts
.addressprint
)
1130 || frame_show_address (frame
, sal
)
1131 || print_what
== LOC_AND_ADDRESS
)
1133 annotate_frame_address ();
1135 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1137 ui_out_field_string (uiout
, "addr", "<unavailable>");
1138 annotate_frame_address_end ();
1139 ui_out_text (uiout
, " in ");
1141 annotate_frame_function_name ();
1142 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
1143 funlang
, DMGL_ANSI
);
1144 ui_out_field_stream (uiout
, "func", stb
);
1145 ui_out_wrap_hint (uiout
, " ");
1146 annotate_frame_args ();
1148 ui_out_text (uiout
, " (");
1151 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1153 struct cleanup
*args_list_chain
;
1154 volatile struct gdb_exception e
;
1156 if (gdbarch_frame_num_args_p (gdbarch
))
1158 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1159 gdb_assert (numargs
>= 0);
1164 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1165 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1167 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1169 /* FIXME: ARGS must be a list. If one argument is a string it
1170 will have " that will not be properly escaped. */
1171 /* Invoke ui_out_tuple_end. */
1172 do_cleanups (args_list_chain
);
1175 ui_out_text (uiout
, ")");
1176 if (sal
.symtab
&& sal
.symtab
->filename
)
1178 annotate_frame_source_begin ();
1179 ui_out_wrap_hint (uiout
, " ");
1180 ui_out_text (uiout
, " at ");
1181 annotate_frame_source_file ();
1182 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1183 if (ui_out_is_mi_like_p (uiout
))
1185 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1187 if (fullname
!= NULL
)
1188 ui_out_field_string (uiout
, "fullname", fullname
);
1190 annotate_frame_source_file_end ();
1191 ui_out_text (uiout
, ":");
1192 annotate_frame_source_line ();
1193 ui_out_field_int (uiout
, "line", sal
.line
);
1194 annotate_frame_source_end ();
1197 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
1200 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1202 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1203 get_frame_pc (frame
));
1207 annotate_frame_where ();
1208 ui_out_wrap_hint (uiout
, " ");
1209 ui_out_text (uiout
, " from ");
1210 ui_out_field_string (uiout
, "from", lib
);
1214 /* do_cleanups will call ui_out_tuple_end() for us. */
1215 do_cleanups (list_chain
);
1216 ui_out_text (uiout
, "\n");
1217 do_cleanups (old_chain
);
1221 /* Read a frame specification in whatever the appropriate format is
1222 from FRAME_EXP. Call error(), printing MESSAGE, if the
1223 specification is in any way invalid (so this function never returns
1224 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1225 the default selected frame was used. */
1227 static struct frame_info
*
1228 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1229 int *selected_frame_p
)
1232 struct value
*args
[4];
1233 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1235 if (frame_exp
== NULL
)
1243 struct cleanup
*cleanup
;
1246 /* Skip leading white space, bail of EOL. */
1247 while (isspace (*frame_exp
))
1252 /* Parse the argument, extract it, save it. */
1254 *p
&& !isspace (*p
);
1256 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1258 cleanup
= make_cleanup (xfree
, addr_string
);
1260 /* NOTE: Parse and evaluate expression, but do not use
1261 functions such as parse_and_eval_long or
1262 parse_and_eval_address to also extract the value.
1263 Instead value_as_long and value_as_address are used.
1264 This avoids problems with expressions that contain
1266 if (numargs
>= ARRAY_SIZE (args
))
1267 error (_("Too many args in frame specification"));
1268 args
[numargs
++] = parse_and_eval (addr_string
);
1270 do_cleanups (cleanup
);
1274 /* If no args, default to the selected frame. */
1277 if (selected_frame_p
!= NULL
)
1278 (*selected_frame_p
) = 1;
1279 return get_selected_frame (message
);
1282 /* None of the remaining use the selected frame. */
1283 if (selected_frame_p
!= NULL
)
1284 (*selected_frame_p
) = 0;
1286 /* Assume the single arg[0] is an integer, and try using that to
1287 select a frame relative to current. */
1290 struct frame_info
*fid
;
1291 int level
= value_as_long (args
[0]);
1293 fid
= find_relative_frame (get_current_frame (), &level
);
1295 /* find_relative_frame was successful. */
1299 /* Convert each value into a corresponding address. */
1303 for (i
= 0; i
< numargs
; i
++)
1304 addrs
[i
] = value_as_address (args
[i
]);
1307 /* Assume that the single arg[0] is an address, use that to identify
1308 a frame with a matching ID. Should this also accept stack/pc or
1309 stack/pc/special. */
1312 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1313 struct frame_info
*fid
;
1315 /* If (s)he specifies the frame with an address, he deserves
1316 what (s)he gets. Still, give the highest one that matches.
1317 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1319 for (fid
= get_current_frame ();
1321 fid
= get_prev_frame (fid
))
1323 if (frame_id_eq (id
, get_frame_id (fid
)))
1325 struct frame_info
*prev_frame
;
1329 prev_frame
= get_prev_frame (fid
);
1331 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1340 /* We couldn't identify the frame as an existing frame, but
1341 perhaps we can create one with a single argument. */
1343 return create_new_frame (addrs
[0], 0);
1344 else if (numargs
== 2)
1345 return create_new_frame (addrs
[0], addrs
[1]);
1347 error (_("Too many args in frame specification"));
1350 static struct frame_info
*
1351 parse_frame_specification (char *frame_exp
)
1353 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1356 /* Print verbosely the selected frame or the frame at address
1357 ADDR_EXP. Absolutely all information in the frame is printed. */
1360 frame_info (char *addr_exp
, int from_tty
)
1362 struct frame_info
*fi
;
1363 struct symtab_and_line sal
;
1364 struct symbol
*func
;
1366 struct frame_info
*calling_frame_info
;
1369 enum language funlang
= language_unknown
;
1370 const char *pc_regname
;
1371 int selected_frame_p
;
1372 struct gdbarch
*gdbarch
;
1373 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1376 CORE_ADDR caller_pc
;
1378 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1379 gdbarch
= get_frame_arch (fi
);
1381 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1382 is not a good name. */
1383 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1384 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1385 easily not match that of the internal value returned by
1387 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1389 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1390 architectures will often have a hardware register called "pc",
1391 and that register's value, again, can easily not match
1395 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1396 find_frame_sal (fi
, &sal
);
1397 func
= get_frame_function (fi
);
1401 funname
= SYMBOL_PRINT_NAME (func
);
1402 funlang
= SYMBOL_LANGUAGE (func
);
1403 if (funlang
== language_cplus
)
1405 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1406 to display the demangled name that we already have
1407 stored in the symbol table, but we stored a version
1408 with DMGL_PARAMS turned on, and here we don't want to
1409 display parameters. So remove the parameters. */
1410 char *func_only
= cp_remove_params (funname
);
1414 funname
= func_only
;
1415 make_cleanup (xfree
, func_only
);
1419 else if (frame_pc_p
)
1421 struct minimal_symbol
*msymbol
;
1423 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1424 if (msymbol
!= NULL
)
1426 funname
= SYMBOL_PRINT_NAME (msymbol
);
1427 funlang
= SYMBOL_LANGUAGE (msymbol
);
1430 calling_frame_info
= get_prev_frame (fi
);
1432 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1434 printf_filtered (_("Stack level %d, frame at "),
1435 frame_relative_level (fi
));
1439 printf_filtered (_("Stack frame at "));
1441 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1442 printf_filtered (":\n");
1443 printf_filtered (" %s = ", pc_regname
);
1445 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1447 fputs_filtered ("<unavailable>", gdb_stdout
);
1452 printf_filtered (" in ");
1453 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1454 DMGL_ANSI
| DMGL_PARAMS
);
1458 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1459 puts_filtered ("; ");
1461 printf_filtered ("saved %s ", pc_regname
);
1462 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1463 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1465 fputs_filtered ("<unavailable>", gdb_stdout
);
1466 printf_filtered ("\n");
1468 if (calling_frame_info
== NULL
)
1470 enum unwind_stop_reason reason
;
1472 reason
= get_frame_unwind_stop_reason (fi
);
1473 if (reason
!= UNWIND_NO_REASON
)
1474 printf_filtered (_(" Outermost frame: %s\n"),
1475 frame_stop_reason_string (reason
));
1477 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1478 puts_filtered (" tail call frame");
1479 else if (get_frame_type (fi
) == INLINE_FRAME
)
1480 printf_filtered (" inlined into frame %d",
1481 frame_relative_level (get_prev_frame (fi
)));
1484 printf_filtered (" called by frame at ");
1485 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1488 if (get_next_frame (fi
) && calling_frame_info
)
1489 puts_filtered (",");
1491 if (get_next_frame (fi
))
1493 printf_filtered (" caller of frame at ");
1494 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1497 if (get_next_frame (fi
) || calling_frame_info
)
1498 puts_filtered ("\n");
1501 printf_filtered (" source language %s.\n",
1502 language_str (s
->language
));
1505 /* Address of the argument list for this frame, or 0. */
1506 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1507 /* Number of args for this frame, or -1 if unknown. */
1511 printf_filtered (" Arglist at unknown address.\n");
1514 printf_filtered (" Arglist at ");
1515 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1516 printf_filtered (",");
1518 if (!gdbarch_frame_num_args_p (gdbarch
))
1521 puts_filtered (" args: ");
1525 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1526 gdb_assert (numargs
>= 0);
1528 puts_filtered (" no args.");
1529 else if (numargs
== 1)
1530 puts_filtered (" 1 arg: ");
1532 printf_filtered (" %d args: ", numargs
);
1534 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1535 puts_filtered ("\n");
1539 /* Address of the local variables for this frame, or 0. */
1540 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1543 printf_filtered (" Locals at unknown address,");
1546 printf_filtered (" Locals at ");
1547 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1548 printf_filtered (",");
1552 /* Print as much information as possible on the location of all the
1555 enum lval_type lval
;
1564 /* The sp is special; what's displayed isn't the save address, but
1565 the value of the previous frame's sp. This is a legacy thing,
1566 at one stage the frame cached the previous frame's SP instead
1567 of its address, hence it was easiest to just display the cached
1569 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1571 /* Find out the location of the saved stack pointer with out
1572 actually evaluating it. */
1573 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1574 &optimized
, &unavailable
, &lval
, &addr
,
1576 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1578 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1579 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1580 gdb_byte value
[MAX_REGISTER_SIZE
];
1583 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1584 &optimized
, &unavailable
, &lval
, &addr
,
1586 /* NOTE: cagney/2003-05-22: This is assuming that the
1587 stack pointer was packed as an unsigned integer. That
1588 may or may not be valid. */
1589 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1590 printf_filtered (" Previous frame's sp is ");
1591 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1592 printf_filtered ("\n");
1595 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1597 printf_filtered (" Previous frame's sp at ");
1598 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1599 printf_filtered ("\n");
1602 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1604 printf_filtered (" Previous frame's sp in %s\n",
1605 gdbarch_register_name (gdbarch
, realnum
));
1608 /* else keep quiet. */
1612 numregs
= gdbarch_num_regs (gdbarch
)
1613 + gdbarch_num_pseudo_regs (gdbarch
);
1614 for (i
= 0; i
< numregs
; i
++)
1615 if (i
!= gdbarch_sp_regnum (gdbarch
)
1616 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1618 /* Find out the location of the saved register without
1619 fetching the corresponding value. */
1620 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1621 &lval
, &addr
, &realnum
, NULL
);
1622 /* For moment, only display registers that were saved on the
1624 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1627 puts_filtered (" Saved registers:\n ");
1629 puts_filtered (",");
1631 printf_filtered (" %s at ",
1632 gdbarch_register_name (gdbarch
, i
));
1633 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1637 if (count
|| need_nl
)
1638 puts_filtered ("\n");
1641 do_cleanups (back_to
);
1644 /* Print briefly all stack frames or just the innermost COUNT_EXP
1648 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1650 struct frame_info
*fi
;
1653 struct frame_info
*trailing
;
1656 if (!target_has_stack
)
1657 error (_("No stack."));
1659 /* The following code must do two things. First, it must set the
1660 variable TRAILING to the frame from which we should start
1661 printing. Second, it must set the variable count to the number
1662 of frames which we should print, or -1 if all of them. */
1663 trailing
= get_current_frame ();
1668 count
= parse_and_eval_long (count_exp
);
1671 struct frame_info
*current
;
1676 while (current
&& count
--)
1679 current
= get_prev_frame (current
);
1682 /* Will stop when CURRENT reaches the top of the stack.
1683 TRAILING will be COUNT below it. */
1687 trailing
= get_prev_frame (trailing
);
1688 current
= get_prev_frame (current
);
1700 /* Read in symbols for all of the frames. Need to do this in a
1701 separate pass so that "Reading in symbols for xxx" messages
1702 don't screw up the appearance of the backtrace. Also if
1703 people have strong opinions against reading symbols for
1704 backtrace this may have to be an option. */
1706 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1711 pc
= get_frame_address_in_block (fi
);
1712 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1716 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1720 /* Don't use print_stack_frame; if an error() occurs it probably
1721 means further attempts to backtrace would fail (on the other
1722 hand, perhaps the code does or could be fixed to make sure
1723 the frame->prev field gets set to NULL in that case). */
1724 print_frame_info (fi
, 1, LOCATION
, 1);
1726 print_frame_local_vars (fi
, 1, gdb_stdout
);
1728 /* Save the last frame to check for error conditions. */
1732 /* If we've stopped before the end, mention that. */
1734 printf_filtered (_("(More stack frames follow...)\n"));
1736 /* If we've run out of frames, and the reason appears to be an error
1737 condition, print it. */
1738 if (fi
== NULL
&& trailing
!= NULL
)
1740 enum unwind_stop_reason reason
;
1742 reason
= get_frame_unwind_stop_reason (trailing
);
1743 if (reason
>= UNWIND_FIRST_ERROR
)
1744 printf_filtered (_("Backtrace stopped: %s\n"),
1745 frame_stop_reason_string (reason
));
1750 backtrace_command (char *arg
, int from_tty
)
1752 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1753 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1760 argv
= gdb_buildargv (arg
);
1761 make_cleanup_freeargv (argv
);
1763 for (i
= 0; argv
[i
]; i
++)
1767 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1768 argv
[i
][j
] = tolower (argv
[i
][j
]);
1770 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1771 fulltrace_arg
= argc
;
1774 arglen
+= strlen (argv
[i
]);
1779 if (fulltrace_arg
>= 0)
1783 arg
= xmalloc (arglen
+ 1);
1784 make_cleanup (xfree
, arg
);
1786 for (i
= 0; i
< (argc
+ 1); i
++)
1788 if (i
!= fulltrace_arg
)
1790 strcat (arg
, argv
[i
]);
1800 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1802 do_cleanups (old_chain
);
1806 backtrace_full_command (char *arg
, int from_tty
)
1808 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1812 /* Iterate over the local variables of a block B, calling CB with
1816 iterate_over_block_locals (struct block
*b
,
1817 iterate_over_block_arg_local_vars_cb cb
,
1820 struct dict_iterator iter
;
1823 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1825 switch (SYMBOL_CLASS (sym
))
1831 if (SYMBOL_IS_ARGUMENT (sym
))
1833 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1837 /* Ignore symbols which are not locals. */
1844 /* Same, but print labels. */
1847 /* Commented out, as the code using this function has also been
1848 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1849 was commented out in the first place. The discussion introducing
1850 this change (2007-12-04: Support lexical blocks and function bodies
1851 that occupy non-contiguous address ranges) did not explain why
1852 this change was made. */
1854 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1855 int *have_default
, struct ui_file
*stream
)
1857 struct dict_iterator iter
;
1859 int values_printed
= 0;
1861 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1863 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1869 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1871 struct symtab_and_line sal
;
1872 struct value_print_options opts
;
1874 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1876 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1877 get_user_print_options (&opts
);
1878 if (opts
.addressprint
)
1880 fprintf_filtered (stream
, " ");
1881 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1884 fprintf_filtered (stream
, " in file %s, line %d\n",
1885 sal
.symtab
->filename
, sal
.line
);
1889 return values_printed
;
1893 /* Iterate over all the local variables in block B, including all its
1894 superblocks, stopping when the top-level block is reached. */
1897 iterate_over_block_local_vars (struct block
*block
,
1898 iterate_over_block_arg_local_vars_cb cb
,
1903 iterate_over_block_locals (block
, cb
, cb_data
);
1904 /* After handling the function's top-level block, stop. Don't
1905 continue to its superblock, the block of per-file
1907 if (BLOCK_FUNCTION (block
))
1909 block
= BLOCK_SUPERBLOCK (block
);
1913 /* Data to be passed around in the calls to the locals and args
1916 struct print_variable_and_value_data
1918 struct frame_info
*frame
;
1920 struct ui_file
*stream
;
1924 /* The callback for the locals and args iterators. */
1927 do_print_variable_and_value (const char *print_name
,
1931 struct print_variable_and_value_data
*p
= cb_data
;
1933 print_variable_and_value (print_name
, sym
,
1934 p
->frame
, p
->stream
, p
->num_tabs
);
1935 p
->values_printed
= 1;
1939 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1940 struct ui_file
*stream
)
1942 struct print_variable_and_value_data cb_data
;
1943 struct block
*block
;
1946 if (!get_frame_pc_if_available (frame
, &pc
))
1948 fprintf_filtered (stream
,
1949 _("PC unavailable, cannot determine locals.\n"));
1953 block
= get_frame_block (frame
, 0);
1956 fprintf_filtered (stream
, "No symbol table info available.\n");
1960 cb_data
.frame
= frame
;
1961 cb_data
.num_tabs
= 4 * num_tabs
;
1962 cb_data
.stream
= stream
;
1963 cb_data
.values_printed
= 0;
1965 iterate_over_block_local_vars (block
,
1966 do_print_variable_and_value
,
1969 if (!cb_data
.values_printed
)
1970 fprintf_filtered (stream
, _("No locals.\n"));
1973 /* Same, but print labels. */
1976 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1977 struct ui_file
*stream
)
1980 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1982 struct blockvector
*bl
;
1983 struct block
*block
= get_frame_block (frame
, 0);
1984 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1985 int values_printed
= 0;
1986 int index
, have_default
= 0;
1987 char *blocks_printed
;
1988 CORE_ADDR pc
= get_frame_pc (frame
);
1992 fprintf_filtered (stream
, "No symbol table info available.\n");
1996 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1997 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1998 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2002 CORE_ADDR end
= BLOCK_END (block
) - 4;
2005 if (bl
!= blockvector_for_pc (end
, &index
))
2006 error (_("blockvector blotch"));
2007 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2008 error (_("blockvector botch"));
2009 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2012 /* Don't print out blocks that have gone by. */
2013 while (index
< last_index
2014 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2017 while (index
< last_index
2018 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2020 if (blocks_printed
[index
] == 0)
2022 if (print_block_frame_labels (gdbarch
,
2023 BLOCKVECTOR_BLOCK (bl
, index
),
2024 &have_default
, stream
))
2026 blocks_printed
[index
] = 1;
2032 if (values_printed
&& this_level_only
)
2035 /* After handling the function's top-level block, stop. Don't
2036 continue to its superblock, the block of per-file symbols.
2037 Also do not continue to the containing function of an inlined
2039 if (BLOCK_FUNCTION (block
))
2041 block
= BLOCK_SUPERBLOCK (block
);
2044 if (!values_printed
&& !this_level_only
)
2045 fprintf_filtered (stream
, _("No catches.\n"));
2050 locals_info (char *args
, int from_tty
)
2052 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2057 catch_info (char *ignore
, int from_tty
)
2059 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
2060 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
2064 /* Iterate over all the argument variables in block B.
2066 Returns 1 if any argument was walked; 0 otherwise. */
2069 iterate_over_block_arg_vars (struct block
*b
,
2070 iterate_over_block_arg_local_vars_cb cb
,
2073 struct dict_iterator iter
;
2074 struct symbol
*sym
, *sym2
;
2076 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2078 /* Don't worry about things which aren't arguments. */
2079 if (SYMBOL_IS_ARGUMENT (sym
))
2081 /* We have to look up the symbol because arguments can have
2082 two entries (one a parameter, one a local) and the one we
2083 want is the local, which lookup_symbol will find for us.
2084 This includes gcc1 (not gcc2) on the sparc when passing a
2085 small structure and gcc2 when the argument type is float
2086 and it is passed as a double and converted to float by
2087 the prologue (in the latter case the type of the LOC_ARG
2088 symbol is double and the type of the LOC_LOCAL symbol is
2089 float). There are also LOC_ARG/LOC_REGISTER pairs which
2090 are not combined in symbol-reading. */
2092 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2093 b
, VAR_DOMAIN
, NULL
);
2094 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2100 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2102 struct print_variable_and_value_data cb_data
;
2103 struct symbol
*func
;
2106 if (!get_frame_pc_if_available (frame
, &pc
))
2108 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2112 func
= get_frame_function (frame
);
2115 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2119 cb_data
.frame
= frame
;
2120 cb_data
.num_tabs
= 0;
2121 cb_data
.stream
= gdb_stdout
;
2122 cb_data
.values_printed
= 0;
2124 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2125 do_print_variable_and_value
, &cb_data
);
2127 if (!cb_data
.values_printed
)
2128 fprintf_filtered (stream
, _("No arguments.\n"));
2132 args_info (char *ignore
, int from_tty
)
2134 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2140 args_plus_locals_info (char *ignore
, int from_tty
)
2142 args_info (ignore
, from_tty
);
2143 locals_info (ignore
, from_tty
);
2147 /* Select frame FRAME. Also print the stack frame and show the source
2148 if this is the tui version. */
2150 select_and_print_frame (struct frame_info
*frame
)
2152 select_frame (frame
);
2154 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2157 /* Return the symbol-block in which the selected frame is executing.
2158 Can return zero under various legitimate circumstances.
2160 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2161 code address within the block returned. We use this to decide
2162 which macros are in scope. */
2165 get_selected_block (CORE_ADDR
*addr_in_block
)
2167 if (!has_stack_frames ())
2170 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2173 /* Find a frame a certain number of levels away from FRAME.
2174 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2175 Positive means go to earlier frames (up); negative, the reverse.
2176 The int that contains the number of levels is counted toward
2177 zero as the frames for those levels are found.
2178 If the top or bottom frame is reached, that frame is returned,
2179 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2180 how much farther the original request asked to go. */
2183 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2185 /* Going up is simple: just call get_prev_frame enough times or
2186 until the initial frame is reached. */
2187 while (*level_offset_ptr
> 0)
2189 struct frame_info
*prev
= get_prev_frame (frame
);
2193 (*level_offset_ptr
)--;
2197 /* Going down is just as simple. */
2198 while (*level_offset_ptr
< 0)
2200 struct frame_info
*next
= get_next_frame (frame
);
2204 (*level_offset_ptr
)++;
2211 /* The "select_frame" command. With no argument this is a NOP.
2212 Select the frame at level LEVEL_EXP if it is a valid level.
2213 Otherwise, treat LEVEL_EXP as an address expression and select it.
2215 See parse_frame_specification for more info on proper frame
2219 select_frame_command (char *level_exp
, int from_tty
)
2221 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2224 /* The "frame" command. With no argument, print the selected frame
2225 briefly. With an argument, behave like select_frame and then print
2226 the selected frame. */
2229 frame_command (char *level_exp
, int from_tty
)
2231 select_frame_command (level_exp
, from_tty
);
2232 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2235 /* The XDB Compatibility command to print the current frame. */
2238 current_frame_command (char *level_exp
, int from_tty
)
2240 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2243 /* Select the frame up one or COUNT_EXP stack levels from the
2244 previously selected frame, and print it briefly. */
2247 up_silently_base (char *count_exp
)
2249 struct frame_info
*frame
;
2253 count
= parse_and_eval_long (count_exp
);
2255 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2256 if (count
!= 0 && count_exp
== NULL
)
2257 error (_("Initial frame selected; you cannot go up."));
2258 select_frame (frame
);
2262 up_silently_command (char *count_exp
, int from_tty
)
2264 up_silently_base (count_exp
);
2268 up_command (char *count_exp
, int from_tty
)
2270 up_silently_base (count_exp
);
2271 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2274 /* Select the frame down one or COUNT_EXP stack levels from the previously
2275 selected frame, and print it briefly. */
2278 down_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
)
2289 /* We only do this if COUNT_EXP is not specified. That way
2290 "down" means to really go down (and let me know if that is
2291 impossible), but "down 9999" can be used to mean go all the
2292 way down without getting an error. */
2294 error (_("Bottom (innermost) frame selected; you cannot go down."));
2297 select_frame (frame
);
2301 down_silently_command (char *count_exp
, int from_tty
)
2303 down_silently_base (count_exp
);
2307 down_command (char *count_exp
, int from_tty
)
2309 down_silently_base (count_exp
);
2310 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2315 return_command (char *retval_exp
, int from_tty
)
2317 struct frame_info
*thisframe
;
2318 struct gdbarch
*gdbarch
;
2319 struct symbol
*thisfun
;
2320 struct value
*return_value
= NULL
;
2321 const char *query_prefix
= "";
2323 thisframe
= get_selected_frame ("No selected frame.");
2324 thisfun
= get_frame_function (thisframe
);
2325 gdbarch
= get_frame_arch (thisframe
);
2327 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2328 error (_("Can not force return from an inlined function."));
2330 /* Compute the return value. If the computation triggers an error,
2331 let it bail. If the return type can't be handled, set
2332 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2336 struct expression
*retval_expr
= parse_expression (retval_exp
);
2337 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2338 struct type
*return_type
= NULL
;
2340 /* Compute the return value. Should the computation fail, this
2341 call throws an error. */
2342 return_value
= evaluate_expression (retval_expr
);
2344 /* Cast return value to the return type of the function. Should
2345 the cast fail, this call throws an error. */
2346 if (thisfun
!= NULL
)
2347 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2348 if (return_type
== NULL
)
2350 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2351 error (_("Return value type not available for selected "
2353 "Please use an explicit cast of the value to return."));
2354 return_type
= value_type (return_value
);
2356 do_cleanups (old_chain
);
2357 CHECK_TYPEDEF (return_type
);
2358 return_value
= value_cast (return_type
, return_value
);
2360 /* Make sure the value is fully evaluated. It may live in the
2361 stack frame we're about to pop. */
2362 if (value_lazy (return_value
))
2363 value_fetch_lazy (return_value
);
2365 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2366 /* If the return-type is "void", don't try to find the
2367 return-value's location. However, do still evaluate the
2368 return expression so that, even when the expression result
2369 is discarded, side effects such as "return i++" still
2371 return_value
= NULL
;
2372 else if (thisfun
!= NULL
2373 && using_struct_return (gdbarch
,
2374 SYMBOL_TYPE (thisfun
), return_type
))
2376 query_prefix
= "The location at which to store the "
2377 "function's return value is unknown.\n"
2378 "If you continue, the return value "
2379 "that you specified will be ignored.\n";
2380 return_value
= NULL
;
2384 /* Does an interactive user really want to do this? Include
2385 information, such as how well GDB can handle the return value, in
2386 the query message. */
2391 if (thisfun
== NULL
)
2392 confirmed
= query (_("%sMake selected stack frame return now? "),
2395 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2396 SYMBOL_PRINT_NAME (thisfun
));
2398 error (_("Not confirmed"));
2401 /* Discard the selected frame and all frames inner-to it. */
2402 frame_pop (get_selected_frame (NULL
));
2404 /* Store RETURN_VALUE in the just-returned register set. */
2405 if (return_value
!= NULL
)
2407 struct type
*return_type
= value_type (return_value
);
2408 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2409 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2411 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2413 == RETURN_VALUE_REGISTER_CONVENTION
);
2414 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2415 get_current_regcache (), NULL
/*read*/,
2416 value_contents (return_value
) /*write*/);
2419 /* If we are at the end of a call dummy now, pop the dummy frame
2421 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2422 frame_pop (get_current_frame ());
2424 /* If interactive, print the frame that is now current. */
2426 frame_command ("0", 1);
2428 select_frame_command ("0", 0);
2431 /* Sets the scope to input function name, provided that the function
2432 is within the current stack frame. */
2434 struct function_bounds
2436 CORE_ADDR low
, high
;
2440 func_command (char *arg
, int from_tty
)
2442 struct frame_info
*frame
;
2444 struct symtabs_and_lines sals
;
2447 struct function_bounds
*func_bounds
= NULL
;
2448 struct cleanup
*cleanups
;
2453 frame
= parse_frame_specification ("0");
2454 sals
= decode_line_spec (arg
, DECODE_LINE_FUNFIRSTLINE
);
2455 cleanups
= make_cleanup (xfree
, sals
.sals
);
2456 func_bounds
= (struct function_bounds
*) xmalloc (
2457 sizeof (struct function_bounds
) * sals
.nelts
);
2458 make_cleanup (xfree
, func_bounds
);
2459 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2461 if (sals
.sals
[i
].pspace
!= current_program_space
)
2462 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2463 else if (sals
.sals
[i
].pc
== 0
2464 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2465 &func_bounds
[i
].low
,
2466 &func_bounds
[i
].high
) == 0)
2468 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2474 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2475 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2476 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2480 frame
= find_relative_frame (frame
, &level
);
2483 while (!found
&& level
== 0);
2485 do_cleanups (cleanups
);
2488 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2489 else if (frame
!= get_selected_frame (NULL
))
2490 select_and_print_frame (frame
);
2493 /* Gets the language of the current frame. */
2496 get_frame_language (void)
2498 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2502 volatile struct gdb_exception ex
;
2506 /* We determine the current frame language by looking up its
2507 associated symtab. To retrieve this symtab, we use the frame
2508 PC. However we cannot use the frame PC as is, because it
2509 usually points to the instruction following the "call", which
2510 is sometimes the first instruction of another function. So
2511 we rely on get_frame_address_in_block(), it provides us with
2512 a PC that is guaranteed to be inside the frame's code
2515 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2517 pc
= get_frame_address_in_block (frame
);
2521 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2522 throw_exception (ex
);
2526 s
= find_pc_symtab (pc
);
2532 return language_unknown
;
2536 /* Provide a prototype to silence -Wmissing-prototypes. */
2537 void _initialize_stack (void);
2540 _initialize_stack (void)
2542 add_com ("return", class_stack
, return_command
, _("\
2543 Make selected stack frame return to its caller.\n\
2544 Control remains in the debugger, but when you continue\n\
2545 execution will resume in the frame above the one now selected.\n\
2546 If an argument is given, it is an expression for the value to return."));
2548 add_com ("up", class_stack
, up_command
, _("\
2549 Select and print stack frame that called this one.\n\
2550 An argument says how many frames up to go."));
2551 add_com ("up-silently", class_support
, up_silently_command
, _("\
2552 Same as the `up' command, but does not print anything.\n\
2553 This is useful in command scripts."));
2555 add_com ("down", class_stack
, down_command
, _("\
2556 Select and print stack frame called by this one.\n\
2557 An argument says how many frames down to go."));
2558 add_com_alias ("do", "down", class_stack
, 1);
2559 add_com_alias ("dow", "down", class_stack
, 1);
2560 add_com ("down-silently", class_support
, down_silently_command
, _("\
2561 Same as the `down' command, but does not print anything.\n\
2562 This is useful in command scripts."));
2564 add_com ("frame", class_stack
, frame_command
, _("\
2565 Select and print a stack frame.\nWith no argument, \
2566 print the selected stack frame. (See also \"info frame\").\n\
2567 An argument specifies the frame to select.\n\
2568 It can be a stack frame number or the address of the frame.\n\
2569 With argument, nothing is printed if input is coming from\n\
2570 a command file or a user-defined command."));
2572 add_com_alias ("f", "frame", class_stack
, 1);
2576 add_com ("L", class_stack
, current_frame_command
,
2577 _("Print the current stack frame.\n"));
2578 add_com_alias ("V", "frame", class_stack
, 1);
2580 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2581 Select a stack frame without printing anything.\n\
2582 An argument specifies the frame to select.\n\
2583 It can be a stack frame number or the address of the frame.\n"));
2585 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2586 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2587 With a negative argument, print outermost -COUNT frames.\nUse of the \
2588 'full' qualifier also prints the values of the local variables.\n"));
2589 add_com_alias ("bt", "backtrace", class_stack
, 0);
2592 add_com_alias ("t", "backtrace", class_stack
, 0);
2593 add_com ("T", class_stack
, backtrace_full_command
, _("\
2594 Print backtrace of all stack frames, or innermost COUNT frames\n\
2595 and the values of the local variables.\n\
2596 With a negative argument, print outermost -COUNT frames.\n\
2597 Usage: T <count>\n"));
2600 add_com_alias ("where", "backtrace", class_alias
, 0);
2601 add_info ("stack", backtrace_command
,
2602 _("Backtrace of the stack, or innermost COUNT frames."));
2603 add_info_alias ("s", "stack", 1);
2604 add_info ("frame", frame_info
,
2605 _("All about selected stack frame, or frame at ADDR."));
2606 add_info_alias ("f", "frame", 1);
2607 add_info ("locals", locals_info
,
2608 _("Local variables of current stack frame."));
2609 add_info ("args", args_info
,
2610 _("Argument variables of current stack frame."));
2612 add_com ("l", class_info
, args_plus_locals_info
,
2613 _("Argument and local variables of current stack frame."));
2616 add_com ("func", class_stack
, func_command
, _("\
2617 Select the stack frame that contains <func>.\n\
2618 Usage: func <name>\n"));
2620 add_info ("catch", catch_info
,
2621 _("Exceptions that can be caught in the current stack frame."));
2623 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2624 print_frame_arguments_choices
, &print_frame_arguments
,
2625 _("Set printing of non-scalar frame arguments"),
2626 _("Show printing of non-scalar frame arguments"),
2627 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2629 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2630 &disassemble_next_line
, _("\
2631 Set whether to disassemble next source line or insn when execution stops."),
2633 Show whether to disassemble next source line or insn when execution stops."),
2635 If ON, GDB will display disassembly of the next source line, in addition\n\
2636 to displaying the source line itself. If the next source line cannot\n\
2637 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2638 will display disassembly of next instruction instead of showing the\n\
2640 If AUTO, display disassembly of next instruction only if the source line\n\
2641 cannot be displayed.\n\
2642 If OFF (which is the default), never display the disassembly of the next\n\
2645 show_disassemble_next_line
,
2646 &setlist
, &showlist
);
2647 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2649 add_setshow_enum_cmd ("entry-values", class_stack
,
2650 print_entry_values_choices
, &print_entry_values
,
2651 _("Set printing of function arguments at function "
2653 _("Show printing of function arguments at function "
2656 GDB can sometimes determine the values of function arguments at entry,\n\
2657 in addition to their current values. This option tells GDB whether\n\
2658 to print the current value, the value at entry (marked as val@entry),\n\
2659 or both. Note that one or both of these values may be <optimized out>."),
2660 NULL
, NULL
, &setprintlist
, &showprintlist
);