1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2005, 2007-2012 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"
50 #include "gdb_assert.h"
52 #include "gdb_string.h"
57 void (*deprecated_selected_frame_level_changed_hook
) (int);
59 /* The possible choices of "set print frame-arguments", and the value
62 static const char *print_frame_arguments_choices
[] =
63 {"all", "scalars", "none", NULL
};
64 static const char *print_frame_arguments
= "scalars";
66 /* The possible choices of "set print entry-values", and the value
69 const char print_entry_values_no
[] = "no";
70 const char print_entry_values_only
[] = "only";
71 const char print_entry_values_preferred
[] = "preferred";
72 const char print_entry_values_if_needed
[] = "if-needed";
73 const char print_entry_values_both
[] = "both";
74 const char print_entry_values_compact
[] = "compact";
75 const char print_entry_values_default
[] = "default";
76 static const char *print_entry_values_choices
[] =
78 print_entry_values_no
,
79 print_entry_values_only
,
80 print_entry_values_preferred
,
81 print_entry_values_if_needed
,
82 print_entry_values_both
,
83 print_entry_values_compact
,
84 print_entry_values_default
,
87 const char *print_entry_values
= print_entry_values_default
;
89 /* Prototypes for local functions. */
91 static void print_frame_local_vars (struct frame_info
*, int,
94 static void print_frame (struct frame_info
*frame
, int print_level
,
95 enum print_what print_what
, int print_args
,
96 struct symtab_and_line sal
);
98 static void set_last_displayed_sal (int valid
,
99 struct program_space
*pspace
,
101 struct symtab
*symtab
,
104 /* Zero means do things normally; we are interacting directly with the
105 user. One means print the full filename and linenumber when a
106 frame is printed, and do so in a format emacs18/emacs19.22 can
107 parse. Two means print similar annotations, but in many more
108 cases and in a slightly different syntax. */
110 int annotation_level
= 0;
112 /* These variables hold the last symtab and line we displayed to the user.
113 * This is where we insert a breakpoint or a skiplist entry by default. */
114 static int last_displayed_sal_valid
= 0;
115 static struct program_space
*last_displayed_pspace
= 0;
116 static CORE_ADDR last_displayed_addr
= 0;
117 static struct symtab
*last_displayed_symtab
= 0;
118 static int last_displayed_line
= 0;
121 /* Return 1 if we should display the address in addition to the location,
122 because we are in the middle of a statement. */
125 frame_show_address (struct frame_info
*frame
,
126 struct symtab_and_line sal
)
128 /* If there is a line number, but no PC, then there is no location
129 information associated with this sal. The only way that should
130 happen is for the call sites of inlined functions (SAL comes from
131 find_frame_sal). Otherwise, we would have some PC range if the
132 SAL came from a line table. */
133 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
135 if (get_next_frame (frame
) == NULL
)
136 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
138 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
142 return get_frame_pc (frame
) != sal
.pc
;
145 /* Show or print a stack frame FRAME briefly. The output is format
146 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
147 relative level, function name, argument list, and file name and
148 line number. If the frame's PC is not at the beginning of the
149 source line, the actual PC is printed at the beginning. */
152 print_stack_frame (struct frame_info
*frame
, int print_level
,
153 enum print_what print_what
)
155 volatile struct gdb_exception e
;
157 /* For mi, alway print location and address. */
158 if (ui_out_is_mi_like_p (current_uiout
))
159 print_what
= LOC_AND_ADDRESS
;
161 TRY_CATCH (e
, RETURN_MASK_ERROR
)
163 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
165 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
166 set_current_sal_from_frame (frame
, center
);
170 /* Print nameless arguments of frame FRAME on STREAM, where START is
171 the offset of the first nameless argument, and NUM is the number of
172 nameless arguments to print. FIRST is nonzero if this is the first
173 argument (not just the first nameless argument). */
176 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
177 int first
, struct ui_file
*stream
)
179 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
180 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
185 for (i
= 0; i
< num
; i
++)
188 argsaddr
= get_frame_args_address (frame
);
191 arg_value
= read_memory_integer (argsaddr
+ start
,
192 sizeof (int), byte_order
);
194 fprintf_filtered (stream
, ", ");
195 fprintf_filtered (stream
, "%ld", arg_value
);
197 start
+= sizeof (int);
201 /* Print single argument of inferior function. ARG must be already
204 Errors are printed as if they would be the parameter value. Use zeroed ARG
205 iff it should not be printed accoring to user settings. */
208 print_frame_arg (const struct frame_arg
*arg
)
210 struct ui_out
*uiout
= current_uiout
;
211 volatile struct gdb_exception except
;
212 struct cleanup
*old_chain
;
213 struct ui_stream
*stb
;
215 stb
= ui_out_stream_new (uiout
);
216 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
218 gdb_assert (!arg
->val
|| !arg
->error
);
219 gdb_assert (arg
->entry_kind
== print_entry_values_no
220 || arg
->entry_kind
== print_entry_values_only
221 || (!ui_out_is_mi_like_p (uiout
)
222 && arg
->entry_kind
== print_entry_values_compact
));
224 annotate_arg_begin ();
226 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
227 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
228 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
229 if (arg
->entry_kind
== print_entry_values_compact
)
231 /* It is OK to provide invalid MI-like stream as with
232 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
233 fputs_filtered ("=", stb
->stream
);
235 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
236 SYMBOL_LANGUAGE (arg
->sym
),
237 DMGL_PARAMS
| DMGL_ANSI
);
239 if (arg
->entry_kind
== print_entry_values_only
240 || arg
->entry_kind
== print_entry_values_compact
)
241 fputs_filtered ("@entry", stb
->stream
);
242 ui_out_field_stream (uiout
, "name", stb
);
243 annotate_arg_name_end ();
244 ui_out_text (uiout
, "=");
246 if (!arg
->val
&& !arg
->error
)
247 ui_out_text (uiout
, "...");
251 except
.message
= arg
->error
;
254 /* TRY_CATCH has two statements, wrap it in a block. */
256 TRY_CATCH (except
, RETURN_MASK_ERROR
)
258 const struct language_defn
*language
;
259 struct value_print_options opts
;
261 /* Avoid value_print because it will deref ref parameters. We
262 just want to print their addresses. Print ??? for args whose
263 address we do not know. We pass 2 as "recurse" to val_print
264 because our standard indentation here is 4 spaces, and
265 val_print indents 2 for each recurse. */
267 annotate_arg_value (value_type (arg
->val
));
269 /* Use the appropriate language to display our symbol, unless the
270 user forced the language to a specific language. */
271 if (language_mode
== language_mode_auto
)
272 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
274 language
= current_language
;
276 get_raw_print_options (&opts
);
279 /* True in "summary" mode, false otherwise. */
280 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
282 common_val_print (arg
->val
, stb
->stream
, 2, &opts
, language
);
286 fprintf_filtered (stb
->stream
, _("<error reading variable: %s>"),
290 ui_out_field_stream (uiout
, "value", stb
);
292 /* Aleo invoke ui_out_tuple_end. */
293 do_cleanups (old_chain
);
298 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
299 responsible for xfree of ARGP->ERROR. This function never throws an
303 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
304 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
306 struct value
*val
= NULL
, *entryval
= NULL
;
307 char *val_error
= NULL
, *entryval_error
= NULL
;
309 volatile struct gdb_exception except
;
311 if (print_entry_values
!= print_entry_values_only
312 && print_entry_values
!= print_entry_values_preferred
)
314 TRY_CATCH (except
, RETURN_MASK_ERROR
)
316 val
= read_var_value (sym
, frame
);
320 val_error
= alloca (strlen (except
.message
) + 1);
321 strcpy (val_error
, except
.message
);
325 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
326 && print_entry_values
!= print_entry_values_no
327 && (print_entry_values
!= print_entry_values_if_needed
328 || !val
|| value_optimized_out (val
)))
330 TRY_CATCH (except
, RETURN_MASK_ERROR
)
332 const struct symbol_computed_ops
*ops
;
334 ops
= SYMBOL_COMPUTED_OPS (sym
);
335 entryval
= ops
->read_variable_at_entry (sym
, frame
);
339 entryval_error
= alloca (strlen (except
.message
) + 1);
340 strcpy (entryval_error
, except
.message
);
343 if (except
.error
== NO_ENTRY_VALUE_ERROR
344 || (entryval
&& value_optimized_out (entryval
)))
347 entryval_error
= NULL
;
350 if (print_entry_values
== print_entry_values_compact
351 || print_entry_values
== print_entry_values_default
)
353 /* For MI do not try to use print_entry_values_compact for ARGP. */
355 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
357 unsigned len
= TYPE_LENGTH (value_type (val
));
359 if (!value_optimized_out (val
) && value_lazy (val
))
360 value_fetch_lazy (val
);
361 if (!value_optimized_out (val
) && value_lazy (entryval
))
362 value_fetch_lazy (entryval
);
363 if (!value_optimized_out (val
)
364 && value_available_contents_eq (val
, 0, entryval
, 0, len
))
366 /* Initialize it just to avoid a GCC false warning. */
367 struct value
*val_deref
= NULL
, *entryval_deref
;
369 /* DW_AT_GNU_call_site_value does match with the current
370 value. If it is a reference still try to verify if
371 dereferenced DW_AT_GNU_call_site_data_value does not
374 TRY_CATCH (except
, RETURN_MASK_ERROR
)
378 val_deref
= coerce_ref (val
);
379 if (value_lazy (val_deref
))
380 value_fetch_lazy (val_deref
);
381 len_deref
= TYPE_LENGTH (value_type (val_deref
));
383 entryval_deref
= coerce_ref (entryval
);
384 if (value_lazy (entryval_deref
))
385 value_fetch_lazy (entryval_deref
);
387 /* If the reference addresses match but dereferenced
388 content does not match print them. */
390 && value_available_contents_eq (val_deref
, 0,
396 /* Value was not a reference; and its content matches. */
397 if (val
== val_deref
)
399 /* If the dereferenced content could not be fetched do not
401 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
403 else if (except
.message
)
405 entryval_error
= alloca (strlen (except
.message
) + 1);
406 strcpy (entryval_error
, except
.message
);
414 /* Try to remove possibly duplicate error message for ENTRYARGP even
417 if (val_error
&& entryval_error
418 && strcmp (val_error
, entryval_error
) == 0)
420 entryval_error
= NULL
;
422 /* Do not se VAL_EQUAL as the same error message may be shown for
423 the entry value even if no entry values are present in the
429 if (entryval
== NULL
)
431 if (print_entry_values
== print_entry_values_preferred
)
433 TRY_CATCH (except
, RETURN_MASK_ERROR
)
435 val
= read_var_value (sym
, frame
);
439 val_error
= alloca (strlen (except
.message
) + 1);
440 strcpy (val_error
, except
.message
);
443 if (print_entry_values
== print_entry_values_only
444 || print_entry_values
== print_entry_values_both
445 || (print_entry_values
== print_entry_values_preferred
446 && (!val
|| value_optimized_out (val
))))
447 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
449 if ((print_entry_values
== print_entry_values_compact
450 || print_entry_values
== print_entry_values_if_needed
451 || print_entry_values
== print_entry_values_preferred
)
452 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
460 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
461 if (!val
&& !val_error
)
462 argp
->entry_kind
= print_entry_values_only
;
463 else if ((print_entry_values
== print_entry_values_compact
464 || print_entry_values
== print_entry_values_default
) && val_equal
)
466 argp
->entry_kind
= print_entry_values_compact
;
467 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
470 argp
->entry_kind
= print_entry_values_no
;
472 entryargp
->sym
= sym
;
473 entryargp
->val
= entryval
;
474 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
475 if (!entryval
&& !entryval_error
)
476 entryargp
->entry_kind
= print_entry_values_no
;
478 entryargp
->entry_kind
= print_entry_values_only
;
481 /* Print the arguments of frame FRAME on STREAM, given the function
482 FUNC running in that frame (as a symbol), where NUM is the number
483 of arguments according to the stack frame (or -1 if the number of
484 arguments is unknown). */
486 /* Note that currently the "number of arguments according to the
487 stack frame" is only known on VAX where i refers to the "number of
488 ints of arguments according to the stack frame". */
491 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
492 int num
, struct ui_file
*stream
)
494 struct ui_out
*uiout
= current_uiout
;
496 /* Offset of next stack argument beyond the one we have seen that is
497 at the highest offset, or -1 if we haven't come to a stack
499 long highest_offset
= -1;
500 /* Number of ints of arguments that we have printed so far. */
501 int args_printed
= 0;
502 struct cleanup
*old_chain
, *list_chain
;
503 struct ui_stream
*stb
;
504 /* True if we should print arguments, false otherwise. */
505 int print_args
= strcmp (print_frame_arguments
, "none");
506 /* True in "summary" mode, false otherwise. */
507 int summary
= !strcmp (print_frame_arguments
, "scalars");
509 stb
= ui_out_stream_new (uiout
);
510 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
514 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
515 struct dict_iterator iter
;
518 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
520 struct frame_arg arg
, entryarg
;
524 /* Keep track of the highest stack argument offset seen, and
525 skip over any kinds of symbols we don't care about. */
527 if (!SYMBOL_IS_ARGUMENT (sym
))
530 switch (SYMBOL_CLASS (sym
))
535 long current_offset
= SYMBOL_VALUE (sym
);
536 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
538 /* Compute address of next argument by adding the size of
539 this argument and rounding to an int boundary. */
541 ((current_offset
+ arg_size
+ sizeof (int) - 1)
542 & ~(sizeof (int) - 1));
544 /* If this is the highest offset seen yet, set
546 if (highest_offset
== -1
547 || (current_offset
> highest_offset
))
548 highest_offset
= current_offset
;
550 /* Add the number of ints we're about to print to
552 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
555 /* We care about types of symbols, but don't need to
556 keep track of stack offsets in them. */
558 case LOC_REGPARM_ADDR
:
560 case LOC_OPTIMIZED_OUT
:
565 /* We have to look up the symbol because arguments can have
566 two entries (one a parameter, one a local) and the one we
567 want is the local, which lookup_symbol will find for us.
568 This includes gcc1 (not gcc2) on SPARC when passing a
569 small structure and gcc2 when the argument type is float
570 and it is passed as a double and converted to float by
571 the prologue (in the latter case the type of the LOC_ARG
572 symbol is double and the type of the LOC_LOCAL symbol is
574 /* But if the parameter name is null, don't try it. Null
575 parameter names occur on the RS/6000, for traceback
576 tables. FIXME, should we even print them? */
578 if (*SYMBOL_LINKAGE_NAME (sym
))
582 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
583 b
, VAR_DOMAIN
, NULL
);
584 gdb_assert (nsym
!= NULL
);
585 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
586 && !SYMBOL_IS_ARGUMENT (nsym
))
588 /* There is a LOC_ARG/LOC_REGISTER pair. This means
589 that it was passed on the stack and loaded into a
590 register, or passed in a register and stored in a
591 stack slot. GDB 3.x used the LOC_ARG; GDB
592 4.0-4.11 used the LOC_REGISTER.
594 Reasons for using the LOC_ARG:
596 (1) Because find_saved_registers may be slow for
599 (2) Because registers are often re-used and stack
600 slots rarely (never?) are. Therefore using
601 the stack slot is much less likely to print
604 Reasons why we might want to use the LOC_REGISTER:
606 (1) So that the backtrace prints the same value
607 as "print foo". I see no compelling reason
608 why this needs to be the case; having the
609 backtrace print the value which was passed
610 in, and "print foo" print the value as
611 modified within the called function, makes
614 Additional note: It might be nice if "info args"
615 displayed both values.
617 One more note: There is a case with SPARC
618 structure passing where we need to use the
619 LOC_REGISTER, but this is dealt with by creating
620 a single LOC_REGPARM in symbol reading. */
622 /* Leave sym (the LOC_ARG) alone. */
629 /* Print the current arg. */
631 ui_out_text (uiout
, ", ");
632 ui_out_wrap_hint (uiout
, " ");
636 memset (&arg
, 0, sizeof (arg
));
638 arg
.entry_kind
= print_entry_values_no
;
639 memset (&entryarg
, 0, sizeof (entryarg
));
641 entryarg
.entry_kind
= print_entry_values_no
;
644 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
646 if (arg
.entry_kind
!= print_entry_values_only
)
647 print_frame_arg (&arg
);
649 if (entryarg
.entry_kind
!= print_entry_values_no
)
651 if (arg
.entry_kind
!= print_entry_values_only
)
653 ui_out_text (uiout
, ", ");
654 ui_out_wrap_hint (uiout
, " ");
657 print_frame_arg (&entryarg
);
661 xfree (entryarg
.error
);
667 /* Don't print nameless args in situations where we don't know
668 enough about the stack to find them. */
673 if (highest_offset
== -1)
674 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
676 start
= highest_offset
;
678 print_frame_nameless_args (frame
, start
, num
- args_printed
,
682 do_cleanups (old_chain
);
685 /* Set the current source and line to the location given by frame
686 FRAME, if possible. When CENTER is true, adjust so the relevant
687 line is in the center of the next 'list'. */
690 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
692 struct symtab_and_line sal
;
694 find_frame_sal (frame
, &sal
);
698 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
699 set_current_source_symtab_and_line (&sal
);
703 /* If ON, GDB will display disassembly of the next source line when
704 execution of the program being debugged stops.
705 If AUTO (which is the default), or there's no line info to determine
706 the source line of the next instruction, display disassembly of next
707 instruction instead. */
709 static enum auto_boolean disassemble_next_line
;
712 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
713 struct cmd_list_element
*c
,
716 fprintf_filtered (file
,
717 _("Debugger's willingness to use "
718 "disassemble-next-line is %s.\n"),
722 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
723 because it will be broken by filter sometime. */
726 do_gdb_disassembly (struct gdbarch
*gdbarch
,
727 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
729 volatile struct gdb_exception exception
;
731 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
733 gdb_disassembly (gdbarch
, current_uiout
, 0,
734 DISASSEMBLY_RAW_INSN
, how_many
,
737 if (exception
.reason
< 0)
739 /* If an exception was thrown while doing the disassembly, print
740 the error message, to give the user a clue of what happened. */
741 exception_print (gdb_stderr
, exception
);
745 /* Print information about frame FRAME. The output is format according
746 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
749 SRC_LINE: Print only source line.
750 LOCATION: Print only location.
751 LOC_AND_SRC: Print location and source line.
753 Used in "where" output, and to emit breakpoint or step
757 print_frame_info (struct frame_info
*frame
, int print_level
,
758 enum print_what print_what
, int print_args
)
760 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
761 struct symtab_and_line sal
;
764 struct ui_out
*uiout
= current_uiout
;
766 if (get_frame_type (frame
) == DUMMY_FRAME
767 || get_frame_type (frame
) == SIGTRAMP_FRAME
768 || get_frame_type (frame
) == ARCH_FRAME
)
770 struct cleanup
*uiout_cleanup
771 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
773 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
774 gdbarch
, get_frame_pc (frame
));
776 /* Do this regardless of SOURCE because we don't have any source
777 to list for this frame. */
780 ui_out_text (uiout
, "#");
781 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
782 frame_relative_level (frame
));
784 if (ui_out_is_mi_like_p (uiout
))
786 annotate_frame_address ();
787 ui_out_field_core_addr (uiout
, "addr",
788 gdbarch
, get_frame_pc (frame
));
789 annotate_frame_address_end ();
792 if (get_frame_type (frame
) == DUMMY_FRAME
)
794 annotate_function_call ();
795 ui_out_field_string (uiout
, "func", "<function called from gdb>");
797 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
799 annotate_signal_handler_caller ();
800 ui_out_field_string (uiout
, "func", "<signal handler called>");
802 else if (get_frame_type (frame
) == ARCH_FRAME
)
804 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
806 ui_out_text (uiout
, "\n");
807 annotate_frame_end ();
809 do_cleanups (uiout_cleanup
);
813 /* If FRAME is not the innermost frame, that normally means that
814 FRAME->pc points to *after* the call instruction, and we want to
815 get the line containing the call, never the next line. But if
816 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
817 next frame was not entered as the result of a call, and we want
818 to get the line containing FRAME->pc. */
819 find_frame_sal (frame
, &sal
);
821 location_print
= (print_what
== LOCATION
822 || print_what
== LOC_AND_ADDRESS
823 || print_what
== SRC_AND_LOC
);
825 if (location_print
|| !sal
.symtab
)
826 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
828 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
830 /* If disassemble-next-line is set to auto or on and doesn't have
831 the line debug messages for $pc, output the next instruction. */
832 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
833 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
834 && source_print
&& !sal
.symtab
)
835 do_gdb_disassembly (get_frame_arch (frame
), 1,
836 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
838 if (source_print
&& sal
.symtab
)
841 int mid_statement
= ((print_what
== SRC_LINE
)
842 && frame_show_address (frame
, sal
));
844 if (annotation_level
)
845 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
846 get_frame_pc (frame
));
849 if (deprecated_print_frame_info_listing_hook
)
850 deprecated_print_frame_info_listing_hook (sal
.symtab
,
855 struct value_print_options opts
;
857 get_user_print_options (&opts
);
858 /* We used to do this earlier, but that is clearly
859 wrong. This function is used by many different
860 parts of gdb, including normal_stop in infrun.c,
861 which uses this to print out the current PC
862 when we stepi/nexti into the middle of a source
863 line. Only the command line really wants this
864 behavior. Other UIs probably would like the
865 ability to decide for themselves if it is desired. */
866 if (opts
.addressprint
&& mid_statement
)
868 ui_out_field_core_addr (uiout
, "addr",
869 gdbarch
, get_frame_pc (frame
));
870 ui_out_text (uiout
, "\t");
873 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
877 /* If disassemble-next-line is set to on and there is line debug
878 messages, output assembly codes for next line. */
879 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
880 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
883 if (print_what
!= LOCATION
)
887 if (get_frame_pc_if_available (frame
, &pc
))
888 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
890 set_last_displayed_sal (0, 0, 0, 0, 0);
893 annotate_frame_end ();
895 gdb_flush (gdb_stdout
);
898 /* Remember the last symtab and line we displayed, which we use e.g.
899 * as the place to put a breakpoint when the `break' command is
900 * invoked with no arguments. */
903 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
904 CORE_ADDR addr
, struct symtab
*symtab
,
907 last_displayed_sal_valid
= valid
;
908 last_displayed_pspace
= pspace
;
909 last_displayed_addr
= addr
;
910 last_displayed_symtab
= symtab
;
911 last_displayed_line
= line
;
914 /* Forget the last sal we displayed. */
917 clear_last_displayed_sal (void)
919 last_displayed_sal_valid
= 0;
920 last_displayed_pspace
= 0;
921 last_displayed_addr
= 0;
922 last_displayed_symtab
= 0;
923 last_displayed_line
= 0;
926 /* Is our record of the last sal we displayed valid? If not,
927 * the get_last_displayed_* functions will return NULL or 0, as
931 last_displayed_sal_is_valid (void)
933 return last_displayed_sal_valid
;
936 /* Get the pspace of the last sal we displayed, if it's valid. */
938 struct program_space
*
939 get_last_displayed_pspace (void)
941 if (last_displayed_sal_valid
)
942 return last_displayed_pspace
;
946 /* Get the address of the last sal we displayed, if it's valid. */
949 get_last_displayed_addr (void)
951 if (last_displayed_sal_valid
)
952 return last_displayed_addr
;
956 /* Get the symtab of the last sal we displayed, if it's valid. */
959 get_last_displayed_symtab (void)
961 if (last_displayed_sal_valid
)
962 return last_displayed_symtab
;
966 /* Get the line of the last sal we displayed, if it's valid. */
969 get_last_displayed_line (void)
971 if (last_displayed_sal_valid
)
972 return last_displayed_line
;
976 /* Get the last sal we displayed, if it's valid. */
979 get_last_displayed_sal (struct symtab_and_line
*sal
)
981 if (last_displayed_sal_valid
)
983 sal
->pspace
= last_displayed_pspace
;
984 sal
->pc
= last_displayed_addr
;
985 sal
->symtab
= last_displayed_symtab
;
986 sal
->line
= last_displayed_line
;
998 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
999 corresponding to FRAME. */
1002 find_frame_funname (struct frame_info
*frame
, char **funname
,
1003 enum language
*funlang
, struct symbol
**funcp
)
1005 struct symbol
*func
;
1008 *funlang
= language_unknown
;
1012 func
= get_frame_function (frame
);
1015 /* In certain pathological cases, the symtabs give the wrong
1016 function (when we are in the first function in a file which
1017 is compiled without debugging symbols, the previous function
1018 is compiled with debugging symbols, and the "foo.o" symbol
1019 that is supposed to tell us where the file with debugging
1020 symbols ends has been truncated by ar because it is longer
1021 than 15 characters). This also occurs if the user uses asm()
1022 to create a function but not stabs for it (in a file compiled
1025 So look in the minimal symbol tables as well, and if it comes
1026 up with a larger address for the function use that instead.
1027 I don't think this can ever cause any problems; there
1028 shouldn't be any minimal symbols in the middle of a function;
1029 if this is ever changed many parts of GDB will need to be
1030 changed (and we'll create a find_pc_minimal_function or some
1033 struct minimal_symbol
*msymbol
= NULL
;
1035 /* Don't attempt to do this for inlined functions, which do not
1036 have a corresponding minimal symbol. */
1037 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1039 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1042 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1043 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1045 /* We also don't know anything about the function besides
1046 its address and name. */
1048 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1049 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1053 *funname
= SYMBOL_PRINT_NAME (func
);
1054 *funlang
= SYMBOL_LANGUAGE (func
);
1057 if (*funlang
== language_cplus
)
1059 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1060 to display the demangled name that we already have
1061 stored in the symbol table, but we stored a version
1062 with DMGL_PARAMS turned on, and here we don't want to
1063 display parameters. So remove the parameters. */
1064 char *func_only
= cp_remove_params (*funname
);
1068 *funname
= func_only
;
1069 make_cleanup (xfree
, func_only
);
1076 struct minimal_symbol
*msymbol
;
1079 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1082 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1083 if (msymbol
!= NULL
)
1085 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1086 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1092 print_frame (struct frame_info
*frame
, int print_level
,
1093 enum print_what print_what
, int print_args
,
1094 struct symtab_and_line sal
)
1096 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1097 struct ui_out
*uiout
= current_uiout
;
1098 char *funname
= NULL
;
1099 enum language funlang
= language_unknown
;
1100 struct ui_stream
*stb
;
1101 struct cleanup
*old_chain
, *list_chain
;
1102 struct value_print_options opts
;
1103 struct symbol
*func
;
1107 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1109 stb
= ui_out_stream_new (uiout
);
1110 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1112 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1114 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1117 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1121 ui_out_text (uiout
, "#");
1122 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1123 frame_relative_level (frame
));
1125 get_user_print_options (&opts
);
1126 if (opts
.addressprint
)
1128 || frame_show_address (frame
, sal
)
1129 || print_what
== LOC_AND_ADDRESS
)
1131 annotate_frame_address ();
1133 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1135 ui_out_field_string (uiout
, "addr", "<unavailable>");
1136 annotate_frame_address_end ();
1137 ui_out_text (uiout
, " in ");
1139 annotate_frame_function_name ();
1140 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
1141 funlang
, DMGL_ANSI
);
1142 ui_out_field_stream (uiout
, "func", stb
);
1143 ui_out_wrap_hint (uiout
, " ");
1144 annotate_frame_args ();
1146 ui_out_text (uiout
, " (");
1149 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1151 struct cleanup
*args_list_chain
;
1152 volatile struct gdb_exception e
;
1154 if (gdbarch_frame_num_args_p (gdbarch
))
1156 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1157 gdb_assert (numargs
>= 0);
1162 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1163 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1165 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1167 /* FIXME: ARGS must be a list. If one argument is a string it
1168 will have " that will not be properly escaped. */
1169 /* Invoke ui_out_tuple_end. */
1170 do_cleanups (args_list_chain
);
1173 ui_out_text (uiout
, ")");
1174 if (sal
.symtab
&& sal
.symtab
->filename
)
1176 annotate_frame_source_begin ();
1177 ui_out_wrap_hint (uiout
, " ");
1178 ui_out_text (uiout
, " at ");
1179 annotate_frame_source_file ();
1180 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1181 if (ui_out_is_mi_like_p (uiout
))
1183 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1185 if (fullname
!= NULL
)
1186 ui_out_field_string (uiout
, "fullname", fullname
);
1188 annotate_frame_source_file_end ();
1189 ui_out_text (uiout
, ":");
1190 annotate_frame_source_line ();
1191 ui_out_field_int (uiout
, "line", sal
.line
);
1192 annotate_frame_source_end ();
1195 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
1198 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1200 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1201 get_frame_pc (frame
));
1205 annotate_frame_where ();
1206 ui_out_wrap_hint (uiout
, " ");
1207 ui_out_text (uiout
, " from ");
1208 ui_out_field_string (uiout
, "from", lib
);
1212 /* do_cleanups will call ui_out_tuple_end() for us. */
1213 do_cleanups (list_chain
);
1214 ui_out_text (uiout
, "\n");
1215 do_cleanups (old_chain
);
1219 /* Read a frame specification in whatever the appropriate format is
1220 from FRAME_EXP. Call error(), printing MESSAGE, if the
1221 specification is in any way invalid (so this function never returns
1222 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1223 the default selected frame was used. */
1225 static struct frame_info
*
1226 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1227 int *selected_frame_p
)
1230 struct value
*args
[4];
1231 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1233 if (frame_exp
== NULL
)
1241 struct cleanup
*cleanup
;
1244 /* Skip leading white space, bail of EOL. */
1245 while (isspace (*frame_exp
))
1250 /* Parse the argument, extract it, save it. */
1252 *p
&& !isspace (*p
);
1254 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1256 cleanup
= make_cleanup (xfree
, addr_string
);
1258 /* NOTE: Parse and evaluate expression, but do not use
1259 functions such as parse_and_eval_long or
1260 parse_and_eval_address to also extract the value.
1261 Instead value_as_long and value_as_address are used.
1262 This avoids problems with expressions that contain
1264 if (numargs
>= ARRAY_SIZE (args
))
1265 error (_("Too many args in frame specification"));
1266 args
[numargs
++] = parse_and_eval (addr_string
);
1268 do_cleanups (cleanup
);
1272 /* If no args, default to the selected frame. */
1275 if (selected_frame_p
!= NULL
)
1276 (*selected_frame_p
) = 1;
1277 return get_selected_frame (message
);
1280 /* None of the remaining use the selected frame. */
1281 if (selected_frame_p
!= NULL
)
1282 (*selected_frame_p
) = 0;
1284 /* Assume the single arg[0] is an integer, and try using that to
1285 select a frame relative to current. */
1288 struct frame_info
*fid
;
1289 int level
= value_as_long (args
[0]);
1291 fid
= find_relative_frame (get_current_frame (), &level
);
1293 /* find_relative_frame was successful. */
1297 /* Convert each value into a corresponding address. */
1301 for (i
= 0; i
< numargs
; i
++)
1302 addrs
[i
] = value_as_address (args
[i
]);
1305 /* Assume that the single arg[0] is an address, use that to identify
1306 a frame with a matching ID. Should this also accept stack/pc or
1307 stack/pc/special. */
1310 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1311 struct frame_info
*fid
;
1313 /* If (s)he specifies the frame with an address, he deserves
1314 what (s)he gets. Still, give the highest one that matches.
1315 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1317 for (fid
= get_current_frame ();
1319 fid
= get_prev_frame (fid
))
1321 if (frame_id_eq (id
, get_frame_id (fid
)))
1323 struct frame_info
*prev_frame
;
1327 prev_frame
= get_prev_frame (fid
);
1329 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1338 /* We couldn't identify the frame as an existing frame, but
1339 perhaps we can create one with a single argument. */
1341 return create_new_frame (addrs
[0], 0);
1342 else if (numargs
== 2)
1343 return create_new_frame (addrs
[0], addrs
[1]);
1345 error (_("Too many args in frame specification"));
1348 static struct frame_info
*
1349 parse_frame_specification (char *frame_exp
)
1351 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1354 /* Print verbosely the selected frame or the frame at address
1355 ADDR_EXP. Absolutely all information in the frame is printed. */
1358 frame_info (char *addr_exp
, int from_tty
)
1360 struct frame_info
*fi
;
1361 struct symtab_and_line sal
;
1362 struct symbol
*func
;
1364 struct frame_info
*calling_frame_info
;
1367 enum language funlang
= language_unknown
;
1368 const char *pc_regname
;
1369 int selected_frame_p
;
1370 struct gdbarch
*gdbarch
;
1371 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1374 CORE_ADDR caller_pc
;
1376 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1377 gdbarch
= get_frame_arch (fi
);
1379 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1380 is not a good name. */
1381 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1382 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1383 easily not match that of the internal value returned by
1385 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1387 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1388 architectures will often have a hardware register called "pc",
1389 and that register's value, again, can easily not match
1393 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1394 find_frame_sal (fi
, &sal
);
1395 func
= get_frame_function (fi
);
1399 funname
= SYMBOL_PRINT_NAME (func
);
1400 funlang
= SYMBOL_LANGUAGE (func
);
1401 if (funlang
== language_cplus
)
1403 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1404 to display the demangled name that we already have
1405 stored in the symbol table, but we stored a version
1406 with DMGL_PARAMS turned on, and here we don't want to
1407 display parameters. So remove the parameters. */
1408 char *func_only
= cp_remove_params (funname
);
1412 funname
= func_only
;
1413 make_cleanup (xfree
, func_only
);
1417 else if (frame_pc_p
)
1419 struct minimal_symbol
*msymbol
;
1421 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1422 if (msymbol
!= NULL
)
1424 funname
= SYMBOL_PRINT_NAME (msymbol
);
1425 funlang
= SYMBOL_LANGUAGE (msymbol
);
1428 calling_frame_info
= get_prev_frame (fi
);
1430 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1432 printf_filtered (_("Stack level %d, frame at "),
1433 frame_relative_level (fi
));
1437 printf_filtered (_("Stack frame at "));
1439 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1440 printf_filtered (":\n");
1441 printf_filtered (" %s = ", pc_regname
);
1443 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1445 fputs_filtered ("<unavailable>", gdb_stdout
);
1450 printf_filtered (" in ");
1451 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1452 DMGL_ANSI
| DMGL_PARAMS
);
1456 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1457 puts_filtered ("; ");
1459 printf_filtered ("saved %s ", pc_regname
);
1460 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1461 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1463 fputs_filtered ("<unavailable>", gdb_stdout
);
1464 printf_filtered ("\n");
1466 if (calling_frame_info
== NULL
)
1468 enum unwind_stop_reason reason
;
1470 reason
= get_frame_unwind_stop_reason (fi
);
1471 if (reason
!= UNWIND_NO_REASON
)
1472 printf_filtered (_(" Outermost frame: %s\n"),
1473 frame_stop_reason_string (reason
));
1475 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1476 puts_filtered (" tail call frame");
1477 else if (get_frame_type (fi
) == INLINE_FRAME
)
1478 printf_filtered (" inlined into frame %d",
1479 frame_relative_level (get_prev_frame (fi
)));
1482 printf_filtered (" called by frame at ");
1483 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1486 if (get_next_frame (fi
) && calling_frame_info
)
1487 puts_filtered (",");
1489 if (get_next_frame (fi
))
1491 printf_filtered (" caller of frame at ");
1492 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1495 if (get_next_frame (fi
) || calling_frame_info
)
1496 puts_filtered ("\n");
1499 printf_filtered (" source language %s.\n",
1500 language_str (s
->language
));
1503 /* Address of the argument list for this frame, or 0. */
1504 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1505 /* Number of args for this frame, or -1 if unknown. */
1509 printf_filtered (" Arglist at unknown address.\n");
1512 printf_filtered (" Arglist at ");
1513 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1514 printf_filtered (",");
1516 if (!gdbarch_frame_num_args_p (gdbarch
))
1519 puts_filtered (" args: ");
1523 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1524 gdb_assert (numargs
>= 0);
1526 puts_filtered (" no args.");
1527 else if (numargs
== 1)
1528 puts_filtered (" 1 arg: ");
1530 printf_filtered (" %d args: ", numargs
);
1532 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1533 puts_filtered ("\n");
1537 /* Address of the local variables for this frame, or 0. */
1538 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1541 printf_filtered (" Locals at unknown address,");
1544 printf_filtered (" Locals at ");
1545 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1546 printf_filtered (",");
1550 /* Print as much information as possible on the location of all the
1553 enum lval_type lval
;
1562 /* The sp is special; what's displayed isn't the save address, but
1563 the value of the previous frame's sp. This is a legacy thing,
1564 at one stage the frame cached the previous frame's SP instead
1565 of its address, hence it was easiest to just display the cached
1567 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1569 /* Find out the location of the saved stack pointer with out
1570 actually evaluating it. */
1571 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1572 &optimized
, &unavailable
, &lval
, &addr
,
1574 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1576 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1577 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1578 gdb_byte value
[MAX_REGISTER_SIZE
];
1581 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1582 &optimized
, &unavailable
, &lval
, &addr
,
1584 /* NOTE: cagney/2003-05-22: This is assuming that the
1585 stack pointer was packed as an unsigned integer. That
1586 may or may not be valid. */
1587 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1588 printf_filtered (" Previous frame's sp is ");
1589 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1590 printf_filtered ("\n");
1593 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1595 printf_filtered (" Previous frame's sp at ");
1596 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1597 printf_filtered ("\n");
1600 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1602 printf_filtered (" Previous frame's sp in %s\n",
1603 gdbarch_register_name (gdbarch
, realnum
));
1606 /* else keep quiet. */
1610 numregs
= gdbarch_num_regs (gdbarch
)
1611 + gdbarch_num_pseudo_regs (gdbarch
);
1612 for (i
= 0; i
< numregs
; i
++)
1613 if (i
!= gdbarch_sp_regnum (gdbarch
)
1614 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1616 /* Find out the location of the saved register without
1617 fetching the corresponding value. */
1618 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1619 &lval
, &addr
, &realnum
, NULL
);
1620 /* For moment, only display registers that were saved on the
1622 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1625 puts_filtered (" Saved registers:\n ");
1627 puts_filtered (",");
1629 printf_filtered (" %s at ",
1630 gdbarch_register_name (gdbarch
, i
));
1631 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1635 if (count
|| need_nl
)
1636 puts_filtered ("\n");
1639 do_cleanups (back_to
);
1642 /* Print briefly all stack frames or just the innermost COUNT_EXP
1646 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1648 struct frame_info
*fi
;
1651 struct frame_info
*trailing
;
1654 if (!target_has_stack
)
1655 error (_("No stack."));
1657 /* The following code must do two things. First, it must set the
1658 variable TRAILING to the frame from which we should start
1659 printing. Second, it must set the variable count to the number
1660 of frames which we should print, or -1 if all of them. */
1661 trailing
= get_current_frame ();
1666 count
= parse_and_eval_long (count_exp
);
1669 struct frame_info
*current
;
1674 while (current
&& count
--)
1677 current
= get_prev_frame (current
);
1680 /* Will stop when CURRENT reaches the top of the stack.
1681 TRAILING will be COUNT below it. */
1685 trailing
= get_prev_frame (trailing
);
1686 current
= get_prev_frame (current
);
1698 /* Read in symbols for all of the frames. Need to do this in a
1699 separate pass so that "Reading in symbols for xxx" messages
1700 don't screw up the appearance of the backtrace. Also if
1701 people have strong opinions against reading symbols for
1702 backtrace this may have to be an option. */
1704 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1709 pc
= get_frame_address_in_block (fi
);
1710 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1714 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1718 /* Don't use print_stack_frame; if an error() occurs it probably
1719 means further attempts to backtrace would fail (on the other
1720 hand, perhaps the code does or could be fixed to make sure
1721 the frame->prev field gets set to NULL in that case). */
1722 print_frame_info (fi
, 1, LOCATION
, 1);
1724 print_frame_local_vars (fi
, 1, gdb_stdout
);
1726 /* Save the last frame to check for error conditions. */
1730 /* If we've stopped before the end, mention that. */
1732 printf_filtered (_("(More stack frames follow...)\n"));
1734 /* If we've run out of frames, and the reason appears to be an error
1735 condition, print it. */
1736 if (fi
== NULL
&& trailing
!= NULL
)
1738 enum unwind_stop_reason reason
;
1740 reason
= get_frame_unwind_stop_reason (trailing
);
1741 if (reason
>= UNWIND_FIRST_ERROR
)
1742 printf_filtered (_("Backtrace stopped: %s\n"),
1743 frame_stop_reason_string (reason
));
1748 backtrace_command (char *arg
, int from_tty
)
1750 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1751 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1758 argv
= gdb_buildargv (arg
);
1759 make_cleanup_freeargv (argv
);
1761 for (i
= 0; argv
[i
]; i
++)
1765 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1766 argv
[i
][j
] = tolower (argv
[i
][j
]);
1768 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1769 fulltrace_arg
= argc
;
1772 arglen
+= strlen (argv
[i
]);
1777 if (fulltrace_arg
>= 0)
1781 arg
= xmalloc (arglen
+ 1);
1782 make_cleanup (xfree
, arg
);
1784 for (i
= 0; i
< (argc
+ 1); i
++)
1786 if (i
!= fulltrace_arg
)
1788 strcat (arg
, argv
[i
]);
1798 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1800 do_cleanups (old_chain
);
1804 backtrace_full_command (char *arg
, int from_tty
)
1806 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1810 /* Iterate over the local variables of a block B, calling CB with
1814 iterate_over_block_locals (struct block
*b
,
1815 iterate_over_block_arg_local_vars_cb cb
,
1818 struct dict_iterator iter
;
1821 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1823 switch (SYMBOL_CLASS (sym
))
1829 if (SYMBOL_IS_ARGUMENT (sym
))
1831 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1835 /* Ignore symbols which are not locals. */
1842 /* Same, but print labels. */
1845 /* Commented out, as the code using this function has also been
1846 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1847 was commented out in the first place. The discussion introducing
1848 this change (2007-12-04: Support lexical blocks and function bodies
1849 that occupy non-contiguous address ranges) did not explain why
1850 this change was made. */
1852 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1853 int *have_default
, struct ui_file
*stream
)
1855 struct dict_iterator iter
;
1857 int values_printed
= 0;
1859 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1861 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1867 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1869 struct symtab_and_line sal
;
1870 struct value_print_options opts
;
1872 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1874 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1875 get_user_print_options (&opts
);
1876 if (opts
.addressprint
)
1878 fprintf_filtered (stream
, " ");
1879 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1882 fprintf_filtered (stream
, " in file %s, line %d\n",
1883 sal
.symtab
->filename
, sal
.line
);
1887 return values_printed
;
1891 /* Iterate over all the local variables in block B, including all its
1892 superblocks, stopping when the top-level block is reached. */
1895 iterate_over_block_local_vars (struct block
*block
,
1896 iterate_over_block_arg_local_vars_cb cb
,
1901 iterate_over_block_locals (block
, cb
, cb_data
);
1902 /* After handling the function's top-level block, stop. Don't
1903 continue to its superblock, the block of per-file
1905 if (BLOCK_FUNCTION (block
))
1907 block
= BLOCK_SUPERBLOCK (block
);
1911 /* Data to be passed around in the calls to the locals and args
1914 struct print_variable_and_value_data
1916 struct frame_info
*frame
;
1918 struct ui_file
*stream
;
1922 /* The callback for the locals and args iterators. */
1925 do_print_variable_and_value (const char *print_name
,
1929 struct print_variable_and_value_data
*p
= cb_data
;
1931 print_variable_and_value (print_name
, sym
,
1932 p
->frame
, p
->stream
, p
->num_tabs
);
1933 p
->values_printed
= 1;
1937 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1938 struct ui_file
*stream
)
1940 struct print_variable_and_value_data cb_data
;
1941 struct block
*block
;
1944 if (!get_frame_pc_if_available (frame
, &pc
))
1946 fprintf_filtered (stream
,
1947 _("PC unavailable, cannot determine locals.\n"));
1951 block
= get_frame_block (frame
, 0);
1954 fprintf_filtered (stream
, "No symbol table info available.\n");
1958 cb_data
.frame
= frame
;
1959 cb_data
.num_tabs
= 4 * num_tabs
;
1960 cb_data
.stream
= stream
;
1961 cb_data
.values_printed
= 0;
1963 iterate_over_block_local_vars (block
,
1964 do_print_variable_and_value
,
1967 if (!cb_data
.values_printed
)
1968 fprintf_filtered (stream
, _("No locals.\n"));
1971 /* Same, but print labels. */
1974 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1975 struct ui_file
*stream
)
1978 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1980 struct blockvector
*bl
;
1981 struct block
*block
= get_frame_block (frame
, 0);
1982 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1983 int values_printed
= 0;
1984 int index
, have_default
= 0;
1985 char *blocks_printed
;
1986 CORE_ADDR pc
= get_frame_pc (frame
);
1990 fprintf_filtered (stream
, "No symbol table info available.\n");
1994 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1995 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1996 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2000 CORE_ADDR end
= BLOCK_END (block
) - 4;
2003 if (bl
!= blockvector_for_pc (end
, &index
))
2004 error (_("blockvector blotch"));
2005 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2006 error (_("blockvector botch"));
2007 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2010 /* Don't print out blocks that have gone by. */
2011 while (index
< last_index
2012 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2015 while (index
< last_index
2016 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2018 if (blocks_printed
[index
] == 0)
2020 if (print_block_frame_labels (gdbarch
,
2021 BLOCKVECTOR_BLOCK (bl
, index
),
2022 &have_default
, stream
))
2024 blocks_printed
[index
] = 1;
2030 if (values_printed
&& this_level_only
)
2033 /* After handling the function's top-level block, stop. Don't
2034 continue to its superblock, the block of per-file symbols.
2035 Also do not continue to the containing function of an inlined
2037 if (BLOCK_FUNCTION (block
))
2039 block
= BLOCK_SUPERBLOCK (block
);
2042 if (!values_printed
&& !this_level_only
)
2043 fprintf_filtered (stream
, _("No catches.\n"));
2048 locals_info (char *args
, int from_tty
)
2050 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2055 catch_info (char *ignore
, int from_tty
)
2057 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
2058 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
2062 /* Iterate over all the argument variables in block B.
2064 Returns 1 if any argument was walked; 0 otherwise. */
2067 iterate_over_block_arg_vars (struct block
*b
,
2068 iterate_over_block_arg_local_vars_cb cb
,
2071 struct dict_iterator iter
;
2072 struct symbol
*sym
, *sym2
;
2074 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2076 /* Don't worry about things which aren't arguments. */
2077 if (SYMBOL_IS_ARGUMENT (sym
))
2079 /* We have to look up the symbol because arguments can have
2080 two entries (one a parameter, one a local) and the one we
2081 want is the local, which lookup_symbol will find for us.
2082 This includes gcc1 (not gcc2) on the sparc when passing a
2083 small structure and gcc2 when the argument type is float
2084 and it is passed as a double and converted to float by
2085 the prologue (in the latter case the type of the LOC_ARG
2086 symbol is double and the type of the LOC_LOCAL symbol is
2087 float). There are also LOC_ARG/LOC_REGISTER pairs which
2088 are not combined in symbol-reading. */
2090 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2091 b
, VAR_DOMAIN
, NULL
);
2092 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2098 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2100 struct print_variable_and_value_data cb_data
;
2101 struct symbol
*func
;
2104 if (!get_frame_pc_if_available (frame
, &pc
))
2106 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2110 func
= get_frame_function (frame
);
2113 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2117 cb_data
.frame
= frame
;
2118 cb_data
.num_tabs
= 0;
2119 cb_data
.stream
= gdb_stdout
;
2120 cb_data
.values_printed
= 0;
2122 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2123 do_print_variable_and_value
, &cb_data
);
2125 if (!cb_data
.values_printed
)
2126 fprintf_filtered (stream
, _("No arguments.\n"));
2130 args_info (char *ignore
, int from_tty
)
2132 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2138 args_plus_locals_info (char *ignore
, int from_tty
)
2140 args_info (ignore
, from_tty
);
2141 locals_info (ignore
, from_tty
);
2145 /* Select frame FRAME. Also print the stack frame and show the source
2146 if this is the tui version. */
2148 select_and_print_frame (struct frame_info
*frame
)
2150 select_frame (frame
);
2152 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2155 /* Return the symbol-block in which the selected frame is executing.
2156 Can return zero under various legitimate circumstances.
2158 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2159 code address within the block returned. We use this to decide
2160 which macros are in scope. */
2163 get_selected_block (CORE_ADDR
*addr_in_block
)
2165 if (!has_stack_frames ())
2168 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2171 /* Find a frame a certain number of levels away from FRAME.
2172 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2173 Positive means go to earlier frames (up); negative, the reverse.
2174 The int that contains the number of levels is counted toward
2175 zero as the frames for those levels are found.
2176 If the top or bottom frame is reached, that frame is returned,
2177 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2178 how much farther the original request asked to go. */
2181 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2183 /* Going up is simple: just call get_prev_frame enough times or
2184 until the initial frame is reached. */
2185 while (*level_offset_ptr
> 0)
2187 struct frame_info
*prev
= get_prev_frame (frame
);
2191 (*level_offset_ptr
)--;
2195 /* Going down is just as simple. */
2196 while (*level_offset_ptr
< 0)
2198 struct frame_info
*next
= get_next_frame (frame
);
2202 (*level_offset_ptr
)++;
2209 /* The "select_frame" command. With no argument this is a NOP.
2210 Select the frame at level LEVEL_EXP if it is a valid level.
2211 Otherwise, treat LEVEL_EXP as an address expression and select it.
2213 See parse_frame_specification for more info on proper frame
2217 select_frame_command (char *level_exp
, int from_tty
)
2219 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2222 /* The "frame" command. With no argument, print the selected frame
2223 briefly. With an argument, behave like select_frame and then print
2224 the selected frame. */
2227 frame_command (char *level_exp
, int from_tty
)
2229 select_frame_command (level_exp
, from_tty
);
2230 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2233 /* The XDB Compatibility command to print the current frame. */
2236 current_frame_command (char *level_exp
, int from_tty
)
2238 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2241 /* Select the frame up one or COUNT_EXP stack levels from the
2242 previously selected frame, and print it briefly. */
2245 up_silently_base (char *count_exp
)
2247 struct frame_info
*frame
;
2251 count
= parse_and_eval_long (count_exp
);
2253 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2254 if (count
!= 0 && count_exp
== NULL
)
2255 error (_("Initial frame selected; you cannot go up."));
2256 select_frame (frame
);
2260 up_silently_command (char *count_exp
, int from_tty
)
2262 up_silently_base (count_exp
);
2266 up_command (char *count_exp
, int from_tty
)
2268 up_silently_base (count_exp
);
2269 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2272 /* Select the frame down one or COUNT_EXP stack levels from the previously
2273 selected frame, and print it briefly. */
2276 down_silently_base (char *count_exp
)
2278 struct frame_info
*frame
;
2282 count
= -parse_and_eval_long (count_exp
);
2284 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2285 if (count
!= 0 && count_exp
== NULL
)
2287 /* We only do this if COUNT_EXP is not specified. That way
2288 "down" means to really go down (and let me know if that is
2289 impossible), but "down 9999" can be used to mean go all the
2290 way down without getting an error. */
2292 error (_("Bottom (innermost) frame selected; you cannot go down."));
2295 select_frame (frame
);
2299 down_silently_command (char *count_exp
, int from_tty
)
2301 down_silently_base (count_exp
);
2305 down_command (char *count_exp
, int from_tty
)
2307 down_silently_base (count_exp
);
2308 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2313 return_command (char *retval_exp
, int from_tty
)
2315 struct frame_info
*thisframe
;
2316 struct gdbarch
*gdbarch
;
2317 struct symbol
*thisfun
;
2318 struct value
*return_value
= NULL
;
2319 const char *query_prefix
= "";
2321 thisframe
= get_selected_frame ("No selected frame.");
2322 thisfun
= get_frame_function (thisframe
);
2323 gdbarch
= get_frame_arch (thisframe
);
2325 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2326 error (_("Can not force return from an inlined function."));
2328 /* Compute the return value. If the computation triggers an error,
2329 let it bail. If the return type can't be handled, set
2330 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2334 struct expression
*retval_expr
= parse_expression (retval_exp
);
2335 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2336 struct type
*return_type
= NULL
;
2338 /* Compute the return value. Should the computation fail, this
2339 call throws an error. */
2340 return_value
= evaluate_expression (retval_expr
);
2342 /* Cast return value to the return type of the function. Should
2343 the cast fail, this call throws an error. */
2344 if (thisfun
!= NULL
)
2345 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2346 if (return_type
== NULL
)
2348 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2349 error (_("Return value type not available for selected "
2351 "Please use an explicit cast of the value to return."));
2352 return_type
= value_type (return_value
);
2354 do_cleanups (old_chain
);
2355 CHECK_TYPEDEF (return_type
);
2356 return_value
= value_cast (return_type
, return_value
);
2358 /* Make sure the value is fully evaluated. It may live in the
2359 stack frame we're about to pop. */
2360 if (value_lazy (return_value
))
2361 value_fetch_lazy (return_value
);
2363 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2364 /* If the return-type is "void", don't try to find the
2365 return-value's location. However, do still evaluate the
2366 return expression so that, even when the expression result
2367 is discarded, side effects such as "return i++" still
2369 return_value
= NULL
;
2370 else if (thisfun
!= NULL
2371 && using_struct_return (gdbarch
,
2372 SYMBOL_TYPE (thisfun
), return_type
))
2374 query_prefix
= "The location at which to store the "
2375 "function's return value is unknown.\n"
2376 "If you continue, the return value "
2377 "that you specified will be ignored.\n";
2378 return_value
= NULL
;
2382 /* Does an interactive user really want to do this? Include
2383 information, such as how well GDB can handle the return value, in
2384 the query message. */
2389 if (thisfun
== NULL
)
2390 confirmed
= query (_("%sMake selected stack frame return now? "),
2393 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2394 SYMBOL_PRINT_NAME (thisfun
));
2396 error (_("Not confirmed"));
2399 /* Discard the selected frame and all frames inner-to it. */
2400 frame_pop (get_selected_frame (NULL
));
2402 /* Store RETURN_VALUE in the just-returned register set. */
2403 if (return_value
!= NULL
)
2405 struct type
*return_type
= value_type (return_value
);
2406 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2407 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2409 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2411 == RETURN_VALUE_REGISTER_CONVENTION
);
2412 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2413 get_current_regcache (), NULL
/*read*/,
2414 value_contents (return_value
) /*write*/);
2417 /* If we are at the end of a call dummy now, pop the dummy frame
2419 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2420 frame_pop (get_current_frame ());
2422 /* If interactive, print the frame that is now current. */
2424 frame_command ("0", 1);
2426 select_frame_command ("0", 0);
2429 /* Sets the scope to input function name, provided that the function
2430 is within the current stack frame. */
2432 struct function_bounds
2434 CORE_ADDR low
, high
;
2438 func_command (char *arg
, int from_tty
)
2440 struct frame_info
*frame
;
2442 struct symtabs_and_lines sals
;
2445 struct function_bounds
*func_bounds
= NULL
;
2446 struct cleanup
*cleanups
;
2451 frame
= parse_frame_specification ("0");
2452 sals
= decode_line_spec (arg
, DECODE_LINE_FUNFIRSTLINE
);
2453 cleanups
= make_cleanup (xfree
, sals
.sals
);
2454 func_bounds
= (struct function_bounds
*) xmalloc (
2455 sizeof (struct function_bounds
) * sals
.nelts
);
2456 make_cleanup (xfree
, func_bounds
);
2457 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2459 if (sals
.sals
[i
].pspace
!= current_program_space
)
2460 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2461 else if (sals
.sals
[i
].pc
== 0
2462 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2463 &func_bounds
[i
].low
,
2464 &func_bounds
[i
].high
) == 0)
2466 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2472 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2473 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2474 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2478 frame
= find_relative_frame (frame
, &level
);
2481 while (!found
&& level
== 0);
2483 do_cleanups (cleanups
);
2486 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2487 else if (frame
!= get_selected_frame (NULL
))
2488 select_and_print_frame (frame
);
2491 /* Gets the language of the current frame. */
2494 get_frame_language (void)
2496 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2500 volatile struct gdb_exception ex
;
2504 /* We determine the current frame language by looking up its
2505 associated symtab. To retrieve this symtab, we use the frame
2506 PC. However we cannot use the frame PC as is, because it
2507 usually points to the instruction following the "call", which
2508 is sometimes the first instruction of another function. So
2509 we rely on get_frame_address_in_block(), it provides us with
2510 a PC that is guaranteed to be inside the frame's code
2513 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2515 pc
= get_frame_address_in_block (frame
);
2519 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2520 throw_exception (ex
);
2524 s
= find_pc_symtab (pc
);
2530 return language_unknown
;
2534 /* Provide a prototype to silence -Wmissing-prototypes. */
2535 void _initialize_stack (void);
2538 _initialize_stack (void)
2540 add_com ("return", class_stack
, return_command
, _("\
2541 Make selected stack frame return to its caller.\n\
2542 Control remains in the debugger, but when you continue\n\
2543 execution will resume in the frame above the one now selected.\n\
2544 If an argument is given, it is an expression for the value to return."));
2546 add_com ("up", class_stack
, up_command
, _("\
2547 Select and print stack frame that called this one.\n\
2548 An argument says how many frames up to go."));
2549 add_com ("up-silently", class_support
, up_silently_command
, _("\
2550 Same as the `up' command, but does not print anything.\n\
2551 This is useful in command scripts."));
2553 add_com ("down", class_stack
, down_command
, _("\
2554 Select and print stack frame called by this one.\n\
2555 An argument says how many frames down to go."));
2556 add_com_alias ("do", "down", class_stack
, 1);
2557 add_com_alias ("dow", "down", class_stack
, 1);
2558 add_com ("down-silently", class_support
, down_silently_command
, _("\
2559 Same as the `down' command, but does not print anything.\n\
2560 This is useful in command scripts."));
2562 add_com ("frame", class_stack
, frame_command
, _("\
2563 Select and print a stack frame.\nWith no argument, \
2564 print the selected stack frame. (See also \"info frame\").\n\
2565 An argument specifies the frame to select.\n\
2566 It can be a stack frame number or the address of the frame.\n\
2567 With argument, nothing is printed if input is coming from\n\
2568 a command file or a user-defined command."));
2570 add_com_alias ("f", "frame", class_stack
, 1);
2574 add_com ("L", class_stack
, current_frame_command
,
2575 _("Print the current stack frame.\n"));
2576 add_com_alias ("V", "frame", class_stack
, 1);
2578 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2579 Select a stack frame without printing anything.\n\
2580 An argument specifies the frame to select.\n\
2581 It can be a stack frame number or the address of the frame.\n"));
2583 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2584 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2585 With a negative argument, print outermost -COUNT frames.\nUse of the \
2586 'full' qualifier also prints the values of the local variables.\n"));
2587 add_com_alias ("bt", "backtrace", class_stack
, 0);
2590 add_com_alias ("t", "backtrace", class_stack
, 0);
2591 add_com ("T", class_stack
, backtrace_full_command
, _("\
2592 Print backtrace of all stack frames, or innermost COUNT frames\n\
2593 and the values of the local variables.\n\
2594 With a negative argument, print outermost -COUNT frames.\n\
2595 Usage: T <count>\n"));
2598 add_com_alias ("where", "backtrace", class_alias
, 0);
2599 add_info ("stack", backtrace_command
,
2600 _("Backtrace of the stack, or innermost COUNT frames."));
2601 add_info_alias ("s", "stack", 1);
2602 add_info ("frame", frame_info
,
2603 _("All about selected stack frame, or frame at ADDR."));
2604 add_info_alias ("f", "frame", 1);
2605 add_info ("locals", locals_info
,
2606 _("Local variables of current stack frame."));
2607 add_info ("args", args_info
,
2608 _("Argument variables of current stack frame."));
2610 add_com ("l", class_info
, args_plus_locals_info
,
2611 _("Argument and local variables of current stack frame."));
2614 add_com ("func", class_stack
, func_command
, _("\
2615 Select the stack frame that contains <func>.\n\
2616 Usage: func <name>\n"));
2618 add_info ("catch", catch_info
,
2619 _("Exceptions that can be caught in the current stack frame."));
2621 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2622 print_frame_arguments_choices
, &print_frame_arguments
,
2623 _("Set printing of non-scalar frame arguments"),
2624 _("Show printing of non-scalar frame arguments"),
2625 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2627 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2628 &disassemble_next_line
, _("\
2629 Set whether to disassemble next source line or insn when execution stops."),
2631 Show whether to disassemble next source line or insn when execution stops."),
2633 If ON, GDB will display disassembly of the next source line, in addition\n\
2634 to displaying the source line itself. If the next source line cannot\n\
2635 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2636 will display disassembly of next instruction instead of showing the\n\
2638 If AUTO, display disassembly of next instruction only if the source line\n\
2639 cannot be displayed.\n\
2640 If OFF (which is the default), never display the disassembly of the next\n\
2643 show_disassemble_next_line
,
2644 &setlist
, &showlist
);
2645 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2647 add_setshow_enum_cmd ("entry-values", class_stack
,
2648 print_entry_values_choices
, &print_entry_values
,
2649 _("Set printing of function arguments at function "
2651 _("Show printing of function arguments at function "
2654 GDB can sometimes determine the values of function arguments at entry,\n\
2655 in addition to their current values. This option tells GDB whether\n\
2656 to print the current value, the value at entry (marked as val@entry),\n\
2657 or both. Note that one or both of these values may be <optimized out>."),
2658 NULL
, NULL
, &setprintlist
, &showprintlist
);