1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "exceptions.h"
40 #include "reggroups.h"
44 #include "gdbthread.h"
45 #include "cp-support.h"
47 #include "inline-frame.h"
49 #include "cli/cli-utils.h"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
58 void (*deprecated_selected_frame_level_changed_hook
) (int);
60 /* The possible choices of "set print frame-arguments", and the value
63 static const char *const print_frame_arguments_choices
[] =
64 {"all", "scalars", "none", NULL
};
65 static const char *print_frame_arguments
= "scalars";
67 /* 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 *const 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
;
216 stb
= mem_fileopen ();
217 old_chain
= make_cleanup_ui_file_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
, 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
);
236 fprintf_symbol_filtered (stb
, 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
);
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
, 2, &opts
, language
);
287 fprintf_filtered (stb
, _("<error reading variable: %s>"),
291 ui_out_field_stream (uiout
, "value", stb
);
293 /* Also 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 struct type
*type
= 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,
368 /* Initialize it just to avoid a GCC false warning. */
369 struct value
*val_deref
= NULL
, *entryval_deref
;
371 /* DW_AT_GNU_call_site_value does match with the current
372 value. If it is a reference still try to verify if
373 dereferenced DW_AT_GNU_call_site_data_value does not
376 TRY_CATCH (except
, RETURN_MASK_ERROR
)
378 struct type
*type_deref
;
380 val_deref
= coerce_ref (val
);
381 if (value_lazy (val_deref
))
382 value_fetch_lazy (val_deref
);
383 type_deref
= value_type (val_deref
);
385 entryval_deref
= coerce_ref (entryval
);
386 if (value_lazy (entryval_deref
))
387 value_fetch_lazy (entryval_deref
);
389 /* If the reference addresses match but dereferenced
390 content does not match print them. */
392 && value_available_contents_eq (val_deref
, 0,
394 TYPE_LENGTH (type_deref
)))
398 /* Value was not a reference; and its content matches. */
399 if (val
== val_deref
)
401 /* If the dereferenced content could not be fetched do not
403 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
405 else if (except
.message
)
407 entryval_error
= alloca (strlen (except
.message
) + 1);
408 strcpy (entryval_error
, except
.message
);
416 /* Try to remove possibly duplicate error message for ENTRYARGP even
419 if (val_error
&& entryval_error
420 && strcmp (val_error
, entryval_error
) == 0)
422 entryval_error
= NULL
;
424 /* Do not se VAL_EQUAL as the same error message may be shown for
425 the entry value even if no entry values are present in the
431 if (entryval
== NULL
)
433 if (print_entry_values
== print_entry_values_preferred
)
435 TRY_CATCH (except
, RETURN_MASK_ERROR
)
437 val
= read_var_value (sym
, frame
);
441 val_error
= alloca (strlen (except
.message
) + 1);
442 strcpy (val_error
, except
.message
);
445 if (print_entry_values
== print_entry_values_only
446 || print_entry_values
== print_entry_values_both
447 || (print_entry_values
== print_entry_values_preferred
448 && (!val
|| value_optimized_out (val
))))
449 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
451 if ((print_entry_values
== print_entry_values_compact
452 || print_entry_values
== print_entry_values_if_needed
453 || print_entry_values
== print_entry_values_preferred
)
454 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
462 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
463 if (!val
&& !val_error
)
464 argp
->entry_kind
= print_entry_values_only
;
465 else if ((print_entry_values
== print_entry_values_compact
466 || print_entry_values
== print_entry_values_default
) && val_equal
)
468 argp
->entry_kind
= print_entry_values_compact
;
469 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
472 argp
->entry_kind
= print_entry_values_no
;
474 entryargp
->sym
= sym
;
475 entryargp
->val
= entryval
;
476 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
477 if (!entryval
&& !entryval_error
)
478 entryargp
->entry_kind
= print_entry_values_no
;
480 entryargp
->entry_kind
= print_entry_values_only
;
483 /* Print the arguments of frame FRAME on STREAM, given the function
484 FUNC running in that frame (as a symbol), where NUM is the number
485 of arguments according to the stack frame (or -1 if the number of
486 arguments is unknown). */
488 /* Note that currently the "number of arguments according to the
489 stack frame" is only known on VAX where i refers to the "number of
490 ints of arguments according to the stack frame". */
493 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
494 int num
, struct ui_file
*stream
)
496 struct ui_out
*uiout
= current_uiout
;
498 /* Offset of next stack argument beyond the one we have seen that is
499 at the highest offset, or -1 if we haven't come to a stack
501 long highest_offset
= -1;
502 /* Number of ints of arguments that we have printed so far. */
503 int args_printed
= 0;
504 struct cleanup
*old_chain
;
506 /* True if we should print arguments, false otherwise. */
507 int print_args
= strcmp (print_frame_arguments
, "none");
509 stb
= mem_fileopen ();
510 old_chain
= make_cleanup_ui_file_delete (stb
);
514 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
515 struct block_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
;
912 if (valid
&& pspace
== NULL
)
914 clear_last_displayed_sal ();
915 internal_error (__FILE__
, __LINE__
,
916 _("Trying to set NULL pspace."));
920 /* Forget the last sal we displayed. */
923 clear_last_displayed_sal (void)
925 last_displayed_sal_valid
= 0;
926 last_displayed_pspace
= 0;
927 last_displayed_addr
= 0;
928 last_displayed_symtab
= 0;
929 last_displayed_line
= 0;
932 /* Is our record of the last sal we displayed valid? If not,
933 * the get_last_displayed_* functions will return NULL or 0, as
937 last_displayed_sal_is_valid (void)
939 return last_displayed_sal_valid
;
942 /* Get the pspace of the last sal we displayed, if it's valid. */
944 struct program_space
*
945 get_last_displayed_pspace (void)
947 if (last_displayed_sal_valid
)
948 return last_displayed_pspace
;
952 /* Get the address of the last sal we displayed, if it's valid. */
955 get_last_displayed_addr (void)
957 if (last_displayed_sal_valid
)
958 return last_displayed_addr
;
962 /* Get the symtab of the last sal we displayed, if it's valid. */
965 get_last_displayed_symtab (void)
967 if (last_displayed_sal_valid
)
968 return last_displayed_symtab
;
972 /* Get the line of the last sal we displayed, if it's valid. */
975 get_last_displayed_line (void)
977 if (last_displayed_sal_valid
)
978 return last_displayed_line
;
982 /* Get the last sal we displayed, if it's valid. */
985 get_last_displayed_sal (struct symtab_and_line
*sal
)
987 if (last_displayed_sal_valid
)
989 sal
->pspace
= last_displayed_pspace
;
990 sal
->pc
= last_displayed_addr
;
991 sal
->symtab
= last_displayed_symtab
;
992 sal
->line
= last_displayed_line
;
1004 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1005 corresponding to FRAME. */
1008 find_frame_funname (struct frame_info
*frame
, const char **funname
,
1009 enum language
*funlang
, struct symbol
**funcp
)
1011 struct symbol
*func
;
1014 *funlang
= language_unknown
;
1018 func
= get_frame_function (frame
);
1021 /* In certain pathological cases, the symtabs give the wrong
1022 function (when we are in the first function in a file which
1023 is compiled without debugging symbols, the previous function
1024 is compiled with debugging symbols, and the "foo.o" symbol
1025 that is supposed to tell us where the file with debugging
1026 symbols ends has been truncated by ar because it is longer
1027 than 15 characters). This also occurs if the user uses asm()
1028 to create a function but not stabs for it (in a file compiled
1031 So look in the minimal symbol tables as well, and if it comes
1032 up with a larger address for the function use that instead.
1033 I don't think this can ever cause any problems; there
1034 shouldn't be any minimal symbols in the middle of a function;
1035 if this is ever changed many parts of GDB will need to be
1036 changed (and we'll create a find_pc_minimal_function or some
1039 struct minimal_symbol
*msymbol
= NULL
;
1041 /* Don't attempt to do this for inlined functions, which do not
1042 have a corresponding minimal symbol. */
1043 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1045 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1048 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1049 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1051 /* We also don't know anything about the function besides
1052 its address and name. */
1054 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1055 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1059 *funname
= SYMBOL_PRINT_NAME (func
);
1060 *funlang
= SYMBOL_LANGUAGE (func
);
1063 if (*funlang
== language_cplus
)
1065 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1066 to display the demangled name that we already have
1067 stored in the symbol table, but we stored a version
1068 with DMGL_PARAMS turned on, and here we don't want to
1069 display parameters. So remove the parameters. */
1070 char *func_only
= cp_remove_params (*funname
);
1074 *funname
= func_only
;
1075 make_cleanup (xfree
, func_only
);
1082 struct minimal_symbol
*msymbol
;
1085 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1088 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1089 if (msymbol
!= NULL
)
1091 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1092 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1098 print_frame (struct frame_info
*frame
, int print_level
,
1099 enum print_what print_what
, int print_args
,
1100 struct symtab_and_line sal
)
1102 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1103 struct ui_out
*uiout
= current_uiout
;
1104 const char *funname
= NULL
;
1105 enum language funlang
= language_unknown
;
1106 struct ui_file
*stb
;
1107 struct cleanup
*old_chain
, *list_chain
;
1108 struct value_print_options opts
;
1109 struct symbol
*func
;
1113 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1115 stb
= mem_fileopen ();
1116 old_chain
= make_cleanup_ui_file_delete (stb
);
1118 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1120 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1123 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1127 ui_out_text (uiout
, "#");
1128 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1129 frame_relative_level (frame
));
1131 get_user_print_options (&opts
);
1132 if (opts
.addressprint
)
1134 || frame_show_address (frame
, sal
)
1135 || print_what
== LOC_AND_ADDRESS
)
1137 annotate_frame_address ();
1139 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1141 ui_out_field_string (uiout
, "addr", "<unavailable>");
1142 annotate_frame_address_end ();
1143 ui_out_text (uiout
, " in ");
1145 annotate_frame_function_name ();
1146 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1147 funlang
, DMGL_ANSI
);
1148 ui_out_field_stream (uiout
, "func", stb
);
1149 ui_out_wrap_hint (uiout
, " ");
1150 annotate_frame_args ();
1152 ui_out_text (uiout
, " (");
1155 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1157 struct cleanup
*args_list_chain
;
1158 volatile struct gdb_exception e
;
1160 if (gdbarch_frame_num_args_p (gdbarch
))
1162 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1163 gdb_assert (numargs
>= 0);
1168 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1169 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1171 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1173 /* FIXME: ARGS must be a list. If one argument is a string it
1174 will have " that will not be properly escaped. */
1175 /* Invoke ui_out_tuple_end. */
1176 do_cleanups (args_list_chain
);
1179 ui_out_text (uiout
, ")");
1182 const char *filename_display
;
1184 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1185 annotate_frame_source_begin ();
1186 ui_out_wrap_hint (uiout
, " ");
1187 ui_out_text (uiout
, " at ");
1188 annotate_frame_source_file ();
1189 ui_out_field_string (uiout
, "file", filename_display
);
1190 if (ui_out_is_mi_like_p (uiout
))
1192 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1194 ui_out_field_string (uiout
, "fullname", fullname
);
1196 annotate_frame_source_file_end ();
1197 ui_out_text (uiout
, ":");
1198 annotate_frame_source_line ();
1199 ui_out_field_int (uiout
, "line", sal
.line
);
1200 annotate_frame_source_end ();
1203 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1206 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1208 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1209 get_frame_pc (frame
));
1213 annotate_frame_where ();
1214 ui_out_wrap_hint (uiout
, " ");
1215 ui_out_text (uiout
, " from ");
1216 ui_out_field_string (uiout
, "from", lib
);
1220 /* do_cleanups will call ui_out_tuple_end() for us. */
1221 do_cleanups (list_chain
);
1222 ui_out_text (uiout
, "\n");
1223 do_cleanups (old_chain
);
1227 /* Read a frame specification in whatever the appropriate format is
1228 from FRAME_EXP. Call error(), printing MESSAGE, if the
1229 specification is in any way invalid (so this function never returns
1230 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1231 the default selected frame was used. */
1233 static struct frame_info
*
1234 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1235 int *selected_frame_p
)
1238 struct value
*args
[4];
1239 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1241 if (frame_exp
== NULL
)
1249 struct cleanup
*cleanup
;
1252 /* Skip leading white space, bail of EOL. */
1253 frame_exp
= skip_spaces_const (frame_exp
);
1257 /* Parse the argument, extract it, save it. */
1259 *p
&& !isspace (*p
);
1261 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1263 cleanup
= make_cleanup (xfree
, addr_string
);
1265 /* NOTE: Parse and evaluate expression, but do not use
1266 functions such as parse_and_eval_long or
1267 parse_and_eval_address to also extract the value.
1268 Instead value_as_long and value_as_address are used.
1269 This avoids problems with expressions that contain
1271 if (numargs
>= ARRAY_SIZE (args
))
1272 error (_("Too many args in frame specification"));
1273 args
[numargs
++] = parse_and_eval (addr_string
);
1275 do_cleanups (cleanup
);
1279 /* If no args, default to the selected frame. */
1282 if (selected_frame_p
!= NULL
)
1283 (*selected_frame_p
) = 1;
1284 return get_selected_frame (message
);
1287 /* None of the remaining use the selected frame. */
1288 if (selected_frame_p
!= NULL
)
1289 (*selected_frame_p
) = 0;
1291 /* Assume the single arg[0] is an integer, and try using that to
1292 select a frame relative to current. */
1295 struct frame_info
*fid
;
1296 int level
= value_as_long (args
[0]);
1298 fid
= find_relative_frame (get_current_frame (), &level
);
1300 /* find_relative_frame was successful. */
1304 /* Convert each value into a corresponding address. */
1308 for (i
= 0; i
< numargs
; i
++)
1309 addrs
[i
] = value_as_address (args
[i
]);
1312 /* Assume that the single arg[0] is an address, use that to identify
1313 a frame with a matching ID. Should this also accept stack/pc or
1314 stack/pc/special. */
1317 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1318 struct frame_info
*fid
;
1320 /* If (s)he specifies the frame with an address, he deserves
1321 what (s)he gets. Still, give the highest one that matches.
1322 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1324 for (fid
= get_current_frame ();
1326 fid
= get_prev_frame (fid
))
1328 if (frame_id_eq (id
, get_frame_id (fid
)))
1330 struct frame_info
*prev_frame
;
1334 prev_frame
= get_prev_frame (fid
);
1336 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1345 /* We couldn't identify the frame as an existing frame, but
1346 perhaps we can create one with a single argument. */
1348 return create_new_frame (addrs
[0], 0);
1349 else if (numargs
== 2)
1350 return create_new_frame (addrs
[0], addrs
[1]);
1352 error (_("Too many args in frame specification"));
1355 static struct frame_info
*
1356 parse_frame_specification (char *frame_exp
)
1358 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1361 /* Print verbosely the selected frame or the frame at address
1362 ADDR_EXP. Absolutely all information in the frame is printed. */
1365 frame_info (char *addr_exp
, int from_tty
)
1367 struct frame_info
*fi
;
1368 struct symtab_and_line sal
;
1369 struct symbol
*func
;
1371 struct frame_info
*calling_frame_info
;
1373 const char *funname
= 0;
1374 enum language funlang
= language_unknown
;
1375 const char *pc_regname
;
1376 int selected_frame_p
;
1377 struct gdbarch
*gdbarch
;
1378 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1381 CORE_ADDR caller_pc
;
1383 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1384 gdbarch
= get_frame_arch (fi
);
1386 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1387 is not a good name. */
1388 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1389 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1390 easily not match that of the internal value returned by
1392 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1394 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1395 architectures will often have a hardware register called "pc",
1396 and that register's value, again, can easily not match
1400 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1401 find_frame_sal (fi
, &sal
);
1402 func
= get_frame_function (fi
);
1406 funname
= SYMBOL_PRINT_NAME (func
);
1407 funlang
= SYMBOL_LANGUAGE (func
);
1408 if (funlang
== language_cplus
)
1410 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1411 to display the demangled name that we already have
1412 stored in the symbol table, but we stored a version
1413 with DMGL_PARAMS turned on, and here we don't want to
1414 display parameters. So remove the parameters. */
1415 char *func_only
= cp_remove_params (funname
);
1419 funname
= func_only
;
1420 make_cleanup (xfree
, func_only
);
1424 else if (frame_pc_p
)
1426 struct minimal_symbol
*msymbol
;
1428 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1429 if (msymbol
!= NULL
)
1431 funname
= SYMBOL_PRINT_NAME (msymbol
);
1432 funlang
= SYMBOL_LANGUAGE (msymbol
);
1435 calling_frame_info
= get_prev_frame (fi
);
1437 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1439 printf_filtered (_("Stack level %d, frame at "),
1440 frame_relative_level (fi
));
1444 printf_filtered (_("Stack frame at "));
1446 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1447 printf_filtered (":\n");
1448 printf_filtered (" %s = ", pc_regname
);
1450 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1452 fputs_filtered ("<unavailable>", gdb_stdout
);
1457 printf_filtered (" in ");
1458 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1459 DMGL_ANSI
| DMGL_PARAMS
);
1463 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1465 puts_filtered ("; ");
1467 printf_filtered ("saved %s ", pc_regname
);
1468 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1469 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1471 fputs_filtered ("<unavailable>", gdb_stdout
);
1472 printf_filtered ("\n");
1474 if (calling_frame_info
== NULL
)
1476 enum unwind_stop_reason reason
;
1478 reason
= get_frame_unwind_stop_reason (fi
);
1479 if (reason
!= UNWIND_NO_REASON
)
1480 printf_filtered (_(" Outermost frame: %s\n"),
1481 frame_stop_reason_string (reason
));
1483 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1484 puts_filtered (" tail call frame");
1485 else if (get_frame_type (fi
) == INLINE_FRAME
)
1486 printf_filtered (" inlined into frame %d",
1487 frame_relative_level (get_prev_frame (fi
)));
1490 printf_filtered (" called by frame at ");
1491 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1494 if (get_next_frame (fi
) && calling_frame_info
)
1495 puts_filtered (",");
1497 if (get_next_frame (fi
))
1499 printf_filtered (" caller of frame at ");
1500 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1503 if (get_next_frame (fi
) || calling_frame_info
)
1504 puts_filtered ("\n");
1507 printf_filtered (" source language %s.\n",
1508 language_str (s
->language
));
1511 /* Address of the argument list for this frame, or 0. */
1512 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1513 /* Number of args for this frame, or -1 if unknown. */
1517 printf_filtered (" Arglist at unknown address.\n");
1520 printf_filtered (" Arglist at ");
1521 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1522 printf_filtered (",");
1524 if (!gdbarch_frame_num_args_p (gdbarch
))
1527 puts_filtered (" args: ");
1531 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1532 gdb_assert (numargs
>= 0);
1534 puts_filtered (" no args.");
1535 else if (numargs
== 1)
1536 puts_filtered (" 1 arg: ");
1538 printf_filtered (" %d args: ", numargs
);
1540 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1541 puts_filtered ("\n");
1545 /* Address of the local variables for this frame, or 0. */
1546 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1549 printf_filtered (" Locals at unknown address,");
1552 printf_filtered (" Locals at ");
1553 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1554 printf_filtered (",");
1558 /* Print as much information as possible on the location of all the
1561 enum lval_type lval
;
1570 /* The sp is special; what's displayed isn't the save address, but
1571 the value of the previous frame's sp. This is a legacy thing,
1572 at one stage the frame cached the previous frame's SP instead
1573 of its address, hence it was easiest to just display the cached
1575 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1577 /* Find out the location of the saved stack pointer with out
1578 actually evaluating it. */
1579 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1580 &optimized
, &unavailable
, &lval
, &addr
,
1582 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1584 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1585 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1586 gdb_byte value
[MAX_REGISTER_SIZE
];
1589 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1590 &optimized
, &unavailable
, &lval
, &addr
,
1592 /* NOTE: cagney/2003-05-22: This is assuming that the
1593 stack pointer was packed as an unsigned integer. That
1594 may or may not be valid. */
1595 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1596 printf_filtered (" Previous frame's sp is ");
1597 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1598 printf_filtered ("\n");
1601 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1603 printf_filtered (" Previous frame's sp at ");
1604 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1605 printf_filtered ("\n");
1608 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1610 printf_filtered (" Previous frame's sp in %s\n",
1611 gdbarch_register_name (gdbarch
, realnum
));
1614 /* else keep quiet. */
1618 numregs
= gdbarch_num_regs (gdbarch
)
1619 + gdbarch_num_pseudo_regs (gdbarch
);
1620 for (i
= 0; i
< numregs
; i
++)
1621 if (i
!= gdbarch_sp_regnum (gdbarch
)
1622 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1624 /* Find out the location of the saved register without
1625 fetching the corresponding value. */
1626 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1627 &lval
, &addr
, &realnum
, NULL
);
1628 /* For moment, only display registers that were saved on the
1630 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1633 puts_filtered (" Saved registers:\n ");
1635 puts_filtered (",");
1637 printf_filtered (" %s at ",
1638 gdbarch_register_name (gdbarch
, i
));
1639 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1643 if (count
|| need_nl
)
1644 puts_filtered ("\n");
1647 do_cleanups (back_to
);
1650 /* Print briefly all stack frames or just the innermost COUNT_EXP
1654 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1656 struct frame_info
*fi
;
1659 struct frame_info
*trailing
;
1662 if (!target_has_stack
)
1663 error (_("No stack."));
1665 /* The following code must do two things. First, it must set the
1666 variable TRAILING to the frame from which we should start
1667 printing. Second, it must set the variable count to the number
1668 of frames which we should print, or -1 if all of them. */
1669 trailing
= get_current_frame ();
1674 count
= parse_and_eval_long (count_exp
);
1677 struct frame_info
*current
;
1682 while (current
&& count
--)
1685 current
= get_prev_frame (current
);
1688 /* Will stop when CURRENT reaches the top of the stack.
1689 TRAILING will be COUNT below it. */
1693 trailing
= get_prev_frame (trailing
);
1694 current
= get_prev_frame (current
);
1706 /* Read in symbols for all of the frames. Need to do this in a
1707 separate pass so that "Reading in symbols for xxx" messages
1708 don't screw up the appearance of the backtrace. Also if
1709 people have strong opinions against reading symbols for
1710 backtrace this may have to be an option. */
1712 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1717 pc
= get_frame_address_in_block (fi
);
1718 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1722 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1726 /* Don't use print_stack_frame; if an error() occurs it probably
1727 means further attempts to backtrace would fail (on the other
1728 hand, perhaps the code does or could be fixed to make sure
1729 the frame->prev field gets set to NULL in that case). */
1730 print_frame_info (fi
, 1, LOCATION
, 1);
1733 struct frame_id frame_id
= get_frame_id (fi
);
1735 print_frame_local_vars (fi
, 1, gdb_stdout
);
1737 /* print_frame_local_vars invalidates FI. */
1738 fi
= frame_find_by_id (frame_id
);
1742 warning (_("Unable to restore previously selected frame."));
1747 /* Save the last frame to check for error conditions. */
1751 /* If we've stopped before the end, mention that. */
1753 printf_filtered (_("(More stack frames follow...)\n"));
1755 /* If we've run out of frames, and the reason appears to be an error
1756 condition, print it. */
1757 if (fi
== NULL
&& trailing
!= NULL
)
1759 enum unwind_stop_reason reason
;
1761 reason
= get_frame_unwind_stop_reason (trailing
);
1762 if (reason
>= UNWIND_FIRST_ERROR
)
1763 printf_filtered (_("Backtrace stopped: %s\n"),
1764 frame_stop_reason_string (reason
));
1769 backtrace_command (char *arg
, int from_tty
)
1771 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1772 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1779 argv
= gdb_buildargv (arg
);
1780 make_cleanup_freeargv (argv
);
1782 for (i
= 0; argv
[i
]; i
++)
1786 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1787 argv
[i
][j
] = tolower (argv
[i
][j
]);
1789 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1790 fulltrace_arg
= argc
;
1793 arglen
+= strlen (argv
[i
]);
1798 if (fulltrace_arg
>= 0)
1802 arg
= xmalloc (arglen
+ 1);
1803 make_cleanup (xfree
, arg
);
1805 for (i
= 0; i
< (argc
+ 1); i
++)
1807 if (i
!= fulltrace_arg
)
1809 strcat (arg
, argv
[i
]);
1819 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1821 do_cleanups (old_chain
);
1825 backtrace_full_command (char *arg
, int from_tty
)
1827 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1831 /* Iterate over the local variables of a block B, calling CB with
1835 iterate_over_block_locals (struct block
*b
,
1836 iterate_over_block_arg_local_vars_cb cb
,
1839 struct block_iterator iter
;
1842 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1844 switch (SYMBOL_CLASS (sym
))
1850 if (SYMBOL_IS_ARGUMENT (sym
))
1852 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1854 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1858 /* Ignore symbols which are not locals. */
1865 /* Same, but print labels. */
1868 /* Commented out, as the code using this function has also been
1869 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1870 was commented out in the first place. The discussion introducing
1871 this change (2007-12-04: Support lexical blocks and function bodies
1872 that occupy non-contiguous address ranges) did not explain why
1873 this change was made. */
1875 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1876 int *have_default
, struct ui_file
*stream
)
1878 struct block_iterator iter
;
1880 int values_printed
= 0;
1882 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1884 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1890 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1892 struct symtab_and_line sal
;
1893 struct value_print_options opts
;
1895 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1897 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1898 get_user_print_options (&opts
);
1899 if (opts
.addressprint
)
1901 fprintf_filtered (stream
, " ");
1902 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1905 fprintf_filtered (stream
, " in file %s, line %d\n",
1906 sal
.symtab
->filename
, sal
.line
);
1910 return values_printed
;
1914 /* Iterate over all the local variables in block B, including all its
1915 superblocks, stopping when the top-level block is reached. */
1918 iterate_over_block_local_vars (struct block
*block
,
1919 iterate_over_block_arg_local_vars_cb cb
,
1924 iterate_over_block_locals (block
, cb
, cb_data
);
1925 /* After handling the function's top-level block, stop. Don't
1926 continue to its superblock, the block of per-file
1928 if (BLOCK_FUNCTION (block
))
1930 block
= BLOCK_SUPERBLOCK (block
);
1934 /* Data to be passed around in the calls to the locals and args
1937 struct print_variable_and_value_data
1939 struct frame_id frame_id
;
1941 struct ui_file
*stream
;
1945 /* The callback for the locals and args iterators. */
1948 do_print_variable_and_value (const char *print_name
,
1952 struct print_variable_and_value_data
*p
= cb_data
;
1953 struct frame_info
*frame
;
1955 frame
= frame_find_by_id (p
->frame_id
);
1958 warning (_("Unable to restore previously selected frame."));
1962 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
1964 /* print_variable_and_value invalidates FRAME. */
1967 p
->values_printed
= 1;
1970 /* Print all variables from the innermost up to the function block of FRAME.
1971 Print them with values to STREAM indented by NUM_TABS.
1973 This function will invalidate FRAME. */
1976 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1977 struct ui_file
*stream
)
1979 struct print_variable_and_value_data cb_data
;
1980 struct block
*block
;
1983 if (!get_frame_pc_if_available (frame
, &pc
))
1985 fprintf_filtered (stream
,
1986 _("PC unavailable, cannot determine locals.\n"));
1990 block
= get_frame_block (frame
, 0);
1993 fprintf_filtered (stream
, "No symbol table info available.\n");
1997 cb_data
.frame_id
= get_frame_id (frame
);
1998 cb_data
.num_tabs
= 4 * num_tabs
;
1999 cb_data
.stream
= stream
;
2000 cb_data
.values_printed
= 0;
2002 iterate_over_block_local_vars (block
,
2003 do_print_variable_and_value
,
2006 /* do_print_variable_and_value invalidates FRAME. */
2009 if (!cb_data
.values_printed
)
2010 fprintf_filtered (stream
, _("No locals.\n"));
2014 locals_info (char *args
, int from_tty
)
2016 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2020 /* Iterate over all the argument variables in block B.
2022 Returns 1 if any argument was walked; 0 otherwise. */
2025 iterate_over_block_arg_vars (struct block
*b
,
2026 iterate_over_block_arg_local_vars_cb cb
,
2029 struct block_iterator iter
;
2030 struct symbol
*sym
, *sym2
;
2032 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2034 /* Don't worry about things which aren't arguments. */
2035 if (SYMBOL_IS_ARGUMENT (sym
))
2037 /* We have to look up the symbol because arguments can have
2038 two entries (one a parameter, one a local) and the one we
2039 want is the local, which lookup_symbol will find for us.
2040 This includes gcc1 (not gcc2) on the sparc when passing a
2041 small structure and gcc2 when the argument type is float
2042 and it is passed as a double and converted to float by
2043 the prologue (in the latter case the type of the LOC_ARG
2044 symbol is double and the type of the LOC_LOCAL symbol is
2045 float). There are also LOC_ARG/LOC_REGISTER pairs which
2046 are not combined in symbol-reading. */
2048 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2049 b
, VAR_DOMAIN
, NULL
);
2050 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2055 /* Print all argument variables of the function of FRAME.
2056 Print them with values to STREAM.
2058 This function will invalidate FRAME. */
2061 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2063 struct print_variable_and_value_data cb_data
;
2064 struct symbol
*func
;
2067 if (!get_frame_pc_if_available (frame
, &pc
))
2069 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2073 func
= get_frame_function (frame
);
2076 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2080 cb_data
.frame_id
= get_frame_id (frame
);
2081 cb_data
.num_tabs
= 0;
2082 cb_data
.stream
= gdb_stdout
;
2083 cb_data
.values_printed
= 0;
2085 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2086 do_print_variable_and_value
, &cb_data
);
2088 /* do_print_variable_and_value invalidates FRAME. */
2091 if (!cb_data
.values_printed
)
2092 fprintf_filtered (stream
, _("No arguments.\n"));
2096 args_info (char *ignore
, int from_tty
)
2098 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2104 args_plus_locals_info (char *ignore
, int from_tty
)
2106 args_info (ignore
, from_tty
);
2107 locals_info (ignore
, from_tty
);
2111 /* Select frame FRAME. Also print the stack frame and show the source
2112 if this is the tui version. */
2114 select_and_print_frame (struct frame_info
*frame
)
2116 select_frame (frame
);
2118 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2121 /* Return the symbol-block in which the selected frame is executing.
2122 Can return zero under various legitimate circumstances.
2124 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2125 code address within the block returned. We use this to decide
2126 which macros are in scope. */
2129 get_selected_block (CORE_ADDR
*addr_in_block
)
2131 if (!has_stack_frames ())
2134 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2137 /* Find a frame a certain number of levels away from FRAME.
2138 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2139 Positive means go to earlier frames (up); negative, the reverse.
2140 The int that contains the number of levels is counted toward
2141 zero as the frames for those levels are found.
2142 If the top or bottom frame is reached, that frame is returned,
2143 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2144 how much farther the original request asked to go. */
2147 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2149 /* Going up is simple: just call get_prev_frame enough times or
2150 until the initial frame is reached. */
2151 while (*level_offset_ptr
> 0)
2153 struct frame_info
*prev
= get_prev_frame (frame
);
2157 (*level_offset_ptr
)--;
2161 /* Going down is just as simple. */
2162 while (*level_offset_ptr
< 0)
2164 struct frame_info
*next
= get_next_frame (frame
);
2168 (*level_offset_ptr
)++;
2175 /* The "select_frame" command. With no argument this is a NOP.
2176 Select the frame at level LEVEL_EXP if it is a valid level.
2177 Otherwise, treat LEVEL_EXP as an address expression and select it.
2179 See parse_frame_specification for more info on proper frame
2183 select_frame_command (char *level_exp
, int from_tty
)
2185 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2188 /* The "frame" command. With no argument, print the selected frame
2189 briefly. With an argument, behave like select_frame and then print
2190 the selected frame. */
2193 frame_command (char *level_exp
, int from_tty
)
2195 select_frame_command (level_exp
, from_tty
);
2196 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2199 /* The XDB Compatibility command to print the current frame. */
2202 current_frame_command (char *level_exp
, int from_tty
)
2204 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2207 /* Select the frame up one or COUNT_EXP stack levels from the
2208 previously selected frame, and print it briefly. */
2211 up_silently_base (char *count_exp
)
2213 struct frame_info
*frame
;
2217 count
= parse_and_eval_long (count_exp
);
2219 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2220 if (count
!= 0 && count_exp
== NULL
)
2221 error (_("Initial frame selected; you cannot go up."));
2222 select_frame (frame
);
2226 up_silently_command (char *count_exp
, int from_tty
)
2228 up_silently_base (count_exp
);
2232 up_command (char *count_exp
, int from_tty
)
2234 up_silently_base (count_exp
);
2235 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2238 /* Select the frame down one or COUNT_EXP stack levels from the previously
2239 selected frame, and print it briefly. */
2242 down_silently_base (char *count_exp
)
2244 struct frame_info
*frame
;
2248 count
= -parse_and_eval_long (count_exp
);
2250 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2251 if (count
!= 0 && count_exp
== NULL
)
2253 /* We only do this if COUNT_EXP is not specified. That way
2254 "down" means to really go down (and let me know if that is
2255 impossible), but "down 9999" can be used to mean go all the
2256 way down without getting an error. */
2258 error (_("Bottom (innermost) frame selected; you cannot go down."));
2261 select_frame (frame
);
2265 down_silently_command (char *count_exp
, int from_tty
)
2267 down_silently_base (count_exp
);
2271 down_command (char *count_exp
, int from_tty
)
2273 down_silently_base (count_exp
);
2274 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2279 return_command (char *retval_exp
, int from_tty
)
2281 /* Initialize it just to avoid a GCC false warning. */
2282 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2283 struct frame_info
*thisframe
;
2284 struct gdbarch
*gdbarch
;
2285 struct symbol
*thisfun
;
2286 struct value
*return_value
= NULL
;
2287 struct value
*function
= NULL
;
2288 const char *query_prefix
= "";
2290 thisframe
= get_selected_frame ("No selected frame.");
2291 thisfun
= get_frame_function (thisframe
);
2292 gdbarch
= get_frame_arch (thisframe
);
2294 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2295 error (_("Can not force return from an inlined function."));
2297 /* Compute the return value. If the computation triggers an error,
2298 let it bail. If the return type can't be handled, set
2299 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2303 struct expression
*retval_expr
= parse_expression (retval_exp
);
2304 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2305 struct type
*return_type
= NULL
;
2307 /* Compute the return value. Should the computation fail, this
2308 call throws an error. */
2309 return_value
= evaluate_expression (retval_expr
);
2311 /* Cast return value to the return type of the function. Should
2312 the cast fail, this call throws an error. */
2313 if (thisfun
!= NULL
)
2314 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2315 if (return_type
== NULL
)
2317 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2318 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2319 error (_("Return value type not available for selected "
2321 "Please use an explicit cast of the value to return."));
2322 return_type
= value_type (return_value
);
2324 do_cleanups (old_chain
);
2325 CHECK_TYPEDEF (return_type
);
2326 return_value
= value_cast (return_type
, return_value
);
2328 /* Make sure the value is fully evaluated. It may live in the
2329 stack frame we're about to pop. */
2330 if (value_lazy (return_value
))
2331 value_fetch_lazy (return_value
);
2333 if (thisfun
!= NULL
)
2334 function
= read_var_value (thisfun
, thisframe
);
2336 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2337 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2338 /* If the return-type is "void", don't try to find the
2339 return-value's location. However, do still evaluate the
2340 return expression so that, even when the expression result
2341 is discarded, side effects such as "return i++" still
2343 return_value
= NULL
;
2344 else if (thisfun
!= NULL
)
2346 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2347 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2348 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2350 query_prefix
= "The location at which to store the "
2351 "function's return value is unknown.\n"
2352 "If you continue, the return value "
2353 "that you specified will be ignored.\n";
2354 return_value
= NULL
;
2359 /* Does an interactive user really want to do this? Include
2360 information, such as how well GDB can handle the return value, in
2361 the query message. */
2366 if (thisfun
== NULL
)
2367 confirmed
= query (_("%sMake selected stack frame return now? "),
2370 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2371 SYMBOL_PRINT_NAME (thisfun
));
2373 error (_("Not confirmed"));
2376 /* Discard the selected frame and all frames inner-to it. */
2377 frame_pop (get_selected_frame (NULL
));
2379 /* Store RETURN_VALUE in the just-returned register set. */
2380 if (return_value
!= NULL
)
2382 struct type
*return_type
= value_type (return_value
);
2383 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2385 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2386 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2387 gdbarch_return_value (gdbarch
, function
, return_type
,
2388 get_current_regcache (), NULL
/*read*/,
2389 value_contents (return_value
) /*write*/);
2392 /* If we are at the end of a call dummy now, pop the dummy frame
2394 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2395 frame_pop (get_current_frame ());
2397 /* If interactive, print the frame that is now current. */
2399 frame_command ("0", 1);
2401 select_frame_command ("0", 0);
2404 /* Sets the scope to input function name, provided that the function
2405 is within the current stack frame. */
2407 struct function_bounds
2409 CORE_ADDR low
, high
;
2413 func_command (char *arg
, int from_tty
)
2415 struct frame_info
*frame
;
2417 struct symtabs_and_lines sals
;
2420 struct function_bounds
*func_bounds
= NULL
;
2421 struct cleanup
*cleanups
;
2426 frame
= parse_frame_specification ("0");
2427 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2428 cleanups
= make_cleanup (xfree
, sals
.sals
);
2429 func_bounds
= (struct function_bounds
*) xmalloc (
2430 sizeof (struct function_bounds
) * sals
.nelts
);
2431 make_cleanup (xfree
, func_bounds
);
2432 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2434 if (sals
.sals
[i
].pspace
!= current_program_space
)
2435 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2436 else if (sals
.sals
[i
].pc
== 0
2437 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2438 &func_bounds
[i
].low
,
2439 &func_bounds
[i
].high
) == 0)
2441 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2447 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2448 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2449 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2453 frame
= find_relative_frame (frame
, &level
);
2456 while (!found
&& level
== 0);
2458 do_cleanups (cleanups
);
2461 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2462 else if (frame
!= get_selected_frame (NULL
))
2463 select_and_print_frame (frame
);
2466 /* Gets the language of the current frame. */
2469 get_frame_language (void)
2471 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2475 volatile struct gdb_exception ex
;
2479 /* We determine the current frame language by looking up its
2480 associated symtab. To retrieve this symtab, we use the frame
2481 PC. However we cannot use the frame PC as is, because it
2482 usually points to the instruction following the "call", which
2483 is sometimes the first instruction of another function. So
2484 we rely on get_frame_address_in_block(), it provides us with
2485 a PC that is guaranteed to be inside the frame's code
2488 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2490 pc
= get_frame_address_in_block (frame
);
2494 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2495 throw_exception (ex
);
2499 s
= find_pc_symtab (pc
);
2505 return language_unknown
;
2509 /* Provide a prototype to silence -Wmissing-prototypes. */
2510 void _initialize_stack (void);
2513 _initialize_stack (void)
2515 add_com ("return", class_stack
, return_command
, _("\
2516 Make selected stack frame return to its caller.\n\
2517 Control remains in the debugger, but when you continue\n\
2518 execution will resume in the frame above the one now selected.\n\
2519 If an argument is given, it is an expression for the value to return."));
2521 add_com ("up", class_stack
, up_command
, _("\
2522 Select and print stack frame that called this one.\n\
2523 An argument says how many frames up to go."));
2524 add_com ("up-silently", class_support
, up_silently_command
, _("\
2525 Same as the `up' command, but does not print anything.\n\
2526 This is useful in command scripts."));
2528 add_com ("down", class_stack
, down_command
, _("\
2529 Select and print stack frame called by this one.\n\
2530 An argument says how many frames down to go."));
2531 add_com_alias ("do", "down", class_stack
, 1);
2532 add_com_alias ("dow", "down", class_stack
, 1);
2533 add_com ("down-silently", class_support
, down_silently_command
, _("\
2534 Same as the `down' command, but does not print anything.\n\
2535 This is useful in command scripts."));
2537 add_com ("frame", class_stack
, frame_command
, _("\
2538 Select and print a stack frame.\nWith no argument, \
2539 print the selected stack frame. (See also \"info frame\").\n\
2540 An argument specifies the frame to select.\n\
2541 It can be a stack frame number or the address of the frame.\n\
2542 With argument, nothing is printed if input is coming from\n\
2543 a command file or a user-defined command."));
2545 add_com_alias ("f", "frame", class_stack
, 1);
2549 add_com ("L", class_stack
, current_frame_command
,
2550 _("Print the current stack frame.\n"));
2551 add_com_alias ("V", "frame", class_stack
, 1);
2553 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2554 Select a stack frame without printing anything.\n\
2555 An argument specifies the frame to select.\n\
2556 It can be a stack frame number or the address of the frame.\n"));
2558 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2559 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2560 With a negative argument, print outermost -COUNT frames.\nUse of the \
2561 'full' qualifier also prints the values of the local variables.\n"));
2562 add_com_alias ("bt", "backtrace", class_stack
, 0);
2565 add_com_alias ("t", "backtrace", class_stack
, 0);
2566 add_com ("T", class_stack
, backtrace_full_command
, _("\
2567 Print backtrace of all stack frames, or innermost COUNT frames\n\
2568 and the values of the local variables.\n\
2569 With a negative argument, print outermost -COUNT frames.\n\
2570 Usage: T <count>\n"));
2573 add_com_alias ("where", "backtrace", class_alias
, 0);
2574 add_info ("stack", backtrace_command
,
2575 _("Backtrace of the stack, or innermost COUNT frames."));
2576 add_info_alias ("s", "stack", 1);
2577 add_info ("frame", frame_info
,
2578 _("All about selected stack frame, or frame at ADDR."));
2579 add_info_alias ("f", "frame", 1);
2580 add_info ("locals", locals_info
,
2581 _("Local variables of current stack frame."));
2582 add_info ("args", args_info
,
2583 _("Argument variables of current stack frame."));
2585 add_com ("l", class_info
, args_plus_locals_info
,
2586 _("Argument and local variables of current stack frame."));
2589 add_com ("func", class_stack
, func_command
, _("\
2590 Select the stack frame that contains <func>.\n\
2591 Usage: func <name>\n"));
2593 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2594 print_frame_arguments_choices
, &print_frame_arguments
,
2595 _("Set printing of non-scalar frame arguments"),
2596 _("Show printing of non-scalar frame arguments"),
2597 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2599 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2600 &disassemble_next_line
, _("\
2601 Set whether to disassemble next source line or insn when execution stops."),
2603 Show whether to disassemble next source line or insn when execution stops."),
2605 If ON, GDB will display disassembly of the next source line, in addition\n\
2606 to displaying the source line itself. If the next source line cannot\n\
2607 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2608 will display disassembly of next instruction instead of showing the\n\
2610 If AUTO, display disassembly of next instruction only if the source line\n\
2611 cannot be displayed.\n\
2612 If OFF (which is the default), never display the disassembly of the next\n\
2615 show_disassemble_next_line
,
2616 &setlist
, &showlist
);
2617 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2619 add_setshow_enum_cmd ("entry-values", class_stack
,
2620 print_entry_values_choices
, &print_entry_values
,
2621 _("Set printing of function arguments at function "
2623 _("Show printing of function arguments at function "
2626 GDB can sometimes determine the values of function arguments at entry,\n\
2627 in addition to their current values. This option tells GDB whether\n\
2628 to print the current value, the value at entry (marked as val@entry),\n\
2629 or both. Note that one or both of these values may be <optimized out>."),
2630 NULL
, NULL
, &setprintlist
, &showprintlist
);