1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
33 #include "breakpoint.h"
40 #include "dictionary.h"
41 #include "exceptions.h"
42 #include "reggroups.h"
46 #include "gdbthread.h"
47 #include "cp-support.h"
49 #include "inline-frame.h"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
58 void (*deprecated_selected_frame_level_changed_hook
) (int);
60 /* The possible choices of "set print frame-arguments", and the value
63 static const char *print_frame_arguments_choices
[] =
64 {"all", "scalars", "none", NULL
};
65 static const char *print_frame_arguments
= "scalars";
67 /* The possible choices of "set print entry-values", and the value
70 const char print_entry_values_no
[] = "no";
71 const char print_entry_values_only
[] = "only";
72 const char print_entry_values_preferred
[] = "preferred";
73 const char print_entry_values_if_needed
[] = "if-needed";
74 const char print_entry_values_both
[] = "both";
75 const char print_entry_values_compact
[] = "compact";
76 const char print_entry_values_default
[] = "default";
77 static const char *print_entry_values_choices
[] =
79 print_entry_values_no
,
80 print_entry_values_only
,
81 print_entry_values_preferred
,
82 print_entry_values_if_needed
,
83 print_entry_values_both
,
84 print_entry_values_compact
,
85 print_entry_values_default
,
88 const char *print_entry_values
= print_entry_values_default
;
90 /* Prototypes for local functions. */
92 static void print_frame_local_vars (struct frame_info
*, int,
95 static void print_frame (struct frame_info
*frame
, int print_level
,
96 enum print_what print_what
, int print_args
,
97 struct symtab_and_line sal
);
99 /* Zero means do things normally; we are interacting directly with the
100 user. One means print the full filename and linenumber when a
101 frame is printed, and do so in a format emacs18/emacs19.22 can
102 parse. Two means print similar annotations, but in many more
103 cases and in a slightly different syntax. */
105 int annotation_level
= 0;
108 /* Return 1 if we should display the address in addition to the location,
109 because we are in the middle of a statement. */
112 frame_show_address (struct frame_info
*frame
,
113 struct symtab_and_line sal
)
115 /* If there is a line number, but no PC, then there is no location
116 information associated with this sal. The only way that should
117 happen is for the call sites of inlined functions (SAL comes from
118 find_frame_sal). Otherwise, we would have some PC range if the
119 SAL came from a line table. */
120 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
122 if (get_next_frame (frame
) == NULL
)
123 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
125 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
129 return get_frame_pc (frame
) != sal
.pc
;
132 /* Show or print a stack frame FRAME briefly. The output is format
133 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
134 relative level, function name, argument list, and file name and
135 line number. If the frame's PC is not at the beginning of the
136 source line, the actual PC is printed at the beginning. */
139 print_stack_frame (struct frame_info
*frame
, int print_level
,
140 enum print_what print_what
)
142 volatile struct gdb_exception e
;
144 /* For mi, alway print location and address. */
145 if (ui_out_is_mi_like_p (current_uiout
))
146 print_what
= LOC_AND_ADDRESS
;
148 TRY_CATCH (e
, RETURN_MASK_ERROR
)
150 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
152 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
153 set_current_sal_from_frame (frame
, center
);
157 /* Print nameless arguments of frame FRAME on STREAM, where START is
158 the offset of the first nameless argument, and NUM is the number of
159 nameless arguments to print. FIRST is nonzero if this is the first
160 argument (not just the first nameless argument). */
163 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
164 int first
, struct ui_file
*stream
)
166 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
167 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
172 for (i
= 0; i
< num
; i
++)
175 argsaddr
= get_frame_args_address (frame
);
178 arg_value
= read_memory_integer (argsaddr
+ start
,
179 sizeof (int), byte_order
);
181 fprintf_filtered (stream
, ", ");
182 fprintf_filtered (stream
, "%ld", arg_value
);
184 start
+= sizeof (int);
188 /* Print single argument of inferior function. ARG must be already
191 Errors are printed as if they would be the parameter value. Use zeroed ARG
192 iff it should not be printed accoring to user settings. */
195 print_frame_arg (const struct frame_arg
*arg
)
197 struct ui_out
*uiout
= current_uiout
;
198 volatile struct gdb_exception except
;
199 struct cleanup
*old_chain
;
200 struct ui_stream
*stb
;
202 stb
= ui_out_stream_new (uiout
);
203 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
205 gdb_assert (!arg
->val
|| !arg
->error
);
206 gdb_assert (arg
->entry_kind
== print_entry_values_no
207 || arg
->entry_kind
== print_entry_values_only
208 || (!ui_out_is_mi_like_p (uiout
)
209 && arg
->entry_kind
== print_entry_values_compact
));
211 annotate_arg_begin ();
213 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
214 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
215 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
216 if (arg
->entry_kind
== print_entry_values_compact
)
218 /* It is OK to provide invalid MI-like stream as with
219 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
220 fputs_filtered ("=", stb
->stream
);
222 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (arg
->sym
),
223 SYMBOL_LANGUAGE (arg
->sym
),
224 DMGL_PARAMS
| DMGL_ANSI
);
226 if (arg
->entry_kind
== print_entry_values_only
227 || arg
->entry_kind
== print_entry_values_compact
)
228 fputs_filtered ("@entry", stb
->stream
);
229 ui_out_field_stream (uiout
, "name", stb
);
230 annotate_arg_name_end ();
231 ui_out_text (uiout
, "=");
233 if (!arg
->val
&& !arg
->error
)
234 ui_out_text (uiout
, "...");
238 except
.message
= arg
->error
;
241 /* TRY_CATCH has two statements, wrap it in a block. */
243 TRY_CATCH (except
, RETURN_MASK_ERROR
)
245 const struct language_defn
*language
;
246 struct value_print_options opts
;
248 /* Avoid value_print because it will deref ref parameters. We
249 just want to print their addresses. Print ??? for args whose
250 address we do not know. We pass 2 as "recurse" to val_print
251 because our standard indentation here is 4 spaces, and
252 val_print indents 2 for each recurse. */
254 annotate_arg_value (value_type (arg
->val
));
256 /* Use the appropriate language to display our symbol, unless the
257 user forced the language to a specific language. */
258 if (language_mode
== language_mode_auto
)
259 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
261 language
= current_language
;
263 get_raw_print_options (&opts
);
266 /* True in "summary" mode, false otherwise. */
267 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
269 common_val_print (arg
->val
, stb
->stream
, 2, &opts
, language
);
273 fprintf_filtered (stb
->stream
, _("<error reading variable: %s>"),
277 ui_out_field_stream (uiout
, "value", stb
);
279 /* Aleo invoke ui_out_tuple_end. */
280 do_cleanups (old_chain
);
285 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
286 responsible for xfree of ARGP->ERROR. This function never throws an
290 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
291 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
293 struct value
*val
= NULL
, *entryval
= NULL
;
294 char *val_error
= NULL
, *entryval_error
= NULL
;
296 volatile struct gdb_exception except
;
298 if (print_entry_values
!= print_entry_values_only
299 && print_entry_values
!= print_entry_values_preferred
)
301 TRY_CATCH (except
, RETURN_MASK_ERROR
)
303 val
= read_var_value (sym
, frame
);
307 val_error
= alloca (strlen (except
.message
) + 1);
308 strcpy (val_error
, except
.message
);
312 if (SYMBOL_CLASS (sym
) == LOC_COMPUTED
313 && print_entry_values
!= print_entry_values_no
314 && (print_entry_values
!= print_entry_values_if_needed
315 || !val
|| value_optimized_out (val
)))
317 TRY_CATCH (except
, RETURN_MASK_ERROR
)
319 const struct symbol_computed_ops
*ops
;
321 ops
= SYMBOL_COMPUTED_OPS (sym
);
322 entryval
= ops
->read_variable_at_entry (sym
, frame
);
326 entryval_error
= alloca (strlen (except
.message
) + 1);
327 strcpy (entryval_error
, except
.message
);
330 if (except
.error
== NO_ENTRY_VALUE_ERROR
331 || (entryval
&& value_optimized_out (entryval
)))
334 entryval_error
= NULL
;
337 if (print_entry_values
== print_entry_values_compact
338 || print_entry_values
== print_entry_values_default
)
340 /* For MI do not try to use print_entry_values_compact for ARGP. */
342 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
344 unsigned len
= TYPE_LENGTH (value_type (val
));
346 if (!value_optimized_out (val
) && value_lazy (val
))
347 value_fetch_lazy (val
);
348 if (!value_optimized_out (val
) && value_lazy (entryval
))
349 value_fetch_lazy (entryval
);
350 if (!value_optimized_out (val
)
351 && value_available_contents_eq (val
, 0, entryval
, 0, len
))
353 /* Initialize it just to avoid a GCC false warning. */
354 struct value
*val_deref
= NULL
, *entryval_deref
;
356 /* DW_AT_GNU_call_site_value does match with the current
357 value. If it is a reference still try to verify if
358 dereferenced DW_AT_GNU_call_site_data_value does not
361 TRY_CATCH (except
, RETURN_MASK_ERROR
)
365 val_deref
= coerce_ref (val
);
366 if (value_lazy (val_deref
))
367 value_fetch_lazy (val_deref
);
368 len_deref
= TYPE_LENGTH (value_type (val_deref
));
370 entryval_deref
= coerce_ref (entryval
);
371 if (value_lazy (entryval_deref
))
372 value_fetch_lazy (entryval_deref
);
374 /* If the reference addresses match but dereferenced
375 content does not match print them. */
377 && value_available_contents_eq (val_deref
, 0,
383 /* Value was not a reference; and its content matches. */
384 if (val
== val_deref
)
386 /* If the dereferenced content could not be fetched do not
388 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
390 else if (except
.message
)
392 entryval_error
= alloca (strlen (except
.message
) + 1);
393 strcpy (entryval_error
, except
.message
);
401 /* Try to remove possibly duplicate error message for ENTRYARGP even
404 if (val_error
&& entryval_error
405 && strcmp (val_error
, entryval_error
) == 0)
407 entryval_error
= NULL
;
409 /* Do not se VAL_EQUAL as the same error message may be shown for
410 the entry value even if no entry values are present in the
416 if (entryval
== NULL
)
418 if (print_entry_values
== print_entry_values_preferred
)
420 TRY_CATCH (except
, RETURN_MASK_ERROR
)
422 val
= read_var_value (sym
, frame
);
426 val_error
= alloca (strlen (except
.message
) + 1);
427 strcpy (val_error
, except
.message
);
430 if (print_entry_values
== print_entry_values_only
431 || print_entry_values
== print_entry_values_both
432 || (print_entry_values
== print_entry_values_preferred
433 && (!val
|| value_optimized_out (val
))))
434 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
436 if ((print_entry_values
== print_entry_values_compact
437 || print_entry_values
== print_entry_values_if_needed
438 || print_entry_values
== print_entry_values_preferred
)
439 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
447 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
448 if (!val
&& !val_error
)
449 argp
->entry_kind
= print_entry_values_only
;
450 else if ((print_entry_values
== print_entry_values_compact
451 || print_entry_values
== print_entry_values_default
) && val_equal
)
453 argp
->entry_kind
= print_entry_values_compact
;
454 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
457 argp
->entry_kind
= print_entry_values_no
;
459 entryargp
->sym
= sym
;
460 entryargp
->val
= entryval
;
461 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
462 if (!entryval
&& !entryval_error
)
463 entryargp
->entry_kind
= print_entry_values_no
;
465 entryargp
->entry_kind
= print_entry_values_only
;
468 /* Print the arguments of frame FRAME on STREAM, given the function
469 FUNC running in that frame (as a symbol), where NUM is the number
470 of arguments according to the stack frame (or -1 if the number of
471 arguments is unknown). */
473 /* Note that currently the "number of arguments according to the
474 stack frame" is only known on VAX where i refers to the "number of
475 ints of arguments according to the stack frame". */
478 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
479 int num
, struct ui_file
*stream
)
481 struct ui_out
*uiout
= current_uiout
;
483 /* Offset of next stack argument beyond the one we have seen that is
484 at the highest offset, or -1 if we haven't come to a stack
486 long highest_offset
= -1;
487 /* Number of ints of arguments that we have printed so far. */
488 int args_printed
= 0;
489 struct cleanup
*old_chain
, *list_chain
;
490 struct ui_stream
*stb
;
491 /* True if we should print arguments, false otherwise. */
492 int print_args
= strcmp (print_frame_arguments
, "none");
493 /* True in "summary" mode, false otherwise. */
494 int summary
= !strcmp (print_frame_arguments
, "scalars");
496 stb
= ui_out_stream_new (uiout
);
497 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
501 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
502 struct dict_iterator iter
;
505 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
507 struct frame_arg arg
, entryarg
;
511 /* Keep track of the highest stack argument offset seen, and
512 skip over any kinds of symbols we don't care about. */
514 if (!SYMBOL_IS_ARGUMENT (sym
))
517 switch (SYMBOL_CLASS (sym
))
522 long current_offset
= SYMBOL_VALUE (sym
);
523 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
525 /* Compute address of next argument by adding the size of
526 this argument and rounding to an int boundary. */
528 ((current_offset
+ arg_size
+ sizeof (int) - 1)
529 & ~(sizeof (int) - 1));
531 /* If this is the highest offset seen yet, set
533 if (highest_offset
== -1
534 || (current_offset
> highest_offset
))
535 highest_offset
= current_offset
;
537 /* Add the number of ints we're about to print to
539 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
542 /* We care about types of symbols, but don't need to
543 keep track of stack offsets in them. */
545 case LOC_REGPARM_ADDR
:
547 case LOC_OPTIMIZED_OUT
:
552 /* We have to look up the symbol because arguments can have
553 two entries (one a parameter, one a local) and the one we
554 want is the local, which lookup_symbol will find for us.
555 This includes gcc1 (not gcc2) on SPARC when passing a
556 small structure and gcc2 when the argument type is float
557 and it is passed as a double and converted to float by
558 the prologue (in the latter case the type of the LOC_ARG
559 symbol is double and the type of the LOC_LOCAL symbol is
561 /* But if the parameter name is null, don't try it. Null
562 parameter names occur on the RS/6000, for traceback
563 tables. FIXME, should we even print them? */
565 if (*SYMBOL_LINKAGE_NAME (sym
))
569 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
570 b
, VAR_DOMAIN
, NULL
);
571 gdb_assert (nsym
!= NULL
);
572 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
573 && !SYMBOL_IS_ARGUMENT (nsym
))
575 /* There is a LOC_ARG/LOC_REGISTER pair. This means
576 that it was passed on the stack and loaded into a
577 register, or passed in a register and stored in a
578 stack slot. GDB 3.x used the LOC_ARG; GDB
579 4.0-4.11 used the LOC_REGISTER.
581 Reasons for using the LOC_ARG:
583 (1) Because find_saved_registers may be slow for
586 (2) Because registers are often re-used and stack
587 slots rarely (never?) are. Therefore using
588 the stack slot is much less likely to print
591 Reasons why we might want to use the LOC_REGISTER:
593 (1) So that the backtrace prints the same value
594 as "print foo". I see no compelling reason
595 why this needs to be the case; having the
596 backtrace print the value which was passed
597 in, and "print foo" print the value as
598 modified within the called function, makes
601 Additional note: It might be nice if "info args"
602 displayed both values.
604 One more note: There is a case with SPARC
605 structure passing where we need to use the
606 LOC_REGISTER, but this is dealt with by creating
607 a single LOC_REGPARM in symbol reading. */
609 /* Leave sym (the LOC_ARG) alone. */
616 /* Print the current arg. */
618 ui_out_text (uiout
, ", ");
619 ui_out_wrap_hint (uiout
, " ");
623 memset (&arg
, 0, sizeof (arg
));
625 arg
.entry_kind
= print_entry_values_no
;
626 memset (&entryarg
, 0, sizeof (entryarg
));
628 entryarg
.entry_kind
= print_entry_values_no
;
631 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
633 if (arg
.entry_kind
!= print_entry_values_only
)
634 print_frame_arg (&arg
);
636 if (entryarg
.entry_kind
!= print_entry_values_no
)
638 if (arg
.entry_kind
!= print_entry_values_only
)
640 ui_out_text (uiout
, ", ");
641 ui_out_wrap_hint (uiout
, " ");
644 print_frame_arg (&entryarg
);
648 xfree (entryarg
.error
);
654 /* Don't print nameless args in situations where we don't know
655 enough about the stack to find them. */
660 if (highest_offset
== -1)
661 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
663 start
= highest_offset
;
665 print_frame_nameless_args (frame
, start
, num
- args_printed
,
669 do_cleanups (old_chain
);
672 /* Set the current source and line to the location given by frame
673 FRAME, if possible. When CENTER is true, adjust so the relevant
674 line is in the center of the next 'list'. */
677 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
679 struct symtab_and_line sal
;
681 find_frame_sal (frame
, &sal
);
685 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
686 set_current_source_symtab_and_line (&sal
);
690 /* If ON, GDB will display disassembly of the next source line when
691 execution of the program being debugged stops.
692 If AUTO (which is the default), or there's no line info to determine
693 the source line of the next instruction, display disassembly of next
694 instruction instead. */
696 static enum auto_boolean disassemble_next_line
;
699 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
700 struct cmd_list_element
*c
,
703 fprintf_filtered (file
,
704 _("Debugger's willingness to use "
705 "disassemble-next-line is %s.\n"),
709 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
710 because it will be broken by filter sometime. */
713 do_gdb_disassembly (struct gdbarch
*gdbarch
,
714 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
716 volatile struct gdb_exception exception
;
718 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
720 gdb_disassembly (gdbarch
, current_uiout
, 0,
721 DISASSEMBLY_RAW_INSN
, how_many
,
724 if (exception
.reason
< 0)
726 /* If an exception was thrown while doing the disassembly, print
727 the error message, to give the user a clue of what happened. */
728 exception_print (gdb_stderr
, exception
);
732 /* Print information about frame FRAME. The output is format according
733 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
736 SRC_LINE: Print only source line.
737 LOCATION: Print only location.
738 LOC_AND_SRC: Print location and source line.
740 Used in "where" output, and to emit breakpoint or step
744 print_frame_info (struct frame_info
*frame
, int print_level
,
745 enum print_what print_what
, int print_args
)
747 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
748 struct symtab_and_line sal
;
751 struct ui_out
*uiout
= current_uiout
;
753 if (get_frame_type (frame
) == DUMMY_FRAME
754 || get_frame_type (frame
) == SIGTRAMP_FRAME
755 || get_frame_type (frame
) == ARCH_FRAME
)
757 struct cleanup
*uiout_cleanup
758 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
760 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
761 gdbarch
, get_frame_pc (frame
));
763 /* Do this regardless of SOURCE because we don't have any source
764 to list for this frame. */
767 ui_out_text (uiout
, "#");
768 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
769 frame_relative_level (frame
));
771 if (ui_out_is_mi_like_p (uiout
))
773 annotate_frame_address ();
774 ui_out_field_core_addr (uiout
, "addr",
775 gdbarch
, get_frame_pc (frame
));
776 annotate_frame_address_end ();
779 if (get_frame_type (frame
) == DUMMY_FRAME
)
781 annotate_function_call ();
782 ui_out_field_string (uiout
, "func", "<function called from gdb>");
784 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
786 annotate_signal_handler_caller ();
787 ui_out_field_string (uiout
, "func", "<signal handler called>");
789 else if (get_frame_type (frame
) == ARCH_FRAME
)
791 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
793 ui_out_text (uiout
, "\n");
794 annotate_frame_end ();
796 do_cleanups (uiout_cleanup
);
800 /* If FRAME is not the innermost frame, that normally means that
801 FRAME->pc points to *after* the call instruction, and we want to
802 get the line containing the call, never the next line. But if
803 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
804 next frame was not entered as the result of a call, and we want
805 to get the line containing FRAME->pc. */
806 find_frame_sal (frame
, &sal
);
808 location_print
= (print_what
== LOCATION
809 || print_what
== LOC_AND_ADDRESS
810 || print_what
== SRC_AND_LOC
);
812 if (location_print
|| !sal
.symtab
)
813 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
815 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
817 /* If disassemble-next-line is set to auto or on and doesn't have
818 the line debug messages for $pc, output the next instruction. */
819 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
820 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
821 && source_print
&& !sal
.symtab
)
822 do_gdb_disassembly (get_frame_arch (frame
), 1,
823 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
825 if (source_print
&& sal
.symtab
)
828 int mid_statement
= ((print_what
== SRC_LINE
)
829 && frame_show_address (frame
, sal
));
831 if (annotation_level
)
832 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
833 get_frame_pc (frame
));
836 if (deprecated_print_frame_info_listing_hook
)
837 deprecated_print_frame_info_listing_hook (sal
.symtab
,
842 struct value_print_options opts
;
844 get_user_print_options (&opts
);
845 /* We used to do this earlier, but that is clearly
846 wrong. This function is used by many different
847 parts of gdb, including normal_stop in infrun.c,
848 which uses this to print out the current PC
849 when we stepi/nexti into the middle of a source
850 line. Only the command line really wants this
851 behavior. Other UIs probably would like the
852 ability to decide for themselves if it is desired. */
853 if (opts
.addressprint
&& mid_statement
)
855 ui_out_field_core_addr (uiout
, "addr",
856 gdbarch
, get_frame_pc (frame
));
857 ui_out_text (uiout
, "\t");
860 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
864 /* If disassemble-next-line is set to on and there is line debug
865 messages, output assembly codes for next line. */
866 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
867 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
870 if (print_what
!= LOCATION
)
874 if (get_frame_pc_if_available (frame
, &pc
))
875 set_default_breakpoint (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
877 set_default_breakpoint (0, 0, 0, 0, 0);
880 annotate_frame_end ();
882 gdb_flush (gdb_stdout
);
885 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
886 corresponding to FRAME. */
889 find_frame_funname (struct frame_info
*frame
, char **funname
,
890 enum language
*funlang
, struct symbol
**funcp
)
895 *funlang
= language_unknown
;
899 func
= get_frame_function (frame
);
902 /* In certain pathological cases, the symtabs give the wrong
903 function (when we are in the first function in a file which
904 is compiled without debugging symbols, the previous function
905 is compiled with debugging symbols, and the "foo.o" symbol
906 that is supposed to tell us where the file with debugging
907 symbols ends has been truncated by ar because it is longer
908 than 15 characters). This also occurs if the user uses asm()
909 to create a function but not stabs for it (in a file compiled
912 So look in the minimal symbol tables as well, and if it comes
913 up with a larger address for the function use that instead.
914 I don't think this can ever cause any problems; there
915 shouldn't be any minimal symbols in the middle of a function;
916 if this is ever changed many parts of GDB will need to be
917 changed (and we'll create a find_pc_minimal_function or some
920 struct minimal_symbol
*msymbol
= NULL
;
922 /* Don't attempt to do this for inlined functions, which do not
923 have a corresponding minimal symbol. */
924 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
926 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
929 && (SYMBOL_VALUE_ADDRESS (msymbol
)
930 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
932 /* We also don't know anything about the function besides
933 its address and name. */
935 *funname
= SYMBOL_PRINT_NAME (msymbol
);
936 *funlang
= SYMBOL_LANGUAGE (msymbol
);
940 *funname
= SYMBOL_PRINT_NAME (func
);
941 *funlang
= SYMBOL_LANGUAGE (func
);
944 if (*funlang
== language_cplus
)
946 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
947 to display the demangled name that we already have
948 stored in the symbol table, but we stored a version
949 with DMGL_PARAMS turned on, and here we don't want to
950 display parameters. So remove the parameters. */
951 char *func_only
= cp_remove_params (*funname
);
955 *funname
= func_only
;
956 make_cleanup (xfree
, func_only
);
963 struct minimal_symbol
*msymbol
;
966 if (!get_frame_address_in_block_if_available (frame
, &pc
))
969 msymbol
= lookup_minimal_symbol_by_pc (pc
);
972 *funname
= SYMBOL_PRINT_NAME (msymbol
);
973 *funlang
= SYMBOL_LANGUAGE (msymbol
);
979 print_frame (struct frame_info
*frame
, int print_level
,
980 enum print_what print_what
, int print_args
,
981 struct symtab_and_line sal
)
983 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
984 struct ui_out
*uiout
= current_uiout
;
985 char *funname
= NULL
;
986 enum language funlang
= language_unknown
;
987 struct ui_stream
*stb
;
988 struct cleanup
*old_chain
, *list_chain
;
989 struct value_print_options opts
;
994 pc_p
= get_frame_pc_if_available (frame
, &pc
);
996 stb
= ui_out_stream_new (uiout
);
997 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
999 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1001 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1004 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1008 ui_out_text (uiout
, "#");
1009 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1010 frame_relative_level (frame
));
1012 get_user_print_options (&opts
);
1013 if (opts
.addressprint
)
1015 || frame_show_address (frame
, sal
)
1016 || print_what
== LOC_AND_ADDRESS
)
1018 annotate_frame_address ();
1020 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1022 ui_out_field_string (uiout
, "addr", "<unavailable>");
1023 annotate_frame_address_end ();
1024 ui_out_text (uiout
, " in ");
1026 annotate_frame_function_name ();
1027 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
1028 funlang
, DMGL_ANSI
);
1029 ui_out_field_stream (uiout
, "func", stb
);
1030 ui_out_wrap_hint (uiout
, " ");
1031 annotate_frame_args ();
1033 ui_out_text (uiout
, " (");
1036 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1038 struct cleanup
*args_list_chain
;
1039 volatile struct gdb_exception e
;
1041 if (gdbarch_frame_num_args_p (gdbarch
))
1043 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1044 gdb_assert (numargs
>= 0);
1049 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1050 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1052 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1054 /* FIXME: ARGS must be a list. If one argument is a string it
1055 will have " that will not be properly escaped. */
1056 /* Invoke ui_out_tuple_end. */
1057 do_cleanups (args_list_chain
);
1060 ui_out_text (uiout
, ")");
1061 if (sal
.symtab
&& sal
.symtab
->filename
)
1063 annotate_frame_source_begin ();
1064 ui_out_wrap_hint (uiout
, " ");
1065 ui_out_text (uiout
, " at ");
1066 annotate_frame_source_file ();
1067 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1068 if (ui_out_is_mi_like_p (uiout
))
1070 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1072 if (fullname
!= NULL
)
1073 ui_out_field_string (uiout
, "fullname", fullname
);
1075 annotate_frame_source_file_end ();
1076 ui_out_text (uiout
, ":");
1077 annotate_frame_source_line ();
1078 ui_out_field_int (uiout
, "line", sal
.line
);
1079 annotate_frame_source_end ();
1082 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
1085 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1087 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1088 get_frame_pc (frame
));
1092 annotate_frame_where ();
1093 ui_out_wrap_hint (uiout
, " ");
1094 ui_out_text (uiout
, " from ");
1095 ui_out_field_string (uiout
, "from", lib
);
1099 /* do_cleanups will call ui_out_tuple_end() for us. */
1100 do_cleanups (list_chain
);
1101 ui_out_text (uiout
, "\n");
1102 do_cleanups (old_chain
);
1106 /* Read a frame specification in whatever the appropriate format is
1107 from FRAME_EXP. Call error(), printing MESSAGE, if the
1108 specification is in any way invalid (so this function never returns
1109 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1110 the default selected frame was used. */
1112 static struct frame_info
*
1113 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1114 int *selected_frame_p
)
1117 struct value
*args
[4];
1118 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1120 if (frame_exp
== NULL
)
1128 struct cleanup
*cleanup
;
1131 /* Skip leading white space, bail of EOL. */
1132 while (isspace (*frame_exp
))
1137 /* Parse the argument, extract it, save it. */
1139 *p
&& !isspace (*p
);
1141 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1143 cleanup
= make_cleanup (xfree
, addr_string
);
1145 /* NOTE: Parse and evaluate expression, but do not use
1146 functions such as parse_and_eval_long or
1147 parse_and_eval_address to also extract the value.
1148 Instead value_as_long and value_as_address are used.
1149 This avoids problems with expressions that contain
1151 if (numargs
>= ARRAY_SIZE (args
))
1152 error (_("Too many args in frame specification"));
1153 args
[numargs
++] = parse_and_eval (addr_string
);
1155 do_cleanups (cleanup
);
1159 /* If no args, default to the selected frame. */
1162 if (selected_frame_p
!= NULL
)
1163 (*selected_frame_p
) = 1;
1164 return get_selected_frame (message
);
1167 /* None of the remaining use the selected frame. */
1168 if (selected_frame_p
!= NULL
)
1169 (*selected_frame_p
) = 0;
1171 /* Assume the single arg[0] is an integer, and try using that to
1172 select a frame relative to current. */
1175 struct frame_info
*fid
;
1176 int level
= value_as_long (args
[0]);
1178 fid
= find_relative_frame (get_current_frame (), &level
);
1180 /* find_relative_frame was successful. */
1184 /* Convert each value into a corresponding address. */
1188 for (i
= 0; i
< numargs
; i
++)
1189 addrs
[i
] = value_as_address (args
[i
]);
1192 /* Assume that the single arg[0] is an address, use that to identify
1193 a frame with a matching ID. Should this also accept stack/pc or
1194 stack/pc/special. */
1197 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1198 struct frame_info
*fid
;
1200 /* If (s)he specifies the frame with an address, he deserves
1201 what (s)he gets. Still, give the highest one that matches.
1202 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1204 for (fid
= get_current_frame ();
1206 fid
= get_prev_frame (fid
))
1208 if (frame_id_eq (id
, get_frame_id (fid
)))
1210 struct frame_info
*prev_frame
;
1214 prev_frame
= get_prev_frame (fid
);
1216 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1225 /* We couldn't identify the frame as an existing frame, but
1226 perhaps we can create one with a single argument. */
1228 return create_new_frame (addrs
[0], 0);
1229 else if (numargs
== 2)
1230 return create_new_frame (addrs
[0], addrs
[1]);
1232 error (_("Too many args in frame specification"));
1235 static struct frame_info
*
1236 parse_frame_specification (char *frame_exp
)
1238 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1241 /* Print verbosely the selected frame or the frame at address
1242 ADDR_EXP. Absolutely all information in the frame is printed. */
1245 frame_info (char *addr_exp
, int from_tty
)
1247 struct frame_info
*fi
;
1248 struct symtab_and_line sal
;
1249 struct symbol
*func
;
1251 struct frame_info
*calling_frame_info
;
1254 enum language funlang
= language_unknown
;
1255 const char *pc_regname
;
1256 int selected_frame_p
;
1257 struct gdbarch
*gdbarch
;
1258 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1261 CORE_ADDR caller_pc
;
1263 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1264 gdbarch
= get_frame_arch (fi
);
1266 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1267 is not a good name. */
1268 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1269 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1270 easily not match that of the internal value returned by
1272 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1274 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1275 architectures will often have a hardware register called "pc",
1276 and that register's value, again, can easily not match
1280 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1281 find_frame_sal (fi
, &sal
);
1282 func
= get_frame_function (fi
);
1286 funname
= SYMBOL_PRINT_NAME (func
);
1287 funlang
= SYMBOL_LANGUAGE (func
);
1288 if (funlang
== language_cplus
)
1290 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1291 to display the demangled name that we already have
1292 stored in the symbol table, but we stored a version
1293 with DMGL_PARAMS turned on, and here we don't want to
1294 display parameters. So remove the parameters. */
1295 char *func_only
= cp_remove_params (funname
);
1299 funname
= func_only
;
1300 make_cleanup (xfree
, func_only
);
1304 else if (frame_pc_p
)
1306 struct minimal_symbol
*msymbol
;
1308 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1309 if (msymbol
!= NULL
)
1311 funname
= SYMBOL_PRINT_NAME (msymbol
);
1312 funlang
= SYMBOL_LANGUAGE (msymbol
);
1315 calling_frame_info
= get_prev_frame (fi
);
1317 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1319 printf_filtered (_("Stack level %d, frame at "),
1320 frame_relative_level (fi
));
1324 printf_filtered (_("Stack frame at "));
1326 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1327 printf_filtered (":\n");
1328 printf_filtered (" %s = ", pc_regname
);
1330 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1332 fputs_filtered ("<unavailable>", gdb_stdout
);
1337 printf_filtered (" in ");
1338 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1339 DMGL_ANSI
| DMGL_PARAMS
);
1343 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1344 puts_filtered ("; ");
1346 printf_filtered ("saved %s ", pc_regname
);
1347 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1348 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1350 fputs_filtered ("<unavailable>", gdb_stdout
);
1351 printf_filtered ("\n");
1353 if (calling_frame_info
== NULL
)
1355 enum unwind_stop_reason reason
;
1357 reason
= get_frame_unwind_stop_reason (fi
);
1358 if (reason
!= UNWIND_NO_REASON
)
1359 printf_filtered (_(" Outermost frame: %s\n"),
1360 frame_stop_reason_string (reason
));
1362 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1363 puts_filtered (" tail call frame");
1364 else if (get_frame_type (fi
) == INLINE_FRAME
)
1365 printf_filtered (" inlined into frame %d",
1366 frame_relative_level (get_prev_frame (fi
)));
1369 printf_filtered (" called by frame at ");
1370 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1373 if (get_next_frame (fi
) && calling_frame_info
)
1374 puts_filtered (",");
1376 if (get_next_frame (fi
))
1378 printf_filtered (" caller of frame at ");
1379 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1382 if (get_next_frame (fi
) || calling_frame_info
)
1383 puts_filtered ("\n");
1386 printf_filtered (" source language %s.\n",
1387 language_str (s
->language
));
1390 /* Address of the argument list for this frame, or 0. */
1391 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1392 /* Number of args for this frame, or -1 if unknown. */
1396 printf_filtered (" Arglist at unknown address.\n");
1399 printf_filtered (" Arglist at ");
1400 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1401 printf_filtered (",");
1403 if (!gdbarch_frame_num_args_p (gdbarch
))
1406 puts_filtered (" args: ");
1410 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1411 gdb_assert (numargs
>= 0);
1413 puts_filtered (" no args.");
1414 else if (numargs
== 1)
1415 puts_filtered (" 1 arg: ");
1417 printf_filtered (" %d args: ", numargs
);
1419 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1420 puts_filtered ("\n");
1424 /* Address of the local variables for this frame, or 0. */
1425 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1428 printf_filtered (" Locals at unknown address,");
1431 printf_filtered (" Locals at ");
1432 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1433 printf_filtered (",");
1437 /* Print as much information as possible on the location of all the
1440 enum lval_type lval
;
1449 /* The sp is special; what's displayed isn't the save address, but
1450 the value of the previous frame's sp. This is a legacy thing,
1451 at one stage the frame cached the previous frame's SP instead
1452 of its address, hence it was easiest to just display the cached
1454 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1456 /* Find out the location of the saved stack pointer with out
1457 actually evaluating it. */
1458 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1459 &optimized
, &unavailable
, &lval
, &addr
,
1461 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1463 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1464 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1465 gdb_byte value
[MAX_REGISTER_SIZE
];
1468 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1469 &optimized
, &unavailable
, &lval
, &addr
,
1471 /* NOTE: cagney/2003-05-22: This is assuming that the
1472 stack pointer was packed as an unsigned integer. That
1473 may or may not be valid. */
1474 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1475 printf_filtered (" Previous frame's sp is ");
1476 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1477 printf_filtered ("\n");
1480 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1482 printf_filtered (" Previous frame's sp at ");
1483 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1484 printf_filtered ("\n");
1487 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1489 printf_filtered (" Previous frame's sp in %s\n",
1490 gdbarch_register_name (gdbarch
, realnum
));
1493 /* else keep quiet. */
1497 numregs
= gdbarch_num_regs (gdbarch
)
1498 + gdbarch_num_pseudo_regs (gdbarch
);
1499 for (i
= 0; i
< numregs
; i
++)
1500 if (i
!= gdbarch_sp_regnum (gdbarch
)
1501 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1503 /* Find out the location of the saved register without
1504 fetching the corresponding value. */
1505 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1506 &lval
, &addr
, &realnum
, NULL
);
1507 /* For moment, only display registers that were saved on the
1509 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1512 puts_filtered (" Saved registers:\n ");
1514 puts_filtered (",");
1516 printf_filtered (" %s at ",
1517 gdbarch_register_name (gdbarch
, i
));
1518 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1522 if (count
|| need_nl
)
1523 puts_filtered ("\n");
1526 do_cleanups (back_to
);
1529 /* Print briefly all stack frames or just the innermost COUNT_EXP
1533 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1535 struct frame_info
*fi
;
1538 struct frame_info
*trailing
;
1541 if (!target_has_stack
)
1542 error (_("No stack."));
1544 /* The following code must do two things. First, it must set the
1545 variable TRAILING to the frame from which we should start
1546 printing. Second, it must set the variable count to the number
1547 of frames which we should print, or -1 if all of them. */
1548 trailing
= get_current_frame ();
1553 count
= parse_and_eval_long (count_exp
);
1556 struct frame_info
*current
;
1561 while (current
&& count
--)
1564 current
= get_prev_frame (current
);
1567 /* Will stop when CURRENT reaches the top of the stack.
1568 TRAILING will be COUNT below it. */
1572 trailing
= get_prev_frame (trailing
);
1573 current
= get_prev_frame (current
);
1585 /* Read in symbols for all of the frames. Need to do this in a
1586 separate pass so that "Reading in symbols for xxx" messages
1587 don't screw up the appearance of the backtrace. Also if
1588 people have strong opinions against reading symbols for
1589 backtrace this may have to be an option. */
1591 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1596 pc
= get_frame_address_in_block (fi
);
1597 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1601 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1605 /* Don't use print_stack_frame; if an error() occurs it probably
1606 means further attempts to backtrace would fail (on the other
1607 hand, perhaps the code does or could be fixed to make sure
1608 the frame->prev field gets set to NULL in that case). */
1609 print_frame_info (fi
, 1, LOCATION
, 1);
1611 print_frame_local_vars (fi
, 1, gdb_stdout
);
1613 /* Save the last frame to check for error conditions. */
1617 /* If we've stopped before the end, mention that. */
1619 printf_filtered (_("(More stack frames follow...)\n"));
1621 /* If we've run out of frames, and the reason appears to be an error
1622 condition, print it. */
1623 if (fi
== NULL
&& trailing
!= NULL
)
1625 enum unwind_stop_reason reason
;
1627 reason
= get_frame_unwind_stop_reason (trailing
);
1628 if (reason
>= UNWIND_FIRST_ERROR
)
1629 printf_filtered (_("Backtrace stopped: %s\n"),
1630 frame_stop_reason_string (reason
));
1635 backtrace_command (char *arg
, int from_tty
)
1637 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1638 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1645 argv
= gdb_buildargv (arg
);
1646 make_cleanup_freeargv (argv
);
1648 for (i
= 0; argv
[i
]; i
++)
1652 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1653 argv
[i
][j
] = tolower (argv
[i
][j
]);
1655 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1656 fulltrace_arg
= argc
;
1659 arglen
+= strlen (argv
[i
]);
1664 if (fulltrace_arg
>= 0)
1668 arg
= xmalloc (arglen
+ 1);
1669 make_cleanup (xfree
, arg
);
1671 for (i
= 0; i
< (argc
+ 1); i
++)
1673 if (i
!= fulltrace_arg
)
1675 strcat (arg
, argv
[i
]);
1685 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1687 do_cleanups (old_chain
);
1691 backtrace_full_command (char *arg
, int from_tty
)
1693 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1697 /* Iterate over the local variables of a block B, calling CB with
1701 iterate_over_block_locals (struct block
*b
,
1702 iterate_over_block_arg_local_vars_cb cb
,
1705 struct dict_iterator iter
;
1708 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1710 switch (SYMBOL_CLASS (sym
))
1716 if (SYMBOL_IS_ARGUMENT (sym
))
1718 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1722 /* Ignore symbols which are not locals. */
1729 /* Same, but print labels. */
1732 /* Commented out, as the code using this function has also been
1733 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1734 was commented out in the first place. The discussion introducing
1735 this change (2007-12-04: Support lexical blocks and function bodies
1736 that occupy non-contiguous address ranges) did not explain why
1737 this change was made. */
1739 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1740 int *have_default
, struct ui_file
*stream
)
1742 struct dict_iterator iter
;
1744 int values_printed
= 0;
1746 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1748 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1754 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1756 struct symtab_and_line sal
;
1757 struct value_print_options opts
;
1759 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1761 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1762 get_user_print_options (&opts
);
1763 if (opts
.addressprint
)
1765 fprintf_filtered (stream
, " ");
1766 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1769 fprintf_filtered (stream
, " in file %s, line %d\n",
1770 sal
.symtab
->filename
, sal
.line
);
1774 return values_printed
;
1778 /* Iterate over all the local variables in block B, including all its
1779 superblocks, stopping when the top-level block is reached. */
1782 iterate_over_block_local_vars (struct block
*block
,
1783 iterate_over_block_arg_local_vars_cb cb
,
1788 iterate_over_block_locals (block
, cb
, cb_data
);
1789 /* After handling the function's top-level block, stop. Don't
1790 continue to its superblock, the block of per-file
1792 if (BLOCK_FUNCTION (block
))
1794 block
= BLOCK_SUPERBLOCK (block
);
1798 /* Data to be passed around in the calls to the locals and args
1801 struct print_variable_and_value_data
1803 struct frame_info
*frame
;
1805 struct ui_file
*stream
;
1809 /* The callback for the locals and args iterators. */
1812 do_print_variable_and_value (const char *print_name
,
1816 struct print_variable_and_value_data
*p
= cb_data
;
1818 print_variable_and_value (print_name
, sym
,
1819 p
->frame
, p
->stream
, p
->num_tabs
);
1820 p
->values_printed
= 1;
1824 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1825 struct ui_file
*stream
)
1827 struct print_variable_and_value_data cb_data
;
1828 struct block
*block
;
1831 if (!get_frame_pc_if_available (frame
, &pc
))
1833 fprintf_filtered (stream
,
1834 _("PC unavailable, cannot determine locals.\n"));
1838 block
= get_frame_block (frame
, 0);
1841 fprintf_filtered (stream
, "No symbol table info available.\n");
1845 cb_data
.frame
= frame
;
1846 cb_data
.num_tabs
= 4 * num_tabs
;
1847 cb_data
.stream
= stream
;
1848 cb_data
.values_printed
= 0;
1850 iterate_over_block_local_vars (block
,
1851 do_print_variable_and_value
,
1854 if (!cb_data
.values_printed
)
1855 fprintf_filtered (stream
, _("No locals.\n"));
1858 /* Same, but print labels. */
1861 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1862 struct ui_file
*stream
)
1865 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1867 struct blockvector
*bl
;
1868 struct block
*block
= get_frame_block (frame
, 0);
1869 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1870 int values_printed
= 0;
1871 int index
, have_default
= 0;
1872 char *blocks_printed
;
1873 CORE_ADDR pc
= get_frame_pc (frame
);
1877 fprintf_filtered (stream
, "No symbol table info available.\n");
1881 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1882 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1883 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1887 CORE_ADDR end
= BLOCK_END (block
) - 4;
1890 if (bl
!= blockvector_for_pc (end
, &index
))
1891 error (_("blockvector blotch"));
1892 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1893 error (_("blockvector botch"));
1894 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1897 /* Don't print out blocks that have gone by. */
1898 while (index
< last_index
1899 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1902 while (index
< last_index
1903 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1905 if (blocks_printed
[index
] == 0)
1907 if (print_block_frame_labels (gdbarch
,
1908 BLOCKVECTOR_BLOCK (bl
, index
),
1909 &have_default
, stream
))
1911 blocks_printed
[index
] = 1;
1917 if (values_printed
&& this_level_only
)
1920 /* After handling the function's top-level block, stop. Don't
1921 continue to its superblock, the block of per-file symbols.
1922 Also do not continue to the containing function of an inlined
1924 if (BLOCK_FUNCTION (block
))
1926 block
= BLOCK_SUPERBLOCK (block
);
1929 if (!values_printed
&& !this_level_only
)
1930 fprintf_filtered (stream
, _("No catches.\n"));
1935 locals_info (char *args
, int from_tty
)
1937 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1942 catch_info (char *ignore
, int from_tty
)
1944 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1945 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1949 /* Iterate over all the argument variables in block B.
1951 Returns 1 if any argument was walked; 0 otherwise. */
1954 iterate_over_block_arg_vars (struct block
*b
,
1955 iterate_over_block_arg_local_vars_cb cb
,
1958 struct dict_iterator iter
;
1959 struct symbol
*sym
, *sym2
;
1961 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1963 /* Don't worry about things which aren't arguments. */
1964 if (SYMBOL_IS_ARGUMENT (sym
))
1966 /* We have to look up the symbol because arguments can have
1967 two entries (one a parameter, one a local) and the one we
1968 want is the local, which lookup_symbol will find for us.
1969 This includes gcc1 (not gcc2) on the sparc when passing a
1970 small structure and gcc2 when the argument type is float
1971 and it is passed as a double and converted to float by
1972 the prologue (in the latter case the type of the LOC_ARG
1973 symbol is double and the type of the LOC_LOCAL symbol is
1974 float). There are also LOC_ARG/LOC_REGISTER pairs which
1975 are not combined in symbol-reading. */
1977 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1978 b
, VAR_DOMAIN
, NULL
);
1979 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
1985 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1987 struct print_variable_and_value_data cb_data
;
1988 struct symbol
*func
;
1991 if (!get_frame_pc_if_available (frame
, &pc
))
1993 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
1997 func
= get_frame_function (frame
);
2000 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2004 cb_data
.frame
= frame
;
2005 cb_data
.num_tabs
= 0;
2006 cb_data
.stream
= gdb_stdout
;
2007 cb_data
.values_printed
= 0;
2009 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2010 do_print_variable_and_value
, &cb_data
);
2012 if (!cb_data
.values_printed
)
2013 fprintf_filtered (stream
, _("No arguments.\n"));
2017 args_info (char *ignore
, int from_tty
)
2019 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2025 args_plus_locals_info (char *ignore
, int from_tty
)
2027 args_info (ignore
, from_tty
);
2028 locals_info (ignore
, from_tty
);
2032 /* Select frame FRAME. Also print the stack frame and show the source
2033 if this is the tui version. */
2035 select_and_print_frame (struct frame_info
*frame
)
2037 select_frame (frame
);
2039 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2042 /* Return the symbol-block in which the selected frame is executing.
2043 Can return zero under various legitimate circumstances.
2045 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2046 code address within the block returned. We use this to decide
2047 which macros are in scope. */
2050 get_selected_block (CORE_ADDR
*addr_in_block
)
2052 if (!has_stack_frames ())
2055 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2058 /* Find a frame a certain number of levels away from FRAME.
2059 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2060 Positive means go to earlier frames (up); negative, the reverse.
2061 The int that contains the number of levels is counted toward
2062 zero as the frames for those levels are found.
2063 If the top or bottom frame is reached, that frame is returned,
2064 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2065 how much farther the original request asked to go. */
2068 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2070 /* Going up is simple: just call get_prev_frame enough times or
2071 until the initial frame is reached. */
2072 while (*level_offset_ptr
> 0)
2074 struct frame_info
*prev
= get_prev_frame (frame
);
2078 (*level_offset_ptr
)--;
2082 /* Going down is just as simple. */
2083 while (*level_offset_ptr
< 0)
2085 struct frame_info
*next
= get_next_frame (frame
);
2089 (*level_offset_ptr
)++;
2096 /* The "select_frame" command. With no argument this is a NOP.
2097 Select the frame at level LEVEL_EXP if it is a valid level.
2098 Otherwise, treat LEVEL_EXP as an address expression and select it.
2100 See parse_frame_specification for more info on proper frame
2104 select_frame_command (char *level_exp
, int from_tty
)
2106 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2109 /* The "frame" command. With no argument, print the selected frame
2110 briefly. With an argument, behave like select_frame and then print
2111 the selected frame. */
2114 frame_command (char *level_exp
, int from_tty
)
2116 select_frame_command (level_exp
, from_tty
);
2117 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2120 /* The XDB Compatibility command to print the current frame. */
2123 current_frame_command (char *level_exp
, int from_tty
)
2125 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2128 /* Select the frame up one or COUNT_EXP stack levels from the
2129 previously selected frame, and print it briefly. */
2132 up_silently_base (char *count_exp
)
2134 struct frame_info
*frame
;
2138 count
= parse_and_eval_long (count_exp
);
2140 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2141 if (count
!= 0 && count_exp
== NULL
)
2142 error (_("Initial frame selected; you cannot go up."));
2143 select_frame (frame
);
2147 up_silently_command (char *count_exp
, int from_tty
)
2149 up_silently_base (count_exp
);
2153 up_command (char *count_exp
, int from_tty
)
2155 up_silently_base (count_exp
);
2156 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2159 /* Select the frame down one or COUNT_EXP stack levels from the previously
2160 selected frame, and print it briefly. */
2163 down_silently_base (char *count_exp
)
2165 struct frame_info
*frame
;
2169 count
= -parse_and_eval_long (count_exp
);
2171 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2172 if (count
!= 0 && count_exp
== NULL
)
2174 /* We only do this if COUNT_EXP is not specified. That way
2175 "down" means to really go down (and let me know if that is
2176 impossible), but "down 9999" can be used to mean go all the
2177 way down without getting an error. */
2179 error (_("Bottom (innermost) frame selected; you cannot go down."));
2182 select_frame (frame
);
2186 down_silently_command (char *count_exp
, int from_tty
)
2188 down_silently_base (count_exp
);
2192 down_command (char *count_exp
, int from_tty
)
2194 down_silently_base (count_exp
);
2195 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2200 return_command (char *retval_exp
, int from_tty
)
2202 struct frame_info
*thisframe
;
2203 struct gdbarch
*gdbarch
;
2204 struct symbol
*thisfun
;
2205 struct value
*return_value
= NULL
;
2206 const char *query_prefix
= "";
2208 thisframe
= get_selected_frame ("No selected frame.");
2209 thisfun
= get_frame_function (thisframe
);
2210 gdbarch
= get_frame_arch (thisframe
);
2212 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2213 error (_("Can not force return from an inlined function."));
2215 /* Compute the return value. If the computation triggers an error,
2216 let it bail. If the return type can't be handled, set
2217 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2221 struct expression
*retval_expr
= parse_expression (retval_exp
);
2222 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2223 struct type
*return_type
= NULL
;
2225 /* Compute the return value. Should the computation fail, this
2226 call throws an error. */
2227 return_value
= evaluate_expression (retval_expr
);
2229 /* Cast return value to the return type of the function. Should
2230 the cast fail, this call throws an error. */
2231 if (thisfun
!= NULL
)
2232 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2233 if (return_type
== NULL
)
2235 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2236 error (_("Return value type not available for selected "
2238 "Please use an explicit cast of the value to return."));
2239 return_type
= value_type (return_value
);
2241 do_cleanups (old_chain
);
2242 CHECK_TYPEDEF (return_type
);
2243 return_value
= value_cast (return_type
, return_value
);
2245 /* Make sure the value is fully evaluated. It may live in the
2246 stack frame we're about to pop. */
2247 if (value_lazy (return_value
))
2248 value_fetch_lazy (return_value
);
2250 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2251 /* If the return-type is "void", don't try to find the
2252 return-value's location. However, do still evaluate the
2253 return expression so that, even when the expression result
2254 is discarded, side effects such as "return i++" still
2256 return_value
= NULL
;
2257 else if (thisfun
!= NULL
2258 && using_struct_return (gdbarch
,
2259 SYMBOL_TYPE (thisfun
), return_type
))
2261 query_prefix
= "The location at which to store the "
2262 "function's return value is unknown.\n"
2263 "If you continue, the return value "
2264 "that you specified will be ignored.\n";
2265 return_value
= NULL
;
2269 /* Does an interactive user really want to do this? Include
2270 information, such as how well GDB can handle the return value, in
2271 the query message. */
2276 if (thisfun
== NULL
)
2277 confirmed
= query (_("%sMake selected stack frame return now? "),
2280 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2281 SYMBOL_PRINT_NAME (thisfun
));
2283 error (_("Not confirmed"));
2286 /* Discard the selected frame and all frames inner-to it. */
2287 frame_pop (get_selected_frame (NULL
));
2289 /* Store RETURN_VALUE in the just-returned register set. */
2290 if (return_value
!= NULL
)
2292 struct type
*return_type
= value_type (return_value
);
2293 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2294 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2296 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2298 == RETURN_VALUE_REGISTER_CONVENTION
);
2299 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2300 get_current_regcache (), NULL
/*read*/,
2301 value_contents (return_value
) /*write*/);
2304 /* If we are at the end of a call dummy now, pop the dummy frame
2306 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2307 frame_pop (get_current_frame ());
2309 /* If interactive, print the frame that is now current. */
2311 frame_command ("0", 1);
2313 select_frame_command ("0", 0);
2316 /* Sets the scope to input function name, provided that the function
2317 is within the current stack frame. */
2319 struct function_bounds
2321 CORE_ADDR low
, high
;
2325 func_command (char *arg
, int from_tty
)
2327 struct frame_info
*frame
;
2329 struct symtabs_and_lines sals
;
2332 struct function_bounds
*func_bounds
= NULL
;
2337 frame
= parse_frame_specification ("0");
2338 sals
= decode_line_spec (arg
, 1);
2339 func_bounds
= (struct function_bounds
*) xmalloc (
2340 sizeof (struct function_bounds
) * sals
.nelts
);
2341 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2343 if (sals
.sals
[i
].pc
== 0
2344 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2345 &func_bounds
[i
].low
,
2346 &func_bounds
[i
].high
) == 0)
2348 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2354 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2355 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2356 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2360 frame
= find_relative_frame (frame
, &level
);
2363 while (!found
&& level
== 0);
2366 xfree (func_bounds
);
2369 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2370 else if (frame
!= get_selected_frame (NULL
))
2371 select_and_print_frame (frame
);
2374 /* Gets the language of the current frame. */
2377 get_frame_language (void)
2379 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2383 volatile struct gdb_exception ex
;
2387 /* We determine the current frame language by looking up its
2388 associated symtab. To retrieve this symtab, we use the frame
2389 PC. However we cannot use the frame PC as is, because it
2390 usually points to the instruction following the "call", which
2391 is sometimes the first instruction of another function. So
2392 we rely on get_frame_address_in_block(), it provides us with
2393 a PC that is guaranteed to be inside the frame's code
2396 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2398 pc
= get_frame_address_in_block (frame
);
2402 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2403 throw_exception (ex
);
2407 s
= find_pc_symtab (pc
);
2413 return language_unknown
;
2417 /* Provide a prototype to silence -Wmissing-prototypes. */
2418 void _initialize_stack (void);
2421 _initialize_stack (void)
2423 add_com ("return", class_stack
, return_command
, _("\
2424 Make selected stack frame return to its caller.\n\
2425 Control remains in the debugger, but when you continue\n\
2426 execution will resume in the frame above the one now selected.\n\
2427 If an argument is given, it is an expression for the value to return."));
2429 add_com ("up", class_stack
, up_command
, _("\
2430 Select and print stack frame that called this one.\n\
2431 An argument says how many frames up to go."));
2432 add_com ("up-silently", class_support
, up_silently_command
, _("\
2433 Same as the `up' command, but does not print anything.\n\
2434 This is useful in command scripts."));
2436 add_com ("down", class_stack
, down_command
, _("\
2437 Select and print stack frame called by this one.\n\
2438 An argument says how many frames down to go."));
2439 add_com_alias ("do", "down", class_stack
, 1);
2440 add_com_alias ("dow", "down", class_stack
, 1);
2441 add_com ("down-silently", class_support
, down_silently_command
, _("\
2442 Same as the `down' command, but does not print anything.\n\
2443 This is useful in command scripts."));
2445 add_com ("frame", class_stack
, frame_command
, _("\
2446 Select and print a stack frame.\nWith no argument, \
2447 print the selected stack frame. (See also \"info frame\").\n\
2448 An argument specifies the frame to select.\n\
2449 It can be a stack frame number or the address of the frame.\n\
2450 With argument, nothing is printed if input is coming from\n\
2451 a command file or a user-defined command."));
2453 add_com_alias ("f", "frame", class_stack
, 1);
2457 add_com ("L", class_stack
, current_frame_command
,
2458 _("Print the current stack frame.\n"));
2459 add_com_alias ("V", "frame", class_stack
, 1);
2461 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2462 Select a stack frame without printing anything.\n\
2463 An argument specifies the frame to select.\n\
2464 It can be a stack frame number or the address of the frame.\n"));
2466 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2467 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2468 With a negative argument, print outermost -COUNT frames.\nUse of the \
2469 'full' qualifier also prints the values of the local variables.\n"));
2470 add_com_alias ("bt", "backtrace", class_stack
, 0);
2473 add_com_alias ("t", "backtrace", class_stack
, 0);
2474 add_com ("T", class_stack
, backtrace_full_command
, _("\
2475 Print backtrace of all stack frames, or innermost COUNT frames\n\
2476 and the values of the local variables.\n\
2477 With a negative argument, print outermost -COUNT frames.\n\
2478 Usage: T <count>\n"));
2481 add_com_alias ("where", "backtrace", class_alias
, 0);
2482 add_info ("stack", backtrace_command
,
2483 _("Backtrace of the stack, or innermost COUNT frames."));
2484 add_info_alias ("s", "stack", 1);
2485 add_info ("frame", frame_info
,
2486 _("All about selected stack frame, or frame at ADDR."));
2487 add_info_alias ("f", "frame", 1);
2488 add_info ("locals", locals_info
,
2489 _("Local variables of current stack frame."));
2490 add_info ("args", args_info
,
2491 _("Argument variables of current stack frame."));
2493 add_com ("l", class_info
, args_plus_locals_info
,
2494 _("Argument and local variables of current stack frame."));
2497 add_com ("func", class_stack
, func_command
, _("\
2498 Select the stack frame that contains <func>.\n\
2499 Usage: func <name>\n"));
2501 add_info ("catch", catch_info
,
2502 _("Exceptions that can be caught in the current stack frame."));
2504 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2505 print_frame_arguments_choices
, &print_frame_arguments
,
2506 _("Set printing of non-scalar frame arguments"),
2507 _("Show printing of non-scalar frame arguments"),
2508 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2510 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2511 &disassemble_next_line
, _("\
2512 Set whether to disassemble next source line or insn when execution stops."),
2514 Show whether to disassemble next source line or insn when execution stops."),
2516 If ON, GDB will display disassembly of the next source line, in addition\n\
2517 to displaying the source line itself. If the next source line cannot\n\
2518 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2519 will display disassembly of next instruction instead of showing the\n\
2521 If AUTO, display disassembly of next instruction only if the source line\n\
2522 cannot be displayed.\n\
2523 If OFF (which is the default), never display the disassembly of the next\n\
2526 show_disassemble_next_line
,
2527 &setlist
, &showlist
);
2528 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2530 add_setshow_enum_cmd ("entry-values", class_stack
,
2531 print_entry_values_choices
, &print_entry_values
,
2532 _("Set printing of function arguments at function "
2534 _("Show printing of function arguments at function "
2537 GDB can sometimes determine the values of function arguments at entry,\n\
2538 in addition to their current values. This option tells GDB whether\n\
2539 to print the current value, the value at entry (marked as val@entry),\n\
2540 or both. Note that one or both of these values may be <optimized out>."),
2541 NULL
, NULL
, &setprintlist
, &showprintlist
);