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
))
358 /* Try to remove possibly duplicate error message for ENTRYARGP even
361 if (val_error
&& entryval_error
362 && strcmp (val_error
, entryval_error
) == 0)
364 entryval_error
= NULL
;
366 /* Do not se VAL_EQUAL as the same error message may be shown for
367 the entry value even if no entry values are present in the
373 if (entryval
== NULL
)
375 if (print_entry_values
== print_entry_values_preferred
)
377 TRY_CATCH (except
, RETURN_MASK_ERROR
)
379 val
= read_var_value (sym
, frame
);
383 val_error
= alloca (strlen (except
.message
) + 1);
384 strcpy (val_error
, except
.message
);
387 if (print_entry_values
== print_entry_values_only
388 || print_entry_values
== print_entry_values_both
389 || (print_entry_values
== print_entry_values_preferred
390 && (!val
|| value_optimized_out (val
))))
391 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
393 if ((print_entry_values
== print_entry_values_compact
394 || print_entry_values
== print_entry_values_if_needed
395 || print_entry_values
== print_entry_values_preferred
)
396 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
404 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
405 if (!val
&& !val_error
)
406 argp
->entry_kind
= print_entry_values_only
;
407 else if ((print_entry_values
== print_entry_values_compact
408 || print_entry_values
== print_entry_values_default
) && val_equal
)
410 argp
->entry_kind
= print_entry_values_compact
;
411 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
414 argp
->entry_kind
= print_entry_values_no
;
416 entryargp
->sym
= sym
;
417 entryargp
->val
= entryval
;
418 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
419 if (!entryval
&& !entryval_error
)
420 entryargp
->entry_kind
= print_entry_values_no
;
422 entryargp
->entry_kind
= print_entry_values_only
;
425 /* Print the arguments of frame FRAME on STREAM, given the function
426 FUNC running in that frame (as a symbol), where NUM is the number
427 of arguments according to the stack frame (or -1 if the number of
428 arguments is unknown). */
430 /* Note that currently the "number of arguments according to the
431 stack frame" is only known on VAX where i refers to the "number of
432 ints of arguments according to the stack frame". */
435 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
436 int num
, struct ui_file
*stream
)
438 struct ui_out
*uiout
= current_uiout
;
440 /* Offset of next stack argument beyond the one we have seen that is
441 at the highest offset, or -1 if we haven't come to a stack
443 long highest_offset
= -1;
444 /* Number of ints of arguments that we have printed so far. */
445 int args_printed
= 0;
446 struct cleanup
*old_chain
, *list_chain
;
447 struct ui_stream
*stb
;
448 /* True if we should print arguments, false otherwise. */
449 int print_args
= strcmp (print_frame_arguments
, "none");
450 /* True in "summary" mode, false otherwise. */
451 int summary
= !strcmp (print_frame_arguments
, "scalars");
453 stb
= ui_out_stream_new (uiout
);
454 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
458 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
459 struct dict_iterator iter
;
462 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
464 struct frame_arg arg
, entryarg
;
468 /* Keep track of the highest stack argument offset seen, and
469 skip over any kinds of symbols we don't care about. */
471 if (!SYMBOL_IS_ARGUMENT (sym
))
474 switch (SYMBOL_CLASS (sym
))
479 long current_offset
= SYMBOL_VALUE (sym
);
480 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
482 /* Compute address of next argument by adding the size of
483 this argument and rounding to an int boundary. */
485 ((current_offset
+ arg_size
+ sizeof (int) - 1)
486 & ~(sizeof (int) - 1));
488 /* If this is the highest offset seen yet, set
490 if (highest_offset
== -1
491 || (current_offset
> highest_offset
))
492 highest_offset
= current_offset
;
494 /* Add the number of ints we're about to print to
496 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
499 /* We care about types of symbols, but don't need to
500 keep track of stack offsets in them. */
502 case LOC_REGPARM_ADDR
:
504 case LOC_OPTIMIZED_OUT
:
509 /* We have to look up the symbol because arguments can have
510 two entries (one a parameter, one a local) and the one we
511 want is the local, which lookup_symbol will find for us.
512 This includes gcc1 (not gcc2) on SPARC when passing a
513 small structure and gcc2 when the argument type is float
514 and it is passed as a double and converted to float by
515 the prologue (in the latter case the type of the LOC_ARG
516 symbol is double and the type of the LOC_LOCAL symbol is
518 /* But if the parameter name is null, don't try it. Null
519 parameter names occur on the RS/6000, for traceback
520 tables. FIXME, should we even print them? */
522 if (*SYMBOL_LINKAGE_NAME (sym
))
526 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
527 b
, VAR_DOMAIN
, NULL
);
528 gdb_assert (nsym
!= NULL
);
529 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
530 && !SYMBOL_IS_ARGUMENT (nsym
))
532 /* There is a LOC_ARG/LOC_REGISTER pair. This means
533 that it was passed on the stack and loaded into a
534 register, or passed in a register and stored in a
535 stack slot. GDB 3.x used the LOC_ARG; GDB
536 4.0-4.11 used the LOC_REGISTER.
538 Reasons for using the LOC_ARG:
540 (1) Because find_saved_registers may be slow for
543 (2) Because registers are often re-used and stack
544 slots rarely (never?) are. Therefore using
545 the stack slot is much less likely to print
548 Reasons why we might want to use the LOC_REGISTER:
550 (1) So that the backtrace prints the same value
551 as "print foo". I see no compelling reason
552 why this needs to be the case; having the
553 backtrace print the value which was passed
554 in, and "print foo" print the value as
555 modified within the called function, makes
558 Additional note: It might be nice if "info args"
559 displayed both values.
561 One more note: There is a case with SPARC
562 structure passing where we need to use the
563 LOC_REGISTER, but this is dealt with by creating
564 a single LOC_REGPARM in symbol reading. */
566 /* Leave sym (the LOC_ARG) alone. */
573 /* Print the current arg. */
575 ui_out_text (uiout
, ", ");
576 ui_out_wrap_hint (uiout
, " ");
580 memset (&arg
, 0, sizeof (arg
));
582 arg
.entry_kind
= print_entry_values_no
;
583 memset (&entryarg
, 0, sizeof (entryarg
));
585 entryarg
.entry_kind
= print_entry_values_no
;
588 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
590 if (arg
.entry_kind
!= print_entry_values_only
)
591 print_frame_arg (&arg
);
593 if (entryarg
.entry_kind
!= print_entry_values_no
)
595 if (arg
.entry_kind
!= print_entry_values_only
)
597 ui_out_text (uiout
, ", ");
598 ui_out_wrap_hint (uiout
, " ");
601 print_frame_arg (&entryarg
);
605 xfree (entryarg
.error
);
611 /* Don't print nameless args in situations where we don't know
612 enough about the stack to find them. */
617 if (highest_offset
== -1)
618 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
620 start
= highest_offset
;
622 print_frame_nameless_args (frame
, start
, num
- args_printed
,
626 do_cleanups (old_chain
);
629 /* Set the current source and line to the location given by frame
630 FRAME, if possible. When CENTER is true, adjust so the relevant
631 line is in the center of the next 'list'. */
634 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
636 struct symtab_and_line sal
;
638 find_frame_sal (frame
, &sal
);
642 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
643 set_current_source_symtab_and_line (&sal
);
647 /* If ON, GDB will display disassembly of the next source line when
648 execution of the program being debugged stops.
649 If AUTO (which is the default), or there's no line info to determine
650 the source line of the next instruction, display disassembly of next
651 instruction instead. */
653 static enum auto_boolean disassemble_next_line
;
656 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
657 struct cmd_list_element
*c
,
660 fprintf_filtered (file
,
661 _("Debugger's willingness to use "
662 "disassemble-next-line is %s.\n"),
666 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
667 because it will be broken by filter sometime. */
670 do_gdb_disassembly (struct gdbarch
*gdbarch
,
671 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
673 volatile struct gdb_exception exception
;
675 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
677 gdb_disassembly (gdbarch
, current_uiout
, 0,
678 DISASSEMBLY_RAW_INSN
, how_many
,
681 if (exception
.reason
< 0)
683 /* If an exception was thrown while doing the disassembly, print
684 the error message, to give the user a clue of what happened. */
685 exception_print (gdb_stderr
, exception
);
689 /* Print information about frame FRAME. The output is format according
690 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
693 SRC_LINE: Print only source line.
694 LOCATION: Print only location.
695 LOC_AND_SRC: Print location and source line.
697 Used in "where" output, and to emit breakpoint or step
701 print_frame_info (struct frame_info
*frame
, int print_level
,
702 enum print_what print_what
, int print_args
)
704 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
705 struct symtab_and_line sal
;
708 struct ui_out
*uiout
= current_uiout
;
710 if (get_frame_type (frame
) == DUMMY_FRAME
711 || get_frame_type (frame
) == SIGTRAMP_FRAME
712 || get_frame_type (frame
) == ARCH_FRAME
)
714 struct cleanup
*uiout_cleanup
715 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
717 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
718 gdbarch
, get_frame_pc (frame
));
720 /* Do this regardless of SOURCE because we don't have any source
721 to list for this frame. */
724 ui_out_text (uiout
, "#");
725 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
726 frame_relative_level (frame
));
728 if (ui_out_is_mi_like_p (uiout
))
730 annotate_frame_address ();
731 ui_out_field_core_addr (uiout
, "addr",
732 gdbarch
, get_frame_pc (frame
));
733 annotate_frame_address_end ();
736 if (get_frame_type (frame
) == DUMMY_FRAME
)
738 annotate_function_call ();
739 ui_out_field_string (uiout
, "func", "<function called from gdb>");
741 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
743 annotate_signal_handler_caller ();
744 ui_out_field_string (uiout
, "func", "<signal handler called>");
746 else if (get_frame_type (frame
) == ARCH_FRAME
)
748 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
750 ui_out_text (uiout
, "\n");
751 annotate_frame_end ();
753 do_cleanups (uiout_cleanup
);
757 /* If FRAME is not the innermost frame, that normally means that
758 FRAME->pc points to *after* the call instruction, and we want to
759 get the line containing the call, never the next line. But if
760 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
761 next frame was not entered as the result of a call, and we want
762 to get the line containing FRAME->pc. */
763 find_frame_sal (frame
, &sal
);
765 location_print
= (print_what
== LOCATION
766 || print_what
== LOC_AND_ADDRESS
767 || print_what
== SRC_AND_LOC
);
769 if (location_print
|| !sal
.symtab
)
770 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
772 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
774 /* If disassemble-next-line is set to auto or on and doesn't have
775 the line debug messages for $pc, output the next instruction. */
776 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
777 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
778 && source_print
&& !sal
.symtab
)
779 do_gdb_disassembly (get_frame_arch (frame
), 1,
780 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
782 if (source_print
&& sal
.symtab
)
785 int mid_statement
= ((print_what
== SRC_LINE
)
786 && frame_show_address (frame
, sal
));
788 if (annotation_level
)
789 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
790 get_frame_pc (frame
));
793 if (deprecated_print_frame_info_listing_hook
)
794 deprecated_print_frame_info_listing_hook (sal
.symtab
,
799 struct value_print_options opts
;
801 get_user_print_options (&opts
);
802 /* We used to do this earlier, but that is clearly
803 wrong. This function is used by many different
804 parts of gdb, including normal_stop in infrun.c,
805 which uses this to print out the current PC
806 when we stepi/nexti into the middle of a source
807 line. Only the command line really wants this
808 behavior. Other UIs probably would like the
809 ability to decide for themselves if it is desired. */
810 if (opts
.addressprint
&& mid_statement
)
812 ui_out_field_core_addr (uiout
, "addr",
813 gdbarch
, get_frame_pc (frame
));
814 ui_out_text (uiout
, "\t");
817 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
821 /* If disassemble-next-line is set to on and there is line debug
822 messages, output assembly codes for next line. */
823 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
824 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
827 if (print_what
!= LOCATION
)
831 if (get_frame_pc_if_available (frame
, &pc
))
832 set_default_breakpoint (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
834 set_default_breakpoint (0, 0, 0, 0, 0);
837 annotate_frame_end ();
839 gdb_flush (gdb_stdout
);
842 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
843 corresponding to FRAME. */
846 find_frame_funname (struct frame_info
*frame
, char **funname
,
847 enum language
*funlang
, struct symbol
**funcp
)
852 *funlang
= language_unknown
;
856 func
= get_frame_function (frame
);
859 /* In certain pathological cases, the symtabs give the wrong
860 function (when we are in the first function in a file which
861 is compiled without debugging symbols, the previous function
862 is compiled with debugging symbols, and the "foo.o" symbol
863 that is supposed to tell us where the file with debugging
864 symbols ends has been truncated by ar because it is longer
865 than 15 characters). This also occurs if the user uses asm()
866 to create a function but not stabs for it (in a file compiled
869 So look in the minimal symbol tables as well, and if it comes
870 up with a larger address for the function use that instead.
871 I don't think this can ever cause any problems; there
872 shouldn't be any minimal symbols in the middle of a function;
873 if this is ever changed many parts of GDB will need to be
874 changed (and we'll create a find_pc_minimal_function or some
877 struct minimal_symbol
*msymbol
= NULL
;
879 /* Don't attempt to do this for inlined functions, which do not
880 have a corresponding minimal symbol. */
881 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
883 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
886 && (SYMBOL_VALUE_ADDRESS (msymbol
)
887 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
889 /* We also don't know anything about the function besides
890 its address and name. */
892 *funname
= SYMBOL_PRINT_NAME (msymbol
);
893 *funlang
= SYMBOL_LANGUAGE (msymbol
);
897 *funname
= SYMBOL_PRINT_NAME (func
);
898 *funlang
= SYMBOL_LANGUAGE (func
);
901 if (*funlang
== language_cplus
)
903 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
904 to display the demangled name that we already have
905 stored in the symbol table, but we stored a version
906 with DMGL_PARAMS turned on, and here we don't want to
907 display parameters. So remove the parameters. */
908 char *func_only
= cp_remove_params (*funname
);
912 *funname
= func_only
;
913 make_cleanup (xfree
, func_only
);
920 struct minimal_symbol
*msymbol
;
923 if (!get_frame_address_in_block_if_available (frame
, &pc
))
926 msymbol
= lookup_minimal_symbol_by_pc (pc
);
929 *funname
= SYMBOL_PRINT_NAME (msymbol
);
930 *funlang
= SYMBOL_LANGUAGE (msymbol
);
936 print_frame (struct frame_info
*frame
, int print_level
,
937 enum print_what print_what
, int print_args
,
938 struct symtab_and_line sal
)
940 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
941 struct ui_out
*uiout
= current_uiout
;
942 char *funname
= NULL
;
943 enum language funlang
= language_unknown
;
944 struct ui_stream
*stb
;
945 struct cleanup
*old_chain
, *list_chain
;
946 struct value_print_options opts
;
951 pc_p
= get_frame_pc_if_available (frame
, &pc
);
953 stb
= ui_out_stream_new (uiout
);
954 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
956 find_frame_funname (frame
, &funname
, &funlang
, &func
);
958 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
961 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
965 ui_out_text (uiout
, "#");
966 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
967 frame_relative_level (frame
));
969 get_user_print_options (&opts
);
970 if (opts
.addressprint
)
972 || frame_show_address (frame
, sal
)
973 || print_what
== LOC_AND_ADDRESS
)
975 annotate_frame_address ();
977 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
979 ui_out_field_string (uiout
, "addr", "<unavailable>");
980 annotate_frame_address_end ();
981 ui_out_text (uiout
, " in ");
983 annotate_frame_function_name ();
984 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
986 ui_out_field_stream (uiout
, "func", stb
);
987 ui_out_wrap_hint (uiout
, " ");
988 annotate_frame_args ();
990 ui_out_text (uiout
, " (");
993 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
995 struct cleanup
*args_list_chain
;
996 volatile struct gdb_exception e
;
998 if (gdbarch_frame_num_args_p (gdbarch
))
1000 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1001 gdb_assert (numargs
>= 0);
1006 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1007 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1009 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1011 /* FIXME: ARGS must be a list. If one argument is a string it
1012 will have " that will not be properly escaped. */
1013 /* Invoke ui_out_tuple_end. */
1014 do_cleanups (args_list_chain
);
1017 ui_out_text (uiout
, ")");
1018 if (sal
.symtab
&& sal
.symtab
->filename
)
1020 annotate_frame_source_begin ();
1021 ui_out_wrap_hint (uiout
, " ");
1022 ui_out_text (uiout
, " at ");
1023 annotate_frame_source_file ();
1024 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
1025 if (ui_out_is_mi_like_p (uiout
))
1027 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1029 if (fullname
!= NULL
)
1030 ui_out_field_string (uiout
, "fullname", fullname
);
1032 annotate_frame_source_file_end ();
1033 ui_out_text (uiout
, ":");
1034 annotate_frame_source_line ();
1035 ui_out_field_int (uiout
, "line", sal
.line
);
1036 annotate_frame_source_end ();
1039 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
1042 char *lib
= PC_SOLIB (get_frame_pc (frame
));
1044 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1045 get_frame_pc (frame
));
1049 annotate_frame_where ();
1050 ui_out_wrap_hint (uiout
, " ");
1051 ui_out_text (uiout
, " from ");
1052 ui_out_field_string (uiout
, "from", lib
);
1056 /* do_cleanups will call ui_out_tuple_end() for us. */
1057 do_cleanups (list_chain
);
1058 ui_out_text (uiout
, "\n");
1059 do_cleanups (old_chain
);
1063 /* Read a frame specification in whatever the appropriate format is
1064 from FRAME_EXP. Call error(), printing MESSAGE, if the
1065 specification is in any way invalid (so this function never returns
1066 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1067 the default selected frame was used. */
1069 static struct frame_info
*
1070 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1071 int *selected_frame_p
)
1074 struct value
*args
[4];
1075 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1077 if (frame_exp
== NULL
)
1085 struct cleanup
*cleanup
;
1088 /* Skip leading white space, bail of EOL. */
1089 while (isspace (*frame_exp
))
1094 /* Parse the argument, extract it, save it. */
1096 *p
&& !isspace (*p
);
1098 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1100 cleanup
= make_cleanup (xfree
, addr_string
);
1102 /* NOTE: Parse and evaluate expression, but do not use
1103 functions such as parse_and_eval_long or
1104 parse_and_eval_address to also extract the value.
1105 Instead value_as_long and value_as_address are used.
1106 This avoids problems with expressions that contain
1108 if (numargs
>= ARRAY_SIZE (args
))
1109 error (_("Too many args in frame specification"));
1110 args
[numargs
++] = parse_and_eval (addr_string
);
1112 do_cleanups (cleanup
);
1116 /* If no args, default to the selected frame. */
1119 if (selected_frame_p
!= NULL
)
1120 (*selected_frame_p
) = 1;
1121 return get_selected_frame (message
);
1124 /* None of the remaining use the selected frame. */
1125 if (selected_frame_p
!= NULL
)
1126 (*selected_frame_p
) = 0;
1128 /* Assume the single arg[0] is an integer, and try using that to
1129 select a frame relative to current. */
1132 struct frame_info
*fid
;
1133 int level
= value_as_long (args
[0]);
1135 fid
= find_relative_frame (get_current_frame (), &level
);
1137 /* find_relative_frame was successful. */
1141 /* Convert each value into a corresponding address. */
1145 for (i
= 0; i
< numargs
; i
++)
1146 addrs
[i
] = value_as_address (args
[i
]);
1149 /* Assume that the single arg[0] is an address, use that to identify
1150 a frame with a matching ID. Should this also accept stack/pc or
1151 stack/pc/special. */
1154 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1155 struct frame_info
*fid
;
1157 /* If (s)he specifies the frame with an address, he deserves
1158 what (s)he gets. Still, give the highest one that matches.
1159 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1161 for (fid
= get_current_frame ();
1163 fid
= get_prev_frame (fid
))
1165 if (frame_id_eq (id
, get_frame_id (fid
)))
1167 struct frame_info
*prev_frame
;
1171 prev_frame
= get_prev_frame (fid
);
1173 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1182 /* We couldn't identify the frame as an existing frame, but
1183 perhaps we can create one with a single argument. */
1185 return create_new_frame (addrs
[0], 0);
1186 else if (numargs
== 2)
1187 return create_new_frame (addrs
[0], addrs
[1]);
1189 error (_("Too many args in frame specification"));
1192 static struct frame_info
*
1193 parse_frame_specification (char *frame_exp
)
1195 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1198 /* Print verbosely the selected frame or the frame at address
1199 ADDR_EXP. Absolutely all information in the frame is printed. */
1202 frame_info (char *addr_exp
, int from_tty
)
1204 struct frame_info
*fi
;
1205 struct symtab_and_line sal
;
1206 struct symbol
*func
;
1208 struct frame_info
*calling_frame_info
;
1211 enum language funlang
= language_unknown
;
1212 const char *pc_regname
;
1213 int selected_frame_p
;
1214 struct gdbarch
*gdbarch
;
1215 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1218 CORE_ADDR caller_pc
;
1220 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1221 gdbarch
= get_frame_arch (fi
);
1223 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1224 is not a good name. */
1225 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1226 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1227 easily not match that of the internal value returned by
1229 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1231 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1232 architectures will often have a hardware register called "pc",
1233 and that register's value, again, can easily not match
1237 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1238 find_frame_sal (fi
, &sal
);
1239 func
= get_frame_function (fi
);
1243 funname
= SYMBOL_PRINT_NAME (func
);
1244 funlang
= SYMBOL_LANGUAGE (func
);
1245 if (funlang
== language_cplus
)
1247 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1248 to display the demangled name that we already have
1249 stored in the symbol table, but we stored a version
1250 with DMGL_PARAMS turned on, and here we don't want to
1251 display parameters. So remove the parameters. */
1252 char *func_only
= cp_remove_params (funname
);
1256 funname
= func_only
;
1257 make_cleanup (xfree
, func_only
);
1261 else if (frame_pc_p
)
1263 struct minimal_symbol
*msymbol
;
1265 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1266 if (msymbol
!= NULL
)
1268 funname
= SYMBOL_PRINT_NAME (msymbol
);
1269 funlang
= SYMBOL_LANGUAGE (msymbol
);
1272 calling_frame_info
= get_prev_frame (fi
);
1274 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1276 printf_filtered (_("Stack level %d, frame at "),
1277 frame_relative_level (fi
));
1281 printf_filtered (_("Stack frame at "));
1283 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1284 printf_filtered (":\n");
1285 printf_filtered (" %s = ", pc_regname
);
1287 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1289 fputs_filtered ("<unavailable>", gdb_stdout
);
1294 printf_filtered (" in ");
1295 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1296 DMGL_ANSI
| DMGL_PARAMS
);
1300 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1301 puts_filtered ("; ");
1303 printf_filtered ("saved %s ", pc_regname
);
1304 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1305 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1307 fputs_filtered ("<unavailable>", gdb_stdout
);
1308 printf_filtered ("\n");
1310 if (calling_frame_info
== NULL
)
1312 enum unwind_stop_reason reason
;
1314 reason
= get_frame_unwind_stop_reason (fi
);
1315 if (reason
!= UNWIND_NO_REASON
)
1316 printf_filtered (_(" Outermost frame: %s\n"),
1317 frame_stop_reason_string (reason
));
1319 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1320 puts_filtered (" tail call frame");
1321 else if (get_frame_type (fi
) == INLINE_FRAME
)
1322 printf_filtered (" inlined into frame %d",
1323 frame_relative_level (get_prev_frame (fi
)));
1326 printf_filtered (" called by frame at ");
1327 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1330 if (get_next_frame (fi
) && calling_frame_info
)
1331 puts_filtered (",");
1333 if (get_next_frame (fi
))
1335 printf_filtered (" caller of frame at ");
1336 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1339 if (get_next_frame (fi
) || calling_frame_info
)
1340 puts_filtered ("\n");
1343 printf_filtered (" source language %s.\n",
1344 language_str (s
->language
));
1347 /* Address of the argument list for this frame, or 0. */
1348 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1349 /* Number of args for this frame, or -1 if unknown. */
1353 printf_filtered (" Arglist at unknown address.\n");
1356 printf_filtered (" Arglist at ");
1357 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1358 printf_filtered (",");
1360 if (!gdbarch_frame_num_args_p (gdbarch
))
1363 puts_filtered (" args: ");
1367 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1368 gdb_assert (numargs
>= 0);
1370 puts_filtered (" no args.");
1371 else if (numargs
== 1)
1372 puts_filtered (" 1 arg: ");
1374 printf_filtered (" %d args: ", numargs
);
1376 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1377 puts_filtered ("\n");
1381 /* Address of the local variables for this frame, or 0. */
1382 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1385 printf_filtered (" Locals at unknown address,");
1388 printf_filtered (" Locals at ");
1389 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1390 printf_filtered (",");
1394 /* Print as much information as possible on the location of all the
1397 enum lval_type lval
;
1406 /* The sp is special; what's displayed isn't the save address, but
1407 the value of the previous frame's sp. This is a legacy thing,
1408 at one stage the frame cached the previous frame's SP instead
1409 of its address, hence it was easiest to just display the cached
1411 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1413 /* Find out the location of the saved stack pointer with out
1414 actually evaluating it. */
1415 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1416 &optimized
, &unavailable
, &lval
, &addr
,
1418 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1420 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1421 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1422 gdb_byte value
[MAX_REGISTER_SIZE
];
1425 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1426 &optimized
, &unavailable
, &lval
, &addr
,
1428 /* NOTE: cagney/2003-05-22: This is assuming that the
1429 stack pointer was packed as an unsigned integer. That
1430 may or may not be valid. */
1431 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1432 printf_filtered (" Previous frame's sp is ");
1433 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1434 printf_filtered ("\n");
1437 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1439 printf_filtered (" Previous frame's sp at ");
1440 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1441 printf_filtered ("\n");
1444 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1446 printf_filtered (" Previous frame's sp in %s\n",
1447 gdbarch_register_name (gdbarch
, realnum
));
1450 /* else keep quiet. */
1454 numregs
= gdbarch_num_regs (gdbarch
)
1455 + gdbarch_num_pseudo_regs (gdbarch
);
1456 for (i
= 0; i
< numregs
; i
++)
1457 if (i
!= gdbarch_sp_regnum (gdbarch
)
1458 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1460 /* Find out the location of the saved register without
1461 fetching the corresponding value. */
1462 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1463 &lval
, &addr
, &realnum
, NULL
);
1464 /* For moment, only display registers that were saved on the
1466 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1469 puts_filtered (" Saved registers:\n ");
1471 puts_filtered (",");
1473 printf_filtered (" %s at ",
1474 gdbarch_register_name (gdbarch
, i
));
1475 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1479 if (count
|| need_nl
)
1480 puts_filtered ("\n");
1483 do_cleanups (back_to
);
1486 /* Print briefly all stack frames or just the innermost COUNT_EXP
1490 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1492 struct frame_info
*fi
;
1495 struct frame_info
*trailing
;
1498 if (!target_has_stack
)
1499 error (_("No stack."));
1501 /* The following code must do two things. First, it must set the
1502 variable TRAILING to the frame from which we should start
1503 printing. Second, it must set the variable count to the number
1504 of frames which we should print, or -1 if all of them. */
1505 trailing
= get_current_frame ();
1510 count
= parse_and_eval_long (count_exp
);
1513 struct frame_info
*current
;
1518 while (current
&& count
--)
1521 current
= get_prev_frame (current
);
1524 /* Will stop when CURRENT reaches the top of the stack.
1525 TRAILING will be COUNT below it. */
1529 trailing
= get_prev_frame (trailing
);
1530 current
= get_prev_frame (current
);
1542 /* Read in symbols for all of the frames. Need to do this in a
1543 separate pass so that "Reading in symbols for xxx" messages
1544 don't screw up the appearance of the backtrace. Also if
1545 people have strong opinions against reading symbols for
1546 backtrace this may have to be an option. */
1548 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1553 pc
= get_frame_address_in_block (fi
);
1554 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1558 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1562 /* Don't use print_stack_frame; if an error() occurs it probably
1563 means further attempts to backtrace would fail (on the other
1564 hand, perhaps the code does or could be fixed to make sure
1565 the frame->prev field gets set to NULL in that case). */
1566 print_frame_info (fi
, 1, LOCATION
, 1);
1568 print_frame_local_vars (fi
, 1, gdb_stdout
);
1570 /* Save the last frame to check for error conditions. */
1574 /* If we've stopped before the end, mention that. */
1576 printf_filtered (_("(More stack frames follow...)\n"));
1578 /* If we've run out of frames, and the reason appears to be an error
1579 condition, print it. */
1580 if (fi
== NULL
&& trailing
!= NULL
)
1582 enum unwind_stop_reason reason
;
1584 reason
= get_frame_unwind_stop_reason (trailing
);
1585 if (reason
> UNWIND_FIRST_ERROR
)
1586 printf_filtered (_("Backtrace stopped: %s\n"),
1587 frame_stop_reason_string (reason
));
1592 backtrace_command (char *arg
, int from_tty
)
1594 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1595 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1602 argv
= gdb_buildargv (arg
);
1603 make_cleanup_freeargv (argv
);
1605 for (i
= 0; argv
[i
]; i
++)
1609 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1610 argv
[i
][j
] = tolower (argv
[i
][j
]);
1612 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1613 fulltrace_arg
= argc
;
1616 arglen
+= strlen (argv
[i
]);
1621 if (fulltrace_arg
>= 0)
1625 arg
= xmalloc (arglen
+ 1);
1626 make_cleanup (xfree
, arg
);
1628 for (i
= 0; i
< (argc
+ 1); i
++)
1630 if (i
!= fulltrace_arg
)
1632 strcat (arg
, argv
[i
]);
1642 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */, from_tty
);
1644 do_cleanups (old_chain
);
1648 backtrace_full_command (char *arg
, int from_tty
)
1650 backtrace_command_1 (arg
, 1 /* show_locals */, from_tty
);
1654 /* Iterate over the local variables of a block B, calling CB with
1658 iterate_over_block_locals (struct block
*b
,
1659 iterate_over_block_arg_local_vars_cb cb
,
1662 struct dict_iterator iter
;
1665 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1667 switch (SYMBOL_CLASS (sym
))
1673 if (SYMBOL_IS_ARGUMENT (sym
))
1675 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1679 /* Ignore symbols which are not locals. */
1686 /* Same, but print labels. */
1689 /* Commented out, as the code using this function has also been
1690 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1691 was commented out in the first place. The discussion introducing
1692 this change (2007-12-04: Support lexical blocks and function bodies
1693 that occupy non-contiguous address ranges) did not explain why
1694 this change was made. */
1696 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1697 int *have_default
, struct ui_file
*stream
)
1699 struct dict_iterator iter
;
1701 int values_printed
= 0;
1703 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1705 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1711 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1713 struct symtab_and_line sal
;
1714 struct value_print_options opts
;
1716 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1718 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1719 get_user_print_options (&opts
);
1720 if (opts
.addressprint
)
1722 fprintf_filtered (stream
, " ");
1723 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1726 fprintf_filtered (stream
, " in file %s, line %d\n",
1727 sal
.symtab
->filename
, sal
.line
);
1731 return values_printed
;
1735 /* Iterate over all the local variables in block B, including all its
1736 superblocks, stopping when the top-level block is reached. */
1739 iterate_over_block_local_vars (struct block
*block
,
1740 iterate_over_block_arg_local_vars_cb cb
,
1745 iterate_over_block_locals (block
, cb
, cb_data
);
1746 /* After handling the function's top-level block, stop. Don't
1747 continue to its superblock, the block of per-file
1749 if (BLOCK_FUNCTION (block
))
1751 block
= BLOCK_SUPERBLOCK (block
);
1755 /* Data to be passed around in the calls to the locals and args
1758 struct print_variable_and_value_data
1760 struct frame_info
*frame
;
1762 struct ui_file
*stream
;
1766 /* The callback for the locals and args iterators. */
1769 do_print_variable_and_value (const char *print_name
,
1773 struct print_variable_and_value_data
*p
= cb_data
;
1775 print_variable_and_value (print_name
, sym
,
1776 p
->frame
, p
->stream
, p
->num_tabs
);
1777 p
->values_printed
= 1;
1781 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1782 struct ui_file
*stream
)
1784 struct print_variable_and_value_data cb_data
;
1785 struct block
*block
;
1788 if (!get_frame_pc_if_available (frame
, &pc
))
1790 fprintf_filtered (stream
,
1791 _("PC unavailable, cannot determine locals.\n"));
1795 block
= get_frame_block (frame
, 0);
1798 fprintf_filtered (stream
, "No symbol table info available.\n");
1802 cb_data
.frame
= frame
;
1803 cb_data
.num_tabs
= 4 * num_tabs
;
1804 cb_data
.stream
= stream
;
1805 cb_data
.values_printed
= 0;
1807 iterate_over_block_local_vars (block
,
1808 do_print_variable_and_value
,
1811 if (!cb_data
.values_printed
)
1812 fprintf_filtered (stream
, _("No locals.\n"));
1815 /* Same, but print labels. */
1818 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1819 struct ui_file
*stream
)
1822 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1824 struct blockvector
*bl
;
1825 struct block
*block
= get_frame_block (frame
, 0);
1826 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1827 int values_printed
= 0;
1828 int index
, have_default
= 0;
1829 char *blocks_printed
;
1830 CORE_ADDR pc
= get_frame_pc (frame
);
1834 fprintf_filtered (stream
, "No symbol table info available.\n");
1838 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1839 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1840 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1844 CORE_ADDR end
= BLOCK_END (block
) - 4;
1847 if (bl
!= blockvector_for_pc (end
, &index
))
1848 error (_("blockvector blotch"));
1849 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1850 error (_("blockvector botch"));
1851 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1854 /* Don't print out blocks that have gone by. */
1855 while (index
< last_index
1856 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1859 while (index
< last_index
1860 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1862 if (blocks_printed
[index
] == 0)
1864 if (print_block_frame_labels (gdbarch
,
1865 BLOCKVECTOR_BLOCK (bl
, index
),
1866 &have_default
, stream
))
1868 blocks_printed
[index
] = 1;
1874 if (values_printed
&& this_level_only
)
1877 /* After handling the function's top-level block, stop. Don't
1878 continue to its superblock, the block of per-file symbols.
1879 Also do not continue to the containing function of an inlined
1881 if (BLOCK_FUNCTION (block
))
1883 block
= BLOCK_SUPERBLOCK (block
);
1886 if (!values_printed
&& !this_level_only
)
1887 fprintf_filtered (stream
, _("No catches.\n"));
1892 locals_info (char *args
, int from_tty
)
1894 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1899 catch_info (char *ignore
, int from_tty
)
1901 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1902 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1906 /* Iterate over all the argument variables in block B.
1908 Returns 1 if any argument was walked; 0 otherwise. */
1911 iterate_over_block_arg_vars (struct block
*b
,
1912 iterate_over_block_arg_local_vars_cb cb
,
1915 struct dict_iterator iter
;
1916 struct symbol
*sym
, *sym2
;
1918 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1920 /* Don't worry about things which aren't arguments. */
1921 if (SYMBOL_IS_ARGUMENT (sym
))
1923 /* We have to look up the symbol because arguments can have
1924 two entries (one a parameter, one a local) and the one we
1925 want is the local, which lookup_symbol will find for us.
1926 This includes gcc1 (not gcc2) on the sparc when passing a
1927 small structure and gcc2 when the argument type is float
1928 and it is passed as a double and converted to float by
1929 the prologue (in the latter case the type of the LOC_ARG
1930 symbol is double and the type of the LOC_LOCAL symbol is
1931 float). There are also LOC_ARG/LOC_REGISTER pairs which
1932 are not combined in symbol-reading. */
1934 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1935 b
, VAR_DOMAIN
, NULL
);
1936 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
1942 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1944 struct print_variable_and_value_data cb_data
;
1945 struct symbol
*func
;
1948 if (!get_frame_pc_if_available (frame
, &pc
))
1950 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
1954 func
= get_frame_function (frame
);
1957 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1961 cb_data
.frame
= frame
;
1962 cb_data
.num_tabs
= 0;
1963 cb_data
.stream
= gdb_stdout
;
1964 cb_data
.values_printed
= 0;
1966 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
1967 do_print_variable_and_value
, &cb_data
);
1969 if (!cb_data
.values_printed
)
1970 fprintf_filtered (stream
, _("No arguments.\n"));
1974 args_info (char *ignore
, int from_tty
)
1976 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1982 args_plus_locals_info (char *ignore
, int from_tty
)
1984 args_info (ignore
, from_tty
);
1985 locals_info (ignore
, from_tty
);
1989 /* Select frame FRAME. Also print the stack frame and show the source
1990 if this is the tui version. */
1992 select_and_print_frame (struct frame_info
*frame
)
1994 select_frame (frame
);
1996 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1999 /* Return the symbol-block in which the selected frame is executing.
2000 Can return zero under various legitimate circumstances.
2002 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2003 code address within the block returned. We use this to decide
2004 which macros are in scope. */
2007 get_selected_block (CORE_ADDR
*addr_in_block
)
2009 if (!has_stack_frames ())
2012 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2015 /* Find a frame a certain number of levels away from FRAME.
2016 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2017 Positive means go to earlier frames (up); negative, the reverse.
2018 The int that contains the number of levels is counted toward
2019 zero as the frames for those levels are found.
2020 If the top or bottom frame is reached, that frame is returned,
2021 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2022 how much farther the original request asked to go. */
2025 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2027 /* Going up is simple: just call get_prev_frame enough times or
2028 until the initial frame is reached. */
2029 while (*level_offset_ptr
> 0)
2031 struct frame_info
*prev
= get_prev_frame (frame
);
2035 (*level_offset_ptr
)--;
2039 /* Going down is just as simple. */
2040 while (*level_offset_ptr
< 0)
2042 struct frame_info
*next
= get_next_frame (frame
);
2046 (*level_offset_ptr
)++;
2053 /* The "select_frame" command. With no argument this is a NOP.
2054 Select the frame at level LEVEL_EXP if it is a valid level.
2055 Otherwise, treat LEVEL_EXP as an address expression and select it.
2057 See parse_frame_specification for more info on proper frame
2061 select_frame_command (char *level_exp
, int from_tty
)
2063 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2066 /* The "frame" command. With no argument, print the selected frame
2067 briefly. With an argument, behave like select_frame and then print
2068 the selected frame. */
2071 frame_command (char *level_exp
, int from_tty
)
2073 select_frame_command (level_exp
, from_tty
);
2074 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2077 /* The XDB Compatibility command to print the current frame. */
2080 current_frame_command (char *level_exp
, int from_tty
)
2082 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2085 /* Select the frame up one or COUNT_EXP stack levels from the
2086 previously selected frame, and print it briefly. */
2089 up_silently_base (char *count_exp
)
2091 struct frame_info
*frame
;
2095 count
= parse_and_eval_long (count_exp
);
2097 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2098 if (count
!= 0 && count_exp
== NULL
)
2099 error (_("Initial frame selected; you cannot go up."));
2100 select_frame (frame
);
2104 up_silently_command (char *count_exp
, int from_tty
)
2106 up_silently_base (count_exp
);
2110 up_command (char *count_exp
, int from_tty
)
2112 up_silently_base (count_exp
);
2113 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2116 /* Select the frame down one or COUNT_EXP stack levels from the previously
2117 selected frame, and print it briefly. */
2120 down_silently_base (char *count_exp
)
2122 struct frame_info
*frame
;
2126 count
= -parse_and_eval_long (count_exp
);
2128 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2129 if (count
!= 0 && count_exp
== NULL
)
2131 /* We only do this if COUNT_EXP is not specified. That way
2132 "down" means to really go down (and let me know if that is
2133 impossible), but "down 9999" can be used to mean go all the
2134 way down without getting an error. */
2136 error (_("Bottom (innermost) frame selected; you cannot go down."));
2139 select_frame (frame
);
2143 down_silently_command (char *count_exp
, int from_tty
)
2145 down_silently_base (count_exp
);
2149 down_command (char *count_exp
, int from_tty
)
2151 down_silently_base (count_exp
);
2152 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2157 return_command (char *retval_exp
, int from_tty
)
2159 struct frame_info
*thisframe
;
2160 struct gdbarch
*gdbarch
;
2161 struct symbol
*thisfun
;
2162 struct value
*return_value
= NULL
;
2163 const char *query_prefix
= "";
2165 thisframe
= get_selected_frame ("No selected frame.");
2166 thisfun
= get_frame_function (thisframe
);
2167 gdbarch
= get_frame_arch (thisframe
);
2169 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2170 error (_("Can not force return from an inlined function."));
2172 /* Compute the return value. If the computation triggers an error,
2173 let it bail. If the return type can't be handled, set
2174 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2178 struct expression
*retval_expr
= parse_expression (retval_exp
);
2179 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2180 struct type
*return_type
= NULL
;
2182 /* Compute the return value. Should the computation fail, this
2183 call throws an error. */
2184 return_value
= evaluate_expression (retval_expr
);
2186 /* Cast return value to the return type of the function. Should
2187 the cast fail, this call throws an error. */
2188 if (thisfun
!= NULL
)
2189 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2190 if (return_type
== NULL
)
2192 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2193 error (_("Return value type not available for selected "
2195 "Please use an explicit cast of the value to return."));
2196 return_type
= value_type (return_value
);
2198 do_cleanups (old_chain
);
2199 CHECK_TYPEDEF (return_type
);
2200 return_value
= value_cast (return_type
, return_value
);
2202 /* Make sure the value is fully evaluated. It may live in the
2203 stack frame we're about to pop. */
2204 if (value_lazy (return_value
))
2205 value_fetch_lazy (return_value
);
2207 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2208 /* If the return-type is "void", don't try to find the
2209 return-value's location. However, do still evaluate the
2210 return expression so that, even when the expression result
2211 is discarded, side effects such as "return i++" still
2213 return_value
= NULL
;
2214 else if (thisfun
!= NULL
2215 && using_struct_return (gdbarch
,
2216 SYMBOL_TYPE (thisfun
), return_type
))
2218 query_prefix
= "The location at which to store the "
2219 "function's return value is unknown.\n"
2220 "If you continue, the return value "
2221 "that you specified will be ignored.\n";
2222 return_value
= NULL
;
2226 /* Does an interactive user really want to do this? Include
2227 information, such as how well GDB can handle the return value, in
2228 the query message. */
2233 if (thisfun
== NULL
)
2234 confirmed
= query (_("%sMake selected stack frame return now? "),
2237 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2238 SYMBOL_PRINT_NAME (thisfun
));
2240 error (_("Not confirmed"));
2243 /* Discard the selected frame and all frames inner-to it. */
2244 frame_pop (get_selected_frame (NULL
));
2246 /* Store RETURN_VALUE in the just-returned register set. */
2247 if (return_value
!= NULL
)
2249 struct type
*return_type
= value_type (return_value
);
2250 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2251 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2253 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2255 == RETURN_VALUE_REGISTER_CONVENTION
);
2256 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2257 get_current_regcache (), NULL
/*read*/,
2258 value_contents (return_value
) /*write*/);
2261 /* If we are at the end of a call dummy now, pop the dummy frame
2263 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2264 frame_pop (get_current_frame ());
2266 /* If interactive, print the frame that is now current. */
2268 frame_command ("0", 1);
2270 select_frame_command ("0", 0);
2273 /* Sets the scope to input function name, provided that the function
2274 is within the current stack frame. */
2276 struct function_bounds
2278 CORE_ADDR low
, high
;
2282 func_command (char *arg
, int from_tty
)
2284 struct frame_info
*frame
;
2286 struct symtabs_and_lines sals
;
2289 struct function_bounds
*func_bounds
= NULL
;
2294 frame
= parse_frame_specification ("0");
2295 sals
= decode_line_spec (arg
, 1);
2296 func_bounds
= (struct function_bounds
*) xmalloc (
2297 sizeof (struct function_bounds
) * sals
.nelts
);
2298 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2300 if (sals
.sals
[i
].pc
== 0
2301 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2302 &func_bounds
[i
].low
,
2303 &func_bounds
[i
].high
) == 0)
2305 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2311 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2312 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2313 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2317 frame
= find_relative_frame (frame
, &level
);
2320 while (!found
&& level
== 0);
2323 xfree (func_bounds
);
2326 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2327 else if (frame
!= get_selected_frame (NULL
))
2328 select_and_print_frame (frame
);
2331 /* Gets the language of the current frame. */
2334 get_frame_language (void)
2336 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2340 volatile struct gdb_exception ex
;
2344 /* We determine the current frame language by looking up its
2345 associated symtab. To retrieve this symtab, we use the frame
2346 PC. However we cannot use the frame PC as is, because it
2347 usually points to the instruction following the "call", which
2348 is sometimes the first instruction of another function. So
2349 we rely on get_frame_address_in_block(), it provides us with
2350 a PC that is guaranteed to be inside the frame's code
2353 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2355 pc
= get_frame_address_in_block (frame
);
2359 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2360 throw_exception (ex
);
2364 s
= find_pc_symtab (pc
);
2370 return language_unknown
;
2374 /* Provide a prototype to silence -Wmissing-prototypes. */
2375 void _initialize_stack (void);
2378 _initialize_stack (void)
2380 add_com ("return", class_stack
, return_command
, _("\
2381 Make selected stack frame return to its caller.\n\
2382 Control remains in the debugger, but when you continue\n\
2383 execution will resume in the frame above the one now selected.\n\
2384 If an argument is given, it is an expression for the value to return."));
2386 add_com ("up", class_stack
, up_command
, _("\
2387 Select and print stack frame that called this one.\n\
2388 An argument says how many frames up to go."));
2389 add_com ("up-silently", class_support
, up_silently_command
, _("\
2390 Same as the `up' command, but does not print anything.\n\
2391 This is useful in command scripts."));
2393 add_com ("down", class_stack
, down_command
, _("\
2394 Select and print stack frame called by this one.\n\
2395 An argument says how many frames down to go."));
2396 add_com_alias ("do", "down", class_stack
, 1);
2397 add_com_alias ("dow", "down", class_stack
, 1);
2398 add_com ("down-silently", class_support
, down_silently_command
, _("\
2399 Same as the `down' command, but does not print anything.\n\
2400 This is useful in command scripts."));
2402 add_com ("frame", class_stack
, frame_command
, _("\
2403 Select and print a stack frame.\nWith no argument, \
2404 print the selected stack frame. (See also \"info frame\").\n\
2405 An argument specifies the frame to select.\n\
2406 It can be a stack frame number or the address of the frame.\n\
2407 With argument, nothing is printed if input is coming from\n\
2408 a command file or a user-defined command."));
2410 add_com_alias ("f", "frame", class_stack
, 1);
2414 add_com ("L", class_stack
, current_frame_command
,
2415 _("Print the current stack frame.\n"));
2416 add_com_alias ("V", "frame", class_stack
, 1);
2418 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2419 Select a stack frame without printing anything.\n\
2420 An argument specifies the frame to select.\n\
2421 It can be a stack frame number or the address of the frame.\n"));
2423 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2424 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2425 With a negative argument, print outermost -COUNT frames.\nUse of the \
2426 'full' qualifier also prints the values of the local variables.\n"));
2427 add_com_alias ("bt", "backtrace", class_stack
, 0);
2430 add_com_alias ("t", "backtrace", class_stack
, 0);
2431 add_com ("T", class_stack
, backtrace_full_command
, _("\
2432 Print backtrace of all stack frames, or innermost COUNT frames\n\
2433 and the values of the local variables.\n\
2434 With a negative argument, print outermost -COUNT frames.\n\
2435 Usage: T <count>\n"));
2438 add_com_alias ("where", "backtrace", class_alias
, 0);
2439 add_info ("stack", backtrace_command
,
2440 _("Backtrace of the stack, or innermost COUNT frames."));
2441 add_info_alias ("s", "stack", 1);
2442 add_info ("frame", frame_info
,
2443 _("All about selected stack frame, or frame at ADDR."));
2444 add_info_alias ("f", "frame", 1);
2445 add_info ("locals", locals_info
,
2446 _("Local variables of current stack frame."));
2447 add_info ("args", args_info
,
2448 _("Argument variables of current stack frame."));
2450 add_com ("l", class_info
, args_plus_locals_info
,
2451 _("Argument and local variables of current stack frame."));
2454 add_com ("func", class_stack
, func_command
, _("\
2455 Select the stack frame that contains <func>.\n\
2456 Usage: func <name>\n"));
2458 add_info ("catch", catch_info
,
2459 _("Exceptions that can be caught in the current stack frame."));
2461 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2462 print_frame_arguments_choices
, &print_frame_arguments
,
2463 _("Set printing of non-scalar frame arguments"),
2464 _("Show printing of non-scalar frame arguments"),
2465 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2467 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2468 &disassemble_next_line
, _("\
2469 Set whether to disassemble next source line or insn when execution stops."),
2471 Show whether to disassemble next source line or insn when execution stops."),
2473 If ON, GDB will display disassembly of the next source line, in addition\n\
2474 to displaying the source line itself. If the next source line cannot\n\
2475 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2476 will display disassembly of next instruction instead of showing the\n\
2478 If AUTO, display disassembly of next instruction only if the source line\n\
2479 cannot be displayed.\n\
2480 If OFF (which is the default), never display the disassembly of the next\n\
2483 show_disassemble_next_line
,
2484 &setlist
, &showlist
);
2485 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2487 add_setshow_enum_cmd ("entry-values", class_stack
,
2488 print_entry_values_choices
, &print_entry_values
,
2489 _("Set printing of function arguments at function "
2491 _("Show printing of function arguments at function "
2494 GDB can sometimes determine the values of function arguments at entry,\n\
2495 in addition to their current values. This option tells GDB whether\n\
2496 to print the current value, the value at entry (marked as val@entry),\n\
2497 or both. Note that one or both of these values may be <optimized out>."),
2498 NULL
, NULL
, &setprintlist
, &showprintlist
);