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
= "scalars";
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
);
510 /* If an exception was thrown while doing the disassembly, print
511 the error message, to give the user a clue of what happened. */
512 if (exception
.reason
== RETURN_ERROR
)
513 exception_print (gdb_stderr
, exception
);
516 /* Print information about frame FRAME. The output is format according
517 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
520 SRC_LINE: Print only source line.
521 LOCATION: Print only location.
522 LOC_AND_SRC: Print location and source line.
524 Used in "where" output, and to emit breakpoint or step
528 print_frame_info (struct frame_info
*frame
, int print_level
,
529 enum print_what print_what
, int print_args
)
531 struct symtab_and_line sal
;
535 if (get_frame_type (frame
) == DUMMY_FRAME
536 || get_frame_type (frame
) == SIGTRAMP_FRAME
)
538 struct cleanup
*uiout_cleanup
539 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
541 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
542 get_frame_pc (frame
));
544 /* Do this regardless of SOURCE because we don't have any source
545 to list for this frame. */
548 ui_out_text (uiout
, "#");
549 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
550 frame_relative_level (frame
));
552 if (ui_out_is_mi_like_p (uiout
))
554 annotate_frame_address ();
555 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
556 annotate_frame_address_end ();
559 if (get_frame_type (frame
) == DUMMY_FRAME
)
561 annotate_function_call ();
562 ui_out_field_string (uiout
, "func", "<function called from gdb>");
564 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
566 annotate_signal_handler_caller ();
567 ui_out_field_string (uiout
, "func", "<signal handler called>");
569 ui_out_text (uiout
, "\n");
570 annotate_frame_end ();
572 do_cleanups (uiout_cleanup
);
576 /* If FRAME is not the innermost frame, that normally means that
577 FRAME->pc points to *after* the call instruction, and we want to
578 get the line containing the call, never the next line. But if
579 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
580 next frame was not entered as the result of a call, and we want
581 to get the line containing FRAME->pc. */
582 find_frame_sal (frame
, &sal
);
584 location_print
= (print_what
== LOCATION
585 || print_what
== LOC_AND_ADDRESS
586 || print_what
== SRC_AND_LOC
);
588 if (location_print
|| !sal
.symtab
)
589 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
591 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
593 /* If disassemble-next-line is set to auto or on and doesn't have
594 the line debug messages for $pc, output the next instruction. */
595 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
596 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
597 && source_print
&& !sal
.symtab
)
598 do_gdb_disassembly (1, get_frame_pc (frame
), get_frame_pc (frame
) + 1);
600 if (source_print
&& sal
.symtab
)
603 int mid_statement
= ((print_what
== SRC_LINE
)
604 && (get_frame_pc (frame
) != sal
.pc
));
606 if (annotation_level
)
607 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
608 get_frame_pc (frame
));
611 if (deprecated_print_frame_info_listing_hook
)
612 deprecated_print_frame_info_listing_hook (sal
.symtab
,
617 struct value_print_options opts
;
618 get_user_print_options (&opts
);
619 /* We used to do this earlier, but that is clearly
620 wrong. This function is used by many different
621 parts of gdb, including normal_stop in infrun.c,
622 which uses this to print out the current PC
623 when we stepi/nexti into the middle of a source
624 line. Only the command line really wants this
625 behavior. Other UIs probably would like the
626 ability to decide for themselves if it is desired. */
627 if (opts
.addressprint
&& mid_statement
)
629 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
630 ui_out_text (uiout
, "\t");
633 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
637 /* If disassemble-next-line is set to on and there is line debug
638 messages, output assembly codes for next line. */
639 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
640 do_gdb_disassembly (-1, get_frame_pc (frame
), sal
.end
);
643 if (print_what
!= LOCATION
)
644 set_default_breakpoint (1, get_frame_pc (frame
), sal
.symtab
, sal
.line
);
646 annotate_frame_end ();
648 gdb_flush (gdb_stdout
);
651 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
654 find_frame_funname (struct frame_info
*frame
, char **funname
,
655 enum language
*funlang
)
660 *funlang
= language_unknown
;
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
);
710 *funname
= func_only
;
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
);
730 print_frame (struct frame_info
*frame
, int print_level
,
731 enum print_what print_what
, int print_args
,
732 struct symtab_and_line sal
)
734 char *funname
= NULL
;
735 enum language funlang
= language_unknown
;
736 struct ui_stream
*stb
;
737 struct cleanup
*old_chain
, *list_chain
;
738 struct value_print_options opts
;
740 stb
= ui_out_stream_new (uiout
);
741 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
743 find_frame_funname (frame
, &funname
, &funlang
);
745 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
746 get_frame_pc (frame
));
748 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
752 ui_out_text (uiout
, "#");
753 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
754 frame_relative_level (frame
));
756 get_user_print_options (&opts
);
757 if (opts
.addressprint
)
758 if (get_frame_pc (frame
) != sal
.pc
|| !sal
.symtab
759 || print_what
== LOC_AND_ADDRESS
)
761 annotate_frame_address ();
762 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
763 annotate_frame_address_end ();
764 ui_out_text (uiout
, " in ");
766 annotate_frame_function_name ();
767 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
769 ui_out_field_stream (uiout
, "func", stb
);
770 ui_out_wrap_hint (uiout
, " ");
771 annotate_frame_args ();
773 ui_out_text (uiout
, " (");
776 struct print_args_args args
;
777 struct cleanup
*args_list_chain
;
779 args
.func
= find_pc_function (get_frame_address_in_block (frame
));
780 args
.stream
= gdb_stdout
;
781 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
782 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
783 /* FIXME: ARGS must be a list. If one argument is a string it
784 will have " that will not be properly escaped. */
785 /* Invoke ui_out_tuple_end. */
786 do_cleanups (args_list_chain
);
789 ui_out_text (uiout
, ")");
790 if (sal
.symtab
&& sal
.symtab
->filename
)
792 annotate_frame_source_begin ();
793 ui_out_wrap_hint (uiout
, " ");
794 ui_out_text (uiout
, " at ");
795 annotate_frame_source_file ();
796 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
797 if (ui_out_is_mi_like_p (uiout
))
799 const char *fullname
= symtab_to_fullname (sal
.symtab
);
800 if (fullname
!= NULL
)
801 ui_out_field_string (uiout
, "fullname", fullname
);
803 annotate_frame_source_file_end ();
804 ui_out_text (uiout
, ":");
805 annotate_frame_source_line ();
806 ui_out_field_int (uiout
, "line", sal
.line
);
807 annotate_frame_source_end ();
810 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
813 char *lib
= PC_SOLIB (get_frame_pc (frame
));
815 char *lib
= solib_name_from_address (get_frame_pc (frame
));
819 annotate_frame_where ();
820 ui_out_wrap_hint (uiout
, " ");
821 ui_out_text (uiout
, " from ");
822 ui_out_field_string (uiout
, "from", lib
);
826 /* do_cleanups will call ui_out_tuple_end() for us. */
827 do_cleanups (list_chain
);
828 ui_out_text (uiout
, "\n");
829 do_cleanups (old_chain
);
833 /* Read a frame specification in whatever the appropriate format is
834 from FRAME_EXP. Call error(), printing MESSAGE, if the
835 specification is in any way invalid (so this function never returns
836 NULL). When SEPECTED_P is non-NULL set its target to indicate that
837 the default selected frame was used. */
839 static struct frame_info
*
840 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
841 int *selected_frame_p
)
844 struct value
*args
[4];
845 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
847 if (frame_exp
== NULL
)
852 struct cleanup
*tmp_cleanup
;
858 struct cleanup
*cleanup
;
861 /* Skip leading white space, bail of EOL. */
862 while (isspace (*frame_exp
))
867 /* Parse the argument, extract it, save it. */
871 addr_string
= savestring (frame_exp
, p
- frame_exp
);
873 cleanup
= make_cleanup (xfree
, addr_string
);
875 /* NOTE: Parse and evaluate expression, but do not use
876 functions such as parse_and_eval_long or
877 parse_and_eval_address to also extract the value.
878 Instead value_as_long and value_as_address are used.
879 This avoids problems with expressions that contain
881 if (numargs
>= ARRAY_SIZE (args
))
882 error (_("Too many args in frame specification"));
883 args
[numargs
++] = parse_and_eval (addr_string
);
885 do_cleanups (cleanup
);
889 /* If no args, default to the selected frame. */
892 if (selected_frame_p
!= NULL
)
893 (*selected_frame_p
) = 1;
894 return get_selected_frame (message
);
897 /* None of the remaining use the selected frame. */
898 if (selected_frame_p
!= NULL
)
899 (*selected_frame_p
) = 0;
901 /* Assume the single arg[0] is an integer, and try using that to
902 select a frame relative to current. */
905 struct frame_info
*fid
;
906 int level
= value_as_long (args
[0]);
907 fid
= find_relative_frame (get_current_frame (), &level
);
909 /* find_relative_frame was successful */
913 /* Convert each value into a corresponding address. */
916 for (i
= 0; i
< numargs
; i
++)
917 addrs
[i
] = value_as_address (args
[i
]);
920 /* Assume that the single arg[0] is an address, use that to identify
921 a frame with a matching ID. Should this also accept stack/pc or
925 struct frame_id id
= frame_id_build_wild (addrs
[0]);
926 struct frame_info
*fid
;
928 /* If (s)he specifies the frame with an address, he deserves
929 what (s)he gets. Still, give the highest one that matches.
930 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
932 for (fid
= get_current_frame ();
934 fid
= get_prev_frame (fid
))
936 if (frame_id_eq (id
, get_frame_id (fid
)))
938 while (frame_id_eq (id
, frame_unwind_id (fid
)))
939 fid
= get_prev_frame (fid
);
945 /* We couldn't identify the frame as an existing frame, but
946 perhaps we can create one with a single argument. */
948 return create_new_frame (addrs
[0], 0);
949 else if (numargs
== 2)
950 return create_new_frame (addrs
[0], addrs
[1]);
952 error (_("Too many args in frame specification"));
955 static struct frame_info
*
956 parse_frame_specification (char *frame_exp
)
958 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
961 /* Print verbosely the selected frame or the frame at address
962 ADDR_EXP. Absolutely all information in the frame is printed. */
965 frame_info (char *addr_exp
, int from_tty
)
967 struct frame_info
*fi
;
968 struct symtab_and_line sal
;
971 struct frame_info
*calling_frame_info
;
972 int i
, count
, numregs
;
974 enum language funlang
= language_unknown
;
975 const char *pc_regname
;
976 int selected_frame_p
;
977 struct gdbarch
*gdbarch
;
978 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
980 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
981 gdbarch
= get_frame_arch (fi
);
983 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
984 is not a good name. */
985 if (gdbarch_pc_regnum (gdbarch
) >= 0)
986 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
987 easily not match that of the internal value returned by
989 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
991 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
992 architectures will often have a hardware register called "pc",
993 and that register's value, again, can easily not match
997 find_frame_sal (fi
, &sal
);
998 func
= get_frame_function (fi
);
999 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1001 s
= find_pc_symtab (get_frame_pc (fi
));
1004 funname
= SYMBOL_PRINT_NAME (func
);
1005 funlang
= SYMBOL_LANGUAGE (func
);
1006 if (funlang
== language_cplus
)
1008 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1009 to display the demangled name that we already have
1010 stored in the symbol table, but we stored a version
1011 with DMGL_PARAMS turned on, and here we don't want to
1012 display parameters. So remove the parameters. */
1013 char *func_only
= cp_remove_params (funname
);
1016 funname
= func_only
;
1017 make_cleanup (xfree
, func_only
);
1023 struct minimal_symbol
*msymbol
;
1025 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1026 if (msymbol
!= NULL
)
1028 funname
= SYMBOL_PRINT_NAME (msymbol
);
1029 funlang
= SYMBOL_LANGUAGE (msymbol
);
1032 calling_frame_info
= get_prev_frame (fi
);
1034 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1036 printf_filtered (_("Stack level %d, frame at "),
1037 frame_relative_level (fi
));
1041 printf_filtered (_("Stack frame at "));
1043 fputs_filtered (paddress (get_frame_base (fi
)), gdb_stdout
);
1044 printf_filtered (":\n");
1045 printf_filtered (" %s = ", pc_regname
);
1046 fputs_filtered (paddress (get_frame_pc (fi
)), gdb_stdout
);
1051 printf_filtered (" in ");
1052 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1053 DMGL_ANSI
| DMGL_PARAMS
);
1057 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1058 puts_filtered ("; ");
1060 printf_filtered ("saved %s ", pc_regname
);
1061 fputs_filtered (paddress (frame_pc_unwind (fi
)), gdb_stdout
);
1062 printf_filtered ("\n");
1064 if (calling_frame_info
== NULL
)
1066 enum unwind_stop_reason reason
;
1068 reason
= get_frame_unwind_stop_reason (fi
);
1069 if (reason
!= UNWIND_NO_REASON
)
1070 printf_filtered (_(" Outermost frame: %s\n"),
1071 frame_stop_reason_string (reason
));
1074 if (calling_frame_info
)
1076 printf_filtered (" called by frame at ");
1077 fputs_filtered (paddress (get_frame_base (calling_frame_info
)),
1080 if (get_next_frame (fi
) && calling_frame_info
)
1081 puts_filtered (",");
1083 if (get_next_frame (fi
))
1085 printf_filtered (" caller of frame at ");
1086 fputs_filtered (paddress (get_frame_base (get_next_frame (fi
))),
1089 if (get_next_frame (fi
) || calling_frame_info
)
1090 puts_filtered ("\n");
1093 printf_filtered (" source language %s.\n",
1094 language_str (s
->language
));
1097 /* Address of the argument list for this frame, or 0. */
1098 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1099 /* Number of args for this frame, or -1 if unknown. */
1103 printf_filtered (" Arglist at unknown address.\n");
1106 printf_filtered (" Arglist at ");
1107 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1108 printf_filtered (",");
1110 if (!gdbarch_frame_num_args_p (gdbarch
))
1113 puts_filtered (" args: ");
1117 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1118 gdb_assert (numargs
>= 0);
1120 puts_filtered (" no args.");
1121 else if (numargs
== 1)
1122 puts_filtered (" 1 arg: ");
1124 printf_filtered (" %d args: ", numargs
);
1126 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1127 puts_filtered ("\n");
1131 /* Address of the local variables for this frame, or 0. */
1132 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1135 printf_filtered (" Locals at unknown address,");
1138 printf_filtered (" Locals at ");
1139 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1140 printf_filtered (",");
1144 /* Print as much information as possible on the location of all the
1147 enum lval_type lval
;
1155 /* The sp is special; what's displayed isn't the save address, but
1156 the value of the previous frame's sp. This is a legacy thing,
1157 at one stage the frame cached the previous frame's SP instead
1158 of its address, hence it was easiest to just display the cached
1160 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1162 /* Find out the location of the saved stack pointer with out
1163 actually evaluating it. */
1164 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1165 &optimized
, &lval
, &addr
,
1167 if (!optimized
&& lval
== not_lval
)
1169 gdb_byte value
[MAX_REGISTER_SIZE
];
1171 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1172 &optimized
, &lval
, &addr
,
1174 /* NOTE: cagney/2003-05-22: This is assuming that the
1175 stack pointer was packed as an unsigned integer. That
1176 may or may not be valid. */
1177 sp
= extract_unsigned_integer (value
,
1178 register_size (gdbarch
,
1179 gdbarch_sp_regnum (gdbarch
)));
1180 printf_filtered (" Previous frame's sp is ");
1181 fputs_filtered (paddress (sp
), gdb_stdout
);
1182 printf_filtered ("\n");
1185 else if (!optimized
&& lval
== lval_memory
)
1187 printf_filtered (" Previous frame's sp at ");
1188 fputs_filtered (paddress (addr
), gdb_stdout
);
1189 printf_filtered ("\n");
1192 else if (!optimized
&& lval
== lval_register
)
1194 printf_filtered (" Previous frame's sp in %s\n",
1195 gdbarch_register_name (gdbarch
, realnum
));
1198 /* else keep quiet. */
1202 numregs
= gdbarch_num_regs (gdbarch
)
1203 + gdbarch_num_pseudo_regs (gdbarch
);
1204 for (i
= 0; i
< numregs
; i
++)
1205 if (i
!= gdbarch_sp_regnum (gdbarch
)
1206 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1208 /* Find out the location of the saved register without
1209 fetching the corresponding value. */
1210 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1212 /* For moment, only display registers that were saved on the
1214 if (!optimized
&& lval
== lval_memory
)
1217 puts_filtered (" Saved registers:\n ");
1219 puts_filtered (",");
1221 printf_filtered (" %s at ",
1222 gdbarch_register_name (gdbarch
, i
));
1223 fputs_filtered (paddress (addr
), gdb_stdout
);
1227 if (count
|| need_nl
)
1228 puts_filtered ("\n");
1231 do_cleanups (back_to
);
1234 /* Print briefly all stack frames or just the innermost COUNT_EXP
1238 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1240 struct frame_info
*fi
;
1243 struct frame_info
*trailing
;
1246 if (!target_has_stack
)
1247 error (_("No stack."));
1249 /* The following code must do two things. First, it must set the
1250 variable TRAILING to the frame from which we should start
1251 printing. Second, it must set the variable count to the number
1252 of frames which we should print, or -1 if all of them. */
1253 trailing
= get_current_frame ();
1255 /* The target can be in a state where there is no valid frames
1256 (e.g., just connected). */
1257 if (trailing
== NULL
)
1258 error (_("No stack."));
1263 count
= parse_and_eval_long (count_exp
);
1266 struct frame_info
*current
;
1271 while (current
&& count
--)
1274 current
= get_prev_frame (current
);
1277 /* Will stop when CURRENT reaches the top of the stack.
1278 TRAILING will be COUNT below it. */
1282 trailing
= get_prev_frame (trailing
);
1283 current
= get_prev_frame (current
);
1295 struct partial_symtab
*ps
;
1297 /* Read in symbols for all of the frames. Need to do this in a
1298 separate pass so that "Reading in symbols for xxx" messages
1299 don't screw up the appearance of the backtrace. Also if
1300 people have strong opinions against reading symbols for
1301 backtrace this may have to be an option. */
1303 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1306 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1308 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in. */
1312 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1316 /* Don't use print_stack_frame; if an error() occurs it probably
1317 means further attempts to backtrace would fail (on the other
1318 hand, perhaps the code does or could be fixed to make sure
1319 the frame->prev field gets set to NULL in that case). */
1320 print_frame_info (fi
, 1, LOCATION
, 1);
1322 print_frame_local_vars (fi
, 1, gdb_stdout
);
1324 /* Save the last frame to check for error conditions. */
1328 /* If we've stopped before the end, mention that. */
1330 printf_filtered (_("(More stack frames follow...)\n"));
1332 /* If we've run out of frames, and the reason appears to be an error
1333 condition, print it. */
1334 if (fi
== NULL
&& trailing
!= NULL
)
1336 enum unwind_stop_reason reason
;
1338 reason
= get_frame_unwind_stop_reason (trailing
);
1339 if (reason
> UNWIND_FIRST_ERROR
)
1340 printf_filtered (_("Backtrace stopped: %s\n"),
1341 frame_stop_reason_string (reason
));
1345 struct backtrace_command_args
1352 /* Stub for catch_errors. */
1355 backtrace_command_stub (void *data
)
1357 struct backtrace_command_args
*args
= data
;
1358 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1363 backtrace_command (char *arg
, int from_tty
)
1365 struct cleanup
*old_chain
= NULL
;
1366 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1367 struct backtrace_command_args btargs
;
1374 argv
= gdb_buildargv (arg
);
1375 old_chain
= make_cleanup_freeargv (argv
);
1377 for (i
= 0; argv
[i
]; i
++)
1381 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1382 argv
[i
][j
] = tolower (argv
[i
][j
]);
1384 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1385 fulltrace_arg
= argc
;
1388 arglen
+= strlen (argv
[i
]);
1393 if (fulltrace_arg
>= 0)
1397 arg
= xmalloc (arglen
+ 1);
1398 memset (arg
, 0, arglen
+ 1);
1399 for (i
= 0; i
< (argc
+ 1); i
++)
1401 if (i
!= fulltrace_arg
)
1403 strcat (arg
, argv
[i
]);
1413 btargs
.count_exp
= arg
;
1414 btargs
.show_locals
= (fulltrace_arg
>= 0);
1415 btargs
.from_tty
= from_tty
;
1416 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1418 if (fulltrace_arg
>= 0 && arglen
> 0)
1422 do_cleanups (old_chain
);
1426 backtrace_full_command (char *arg
, int from_tty
)
1428 struct backtrace_command_args btargs
;
1429 btargs
.count_exp
= arg
;
1430 btargs
.show_locals
= 1;
1431 btargs
.from_tty
= from_tty
;
1432 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1436 /* Print the local variables of a block B active in FRAME on STREAM.
1437 Return 1 if any variables were printed; 0 otherwise. */
1440 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1441 int num_tabs
, struct ui_file
*stream
)
1443 struct dict_iterator iter
;
1445 int values_printed
= 0;
1448 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1450 switch (SYMBOL_CLASS (sym
))
1456 if (SYMBOL_IS_ARGUMENT (sym
))
1459 print_variable_and_value (NULL
, sym
, frame
, stream
, 4 * num_tabs
);
1463 /* Ignore symbols which are not locals. */
1468 return values_printed
;
1471 /* Same, but print labels. */
1474 print_block_frame_labels (struct block
*b
, int *have_default
,
1475 struct ui_file
*stream
)
1477 struct dict_iterator iter
;
1479 int values_printed
= 0;
1481 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1483 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1489 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1491 struct symtab_and_line sal
;
1492 struct value_print_options opts
;
1493 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1495 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1496 get_user_print_options (&opts
);
1497 if (opts
.addressprint
)
1499 fprintf_filtered (stream
, " ");
1500 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym
)), stream
);
1502 fprintf_filtered (stream
, " in file %s, line %d\n",
1503 sal
.symtab
->filename
, sal
.line
);
1507 return values_printed
;
1510 /* Print on STREAM all the local variables in frame FRAME, including
1511 all the blocks active in that frame at its current PC.
1513 Returns 1 if the job was done, or 0 if nothing was printed because
1514 we have no info on the function running in FRAME. */
1517 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1518 struct ui_file
*stream
)
1520 struct block
*block
= get_frame_block (frame
, 0);
1521 int values_printed
= 0;
1525 fprintf_filtered (stream
, "No symbol table info available.\n");
1531 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1533 /* After handling the function's top-level block, stop. Don't
1534 continue to its superblock, the block of per-file symbols. */
1535 if (BLOCK_FUNCTION (block
))
1537 block
= BLOCK_SUPERBLOCK (block
);
1540 if (!values_printed
)
1541 fprintf_filtered (stream
, _("No locals.\n"));
1544 /* Same, but print labels. */
1547 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1548 struct ui_file
*stream
)
1551 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1553 struct blockvector
*bl
;
1554 struct block
*block
= get_frame_block (frame
, 0);
1555 int values_printed
= 0;
1556 int index
, have_default
= 0;
1557 char *blocks_printed
;
1558 CORE_ADDR pc
= get_frame_pc (frame
);
1562 fprintf_filtered (stream
, "No symbol table info available.\n");
1566 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1567 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1568 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1572 CORE_ADDR end
= BLOCK_END (block
) - 4;
1575 if (bl
!= blockvector_for_pc (end
, &index
))
1576 error (_("blockvector blotch"));
1577 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1578 error (_("blockvector botch"));
1579 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1582 /* Don't print out blocks that have gone by. */
1583 while (index
< last_index
1584 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1587 while (index
< last_index
1588 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1590 if (blocks_printed
[index
] == 0)
1592 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
),
1593 &have_default
, stream
))
1595 blocks_printed
[index
] = 1;
1601 if (values_printed
&& this_level_only
)
1604 /* After handling the function's top-level block, stop. Don't
1605 continue to its superblock, the block of per-file symbols. */
1606 if (BLOCK_FUNCTION (block
))
1608 block
= BLOCK_SUPERBLOCK (block
);
1611 if (!values_printed
&& !this_level_only
)
1612 fprintf_filtered (stream
, _("No catches.\n"));
1617 locals_info (char *args
, int from_tty
)
1619 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1624 catch_info (char *ignore
, int from_tty
)
1626 struct symtab_and_line
*sal
;
1628 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1629 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1634 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1636 struct symbol
*func
= get_frame_function (frame
);
1638 struct dict_iterator iter
;
1639 struct symbol
*sym
, *sym2
;
1640 int values_printed
= 0;
1644 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1648 b
= SYMBOL_BLOCK_VALUE (func
);
1649 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1651 /* Don't worry about things which aren't arguments. */
1652 if (SYMBOL_IS_ARGUMENT (sym
))
1656 /* We have to look up the symbol because arguments can have
1657 two entries (one a parameter, one a local) and the one we
1658 want is the local, which lookup_symbol will find for us.
1659 This includes gcc1 (not gcc2) on the sparc when passing a
1660 small structure and gcc2 when the argument type is float
1661 and it is passed as a double and converted to float by
1662 the prologue (in the latter case the type of the LOC_ARG
1663 symbol is double and the type of the LOC_LOCAL symbol is
1664 float). There are also LOC_ARG/LOC_REGISTER pairs which
1665 are not combined in symbol-reading. */
1667 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1668 b
, VAR_DOMAIN
, NULL
);
1669 print_variable_and_value (SYMBOL_PRINT_NAME (sym
), sym2
,
1674 if (!values_printed
)
1675 fprintf_filtered (stream
, _("No arguments.\n"));
1679 args_info (char *ignore
, int from_tty
)
1681 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1687 args_plus_locals_info (char *ignore
, int from_tty
)
1689 args_info (ignore
, from_tty
);
1690 locals_info (ignore
, from_tty
);
1694 /* Select frame FRAME. Also print the stack frame and show the source
1695 if this is the tui version. */
1697 select_and_print_frame (struct frame_info
*frame
)
1699 select_frame (frame
);
1701 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1704 /* Return the symbol-block in which the selected frame is executing.
1705 Can return zero under various legitimate circumstances.
1707 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1708 code address within the block returned. We use this to decide
1709 which macros are in scope. */
1712 get_selected_block (CORE_ADDR
*addr_in_block
)
1714 if (!has_stack_frames ())
1717 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1720 /* Find a frame a certain number of levels away from FRAME.
1721 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1722 Positive means go to earlier frames (up); negative, the reverse.
1723 The int that contains the number of levels is counted toward
1724 zero as the frames for those levels are found.
1725 If the top or bottom frame is reached, that frame is returned,
1726 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1727 how much farther the original request asked to go. */
1730 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1732 /* Going up is simple: just call get_prev_frame enough times or
1733 until the initial frame is reached. */
1734 while (*level_offset_ptr
> 0)
1736 struct frame_info
*prev
= get_prev_frame (frame
);
1739 (*level_offset_ptr
)--;
1743 /* Going down is just as simple. */
1744 while (*level_offset_ptr
< 0)
1746 struct frame_info
*next
= get_next_frame (frame
);
1749 (*level_offset_ptr
)++;
1756 /* The "select_frame" command. With no argument this is a NOP.
1757 Select the frame at level LEVEL_EXP if it is a valid level.
1758 Otherwise, treat LEVEL_EXP as an address expression and select it.
1760 See parse_frame_specification for more info on proper frame
1764 select_frame_command (char *level_exp
, int from_tty
)
1766 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1769 /* The "frame" command. With no argument, print the selected frame
1770 briefly. With an argument, behave like select_frame and then print
1771 the selected frame. */
1774 frame_command (char *level_exp
, int from_tty
)
1776 select_frame_command (level_exp
, from_tty
);
1777 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1780 /* The XDB Compatibility command to print the current frame. */
1783 current_frame_command (char *level_exp
, int from_tty
)
1785 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1788 /* Select the frame up one or COUNT_EXP stack levels from the
1789 previously selected frame, and print it briefly. */
1792 up_silently_base (char *count_exp
)
1794 struct frame_info
*frame
;
1798 count
= parse_and_eval_long (count_exp
);
1800 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1801 if (count
!= 0 && count_exp
== NULL
)
1802 error (_("Initial frame selected; you cannot go up."));
1803 select_frame (frame
);
1807 up_silently_command (char *count_exp
, int from_tty
)
1809 up_silently_base (count_exp
);
1813 up_command (char *count_exp
, int from_tty
)
1815 up_silently_base (count_exp
);
1816 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1819 /* Select the frame down one or COUNT_EXP stack levels from the previously
1820 selected frame, and print it briefly. */
1823 down_silently_base (char *count_exp
)
1825 struct frame_info
*frame
;
1828 count
= -parse_and_eval_long (count_exp
);
1830 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1831 if (count
!= 0 && count_exp
== NULL
)
1833 /* We only do this if COUNT_EXP is not specified. That way
1834 "down" means to really go down (and let me know if that is
1835 impossible), but "down 9999" can be used to mean go all the
1836 way down without getting an error. */
1838 error (_("Bottom (innermost) frame selected; you cannot go down."));
1841 select_frame (frame
);
1845 down_silently_command (char *count_exp
, int from_tty
)
1847 down_silently_base (count_exp
);
1851 down_command (char *count_exp
, int from_tty
)
1853 down_silently_base (count_exp
);
1854 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1859 return_command (char *retval_exp
, int from_tty
)
1861 struct frame_info
*thisframe
;
1862 struct symbol
*thisfun
;
1863 struct value
*return_value
= NULL
;
1864 const char *query_prefix
= "";
1866 thisframe
= get_selected_frame ("No selected frame.");
1867 thisfun
= get_frame_function (thisframe
);
1869 /* Compute the return value. If the computation triggers an error,
1870 let it bail. If the return type can't be handled, set
1871 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1875 struct expression
*retval_expr
= parse_expression (retval_exp
);
1876 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1877 struct type
*return_type
= NULL
;
1879 /* Compute the return value. Should the computation fail, this
1880 call throws an error. */
1881 return_value
= evaluate_expression (retval_expr
);
1883 /* Cast return value to the return type of the function. Should
1884 the cast fail, this call throws an error. */
1885 if (thisfun
!= NULL
)
1886 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1887 if (return_type
== NULL
)
1889 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1890 error (_("Return value type not available for selected "
1892 "Please use an explicit cast of the value to return."));
1893 return_type
= value_type (return_value
);
1895 do_cleanups (old_chain
);
1896 CHECK_TYPEDEF (return_type
);
1897 return_value
= value_cast (return_type
, return_value
);
1899 /* Make sure the value is fully evaluated. It may live in the
1900 stack frame we're about to pop. */
1901 if (value_lazy (return_value
))
1902 value_fetch_lazy (return_value
);
1904 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1905 /* If the return-type is "void", don't try to find the
1906 return-value's location. However, do still evaluate the
1907 return expression so that, even when the expression result
1908 is discarded, side effects such as "return i++" still
1910 return_value
= NULL
;
1911 else if (thisfun
!= NULL
1912 && using_struct_return (SYMBOL_TYPE (thisfun
), return_type
))
1915 The location at which to store the function's return value is unknown.\n\
1916 If you continue, the return value that you specified will be ignored.\n";
1917 return_value
= NULL
;
1921 /* Does an interactive user really want to do this? Include
1922 information, such as how well GDB can handle the return value, in
1923 the query message. */
1927 if (thisfun
== NULL
)
1928 confirmed
= query (_("%sMake selected stack frame return now? "),
1931 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1932 SYMBOL_PRINT_NAME (thisfun
));
1934 error (_("Not confirmed"));
1937 /* Discard the selected frame and all frames inner-to it. */
1938 frame_pop (get_selected_frame (NULL
));
1940 /* Store RETURN_VALUE in the just-returned register set. */
1941 if (return_value
!= NULL
)
1943 struct type
*return_type
= value_type (return_value
);
1944 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1945 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
1947 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
1949 == RETURN_VALUE_REGISTER_CONVENTION
);
1950 gdbarch_return_value (gdbarch
, func_type
, return_type
,
1951 get_current_regcache (), NULL
/*read*/,
1952 value_contents (return_value
) /*write*/);
1955 /* If we are at the end of a call dummy now, pop the dummy frame
1957 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1958 frame_pop (get_current_frame ());
1960 /* If interactive, print the frame that is now current. */
1962 frame_command ("0", 1);
1964 select_frame_command ("0", 0);
1967 /* Sets the scope to input function name, provided that the function
1968 is within the current stack frame */
1970 struct function_bounds
1972 CORE_ADDR low
, high
;
1976 func_command (char *arg
, int from_tty
)
1978 struct frame_info
*frame
;
1980 struct symtabs_and_lines sals
;
1983 struct function_bounds
*func_bounds
= NULL
;
1988 frame
= parse_frame_specification ("0");
1989 sals
= decode_line_spec (arg
, 1);
1990 func_bounds
= (struct function_bounds
*) xmalloc (
1991 sizeof (struct function_bounds
) * sals
.nelts
);
1992 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1994 if (sals
.sals
[i
].pc
== 0
1995 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
1996 &func_bounds
[i
].low
,
1997 &func_bounds
[i
].high
) == 0)
1999 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2005 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2006 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2007 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2011 frame
= find_relative_frame (frame
, &level
);
2014 while (!found
&& level
== 0);
2017 xfree (func_bounds
);
2020 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2021 else if (frame
!= get_selected_frame (NULL
))
2022 select_and_print_frame (frame
);
2025 /* Gets the language of the current frame. */
2028 get_frame_language (void)
2030 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2034 /* We determine the current frame language by looking up its
2035 associated symtab. To retrieve this symtab, we use the frame
2036 PC. However we cannot use the frame PC as is, because it
2037 usually points to the instruction following the "call", which
2038 is sometimes the first instruction of another function. So
2039 we rely on get_frame_address_in_block(), it provides us with
2040 a PC that is guaranteed to be inside the frame's code
2042 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2043 struct symtab
*s
= find_pc_symtab (pc
);
2049 return language_unknown
;
2053 /* Provide a prototype to silence -Wmissing-prototypes. */
2054 void _initialize_stack (void);
2057 _initialize_stack (void)
2060 backtrace_limit
= 30;
2063 add_com ("return", class_stack
, return_command
, _("\
2064 Make selected stack frame return to its caller.\n\
2065 Control remains in the debugger, but when you continue\n\
2066 execution will resume in the frame above the one now selected.\n\
2067 If an argument is given, it is an expression for the value to return."));
2069 add_com ("up", class_stack
, up_command
, _("\
2070 Select and print stack frame that called this one.\n\
2071 An argument says how many frames up to go."));
2072 add_com ("up-silently", class_support
, up_silently_command
, _("\
2073 Same as the `up' command, but does not print anything.\n\
2074 This is useful in command scripts."));
2076 add_com ("down", class_stack
, down_command
, _("\
2077 Select and print stack frame called by this one.\n\
2078 An argument says how many frames down to go."));
2079 add_com_alias ("do", "down", class_stack
, 1);
2080 add_com_alias ("dow", "down", class_stack
, 1);
2081 add_com ("down-silently", class_support
, down_silently_command
, _("\
2082 Same as the `down' command, but does not print anything.\n\
2083 This is useful in command scripts."));
2085 add_com ("frame", class_stack
, frame_command
, _("\
2086 Select and print a stack frame.\n\
2087 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2088 An argument specifies the frame to select.\n\
2089 It can be a stack frame number or the address of the frame.\n\
2090 With argument, nothing is printed if input is coming from\n\
2091 a command file or a user-defined command."));
2093 add_com_alias ("f", "frame", class_stack
, 1);
2097 add_com ("L", class_stack
, current_frame_command
,
2098 _("Print the current stack frame.\n"));
2099 add_com_alias ("V", "frame", class_stack
, 1);
2101 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2102 Select a stack frame without printing anything.\n\
2103 An argument specifies the frame to select.\n\
2104 It can be a stack frame number or the address of the frame.\n"));
2106 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2107 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2108 With a negative argument, print outermost -COUNT frames.\n\
2109 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2110 add_com_alias ("bt", "backtrace", class_stack
, 0);
2113 add_com_alias ("t", "backtrace", class_stack
, 0);
2114 add_com ("T", class_stack
, backtrace_full_command
, _("\
2115 Print backtrace of all stack frames, or innermost COUNT frames \n\
2116 and the values of the local variables.\n\
2117 With a negative argument, print outermost -COUNT frames.\n\
2118 Usage: T <count>\n"));
2121 add_com_alias ("where", "backtrace", class_alias
, 0);
2122 add_info ("stack", backtrace_command
,
2123 _("Backtrace of the stack, or innermost COUNT frames."));
2124 add_info_alias ("s", "stack", 1);
2125 add_info ("frame", frame_info
,
2126 _("All about selected stack frame, or frame at ADDR."));
2127 add_info_alias ("f", "frame", 1);
2128 add_info ("locals", locals_info
,
2129 _("Local variables of current stack frame."));
2130 add_info ("args", args_info
,
2131 _("Argument variables of current stack frame."));
2133 add_com ("l", class_info
, args_plus_locals_info
,
2134 _("Argument and local variables of current stack frame."));
2137 add_com ("func", class_stack
, func_command
, _("\
2138 Select the stack frame that contains <func>.\n\
2139 Usage: func <name>\n"));
2141 add_info ("catch", catch_info
,
2142 _("Exceptions that can be caught in the current stack frame."));
2144 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2145 print_frame_arguments_choices
, &print_frame_arguments
,
2146 _("Set printing of non-scalar frame arguments"),
2147 _("Show printing of non-scalar frame arguments"),
2148 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2150 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2151 &disassemble_next_line
, _("\
2152 Set whether to disassemble next source line when execution stops."), _("\
2153 Show whether to disassemble next source line when execution stops."), _("\
2154 If ON, GDB will display disassembly of the next source line when\n\
2155 execution of the program being debugged stops.\n\
2156 If AUTO, or there's no line info to determine\n\
2157 the source line of the next instruction, display disassembly of next\n\
2158 instruction instead."),
2160 show_disassemble_next_line
,
2161 &setlist
, &showlist
);
2162 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2165 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2166 "Specify maximum number of frames for \"backtrace\" to print by default."),
2168 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2169 The maximum number of frames for \"backtrace\" to print by default."));