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"
50 #include "gdb_assert.h"
52 #include "gdb_string.h"
57 void (*deprecated_selected_frame_level_changed_hook
) (int);
59 /* The possible choices of "set print frame-arguments", and the value
62 static const char *const print_frame_arguments_choices
[] =
63 {"all", "scalars", "none", NULL
};
64 static const char *print_frame_arguments
= "scalars";
66 /* The possible choices of "set print entry-values", and the value
69 const char print_entry_values_no
[] = "no";
70 const char print_entry_values_only
[] = "only";
71 const char print_entry_values_preferred
[] = "preferred";
72 const char print_entry_values_if_needed
[] = "if-needed";
73 const char print_entry_values_both
[] = "both";
74 const char print_entry_values_compact
[] = "compact";
75 const char print_entry_values_default
[] = "default";
76 static const char *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
;
145 /* Show or print a stack frame FRAME briefly. The output is format
146 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
147 relative level, function name, argument list, and file name and
148 line number. If the frame's PC is not at the beginning of the
149 source line, the actual PC is printed at the beginning. */
152 print_stack_frame (struct frame_info
*frame
, int print_level
,
153 enum print_what print_what
)
155 volatile struct gdb_exception e
;
157 /* For mi, alway print location and address. */
158 if (ui_out_is_mi_like_p (current_uiout
))
159 print_what
= LOC_AND_ADDRESS
;
161 TRY_CATCH (e
, RETURN_MASK_ERROR
)
163 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
165 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
166 set_current_sal_from_frame (frame
, center
);
170 /* Print nameless arguments of frame FRAME on STREAM, where START is
171 the offset of the first nameless argument, and NUM is the number of
172 nameless arguments to print. FIRST is nonzero if this is the first
173 argument (not just the first nameless argument). */
176 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
177 int first
, struct ui_file
*stream
)
179 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
180 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
185 for (i
= 0; i
< num
; i
++)
188 argsaddr
= get_frame_args_address (frame
);
191 arg_value
= read_memory_integer (argsaddr
+ start
,
192 sizeof (int), byte_order
);
194 fprintf_filtered (stream
, ", ");
195 fprintf_filtered (stream
, "%ld", arg_value
);
197 start
+= sizeof (int);
201 /* Print single argument of inferior function. ARG must be already
204 Errors are printed as if they would be the parameter value. Use zeroed ARG
205 iff it should not be printed accoring to user settings. */
208 print_frame_arg (const struct frame_arg
*arg
)
210 struct ui_out
*uiout
= current_uiout
;
211 volatile struct gdb_exception except
;
212 struct cleanup
*old_chain
;
215 stb
= mem_fileopen ();
216 old_chain
= make_cleanup_ui_file_delete (stb
);
218 gdb_assert (!arg
->val
|| !arg
->error
);
219 gdb_assert (arg
->entry_kind
== print_entry_values_no
220 || arg
->entry_kind
== print_entry_values_only
221 || (!ui_out_is_mi_like_p (uiout
)
222 && arg
->entry_kind
== print_entry_values_compact
));
224 annotate_arg_begin ();
226 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
227 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
228 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
229 if (arg
->entry_kind
== print_entry_values_compact
)
231 /* It is OK to provide invalid MI-like stream as with
232 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
233 fputs_filtered ("=", stb
);
235 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
236 SYMBOL_LANGUAGE (arg
->sym
),
237 DMGL_PARAMS
| DMGL_ANSI
);
239 if (arg
->entry_kind
== print_entry_values_only
240 || arg
->entry_kind
== print_entry_values_compact
)
241 fputs_filtered ("@entry", stb
);
242 ui_out_field_stream (uiout
, "name", stb
);
243 annotate_arg_name_end ();
244 ui_out_text (uiout
, "=");
246 if (!arg
->val
&& !arg
->error
)
247 ui_out_text (uiout
, "...");
251 except
.message
= arg
->error
;
254 /* TRY_CATCH has two statements, wrap it in a block. */
256 TRY_CATCH (except
, RETURN_MASK_ERROR
)
258 const struct language_defn
*language
;
259 struct value_print_options opts
;
261 /* Avoid value_print because it will deref ref parameters. We
262 just want to print their addresses. Print ??? for args whose
263 address we do not know. We pass 2 as "recurse" to val_print
264 because our standard indentation here is 4 spaces, and
265 val_print indents 2 for each recurse. */
267 annotate_arg_value (value_type (arg
->val
));
269 /* Use the appropriate language to display our symbol, unless the
270 user forced the language to a specific language. */
271 if (language_mode
== language_mode_auto
)
272 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
274 language
= current_language
;
276 get_raw_print_options (&opts
);
279 /* True in "summary" mode, false otherwise. */
280 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
282 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
286 fprintf_filtered (stb
, _("<error reading variable: %s>"),
290 ui_out_field_stream (uiout
, "value", stb
);
292 /* Also invoke ui_out_tuple_end. */
293 do_cleanups (old_chain
);
298 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
299 responsible for xfree of ARGP->ERROR. This function never throws an
303 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
304 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
306 struct value
*val
= NULL
, *entryval
= NULL
;
307 char *val_error
= NULL
, *entryval_error
= NULL
;
309 volatile struct gdb_exception except
;
311 if (print_entry_values
!= print_entry_values_only
312 && print_entry_values
!= print_entry_values_preferred
)
314 TRY_CATCH (except
, RETURN_MASK_ERROR
)
316 val
= read_var_value (sym
, frame
);
320 val_error
= alloca (strlen (except
.message
) + 1);
321 strcpy (val_error
, except
.message
);
325 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
326 && print_entry_values
!= print_entry_values_no
327 && (print_entry_values
!= print_entry_values_if_needed
328 || !val
|| value_optimized_out (val
)))
330 TRY_CATCH (except
, RETURN_MASK_ERROR
)
332 const struct symbol_computed_ops
*ops
;
334 ops
= SYMBOL_COMPUTED_OPS (sym
);
335 entryval
= ops
->read_variable_at_entry (sym
, frame
);
339 entryval_error
= alloca (strlen (except
.message
) + 1);
340 strcpy (entryval_error
, except
.message
);
343 if (except
.error
== NO_ENTRY_VALUE_ERROR
344 || (entryval
&& value_optimized_out (entryval
)))
347 entryval_error
= NULL
;
350 if (print_entry_values
== print_entry_values_compact
351 || print_entry_values
== print_entry_values_default
)
353 /* For MI do not try to use print_entry_values_compact for ARGP. */
355 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
357 struct type
*type
= value_type (val
);
359 if (!value_optimized_out (val
) && value_lazy (val
))
360 value_fetch_lazy (val
);
361 if (!value_optimized_out (val
) && value_lazy (entryval
))
362 value_fetch_lazy (entryval
);
363 if (!value_optimized_out (val
)
364 && value_available_contents_eq (val
, 0, entryval
, 0,
367 /* Initialize it just to avoid a GCC false warning. */
368 struct value
*val_deref
= NULL
, *entryval_deref
;
370 /* DW_AT_GNU_call_site_value does match with the current
371 value. If it is a reference still try to verify if
372 dereferenced DW_AT_GNU_call_site_data_value does not
375 TRY_CATCH (except
, RETURN_MASK_ERROR
)
377 struct type
*type_deref
;
379 val_deref
= coerce_ref (val
);
380 if (value_lazy (val_deref
))
381 value_fetch_lazy (val_deref
);
382 type_deref
= value_type (val_deref
);
384 entryval_deref
= coerce_ref (entryval
);
385 if (value_lazy (entryval_deref
))
386 value_fetch_lazy (entryval_deref
);
388 /* If the reference addresses match but dereferenced
389 content does not match print them. */
391 && value_available_contents_eq (val_deref
, 0,
393 TYPE_LENGTH (type_deref
)))
397 /* Value was not a reference; and its content matches. */
398 if (val
== val_deref
)
400 /* If the dereferenced content could not be fetched do not
402 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
404 else if (except
.message
)
406 entryval_error
= alloca (strlen (except
.message
) + 1);
407 strcpy (entryval_error
, except
.message
);
415 /* Try to remove possibly duplicate error message for ENTRYARGP even
418 if (val_error
&& entryval_error
419 && strcmp (val_error
, entryval_error
) == 0)
421 entryval_error
= NULL
;
423 /* Do not se VAL_EQUAL as the same error message may be shown for
424 the entry value even if no entry values are present in the
430 if (entryval
== NULL
)
432 if (print_entry_values
== print_entry_values_preferred
)
434 TRY_CATCH (except
, RETURN_MASK_ERROR
)
436 val
= read_var_value (sym
, frame
);
440 val_error
= alloca (strlen (except
.message
) + 1);
441 strcpy (val_error
, except
.message
);
444 if (print_entry_values
== print_entry_values_only
445 || print_entry_values
== print_entry_values_both
446 || (print_entry_values
== print_entry_values_preferred
447 && (!val
|| value_optimized_out (val
))))
448 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
450 if ((print_entry_values
== print_entry_values_compact
451 || print_entry_values
== print_entry_values_if_needed
452 || print_entry_values
== print_entry_values_preferred
)
453 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
461 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
462 if (!val
&& !val_error
)
463 argp
->entry_kind
= print_entry_values_only
;
464 else if ((print_entry_values
== print_entry_values_compact
465 || print_entry_values
== print_entry_values_default
) && val_equal
)
467 argp
->entry_kind
= print_entry_values_compact
;
468 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
471 argp
->entry_kind
= print_entry_values_no
;
473 entryargp
->sym
= sym
;
474 entryargp
->val
= entryval
;
475 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
476 if (!entryval
&& !entryval_error
)
477 entryargp
->entry_kind
= print_entry_values_no
;
479 entryargp
->entry_kind
= print_entry_values_only
;
482 /* Print the arguments of frame FRAME on STREAM, given the function
483 FUNC running in that frame (as a symbol), where NUM is the number
484 of arguments according to the stack frame (or -1 if the number of
485 arguments is unknown). */
487 /* Note that currently the "number of arguments according to the
488 stack frame" is only known on VAX where i refers to the "number of
489 ints of arguments according to the stack frame". */
492 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
493 int num
, struct ui_file
*stream
)
495 struct ui_out
*uiout
= current_uiout
;
497 /* Offset of next stack argument beyond the one we have seen that is
498 at the highest offset, or -1 if we haven't come to a stack
500 long highest_offset
= -1;
501 /* Number of ints of arguments that we have printed so far. */
502 int args_printed
= 0;
503 struct cleanup
*old_chain
;
505 /* True if we should print arguments, false otherwise. */
506 int print_args
= strcmp (print_frame_arguments
, "none");
508 stb
= mem_fileopen ();
509 old_chain
= make_cleanup_ui_file_delete (stb
);
513 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
514 struct block_iterator iter
;
517 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
519 struct frame_arg arg
, entryarg
;
523 /* Keep track of the highest stack argument offset seen, and
524 skip over any kinds of symbols we don't care about. */
526 if (!SYMBOL_IS_ARGUMENT (sym
))
529 switch (SYMBOL_CLASS (sym
))
534 long current_offset
= SYMBOL_VALUE (sym
);
535 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
537 /* Compute address of next argument by adding the size of
538 this argument and rounding to an int boundary. */
540 ((current_offset
+ arg_size
+ sizeof (int) - 1)
541 & ~(sizeof (int) - 1));
543 /* If this is the highest offset seen yet, set
545 if (highest_offset
== -1
546 || (current_offset
> highest_offset
))
547 highest_offset
= current_offset
;
549 /* Add the number of ints we're about to print to
551 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
554 /* We care about types of symbols, but don't need to
555 keep track of stack offsets in them. */
557 case LOC_REGPARM_ADDR
:
559 case LOC_OPTIMIZED_OUT
:
564 /* We have to look up the symbol because arguments can have
565 two entries (one a parameter, one a local) and the one we
566 want is the local, which lookup_symbol will find for us.
567 This includes gcc1 (not gcc2) on SPARC when passing a
568 small structure and gcc2 when the argument type is float
569 and it is passed as a double and converted to float by
570 the prologue (in the latter case the type of the LOC_ARG
571 symbol is double and the type of the LOC_LOCAL symbol is
573 /* But if the parameter name is null, don't try it. Null
574 parameter names occur on the RS/6000, for traceback
575 tables. FIXME, should we even print them? */
577 if (*SYMBOL_LINKAGE_NAME (sym
))
581 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
582 b
, VAR_DOMAIN
, NULL
);
583 gdb_assert (nsym
!= NULL
);
584 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
585 && !SYMBOL_IS_ARGUMENT (nsym
))
587 /* There is a LOC_ARG/LOC_REGISTER pair. This means
588 that it was passed on the stack and loaded into a
589 register, or passed in a register and stored in a
590 stack slot. GDB 3.x used the LOC_ARG; GDB
591 4.0-4.11 used the LOC_REGISTER.
593 Reasons for using the LOC_ARG:
595 (1) Because find_saved_registers may be slow for
598 (2) Because registers are often re-used and stack
599 slots rarely (never?) are. Therefore using
600 the stack slot is much less likely to print
603 Reasons why we might want to use the LOC_REGISTER:
605 (1) So that the backtrace prints the same value
606 as "print foo". I see no compelling reason
607 why this needs to be the case; having the
608 backtrace print the value which was passed
609 in, and "print foo" print the value as
610 modified within the called function, makes
613 Additional note: It might be nice if "info args"
614 displayed both values.
616 One more note: There is a case with SPARC
617 structure passing where we need to use the
618 LOC_REGISTER, but this is dealt with by creating
619 a single LOC_REGPARM in symbol reading. */
621 /* Leave sym (the LOC_ARG) alone. */
628 /* Print the current arg. */
630 ui_out_text (uiout
, ", ");
631 ui_out_wrap_hint (uiout
, " ");
635 memset (&arg
, 0, sizeof (arg
));
637 arg
.entry_kind
= print_entry_values_no
;
638 memset (&entryarg
, 0, sizeof (entryarg
));
640 entryarg
.entry_kind
= print_entry_values_no
;
643 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
645 if (arg
.entry_kind
!= print_entry_values_only
)
646 print_frame_arg (&arg
);
648 if (entryarg
.entry_kind
!= print_entry_values_no
)
650 if (arg
.entry_kind
!= print_entry_values_only
)
652 ui_out_text (uiout
, ", ");
653 ui_out_wrap_hint (uiout
, " ");
656 print_frame_arg (&entryarg
);
660 xfree (entryarg
.error
);
666 /* Don't print nameless args in situations where we don't know
667 enough about the stack to find them. */
672 if (highest_offset
== -1)
673 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
675 start
= highest_offset
;
677 print_frame_nameless_args (frame
, start
, num
- args_printed
,
681 do_cleanups (old_chain
);
684 /* Set the current source and line to the location given by frame
685 FRAME, if possible. When CENTER is true, adjust so the relevant
686 line is in the center of the next 'list'. */
689 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
691 struct symtab_and_line sal
;
693 find_frame_sal (frame
, &sal
);
697 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
698 set_current_source_symtab_and_line (&sal
);
702 /* If ON, GDB will display disassembly of the next source line when
703 execution of the program being debugged stops.
704 If AUTO (which is the default), or there's no line info to determine
705 the source line of the next instruction, display disassembly of next
706 instruction instead. */
708 static enum auto_boolean disassemble_next_line
;
711 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
712 struct cmd_list_element
*c
,
715 fprintf_filtered (file
,
716 _("Debugger's willingness to use "
717 "disassemble-next-line is %s.\n"),
721 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
722 because it will be broken by filter sometime. */
725 do_gdb_disassembly (struct gdbarch
*gdbarch
,
726 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
728 volatile struct gdb_exception exception
;
730 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
732 gdb_disassembly (gdbarch
, current_uiout
, 0,
733 DISASSEMBLY_RAW_INSN
, how_many
,
736 if (exception
.reason
< 0)
738 /* If an exception was thrown while doing the disassembly, print
739 the error message, to give the user a clue of what happened. */
740 exception_print (gdb_stderr
, exception
);
744 /* Print information about frame FRAME. The output is format according
745 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
748 SRC_LINE: Print only source line.
749 LOCATION: Print only location.
750 LOC_AND_SRC: Print location and source line.
752 Used in "where" output, and to emit breakpoint or step
756 print_frame_info (struct frame_info
*frame
, int print_level
,
757 enum print_what print_what
, int print_args
)
759 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
760 struct symtab_and_line sal
;
763 struct ui_out
*uiout
= current_uiout
;
765 if (get_frame_type (frame
) == DUMMY_FRAME
766 || get_frame_type (frame
) == SIGTRAMP_FRAME
767 || get_frame_type (frame
) == ARCH_FRAME
)
769 struct cleanup
*uiout_cleanup
770 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
772 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
773 gdbarch
, get_frame_pc (frame
));
775 /* Do this regardless of SOURCE because we don't have any source
776 to list for this frame. */
779 ui_out_text (uiout
, "#");
780 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
781 frame_relative_level (frame
));
783 if (ui_out_is_mi_like_p (uiout
))
785 annotate_frame_address ();
786 ui_out_field_core_addr (uiout
, "addr",
787 gdbarch
, get_frame_pc (frame
));
788 annotate_frame_address_end ();
791 if (get_frame_type (frame
) == DUMMY_FRAME
)
793 annotate_function_call ();
794 ui_out_field_string (uiout
, "func", "<function called from gdb>");
796 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
798 annotate_signal_handler_caller ();
799 ui_out_field_string (uiout
, "func", "<signal handler called>");
801 else if (get_frame_type (frame
) == ARCH_FRAME
)
803 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
805 ui_out_text (uiout
, "\n");
806 annotate_frame_end ();
808 do_cleanups (uiout_cleanup
);
812 /* If FRAME is not the innermost frame, that normally means that
813 FRAME->pc points to *after* the call instruction, and we want to
814 get the line containing the call, never the next line. But if
815 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
816 next frame was not entered as the result of a call, and we want
817 to get the line containing FRAME->pc. */
818 find_frame_sal (frame
, &sal
);
820 location_print
= (print_what
== LOCATION
821 || print_what
== LOC_AND_ADDRESS
822 || print_what
== SRC_AND_LOC
);
824 if (location_print
|| !sal
.symtab
)
825 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
827 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
829 /* If disassemble-next-line is set to auto or on and doesn't have
830 the line debug messages for $pc, output the next instruction. */
831 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
832 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
833 && source_print
&& !sal
.symtab
)
834 do_gdb_disassembly (get_frame_arch (frame
), 1,
835 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
837 if (source_print
&& sal
.symtab
)
840 int mid_statement
= ((print_what
== SRC_LINE
)
841 && frame_show_address (frame
, sal
));
843 if (annotation_level
)
844 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
845 get_frame_pc (frame
));
848 if (deprecated_print_frame_info_listing_hook
)
849 deprecated_print_frame_info_listing_hook (sal
.symtab
,
854 struct value_print_options opts
;
856 get_user_print_options (&opts
);
857 /* We used to do this earlier, but that is clearly
858 wrong. This function is used by many different
859 parts of gdb, including normal_stop in infrun.c,
860 which uses this to print out the current PC
861 when we stepi/nexti into the middle of a source
862 line. Only the command line really wants this
863 behavior. Other UIs probably would like the
864 ability to decide for themselves if it is desired. */
865 if (opts
.addressprint
&& mid_statement
)
867 ui_out_field_core_addr (uiout
, "addr",
868 gdbarch
, get_frame_pc (frame
));
869 ui_out_text (uiout
, "\t");
872 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
876 /* If disassemble-next-line is set to on and there is line debug
877 messages, output assembly codes for next line. */
878 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
879 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
882 if (print_what
!= LOCATION
)
886 if (get_frame_pc_if_available (frame
, &pc
))
887 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
889 set_last_displayed_sal (0, 0, 0, 0, 0);
892 annotate_frame_end ();
894 gdb_flush (gdb_stdout
);
897 /* Remember the last symtab and line we displayed, which we use e.g.
898 * as the place to put a breakpoint when the `break' command is
899 * invoked with no arguments. */
902 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
903 CORE_ADDR addr
, struct symtab
*symtab
,
906 last_displayed_sal_valid
= valid
;
907 last_displayed_pspace
= pspace
;
908 last_displayed_addr
= addr
;
909 last_displayed_symtab
= symtab
;
910 last_displayed_line
= line
;
911 if (valid
&& pspace
== NULL
)
913 clear_last_displayed_sal ();
914 internal_error (__FILE__
, __LINE__
,
915 _("Trying to set NULL pspace."));
919 /* Forget the last sal we displayed. */
922 clear_last_displayed_sal (void)
924 last_displayed_sal_valid
= 0;
925 last_displayed_pspace
= 0;
926 last_displayed_addr
= 0;
927 last_displayed_symtab
= 0;
928 last_displayed_line
= 0;
931 /* Is our record of the last sal we displayed valid? If not,
932 * the get_last_displayed_* functions will return NULL or 0, as
936 last_displayed_sal_is_valid (void)
938 return last_displayed_sal_valid
;
941 /* Get the pspace of the last sal we displayed, if it's valid. */
943 struct program_space
*
944 get_last_displayed_pspace (void)
946 if (last_displayed_sal_valid
)
947 return last_displayed_pspace
;
951 /* Get the address of the last sal we displayed, if it's valid. */
954 get_last_displayed_addr (void)
956 if (last_displayed_sal_valid
)
957 return last_displayed_addr
;
961 /* Get the symtab of the last sal we displayed, if it's valid. */
964 get_last_displayed_symtab (void)
966 if (last_displayed_sal_valid
)
967 return last_displayed_symtab
;
971 /* Get the line of the last sal we displayed, if it's valid. */
974 get_last_displayed_line (void)
976 if (last_displayed_sal_valid
)
977 return last_displayed_line
;
981 /* Get the last sal we displayed, if it's valid. */
984 get_last_displayed_sal (struct symtab_and_line
*sal
)
986 if (last_displayed_sal_valid
)
988 sal
->pspace
= last_displayed_pspace
;
989 sal
->pc
= last_displayed_addr
;
990 sal
->symtab
= last_displayed_symtab
;
991 sal
->line
= last_displayed_line
;
1003 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1004 corresponding to FRAME. */
1007 find_frame_funname (struct frame_info
*frame
, const char **funname
,
1008 enum language
*funlang
, struct symbol
**funcp
)
1010 struct symbol
*func
;
1013 *funlang
= language_unknown
;
1017 func
= get_frame_function (frame
);
1020 /* In certain pathological cases, the symtabs give the wrong
1021 function (when we are in the first function in a file which
1022 is compiled without debugging symbols, the previous function
1023 is compiled with debugging symbols, and the "foo.o" symbol
1024 that is supposed to tell us where the file with debugging
1025 symbols ends has been truncated by ar because it is longer
1026 than 15 characters). This also occurs if the user uses asm()
1027 to create a function but not stabs for it (in a file compiled
1030 So look in the minimal symbol tables as well, and if it comes
1031 up with a larger address for the function use that instead.
1032 I don't think this can ever cause any problems; there
1033 shouldn't be any minimal symbols in the middle of a function;
1034 if this is ever changed many parts of GDB will need to be
1035 changed (and we'll create a find_pc_minimal_function or some
1038 struct minimal_symbol
*msymbol
= NULL
;
1040 /* Don't attempt to do this for inlined functions, which do not
1041 have a corresponding minimal symbol. */
1042 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1044 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1047 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1048 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1050 /* We also don't know anything about the function besides
1051 its address and name. */
1053 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1054 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1058 *funname
= SYMBOL_PRINT_NAME (func
);
1059 *funlang
= SYMBOL_LANGUAGE (func
);
1062 if (*funlang
== language_cplus
)
1064 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1065 to display the demangled name that we already have
1066 stored in the symbol table, but we stored a version
1067 with DMGL_PARAMS turned on, and here we don't want to
1068 display parameters. So remove the parameters. */
1069 char *func_only
= cp_remove_params (*funname
);
1073 *funname
= func_only
;
1074 make_cleanup (xfree
, func_only
);
1081 struct minimal_symbol
*msymbol
;
1084 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1087 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1088 if (msymbol
!= NULL
)
1090 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1091 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1097 print_frame (struct frame_info
*frame
, int print_level
,
1098 enum print_what print_what
, int print_args
,
1099 struct symtab_and_line sal
)
1101 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1102 struct ui_out
*uiout
= current_uiout
;
1103 const char *funname
= NULL
;
1104 enum language funlang
= language_unknown
;
1105 struct ui_file
*stb
;
1106 struct cleanup
*old_chain
, *list_chain
;
1107 struct value_print_options opts
;
1108 struct symbol
*func
;
1112 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1114 stb
= mem_fileopen ();
1115 old_chain
= make_cleanup_ui_file_delete (stb
);
1117 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1119 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1122 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1126 ui_out_text (uiout
, "#");
1127 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1128 frame_relative_level (frame
));
1130 get_user_print_options (&opts
);
1131 if (opts
.addressprint
)
1133 || frame_show_address (frame
, sal
)
1134 || print_what
== LOC_AND_ADDRESS
)
1136 annotate_frame_address ();
1138 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1140 ui_out_field_string (uiout
, "addr", "<unavailable>");
1141 annotate_frame_address_end ();
1142 ui_out_text (uiout
, " in ");
1144 annotate_frame_function_name ();
1145 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1146 funlang
, DMGL_ANSI
);
1147 ui_out_field_stream (uiout
, "func", stb
);
1148 ui_out_wrap_hint (uiout
, " ");
1149 annotate_frame_args ();
1151 ui_out_text (uiout
, " (");
1154 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1156 struct cleanup
*args_list_chain
;
1157 volatile struct gdb_exception e
;
1159 if (gdbarch_frame_num_args_p (gdbarch
))
1161 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1162 gdb_assert (numargs
>= 0);
1167 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1168 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1170 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1172 /* FIXME: ARGS must be a list. If one argument is a string it
1173 will have " that will not be properly escaped. */
1174 /* Invoke ui_out_tuple_end. */
1175 do_cleanups (args_list_chain
);
1178 ui_out_text (uiout
, ")");
1181 annotate_frame_source_begin ();
1182 ui_out_wrap_hint (uiout
, " ");
1183 ui_out_text (uiout
, " at ");
1184 annotate_frame_source_file ();
1185 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1186 if (ui_out_is_mi_like_p (uiout
))
1188 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1190 ui_out_field_string (uiout
, "fullname", fullname
);
1192 annotate_frame_source_file_end ();
1193 ui_out_text (uiout
, ":");
1194 annotate_frame_source_line ();
1195 ui_out_field_int (uiout
, "line", sal
.line
);
1196 annotate_frame_source_end ();
1199 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1202 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1204 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1205 get_frame_pc (frame
));
1209 annotate_frame_where ();
1210 ui_out_wrap_hint (uiout
, " ");
1211 ui_out_text (uiout
, " from ");
1212 ui_out_field_string (uiout
, "from", lib
);
1216 /* do_cleanups will call ui_out_tuple_end() for us. */
1217 do_cleanups (list_chain
);
1218 ui_out_text (uiout
, "\n");
1219 do_cleanups (old_chain
);
1223 /* Read a frame specification in whatever the appropriate format is
1224 from FRAME_EXP. Call error(), printing MESSAGE, if the
1225 specification is in any way invalid (so this function never returns
1226 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1227 the default selected frame was used. */
1229 static struct frame_info
*
1230 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1231 int *selected_frame_p
)
1234 struct value
*args
[4];
1235 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1237 if (frame_exp
== NULL
)
1245 struct cleanup
*cleanup
;
1248 /* Skip leading white space, bail of EOL. */
1249 while (isspace (*frame_exp
))
1254 /* Parse the argument, extract it, save it. */
1256 *p
&& !isspace (*p
);
1258 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1260 cleanup
= make_cleanup (xfree
, addr_string
);
1262 /* NOTE: Parse and evaluate expression, but do not use
1263 functions such as parse_and_eval_long or
1264 parse_and_eval_address to also extract the value.
1265 Instead value_as_long and value_as_address are used.
1266 This avoids problems with expressions that contain
1268 if (numargs
>= ARRAY_SIZE (args
))
1269 error (_("Too many args in frame specification"));
1270 args
[numargs
++] = parse_and_eval (addr_string
);
1272 do_cleanups (cleanup
);
1276 /* If no args, default to the selected frame. */
1279 if (selected_frame_p
!= NULL
)
1280 (*selected_frame_p
) = 1;
1281 return get_selected_frame (message
);
1284 /* None of the remaining use the selected frame. */
1285 if (selected_frame_p
!= NULL
)
1286 (*selected_frame_p
) = 0;
1288 /* Assume the single arg[0] is an integer, and try using that to
1289 select a frame relative to current. */
1292 struct frame_info
*fid
;
1293 int level
= value_as_long (args
[0]);
1295 fid
= find_relative_frame (get_current_frame (), &level
);
1297 /* find_relative_frame was successful. */
1301 /* Convert each value into a corresponding address. */
1305 for (i
= 0; i
< numargs
; i
++)
1306 addrs
[i
] = value_as_address (args
[i
]);
1309 /* Assume that the single arg[0] is an address, use that to identify
1310 a frame with a matching ID. Should this also accept stack/pc or
1311 stack/pc/special. */
1314 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1315 struct frame_info
*fid
;
1317 /* If (s)he specifies the frame with an address, he deserves
1318 what (s)he gets. Still, give the highest one that matches.
1319 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1321 for (fid
= get_current_frame ();
1323 fid
= get_prev_frame (fid
))
1325 if (frame_id_eq (id
, get_frame_id (fid
)))
1327 struct frame_info
*prev_frame
;
1331 prev_frame
= get_prev_frame (fid
);
1333 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1342 /* We couldn't identify the frame as an existing frame, but
1343 perhaps we can create one with a single argument. */
1345 return create_new_frame (addrs
[0], 0);
1346 else if (numargs
== 2)
1347 return create_new_frame (addrs
[0], addrs
[1]);
1349 error (_("Too many args in frame specification"));
1352 static struct frame_info
*
1353 parse_frame_specification (char *frame_exp
)
1355 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1358 /* Print verbosely the selected frame or the frame at address
1359 ADDR_EXP. Absolutely all information in the frame is printed. */
1362 frame_info (char *addr_exp
, int from_tty
)
1364 struct frame_info
*fi
;
1365 struct symtab_and_line sal
;
1366 struct symbol
*func
;
1368 struct frame_info
*calling_frame_info
;
1370 const char *funname
= 0;
1371 enum language funlang
= language_unknown
;
1372 const char *pc_regname
;
1373 int selected_frame_p
;
1374 struct gdbarch
*gdbarch
;
1375 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1378 CORE_ADDR caller_pc
;
1380 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1381 gdbarch
= get_frame_arch (fi
);
1383 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1384 is not a good name. */
1385 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1386 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1387 easily not match that of the internal value returned by
1389 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1391 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1392 architectures will often have a hardware register called "pc",
1393 and that register's value, again, can easily not match
1397 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1398 find_frame_sal (fi
, &sal
);
1399 func
= get_frame_function (fi
);
1403 funname
= SYMBOL_PRINT_NAME (func
);
1404 funlang
= SYMBOL_LANGUAGE (func
);
1405 if (funlang
== language_cplus
)
1407 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1408 to display the demangled name that we already have
1409 stored in the symbol table, but we stored a version
1410 with DMGL_PARAMS turned on, and here we don't want to
1411 display parameters. So remove the parameters. */
1412 char *func_only
= cp_remove_params (funname
);
1416 funname
= func_only
;
1417 make_cleanup (xfree
, func_only
);
1421 else if (frame_pc_p
)
1423 struct minimal_symbol
*msymbol
;
1425 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1426 if (msymbol
!= NULL
)
1428 funname
= SYMBOL_PRINT_NAME (msymbol
);
1429 funlang
= SYMBOL_LANGUAGE (msymbol
);
1432 calling_frame_info
= get_prev_frame (fi
);
1434 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1436 printf_filtered (_("Stack level %d, frame at "),
1437 frame_relative_level (fi
));
1441 printf_filtered (_("Stack frame at "));
1443 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1444 printf_filtered (":\n");
1445 printf_filtered (" %s = ", pc_regname
);
1447 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1449 fputs_filtered ("<unavailable>", gdb_stdout
);
1454 printf_filtered (" in ");
1455 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1456 DMGL_ANSI
| DMGL_PARAMS
);
1460 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1461 puts_filtered ("; ");
1463 printf_filtered ("saved %s ", pc_regname
);
1464 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1465 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1467 fputs_filtered ("<unavailable>", gdb_stdout
);
1468 printf_filtered ("\n");
1470 if (calling_frame_info
== NULL
)
1472 enum unwind_stop_reason reason
;
1474 reason
= get_frame_unwind_stop_reason (fi
);
1475 if (reason
!= UNWIND_NO_REASON
)
1476 printf_filtered (_(" Outermost frame: %s\n"),
1477 frame_stop_reason_string (reason
));
1479 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1480 puts_filtered (" tail call frame");
1481 else if (get_frame_type (fi
) == INLINE_FRAME
)
1482 printf_filtered (" inlined into frame %d",
1483 frame_relative_level (get_prev_frame (fi
)));
1486 printf_filtered (" called by frame at ");
1487 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1490 if (get_next_frame (fi
) && calling_frame_info
)
1491 puts_filtered (",");
1493 if (get_next_frame (fi
))
1495 printf_filtered (" caller of frame at ");
1496 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1499 if (get_next_frame (fi
) || calling_frame_info
)
1500 puts_filtered ("\n");
1503 printf_filtered (" source language %s.\n",
1504 language_str (s
->language
));
1507 /* Address of the argument list for this frame, or 0. */
1508 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1509 /* Number of args for this frame, or -1 if unknown. */
1513 printf_filtered (" Arglist at unknown address.\n");
1516 printf_filtered (" Arglist at ");
1517 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1518 printf_filtered (",");
1520 if (!gdbarch_frame_num_args_p (gdbarch
))
1523 puts_filtered (" args: ");
1527 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1528 gdb_assert (numargs
>= 0);
1530 puts_filtered (" no args.");
1531 else if (numargs
== 1)
1532 puts_filtered (" 1 arg: ");
1534 printf_filtered (" %d args: ", numargs
);
1536 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1537 puts_filtered ("\n");
1541 /* Address of the local variables for this frame, or 0. */
1542 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1545 printf_filtered (" Locals at unknown address,");
1548 printf_filtered (" Locals at ");
1549 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1550 printf_filtered (",");
1554 /* Print as much information as possible on the location of all the
1557 enum lval_type lval
;
1566 /* The sp is special; what's displayed isn't the save address, but
1567 the value of the previous frame's sp. This is a legacy thing,
1568 at one stage the frame cached the previous frame's SP instead
1569 of its address, hence it was easiest to just display the cached
1571 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1573 /* Find out the location of the saved stack pointer with out
1574 actually evaluating it. */
1575 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1576 &optimized
, &unavailable
, &lval
, &addr
,
1578 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1580 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1581 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1582 gdb_byte value
[MAX_REGISTER_SIZE
];
1585 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1586 &optimized
, &unavailable
, &lval
, &addr
,
1588 /* NOTE: cagney/2003-05-22: This is assuming that the
1589 stack pointer was packed as an unsigned integer. That
1590 may or may not be valid. */
1591 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1592 printf_filtered (" Previous frame's sp is ");
1593 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1594 printf_filtered ("\n");
1597 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1599 printf_filtered (" Previous frame's sp at ");
1600 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1601 printf_filtered ("\n");
1604 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1606 printf_filtered (" Previous frame's sp in %s\n",
1607 gdbarch_register_name (gdbarch
, realnum
));
1610 /* else keep quiet. */
1614 numregs
= gdbarch_num_regs (gdbarch
)
1615 + gdbarch_num_pseudo_regs (gdbarch
);
1616 for (i
= 0; i
< numregs
; i
++)
1617 if (i
!= gdbarch_sp_regnum (gdbarch
)
1618 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1620 /* Find out the location of the saved register without
1621 fetching the corresponding value. */
1622 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1623 &lval
, &addr
, &realnum
, NULL
);
1624 /* For moment, only display registers that were saved on the
1626 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1629 puts_filtered (" Saved registers:\n ");
1631 puts_filtered (",");
1633 printf_filtered (" %s at ",
1634 gdbarch_register_name (gdbarch
, i
));
1635 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1639 if (count
|| need_nl
)
1640 puts_filtered ("\n");
1643 do_cleanups (back_to
);
1646 /* Print briefly all stack frames or just the innermost COUNT_EXP
1650 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1652 struct frame_info
*fi
;
1655 struct frame_info
*trailing
;
1658 if (!target_has_stack
)
1659 error (_("No stack."));
1661 /* The following code must do two things. First, it must set the
1662 variable TRAILING to the frame from which we should start
1663 printing. Second, it must set the variable count to the number
1664 of frames which we should print, or -1 if all of them. */
1665 trailing
= get_current_frame ();
1670 count
= parse_and_eval_long (count_exp
);
1673 struct frame_info
*current
;
1678 while (current
&& count
--)
1681 current
= get_prev_frame (current
);
1684 /* Will stop when CURRENT reaches the top of the stack.
1685 TRAILING will be COUNT below it. */
1689 trailing
= get_prev_frame (trailing
);
1690 current
= get_prev_frame (current
);
1702 /* Read in symbols for all of the frames. Need to do this in a
1703 separate pass so that "Reading in symbols for xxx" messages
1704 don't screw up the appearance of the backtrace. Also if
1705 people have strong opinions against reading symbols for
1706 backtrace this may have to be an option. */
1708 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1713 pc
= get_frame_address_in_block (fi
);
1714 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1718 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1722 /* Don't use print_stack_frame; if an error() occurs it probably
1723 means further attempts to backtrace would fail (on the other
1724 hand, perhaps the code does or could be fixed to make sure
1725 the frame->prev field gets set to NULL in that case). */
1726 print_frame_info (fi
, 1, LOCATION
, 1);
1729 struct frame_id frame_id
= get_frame_id (fi
);
1731 print_frame_local_vars (fi
, 1, gdb_stdout
);
1733 /* print_frame_local_vars invalidates FI. */
1734 fi
= frame_find_by_id (frame_id
);
1738 warning (_("Unable to restore previously selected frame."));
1743 /* Save the last frame to check for error conditions. */
1747 /* If we've stopped before the end, mention that. */
1749 printf_filtered (_("(More stack frames follow...)\n"));
1751 /* If we've run out of frames, and the reason appears to be an error
1752 condition, print it. */
1753 if (fi
== NULL
&& trailing
!= NULL
)
1755 enum unwind_stop_reason reason
;
1757 reason
= get_frame_unwind_stop_reason (trailing
);
1758 if (reason
>= UNWIND_FIRST_ERROR
)
1759 printf_filtered (_("Backtrace stopped: %s\n"),
1760 frame_stop_reason_string (reason
));
1765 backtrace_command (char *arg
, int from_tty
)
1767 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1768 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1775 argv
= gdb_buildargv (arg
);
1776 make_cleanup_freeargv (argv
);
1778 for (i
= 0; argv
[i
]; i
++)
1782 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1783 argv
[i
][j
] = tolower (argv
[i
][j
]);
1785 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1786 fulltrace_arg
= argc
;
1789 arglen
+= strlen (argv
[i
]);
1794 if (fulltrace_arg
>= 0)
1798 arg
= xmalloc (arglen
+ 1);
1799 make_cleanup (xfree
, arg
);
1801 for (i
= 0; i
< (argc
+ 1); i
++)
1803 if (i
!= fulltrace_arg
)
1805 strcat (arg
, argv
[i
]);
1815 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1817 do_cleanups (old_chain
);
1821 backtrace_full_command (char *arg
, int from_tty
)
1823 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1827 /* Iterate over the local variables of a block B, calling CB with
1831 iterate_over_block_locals (struct block
*b
,
1832 iterate_over_block_arg_local_vars_cb cb
,
1835 struct block_iterator iter
;
1838 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1840 switch (SYMBOL_CLASS (sym
))
1846 if (SYMBOL_IS_ARGUMENT (sym
))
1848 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1850 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1854 /* Ignore symbols which are not locals. */
1861 /* Same, but print labels. */
1864 /* Commented out, as the code using this function has also been
1865 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1866 was commented out in the first place. The discussion introducing
1867 this change (2007-12-04: Support lexical blocks and function bodies
1868 that occupy non-contiguous address ranges) did not explain why
1869 this change was made. */
1871 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1872 int *have_default
, struct ui_file
*stream
)
1874 struct block_iterator iter
;
1876 int values_printed
= 0;
1878 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1880 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1886 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1888 struct symtab_and_line sal
;
1889 struct value_print_options opts
;
1891 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1893 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1894 get_user_print_options (&opts
);
1895 if (opts
.addressprint
)
1897 fprintf_filtered (stream
, " ");
1898 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1901 fprintf_filtered (stream
, " in file %s, line %d\n",
1902 sal
.symtab
->filename
, sal
.line
);
1906 return values_printed
;
1910 /* Iterate over all the local variables in block B, including all its
1911 superblocks, stopping when the top-level block is reached. */
1914 iterate_over_block_local_vars (struct block
*block
,
1915 iterate_over_block_arg_local_vars_cb cb
,
1920 iterate_over_block_locals (block
, cb
, cb_data
);
1921 /* After handling the function's top-level block, stop. Don't
1922 continue to its superblock, the block of per-file
1924 if (BLOCK_FUNCTION (block
))
1926 block
= BLOCK_SUPERBLOCK (block
);
1930 /* Data to be passed around in the calls to the locals and args
1933 struct print_variable_and_value_data
1935 struct frame_id frame_id
;
1937 struct ui_file
*stream
;
1941 /* The callback for the locals and args iterators. */
1944 do_print_variable_and_value (const char *print_name
,
1948 struct print_variable_and_value_data
*p
= cb_data
;
1949 struct frame_info
*frame
;
1951 frame
= frame_find_by_id (p
->frame_id
);
1954 warning (_("Unable to restore previously selected frame."));
1958 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
1960 /* print_variable_and_value invalidates FRAME. */
1963 p
->values_printed
= 1;
1966 /* Print all variables from the innermost up to the function block of FRAME.
1967 Print them with values to STREAM indented by NUM_TABS.
1969 This function will invalidate FRAME. */
1972 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1973 struct ui_file
*stream
)
1975 struct print_variable_and_value_data cb_data
;
1976 struct block
*block
;
1979 if (!get_frame_pc_if_available (frame
, &pc
))
1981 fprintf_filtered (stream
,
1982 _("PC unavailable, cannot determine locals.\n"));
1986 block
= get_frame_block (frame
, 0);
1989 fprintf_filtered (stream
, "No symbol table info available.\n");
1993 cb_data
.frame_id
= get_frame_id (frame
);
1994 cb_data
.num_tabs
= 4 * num_tabs
;
1995 cb_data
.stream
= stream
;
1996 cb_data
.values_printed
= 0;
1998 iterate_over_block_local_vars (block
,
1999 do_print_variable_and_value
,
2002 /* do_print_variable_and_value invalidates FRAME. */
2005 if (!cb_data
.values_printed
)
2006 fprintf_filtered (stream
, _("No locals.\n"));
2010 locals_info (char *args
, int from_tty
)
2012 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2016 /* Iterate over all the argument variables in block B.
2018 Returns 1 if any argument was walked; 0 otherwise. */
2021 iterate_over_block_arg_vars (struct block
*b
,
2022 iterate_over_block_arg_local_vars_cb cb
,
2025 struct block_iterator iter
;
2026 struct symbol
*sym
, *sym2
;
2028 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2030 /* Don't worry about things which aren't arguments. */
2031 if (SYMBOL_IS_ARGUMENT (sym
))
2033 /* We have to look up the symbol because arguments can have
2034 two entries (one a parameter, one a local) and the one we
2035 want is the local, which lookup_symbol will find for us.
2036 This includes gcc1 (not gcc2) on the sparc when passing a
2037 small structure and gcc2 when the argument type is float
2038 and it is passed as a double and converted to float by
2039 the prologue (in the latter case the type of the LOC_ARG
2040 symbol is double and the type of the LOC_LOCAL symbol is
2041 float). There are also LOC_ARG/LOC_REGISTER pairs which
2042 are not combined in symbol-reading. */
2044 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2045 b
, VAR_DOMAIN
, NULL
);
2046 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2051 /* Print all argument variables of the function of FRAME.
2052 Print them with values to STREAM.
2054 This function will invalidate FRAME. */
2057 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2059 struct print_variable_and_value_data cb_data
;
2060 struct symbol
*func
;
2063 if (!get_frame_pc_if_available (frame
, &pc
))
2065 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2069 func
= get_frame_function (frame
);
2072 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2076 cb_data
.frame_id
= get_frame_id (frame
);
2077 cb_data
.num_tabs
= 0;
2078 cb_data
.stream
= gdb_stdout
;
2079 cb_data
.values_printed
= 0;
2081 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2082 do_print_variable_and_value
, &cb_data
);
2084 /* do_print_variable_and_value invalidates FRAME. */
2087 if (!cb_data
.values_printed
)
2088 fprintf_filtered (stream
, _("No arguments.\n"));
2092 args_info (char *ignore
, int from_tty
)
2094 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2100 args_plus_locals_info (char *ignore
, int from_tty
)
2102 args_info (ignore
, from_tty
);
2103 locals_info (ignore
, from_tty
);
2107 /* Select frame FRAME. Also print the stack frame and show the source
2108 if this is the tui version. */
2110 select_and_print_frame (struct frame_info
*frame
)
2112 select_frame (frame
);
2114 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2117 /* Return the symbol-block in which the selected frame is executing.
2118 Can return zero under various legitimate circumstances.
2120 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2121 code address within the block returned. We use this to decide
2122 which macros are in scope. */
2125 get_selected_block (CORE_ADDR
*addr_in_block
)
2127 if (!has_stack_frames ())
2130 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2133 /* Find a frame a certain number of levels away from FRAME.
2134 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2135 Positive means go to earlier frames (up); negative, the reverse.
2136 The int that contains the number of levels is counted toward
2137 zero as the frames for those levels are found.
2138 If the top or bottom frame is reached, that frame is returned,
2139 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2140 how much farther the original request asked to go. */
2143 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2145 /* Going up is simple: just call get_prev_frame enough times or
2146 until the initial frame is reached. */
2147 while (*level_offset_ptr
> 0)
2149 struct frame_info
*prev
= get_prev_frame (frame
);
2153 (*level_offset_ptr
)--;
2157 /* Going down is just as simple. */
2158 while (*level_offset_ptr
< 0)
2160 struct frame_info
*next
= get_next_frame (frame
);
2164 (*level_offset_ptr
)++;
2171 /* The "select_frame" command. With no argument this is a NOP.
2172 Select the frame at level LEVEL_EXP if it is a valid level.
2173 Otherwise, treat LEVEL_EXP as an address expression and select it.
2175 See parse_frame_specification for more info on proper frame
2179 select_frame_command (char *level_exp
, int from_tty
)
2181 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2184 /* The "frame" command. With no argument, print the selected frame
2185 briefly. With an argument, behave like select_frame and then print
2186 the selected frame. */
2189 frame_command (char *level_exp
, int from_tty
)
2191 select_frame_command (level_exp
, from_tty
);
2192 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2195 /* The XDB Compatibility command to print the current frame. */
2198 current_frame_command (char *level_exp
, int from_tty
)
2200 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2203 /* Select the frame up one or COUNT_EXP stack levels from the
2204 previously selected frame, and print it briefly. */
2207 up_silently_base (char *count_exp
)
2209 struct frame_info
*frame
;
2213 count
= parse_and_eval_long (count_exp
);
2215 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2216 if (count
!= 0 && count_exp
== NULL
)
2217 error (_("Initial frame selected; you cannot go up."));
2218 select_frame (frame
);
2222 up_silently_command (char *count_exp
, int from_tty
)
2224 up_silently_base (count_exp
);
2228 up_command (char *count_exp
, int from_tty
)
2230 up_silently_base (count_exp
);
2231 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2234 /* Select the frame down one or COUNT_EXP stack levels from the previously
2235 selected frame, and print it briefly. */
2238 down_silently_base (char *count_exp
)
2240 struct frame_info
*frame
;
2244 count
= -parse_and_eval_long (count_exp
);
2246 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2247 if (count
!= 0 && count_exp
== NULL
)
2249 /* We only do this if COUNT_EXP is not specified. That way
2250 "down" means to really go down (and let me know if that is
2251 impossible), but "down 9999" can be used to mean go all the
2252 way down without getting an error. */
2254 error (_("Bottom (innermost) frame selected; you cannot go down."));
2257 select_frame (frame
);
2261 down_silently_command (char *count_exp
, int from_tty
)
2263 down_silently_base (count_exp
);
2267 down_command (char *count_exp
, int from_tty
)
2269 down_silently_base (count_exp
);
2270 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2275 return_command (char *retval_exp
, int from_tty
)
2277 struct frame_info
*thisframe
;
2278 struct gdbarch
*gdbarch
;
2279 struct symbol
*thisfun
;
2280 struct value
*return_value
= NULL
;
2281 struct value
*function
= NULL
;
2282 const char *query_prefix
= "";
2284 thisframe
= get_selected_frame ("No selected frame.");
2285 thisfun
= get_frame_function (thisframe
);
2286 gdbarch
= get_frame_arch (thisframe
);
2288 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2289 error (_("Can not force return from an inlined function."));
2291 /* Compute the return value. If the computation triggers an error,
2292 let it bail. If the return type can't be handled, set
2293 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2297 struct expression
*retval_expr
= parse_expression (retval_exp
);
2298 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2299 struct type
*return_type
= NULL
;
2301 /* Compute the return value. Should the computation fail, this
2302 call throws an error. */
2303 return_value
= evaluate_expression (retval_expr
);
2305 /* Cast return value to the return type of the function. Should
2306 the cast fail, this call throws an error. */
2307 if (thisfun
!= NULL
)
2308 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2309 if (return_type
== NULL
)
2311 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2312 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2313 error (_("Return value type not available for selected "
2315 "Please use an explicit cast of the value to return."));
2316 return_type
= value_type (return_value
);
2318 do_cleanups (old_chain
);
2319 CHECK_TYPEDEF (return_type
);
2320 return_value
= value_cast (return_type
, return_value
);
2322 /* Make sure the value is fully evaluated. It may live in the
2323 stack frame we're about to pop. */
2324 if (value_lazy (return_value
))
2325 value_fetch_lazy (return_value
);
2327 if (thisfun
!= NULL
)
2328 function
= read_var_value (thisfun
, thisframe
);
2330 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2331 /* If the return-type is "void", don't try to find the
2332 return-value's location. However, do still evaluate the
2333 return expression so that, even when the expression result
2334 is discarded, side effects such as "return i++" still
2336 return_value
= NULL
;
2337 else if (thisfun
!= NULL
2338 && using_struct_return (gdbarch
, function
, return_type
))
2340 query_prefix
= "The location at which to store the "
2341 "function's return value is unknown.\n"
2342 "If you continue, the return value "
2343 "that you specified will be ignored.\n";
2344 return_value
= NULL
;
2348 /* Does an interactive user really want to do this? Include
2349 information, such as how well GDB can handle the return value, in
2350 the query message. */
2355 if (thisfun
== NULL
)
2356 confirmed
= query (_("%sMake selected stack frame return now? "),
2359 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2360 SYMBOL_PRINT_NAME (thisfun
));
2362 error (_("Not confirmed"));
2365 /* Discard the selected frame and all frames inner-to it. */
2366 frame_pop (get_selected_frame (NULL
));
2368 /* Store RETURN_VALUE in the just-returned register set. */
2369 if (return_value
!= NULL
)
2371 struct type
*return_type
= value_type (return_value
);
2372 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2374 gdb_assert (gdbarch_return_value (gdbarch
, function
, return_type
, NULL
,
2376 == RETURN_VALUE_REGISTER_CONVENTION
);
2377 gdbarch_return_value (gdbarch
, function
, return_type
,
2378 get_current_regcache (), NULL
/*read*/,
2379 value_contents (return_value
) /*write*/);
2382 /* If we are at the end of a call dummy now, pop the dummy frame
2384 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2385 frame_pop (get_current_frame ());
2387 /* If interactive, print the frame that is now current. */
2389 frame_command ("0", 1);
2391 select_frame_command ("0", 0);
2394 /* Sets the scope to input function name, provided that the function
2395 is within the current stack frame. */
2397 struct function_bounds
2399 CORE_ADDR low
, high
;
2403 func_command (char *arg
, int from_tty
)
2405 struct frame_info
*frame
;
2407 struct symtabs_and_lines sals
;
2410 struct function_bounds
*func_bounds
= NULL
;
2411 struct cleanup
*cleanups
;
2416 frame
= parse_frame_specification ("0");
2417 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2418 cleanups
= make_cleanup (xfree
, sals
.sals
);
2419 func_bounds
= (struct function_bounds
*) xmalloc (
2420 sizeof (struct function_bounds
) * sals
.nelts
);
2421 make_cleanup (xfree
, func_bounds
);
2422 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2424 if (sals
.sals
[i
].pspace
!= current_program_space
)
2425 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2426 else if (sals
.sals
[i
].pc
== 0
2427 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2428 &func_bounds
[i
].low
,
2429 &func_bounds
[i
].high
) == 0)
2431 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2437 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2438 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2439 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2443 frame
= find_relative_frame (frame
, &level
);
2446 while (!found
&& level
== 0);
2448 do_cleanups (cleanups
);
2451 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2452 else if (frame
!= get_selected_frame (NULL
))
2453 select_and_print_frame (frame
);
2456 /* Gets the language of the current frame. */
2459 get_frame_language (void)
2461 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2465 volatile struct gdb_exception ex
;
2469 /* We determine the current frame language by looking up its
2470 associated symtab. To retrieve this symtab, we use the frame
2471 PC. However we cannot use the frame PC as is, because it
2472 usually points to the instruction following the "call", which
2473 is sometimes the first instruction of another function. So
2474 we rely on get_frame_address_in_block(), it provides us with
2475 a PC that is guaranteed to be inside the frame's code
2478 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2480 pc
= get_frame_address_in_block (frame
);
2484 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2485 throw_exception (ex
);
2489 s
= find_pc_symtab (pc
);
2495 return language_unknown
;
2499 /* Provide a prototype to silence -Wmissing-prototypes. */
2500 void _initialize_stack (void);
2503 _initialize_stack (void)
2505 add_com ("return", class_stack
, return_command
, _("\
2506 Make selected stack frame return to its caller.\n\
2507 Control remains in the debugger, but when you continue\n\
2508 execution will resume in the frame above the one now selected.\n\
2509 If an argument is given, it is an expression for the value to return."));
2511 add_com ("up", class_stack
, up_command
, _("\
2512 Select and print stack frame that called this one.\n\
2513 An argument says how many frames up to go."));
2514 add_com ("up-silently", class_support
, up_silently_command
, _("\
2515 Same as the `up' command, but does not print anything.\n\
2516 This is useful in command scripts."));
2518 add_com ("down", class_stack
, down_command
, _("\
2519 Select and print stack frame called by this one.\n\
2520 An argument says how many frames down to go."));
2521 add_com_alias ("do", "down", class_stack
, 1);
2522 add_com_alias ("dow", "down", class_stack
, 1);
2523 add_com ("down-silently", class_support
, down_silently_command
, _("\
2524 Same as the `down' command, but does not print anything.\n\
2525 This is useful in command scripts."));
2527 add_com ("frame", class_stack
, frame_command
, _("\
2528 Select and print a stack frame.\nWith no argument, \
2529 print the selected stack frame. (See also \"info frame\").\n\
2530 An argument specifies the frame to select.\n\
2531 It can be a stack frame number or the address of the frame.\n\
2532 With argument, nothing is printed if input is coming from\n\
2533 a command file or a user-defined command."));
2535 add_com_alias ("f", "frame", class_stack
, 1);
2539 add_com ("L", class_stack
, current_frame_command
,
2540 _("Print the current stack frame.\n"));
2541 add_com_alias ("V", "frame", class_stack
, 1);
2543 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2544 Select a stack frame without printing anything.\n\
2545 An argument specifies the frame to select.\n\
2546 It can be a stack frame number or the address of the frame.\n"));
2548 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2549 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2550 With a negative argument, print outermost -COUNT frames.\nUse of the \
2551 'full' qualifier also prints the values of the local variables.\n"));
2552 add_com_alias ("bt", "backtrace", class_stack
, 0);
2555 add_com_alias ("t", "backtrace", class_stack
, 0);
2556 add_com ("T", class_stack
, backtrace_full_command
, _("\
2557 Print backtrace of all stack frames, or innermost COUNT frames\n\
2558 and the values of the local variables.\n\
2559 With a negative argument, print outermost -COUNT frames.\n\
2560 Usage: T <count>\n"));
2563 add_com_alias ("where", "backtrace", class_alias
, 0);
2564 add_info ("stack", backtrace_command
,
2565 _("Backtrace of the stack, or innermost COUNT frames."));
2566 add_info_alias ("s", "stack", 1);
2567 add_info ("frame", frame_info
,
2568 _("All about selected stack frame, or frame at ADDR."));
2569 add_info_alias ("f", "frame", 1);
2570 add_info ("locals", locals_info
,
2571 _("Local variables of current stack frame."));
2572 add_info ("args", args_info
,
2573 _("Argument variables of current stack frame."));
2575 add_com ("l", class_info
, args_plus_locals_info
,
2576 _("Argument and local variables of current stack frame."));
2579 add_com ("func", class_stack
, func_command
, _("\
2580 Select the stack frame that contains <func>.\n\
2581 Usage: func <name>\n"));
2583 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2584 print_frame_arguments_choices
, &print_frame_arguments
,
2585 _("Set printing of non-scalar frame arguments"),
2586 _("Show printing of non-scalar frame arguments"),
2587 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2589 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2590 &disassemble_next_line
, _("\
2591 Set whether to disassemble next source line or insn when execution stops."),
2593 Show whether to disassemble next source line or insn when execution stops."),
2595 If ON, GDB will display disassembly of the next source line, in addition\n\
2596 to displaying the source line itself. If the next source line cannot\n\
2597 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2598 will display disassembly of next instruction instead of showing the\n\
2600 If AUTO, display disassembly of next instruction only if the source line\n\
2601 cannot be displayed.\n\
2602 If OFF (which is the default), never display the disassembly of the next\n\
2605 show_disassemble_next_line
,
2606 &setlist
, &showlist
);
2607 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2609 add_setshow_enum_cmd ("entry-values", class_stack
,
2610 print_entry_values_choices
, &print_entry_values
,
2611 _("Set printing of function arguments at function "
2613 _("Show printing of function arguments at function "
2616 GDB can sometimes determine the values of function arguments at entry,\n\
2617 in addition to their current values. This option tells GDB whether\n\
2618 to print the current value, the value at entry (marked as val@entry),\n\
2619 or both. Note that one or both of these values may be <optimized out>."),
2620 NULL
, NULL
, &setprintlist
, &showprintlist
);