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
);
648 print_frame (struct frame_info
*frame
, int print_level
,
649 enum print_what print_what
, int print_args
,
650 struct symtab_and_line sal
)
653 char *funname
= NULL
;
654 enum language funlang
= language_unknown
;
655 struct ui_stream
*stb
;
656 struct cleanup
*old_chain
, *list_chain
;
657 struct value_print_options opts
;
659 stb
= ui_out_stream_new (uiout
);
660 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
662 func
= find_pc_function (get_frame_address_in_block (frame
));
665 /* In certain pathological cases, the symtabs give the wrong
666 function (when we are in the first function in a file which
667 is compiled without debugging symbols, the previous function
668 is compiled with debugging symbols, and the "foo.o" symbol
669 that is supposed to tell us where the file with debugging
670 symbols ends has been truncated by ar because it is longer
671 than 15 characters). This also occurs if the user uses asm()
672 to create a function but not stabs for it (in a file compiled
675 So look in the minimal symbol tables as well, and if it comes
676 up with a larger address for the function use that instead.
677 I don't think this can ever cause any problems; there
678 shouldn't be any minimal symbols in the middle of a function;
679 if this is ever changed many parts of GDB will need to be
680 changed (and we'll create a find_pc_minimal_function or some
683 struct minimal_symbol
*msymbol
=
684 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
687 && (SYMBOL_VALUE_ADDRESS (msymbol
)
688 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
690 /* We also don't know anything about the function besides
691 its address and name. */
693 funname
= SYMBOL_PRINT_NAME (msymbol
);
694 funlang
= SYMBOL_LANGUAGE (msymbol
);
698 funname
= SYMBOL_PRINT_NAME (func
);
699 funlang
= SYMBOL_LANGUAGE (func
);
700 if (funlang
== language_cplus
)
702 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
703 to display the demangled name that we already have
704 stored in the symbol table, but we stored a version
705 with DMGL_PARAMS turned on, and here we don't want to
706 display parameters. So remove the parameters. */
707 char *func_only
= cp_remove_params (funname
);
711 make_cleanup (xfree
, func_only
);
718 struct minimal_symbol
*msymbol
=
719 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
723 funname
= SYMBOL_PRINT_NAME (msymbol
);
724 funlang
= SYMBOL_LANGUAGE (msymbol
);
728 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
729 get_frame_pc (frame
));
731 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
735 ui_out_text (uiout
, "#");
736 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
737 frame_relative_level (frame
));
739 get_user_print_options (&opts
);
740 if (opts
.addressprint
)
741 if (get_frame_pc (frame
) != sal
.pc
|| !sal
.symtab
742 || print_what
== LOC_AND_ADDRESS
)
744 annotate_frame_address ();
745 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
746 annotate_frame_address_end ();
747 ui_out_text (uiout
, " in ");
749 annotate_frame_function_name ();
750 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
752 ui_out_field_stream (uiout
, "func", stb
);
753 ui_out_wrap_hint (uiout
, " ");
754 annotate_frame_args ();
756 ui_out_text (uiout
, " (");
759 struct print_args_args args
;
760 struct cleanup
*args_list_chain
;
763 args
.stream
= gdb_stdout
;
764 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
765 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
766 /* FIXME: ARGS must be a list. If one argument is a string it
767 will have " that will not be properly escaped. */
768 /* Invoke ui_out_tuple_end. */
769 do_cleanups (args_list_chain
);
772 ui_out_text (uiout
, ")");
773 if (sal
.symtab
&& sal
.symtab
->filename
)
775 annotate_frame_source_begin ();
776 ui_out_wrap_hint (uiout
, " ");
777 ui_out_text (uiout
, " at ");
778 annotate_frame_source_file ();
779 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
780 if (ui_out_is_mi_like_p (uiout
))
782 const char *fullname
= symtab_to_fullname (sal
.symtab
);
783 if (fullname
!= NULL
)
784 ui_out_field_string (uiout
, "fullname", fullname
);
786 annotate_frame_source_file_end ();
787 ui_out_text (uiout
, ":");
788 annotate_frame_source_line ();
789 ui_out_field_int (uiout
, "line", sal
.line
);
790 annotate_frame_source_end ();
793 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
796 char *lib
= PC_SOLIB (get_frame_pc (frame
));
798 char *lib
= solib_name_from_address (get_frame_pc (frame
));
802 annotate_frame_where ();
803 ui_out_wrap_hint (uiout
, " ");
804 ui_out_text (uiout
, " from ");
805 ui_out_field_string (uiout
, "from", lib
);
809 /* do_cleanups will call ui_out_tuple_end() for us. */
810 do_cleanups (list_chain
);
811 ui_out_text (uiout
, "\n");
812 do_cleanups (old_chain
);
816 /* Read a frame specification in whatever the appropriate format is
817 from FRAME_EXP. Call error(), printing MESSAGE, if the
818 specification is in any way invalid (so this function never returns
819 NULL). When SEPECTED_P is non-NULL set its target to indicate that
820 the default selected frame was used. */
822 static struct frame_info
*
823 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
824 int *selected_frame_p
)
827 struct value
*args
[4];
828 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
830 if (frame_exp
== NULL
)
835 struct cleanup
*tmp_cleanup
;
841 struct cleanup
*cleanup
;
844 /* Skip leading white space, bail of EOL. */
845 while (isspace (*frame_exp
))
850 /* Parse the argument, extract it, save it. */
854 addr_string
= savestring (frame_exp
, p
- frame_exp
);
856 cleanup
= make_cleanup (xfree
, addr_string
);
858 /* NOTE: Parse and evaluate expression, but do not use
859 functions such as parse_and_eval_long or
860 parse_and_eval_address to also extract the value.
861 Instead value_as_long and value_as_address are used.
862 This avoids problems with expressions that contain
864 if (numargs
>= ARRAY_SIZE (args
))
865 error (_("Too many args in frame specification"));
866 args
[numargs
++] = parse_and_eval (addr_string
);
868 do_cleanups (cleanup
);
872 /* If no args, default to the selected frame. */
875 if (selected_frame_p
!= NULL
)
876 (*selected_frame_p
) = 1;
877 return get_selected_frame (message
);
880 /* None of the remaining use the selected frame. */
881 if (selected_frame_p
!= NULL
)
882 (*selected_frame_p
) = 0;
884 /* Assume the single arg[0] is an integer, and try using that to
885 select a frame relative to current. */
888 struct frame_info
*fid
;
889 int level
= value_as_long (args
[0]);
890 fid
= find_relative_frame (get_current_frame (), &level
);
892 /* find_relative_frame was successful */
896 /* Convert each value into a corresponding address. */
899 for (i
= 0; i
< numargs
; i
++)
900 addrs
[i
] = value_as_address (args
[i
]);
903 /* Assume that the single arg[0] is an address, use that to identify
904 a frame with a matching ID. Should this also accept stack/pc or
908 struct frame_id id
= frame_id_build_wild (addrs
[0]);
909 struct frame_info
*fid
;
911 /* If (s)he specifies the frame with an address, he deserves
912 what (s)he gets. Still, give the highest one that matches.
913 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
915 for (fid
= get_current_frame ();
917 fid
= get_prev_frame (fid
))
919 if (frame_id_eq (id
, get_frame_id (fid
)))
921 while (frame_id_eq (id
, frame_unwind_id (fid
)))
922 fid
= get_prev_frame (fid
);
928 /* We couldn't identify the frame as an existing frame, but
929 perhaps we can create one with a single argument. */
931 return create_new_frame (addrs
[0], 0);
932 else if (numargs
== 2)
933 return create_new_frame (addrs
[0], addrs
[1]);
935 error (_("Too many args in frame specification"));
938 static struct frame_info
*
939 parse_frame_specification (char *frame_exp
)
941 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
944 /* Print verbosely the selected frame or the frame at address
945 ADDR_EXP. Absolutely all information in the frame is printed. */
948 frame_info (char *addr_exp
, int from_tty
)
950 struct frame_info
*fi
;
951 struct symtab_and_line sal
;
954 struct frame_info
*calling_frame_info
;
955 int i
, count
, numregs
;
957 enum language funlang
= language_unknown
;
958 const char *pc_regname
;
959 int selected_frame_p
;
960 struct gdbarch
*gdbarch
;
961 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
963 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
964 gdbarch
= get_frame_arch (fi
);
966 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
967 is not a good name. */
968 if (gdbarch_pc_regnum (gdbarch
) >= 0)
969 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
970 easily not match that of the internal value returned by
972 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
974 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
975 architectures will often have a hardware register called "pc",
976 and that register's value, again, can easily not match
980 find_frame_sal (fi
, &sal
);
981 func
= get_frame_function (fi
);
982 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
984 s
= find_pc_symtab (get_frame_pc (fi
));
987 funname
= SYMBOL_PRINT_NAME (func
);
988 funlang
= SYMBOL_LANGUAGE (func
);
989 if (funlang
== language_cplus
)
991 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
992 to display the demangled name that we already have
993 stored in the symbol table, but we stored a version
994 with DMGL_PARAMS turned on, and here we don't want to
995 display parameters. So remove the parameters. */
996 char *func_only
= cp_remove_params (funname
);
1000 make_cleanup (xfree
, func_only
);
1006 struct minimal_symbol
*msymbol
;
1008 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1009 if (msymbol
!= NULL
)
1011 funname
= SYMBOL_PRINT_NAME (msymbol
);
1012 funlang
= SYMBOL_LANGUAGE (msymbol
);
1015 calling_frame_info
= get_prev_frame (fi
);
1017 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1019 printf_filtered (_("Stack level %d, frame at "),
1020 frame_relative_level (fi
));
1024 printf_filtered (_("Stack frame at "));
1026 fputs_filtered (paddress (get_frame_base (fi
)), gdb_stdout
);
1027 printf_filtered (":\n");
1028 printf_filtered (" %s = ", pc_regname
);
1029 fputs_filtered (paddress (get_frame_pc (fi
)), gdb_stdout
);
1034 printf_filtered (" in ");
1035 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1036 DMGL_ANSI
| DMGL_PARAMS
);
1040 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1041 puts_filtered ("; ");
1043 printf_filtered ("saved %s ", pc_regname
);
1044 fputs_filtered (paddress (frame_pc_unwind (fi
)), gdb_stdout
);
1045 printf_filtered ("\n");
1047 if (calling_frame_info
== NULL
)
1049 enum unwind_stop_reason reason
;
1051 reason
= get_frame_unwind_stop_reason (fi
);
1052 if (reason
!= UNWIND_NO_REASON
)
1053 printf_filtered (_(" Outermost frame: %s\n"),
1054 frame_stop_reason_string (reason
));
1057 if (calling_frame_info
)
1059 printf_filtered (" called by frame at ");
1060 fputs_filtered (paddress (get_frame_base (calling_frame_info
)),
1063 if (get_next_frame (fi
) && calling_frame_info
)
1064 puts_filtered (",");
1066 if (get_next_frame (fi
))
1068 printf_filtered (" caller of frame at ");
1069 fputs_filtered (paddress (get_frame_base (get_next_frame (fi
))),
1072 if (get_next_frame (fi
) || calling_frame_info
)
1073 puts_filtered ("\n");
1076 printf_filtered (" source language %s.\n",
1077 language_str (s
->language
));
1080 /* Address of the argument list for this frame, or 0. */
1081 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1082 /* Number of args for this frame, or -1 if unknown. */
1086 printf_filtered (" Arglist at unknown address.\n");
1089 printf_filtered (" Arglist at ");
1090 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1091 printf_filtered (",");
1093 if (!gdbarch_frame_num_args_p (gdbarch
))
1096 puts_filtered (" args: ");
1100 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1101 gdb_assert (numargs
>= 0);
1103 puts_filtered (" no args.");
1104 else if (numargs
== 1)
1105 puts_filtered (" 1 arg: ");
1107 printf_filtered (" %d args: ", numargs
);
1109 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1110 puts_filtered ("\n");
1114 /* Address of the local variables for this frame, or 0. */
1115 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1118 printf_filtered (" Locals at unknown address,");
1121 printf_filtered (" Locals at ");
1122 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1123 printf_filtered (",");
1127 /* Print as much information as possible on the location of all the
1130 enum lval_type lval
;
1138 /* The sp is special; what's displayed isn't the save address, but
1139 the value of the previous frame's sp. This is a legacy thing,
1140 at one stage the frame cached the previous frame's SP instead
1141 of its address, hence it was easiest to just display the cached
1143 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1145 /* Find out the location of the saved stack pointer with out
1146 actually evaluating it. */
1147 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1148 &optimized
, &lval
, &addr
,
1150 if (!optimized
&& lval
== not_lval
)
1152 gdb_byte value
[MAX_REGISTER_SIZE
];
1154 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1155 &optimized
, &lval
, &addr
,
1157 /* NOTE: cagney/2003-05-22: This is assuming that the
1158 stack pointer was packed as an unsigned integer. That
1159 may or may not be valid. */
1160 sp
= extract_unsigned_integer (value
,
1161 register_size (gdbarch
,
1162 gdbarch_sp_regnum (gdbarch
)));
1163 printf_filtered (" Previous frame's sp is ");
1164 fputs_filtered (paddress (sp
), gdb_stdout
);
1165 printf_filtered ("\n");
1168 else if (!optimized
&& lval
== lval_memory
)
1170 printf_filtered (" Previous frame's sp at ");
1171 fputs_filtered (paddress (addr
), gdb_stdout
);
1172 printf_filtered ("\n");
1175 else if (!optimized
&& lval
== lval_register
)
1177 printf_filtered (" Previous frame's sp in %s\n",
1178 gdbarch_register_name (gdbarch
, realnum
));
1181 /* else keep quiet. */
1185 numregs
= gdbarch_num_regs (gdbarch
)
1186 + gdbarch_num_pseudo_regs (gdbarch
);
1187 for (i
= 0; i
< numregs
; i
++)
1188 if (i
!= gdbarch_sp_regnum (gdbarch
)
1189 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1191 /* Find out the location of the saved register without
1192 fetching the corresponding value. */
1193 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1195 /* For moment, only display registers that were saved on the
1197 if (!optimized
&& lval
== lval_memory
)
1200 puts_filtered (" Saved registers:\n ");
1202 puts_filtered (",");
1204 printf_filtered (" %s at ",
1205 gdbarch_register_name (gdbarch
, i
));
1206 fputs_filtered (paddress (addr
), gdb_stdout
);
1210 if (count
|| need_nl
)
1211 puts_filtered ("\n");
1214 do_cleanups (back_to
);
1217 /* Print briefly all stack frames or just the innermost COUNT_EXP
1221 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1223 struct frame_info
*fi
;
1226 struct frame_info
*trailing
;
1229 if (!target_has_stack
)
1230 error (_("No stack."));
1232 /* The following code must do two things. First, it must set the
1233 variable TRAILING to the frame from which we should start
1234 printing. Second, it must set the variable count to the number
1235 of frames which we should print, or -1 if all of them. */
1236 trailing
= get_current_frame ();
1238 /* The target can be in a state where there is no valid frames
1239 (e.g., just connected). */
1240 if (trailing
== NULL
)
1241 error (_("No stack."));
1246 count
= parse_and_eval_long (count_exp
);
1249 struct frame_info
*current
;
1254 while (current
&& count
--)
1257 current
= get_prev_frame (current
);
1260 /* Will stop when CURRENT reaches the top of the stack.
1261 TRAILING will be COUNT below it. */
1265 trailing
= get_prev_frame (trailing
);
1266 current
= get_prev_frame (current
);
1278 struct partial_symtab
*ps
;
1280 /* Read in symbols for all of the frames. Need to do this in a
1281 separate pass so that "Reading in symbols for xxx" messages
1282 don't screw up the appearance of the backtrace. Also if
1283 people have strong opinions against reading symbols for
1284 backtrace this may have to be an option. */
1286 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1289 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1291 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in. */
1295 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1299 /* Don't use print_stack_frame; if an error() occurs it probably
1300 means further attempts to backtrace would fail (on the other
1301 hand, perhaps the code does or could be fixed to make sure
1302 the frame->prev field gets set to NULL in that case). */
1303 print_frame_info (fi
, 1, LOCATION
, 1);
1305 print_frame_local_vars (fi
, 1, gdb_stdout
);
1307 /* Save the last frame to check for error conditions. */
1311 /* If we've stopped before the end, mention that. */
1313 printf_filtered (_("(More stack frames follow...)\n"));
1315 /* If we've run out of frames, and the reason appears to be an error
1316 condition, print it. */
1317 if (fi
== NULL
&& trailing
!= NULL
)
1319 enum unwind_stop_reason reason
;
1321 reason
= get_frame_unwind_stop_reason (trailing
);
1322 if (reason
> UNWIND_FIRST_ERROR
)
1323 printf_filtered (_("Backtrace stopped: %s\n"),
1324 frame_stop_reason_string (reason
));
1328 struct backtrace_command_args
1335 /* Stub for catch_errors. */
1338 backtrace_command_stub (void *data
)
1340 struct backtrace_command_args
*args
= data
;
1341 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1346 backtrace_command (char *arg
, int from_tty
)
1348 struct cleanup
*old_chain
= NULL
;
1349 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1350 struct backtrace_command_args btargs
;
1357 argv
= gdb_buildargv (arg
);
1358 old_chain
= make_cleanup_freeargv (argv
);
1360 for (i
= 0; argv
[i
]; i
++)
1364 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1365 argv
[i
][j
] = tolower (argv
[i
][j
]);
1367 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1368 fulltrace_arg
= argc
;
1371 arglen
+= strlen (argv
[i
]);
1376 if (fulltrace_arg
>= 0)
1380 arg
= xmalloc (arglen
+ 1);
1381 memset (arg
, 0, arglen
+ 1);
1382 for (i
= 0; i
< (argc
+ 1); i
++)
1384 if (i
!= fulltrace_arg
)
1386 strcat (arg
, argv
[i
]);
1396 btargs
.count_exp
= arg
;
1397 btargs
.show_locals
= (fulltrace_arg
>= 0);
1398 btargs
.from_tty
= from_tty
;
1399 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1401 if (fulltrace_arg
>= 0 && arglen
> 0)
1405 do_cleanups (old_chain
);
1409 backtrace_full_command (char *arg
, int from_tty
)
1411 struct backtrace_command_args btargs
;
1412 btargs
.count_exp
= arg
;
1413 btargs
.show_locals
= 1;
1414 btargs
.from_tty
= from_tty
;
1415 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1419 /* Print the local variables of a block B active in FRAME on STREAM.
1420 Return 1 if any variables were printed; 0 otherwise. */
1423 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1424 int num_tabs
, struct ui_file
*stream
)
1426 struct dict_iterator iter
;
1428 int values_printed
= 0;
1431 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1433 switch (SYMBOL_CLASS (sym
))
1439 if (SYMBOL_IS_ARGUMENT (sym
))
1442 print_variable_and_value (NULL
, sym
, frame
, stream
, 4 * num_tabs
);
1446 /* Ignore symbols which are not locals. */
1451 return values_printed
;
1454 /* Same, but print labels. */
1457 print_block_frame_labels (struct block
*b
, int *have_default
,
1458 struct ui_file
*stream
)
1460 struct dict_iterator iter
;
1462 int values_printed
= 0;
1464 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1466 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1472 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1474 struct symtab_and_line sal
;
1475 struct value_print_options opts
;
1476 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1478 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1479 get_user_print_options (&opts
);
1480 if (opts
.addressprint
)
1482 fprintf_filtered (stream
, " ");
1483 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym
)), stream
);
1485 fprintf_filtered (stream
, " in file %s, line %d\n",
1486 sal
.symtab
->filename
, sal
.line
);
1490 return values_printed
;
1493 /* Print on STREAM all the local variables in frame FRAME, including
1494 all the blocks active in that frame at its current PC.
1496 Returns 1 if the job was done, or 0 if nothing was printed because
1497 we have no info on the function running in FRAME. */
1500 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1501 struct ui_file
*stream
)
1503 struct block
*block
= get_frame_block (frame
, 0);
1504 int values_printed
= 0;
1508 fprintf_filtered (stream
, "No symbol table info available.\n");
1514 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1516 /* After handling the function's top-level block, stop. Don't
1517 continue to its superblock, the block of per-file symbols. */
1518 if (BLOCK_FUNCTION (block
))
1520 block
= BLOCK_SUPERBLOCK (block
);
1523 if (!values_printed
)
1524 fprintf_filtered (stream
, _("No locals.\n"));
1527 /* Same, but print labels. */
1530 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1531 struct ui_file
*stream
)
1534 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1536 struct blockvector
*bl
;
1537 struct block
*block
= get_frame_block (frame
, 0);
1538 int values_printed
= 0;
1539 int index
, have_default
= 0;
1540 char *blocks_printed
;
1541 CORE_ADDR pc
= get_frame_pc (frame
);
1545 fprintf_filtered (stream
, "No symbol table info available.\n");
1549 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1550 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1551 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1555 CORE_ADDR end
= BLOCK_END (block
) - 4;
1558 if (bl
!= blockvector_for_pc (end
, &index
))
1559 error (_("blockvector blotch"));
1560 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1561 error (_("blockvector botch"));
1562 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1565 /* Don't print out blocks that have gone by. */
1566 while (index
< last_index
1567 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1570 while (index
< last_index
1571 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1573 if (blocks_printed
[index
] == 0)
1575 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
),
1576 &have_default
, stream
))
1578 blocks_printed
[index
] = 1;
1584 if (values_printed
&& this_level_only
)
1587 /* After handling the function's top-level block, stop. Don't
1588 continue to its superblock, the block of per-file symbols. */
1589 if (BLOCK_FUNCTION (block
))
1591 block
= BLOCK_SUPERBLOCK (block
);
1594 if (!values_printed
&& !this_level_only
)
1595 fprintf_filtered (stream
, _("No catches.\n"));
1600 locals_info (char *args
, int from_tty
)
1602 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1607 catch_info (char *ignore
, int from_tty
)
1609 struct symtab_and_line
*sal
;
1611 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1612 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1617 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1619 struct symbol
*func
= get_frame_function (frame
);
1621 struct dict_iterator iter
;
1622 struct symbol
*sym
, *sym2
;
1623 int values_printed
= 0;
1627 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1631 b
= SYMBOL_BLOCK_VALUE (func
);
1632 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1634 /* Don't worry about things which aren't arguments. */
1635 if (SYMBOL_IS_ARGUMENT (sym
))
1639 /* We have to look up the symbol because arguments can have
1640 two entries (one a parameter, one a local) and the one we
1641 want is the local, which lookup_symbol will find for us.
1642 This includes gcc1 (not gcc2) on the sparc when passing a
1643 small structure and gcc2 when the argument type is float
1644 and it is passed as a double and converted to float by
1645 the prologue (in the latter case the type of the LOC_ARG
1646 symbol is double and the type of the LOC_LOCAL symbol is
1647 float). There are also LOC_ARG/LOC_REGISTER pairs which
1648 are not combined in symbol-reading. */
1650 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1651 b
, VAR_DOMAIN
, NULL
);
1652 print_variable_and_value (SYMBOL_PRINT_NAME (sym
), sym2
,
1657 if (!values_printed
)
1658 fprintf_filtered (stream
, _("No arguments.\n"));
1662 args_info (char *ignore
, int from_tty
)
1664 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1670 args_plus_locals_info (char *ignore
, int from_tty
)
1672 args_info (ignore
, from_tty
);
1673 locals_info (ignore
, from_tty
);
1677 /* Select frame FRAME. Also print the stack frame and show the source
1678 if this is the tui version. */
1680 select_and_print_frame (struct frame_info
*frame
)
1682 select_frame (frame
);
1684 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1687 /* Return the symbol-block in which the selected frame is executing.
1688 Can return zero under various legitimate circumstances.
1690 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1691 code address within the block returned. We use this to decide
1692 which macros are in scope. */
1695 get_selected_block (CORE_ADDR
*addr_in_block
)
1697 if (!target_has_stack
)
1700 if (is_exited (inferior_ptid
))
1703 if (is_executing (inferior_ptid
))
1706 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1709 /* Find a frame a certain number of levels away from FRAME.
1710 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1711 Positive means go to earlier frames (up); negative, the reverse.
1712 The int that contains the number of levels is counted toward
1713 zero as the frames for those levels are found.
1714 If the top or bottom frame is reached, that frame is returned,
1715 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1716 how much farther the original request asked to go. */
1719 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1721 /* Going up is simple: just call get_prev_frame enough times or
1722 until the initial frame is reached. */
1723 while (*level_offset_ptr
> 0)
1725 struct frame_info
*prev
= get_prev_frame (frame
);
1728 (*level_offset_ptr
)--;
1732 /* Going down is just as simple. */
1733 while (*level_offset_ptr
< 0)
1735 struct frame_info
*next
= get_next_frame (frame
);
1738 (*level_offset_ptr
)++;
1745 /* The "select_frame" command. With no argument this is a NOP.
1746 Select the frame at level LEVEL_EXP if it is a valid level.
1747 Otherwise, treat LEVEL_EXP as an address expression and select it.
1749 See parse_frame_specification for more info on proper frame
1753 select_frame_command (char *level_exp
, int from_tty
)
1755 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1758 /* The "frame" command. With no argument, print the selected frame
1759 briefly. With an argument, behave like select_frame and then print
1760 the selected frame. */
1763 frame_command (char *level_exp
, int from_tty
)
1765 select_frame_command (level_exp
, from_tty
);
1766 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1769 /* The XDB Compatibility command to print the current frame. */
1772 current_frame_command (char *level_exp
, int from_tty
)
1774 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1777 /* Select the frame up one or COUNT_EXP stack levels from the
1778 previously selected frame, and print it briefly. */
1781 up_silently_base (char *count_exp
)
1783 struct frame_info
*frame
;
1787 count
= parse_and_eval_long (count_exp
);
1789 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1790 if (count
!= 0 && count_exp
== NULL
)
1791 error (_("Initial frame selected; you cannot go up."));
1792 select_frame (frame
);
1796 up_silently_command (char *count_exp
, int from_tty
)
1798 up_silently_base (count_exp
);
1802 up_command (char *count_exp
, int from_tty
)
1804 up_silently_base (count_exp
);
1805 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1808 /* Select the frame down one or COUNT_EXP stack levels from the previously
1809 selected frame, and print it briefly. */
1812 down_silently_base (char *count_exp
)
1814 struct frame_info
*frame
;
1817 count
= -parse_and_eval_long (count_exp
);
1819 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1820 if (count
!= 0 && count_exp
== NULL
)
1822 /* We only do this if COUNT_EXP is not specified. That way
1823 "down" means to really go down (and let me know if that is
1824 impossible), but "down 9999" can be used to mean go all the
1825 way down without getting an error. */
1827 error (_("Bottom (innermost) frame selected; you cannot go down."));
1830 select_frame (frame
);
1834 down_silently_command (char *count_exp
, int from_tty
)
1836 down_silently_base (count_exp
);
1840 down_command (char *count_exp
, int from_tty
)
1842 down_silently_base (count_exp
);
1843 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1848 return_command (char *retval_exp
, int from_tty
)
1850 struct frame_info
*thisframe
;
1851 struct symbol
*thisfun
;
1852 struct value
*return_value
= NULL
;
1853 const char *query_prefix
= "";
1855 thisframe
= get_selected_frame ("No selected frame.");
1856 thisfun
= get_frame_function (thisframe
);
1858 /* Compute the return value. If the computation triggers an error,
1859 let it bail. If the return type can't be handled, set
1860 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1864 struct expression
*retval_expr
= parse_expression (retval_exp
);
1865 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1866 struct type
*return_type
= NULL
;
1868 /* Compute the return value. Should the computation fail, this
1869 call throws an error. */
1870 return_value
= evaluate_expression (retval_expr
);
1872 /* Cast return value to the return type of the function. Should
1873 the cast fail, this call throws an error. */
1874 if (thisfun
!= NULL
)
1875 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1876 if (return_type
== NULL
)
1878 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1879 error (_("Return value type not available for selected "
1881 "Please use an explicit cast of the value to return."));
1882 return_type
= value_type (return_value
);
1884 do_cleanups (old_chain
);
1885 CHECK_TYPEDEF (return_type
);
1886 return_value
= value_cast (return_type
, return_value
);
1888 /* Make sure the value is fully evaluated. It may live in the
1889 stack frame we're about to pop. */
1890 if (value_lazy (return_value
))
1891 value_fetch_lazy (return_value
);
1893 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1894 /* If the return-type is "void", don't try to find the
1895 return-value's location. However, do still evaluate the
1896 return expression so that, even when the expression result
1897 is discarded, side effects such as "return i++" still
1899 return_value
= NULL
;
1900 else if (thisfun
!= NULL
1901 && using_struct_return (SYMBOL_TYPE (thisfun
), return_type
))
1904 The location at which to store the function's return value is unknown.\n\
1905 If you continue, the return value that you specified will be ignored.\n";
1906 return_value
= NULL
;
1910 /* Does an interactive user really want to do this? Include
1911 information, such as how well GDB can handle the return value, in
1912 the query message. */
1916 if (thisfun
== NULL
)
1917 confirmed
= query (_("%sMake selected stack frame return now? "),
1920 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1921 SYMBOL_PRINT_NAME (thisfun
));
1923 error (_("Not confirmed"));
1926 /* Discard the selected frame and all frames inner-to it. */
1927 frame_pop (get_selected_frame (NULL
));
1929 /* Store RETURN_VALUE in the just-returned register set. */
1930 if (return_value
!= NULL
)
1932 struct type
*return_type
= value_type (return_value
);
1933 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1934 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
1936 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
1938 == RETURN_VALUE_REGISTER_CONVENTION
);
1939 gdbarch_return_value (gdbarch
, func_type
, return_type
,
1940 get_current_regcache (), NULL
/*read*/,
1941 value_contents (return_value
) /*write*/);
1944 /* If we are at the end of a call dummy now, pop the dummy frame
1946 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1947 frame_pop (get_current_frame ());
1949 /* If interactive, print the frame that is now current. */
1951 frame_command ("0", 1);
1953 select_frame_command ("0", 0);
1956 /* Sets the scope to input function name, provided that the function
1957 is within the current stack frame */
1959 struct function_bounds
1961 CORE_ADDR low
, high
;
1965 func_command (char *arg
, int from_tty
)
1967 struct frame_info
*frame
;
1969 struct symtabs_and_lines sals
;
1972 struct function_bounds
*func_bounds
= NULL
;
1977 frame
= parse_frame_specification ("0");
1978 sals
= decode_line_spec (arg
, 1);
1979 func_bounds
= (struct function_bounds
*) xmalloc (
1980 sizeof (struct function_bounds
) * sals
.nelts
);
1981 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1983 if (sals
.sals
[i
].pc
== 0
1984 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
1985 &func_bounds
[i
].low
,
1986 &func_bounds
[i
].high
) == 0)
1988 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
1994 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1995 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
1996 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2000 frame
= find_relative_frame (frame
, &level
);
2003 while (!found
&& level
== 0);
2006 xfree (func_bounds
);
2009 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2010 else if (frame
!= get_selected_frame (NULL
))
2011 select_and_print_frame (frame
);
2014 /* Gets the language of the current frame. */
2017 get_frame_language (void)
2019 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2023 /* We determine the current frame language by looking up its
2024 associated symtab. To retrieve this symtab, we use the frame
2025 PC. However we cannot use the frame PC as is, because it
2026 usually points to the instruction following the "call", which
2027 is sometimes the first instruction of another function. So
2028 we rely on get_frame_address_in_block(), it provides us with
2029 a PC that is guaranteed to be inside the frame's code
2031 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2032 struct symtab
*s
= find_pc_symtab (pc
);
2038 return language_unknown
;
2042 /* Provide a prototype to silence -Wmissing-prototypes. */
2043 void _initialize_stack (void);
2046 _initialize_stack (void)
2049 backtrace_limit
= 30;
2052 add_com ("return", class_stack
, return_command
, _("\
2053 Make selected stack frame return to its caller.\n\
2054 Control remains in the debugger, but when you continue\n\
2055 execution will resume in the frame above the one now selected.\n\
2056 If an argument is given, it is an expression for the value to return."));
2058 add_com ("up", class_stack
, up_command
, _("\
2059 Select and print stack frame that called this one.\n\
2060 An argument says how many frames up to go."));
2061 add_com ("up-silently", class_support
, up_silently_command
, _("\
2062 Same as the `up' command, but does not print anything.\n\
2063 This is useful in command scripts."));
2065 add_com ("down", class_stack
, down_command
, _("\
2066 Select and print stack frame called by this one.\n\
2067 An argument says how many frames down to go."));
2068 add_com_alias ("do", "down", class_stack
, 1);
2069 add_com_alias ("dow", "down", class_stack
, 1);
2070 add_com ("down-silently", class_support
, down_silently_command
, _("\
2071 Same as the `down' command, but does not print anything.\n\
2072 This is useful in command scripts."));
2074 add_com ("frame", class_stack
, frame_command
, _("\
2075 Select and print a stack frame.\n\
2076 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2077 An argument specifies the frame to select.\n\
2078 It can be a stack frame number or the address of the frame.\n\
2079 With argument, nothing is printed if input is coming from\n\
2080 a command file or a user-defined command."));
2082 add_com_alias ("f", "frame", class_stack
, 1);
2086 add_com ("L", class_stack
, current_frame_command
,
2087 _("Print the current stack frame.\n"));
2088 add_com_alias ("V", "frame", class_stack
, 1);
2090 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2091 Select a stack frame without printing anything.\n\
2092 An argument specifies the frame to select.\n\
2093 It can be a stack frame number or the address of the frame.\n"));
2095 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2096 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2097 With a negative argument, print outermost -COUNT frames.\n\
2098 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2099 add_com_alias ("bt", "backtrace", class_stack
, 0);
2102 add_com_alias ("t", "backtrace", class_stack
, 0);
2103 add_com ("T", class_stack
, backtrace_full_command
, _("\
2104 Print backtrace of all stack frames, or innermost COUNT frames \n\
2105 and the values of the local variables.\n\
2106 With a negative argument, print outermost -COUNT frames.\n\
2107 Usage: T <count>\n"));
2110 add_com_alias ("where", "backtrace", class_alias
, 0);
2111 add_info ("stack", backtrace_command
,
2112 _("Backtrace of the stack, or innermost COUNT frames."));
2113 add_info_alias ("s", "stack", 1);
2114 add_info ("frame", frame_info
,
2115 _("All about selected stack frame, or frame at ADDR."));
2116 add_info_alias ("f", "frame", 1);
2117 add_info ("locals", locals_info
,
2118 _("Local variables of current stack frame."));
2119 add_info ("args", args_info
,
2120 _("Argument variables of current stack frame."));
2122 add_com ("l", class_info
, args_plus_locals_info
,
2123 _("Argument and local variables of current stack frame."));
2126 add_com ("func", class_stack
, func_command
, _("\
2127 Select the stack frame that contains <func>.\n\
2128 Usage: func <name>\n"));
2130 add_info ("catch", catch_info
,
2131 _("Exceptions that can be caught in the current stack frame."));
2133 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2134 print_frame_arguments_choices
, &print_frame_arguments
,
2135 _("Set printing of non-scalar frame arguments"),
2136 _("Show printing of non-scalar frame arguments"),
2137 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2139 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2140 &disassemble_next_line
, _("\
2141 Set whether to disassemble next source line when execution stops."), _("\
2142 Show whether to disassemble next source line when execution stops."), _("\
2143 If ON, GDB will display disassembly of the next source line when\n\
2144 execution of the program being debugged stops.\n\
2145 If AUTO (which is the default), or there's no line info to determine\n\
2146 the source line of the next instruction, display disassembly of next\n\
2147 instruction instead."),
2149 show_disassemble_next_line
,
2150 &setlist
, &showlist
);
2151 disassemble_next_line
= AUTO_BOOLEAN_AUTO
;
2154 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2155 "Specify maximum number of frames for \"backtrace\" to print by default."),
2157 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2158 The maximum number of frames for \"backtrace\" to print by default."));