1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "expression.h"
31 #include "breakpoint.h"
38 #include "dictionary.h"
39 #include "exceptions.h"
40 #include "reggroups.h"
44 #include "gdbthread.h"
45 #include "cp-support.h"
47 #include "inline-frame.h"
49 #include "cli/cli-utils.h"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
57 #include "python/python.h"
59 void (*deprecated_selected_frame_level_changed_hook
) (int);
61 /* The possible choices of "set print frame-arguments", and the value
64 static const char *const print_frame_arguments_choices
[] =
65 {"all", "scalars", "none", NULL
};
66 static const char *print_frame_arguments
= "scalars";
68 /* The possible choices of "set print entry-values", and the value
71 const char print_entry_values_no
[] = "no";
72 const char print_entry_values_only
[] = "only";
73 const char print_entry_values_preferred
[] = "preferred";
74 const char print_entry_values_if_needed
[] = "if-needed";
75 const char print_entry_values_both
[] = "both";
76 const char print_entry_values_compact
[] = "compact";
77 const char print_entry_values_default
[] = "default";
78 static const char *const print_entry_values_choices
[] =
80 print_entry_values_no
,
81 print_entry_values_only
,
82 print_entry_values_preferred
,
83 print_entry_values_if_needed
,
84 print_entry_values_both
,
85 print_entry_values_compact
,
86 print_entry_values_default
,
89 const char *print_entry_values
= print_entry_values_default
;
91 /* Prototypes for local functions. */
93 static void print_frame_local_vars (struct frame_info
*, int,
96 static void print_frame (struct frame_info
*frame
, int print_level
,
97 enum print_what print_what
, int print_args
,
98 struct symtab_and_line sal
);
100 static void set_last_displayed_sal (int valid
,
101 struct program_space
*pspace
,
103 struct symtab
*symtab
,
106 /* Zero means do things normally; we are interacting directly with the
107 user. One means print the full filename and linenumber when a
108 frame is printed, and do so in a format emacs18/emacs19.22 can
109 parse. Two means print similar annotations, but in many more
110 cases and in a slightly different syntax. */
112 int annotation_level
= 0;
114 /* These variables hold the last symtab and line we displayed to the user.
115 * This is where we insert a breakpoint or a skiplist entry by default. */
116 static int last_displayed_sal_valid
= 0;
117 static struct program_space
*last_displayed_pspace
= 0;
118 static CORE_ADDR last_displayed_addr
= 0;
119 static struct symtab
*last_displayed_symtab
= 0;
120 static int last_displayed_line
= 0;
123 /* Return 1 if we should display the address in addition to the location,
124 because we are in the middle of a statement. */
127 frame_show_address (struct frame_info
*frame
,
128 struct symtab_and_line sal
)
130 /* If there is a line number, but no PC, then there is no location
131 information associated with this sal. The only way that should
132 happen is for the call sites of inlined functions (SAL comes from
133 find_frame_sal). Otherwise, we would have some PC range if the
134 SAL came from a line table. */
135 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
137 if (get_next_frame (frame
) == NULL
)
138 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
140 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
144 return get_frame_pc (frame
) != sal
.pc
;
147 /* Show or print a stack frame FRAME briefly. The output is format
148 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
149 relative level, function name, argument list, and file name and
150 line number. If the frame's PC is not at the beginning of the
151 source line, the actual PC is printed at the beginning. */
154 print_stack_frame (struct frame_info
*frame
, int print_level
,
155 enum print_what print_what
)
157 volatile struct gdb_exception e
;
159 /* For mi, alway print location and address. */
160 if (ui_out_is_mi_like_p (current_uiout
))
161 print_what
= LOC_AND_ADDRESS
;
163 TRY_CATCH (e
, RETURN_MASK_ERROR
)
165 int center
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
167 print_frame_info (frame
, print_level
, print_what
, 1 /* print_args */);
168 set_current_sal_from_frame (frame
, center
);
172 /* Print nameless arguments of frame FRAME on STREAM, where START is
173 the offset of the first nameless argument, and NUM is the number of
174 nameless arguments to print. FIRST is nonzero if this is the first
175 argument (not just the first nameless argument). */
178 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
179 int first
, struct ui_file
*stream
)
181 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
182 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
187 for (i
= 0; i
< num
; i
++)
190 argsaddr
= get_frame_args_address (frame
);
193 arg_value
= read_memory_integer (argsaddr
+ start
,
194 sizeof (int), byte_order
);
196 fprintf_filtered (stream
, ", ");
197 fprintf_filtered (stream
, "%ld", arg_value
);
199 start
+= sizeof (int);
203 /* Print single argument of inferior function. ARG must be already
206 Errors are printed as if they would be the parameter value. Use zeroed ARG
207 iff it should not be printed accoring to user settings. */
210 print_frame_arg (const struct frame_arg
*arg
)
212 struct ui_out
*uiout
= current_uiout
;
213 volatile struct gdb_exception except
;
214 struct cleanup
*old_chain
;
217 stb
= mem_fileopen ();
218 old_chain
= make_cleanup_ui_file_delete (stb
);
220 gdb_assert (!arg
->val
|| !arg
->error
);
221 gdb_assert (arg
->entry_kind
== print_entry_values_no
222 || arg
->entry_kind
== print_entry_values_only
223 || (!ui_out_is_mi_like_p (uiout
)
224 && arg
->entry_kind
== print_entry_values_compact
));
226 annotate_arg_begin ();
228 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
229 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
230 SYMBOL_LANGUAGE (arg
->sym
), DMGL_PARAMS
| DMGL_ANSI
);
231 if (arg
->entry_kind
== print_entry_values_compact
)
233 /* It is OK to provide invalid MI-like stream as with
234 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
235 fputs_filtered ("=", stb
);
237 fprintf_symbol_filtered (stb
, SYMBOL_PRINT_NAME (arg
->sym
),
238 SYMBOL_LANGUAGE (arg
->sym
),
239 DMGL_PARAMS
| DMGL_ANSI
);
241 if (arg
->entry_kind
== print_entry_values_only
242 || arg
->entry_kind
== print_entry_values_compact
)
243 fputs_filtered ("@entry", stb
);
244 ui_out_field_stream (uiout
, "name", stb
);
245 annotate_arg_name_end ();
246 ui_out_text (uiout
, "=");
248 if (!arg
->val
&& !arg
->error
)
249 ui_out_text (uiout
, "...");
253 except
.message
= arg
->error
;
256 /* TRY_CATCH has two statements, wrap it in a block. */
258 TRY_CATCH (except
, RETURN_MASK_ERROR
)
260 const struct language_defn
*language
;
261 struct value_print_options opts
;
263 /* Avoid value_print because it will deref ref parameters. We
264 just want to print their addresses. Print ??? for args whose
265 address we do not know. We pass 2 as "recurse" to val_print
266 because our standard indentation here is 4 spaces, and
267 val_print indents 2 for each recurse. */
269 annotate_arg_value (value_type (arg
->val
));
271 /* Use the appropriate language to display our symbol, unless the
272 user forced the language to a specific language. */
273 if (language_mode
== language_mode_auto
)
274 language
= language_def (SYMBOL_LANGUAGE (arg
->sym
));
276 language
= current_language
;
278 get_no_prettyformat_print_options (&opts
);
281 /* True in "summary" mode, false otherwise. */
282 opts
.summary
= !strcmp (print_frame_arguments
, "scalars");
284 common_val_print (arg
->val
, stb
, 2, &opts
, language
);
288 fprintf_filtered (stb
, _("<error reading variable: %s>"),
292 ui_out_field_stream (uiout
, "value", stb
);
294 /* Also invoke ui_out_tuple_end. */
295 do_cleanups (old_chain
);
300 /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
301 responsible for xfree of ARGP->ERROR. This function never throws an
305 read_frame_arg (struct symbol
*sym
, struct frame_info
*frame
,
306 struct frame_arg
*argp
, struct frame_arg
*entryargp
)
308 struct value
*val
= NULL
, *entryval
= NULL
;
309 char *val_error
= NULL
, *entryval_error
= NULL
;
311 volatile struct gdb_exception except
;
313 if (print_entry_values
!= print_entry_values_only
314 && print_entry_values
!= print_entry_values_preferred
)
316 TRY_CATCH (except
, RETURN_MASK_ERROR
)
318 val
= read_var_value (sym
, frame
);
322 val_error
= alloca (strlen (except
.message
) + 1);
323 strcpy (val_error
, except
.message
);
327 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
328 && SYMBOL_COMPUTED_OPS (sym
)->read_variable_at_entry
!= NULL
329 && print_entry_values
!= print_entry_values_no
330 && (print_entry_values
!= print_entry_values_if_needed
331 || !val
|| value_optimized_out (val
)))
333 TRY_CATCH (except
, RETURN_MASK_ERROR
)
335 const struct symbol_computed_ops
*ops
;
337 ops
= SYMBOL_COMPUTED_OPS (sym
);
338 entryval
= ops
->read_variable_at_entry (sym
, frame
);
342 entryval_error
= alloca (strlen (except
.message
) + 1);
343 strcpy (entryval_error
, except
.message
);
346 if (except
.error
== NO_ENTRY_VALUE_ERROR
347 || (entryval
&& value_optimized_out (entryval
)))
350 entryval_error
= NULL
;
353 if (print_entry_values
== print_entry_values_compact
354 || print_entry_values
== print_entry_values_default
)
356 /* For MI do not try to use print_entry_values_compact for ARGP. */
358 if (val
&& entryval
&& !ui_out_is_mi_like_p (current_uiout
))
360 struct type
*type
= value_type (val
);
362 if (!value_optimized_out (val
)
363 && value_available_contents_eq (val
, 0, entryval
, 0,
366 /* Initialize it just to avoid a GCC false warning. */
367 struct value
*val_deref
= NULL
, *entryval_deref
;
369 /* DW_AT_GNU_call_site_value does match with the current
370 value. If it is a reference still try to verify if
371 dereferenced DW_AT_GNU_call_site_data_value does not
374 TRY_CATCH (except
, RETURN_MASK_ERROR
)
376 struct type
*type_deref
;
378 val_deref
= coerce_ref (val
);
379 if (value_lazy (val_deref
))
380 value_fetch_lazy (val_deref
);
381 type_deref
= value_type (val_deref
);
383 entryval_deref
= coerce_ref (entryval
);
384 if (value_lazy (entryval_deref
))
385 value_fetch_lazy (entryval_deref
);
387 /* If the reference addresses match but dereferenced
388 content does not match print them. */
390 && value_available_contents_eq (val_deref
, 0,
392 TYPE_LENGTH (type_deref
)))
396 /* Value was not a reference; and its content matches. */
397 if (val
== val_deref
)
399 /* If the dereferenced content could not be fetched do not
401 else if (except
.error
== NO_ENTRY_VALUE_ERROR
)
403 else if (except
.message
)
405 entryval_error
= alloca (strlen (except
.message
) + 1);
406 strcpy (entryval_error
, except
.message
);
414 /* Try to remove possibly duplicate error message for ENTRYARGP even
417 if (val_error
&& entryval_error
418 && strcmp (val_error
, entryval_error
) == 0)
420 entryval_error
= NULL
;
422 /* Do not se VAL_EQUAL as the same error message may be shown for
423 the entry value even if no entry values are present in the
429 if (entryval
== NULL
)
431 if (print_entry_values
== print_entry_values_preferred
)
433 TRY_CATCH (except
, RETURN_MASK_ERROR
)
435 val
= read_var_value (sym
, frame
);
439 val_error
= alloca (strlen (except
.message
) + 1);
440 strcpy (val_error
, except
.message
);
443 if (print_entry_values
== print_entry_values_only
444 || print_entry_values
== print_entry_values_both
445 || (print_entry_values
== print_entry_values_preferred
446 && (!val
|| value_optimized_out (val
))))
447 entryval
= allocate_optimized_out_value (SYMBOL_TYPE (sym
));
449 if ((print_entry_values
== print_entry_values_compact
450 || print_entry_values
== print_entry_values_if_needed
451 || print_entry_values
== print_entry_values_preferred
)
452 && (!val
|| value_optimized_out (val
)) && entryval
!= NULL
)
460 argp
->error
= val_error
? xstrdup (val_error
) : NULL
;
461 if (!val
&& !val_error
)
462 argp
->entry_kind
= print_entry_values_only
;
463 else if ((print_entry_values
== print_entry_values_compact
464 || print_entry_values
== print_entry_values_default
) && val_equal
)
466 argp
->entry_kind
= print_entry_values_compact
;
467 gdb_assert (!ui_out_is_mi_like_p (current_uiout
));
470 argp
->entry_kind
= print_entry_values_no
;
472 entryargp
->sym
= sym
;
473 entryargp
->val
= entryval
;
474 entryargp
->error
= entryval_error
? xstrdup (entryval_error
) : NULL
;
475 if (!entryval
&& !entryval_error
)
476 entryargp
->entry_kind
= print_entry_values_no
;
478 entryargp
->entry_kind
= print_entry_values_only
;
481 /* Print the arguments of frame FRAME on STREAM, given the function
482 FUNC running in that frame (as a symbol), where NUM is the number
483 of arguments according to the stack frame (or -1 if the number of
484 arguments is unknown). */
486 /* Note that currently the "number of arguments according to the
487 stack frame" is only known on VAX where i refers to the "number of
488 ints of arguments according to the stack frame". */
491 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
492 int num
, struct ui_file
*stream
)
494 struct ui_out
*uiout
= current_uiout
;
496 /* Offset of next stack argument beyond the one we have seen that is
497 at the highest offset, or -1 if we haven't come to a stack
499 long highest_offset
= -1;
500 /* Number of ints of arguments that we have printed so far. */
501 int args_printed
= 0;
502 struct cleanup
*old_chain
;
504 /* True if we should print arguments, false otherwise. */
505 int print_args
= strcmp (print_frame_arguments
, "none");
507 stb
= mem_fileopen ();
508 old_chain
= make_cleanup_ui_file_delete (stb
);
512 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
513 struct block_iterator iter
;
516 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
518 struct frame_arg arg
, entryarg
;
522 /* Keep track of the highest stack argument offset seen, and
523 skip over any kinds of symbols we don't care about. */
525 if (!SYMBOL_IS_ARGUMENT (sym
))
528 switch (SYMBOL_CLASS (sym
))
533 long current_offset
= SYMBOL_VALUE (sym
);
534 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
536 /* Compute address of next argument by adding the size of
537 this argument and rounding to an int boundary. */
539 ((current_offset
+ arg_size
+ sizeof (int) - 1)
540 & ~(sizeof (int) - 1));
542 /* If this is the highest offset seen yet, set
544 if (highest_offset
== -1
545 || (current_offset
> highest_offset
))
546 highest_offset
= current_offset
;
548 /* Add the number of ints we're about to print to
550 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
553 /* We care about types of symbols, but don't need to
554 keep track of stack offsets in them. */
556 case LOC_REGPARM_ADDR
:
558 case LOC_OPTIMIZED_OUT
:
563 /* We have to look up the symbol because arguments can have
564 two entries (one a parameter, one a local) and the one we
565 want is the local, which lookup_symbol will find for us.
566 This includes gcc1 (not gcc2) on SPARC when passing a
567 small structure and gcc2 when the argument type is float
568 and it is passed as a double and converted to float by
569 the prologue (in the latter case the type of the LOC_ARG
570 symbol is double and the type of the LOC_LOCAL symbol is
572 /* But if the parameter name is null, don't try it. Null
573 parameter names occur on the RS/6000, for traceback
574 tables. FIXME, should we even print them? */
576 if (*SYMBOL_LINKAGE_NAME (sym
))
580 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
581 b
, VAR_DOMAIN
, NULL
);
582 gdb_assert (nsym
!= NULL
);
583 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
584 && !SYMBOL_IS_ARGUMENT (nsym
))
586 /* There is a LOC_ARG/LOC_REGISTER pair. This means
587 that it was passed on the stack and loaded into a
588 register, or passed in a register and stored in a
589 stack slot. GDB 3.x used the LOC_ARG; GDB
590 4.0-4.11 used the LOC_REGISTER.
592 Reasons for using the LOC_ARG:
594 (1) Because find_saved_registers may be slow for
597 (2) Because registers are often re-used and stack
598 slots rarely (never?) are. Therefore using
599 the stack slot is much less likely to print
602 Reasons why we might want to use the LOC_REGISTER:
604 (1) So that the backtrace prints the same value
605 as "print foo". I see no compelling reason
606 why this needs to be the case; having the
607 backtrace print the value which was passed
608 in, and "print foo" print the value as
609 modified within the called function, makes
612 Additional note: It might be nice if "info args"
613 displayed both values.
615 One more note: There is a case with SPARC
616 structure passing where we need to use the
617 LOC_REGISTER, but this is dealt with by creating
618 a single LOC_REGPARM in symbol reading. */
620 /* Leave sym (the LOC_ARG) alone. */
627 /* Print the current arg. */
629 ui_out_text (uiout
, ", ");
630 ui_out_wrap_hint (uiout
, " ");
634 memset (&arg
, 0, sizeof (arg
));
636 arg
.entry_kind
= print_entry_values_no
;
637 memset (&entryarg
, 0, sizeof (entryarg
));
639 entryarg
.entry_kind
= print_entry_values_no
;
642 read_frame_arg (sym
, frame
, &arg
, &entryarg
);
644 if (arg
.entry_kind
!= print_entry_values_only
)
645 print_frame_arg (&arg
);
647 if (entryarg
.entry_kind
!= print_entry_values_no
)
649 if (arg
.entry_kind
!= print_entry_values_only
)
651 ui_out_text (uiout
, ", ");
652 ui_out_wrap_hint (uiout
, " ");
655 print_frame_arg (&entryarg
);
659 xfree (entryarg
.error
);
665 /* Don't print nameless args in situations where we don't know
666 enough about the stack to find them. */
671 if (highest_offset
== -1)
672 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
674 start
= highest_offset
;
676 print_frame_nameless_args (frame
, start
, num
- args_printed
,
680 do_cleanups (old_chain
);
683 /* Set the current source and line to the location given by frame
684 FRAME, if possible. When CENTER is true, adjust so the relevant
685 line is in the center of the next 'list'. */
688 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
690 struct symtab_and_line sal
;
692 find_frame_sal (frame
, &sal
);
696 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
697 set_current_source_symtab_and_line (&sal
);
701 /* If ON, GDB will display disassembly of the next source line when
702 execution of the program being debugged stops.
703 If AUTO (which is the default), or there's no line info to determine
704 the source line of the next instruction, display disassembly of next
705 instruction instead. */
707 static enum auto_boolean disassemble_next_line
;
710 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
711 struct cmd_list_element
*c
,
714 fprintf_filtered (file
,
715 _("Debugger's willingness to use "
716 "disassemble-next-line is %s.\n"),
720 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
721 because it will be broken by filter sometime. */
724 do_gdb_disassembly (struct gdbarch
*gdbarch
,
725 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
727 volatile struct gdb_exception exception
;
729 TRY_CATCH (exception
, RETURN_MASK_ERROR
)
731 gdb_disassembly (gdbarch
, current_uiout
, 0,
732 DISASSEMBLY_RAW_INSN
, how_many
,
735 if (exception
.reason
< 0)
737 /* If an exception was thrown while doing the disassembly, print
738 the error message, to give the user a clue of what happened. */
739 exception_print (gdb_stderr
, exception
);
743 /* Print information about frame FRAME. The output is format according
744 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
747 SRC_LINE: Print only source line.
748 LOCATION: Print only location.
749 LOC_AND_SRC: Print location and source line.
751 Used in "where" output, and to emit breakpoint or step
755 print_frame_info (struct frame_info
*frame
, int print_level
,
756 enum print_what print_what
, int print_args
)
758 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
759 struct symtab_and_line sal
;
762 struct ui_out
*uiout
= current_uiout
;
764 if (get_frame_type (frame
) == DUMMY_FRAME
765 || get_frame_type (frame
) == SIGTRAMP_FRAME
766 || get_frame_type (frame
) == ARCH_FRAME
)
768 struct cleanup
*uiout_cleanup
769 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
771 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
772 gdbarch
, get_frame_pc (frame
));
774 /* Do this regardless of SOURCE because we don't have any source
775 to list for this frame. */
778 ui_out_text (uiout
, "#");
779 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
780 frame_relative_level (frame
));
782 if (ui_out_is_mi_like_p (uiout
))
784 annotate_frame_address ();
785 ui_out_field_core_addr (uiout
, "addr",
786 gdbarch
, get_frame_pc (frame
));
787 annotate_frame_address_end ();
790 if (get_frame_type (frame
) == DUMMY_FRAME
)
792 annotate_function_call ();
793 ui_out_field_string (uiout
, "func", "<function called from gdb>");
795 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
797 annotate_signal_handler_caller ();
798 ui_out_field_string (uiout
, "func", "<signal handler called>");
800 else if (get_frame_type (frame
) == ARCH_FRAME
)
802 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
804 ui_out_text (uiout
, "\n");
805 annotate_frame_end ();
807 do_cleanups (uiout_cleanup
);
811 /* If FRAME is not the innermost frame, that normally means that
812 FRAME->pc points to *after* the call instruction, and we want to
813 get the line containing the call, never the next line. But if
814 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
815 next frame was not entered as the result of a call, and we want
816 to get the line containing FRAME->pc. */
817 find_frame_sal (frame
, &sal
);
819 location_print
= (print_what
== LOCATION
820 || print_what
== LOC_AND_ADDRESS
821 || print_what
== SRC_AND_LOC
);
823 if (location_print
|| !sal
.symtab
)
824 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
826 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
828 /* If disassemble-next-line is set to auto or on and doesn't have
829 the line debug messages for $pc, output the next instruction. */
830 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
831 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
832 && source_print
&& !sal
.symtab
)
833 do_gdb_disassembly (get_frame_arch (frame
), 1,
834 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
836 if (source_print
&& sal
.symtab
)
839 int mid_statement
= ((print_what
== SRC_LINE
)
840 && frame_show_address (frame
, sal
));
842 if (annotation_level
)
843 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
844 get_frame_pc (frame
));
847 if (deprecated_print_frame_info_listing_hook
)
848 deprecated_print_frame_info_listing_hook (sal
.symtab
,
853 struct value_print_options opts
;
855 get_user_print_options (&opts
);
856 /* We used to do this earlier, but that is clearly
857 wrong. This function is used by many different
858 parts of gdb, including normal_stop in infrun.c,
859 which uses this to print out the current PC
860 when we stepi/nexti into the middle of a source
861 line. Only the command line really wants this
862 behavior. Other UIs probably would like the
863 ability to decide for themselves if it is desired. */
864 if (opts
.addressprint
&& mid_statement
)
866 ui_out_field_core_addr (uiout
, "addr",
867 gdbarch
, get_frame_pc (frame
));
868 ui_out_text (uiout
, "\t");
871 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
875 /* If disassemble-next-line is set to on and there is line debug
876 messages, output assembly codes for next line. */
877 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
878 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
881 if (print_what
!= LOCATION
)
885 if (get_frame_pc_if_available (frame
, &pc
))
886 set_last_displayed_sal (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
888 set_last_displayed_sal (0, 0, 0, 0, 0);
891 annotate_frame_end ();
893 gdb_flush (gdb_stdout
);
896 /* Remember the last symtab and line we displayed, which we use e.g.
897 * as the place to put a breakpoint when the `break' command is
898 * invoked with no arguments. */
901 set_last_displayed_sal (int valid
, struct program_space
*pspace
,
902 CORE_ADDR addr
, struct symtab
*symtab
,
905 last_displayed_sal_valid
= valid
;
906 last_displayed_pspace
= pspace
;
907 last_displayed_addr
= addr
;
908 last_displayed_symtab
= symtab
;
909 last_displayed_line
= line
;
910 if (valid
&& pspace
== NULL
)
912 clear_last_displayed_sal ();
913 internal_error (__FILE__
, __LINE__
,
914 _("Trying to set NULL pspace."));
918 /* Forget the last sal we displayed. */
921 clear_last_displayed_sal (void)
923 last_displayed_sal_valid
= 0;
924 last_displayed_pspace
= 0;
925 last_displayed_addr
= 0;
926 last_displayed_symtab
= 0;
927 last_displayed_line
= 0;
930 /* Is our record of the last sal we displayed valid? If not,
931 * the get_last_displayed_* functions will return NULL or 0, as
935 last_displayed_sal_is_valid (void)
937 return last_displayed_sal_valid
;
940 /* Get the pspace of the last sal we displayed, if it's valid. */
942 struct program_space
*
943 get_last_displayed_pspace (void)
945 if (last_displayed_sal_valid
)
946 return last_displayed_pspace
;
950 /* Get the address of the last sal we displayed, if it's valid. */
953 get_last_displayed_addr (void)
955 if (last_displayed_sal_valid
)
956 return last_displayed_addr
;
960 /* Get the symtab of the last sal we displayed, if it's valid. */
963 get_last_displayed_symtab (void)
965 if (last_displayed_sal_valid
)
966 return last_displayed_symtab
;
970 /* Get the line of the last sal we displayed, if it's valid. */
973 get_last_displayed_line (void)
975 if (last_displayed_sal_valid
)
976 return last_displayed_line
;
980 /* Get the last sal we displayed, if it's valid. */
983 get_last_displayed_sal (struct symtab_and_line
*sal
)
985 if (last_displayed_sal_valid
)
987 sal
->pspace
= last_displayed_pspace
;
988 sal
->pc
= last_displayed_addr
;
989 sal
->symtab
= last_displayed_symtab
;
990 sal
->line
= last_displayed_line
;
1002 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1003 corresponding to FRAME. FUNNAME needs to be freed by the caller. */
1006 find_frame_funname (struct frame_info
*frame
, char **funname
,
1007 enum language
*funlang
, struct symbol
**funcp
)
1009 struct symbol
*func
;
1012 *funlang
= language_unknown
;
1016 func
= get_frame_function (frame
);
1019 /* In certain pathological cases, the symtabs give the wrong
1020 function (when we are in the first function in a file which
1021 is compiled without debugging symbols, the previous function
1022 is compiled with debugging symbols, and the "foo.o" symbol
1023 that is supposed to tell us where the file with debugging
1024 symbols ends has been truncated by ar because it is longer
1025 than 15 characters). This also occurs if the user uses asm()
1026 to create a function but not stabs for it (in a file compiled
1029 So look in the minimal symbol tables as well, and if it comes
1030 up with a larger address for the function use that instead.
1031 I don't think this can ever cause any problems; there
1032 shouldn't be any minimal symbols in the middle of a function;
1033 if this is ever changed many parts of GDB will need to be
1034 changed (and we'll create a find_pc_minimal_function or some
1037 struct bound_minimal_symbol msymbol
;
1039 /* Don't attempt to do this for inlined functions, which do not
1040 have a corresponding minimal symbol. */
1041 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
1043 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
1045 memset (&msymbol
, 0, sizeof (msymbol
));
1047 if (msymbol
.minsym
!= NULL
1048 && (SYMBOL_VALUE_ADDRESS (msymbol
.minsym
)
1049 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
1051 /* We also don't know anything about the function besides
1052 its address and name. */
1054 *funname
= xstrdup (SYMBOL_PRINT_NAME (msymbol
.minsym
));
1055 *funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1059 *funname
= xstrdup (SYMBOL_PRINT_NAME (func
));
1060 *funlang
= SYMBOL_LANGUAGE (func
);
1063 if (*funlang
== language_cplus
)
1065 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1066 to display the demangled name that we already have
1067 stored in the symbol table, but we stored a version
1068 with DMGL_PARAMS turned on, and here we don't want to
1069 display parameters. So remove the parameters. */
1070 char *func_only
= cp_remove_params (*funname
);
1075 *funname
= func_only
;
1082 struct bound_minimal_symbol msymbol
;
1085 if (!get_frame_address_in_block_if_available (frame
, &pc
))
1088 msymbol
= lookup_minimal_symbol_by_pc (pc
);
1089 if (msymbol
.minsym
!= NULL
)
1091 *funname
= xstrdup (SYMBOL_PRINT_NAME (msymbol
.minsym
));
1092 *funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1098 print_frame (struct frame_info
*frame
, int print_level
,
1099 enum print_what print_what
, int print_args
,
1100 struct symtab_and_line sal
)
1102 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1103 struct ui_out
*uiout
= current_uiout
;
1104 char *funname
= NULL
;
1105 enum language funlang
= language_unknown
;
1106 struct ui_file
*stb
;
1107 struct cleanup
*old_chain
, *list_chain
;
1108 struct value_print_options opts
;
1109 struct symbol
*func
;
1113 pc_p
= get_frame_pc_if_available (frame
, &pc
);
1115 stb
= mem_fileopen ();
1116 old_chain
= make_cleanup_ui_file_delete (stb
);
1118 find_frame_funname (frame
, &funname
, &funlang
, &func
);
1119 make_cleanup (xfree
, funname
);
1121 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
1124 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
1128 ui_out_text (uiout
, "#");
1129 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
1130 frame_relative_level (frame
));
1132 get_user_print_options (&opts
);
1133 if (opts
.addressprint
)
1135 || frame_show_address (frame
, sal
)
1136 || print_what
== LOC_AND_ADDRESS
)
1138 annotate_frame_address ();
1140 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
1142 ui_out_field_string (uiout
, "addr", "<unavailable>");
1143 annotate_frame_address_end ();
1144 ui_out_text (uiout
, " in ");
1146 annotate_frame_function_name ();
1147 fprintf_symbol_filtered (stb
, funname
? funname
: "??",
1148 funlang
, DMGL_ANSI
);
1149 ui_out_field_stream (uiout
, "func", stb
);
1150 ui_out_wrap_hint (uiout
, " ");
1151 annotate_frame_args ();
1153 ui_out_text (uiout
, " (");
1156 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1158 struct cleanup
*args_list_chain
;
1159 volatile struct gdb_exception e
;
1161 if (gdbarch_frame_num_args_p (gdbarch
))
1163 numargs
= gdbarch_frame_num_args (gdbarch
, frame
);
1164 gdb_assert (numargs
>= 0);
1169 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
1170 TRY_CATCH (e
, RETURN_MASK_ERROR
)
1172 print_frame_args (func
, frame
, numargs
, gdb_stdout
);
1174 /* FIXME: ARGS must be a list. If one argument is a string it
1175 will have " that will not be properly escaped. */
1176 /* Invoke ui_out_tuple_end. */
1177 do_cleanups (args_list_chain
);
1180 ui_out_text (uiout
, ")");
1183 const char *filename_display
;
1185 filename_display
= symtab_to_filename_for_display (sal
.symtab
);
1186 annotate_frame_source_begin ();
1187 ui_out_wrap_hint (uiout
, " ");
1188 ui_out_text (uiout
, " at ");
1189 annotate_frame_source_file ();
1190 ui_out_field_string (uiout
, "file", filename_display
);
1191 if (ui_out_is_mi_like_p (uiout
))
1193 const char *fullname
= symtab_to_fullname (sal
.symtab
);
1195 ui_out_field_string (uiout
, "fullname", fullname
);
1197 annotate_frame_source_file_end ();
1198 ui_out_text (uiout
, ":");
1199 annotate_frame_source_line ();
1200 ui_out_field_int (uiout
, "line", sal
.line
);
1201 annotate_frame_source_end ();
1204 if (pc_p
&& (funname
== NULL
|| sal
.symtab
== NULL
))
1206 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
1207 get_frame_pc (frame
));
1211 annotate_frame_where ();
1212 ui_out_wrap_hint (uiout
, " ");
1213 ui_out_text (uiout
, " from ");
1214 ui_out_field_string (uiout
, "from", lib
);
1218 /* do_cleanups will call ui_out_tuple_end() for us. */
1219 do_cleanups (list_chain
);
1220 ui_out_text (uiout
, "\n");
1221 do_cleanups (old_chain
);
1225 /* Read a frame specification in whatever the appropriate format is
1226 from FRAME_EXP. Call error(), printing MESSAGE, if the
1227 specification is in any way invalid (so this function never returns
1228 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1229 the default selected frame was used. */
1231 static struct frame_info
*
1232 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
1233 int *selected_frame_p
)
1236 struct value
*args
[4];
1237 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
1239 if (frame_exp
== NULL
)
1247 struct cleanup
*cleanup
;
1250 /* Skip leading white space, bail of EOL. */
1251 frame_exp
= skip_spaces_const (frame_exp
);
1255 /* Parse the argument, extract it, save it. */
1257 *p
&& !isspace (*p
);
1259 addr_string
= savestring (frame_exp
, p
- frame_exp
);
1261 cleanup
= make_cleanup (xfree
, addr_string
);
1263 /* NOTE: Parse and evaluate expression, but do not use
1264 functions such as parse_and_eval_long or
1265 parse_and_eval_address to also extract the value.
1266 Instead value_as_long and value_as_address are used.
1267 This avoids problems with expressions that contain
1269 if (numargs
>= ARRAY_SIZE (args
))
1270 error (_("Too many args in frame specification"));
1271 args
[numargs
++] = parse_and_eval (addr_string
);
1273 do_cleanups (cleanup
);
1277 /* If no args, default to the selected frame. */
1280 if (selected_frame_p
!= NULL
)
1281 (*selected_frame_p
) = 1;
1282 return get_selected_frame (message
);
1285 /* None of the remaining use the selected frame. */
1286 if (selected_frame_p
!= NULL
)
1287 (*selected_frame_p
) = 0;
1289 /* Assume the single arg[0] is an integer, and try using that to
1290 select a frame relative to current. */
1293 struct frame_info
*fid
;
1294 int level
= value_as_long (args
[0]);
1296 fid
= find_relative_frame (get_current_frame (), &level
);
1298 /* find_relative_frame was successful. */
1302 /* Convert each value into a corresponding address. */
1306 for (i
= 0; i
< numargs
; i
++)
1307 addrs
[i
] = value_as_address (args
[i
]);
1310 /* Assume that the single arg[0] is an address, use that to identify
1311 a frame with a matching ID. Should this also accept stack/pc or
1312 stack/pc/special. */
1315 struct frame_id id
= frame_id_build_wild (addrs
[0]);
1316 struct frame_info
*fid
;
1318 /* If (s)he specifies the frame with an address, he deserves
1319 what (s)he gets. Still, give the highest one that matches.
1320 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1322 for (fid
= get_current_frame ();
1324 fid
= get_prev_frame (fid
))
1326 if (frame_id_eq (id
, get_frame_id (fid
)))
1328 struct frame_info
*prev_frame
;
1332 prev_frame
= get_prev_frame (fid
);
1334 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1343 /* We couldn't identify the frame as an existing frame, but
1344 perhaps we can create one with a single argument. */
1346 return create_new_frame (addrs
[0], 0);
1347 else if (numargs
== 2)
1348 return create_new_frame (addrs
[0], addrs
[1]);
1350 error (_("Too many args in frame specification"));
1353 static struct frame_info
*
1354 parse_frame_specification (char *frame_exp
)
1356 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1359 /* Print verbosely the selected frame or the frame at address
1360 ADDR_EXP. Absolutely all information in the frame is printed. */
1363 frame_info (char *addr_exp
, int from_tty
)
1365 struct frame_info
*fi
;
1366 struct symtab_and_line sal
;
1367 struct symbol
*func
;
1369 struct frame_info
*calling_frame_info
;
1371 const char *funname
= 0;
1372 enum language funlang
= language_unknown
;
1373 const char *pc_regname
;
1374 int selected_frame_p
;
1375 struct gdbarch
*gdbarch
;
1376 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1379 CORE_ADDR caller_pc
;
1381 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1382 gdbarch
= get_frame_arch (fi
);
1384 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1385 is not a good name. */
1386 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1387 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1388 easily not match that of the internal value returned by
1390 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1392 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1393 architectures will often have a hardware register called "pc",
1394 and that register's value, again, can easily not match
1398 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1399 find_frame_sal (fi
, &sal
);
1400 func
= get_frame_function (fi
);
1404 funname
= SYMBOL_PRINT_NAME (func
);
1405 funlang
= SYMBOL_LANGUAGE (func
);
1406 if (funlang
== language_cplus
)
1408 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1409 to display the demangled name that we already have
1410 stored in the symbol table, but we stored a version
1411 with DMGL_PARAMS turned on, and here we don't want to
1412 display parameters. So remove the parameters. */
1413 char *func_only
= cp_remove_params (funname
);
1417 funname
= func_only
;
1418 make_cleanup (xfree
, func_only
);
1422 else if (frame_pc_p
)
1424 struct bound_minimal_symbol msymbol
;
1426 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1427 if (msymbol
.minsym
!= NULL
)
1429 funname
= SYMBOL_PRINT_NAME (msymbol
.minsym
);
1430 funlang
= SYMBOL_LANGUAGE (msymbol
.minsym
);
1433 calling_frame_info
= get_prev_frame (fi
);
1435 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1437 printf_filtered (_("Stack level %d, frame at "),
1438 frame_relative_level (fi
));
1442 printf_filtered (_("Stack frame at "));
1444 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1445 printf_filtered (":\n");
1446 printf_filtered (" %s = ", pc_regname
);
1448 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1450 fputs_filtered ("<unavailable>", gdb_stdout
);
1455 printf_filtered (" in ");
1456 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1457 DMGL_ANSI
| DMGL_PARAMS
);
1461 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal
.symtab
),
1463 puts_filtered ("; ");
1465 printf_filtered ("saved %s ", pc_regname
);
1466 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1467 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1469 fputs_filtered ("<unavailable>", gdb_stdout
);
1470 printf_filtered ("\n");
1472 if (calling_frame_info
== NULL
)
1474 enum unwind_stop_reason reason
;
1476 reason
= get_frame_unwind_stop_reason (fi
);
1477 if (reason
!= UNWIND_NO_REASON
)
1478 printf_filtered (_(" Outermost frame: %s\n"),
1479 frame_stop_reason_string (reason
));
1481 else if (get_frame_type (fi
) == TAILCALL_FRAME
)
1482 puts_filtered (" tail call frame");
1483 else if (get_frame_type (fi
) == INLINE_FRAME
)
1484 printf_filtered (" inlined into frame %d",
1485 frame_relative_level (get_prev_frame (fi
)));
1488 printf_filtered (" called by frame at ");
1489 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1492 if (get_next_frame (fi
) && calling_frame_info
)
1493 puts_filtered (",");
1495 if (get_next_frame (fi
))
1497 printf_filtered (" caller of frame at ");
1498 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1501 if (get_next_frame (fi
) || calling_frame_info
)
1502 puts_filtered ("\n");
1505 printf_filtered (" source language %s.\n",
1506 language_str (s
->language
));
1509 /* Address of the argument list for this frame, or 0. */
1510 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1511 /* Number of args for this frame, or -1 if unknown. */
1515 printf_filtered (" Arglist at unknown address.\n");
1518 printf_filtered (" Arglist at ");
1519 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1520 printf_filtered (",");
1522 if (!gdbarch_frame_num_args_p (gdbarch
))
1525 puts_filtered (" args: ");
1529 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1530 gdb_assert (numargs
>= 0);
1532 puts_filtered (" no args.");
1533 else if (numargs
== 1)
1534 puts_filtered (" 1 arg: ");
1536 printf_filtered (" %d args: ", numargs
);
1538 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1539 puts_filtered ("\n");
1543 /* Address of the local variables for this frame, or 0. */
1544 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1547 printf_filtered (" Locals at unknown address,");
1550 printf_filtered (" Locals at ");
1551 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1552 printf_filtered (",");
1556 /* Print as much information as possible on the location of all the
1559 enum lval_type lval
;
1568 /* The sp is special; what's displayed isn't the save address, but
1569 the value of the previous frame's sp. This is a legacy thing,
1570 at one stage the frame cached the previous frame's SP instead
1571 of its address, hence it was easiest to just display the cached
1573 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1575 /* Find out the location of the saved stack pointer with out
1576 actually evaluating it. */
1577 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1578 &optimized
, &unavailable
, &lval
, &addr
,
1580 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1582 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1583 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1584 gdb_byte value
[MAX_REGISTER_SIZE
];
1587 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1588 &optimized
, &unavailable
, &lval
, &addr
,
1590 /* NOTE: cagney/2003-05-22: This is assuming that the
1591 stack pointer was packed as an unsigned integer. That
1592 may or may not be valid. */
1593 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1594 printf_filtered (" Previous frame's sp is ");
1595 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1596 printf_filtered ("\n");
1599 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1601 printf_filtered (" Previous frame's sp at ");
1602 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1603 printf_filtered ("\n");
1606 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1608 printf_filtered (" Previous frame's sp in %s\n",
1609 gdbarch_register_name (gdbarch
, realnum
));
1612 /* else keep quiet. */
1616 numregs
= gdbarch_num_regs (gdbarch
)
1617 + gdbarch_num_pseudo_regs (gdbarch
);
1618 for (i
= 0; i
< numregs
; i
++)
1619 if (i
!= gdbarch_sp_regnum (gdbarch
)
1620 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1622 /* Find out the location of the saved register without
1623 fetching the corresponding value. */
1624 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1625 &lval
, &addr
, &realnum
, NULL
);
1626 /* For moment, only display registers that were saved on the
1628 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1631 puts_filtered (" Saved registers:\n ");
1633 puts_filtered (",");
1635 printf_filtered (" %s at ",
1636 gdbarch_register_name (gdbarch
, i
));
1637 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1641 if (count
|| need_nl
)
1642 puts_filtered ("\n");
1645 do_cleanups (back_to
);
1648 /* Print briefly all stack frames or just the innermost COUNT_EXP
1652 backtrace_command_1 (char *count_exp
, int show_locals
, int no_filters
,
1655 struct frame_info
*fi
;
1658 struct frame_info
*trailing
;
1659 int trailing_level
, py_start
= 0, py_end
= 0;
1660 enum py_bt_status result
= PY_BT_ERROR
;
1662 if (!target_has_stack
)
1663 error (_("No stack."));
1665 /* The following code must do two things. First, it must set the
1666 variable TRAILING to the frame from which we should start
1667 printing. Second, it must set the variable count to the number
1668 of frames which we should print, or -1 if all of them. */
1669 trailing
= get_current_frame ();
1674 count
= parse_and_eval_long (count_exp
);
1677 struct frame_info
*current
;
1683 while (current
&& count
--)
1686 current
= get_prev_frame (current
);
1689 /* Will stop when CURRENT reaches the top of the stack.
1690 TRAILING will be COUNT below it. */
1694 trailing
= get_prev_frame (trailing
);
1695 current
= get_prev_frame (current
);
1715 /* Read in symbols for all of the frames. Need to do this in a
1716 separate pass so that "Reading in symbols for xxx" messages
1717 don't screw up the appearance of the backtrace. Also if
1718 people have strong opinions against reading symbols for
1719 backtrace this may have to be an option. */
1721 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1726 pc
= get_frame_address_in_block (fi
);
1727 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1733 int flags
= PRINT_LEVEL
| PRINT_FRAME_INFO
| PRINT_ARGS
;
1734 enum py_frame_args arg_type
;
1737 flags
|= PRINT_LOCALS
;
1739 if (!strcmp (print_frame_arguments
, "scalars"))
1740 arg_type
= CLI_SCALAR_VALUES
;
1741 else if (!strcmp (print_frame_arguments
, "all"))
1742 arg_type
= CLI_ALL_VALUES
;
1744 arg_type
= NO_VALUES
;
1746 result
= apply_frame_filter (get_current_frame (), flags
, arg_type
,
1747 current_uiout
, py_start
, py_end
);
1750 /* Run the inbuilt backtrace if there are no filters registered, or
1751 "no-filters" has been specified from the command. */
1752 if (no_filters
|| result
== PY_BT_NO_FILTERS
)
1754 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1758 /* Don't use print_stack_frame; if an error() occurs it probably
1759 means further attempts to backtrace would fail (on the other
1760 hand, perhaps the code does or could be fixed to make sure
1761 the frame->prev field gets set to NULL in that case). */
1763 print_frame_info (fi
, 1, LOCATION
, 1);
1766 struct frame_id frame_id
= get_frame_id (fi
);
1768 print_frame_local_vars (fi
, 1, gdb_stdout
);
1770 /* print_frame_local_vars invalidates FI. */
1771 fi
= frame_find_by_id (frame_id
);
1775 warning (_("Unable to restore previously selected frame."));
1780 /* Save the last frame to check for error conditions. */
1784 /* If we've stopped before the end, mention that. */
1786 printf_filtered (_("(More stack frames follow...)\n"));
1788 /* If we've run out of frames, and the reason appears to be an error
1789 condition, print it. */
1790 if (fi
== NULL
&& trailing
!= NULL
)
1792 enum unwind_stop_reason reason
;
1794 reason
= get_frame_unwind_stop_reason (trailing
);
1795 if (reason
>= UNWIND_FIRST_ERROR
)
1796 printf_filtered (_("Backtrace stopped: %s\n"),
1797 frame_stop_reason_string (reason
));
1803 backtrace_command (char *arg
, int from_tty
)
1805 struct cleanup
*old_chain
= make_cleanup (null_cleanup
, NULL
);
1806 int fulltrace_arg
= -1, arglen
= 0, argc
= 0, no_filters
= -1;
1814 argv
= gdb_buildargv (arg
);
1815 make_cleanup_freeargv (argv
);
1817 for (i
= 0; argv
[i
]; i
++)
1821 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1822 argv
[i
][j
] = tolower (argv
[i
][j
]);
1824 if (no_filters
< 0 && subset_compare (argv
[i
], "no-filters"))
1828 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1829 fulltrace_arg
= argc
;
1833 arglen
+= strlen (argv
[i
]);
1839 if (fulltrace_arg
>= 0 || no_filters
>= 0)
1843 arg
= xmalloc (arglen
+ 1);
1844 make_cleanup (xfree
, arg
);
1846 for (i
= 0; i
< argc
; i
++)
1848 if (i
!= fulltrace_arg
&& i
!= no_filters
)
1850 strcat (arg
, argv
[i
]);
1860 backtrace_command_1 (arg
, fulltrace_arg
>= 0 /* show_locals */,
1861 no_filters
>= 0 /* no frame-filters */, from_tty
);
1863 do_cleanups (old_chain
);
1867 backtrace_full_command (char *arg
, int from_tty
)
1869 backtrace_command_1 (arg
, 1 /* show_locals */, 0, from_tty
);
1873 /* Iterate over the local variables of a block B, calling CB with
1877 iterate_over_block_locals (struct block
*b
,
1878 iterate_over_block_arg_local_vars_cb cb
,
1881 struct block_iterator iter
;
1884 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1886 switch (SYMBOL_CLASS (sym
))
1892 if (SYMBOL_IS_ARGUMENT (sym
))
1894 if (SYMBOL_DOMAIN (sym
) == COMMON_BLOCK_DOMAIN
)
1896 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1900 /* Ignore symbols which are not locals. */
1907 /* Same, but print labels. */
1910 /* Commented out, as the code using this function has also been
1911 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1912 was commented out in the first place. The discussion introducing
1913 this change (2007-12-04: Support lexical blocks and function bodies
1914 that occupy non-contiguous address ranges) did not explain why
1915 this change was made. */
1917 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1918 int *have_default
, struct ui_file
*stream
)
1920 struct block_iterator iter
;
1922 int values_printed
= 0;
1924 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1926 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1932 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1934 struct symtab_and_line sal
;
1935 struct value_print_options opts
;
1937 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1939 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1940 get_user_print_options (&opts
);
1941 if (opts
.addressprint
)
1943 fprintf_filtered (stream
, " ");
1944 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1947 fprintf_filtered (stream
, " in file %s, line %d\n",
1948 sal
.symtab
->filename
, sal
.line
);
1952 return values_printed
;
1956 /* Iterate over all the local variables in block B, including all its
1957 superblocks, stopping when the top-level block is reached. */
1960 iterate_over_block_local_vars (struct block
*block
,
1961 iterate_over_block_arg_local_vars_cb cb
,
1966 iterate_over_block_locals (block
, cb
, cb_data
);
1967 /* After handling the function's top-level block, stop. Don't
1968 continue to its superblock, the block of per-file
1970 if (BLOCK_FUNCTION (block
))
1972 block
= BLOCK_SUPERBLOCK (block
);
1976 /* Data to be passed around in the calls to the locals and args
1979 struct print_variable_and_value_data
1981 struct frame_id frame_id
;
1983 struct ui_file
*stream
;
1987 /* The callback for the locals and args iterators. */
1990 do_print_variable_and_value (const char *print_name
,
1994 struct print_variable_and_value_data
*p
= cb_data
;
1995 struct frame_info
*frame
;
1997 frame
= frame_find_by_id (p
->frame_id
);
2000 warning (_("Unable to restore previously selected frame."));
2004 print_variable_and_value (print_name
, sym
, frame
, p
->stream
, p
->num_tabs
);
2006 /* print_variable_and_value invalidates FRAME. */
2009 p
->values_printed
= 1;
2012 /* Print all variables from the innermost up to the function block of FRAME.
2013 Print them with values to STREAM indented by NUM_TABS.
2015 This function will invalidate FRAME. */
2018 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
2019 struct ui_file
*stream
)
2021 struct print_variable_and_value_data cb_data
;
2022 struct block
*block
;
2025 if (!get_frame_pc_if_available (frame
, &pc
))
2027 fprintf_filtered (stream
,
2028 _("PC unavailable, cannot determine locals.\n"));
2032 block
= get_frame_block (frame
, 0);
2035 fprintf_filtered (stream
, "No symbol table info available.\n");
2039 cb_data
.frame_id
= get_frame_id (frame
);
2040 cb_data
.num_tabs
= 4 * num_tabs
;
2041 cb_data
.stream
= stream
;
2042 cb_data
.values_printed
= 0;
2044 iterate_over_block_local_vars (block
,
2045 do_print_variable_and_value
,
2048 /* do_print_variable_and_value invalidates FRAME. */
2051 if (!cb_data
.values_printed
)
2052 fprintf_filtered (stream
, _("No locals.\n"));
2056 locals_info (char *args
, int from_tty
)
2058 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2062 /* Iterate over all the argument variables in block B.
2064 Returns 1 if any argument was walked; 0 otherwise. */
2067 iterate_over_block_arg_vars (struct block
*b
,
2068 iterate_over_block_arg_local_vars_cb cb
,
2071 struct block_iterator iter
;
2072 struct symbol
*sym
, *sym2
;
2074 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
2076 /* Don't worry about things which aren't arguments. */
2077 if (SYMBOL_IS_ARGUMENT (sym
))
2079 /* We have to look up the symbol because arguments can have
2080 two entries (one a parameter, one a local) and the one we
2081 want is the local, which lookup_symbol will find for us.
2082 This includes gcc1 (not gcc2) on the sparc when passing a
2083 small structure and gcc2 when the argument type is float
2084 and it is passed as a double and converted to float by
2085 the prologue (in the latter case the type of the LOC_ARG
2086 symbol is double and the type of the LOC_LOCAL symbol is
2087 float). There are also LOC_ARG/LOC_REGISTER pairs which
2088 are not combined in symbol-reading. */
2090 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
2091 b
, VAR_DOMAIN
, NULL
);
2092 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
2097 /* Print all argument variables of the function of FRAME.
2098 Print them with values to STREAM.
2100 This function will invalidate FRAME. */
2103 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
2105 struct print_variable_and_value_data cb_data
;
2106 struct symbol
*func
;
2109 if (!get_frame_pc_if_available (frame
, &pc
))
2111 fprintf_filtered (stream
, _("PC unavailable, cannot determine args.\n"));
2115 func
= get_frame_function (frame
);
2118 fprintf_filtered (stream
, _("No symbol table info available.\n"));
2122 cb_data
.frame_id
= get_frame_id (frame
);
2123 cb_data
.num_tabs
= 0;
2124 cb_data
.stream
= gdb_stdout
;
2125 cb_data
.values_printed
= 0;
2127 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
2128 do_print_variable_and_value
, &cb_data
);
2130 /* do_print_variable_and_value invalidates FRAME. */
2133 if (!cb_data
.values_printed
)
2134 fprintf_filtered (stream
, _("No arguments.\n"));
2138 args_info (char *ignore
, int from_tty
)
2140 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2146 args_plus_locals_info (char *ignore
, int from_tty
)
2148 args_info (ignore
, from_tty
);
2149 locals_info (ignore
, from_tty
);
2153 /* Select frame FRAME. Also print the stack frame and show the source
2154 if this is the tui version. */
2156 select_and_print_frame (struct frame_info
*frame
)
2158 select_frame (frame
);
2160 print_stack_frame (frame
, 1, SRC_AND_LOC
);
2163 /* Return the symbol-block in which the selected frame is executing.
2164 Can return zero under various legitimate circumstances.
2166 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2167 code address within the block returned. We use this to decide
2168 which macros are in scope. */
2171 get_selected_block (CORE_ADDR
*addr_in_block
)
2173 if (!has_stack_frames ())
2176 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
2179 /* Find a frame a certain number of levels away from FRAME.
2180 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2181 Positive means go to earlier frames (up); negative, the reverse.
2182 The int that contains the number of levels is counted toward
2183 zero as the frames for those levels are found.
2184 If the top or bottom frame is reached, that frame is returned,
2185 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2186 how much farther the original request asked to go. */
2189 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
2191 /* Going up is simple: just call get_prev_frame enough times or
2192 until the initial frame is reached. */
2193 while (*level_offset_ptr
> 0)
2195 struct frame_info
*prev
= get_prev_frame (frame
);
2199 (*level_offset_ptr
)--;
2203 /* Going down is just as simple. */
2204 while (*level_offset_ptr
< 0)
2206 struct frame_info
*next
= get_next_frame (frame
);
2210 (*level_offset_ptr
)++;
2217 /* The "select_frame" command. With no argument this is a NOP.
2218 Select the frame at level LEVEL_EXP if it is a valid level.
2219 Otherwise, treat LEVEL_EXP as an address expression and select it.
2221 See parse_frame_specification for more info on proper frame
2225 select_frame_command (char *level_exp
, int from_tty
)
2227 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
2230 /* The "frame" command. With no argument, print the selected frame
2231 briefly. With an argument, behave like select_frame and then print
2232 the selected frame. */
2235 frame_command (char *level_exp
, int from_tty
)
2237 select_frame_command (level_exp
, from_tty
);
2238 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2241 /* The XDB Compatibility command to print the current frame. */
2244 current_frame_command (char *level_exp
, int from_tty
)
2246 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
2249 /* Select the frame up one or COUNT_EXP stack levels from the
2250 previously selected frame, and print it briefly. */
2253 up_silently_base (char *count_exp
)
2255 struct frame_info
*frame
;
2259 count
= parse_and_eval_long (count_exp
);
2261 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2262 if (count
!= 0 && count_exp
== NULL
)
2263 error (_("Initial frame selected; you cannot go up."));
2264 select_frame (frame
);
2268 up_silently_command (char *count_exp
, int from_tty
)
2270 up_silently_base (count_exp
);
2274 up_command (char *count_exp
, int from_tty
)
2276 up_silently_base (count_exp
);
2277 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2280 /* Select the frame down one or COUNT_EXP stack levels from the previously
2281 selected frame, and print it briefly. */
2284 down_silently_base (char *count_exp
)
2286 struct frame_info
*frame
;
2290 count
= -parse_and_eval_long (count_exp
);
2292 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
2293 if (count
!= 0 && count_exp
== NULL
)
2295 /* We only do this if COUNT_EXP is not specified. That way
2296 "down" means to really go down (and let me know if that is
2297 impossible), but "down 9999" can be used to mean go all the
2298 way down without getting an error. */
2300 error (_("Bottom (innermost) frame selected; you cannot go down."));
2303 select_frame (frame
);
2307 down_silently_command (char *count_exp
, int from_tty
)
2309 down_silently_base (count_exp
);
2313 down_command (char *count_exp
, int from_tty
)
2315 down_silently_base (count_exp
);
2316 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2321 return_command (char *retval_exp
, int from_tty
)
2323 /* Initialize it just to avoid a GCC false warning. */
2324 enum return_value_convention rv_conv
= RETURN_VALUE_STRUCT_CONVENTION
;
2325 struct frame_info
*thisframe
;
2326 struct gdbarch
*gdbarch
;
2327 struct symbol
*thisfun
;
2328 struct value
*return_value
= NULL
;
2329 struct value
*function
= NULL
;
2330 const char *query_prefix
= "";
2332 thisframe
= get_selected_frame ("No selected frame.");
2333 thisfun
= get_frame_function (thisframe
);
2334 gdbarch
= get_frame_arch (thisframe
);
2336 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2337 error (_("Can not force return from an inlined function."));
2339 /* Compute the return value. If the computation triggers an error,
2340 let it bail. If the return type can't be handled, set
2341 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2345 struct expression
*retval_expr
= parse_expression (retval_exp
);
2346 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2347 struct type
*return_type
= NULL
;
2349 /* Compute the return value. Should the computation fail, this
2350 call throws an error. */
2351 return_value
= evaluate_expression (retval_expr
);
2353 /* Cast return value to the return type of the function. Should
2354 the cast fail, this call throws an error. */
2355 if (thisfun
!= NULL
)
2356 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2357 if (return_type
== NULL
)
2359 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
2360 && retval_expr
->elts
[0].opcode
!= UNOP_CAST_TYPE
)
2361 error (_("Return value type not available for selected "
2363 "Please use an explicit cast of the value to return."));
2364 return_type
= value_type (return_value
);
2366 do_cleanups (old_chain
);
2367 CHECK_TYPEDEF (return_type
);
2368 return_value
= value_cast (return_type
, return_value
);
2370 /* Make sure the value is fully evaluated. It may live in the
2371 stack frame we're about to pop. */
2372 if (value_lazy (return_value
))
2373 value_fetch_lazy (return_value
);
2375 if (thisfun
!= NULL
)
2376 function
= read_var_value (thisfun
, thisframe
);
2378 rv_conv
= RETURN_VALUE_REGISTER_CONVENTION
;
2379 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2380 /* If the return-type is "void", don't try to find the
2381 return-value's location. However, do still evaluate the
2382 return expression so that, even when the expression result
2383 is discarded, side effects such as "return i++" still
2385 return_value
= NULL
;
2386 else if (thisfun
!= NULL
)
2388 rv_conv
= struct_return_convention (gdbarch
, function
, return_type
);
2389 if (rv_conv
== RETURN_VALUE_STRUCT_CONVENTION
2390 || rv_conv
== RETURN_VALUE_ABI_RETURNS_ADDRESS
)
2392 query_prefix
= "The location at which to store the "
2393 "function's return value is unknown.\n"
2394 "If you continue, the return value "
2395 "that you specified will be ignored.\n";
2396 return_value
= NULL
;
2401 /* Does an interactive user really want to do this? Include
2402 information, such as how well GDB can handle the return value, in
2403 the query message. */
2408 if (thisfun
== NULL
)
2409 confirmed
= query (_("%sMake selected stack frame return now? "),
2412 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2413 SYMBOL_PRINT_NAME (thisfun
));
2415 error (_("Not confirmed"));
2418 /* Discard the selected frame and all frames inner-to it. */
2419 frame_pop (get_selected_frame (NULL
));
2421 /* Store RETURN_VALUE in the just-returned register set. */
2422 if (return_value
!= NULL
)
2424 struct type
*return_type
= value_type (return_value
);
2425 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2427 gdb_assert (rv_conv
!= RETURN_VALUE_STRUCT_CONVENTION
2428 && rv_conv
!= RETURN_VALUE_ABI_RETURNS_ADDRESS
);
2429 gdbarch_return_value (gdbarch
, function
, return_type
,
2430 get_current_regcache (), NULL
/*read*/,
2431 value_contents (return_value
) /*write*/);
2434 /* If we are at the end of a call dummy now, pop the dummy frame
2436 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2437 frame_pop (get_current_frame ());
2439 /* If interactive, print the frame that is now current. */
2441 frame_command ("0", 1);
2443 select_frame_command ("0", 0);
2446 /* Sets the scope to input function name, provided that the function
2447 is within the current stack frame. */
2449 struct function_bounds
2451 CORE_ADDR low
, high
;
2455 func_command (char *arg
, int from_tty
)
2457 struct frame_info
*frame
;
2459 struct symtabs_and_lines sals
;
2462 struct function_bounds
*func_bounds
= NULL
;
2463 struct cleanup
*cleanups
;
2468 frame
= parse_frame_specification ("0");
2469 sals
= decode_line_with_current_source (arg
, DECODE_LINE_FUNFIRSTLINE
);
2470 cleanups
= make_cleanup (xfree
, sals
.sals
);
2471 func_bounds
= (struct function_bounds
*) xmalloc (
2472 sizeof (struct function_bounds
) * sals
.nelts
);
2473 make_cleanup (xfree
, func_bounds
);
2474 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2476 if (sals
.sals
[i
].pspace
!= current_program_space
)
2477 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2478 else if (sals
.sals
[i
].pc
== 0
2479 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2480 &func_bounds
[i
].low
,
2481 &func_bounds
[i
].high
) == 0)
2483 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2489 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2490 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2491 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2495 frame
= find_relative_frame (frame
, &level
);
2498 while (!found
&& level
== 0);
2500 do_cleanups (cleanups
);
2503 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2504 else if (frame
!= get_selected_frame (NULL
))
2505 select_and_print_frame (frame
);
2508 /* Gets the language of the current frame. */
2511 get_frame_language (void)
2513 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2517 volatile struct gdb_exception ex
;
2521 /* We determine the current frame language by looking up its
2522 associated symtab. To retrieve this symtab, we use the frame
2523 PC. However we cannot use the frame PC as is, because it
2524 usually points to the instruction following the "call", which
2525 is sometimes the first instruction of another function. So
2526 we rely on get_frame_address_in_block(), it provides us with
2527 a PC that is guaranteed to be inside the frame's code
2530 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2532 pc
= get_frame_address_in_block (frame
);
2536 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2537 throw_exception (ex
);
2541 s
= find_pc_symtab (pc
);
2547 return language_unknown
;
2551 /* Provide a prototype to silence -Wmissing-prototypes. */
2552 void _initialize_stack (void);
2555 _initialize_stack (void)
2557 add_com ("return", class_stack
, return_command
, _("\
2558 Make selected stack frame return to its caller.\n\
2559 Control remains in the debugger, but when you continue\n\
2560 execution will resume in the frame above the one now selected.\n\
2561 If an argument is given, it is an expression for the value to return."));
2563 add_com ("up", class_stack
, up_command
, _("\
2564 Select and print stack frame that called this one.\n\
2565 An argument says how many frames up to go."));
2566 add_com ("up-silently", class_support
, up_silently_command
, _("\
2567 Same as the `up' command, but does not print anything.\n\
2568 This is useful in command scripts."));
2570 add_com ("down", class_stack
, down_command
, _("\
2571 Select and print stack frame called by this one.\n\
2572 An argument says how many frames down to go."));
2573 add_com_alias ("do", "down", class_stack
, 1);
2574 add_com_alias ("dow", "down", class_stack
, 1);
2575 add_com ("down-silently", class_support
, down_silently_command
, _("\
2576 Same as the `down' command, but does not print anything.\n\
2577 This is useful in command scripts."));
2579 add_com ("frame", class_stack
, frame_command
, _("\
2580 Select and print a stack frame.\nWith no argument, \
2581 print the selected stack frame. (See also \"info frame\").\n\
2582 An argument specifies the frame to select.\n\
2583 It can be a stack frame number or the address of the frame.\n\
2584 With argument, nothing is printed if input is coming from\n\
2585 a command file or a user-defined command."));
2587 add_com_alias ("f", "frame", class_stack
, 1);
2591 add_com ("L", class_stack
, current_frame_command
,
2592 _("Print the current stack frame.\n"));
2593 add_com_alias ("V", "frame", class_stack
, 1);
2595 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2596 Select a stack frame without printing anything.\n\
2597 An argument specifies the frame to select.\n\
2598 It can be a stack frame number or the address of the frame.\n"));
2600 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2601 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2602 With a negative argument, print outermost -COUNT frames.\nUse of the \
2603 'full' qualifier also prints the values of the local variables.\n\
2604 Use of the 'no-filters' qualifier prohibits frame filters from executing\n\
2605 on this backtrace.\n"));
2606 add_com_alias ("bt", "backtrace", class_stack
, 0);
2609 add_com_alias ("t", "backtrace", class_stack
, 0);
2610 add_com ("T", class_stack
, backtrace_full_command
, _("\
2611 Print backtrace of all stack frames, or innermost COUNT frames\n\
2612 and the values of the local variables.\n\
2613 With a negative argument, print outermost -COUNT frames.\n\
2614 Usage: T <count>\n"));
2617 add_com_alias ("where", "backtrace", class_alias
, 0);
2618 add_info ("stack", backtrace_command
,
2619 _("Backtrace of the stack, or innermost COUNT frames."));
2620 add_info_alias ("s", "stack", 1);
2621 add_info ("frame", frame_info
,
2622 _("All about selected stack frame, or frame at ADDR."));
2623 add_info_alias ("f", "frame", 1);
2624 add_info ("locals", locals_info
,
2625 _("Local variables of current stack frame."));
2626 add_info ("args", args_info
,
2627 _("Argument variables of current stack frame."));
2629 add_com ("l", class_info
, args_plus_locals_info
,
2630 _("Argument and local variables of current stack frame."));
2633 add_com ("func", class_stack
, func_command
, _("\
2634 Select the stack frame that contains <func>.\n\
2635 Usage: func <name>\n"));
2637 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2638 print_frame_arguments_choices
, &print_frame_arguments
,
2639 _("Set printing of non-scalar frame arguments"),
2640 _("Show printing of non-scalar frame arguments"),
2641 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2643 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2644 &disassemble_next_line
, _("\
2645 Set whether to disassemble next source line or insn when execution stops."),
2647 Show whether to disassemble next source line or insn when execution stops."),
2649 If ON, GDB will display disassembly of the next source line, in addition\n\
2650 to displaying the source line itself. If the next source line cannot\n\
2651 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2652 will display disassembly of next instruction instead of showing the\n\
2654 If AUTO, display disassembly of next instruction only if the source line\n\
2655 cannot be displayed.\n\
2656 If OFF (which is the default), never display the disassembly of the next\n\
2659 show_disassemble_next_line
,
2660 &setlist
, &showlist
);
2661 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2663 add_setshow_enum_cmd ("entry-values", class_stack
,
2664 print_entry_values_choices
, &print_entry_values
,
2665 _("Set printing of function arguments at function "
2667 _("Show printing of function arguments at function "
2670 GDB can sometimes determine the values of function arguments at entry,\n\
2671 in addition to their current values. This option tells GDB whether\n\
2672 to print the current value, the value at entry (marked as val@entry),\n\
2673 or both. Note that one or both of these values may be <optimized out>."),
2674 NULL
, NULL
, &setprintlist
, &showprintlist
);