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 /* Prototypes for local functions. */
69 static void print_frame_local_vars (struct frame_info
*, int,
72 static void print_frame (struct frame_info
*frame
, int print_level
,
73 enum print_what print_what
, int print_args
,
74 struct symtab_and_line sal
);
76 /* Zero means do things normally; we are interacting directly with the
77 user. One means print the full filename and linenumber when a
78 frame is printed, and do so in a format emacs18/emacs19.22 can
79 parse. Two means print similar annotations, but in many more
80 cases and in a slightly different syntax. */
82 int annotation_level
= 0;
85 struct print_stack_frame_args
87 struct frame_info
*frame
;
89 enum print_what print_what
;
93 /* Show or print the frame arguments; stub for catch_errors. */
96 print_stack_frame_stub (void *args
)
98 struct print_stack_frame_args
*p
= args
;
99 int center
= (p
->print_what
== SRC_LINE
|| p
->print_what
== SRC_AND_LOC
);
101 print_frame_info (p
->frame
, p
->print_level
, p
->print_what
, p
->print_args
);
102 set_current_sal_from_frame (p
->frame
, center
);
106 /* Return 1 if we should display the address in addition to the location,
107 because we are in the middle of a statement. */
110 frame_show_address (struct frame_info
*frame
,
111 struct symtab_and_line sal
)
113 /* If there is a line number, but no PC, then there is no location
114 information associated with this sal. The only way that should
115 happen is for the call sites of inlined functions (SAL comes from
116 find_frame_sal). Otherwise, we would have some PC range if the
117 SAL came from a line table. */
118 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
120 if (get_next_frame (frame
) == NULL
)
121 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
123 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
127 return get_frame_pc (frame
) != sal
.pc
;
130 /* Show or print a stack frame FRAME briefly. The output is format
131 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
132 relative level, function name, argument list, and file name and
133 line number. If the frame's PC is not at the beginning of the
134 source line, the actual PC is printed at the beginning. */
137 print_stack_frame (struct frame_info
*frame
, int print_level
,
138 enum print_what print_what
)
140 struct print_stack_frame_args args
;
143 args
.print_level
= print_level
;
144 args
.print_what
= print_what
;
145 /* For mi, alway print location and address. */
146 args
.print_what
= ui_out_is_mi_like_p (uiout
) ? LOC_AND_ADDRESS
: print_what
;
149 catch_errors (print_stack_frame_stub
, &args
, "", RETURN_MASK_ERROR
);
152 struct print_args_args
155 struct frame_info
*frame
;
156 struct ui_file
*stream
;
159 static int print_args_stub (void *args
);
161 /* Print nameless arguments of frame FRAME on STREAM, where START is
162 the offset of the first nameless argument, and NUM is the number of
163 nameless arguments to print. FIRST is nonzero if this is the first
164 argument (not just the first nameless argument). */
167 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
168 int first
, struct ui_file
*stream
)
170 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
171 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
176 for (i
= 0; i
< num
; i
++)
179 argsaddr
= get_frame_args_address (frame
);
182 arg_value
= read_memory_integer (argsaddr
+ start
,
183 sizeof (int), byte_order
);
185 fprintf_filtered (stream
, ", ");
186 fprintf_filtered (stream
, "%ld", arg_value
);
188 start
+= sizeof (int);
192 /* Print the arguments of frame FRAME on STREAM, given the function
193 FUNC running in that frame (as a symbol), where NUM is the number
194 of arguments according to the stack frame (or -1 if the number of
195 arguments is unknown). */
197 /* Note that currently the "number of arguments according to the
198 stack frame" is only known on VAX where i refers to the "number of
199 ints of arguments according to the stack frame". */
202 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
203 int num
, struct ui_file
*stream
)
206 /* Offset of next stack argument beyond the one we have seen that is
207 at the highest offset, or -1 if we haven't come to a stack
209 long highest_offset
= -1;
210 /* Number of ints of arguments that we have printed so far. */
211 int args_printed
= 0;
212 struct cleanup
*old_chain
, *list_chain
;
213 struct ui_stream
*stb
;
214 /* True if we should print arguments, false otherwise. */
215 int print_args
= strcmp (print_frame_arguments
, "none");
216 /* True in "summary" mode, false otherwise. */
217 int summary
= !strcmp (print_frame_arguments
, "scalars");
219 stb
= ui_out_stream_new (uiout
);
220 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
224 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
225 struct dict_iterator iter
;
229 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
233 /* Keep track of the highest stack argument offset seen, and
234 skip over any kinds of symbols we don't care about. */
236 if (!SYMBOL_IS_ARGUMENT (sym
))
239 switch (SYMBOL_CLASS (sym
))
244 long current_offset
= SYMBOL_VALUE (sym
);
245 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
247 /* Compute address of next argument by adding the size of
248 this argument and rounding to an int boundary. */
250 ((current_offset
+ arg_size
+ sizeof (int) - 1)
251 & ~(sizeof (int) - 1));
253 /* If this is the highest offset seen yet, set
255 if (highest_offset
== -1
256 || (current_offset
> highest_offset
))
257 highest_offset
= current_offset
;
259 /* Add the number of ints we're about to print to
261 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
264 /* We care about types of symbols, but don't need to
265 keep track of stack offsets in them. */
267 case LOC_REGPARM_ADDR
:
269 case LOC_OPTIMIZED_OUT
:
274 /* We have to look up the symbol because arguments can have
275 two entries (one a parameter, one a local) and the one we
276 want is the local, which lookup_symbol will find for us.
277 This includes gcc1 (not gcc2) on SPARC when passing a
278 small structure and gcc2 when the argument type is float
279 and it is passed as a double and converted to float by
280 the prologue (in the latter case the type of the LOC_ARG
281 symbol is double and the type of the LOC_LOCAL symbol is
283 /* But if the parameter name is null, don't try it. Null
284 parameter names occur on the RS/6000, for traceback
285 tables. FIXME, should we even print them? */
287 if (*SYMBOL_LINKAGE_NAME (sym
))
291 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
292 b
, VAR_DOMAIN
, NULL
);
293 gdb_assert (nsym
!= NULL
);
294 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
295 && !SYMBOL_IS_ARGUMENT (nsym
))
297 /* There is a LOC_ARG/LOC_REGISTER pair. This means
298 that it was passed on the stack and loaded into a
299 register, or passed in a register and stored in a
300 stack slot. GDB 3.x used the LOC_ARG; GDB
301 4.0-4.11 used the LOC_REGISTER.
303 Reasons for using the LOC_ARG:
305 (1) Because find_saved_registers may be slow for
308 (2) Because registers are often re-used and stack
309 slots rarely (never?) are. Therefore using
310 the stack slot is much less likely to print
313 Reasons why we might want to use the LOC_REGISTER:
315 (1) So that the backtrace prints the same value
316 as "print foo". I see no compelling reason
317 why this needs to be the case; having the
318 backtrace print the value which was passed
319 in, and "print foo" print the value as
320 modified within the called function, makes
323 Additional note: It might be nice if "info args"
324 displayed both values.
326 One more note: There is a case with SPARC
327 structure passing where we need to use the
328 LOC_REGISTER, but this is dealt with by creating
329 a single LOC_REGPARM in symbol reading. */
331 /* Leave sym (the LOC_ARG) alone. */
338 /* Print the current arg. */
340 ui_out_text (uiout
, ", ");
341 ui_out_wrap_hint (uiout
, " ");
343 annotate_arg_begin ();
345 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
346 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
347 SYMBOL_LANGUAGE (sym
),
348 DMGL_PARAMS
| DMGL_ANSI
);
349 ui_out_field_stream (uiout
, "name", stb
);
350 annotate_arg_name_end ();
351 ui_out_text (uiout
, "=");
355 /* Avoid value_print because it will deref ref parameters.
356 We just want to print their addresses. Print ??? for
357 args whose address we do not know. We pass 2 as
358 "recurse" to val_print because our standard indentation
359 here is 4 spaces, and val_print indents 2 for each
361 val
= read_var_value (sym
, frame
);
363 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
367 const struct language_defn
*language
;
368 struct value_print_options opts
;
370 /* Use the appropriate language to display our symbol,
371 unless the user forced the language to a specific
373 if (language_mode
== language_mode_auto
)
374 language
= language_def (SYMBOL_LANGUAGE (sym
));
376 language
= current_language
;
378 get_raw_print_options (&opts
);
380 opts
.summary
= summary
;
381 common_val_print (val
, stb
->stream
, 2, &opts
, language
);
382 ui_out_field_stream (uiout
, "value", stb
);
385 ui_out_text (uiout
, "???");
388 ui_out_text (uiout
, "...");
391 /* Invoke ui_out_tuple_end. */
392 do_cleanups (list_chain
);
400 /* Don't print nameless args in situations where we don't know
401 enough about the stack to find them. */
406 if (highest_offset
== -1)
407 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
409 start
= highest_offset
;
411 print_frame_nameless_args (frame
, start
, num
- args_printed
,
415 do_cleanups (old_chain
);
418 /* Stub for catch_errors. */
421 print_args_stub (void *args
)
423 struct print_args_args
*p
= args
;
424 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
427 if (gdbarch_frame_num_args_p (gdbarch
))
429 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
430 gdb_assert (numargs
>= 0);
434 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
438 /* Set the current source and line to the location given by frame
439 FRAME, if possible. When CENTER is true, adjust so the relevant
440 line is in the center of the next 'list'. */
443 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
445 struct symtab_and_line sal
;
447 find_frame_sal (frame
, &sal
);
451 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
452 set_current_source_symtab_and_line (&sal
);
456 /* If ON, GDB will display disassembly of the next source line when
457 execution of the program being debugged stops.
458 If AUTO (which is the default), or there's no line info to determine
459 the source line of the next instruction, display disassembly of next
460 instruction instead. */
462 static enum auto_boolean disassemble_next_line
;
465 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
466 struct cmd_list_element
*c
,
469 fprintf_filtered (file
,
470 _("Debugger's willingness to use "
471 "disassemble-next-line is %s.\n"),
475 /* Show assembly codes; stub for catch_errors. */
477 struct gdb_disassembly_stub_args
479 struct gdbarch
*gdbarch
;
486 gdb_disassembly_stub (void *args
)
488 struct gdb_disassembly_stub_args
*p
= args
;
490 gdb_disassembly (p
->gdbarch
, uiout
, 0,
491 DISASSEMBLY_RAW_INSN
, p
->how_many
,
495 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
496 because it will be broken by filter sometime. */
499 do_gdb_disassembly (struct gdbarch
*gdbarch
,
500 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
502 volatile struct gdb_exception exception
;
503 struct gdb_disassembly_stub_args args
;
505 args
.gdbarch
= gdbarch
;
506 args
.how_many
= how_many
;
509 TRY_CATCH (exception
, RETURN_MASK_ALL
)
511 gdb_disassembly_stub (&args
);
513 /* If an exception was thrown while doing the disassembly, print
514 the error message, to give the user a clue of what happened. */
515 if (exception
.reason
== RETURN_ERROR
)
516 exception_print (gdb_stderr
, exception
);
519 /* Print information about frame FRAME. The output is format according
520 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
523 SRC_LINE: Print only source line.
524 LOCATION: Print only location.
525 LOC_AND_SRC: Print location and source line.
527 Used in "where" output, and to emit breakpoint or step
531 print_frame_info (struct frame_info
*frame
, int print_level
,
532 enum print_what print_what
, int print_args
)
534 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
535 struct symtab_and_line sal
;
539 if (get_frame_type (frame
) == DUMMY_FRAME
540 || get_frame_type (frame
) == SIGTRAMP_FRAME
541 || get_frame_type (frame
) == ARCH_FRAME
)
543 struct cleanup
*uiout_cleanup
544 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
546 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
547 gdbarch
, get_frame_pc (frame
));
549 /* Do this regardless of SOURCE because we don't have any source
550 to list for this frame. */
553 ui_out_text (uiout
, "#");
554 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
555 frame_relative_level (frame
));
557 if (ui_out_is_mi_like_p (uiout
))
559 annotate_frame_address ();
560 ui_out_field_core_addr (uiout
, "addr",
561 gdbarch
, get_frame_pc (frame
));
562 annotate_frame_address_end ();
565 if (get_frame_type (frame
) == DUMMY_FRAME
)
567 annotate_function_call ();
568 ui_out_field_string (uiout
, "func", "<function called from gdb>");
570 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
572 annotate_signal_handler_caller ();
573 ui_out_field_string (uiout
, "func", "<signal handler called>");
575 else if (get_frame_type (frame
) == ARCH_FRAME
)
577 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
579 ui_out_text (uiout
, "\n");
580 annotate_frame_end ();
582 do_cleanups (uiout_cleanup
);
586 /* If FRAME is not the innermost frame, that normally means that
587 FRAME->pc points to *after* the call instruction, and we want to
588 get the line containing the call, never the next line. But if
589 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
590 next frame was not entered as the result of a call, and we want
591 to get the line containing FRAME->pc. */
592 find_frame_sal (frame
, &sal
);
594 location_print
= (print_what
== LOCATION
595 || print_what
== LOC_AND_ADDRESS
596 || print_what
== SRC_AND_LOC
);
598 if (location_print
|| !sal
.symtab
)
599 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
601 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
603 /* If disassemble-next-line is set to auto or on and doesn't have
604 the line debug messages for $pc, output the next instruction. */
605 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
606 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
607 && source_print
&& !sal
.symtab
)
608 do_gdb_disassembly (get_frame_arch (frame
), 1,
609 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
611 if (source_print
&& sal
.symtab
)
614 int mid_statement
= ((print_what
== SRC_LINE
)
615 && frame_show_address (frame
, sal
));
617 if (annotation_level
)
618 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
619 get_frame_pc (frame
));
622 if (deprecated_print_frame_info_listing_hook
)
623 deprecated_print_frame_info_listing_hook (sal
.symtab
,
628 struct value_print_options opts
;
630 get_user_print_options (&opts
);
631 /* We used to do this earlier, but that is clearly
632 wrong. This function is used by many different
633 parts of gdb, including normal_stop in infrun.c,
634 which uses this to print out the current PC
635 when we stepi/nexti into the middle of a source
636 line. Only the command line really wants this
637 behavior. Other UIs probably would like the
638 ability to decide for themselves if it is desired. */
639 if (opts
.addressprint
&& mid_statement
)
641 ui_out_field_core_addr (uiout
, "addr",
642 gdbarch
, get_frame_pc (frame
));
643 ui_out_text (uiout
, "\t");
646 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
650 /* If disassemble-next-line is set to on and there is line debug
651 messages, output assembly codes for next line. */
652 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
653 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
656 if (print_what
!= LOCATION
)
660 if (get_frame_pc_if_available (frame
, &pc
))
661 set_default_breakpoint (1, sal
.pspace
, pc
, sal
.symtab
, sal
.line
);
663 set_default_breakpoint (0, 0, 0, 0, 0);
666 annotate_frame_end ();
668 gdb_flush (gdb_stdout
);
671 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
672 corresponding to FRAME. */
675 find_frame_funname (struct frame_info
*frame
, char **funname
,
676 enum language
*funlang
, struct symbol
**funcp
)
681 *funlang
= language_unknown
;
685 func
= get_frame_function (frame
);
688 /* In certain pathological cases, the symtabs give the wrong
689 function (when we are in the first function in a file which
690 is compiled without debugging symbols, the previous function
691 is compiled with debugging symbols, and the "foo.o" symbol
692 that is supposed to tell us where the file with debugging
693 symbols ends has been truncated by ar because it is longer
694 than 15 characters). This also occurs if the user uses asm()
695 to create a function but not stabs for it (in a file compiled
698 So look in the minimal symbol tables as well, and if it comes
699 up with a larger address for the function use that instead.
700 I don't think this can ever cause any problems; there
701 shouldn't be any minimal symbols in the middle of a function;
702 if this is ever changed many parts of GDB will need to be
703 changed (and we'll create a find_pc_minimal_function or some
706 struct minimal_symbol
*msymbol
= NULL
;
708 /* Don't attempt to do this for inlined functions, which do not
709 have a corresponding minimal symbol. */
710 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
712 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
715 && (SYMBOL_VALUE_ADDRESS (msymbol
)
716 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
718 /* We also don't know anything about the function besides
719 its address and name. */
721 *funname
= SYMBOL_PRINT_NAME (msymbol
);
722 *funlang
= SYMBOL_LANGUAGE (msymbol
);
726 *funname
= SYMBOL_PRINT_NAME (func
);
727 *funlang
= SYMBOL_LANGUAGE (func
);
730 if (*funlang
== language_cplus
)
732 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
733 to display the demangled name that we already have
734 stored in the symbol table, but we stored a version
735 with DMGL_PARAMS turned on, and here we don't want to
736 display parameters. So remove the parameters. */
737 char *func_only
= cp_remove_params (*funname
);
741 *funname
= func_only
;
742 make_cleanup (xfree
, func_only
);
749 struct minimal_symbol
*msymbol
;
752 if (!get_frame_address_in_block_if_available (frame
, &pc
))
755 msymbol
= lookup_minimal_symbol_by_pc (pc
);
758 *funname
= SYMBOL_PRINT_NAME (msymbol
);
759 *funlang
= SYMBOL_LANGUAGE (msymbol
);
765 print_frame (struct frame_info
*frame
, int print_level
,
766 enum print_what print_what
, int print_args
,
767 struct symtab_and_line sal
)
769 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
770 char *funname
= NULL
;
771 enum language funlang
= language_unknown
;
772 struct ui_stream
*stb
;
773 struct cleanup
*old_chain
, *list_chain
;
774 struct value_print_options opts
;
779 pc_p
= get_frame_pc_if_available (frame
, &pc
);
781 stb
= ui_out_stream_new (uiout
);
782 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
784 find_frame_funname (frame
, &funname
, &funlang
, &func
);
786 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
789 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
793 ui_out_text (uiout
, "#");
794 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
795 frame_relative_level (frame
));
797 get_user_print_options (&opts
);
798 if (opts
.addressprint
)
800 || frame_show_address (frame
, sal
)
801 || print_what
== LOC_AND_ADDRESS
)
803 annotate_frame_address ();
805 ui_out_field_core_addr (uiout
, "addr", gdbarch
, pc
);
807 ui_out_field_string (uiout
, "addr", "<unavailable>");
808 annotate_frame_address_end ();
809 ui_out_text (uiout
, " in ");
811 annotate_frame_function_name ();
812 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
814 ui_out_field_stream (uiout
, "func", stb
);
815 ui_out_wrap_hint (uiout
, " ");
816 annotate_frame_args ();
818 ui_out_text (uiout
, " (");
821 struct print_args_args args
;
822 struct cleanup
*args_list_chain
;
826 args
.stream
= gdb_stdout
;
827 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
828 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
829 /* FIXME: ARGS must be a list. If one argument is a string it
830 will have " that will not be properly escaped. */
831 /* Invoke ui_out_tuple_end. */
832 do_cleanups (args_list_chain
);
835 ui_out_text (uiout
, ")");
836 if (sal
.symtab
&& sal
.symtab
->filename
)
838 annotate_frame_source_begin ();
839 ui_out_wrap_hint (uiout
, " ");
840 ui_out_text (uiout
, " at ");
841 annotate_frame_source_file ();
842 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
843 if (ui_out_is_mi_like_p (uiout
))
845 const char *fullname
= symtab_to_fullname (sal
.symtab
);
847 if (fullname
!= NULL
)
848 ui_out_field_string (uiout
, "fullname", fullname
);
850 annotate_frame_source_file_end ();
851 ui_out_text (uiout
, ":");
852 annotate_frame_source_line ();
853 ui_out_field_int (uiout
, "line", sal
.line
);
854 annotate_frame_source_end ();
857 if (pc_p
&& (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
)))
860 char *lib
= PC_SOLIB (get_frame_pc (frame
));
862 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
863 get_frame_pc (frame
));
867 annotate_frame_where ();
868 ui_out_wrap_hint (uiout
, " ");
869 ui_out_text (uiout
, " from ");
870 ui_out_field_string (uiout
, "from", lib
);
874 /* do_cleanups will call ui_out_tuple_end() for us. */
875 do_cleanups (list_chain
);
876 ui_out_text (uiout
, "\n");
877 do_cleanups (old_chain
);
881 /* Read a frame specification in whatever the appropriate format is
882 from FRAME_EXP. Call error(), printing MESSAGE, if the
883 specification is in any way invalid (so this function never returns
884 NULL). When SEPECTED_P is non-NULL set its target to indicate that
885 the default selected frame was used. */
887 static struct frame_info
*
888 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
889 int *selected_frame_p
)
892 struct value
*args
[4];
893 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
895 if (frame_exp
== NULL
)
903 struct cleanup
*cleanup
;
906 /* Skip leading white space, bail of EOL. */
907 while (isspace (*frame_exp
))
912 /* Parse the argument, extract it, save it. */
916 addr_string
= savestring (frame_exp
, p
- frame_exp
);
918 cleanup
= make_cleanup (xfree
, addr_string
);
920 /* NOTE: Parse and evaluate expression, but do not use
921 functions such as parse_and_eval_long or
922 parse_and_eval_address to also extract the value.
923 Instead value_as_long and value_as_address are used.
924 This avoids problems with expressions that contain
926 if (numargs
>= ARRAY_SIZE (args
))
927 error (_("Too many args in frame specification"));
928 args
[numargs
++] = parse_and_eval (addr_string
);
930 do_cleanups (cleanup
);
934 /* If no args, default to the selected frame. */
937 if (selected_frame_p
!= NULL
)
938 (*selected_frame_p
) = 1;
939 return get_selected_frame (message
);
942 /* None of the remaining use the selected frame. */
943 if (selected_frame_p
!= NULL
)
944 (*selected_frame_p
) = 0;
946 /* Assume the single arg[0] is an integer, and try using that to
947 select a frame relative to current. */
950 struct frame_info
*fid
;
951 int level
= value_as_long (args
[0]);
953 fid
= find_relative_frame (get_current_frame (), &level
);
955 /* find_relative_frame was successful. */
959 /* Convert each value into a corresponding address. */
963 for (i
= 0; i
< numargs
; i
++)
964 addrs
[i
] = value_as_address (args
[i
]);
967 /* Assume that the single arg[0] is an address, use that to identify
968 a frame with a matching ID. Should this also accept stack/pc or
972 struct frame_id id
= frame_id_build_wild (addrs
[0]);
973 struct frame_info
*fid
;
975 /* If (s)he specifies the frame with an address, he deserves
976 what (s)he gets. Still, give the highest one that matches.
977 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
979 for (fid
= get_current_frame ();
981 fid
= get_prev_frame (fid
))
983 if (frame_id_eq (id
, get_frame_id (fid
)))
985 struct frame_info
*prev_frame
;
989 prev_frame
= get_prev_frame (fid
);
991 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
1000 /* We couldn't identify the frame as an existing frame, but
1001 perhaps we can create one with a single argument. */
1003 return create_new_frame (addrs
[0], 0);
1004 else if (numargs
== 2)
1005 return create_new_frame (addrs
[0], addrs
[1]);
1007 error (_("Too many args in frame specification"));
1010 static struct frame_info
*
1011 parse_frame_specification (char *frame_exp
)
1013 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
1016 /* Print verbosely the selected frame or the frame at address
1017 ADDR_EXP. Absolutely all information in the frame is printed. */
1020 frame_info (char *addr_exp
, int from_tty
)
1022 struct frame_info
*fi
;
1023 struct symtab_and_line sal
;
1024 struct symbol
*func
;
1026 struct frame_info
*calling_frame_info
;
1029 enum language funlang
= language_unknown
;
1030 const char *pc_regname
;
1031 int selected_frame_p
;
1032 struct gdbarch
*gdbarch
;
1033 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1036 CORE_ADDR caller_pc
;
1038 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1039 gdbarch
= get_frame_arch (fi
);
1041 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1042 is not a good name. */
1043 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1044 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1045 easily not match that of the internal value returned by
1047 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1049 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1050 architectures will often have a hardware register called "pc",
1051 and that register's value, again, can easily not match
1055 frame_pc_p
= get_frame_pc_if_available (fi
, &frame_pc
);
1056 find_frame_sal (fi
, &sal
);
1057 func
= get_frame_function (fi
);
1061 funname
= SYMBOL_PRINT_NAME (func
);
1062 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
);
1074 funname
= func_only
;
1075 make_cleanup (xfree
, func_only
);
1079 else if (frame_pc_p
)
1081 struct minimal_symbol
*msymbol
;
1083 msymbol
= lookup_minimal_symbol_by_pc (frame_pc
);
1084 if (msymbol
!= NULL
)
1086 funname
= SYMBOL_PRINT_NAME (msymbol
);
1087 funlang
= SYMBOL_LANGUAGE (msymbol
);
1090 calling_frame_info
= get_prev_frame (fi
);
1092 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1094 printf_filtered (_("Stack level %d, frame at "),
1095 frame_relative_level (fi
));
1099 printf_filtered (_("Stack frame at "));
1101 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1102 printf_filtered (":\n");
1103 printf_filtered (" %s = ", pc_regname
);
1105 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1107 fputs_filtered ("<unavailable>", gdb_stdout
);
1112 printf_filtered (" in ");
1113 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1114 DMGL_ANSI
| DMGL_PARAMS
);
1118 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1119 puts_filtered ("; ");
1121 printf_filtered ("saved %s ", pc_regname
);
1122 if (frame_unwind_caller_pc_if_available (fi
, &caller_pc
))
1123 fputs_filtered (paddress (gdbarch
, caller_pc
), gdb_stdout
);
1125 fputs_filtered ("<unavailable>", gdb_stdout
);
1126 printf_filtered ("\n");
1128 if (calling_frame_info
== NULL
)
1130 enum unwind_stop_reason reason
;
1132 reason
= get_frame_unwind_stop_reason (fi
);
1133 if (reason
!= UNWIND_NO_REASON
)
1134 printf_filtered (_(" Outermost frame: %s\n"),
1135 frame_stop_reason_string (reason
));
1137 else if (get_frame_type (fi
) == INLINE_FRAME
)
1138 printf_filtered (" inlined into frame %d",
1139 frame_relative_level (get_prev_frame (fi
)));
1142 printf_filtered (" called by frame at ");
1143 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1146 if (get_next_frame (fi
) && calling_frame_info
)
1147 puts_filtered (",");
1149 if (get_next_frame (fi
))
1151 printf_filtered (" caller of frame at ");
1152 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1155 if (get_next_frame (fi
) || calling_frame_info
)
1156 puts_filtered ("\n");
1159 printf_filtered (" source language %s.\n",
1160 language_str (s
->language
));
1163 /* Address of the argument list for this frame, or 0. */
1164 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1165 /* Number of args for this frame, or -1 if unknown. */
1169 printf_filtered (" Arglist at unknown address.\n");
1172 printf_filtered (" Arglist at ");
1173 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1174 printf_filtered (",");
1176 if (!gdbarch_frame_num_args_p (gdbarch
))
1179 puts_filtered (" args: ");
1183 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1184 gdb_assert (numargs
>= 0);
1186 puts_filtered (" no args.");
1187 else if (numargs
== 1)
1188 puts_filtered (" 1 arg: ");
1190 printf_filtered (" %d args: ", numargs
);
1192 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1193 puts_filtered ("\n");
1197 /* Address of the local variables for this frame, or 0. */
1198 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1201 printf_filtered (" Locals at unknown address,");
1204 printf_filtered (" Locals at ");
1205 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1206 printf_filtered (",");
1210 /* Print as much information as possible on the location of all the
1213 enum lval_type lval
;
1222 /* The sp is special; what's displayed isn't the save address, but
1223 the value of the previous frame's sp. This is a legacy thing,
1224 at one stage the frame cached the previous frame's SP instead
1225 of its address, hence it was easiest to just display the cached
1227 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1229 /* Find out the location of the saved stack pointer with out
1230 actually evaluating it. */
1231 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1232 &optimized
, &unavailable
, &lval
, &addr
,
1234 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1236 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1237 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1238 gdb_byte value
[MAX_REGISTER_SIZE
];
1241 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1242 &optimized
, &unavailable
, &lval
, &addr
,
1244 /* NOTE: cagney/2003-05-22: This is assuming that the
1245 stack pointer was packed as an unsigned integer. That
1246 may or may not be valid. */
1247 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1248 printf_filtered (" Previous frame's sp is ");
1249 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1250 printf_filtered ("\n");
1253 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1255 printf_filtered (" Previous frame's sp at ");
1256 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1257 printf_filtered ("\n");
1260 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1262 printf_filtered (" Previous frame's sp in %s\n",
1263 gdbarch_register_name (gdbarch
, realnum
));
1266 /* else keep quiet. */
1270 numregs
= gdbarch_num_regs (gdbarch
)
1271 + gdbarch_num_pseudo_regs (gdbarch
);
1272 for (i
= 0; i
< numregs
; i
++)
1273 if (i
!= gdbarch_sp_regnum (gdbarch
)
1274 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1276 /* Find out the location of the saved register without
1277 fetching the corresponding value. */
1278 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1279 &lval
, &addr
, &realnum
, NULL
);
1280 /* For moment, only display registers that were saved on the
1282 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1285 puts_filtered (" Saved registers:\n ");
1287 puts_filtered (",");
1289 printf_filtered (" %s at ",
1290 gdbarch_register_name (gdbarch
, i
));
1291 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1295 if (count
|| need_nl
)
1296 puts_filtered ("\n");
1299 do_cleanups (back_to
);
1302 /* Print briefly all stack frames or just the innermost COUNT_EXP
1306 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1308 struct frame_info
*fi
;
1311 struct frame_info
*trailing
;
1314 if (!target_has_stack
)
1315 error (_("No stack."));
1317 /* The following code must do two things. First, it must set the
1318 variable TRAILING to the frame from which we should start
1319 printing. Second, it must set the variable count to the number
1320 of frames which we should print, or -1 if all of them. */
1321 trailing
= get_current_frame ();
1326 count
= parse_and_eval_long (count_exp
);
1329 struct frame_info
*current
;
1334 while (current
&& count
--)
1337 current
= get_prev_frame (current
);
1340 /* Will stop when CURRENT reaches the top of the stack.
1341 TRAILING will be COUNT below it. */
1345 trailing
= get_prev_frame (trailing
);
1346 current
= get_prev_frame (current
);
1358 /* Read in symbols for all of the frames. Need to do this in a
1359 separate pass so that "Reading in symbols for xxx" messages
1360 don't screw up the appearance of the backtrace. Also if
1361 people have strong opinions against reading symbols for
1362 backtrace this may have to be an option. */
1364 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1369 pc
= get_frame_address_in_block (fi
);
1370 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1374 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1378 /* Don't use print_stack_frame; if an error() occurs it probably
1379 means further attempts to backtrace would fail (on the other
1380 hand, perhaps the code does or could be fixed to make sure
1381 the frame->prev field gets set to NULL in that case). */
1382 print_frame_info (fi
, 1, LOCATION
, 1);
1384 print_frame_local_vars (fi
, 1, gdb_stdout
);
1386 /* Save the last frame to check for error conditions. */
1390 /* If we've stopped before the end, mention that. */
1392 printf_filtered (_("(More stack frames follow...)\n"));
1394 /* If we've run out of frames, and the reason appears to be an error
1395 condition, print it. */
1396 if (fi
== NULL
&& trailing
!= NULL
)
1398 enum unwind_stop_reason reason
;
1400 reason
= get_frame_unwind_stop_reason (trailing
);
1401 if (reason
> UNWIND_FIRST_ERROR
)
1402 printf_filtered (_("Backtrace stopped: %s\n"),
1403 frame_stop_reason_string (reason
));
1407 struct backtrace_command_args
1414 /* Stub for catch_errors. */
1417 backtrace_command_stub (void *data
)
1419 struct backtrace_command_args
*args
= data
;
1421 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1426 backtrace_command (char *arg
, int from_tty
)
1428 struct cleanup
*old_chain
= NULL
;
1429 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1430 struct backtrace_command_args btargs
;
1437 argv
= gdb_buildargv (arg
);
1438 old_chain
= make_cleanup_freeargv (argv
);
1440 for (i
= 0; argv
[i
]; i
++)
1444 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1445 argv
[i
][j
] = tolower (argv
[i
][j
]);
1447 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1448 fulltrace_arg
= argc
;
1451 arglen
+= strlen (argv
[i
]);
1456 if (fulltrace_arg
>= 0)
1460 arg
= xmalloc (arglen
+ 1);
1461 memset (arg
, 0, arglen
+ 1);
1462 for (i
= 0; i
< (argc
+ 1); i
++)
1464 if (i
!= fulltrace_arg
)
1466 strcat (arg
, argv
[i
]);
1476 btargs
.count_exp
= arg
;
1477 btargs
.show_locals
= (fulltrace_arg
>= 0);
1478 btargs
.from_tty
= from_tty
;
1479 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1481 if (fulltrace_arg
>= 0 && arglen
> 0)
1485 do_cleanups (old_chain
);
1489 backtrace_full_command (char *arg
, int from_tty
)
1491 struct backtrace_command_args btargs
;
1493 btargs
.count_exp
= arg
;
1494 btargs
.show_locals
= 1;
1495 btargs
.from_tty
= from_tty
;
1496 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1500 /* Iterate over the local variables of a block B, calling CB with
1504 iterate_over_block_locals (struct block
*b
,
1505 iterate_over_block_arg_local_vars_cb cb
,
1508 struct dict_iterator iter
;
1511 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1513 switch (SYMBOL_CLASS (sym
))
1519 if (SYMBOL_IS_ARGUMENT (sym
))
1521 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1525 /* Ignore symbols which are not locals. */
1532 /* Same, but print labels. */
1535 /* Commented out, as the code using this function has also been
1536 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1537 was commented out in the first place. The discussion introducing
1538 this change (2007-12-04: Support lexical blocks and function bodies
1539 that occupy non-contiguous address ranges) did not explain why
1540 this change was made. */
1542 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1543 int *have_default
, struct ui_file
*stream
)
1545 struct dict_iterator iter
;
1547 int values_printed
= 0;
1549 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1551 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1557 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1559 struct symtab_and_line sal
;
1560 struct value_print_options opts
;
1562 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1564 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1565 get_user_print_options (&opts
);
1566 if (opts
.addressprint
)
1568 fprintf_filtered (stream
, " ");
1569 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1572 fprintf_filtered (stream
, " in file %s, line %d\n",
1573 sal
.symtab
->filename
, sal
.line
);
1577 return values_printed
;
1581 /* Iterate over all the local variables in block B, including all its
1582 superblocks, stopping when the top-level block is reached. */
1585 iterate_over_block_local_vars (struct block
*block
,
1586 iterate_over_block_arg_local_vars_cb cb
,
1591 iterate_over_block_locals (block
, cb
, cb_data
);
1592 /* After handling the function's top-level block, stop. Don't
1593 continue to its superblock, the block of per-file
1595 if (BLOCK_FUNCTION (block
))
1597 block
= BLOCK_SUPERBLOCK (block
);
1601 /* Data to be passed around in the calls to the locals and args
1604 struct print_variable_and_value_data
1606 struct frame_info
*frame
;
1608 struct ui_file
*stream
;
1612 /* The callback for the locals and args iterators. */
1615 do_print_variable_and_value (const char *print_name
,
1619 struct print_variable_and_value_data
*p
= cb_data
;
1621 print_variable_and_value (print_name
, sym
,
1622 p
->frame
, p
->stream
, p
->num_tabs
);
1623 p
->values_printed
= 1;
1627 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1628 struct ui_file
*stream
)
1630 struct print_variable_and_value_data cb_data
;
1631 struct block
*block
;
1633 block
= get_frame_block (frame
, 0);
1636 fprintf_filtered (stream
, "No symbol table info available.\n");
1640 cb_data
.frame
= frame
;
1641 cb_data
.num_tabs
= 4 * num_tabs
;
1642 cb_data
.stream
= stream
;
1643 cb_data
.values_printed
= 0;
1645 iterate_over_block_local_vars (block
,
1646 do_print_variable_and_value
,
1649 if (!cb_data
.values_printed
)
1650 fprintf_filtered (stream
, _("No locals.\n"));
1653 /* Same, but print labels. */
1656 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1657 struct ui_file
*stream
)
1660 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1662 struct blockvector
*bl
;
1663 struct block
*block
= get_frame_block (frame
, 0);
1664 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1665 int values_printed
= 0;
1666 int index
, have_default
= 0;
1667 char *blocks_printed
;
1668 CORE_ADDR pc
= get_frame_pc (frame
);
1672 fprintf_filtered (stream
, "No symbol table info available.\n");
1676 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1677 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1678 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1682 CORE_ADDR end
= BLOCK_END (block
) - 4;
1685 if (bl
!= blockvector_for_pc (end
, &index
))
1686 error (_("blockvector blotch"));
1687 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1688 error (_("blockvector botch"));
1689 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1692 /* Don't print out blocks that have gone by. */
1693 while (index
< last_index
1694 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1697 while (index
< last_index
1698 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1700 if (blocks_printed
[index
] == 0)
1702 if (print_block_frame_labels (gdbarch
,
1703 BLOCKVECTOR_BLOCK (bl
, index
),
1704 &have_default
, stream
))
1706 blocks_printed
[index
] = 1;
1712 if (values_printed
&& this_level_only
)
1715 /* After handling the function's top-level block, stop. Don't
1716 continue to its superblock, the block of per-file symbols.
1717 Also do not continue to the containing function of an inlined
1719 if (BLOCK_FUNCTION (block
))
1721 block
= BLOCK_SUPERBLOCK (block
);
1724 if (!values_printed
&& !this_level_only
)
1725 fprintf_filtered (stream
, _("No catches.\n"));
1730 locals_info (char *args
, int from_tty
)
1732 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1737 catch_info (char *ignore
, int from_tty
)
1739 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1740 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1744 /* Iterate over all the argument variables in block B.
1746 Returns 1 if any argument was walked; 0 otherwise. */
1749 iterate_over_block_arg_vars (struct block
*b
,
1750 iterate_over_block_arg_local_vars_cb cb
,
1753 struct dict_iterator iter
;
1754 struct symbol
*sym
, *sym2
;
1756 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1758 /* Don't worry about things which aren't arguments. */
1759 if (SYMBOL_IS_ARGUMENT (sym
))
1761 /* We have to look up the symbol because arguments can have
1762 two entries (one a parameter, one a local) and the one we
1763 want is the local, which lookup_symbol will find for us.
1764 This includes gcc1 (not gcc2) on the sparc when passing a
1765 small structure and gcc2 when the argument type is float
1766 and it is passed as a double and converted to float by
1767 the prologue (in the latter case the type of the LOC_ARG
1768 symbol is double and the type of the LOC_LOCAL symbol is
1769 float). There are also LOC_ARG/LOC_REGISTER pairs which
1770 are not combined in symbol-reading. */
1772 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1773 b
, VAR_DOMAIN
, NULL
);
1774 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
1780 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1782 struct print_variable_and_value_data cb_data
;
1783 struct symbol
*func
;
1785 func
= get_frame_function (frame
);
1788 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1792 cb_data
.frame
= frame
;
1793 cb_data
.num_tabs
= 0;
1794 cb_data
.stream
= gdb_stdout
;
1795 cb_data
.values_printed
= 0;
1797 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
1798 do_print_variable_and_value
, &cb_data
);
1800 if (!cb_data
.values_printed
)
1801 fprintf_filtered (stream
, _("No arguments.\n"));
1805 args_info (char *ignore
, int from_tty
)
1807 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1813 args_plus_locals_info (char *ignore
, int from_tty
)
1815 args_info (ignore
, from_tty
);
1816 locals_info (ignore
, from_tty
);
1820 /* Select frame FRAME. Also print the stack frame and show the source
1821 if this is the tui version. */
1823 select_and_print_frame (struct frame_info
*frame
)
1825 select_frame (frame
);
1827 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1830 /* Return the symbol-block in which the selected frame is executing.
1831 Can return zero under various legitimate circumstances.
1833 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1834 code address within the block returned. We use this to decide
1835 which macros are in scope. */
1838 get_selected_block (CORE_ADDR
*addr_in_block
)
1840 if (!has_stack_frames ())
1843 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1846 /* Find a frame a certain number of levels away from FRAME.
1847 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1848 Positive means go to earlier frames (up); negative, the reverse.
1849 The int that contains the number of levels is counted toward
1850 zero as the frames for those levels are found.
1851 If the top or bottom frame is reached, that frame is returned,
1852 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1853 how much farther the original request asked to go. */
1856 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1858 /* Going up is simple: just call get_prev_frame enough times or
1859 until the initial frame is reached. */
1860 while (*level_offset_ptr
> 0)
1862 struct frame_info
*prev
= get_prev_frame (frame
);
1866 (*level_offset_ptr
)--;
1870 /* Going down is just as simple. */
1871 while (*level_offset_ptr
< 0)
1873 struct frame_info
*next
= get_next_frame (frame
);
1877 (*level_offset_ptr
)++;
1884 /* The "select_frame" command. With no argument this is a NOP.
1885 Select the frame at level LEVEL_EXP if it is a valid level.
1886 Otherwise, treat LEVEL_EXP as an address expression and select it.
1888 See parse_frame_specification for more info on proper frame
1892 select_frame_command (char *level_exp
, int from_tty
)
1894 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1897 /* The "frame" command. With no argument, print the selected frame
1898 briefly. With an argument, behave like select_frame and then print
1899 the selected frame. */
1902 frame_command (char *level_exp
, int from_tty
)
1904 select_frame_command (level_exp
, from_tty
);
1905 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1908 /* The XDB Compatibility command to print the current frame. */
1911 current_frame_command (char *level_exp
, int from_tty
)
1913 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1916 /* Select the frame up one or COUNT_EXP stack levels from the
1917 previously selected frame, and print it briefly. */
1920 up_silently_base (char *count_exp
)
1922 struct frame_info
*frame
;
1926 count
= parse_and_eval_long (count_exp
);
1928 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1929 if (count
!= 0 && count_exp
== NULL
)
1930 error (_("Initial frame selected; you cannot go up."));
1931 select_frame (frame
);
1935 up_silently_command (char *count_exp
, int from_tty
)
1937 up_silently_base (count_exp
);
1941 up_command (char *count_exp
, int from_tty
)
1943 up_silently_base (count_exp
);
1944 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1947 /* Select the frame down one or COUNT_EXP stack levels from the previously
1948 selected frame, and print it briefly. */
1951 down_silently_base (char *count_exp
)
1953 struct frame_info
*frame
;
1957 count
= -parse_and_eval_long (count_exp
);
1959 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1960 if (count
!= 0 && count_exp
== NULL
)
1962 /* We only do this if COUNT_EXP is not specified. That way
1963 "down" means to really go down (and let me know if that is
1964 impossible), but "down 9999" can be used to mean go all the
1965 way down without getting an error. */
1967 error (_("Bottom (innermost) frame selected; you cannot go down."));
1970 select_frame (frame
);
1974 down_silently_command (char *count_exp
, int from_tty
)
1976 down_silently_base (count_exp
);
1980 down_command (char *count_exp
, int from_tty
)
1982 down_silently_base (count_exp
);
1983 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1988 return_command (char *retval_exp
, int from_tty
)
1990 struct frame_info
*thisframe
;
1991 struct gdbarch
*gdbarch
;
1992 struct symbol
*thisfun
;
1993 struct value
*return_value
= NULL
;
1994 const char *query_prefix
= "";
1996 thisframe
= get_selected_frame ("No selected frame.");
1997 thisfun
= get_frame_function (thisframe
);
1998 gdbarch
= get_frame_arch (thisframe
);
2000 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
2001 error (_("Can not force return from an inlined function."));
2003 /* Compute the return value. If the computation triggers an error,
2004 let it bail. If the return type can't be handled, set
2005 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2009 struct expression
*retval_expr
= parse_expression (retval_exp
);
2010 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
2011 struct type
*return_type
= NULL
;
2013 /* Compute the return value. Should the computation fail, this
2014 call throws an error. */
2015 return_value
= evaluate_expression (retval_expr
);
2017 /* Cast return value to the return type of the function. Should
2018 the cast fail, this call throws an error. */
2019 if (thisfun
!= NULL
)
2020 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
2021 if (return_type
== NULL
)
2023 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
2024 error (_("Return value type not available for selected "
2026 "Please use an explicit cast of the value to return."));
2027 return_type
= value_type (return_value
);
2029 do_cleanups (old_chain
);
2030 CHECK_TYPEDEF (return_type
);
2031 return_value
= value_cast (return_type
, return_value
);
2033 /* Make sure the value is fully evaluated. It may live in the
2034 stack frame we're about to pop. */
2035 if (value_lazy (return_value
))
2036 value_fetch_lazy (return_value
);
2038 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2039 /* If the return-type is "void", don't try to find the
2040 return-value's location. However, do still evaluate the
2041 return expression so that, even when the expression result
2042 is discarded, side effects such as "return i++" still
2044 return_value
= NULL
;
2045 else if (thisfun
!= NULL
2046 && using_struct_return (gdbarch
,
2047 SYMBOL_TYPE (thisfun
), return_type
))
2049 query_prefix
= "The location at which to store the "
2050 "function's return value is unknown.\n"
2051 "If you continue, the return value "
2052 "that you specified will be ignored.\n";
2053 return_value
= NULL
;
2057 /* Does an interactive user really want to do this? Include
2058 information, such as how well GDB can handle the return value, in
2059 the query message. */
2064 if (thisfun
== NULL
)
2065 confirmed
= query (_("%sMake selected stack frame return now? "),
2068 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2069 SYMBOL_PRINT_NAME (thisfun
));
2071 error (_("Not confirmed"));
2074 /* Discard the selected frame and all frames inner-to it. */
2075 frame_pop (get_selected_frame (NULL
));
2077 /* Store RETURN_VALUE in the just-returned register set. */
2078 if (return_value
!= NULL
)
2080 struct type
*return_type
= value_type (return_value
);
2081 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2082 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2084 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2086 == RETURN_VALUE_REGISTER_CONVENTION
);
2087 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2088 get_current_regcache (), NULL
/*read*/,
2089 value_contents (return_value
) /*write*/);
2092 /* If we are at the end of a call dummy now, pop the dummy frame
2094 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2095 frame_pop (get_current_frame ());
2097 /* If interactive, print the frame that is now current. */
2099 frame_command ("0", 1);
2101 select_frame_command ("0", 0);
2104 /* Sets the scope to input function name, provided that the function
2105 is within the current stack frame. */
2107 struct function_bounds
2109 CORE_ADDR low
, high
;
2113 func_command (char *arg
, int from_tty
)
2115 struct frame_info
*frame
;
2117 struct symtabs_and_lines sals
;
2120 struct function_bounds
*func_bounds
= NULL
;
2125 frame
= parse_frame_specification ("0");
2126 sals
= decode_line_spec (arg
, 1);
2127 func_bounds
= (struct function_bounds
*) xmalloc (
2128 sizeof (struct function_bounds
) * sals
.nelts
);
2129 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2131 if (sals
.sals
[i
].pc
== 0
2132 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2133 &func_bounds
[i
].low
,
2134 &func_bounds
[i
].high
) == 0)
2136 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2142 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2143 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2144 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2148 frame
= find_relative_frame (frame
, &level
);
2151 while (!found
&& level
== 0);
2154 xfree (func_bounds
);
2157 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2158 else if (frame
!= get_selected_frame (NULL
))
2159 select_and_print_frame (frame
);
2162 /* Gets the language of the current frame. */
2165 get_frame_language (void)
2167 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2171 volatile struct gdb_exception ex
;
2175 /* We determine the current frame language by looking up its
2176 associated symtab. To retrieve this symtab, we use the frame
2177 PC. However we cannot use the frame PC as is, because it
2178 usually points to the instruction following the "call", which
2179 is sometimes the first instruction of another function. So
2180 we rely on get_frame_address_in_block(), it provides us with
2181 a PC that is guaranteed to be inside the frame's code
2184 TRY_CATCH (ex
, RETURN_MASK_ERROR
)
2186 pc
= get_frame_address_in_block (frame
);
2190 if (ex
.error
!= NOT_AVAILABLE_ERROR
)
2191 throw_exception (ex
);
2195 s
= find_pc_symtab (pc
);
2201 return language_unknown
;
2205 /* Provide a prototype to silence -Wmissing-prototypes. */
2206 void _initialize_stack (void);
2209 _initialize_stack (void)
2211 add_com ("return", class_stack
, return_command
, _("\
2212 Make selected stack frame return to its caller.\n\
2213 Control remains in the debugger, but when you continue\n\
2214 execution will resume in the frame above the one now selected.\n\
2215 If an argument is given, it is an expression for the value to return."));
2217 add_com ("up", class_stack
, up_command
, _("\
2218 Select and print stack frame that called this one.\n\
2219 An argument says how many frames up to go."));
2220 add_com ("up-silently", class_support
, up_silently_command
, _("\
2221 Same as the `up' command, but does not print anything.\n\
2222 This is useful in command scripts."));
2224 add_com ("down", class_stack
, down_command
, _("\
2225 Select and print stack frame called by this one.\n\
2226 An argument says how many frames down to go."));
2227 add_com_alias ("do", "down", class_stack
, 1);
2228 add_com_alias ("dow", "down", class_stack
, 1);
2229 add_com ("down-silently", class_support
, down_silently_command
, _("\
2230 Same as the `down' command, but does not print anything.\n\
2231 This is useful in command scripts."));
2233 add_com ("frame", class_stack
, frame_command
, _("\
2234 Select and print a stack frame.\nWith no argument, \
2235 print the selected stack frame. (See also \"info frame\").\n\
2236 An argument specifies the frame to select.\n\
2237 It can be a stack frame number or the address of the frame.\n\
2238 With argument, nothing is printed if input is coming from\n\
2239 a command file or a user-defined command."));
2241 add_com_alias ("f", "frame", class_stack
, 1);
2245 add_com ("L", class_stack
, current_frame_command
,
2246 _("Print the current stack frame.\n"));
2247 add_com_alias ("V", "frame", class_stack
, 1);
2249 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2250 Select a stack frame without printing anything.\n\
2251 An argument specifies the frame to select.\n\
2252 It can be a stack frame number or the address of the frame.\n"));
2254 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2255 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2256 With a negative argument, print outermost -COUNT frames.\nUse of the \
2257 'full' qualifier also prints the values of the local variables.\n"));
2258 add_com_alias ("bt", "backtrace", class_stack
, 0);
2261 add_com_alias ("t", "backtrace", class_stack
, 0);
2262 add_com ("T", class_stack
, backtrace_full_command
, _("\
2263 Print backtrace of all stack frames, or innermost COUNT frames\n\
2264 and the values of the local variables.\n\
2265 With a negative argument, print outermost -COUNT frames.\n\
2266 Usage: T <count>\n"));
2269 add_com_alias ("where", "backtrace", class_alias
, 0);
2270 add_info ("stack", backtrace_command
,
2271 _("Backtrace of the stack, or innermost COUNT frames."));
2272 add_info_alias ("s", "stack", 1);
2273 add_info ("frame", frame_info
,
2274 _("All about selected stack frame, or frame at ADDR."));
2275 add_info_alias ("f", "frame", 1);
2276 add_info ("locals", locals_info
,
2277 _("Local variables of current stack frame."));
2278 add_info ("args", args_info
,
2279 _("Argument variables of current stack frame."));
2281 add_com ("l", class_info
, args_plus_locals_info
,
2282 _("Argument and local variables of current stack frame."));
2285 add_com ("func", class_stack
, func_command
, _("\
2286 Select the stack frame that contains <func>.\n\
2287 Usage: func <name>\n"));
2289 add_info ("catch", catch_info
,
2290 _("Exceptions that can be caught in the current stack frame."));
2292 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2293 print_frame_arguments_choices
, &print_frame_arguments
,
2294 _("Set printing of non-scalar frame arguments"),
2295 _("Show printing of non-scalar frame arguments"),
2296 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2298 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2299 &disassemble_next_line
, _("\
2300 Set whether to disassemble next source line or insn when execution stops."),
2302 Show whether to disassemble next source line or insn when execution stops."),
2304 If ON, GDB will display disassembly of the next source line, in addition\n\
2305 to displaying the source line itself. If the next source line cannot\n\
2306 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2307 will display disassembly of next instruction instead of showing the\n\
2309 If AUTO, display disassembly of next instruction only if the source line\n\
2310 cannot be displayed.\n\
2311 If OFF (which is the default), never display the disassembly of the next\n\
2314 show_disassemble_next_line
,
2315 &setlist
, &showlist
);
2316 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;