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");
507 /* True in "summary" mode, false otherwise. */
508 int summary
= !strcmp (print_frame_arguments
, "scalars");
510 stb
= mem_fileopen ();
511 old_chain
= make_cleanup_ui_file_delete (stb
);
515 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
516 struct block_iterator iter
;
519 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
521 struct frame_arg arg
, entryarg
;
525 /* Keep track of the highest stack argument offset seen, and
526 skip over any kinds of symbols we don't care about. */
528 if (!SYMBOL_IS_ARGUMENT (sym
))
531 switch (SYMBOL_CLASS (sym
))
536 long current_offset
= SYMBOL_VALUE (sym
);
537 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
539 /* Compute address of next argument by adding the size of
540 this argument and rounding to an int boundary. */
542 ((current_offset
+ arg_size
+ sizeof (int) - 1)
543 & ~(sizeof (int) - 1));
545 /* If this is the highest offset seen yet, set
547 if (highest_offset
== -1
548 || (current_offset
> highest_offset
))
549 highest_offset
= current_offset
;
551 /* Add the number of ints we're about to print to
553 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
556 /* We care about types of symbols, but don't need to
557 keep track of stack offsets in them. */
559 case LOC_REGPARM_ADDR
:
561 case LOC_OPTIMIZED_OUT
:
566 /* We have to look up the symbol because arguments can have
567 two entries (one a parameter, one a local) and the one we
568 want is the local, which lookup_symbol will find for us.
569 This includes gcc1 (not gcc2) on SPARC when passing a
570 small structure and gcc2 when the argument type is float
571 and it is passed as a double and converted to float by
572 the prologue (in the latter case the type of the LOC_ARG
573 symbol is double and the type of the LOC_LOCAL symbol is
575 /* But if the parameter name is null, don't try it. Null
576 parameter names occur on the RS/6000, for traceback
577 tables. FIXME, should we even print them? */
579 if (*SYMBOL_LINKAGE_NAME (sym
))
583 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
584 b
, VAR_DOMAIN
, NULL
);
585 gdb_assert (nsym
!= NULL
);
586 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
587 && !SYMBOL_IS_ARGUMENT (nsym
))
589 /* There is a LOC_ARG/LOC_REGISTER pair. This means
590 that it was passed on the stack and loaded into a
591 register, or passed in a register and stored in a
592 stack slot. GDB 3.x used the LOC_ARG; GDB
593 4.0-4.11 used the LOC_REGISTER.
595 Reasons for using the LOC_ARG:
597 (1) Because find_saved_registers may be slow for
600 (2) Because registers are often re-used and stack
601 slots rarely (never?) are. Therefore using
602 the stack slot is much less likely to print
605 Reasons why we might want to use the LOC_REGISTER:
607 (1) So that the backtrace prints the same value
608 as "print foo". I see no compelling reason
609 why this needs to be the case; having the
610 backtrace print the value which was passed
611 in, and "print foo" print the value as
612 modified within the called function, makes
615 Additional note: It might be nice if "info args"
616 displayed both values.
618 One more note: There is a case with SPARC
619 structure passing where we need to use the
620 LOC_REGISTER, but this is dealt with by creating
621 a single LOC_REGPARM in symbol reading. */
623 /* Leave sym (the LOC_ARG) alone. */
630 /* Print the current arg. */
632 ui_out_text (uiout
, ", ");
633 ui_out_wrap_hint (uiout
, " ");
637 memset (&arg
, 0, sizeof (arg
));
639 arg
.entry_kind
= print_entry_values_no
;
640 memset (&entryarg
, 0, sizeof (entryarg
));
642 entryarg
.entry_kind
= print_entry_values_no
;
645 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
647 if (arg
.entry_kind
!= print_entry_values_only
)
648 print_frame_arg (&arg
);
650 if (entryarg
.entry_kind
!= print_entry_values_no
)
652 if (arg
.entry_kind
!= print_entry_values_only
)
654 ui_out_text (uiout
, ", ");
655 ui_out_wrap_hint (uiout
, " ");
658 print_frame_arg (&entryarg
);
662 xfree (entryarg
.error
);
668 /* Don't print nameless args in situations where we don't know
669 enough about the stack to find them. */
674 if (highest_offset
== -1)
675 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
677 start
= highest_offset
;
679 print_frame_nameless_args (frame
, start
, num
- args_printed
,
683 do_cleanups (old_chain
);
686 /* Set the current source and line to the location given by frame
687 FRAME, if possible. When CENTER is true, adjust so the relevant
688 line is in the center of the next 'list'. */
691 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
693 struct symtab_and_line sal
;
695 find_frame_sal (frame
, &sal
);
699 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
700 set_current_source_symtab_and_line (&sal
);
704 /* If ON, GDB will display disassembly of the next source line when
705 execution of the program being debugged stops.
706 If AUTO (which is the default), or there's no line info to determine
707 the source line of the next instruction, display disassembly of next
708 instruction instead. */
710 static enum auto_boolean disassemble_next_line
;
713 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
714 struct cmd_list_element
*c
,
717 fprintf_filtered (file
,
718 _("Debugger's willingness to use "
719 "disassemble-next-line is %s.\n"),
723 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
724 because it will be broken by filter sometime. */
727 do_gdb_disassembly (struct gdbarch
*gdbarch
,
728 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
730 volatile struct gdb_exception exception
;
732 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
734 gdb_disassembly (gdbarch
, current_uiout
, 0,
735 DISASSEMBLY_RAW_INSN
, how_many
,
738 if (exception
.reason
< 0)
740 /* If an exception was thrown while doing the disassembly, print
741 the error message, to give the user a clue of what happened. */
742 exception_print (gdb_stderr
, exception
);
746 /* Print information about frame FRAME. The output is format according
747 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
750 SRC_LINE: Print only source line.
751 LOCATION: Print only location.
752 LOC_AND_SRC: Print location and source line.
754 Used in "where" output, and to emit breakpoint or step
758 print_frame_info (struct frame_info
*frame
, int print_level
,
759 enum print_what print_what
, int print_args
)
761 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
762 struct symtab_and_line sal
;
765 struct ui_out
*uiout
= current_uiout
;
767 if (get_frame_type (frame
) == DUMMY_FRAME
768 || get_frame_type (frame
) == SIGTRAMP_FRAME
769 || get_frame_type (frame
) == ARCH_FRAME
)
771 struct cleanup
*uiout_cleanup
772 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
774 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
775 gdbarch
, get_frame_pc (frame
));
777 /* Do this regardless of SOURCE because we don't have any source
778 to list for this frame. */
781 ui_out_text (uiout
, "#");
782 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
783 frame_relative_level (frame
));
785 if (ui_out_is_mi_like_p (uiout
))
787 annotate_frame_address ();
788 ui_out_field_core_addr (uiout
, "addr",
789 gdbarch
, get_frame_pc (frame
));
790 annotate_frame_address_end ();
793 if (get_frame_type (frame
) == DUMMY_FRAME
)
795 annotate_function_call ();
796 ui_out_field_string (uiout
, "func", "<function called from gdb>");
798 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
800 annotate_signal_handler_caller ();
801 ui_out_field_string (uiout
, "func", "<signal handler called>");
803 else if (get_frame_type (frame
) == ARCH_FRAME
)
805 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
807 ui_out_text (uiout
, "\n");
808 annotate_frame_end ();
810 do_cleanups (uiout_cleanup
);
814 /* If FRAME is not the innermost frame, that normally means that
815 FRAME->pc points to *after* the call instruction, and we want to
816 get the line containing the call, never the next line. But if
817 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
818 next frame was not entered as the result of a call, and we want
819 to get the line containing FRAME->pc. */
820 find_frame_sal (frame
, &sal
);
822 location_print
= (print_what
== LOCATION
823 || print_what
== LOC_AND_ADDRESS
824 || print_what
== SRC_AND_LOC
);
826 if (location_print
|| !sal
.symtab
)
827 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
829 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
831 /* If disassemble-next-line is set to auto or on and doesn't have
832 the line debug messages for $pc, output the next instruction. */
833 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
834 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
835 && source_print
&& !sal
.symtab
)
836 do_gdb_disassembly (get_frame_arch (frame
), 1,
837 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
839 if (source_print
&& sal
.symtab
)
842 int mid_statement
= ((print_what
== SRC_LINE
)
843 && frame_show_address (frame
, sal
));
845 if (annotation_level
)
846 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
847 get_frame_pc (frame
));
850 if (deprecated_print_frame_info_listing_hook
)
851 deprecated_print_frame_info_listing_hook (sal
.symtab
,
856 struct value_print_options opts
;
858 get_user_print_options (&opts
);
859 /* We used to do this earlier, but that is clearly
860 wrong. This function is used by many different
861 parts of gdb, including normal_stop in infrun.c,
862 which uses this to print out the current PC
863 when we stepi/nexti into the middle of a source
864 line. Only the command line really wants this
865 behavior. Other UIs probably would like the
866 ability to decide for themselves if it is desired. */
867 if (opts
.addressprint
&& mid_statement
)
869 ui_out_field_core_addr (uiout
, "addr",
870 gdbarch
, get_frame_pc (frame
));
871 ui_out_text (uiout
, "\t");
874 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
878 /* If disassemble-next-line is set to on and there is line debug
879 messages, output assembly codes for next line. */
880 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
881 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
884 if (print_what
!= LOCATION
)
888 if (get_frame_pc_if_available (frame
, &pc
))
889 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
891 set_last_displayed_sal (0, 0, 0, 0, 0);
894 annotate_frame_end ();
896 gdb_flush (gdb_stdout
);
899 /* Remember the last symtab and line we displayed, which we use e.g.
900 * as the place to put a breakpoint when the `break' command is
901 * invoked with no arguments. */
904 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
905 CORE_ADDR addr
, struct symtab
*symtab
,
908 last_displayed_sal_valid
= valid
;
909 last_displayed_pspace
= pspace
;
910 last_displayed_addr
= addr
;
911 last_displayed_symtab
= symtab
;
912 last_displayed_line
= line
;
913 if (valid
&& pspace
== NULL
)
915 clear_last_displayed_sal ();
916 internal_error (__FILE__
, __LINE__
,
917 _("Trying to set NULL pspace."));
921 /* Forget the last sal we displayed. */
924 clear_last_displayed_sal (void)
926 last_displayed_sal_valid
= 0;
927 last_displayed_pspace
= 0;
928 last_displayed_addr
= 0;
929 last_displayed_symtab
= 0;
930 last_displayed_line
= 0;
933 /* Is our record of the last sal we displayed valid? If not,
934 * the get_last_displayed_* functions will return NULL or 0, as
938 last_displayed_sal_is_valid (void)
940 return last_displayed_sal_valid
;
943 /* Get the pspace of the last sal we displayed, if it's valid. */
945 struct program_space
*
946 get_last_displayed_pspace (void)
948 if (last_displayed_sal_valid
)
949 return last_displayed_pspace
;
953 /* Get the address of the last sal we displayed, if it's valid. */
956 get_last_displayed_addr (void)
958 if (last_displayed_sal_valid
)
959 return last_displayed_addr
;
963 /* Get the symtab of the last sal we displayed, if it's valid. */
966 get_last_displayed_symtab (void)
968 if (last_displayed_sal_valid
)
969 return last_displayed_symtab
;
973 /* Get the line of the last sal we displayed, if it's valid. */
976 get_last_displayed_line (void)
978 if (last_displayed_sal_valid
)
979 return last_displayed_line
;
983 /* Get the last sal we displayed, if it's valid. */
986 get_last_displayed_sal (struct symtab_and_line
*sal
)
988 if (last_displayed_sal_valid
)
990 sal
->pspace
= last_displayed_pspace
;
991 sal
->pc
= last_displayed_addr
;
992 sal
->symtab
= last_displayed_symtab
;
993 sal
->line
= last_displayed_line
;
1005 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1006 corresponding to FRAME. */
1009 find_frame_funname (struct frame_info
*frame
, const char **funname
,
1010 enum language
*funlang
, struct symbol
**funcp
)
1012 struct symbol
*func
;
1015 *funlang
= language_unknown
;
1019 func
= get_frame_function (frame
);
1022 /* In certain pathological cases, the symtabs give the wrong
1023 function (when we are in the first function in a file which
1024 is compiled without debugging symbols, the previous function
1025 is compiled with debugging symbols, and the "foo.o" symbol
1026 that is supposed to tell us where the file with debugging
1027 symbols ends has been truncated by ar because it is longer
1028 than 15 characters). This also occurs if the user uses asm()
1029 to create a function but not stabs for it (in a file compiled
1032 So look in the minimal symbol tables as well, and if it comes
1033 up with a larger address for the function use that instead.
1034 I don't think this can ever cause any problems; there
1035 shouldn't be any minimal symbols in the middle of a function;
1036 if this is ever changed many parts of GDB will need to be
1037 changed (and we'll create a find_pc_minimal_function or some
1040 struct minimal_symbol
*msymbol
= NULL
;
1042 /* Don't attempt to do this for inlined functions, which do not
1043 have a corresponding minimal symbol. */
1044 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1046 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1049 && (SYMBOL_VALUE_ADDRESS (msymbol
)
1050 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1052 /* We also don't know anything about the function besides
1053 its address and name. */
1055 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1056 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1060 *funname
= SYMBOL_PRINT_NAME (func
);
1061 *funlang
= SYMBOL_LANGUAGE (func
);
1064 if (*funlang
== language_cplus
)
1066 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1067 to display the demangled name that we already have
1068 stored in the symbol table, but we stored a version
1069 with DMGL_PARAMS turned on, and here we don't want to
1070 display parameters. So remove the parameters. */
1071 char *func_only
= cp_remove_params (*funname
);
1075 *funname
= func_only
;
1076 make_cleanup (xfree
, func_only
);
1083 struct minimal_symbol
*msymbol
;
1086 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1089 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1090 if (msymbol
!= NULL
)
1092 *funname
= SYMBOL_PRINT_NAME (msymbol
);
1093 *funlang
= SYMBOL_LANGUAGE (msymbol
);
1099 print_frame (struct frame_info
*frame
, int print_level
,
1100 enum print_what print_what
, int print_args
,
1101 struct symtab_and_line sal
)
1103 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1104 struct ui_out
*uiout
= current_uiout
;
1105 const char *funname
= NULL
;
1106 enum language funlang
= language_unknown
;
1107 struct ui_file
*stb
;
1108 struct cleanup
*old_chain
, *list_chain
;
1109 struct value_print_options opts
;
1110 struct symbol
*func
;
1114 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1116 stb
= mem_fileopen ();
1117 old_chain
= make_cleanup_ui_file_delete (stb
);
1119 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1121 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1124 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1128 ui_out_text (uiout
, "#");
1129 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1130 frame_relative_level (frame
));
1132 get_user_print_options (&opts
);
1133 if (opts
.addressprint
)
1135 || frame_show_address (frame
, sal
)
1136 || print_what
== LOC_AND_ADDRESS
)
1138 annotate_frame_address ();
1140 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1142 ui_out_field_string (uiout
, "addr", "<unavailable>");
1143 annotate_frame_address_end ();
1144 ui_out_text (uiout
, " in ");
1146 annotate_frame_function_name ();
1147 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1148 funlang
, DMGL_ANSI
);
1149 ui_out_field_stream (uiout
, "func", stb
);
1150 ui_out_wrap_hint (uiout
, " ");
1151 annotate_frame_args ();
1153 ui_out_text (uiout
, " (");
1156 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1158 struct cleanup
*args_list_chain
;
1159 volatile struct gdb_exception e
;
1161 if (gdbarch_frame_num_args_p (gdbarch
))
1163 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1164 gdb_assert (numargs
>= 0);
1169 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1170 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1172 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1174 /* FIXME: ARGS must be a list. If one argument is a string it
1175 will have " that will not be properly escaped. */
1176 /* Invoke ui_out_tuple_end. */
1177 do_cleanups (args_list_chain
);
1180 ui_out_text (uiout
, ")");
1183 annotate_frame_source_begin ();
1184 ui_out_wrap_hint (uiout
, " ");
1185 ui_out_text (uiout
, " at ");
1186 annotate_frame_source_file ();
1187 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1188 if (ui_out_is_mi_like_p (uiout
))
1190 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1192 ui_out_field_string (uiout
, "fullname", fullname
);
1194 annotate_frame_source_file_end ();
1195 ui_out_text (uiout
, ":");
1196 annotate_frame_source_line ();
1197 ui_out_field_int (uiout
, "line", sal
.line
);
1198 annotate_frame_source_end ();
1201 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1204 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1206 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1207 get_frame_pc (frame
));
1211 annotate_frame_where ();
1212 ui_out_wrap_hint (uiout
, " ");
1213 ui_out_text (uiout
, " from ");
1214 ui_out_field_string (uiout
, "from", lib
);
1218 /* do_cleanups will call ui_out_tuple_end() for us. */
1219 do_cleanups (list_chain
);
1220 ui_out_text (uiout
, "\n");
1221 do_cleanups (old_chain
);
1225 /* Read a frame specification in whatever the appropriate format is
1226 from FRAME_EXP. Call error(), printing MESSAGE, if the
1227 specification is in any way invalid (so this function never returns
1228 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1229 the default selected frame was used. */
1231 static struct frame_info
*
1232 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1233 int *selected_frame_p
)
1236 struct value
*args
[4];
1237 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1239 if (frame_exp
== NULL
)
1247 struct cleanup
*cleanup
;
1250 /* Skip leading white space, bail of EOL. */
1251 while (isspace (*frame_exp
))
1256 /* Parse the argument, extract it, save it. */
1258 *p
&& !isspace (*p
);
1260 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1262 cleanup
= make_cleanup (xfree
, addr_string
);
1264 /* NOTE: Parse and evaluate expression, but do not use
1265 functions such as parse_and_eval_long or
1266 parse_and_eval_address to also extract the value.
1267 Instead value_as_long and value_as_address are used.
1268 This avoids problems with expressions that contain
1270 if (numargs
>= ARRAY_SIZE (args
))
1271 error (_("Too many args in frame specification"));
1272 args
[numargs
++] = parse_and_eval (addr_string
);
1274 do_cleanups (cleanup
);
1278 /* If no args, default to the selected frame. */
1281 if (selected_frame_p
!= NULL
)
1282 (*selected_frame_p
) = 1;
1283 return get_selected_frame (message
);
1286 /* None of the remaining use the selected frame. */
1287 if (selected_frame_p
!= NULL
)
1288 (*selected_frame_p
) = 0;
1290 /* Assume the single arg[0] is an integer, and try using that to
1291 select a frame relative to current. */
1294 struct frame_info
*fid
;
1295 int level
= value_as_long (args
[0]);
1297 fid
= find_relative_frame (get_current_frame (), &level
);
1299 /* find_relative_frame was successful. */
1303 /* Convert each value into a corresponding address. */
1307 for (i
= 0; i
< numargs
; i
++)
1308 addrs
[i
] = value_as_address (args
[i
]);
1311 /* Assume that the single arg[0] is an address, use that to identify
1312 a frame with a matching ID. Should this also accept stack/pc or
1313 stack/pc/special. */
1316 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1317 struct frame_info
*fid
;
1319 /* If (s)he specifies the frame with an address, he deserves
1320 what (s)he gets. Still, give the highest one that matches.
1321 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1323 for (fid
= get_current_frame ();
1325 fid
= get_prev_frame (fid
))
1327 if (frame_id_eq (id
, get_frame_id (fid
)))
1329 struct frame_info
*prev_frame
;
1333 prev_frame
= get_prev_frame (fid
);
1335 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1344 /* We couldn't identify the frame as an existing frame, but
1345 perhaps we can create one with a single argument. */
1347 return create_new_frame (addrs
[0], 0);
1348 else if (numargs
== 2)
1349 return create_new_frame (addrs
[0], addrs
[1]);
1351 error (_("Too many args in frame specification"));
1354 static struct frame_info
*
1355 parse_frame_specification (char *frame_exp
)
1357 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1360 /* Print verbosely the selected frame or the frame at address
1361 ADDR_EXP. Absolutely all information in the frame is printed. */
1364 frame_info (char *addr_exp
, int from_tty
)
1366 struct frame_info
*fi
;
1367 struct symtab_and_line sal
;
1368 struct symbol
*func
;
1370 struct frame_info
*calling_frame_info
;
1372 const char *funname
= 0;
1373 enum language funlang
= language_unknown
;
1374 const char *pc_regname
;
1375 int selected_frame_p
;
1376 struct gdbarch
*gdbarch
;
1377 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1380 CORE_ADDR caller_pc
;
1382 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1383 gdbarch
= get_frame_arch (fi
);
1385 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1386 is not a good name. */
1387 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1388 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1389 easily not match that of the internal value returned by
1391 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1393 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1394 architectures will often have a hardware register called "pc",
1395 and that register's value, again, can easily not match
1399 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1400 find_frame_sal (fi
, &sal
);
1401 func
= get_frame_function (fi
);
1405 funname
= SYMBOL_PRINT_NAME (func
);
1406 funlang
= SYMBOL_LANGUAGE (func
);
1407 if (funlang
== language_cplus
)
1409 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1410 to display the demangled name that we already have
1411 stored in the symbol table, but we stored a version
1412 with DMGL_PARAMS turned on, and here we don't want to
1413 display parameters. So remove the parameters. */
1414 char *func_only
= cp_remove_params (funname
);
1418 funname
= func_only
;
1419 make_cleanup (xfree
, func_only
);
1423 else if (frame_pc_p
)
1425 struct minimal_symbol
*msymbol
;
1427 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1428 if (msymbol
!= NULL
)
1430 funname
= SYMBOL_PRINT_NAME (msymbol
);
1431 funlang
= SYMBOL_LANGUAGE (msymbol
);
1434 calling_frame_info
= get_prev_frame (fi
);
1436 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1438 printf_filtered (_("Stack level %d, frame at "),
1439 frame_relative_level (fi
));
1443 printf_filtered (_("Stack frame at "));
1445 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1446 printf_filtered (":\n");
1447 printf_filtered (" %s = ", pc_regname
);
1449 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1451 fputs_filtered ("<unavailable>", gdb_stdout
);
1456 printf_filtered (" in ");
1457 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1458 DMGL_ANSI
| DMGL_PARAMS
);
1462 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1463 puts_filtered ("; ");
1465 printf_filtered ("saved %s ", pc_regname
);
1466 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1467 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1469 fputs_filtered ("<unavailable>", gdb_stdout
);
1470 printf_filtered ("\n");
1472 if (calling_frame_info
== NULL
)
1474 enum unwind_stop_reason reason
;
1476 reason
= get_frame_unwind_stop_reason (fi
);
1477 if (reason
!= UNWIND_NO_REASON
)
1478 printf_filtered (_(" Outermost frame: %s\n"),
1479 frame_stop_reason_string (reason
));
1481 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1482 puts_filtered (" tail call frame");
1483 else if (get_frame_type (fi
) == INLINE_FRAME
)
1484 printf_filtered (" inlined into frame %d",
1485 frame_relative_level (get_prev_frame (fi
)));
1488 printf_filtered (" called by frame at ");
1489 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1492 if (get_next_frame (fi
) && calling_frame_info
)
1493 puts_filtered (",");
1495 if (get_next_frame (fi
))
1497 printf_filtered (" caller of frame at ");
1498 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1501 if (get_next_frame (fi
) || calling_frame_info
)
1502 puts_filtered ("\n");
1505 printf_filtered (" source language %s.\n",
1506 language_str (s
->language
));
1509 /* Address of the argument list for this frame, or 0. */
1510 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1511 /* Number of args for this frame, or -1 if unknown. */
1515 printf_filtered (" Arglist at unknown address.\n");
1518 printf_filtered (" Arglist at ");
1519 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1520 printf_filtered (",");
1522 if (!gdbarch_frame_num_args_p (gdbarch
))
1525 puts_filtered (" args: ");
1529 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1530 gdb_assert (numargs
>= 0);
1532 puts_filtered (" no args.");
1533 else if (numargs
== 1)
1534 puts_filtered (" 1 arg: ");
1536 printf_filtered (" %d args: ", numargs
);
1538 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1539 puts_filtered ("\n");
1543 /* Address of the local variables for this frame, or 0. */
1544 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1547 printf_filtered (" Locals at unknown address,");
1550 printf_filtered (" Locals at ");
1551 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1552 printf_filtered (",");
1556 /* Print as much information as possible on the location of all the
1559 enum lval_type lval
;
1568 /* The sp is special; what's displayed isn't the save address, but
1569 the value of the previous frame's sp. This is a legacy thing,
1570 at one stage the frame cached the previous frame's SP instead
1571 of its address, hence it was easiest to just display the cached
1573 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1575 /* Find out the location of the saved stack pointer with out
1576 actually evaluating it. */
1577 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1578 &optimized
, &unavailable
, &lval
, &addr
,
1580 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1582 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1583 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1584 gdb_byte value
[MAX_REGISTER_SIZE
];
1587 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1588 &optimized
, &unavailable
, &lval
, &addr
,
1590 /* NOTE: cagney/2003-05-22: This is assuming that the
1591 stack pointer was packed as an unsigned integer. That
1592 may or may not be valid. */
1593 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1594 printf_filtered (" Previous frame's sp is ");
1595 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1596 printf_filtered ("\n");
1599 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1601 printf_filtered (" Previous frame's sp at ");
1602 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1603 printf_filtered ("\n");
1606 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1608 printf_filtered (" Previous frame's sp in %s\n",
1609 gdbarch_register_name (gdbarch
, realnum
));
1612 /* else keep quiet. */
1616 numregs
= gdbarch_num_regs (gdbarch
)
1617 + gdbarch_num_pseudo_regs (gdbarch
);
1618 for (i
= 0; i
< numregs
; i
++)
1619 if (i
!= gdbarch_sp_regnum (gdbarch
)
1620 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1622 /* Find out the location of the saved register without
1623 fetching the corresponding value. */
1624 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1625 &lval
, &addr
, &realnum
, NULL
);
1626 /* For moment, only display registers that were saved on the
1628 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1631 puts_filtered (" Saved registers:\n ");
1633 puts_filtered (",");
1635 printf_filtered (" %s at ",
1636 gdbarch_register_name (gdbarch
, i
));
1637 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1641 if (count
|| need_nl
)
1642 puts_filtered ("\n");
1645 do_cleanups (back_to
);
1648 /* Print briefly all stack frames or just the innermost COUNT_EXP
1652 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1654 struct frame_info
*fi
;
1657 struct frame_info
*trailing
;
1660 if (!target_has_stack
)
1661 error (_("No stack."));
1663 /* The following code must do two things. First, it must set the
1664 variable TRAILING to the frame from which we should start
1665 printing. Second, it must set the variable count to the number
1666 of frames which we should print, or -1 if all of them. */
1667 trailing
= get_current_frame ();
1672 count
= parse_and_eval_long (count_exp
);
1675 struct frame_info
*current
;
1680 while (current
&& count
--)
1683 current
= get_prev_frame (current
);
1686 /* Will stop when CURRENT reaches the top of the stack.
1687 TRAILING will be COUNT below it. */
1691 trailing
= get_prev_frame (trailing
);
1692 current
= get_prev_frame (current
);
1704 /* Read in symbols for all of the frames. Need to do this in a
1705 separate pass so that "Reading in symbols for xxx" messages
1706 don't screw up the appearance of the backtrace. Also if
1707 people have strong opinions against reading symbols for
1708 backtrace this may have to be an option. */
1710 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1715 pc
= get_frame_address_in_block (fi
);
1716 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1720 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1724 /* Don't use print_stack_frame; if an error() occurs it probably
1725 means further attempts to backtrace would fail (on the other
1726 hand, perhaps the code does or could be fixed to make sure
1727 the frame->prev field gets set to NULL in that case). */
1728 print_frame_info (fi
, 1, LOCATION
, 1);
1731 struct frame_id frame_id
= get_frame_id (fi
);
1733 print_frame_local_vars (fi
, 1, gdb_stdout
);
1735 /* print_frame_local_vars invalidates FI. */
1736 fi
= frame_find_by_id (frame_id
);
1740 warning (_("Unable to restore previously selected frame."));
1745 /* Save the last frame to check for error conditions. */
1749 /* If we've stopped before the end, mention that. */
1751 printf_filtered (_("(More stack frames follow...)\n"));
1753 /* If we've run out of frames, and the reason appears to be an error
1754 condition, print it. */
1755 if (fi
== NULL
&& trailing
!= NULL
)
1757 enum unwind_stop_reason reason
;
1759 reason
= get_frame_unwind_stop_reason (trailing
);
1760 if (reason
>= UNWIND_FIRST_ERROR
)
1761 printf_filtered (_("Backtrace stopped: %s\n"),
1762 frame_stop_reason_string (reason
));
1767 backtrace_command (char *arg
, int from_tty
)
1769 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1770 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1777 argv
= gdb_buildargv (arg
);
1778 make_cleanup_freeargv (argv
);
1780 for (i
= 0; argv
[i
]; i
++)
1784 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1785 argv
[i
][j
] = tolower (argv
[i
][j
]);
1787 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1788 fulltrace_arg
= argc
;
1791 arglen
+= strlen (argv
[i
]);
1796 if (fulltrace_arg
>= 0)
1800 arg
= xmalloc (arglen
+ 1);
1801 make_cleanup (xfree
, arg
);
1803 for (i
= 0; i
< (argc
+ 1); i
++)
1805 if (i
!= fulltrace_arg
)
1807 strcat (arg
, argv
[i
]);
1817 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1819 do_cleanups (old_chain
);
1823 backtrace_full_command (char *arg
, int from_tty
)
1825 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1829 /* Iterate over the local variables of a block B, calling CB with
1833 iterate_over_block_locals (struct block
*b
,
1834 iterate_over_block_arg_local_vars_cb cb
,
1837 struct block_iterator iter
;
1840 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1842 switch (SYMBOL_CLASS (sym
))
1848 if (SYMBOL_IS_ARGUMENT (sym
))
1850 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1852 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1856 /* Ignore symbols which are not locals. */
1863 /* Same, but print labels. */
1866 /* Commented out, as the code using this function has also been
1867 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1868 was commented out in the first place. The discussion introducing
1869 this change (2007-12-04: Support lexical blocks and function bodies
1870 that occupy non-contiguous address ranges) did not explain why
1871 this change was made. */
1873 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1874 int *have_default
, struct ui_file
*stream
)
1876 struct block_iterator iter
;
1878 int values_printed
= 0;
1880 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1882 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1888 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1890 struct symtab_and_line sal
;
1891 struct value_print_options opts
;
1893 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1895 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1896 get_user_print_options (&opts
);
1897 if (opts
.addressprint
)
1899 fprintf_filtered (stream
, " ");
1900 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1903 fprintf_filtered (stream
, " in file %s, line %d\n",
1904 sal
.symtab
->filename
, sal
.line
);
1908 return values_printed
;
1912 /* Iterate over all the local variables in block B, including all its
1913 superblocks, stopping when the top-level block is reached. */
1916 iterate_over_block_local_vars (struct block
*block
,
1917 iterate_over_block_arg_local_vars_cb cb
,
1922 iterate_over_block_locals (block
, cb
, cb_data
);
1923 /* After handling the function's top-level block, stop. Don't
1924 continue to its superblock, the block of per-file
1926 if (BLOCK_FUNCTION (block
))
1928 block
= BLOCK_SUPERBLOCK (block
);
1932 /* Data to be passed around in the calls to the locals and args
1935 struct print_variable_and_value_data
1937 struct frame_id frame_id
;
1939 struct ui_file
*stream
;
1943 /* The callback for the locals and args iterators. */
1946 do_print_variable_and_value (const char *print_name
,
1950 struct print_variable_and_value_data
*p
= cb_data
;
1951 struct frame_info
*frame
;
1953 frame
= frame_find_by_id (p
->frame_id
);
1956 warning (_("Unable to restore previously selected frame."));
1960 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
1962 /* print_variable_and_value invalidates FRAME. */
1965 p
->values_printed
= 1;
1968 /* Print all variables from the innermost up to the function block of FRAME.
1969 Print them with values to STREAM indented by NUM_TABS.
1971 This function will invalidate FRAME. */
1974 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1975 struct ui_file
*stream
)
1977 struct print_variable_and_value_data cb_data
;
1978 struct block
*block
;
1981 if (!get_frame_pc_if_available (frame
, &pc
))
1983 fprintf_filtered (stream
,
1984 _("PC unavailable, cannot determine locals.\n"));
1988 block
= get_frame_block (frame
, 0);
1991 fprintf_filtered (stream
, "No symbol table info available.\n");
1995 cb_data
.frame_id
= get_frame_id (frame
);
1996 cb_data
.num_tabs
= 4 * num_tabs
;
1997 cb_data
.stream
= stream
;
1998 cb_data
.values_printed
= 0;
2000 iterate_over_block_local_vars (block
,
2001 do_print_variable_and_value
,
2004 /* do_print_variable_and_value invalidates FRAME. */
2007 if (!cb_data
.values_printed
)
2008 fprintf_filtered (stream
, _("No locals.\n"));
2012 locals_info (char *args
, int from_tty
)
2014 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2018 /* Iterate over all the argument variables in block B.
2020 Returns 1 if any argument was walked; 0 otherwise. */
2023 iterate_over_block_arg_vars (struct block
*b
,
2024 iterate_over_block_arg_local_vars_cb cb
,
2027 struct block_iterator iter
;
2028 struct symbol
*sym
, *sym2
;
2030 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2032 /* Don't worry about things which aren't arguments. */
2033 if (SYMBOL_IS_ARGUMENT (sym
))
2035 /* We have to look up the symbol because arguments can have
2036 two entries (one a parameter, one a local) and the one we
2037 want is the local, which lookup_symbol will find for us.
2038 This includes gcc1 (not gcc2) on the sparc when passing a
2039 small structure and gcc2 when the argument type is float
2040 and it is passed as a double and converted to float by
2041 the prologue (in the latter case the type of the LOC_ARG
2042 symbol is double and the type of the LOC_LOCAL symbol is
2043 float). There are also LOC_ARG/LOC_REGISTER pairs which
2044 are not combined in symbol-reading. */
2046 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2047 b
, VAR_DOMAIN
, NULL
);
2048 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2053 /* Print all argument variables of the function of FRAME.
2054 Print them with values to STREAM.
2056 This function will invalidate FRAME. */
2059 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2061 struct print_variable_and_value_data cb_data
;
2062 struct symbol
*func
;
2065 if (!get_frame_pc_if_available (frame
, &pc
))
2067 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2071 func
= get_frame_function (frame
);
2074 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2078 cb_data
.frame_id
= get_frame_id (frame
);
2079 cb_data
.num_tabs
= 0;
2080 cb_data
.stream
= gdb_stdout
;
2081 cb_data
.values_printed
= 0;
2083 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2084 do_print_variable_and_value
, &cb_data
);
2086 /* do_print_variable_and_value invalidates FRAME. */
2089 if (!cb_data
.values_printed
)
2090 fprintf_filtered (stream
, _("No arguments.\n"));
2094 args_info (char *ignore
, int from_tty
)
2096 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2102 args_plus_locals_info (char *ignore
, int from_tty
)
2104 args_info (ignore
, from_tty
);
2105 locals_info (ignore
, from_tty
);
2109 /* Select frame FRAME. Also print the stack frame and show the source
2110 if this is the tui version. */
2112 select_and_print_frame (struct frame_info
*frame
)
2114 select_frame (frame
);
2116 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2119 /* Return the symbol-block in which the selected frame is executing.
2120 Can return zero under various legitimate circumstances.
2122 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2123 code address within the block returned. We use this to decide
2124 which macros are in scope. */
2127 get_selected_block (CORE_ADDR
*addr_in_block
)
2129 if (!has_stack_frames ())
2132 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2135 /* Find a frame a certain number of levels away from FRAME.
2136 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2137 Positive means go to earlier frames (up); negative, the reverse.
2138 The int that contains the number of levels is counted toward
2139 zero as the frames for those levels are found.
2140 If the top or bottom frame is reached, that frame is returned,
2141 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2142 how much farther the original request asked to go. */
2145 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2147 /* Going up is simple: just call get_prev_frame enough times or
2148 until the initial frame is reached. */
2149 while (*level_offset_ptr
> 0)
2151 struct frame_info
*prev
= get_prev_frame (frame
);
2155 (*level_offset_ptr
)--;
2159 /* Going down is just as simple. */
2160 while (*level_offset_ptr
< 0)
2162 struct frame_info
*next
= get_next_frame (frame
);
2166 (*level_offset_ptr
)++;
2173 /* The "select_frame" command. With no argument this is a NOP.
2174 Select the frame at level LEVEL_EXP if it is a valid level.
2175 Otherwise, treat LEVEL_EXP as an address expression and select it.
2177 See parse_frame_specification for more info on proper frame
2181 select_frame_command (char *level_exp
, int from_tty
)
2183 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2186 /* The "frame" command. With no argument, print the selected frame
2187 briefly. With an argument, behave like select_frame and then print
2188 the selected frame. */
2191 frame_command (char *level_exp
, int from_tty
)
2193 select_frame_command (level_exp
, from_tty
);
2194 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2197 /* The XDB Compatibility command to print the current frame. */
2200 current_frame_command (char *level_exp
, int from_tty
)
2202 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2205 /* Select the frame up one or COUNT_EXP stack levels from the
2206 previously selected frame, and print it briefly. */
2209 up_silently_base (char *count_exp
)
2211 struct frame_info
*frame
;
2215 count
= parse_and_eval_long (count_exp
);
2217 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2218 if (count
!= 0 && count_exp
== NULL
)
2219 error (_("Initial frame selected; you cannot go up."));
2220 select_frame (frame
);
2224 up_silently_command (char *count_exp
, int from_tty
)
2226 up_silently_base (count_exp
);
2230 up_command (char *count_exp
, int from_tty
)
2232 up_silently_base (count_exp
);
2233 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2236 /* Select the frame down one or COUNT_EXP stack levels from the previously
2237 selected frame, and print it briefly. */
2240 down_silently_base (char *count_exp
)
2242 struct frame_info
*frame
;
2246 count
= -parse_and_eval_long (count_exp
);
2248 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2249 if (count
!= 0 && count_exp
== NULL
)
2251 /* We only do this if COUNT_EXP is not specified. That way
2252 "down" means to really go down (and let me know if that is
2253 impossible), but "down 9999" can be used to mean go all the
2254 way down without getting an error. */
2256 error (_("Bottom (innermost) frame selected; you cannot go down."));
2259 select_frame (frame
);
2263 down_silently_command (char *count_exp
, int from_tty
)
2265 down_silently_base (count_exp
);
2269 down_command (char *count_exp
, int from_tty
)
2271 down_silently_base (count_exp
);
2272 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2277 return_command (char *retval_exp
, int from_tty
)
2279 struct frame_info
*thisframe
;
2280 struct gdbarch
*gdbarch
;
2281 struct symbol
*thisfun
;
2282 struct value
*return_value
= NULL
;
2283 struct value
*function
= NULL
;
2284 const char *query_prefix
= "";
2286 thisframe
= get_selected_frame ("No selected frame.");
2287 thisfun
= get_frame_function (thisframe
);
2288 gdbarch
= get_frame_arch (thisframe
);
2290 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2291 error (_("Can not force return from an inlined function."));
2293 /* Compute the return value. If the computation triggers an error,
2294 let it bail. If the return type can't be handled, set
2295 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2299 struct expression
*retval_expr
= parse_expression (retval_exp
);
2300 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2301 struct type
*return_type
= NULL
;
2303 /* Compute the return value. Should the computation fail, this
2304 call throws an error. */
2305 return_value
= evaluate_expression (retval_expr
);
2307 /* Cast return value to the return type of the function. Should
2308 the cast fail, this call throws an error. */
2309 if (thisfun
!= NULL
)
2310 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2311 if (return_type
== NULL
)
2313 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2314 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2315 error (_("Return value type not available for selected "
2317 "Please use an explicit cast of the value to return."));
2318 return_type
= value_type (return_value
);
2320 do_cleanups (old_chain
);
2321 CHECK_TYPEDEF (return_type
);
2322 return_value
= value_cast (return_type
, return_value
);
2324 /* Make sure the value is fully evaluated. It may live in the
2325 stack frame we're about to pop. */
2326 if (value_lazy (return_value
))
2327 value_fetch_lazy (return_value
);
2329 if (thisfun
!= NULL
)
2330 function
= read_var_value (thisfun
, thisframe
);
2332 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2333 /* If the return-type is "void", don't try to find the
2334 return-value's location. However, do still evaluate the
2335 return expression so that, even when the expression result
2336 is discarded, side effects such as "return i++" still
2338 return_value
= NULL
;
2339 else if (thisfun
!= NULL
2340 && using_struct_return (gdbarch
, function
, return_type
))
2342 query_prefix
= "The location at which to store the "
2343 "function's return value is unknown.\n"
2344 "If you continue, the return value "
2345 "that you specified will be ignored.\n";
2346 return_value
= NULL
;
2350 /* Does an interactive user really want to do this? Include
2351 information, such as how well GDB can handle the return value, in
2352 the query message. */
2357 if (thisfun
== NULL
)
2358 confirmed
= query (_("%sMake selected stack frame return now? "),
2361 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2362 SYMBOL_PRINT_NAME (thisfun
));
2364 error (_("Not confirmed"));
2367 /* Discard the selected frame and all frames inner-to it. */
2368 frame_pop (get_selected_frame (NULL
));
2370 /* Store RETURN_VALUE in the just-returned register set. */
2371 if (return_value
!= NULL
)
2373 struct type
*return_type
= value_type (return_value
);
2374 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2376 gdb_assert (gdbarch_return_value (gdbarch
, function
, return_type
, NULL
,
2378 == RETURN_VALUE_REGISTER_CONVENTION
);
2379 gdbarch_return_value (gdbarch
, function
, return_type
,
2380 get_current_regcache (), NULL
/*read*/,
2381 value_contents (return_value
) /*write*/);
2384 /* If we are at the end of a call dummy now, pop the dummy frame
2386 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2387 frame_pop (get_current_frame ());
2389 /* If interactive, print the frame that is now current. */
2391 frame_command ("0", 1);
2393 select_frame_command ("0", 0);
2396 /* Sets the scope to input function name, provided that the function
2397 is within the current stack frame. */
2399 struct function_bounds
2401 CORE_ADDR low
, high
;
2405 func_command (char *arg
, int from_tty
)
2407 struct frame_info
*frame
;
2409 struct symtabs_and_lines sals
;
2412 struct function_bounds
*func_bounds
= NULL
;
2413 struct cleanup
*cleanups
;
2418 frame
= parse_frame_specification ("0");
2419 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2420 cleanups
= make_cleanup (xfree
, sals
.sals
);
2421 func_bounds
= (struct function_bounds
*) xmalloc (
2422 sizeof (struct function_bounds
) * sals
.nelts
);
2423 make_cleanup (xfree
, func_bounds
);
2424 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2426 if (sals
.sals
[i
].pspace
!= current_program_space
)
2427 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2428 else if (sals
.sals
[i
].pc
== 0
2429 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2430 &func_bounds
[i
].low
,
2431 &func_bounds
[i
].high
) == 0)
2433 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2439 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2440 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2441 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2445 frame
= find_relative_frame (frame
, &level
);
2448 while (!found
&& level
== 0);
2450 do_cleanups (cleanups
);
2453 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2454 else if (frame
!= get_selected_frame (NULL
))
2455 select_and_print_frame (frame
);
2458 /* Gets the language of the current frame. */
2461 get_frame_language (void)
2463 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2467 volatile struct gdb_exception ex
;
2471 /* We determine the current frame language by looking up its
2472 associated symtab. To retrieve this symtab, we use the frame
2473 PC. However we cannot use the frame PC as is, because it
2474 usually points to the instruction following the "call", which
2475 is sometimes the first instruction of another function. So
2476 we rely on get_frame_address_in_block(), it provides us with
2477 a PC that is guaranteed to be inside the frame's code
2480 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2482 pc
= get_frame_address_in_block (frame
);
2486 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2487 throw_exception (ex
);
2491 s
= find_pc_symtab (pc
);
2497 return language_unknown
;
2501 /* Provide a prototype to silence -Wmissing-prototypes. */
2502 void _initialize_stack (void);
2505 _initialize_stack (void)
2507 add_com ("return", class_stack
, return_command
, _("\
2508 Make selected stack frame return to its caller.\n\
2509 Control remains in the debugger, but when you continue\n\
2510 execution will resume in the frame above the one now selected.\n\
2511 If an argument is given, it is an expression for the value to return."));
2513 add_com ("up", class_stack
, up_command
, _("\
2514 Select and print stack frame that called this one.\n\
2515 An argument says how many frames up to go."));
2516 add_com ("up-silently", class_support
, up_silently_command
, _("\
2517 Same as the `up' command, but does not print anything.\n\
2518 This is useful in command scripts."));
2520 add_com ("down", class_stack
, down_command
, _("\
2521 Select and print stack frame called by this one.\n\
2522 An argument says how many frames down to go."));
2523 add_com_alias ("do", "down", class_stack
, 1);
2524 add_com_alias ("dow", "down", class_stack
, 1);
2525 add_com ("down-silently", class_support
, down_silently_command
, _("\
2526 Same as the `down' command, but does not print anything.\n\
2527 This is useful in command scripts."));
2529 add_com ("frame", class_stack
, frame_command
, _("\
2530 Select and print a stack frame.\nWith no argument, \
2531 print the selected stack frame. (See also \"info frame\").\n\
2532 An argument specifies the frame to select.\n\
2533 It can be a stack frame number or the address of the frame.\n\
2534 With argument, nothing is printed if input is coming from\n\
2535 a command file or a user-defined command."));
2537 add_com_alias ("f", "frame", class_stack
, 1);
2541 add_com ("L", class_stack
, current_frame_command
,
2542 _("Print the current stack frame.\n"));
2543 add_com_alias ("V", "frame", class_stack
, 1);
2545 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2546 Select a stack frame without printing anything.\n\
2547 An argument specifies the frame to select.\n\
2548 It can be a stack frame number or the address of the frame.\n"));
2550 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2551 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2552 With a negative argument, print outermost -COUNT frames.\nUse of the \
2553 'full' qualifier also prints the values of the local variables.\n"));
2554 add_com_alias ("bt", "backtrace", class_stack
, 0);
2557 add_com_alias ("t", "backtrace", class_stack
, 0);
2558 add_com ("T", class_stack
, backtrace_full_command
, _("\
2559 Print backtrace of all stack frames, or innermost COUNT frames\n\
2560 and the values of the local variables.\n\
2561 With a negative argument, print outermost -COUNT frames.\n\
2562 Usage: T <count>\n"));
2565 add_com_alias ("where", "backtrace", class_alias
, 0);
2566 add_info ("stack", backtrace_command
,
2567 _("Backtrace of the stack, or innermost COUNT frames."));
2568 add_info_alias ("s", "stack", 1);
2569 add_info ("frame", frame_info
,
2570 _("All about selected stack frame, or frame at ADDR."));
2571 add_info_alias ("f", "frame", 1);
2572 add_info ("locals", locals_info
,
2573 _("Local variables of current stack frame."));
2574 add_info ("args", args_info
,
2575 _("Argument variables of current stack frame."));
2577 add_com ("l", class_info
, args_plus_locals_info
,
2578 _("Argument and local variables of current stack frame."));
2581 add_com ("func", class_stack
, func_command
, _("\
2582 Select the stack frame that contains <func>.\n\
2583 Usage: func <name>\n"));
2585 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2586 print_frame_arguments_choices
, &print_frame_arguments
,
2587 _("Set printing of non-scalar frame arguments"),
2588 _("Show printing of non-scalar frame arguments"),
2589 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2591 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2592 &disassemble_next_line
, _("\
2593 Set whether to disassemble next source line or insn when execution stops."),
2595 Show whether to disassemble next source line or insn when execution stops."),
2597 If ON, GDB will display disassembly of the next source line, in addition\n\
2598 to displaying the source line itself. If the next source line cannot\n\
2599 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2600 will display disassembly of next instruction instead of showing the\n\
2602 If AUTO, display disassembly of next instruction only if the source line\n\
2603 cannot be displayed.\n\
2604 If OFF (which is the default), never display the disassembly of the next\n\
2607 show_disassemble_next_line
,
2608 &setlist
, &showlist
);
2609 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2611 add_setshow_enum_cmd ("entry-values", class_stack
,
2612 print_entry_values_choices
, &print_entry_values
,
2613 _("Set printing of function arguments at function "
2615 _("Show printing of function arguments at function "
2618 GDB can sometimes determine the values of function arguments at entry,\n\
2619 in addition to their current values. This option tells GDB whether\n\
2620 to print the current value, the value at entry (marked as val@entry),\n\
2621 or both. Note that one or both of these values may be <optimized out>."),
2622 NULL
, NULL
, &setprintlist
, &showprintlist
);