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 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"
47 #include "gdb_assert.h"
49 #include "gdb_string.h"
51 void (*deprecated_selected_frame_level_changed_hook
) (int);
53 /* The possible choices of "set print frame-arguments, and the value
56 static const char *print_frame_arguments_choices
[] =
57 {"all", "scalars", "none", NULL
};
58 static const char *print_frame_arguments
= "all";
60 /* Prototypes for local functions. */
62 static void print_frame_local_vars (struct frame_info
*, int,
65 static void print_frame (struct frame_info
*frame
, int print_level
,
66 enum print_what print_what
, int print_args
,
67 struct symtab_and_line sal
);
69 /* Zero means do things normally; we are interacting directly with the
70 user. One means print the full filename and linenumber when a
71 frame is printed, and do so in a format emacs18/emacs19.22 can
72 parse. Two means print similar annotations, but in many more
73 cases and in a slightly different syntax. */
75 int annotation_level
= 0;
78 struct print_stack_frame_args
80 struct frame_info
*frame
;
82 enum print_what print_what
;
86 /* Show or print the frame arguments; stub for catch_errors. */
89 print_stack_frame_stub (void *args
)
91 struct print_stack_frame_args
*p
= args
;
92 int center
= (p
->print_what
== SRC_LINE
|| p
->print_what
== SRC_AND_LOC
);
94 print_frame_info (p
->frame
, p
->print_level
, p
->print_what
, p
->print_args
);
95 set_current_sal_from_frame (p
->frame
, center
);
99 /* Show or print a stack frame FRAME briefly. The output is format
100 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
101 relative level, function name, argument list, and file name and
102 line number. If the frame's PC is not at the beginning of the
103 source line, the actual PC is printed at the beginning. */
106 print_stack_frame (struct frame_info
*frame
, int print_level
,
107 enum print_what print_what
)
109 struct print_stack_frame_args args
;
112 args
.print_level
= print_level
;
113 args
.print_what
= print_what
;
114 /* For mi, alway print location and address. */
115 args
.print_what
= ui_out_is_mi_like_p (uiout
) ? LOC_AND_ADDRESS
: print_what
;
118 catch_errors (print_stack_frame_stub
, &args
, "", RETURN_MASK_ERROR
);
121 struct print_args_args
124 struct frame_info
*frame
;
125 struct ui_file
*stream
;
128 static int print_args_stub (void *args
);
130 /* Print nameless arguments of frame FRAME on STREAM, where START is
131 the offset of the first nameless argument, and NUM is the number of
132 nameless arguments to print. FIRST is nonzero if this is the first
133 argument (not just the first nameless argument). */
136 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
137 int first
, struct ui_file
*stream
)
143 for (i
= 0; i
< num
; i
++)
146 argsaddr
= get_frame_args_address (frame
);
149 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
151 fprintf_filtered (stream
, ", ");
152 fprintf_filtered (stream
, "%ld", arg_value
);
154 start
+= sizeof (int);
158 /* Return non-zero if the debugger should print the value of the provided
159 symbol parameter (SYM). */
162 print_this_frame_argument_p (struct symbol
*sym
)
166 /* If the user asked to print no argument at all, then obviously
167 do not print this argument. */
169 if (strcmp (print_frame_arguments
, "none") == 0)
172 /* If the user asked to print all arguments, then we should print
175 if (strcmp (print_frame_arguments
, "all") == 0)
178 /* The user asked to print only the scalar arguments, so do not
179 print the non-scalar ones. */
181 type
= CHECK_TYPEDEF (SYMBOL_TYPE (sym
));
182 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
183 type
= CHECK_TYPEDEF (TYPE_TARGET_TYPE (type
));
184 switch (TYPE_CODE (type
))
186 case TYPE_CODE_ARRAY
:
187 case TYPE_CODE_STRUCT
:
188 case TYPE_CODE_UNION
:
190 case TYPE_CODE_STRING
:
191 case TYPE_CODE_BITSTRING
:
198 /* Print the arguments of frame FRAME on STREAM, given the function
199 FUNC running in that frame (as a symbol), where NUM is the number
200 of arguments according to the stack frame (or -1 if the number of
201 arguments is unknown). */
203 /* Note that currently the "number of argumentss according to the
204 stack frame" is only known on VAX where i refers to the "number of
205 ints of argumentss according to the stack frame". */
208 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
209 int num
, struct ui_file
*stream
)
212 /* Offset of next stack argument beyond the one we have seen that is
213 at the highest offset, or -1 if we haven't come to a stack
215 long highest_offset
= -1;
216 /* Number of ints of arguments that we have printed so far. */
217 int args_printed
= 0;
218 struct cleanup
*old_chain
, *list_chain
;
219 struct ui_stream
*stb
;
221 stb
= ui_out_stream_new (uiout
);
222 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
226 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
227 struct dict_iterator iter
;
231 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
235 /* Keep track of the highest stack argument offset seen, and
236 skip over any kinds of symbols we don't care about. */
238 switch (SYMBOL_CLASS (sym
))
243 long current_offset
= SYMBOL_VALUE (sym
);
244 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
246 /* Compute address of next argument by adding the size of
247 this argument and rounding to an int boundary. */
249 ((current_offset
+ arg_size
+ sizeof (int) - 1)
250 & ~(sizeof (int) - 1));
252 /* If this is the highest offset seen yet, set
254 if (highest_offset
== -1
255 || (current_offset
> highest_offset
))
256 highest_offset
= current_offset
;
258 /* Add the number of ints we're about to print to
260 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
263 /* We care about types of symbols, but don't need to
264 keep track of stack offsets in them. */
266 case LOC_REGPARM_ADDR
:
268 case LOC_BASEREG_ARG
:
269 case LOC_COMPUTED_ARG
:
272 /* Other types of symbols we just skip over. */
277 /* We have to look up the symbol because arguments can have
278 two entries (one a parameter, one a local) and the one we
279 want is the local, which lookup_symbol will find for us.
280 This includes gcc1 (not gcc2) on SPARC when passing a
281 small structure and gcc2 when the argument type is float
282 and it is passed as a double and converted to float by
283 the prologue (in the latter case the type of the LOC_ARG
284 symbol is double and the type of the LOC_LOCAL symbol is
286 /* But if the parameter name is null, don't try it. Null
287 parameter names occur on the RS/6000, for traceback
288 tables. FIXME, should we even print them? */
290 if (*DEPRECATED_SYMBOL_NAME (sym
))
293 nsym
= lookup_symbol (DEPRECATED_SYMBOL_NAME (sym
),
294 b
, VAR_DOMAIN
, NULL
, NULL
);
295 gdb_assert (nsym
!= NULL
);
296 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
298 /* There is a LOC_ARG/LOC_REGISTER pair. This means
299 that it was passed on the stack and loaded into a
300 register, or passed in a register and stored in a
301 stack slot. GDB 3.x used the LOC_ARG; GDB
302 4.0-4.11 used the LOC_REGISTER.
304 Reasons for using the LOC_ARG:
306 (1) Because find_saved_registers may be slow for
309 (2) Because registers are often re-used and stack
310 slots rarely (never?) are. Therefore using
311 the stack slot is much less likely to print
314 Reasons why we might want to use the LOC_REGISTER:
316 (1) So that the backtrace prints the same value
317 as "print foo". I see no compelling reason
318 why this needs to be the case; having the
319 backtrace print the value which was passed
320 in, and "print foo" print the value as
321 modified within the called function, makes
324 Additional note: It might be nice if "info args"
325 displayed both values.
327 One more note: There is a case with SPARC
328 structure passing where we need to use the
329 LOC_REGISTER, but this is dealt with by creating
330 a single LOC_REGPARM in symbol reading. */
332 /* Leave sym (the LOC_ARG) alone. */
339 /* Print the current arg. */
341 ui_out_text (uiout
, ", ");
342 ui_out_wrap_hint (uiout
, " ");
344 annotate_arg_begin ();
346 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
347 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
348 SYMBOL_LANGUAGE (sym
),
349 DMGL_PARAMS
| DMGL_ANSI
);
350 ui_out_field_stream (uiout
, "name", stb
);
351 annotate_arg_name_end ();
352 ui_out_text (uiout
, "=");
354 if (print_this_frame_argument_p (sym
))
356 /* Avoid value_print because it will deref ref parameters.
357 We just want to print their addresses. Print ??? for
358 args whose address we do not know. We pass 2 as
359 "recurse" to val_print because our standard indentation
360 here is 4 spaces, and val_print indents 2 for each
362 val
= read_var_value (sym
, frame
);
364 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
368 common_val_print (val
, stb
->stream
, 0, 0, 2,
370 ui_out_field_stream (uiout
, "value", stb
);
373 ui_out_text (uiout
, "???");
376 ui_out_text (uiout
, "...");
379 /* Invoke ui_out_tuple_end. */
380 do_cleanups (list_chain
);
388 /* Don't print nameless args in situations where we don't know
389 enough about the stack to find them. */
394 if (highest_offset
== -1)
395 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
397 start
= highest_offset
;
399 print_frame_nameless_args (frame
, start
, num
- args_printed
,
403 do_cleanups (old_chain
);
406 /* Stub for catch_errors. */
409 print_args_stub (void *args
)
411 struct print_args_args
*p
= args
;
412 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
415 if (gdbarch_frame_num_args_p (gdbarch
))
417 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
418 gdb_assert (numargs
>= 0);
422 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
426 /* Set the current source and line to the location given by frame
427 FRAME, if possible. When CENTER is true, adjust so the relevant
428 line is in the center of the next 'list'. */
431 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
433 struct symtab_and_line sal
;
435 find_frame_sal (frame
, &sal
);
439 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
440 set_current_source_symtab_and_line (&sal
);
444 /* Print information about frame FRAME. The output is format according
445 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
448 SRC_LINE: Print only source line.
449 LOCATION: Print only location.
450 LOC_AND_SRC: Print location and source line.
452 Used in "where" output, and to emit breakpoint or step
456 print_frame_info (struct frame_info
*frame
, int print_level
,
457 enum print_what print_what
, int print_args
)
459 struct symtab_and_line sal
;
463 if (get_frame_type (frame
) == DUMMY_FRAME
464 || get_frame_type (frame
) == SIGTRAMP_FRAME
)
466 struct cleanup
*uiout_cleanup
467 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
469 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
470 get_frame_pc (frame
));
472 /* Do this regardless of SOURCE because we don't have any source
473 to list for this frame. */
476 ui_out_text (uiout
, "#");
477 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
478 frame_relative_level (frame
));
480 if (ui_out_is_mi_like_p (uiout
))
482 annotate_frame_address ();
483 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
484 annotate_frame_address_end ();
487 if (get_frame_type (frame
) == DUMMY_FRAME
)
489 annotate_function_call ();
490 ui_out_field_string (uiout
, "func", "<function called from gdb>");
492 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
494 annotate_signal_handler_caller ();
495 ui_out_field_string (uiout
, "func", "<signal handler called>");
497 ui_out_text (uiout
, "\n");
498 annotate_frame_end ();
500 do_cleanups (uiout_cleanup
);
504 /* If FRAME is not the innermost frame, that normally means that
505 FRAME->pc points to *after* the call instruction, and we want to
506 get the line containing the call, never the next line. But if
507 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
508 next frame was not entered as the result of a call, and we want
509 to get the line containing FRAME->pc. */
510 find_frame_sal (frame
, &sal
);
512 location_print
= (print_what
== LOCATION
513 || print_what
== LOC_AND_ADDRESS
514 || print_what
== SRC_AND_LOC
);
516 if (location_print
|| !sal
.symtab
)
517 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
519 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
521 if (source_print
&& sal
.symtab
)
524 int mid_statement
= ((print_what
== SRC_LINE
)
525 && (get_frame_pc (frame
) != sal
.pc
));
527 if (annotation_level
)
528 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
529 get_frame_pc (frame
));
532 if (deprecated_print_frame_info_listing_hook
)
533 deprecated_print_frame_info_listing_hook (sal
.symtab
,
538 /* We used to do this earlier, but that is clearly
539 wrong. This function is used by many different
540 parts of gdb, including normal_stop in infrun.c,
541 which uses this to print out the current PC
542 when we stepi/nexti into the middle of a source
543 line. Only the command line really wants this
544 behavior. Other UIs probably would like the
545 ability to decide for themselves if it is desired. */
546 if (addressprint
&& mid_statement
)
548 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
549 ui_out_text (uiout
, "\t");
552 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
557 if (print_what
!= LOCATION
)
558 set_default_breakpoint (1, get_frame_pc (frame
), sal
.symtab
, sal
.line
);
560 annotate_frame_end ();
562 gdb_flush (gdb_stdout
);
566 print_frame (struct frame_info
*frame
, int print_level
,
567 enum print_what print_what
, int print_args
,
568 struct symtab_and_line sal
)
571 char *funname
= NULL
;
572 enum language funlang
= language_unknown
;
573 struct ui_stream
*stb
;
574 struct cleanup
*old_chain
, *list_chain
;
576 stb
= ui_out_stream_new (uiout
);
577 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
579 func
= find_pc_function (get_frame_address_in_block (frame
));
582 /* In certain pathological cases, the symtabs give the wrong
583 function (when we are in the first function in a file which
584 is compiled without debugging symbols, the previous function
585 is compiled with debugging symbols, and the "foo.o" symbol
586 that is supposed to tell us where the file with debugging
587 symbols ends has been truncated by ar because it is longer
588 than 15 characters). This also occurs if the user uses asm()
589 to create a function but not stabs for it (in a file compiled
592 So look in the minimal symbol tables as well, and if it comes
593 up with a larger address for the function use that instead.
594 I don't think this can ever cause any problems; there
595 shouldn't be any minimal symbols in the middle of a function;
596 if this is ever changed many parts of GDB will need to be
597 changed (and we'll create a find_pc_minimal_function or some
600 struct minimal_symbol
*msymbol
=
601 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
604 && (SYMBOL_VALUE_ADDRESS (msymbol
)
605 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
607 /* We also don't know anything about the function besides
608 its address and name. */
610 funname
= DEPRECATED_SYMBOL_NAME (msymbol
);
611 funlang
= SYMBOL_LANGUAGE (msymbol
);
615 funname
= DEPRECATED_SYMBOL_NAME (func
);
616 funlang
= SYMBOL_LANGUAGE (func
);
617 if (funlang
== language_cplus
)
619 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
620 to display the demangled name that we already have
621 stored in the symbol table, but we stored a version
622 with DMGL_PARAMS turned on, and here we don't want to
623 display parameters. So call the demangler again, with
626 Yes, printf_symbol_filtered() will again try to
627 demangle the name on the fly, but the issue is that
628 if cplus_demangle() fails here, it will fail there
629 too. So we want to catch the failure (where DEMANGLED
630 is NULL below) here, while we still have our hands on
631 the function symbol.) */
632 char *demangled
= cplus_demangle (funname
, DMGL_ANSI
);
633 if (demangled
== NULL
)
634 /* If the demangler fails, try the demangled name from
635 the symbol table. That'll have parameters, but
636 that's preferable to displaying a mangled name. */
637 funname
= SYMBOL_PRINT_NAME (func
);
645 struct minimal_symbol
*msymbol
=
646 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
650 funname
= DEPRECATED_SYMBOL_NAME (msymbol
);
651 funlang
= SYMBOL_LANGUAGE (msymbol
);
655 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
656 get_frame_pc (frame
));
658 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
662 ui_out_text (uiout
, "#");
663 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
664 frame_relative_level (frame
));
667 if (get_frame_pc (frame
) != sal
.pc
|| !sal
.symtab
668 || print_what
== LOC_AND_ADDRESS
)
670 annotate_frame_address ();
671 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
672 annotate_frame_address_end ();
673 ui_out_text (uiout
, " in ");
675 annotate_frame_function_name ();
676 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
678 ui_out_field_stream (uiout
, "func", stb
);
679 ui_out_wrap_hint (uiout
, " ");
680 annotate_frame_args ();
682 ui_out_text (uiout
, " (");
685 struct print_args_args args
;
686 struct cleanup
*args_list_chain
;
689 args
.stream
= gdb_stdout
;
690 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
691 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
692 /* FIXME: ARGS must be a list. If one argument is a string it
693 will have " that will not be properly escaped. */
694 /* Invoke ui_out_tuple_end. */
695 do_cleanups (args_list_chain
);
698 ui_out_text (uiout
, ")");
699 if (sal
.symtab
&& sal
.symtab
->filename
)
701 annotate_frame_source_begin ();
702 ui_out_wrap_hint (uiout
, " ");
703 ui_out_text (uiout
, " at ");
704 annotate_frame_source_file ();
705 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
706 if (ui_out_is_mi_like_p (uiout
))
708 const char *fullname
= symtab_to_fullname (sal
.symtab
);
709 if (fullname
!= NULL
)
710 ui_out_field_string (uiout
, "fullname", fullname
);
712 annotate_frame_source_file_end ();
713 ui_out_text (uiout
, ":");
714 annotate_frame_source_line ();
715 ui_out_field_int (uiout
, "line", sal
.line
);
716 annotate_frame_source_end ();
719 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
722 char *lib
= PC_SOLIB (get_frame_pc (frame
));
724 char *lib
= solib_address (get_frame_pc (frame
));
728 annotate_frame_where ();
729 ui_out_wrap_hint (uiout
, " ");
730 ui_out_text (uiout
, " from ");
731 ui_out_field_string (uiout
, "from", lib
);
735 /* do_cleanups will call ui_out_tuple_end() for us. */
736 do_cleanups (list_chain
);
737 ui_out_text (uiout
, "\n");
738 do_cleanups (old_chain
);
742 /* Read a frame specification in whatever the appropriate format is
743 from FRAME_EXP. Call error(), printing MESSAGE, if the
744 specification is in any way invalid (so this function never returns
745 NULL). When SEPECTED_P is non-NULL set its target to indicate that
746 the default selected frame was used. */
748 static struct frame_info
*
749 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
750 int *selected_frame_p
)
753 struct value
*args
[4];
754 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
756 if (frame_exp
== NULL
)
761 struct cleanup
*tmp_cleanup
;
767 struct cleanup
*cleanup
;
770 /* Skip leading white space, bail of EOL. */
771 while (isspace (*frame_exp
))
776 /* Parse the argument, extract it, save it. */
780 addr_string
= savestring (frame_exp
, p
- frame_exp
);
782 cleanup
= make_cleanup (xfree
, addr_string
);
784 /* NOTE: Parse and evaluate expression, but do not use
785 functions such as parse_and_eval_long or
786 parse_and_eval_address to also extract the value.
787 Instead value_as_long and value_as_address are used.
788 This avoids problems with expressions that contain
790 if (numargs
>= ARRAY_SIZE (args
))
791 error (_("Too many args in frame specification"));
792 args
[numargs
++] = parse_and_eval (addr_string
);
794 do_cleanups (cleanup
);
798 /* If no args, default to the selected frame. */
801 if (selected_frame_p
!= NULL
)
802 (*selected_frame_p
) = 1;
803 return get_selected_frame (message
);
806 /* None of the remaining use the selected frame. */
807 if (selected_frame_p
!= NULL
)
808 (*selected_frame_p
) = 0;
810 /* Assume the single arg[0] is an integer, and try using that to
811 select a frame relative to current. */
814 struct frame_info
*fid
;
815 int level
= value_as_long (args
[0]);
816 fid
= find_relative_frame (get_current_frame (), &level
);
818 /* find_relative_frame was successful */
822 /* Convert each value into a corresponding address. */
825 for (i
= 0; i
< numargs
; i
++)
826 addrs
[i
] = value_as_address (args
[0]);
829 /* Assume that the single arg[0] is an address, use that to identify
830 a frame with a matching ID. Should this also accept stack/pc or
834 struct frame_id id
= frame_id_build_wild (addrs
[0]);
835 struct frame_info
*fid
;
837 /* If (s)he specifies the frame with an address, he deserves
838 what (s)he gets. Still, give the highest one that matches.
839 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
841 for (fid
= get_current_frame ();
843 fid
= get_prev_frame (fid
))
845 if (frame_id_eq (id
, get_frame_id (fid
)))
847 while (frame_id_eq (id
, frame_unwind_id (fid
)))
848 fid
= get_prev_frame (fid
);
854 /* We couldn't identify the frame as an existing frame, but
855 perhaps we can create one with a single argument. */
857 return create_new_frame (addrs
[0], 0);
858 else if (numargs
== 2)
859 return create_new_frame (addrs
[0], addrs
[1]);
861 error (_("Too many args in frame specification"));
864 static struct frame_info
*
865 parse_frame_specification (char *frame_exp
)
867 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
870 /* Print verbosely the selected frame or the frame at address
871 ADDR_EXP. Absolutely all information in the frame is printed. */
874 frame_info (char *addr_exp
, int from_tty
)
876 struct frame_info
*fi
;
877 struct symtab_and_line sal
;
880 struct frame_info
*calling_frame_info
;
881 int i
, count
, numregs
;
883 enum language funlang
= language_unknown
;
884 const char *pc_regname
;
885 int selected_frame_p
;
886 struct gdbarch
*gdbarch
;
888 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
889 gdbarch
= get_frame_arch (fi
);
891 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
892 is not a good name. */
893 if (gdbarch_pc_regnum (gdbarch
) >= 0)
894 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
895 easily not match that of the internal value returned by
897 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
899 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
900 architectures will often have a hardware register called "pc",
901 and that register's value, again, can easily not match
905 find_frame_sal (fi
, &sal
);
906 func
= get_frame_function (fi
);
907 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
909 s
= find_pc_symtab (get_frame_pc (fi
));
912 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to
913 display the demangled name that we already have stored in the
914 symbol table, but we stored a version with DMGL_PARAMS turned
915 on, and here we don't want to display parameters. So call the
916 demangler again, with DMGL_ANSI only.
918 Yes, printf_symbol_filtered() will again try to demangle the
919 name on the fly, but the issue is that if cplus_demangle()
920 fails here, it will fail there too. So we want to catch the
921 failure (where DEMANGLED is NULL below) here, while we still
922 have our hands on the function symbol.) */
923 funname
= DEPRECATED_SYMBOL_NAME (func
);
924 funlang
= SYMBOL_LANGUAGE (func
);
925 if (funlang
== language_cplus
)
927 char *demangled
= cplus_demangle (funname
, DMGL_ANSI
);
928 /* If the demangler fails, try the demangled name from the
929 symbol table. That'll have parameters, but that's
930 preferable to displaying a mangled name. */
931 if (demangled
== NULL
)
932 funname
= SYMBOL_PRINT_NAME (func
);
939 struct minimal_symbol
*msymbol
;
941 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
944 funname
= DEPRECATED_SYMBOL_NAME (msymbol
);
945 funlang
= SYMBOL_LANGUAGE (msymbol
);
948 calling_frame_info
= get_prev_frame (fi
);
950 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
952 printf_filtered (_("Stack level %d, frame at "),
953 frame_relative_level (fi
));
957 printf_filtered (_("Stack frame at "));
959 fputs_filtered (paddress (get_frame_base (fi
)), gdb_stdout
);
960 printf_filtered (":\n");
961 printf_filtered (" %s = ", pc_regname
);
962 fputs_filtered (paddress (get_frame_pc (fi
)), gdb_stdout
);
967 printf_filtered (" in ");
968 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
969 DMGL_ANSI
| DMGL_PARAMS
);
973 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
974 puts_filtered ("; ");
976 printf_filtered ("saved %s ", pc_regname
);
977 fputs_filtered (paddress (frame_pc_unwind (fi
)), gdb_stdout
);
978 printf_filtered ("\n");
980 if (calling_frame_info
== NULL
)
982 enum unwind_stop_reason reason
;
984 reason
= get_frame_unwind_stop_reason (fi
);
985 if (reason
!= UNWIND_NO_REASON
)
986 printf_filtered (_(" Outermost frame: %s\n"),
987 frame_stop_reason_string (reason
));
990 if (calling_frame_info
)
992 printf_filtered (" called by frame at ");
993 fputs_filtered (paddress (get_frame_base (calling_frame_info
)),
996 if (get_next_frame (fi
) && calling_frame_info
)
999 if (get_next_frame (fi
))
1001 printf_filtered (" caller of frame at ");
1002 fputs_filtered (paddress (get_frame_base (get_next_frame (fi
))),
1005 if (get_next_frame (fi
) || calling_frame_info
)
1006 puts_filtered ("\n");
1009 printf_filtered (" source language %s.\n",
1010 language_str (s
->language
));
1013 /* Address of the argument list for this frame, or 0. */
1014 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1015 /* Number of args for this frame, or -1 if unknown. */
1019 printf_filtered (" Arglist at unknown address.\n");
1022 printf_filtered (" Arglist at ");
1023 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1024 printf_filtered (",");
1026 if (!gdbarch_frame_num_args_p (gdbarch
))
1029 puts_filtered (" args: ");
1033 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1034 gdb_assert (numargs
>= 0);
1036 puts_filtered (" no args.");
1037 else if (numargs
== 1)
1038 puts_filtered (" 1 arg: ");
1040 printf_filtered (" %d args: ", numargs
);
1042 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1043 puts_filtered ("\n");
1047 /* Address of the local variables for this frame, or 0. */
1048 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1051 printf_filtered (" Locals at unknown address,");
1054 printf_filtered (" Locals at ");
1055 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1056 printf_filtered (",");
1060 /* Print as much information as possible on the location of all the
1063 enum lval_type lval
;
1071 /* The sp is special; what's displayed isn't the save address, but
1072 the value of the previous frame's sp. This is a legacy thing,
1073 at one stage the frame cached the previous frame's SP instead
1074 of its address, hence it was easiest to just display the cached
1076 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1078 /* Find out the location of the saved stack pointer with out
1079 actually evaluating it. */
1080 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1081 &optimized
, &lval
, &addr
,
1083 if (!optimized
&& lval
== not_lval
)
1085 gdb_byte value
[MAX_REGISTER_SIZE
];
1087 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1088 &optimized
, &lval
, &addr
,
1090 /* NOTE: cagney/2003-05-22: This is assuming that the
1091 stack pointer was packed as an unsigned integer. That
1092 may or may not be valid. */
1093 sp
= extract_unsigned_integer (value
,
1094 register_size (gdbarch
,
1095 gdbarch_sp_regnum (gdbarch
)));
1096 printf_filtered (" Previous frame's sp is ");
1097 fputs_filtered (paddress (sp
), gdb_stdout
);
1098 printf_filtered ("\n");
1101 else if (!optimized
&& lval
== lval_memory
)
1103 printf_filtered (" Previous frame's sp at ");
1104 fputs_filtered (paddress (addr
), gdb_stdout
);
1105 printf_filtered ("\n");
1108 else if (!optimized
&& lval
== lval_register
)
1110 printf_filtered (" Previous frame's sp in %s\n",
1111 gdbarch_register_name (gdbarch
, realnum
));
1114 /* else keep quiet. */
1118 numregs
= gdbarch_num_regs (gdbarch
)
1119 + gdbarch_num_pseudo_regs (gdbarch
);
1120 for (i
= 0; i
< numregs
; i
++)
1121 if (i
!= gdbarch_sp_regnum (gdbarch
)
1122 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1124 /* Find out the location of the saved register without
1125 fetching the corresponding value. */
1126 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1128 /* For moment, only display registers that were saved on the
1130 if (!optimized
&& lval
== lval_memory
)
1133 puts_filtered (" Saved registers:\n ");
1135 puts_filtered (",");
1137 printf_filtered (" %s at ",
1138 gdbarch_register_name (gdbarch
, i
));
1139 fputs_filtered (paddress (addr
), gdb_stdout
);
1143 if (count
|| need_nl
)
1144 puts_filtered ("\n");
1148 /* Print briefly all stack frames or just the innermost COUNT_EXP
1152 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1154 struct frame_info
*fi
;
1157 struct frame_info
*trailing
;
1160 if (!target_has_stack
)
1161 error (_("No stack."));
1163 /* The following code must do two things. First, it must set the
1164 variable TRAILING to the frame from which we should start
1165 printing. Second, it must set the variable count to the number
1166 of frames which we should print, or -1 if all of them. */
1167 trailing
= get_current_frame ();
1169 /* The target can be in a state where there is no valid frames
1170 (e.g., just connected). */
1171 if (trailing
== NULL
)
1172 error (_("No stack."));
1177 count
= parse_and_eval_long (count_exp
);
1180 struct frame_info
*current
;
1185 while (current
&& count
--)
1188 current
= get_prev_frame (current
);
1191 /* Will stop when CURRENT reaches the top of the stack.
1192 TRAILING will be COUNT below it. */
1196 trailing
= get_prev_frame (trailing
);
1197 current
= get_prev_frame (current
);
1209 struct partial_symtab
*ps
;
1211 /* Read in symbols for all of the frames. Need to do this in a
1212 separate pass so that "Reading in symbols for xxx" messages
1213 don't screw up the appearance of the backtrace. Also if
1214 people have strong opinions against reading symbols for
1215 backtrace this may have to be an option. */
1217 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1220 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1222 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in. */
1226 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1230 /* Don't use print_stack_frame; if an error() occurs it probably
1231 means further attempts to backtrace would fail (on the other
1232 hand, perhaps the code does or could be fixed to make sure
1233 the frame->prev field gets set to NULL in that case). */
1234 print_frame_info (fi
, 1, LOCATION
, 1);
1236 print_frame_local_vars (fi
, 1, gdb_stdout
);
1238 /* Save the last frame to check for error conditions. */
1242 /* If we've stopped before the end, mention that. */
1244 printf_filtered (_("(More stack frames follow...)\n"));
1246 /* If we've run out of frames, and the reason appears to be an error
1247 condition, print it. */
1248 if (fi
== NULL
&& trailing
!= NULL
)
1250 enum unwind_stop_reason reason
;
1252 reason
= get_frame_unwind_stop_reason (trailing
);
1253 if (reason
> UNWIND_FIRST_ERROR
)
1254 printf_filtered (_("Backtrace stopped: %s\n"),
1255 frame_stop_reason_string (reason
));
1259 struct backtrace_command_args
1266 /* Stub for catch_errors. */
1269 backtrace_command_stub (void *data
)
1271 struct backtrace_command_args
*args
= data
;
1272 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1277 backtrace_command (char *arg
, int from_tty
)
1279 struct cleanup
*old_chain
= NULL
;
1280 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1281 struct backtrace_command_args btargs
;
1288 argv
= buildargv (arg
);
1289 old_chain
= make_cleanup_freeargv (argv
);
1291 for (i
= 0; argv
[i
]; i
++)
1295 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1296 argv
[i
][j
] = tolower (argv
[i
][j
]);
1298 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1299 fulltrace_arg
= argc
;
1302 arglen
+= strlen (argv
[i
]);
1307 if (fulltrace_arg
>= 0)
1311 arg
= xmalloc (arglen
+ 1);
1312 memset (arg
, 0, arglen
+ 1);
1313 for (i
= 0; i
< (argc
+ 1); i
++)
1315 if (i
!= fulltrace_arg
)
1317 strcat (arg
, argv
[i
]);
1327 btargs
.count_exp
= arg
;
1328 btargs
.show_locals
= (fulltrace_arg
>= 0);
1329 btargs
.from_tty
= from_tty
;
1330 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1332 if (fulltrace_arg
>= 0 && arglen
> 0)
1336 do_cleanups (old_chain
);
1340 backtrace_full_command (char *arg
, int from_tty
)
1342 struct backtrace_command_args btargs
;
1343 btargs
.count_exp
= arg
;
1344 btargs
.show_locals
= 1;
1345 btargs
.from_tty
= from_tty
;
1346 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1350 /* Print the local variables of a block B active in FRAME on STREAM.
1351 Return 1 if any variables were printed; 0 otherwise. */
1354 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1355 int num_tabs
, struct ui_file
*stream
)
1357 struct dict_iterator iter
;
1359 int values_printed
= 0;
1362 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1364 switch (SYMBOL_CLASS (sym
))
1372 for (j
= 0; j
< num_tabs
; j
++)
1373 fputs_filtered ("\t", stream
);
1374 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1375 fputs_filtered (" = ", stream
);
1376 print_variable_value (sym
, frame
, stream
);
1377 fprintf_filtered (stream
, "\n");
1381 /* Ignore symbols which are not locals. */
1386 return values_printed
;
1389 /* Same, but print labels. */
1392 print_block_frame_labels (struct block
*b
, int *have_default
,
1393 struct ui_file
*stream
)
1395 struct dict_iterator iter
;
1397 int values_printed
= 0;
1399 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1401 if (strcmp (DEPRECATED_SYMBOL_NAME (sym
), "default") == 0)
1407 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1409 struct symtab_and_line sal
;
1410 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1412 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1415 fprintf_filtered (stream
, " ");
1416 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym
)), stream
);
1418 fprintf_filtered (stream
, " in file %s, line %d\n",
1419 sal
.symtab
->filename
, sal
.line
);
1423 return values_printed
;
1426 /* Print on STREAM all the local variables in frame FRAME, including
1427 all the blocks active in that frame at its current PC.
1429 Returns 1 if the job was done, or 0 if nothing was printed because
1430 we have no info on the function running in FRAME. */
1433 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1434 struct ui_file
*stream
)
1436 struct block
*block
= get_frame_block (frame
, 0);
1437 int values_printed
= 0;
1441 fprintf_filtered (stream
, "No symbol table info available.\n");
1447 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1449 /* After handling the function's top-level block, stop. Don't
1450 continue to its superblock, the block of per-file symbols. */
1451 if (BLOCK_FUNCTION (block
))
1453 block
= BLOCK_SUPERBLOCK (block
);
1456 if (!values_printed
)
1457 fprintf_filtered (stream
, _("No locals.\n"));
1460 /* Same, but print labels. */
1463 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1464 struct ui_file
*stream
)
1467 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1469 struct blockvector
*bl
;
1470 struct block
*block
= get_frame_block (frame
, 0);
1471 int values_printed
= 0;
1472 int index
, have_default
= 0;
1473 char *blocks_printed
;
1474 CORE_ADDR pc
= get_frame_pc (frame
);
1478 fprintf_filtered (stream
, "No symbol table info available.\n");
1482 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1483 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1484 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1488 CORE_ADDR end
= BLOCK_END (block
) - 4;
1491 if (bl
!= blockvector_for_pc (end
, &index
))
1492 error (_("blockvector blotch"));
1493 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1494 error (_("blockvector botch"));
1495 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1498 /* Don't print out blocks that have gone by. */
1499 while (index
< last_index
1500 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1503 while (index
< last_index
1504 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1506 if (blocks_printed
[index
] == 0)
1508 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
),
1509 &have_default
, stream
))
1511 blocks_printed
[index
] = 1;
1517 if (values_printed
&& this_level_only
)
1520 /* After handling the function's top-level block, stop. Don't
1521 continue to its superblock, the block of per-file symbols. */
1522 if (BLOCK_FUNCTION (block
))
1524 block
= BLOCK_SUPERBLOCK (block
);
1527 if (!values_printed
&& !this_level_only
)
1528 fprintf_filtered (stream
, _("No catches.\n"));
1533 locals_info (char *args
, int from_tty
)
1535 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1540 catch_info (char *ignore
, int from_tty
)
1542 struct symtab_and_line
*sal
;
1544 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1545 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1550 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1552 struct symbol
*func
= get_frame_function (frame
);
1554 struct dict_iterator iter
;
1555 struct symbol
*sym
, *sym2
;
1556 int values_printed
= 0;
1560 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1564 b
= SYMBOL_BLOCK_VALUE (func
);
1565 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1567 switch (SYMBOL_CLASS (sym
))
1573 case LOC_REGPARM_ADDR
:
1574 case LOC_BASEREG_ARG
:
1575 case LOC_COMPUTED_ARG
:
1577 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1578 fputs_filtered (" = ", stream
);
1580 /* We have to look up the symbol because arguments can have
1581 two entries (one a parameter, one a local) and the one we
1582 want is the local, which lookup_symbol will find for us.
1583 This includes gcc1 (not gcc2) on the sparc when passing a
1584 small structure and gcc2 when the argument type is float
1585 and it is passed as a double and converted to float by
1586 the prologue (in the latter case the type of the LOC_ARG
1587 symbol is double and the type of the LOC_LOCAL symbol is
1588 float). There are also LOC_ARG/LOC_REGISTER pairs which
1589 are not combined in symbol-reading. */
1591 sym2
= lookup_symbol (DEPRECATED_SYMBOL_NAME (sym
),
1592 b
, VAR_DOMAIN
, NULL
, NULL
);
1593 print_variable_value (sym2
, frame
, stream
);
1594 fprintf_filtered (stream
, "\n");
1598 /* Don't worry about things which aren't arguments. */
1603 if (!values_printed
)
1604 fprintf_filtered (stream
, _("No arguments.\n"));
1608 args_info (char *ignore
, int from_tty
)
1610 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1616 args_plus_locals_info (char *ignore
, int from_tty
)
1618 args_info (ignore
, from_tty
);
1619 locals_info (ignore
, from_tty
);
1623 /* Select frame FRAME. Also print the stack frame and show the source
1624 if this is the tui version. */
1626 select_and_print_frame (struct frame_info
*frame
)
1628 select_frame (frame
);
1630 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1633 /* Return the symbol-block in which the selected frame is executing.
1634 Can return zero under various legitimate circumstances.
1636 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1637 code address within the block returned. We use this to decide
1638 which macros are in scope. */
1641 get_selected_block (CORE_ADDR
*addr_in_block
)
1643 if (!target_has_stack
)
1646 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1649 /* Find a frame a certain number of levels away from FRAME.
1650 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1651 Positive means go to earlier frames (up); negative, the reverse.
1652 The int that contains the number of levels is counted toward
1653 zero as the frames for those levels are found.
1654 If the top or bottom frame is reached, that frame is returned,
1655 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1656 how much farther the original request asked to go. */
1659 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1661 /* Going up is simple: just call get_prev_frame enough times or
1662 until the initial frame is reached. */
1663 while (*level_offset_ptr
> 0)
1665 struct frame_info
*prev
= get_prev_frame (frame
);
1668 (*level_offset_ptr
)--;
1672 /* Going down is just as simple. */
1673 while (*level_offset_ptr
< 0)
1675 struct frame_info
*next
= get_next_frame (frame
);
1678 (*level_offset_ptr
)++;
1685 /* The "select_frame" command. With no argument this is a NOP.
1686 Select the frame at level LEVEL_EXP if it is a valid level.
1687 Otherwise, treat LEVEL_EXP as an address expression and select it.
1689 See parse_frame_specification for more info on proper frame
1693 select_frame_command (char *level_exp
, int from_tty
)
1695 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1698 /* The "frame" command. With no argument, print the selected frame
1699 briefly. With an argument, behave like select_frame and then print
1700 the selected frame. */
1703 frame_command (char *level_exp
, int from_tty
)
1705 select_frame_command (level_exp
, from_tty
);
1706 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1709 /* The XDB Compatibility command to print the current frame. */
1712 current_frame_command (char *level_exp
, int from_tty
)
1714 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1717 /* Select the frame up one or COUNT_EXP stack levels from the
1718 previously selected frame, and print it briefly. */
1721 up_silently_base (char *count_exp
)
1723 struct frame_info
*frame
;
1727 count
= parse_and_eval_long (count_exp
);
1729 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1730 if (count
!= 0 && count_exp
== NULL
)
1731 error (_("Initial frame selected; you cannot go up."));
1732 select_frame (frame
);
1736 up_silently_command (char *count_exp
, int from_tty
)
1738 up_silently_base (count_exp
);
1742 up_command (char *count_exp
, int from_tty
)
1744 up_silently_base (count_exp
);
1745 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1748 /* Select the frame down one or COUNT_EXP stack levels from the previously
1749 selected frame, and print it briefly. */
1752 down_silently_base (char *count_exp
)
1754 struct frame_info
*frame
;
1757 count
= -parse_and_eval_long (count_exp
);
1759 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1760 if (count
!= 0 && count_exp
== NULL
)
1762 /* We only do this if COUNT_EXP is not specified. That way
1763 "down" means to really go down (and let me know if that is
1764 impossible), but "down 9999" can be used to mean go all the
1765 way down without getting an error. */
1767 error (_("Bottom (innermost) frame selected; you cannot go down."));
1770 select_frame (frame
);
1774 down_silently_command (char *count_exp
, int from_tty
)
1776 down_silently_base (count_exp
);
1780 down_command (char *count_exp
, int from_tty
)
1782 down_silently_base (count_exp
);
1783 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1788 return_command (char *retval_exp
, int from_tty
)
1790 struct symbol
*thisfun
;
1791 struct value
*return_value
= NULL
;
1792 const char *query_prefix
= "";
1794 thisfun
= get_frame_function (get_selected_frame ("No selected frame."));
1796 /* Compute the return value. If the computation triggers an error,
1797 let it bail. If the return type can't be handled, set
1798 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1802 struct type
*return_type
= NULL
;
1804 /* Compute the return value. Should the computation fail, this
1805 call throws an error. */
1806 return_value
= parse_and_eval (retval_exp
);
1808 /* Cast return value to the return type of the function. Should
1809 the cast fail, this call throws an error. */
1810 if (thisfun
!= NULL
)
1811 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1812 if (return_type
== NULL
)
1813 return_type
= builtin_type_int
;
1814 CHECK_TYPEDEF (return_type
);
1815 return_value
= value_cast (return_type
, return_value
);
1817 /* Make sure the value is fully evaluated. It may live in the
1818 stack frame we're about to pop. */
1819 if (value_lazy (return_value
))
1820 value_fetch_lazy (return_value
);
1822 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1823 /* If the return-type is "void", don't try to find the
1824 return-value's location. However, do still evaluate the
1825 return expression so that, even when the expression result
1826 is discarded, side effects such as "return i++" still
1828 return_value
= NULL
;
1829 else if (using_struct_return (SYMBOL_TYPE (thisfun
), return_type
))
1832 The location at which to store the function's return value is unknown.\n\
1833 If you continue, the return value that you specified will be ignored.\n";
1834 return_value
= NULL
;
1838 /* Does an interactive user really want to do this? Include
1839 information, such as how well GDB can handle the return value, in
1840 the query message. */
1844 if (thisfun
== NULL
)
1845 confirmed
= query (_("%sMake selected stack frame return now? "),
1848 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1849 SYMBOL_PRINT_NAME (thisfun
));
1851 error (_("Not confirmed"));
1854 /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
1855 frame in turn, should this code just go straight to the relevant
1856 frame and pop that? */
1858 /* First discard all frames inner-to the selected frame (making the
1859 selected frame current). */
1861 struct frame_id selected_id
= get_frame_id (get_selected_frame (NULL
));
1862 while (!frame_id_eq (selected_id
, get_frame_id (get_current_frame ())))
1864 struct frame_info
*frame
= get_current_frame ();
1865 if (frame_id_inner (get_frame_arch (frame
), selected_id
,
1866 get_frame_id (frame
)))
1867 /* Caught in the safety net, oops! We've gone way past the
1869 error (_("Problem while popping stack frames (corrupt stack?)"));
1870 frame_pop (get_current_frame ());
1874 /* Second discard the selected frame (which is now also the current
1876 frame_pop (get_current_frame ());
1878 /* Store RETURN_VALUE in the just-returned register set. */
1879 if (return_value
!= NULL
)
1881 struct type
*return_type
= value_type (return_value
);
1882 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1883 gdb_assert (gdbarch_return_value (gdbarch
, SYMBOL_TYPE (thisfun
),
1884 return_type
, NULL
, NULL
, NULL
)
1885 == RETURN_VALUE_REGISTER_CONVENTION
);
1886 gdbarch_return_value (gdbarch
, SYMBOL_TYPE (thisfun
), return_type
,
1887 get_current_regcache (), NULL
/*read*/,
1888 value_contents (return_value
) /*write*/);
1891 /* If we are at the end of a call dummy now, pop the dummy frame
1893 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1894 frame_pop (get_current_frame ());
1896 /* If interactive, print the frame that is now current. */
1898 frame_command ("0", 1);
1900 select_frame_command ("0", 0);
1903 /* Sets the scope to input function name, provided that the function
1904 is within the current stack frame */
1906 struct function_bounds
1908 CORE_ADDR low
, high
;
1912 func_command (char *arg
, int from_tty
)
1914 struct frame_info
*frame
;
1916 struct symtabs_and_lines sals
;
1919 struct function_bounds
*func_bounds
= NULL
;
1924 frame
= parse_frame_specification ("0");
1925 sals
= decode_line_spec (arg
, 1);
1926 func_bounds
= (struct function_bounds
*) xmalloc (
1927 sizeof (struct function_bounds
) * sals
.nelts
);
1928 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1930 if (sals
.sals
[i
].pc
== 0
1931 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
1932 &func_bounds
[i
].low
,
1933 &func_bounds
[i
].high
) == 0)
1935 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
1941 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1942 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
1943 && get_frame_pc (frame
) < func_bounds
[i
].high
);
1947 frame
= find_relative_frame (frame
, &level
);
1950 while (!found
&& level
== 0);
1953 xfree (func_bounds
);
1956 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
1957 else if (frame
!= get_selected_frame (NULL
))
1958 select_and_print_frame (frame
);
1961 /* Gets the language of the current frame. */
1964 get_frame_language (void)
1966 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
1970 /* We determine the current frame language by looking up its
1971 associated symtab. To retrieve this symtab, we use the frame
1972 PC. However we cannot use the frame PC as is, because it
1973 usually points to the instruction following the "call", which
1974 is sometimes the first instruction of another function. So
1975 we rely on get_frame_address_in_block(), it provides us with
1976 a PC that is guaranteed to be inside the frame's code
1978 CORE_ADDR pc
= get_frame_address_in_block (frame
);
1979 struct symtab
*s
= find_pc_symtab (pc
);
1985 return language_unknown
;
1989 /* Provide a prototype to silence -Wmissing-prototypes. */
1990 void _initialize_stack (void);
1993 _initialize_stack (void)
1996 backtrace_limit
= 30;
1999 add_com ("return", class_stack
, return_command
, _("\
2000 Make selected stack frame return to its caller.\n\
2001 Control remains in the debugger, but when you continue\n\
2002 execution will resume in the frame above the one now selected.\n\
2003 If an argument is given, it is an expression for the value to return."));
2005 add_com ("up", class_stack
, up_command
, _("\
2006 Select and print stack frame that called this one.\n\
2007 An argument says how many frames up to go."));
2008 add_com ("up-silently", class_support
, up_silently_command
, _("\
2009 Same as the `up' command, but does not print anything.\n\
2010 This is useful in command scripts."));
2012 add_com ("down", class_stack
, down_command
, _("\
2013 Select and print stack frame called by this one.\n\
2014 An argument says how many frames down to go."));
2015 add_com_alias ("do", "down", class_stack
, 1);
2016 add_com_alias ("dow", "down", class_stack
, 1);
2017 add_com ("down-silently", class_support
, down_silently_command
, _("\
2018 Same as the `down' command, but does not print anything.\n\
2019 This is useful in command scripts."));
2021 add_com ("frame", class_stack
, frame_command
, _("\
2022 Select and print a stack frame.\n\
2023 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2024 An argument specifies the frame to select.\n\
2025 It can be a stack frame number or the address of the frame.\n\
2026 With argument, nothing is printed if input is coming from\n\
2027 a command file or a user-defined command."));
2029 add_com_alias ("f", "frame", class_stack
, 1);
2033 add_com ("L", class_stack
, current_frame_command
,
2034 _("Print the current stack frame.\n"));
2035 add_com_alias ("V", "frame", class_stack
, 1);
2037 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2038 Select a stack frame without printing anything.\n\
2039 An argument specifies the frame to select.\n\
2040 It can be a stack frame number or the address of the frame.\n"));
2042 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2043 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2044 With a negative argument, print outermost -COUNT frames.\n\
2045 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2046 add_com_alias ("bt", "backtrace", class_stack
, 0);
2049 add_com_alias ("t", "backtrace", class_stack
, 0);
2050 add_com ("T", class_stack
, backtrace_full_command
, _("\
2051 Print backtrace of all stack frames, or innermost COUNT frames \n\
2052 and the values of the local variables.\n\
2053 With a negative argument, print outermost -COUNT frames.\n\
2054 Usage: T <count>\n"));
2057 add_com_alias ("where", "backtrace", class_alias
, 0);
2058 add_info ("stack", backtrace_command
,
2059 _("Backtrace of the stack, or innermost COUNT frames."));
2060 add_info_alias ("s", "stack", 1);
2061 add_info ("frame", frame_info
,
2062 _("All about selected stack frame, or frame at ADDR."));
2063 add_info_alias ("f", "frame", 1);
2064 add_info ("locals", locals_info
,
2065 _("Local variables of current stack frame."));
2066 add_info ("args", args_info
,
2067 _("Argument variables of current stack frame."));
2069 add_com ("l", class_info
, args_plus_locals_info
,
2070 _("Argument and local variables of current stack frame."));
2073 add_com ("func", class_stack
, func_command
, _("\
2074 Select the stack frame that contains <func>.\n\
2075 Usage: func <name>\n"));
2077 add_info ("catch", catch_info
,
2078 _("Exceptions that can be caught in the current stack frame."));
2080 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2081 print_frame_arguments_choices
, &print_frame_arguments
,
2082 _("Set printing of non-scalar frame arguments"),
2083 _("Show printing of non-scalar frame arguments"),
2084 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2087 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2088 "Specify maximum number of frames for \"backtrace\" to print by default."),
2090 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2091 The maximum number of frames for \"backtrace\" to print by default."));