1 /* Print and select stack frames for GDB, the GNU debugger.
2 Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "gdb_string.h"
27 #include "expression.h"
33 #include "breakpoint.h"
40 /* Prototypes for exported functions. */
42 void args_info
PARAMS ((char *, int));
44 void locals_info
PARAMS ((char *, int));
46 void (*selected_frame_level_changed_hook
) PARAMS ((int));
48 void _initialize_stack
PARAMS ((void));
50 /* Prototypes for local functions. */
52 static void return_command
PARAMS ((char *, int));
54 static void down_command
PARAMS ((char *, int));
56 static void down_silently_command
PARAMS ((char *, int));
58 static void up_command
PARAMS ((char *, int));
60 static void up_silently_command
PARAMS ((char *, int));
62 static void frame_command
PARAMS ((char *, int));
64 static void select_frame_command
PARAMS ((char *, int));
66 static void print_frame_arg_vars
PARAMS ((struct frame_info
*, GDB_FILE
*));
68 static void catch_info
PARAMS ((char *, int));
70 static void print_frame_label_vars
PARAMS ((struct frame_info
*, int,
73 static void print_frame_local_vars
PARAMS ((struct frame_info
*, GDB_FILE
*));
75 static int print_block_frame_labels
PARAMS ((struct block
*, int *,
78 static int print_block_frame_locals
PARAMS ((struct block
*,
82 static void backtrace_command
PARAMS ((char *, int));
84 static struct frame_info
*parse_frame_specification
PARAMS ((char *));
86 static void frame_info
PARAMS ((char *, int));
88 extern int addressprint
; /* Print addresses, or stay symbolic only? */
89 extern int info_verbose
; /* Verbosity of symbol reading msgs */
90 extern int lines_to_list
; /* # of lines "list" command shows by default */
92 /* The "selected" stack frame is used by default for local and arg access.
93 May be zero, for no selected frame. */
95 struct frame_info
*selected_frame
;
97 /* Level of the selected frame:
98 0 for innermost, 1 for its caller, ...
99 or -1 for frame specified by address with no defined level. */
101 int selected_frame_level
;
103 /* Zero means do things normally; we are interacting directly with the
104 user. One means print the full filename and linenumber when a
105 frame is printed, and do so in a format emacs18/emacs19.22 can
106 parse. Two means print similar annotations, but in many more
107 cases and in a slightly different syntax. */
109 int annotation_level
= 0;
112 struct print_stack_frame_args
{
113 struct frame_info
*fi
;
119 static int print_stack_frame_stub
PARAMS ((char *));
121 /* Pass the args the way catch_errors wants them. */
123 print_stack_frame_stub (args
)
126 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*)args
;
128 print_frame_info (p
->fi
, p
->level
, p
->source
, p
->args
);
132 /* Print a stack frame briefly. FRAME_INFI should be the frame info
133 and LEVEL should be its level in the stack (or -1 for level not defined).
134 This prints the level, the function executing, the arguments,
135 and the file name and line number.
136 If the pc is not at the beginning of the source line,
137 the actual pc is printed at the beginning.
139 If SOURCE is 1, print the source line as well.
140 If SOURCE is -1, print ONLY the source line. */
143 print_stack_frame (fi
, level
, source
)
144 struct frame_info
*fi
;
148 struct print_stack_frame_args args
;
152 args
.source
= source
;
155 catch_errors (print_stack_frame_stub
, (char *)&args
, "", RETURN_MASK_ALL
);
158 struct print_args_args
{
160 struct frame_info
*fi
;
163 static int print_args_stub
PARAMS ((char *));
165 /* Pass the args the way catch_errors wants them. */
168 print_args_stub (args
)
172 struct print_args_args
*p
= (struct print_args_args
*)args
;
174 FRAME_NUM_ARGS (numargs
, (p
->fi
));
175 print_frame_args (p
->func
, p
->fi
, numargs
, gdb_stdout
);
179 /* LEVEL is the level of the frame, or -1 if it is the innermost frame
180 but we don't want to print the level. */
183 print_frame_info (fi
, level
, source
, args
)
184 struct frame_info
*fi
;
189 struct symtab_and_line sal
;
191 register char *funname
= 0;
192 enum language funlang
= language_unknown
;
195 char buf
[MAX_REGISTER_RAW_SIZE
];
198 /* On the 68k, this spends too much time in m68k_find_saved_regs. */
200 /* Get the value of SP_REGNUM relative to the frame. */
201 get_saved_register (buf
, (int *)NULL
, (CORE_ADDR
*)NULL
,
202 FRAME_INFO_ID (fi
), SP_REGNUM
, (enum lval_type
*)NULL
);
203 sp
= extract_address (buf
, REGISTER_RAW_SIZE (SP_REGNUM
));
205 /* This is not a perfect test, because if a function alloca's some
206 memory, puts some code there, and then jumps into it, then the test
207 will succeed even though there is no call dummy. Probably best is
208 to check for a bp_call_dummy breakpoint. */
209 if (PC_IN_CALL_DUMMY (fi
->pc
, sp
, fi
->frame
))
211 if (frame_in_dummy (fi
))
214 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
216 /* Do this regardless of SOURCE because we don't have any source
217 to list for this frame. */
219 printf_filtered ("#%-2d ", level
);
220 annotate_function_call ();
221 printf_filtered ("<function called from gdb>\n");
222 annotate_frame_end ();
225 if (fi
->signal_handler_caller
)
227 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
229 /* Do this regardless of SOURCE because we don't have any source
230 to list for this frame. */
232 printf_filtered ("#%-2d ", level
);
233 annotate_signal_handler_caller ();
234 printf_filtered ("<signal handler called>\n");
235 annotate_frame_end ();
239 /* If fi is not the innermost frame, that normally means that fi->pc
240 points to *after* the call instruction, and we want to get the line
241 containing the call, never the next line. But if the next frame is
242 a signal_handler_caller or a dummy frame, then the next frame was
243 not entered as the result of a call, and we want to get the line
244 containing fi->pc. */
246 find_pc_line (fi
->pc
,
248 && !fi
->next
->signal_handler_caller
249 && !frame_in_dummy (fi
->next
));
251 func
= find_pc_function (fi
->pc
);
254 /* In certain pathological cases, the symtabs give the wrong
255 function (when we are in the first function in a file which
256 is compiled without debugging symbols, the previous function
257 is compiled with debugging symbols, and the "foo.o" symbol
258 that is supposed to tell us where the file with debugging symbols
259 ends has been truncated by ar because it is longer than 15
260 characters). This also occurs if the user uses asm() to create
261 a function but not stabs for it (in a file compiled -g).
263 So look in the minimal symbol tables as well, and if it comes
264 up with a larger address for the function use that instead.
265 I don't think this can ever cause any problems; there shouldn't
266 be any minimal symbols in the middle of a function; if this is
267 ever changed many parts of GDB will need to be changed (and we'll
268 create a find_pc_minimal_function or some such). */
270 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
272 && (SYMBOL_VALUE_ADDRESS (msymbol
)
273 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
276 /* There is no particular reason to think the line number
277 information is wrong. Someone might have just put in
278 a label with asm() but left the line numbers alone. */
279 /* In this case we have no way of knowing the source file
280 and line number, so don't print them. */
283 /* We also don't know anything about the function besides
284 its address and name. */
286 funname
= SYMBOL_NAME (msymbol
);
287 funlang
= SYMBOL_LANGUAGE (msymbol
);
291 funname
= SYMBOL_NAME (func
);
292 funlang
= SYMBOL_LANGUAGE (func
);
297 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
300 funname
= SYMBOL_NAME (msymbol
);
301 funlang
= SYMBOL_LANGUAGE (msymbol
);
305 if (source
>= 0 || !sal
.symtab
)
307 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
310 printf_filtered ("#%-2d ", level
);
312 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
)
314 annotate_frame_address ();
315 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
316 annotate_frame_address_end ();
317 printf_filtered (" in ");
319 annotate_frame_function_name ();
320 fprintf_symbol_filtered (gdb_stdout
, funname
? funname
: "??", funlang
,
323 annotate_frame_args ();
324 fputs_filtered (" (", gdb_stdout
);
327 struct print_args_args args
;
330 catch_errors (print_args_stub
, (char *)&args
, "", RETURN_MASK_ALL
);
333 printf_filtered (")");
334 if (sal
.symtab
&& sal
.symtab
->filename
)
336 annotate_frame_source_begin ();
338 printf_filtered (" at ");
339 annotate_frame_source_file ();
340 printf_filtered ("%s", sal
.symtab
->filename
);
341 annotate_frame_source_file_end ();
342 printf_filtered (":");
343 annotate_frame_source_line ();
344 printf_filtered ("%d", sal
.line
);
345 annotate_frame_source_end ();
348 #ifdef PC_LOAD_SEGMENT
349 /* If we couldn't print out function name but if can figure out what
350 load segment this pc value is from, at least print out some info
351 about its load segment. */
354 annotate_frame_where ();
356 printf_filtered (" from %s", PC_LOAD_SEGMENT (fi
->pc
));
362 char *lib
= PC_SOLIB (fi
->pc
);
365 annotate_frame_where ();
367 printf_filtered (" from %s", lib
);
371 printf_filtered ("\n");
374 if ((source
!= 0) && sal
.symtab
)
377 int mid_statement
= source
< 0 && fi
->pc
!= sal
.pc
;
378 if (annotation_level
)
379 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
383 if (addressprint
&& mid_statement
)
385 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
386 printf_filtered ("\t");
388 if (print_frame_info_listing_hook
)
389 print_frame_info_listing_hook (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
391 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
393 current_source_line
= max (sal
.line
- lines_to_list
/2, 1);
396 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
398 annotate_frame_end ();
400 gdb_flush (gdb_stdout
);
403 /* Read a frame specification in whatever the appropriate format is.
404 Call error() if the specification is in any way invalid (i.e.
405 this function never returns NULL). */
407 static struct frame_info
*
408 parse_frame_specification (frame_exp
)
413 CORE_ADDR args
[MAXARGS
];
417 char *addr_string
, *p
;
418 struct cleanup
*tmp_cleanup
;
420 while (*frame_exp
== ' ') frame_exp
++;
424 if (numargs
> MAXARGS
)
425 error ("Too many args in frame specification");
426 /* Parse an argument. */
427 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
429 addr_string
= savestring(frame_exp
, p
- frame_exp
);
432 tmp_cleanup
= make_cleanup (free
, addr_string
);
433 args
[numargs
++] = parse_and_eval_address (addr_string
);
434 do_cleanups (tmp_cleanup
);
437 /* Skip spaces, move to possible next arg. */
438 while (*p
== ' ') p
++;
446 if (selected_frame
== NULL
)
447 error ("No selected frame.");
448 return selected_frame
;
453 struct frame_info
*fid
=
454 find_relative_frame (get_current_frame (), &level
);
455 struct frame_info
*tfid
;
458 /* find_relative_frame was successful */
461 /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
462 take at least 2 addresses. It is important to detect this case
463 here so that "frame 100" does not give a confusing error message
464 like "frame specification requires two addresses". This of course
465 does not solve the "frame 100" problem for machines on which
466 a frame specification can be made with one address. To solve
467 that, we need a new syntax for a specifying a frame by address.
468 I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
469 two args, etc.), but people might think that is too much typing,
470 so I guess *0x23,0x45 would be a possible alternative (commas
471 really should be used instead of spaces to delimit; using spaces
472 normally works in an expression). */
473 #ifdef SETUP_ARBITRARY_FRAME
474 error ("No frame %d", args
[0]);
477 /* If (s)he specifies the frame with an address, he deserves what
478 (s)he gets. Still, give the highest one that matches. */
480 for (fid
= get_current_frame ();
481 fid
&& fid
->frame
!= args
[0];
482 fid
= get_prev_frame (fid
))
486 while ((tfid
= get_prev_frame (fid
)) &&
487 (tfid
->frame
== args
[0]))
490 /* We couldn't identify the frame as an existing frame, but
491 perhaps we can create one with a single argument. */
495 #ifdef SETUP_ARBITRARY_FRAME
496 return SETUP_ARBITRARY_FRAME (numargs
, args
);
498 /* Usual case. Do it here rather than have everyone supply
499 a SETUP_ARBITRARY_FRAME that does this. */
501 return create_new_frame (args
[0], 0);
502 error ("Too many args in frame specification");
509 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
510 that if it is unsure about the answer, it returns 0
511 instead of guessing (this happens on the VAX and i960, for example).
513 On most machines, we never have to guess about the args address,
514 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
515 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
516 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
519 /* Print verbosely the selected frame or the frame at address ADDR.
520 This means absolutely all information in the frame is printed. */
523 frame_info (addr_exp
, from_tty
)
527 struct frame_info
*fi
;
528 struct frame_saved_regs fsr
;
529 struct symtab_and_line sal
;
532 struct frame_info
*calling_frame_info
;
533 int i
, count
, numregs
;
535 enum language funlang
= language_unknown
;
537 if (!target_has_stack
)
540 fi
= parse_frame_specification (addr_exp
);
542 error ("Invalid frame specified.");
544 sal
= find_pc_line (fi
->pc
,
546 && !fi
->next
->signal_handler_caller
547 && !frame_in_dummy (fi
->next
));
548 func
= get_frame_function (fi
);
549 s
= find_pc_symtab(fi
->pc
);
552 funname
= SYMBOL_NAME (func
);
553 funlang
= SYMBOL_LANGUAGE (func
);
557 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
560 funname
= SYMBOL_NAME (msymbol
);
561 funlang
= SYMBOL_LANGUAGE (msymbol
);
564 calling_frame_info
= get_prev_frame (fi
);
566 if (!addr_exp
&& selected_frame_level
>= 0)
568 printf_filtered ("Stack level %d, frame at ", selected_frame_level
);
569 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
570 printf_filtered (":\n");
574 printf_filtered ("Stack frame at ");
575 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
576 printf_filtered (":\n");
578 printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM
));
579 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
584 printf_filtered (" in ");
585 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
586 DMGL_ANSI
| DMGL_PARAMS
);
590 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
591 puts_filtered ("; ");
593 printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM
));
594 print_address_numeric (FRAME_SAVED_PC (fi
), 1, gdb_stdout
);
595 printf_filtered ("\n");
599 #ifdef FRAMELESS_FUNCTION_INVOCATION
600 FRAMELESS_FUNCTION_INVOCATION (fi
, frameless
);
603 printf_filtered (" (FRAMELESS),");
606 if (calling_frame_info
)
608 printf_filtered (" called by frame at ");
609 print_address_numeric (calling_frame_info
->frame
, 1, gdb_stdout
);
611 if (fi
->next
&& calling_frame_info
)
616 printf_filtered (" caller of frame at ");
617 print_address_numeric (fi
->next
->frame
, 1, gdb_stdout
);
619 if (fi
->next
|| calling_frame_info
)
620 puts_filtered ("\n");
622 printf_filtered (" source language %s.\n", language_str (s
->language
));
624 #ifdef PRINT_EXTRA_FRAME_INFO
625 PRINT_EXTRA_FRAME_INFO (fi
);
629 /* Address of the argument list for this frame, or 0. */
630 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
631 /* Number of args for this frame, or -1 if unknown. */
635 printf_filtered (" Arglist at unknown address.\n");
638 printf_filtered (" Arglist at ");
639 print_address_numeric (arg_list
, 1, gdb_stdout
);
640 printf_filtered (",");
642 FRAME_NUM_ARGS (numargs
, fi
);
644 puts_filtered (" args: ");
645 else if (numargs
== 0)
646 puts_filtered (" no args.");
647 else if (numargs
== 1)
648 puts_filtered (" 1 arg: ");
650 printf_filtered (" %d args: ", numargs
);
651 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
652 puts_filtered ("\n");
656 /* Address of the local variables for this frame, or 0. */
657 CORE_ADDR arg_list
= FRAME_LOCALS_ADDRESS (fi
);
660 printf_filtered (" Locals at unknown address,");
663 printf_filtered (" Locals at ");
664 print_address_numeric (arg_list
, 1, gdb_stdout
);
665 printf_filtered (",");
669 #if defined (FRAME_FIND_SAVED_REGS)
670 get_frame_saved_regs (fi
, &fsr
);
671 /* The sp is special; what's returned isn't the save address, but
672 actually the value of the previous frame's sp. */
673 printf_filtered (" Previous frame's sp is ");
674 print_address_numeric (fsr
.regs
[SP_REGNUM
], 1, gdb_stdout
);
675 printf_filtered ("\n");
677 numregs
= ARCH_NUM_REGS
;
678 for (i
= 0; i
< numregs
; i
++)
679 if (fsr
.regs
[i
] && i
!= SP_REGNUM
)
682 puts_filtered (" Saved registers:\n ");
686 printf_filtered (" %s at ", REGISTER_NAME (i
));
687 print_address_numeric (fsr
.regs
[i
], 1, gdb_stdout
);
691 puts_filtered ("\n");
692 #else /* Have FRAME_FIND_SAVED_REGS. */
693 /* We could get some information about saved registers by calling
694 get_saved_register on each register. Which info goes with which frame
695 is necessarily lost, however, and I suspect that the users don't care
696 whether they get the info. */
697 puts_filtered ("\n");
698 #endif /* Have FRAME_FIND_SAVED_REGS. */
702 /* Set a limit on the number of frames printed by default in a
705 static int backtrace_limit
;
708 set_backtrace_limit_command (count_exp
, from_tty
)
712 int count
= parse_and_eval_address (count_exp
);
715 error ("Negative argument not meaningful as backtrace limit.");
717 backtrace_limit
= count
;
721 backtrace_limit_info (arg
, from_tty
)
726 error ("\"Info backtrace-limit\" takes no arguments.");
728 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit
);
732 /* Print briefly all stack frames or just the innermost COUNT frames. */
735 backtrace_command (count_exp
, from_tty
)
739 struct frame_info
*fi
;
742 register struct frame_info
*trailing
;
743 register int trailing_level
;
745 if (!target_has_stack
)
748 /* The following code must do two things. First, it must
749 set the variable TRAILING to the frame from which we should start
750 printing. Second, it must set the variable count to the number
751 of frames which we should print, or -1 if all of them. */
752 trailing
= get_current_frame ();
756 count
= parse_and_eval_address (count_exp
);
759 struct frame_info
*current
;
764 while (current
&& count
--)
767 current
= get_prev_frame (current
);
770 /* Will stop when CURRENT reaches the top of the stack. TRAILING
771 will be COUNT below it. */
775 trailing
= get_prev_frame (trailing
);
776 current
= get_prev_frame (current
);
788 struct partial_symtab
*ps
;
790 /* Read in symbols for all of the frames. Need to do this in
791 a separate pass so that "Reading in symbols for xxx" messages
792 don't screw up the appearance of the backtrace. Also
793 if people have strong opinions against reading symbols for
794 backtrace this may have to be an option. */
798 fi
= get_prev_frame (fi
))
801 ps
= find_pc_psymtab (fi
->pc
);
803 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
807 for (i
= 0, fi
= trailing
;
809 i
++, fi
= get_prev_frame (fi
))
813 /* Don't use print_stack_frame; if an error() occurs it probably
814 means further attempts to backtrace would fail (on the other
815 hand, perhaps the code does or could be fixed to make sure
816 the frame->prev field gets set to NULL in that case). */
817 print_frame_info (fi
, trailing_level
+ i
, 0, 1);
820 /* If we've stopped before the end, mention that. */
822 printf_filtered ("(More stack frames follow...)\n");
825 /* Print the local variables of a block B active in FRAME.
826 Return 1 if any variables were printed; 0 otherwise. */
829 print_block_frame_locals (b
, fi
, stream
)
831 register struct frame_info
*fi
;
832 register GDB_FILE
*stream
;
836 register struct symbol
*sym
;
837 register int values_printed
= 0;
839 nsyms
= BLOCK_NSYMS (b
);
841 for (i
= 0; i
< nsyms
; i
++)
843 sym
= BLOCK_SYM (b
, i
);
844 switch (SYMBOL_CLASS (sym
))
851 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
852 fputs_filtered (" = ", stream
);
853 print_variable_value (sym
, fi
, stream
);
854 fprintf_filtered (stream
, "\n");
858 /* Ignore symbols which are not locals. */
862 return values_printed
;
865 /* Same, but print labels. */
868 print_block_frame_labels (b
, have_default
, stream
)
871 register GDB_FILE
*stream
;
875 register struct symbol
*sym
;
876 register int values_printed
= 0;
878 nsyms
= BLOCK_NSYMS (b
);
880 for (i
= 0; i
< nsyms
; i
++)
882 sym
= BLOCK_SYM (b
, i
);
883 if (STREQ (SYMBOL_NAME (sym
), "default"))
889 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
891 struct symtab_and_line sal
;
892 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
894 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
897 fprintf_filtered (stream
, " ");
898 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, stream
);
900 fprintf_filtered (stream
, " in file %s, line %d\n",
901 sal
.symtab
->filename
, sal
.line
);
904 return values_printed
;
907 /* Print on STREAM all the local variables in frame FRAME,
908 including all the blocks active in that frame
911 Returns 1 if the job was done,
912 or 0 if nothing was printed because we have no info
913 on the function running in FRAME. */
916 print_frame_local_vars (fi
, stream
)
917 register struct frame_info
*fi
;
918 register GDB_FILE
*stream
;
920 register struct block
*block
= get_frame_block (fi
);
921 register int values_printed
= 0;
925 fprintf_filtered (stream
, "No symbol table info available.\n");
931 if (print_block_frame_locals (block
, fi
, stream
))
933 /* After handling the function's top-level block, stop.
934 Don't continue to its superblock, the block of
936 if (BLOCK_FUNCTION (block
))
938 block
= BLOCK_SUPERBLOCK (block
);
943 fprintf_filtered (stream
, "No locals.\n");
947 /* Same, but print labels. */
950 print_frame_label_vars (fi
, this_level_only
, stream
)
951 register struct frame_info
*fi
;
953 register GDB_FILE
*stream
;
955 register struct blockvector
*bl
;
956 register struct block
*block
= get_frame_block (fi
);
957 register int values_printed
= 0;
958 int index
, have_default
= 0;
959 char *blocks_printed
;
960 CORE_ADDR pc
= fi
->pc
;
964 fprintf_filtered (stream
, "No symbol table info available.\n");
968 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
969 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
970 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
974 CORE_ADDR end
= BLOCK_END (block
) - 4;
977 if (bl
!= blockvector_for_pc (end
, &index
))
978 error ("blockvector blotch");
979 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
980 error ("blockvector botch");
981 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
984 /* Don't print out blocks that have gone by. */
985 while (index
< last_index
986 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
989 while (index
< last_index
990 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
992 if (blocks_printed
[index
] == 0)
994 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
996 blocks_printed
[index
] = 1;
1002 if (values_printed
&& this_level_only
)
1005 /* After handling the function's top-level block, stop.
1006 Don't continue to its superblock, the block of
1007 per-file symbols. */
1008 if (BLOCK_FUNCTION (block
))
1010 block
= BLOCK_SUPERBLOCK (block
);
1013 if (!values_printed
&& !this_level_only
)
1015 fprintf_filtered (stream
, "No catches.\n");
1021 locals_info (args
, from_tty
)
1025 if (!selected_frame
)
1026 error ("No frame selected.");
1027 print_frame_local_vars (selected_frame
, gdb_stdout
);
1031 catch_info (ignore
, from_tty
)
1035 if (!selected_frame
)
1036 error ("No frame selected.");
1037 print_frame_label_vars (selected_frame
, 0, gdb_stdout
);
1041 print_frame_arg_vars (fi
, stream
)
1042 register struct frame_info
*fi
;
1043 register GDB_FILE
*stream
;
1045 struct symbol
*func
= get_frame_function (fi
);
1046 register struct block
*b
;
1049 register struct symbol
*sym
, *sym2
;
1050 register int values_printed
= 0;
1054 fprintf_filtered (stream
, "No symbol table info available.\n");
1058 b
= SYMBOL_BLOCK_VALUE (func
);
1059 nsyms
= BLOCK_NSYMS (b
);
1061 for (i
= 0; i
< nsyms
; i
++)
1063 sym
= BLOCK_SYM (b
, i
);
1064 switch (SYMBOL_CLASS (sym
))
1070 case LOC_REGPARM_ADDR
:
1071 case LOC_BASEREG_ARG
:
1073 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1074 fputs_filtered (" = ", stream
);
1076 /* We have to look up the symbol because arguments can have
1077 two entries (one a parameter, one a local) and the one we
1078 want is the local, which lookup_symbol will find for us.
1079 This includes gcc1 (not gcc2) on the sparc when passing a
1080 small structure and gcc2 when the argument type is float
1081 and it is passed as a double and converted to float by
1082 the prologue (in the latter case the type of the LOC_ARG
1083 symbol is double and the type of the LOC_LOCAL symbol is
1084 float). There are also LOC_ARG/LOC_REGISTER pairs which
1085 are not combined in symbol-reading. */
1087 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
1088 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
1089 print_variable_value (sym2
, fi
, stream
);
1090 fprintf_filtered (stream
, "\n");
1094 /* Don't worry about things which aren't arguments. */
1099 if (!values_printed
)
1101 fprintf_filtered (stream
, "No arguments.\n");
1106 args_info (ignore
, from_tty
)
1110 if (!selected_frame
)
1111 error ("No frame selected.");
1112 print_frame_arg_vars (selected_frame
, gdb_stdout
);
1116 /* Select frame FI, and note that its stack level is LEVEL.
1117 LEVEL may be -1 if an actual level number is not known. */
1120 select_frame (fi
, level
)
1121 struct frame_info
*fi
;
1124 register struct symtab
*s
;
1126 selected_frame
= fi
;
1127 selected_frame_level
= level
;
1128 if (selected_frame_level_changed_hook
)
1129 selected_frame_level_changed_hook (level
);
1131 /* Ensure that symbols for this frame are read in. Also, determine the
1132 source language of this frame, and switch to it if desired. */
1135 s
= find_pc_symtab (fi
->pc
);
1137 && s
->language
!= current_language
->la_language
1138 && s
->language
!= language_unknown
1139 && language_mode
== language_mode_auto
) {
1140 set_language(s
->language
);
1145 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
1146 If there is no selected frame, *FRAMEP is set to NULL. */
1149 record_selected_frame (frameaddrp
, levelp
)
1150 CORE_ADDR
*frameaddrp
;
1153 *frameaddrp
= selected_frame
? selected_frame
->frame
: 0;
1154 *levelp
= selected_frame_level
;
1157 /* Return the symbol-block in which the selected frame is executing.
1158 Can return zero under various legitimate circumstances. */
1161 get_selected_block ()
1163 if (!target_has_stack
)
1166 if (!selected_frame
)
1167 return get_current_block ();
1168 return get_frame_block (selected_frame
);
1171 /* Find a frame a certain number of levels away from FRAME.
1172 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1173 Positive means go to earlier frames (up); negative, the reverse.
1174 The int that contains the number of levels is counted toward
1175 zero as the frames for those levels are found.
1176 If the top or bottom frame is reached, that frame is returned,
1177 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1178 how much farther the original request asked to go. */
1181 find_relative_frame (frame
, level_offset_ptr
)
1182 register struct frame_info
*frame
;
1183 register int *level_offset_ptr
;
1185 register struct frame_info
*prev
;
1186 register struct frame_info
*frame1
;
1188 /* Going up is simple: just do get_prev_frame enough times
1189 or until initial frame is reached. */
1190 while (*level_offset_ptr
> 0)
1192 prev
= get_prev_frame (frame
);
1195 (*level_offset_ptr
)--;
1198 /* Going down is just as simple. */
1199 if (*level_offset_ptr
< 0)
1201 while (*level_offset_ptr
< 0) {
1202 frame1
= get_next_frame (frame
);
1206 (*level_offset_ptr
)++;
1212 /* The "select_frame" command. With no arg, NOP.
1213 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1214 valid level. Otherwise, treat level_exp as an address expression
1215 and select it. See parse_frame_specification for more info on proper
1216 frame expressions. */
1220 select_frame_command (level_exp
, from_tty
)
1224 register struct frame_info
*frame
, *frame1
;
1225 unsigned int level
= 0;
1227 if (!target_has_stack
)
1228 error ("No stack.");
1230 frame
= parse_frame_specification (level_exp
);
1232 /* Try to figure out what level this frame is. But if there is
1233 no current stack, don't error out -- let the user set one. */
1235 if (get_current_frame()) {
1236 for (frame1
= get_prev_frame (0);
1237 frame1
&& frame1
!= frame
;
1238 frame1
= get_prev_frame (frame1
))
1245 select_frame (frame
, level
);
1248 /* The "frame" command. With no arg, print selected frame briefly.
1249 With arg, behaves like select_frame and then prints the selected
1253 frame_command (level_exp
, from_tty
)
1257 select_frame_command (level_exp
, from_tty
);
1258 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1261 /* Select the frame up one or COUNT stack levels
1262 from the previously selected frame, and print it briefly. */
1266 up_silently_command (count_exp
, from_tty
)
1270 register struct frame_info
*fi
;
1271 int count
= 1, count1
;
1273 count
= parse_and_eval_address (count_exp
);
1276 if (target_has_stack
== 0 || selected_frame
== 0)
1277 error ("No stack.");
1279 fi
= find_relative_frame (selected_frame
, &count1
);
1280 if (count1
!= 0 && count_exp
== 0)
1281 error ("Initial frame selected; you cannot go up.");
1282 select_frame (fi
, selected_frame_level
+ count
- count1
);
1286 up_command (count_exp
, from_tty
)
1290 up_silently_command (count_exp
, from_tty
);
1291 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1294 /* Select the frame down one or COUNT stack levels
1295 from the previously selected frame, and print it briefly. */
1299 down_silently_command (count_exp
, from_tty
)
1303 register struct frame_info
*frame
;
1304 int count
= -1, count1
;
1306 count
= - parse_and_eval_address (count_exp
);
1309 if (target_has_stack
== 0 || selected_frame
== 0)
1310 error ("No stack.");
1312 frame
= find_relative_frame (selected_frame
, &count1
);
1313 if (count1
!= 0 && count_exp
== 0)
1316 /* We only do this if count_exp is not specified. That way "down"
1317 means to really go down (and let me know if that is
1318 impossible), but "down 9999" can be used to mean go all the way
1319 down without getting an error. */
1321 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1324 select_frame (frame
, selected_frame_level
+ count
- count1
);
1329 down_command (count_exp
, from_tty
)
1333 down_silently_command (count_exp
, from_tty
);
1334 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1338 return_command (retval_exp
, from_tty
)
1342 struct symbol
*thisfun
;
1343 CORE_ADDR selected_frame_addr
;
1344 CORE_ADDR selected_frame_pc
;
1345 struct frame_info
*frame
;
1346 value_ptr return_value
= NULL
;
1348 if (selected_frame
== NULL
)
1349 error ("No selected frame.");
1350 thisfun
= get_frame_function (selected_frame
);
1351 selected_frame_addr
= FRAME_FP (selected_frame
);
1352 selected_frame_pc
= selected_frame
->pc
;
1354 /* Compute the return value (if any -- possibly getting errors here). */
1358 struct type
*return_type
= NULL
;
1360 return_value
= parse_and_eval (retval_exp
);
1362 /* Cast return value to the return type of the function. */
1363 if (thisfun
!= NULL
)
1364 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1365 if (return_type
== NULL
)
1366 return_type
= builtin_type_int
;
1367 return_value
= value_cast (return_type
, return_value
);
1369 /* Make sure we have fully evaluated it, since
1370 it might live in the stack frame we're about to pop. */
1371 if (VALUE_LAZY (return_value
))
1372 value_fetch_lazy (return_value
);
1375 /* If interactive, require confirmation. */
1381 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun
)))
1383 error ("Not confirmed.");
1388 if (!query ("Make selected stack frame return now? "))
1389 error ("Not confirmed.");
1392 /* Do the real work. Pop until the specified frame is current. We
1393 use this method because the selected_frame is not valid after
1394 a POP_FRAME. The pc comparison makes this work even if the
1395 selected frame shares its fp with another frame. */
1397 while (selected_frame_addr
!= (frame
= get_current_frame())->frame
1398 || selected_frame_pc
!= frame
->pc
)
1401 /* Then pop that frame. */
1405 /* Compute the return value (if any) and store in the place
1406 for return values. */
1409 set_return_value (return_value
);
1411 /* If interactive, print the frame that is now current. */
1414 frame_command ("0", 1);
1416 select_frame_command ("0", 0);
1419 /* Gets the language of the current frame. */
1422 get_frame_language()
1424 register struct symtab
*s
;
1425 enum language flang
; /* The language of the current frame */
1429 s
= find_pc_symtab(selected_frame
->pc
);
1431 flang
= s
->language
;
1433 flang
= language_unknown
;
1436 flang
= language_unknown
;
1442 _initialize_stack ()
1445 backtrace_limit
= 30;
1448 add_com ("return", class_stack
, return_command
,
1449 "Make selected stack frame return to its caller.\n\
1450 Control remains in the debugger, but when you continue\n\
1451 execution will resume in the frame above the one now selected.\n\
1452 If an argument is given, it is an expression for the value to return.");
1454 add_com ("up", class_stack
, up_command
,
1455 "Select and print stack frame that called this one.\n\
1456 An argument says how many frames up to go.");
1457 add_com ("up-silently", class_support
, up_silently_command
,
1458 "Same as the `up' command, but does not print anything.\n\
1459 This is useful in command scripts.");
1461 add_com ("down", class_stack
, down_command
,
1462 "Select and print stack frame called by this one.\n\
1463 An argument says how many frames down to go.");
1464 add_com_alias ("do", "down", class_stack
, 1);
1465 add_com_alias ("dow", "down", class_stack
, 1);
1466 add_com ("down-silently", class_support
, down_silently_command
,
1467 "Same as the `down' command, but does not print anything.\n\
1468 This is useful in command scripts.");
1470 add_com ("frame", class_stack
, frame_command
,
1471 "Select and print a stack frame.\n\
1472 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1473 An argument specifies the frame to select.\n\
1474 It can be a stack frame number or the address of the frame.\n\
1475 With argument, nothing is printed if input is coming from\n\
1476 a command file or a user-defined command.");
1478 add_com_alias ("f", "frame", class_stack
, 1);
1480 add_com ("select-frame", class_stack
, select_frame_command
,
1481 "Select a stack frame without printing anything.\n\
1482 An argument specifies the frame to select.\n\
1483 It can be a stack frame number or the address of the frame.\n");
1485 add_com ("backtrace", class_stack
, backtrace_command
,
1486 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1487 With a negative argument, print outermost -COUNT frames.");
1488 add_com_alias ("bt", "backtrace", class_stack
, 0);
1489 add_com_alias ("where", "backtrace", class_alias
, 0);
1490 add_info ("stack", backtrace_command
,
1491 "Backtrace of the stack, or innermost COUNT frames.");
1492 add_info_alias ("s", "stack", 1);
1493 add_info ("frame", frame_info
,
1494 "All about selected stack frame, or frame at ADDR.");
1495 add_info_alias ("f", "frame", 1);
1496 add_info ("locals", locals_info
,
1497 "Local variables of current stack frame.");
1498 add_info ("args", args_info
,
1499 "Argument variables of current stack frame.");
1500 add_info ("catch", catch_info
,
1501 "Exceptions that can be caught in the current stack frame.");
1504 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
1505 "Specify maximum number of frames for \"backtrace\" to print by default.",
1507 add_info ("backtrace-limit", backtrace_limit_info
,
1508 "The maximum number of frames for \"backtrace\" to print by default.");