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"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
58 void (*deprecated_selected_frame_level_changed_hook
) (int);
60 /* The possible choices of "set print frame-arguments", and the value
63 static const char *print_frame_arguments_choices
[] =
64 {"all", "scalars", "none", NULL
};
65 static const char *print_frame_arguments
= "scalars";
67 /* The possible choices of "set print entry-values", and the value
70 const char print_entry_values_no
[] = "no";
71 const char print_entry_values_only
[] = "only";
72 const char print_entry_values_preferred
[] = "preferred";
73 const char print_entry_values_if_needed
[] = "if-needed";
74 const char print_entry_values_both
[] = "both";
75 const char print_entry_values_compact
[] = "compact";
76 const char print_entry_values_default
[] = "default";
77 static const char *print_entry_values_choices
[] =
79 print_entry_values_no
,
80 print_entry_values_only
,
81 print_entry_values_preferred
,
82 print_entry_values_if_needed
,
83 print_entry_values_both
,
84 print_entry_values_compact
,
85 print_entry_values_default
,
88 const char *print_entry_values
= print_entry_values_default
;
90 /* Prototypes for local functions. */
92 static void print_frame_local_vars (struct frame_info
*, int,
95 static void print_frame (struct frame_info
*frame
, int print_level
,
96 enum print_what print_what
, int print_args
,
97 struct symtab_and_line sal
);
99 static void set_last_displayed_sal (int valid
,
100 struct program_space
*pspace
,
102 struct symtab
*symtab
,
105 /* Zero means do things normally; we are interacting directly with the
106 user. One means print the full filename and linenumber when a
107 frame is printed, and do so in a format emacs18/emacs19.22 can
108 parse. Two means print similar annotations, but in many more
109 cases and in a slightly different syntax. */
111 int annotation_level
= 0;
113 /* These variables hold the last symtab and line we displayed to the user.
114 * This is where we insert a breakpoint or a skiplist entry by default. */
115 static int last_displayed_sal_valid
= 0;
116 static struct program_space
*last_displayed_pspace
= 0;
117 static CORE_ADDR last_displayed_addr
= 0;
118 static struct symtab
*last_displayed_symtab
= 0;
119 static int last_displayed_line
= 0;
122 /* Return 1 if we should display the address in addition to the location,
123 because we are in the middle of a statement. */
126 frame_show_address (struct frame_info
*frame
,
127 struct symtab_and_line sal
)
129 /* If there is a line number, but no PC, then there is no location
130 information associated with this sal. The only way that should
131 happen is for the call sites of inlined functions (SAL comes from
132 find_frame_sal). Otherwise, we would have some PC range if the
133 SAL came from a line table. */
134 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
136 if (get_next_frame (frame
) == NULL
)
137 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
139 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
143 return get_frame_pc (frame
) != sal
.pc
;
146 /* Show or print a stack frame FRAME briefly. The output is format
147 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
148 relative level, function name, argument list, and file name and
149 line number. If the frame's PC is not at the beginning of the
150 source line, the actual PC is printed at the beginning. */
153 print_stack_frame (struct frame_info
*frame
, int print_level
,
154 enum print_what print_what
)
156 volatile struct gdb_exception e
;
158 /* For mi, alway print location and address. */
159 if (ui_out_is_mi_like_p (current_uiout
))
160 print_what
= LOC_AND_ADDRESS
;
162 TRY_CATCH (e
, RETURN_MASK_ERROR
)
164 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
166 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
167 set_current_sal_from_frame (frame
, center
);
171 /* Print nameless arguments of frame FRAME on STREAM, where START is
172 the offset of the first nameless argument, and NUM is the number of
173 nameless arguments to print. FIRST is nonzero if this is the first
174 argument (not just the first nameless argument). */
177 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
178 int first
, struct ui_file
*stream
)
180 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
181 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
186 for (i
= 0; i
< num
; i
++)
189 argsaddr
= get_frame_args_address (frame
);
192 arg_value
= read_memory_integer (argsaddr
+ start
,
193 sizeof (int), byte_order
);
195 fprintf_filtered (stream
, ", ");
196 fprintf_filtered (stream
, "%ld", arg_value
);
198 start
+= sizeof (int);
202 /* Print single argument of inferior function. ARG must be already
205 Errors are printed as if they would be the parameter value. Use zeroed ARG
206 iff it should not be printed accoring to user settings. */
209 print_frame_arg (const struct frame_arg
*arg
)
211 struct ui_out
*uiout
= current_uiout
;
212 volatile struct gdb_exception except
;
213 struct cleanup
*old_chain
;
214 struct ui_stream
*stb
;
216 stb
= ui_out_stream_new (uiout
);
217 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
219 gdb_assert (!arg
->val
|| !arg
->error
);
220 gdb_assert (arg
->entry_kind
== print_entry_values_no
221 || arg
->entry_kind
== print_entry_values_only
222 || (!ui_out_is_mi_like_p (uiout
)
223 && arg
->entry_kind
== print_entry_values_compact
));
225 annotate_arg_begin ();
227 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
228 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
229 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
230 if (arg
->entry_kind
== print_entry_values_compact
)
232 /* It is OK to provide invalid MI-like stream as with
233 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
234 fputs_filtered ("=", stb
->stream
);
236 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
237 SYMBOL_LANGUAGE (arg
->sym
),
238 DMGL_PARAMS
| DMGL_ANSI
);
240 if (arg
->entry_kind
== print_entry_values_only
241 || arg
->entry_kind
== print_entry_values_compact
)
242 fputs_filtered ("@entry", stb
->stream
);
243 ui_out_field_stream (uiout
, "name", stb
);
244 annotate_arg_name_end ();
245 ui_out_text (uiout
, "=");
247 if (!arg
->val
&& !arg
->error
)
248 ui_out_text (uiout
, "...");
252 except
.message
= arg
->error
;
255 /* TRY_CATCH has two statements, wrap it in a block. */
257 TRY_CATCH (except
, RETURN_MASK_ERROR
)
259 const struct language_defn
*language
;
260 struct value_print_options opts
;
262 /* Avoid value_print because it will deref ref parameters. We
263 just want to print their addresses. Print ??? for args whose
264 address we do not know. We pass 2 as "recurse" to val_print
265 because our standard indentation here is 4 spaces, and
266 val_print indents 2 for each recurse. */
268 annotate_arg_value (value_type (arg
->val
));
270 /* Use the appropriate language to display our symbol, unless the
271 user forced the language to a specific language. */
272 if (language_mode
== language_mode_auto
)
273 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
275 language
= current_language
;
277 get_raw_print_options (&opts
);
280 /* True in "summary" mode, false otherwise. */
281 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
283 common_val_print (arg
->val
, stb
->stream
, 2, &opts
, language
);
287 fprintf_filtered (stb
->stream
, _("<error reading variable: %s>"),
291 ui_out_field_stream (uiout
, "value", stb
);
293 /* Aleo invoke ui_out_tuple_end. */
294 do_cleanups (old_chain
);
299 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
300 responsible for xfree of ARGP->ERROR. This function never throws an
304 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
305 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
307 struct value
*val
= NULL
, *entryval
= NULL
;
308 char *val_error
= NULL
, *entryval_error
= NULL
;
310 volatile struct gdb_exception except
;
312 if (print_entry_values
!= print_entry_values_only
313 && print_entry_values
!= print_entry_values_preferred
)
315 TRY_CATCH (except
, RETURN_MASK_ERROR
)
317 val
= read_var_value (sym
, frame
);
321 val_error
= alloca (strlen (except
.message
) + 1);
322 strcpy (val_error
, except
.message
);
326 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
327 && print_entry_values
!= print_entry_values_no
328 && (print_entry_values
!= print_entry_values_if_needed
329 || !val
|| value_optimized_out (val
)))
331 TRY_CATCH (except
, RETURN_MASK_ERROR
)
333 const struct symbol_computed_ops
*ops
;
335 ops
= SYMBOL_COMPUTED_OPS (sym
);
336 entryval
= ops
->read_variable_at_entry (sym
, frame
);
340 entryval_error
= alloca (strlen (except
.message
) + 1);
341 strcpy (entryval_error
, except
.message
);
344 if (except
.error
== NO_ENTRY_VALUE_ERROR
345 || (entryval
&& value_optimized_out (entryval
)))
348 entryval_error
= NULL
;
351 if (print_entry_values
== print_entry_values_compact
352 || print_entry_values
== print_entry_values_default
)
354 /* For MI do not try to use print_entry_values_compact for ARGP. */
356 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
358 unsigned len
= TYPE_LENGTH (value_type (val
));
360 if (!value_optimized_out (val
) && value_lazy (val
))
361 value_fetch_lazy (val
);
362 if (!value_optimized_out (val
) && value_lazy (entryval
))
363 value_fetch_lazy (entryval
);
364 if (!value_optimized_out (val
)
365 && value_available_contents_eq (val
, 0, entryval
, 0, len
))
367 /* Initialize it just to avoid a GCC false warning. */
368 struct value
*val_deref
= NULL
, *entryval_deref
;
370 /* DW_AT_GNU_call_site_value does match with the current
371 value. If it is a reference still try to verify if
372 dereferenced DW_AT_GNU_call_site_data_value does not
375 TRY_CATCH (except
, RETURN_MASK_ERROR
)
379 val_deref
= coerce_ref (val
);
380 if (value_lazy (val_deref
))
381 value_fetch_lazy (val_deref
);
382 len_deref
= TYPE_LENGTH (value_type (val_deref
));
384 entryval_deref
= coerce_ref (entryval
);
385 if (value_lazy (entryval_deref
))
386 value_fetch_lazy (entryval_deref
);
388 /* If the reference addresses match but dereferenced
389 content does not match print them. */
391 && value_available_contents_eq (val_deref
, 0,
397 /* Value was not a reference; and its content matches. */
398 if (val
== val_deref
)
400 /* If the dereferenced content could not be fetched do not
402 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
404 else if (except
.message
)
406 entryval_error
= alloca (strlen (except
.message
) + 1);
407 strcpy (entryval_error
, except
.message
);
415 /* Try to remove possibly duplicate error message for ENTRYARGP even
418 if (val_error
&& entryval_error
419 && strcmp (val_error
, entryval_error
) == 0)
421 entryval_error
= NULL
;
423 /* Do not se VAL_EQUAL as the same error message may be shown for
424 the entry value even if no entry values are present in the
430 if (entryval
== NULL
)
432 if (print_entry_values
== print_entry_values_preferred
)
434 TRY_CATCH (except
, RETURN_MASK_ERROR
)
436 val
= read_var_value (sym
, frame
);
440 val_error
= alloca (strlen (except
.message
) + 1);
441 strcpy (val_error
, except
.message
);
444 if (print_entry_values
== print_entry_values_only
445 || print_entry_values
== print_entry_values_both
446 || (print_entry_values
== print_entry_values_preferred
447 && (!val
|| value_optimized_out (val
))))
448 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
450 if ((print_entry_values
== print_entry_values_compact
451 || print_entry_values
== print_entry_values_if_needed
452 || print_entry_values
== print_entry_values_preferred
)
453 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
461 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
462 if (!val
&& !val_error
)
463 argp
->entry_kind
= print_entry_values_only
;
464 else if ((print_entry_values
== print_entry_values_compact
465 || print_entry_values
== print_entry_values_default
) && val_equal
)
467 argp
->entry_kind
= print_entry_values_compact
;
468 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
471 argp
->entry_kind
= print_entry_values_no
;
473 entryargp
->sym
= sym
;
474 entryargp
->val
= entryval
;
475 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
476 if (!entryval
&& !entryval_error
)
477 entryargp
->entry_kind
= print_entry_values_no
;
479 entryargp
->entry_kind
= print_entry_values_only
;
482 /* Print the arguments of frame FRAME on STREAM, given the function
483 FUNC running in that frame (as a symbol), where NUM is the number
484 of arguments according to the stack frame (or -1 if the number of
485 arguments is unknown). */
487 /* Note that currently the "number of arguments according to the
488 stack frame" is only known on VAX where i refers to the "number of
489 ints of arguments according to the stack frame". */
492 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
493 int num
, struct ui_file
*stream
)
495 struct ui_out
*uiout
= current_uiout
;
497 /* Offset of next stack argument beyond the one we have seen that is
498 at the highest offset, or -1 if we haven't come to a stack
500 long highest_offset
= -1;
501 /* Number of ints of arguments that we have printed so far. */
502 int args_printed
= 0;
503 struct cleanup
*old_chain
, *list_chain
;
504 struct ui_stream
*stb
;
505 /* True if we should print arguments, false otherwise. */
506 int print_args
= strcmp (print_frame_arguments
, "none");
507 /* True in "summary" mode, false otherwise. */
508 int summary
= !strcmp (print_frame_arguments
, "scalars");
510 stb
= ui_out_stream_new (uiout
);
511 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
515 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
516 struct dict_iterator iter
;
519 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
521 struct frame_arg arg
, entryarg
;
525 /* Keep track of the highest stack argument offset seen, and
526 skip over any kinds of symbols we don't care about. */
528 if (!SYMBOL_IS_ARGUMENT (sym
))
531 switch (SYMBOL_CLASS (sym
))
536 long current_offset
= SYMBOL_VALUE (sym
);
537 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
539 /* Compute address of next argument by adding the size of
540 this argument and rounding to an int boundary. */
542 ((current_offset
+ arg_size
+ sizeof (int) - 1)
543 & ~(sizeof (int) - 1));
545 /* If this is the highest offset seen yet, set
547 if (highest_offset
== -1
548 || (current_offset
> highest_offset
))
549 highest_offset
= current_offset
;
551 /* Add the number of ints we're about to print to
553 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
556 /* We care about types of symbols, but don't need to
557 keep track of stack offsets in them. */
559 case LOC_REGPARM_ADDR
:
561 case LOC_OPTIMIZED_OUT
:
566 /* We have to look up the symbol because arguments can have
567 two entries (one a parameter, one a local) and the one we
568 want is the local, which lookup_symbol will find for us.
569 This includes gcc1 (not gcc2) on SPARC when passing a
570 small structure and gcc2 when the argument type is float
571 and it is passed as a double and converted to float by
572 the prologue (in the latter case the type of the LOC_ARG
573 symbol is double and the type of the LOC_LOCAL symbol is
575 /* But if the parameter name is null, don't try it. Null
576 parameter names occur on the RS/6000, for traceback
577 tables. FIXME, should we even print them? */
579 if (*SYMBOL_LINKAGE_NAME (sym
))
583 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
584 b
, VAR_DOMAIN
, NULL
);
585 gdb_assert (nsym
!= NULL
);
586 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
587 && !SYMBOL_IS_ARGUMENT (nsym
))
589 /* There is a LOC_ARG/LOC_REGISTER pair. This means
590 that it was passed on the stack and loaded into a
591 register, or passed in a register and stored in a
592 stack slot. GDB 3.x used the LOC_ARG; GDB
593 4.0-4.11 used the LOC_REGISTER.
595 Reasons for using the LOC_ARG:
597 (1) Because find_saved_registers may be slow for
600 (2) Because registers are often re-used and stack
601 slots rarely (never?) are. Therefore using
602 the stack slot is much less likely to print
605 Reasons why we might want to use the LOC_REGISTER:
607 (1) So that the backtrace prints the same value
608 as "print foo". I see no compelling reason
609 why this needs to be the case; having the
610 backtrace print the value which was passed
611 in, and "print foo" print the value as
612 modified within the called function, makes
615 Additional note: It might be nice if "info args"
616 displayed both values.
618 One more note: There is a case with SPARC
619 structure passing where we need to use the
620 LOC_REGISTER, but this is dealt with by creating
621 a single LOC_REGPARM in symbol reading. */
623 /* Leave sym (the LOC_ARG) alone. */
630 /* Print the current arg. */
632 ui_out_text (uiout
, ", ");
633 ui_out_wrap_hint (uiout
, " ");
637 memset (&arg
, 0, sizeof (arg
));
639 arg
.entry_kind
= print_entry_values_no
;
640 memset (&entryarg
, 0, sizeof (entryarg
));
642 entryarg
.entry_kind
= print_entry_values_no
;
645 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
647 if (arg
.entry_kind
!= print_entry_values_only
)
648 print_frame_arg (&arg
);
650 if (entryarg
.entry_kind
!= print_entry_values_no
)
652 if (arg
.entry_kind
!= print_entry_values_only
)
654 ui_out_text (uiout
, ", ");
655 ui_out_wrap_hint (uiout
, " ");
658 print_frame_arg (&entryarg
);
662 xfree (entryarg
.error
);
668 /* Don't print nameless args in situations where we don't know
669 enough about the stack to find them. */
674 if (highest_offset
== -1)
675 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
677 start
= highest_offset
;
679 print_frame_nameless_args (frame
, start
, num
- args_printed
,
683 do_cleanups (old_chain
);
686 /* Set the current source and line to the location given by frame
687 FRAME, if possible. When CENTER is true, adjust so the relevant
688 line is in the center of the next 'list'. */
691 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
693 struct symtab_and_line sal
;
695 find_frame_sal (frame
, &sal
);
699 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
700 set_current_source_symtab_and_line (&sal
);
704 /* If ON, GDB will display disassembly of the next source line when
705 execution of the program being debugged stops.
706 If AUTO (which is the default), or there's no line info to determine
707 the source line of the next instruction, display disassembly of next
708 instruction instead. */
710 static enum auto_boolean disassemble_next_line
;
713 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
714 struct cmd_list_element
*c
,
717 fprintf_filtered (file
,
718 _("Debugger's willingness to use "
719 "disassemble-next-line is %s.\n"),
723 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
724 because it will be broken by filter sometime. */
727 do_gdb_disassembly (struct gdbarch
*gdbarch
,
728 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
730 volatile struct gdb_exception exception
;
732 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
734 gdb_disassembly (gdbarch
, current_uiout
, 0,
735 DISASSEMBLY_RAW_INSN
, how_many
,
738 if (exception
.reason
< 0)
740 /* If an exception was thrown while doing the disassembly, print
741 the error message, to give the user a clue of what happened. */
742 exception_print (gdb_stderr
, exception
);
746 /* Print information about frame FRAME. The output is format according
747 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
750 SRC_LINE: Print only source line.
751 LOCATION: Print only location.
752 LOC_AND_SRC: Print location and source line.
754 Used in "where" output, and to emit breakpoint or step
758 print_frame_info (struct frame_info
*frame
, int print_level
,
759 enum print_what print_what
, int print_args
)
761 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
762 struct symtab_and_line sal
;
765 struct ui_out
*uiout
= current_uiout
;
767 if (get_frame_type (frame
) == DUMMY_FRAME
768 || get_frame_type (frame
) == SIGTRAMP_FRAME
769 || get_frame_type (frame
) == ARCH_FRAME
)
771 struct cleanup
*uiout_cleanup
772 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
774 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
775 gdbarch
, get_frame_pc (frame
));
777 /* Do this regardless of SOURCE because we don't have any source
778 to list for this frame. */
781 ui_out_text (uiout
, "#");
782 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
783 frame_relative_level (frame
));
785 if (ui_out_is_mi_like_p (uiout
))
787 annotate_frame_address ();
788 ui_out_field_core_addr (uiout
, "addr",
789 gdbarch
, get_frame_pc (frame
));
790 annotate_frame_address_end ();
793 if (get_frame_type (frame
) == DUMMY_FRAME
)
795 annotate_function_call ();
796 ui_out_field_string (uiout
, "func", "<function called from gdb>");
798 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
800 annotate_signal_handler_caller ();
801 ui_out_field_string (uiout
, "func", "<signal handler called>");
803 else if (get_frame_type (frame
) == ARCH_FRAME
)
805 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
807 ui_out_text (uiout
, "\n");
808 annotate_frame_end ();
810 do_cleanups (uiout_cleanup
);
814 /* If FRAME is not the innermost frame, that normally means that
815 FRAME->pc points to *after* the call instruction, and we want to
816 get the line containing the call, never the next line. But if
817 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
818 next frame was not entered as the result of a call, and we want
819 to get the line containing FRAME->pc. */
820 find_frame_sal (frame
, &sal
);
822 location_print
= (print_what
== LOCATION
823 || print_what
== LOC_AND_ADDRESS
824 || print_what
== SRC_AND_LOC
);
826 if (location_print
|| !sal
.symtab
)
827 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
829 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
831 /* If disassemble-next-line is set to auto or on and doesn't have
832 the line debug messages for $pc, output the next instruction. */
833 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
834 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
835 && source_print
&& !sal
.symtab
)
836 do_gdb_disassembly (get_frame_arch (frame
), 1,
837 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
839 if (source_print
&& sal
.symtab
)
842 int mid_statement
= ((print_what
== SRC_LINE
)
843 && frame_show_address (frame
, sal
));
845 if (annotation_level
)
846 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
847 get_frame_pc (frame
));
850 if (deprecated_print_frame_info_listing_hook
)
851 deprecated_print_frame_info_listing_hook (sal
.symtab
,
856 struct value_print_options opts
;
858 get_user_print_options (&opts
);
859 /* We used to do this earlier, but that is clearly
860 wrong. This function is used by many different
861 parts of gdb, including normal_stop in infrun.c,
862 which uses this to print out the current PC
863 when we stepi/nexti into the middle of a source
864 line. Only the command line really wants this
865 behavior. Other UIs probably would like the
866 ability to decide for themselves if it is desired. */
867 if (opts
.addressprint
&& mid_statement
)
869 ui_out_field_core_addr (uiout
, "addr",
870 gdbarch
, get_frame_pc (frame
));
871 ui_out_text (uiout
, "\t");
874 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
878 /* If disassemble-next-line is set to on and there is line debug
879 messages, output assembly codes for next line. */
880 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
881 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
884 if (print_what
!= LOCATION
)
888 if (get_frame_pc_if_available (frame
, &pc
))
889 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
891 set_last_displayed_sal (0, 0, 0, 0, 0);
894 annotate_frame_end ();
896 gdb_flush (gdb_stdout
);
899 /* Remember the last symtab and line we displayed, which we use e.g.
900 * as the place to put a breakpoint when the `break' command is
901 * invoked with no arguments. */
904 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
905 CORE_ADDR addr
, struct symtab
*symtab
,
908 last_displayed_sal_valid
= valid
;
909 last_displayed_pspace
= pspace
;
910 last_displayed_addr
= addr
;
911 last_displayed_symtab
= symtab
;
912 last_displayed_line
= line
;
915 /* Forget the last sal we displayed. */
918 clear_last_displayed_sal (void)
920 last_displayed_sal_valid
= 0;
921 last_displayed_pspace
= 0;
922 last_displayed_addr
= 0;
923 last_displayed_symtab
= 0;
924 last_displayed_line
= 0;
927 /* Is our record of the last sal we displayed valid? If not,
928 * the get_last_displayed_* functions will return NULL or 0, as
932 last_displayed_sal_is_valid (void)
934 return last_displayed_sal_valid
;
937 /* Get the pspace of the last sal we displayed, if it's valid. */
939 struct program_space
*
940 get_last_displayed_pspace (void)
942 if (last_displayed_sal_valid
)
943 return last_displayed_pspace
;
947 /* Get the address of the last sal we displayed, if it's valid. */
950 get_last_displayed_addr (void)
952 if (last_displayed_sal_valid
)
953 return last_displayed_addr
;
957 /* Get the symtab of the last sal we displayed, if it's valid. */
960 get_last_displayed_symtab (void)
962 if (last_displayed_sal_valid
)
963 return last_displayed_symtab
;
967 /* Get the line of the last sal we displayed, if it's valid. */
970 get_last_displayed_line (void)
972 if (last_displayed_sal_valid
)
973 return last_displayed_line
;
977 /* Get the last sal we displayed, if it's valid. */
980 get_last_displayed_sal (struct symtab_and_line
*sal
)
982 if (last_displayed_sal_valid
)
984 sal
->pspace
= last_displayed_pspace
;
985 sal
->pc
= last_displayed_addr
;
986 sal
->symtab
= last_displayed_symtab
;
987 sal
->line
= last_displayed_line
;
999 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1000 corresponding to FRAME. */
1003 find_frame_funname (struct frame_info
*frame
, char **funname
,
1004 enum language
*funlang
, struct symbol
**funcp
)
1006 struct symbol
*func
;
1009 *funlang
= language_unknown
;
1013 func
= get_frame_function (frame
);
1016 /* In certain pathological cases, the symtabs give the wrong
1017 function (when we are in the first function in a file which
1018 is compiled without debugging symbols, the previous function
1019 is compiled with debugging symbols, and the "foo.o" symbol
1020 that is supposed to tell us where the file with debugging
1021 symbols ends has been truncated by ar because it is longer
1022 than 15 characters). This also occurs if the user uses asm()
1023 to create a function but not stabs for it (in a file compiled
1026 So look in the minimal symbol tables as well, and if it comes
1027 up with a larger address for the function use that instead.
1028 I don't think this can ever cause any problems; there
1029 shouldn't be any minimal symbols in the middle of a function;
1030 if this is ever changed many parts of GDB will need to be
1031 changed (and we'll create a find_pc_minimal_function or some
1034 struct minimal_symbol
*msymbol
= NULL
;
1036 /* Don't attempt to do this for inlined functions, which do not
1037 have a corresponding minimal symbol. */
1038 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1040 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1043 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1044 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1046 /* We also don't know anything about the function besides
1047 its address and name. */
1049 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1050 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1054 *funname
= SYMBOL_PRINT_NAME (func
);
1055 *funlang
= SYMBOL_LANGUAGE (func
);
1058 if (*funlang
== language_cplus
)
1060 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1061 to display the demangled name that we already have
1062 stored in the symbol table, but we stored a version
1063 with DMGL_PARAMS turned on, and here we don't want to
1064 display parameters. So remove the parameters. */
1065 char *func_only
= cp_remove_params (*funname
);
1069 *funname
= func_only
;
1070 make_cleanup (xfree
, func_only
);
1077 struct minimal_symbol
*msymbol
;
1080 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1083 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1084 if (msymbol
!= NULL
)
1086 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1087 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1093 print_frame (struct frame_info
*frame
, int print_level
,
1094 enum print_what print_what
, int print_args
,
1095 struct symtab_and_line sal
)
1097 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1098 struct ui_out
*uiout
= current_uiout
;
1099 char *funname
= NULL
;
1100 enum language funlang
= language_unknown
;
1101 struct ui_stream
*stb
;
1102 struct cleanup
*old_chain
, *list_chain
;
1103 struct value_print_options opts
;
1104 struct symbol
*func
;
1108 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1110 stb
= ui_out_stream_new (uiout
);
1111 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
1113 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1115 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1118 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1122 ui_out_text (uiout
, "#");
1123 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1124 frame_relative_level (frame
));
1126 get_user_print_options (&opts
);
1127 if (opts
.addressprint
)
1129 || frame_show_address (frame
, sal
)
1130 || print_what
== LOC_AND_ADDRESS
)
1132 annotate_frame_address ();
1134 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1136 ui_out_field_string (uiout
, "addr", "<unavailable>");
1137 annotate_frame_address_end ();
1138 ui_out_text (uiout
, " in ");
1140 annotate_frame_function_name ();
1141 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
1142 funlang
, DMGL_ANSI
);
1143 ui_out_field_stream (uiout
, "func", stb
);
1144 ui_out_wrap_hint (uiout
, " ");
1145 annotate_frame_args ();
1147 ui_out_text (uiout
, " (");
1150 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1152 struct cleanup
*args_list_chain
;
1153 volatile struct gdb_exception e
;
1155 if (gdbarch_frame_num_args_p (gdbarch
))
1157 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1158 gdb_assert (numargs
>= 0);
1163 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1164 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1166 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1168 /* FIXME: ARGS must be a list. If one argument is a string it
1169 will have " that will not be properly escaped. */
1170 /* Invoke ui_out_tuple_end. */
1171 do_cleanups (args_list_chain
);
1174 ui_out_text (uiout
, ")");
1175 if (sal
.symtab
&& sal
.symtab
->filename
)
1177 annotate_frame_source_begin ();
1178 ui_out_wrap_hint (uiout
, " ");
1179 ui_out_text (uiout
, " at ");
1180 annotate_frame_source_file ();
1181 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1182 if (ui_out_is_mi_like_p (uiout
))
1184 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1186 if (fullname
!= NULL
)
1187 ui_out_field_string (uiout
, "fullname", fullname
);
1189 annotate_frame_source_file_end ();
1190 ui_out_text (uiout
, ":");
1191 annotate_frame_source_line ();
1192 ui_out_field_int (uiout
, "line", sal
.line
);
1193 annotate_frame_source_end ();
1196 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
1199 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1201 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1202 get_frame_pc (frame
));
1206 annotate_frame_where ();
1207 ui_out_wrap_hint (uiout
, " ");
1208 ui_out_text (uiout
, " from ");
1209 ui_out_field_string (uiout
, "from", lib
);
1213 /* do_cleanups will call ui_out_tuple_end() for us. */
1214 do_cleanups (list_chain
);
1215 ui_out_text (uiout
, "\n");
1216 do_cleanups (old_chain
);
1220 /* Read a frame specification in whatever the appropriate format is
1221 from FRAME_EXP. Call error(), printing MESSAGE, if the
1222 specification is in any way invalid (so this function never returns
1223 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1224 the default selected frame was used. */
1226 static struct frame_info
*
1227 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1228 int *selected_frame_p
)
1231 struct value
*args
[4];
1232 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1234 if (frame_exp
== NULL
)
1242 struct cleanup
*cleanup
;
1245 /* Skip leading white space, bail of EOL. */
1246 while (isspace (*frame_exp
))
1251 /* Parse the argument, extract it, save it. */
1253 *p
&& !isspace (*p
);
1255 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1257 cleanup
= make_cleanup (xfree
, addr_string
);
1259 /* NOTE: Parse and evaluate expression, but do not use
1260 functions such as parse_and_eval_long or
1261 parse_and_eval_address to also extract the value.
1262 Instead value_as_long and value_as_address are used.
1263 This avoids problems with expressions that contain
1265 if (numargs
>= ARRAY_SIZE (args
))
1266 error (_("Too many args in frame specification"));
1267 args
[numargs
++] = parse_and_eval (addr_string
);
1269 do_cleanups (cleanup
);
1273 /* If no args, default to the selected frame. */
1276 if (selected_frame_p
!= NULL
)
1277 (*selected_frame_p
) = 1;
1278 return get_selected_frame (message
);
1281 /* None of the remaining use the selected frame. */
1282 if (selected_frame_p
!= NULL
)
1283 (*selected_frame_p
) = 0;
1285 /* Assume the single arg[0] is an integer, and try using that to
1286 select a frame relative to current. */
1289 struct frame_info
*fid
;
1290 int level
= value_as_long (args
[0]);
1292 fid
= find_relative_frame (get_current_frame (), &level
);
1294 /* find_relative_frame was successful. */
1298 /* Convert each value into a corresponding address. */
1302 for (i
= 0; i
< numargs
; i
++)
1303 addrs
[i
] = value_as_address (args
[i
]);
1306 /* Assume that the single arg[0] is an address, use that to identify
1307 a frame with a matching ID. Should this also accept stack/pc or
1308 stack/pc/special. */
1311 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1312 struct frame_info
*fid
;
1314 /* If (s)he specifies the frame with an address, he deserves
1315 what (s)he gets. Still, give the highest one that matches.
1316 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1318 for (fid
= get_current_frame ();
1320 fid
= get_prev_frame (fid
))
1322 if (frame_id_eq (id
, get_frame_id (fid
)))
1324 struct frame_info
*prev_frame
;
1328 prev_frame
= get_prev_frame (fid
);
1330 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1339 /* We couldn't identify the frame as an existing frame, but
1340 perhaps we can create one with a single argument. */
1342 return create_new_frame (addrs
[0], 0);
1343 else if (numargs
== 2)
1344 return create_new_frame (addrs
[0], addrs
[1]);
1346 error (_("Too many args in frame specification"));
1349 static struct frame_info
*
1350 parse_frame_specification (char *frame_exp
)
1352 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1355 /* Print verbosely the selected frame or the frame at address
1356 ADDR_EXP. Absolutely all information in the frame is printed. */
1359 frame_info (char *addr_exp
, int from_tty
)
1361 struct frame_info
*fi
;
1362 struct symtab_and_line sal
;
1363 struct symbol
*func
;
1365 struct frame_info
*calling_frame_info
;
1368 enum language funlang
= language_unknown
;
1369 const char *pc_regname
;
1370 int selected_frame_p
;
1371 struct gdbarch
*gdbarch
;
1372 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1375 CORE_ADDR caller_pc
;
1377 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1378 gdbarch
= get_frame_arch (fi
);
1380 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1381 is not a good name. */
1382 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1383 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1384 easily not match that of the internal value returned by
1386 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1388 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1389 architectures will often have a hardware register called "pc",
1390 and that register's value, again, can easily not match
1394 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1395 find_frame_sal (fi
, &sal
);
1396 func
= get_frame_function (fi
);
1400 funname
= SYMBOL_PRINT_NAME (func
);
1401 funlang
= SYMBOL_LANGUAGE (func
);
1402 if (funlang
== language_cplus
)
1404 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1405 to display the demangled name that we already have
1406 stored in the symbol table, but we stored a version
1407 with DMGL_PARAMS turned on, and here we don't want to
1408 display parameters. So remove the parameters. */
1409 char *func_only
= cp_remove_params (funname
);
1413 funname
= func_only
;
1414 make_cleanup (xfree
, func_only
);
1418 else if (frame_pc_p
)
1420 struct minimal_symbol
*msymbol
;
1422 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1423 if (msymbol
!= NULL
)
1425 funname
= SYMBOL_PRINT_NAME (msymbol
);
1426 funlang
= SYMBOL_LANGUAGE (msymbol
);
1429 calling_frame_info
= get_prev_frame (fi
);
1431 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1433 printf_filtered (_("Stack level %d, frame at "),
1434 frame_relative_level (fi
));
1438 printf_filtered (_("Stack frame at "));
1440 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1441 printf_filtered (":\n");
1442 printf_filtered (" %s = ", pc_regname
);
1444 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1446 fputs_filtered ("<unavailable>", gdb_stdout
);
1451 printf_filtered (" in ");
1452 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1453 DMGL_ANSI
| DMGL_PARAMS
);
1457 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1458 puts_filtered ("; ");
1460 printf_filtered ("saved %s ", pc_regname
);
1461 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1462 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1464 fputs_filtered ("<unavailable>", gdb_stdout
);
1465 printf_filtered ("\n");
1467 if (calling_frame_info
== NULL
)
1469 enum unwind_stop_reason reason
;
1471 reason
= get_frame_unwind_stop_reason (fi
);
1472 if (reason
!= UNWIND_NO_REASON
)
1473 printf_filtered (_(" Outermost frame: %s\n"),
1474 frame_stop_reason_string (reason
));
1476 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1477 puts_filtered (" tail call frame");
1478 else if (get_frame_type (fi
) == INLINE_FRAME
)
1479 printf_filtered (" inlined into frame %d",
1480 frame_relative_level (get_prev_frame (fi
)));
1483 printf_filtered (" called by frame at ");
1484 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1487 if (get_next_frame (fi
) && calling_frame_info
)
1488 puts_filtered (",");
1490 if (get_next_frame (fi
))
1492 printf_filtered (" caller of frame at ");
1493 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1496 if (get_next_frame (fi
) || calling_frame_info
)
1497 puts_filtered ("\n");
1500 printf_filtered (" source language %s.\n",
1501 language_str (s
->language
));
1504 /* Address of the argument list for this frame, or 0. */
1505 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1506 /* Number of args for this frame, or -1 if unknown. */
1510 printf_filtered (" Arglist at unknown address.\n");
1513 printf_filtered (" Arglist at ");
1514 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1515 printf_filtered (",");
1517 if (!gdbarch_frame_num_args_p (gdbarch
))
1520 puts_filtered (" args: ");
1524 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1525 gdb_assert (numargs
>= 0);
1527 puts_filtered (" no args.");
1528 else if (numargs
== 1)
1529 puts_filtered (" 1 arg: ");
1531 printf_filtered (" %d args: ", numargs
);
1533 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1534 puts_filtered ("\n");
1538 /* Address of the local variables for this frame, or 0. */
1539 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1542 printf_filtered (" Locals at unknown address,");
1545 printf_filtered (" Locals at ");
1546 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1547 printf_filtered (",");
1551 /* Print as much information as possible on the location of all the
1554 enum lval_type lval
;
1563 /* The sp is special; what's displayed isn't the save address, but
1564 the value of the previous frame's sp. This is a legacy thing,
1565 at one stage the frame cached the previous frame's SP instead
1566 of its address, hence it was easiest to just display the cached
1568 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1570 /* Find out the location of the saved stack pointer with out
1571 actually evaluating it. */
1572 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1573 &optimized
, &unavailable
, &lval
, &addr
,
1575 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1577 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1578 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1579 gdb_byte value
[MAX_REGISTER_SIZE
];
1582 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1583 &optimized
, &unavailable
, &lval
, &addr
,
1585 /* NOTE: cagney/2003-05-22: This is assuming that the
1586 stack pointer was packed as an unsigned integer. That
1587 may or may not be valid. */
1588 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1589 printf_filtered (" Previous frame's sp is ");
1590 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1591 printf_filtered ("\n");
1594 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1596 printf_filtered (" Previous frame's sp at ");
1597 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1598 printf_filtered ("\n");
1601 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1603 printf_filtered (" Previous frame's sp in %s\n",
1604 gdbarch_register_name (gdbarch
, realnum
));
1607 /* else keep quiet. */
1611 numregs
= gdbarch_num_regs (gdbarch
)
1612 + gdbarch_num_pseudo_regs (gdbarch
);
1613 for (i
= 0; i
< numregs
; i
++)
1614 if (i
!= gdbarch_sp_regnum (gdbarch
)
1615 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1617 /* Find out the location of the saved register without
1618 fetching the corresponding value. */
1619 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1620 &lval
, &addr
, &realnum
, NULL
);
1621 /* For moment, only display registers that were saved on the
1623 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1626 puts_filtered (" Saved registers:\n ");
1628 puts_filtered (",");
1630 printf_filtered (" %s at ",
1631 gdbarch_register_name (gdbarch
, i
));
1632 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1636 if (count
|| need_nl
)
1637 puts_filtered ("\n");
1640 do_cleanups (back_to
);
1643 /* Print briefly all stack frames or just the innermost COUNT_EXP
1647 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1649 struct frame_info
*fi
;
1652 struct frame_info
*trailing
;
1655 if (!target_has_stack
)
1656 error (_("No stack."));
1658 /* The following code must do two things. First, it must set the
1659 variable TRAILING to the frame from which we should start
1660 printing. Second, it must set the variable count to the number
1661 of frames which we should print, or -1 if all of them. */
1662 trailing
= get_current_frame ();
1667 count
= parse_and_eval_long (count_exp
);
1670 struct frame_info
*current
;
1675 while (current
&& count
--)
1678 current
= get_prev_frame (current
);
1681 /* Will stop when CURRENT reaches the top of the stack.
1682 TRAILING will be COUNT below it. */
1686 trailing
= get_prev_frame (trailing
);
1687 current
= get_prev_frame (current
);
1699 /* Read in symbols for all of the frames. Need to do this in a
1700 separate pass so that "Reading in symbols for xxx" messages
1701 don't screw up the appearance of the backtrace. Also if
1702 people have strong opinions against reading symbols for
1703 backtrace this may have to be an option. */
1705 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1710 pc
= get_frame_address_in_block (fi
);
1711 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1715 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1719 /* Don't use print_stack_frame; if an error() occurs it probably
1720 means further attempts to backtrace would fail (on the other
1721 hand, perhaps the code does or could be fixed to make sure
1722 the frame->prev field gets set to NULL in that case). */
1723 print_frame_info (fi
, 1, LOCATION
, 1);
1725 print_frame_local_vars (fi
, 1, gdb_stdout
);
1727 /* Save the last frame to check for error conditions. */
1731 /* If we've stopped before the end, mention that. */
1733 printf_filtered (_("(More stack frames follow...)\n"));
1735 /* If we've run out of frames, and the reason appears to be an error
1736 condition, print it. */
1737 if (fi
== NULL
&& trailing
!= NULL
)
1739 enum unwind_stop_reason reason
;
1741 reason
= get_frame_unwind_stop_reason (trailing
);
1742 if (reason
>= UNWIND_FIRST_ERROR
)
1743 printf_filtered (_("Backtrace stopped: %s\n"),
1744 frame_stop_reason_string (reason
));
1749 backtrace_command (char *arg
, int from_tty
)
1751 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1752 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1759 argv
= gdb_buildargv (arg
);
1760 make_cleanup_freeargv (argv
);
1762 for (i
= 0; argv
[i
]; i
++)
1766 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1767 argv
[i
][j
] = tolower (argv
[i
][j
]);
1769 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1770 fulltrace_arg
= argc
;
1773 arglen
+= strlen (argv
[i
]);
1778 if (fulltrace_arg
>= 0)
1782 arg
= xmalloc (arglen
+ 1);
1783 make_cleanup (xfree
, arg
);
1785 for (i
= 0; i
< (argc
+ 1); i
++)
1787 if (i
!= fulltrace_arg
)
1789 strcat (arg
, argv
[i
]);
1799 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1801 do_cleanups (old_chain
);
1805 backtrace_full_command (char *arg
, int from_tty
)
1807 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1811 /* Iterate over the local variables of a block B, calling CB with
1815 iterate_over_block_locals (struct block
*b
,
1816 iterate_over_block_arg_local_vars_cb cb
,
1819 struct dict_iterator iter
;
1822 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1824 switch (SYMBOL_CLASS (sym
))
1830 if (SYMBOL_IS_ARGUMENT (sym
))
1832 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1836 /* Ignore symbols which are not locals. */
1843 /* Same, but print labels. */
1846 /* Commented out, as the code using this function has also been
1847 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1848 was commented out in the first place. The discussion introducing
1849 this change (2007-12-04: Support lexical blocks and function bodies
1850 that occupy non-contiguous address ranges) did not explain why
1851 this change was made. */
1853 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1854 int *have_default
, struct ui_file
*stream
)
1856 struct dict_iterator iter
;
1858 int values_printed
= 0;
1860 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1862 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1868 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1870 struct symtab_and_line sal
;
1871 struct value_print_options opts
;
1873 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1875 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1876 get_user_print_options (&opts
);
1877 if (opts
.addressprint
)
1879 fprintf_filtered (stream
, " ");
1880 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1883 fprintf_filtered (stream
, " in file %s, line %d\n",
1884 sal
.symtab
->filename
, sal
.line
);
1888 return values_printed
;
1892 /* Iterate over all the local variables in block B, including all its
1893 superblocks, stopping when the top-level block is reached. */
1896 iterate_over_block_local_vars (struct block
*block
,
1897 iterate_over_block_arg_local_vars_cb cb
,
1902 iterate_over_block_locals (block
, cb
, cb_data
);
1903 /* After handling the function's top-level block, stop. Don't
1904 continue to its superblock, the block of per-file
1906 if (BLOCK_FUNCTION (block
))
1908 block
= BLOCK_SUPERBLOCK (block
);
1912 /* Data to be passed around in the calls to the locals and args
1915 struct print_variable_and_value_data
1917 struct frame_info
*frame
;
1919 struct ui_file
*stream
;
1923 /* The callback for the locals and args iterators. */
1926 do_print_variable_and_value (const char *print_name
,
1930 struct print_variable_and_value_data
*p
= cb_data
;
1932 print_variable_and_value (print_name
, sym
,
1933 p
->frame
, p
->stream
, p
->num_tabs
);
1934 p
->values_printed
= 1;
1938 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1939 struct ui_file
*stream
)
1941 struct print_variable_and_value_data cb_data
;
1942 struct block
*block
;
1945 if (!get_frame_pc_if_available (frame
, &pc
))
1947 fprintf_filtered (stream
,
1948 _("PC unavailable, cannot determine locals.\n"));
1952 block
= get_frame_block (frame
, 0);
1955 fprintf_filtered (stream
, "No symbol table info available.\n");
1959 cb_data
.frame
= frame
;
1960 cb_data
.num_tabs
= 4 * num_tabs
;
1961 cb_data
.stream
= stream
;
1962 cb_data
.values_printed
= 0;
1964 iterate_over_block_local_vars (block
,
1965 do_print_variable_and_value
,
1968 if (!cb_data
.values_printed
)
1969 fprintf_filtered (stream
, _("No locals.\n"));
1972 /* Same, but print labels. */
1975 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1976 struct ui_file
*stream
)
1979 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1981 struct blockvector
*bl
;
1982 struct block
*block
= get_frame_block (frame
, 0);
1983 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1984 int values_printed
= 0;
1985 int index
, have_default
= 0;
1986 char *blocks_printed
;
1987 CORE_ADDR pc
= get_frame_pc (frame
);
1991 fprintf_filtered (stream
, "No symbol table info available.\n");
1995 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1996 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1997 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
2001 CORE_ADDR end
= BLOCK_END (block
) - 4;
2004 if (bl
!= blockvector_for_pc (end
, &index
))
2005 error (_("blockvector blotch"));
2006 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
2007 error (_("blockvector botch"));
2008 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
2011 /* Don't print out blocks that have gone by. */
2012 while (index
< last_index
2013 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
2016 while (index
< last_index
2017 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
2019 if (blocks_printed
[index
] == 0)
2021 if (print_block_frame_labels (gdbarch
,
2022 BLOCKVECTOR_BLOCK (bl
, index
),
2023 &have_default
, stream
))
2025 blocks_printed
[index
] = 1;
2031 if (values_printed
&& this_level_only
)
2034 /* After handling the function's top-level block, stop. Don't
2035 continue to its superblock, the block of per-file symbols.
2036 Also do not continue to the containing function of an inlined
2038 if (BLOCK_FUNCTION (block
))
2040 block
= BLOCK_SUPERBLOCK (block
);
2043 if (!values_printed
&& !this_level_only
)
2044 fprintf_filtered (stream
, _("No catches.\n"));
2049 locals_info (char *args
, int from_tty
)
2051 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2056 catch_info (char *ignore
, int from_tty
)
2058 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
2059 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
2063 /* Iterate over all the argument variables in block B.
2065 Returns 1 if any argument was walked; 0 otherwise. */
2068 iterate_over_block_arg_vars (struct block
*b
,
2069 iterate_over_block_arg_local_vars_cb cb
,
2072 struct dict_iterator iter
;
2073 struct symbol
*sym
, *sym2
;
2075 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2077 /* Don't worry about things which aren't arguments. */
2078 if (SYMBOL_IS_ARGUMENT (sym
))
2080 /* We have to look up the symbol because arguments can have
2081 two entries (one a parameter, one a local) and the one we
2082 want is the local, which lookup_symbol will find for us.
2083 This includes gcc1 (not gcc2) on the sparc when passing a
2084 small structure and gcc2 when the argument type is float
2085 and it is passed as a double and converted to float by
2086 the prologue (in the latter case the type of the LOC_ARG
2087 symbol is double and the type of the LOC_LOCAL symbol is
2088 float). There are also LOC_ARG/LOC_REGISTER pairs which
2089 are not combined in symbol-reading. */
2091 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2092 b
, VAR_DOMAIN
, NULL
);
2093 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2099 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2101 struct print_variable_and_value_data cb_data
;
2102 struct symbol
*func
;
2105 if (!get_frame_pc_if_available (frame
, &pc
))
2107 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2111 func
= get_frame_function (frame
);
2114 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2118 cb_data
.frame
= frame
;
2119 cb_data
.num_tabs
= 0;
2120 cb_data
.stream
= gdb_stdout
;
2121 cb_data
.values_printed
= 0;
2123 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2124 do_print_variable_and_value
, &cb_data
);
2126 if (!cb_data
.values_printed
)
2127 fprintf_filtered (stream
, _("No arguments.\n"));
2131 args_info (char *ignore
, int from_tty
)
2133 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2139 args_plus_locals_info (char *ignore
, int from_tty
)
2141 args_info (ignore
, from_tty
);
2142 locals_info (ignore
, from_tty
);
2146 /* Select frame FRAME. Also print the stack frame and show the source
2147 if this is the tui version. */
2149 select_and_print_frame (struct frame_info
*frame
)
2151 select_frame (frame
);
2153 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2156 /* Return the symbol-block in which the selected frame is executing.
2157 Can return zero under various legitimate circumstances.
2159 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2160 code address within the block returned. We use this to decide
2161 which macros are in scope. */
2164 get_selected_block (CORE_ADDR
*addr_in_block
)
2166 if (!has_stack_frames ())
2169 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2172 /* Find a frame a certain number of levels away from FRAME.
2173 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2174 Positive means go to earlier frames (up); negative, the reverse.
2175 The int that contains the number of levels is counted toward
2176 zero as the frames for those levels are found.
2177 If the top or bottom frame is reached, that frame is returned,
2178 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2179 how much farther the original request asked to go. */
2182 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2184 /* Going up is simple: just call get_prev_frame enough times or
2185 until the initial frame is reached. */
2186 while (*level_offset_ptr
> 0)
2188 struct frame_info
*prev
= get_prev_frame (frame
);
2192 (*level_offset_ptr
)--;
2196 /* Going down is just as simple. */
2197 while (*level_offset_ptr
< 0)
2199 struct frame_info
*next
= get_next_frame (frame
);
2203 (*level_offset_ptr
)++;
2210 /* The "select_frame" command. With no argument this is a NOP.
2211 Select the frame at level LEVEL_EXP if it is a valid level.
2212 Otherwise, treat LEVEL_EXP as an address expression and select it.
2214 See parse_frame_specification for more info on proper frame
2218 select_frame_command (char *level_exp
, int from_tty
)
2220 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2223 /* The "frame" command. With no argument, print the selected frame
2224 briefly. With an argument, behave like select_frame and then print
2225 the selected frame. */
2228 frame_command (char *level_exp
, int from_tty
)
2230 select_frame_command (level_exp
, from_tty
);
2231 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2234 /* The XDB Compatibility command to print the current frame. */
2237 current_frame_command (char *level_exp
, int from_tty
)
2239 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2242 /* Select the frame up one or COUNT_EXP stack levels from the
2243 previously selected frame, and print it briefly. */
2246 up_silently_base (char *count_exp
)
2248 struct frame_info
*frame
;
2252 count
= parse_and_eval_long (count_exp
);
2254 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2255 if (count
!= 0 && count_exp
== NULL
)
2256 error (_("Initial frame selected; you cannot go up."));
2257 select_frame (frame
);
2261 up_silently_command (char *count_exp
, int from_tty
)
2263 up_silently_base (count_exp
);
2267 up_command (char *count_exp
, int from_tty
)
2269 up_silently_base (count_exp
);
2270 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2273 /* Select the frame down one or COUNT_EXP stack levels from the previously
2274 selected frame, and print it briefly. */
2277 down_silently_base (char *count_exp
)
2279 struct frame_info
*frame
;
2283 count
= -parse_and_eval_long (count_exp
);
2285 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2286 if (count
!= 0 && count_exp
== NULL
)
2288 /* We only do this if COUNT_EXP is not specified. That way
2289 "down" means to really go down (and let me know if that is
2290 impossible), but "down 9999" can be used to mean go all the
2291 way down without getting an error. */
2293 error (_("Bottom (innermost) frame selected; you cannot go down."));
2296 select_frame (frame
);
2300 down_silently_command (char *count_exp
, int from_tty
)
2302 down_silently_base (count_exp
);
2306 down_command (char *count_exp
, int from_tty
)
2308 down_silently_base (count_exp
);
2309 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2314 return_command (char *retval_exp
, int from_tty
)
2316 struct frame_info
*thisframe
;
2317 struct gdbarch
*gdbarch
;
2318 struct symbol
*thisfun
;
2319 struct value
*return_value
= NULL
;
2320 const char *query_prefix
= "";
2322 thisframe
= get_selected_frame ("No selected frame.");
2323 thisfun
= get_frame_function (thisframe
);
2324 gdbarch
= get_frame_arch (thisframe
);
2326 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2327 error (_("Can not force return from an inlined function."));
2329 /* Compute the return value. If the computation triggers an error,
2330 let it bail. If the return type can't be handled, set
2331 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2335 struct expression
*retval_expr
= parse_expression (retval_exp
);
2336 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2337 struct type
*return_type
= NULL
;
2339 /* Compute the return value. Should the computation fail, this
2340 call throws an error. */
2341 return_value
= evaluate_expression (retval_expr
);
2343 /* Cast return value to the return type of the function. Should
2344 the cast fail, this call throws an error. */
2345 if (thisfun
!= NULL
)
2346 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2347 if (return_type
== NULL
)
2349 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2350 error (_("Return value type not available for selected "
2352 "Please use an explicit cast of the value to return."));
2353 return_type
= value_type (return_value
);
2355 do_cleanups (old_chain
);
2356 CHECK_TYPEDEF (return_type
);
2357 return_value
= value_cast (return_type
, return_value
);
2359 /* Make sure the value is fully evaluated. It may live in the
2360 stack frame we're about to pop. */
2361 if (value_lazy (return_value
))
2362 value_fetch_lazy (return_value
);
2364 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2365 /* If the return-type is "void", don't try to find the
2366 return-value's location. However, do still evaluate the
2367 return expression so that, even when the expression result
2368 is discarded, side effects such as "return i++" still
2370 return_value
= NULL
;
2371 else if (thisfun
!= NULL
2372 && using_struct_return (gdbarch
,
2373 SYMBOL_TYPE (thisfun
), return_type
))
2375 query_prefix
= "The location at which to store the "
2376 "function's return value is unknown.\n"
2377 "If you continue, the return value "
2378 "that you specified will be ignored.\n";
2379 return_value
= NULL
;
2383 /* Does an interactive user really want to do this? Include
2384 information, such as how well GDB can handle the return value, in
2385 the query message. */
2390 if (thisfun
== NULL
)
2391 confirmed
= query (_("%sMake selected stack frame return now? "),
2394 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2395 SYMBOL_PRINT_NAME (thisfun
));
2397 error (_("Not confirmed"));
2400 /* Discard the selected frame and all frames inner-to it. */
2401 frame_pop (get_selected_frame (NULL
));
2403 /* Store RETURN_VALUE in the just-returned register set. */
2404 if (return_value
!= NULL
)
2406 struct type
*return_type
= value_type (return_value
);
2407 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2408 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2410 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2412 == RETURN_VALUE_REGISTER_CONVENTION
);
2413 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2414 get_current_regcache (), NULL
/*read*/,
2415 value_contents (return_value
) /*write*/);
2418 /* If we are at the end of a call dummy now, pop the dummy frame
2420 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2421 frame_pop (get_current_frame ());
2423 /* If interactive, print the frame that is now current. */
2425 frame_command ("0", 1);
2427 select_frame_command ("0", 0);
2430 /* Sets the scope to input function name, provided that the function
2431 is within the current stack frame. */
2433 struct function_bounds
2435 CORE_ADDR low
, high
;
2439 func_command (char *arg
, int from_tty
)
2441 struct frame_info
*frame
;
2443 struct symtabs_and_lines sals
;
2446 struct function_bounds
*func_bounds
= NULL
;
2451 frame
= parse_frame_specification ("0");
2452 sals
= decode_line_spec (arg
, 1);
2453 func_bounds
= (struct function_bounds
*) xmalloc (
2454 sizeof (struct function_bounds
) * sals
.nelts
);
2455 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2457 if (sals
.sals
[i
].pc
== 0
2458 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2459 &func_bounds
[i
].low
,
2460 &func_bounds
[i
].high
) == 0)
2462 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2468 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2469 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2470 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2474 frame
= find_relative_frame (frame
, &level
);
2477 while (!found
&& level
== 0);
2480 xfree (func_bounds
);
2483 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2484 else if (frame
!= get_selected_frame (NULL
))
2485 select_and_print_frame (frame
);
2488 /* Gets the language of the current frame. */
2491 get_frame_language (void)
2493 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2497 volatile struct gdb_exception ex
;
2501 /* We determine the current frame language by looking up its
2502 associated symtab. To retrieve this symtab, we use the frame
2503 PC. However we cannot use the frame PC as is, because it
2504 usually points to the instruction following the "call", which
2505 is sometimes the first instruction of another function. So
2506 we rely on get_frame_address_in_block(), it provides us with
2507 a PC that is guaranteed to be inside the frame's code
2510 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2512 pc
= get_frame_address_in_block (frame
);
2516 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2517 throw_exception (ex
);
2521 s
= find_pc_symtab (pc
);
2527 return language_unknown
;
2531 /* Provide a prototype to silence -Wmissing-prototypes. */
2532 void _initialize_stack (void);
2535 _initialize_stack (void)
2537 add_com ("return", class_stack
, return_command
, _("\
2538 Make selected stack frame return to its caller.\n\
2539 Control remains in the debugger, but when you continue\n\
2540 execution will resume in the frame above the one now selected.\n\
2541 If an argument is given, it is an expression for the value to return."));
2543 add_com ("up", class_stack
, up_command
, _("\
2544 Select and print stack frame that called this one.\n\
2545 An argument says how many frames up to go."));
2546 add_com ("up-silently", class_support
, up_silently_command
, _("\
2547 Same as the `up' command, but does not print anything.\n\
2548 This is useful in command scripts."));
2550 add_com ("down", class_stack
, down_command
, _("\
2551 Select and print stack frame called by this one.\n\
2552 An argument says how many frames down to go."));
2553 add_com_alias ("do", "down", class_stack
, 1);
2554 add_com_alias ("dow", "down", class_stack
, 1);
2555 add_com ("down-silently", class_support
, down_silently_command
, _("\
2556 Same as the `down' command, but does not print anything.\n\
2557 This is useful in command scripts."));
2559 add_com ("frame", class_stack
, frame_command
, _("\
2560 Select and print a stack frame.\nWith no argument, \
2561 print the selected stack frame. (See also \"info frame\").\n\
2562 An argument specifies the frame to select.\n\
2563 It can be a stack frame number or the address of the frame.\n\
2564 With argument, nothing is printed if input is coming from\n\
2565 a command file or a user-defined command."));
2567 add_com_alias ("f", "frame", class_stack
, 1);
2571 add_com ("L", class_stack
, current_frame_command
,
2572 _("Print the current stack frame.\n"));
2573 add_com_alias ("V", "frame", class_stack
, 1);
2575 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2576 Select a stack frame without printing anything.\n\
2577 An argument specifies the frame to select.\n\
2578 It can be a stack frame number or the address of the frame.\n"));
2580 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2581 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2582 With a negative argument, print outermost -COUNT frames.\nUse of the \
2583 'full' qualifier also prints the values of the local variables.\n"));
2584 add_com_alias ("bt", "backtrace", class_stack
, 0);
2587 add_com_alias ("t", "backtrace", class_stack
, 0);
2588 add_com ("T", class_stack
, backtrace_full_command
, _("\
2589 Print backtrace of all stack frames, or innermost COUNT frames\n\
2590 and the values of the local variables.\n\
2591 With a negative argument, print outermost -COUNT frames.\n\
2592 Usage: T <count>\n"));
2595 add_com_alias ("where", "backtrace", class_alias
, 0);
2596 add_info ("stack", backtrace_command
,
2597 _("Backtrace of the stack, or innermost COUNT frames."));
2598 add_info_alias ("s", "stack", 1);
2599 add_info ("frame", frame_info
,
2600 _("All about selected stack frame, or frame at ADDR."));
2601 add_info_alias ("f", "frame", 1);
2602 add_info ("locals", locals_info
,
2603 _("Local variables of current stack frame."));
2604 add_info ("args", args_info
,
2605 _("Argument variables of current stack frame."));
2607 add_com ("l", class_info
, args_plus_locals_info
,
2608 _("Argument and local variables of current stack frame."));
2611 add_com ("func", class_stack
, func_command
, _("\
2612 Select the stack frame that contains <func>.\n\
2613 Usage: func <name>\n"));
2615 add_info ("catch", catch_info
,
2616 _("Exceptions that can be caught in the current stack frame."));
2618 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2619 print_frame_arguments_choices
, &print_frame_arguments
,
2620 _("Set printing of non-scalar frame arguments"),
2621 _("Show printing of non-scalar frame arguments"),
2622 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2624 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2625 &disassemble_next_line
, _("\
2626 Set whether to disassemble next source line or insn when execution stops."),
2628 Show whether to disassemble next source line or insn when execution stops."),
2630 If ON, GDB will display disassembly of the next source line, in addition\n\
2631 to displaying the source line itself. If the next source line cannot\n\
2632 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2633 will display disassembly of next instruction instead of showing the\n\
2635 If AUTO, display disassembly of next instruction only if the source line\n\
2636 cannot be displayed.\n\
2637 If OFF (which is the default), never display the disassembly of the next\n\
2640 show_disassemble_next_line
,
2641 &setlist
, &showlist
);
2642 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2644 add_setshow_enum_cmd ("entry-values", class_stack
,
2645 print_entry_values_choices
, &print_entry_values
,
2646 _("Set printing of function arguments at function "
2648 _("Show printing of function arguments at function "
2651 GDB can sometimes determine the values of function arguments at entry,\n\
2652 in addition to their current values. This option tells GDB whether\n\
2653 to print the current value, the value at entry (marked as val@entry),\n\
2654 or both. Note that one or both of these values may be <optimized out>."),
2655 NULL
, NULL
, &setprintlist
, &showprintlist
);