1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 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 "reggroups.h"
43 #include "gdbthread.h"
44 #include "cp-support.h"
46 #include "inline-frame.h"
48 #include "cli/cli-utils.h"
51 #include "safe-ctype.h"
53 #include "extension.h"
56 /* The possible choices of "set print frame-arguments", and the value
59 static const char *const print_frame_arguments_choices
[] =
60 {"all", "scalars", "none", NULL
};
61 static const char *print_frame_arguments
= "scalars";
63 /* If non-zero, don't invoke pretty-printers for frame arguments. */
64 static int print_raw_frame_arguments
;
66 /* The possible choices of "set print entry-values", and the value
69 const char print_entry_values_no
[] = "no";
70 const char print_entry_values_only
[] = "only";
71 const char print_entry_values_preferred
[] = "preferred";
72 const char print_entry_values_if_needed
[] = "if-needed";
73 const char print_entry_values_both
[] = "both";
74 const char print_entry_values_compact
[] = "compact";
75 const char print_entry_values_default
[] = "default";
76 static const char *const print_entry_values_choices
[] =
78 print_entry_values_no
,
79 print_entry_values_only
,
80 print_entry_values_preferred
,
81 print_entry_values_if_needed
,
82 print_entry_values_both
,
83 print_entry_values_compact
,
84 print_entry_values_default
,
87 const char *print_entry_values
= print_entry_values_default
;
89 /* Prototypes for local functions. */
91 static void print_frame_local_vars (struct frame_info
*, int,
94 static void print_frame (struct frame_info
*frame
, int print_level
,
95 enum print_what print_what
, int print_args
,
96 struct symtab_and_line sal
);
98 static void set_last_displayed_sal (int valid
,
99 struct program_space
*pspace
,
101 struct symtab
*symtab
,
104 /* Zero means do things normally; we are interacting directly with the
105 user. One means print the full filename and linenumber when a
106 frame is printed, and do so in a format emacs18/emacs19.22 can
107 parse. Two means print similar annotations, but in many more
108 cases and in a slightly different syntax. */
110 int annotation_level
= 0;
112 /* These variables hold the last symtab and line we displayed to the user.
113 * This is where we insert a breakpoint or a skiplist entry by default. */
114 static int last_displayed_sal_valid
= 0;
115 static struct program_space
*last_displayed_pspace
= 0;
116 static CORE_ADDR last_displayed_addr
= 0;
117 static struct symtab
*last_displayed_symtab
= 0;
118 static int last_displayed_line
= 0;
121 /* Return 1 if we should display the address in addition to the location,
122 because we are in the middle of a statement. */
125 frame_show_address (struct frame_info
*frame
,
126 struct symtab_and_line sal
)
128 /* If there is a line number, but no PC, then there is no location
129 information associated with this sal. The only way that should
130 happen is for the call sites of inlined functions (SAL comes from
131 find_frame_sal). Otherwise, we would have some PC range if the
132 SAL came from a line table. */
133 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
135 if (get_next_frame (frame
) == NULL
)
136 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
138 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
142 return get_frame_pc (frame
) != sal
.pc
;
148 print_stack_frame_to_uiout (struct ui_out
*uiout
, struct frame_info
*frame
,
149 int print_level
, enum print_what print_what
,
152 scoped_restore save_uiout
= make_scoped_restore (¤t_uiout
, uiout
);
154 print_stack_frame (frame
, print_level
, print_what
, set_current_sal
);
157 /* Show or print a stack frame FRAME briefly. The output is formatted
158 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
159 relative level, function name, argument list, and file name and
160 line number. If the frame's PC is not at the beginning of the
161 source line, the actual PC is printed at the beginning. */
164 print_stack_frame (struct frame_info
*frame
, int print_level
,
165 enum print_what print_what
,
169 /* For mi, alway print location and address. */
170 if (current_uiout
->is_mi_like_p ())
171 print_what
= LOC_AND_ADDRESS
;
175 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */,
178 set_current_sal_from_frame (frame
);
180 CATCH (e
, RETURN_MASK_ERROR
)
186 /* Print nameless arguments of frame FRAME on STREAM, where START is
187 the offset of the first nameless argument, and NUM is the number of
188 nameless arguments to print. FIRST is nonzero if this is the first
189 argument (not just the first nameless argument). */
192 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
193 int first
, struct ui_file
*stream
)
195 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
196 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
201 for (i
= 0; i
< num
; i
++)
204 argsaddr
= get_frame_args_address (frame
);
207 arg_value
= read_memory_integer (argsaddr
+ start
,
208 sizeof (int), byte_order
);
210 fprintf_filtered (stream
, ", ");
211 fprintf_filtered (stream
, "%ld", arg_value
);
213 start
+= sizeof (int);
217 /* Print single argument of inferior function. ARG must be already
220 Errors are printed as if they would be the parameter value. Use zeroed ARG
221 iff it should not be printed accoring to user settings. */
224 print_frame_arg (const struct frame_arg
*arg
)
226 struct ui_out
*uiout
= current_uiout
;
227 const char *error_message
= NULL
;
231 gdb_assert (!arg
->val
|| !arg
->error
);
232 gdb_assert (arg
->entry_kind
== print_entry_values_no
233 || arg
->entry_kind
== print_entry_values_only
234 || (!uiout
->is_mi_like_p ()
235 && arg
->entry_kind
== print_entry_values_compact
));
237 annotate_arg_emitter arg_emitter
;
238 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
239 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
240 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
241 if (arg
->entry_kind
== print_entry_values_compact
)
243 /* It is OK to provide invalid MI-like stream as with
244 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
247 fprintf_symbol_filtered (&stb
, SYMBOL_PRINT_NAME (arg
->sym
),
248 SYMBOL_LANGUAGE (arg
->sym
),
249 DMGL_PARAMS
| DMGL_ANSI
);
251 if (arg
->entry_kind
== print_entry_values_only
252 || arg
->entry_kind
== print_entry_values_compact
)
254 uiout
->field_stream ("name", stb
);
255 annotate_arg_name_end ();
258 if (!arg
->val
&& !arg
->error
)
263 error_message
= arg
->error
;
268 const struct language_defn
*language
;
269 struct value_print_options opts
;
271 /* Avoid value_print because it will deref ref parameters. We
272 just want to print their addresses. Print ??? for args whose
273 address we do not know. We pass 2 as "recurse" to val_print
274 because our standard indentation here is 4 spaces, and
275 val_print indents 2 for each recurse. */
277 annotate_arg_value (value_type (arg
->val
));
279 /* Use the appropriate language to display our symbol, unless the
280 user forced the language to a specific language. */
281 if (language_mode
== language_mode_auto
)
282 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
284 language
= current_language
;
286 get_no_prettyformat_print_options (&opts
);
288 opts
.raw
= print_raw_frame_arguments
;
290 /* True in "summary" mode, false otherwise. */
291 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
293 common_val_print (arg
->val
, &stb
, 2, &opts
, language
);
295 CATCH (except
, RETURN_MASK_ERROR
)
297 error_message
= except
.message
;
301 if (error_message
!= NULL
)
302 stb
.printf (_("<error reading variable: %s>"), error_message
);
305 uiout
->field_stream ("value", stb
);
308 /* Read in inferior function local SYM at FRAME into ARGP. Caller is
309 responsible for xfree of ARGP->ERROR. This function never throws an
313 read_frame_local (struct symbol
*sym
, struct frame_info
*frame
,
314 struct frame_arg
*argp
)
322 argp
->val
= read_var_value (sym
, NULL
, frame
);
324 CATCH (except
, RETURN_MASK_ERROR
)
326 argp
->error
= xstrdup (except
.message
);
331 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
332 responsible for xfree of ARGP->ERROR. This function never throws an
336 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
337 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
339 struct value
*val
= NULL
, *entryval
= NULL
;
340 char *val_error
= NULL
, *entryval_error
= NULL
;
343 if (print_entry_values
!= print_entry_values_only
344 && print_entry_values
!= print_entry_values_preferred
)
348 val
= read_var_value (sym
, NULL
, frame
);
350 CATCH (except
, RETURN_MASK_ERROR
)
352 val_error
= (char *) alloca (strlen (except
.message
) + 1);
353 strcpy (val_error
, except
.message
);
358 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
359 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
360 && print_entry_values
!= print_entry_values_no
361 && (print_entry_values
!= print_entry_values_if_needed
362 || !val
|| value_optimized_out (val
)))
366 const struct symbol_computed_ops
*ops
;
368 ops
= SYMBOL_COMPUTED_OPS (sym
);
369 entryval
= ops
->read_variable_at_entry (sym
, frame
);
371 CATCH (except
, RETURN_MASK_ERROR
)
373 if (except
.error
!= NO_ENTRY_VALUE_ERROR
)
375 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
376 strcpy (entryval_error
, except
.message
);
381 if (entryval
!= NULL
&& value_optimized_out (entryval
))
384 if (print_entry_values
== print_entry_values_compact
385 || print_entry_values
== print_entry_values_default
)
387 /* For MI do not try to use print_entry_values_compact for ARGP. */
389 if (val
&& entryval
&& !current_uiout
->is_mi_like_p ())
391 struct type
*type
= value_type (val
);
393 if (value_lazy (val
))
394 value_fetch_lazy (val
);
395 if (value_lazy (entryval
))
396 value_fetch_lazy (entryval
);
398 if (value_contents_eq (val
, 0, entryval
, 0, TYPE_LENGTH (type
)))
400 /* Initialize it just to avoid a GCC false warning. */
401 struct value
*val_deref
= NULL
, *entryval_deref
;
403 /* DW_AT_call_value does match with the current
404 value. If it is a reference still try to verify if
405 dereferenced DW_AT_call_data_value does not differ. */
409 struct type
*type_deref
;
411 val_deref
= coerce_ref (val
);
412 if (value_lazy (val_deref
))
413 value_fetch_lazy (val_deref
);
414 type_deref
= value_type (val_deref
);
416 entryval_deref
= coerce_ref (entryval
);
417 if (value_lazy (entryval_deref
))
418 value_fetch_lazy (entryval_deref
);
420 /* If the reference addresses match but dereferenced
421 content does not match print them. */
423 && value_contents_eq (val_deref
, 0,
425 TYPE_LENGTH (type_deref
)))
428 CATCH (except
, RETURN_MASK_ERROR
)
430 /* If the dereferenced content could not be
431 fetched do not display anything. */
432 if (except
.error
== NO_ENTRY_VALUE_ERROR
)
434 else if (except
.message
!= NULL
)
436 entryval_error
= (char *) alloca (strlen (except
.message
) + 1);
437 strcpy (entryval_error
, except
.message
);
442 /* Value was not a reference; and its content matches. */
443 if (val
== val_deref
)
451 /* Try to remove possibly duplicate error message for ENTRYARGP even
454 if (val_error
&& entryval_error
455 && strcmp (val_error
, entryval_error
) == 0)
457 entryval_error
= NULL
;
459 /* Do not se VAL_EQUAL as the same error message may be shown for
460 the entry value even if no entry values are present in the
466 if (entryval
== NULL
)
468 if (print_entry_values
== print_entry_values_preferred
)
470 gdb_assert (val
== NULL
);
474 val
= read_var_value (sym
, NULL
, frame
);
476 CATCH (except
, RETURN_MASK_ERROR
)
478 val_error
= (char *) alloca (strlen (except
.message
) + 1);
479 strcpy (val_error
, except
.message
);
483 if (print_entry_values
== print_entry_values_only
484 || print_entry_values
== print_entry_values_both
485 || (print_entry_values
== print_entry_values_preferred
486 && (!val
|| value_optimized_out (val
))))
488 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
489 entryval_error
= NULL
;
492 if ((print_entry_values
== print_entry_values_compact
493 || print_entry_values
== print_entry_values_if_needed
494 || print_entry_values
== print_entry_values_preferred
)
495 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
503 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
504 if (!val
&& !val_error
)
505 argp
->entry_kind
= print_entry_values_only
;
506 else if ((print_entry_values
== print_entry_values_compact
507 || print_entry_values
== print_entry_values_default
) && val_equal
)
509 argp
->entry_kind
= print_entry_values_compact
;
510 gdb_assert (!current_uiout
->is_mi_like_p ());
513 argp
->entry_kind
= print_entry_values_no
;
515 entryargp
->sym
= sym
;
516 entryargp
->val
= entryval
;
517 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
518 if (!entryval
&& !entryval_error
)
519 entryargp
->entry_kind
= print_entry_values_no
;
521 entryargp
->entry_kind
= print_entry_values_only
;
524 /* Print the arguments of frame FRAME on STREAM, given the function
525 FUNC running in that frame (as a symbol), where NUM is the number
526 of arguments according to the stack frame (or -1 if the number of
527 arguments is unknown). */
529 /* Note that currently the "number of arguments according to the
530 stack frame" is only known on VAX where i refers to the "number of
531 ints of arguments according to the stack frame". */
534 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
535 int num
, struct ui_file
*stream
)
537 struct ui_out
*uiout
= current_uiout
;
539 /* Offset of next stack argument beyond the one we have seen that is
540 at the highest offset, or -1 if we haven't come to a stack
542 long highest_offset
= -1;
543 /* Number of ints of arguments that we have printed so far. */
544 int args_printed
= 0;
545 /* True if we should print arguments, false otherwise. */
546 int print_args
= strcmp (print_frame_arguments
, "none");
550 const struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
551 struct block_iterator iter
;
554 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
556 struct frame_arg arg
, entryarg
;
560 /* Keep track of the highest stack argument offset seen, and
561 skip over any kinds of symbols we don't care about. */
563 if (!SYMBOL_IS_ARGUMENT (sym
))
566 switch (SYMBOL_CLASS (sym
))
571 long current_offset
= SYMBOL_VALUE (sym
);
572 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
574 /* Compute address of next argument by adding the size of
575 this argument and rounding to an int boundary. */
577 ((current_offset
+ arg_size
+ sizeof (int) - 1)
578 & ~(sizeof (int) - 1));
580 /* If this is the highest offset seen yet, set
582 if (highest_offset
== -1
583 || (current_offset
> highest_offset
))
584 highest_offset
= current_offset
;
586 /* Add the number of ints we're about to print to
588 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
591 /* We care about types of symbols, but don't need to
592 keep track of stack offsets in them. */
594 case LOC_REGPARM_ADDR
:
596 case LOC_OPTIMIZED_OUT
:
601 /* We have to look up the symbol because arguments can have
602 two entries (one a parameter, one a local) and the one we
603 want is the local, which lookup_symbol will find for us.
604 This includes gcc1 (not gcc2) on SPARC when passing a
605 small structure and gcc2 when the argument type is float
606 and it is passed as a double and converted to float by
607 the prologue (in the latter case the type of the LOC_ARG
608 symbol is double and the type of the LOC_LOCAL symbol is
610 /* But if the parameter name is null, don't try it. Null
611 parameter names occur on the RS/6000, for traceback
612 tables. FIXME, should we even print them? */
614 if (*SYMBOL_LINKAGE_NAME (sym
))
618 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
619 b
, VAR_DOMAIN
, NULL
).symbol
;
620 gdb_assert (nsym
!= NULL
);
621 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
622 && !SYMBOL_IS_ARGUMENT (nsym
))
624 /* There is a LOC_ARG/LOC_REGISTER pair. This means
625 that it was passed on the stack and loaded into a
626 register, or passed in a register and stored in a
627 stack slot. GDB 3.x used the LOC_ARG; GDB
628 4.0-4.11 used the LOC_REGISTER.
630 Reasons for using the LOC_ARG:
632 (1) Because find_saved_registers may be slow for
635 (2) Because registers are often re-used and stack
636 slots rarely (never?) are. Therefore using
637 the stack slot is much less likely to print
640 Reasons why we might want to use the LOC_REGISTER:
642 (1) So that the backtrace prints the same value
643 as "print foo". I see no compelling reason
644 why this needs to be the case; having the
645 backtrace print the value which was passed
646 in, and "print foo" print the value as
647 modified within the called function, makes
650 Additional note: It might be nice if "info args"
651 displayed both values.
653 One more note: There is a case with SPARC
654 structure passing where we need to use the
655 LOC_REGISTER, but this is dealt with by creating
656 a single LOC_REGPARM in symbol reading. */
658 /* Leave sym (the LOC_ARG) alone. */
665 /* Print the current arg. */
668 uiout
->wrap_hint (" ");
672 memset (&arg
, 0, sizeof (arg
));
674 arg
.entry_kind
= print_entry_values_no
;
675 memset (&entryarg
, 0, sizeof (entryarg
));
677 entryarg
.entry_kind
= print_entry_values_no
;
680 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
682 if (arg
.entry_kind
!= print_entry_values_only
)
683 print_frame_arg (&arg
);
685 if (entryarg
.entry_kind
!= print_entry_values_no
)
687 if (arg
.entry_kind
!= print_entry_values_only
)
690 uiout
->wrap_hint (" ");
693 print_frame_arg (&entryarg
);
697 xfree (entryarg
.error
);
703 /* Don't print nameless args in situations where we don't know
704 enough about the stack to find them. */
709 if (highest_offset
== -1)
710 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
712 start
= highest_offset
;
714 print_frame_nameless_args (frame
, start
, num
- args_printed
,
719 /* Set the current source and line to the location given by frame
720 FRAME, if possible. When CENTER is true, adjust so the relevant
721 line is in the center of the next 'list'. */
724 set_current_sal_from_frame (struct frame_info
*frame
)
726 symtab_and_line sal
= find_frame_sal (frame
);
727 if (sal
.symtab
!= NULL
)
728 set_current_source_symtab_and_line (sal
);
731 /* If ON, GDB will display disassembly of the next source line when
732 execution of the program being debugged stops.
733 If AUTO (which is the default), or there's no line info to determine
734 the source line of the next instruction, display disassembly of next
735 instruction instead. */
737 static enum auto_boolean disassemble_next_line
;
740 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
741 struct cmd_list_element
*c
,
744 fprintf_filtered (file
,
745 _("Debugger's willingness to use "
746 "disassemble-next-line is %s.\n"),
750 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
751 because it will be broken by filter sometime. */
754 do_gdb_disassembly (struct gdbarch
*gdbarch
,
755 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
760 gdb_disassembly (gdbarch
, current_uiout
,
761 DISASSEMBLY_RAW_INSN
, how_many
,
764 CATCH (exception
, RETURN_MASK_ERROR
)
766 /* If an exception was thrown while doing the disassembly, print
767 the error message, to give the user a clue of what happened. */
768 exception_print (gdb_stderr
, exception
);
773 /* Print information about frame FRAME. The output is format according
774 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
777 SRC_LINE: Print only source line.
778 LOCATION: Print only location.
779 LOC_AND_SRC: Print location and source line.
781 Used in "where" output, and to emit breakpoint or step
785 print_frame_info (struct frame_info
*frame
, int print_level
,
786 enum print_what print_what
, int print_args
,
789 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
792 struct ui_out
*uiout
= current_uiout
;
794 if (get_frame_type (frame
) == DUMMY_FRAME
795 || get_frame_type (frame
) == SIGTRAMP_FRAME
796 || get_frame_type (frame
) == ARCH_FRAME
)
798 ui_out_emit_tuple
tuple_emitter (uiout
, "frame");
800 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
801 gdbarch
, get_frame_pc (frame
));
803 /* Do this regardless of SOURCE because we don't have any source
804 to list for this frame. */
808 uiout
->field_fmt_int (2, ui_left
, "level",
809 frame_relative_level (frame
));
811 if (uiout
->is_mi_like_p ())
813 annotate_frame_address ();
814 uiout
->field_core_addr ("addr",
815 gdbarch
, get_frame_pc (frame
));
816 annotate_frame_address_end ();
819 if (get_frame_type (frame
) == DUMMY_FRAME
)
821 annotate_function_call ();
822 uiout
->field_string ("func", "<function called from gdb>");
824 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
826 annotate_signal_handler_caller ();
827 uiout
->field_string ("func", "<signal handler called>");
829 else if (get_frame_type (frame
) == ARCH_FRAME
)
831 uiout
->field_string ("func", "<cross-architecture call>");
834 annotate_frame_end ();
836 /* If disassemble-next-line is set to auto or on output the next
838 if (disassemble_next_line
== AUTO_BOOLEAN_AUTO
839 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
840 do_gdb_disassembly (get_frame_arch (frame
), 1,
841 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
846 /* If FRAME is not the innermost frame, that normally means that
847 FRAME->pc points to *after* the call instruction, and we want to
848 get the line containing the call, never the next line. But if
849 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
850 next frame was not entered as the result of a call, and we want
851 to get the line containing FRAME->pc. */
852 symtab_and_line sal
= find_frame_sal (frame
);
854 location_print
= (print_what
== LOCATION
855 || print_what
== LOC_AND_ADDRESS
856 || print_what
== SRC_AND_LOC
);
858 if (location_print
|| !sal
.symtab
)
859 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
861 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
863 /* If disassemble-next-line is set to auto or on and doesn't have
864 the line debug messages for $pc, output the next instruction. */
865 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
866 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
867 && source_print
&& !sal
.symtab
)
868 do_gdb_disassembly (get_frame_arch (frame
), 1,
869 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
871 if (source_print
&& sal
.symtab
)
874 int mid_statement
= ((print_what
== SRC_LINE
)
875 && frame_show_address (frame
, sal
));
877 if (annotation_level
)
878 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
879 get_frame_pc (frame
));
882 if (deprecated_print_frame_info_listing_hook
)
883 deprecated_print_frame_info_listing_hook (sal
.symtab
,
888 struct value_print_options opts
;
890 get_user_print_options (&opts
);
891 /* We used to do this earlier, but that is clearly
892 wrong. This function is used by many different
893 parts of gdb, including normal_stop in infrun.c,
894 which uses this to print out the current PC
895 when we stepi/nexti into the middle of a source
896 line. Only the command line really wants this
897 behavior. Other UIs probably would like the
898 ability to decide for themselves if it is desired. */
899 if (opts
.addressprint
&& mid_statement
)
901 uiout
->field_core_addr ("addr",
902 gdbarch
, get_frame_pc (frame
));
906 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
910 /* If disassemble-next-line is set to on and there is line debug
911 messages, output assembly codes for next line. */
912 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
913 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
920 if (get_frame_pc_if_available (frame
, &pc
))
921 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
923 set_last_displayed_sal (0, 0, 0, 0, 0);
926 annotate_frame_end ();
928 gdb_flush (gdb_stdout
);
931 /* Remember the last symtab and line we displayed, which we use e.g.
932 * as the place to put a breakpoint when the `break' command is
933 * invoked with no arguments. */
936 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
937 CORE_ADDR addr
, struct symtab
*symtab
,
940 last_displayed_sal_valid
= valid
;
941 last_displayed_pspace
= pspace
;
942 last_displayed_addr
= addr
;
943 last_displayed_symtab
= symtab
;
944 last_displayed_line
= line
;
945 if (valid
&& pspace
== NULL
)
947 clear_last_displayed_sal ();
948 internal_error (__FILE__
, __LINE__
,
949 _("Trying to set NULL pspace."));
953 /* Forget the last sal we displayed. */
956 clear_last_displayed_sal (void)
958 last_displayed_sal_valid
= 0;
959 last_displayed_pspace
= 0;
960 last_displayed_addr
= 0;
961 last_displayed_symtab
= 0;
962 last_displayed_line
= 0;
965 /* Is our record of the last sal we displayed valid? If not,
966 * the get_last_displayed_* functions will return NULL or 0, as
970 last_displayed_sal_is_valid (void)
972 return last_displayed_sal_valid
;
975 /* Get the pspace of the last sal we displayed, if it's valid. */
977 struct program_space
*
978 get_last_displayed_pspace (void)
980 if (last_displayed_sal_valid
)
981 return last_displayed_pspace
;
985 /* Get the address of the last sal we displayed, if it's valid. */
988 get_last_displayed_addr (void)
990 if (last_displayed_sal_valid
)
991 return last_displayed_addr
;
995 /* Get the symtab of the last sal we displayed, if it's valid. */
998 get_last_displayed_symtab (void)
1000 if (last_displayed_sal_valid
)
1001 return last_displayed_symtab
;
1005 /* Get the line of the last sal we displayed, if it's valid. */
1008 get_last_displayed_line (void)
1010 if (last_displayed_sal_valid
)
1011 return last_displayed_line
;
1015 /* Get the last sal we displayed, if it's valid. */
1018 get_last_displayed_sal ()
1020 symtab_and_line sal
;
1022 if (last_displayed_sal_valid
)
1024 sal
.pspace
= last_displayed_pspace
;
1025 sal
.pc
= last_displayed_addr
;
1026 sal
.symtab
= last_displayed_symtab
;
1027 sal
.line
= last_displayed_line
;
1034 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1035 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1038 find_frame_funname (struct frame_info
*frame
, char **funname
,
1039 enum language
*funlang
, struct symbol
**funcp
)
1041 struct symbol
*func
;
1044 *funlang
= language_unknown
;
1048 func
= get_frame_function (frame
);
1051 /* In certain pathological cases, the symtabs give the wrong
1052 function (when we are in the first function in a file which
1053 is compiled without debugging symbols, the previous function
1054 is compiled with debugging symbols, and the "foo.o" symbol
1055 that is supposed to tell us where the file with debugging
1056 symbols ends has been truncated by ar because it is longer
1057 than 15 characters). This also occurs if the user uses asm()
1058 to create a function but not stabs for it (in a file compiled
1061 So look in the minimal symbol tables as well, and if it comes
1062 up with a larger address for the function use that instead.
1063 I don't think this can ever cause any problems; there
1064 shouldn't be any minimal symbols in the middle of a function;
1065 if this is ever changed many parts of GDB will need to be
1066 changed (and we'll create a find_pc_minimal_function or some
1069 struct bound_minimal_symbol msymbol
;
1071 /* Don't attempt to do this for inlined functions, which do not
1072 have a corresponding minimal symbol. */
1073 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1075 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1077 memset (&msymbol
, 0, sizeof (msymbol
));
1079 if (msymbol
.minsym
!= NULL
1080 && (BMSYMBOL_VALUE_ADDRESS (msymbol
)
1081 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1083 /* We also don't know anything about the function besides
1084 its address and name. */
1086 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1087 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1091 const char *print_name
= SYMBOL_PRINT_NAME (func
);
1093 *funlang
= SYMBOL_LANGUAGE (func
);
1096 if (*funlang
== language_cplus
)
1098 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1099 to display the demangled name that we already have
1100 stored in the symbol table, but we stored a version
1101 with DMGL_PARAMS turned on, and here we don't want to
1102 display parameters. So remove the parameters. */
1103 char *func_only
= cp_remove_params (print_name
);
1106 *funname
= func_only
;
1109 /* If we didn't hit the C++ case above, set *funname here.
1110 This approach is taken to avoid having to install a
1111 cleanup in case cp_remove_params can throw. */
1112 if (*funname
== NULL
)
1113 *funname
= xstrdup (print_name
);
1118 struct bound_minimal_symbol msymbol
;
1121 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1124 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1125 if (msymbol
.minsym
!= NULL
)
1127 *funname
= xstrdup (MSYMBOL_PRINT_NAME (msymbol
.minsym
));
1128 *funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1134 print_frame (struct frame_info
*frame
, int print_level
,
1135 enum print_what print_what
, int print_args
,
1136 struct symtab_and_line sal
)
1138 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1139 struct ui_out
*uiout
= current_uiout
;
1140 char *funname
= NULL
;
1141 enum language funlang
= language_unknown
;
1142 struct cleanup
*old_chain
, *list_chain
;
1143 struct value_print_options opts
;
1144 struct symbol
*func
;
1148 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1151 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1152 old_chain
= make_cleanup (xfree
, funname
);
1154 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1157 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1162 uiout
->field_fmt_int (2, ui_left
, "level",
1163 frame_relative_level (frame
));
1165 get_user_print_options (&opts
);
1166 if (opts
.addressprint
)
1168 || frame_show_address (frame
, sal
)
1169 || print_what
== LOC_AND_ADDRESS
)
1171 annotate_frame_address ();
1173 uiout
->field_core_addr ("addr", gdbarch
, pc
);
1175 uiout
->field_string ("addr", "<unavailable>");
1176 annotate_frame_address_end ();
1177 uiout
->text (" in ");
1179 annotate_frame_function_name ();
1182 fprintf_symbol_filtered (&stb
, funname
? funname
: "??",
1183 funlang
, DMGL_ANSI
);
1184 uiout
->field_stream ("func", stb
);
1185 uiout
->wrap_hint (" ");
1186 annotate_frame_args ();
1191 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1194 if (gdbarch_frame_num_args_p (gdbarch
))
1196 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1197 gdb_assert (numargs
>= 0);
1203 ui_out_emit_list
list_emitter (uiout
, "args");
1206 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1208 CATCH (e
, RETURN_MASK_ERROR
)
1213 /* FIXME: ARGS must be a list. If one argument is a string it
1214 will have " that will not be properly escaped. */
1221 const char *filename_display
;
1223 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1224 annotate_frame_source_begin ();
1225 uiout
->wrap_hint (" ");
1226 uiout
->text (" at ");
1227 annotate_frame_source_file ();
1228 uiout
->field_string ("file", filename_display
);
1229 if (uiout
->is_mi_like_p ())
1231 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1233 uiout
->field_string ("fullname", fullname
);
1235 annotate_frame_source_file_end ();
1237 annotate_frame_source_line ();
1238 uiout
->field_int ("line", sal
.line
);
1239 annotate_frame_source_end ();
1242 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1244 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1245 get_frame_pc (frame
));
1249 annotate_frame_where ();
1250 uiout
->wrap_hint (" ");
1251 uiout
->text (" from ");
1252 uiout
->field_string ("from", lib
);
1256 /* do_cleanups will call ui_out_tuple_end() for us. */
1257 do_cleanups (list_chain
);
1259 do_cleanups (old_chain
);
1263 /* Read a frame specification in whatever the appropriate format is from
1264 FRAME_EXP. Call error() if the specification is in any way invalid (so
1265 this function never returns NULL). When SELECTED_FRAME_P is non-NULL
1266 set its target to indicate that the default selected frame was used. */
1268 static struct frame_info
*
1269 parse_frame_specification (const char *frame_exp
, int *selected_frame_p
)
1272 struct value
*args
[4];
1273 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1275 if (frame_exp
== NULL
)
1283 struct cleanup
*cleanup
;
1286 /* Skip leading white space, bail of EOL. */
1287 frame_exp
= skip_spaces_const (frame_exp
);
1291 /* Parse the argument, extract it, save it. */
1293 *p
&& !ISSPACE (*p
);
1295 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1297 cleanup
= make_cleanup (xfree
, addr_string
);
1299 /* NOTE: Parse and evaluate expression, but do not use
1300 functions such as parse_and_eval_long or
1301 parse_and_eval_address to also extract the value.
1302 Instead value_as_long and value_as_address are used.
1303 This avoids problems with expressions that contain
1305 if (numargs
>= ARRAY_SIZE (args
))
1306 error (_("Too many args in frame specification"));
1307 args
[numargs
++] = parse_and_eval (addr_string
);
1309 do_cleanups (cleanup
);
1313 /* If no args, default to the selected frame. */
1316 if (selected_frame_p
!= NULL
)
1317 (*selected_frame_p
) = 1;
1318 return get_selected_frame (_("No stack."));
1321 /* None of the remaining use the selected frame. */
1322 if (selected_frame_p
!= NULL
)
1323 (*selected_frame_p
) = 0;
1325 /* Assume the single arg[0] is an integer, and try using that to
1326 select a frame relative to current. */
1329 struct frame_info
*fid
;
1330 int level
= value_as_long (args
[0]);
1332 fid
= find_relative_frame (get_current_frame (), &level
);
1334 /* find_relative_frame was successful. */
1338 /* Convert each value into a corresponding address. */
1342 for (i
= 0; i
< numargs
; i
++)
1343 addrs
[i
] = value_as_address (args
[i
]);
1346 /* Assume that the single arg[0] is an address, use that to identify
1347 a frame with a matching ID. Should this also accept stack/pc or
1348 stack/pc/special. */
1351 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1352 struct frame_info
*fid
;
1354 /* If (s)he specifies the frame with an address, he deserves
1355 what (s)he gets. Still, give the highest one that matches.
1356 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1358 for (fid
= get_current_frame ();
1360 fid
= get_prev_frame (fid
))
1362 if (frame_id_eq (id
, get_frame_id (fid
)))
1364 struct frame_info
*prev_frame
;
1368 prev_frame
= get_prev_frame (fid
);
1370 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1379 /* We couldn't identify the frame as an existing frame, but
1380 perhaps we can create one with a single argument. */
1382 return create_new_frame (addrs
[0], 0);
1383 else if (numargs
== 2)
1384 return create_new_frame (addrs
[0], addrs
[1]);
1386 error (_("Too many args in frame specification"));
1389 /* Print verbosely the selected frame or the frame at address
1390 ADDR_EXP. Absolutely all information in the frame is printed. */
1393 info_frame_command (char *addr_exp
, int from_tty
)
1395 struct frame_info
*fi
;
1396 struct symbol
*func
;
1398 struct frame_info
*calling_frame_info
;
1400 const char *funname
= 0;
1401 enum language funlang
= language_unknown
;
1402 const char *pc_regname
;
1403 int selected_frame_p
;
1404 struct gdbarch
*gdbarch
;
1405 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1408 /* Initialize it to avoid "may be used uninitialized" warning. */
1409 CORE_ADDR caller_pc
= 0;
1410 int caller_pc_p
= 0;
1412 fi
= parse_frame_specification (addr_exp
, &selected_frame_p
);
1413 gdbarch
= get_frame_arch (fi
);
1415 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1416 is not a good name. */
1417 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1418 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1419 easily not match that of the internal value returned by
1421 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1423 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1424 architectures will often have a hardware register called "pc",
1425 and that register's value, again, can easily not match
1429 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1430 func
= get_frame_function (fi
);
1431 symtab_and_line sal
= find_frame_sal (fi
);
1435 funname
= SYMBOL_PRINT_NAME (func
);
1436 funlang
= SYMBOL_LANGUAGE (func
);
1437 if (funlang
== language_cplus
)
1439 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1440 to display the demangled name that we already have
1441 stored in the symbol table, but we stored a version
1442 with DMGL_PARAMS turned on, and here we don't want to
1443 display parameters. So remove the parameters. */
1444 char *func_only
= cp_remove_params (funname
);
1448 funname
= func_only
;
1449 make_cleanup (xfree
, func_only
);
1453 else if (frame_pc_p
)
1455 struct bound_minimal_symbol msymbol
;
1457 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1458 if (msymbol
.minsym
!= NULL
)
1460 funname
= MSYMBOL_PRINT_NAME (msymbol
.minsym
);
1461 funlang
= MSYMBOL_LANGUAGE (msymbol
.minsym
);
1464 calling_frame_info
= get_prev_frame (fi
);
1466 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1468 printf_filtered (_("Stack level %d, frame at "),
1469 frame_relative_level (fi
));
1473 printf_filtered (_("Stack frame at "));
1475 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1476 printf_filtered (":\n");
1477 printf_filtered (" %s = ", pc_regname
);
1479 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1481 fputs_filtered ("<unavailable>", gdb_stdout
);
1486 printf_filtered (" in ");
1487 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1488 DMGL_ANSI
| DMGL_PARAMS
);
1492 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1494 puts_filtered ("; ");
1496 printf_filtered ("saved %s = ", pc_regname
);
1498 if (!frame_id_p (frame_unwind_caller_id (fi
)))
1499 val_print_not_saved (gdb_stdout
);
1504 caller_pc
= frame_unwind_caller_pc (fi
);
1507 CATCH (ex
, RETURN_MASK_ERROR
)
1511 case NOT_AVAILABLE_ERROR
:
1512 val_print_unavailable (gdb_stdout
);
1514 case OPTIMIZED_OUT_ERROR
:
1515 val_print_not_saved (gdb_stdout
);
1518 fprintf_filtered (gdb_stdout
, _("<error: %s>"), ex
.message
);
1526 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1527 printf_filtered ("\n");
1529 if (calling_frame_info
== NULL
)
1531 enum unwind_stop_reason reason
;
1533 reason
= get_frame_unwind_stop_reason (fi
);
1534 if (reason
!= UNWIND_NO_REASON
)
1535 printf_filtered (_(" Outermost frame: %s\n"),
1536 frame_stop_reason_string (fi
));
1538 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1539 puts_filtered (" tail call frame");
1540 else if (get_frame_type (fi
) == INLINE_FRAME
)
1541 printf_filtered (" inlined into frame %d",
1542 frame_relative_level (get_prev_frame (fi
)));
1545 printf_filtered (" called by frame at ");
1546 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1549 if (get_next_frame (fi
) && calling_frame_info
)
1550 puts_filtered (",");
1552 if (get_next_frame (fi
))
1554 printf_filtered (" caller of frame at ");
1555 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1558 if (get_next_frame (fi
) || calling_frame_info
)
1559 puts_filtered ("\n");
1562 printf_filtered (" source language %s.\n",
1563 language_str (s
->language
));
1566 /* Address of the argument list for this frame, or 0. */
1567 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1568 /* Number of args for this frame, or -1 if unknown. */
1572 printf_filtered (" Arglist at unknown address.\n");
1575 printf_filtered (" Arglist at ");
1576 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1577 printf_filtered (",");
1579 if (!gdbarch_frame_num_args_p (gdbarch
))
1582 puts_filtered (" args: ");
1586 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1587 gdb_assert (numargs
>= 0);
1589 puts_filtered (" no args.");
1590 else if (numargs
== 1)
1591 puts_filtered (" 1 arg: ");
1593 printf_filtered (" %d args: ", numargs
);
1595 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1596 puts_filtered ("\n");
1600 /* Address of the local variables for this frame, or 0. */
1601 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1604 printf_filtered (" Locals at unknown address,");
1607 printf_filtered (" Locals at ");
1608 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1609 printf_filtered (",");
1613 /* Print as much information as possible on the location of all the
1619 int sp_regnum
= gdbarch_sp_regnum (gdbarch
);
1621 /* The sp is special; what's displayed isn't the save address, but
1622 the value of the previous frame's sp. This is a legacy thing,
1623 at one stage the frame cached the previous frame's SP instead
1624 of its address, hence it was easiest to just display the cached
1628 struct value
*value
= frame_unwind_register_value (fi
, sp_regnum
);
1629 gdb_assert (value
!= NULL
);
1631 if (!value_optimized_out (value
) && value_entirely_available (value
))
1633 if (VALUE_LVAL (value
) == not_lval
)
1636 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1637 int sp_size
= register_size (gdbarch
, sp_regnum
);
1639 sp
= extract_unsigned_integer (value_contents_all (value
),
1640 sp_size
, byte_order
);
1642 printf_filtered (" Previous frame's sp is ");
1643 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1644 printf_filtered ("\n");
1646 else if (VALUE_LVAL (value
) == lval_memory
)
1648 printf_filtered (" Previous frame's sp at ");
1649 fputs_filtered (paddress (gdbarch
, value_address (value
)),
1651 printf_filtered ("\n");
1653 else if (VALUE_LVAL (value
) == lval_register
)
1655 printf_filtered (" Previous frame's sp in %s\n",
1656 gdbarch_register_name (gdbarch
,
1657 VALUE_REGNUM (value
)));
1660 release_value (value
);
1664 /* else keep quiet. */
1668 numregs
= gdbarch_num_regs (gdbarch
)
1669 + gdbarch_num_pseudo_regs (gdbarch
);
1670 for (i
= 0; i
< numregs
; i
++)
1672 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1674 enum lval_type lval
;
1680 /* Find out the location of the saved register without
1681 fetching the corresponding value. */
1682 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1683 &lval
, &addr
, &realnum
, NULL
);
1684 /* For moment, only display registers that were saved on the
1686 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1689 puts_filtered (" Saved registers:\n ");
1691 puts_filtered (",");
1693 printf_filtered (" %s at ",
1694 gdbarch_register_name (gdbarch
, i
));
1695 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1699 if (count
|| need_nl
)
1700 puts_filtered ("\n");
1703 do_cleanups (back_to
);
1706 /* Print briefly all stack frames or just the innermost COUNT_EXP
1710 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1713 struct frame_info
*fi
;
1716 struct frame_info
*trailing
;
1717 int trailing_level
, py_start
= 0, py_end
= 0;
1718 enum ext_lang_bt_status result
= EXT_LANG_BT_ERROR
;
1720 if (!target_has_stack
)
1721 error (_("No stack."));
1723 /* The following code must do two things. First, it must set the
1724 variable TRAILING to the frame from which we should start
1725 printing. Second, it must set the variable count to the number
1726 of frames which we should print, or -1 if all of them. */
1727 trailing
= get_current_frame ();
1732 count
= parse_and_eval_long (count_exp
);
1735 struct frame_info
*current
;
1741 while (current
&& count
--)
1744 current
= get_prev_frame (current
);
1747 /* Will stop when CURRENT reaches the top of the stack.
1748 TRAILING will be COUNT below it. */
1752 trailing
= get_prev_frame (trailing
);
1753 current
= get_prev_frame (current
);
1773 /* Read in symbols for all of the frames. Need to do this in a
1774 separate pass so that "Reading in symbols for xxx" messages
1775 don't screw up the appearance of the backtrace. Also if
1776 people have strong opinions against reading symbols for
1777 backtrace this may have to be an option. */
1779 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1784 pc
= get_frame_address_in_block (fi
);
1785 expand_symtab_containing_pc (pc
, find_pc_mapped_section (pc
));
1791 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1792 enum ext_lang_frame_args arg_type
;
1795 flags
|= PRINT_LOCALS
;
1797 if (!strcmp (print_frame_arguments
, "scalars"))
1798 arg_type
= CLI_SCALAR_VALUES
;
1799 else if (!strcmp (print_frame_arguments
, "all"))
1800 arg_type
= CLI_ALL_VALUES
;
1802 arg_type
= NO_VALUES
;
1804 result
= apply_ext_lang_frame_filter (get_current_frame (), flags
,
1805 arg_type
, current_uiout
,
1809 /* Run the inbuilt backtrace if there are no filters registered, or
1810 "no-filters" has been specified from the command. */
1811 if (no_filters
|| result
== EXT_LANG_BT_NO_FILTERS
)
1813 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1817 /* Don't use print_stack_frame; if an error() occurs it probably
1818 means further attempts to backtrace would fail (on the other
1819 hand, perhaps the code does or could be fixed to make sure
1820 the frame->prev field gets set to NULL in that case). */
1822 print_frame_info (fi
, 1, LOCATION
, 1, 0);
1825 struct frame_id frame_id
= get_frame_id (fi
);
1827 print_frame_local_vars (fi
, 1, gdb_stdout
);
1829 /* print_frame_local_vars invalidates FI. */
1830 fi
= frame_find_by_id (frame_id
);
1834 warning (_("Unable to restore previously selected frame."));
1839 /* Save the last frame to check for error conditions. */
1843 /* If we've stopped before the end, mention that. */
1845 printf_filtered (_("(More stack frames follow...)\n"));
1847 /* If we've run out of frames, and the reason appears to be an error
1848 condition, print it. */
1849 if (fi
== NULL
&& trailing
!= NULL
)
1851 enum unwind_stop_reason reason
;
1853 reason
= get_frame_unwind_stop_reason (trailing
);
1854 if (reason
>= UNWIND_FIRST_ERROR
)
1855 printf_filtered (_("Backtrace stopped: %s\n"),
1856 frame_stop_reason_string (trailing
));
1862 backtrace_command (char *arg
, int from_tty
)
1864 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1865 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1873 gdb_argv
built_argv (arg
);
1874 argv
= built_argv
.get ();
1876 for (i
= 0; argv
[i
]; i
++)
1880 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1881 argv
[i
][j
] = TOLOWER (argv
[i
][j
]);
1883 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1887 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1888 fulltrace_arg
= argc
;
1892 arglen
+= strlen (argv
[i
]);
1898 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1902 arg
= (char *) xmalloc (arglen
+ 1);
1903 make_cleanup (xfree
, arg
);
1905 for (i
= 0; i
< argc
; i
++)
1907 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1909 strcat (arg
, argv
[i
]);
1919 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1920 no_filters
>= 0 /* no frame-filters */, from_tty
);
1922 do_cleanups (old_chain
);
1925 /* Iterate over the local variables of a block B, calling CB with
1929 iterate_over_block_locals (const struct block
*b
,
1930 iterate_over_block_arg_local_vars_cb cb
,
1933 struct block_iterator iter
;
1936 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1938 switch (SYMBOL_CLASS (sym
))
1944 if (SYMBOL_IS_ARGUMENT (sym
))
1946 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1948 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1952 /* Ignore symbols which are not locals. */
1959 /* Same, but print labels. */
1962 /* Commented out, as the code using this function has also been
1963 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1964 was commented out in the first place. The discussion introducing
1965 this change (2007-12-04: Support lexical blocks and function bodies
1966 that occupy non-contiguous address ranges) did not explain why
1967 this change was made. */
1969 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1970 int *have_default
, struct ui_file
*stream
)
1972 struct block_iterator iter
;
1974 int values_printed
= 0;
1976 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1978 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1984 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1986 struct symtab_and_line sal
;
1987 struct value_print_options opts
;
1989 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1991 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1992 get_user_print_options (&opts
);
1993 if (opts
.addressprint
)
1995 fprintf_filtered (stream
, " ");
1996 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1999 fprintf_filtered (stream
, " in file %s, line %d\n",
2000 sal
.symtab
->filename
, sal
.line
);
2004 return values_printed
;
2008 /* Iterate over all the local variables in block B, including all its
2009 superblocks, stopping when the top-level block is reached. */
2012 iterate_over_block_local_vars (const struct block
*block
,
2013 iterate_over_block_arg_local_vars_cb cb
,
2018 iterate_over_block_locals (block
, cb
, cb_data
);
2019 /* After handling the function's top-level block, stop. Don't
2020 continue to its superblock, the block of per-file
2022 if (BLOCK_FUNCTION (block
))
2024 block
= BLOCK_SUPERBLOCK (block
);
2028 /* Data to be passed around in the calls to the locals and args
2031 struct print_variable_and_value_data
2033 struct frame_id frame_id
;
2035 struct ui_file
*stream
;
2039 /* The callback for the locals and args iterators. */
2042 do_print_variable_and_value (const char *print_name
,
2046 struct print_variable_and_value_data
*p
2047 = (struct print_variable_and_value_data
*) cb_data
;
2048 struct frame_info
*frame
;
2050 frame
= frame_find_by_id (p
->frame_id
);
2053 warning (_("Unable to restore previously selected frame."));
2057 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2059 /* print_variable_and_value invalidates FRAME. */
2062 p
->values_printed
= 1;
2065 /* Print all variables from the innermost up to the function block of FRAME.
2066 Print them with values to STREAM indented by NUM_TABS.
2068 This function will invalidate FRAME. */
2071 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2072 struct ui_file
*stream
)
2074 struct print_variable_and_value_data cb_data
;
2075 const struct block
*block
;
2077 struct gdb_exception except
= exception_none
;
2079 if (!get_frame_pc_if_available (frame
, &pc
))
2081 fprintf_filtered (stream
,
2082 _("PC unavailable, cannot determine locals.\n"));
2086 block
= get_frame_block (frame
, 0);
2089 fprintf_filtered (stream
, "No symbol table info available.\n");
2093 cb_data
.frame_id
= get_frame_id (frame
);
2094 cb_data
.num_tabs
= 4 * num_tabs
;
2095 cb_data
.stream
= stream
;
2096 cb_data
.values_printed
= 0;
2098 /* Temporarily change the selected frame to the given FRAME.
2099 This allows routines that rely on the selected frame instead
2100 of being given a frame as parameter to use the correct frame. */
2101 select_frame (frame
);
2105 iterate_over_block_local_vars (block
,
2106 do_print_variable_and_value
,
2109 CATCH (ex
, RETURN_MASK_ALL
)
2115 /* Restore the selected frame, and then rethrow if there was a problem. */
2116 select_frame (frame_find_by_id (cb_data
.frame_id
));
2117 if (except
.reason
< 0)
2118 throw_exception (except
);
2120 /* do_print_variable_and_value invalidates FRAME. */
2123 if (!cb_data
.values_printed
)
2124 fprintf_filtered (stream
, _("No locals.\n"));
2128 info_locals_command (char *args
, int from_tty
)
2130 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2134 /* Iterate over all the argument variables in block B.
2136 Returns 1 if any argument was walked; 0 otherwise. */
2139 iterate_over_block_arg_vars (const struct block
*b
,
2140 iterate_over_block_arg_local_vars_cb cb
,
2143 struct block_iterator iter
;
2144 struct symbol
*sym
, *sym2
;
2146 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2148 /* Don't worry about things which aren't arguments. */
2149 if (SYMBOL_IS_ARGUMENT (sym
))
2151 /* We have to look up the symbol because arguments can have
2152 two entries (one a parameter, one a local) and the one we
2153 want is the local, which lookup_symbol will find for us.
2154 This includes gcc1 (not gcc2) on the sparc when passing a
2155 small structure and gcc2 when the argument type is float
2156 and it is passed as a double and converted to float by
2157 the prologue (in the latter case the type of the LOC_ARG
2158 symbol is double and the type of the LOC_LOCAL symbol is
2159 float). There are also LOC_ARG/LOC_REGISTER pairs which
2160 are not combined in symbol-reading. */
2162 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2163 b
, VAR_DOMAIN
, NULL
).symbol
;
2164 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2169 /* Print all argument variables of the function of FRAME.
2170 Print them with values to STREAM.
2172 This function will invalidate FRAME. */
2175 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2177 struct print_variable_and_value_data cb_data
;
2178 struct symbol
*func
;
2181 if (!get_frame_pc_if_available (frame
, &pc
))
2183 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2187 func
= get_frame_function (frame
);
2190 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2194 cb_data
.frame_id
= get_frame_id (frame
);
2195 cb_data
.num_tabs
= 0;
2196 cb_data
.stream
= gdb_stdout
;
2197 cb_data
.values_printed
= 0;
2199 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2200 do_print_variable_and_value
, &cb_data
);
2202 /* do_print_variable_and_value invalidates FRAME. */
2205 if (!cb_data
.values_printed
)
2206 fprintf_filtered (stream
, _("No arguments.\n"));
2210 info_args_command (char *ignore
, int from_tty
)
2212 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2216 /* Select frame FRAME. Also print the stack frame and show the source
2217 if this is the tui version. */
2219 select_and_print_frame (struct frame_info
*frame
)
2221 select_frame (frame
);
2223 print_stack_frame (frame
, 1, SRC_AND_LOC
, 1);
2226 /* Return the symbol-block in which the selected frame is executing.
2227 Can return zero under various legitimate circumstances.
2229 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2230 code address within the block returned. We use this to decide
2231 which macros are in scope. */
2233 const struct block
*
2234 get_selected_block (CORE_ADDR
*addr_in_block
)
2236 if (!has_stack_frames ())
2239 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2242 /* Find a frame a certain number of levels away from FRAME.
2243 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2244 Positive means go to earlier frames (up); negative, the reverse.
2245 The int that contains the number of levels is counted toward
2246 zero as the frames for those levels are found.
2247 If the top or bottom frame is reached, that frame is returned,
2248 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2249 how much farther the original request asked to go. */
2252 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2254 /* Going up is simple: just call get_prev_frame enough times or
2255 until the initial frame is reached. */
2256 while (*level_offset_ptr
> 0)
2258 struct frame_info
*prev
= get_prev_frame (frame
);
2262 (*level_offset_ptr
)--;
2266 /* Going down is just as simple. */
2267 while (*level_offset_ptr
< 0)
2269 struct frame_info
*next
= get_next_frame (frame
);
2273 (*level_offset_ptr
)++;
2280 /* The "select_frame" command. With no argument this is a NOP.
2281 Select the frame at level LEVEL_EXP if it is a valid level.
2282 Otherwise, treat LEVEL_EXP as an address expression and select it.
2284 See parse_frame_specification for more info on proper frame
2288 select_frame_command (char *level_exp
, int from_tty
)
2290 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2292 select_frame (parse_frame_specification (level_exp
, NULL
));
2293 if (get_selected_frame_if_set () != prev_frame
)
2294 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2297 /* The "frame" command. With no argument, print the selected frame
2298 briefly. With an argument, behave like select_frame and then print
2299 the selected frame. */
2302 frame_command (char *level_exp
, int from_tty
)
2304 struct frame_info
*prev_frame
= get_selected_frame_if_set ();
2306 select_frame (parse_frame_specification (level_exp
, NULL
));
2307 if (get_selected_frame_if_set () != prev_frame
)
2308 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2310 print_selected_thread_frame (current_uiout
, USER_SELECTED_FRAME
);
2313 /* Select the frame up one or COUNT_EXP stack levels from the
2314 previously selected frame, and print it briefly. */
2317 up_silently_base (const char *count_exp
)
2319 struct frame_info
*frame
;
2323 count
= parse_and_eval_long (count_exp
);
2325 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2326 if (count
!= 0 && count_exp
== NULL
)
2327 error (_("Initial frame selected; you cannot go up."));
2328 select_frame (frame
);
2332 up_silently_command (char *count_exp
, int from_tty
)
2334 up_silently_base (count_exp
);
2338 up_command (char *count_exp
, int from_tty
)
2340 up_silently_base (count_exp
);
2341 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2344 /* Select the frame down one or COUNT_EXP stack levels from the previously
2345 selected frame, and print it briefly. */
2348 down_silently_base (const char *count_exp
)
2350 struct frame_info
*frame
;
2354 count
= -parse_and_eval_long (count_exp
);
2356 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2357 if (count
!= 0 && count_exp
== NULL
)
2359 /* We only do this if COUNT_EXP is not specified. That way
2360 "down" means to really go down (and let me know if that is
2361 impossible), but "down 9999" can be used to mean go all the
2362 way down without getting an error. */
2364 error (_("Bottom (innermost) frame selected; you cannot go down."));
2367 select_frame (frame
);
2371 down_silently_command (char *count_exp
, int from_tty
)
2373 down_silently_base (count_exp
);
2377 down_command (char *count_exp
, int from_tty
)
2379 down_silently_base (count_exp
);
2380 observer_notify_user_selected_context_changed (USER_SELECTED_FRAME
);
2384 return_command (char *retval_exp
, int from_tty
)
2386 /* Initialize it just to avoid a GCC false warning. */
2387 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2388 struct frame_info
*thisframe
;
2389 struct gdbarch
*gdbarch
;
2390 struct symbol
*thisfun
;
2391 struct value
*return_value
= NULL
;
2392 struct value
*function
= NULL
;
2393 const char *query_prefix
= "";
2395 thisframe
= get_selected_frame ("No selected frame.");
2396 thisfun
= get_frame_function (thisframe
);
2397 gdbarch
= get_frame_arch (thisframe
);
2399 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2400 error (_("Can not force return from an inlined function."));
2402 /* Compute the return value. If the computation triggers an error,
2403 let it bail. If the return type can't be handled, set
2404 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2408 expression_up retval_expr
= parse_expression (retval_exp
);
2409 struct type
*return_type
= NULL
;
2411 /* Compute the return value. Should the computation fail, this
2412 call throws an error. */
2413 return_value
= evaluate_expression (retval_expr
.get ());
2415 /* Cast return value to the return type of the function. Should
2416 the cast fail, this call throws an error. */
2417 if (thisfun
!= NULL
)
2418 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2419 if (return_type
== NULL
)
2421 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2422 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2423 error (_("Return value type not available for selected "
2425 "Please use an explicit cast of the value to return."));
2426 return_type
= value_type (return_value
);
2428 return_type
= check_typedef (return_type
);
2429 return_value
= value_cast (return_type
, return_value
);
2431 /* Make sure the value is fully evaluated. It may live in the
2432 stack frame we're about to pop. */
2433 if (value_lazy (return_value
))
2434 value_fetch_lazy (return_value
);
2436 if (thisfun
!= NULL
)
2437 function
= read_var_value (thisfun
, NULL
, thisframe
);
2439 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2440 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2441 /* If the return-type is "void", don't try to find the
2442 return-value's location. However, do still evaluate the
2443 return expression so that, even when the expression result
2444 is discarded, side effects such as "return i++" still
2446 return_value
= NULL
;
2447 else if (thisfun
!= NULL
)
2449 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2450 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2451 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2453 query_prefix
= "The location at which to store the "
2454 "function's return value is unknown.\n"
2455 "If you continue, the return value "
2456 "that you specified will be ignored.\n";
2457 return_value
= NULL
;
2462 /* Does an interactive user really want to do this? Include
2463 information, such as how well GDB can handle the return value, in
2464 the query message. */
2469 if (thisfun
== NULL
)
2470 confirmed
= query (_("%sMake selected stack frame return now? "),
2474 if (TYPE_NO_RETURN (thisfun
->type
))
2475 warning (_("Function does not return normally to caller."));
2476 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2477 SYMBOL_PRINT_NAME (thisfun
));
2480 error (_("Not confirmed"));
2483 /* Discard the selected frame and all frames inner-to it. */
2484 frame_pop (get_selected_frame (NULL
));
2486 /* Store RETURN_VALUE in the just-returned register set. */
2487 if (return_value
!= NULL
)
2489 struct type
*return_type
= value_type (return_value
);
2490 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2492 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2493 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2494 gdbarch_return_value (gdbarch
, function
, return_type
,
2495 get_current_regcache (), NULL
/*read*/,
2496 value_contents (return_value
) /*write*/);
2499 /* If we are at the end of a call dummy now, pop the dummy frame
2501 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2502 frame_pop (get_current_frame ());
2504 select_frame (get_current_frame ());
2505 /* If interactive, print the frame that is now current. */
2507 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
, 1);
2510 /* Sets the scope to input function name, provided that the function
2511 is within the current stack frame. */
2513 struct function_bounds
2515 CORE_ADDR low
, high
;
2519 func_command (char *arg
, int from_tty
)
2521 struct frame_info
*frame
;
2524 struct function_bounds
*func_bounds
= NULL
;
2529 frame
= get_current_frame ();
2530 std::vector
<symtab_and_line
> sals
2531 = decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2532 func_bounds
= XNEWVEC (struct function_bounds
, sals
.size ());
2533 struct cleanup
*cleanups
= make_cleanup (xfree
, func_bounds
);
2534 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2536 if (sals
[i
].pspace
!= current_program_space
)
2537 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2538 else if (sals
[i
].pc
== 0
2539 || find_pc_partial_function (sals
[i
].pc
, NULL
,
2540 &func_bounds
[i
].low
,
2541 &func_bounds
[i
].high
) == 0)
2543 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2549 for (size_t i
= 0; (i
< sals
.size () && !found
); i
++)
2550 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2551 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2555 frame
= find_relative_frame (frame
, &level
);
2558 while (!found
&& level
== 0);
2560 do_cleanups (cleanups
);
2563 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2564 else if (frame
!= get_selected_frame (NULL
))
2565 select_and_print_frame (frame
);
2569 _initialize_stack (void)
2571 add_com ("return", class_stack
, return_command
, _("\
2572 Make selected stack frame return to its caller.\n\
2573 Control remains in the debugger, but when you continue\n\
2574 execution will resume in the frame above the one now selected.\n\
2575 If an argument is given, it is an expression for the value to return."));
2577 add_com ("up", class_stack
, up_command
, _("\
2578 Select and print stack frame that called this one.\n\
2579 An argument says how many frames up to go."));
2580 add_com ("up-silently", class_support
, up_silently_command
, _("\
2581 Same as the `up' command, but does not print anything.\n\
2582 This is useful in command scripts."));
2584 add_com ("down", class_stack
, down_command
, _("\
2585 Select and print stack frame called by this one.\n\
2586 An argument says how many frames down to go."));
2587 add_com_alias ("do", "down", class_stack
, 1);
2588 add_com_alias ("dow", "down", class_stack
, 1);
2589 add_com ("down-silently", class_support
, down_silently_command
, _("\
2590 Same as the `down' command, but does not print anything.\n\
2591 This is useful in command scripts."));
2593 add_com ("frame", class_stack
, frame_command
, _("\
2594 Select and print a stack frame.\nWith no argument, \
2595 print the selected stack frame. (See also \"info frame\").\n\
2596 An argument specifies the frame to select.\n\
2597 It can be a stack frame number or the address of the frame.\n"));
2599 add_com_alias ("f", "frame", class_stack
, 1);
2601 add_com_suppress_notification ("select-frame", class_stack
, select_frame_command
, _("\
2602 Select a stack frame without printing anything.\n\
2603 An argument specifies the frame to select.\n\
2604 It can be a stack frame number or the address of the frame.\n"),
2605 &cli_suppress_notification
.user_selected_context
);
2607 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2608 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2609 With a negative argument, print outermost -COUNT frames.\nUse of the \
2610 'full' qualifier also prints the values of the local variables.\n\
2611 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2612 on this backtrace.\n"));
2613 add_com_alias ("bt", "backtrace", class_stack
, 0);
2615 add_com_alias ("where", "backtrace", class_alias
, 0);
2616 add_info ("stack", backtrace_command
,
2617 _("Backtrace of the stack, or innermost COUNT frames."));
2618 add_info_alias ("s", "stack", 1);
2619 add_info ("frame", info_frame_command
,
2620 _("All about selected stack frame, or frame at ADDR."));
2621 add_info_alias ("f", "frame", 1);
2622 add_info ("locals", info_locals_command
,
2623 _("Local variables of current stack frame."));
2624 add_info ("args", info_args_command
,
2625 _("Argument variables of current stack frame."));
2628 add_com ("func", class_stack
, func_command
, _("\
2629 Select the stack frame that contains <func>.\n\
2630 Usage: func <name>\n"));
2632 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2633 print_frame_arguments_choices
, &print_frame_arguments
,
2634 _("Set printing of non-scalar frame arguments"),
2635 _("Show printing of non-scalar frame arguments"),
2636 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2638 add_setshow_boolean_cmd ("frame-arguments", no_class
,
2639 &print_raw_frame_arguments
, _("\
2640 Set whether to print frame arguments in raw form."), _("\
2641 Show whether to print frame arguments in raw form."), _("\
2642 If set, frame arguments are printed in raw form, bypassing any\n\
2643 pretty-printers for that value."),
2645 &setprintrawlist
, &showprintrawlist
);
2647 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2648 &disassemble_next_line
, _("\
2649 Set whether to disassemble next source line or insn when execution stops."),
2651 Show whether to disassemble next source line or insn when execution stops."),
2653 If ON, GDB will display disassembly of the next source line, in addition\n\
2654 to displaying the source line itself. If the next source line cannot\n\
2655 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2656 will display disassembly of next instruction instead of showing the\n\
2658 If AUTO, display disassembly of next instruction only if the source line\n\
2659 cannot be displayed.\n\
2660 If OFF (which is the default), never display the disassembly of the next\n\
2663 show_disassemble_next_line
,
2664 &setlist
, &showlist
);
2665 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2667 add_setshow_enum_cmd ("entry-values", class_stack
,
2668 print_entry_values_choices
, &print_entry_values
,
2669 _("Set printing of function arguments at function "
2671 _("Show printing of function arguments at function "
2674 GDB can sometimes determine the values of function arguments at entry,\n\
2675 in addition to their current values. This option tells GDB whether\n\
2676 to print the current value, the value at entry (marked as val@entry),\n\
2677 or both. Note that one or both of these values may be <optimized out>."),
2678 NULL
, NULL
, &setprintlist
, &showprintlist
);