1 /* Print and select stack frames for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "expression.h"
30 #include "breakpoint.h"
35 return_command
PARAMS ((char *, int));
38 down_command
PARAMS ((char *, int));
41 down_silently_command
PARAMS ((char *, int));
44 up_command
PARAMS ((char *, int));
47 up_silently_command
PARAMS ((char *, int));
50 frame_command
PARAMS ((char *, int));
53 select_frame_command
PARAMS ((char *, int));
56 args_info
PARAMS ((char *, int));
59 print_frame_arg_vars
PARAMS ((FRAME
, GDB_FILE
*));
62 catch_info
PARAMS ((char *, int));
65 locals_info
PARAMS ((char *, int));
68 print_frame_label_vars
PARAMS ((FRAME
, int, GDB_FILE
*));
71 print_frame_local_vars
PARAMS ((FRAME
, GDB_FILE
*));
74 print_block_frame_labels
PARAMS ((struct block
*, int *, GDB_FILE
*));
77 print_block_frame_locals
PARAMS ((struct block
*, FRAME
, GDB_FILE
*));
80 backtrace_command
PARAMS ((char *, int));
83 parse_frame_specification
PARAMS ((char *));
86 frame_info
PARAMS ((char *, int));
89 extern int addressprint
; /* Print addresses, or stay symbolic only? */
90 extern int info_verbose
; /* Verbosity of symbol reading msgs */
91 extern int lines_to_list
; /* # of lines "list" command shows by default */
93 /* The "selected" stack frame is used by default for local and arg access.
94 May be zero, for no selected frame. */
98 /* Level of the selected frame:
99 0 for innermost, 1 for its caller, ...
100 or -1 for frame specified by address with no defined level. */
102 int selected_frame_level
;
104 /* Nonzero means print the full filename and linenumber
105 when a frame is printed, and do so in a format programs can parse. */
107 int frame_file_full_name
= 0;
110 struct print_stack_frame_args
{
111 struct frame_info
*fi
;
117 static int print_stack_frame_stub
PARAMS ((char *));
119 /* Pass the args the way catch_errors wants them. */
121 print_stack_frame_stub (args
)
124 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*)args
;
125 print_frame_info (p
->fi
, p
->level
, p
->source
, p
->args
);
129 /* Print a stack frame briefly. FRAME should be the frame id
130 and LEVEL should be its level in the stack (or -1 for level not defined).
131 This prints the level, the function executing, the arguments,
132 and the file name and line number.
133 If the pc is not at the beginning of the source line,
134 the actual pc is printed at the beginning.
136 If SOURCE is 1, print the source line as well.
137 If SOURCE is -1, print ONLY the source line. */
140 print_stack_frame (frame
, level
, source
)
145 struct print_stack_frame_args args
;
147 args
.fi
= get_frame_info (frame
);
149 args
.source
= source
;
152 catch_errors (print_stack_frame_stub
, (char *)&args
, "", RETURN_MASK_ERROR
);
155 struct print_args_args
{
157 struct frame_info
*fi
;
160 static int print_args_stub
PARAMS ((char *));
162 /* Pass the args the way catch_errors wants them. */
164 print_args_stub (args
)
168 struct print_args_args
*p
= (struct print_args_args
*)args
;
169 FRAME_NUM_ARGS (numargs
, (p
->fi
));
170 print_frame_args (p
->func
, p
->fi
, numargs
, gdb_stdout
);
175 print_frame_info (fi
, level
, source
, args
)
176 struct frame_info
*fi
;
181 struct symtab_and_line sal
;
183 register char *funname
= 0;
184 enum language funlang
= language_unknown
;
185 char buf
[MAX_REGISTER_RAW_SIZE
];
189 /* On the 68k, this spends too much time in m68k_find_saved_regs. */
191 /* Get the value of SP_REGNUM relative to the frame. */
192 get_saved_register (buf
, (int *)NULL
, (CORE_ADDR
*)NULL
,
193 FRAME_INFO_ID (fi
), SP_REGNUM
, (enum lval_type
*)NULL
);
194 sp
= extract_address (buf
, REGISTER_RAW_SIZE (SP_REGNUM
));
196 /* This is not a perfect test, because if a function alloca's some
197 memory, puts some code there, and then jumps into it, then the test
198 will succeed even though there is no call dummy. Probably best is
199 to check for a bp_call_dummy breakpoint. */
200 if (PC_IN_CALL_DUMMY (fi
->pc
, sp
, fi
->frame
))
202 if (frame_in_dummy (fi
))
205 /* Do this regardless of SOURCE because we don't have any source
206 to list for this frame. */
208 printf_filtered ("#%-2d ", level
);
209 printf_filtered ("<function called from gdb>\n");
212 if (fi
->signal_handler_caller
)
214 /* Do this regardless of SOURCE because we don't have any source
215 to list for this frame. */
217 printf_filtered ("#%-2d ", level
);
218 printf_filtered ("<signal handler called>\n");
222 /* If fi is not the innermost frame, that normally means that fi->pc
223 points to *after* the call instruction, and we want to get the line
224 containing the call, never the next line. But if the next frame is
225 a signal_handler_caller frame, then the next frame was not entered
226 as the result of a call, and we want to get the line containing
229 find_pc_line (fi
->pc
,
230 fi
->next
!= NULL
&& fi
->next
->signal_handler_caller
== 0);
232 func
= find_pc_function (fi
->pc
);
235 /* In certain pathological cases, the symtabs give the wrong
236 function (when we are in the first function in a file which
237 is compiled without debugging symbols, the previous function
238 is compiled with debugging symbols, and the "foo.o" symbol
239 that is supposed to tell us where the file with debugging symbols
240 ends has been truncated by ar because it is longer than 15
241 characters). This also occurs if the user uses asm() to create
242 a function but not stabs for it (in a file compiled -g).
244 So look in the minimal symbol tables as well, and if it comes
245 up with a larger address for the function use that instead.
246 I don't think this can ever cause any problems; there shouldn't
247 be any minimal symbols in the middle of a function; if this is
248 ever changed many parts of GDB will need to be changed (and we'll
249 create a find_pc_minimal_function or some such). */
251 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
253 && (SYMBOL_VALUE_ADDRESS (msymbol
)
254 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
256 /* In this case we have no way of knowing the source file
257 and line number, so don't print them. */
259 /* We also don't know anything about the function besides
260 its address and name. */
262 funname
= SYMBOL_NAME (msymbol
);
263 funlang
= SYMBOL_LANGUAGE (msymbol
);
267 funname
= SYMBOL_NAME (func
);
268 funlang
= SYMBOL_LANGUAGE (func
);
273 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
276 funname
= SYMBOL_NAME (msymbol
);
277 funlang
= SYMBOL_LANGUAGE (msymbol
);
281 if (source
>= 0 || !sal
.symtab
)
284 printf_filtered ("#%-2d ", level
);
286 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
)
287 printf_filtered ("%s in ", local_hex_string((unsigned long) fi
->pc
));
288 fprintf_symbol_filtered (gdb_stdout
, funname
? funname
: "??", funlang
,
291 fputs_filtered (" (", gdb_stdout
);
294 struct print_args_args args
;
297 catch_errors (print_args_stub
, (char *)&args
, "", RETURN_MASK_ERROR
);
299 printf_filtered (")");
300 if (sal
.symtab
&& sal
.symtab
->filename
)
303 printf_filtered (" at %s:%d", sal
.symtab
->filename
, sal
.line
);
306 #ifdef PC_LOAD_SEGMENT
307 /* If we couldn't print out function name but if can figure out what
308 load segment this pc value is from, at least print out some info
309 about its load segment. */
312 printf_filtered (" from %s", PC_LOAD_SEGMENT (fi
->pc
));
315 printf_filtered ("\n");
318 if ((source
!= 0) && sal
.symtab
)
321 int mid_statement
= source
< 0 && fi
->pc
!= sal
.pc
;
322 if (frame_file_full_name
)
323 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
327 if (addressprint
&& mid_statement
)
328 printf_filtered ("%s\t", local_hex_string((unsigned long) fi
->pc
));
329 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
331 current_source_line
= max (sal
.line
- lines_to_list
/2, 1);
334 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
336 gdb_flush (gdb_stdout
);
340 * Read a frame specification in whatever the appropriate format is.
341 * Call error() if the specification is in any way invalid (i.e.
342 * this function never returns NULL).
345 parse_frame_specification (frame_exp
)
350 CORE_ADDR args
[MAXARGS
];
354 char *addr_string
, *p
;
355 struct cleanup
*tmp_cleanup
;
357 while (*frame_exp
== ' ') frame_exp
++;
361 if (numargs
> MAXARGS
)
362 error ("Too many args in frame specification");
363 /* Parse an argument. */
364 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
366 addr_string
= savestring(frame_exp
, p
- frame_exp
);
369 tmp_cleanup
= make_cleanup (free
, addr_string
);
370 args
[numargs
++] = parse_and_eval_address (addr_string
);
371 do_cleanups (tmp_cleanup
);
374 /* Skip spaces, move to possible next arg. */
375 while (*p
== ' ') p
++;
383 if (selected_frame
== NULL
)
384 error ("No selected frame.");
385 return selected_frame
;
390 FRAME fid
= find_relative_frame (get_current_frame (), &level
);
394 /* find_relative_frame was successful */
397 /* If (s)he specifies the frame with an address, he deserves what
398 (s)he gets. Still, give the highest one that matches. */
400 for (fid
= get_current_frame ();
401 fid
&& FRAME_FP (fid
) != args
[0];
402 fid
= get_prev_frame (fid
))
406 while ((tfid
= get_prev_frame (fid
)) &&
407 (FRAME_FP (tfid
) == args
[0]))
410 /* We couldn't identify the frame as an existing frame, but
411 perhaps we can create one with a single argument.
412 Fall through to default case; it's up to SETUP_ARBITRARY_FRAME
413 to complain if it doesn't like a single arg. */
417 #ifdef SETUP_ARBITRARY_FRAME
418 return SETUP_ARBITRARY_FRAME (numargs
, args
);
420 /* Usual case. Do it here rather than have everyone supply
421 a SETUP_ARBITRARY_FRAME that does this. */
423 return create_new_frame (args
[0], 0);
424 error ("Too many args in frame specification");
431 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
432 that if it is unsure about the answer, it returns 0
433 instead of guessing (this happens on the VAX and i960, for example).
435 On most machines, we never have to guess about the args address,
436 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
437 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
438 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
441 /* Print verbosely the selected frame or the frame at address ADDR.
442 This means absolutely all information in the frame is printed. */
445 frame_info (addr_exp
, from_tty
)
450 struct frame_info
*fi
;
451 struct frame_saved_regs fsr
;
452 struct symtab_and_line sal
;
458 enum language funlang
= language_unknown
;
460 if (!target_has_stack
)
463 frame
= parse_frame_specification (addr_exp
);
465 error ("Invalid frame specified.");
467 fi
= get_frame_info (frame
);
468 sal
= find_pc_line (fi
->pc
,
469 fi
->next
!= NULL
&& fi
->next
->signal_handler_caller
== 0);
470 func
= get_frame_function (frame
);
471 s
= find_pc_symtab(fi
->pc
);
474 funname
= SYMBOL_NAME (func
);
475 funlang
= SYMBOL_LANGUAGE (func
);
479 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
482 funname
= SYMBOL_NAME (msymbol
);
483 funlang
= SYMBOL_LANGUAGE (msymbol
);
486 calling_frame
= get_prev_frame (frame
);
488 if (!addr_exp
&& selected_frame_level
>= 0) {
489 printf_filtered ("Stack level %d, frame at %s:\n",
490 selected_frame_level
,
491 local_hex_string((unsigned long) FRAME_FP(frame
)));
493 printf_filtered ("Stack frame at %s:\n",
494 local_hex_string((unsigned long) FRAME_FP(frame
)));
496 printf_filtered (" %s = %s",
497 reg_names
[PC_REGNUM
],
498 local_hex_string((unsigned long) fi
->pc
));
503 printf_filtered (" in ");
504 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
505 DMGL_ANSI
| DMGL_PARAMS
);
509 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
510 puts_filtered ("; ");
512 printf_filtered ("saved %s %s\n", reg_names
[PC_REGNUM
],
513 local_hex_string((unsigned long) FRAME_SAVED_PC (frame
)));
517 #ifdef FRAMELESS_FUNCTION_INVOCATION
518 FRAMELESS_FUNCTION_INVOCATION (fi
, frameless
);
521 printf_filtered (" (FRAMELESS),");
525 printf_filtered (" called by frame at %s",
526 local_hex_string((unsigned long) FRAME_FP (calling_frame
)));
527 if (fi
->next
&& calling_frame
)
531 printf_filtered (" caller of frame at %s",
532 local_hex_string ((unsigned long) fi
->next
->frame
));
533 if (fi
->next
|| calling_frame
)
534 puts_filtered ("\n");
536 printf_filtered(" source language %s.\n", language_str(s
->language
));
538 #ifdef PRINT_EXTRA_FRAME_INFO
539 PRINT_EXTRA_FRAME_INFO (fi
);
543 /* Address of the argument list for this frame, or 0. */
544 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
545 /* Number of args for this frame, or -1 if unknown. */
549 printf_filtered (" Arglist at unknown address.\n");
552 printf_filtered (" Arglist at %s,",
553 local_hex_string((unsigned long) arg_list
));
555 FRAME_NUM_ARGS (numargs
, fi
);
557 puts_filtered (" args: ");
558 else if (numargs
== 0)
559 puts_filtered (" no args.");
560 else if (numargs
== 1)
561 puts_filtered (" 1 arg: ");
563 printf_filtered (" %d args: ", numargs
);
564 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
565 puts_filtered ("\n");
569 /* Address of the local variables for this frame, or 0. */
570 CORE_ADDR arg_list
= FRAME_LOCALS_ADDRESS (fi
);
573 printf_filtered (" Locals at unknown address,");
575 printf_filtered (" Locals at %s,",
576 local_hex_string((unsigned long) arg_list
));
579 #if defined (FRAME_FIND_SAVED_REGS)
580 get_frame_saved_regs (fi
, &fsr
);
581 /* The sp is special; what's returned isn't the save address, but
582 actually the value of the previous frame's sp. */
583 printf_filtered (" Previous frame's sp is %s\n",
584 local_hex_string((unsigned long) fsr
.regs
[SP_REGNUM
]));
586 for (i
= 0; i
< NUM_REGS
; i
++)
587 if (fsr
.regs
[i
] && i
!= SP_REGNUM
)
590 puts_filtered (" Saved registers:\n ");
594 printf_filtered (" %s at %s", reg_names
[i
],
595 local_hex_string((unsigned long) fsr
.regs
[i
]));
599 puts_filtered ("\n");
600 #endif /* Have FRAME_FIND_SAVED_REGS. */
604 /* Set a limit on the number of frames printed by default in a
607 static int backtrace_limit
;
610 set_backtrace_limit_command (count_exp
, from_tty
)
614 int count
= parse_and_eval_address (count_exp
);
617 error ("Negative argument not meaningful as backtrace limit.");
619 backtrace_limit
= count
;
623 backtrace_limit_info (arg
, from_tty
)
628 error ("\"Info backtrace-limit\" takes no arguments.");
630 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit
);
634 /* Print briefly all stack frames or just the innermost COUNT frames. */
637 backtrace_command (count_exp
, from_tty
)
641 struct frame_info
*fi
;
643 register FRAME frame
;
645 register FRAME trailing
;
646 register int trailing_level
;
648 if (!target_has_stack
)
651 /* The following code must do two things. First, it must
652 set the variable TRAILING to the frame from which we should start
653 printing. Second, it must set the variable count to the number
654 of frames which we should print, or -1 if all of them. */
655 trailing
= get_current_frame ();
659 count
= parse_and_eval_address (count_exp
);
667 while (current
&& count
--)
670 current
= get_prev_frame (current
);
673 /* Will stop when CURRENT reaches the top of the stack. TRAILING
674 will be COUNT below it. */
678 trailing
= get_prev_frame (trailing
);
679 current
= get_prev_frame (current
);
691 struct partial_symtab
*ps
;
693 /* Read in symbols for all of the frames. Need to do this in
694 a separate pass so that "Reading in symbols for xxx" messages
695 don't screw up the appearance of the backtrace. Also
696 if people have strong opinions against reading symbols for
697 backtrace this may have to be an option. */
699 for (frame
= trailing
;
700 frame
!= NULL
&& i
--;
701 frame
= get_prev_frame (frame
))
704 fi
= get_frame_info (frame
);
705 ps
= find_pc_psymtab (fi
->pc
);
707 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
711 for (i
= 0, frame
= trailing
;
713 i
++, frame
= get_prev_frame (frame
))
716 fi
= get_frame_info (frame
);
718 /* Don't use print_stack_frame; if an error() occurs it probably
719 means further attempts to backtrace would fail (on the other
720 hand, perhaps the code does or could be fixed to make sure
721 the frame->prev field gets set to NULL in that case). */
722 print_frame_info (fi
, trailing_level
+ i
, 0, 1);
725 /* If we've stopped before the end, mention that. */
726 if (frame
&& from_tty
)
727 printf_filtered ("(More stack frames follow...)\n");
730 /* Print the local variables of a block B active in FRAME.
731 Return 1 if any variables were printed; 0 otherwise. */
734 print_block_frame_locals (b
, frame
, stream
)
736 register FRAME frame
;
737 register GDB_FILE
*stream
;
741 register struct symbol
*sym
;
742 register int values_printed
= 0;
744 nsyms
= BLOCK_NSYMS (b
);
746 for (i
= 0; i
< nsyms
; i
++)
748 sym
= BLOCK_SYM (b
, i
);
749 if (SYMBOL_CLASS (sym
) == LOC_LOCAL
750 || SYMBOL_CLASS (sym
) == LOC_REGISTER
751 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
754 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
755 fputs_filtered (" = ", stream
);
756 print_variable_value (sym
, frame
, stream
);
757 fprintf_filtered (stream
, "\n");
760 return values_printed
;
763 /* Same, but print labels. */
766 print_block_frame_labels (b
, have_default
, stream
)
769 register GDB_FILE
*stream
;
773 register struct symbol
*sym
;
774 register int values_printed
= 0;
776 nsyms
= BLOCK_NSYMS (b
);
778 for (i
= 0; i
< nsyms
; i
++)
780 sym
= BLOCK_SYM (b
, i
);
781 if (STREQ (SYMBOL_NAME (sym
), "default"))
787 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
789 struct symtab_and_line sal
;
790 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
792 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
794 fprintf_filtered (stream
, " %s",
795 local_hex_string((unsigned long) SYMBOL_VALUE_ADDRESS (sym
)));
796 fprintf_filtered (stream
, " in file %s, line %d\n",
797 sal
.symtab
->filename
, sal
.line
);
800 return values_printed
;
803 /* Print on STREAM all the local variables in frame FRAME,
804 including all the blocks active in that frame
807 Returns 1 if the job was done,
808 or 0 if nothing was printed because we have no info
809 on the function running in FRAME. */
812 print_frame_local_vars (frame
, stream
)
813 register FRAME frame
;
814 register GDB_FILE
*stream
;
816 register struct block
*block
= get_frame_block (frame
);
817 register int values_printed
= 0;
821 fprintf_filtered (stream
, "No symbol table info available.\n");
827 if (print_block_frame_locals (block
, frame
, stream
))
829 /* After handling the function's top-level block, stop.
830 Don't continue to its superblock, the block of
832 if (BLOCK_FUNCTION (block
))
834 block
= BLOCK_SUPERBLOCK (block
);
839 fprintf_filtered (stream
, "No locals.\n");
843 /* Same, but print labels. */
846 print_frame_label_vars (frame
, this_level_only
, stream
)
847 register FRAME frame
;
849 register GDB_FILE
*stream
;
851 register struct blockvector
*bl
;
852 register struct block
*block
= get_frame_block (frame
);
853 register int values_printed
= 0;
854 int index
, have_default
= 0;
855 char *blocks_printed
;
856 struct frame_info
*fi
= get_frame_info (frame
);
857 CORE_ADDR pc
= fi
->pc
;
861 fprintf_filtered (stream
, "No symbol table info available.\n");
865 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
866 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
867 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
871 CORE_ADDR end
= BLOCK_END (block
) - 4;
874 if (bl
!= blockvector_for_pc (end
, &index
))
875 error ("blockvector blotch");
876 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
877 error ("blockvector botch");
878 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
881 /* Don't print out blocks that have gone by. */
882 while (index
< last_index
883 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
886 while (index
< last_index
887 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
889 if (blocks_printed
[index
] == 0)
891 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
893 blocks_printed
[index
] = 1;
899 if (values_printed
&& this_level_only
)
902 /* After handling the function's top-level block, stop.
903 Don't continue to its superblock, the block of
905 if (BLOCK_FUNCTION (block
))
907 block
= BLOCK_SUPERBLOCK (block
);
910 if (!values_printed
&& !this_level_only
)
912 fprintf_filtered (stream
, "No catches.\n");
918 locals_info (args
, from_tty
)
923 error ("No frame selected.");
924 print_frame_local_vars (selected_frame
, gdb_stdout
);
928 catch_info (ignore
, from_tty
)
933 error ("No frame selected.");
934 print_frame_label_vars (selected_frame
, 0, gdb_stdout
);
938 print_frame_arg_vars (frame
, stream
)
939 register FRAME frame
;
940 register GDB_FILE
*stream
;
942 struct symbol
*func
= get_frame_function (frame
);
943 register struct block
*b
;
946 register struct symbol
*sym
, *sym2
;
947 register int values_printed
= 0;
951 fprintf_filtered (stream
, "No symbol table info available.\n");
955 b
= SYMBOL_BLOCK_VALUE (func
);
956 nsyms
= BLOCK_NSYMS (b
);
958 for (i
= 0; i
< nsyms
; i
++)
960 sym
= BLOCK_SYM (b
, i
);
961 switch (SYMBOL_CLASS (sym
))
967 case LOC_REGPARM_ADDR
:
968 case LOC_BASEREG_ARG
:
970 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
971 fputs_filtered (" = ", stream
);
973 /* We have to look up the symbol because arguments can have
974 two entries (one a parameter, one a local) and the one we
975 want is the local, which lookup_symbol will find for us.
976 This includes gcc1 (not gcc2) on the sparc when passing a
977 small structure and gcc2 when the argument type is float
978 and it is passed as a double and converted to float by
979 the prologue (in the latter case the type of the LOC_ARG
980 symbol is double and the type of the LOC_LOCAL symbol is
981 float). There are also LOC_ARG/LOC_REGISTER pairs which
982 are not combined in symbol-reading. */
984 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
985 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
986 print_variable_value (sym2
, frame
, stream
);
987 fprintf_filtered (stream
, "\n");
991 /* Don't worry about things which aren't arguments. */
998 fprintf_filtered (stream
, "No arguments.\n");
1003 args_info (ignore
, from_tty
)
1007 if (!selected_frame
)
1008 error ("No frame selected.");
1009 print_frame_arg_vars (selected_frame
, gdb_stdout
);
1012 /* Select frame FRAME, and note that its stack level is LEVEL.
1013 LEVEL may be -1 if an actual level number is not known. */
1016 select_frame (frame
, level
)
1020 register struct symtab
*s
;
1022 selected_frame
= frame
;
1023 selected_frame_level
= level
;
1025 /* Ensure that symbols for this frame are read in. Also, determine the
1026 source language of this frame, and switch to it if desired. */
1029 s
= find_pc_symtab (get_frame_info (frame
)->pc
);
1031 && s
->language
!= current_language
->la_language
1032 && s
->language
!= language_unknown
1033 && language_mode
== language_mode_auto
) {
1034 set_language(s
->language
);
1039 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
1040 If there is no selected frame, *FRAMEP is set to NULL. */
1043 record_selected_frame (frameaddrp
, levelp
)
1044 FRAME_ADDR
*frameaddrp
;
1047 *frameaddrp
= selected_frame
? FRAME_FP (selected_frame
) : 0;
1048 *levelp
= selected_frame_level
;
1051 /* Return the symbol-block in which the selected frame is executing.
1052 Can return zero under various legitimate circumstances. */
1055 get_selected_block ()
1057 if (!target_has_stack
)
1060 if (!selected_frame
)
1061 return get_current_block ();
1062 return get_frame_block (selected_frame
);
1065 /* Find a frame a certain number of levels away from FRAME.
1066 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1067 Positive means go to earlier frames (up); negative, the reverse.
1068 The int that contains the number of levels is counted toward
1069 zero as the frames for those levels are found.
1070 If the top or bottom frame is reached, that frame is returned,
1071 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1072 how much farther the original request asked to go. */
1075 find_relative_frame (frame
, level_offset_ptr
)
1076 register FRAME frame
;
1077 register int* level_offset_ptr
;
1079 register FRAME prev
;
1080 register FRAME frame1
;
1082 /* Going up is simple: just do get_prev_frame enough times
1083 or until initial frame is reached. */
1084 while (*level_offset_ptr
> 0)
1086 prev
= get_prev_frame (frame
);
1089 (*level_offset_ptr
)--;
1092 /* Going down is just as simple. */
1093 if (*level_offset_ptr
< 0)
1095 while (*level_offset_ptr
< 0) {
1096 frame1
= get_next_frame (frame
);
1100 (*level_offset_ptr
)++;
1106 /* The "select_frame" command. With no arg, NOP.
1107 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1108 valid level. Otherwise, treat level_exp as an address expression
1109 and select it. See parse_frame_specification for more info on proper
1110 frame expressions. */
1114 select_frame_command (level_exp
, from_tty
)
1118 register FRAME frame
, frame1
;
1119 unsigned int level
= 0;
1121 if (!target_has_stack
)
1122 error ("No stack.");
1124 frame
= parse_frame_specification (level_exp
);
1126 /* Try to figure out what level this frame is. But if there is
1127 no current stack, don't error out -- let the user set one. */
1129 if (get_current_frame()) {
1130 for (frame1
= get_prev_frame (0);
1131 frame1
&& frame1
!= frame
;
1132 frame1
= get_prev_frame (frame1
))
1139 select_frame (frame
, level
);
1142 /* The "frame" command. With no arg, print selected frame briefly.
1143 With arg, behaves like select_frame and then prints the selected
1147 frame_command (level_exp
, from_tty
)
1151 select_frame_command (level_exp
, from_tty
);
1152 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1155 /* Select the frame up one or COUNT stack levels
1156 from the previously selected frame, and print it briefly. */
1160 up_silently_command (count_exp
, from_tty
)
1164 register FRAME frame
;
1165 int count
= 1, count1
;
1167 count
= parse_and_eval_address (count_exp
);
1170 if (target_has_stack
== 0 || selected_frame
== 0)
1171 error ("No stack.");
1173 frame
= find_relative_frame (selected_frame
, &count1
);
1174 if (count1
!= 0 && count_exp
== 0)
1175 error ("Initial frame selected; you cannot go up.");
1176 select_frame (frame
, selected_frame_level
+ count
- count1
);
1180 up_command (count_exp
, from_tty
)
1184 up_silently_command (count_exp
, from_tty
);
1185 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1188 /* Select the frame down one or COUNT stack levels
1189 from the previously selected frame, and print it briefly. */
1193 down_silently_command (count_exp
, from_tty
)
1197 register FRAME frame
;
1198 int count
= -1, count1
;
1200 count
= - parse_and_eval_address (count_exp
);
1203 if (target_has_stack
== 0 || selected_frame
== 0)
1204 error ("No stack.");
1206 frame
= find_relative_frame (selected_frame
, &count1
);
1207 if (count1
!= 0 && count_exp
== 0)
1210 /* We only do this if count_exp is not specified. That way "down"
1211 means to really go down (and let me know if that is
1212 impossible), but "down 9999" can be used to mean go all the way
1213 down without getting an error. */
1215 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1218 select_frame (frame
, selected_frame_level
+ count
- count1
);
1223 down_command (count_exp
, from_tty
)
1227 down_silently_command (count_exp
, from_tty
);
1228 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1232 return_command (retval_exp
, from_tty
)
1236 struct symbol
*thisfun
;
1237 FRAME_ADDR selected_frame_addr
;
1238 CORE_ADDR selected_frame_pc
;
1240 value return_value
= NULL
;
1242 if (selected_frame
== NULL
)
1243 error ("No selected frame.");
1244 thisfun
= get_frame_function (selected_frame
);
1245 selected_frame_addr
= FRAME_FP (selected_frame
);
1246 selected_frame_pc
= (get_frame_info (selected_frame
))->pc
;
1248 /* Compute the return value (if any -- possibly getting errors here). */
1252 return_value
= parse_and_eval (retval_exp
);
1254 /* Make sure we have fully evaluated it, since
1255 it might live in the stack frame we're about to pop. */
1256 if (VALUE_LAZY (return_value
))
1257 value_fetch_lazy (return_value
);
1260 /* If interactive, require confirmation. */
1266 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun
)))
1268 error ("Not confirmed.");
1273 if (!query ("Make selected stack frame return now? "))
1274 error ("Not confirmed.");
1277 /* Do the real work. Pop until the specified frame is current. We
1278 use this method because the selected_frame is not valid after
1279 a POP_FRAME. The pc comparison makes this work even if the
1280 selected frame shares its fp with another frame. */
1282 while ( selected_frame_addr
!= FRAME_FP (frame
= get_current_frame())
1283 || selected_frame_pc
!= (get_frame_info (frame
))->pc
)
1286 /* Then pop that frame. */
1290 /* Compute the return value (if any) and store in the place
1291 for return values. */
1294 set_return_value (return_value
);
1296 /* If interactive, print the frame that is now current. */
1299 frame_command ("0", 1);
1302 /* Gets the language of the current frame. */
1304 get_frame_language()
1306 register struct symtab
*s
;
1308 enum language flang
; /* The language of the current frame */
1310 fr
= get_frame_info(selected_frame
);
1313 s
= find_pc_symtab(fr
->pc
);
1315 flang
= s
->language
;
1317 flang
= language_unknown
;
1320 flang
= language_unknown
;
1326 _initialize_stack ()
1329 backtrace_limit
= 30;
1332 add_com ("return", class_stack
, return_command
,
1333 "Make selected stack frame return to its caller.\n\
1334 Control remains in the debugger, but when you continue\n\
1335 execution will resume in the frame above the one now selected.\n\
1336 If an argument is given, it is an expression for the value to return.");
1338 add_com ("up", class_stack
, up_command
,
1339 "Select and print stack frame that called this one.\n\
1340 An argument says how many frames up to go.");
1341 add_com ("up-silently", class_support
, up_silently_command
,
1342 "Same as the `up' command, but does not print anything.\n\
1343 This is useful in command scripts.");
1345 add_com ("down", class_stack
, down_command
,
1346 "Select and print stack frame called by this one.\n\
1347 An argument says how many frames down to go.");
1348 add_com_alias ("do", "down", class_stack
, 1);
1349 add_com_alias ("dow", "down", class_stack
, 1);
1350 add_com ("down-silently", class_support
, down_silently_command
,
1351 "Same as the `down' command, but does not print anything.\n\
1352 This is useful in command scripts.");
1354 add_com ("frame", class_stack
, frame_command
,
1355 "Select and print a stack frame.\n\
1356 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1357 An argument specifies the frame to select.\n\
1358 It can be a stack frame number or the address of the frame.\n\
1359 With argument, nothing is printed if input is coming from\n\
1360 a command file or a user-defined command.");
1362 add_com_alias ("f", "frame", class_stack
, 1);
1364 add_com ("select-frame", class_stack
, select_frame_command
,
1365 "Select a stack frame without printing anything.\n\
1366 An argument specifies the frame to select.\n\
1367 It can be a stack frame number or the address of the frame.\n");
1369 add_com ("backtrace", class_stack
, backtrace_command
,
1370 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1371 With a negative argument, print outermost -COUNT frames.");
1372 add_com_alias ("bt", "backtrace", class_stack
, 0);
1373 add_com_alias ("where", "backtrace", class_alias
, 0);
1374 add_info ("stack", backtrace_command
,
1375 "Backtrace of the stack, or innermost COUNT frames.");
1376 add_info_alias ("s", "stack", 1);
1377 add_info ("frame", frame_info
,
1378 "All about selected stack frame, or frame at ADDR.");
1379 add_info_alias ("f", "frame", 1);
1380 add_info ("locals", locals_info
,
1381 "Local variables of current stack frame.");
1382 add_info ("args", args_info
,
1383 "Argument variables of current stack frame.");
1384 add_info ("catch", catch_info
,
1385 "Exceptions that can be caught in the current stack frame.");
1388 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
1389 "Specify maximum number of frames for \"backtrace\" to print by default.",
1391 add_info ("backtrace-limit", backtrace_limit_info
,
1392 "The maximum number of frames for \"backtrace\" to print by default.");