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 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"
50 #include "gdb_assert.h"
52 #include "gdb_string.h"
54 void (*deprecated_selected_frame_level_changed_hook
) (int);
56 /* The possible choices of "set print frame-arguments, and the value
59 static const char *print_frame_arguments_choices
[] =
60 {"all", "scalars", "none", NULL
};
61 static const char *print_frame_arguments
= "all";
63 /* Prototypes for local functions. */
65 static void print_frame_local_vars (struct frame_info
*, int,
68 static void print_frame (struct frame_info
*frame
, int print_level
,
69 enum print_what print_what
, int print_args
,
70 struct symtab_and_line sal
);
72 /* Zero means do things normally; we are interacting directly with the
73 user. One means print the full filename and linenumber when a
74 frame is printed, and do so in a format emacs18/emacs19.22 can
75 parse. Two means print similar annotations, but in many more
76 cases and in a slightly different syntax. */
78 int annotation_level
= 0;
81 struct print_stack_frame_args
83 struct frame_info
*frame
;
85 enum print_what print_what
;
89 /* Show or print the frame arguments; stub for catch_errors. */
92 print_stack_frame_stub (void *args
)
94 struct print_stack_frame_args
*p
= args
;
95 int center
= (p
->print_what
== SRC_LINE
|| p
->print_what
== SRC_AND_LOC
);
97 print_frame_info (p
->frame
, p
->print_level
, p
->print_what
, p
->print_args
);
98 set_current_sal_from_frame (p
->frame
, center
);
102 /* Show or print a stack frame FRAME briefly. The output is format
103 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
104 relative level, function name, argument list, and file name and
105 line number. If the frame's PC is not at the beginning of the
106 source line, the actual PC is printed at the beginning. */
109 print_stack_frame (struct frame_info
*frame
, int print_level
,
110 enum print_what print_what
)
112 struct print_stack_frame_args args
;
115 args
.print_level
= print_level
;
116 args
.print_what
= print_what
;
117 /* For mi, alway print location and address. */
118 args
.print_what
= ui_out_is_mi_like_p (uiout
) ? LOC_AND_ADDRESS
: print_what
;
121 catch_errors (print_stack_frame_stub
, &args
, "", RETURN_MASK_ERROR
);
124 struct print_args_args
127 struct frame_info
*frame
;
128 struct ui_file
*stream
;
131 static int print_args_stub (void *args
);
133 /* Print nameless arguments of frame FRAME on STREAM, where START is
134 the offset of the first nameless argument, and NUM is the number of
135 nameless arguments to print. FIRST is nonzero if this is the first
136 argument (not just the first nameless argument). */
139 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
140 int first
, struct ui_file
*stream
)
146 for (i
= 0; i
< num
; i
++)
149 argsaddr
= get_frame_args_address (frame
);
152 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
154 fprintf_filtered (stream
, ", ");
155 fprintf_filtered (stream
, "%ld", arg_value
);
157 start
+= sizeof (int);
161 /* Return non-zero if the debugger should print the value of the provided
162 symbol parameter (SYM). */
165 print_this_frame_argument_p (struct symbol
*sym
)
169 /* If the user asked to print no argument at all, then obviously
170 do not print this argument. */
172 if (strcmp (print_frame_arguments
, "none") == 0)
175 /* If the user asked to print all arguments, then we should print
178 if (strcmp (print_frame_arguments
, "all") == 0)
181 /* The user asked to print only the scalar arguments, so do not
182 print the non-scalar ones. */
184 type
= check_typedef (SYMBOL_TYPE (sym
));
185 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
186 type
= check_typedef (TYPE_TARGET_TYPE (type
));
187 switch (TYPE_CODE (type
))
189 case TYPE_CODE_ARRAY
:
190 case TYPE_CODE_STRUCT
:
191 case TYPE_CODE_UNION
:
193 case TYPE_CODE_STRING
:
194 case TYPE_CODE_BITSTRING
:
201 /* Print the arguments of frame FRAME on STREAM, given the function
202 FUNC running in that frame (as a symbol), where NUM is the number
203 of arguments according to the stack frame (or -1 if the number of
204 arguments is unknown). */
206 /* Note that currently the "number of arguments according to the
207 stack frame" is only known on VAX where i refers to the "number of
208 ints of arguments according to the stack frame". */
211 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
212 int num
, struct ui_file
*stream
)
215 /* Offset of next stack argument beyond the one we have seen that is
216 at the highest offset, or -1 if we haven't come to a stack
218 long highest_offset
= -1;
219 /* Number of ints of arguments that we have printed so far. */
220 int args_printed
= 0;
221 struct cleanup
*old_chain
, *list_chain
;
222 struct ui_stream
*stb
;
224 stb
= ui_out_stream_new (uiout
);
225 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
229 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
230 struct dict_iterator iter
;
234 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
238 /* Keep track of the highest stack argument offset seen, and
239 skip over any kinds of symbols we don't care about. */
241 if (!SYMBOL_IS_ARGUMENT (sym
))
244 switch (SYMBOL_CLASS (sym
))
249 long current_offset
= SYMBOL_VALUE (sym
);
250 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
252 /* Compute address of next argument by adding the size of
253 this argument and rounding to an int boundary. */
255 ((current_offset
+ arg_size
+ sizeof (int) - 1)
256 & ~(sizeof (int) - 1));
258 /* If this is the highest offset seen yet, set
260 if (highest_offset
== -1
261 || (current_offset
> highest_offset
))
262 highest_offset
= current_offset
;
264 /* Add the number of ints we're about to print to
266 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
269 /* We care about types of symbols, but don't need to
270 keep track of stack offsets in them. */
272 case LOC_REGPARM_ADDR
:
274 case LOC_OPTIMIZED_OUT
:
279 /* We have to look up the symbol because arguments can have
280 two entries (one a parameter, one a local) and the one we
281 want is the local, which lookup_symbol will find for us.
282 This includes gcc1 (not gcc2) on SPARC when passing a
283 small structure and gcc2 when the argument type is float
284 and it is passed as a double and converted to float by
285 the prologue (in the latter case the type of the LOC_ARG
286 symbol is double and the type of the LOC_LOCAL symbol is
288 /* But if the parameter name is null, don't try it. Null
289 parameter names occur on the RS/6000, for traceback
290 tables. FIXME, should we even print them? */
292 if (*SYMBOL_LINKAGE_NAME (sym
))
295 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
296 b
, VAR_DOMAIN
, NULL
);
297 gdb_assert (nsym
!= NULL
);
298 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
299 && !SYMBOL_IS_ARGUMENT (nsym
))
301 /* There is a LOC_ARG/LOC_REGISTER pair. This means
302 that it was passed on the stack and loaded into a
303 register, or passed in a register and stored in a
304 stack slot. GDB 3.x used the LOC_ARG; GDB
305 4.0-4.11 used the LOC_REGISTER.
307 Reasons for using the LOC_ARG:
309 (1) Because find_saved_registers may be slow for
312 (2) Because registers are often re-used and stack
313 slots rarely (never?) are. Therefore using
314 the stack slot is much less likely to print
317 Reasons why we might want to use the LOC_REGISTER:
319 (1) So that the backtrace prints the same value
320 as "print foo". I see no compelling reason
321 why this needs to be the case; having the
322 backtrace print the value which was passed
323 in, and "print foo" print the value as
324 modified within the called function, makes
327 Additional note: It might be nice if "info args"
328 displayed both values.
330 One more note: There is a case with SPARC
331 structure passing where we need to use the
332 LOC_REGISTER, but this is dealt with by creating
333 a single LOC_REGPARM in symbol reading. */
335 /* Leave sym (the LOC_ARG) alone. */
342 /* Print the current arg. */
344 ui_out_text (uiout
, ", ");
345 ui_out_wrap_hint (uiout
, " ");
347 annotate_arg_begin ();
349 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
350 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
351 SYMBOL_LANGUAGE (sym
),
352 DMGL_PARAMS
| DMGL_ANSI
);
353 ui_out_field_stream (uiout
, "name", stb
);
354 annotate_arg_name_end ();
355 ui_out_text (uiout
, "=");
357 if (print_this_frame_argument_p (sym
))
359 /* Avoid value_print because it will deref ref parameters.
360 We just want to print their addresses. Print ??? for
361 args whose address we do not know. We pass 2 as
362 "recurse" to val_print because our standard indentation
363 here is 4 spaces, and val_print indents 2 for each
365 val
= read_var_value (sym
, frame
);
367 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
371 const struct language_defn
*language
;
372 struct value_print_options opts
;
374 /* Use the appropriate language to display our symbol,
375 unless the user forced the language to a specific
377 if (language_mode
== language_mode_auto
)
378 language
= language_def (SYMBOL_LANGUAGE (sym
));
380 language
= current_language
;
382 get_raw_print_options (&opts
);
384 common_val_print (val
, stb
->stream
, 2,
386 ui_out_field_stream (uiout
, "value", stb
);
389 ui_out_text (uiout
, "???");
392 ui_out_text (uiout
, "...");
395 /* Invoke ui_out_tuple_end. */
396 do_cleanups (list_chain
);
404 /* Don't print nameless args in situations where we don't know
405 enough about the stack to find them. */
410 if (highest_offset
== -1)
411 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
413 start
= highest_offset
;
415 print_frame_nameless_args (frame
, start
, num
- args_printed
,
419 do_cleanups (old_chain
);
422 /* Stub for catch_errors. */
425 print_args_stub (void *args
)
427 struct print_args_args
*p
= args
;
428 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
431 if (gdbarch_frame_num_args_p (gdbarch
))
433 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
434 gdb_assert (numargs
>= 0);
438 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
442 /* Set the current source and line to the location given by frame
443 FRAME, if possible. When CENTER is true, adjust so the relevant
444 line is in the center of the next 'list'. */
447 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
449 struct symtab_and_line sal
;
451 find_frame_sal (frame
, &sal
);
455 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
456 set_current_source_symtab_and_line (&sal
);
460 /* If ON, GDB will display disassembly of the next source line when
461 execution of the program being debugged stops.
462 If AUTO (which is the default), or there's no line info to determine
463 the source line of the next instruction, display disassembly of next
464 instruction instead. */
466 static enum auto_boolean disassemble_next_line
;
469 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
470 struct cmd_list_element
*c
,
473 fprintf_filtered (file
, _("\
474 Debugger's willingness to use disassemble-next-line is %s.\n"),
478 /* Show assembly codes; stub for catch_errors. */
480 struct gdb_disassembly_stub_args
488 gdb_disassembly_stub (void *args
)
490 struct gdb_disassembly_stub_args
*p
= args
;
491 gdb_disassembly (uiout
, 0, 0, p
->how_many
, p
->low
, p
->high
);
494 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
495 because it will be broken by filter sometime. */
498 do_gdb_disassembly (int how_many
, CORE_ADDR low
, CORE_ADDR high
)
500 volatile struct gdb_exception exception
;
501 struct gdb_disassembly_stub_args args
;
503 args
.how_many
= how_many
;
506 TRY_CATCH (exception
, RETURN_MASK_ALL
)
508 gdb_disassembly_stub (&args
);
512 /* Print information about frame FRAME. The output is format according
513 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
516 SRC_LINE: Print only source line.
517 LOCATION: Print only location.
518 LOC_AND_SRC: Print location and source line.
520 Used in "where" output, and to emit breakpoint or step
524 print_frame_info (struct frame_info
*frame
, int print_level
,
525 enum print_what print_what
, int print_args
)
527 struct symtab_and_line sal
;
531 if (get_frame_type (frame
) == DUMMY_FRAME
532 || get_frame_type (frame
) == SIGTRAMP_FRAME
)
534 struct cleanup
*uiout_cleanup
535 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
537 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
538 get_frame_pc (frame
));
540 /* Do this regardless of SOURCE because we don't have any source
541 to list for this frame. */
544 ui_out_text (uiout
, "#");
545 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
546 frame_relative_level (frame
));
548 if (ui_out_is_mi_like_p (uiout
))
550 annotate_frame_address ();
551 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
552 annotate_frame_address_end ();
555 if (get_frame_type (frame
) == DUMMY_FRAME
)
557 annotate_function_call ();
558 ui_out_field_string (uiout
, "func", "<function called from gdb>");
560 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
562 annotate_signal_handler_caller ();
563 ui_out_field_string (uiout
, "func", "<signal handler called>");
565 ui_out_text (uiout
, "\n");
566 annotate_frame_end ();
568 do_cleanups (uiout_cleanup
);
572 /* If FRAME is not the innermost frame, that normally means that
573 FRAME->pc points to *after* the call instruction, and we want to
574 get the line containing the call, never the next line. But if
575 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
576 next frame was not entered as the result of a call, and we want
577 to get the line containing FRAME->pc. */
578 find_frame_sal (frame
, &sal
);
580 location_print
= (print_what
== LOCATION
581 || print_what
== LOC_AND_ADDRESS
582 || print_what
== SRC_AND_LOC
);
584 if (location_print
|| !sal
.symtab
)
585 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
587 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
589 /* If disassemble-next-line is set to auto or on and doesn't have
590 the line debug messages for $pc, output the next instruction. */
591 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
592 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
593 && source_print
&& !sal
.symtab
)
594 do_gdb_disassembly (1, get_frame_pc (frame
), get_frame_pc (frame
) + 1);
596 if (source_print
&& sal
.symtab
)
599 int mid_statement
= ((print_what
== SRC_LINE
)
600 && (get_frame_pc (frame
) != sal
.pc
));
602 if (annotation_level
)
603 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
604 get_frame_pc (frame
));
607 if (deprecated_print_frame_info_listing_hook
)
608 deprecated_print_frame_info_listing_hook (sal
.symtab
,
613 struct value_print_options opts
;
614 get_user_print_options (&opts
);
615 /* We used to do this earlier, but that is clearly
616 wrong. This function is used by many different
617 parts of gdb, including normal_stop in infrun.c,
618 which uses this to print out the current PC
619 when we stepi/nexti into the middle of a source
620 line. Only the command line really wants this
621 behavior. Other UIs probably would like the
622 ability to decide for themselves if it is desired. */
623 if (opts
.addressprint
&& mid_statement
)
625 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
626 ui_out_text (uiout
, "\t");
629 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
633 /* If disassemble-next-line is set to on and there is line debug
634 messages, output assembly codes for next line. */
635 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
636 do_gdb_disassembly (-1, get_frame_pc (frame
), sal
.end
);
639 if (print_what
!= LOCATION
)
640 set_default_breakpoint (1, get_frame_pc (frame
), sal
.symtab
, sal
.line
);
642 annotate_frame_end ();
644 gdb_flush (gdb_stdout
);
647 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
650 find_frame_funname (struct frame_info
*frame
, char **funname
,
651 enum language
*funlang
)
656 *funlang
= language_unknown
;
658 func
= find_pc_function (get_frame_address_in_block (frame
));
661 /* In certain pathological cases, the symtabs give the wrong
662 function (when we are in the first function in a file which
663 is compiled without debugging symbols, the previous function
664 is compiled with debugging symbols, and the "foo.o" symbol
665 that is supposed to tell us where the file with debugging
666 symbols ends has been truncated by ar because it is longer
667 than 15 characters). This also occurs if the user uses asm()
668 to create a function but not stabs for it (in a file compiled
671 So look in the minimal symbol tables as well, and if it comes
672 up with a larger address for the function use that instead.
673 I don't think this can ever cause any problems; there
674 shouldn't be any minimal symbols in the middle of a function;
675 if this is ever changed many parts of GDB will need to be
676 changed (and we'll create a find_pc_minimal_function or some
679 struct minimal_symbol
*msymbol
=
680 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
683 && (SYMBOL_VALUE_ADDRESS (msymbol
)
684 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
686 /* We also don't know anything about the function besides
687 its address and name. */
689 *funname
= SYMBOL_PRINT_NAME (msymbol
);
690 *funlang
= SYMBOL_LANGUAGE (msymbol
);
694 *funname
= SYMBOL_PRINT_NAME (func
);
695 *funlang
= SYMBOL_LANGUAGE (func
);
696 if (*funlang
== language_cplus
)
698 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
699 to display the demangled name that we already have
700 stored in the symbol table, but we stored a version
701 with DMGL_PARAMS turned on, and here we don't want to
702 display parameters. So remove the parameters. */
703 char *func_only
= cp_remove_params (*funname
);
706 *funname
= func_only
;
707 make_cleanup (xfree
, func_only
);
714 struct minimal_symbol
*msymbol
=
715 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
719 *funname
= SYMBOL_PRINT_NAME (msymbol
);
720 *funlang
= SYMBOL_LANGUAGE (msymbol
);
726 print_frame (struct frame_info
*frame
, int print_level
,
727 enum print_what print_what
, int print_args
,
728 struct symtab_and_line sal
)
730 char *funname
= NULL
;
731 enum language funlang
= language_unknown
;
732 struct ui_stream
*stb
;
733 struct cleanup
*old_chain
, *list_chain
;
734 struct value_print_options opts
;
736 stb
= ui_out_stream_new (uiout
);
737 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
739 find_frame_funname (frame
, &funname
, &funlang
);
741 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
742 get_frame_pc (frame
));
744 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
748 ui_out_text (uiout
, "#");
749 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
750 frame_relative_level (frame
));
752 get_user_print_options (&opts
);
753 if (opts
.addressprint
)
754 if (get_frame_pc (frame
) != sal
.pc
|| !sal
.symtab
755 || print_what
== LOC_AND_ADDRESS
)
757 annotate_frame_address ();
758 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
759 annotate_frame_address_end ();
760 ui_out_text (uiout
, " in ");
762 annotate_frame_function_name ();
763 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
765 ui_out_field_stream (uiout
, "func", stb
);
766 ui_out_wrap_hint (uiout
, " ");
767 annotate_frame_args ();
769 ui_out_text (uiout
, " (");
772 struct print_args_args args
;
773 struct cleanup
*args_list_chain
;
775 args
.func
= find_pc_function (get_frame_address_in_block (frame
));
776 args
.stream
= gdb_stdout
;
777 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
778 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
779 /* FIXME: ARGS must be a list. If one argument is a string it
780 will have " that will not be properly escaped. */
781 /* Invoke ui_out_tuple_end. */
782 do_cleanups (args_list_chain
);
785 ui_out_text (uiout
, ")");
786 if (sal
.symtab
&& sal
.symtab
->filename
)
788 annotate_frame_source_begin ();
789 ui_out_wrap_hint (uiout
, " ");
790 ui_out_text (uiout
, " at ");
791 annotate_frame_source_file ();
792 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
793 if (ui_out_is_mi_like_p (uiout
))
795 const char *fullname
= symtab_to_fullname (sal
.symtab
);
796 if (fullname
!= NULL
)
797 ui_out_field_string (uiout
, "fullname", fullname
);
799 annotate_frame_source_file_end ();
800 ui_out_text (uiout
, ":");
801 annotate_frame_source_line ();
802 ui_out_field_int (uiout
, "line", sal
.line
);
803 annotate_frame_source_end ();
806 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
809 char *lib
= PC_SOLIB (get_frame_pc (frame
));
811 char *lib
= solib_name_from_address (get_frame_pc (frame
));
815 annotate_frame_where ();
816 ui_out_wrap_hint (uiout
, " ");
817 ui_out_text (uiout
, " from ");
818 ui_out_field_string (uiout
, "from", lib
);
822 /* do_cleanups will call ui_out_tuple_end() for us. */
823 do_cleanups (list_chain
);
824 ui_out_text (uiout
, "\n");
825 do_cleanups (old_chain
);
829 /* Read a frame specification in whatever the appropriate format is
830 from FRAME_EXP. Call error(), printing MESSAGE, if the
831 specification is in any way invalid (so this function never returns
832 NULL). When SEPECTED_P is non-NULL set its target to indicate that
833 the default selected frame was used. */
835 static struct frame_info
*
836 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
837 int *selected_frame_p
)
840 struct value
*args
[4];
841 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
843 if (frame_exp
== NULL
)
848 struct cleanup
*tmp_cleanup
;
854 struct cleanup
*cleanup
;
857 /* Skip leading white space, bail of EOL. */
858 while (isspace (*frame_exp
))
863 /* Parse the argument, extract it, save it. */
867 addr_string
= savestring (frame_exp
, p
- frame_exp
);
869 cleanup
= make_cleanup (xfree
, addr_string
);
871 /* NOTE: Parse and evaluate expression, but do not use
872 functions such as parse_and_eval_long or
873 parse_and_eval_address to also extract the value.
874 Instead value_as_long and value_as_address are used.
875 This avoids problems with expressions that contain
877 if (numargs
>= ARRAY_SIZE (args
))
878 error (_("Too many args in frame specification"));
879 args
[numargs
++] = parse_and_eval (addr_string
);
881 do_cleanups (cleanup
);
885 /* If no args, default to the selected frame. */
888 if (selected_frame_p
!= NULL
)
889 (*selected_frame_p
) = 1;
890 return get_selected_frame (message
);
893 /* None of the remaining use the selected frame. */
894 if (selected_frame_p
!= NULL
)
895 (*selected_frame_p
) = 0;
897 /* Assume the single arg[0] is an integer, and try using that to
898 select a frame relative to current. */
901 struct frame_info
*fid
;
902 int level
= value_as_long (args
[0]);
903 fid
= find_relative_frame (get_current_frame (), &level
);
905 /* find_relative_frame was successful */
909 /* Convert each value into a corresponding address. */
912 for (i
= 0; i
< numargs
; i
++)
913 addrs
[i
] = value_as_address (args
[i
]);
916 /* Assume that the single arg[0] is an address, use that to identify
917 a frame with a matching ID. Should this also accept stack/pc or
921 struct frame_id id
= frame_id_build_wild (addrs
[0]);
922 struct frame_info
*fid
;
924 /* If (s)he specifies the frame with an address, he deserves
925 what (s)he gets. Still, give the highest one that matches.
926 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
928 for (fid
= get_current_frame ();
930 fid
= get_prev_frame (fid
))
932 if (frame_id_eq (id
, get_frame_id (fid
)))
934 while (frame_id_eq (id
, frame_unwind_id (fid
)))
935 fid
= get_prev_frame (fid
);
941 /* We couldn't identify the frame as an existing frame, but
942 perhaps we can create one with a single argument. */
944 return create_new_frame (addrs
[0], 0);
945 else if (numargs
== 2)
946 return create_new_frame (addrs
[0], addrs
[1]);
948 error (_("Too many args in frame specification"));
951 static struct frame_info
*
952 parse_frame_specification (char *frame_exp
)
954 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
957 /* Print verbosely the selected frame or the frame at address
958 ADDR_EXP. Absolutely all information in the frame is printed. */
961 frame_info (char *addr_exp
, int from_tty
)
963 struct frame_info
*fi
;
964 struct symtab_and_line sal
;
967 struct frame_info
*calling_frame_info
;
968 int i
, count
, numregs
;
970 enum language funlang
= language_unknown
;
971 const char *pc_regname
;
972 int selected_frame_p
;
973 struct gdbarch
*gdbarch
;
974 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
976 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
977 gdbarch
= get_frame_arch (fi
);
979 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
980 is not a good name. */
981 if (gdbarch_pc_regnum (gdbarch
) >= 0)
982 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
983 easily not match that of the internal value returned by
985 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
987 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
988 architectures will often have a hardware register called "pc",
989 and that register's value, again, can easily not match
993 find_frame_sal (fi
, &sal
);
994 func
= get_frame_function (fi
);
995 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
997 s
= find_pc_symtab (get_frame_pc (fi
));
1000 funname
= SYMBOL_PRINT_NAME (func
);
1001 funlang
= SYMBOL_LANGUAGE (func
);
1002 if (funlang
== language_cplus
)
1004 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1005 to display the demangled name that we already have
1006 stored in the symbol table, but we stored a version
1007 with DMGL_PARAMS turned on, and here we don't want to
1008 display parameters. So remove the parameters. */
1009 char *func_only
= cp_remove_params (funname
);
1012 funname
= func_only
;
1013 make_cleanup (xfree
, func_only
);
1019 struct minimal_symbol
*msymbol
;
1021 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1022 if (msymbol
!= NULL
)
1024 funname
= SYMBOL_PRINT_NAME (msymbol
);
1025 funlang
= SYMBOL_LANGUAGE (msymbol
);
1028 calling_frame_info
= get_prev_frame (fi
);
1030 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1032 printf_filtered (_("Stack level %d, frame at "),
1033 frame_relative_level (fi
));
1037 printf_filtered (_("Stack frame at "));
1039 fputs_filtered (paddress (get_frame_base (fi
)), gdb_stdout
);
1040 printf_filtered (":\n");
1041 printf_filtered (" %s = ", pc_regname
);
1042 fputs_filtered (paddress (get_frame_pc (fi
)), gdb_stdout
);
1047 printf_filtered (" in ");
1048 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1049 DMGL_ANSI
| DMGL_PARAMS
);
1053 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1054 puts_filtered ("; ");
1056 printf_filtered ("saved %s ", pc_regname
);
1057 fputs_filtered (paddress (frame_pc_unwind (fi
)), gdb_stdout
);
1058 printf_filtered ("\n");
1060 if (calling_frame_info
== NULL
)
1062 enum unwind_stop_reason reason
;
1064 reason
= get_frame_unwind_stop_reason (fi
);
1065 if (reason
!= UNWIND_NO_REASON
)
1066 printf_filtered (_(" Outermost frame: %s\n"),
1067 frame_stop_reason_string (reason
));
1070 if (calling_frame_info
)
1072 printf_filtered (" called by frame at ");
1073 fputs_filtered (paddress (get_frame_base (calling_frame_info
)),
1076 if (get_next_frame (fi
) && calling_frame_info
)
1077 puts_filtered (",");
1079 if (get_next_frame (fi
))
1081 printf_filtered (" caller of frame at ");
1082 fputs_filtered (paddress (get_frame_base (get_next_frame (fi
))),
1085 if (get_next_frame (fi
) || calling_frame_info
)
1086 puts_filtered ("\n");
1089 printf_filtered (" source language %s.\n",
1090 language_str (s
->language
));
1093 /* Address of the argument list for this frame, or 0. */
1094 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1095 /* Number of args for this frame, or -1 if unknown. */
1099 printf_filtered (" Arglist at unknown address.\n");
1102 printf_filtered (" Arglist at ");
1103 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1104 printf_filtered (",");
1106 if (!gdbarch_frame_num_args_p (gdbarch
))
1109 puts_filtered (" args: ");
1113 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1114 gdb_assert (numargs
>= 0);
1116 puts_filtered (" no args.");
1117 else if (numargs
== 1)
1118 puts_filtered (" 1 arg: ");
1120 printf_filtered (" %d args: ", numargs
);
1122 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1123 puts_filtered ("\n");
1127 /* Address of the local variables for this frame, or 0. */
1128 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1131 printf_filtered (" Locals at unknown address,");
1134 printf_filtered (" Locals at ");
1135 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1136 printf_filtered (",");
1140 /* Print as much information as possible on the location of all the
1143 enum lval_type lval
;
1151 /* The sp is special; what's displayed isn't the save address, but
1152 the value of the previous frame's sp. This is a legacy thing,
1153 at one stage the frame cached the previous frame's SP instead
1154 of its address, hence it was easiest to just display the cached
1156 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1158 /* Find out the location of the saved stack pointer with out
1159 actually evaluating it. */
1160 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1161 &optimized
, &lval
, &addr
,
1163 if (!optimized
&& lval
== not_lval
)
1165 gdb_byte value
[MAX_REGISTER_SIZE
];
1167 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1168 &optimized
, &lval
, &addr
,
1170 /* NOTE: cagney/2003-05-22: This is assuming that the
1171 stack pointer was packed as an unsigned integer. That
1172 may or may not be valid. */
1173 sp
= extract_unsigned_integer (value
,
1174 register_size (gdbarch
,
1175 gdbarch_sp_regnum (gdbarch
)));
1176 printf_filtered (" Previous frame's sp is ");
1177 fputs_filtered (paddress (sp
), gdb_stdout
);
1178 printf_filtered ("\n");
1181 else if (!optimized
&& lval
== lval_memory
)
1183 printf_filtered (" Previous frame's sp at ");
1184 fputs_filtered (paddress (addr
), gdb_stdout
);
1185 printf_filtered ("\n");
1188 else if (!optimized
&& lval
== lval_register
)
1190 printf_filtered (" Previous frame's sp in %s\n",
1191 gdbarch_register_name (gdbarch
, realnum
));
1194 /* else keep quiet. */
1198 numregs
= gdbarch_num_regs (gdbarch
)
1199 + gdbarch_num_pseudo_regs (gdbarch
);
1200 for (i
= 0; i
< numregs
; i
++)
1201 if (i
!= gdbarch_sp_regnum (gdbarch
)
1202 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1204 /* Find out the location of the saved register without
1205 fetching the corresponding value. */
1206 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1208 /* For moment, only display registers that were saved on the
1210 if (!optimized
&& lval
== lval_memory
)
1213 puts_filtered (" Saved registers:\n ");
1215 puts_filtered (",");
1217 printf_filtered (" %s at ",
1218 gdbarch_register_name (gdbarch
, i
));
1219 fputs_filtered (paddress (addr
), gdb_stdout
);
1223 if (count
|| need_nl
)
1224 puts_filtered ("\n");
1227 do_cleanups (back_to
);
1230 /* Print briefly all stack frames or just the innermost COUNT_EXP
1234 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1236 struct frame_info
*fi
;
1239 struct frame_info
*trailing
;
1242 if (!target_has_stack
)
1243 error (_("No stack."));
1245 /* The following code must do two things. First, it must set the
1246 variable TRAILING to the frame from which we should start
1247 printing. Second, it must set the variable count to the number
1248 of frames which we should print, or -1 if all of them. */
1249 trailing
= get_current_frame ();
1251 /* The target can be in a state where there is no valid frames
1252 (e.g., just connected). */
1253 if (trailing
== NULL
)
1254 error (_("No stack."));
1259 count
= parse_and_eval_long (count_exp
);
1262 struct frame_info
*current
;
1267 while (current
&& count
--)
1270 current
= get_prev_frame (current
);
1273 /* Will stop when CURRENT reaches the top of the stack.
1274 TRAILING will be COUNT below it. */
1278 trailing
= get_prev_frame (trailing
);
1279 current
= get_prev_frame (current
);
1291 struct partial_symtab
*ps
;
1293 /* Read in symbols for all of the frames. Need to do this in a
1294 separate pass so that "Reading in symbols for xxx" messages
1295 don't screw up the appearance of the backtrace. Also if
1296 people have strong opinions against reading symbols for
1297 backtrace this may have to be an option. */
1299 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1302 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1304 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in. */
1308 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1312 /* Don't use print_stack_frame; if an error() occurs it probably
1313 means further attempts to backtrace would fail (on the other
1314 hand, perhaps the code does or could be fixed to make sure
1315 the frame->prev field gets set to NULL in that case). */
1316 print_frame_info (fi
, 1, LOCATION
, 1);
1318 print_frame_local_vars (fi
, 1, gdb_stdout
);
1320 /* Save the last frame to check for error conditions. */
1324 /* If we've stopped before the end, mention that. */
1326 printf_filtered (_("(More stack frames follow...)\n"));
1328 /* If we've run out of frames, and the reason appears to be an error
1329 condition, print it. */
1330 if (fi
== NULL
&& trailing
!= NULL
)
1332 enum unwind_stop_reason reason
;
1334 reason
= get_frame_unwind_stop_reason (trailing
);
1335 if (reason
> UNWIND_FIRST_ERROR
)
1336 printf_filtered (_("Backtrace stopped: %s\n"),
1337 frame_stop_reason_string (reason
));
1341 struct backtrace_command_args
1348 /* Stub for catch_errors. */
1351 backtrace_command_stub (void *data
)
1353 struct backtrace_command_args
*args
= data
;
1354 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1359 backtrace_command (char *arg
, int from_tty
)
1361 struct cleanup
*old_chain
= NULL
;
1362 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1363 struct backtrace_command_args btargs
;
1370 argv
= gdb_buildargv (arg
);
1371 old_chain
= make_cleanup_freeargv (argv
);
1373 for (i
= 0; argv
[i
]; i
++)
1377 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1378 argv
[i
][j
] = tolower (argv
[i
][j
]);
1380 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1381 fulltrace_arg
= argc
;
1384 arglen
+= strlen (argv
[i
]);
1389 if (fulltrace_arg
>= 0)
1393 arg
= xmalloc (arglen
+ 1);
1394 memset (arg
, 0, arglen
+ 1);
1395 for (i
= 0; i
< (argc
+ 1); i
++)
1397 if (i
!= fulltrace_arg
)
1399 strcat (arg
, argv
[i
]);
1409 btargs
.count_exp
= arg
;
1410 btargs
.show_locals
= (fulltrace_arg
>= 0);
1411 btargs
.from_tty
= from_tty
;
1412 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1414 if (fulltrace_arg
>= 0 && arglen
> 0)
1418 do_cleanups (old_chain
);
1422 backtrace_full_command (char *arg
, int from_tty
)
1424 struct backtrace_command_args btargs
;
1425 btargs
.count_exp
= arg
;
1426 btargs
.show_locals
= 1;
1427 btargs
.from_tty
= from_tty
;
1428 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1432 /* Print the local variables of a block B active in FRAME on STREAM.
1433 Return 1 if any variables were printed; 0 otherwise. */
1436 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1437 int num_tabs
, struct ui_file
*stream
)
1439 struct dict_iterator iter
;
1441 int values_printed
= 0;
1444 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1446 switch (SYMBOL_CLASS (sym
))
1452 if (SYMBOL_IS_ARGUMENT (sym
))
1455 print_variable_and_value (NULL
, sym
, frame
, stream
, 4 * num_tabs
);
1459 /* Ignore symbols which are not locals. */
1464 return values_printed
;
1467 /* Same, but print labels. */
1470 print_block_frame_labels (struct block
*b
, int *have_default
,
1471 struct ui_file
*stream
)
1473 struct dict_iterator iter
;
1475 int values_printed
= 0;
1477 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1479 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1485 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1487 struct symtab_and_line sal
;
1488 struct value_print_options opts
;
1489 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1491 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1492 get_user_print_options (&opts
);
1493 if (opts
.addressprint
)
1495 fprintf_filtered (stream
, " ");
1496 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym
)), stream
);
1498 fprintf_filtered (stream
, " in file %s, line %d\n",
1499 sal
.symtab
->filename
, sal
.line
);
1503 return values_printed
;
1506 /* Print on STREAM all the local variables in frame FRAME, including
1507 all the blocks active in that frame at its current PC.
1509 Returns 1 if the job was done, or 0 if nothing was printed because
1510 we have no info on the function running in FRAME. */
1513 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1514 struct ui_file
*stream
)
1516 struct block
*block
= get_frame_block (frame
, 0);
1517 int values_printed
= 0;
1521 fprintf_filtered (stream
, "No symbol table info available.\n");
1527 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1529 /* After handling the function's top-level block, stop. Don't
1530 continue to its superblock, the block of per-file symbols. */
1531 if (BLOCK_FUNCTION (block
))
1533 block
= BLOCK_SUPERBLOCK (block
);
1536 if (!values_printed
)
1537 fprintf_filtered (stream
, _("No locals.\n"));
1540 /* Same, but print labels. */
1543 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1544 struct ui_file
*stream
)
1547 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1549 struct blockvector
*bl
;
1550 struct block
*block
= get_frame_block (frame
, 0);
1551 int values_printed
= 0;
1552 int index
, have_default
= 0;
1553 char *blocks_printed
;
1554 CORE_ADDR pc
= get_frame_pc (frame
);
1558 fprintf_filtered (stream
, "No symbol table info available.\n");
1562 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1563 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1564 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1568 CORE_ADDR end
= BLOCK_END (block
) - 4;
1571 if (bl
!= blockvector_for_pc (end
, &index
))
1572 error (_("blockvector blotch"));
1573 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1574 error (_("blockvector botch"));
1575 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1578 /* Don't print out blocks that have gone by. */
1579 while (index
< last_index
1580 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1583 while (index
< last_index
1584 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1586 if (blocks_printed
[index
] == 0)
1588 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
),
1589 &have_default
, stream
))
1591 blocks_printed
[index
] = 1;
1597 if (values_printed
&& this_level_only
)
1600 /* After handling the function's top-level block, stop. Don't
1601 continue to its superblock, the block of per-file symbols. */
1602 if (BLOCK_FUNCTION (block
))
1604 block
= BLOCK_SUPERBLOCK (block
);
1607 if (!values_printed
&& !this_level_only
)
1608 fprintf_filtered (stream
, _("No catches.\n"));
1613 locals_info (char *args
, int from_tty
)
1615 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1620 catch_info (char *ignore
, int from_tty
)
1622 struct symtab_and_line
*sal
;
1624 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1625 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1630 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1632 struct symbol
*func
= get_frame_function (frame
);
1634 struct dict_iterator iter
;
1635 struct symbol
*sym
, *sym2
;
1636 int values_printed
= 0;
1640 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1644 b
= SYMBOL_BLOCK_VALUE (func
);
1645 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1647 /* Don't worry about things which aren't arguments. */
1648 if (SYMBOL_IS_ARGUMENT (sym
))
1652 /* We have to look up the symbol because arguments can have
1653 two entries (one a parameter, one a local) and the one we
1654 want is the local, which lookup_symbol will find for us.
1655 This includes gcc1 (not gcc2) on the sparc when passing a
1656 small structure and gcc2 when the argument type is float
1657 and it is passed as a double and converted to float by
1658 the prologue (in the latter case the type of the LOC_ARG
1659 symbol is double and the type of the LOC_LOCAL symbol is
1660 float). There are also LOC_ARG/LOC_REGISTER pairs which
1661 are not combined in symbol-reading. */
1663 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1664 b
, VAR_DOMAIN
, NULL
);
1665 print_variable_and_value (SYMBOL_PRINT_NAME (sym
), sym2
,
1670 if (!values_printed
)
1671 fprintf_filtered (stream
, _("No arguments.\n"));
1675 args_info (char *ignore
, int from_tty
)
1677 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1683 args_plus_locals_info (char *ignore
, int from_tty
)
1685 args_info (ignore
, from_tty
);
1686 locals_info (ignore
, from_tty
);
1690 /* Select frame FRAME. Also print the stack frame and show the source
1691 if this is the tui version. */
1693 select_and_print_frame (struct frame_info
*frame
)
1695 select_frame (frame
);
1697 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1700 /* Return the symbol-block in which the selected frame is executing.
1701 Can return zero under various legitimate circumstances.
1703 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1704 code address within the block returned. We use this to decide
1705 which macros are in scope. */
1708 get_selected_block (CORE_ADDR
*addr_in_block
)
1710 if (!has_stack_frames ())
1713 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1716 /* Find a frame a certain number of levels away from FRAME.
1717 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1718 Positive means go to earlier frames (up); negative, the reverse.
1719 The int that contains the number of levels is counted toward
1720 zero as the frames for those levels are found.
1721 If the top or bottom frame is reached, that frame is returned,
1722 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1723 how much farther the original request asked to go. */
1726 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1728 /* Going up is simple: just call get_prev_frame enough times or
1729 until the initial frame is reached. */
1730 while (*level_offset_ptr
> 0)
1732 struct frame_info
*prev
= get_prev_frame (frame
);
1735 (*level_offset_ptr
)--;
1739 /* Going down is just as simple. */
1740 while (*level_offset_ptr
< 0)
1742 struct frame_info
*next
= get_next_frame (frame
);
1745 (*level_offset_ptr
)++;
1752 /* The "select_frame" command. With no argument this is a NOP.
1753 Select the frame at level LEVEL_EXP if it is a valid level.
1754 Otherwise, treat LEVEL_EXP as an address expression and select it.
1756 See parse_frame_specification for more info on proper frame
1760 select_frame_command (char *level_exp
, int from_tty
)
1762 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1765 /* The "frame" command. With no argument, print the selected frame
1766 briefly. With an argument, behave like select_frame and then print
1767 the selected frame. */
1770 frame_command (char *level_exp
, int from_tty
)
1772 select_frame_command (level_exp
, from_tty
);
1773 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1776 /* The XDB Compatibility command to print the current frame. */
1779 current_frame_command (char *level_exp
, int from_tty
)
1781 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1784 /* Select the frame up one or COUNT_EXP stack levels from the
1785 previously selected frame, and print it briefly. */
1788 up_silently_base (char *count_exp
)
1790 struct frame_info
*frame
;
1794 count
= parse_and_eval_long (count_exp
);
1796 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1797 if (count
!= 0 && count_exp
== NULL
)
1798 error (_("Initial frame selected; you cannot go up."));
1799 select_frame (frame
);
1803 up_silently_command (char *count_exp
, int from_tty
)
1805 up_silently_base (count_exp
);
1809 up_command (char *count_exp
, int from_tty
)
1811 up_silently_base (count_exp
);
1812 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1815 /* Select the frame down one or COUNT_EXP stack levels from the previously
1816 selected frame, and print it briefly. */
1819 down_silently_base (char *count_exp
)
1821 struct frame_info
*frame
;
1824 count
= -parse_and_eval_long (count_exp
);
1826 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1827 if (count
!= 0 && count_exp
== NULL
)
1829 /* We only do this if COUNT_EXP is not specified. That way
1830 "down" means to really go down (and let me know if that is
1831 impossible), but "down 9999" can be used to mean go all the
1832 way down without getting an error. */
1834 error (_("Bottom (innermost) frame selected; you cannot go down."));
1837 select_frame (frame
);
1841 down_silently_command (char *count_exp
, int from_tty
)
1843 down_silently_base (count_exp
);
1847 down_command (char *count_exp
, int from_tty
)
1849 down_silently_base (count_exp
);
1850 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1855 return_command (char *retval_exp
, int from_tty
)
1857 struct frame_info
*thisframe
;
1858 struct symbol
*thisfun
;
1859 struct value
*return_value
= NULL
;
1860 const char *query_prefix
= "";
1862 thisframe
= get_selected_frame ("No selected frame.");
1863 thisfun
= get_frame_function (thisframe
);
1865 /* Compute the return value. If the computation triggers an error,
1866 let it bail. If the return type can't be handled, set
1867 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1871 struct expression
*retval_expr
= parse_expression (retval_exp
);
1872 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1873 struct type
*return_type
= NULL
;
1875 /* Compute the return value. Should the computation fail, this
1876 call throws an error. */
1877 return_value
= evaluate_expression (retval_expr
);
1879 /* Cast return value to the return type of the function. Should
1880 the cast fail, this call throws an error. */
1881 if (thisfun
!= NULL
)
1882 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1883 if (return_type
== NULL
)
1885 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1886 error (_("Return value type not available for selected "
1888 "Please use an explicit cast of the value to return."));
1889 return_type
= value_type (return_value
);
1891 do_cleanups (old_chain
);
1892 CHECK_TYPEDEF (return_type
);
1893 return_value
= value_cast (return_type
, return_value
);
1895 /* Make sure the value is fully evaluated. It may live in the
1896 stack frame we're about to pop. */
1897 if (value_lazy (return_value
))
1898 value_fetch_lazy (return_value
);
1900 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1901 /* If the return-type is "void", don't try to find the
1902 return-value's location. However, do still evaluate the
1903 return expression so that, even when the expression result
1904 is discarded, side effects such as "return i++" still
1906 return_value
= NULL
;
1907 else if (thisfun
!= NULL
1908 && using_struct_return (SYMBOL_TYPE (thisfun
), return_type
))
1911 The location at which to store the function's return value is unknown.\n\
1912 If you continue, the return value that you specified will be ignored.\n";
1913 return_value
= NULL
;
1917 /* Does an interactive user really want to do this? Include
1918 information, such as how well GDB can handle the return value, in
1919 the query message. */
1923 if (thisfun
== NULL
)
1924 confirmed
= query (_("%sMake selected stack frame return now? "),
1927 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1928 SYMBOL_PRINT_NAME (thisfun
));
1930 error (_("Not confirmed"));
1933 /* Discard the selected frame and all frames inner-to it. */
1934 frame_pop (get_selected_frame (NULL
));
1936 /* Store RETURN_VALUE in the just-returned register set. */
1937 if (return_value
!= NULL
)
1939 struct type
*return_type
= value_type (return_value
);
1940 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1941 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
1943 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
1945 == RETURN_VALUE_REGISTER_CONVENTION
);
1946 gdbarch_return_value (gdbarch
, func_type
, return_type
,
1947 get_current_regcache (), NULL
/*read*/,
1948 value_contents (return_value
) /*write*/);
1951 /* If we are at the end of a call dummy now, pop the dummy frame
1953 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1954 frame_pop (get_current_frame ());
1956 /* If interactive, print the frame that is now current. */
1958 frame_command ("0", 1);
1960 select_frame_command ("0", 0);
1963 /* Sets the scope to input function name, provided that the function
1964 is within the current stack frame */
1966 struct function_bounds
1968 CORE_ADDR low
, high
;
1972 func_command (char *arg
, int from_tty
)
1974 struct frame_info
*frame
;
1976 struct symtabs_and_lines sals
;
1979 struct function_bounds
*func_bounds
= NULL
;
1984 frame
= parse_frame_specification ("0");
1985 sals
= decode_line_spec (arg
, 1);
1986 func_bounds
= (struct function_bounds
*) xmalloc (
1987 sizeof (struct function_bounds
) * sals
.nelts
);
1988 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1990 if (sals
.sals
[i
].pc
== 0
1991 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
1992 &func_bounds
[i
].low
,
1993 &func_bounds
[i
].high
) == 0)
1995 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2001 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2002 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2003 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2007 frame
= find_relative_frame (frame
, &level
);
2010 while (!found
&& level
== 0);
2013 xfree (func_bounds
);
2016 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2017 else if (frame
!= get_selected_frame (NULL
))
2018 select_and_print_frame (frame
);
2021 /* Gets the language of the current frame. */
2024 get_frame_language (void)
2026 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2030 /* We determine the current frame language by looking up its
2031 associated symtab. To retrieve this symtab, we use the frame
2032 PC. However we cannot use the frame PC as is, because it
2033 usually points to the instruction following the "call", which
2034 is sometimes the first instruction of another function. So
2035 we rely on get_frame_address_in_block(), it provides us with
2036 a PC that is guaranteed to be inside the frame's code
2038 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2039 struct symtab
*s
= find_pc_symtab (pc
);
2045 return language_unknown
;
2049 /* Provide a prototype to silence -Wmissing-prototypes. */
2050 void _initialize_stack (void);
2053 _initialize_stack (void)
2056 backtrace_limit
= 30;
2059 add_com ("return", class_stack
, return_command
, _("\
2060 Make selected stack frame return to its caller.\n\
2061 Control remains in the debugger, but when you continue\n\
2062 execution will resume in the frame above the one now selected.\n\
2063 If an argument is given, it is an expression for the value to return."));
2065 add_com ("up", class_stack
, up_command
, _("\
2066 Select and print stack frame that called this one.\n\
2067 An argument says how many frames up to go."));
2068 add_com ("up-silently", class_support
, up_silently_command
, _("\
2069 Same as the `up' command, but does not print anything.\n\
2070 This is useful in command scripts."));
2072 add_com ("down", class_stack
, down_command
, _("\
2073 Select and print stack frame called by this one.\n\
2074 An argument says how many frames down to go."));
2075 add_com_alias ("do", "down", class_stack
, 1);
2076 add_com_alias ("dow", "down", class_stack
, 1);
2077 add_com ("down-silently", class_support
, down_silently_command
, _("\
2078 Same as the `down' command, but does not print anything.\n\
2079 This is useful in command scripts."));
2081 add_com ("frame", class_stack
, frame_command
, _("\
2082 Select and print a stack frame.\n\
2083 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2084 An argument specifies the frame to select.\n\
2085 It can be a stack frame number or the address of the frame.\n\
2086 With argument, nothing is printed if input is coming from\n\
2087 a command file or a user-defined command."));
2089 add_com_alias ("f", "frame", class_stack
, 1);
2093 add_com ("L", class_stack
, current_frame_command
,
2094 _("Print the current stack frame.\n"));
2095 add_com_alias ("V", "frame", class_stack
, 1);
2097 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2098 Select a stack frame without printing anything.\n\
2099 An argument specifies the frame to select.\n\
2100 It can be a stack frame number or the address of the frame.\n"));
2102 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2103 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2104 With a negative argument, print outermost -COUNT frames.\n\
2105 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2106 add_com_alias ("bt", "backtrace", class_stack
, 0);
2109 add_com_alias ("t", "backtrace", class_stack
, 0);
2110 add_com ("T", class_stack
, backtrace_full_command
, _("\
2111 Print backtrace of all stack frames, or innermost COUNT frames \n\
2112 and the values of the local variables.\n\
2113 With a negative argument, print outermost -COUNT frames.\n\
2114 Usage: T <count>\n"));
2117 add_com_alias ("where", "backtrace", class_alias
, 0);
2118 add_info ("stack", backtrace_command
,
2119 _("Backtrace of the stack, or innermost COUNT frames."));
2120 add_info_alias ("s", "stack", 1);
2121 add_info ("frame", frame_info
,
2122 _("All about selected stack frame, or frame at ADDR."));
2123 add_info_alias ("f", "frame", 1);
2124 add_info ("locals", locals_info
,
2125 _("Local variables of current stack frame."));
2126 add_info ("args", args_info
,
2127 _("Argument variables of current stack frame."));
2129 add_com ("l", class_info
, args_plus_locals_info
,
2130 _("Argument and local variables of current stack frame."));
2133 add_com ("func", class_stack
, func_command
, _("\
2134 Select the stack frame that contains <func>.\n\
2135 Usage: func <name>\n"));
2137 add_info ("catch", catch_info
,
2138 _("Exceptions that can be caught in the current stack frame."));
2140 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2141 print_frame_arguments_choices
, &print_frame_arguments
,
2142 _("Set printing of non-scalar frame arguments"),
2143 _("Show printing of non-scalar frame arguments"),
2144 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2146 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2147 &disassemble_next_line
, _("\
2148 Set whether to disassemble next source line when execution stops."), _("\
2149 Show whether to disassemble next source line when execution stops."), _("\
2150 If ON, GDB will display disassembly of the next source line when\n\
2151 execution of the program being debugged stops.\n\
2152 If AUTO (which is the default), or there's no line info to determine\n\
2153 the source line of the next instruction, display disassembly of next\n\
2154 instruction instead."),
2156 show_disassemble_next_line
,
2157 &setlist
, &showlist
);
2158 disassemble_next_line
= AUTO_BOOLEAN_AUTO
;
2161 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2162 "Specify maximum number of frames for \"backtrace\" to print by default."),
2164 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2165 The maximum number of frames for \"backtrace\" to print by default."));