1 /* Print and select stack frames for GDB, the GNU debugger.
2 Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
4 This file is part of GDB.
6 GDB 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 1, or (at your option)
11 GDB 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 GDB; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
30 #include "breakpoint.h"
32 extern int addressprint
; /* Print addresses, or stay symbolic only? */
33 extern int info_verbose
; /* Verbosity of symbol reading msgs */
34 extern char *reg_names
[]; /* Names of registers */
36 /* Thie "selected" stack frame is used by default for local and arg access.
37 May be zero, for no selected frame. */
41 /* Level of the selected frame:
42 0 for innermost, 1 for its caller, ...
43 or -1 for frame specified by address with no defined level. */
45 int selected_frame_level
;
47 /* Nonzero means print the full filename and linenumber
48 when a frame is printed, and do so in a format programs can parse. */
50 int frame_file_full_name
= 0;
52 void print_frame_info ();
54 /* Print a stack frame briefly. FRAME should be the frame id
55 and LEVEL should be its level in the stack (or -1 for level not defined).
56 This prints the level, the function executing, the arguments,
57 and the file name and line number.
58 If the pc is not at the beginning of the source line,
59 the actual pc is printed at the beginning.
61 If SOURCE is 1, print the source line as well.
62 If SOURCE is -1, print ONLY the source line. */
65 print_stack_frame (frame
, level
, source
)
70 struct frame_info
*fi
;
72 fi
= get_frame_info (frame
);
74 print_frame_info (fi
, level
, source
, 1);
78 print_frame_info (fi
, level
, source
, args
)
79 struct frame_info
*fi
;
84 struct symtab_and_line sal
;
86 register char *funname
= 0;
89 #if 0 /* Symbol reading is fast enough now */
90 struct partial_symtab
*pst
;
92 /* Don't give very much information if we haven't readin the
94 pst
= find_pc_psymtab (fi
->pc
);
95 if (pst
&& !pst
->readin
)
97 /* Abbreviated information. */
100 if (!find_pc_partial_function (fi
->pc
, &fname
, 0))
103 printf_filtered ("#%-2d ", level
);
105 printf_filtered ("0x%x in ", fi
->pc
);
107 fputs_demangled (fname
, stdout
, -1);
108 fputs_filtered (" (...)\n", stdout
);
114 sal
= find_pc_line (fi
->pc
, fi
->next_frame
);
115 func
= find_pc_function (fi
->pc
);
118 /* In certain pathological cases, the symtabs give the wrong
119 function (when we are in the first function in a file which
120 is compiled without debugging symbols, the previous function
121 is compiled with debugging symbols, and the "foo.o" symbol
122 that is supposed to tell us where the file with debugging symbols
123 ends has been truncated by ar because it is longer than 15
126 So look in the misc_function_vector as well, and if it comes
127 up with a larger address for the function use that instead.
128 I don't think this can ever cause any problems;
129 there shouldn't be any
130 misc_function_vector symbols in the middle of a function. */
131 int misc_index
= find_pc_misc_function (fi
->pc
);
133 && (misc_function_vector
[misc_index
].address
134 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
136 /* In this case we have no way of knowing the source file
137 and line number, so don't print them. */
139 /* We also don't know anything about the function besides
140 its address and name. */
142 funname
= misc_function_vector
[misc_index
].name
;
145 funname
= SYMBOL_NAME (func
);
149 register int misc_index
= find_pc_misc_function (fi
->pc
);
151 funname
= misc_function_vector
[misc_index
].name
;
154 if (source
>= 0 || !sal
.symtab
)
157 printf_filtered ("#%-2d ", level
);
159 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
)
160 printf_filtered ("0x%x in ", fi
->pc
);
161 fputs_demangled (funname
? funname
: "??", stdout
, -1);
163 fputs_filtered (" (", stdout
);
166 FRAME_NUM_ARGS (numargs
, fi
);
167 print_frame_args (func
, fi
, numargs
, stdout
);
169 printf_filtered (")");
170 if (sal
.symtab
&& sal
.symtab
->filename
)
173 printf_filtered (" at %s:%d", sal
.symtab
->filename
, sal
.line
);
175 printf_filtered ("\n");
178 if ((source
!= 0) && sal
.symtab
)
181 int mid_statement
= source
< 0 && fi
->pc
!= sal
.pc
;
182 if (frame_file_full_name
)
183 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
);
186 if (addressprint
&& mid_statement
)
187 printf_filtered ("0x%x\t", fi
->pc
);
188 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
190 current_source_line
= max (sal
.line
- lines_to_list () / 2, 1);
193 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
198 /* Call here to print info on selected frame, after a trap. */
201 print_sel_frame (just_source
)
204 print_stack_frame (selected_frame
, -1, just_source
? -1 : 1);
207 /* Print info on the selected frame, including level number
211 print_selected_frame ()
213 print_stack_frame (selected_frame
, selected_frame_level
, 0);
216 void flush_cached_frames ();
218 #ifdef FRAME_SPECIFICATION_DYADIC
219 extern FRAME
setup_arbitrary_frame ();
223 * Read a frame specification in whatever the appropriate format is.
226 parse_frame_specification (frame_exp
)
234 char *addr_string
, *p
;
235 struct cleanup
*tmp_cleanup
;
237 while (*frame_exp
== ' ') frame_exp
++;
238 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
244 addr_string
= savestring(frame_exp
, p
- frame_exp
);
247 tmp_cleanup
= make_cleanup (free
, addr_string
);
248 arg1
= parse_and_eval_address (addr_string
);
249 do_cleanups (tmp_cleanup
);
252 while (*p
== ' ') p
++;
257 arg2
= parse_and_eval_address (p
);
265 return selected_frame
;
270 FRAME fid
= find_relative_frame (get_current_frame (), &level
);
274 /* find_relative_frame was successful */
277 /* If (s)he specifies the frame with an address, he deserves what
278 (s)he gets. Still, give the highest one that matches. */
280 for (fid
= get_current_frame ();
281 fid
&& FRAME_FP (fid
) != arg1
;
282 fid
= get_prev_frame (fid
))
286 while ((tfid
= get_prev_frame (fid
)) &&
287 (FRAME_FP (tfid
) == arg1
))
290 #ifdef FRAME_SPECIFICATION_DYADIC
292 error ("Incorrect number of args in frame specification");
296 return create_new_frame (arg1
, 0);
301 /* Must be addresses */
302 #ifndef FRAME_SPECIFICATION_DYADIC
303 error ("Incorrect number of args in frame specification");
305 return setup_arbitrary_frame (arg1
, arg2
);
309 fatal ("Internal: Error in parsing in parse_frame_specification");
313 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
314 that if it is unsure about the answer, it returns 0
315 instead of guessing (this happens on the VAX and i960, for example).
317 On most machines, we never have to guess about the args address,
318 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
319 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
320 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
323 /* Print verbosely the selected frame or the frame at address ADDR.
324 This means absolutely all information in the frame is printed. */
327 frame_info (addr_exp
)
331 struct frame_info
*fi
;
332 struct frame_saved_regs fsr
;
333 struct symtab_and_line sal
;
339 if (!target_has_stack
)
340 error ("No inferior or core file.");
342 frame
= parse_frame_specification (addr_exp
);
344 error ("Invalid frame specified.");
346 fi
= get_frame_info (frame
);
347 sal
= find_pc_line (fi
->pc
, fi
->next_frame
);
348 func
= get_frame_function (frame
);
350 funname
= SYMBOL_NAME (func
);
353 register int misc_index
= find_pc_misc_function (fi
->pc
);
355 funname
= misc_function_vector
[misc_index
].name
;
357 calling_frame
= get_prev_frame (frame
);
359 if (!addr_exp
&& selected_frame_level
>= 0)
360 printf_filtered ("Stack level %d, frame at 0x%x:\n %s = 0x%x",
361 selected_frame_level
, FRAME_FP(frame
),
362 reg_names
[PC_REGNUM
], fi
->pc
);
364 printf_filtered ("Stack frame at 0x%x:\n %s = 0x%x",
365 FRAME_FP(frame
), reg_names
[PC_REGNUM
], fi
->pc
);
369 printf_filtered (" in %s", funname
);
372 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
373 puts_filtered ("; ");
375 printf_filtered ("saved %s 0x%x\n", reg_names
[PC_REGNUM
],
376 FRAME_SAVED_PC (frame
));
378 printf_filtered (" called by frame at 0x%x", FRAME_FP (calling_frame
));
379 if (fi
->next_frame
&& calling_frame
)
383 printf_filtered (" caller of frame at 0x%x", fi
->next_frame
);
384 if (fi
->next_frame
|| calling_frame
)
385 puts_filtered ("\n");
388 /* Address of the argument list for this frame, or 0. */
389 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
390 /* Number of args for this frame, or -1 if unknown. */
394 printf_filtered (" Arglist at unknown address.\n");
397 printf_filtered (" Arglist at 0x%x,", arg_list
);
399 FRAME_NUM_ARGS (numargs
, fi
);
401 puts_filtered (" args: ");
402 else if (numargs
== 0)
403 puts_filtered (" no args.");
404 else if (numargs
== 1)
405 puts_filtered (" 1 arg: ");
407 printf_filtered (" %d args: ", numargs
);
408 print_frame_args (func
, fi
, numargs
, stdout
);
409 puts_filtered ("\n");
413 #if defined (FRAME_FIND_SAVED_REGS)
414 get_frame_saved_regs (fi
, &fsr
);
415 /* The sp is special; what's returned isn't the save address, but
416 actually the value of the previous frame's sp. */
417 printf_filtered (" Previous frame's sp is 0x%x\n", fsr
.regs
[SP_REGNUM
]);
419 for (i
= 0; i
< NUM_REGS
; i
++)
420 if (fsr
.regs
[i
] && i
!= SP_REGNUM
)
423 puts_filtered (" Saved registers:\n ");
427 printf_filtered (" %s at 0x%x", reg_names
[i
], fsr
.regs
[i
]);
431 puts_filtered ("\n");
432 #endif /* Have FRAME_FIND_SAVED_REGS. */
436 /* Set a limit on the number of frames printed by default in a
439 static int backtrace_limit
;
442 set_backtrace_limit_command (count_exp
, from_tty
)
446 int count
= parse_and_eval_address (count_exp
);
449 error ("Negative argument not meaningful as backtrace limit.");
451 backtrace_limit
= count
;
455 backtrace_limit_info (arg
, from_tty
)
460 error ("\"Info backtrace-limit\" takes no arguments.");
462 printf ("Backtrace limit: %d.\n", backtrace_limit
);
466 /* Print briefly all stack frames or just the innermost COUNT frames. */
469 backtrace_command (count_exp
, from_tty
)
473 struct frame_info
*fi
;
475 register FRAME frame
;
477 register FRAME trailing
;
478 register int trailing_level
;
480 /* The following code must do two things. First, it must
481 set the variable TRAILING to the frame from which we should start
482 printing. Second, it must set the variable count to the number
483 of frames which we should print, or -1 if all of them. */
484 trailing
= get_current_frame ();
488 count
= parse_and_eval_address (count_exp
);
496 while (current
&& count
--)
499 current
= get_prev_frame (current
);
502 /* Will stop when CURRENT reaches the top of the stack. TRAILING
503 will be COUNT below it. */
507 trailing
= get_prev_frame (trailing
);
508 current
= get_prev_frame (current
);
520 struct partial_symtab
*ps
;
522 /* Read in symbols for all of the frames. Need to do this in
523 a separate pass so that "Reading in symbols for xxx" messages
524 don't screw up the appearance of the backtrace. Also
525 if people have strong opinions against reading symbols for
526 backtrace this may have to be an option. */
528 for (frame
= trailing
;
529 frame
!= NULL
&& i
--;
530 frame
= get_prev_frame (frame
))
533 fi
= get_frame_info (frame
);
534 ps
= find_pc_psymtab (fi
->pc
);
536 (void) PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
540 for (i
= 0, frame
= trailing
;
542 i
++, frame
= get_prev_frame (frame
))
545 fi
= get_frame_info (frame
);
546 print_frame_info (fi
, trailing_level
+ i
, 0, 1);
549 /* If we've stopped before the end, mention that. */
550 if (frame
&& from_tty
)
551 printf_filtered ("(More stack frames follow...)\n");
554 /* Print the local variables of a block B active in FRAME.
555 Return 1 if any variables were printed; 0 otherwise. */
558 print_block_frame_locals (b
, frame
, stream
)
560 register FRAME frame
;
561 register FILE *stream
;
565 register struct symbol
*sym
;
566 register int values_printed
= 0;
568 nsyms
= BLOCK_NSYMS (b
);
570 for (i
= 0; i
< nsyms
; i
++)
572 sym
= BLOCK_SYM (b
, i
);
573 if (SYMBOL_CLASS (sym
) == LOC_LOCAL
574 || SYMBOL_CLASS (sym
) == LOC_REGISTER
575 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
578 fprint_symbol (stream
, SYMBOL_NAME (sym
));
579 fputs_filtered (" = ", stream
);
580 print_variable_value (sym
, frame
, stream
);
581 fprintf_filtered (stream
, "\n");
585 return values_printed
;
588 /* Same, but print labels.
589 FIXME, this does not even reference FRAME... --gnu */
592 print_block_frame_labels (b
, frame
, have_default
, stream
)
594 register FRAME frame
;
596 register FILE *stream
;
600 register struct symbol
*sym
;
601 register int values_printed
= 0;
603 nsyms
= BLOCK_NSYMS (b
);
605 for (i
= 0; i
< nsyms
; i
++)
607 sym
= BLOCK_SYM (b
, i
);
608 if (! strcmp (SYMBOL_NAME (sym
), "default"))
614 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
616 struct symtab_and_line sal
;
617 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
619 fputs_demangled (SYMBOL_NAME (sym
), stream
, 1);
621 fprintf_filtered (stream
, " 0x%x", SYMBOL_VALUE_ADDRESS (sym
));
622 fprintf_filtered (stream
, " in file %s, line %d\n",
623 sal
.symtab
->filename
, sal
.line
);
627 return values_printed
;
630 /* Print on STREAM all the local variables in frame FRAME,
631 including all the blocks active in that frame
634 Returns 1 if the job was done,
635 or 0 if nothing was printed because we have no info
636 on the function running in FRAME. */
639 print_frame_local_vars (frame
, stream
)
640 register FRAME frame
;
641 register FILE *stream
;
643 register struct block
*block
= get_frame_block (frame
);
644 register int values_printed
= 0;
648 fprintf_filtered (stream
, "No symbol table info available.\n");
655 if (print_block_frame_locals (block
, frame
, stream
))
657 /* After handling the function's top-level block, stop.
658 Don't continue to its superblock, the block of
660 if (BLOCK_FUNCTION (block
))
662 block
= BLOCK_SUPERBLOCK (block
);
667 fprintf_filtered (stream
, "No locals.\n");
674 /* Same, but print labels. */
677 print_frame_label_vars (frame
, this_level_only
, stream
)
678 register FRAME frame
;
680 register FILE *stream
;
682 extern struct blockvector
*blockvector_for_pc ();
683 register struct blockvector
*bl
;
684 register struct block
*block
= get_frame_block (frame
);
685 register int values_printed
= 0;
686 int index
, have_default
= 0;
687 char *blocks_printed
;
688 struct frame_info
*fi
= get_frame_info (frame
);
689 CORE_ADDR pc
= fi
->pc
;
693 fprintf_filtered (stream
, "No symbol table info available.\n");
698 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
699 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
700 bzero (blocks_printed
, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
704 CORE_ADDR end
= BLOCK_END (block
) - 4;
707 if (bl
!= blockvector_for_pc (end
, &index
))
708 error ("blockvector blotch");
709 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
710 error ("blockvector botch");
711 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
714 /* Don't print out blocks that have gone by. */
715 while (index
< last_index
716 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
719 while (index
< last_index
720 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
722 if (blocks_printed
[index
] == 0)
724 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), frame
, &have_default
, stream
))
726 blocks_printed
[index
] = 1;
732 if (values_printed
&& this_level_only
)
735 /* After handling the function's top-level block, stop.
736 Don't continue to its superblock, the block of
738 if (BLOCK_FUNCTION (block
))
740 block
= BLOCK_SUPERBLOCK (block
);
743 if (!values_printed
&& !this_level_only
)
745 fprintf_filtered (stream
, "No catches.\n");
749 return values_printed
;
753 locals_info (args
, from_tty
)
757 if (!target_has_stack
)
760 print_frame_local_vars (selected_frame
, stdout
);
766 if (!target_has_stack
)
769 print_frame_label_vars (selected_frame
, 0, stdout
);
773 print_frame_arg_vars (frame
, stream
)
774 register FRAME frame
;
775 register FILE *stream
;
777 struct symbol
*func
= get_frame_function (frame
);
778 register struct block
*b
;
781 register struct symbol
*sym
, *sym2
;
782 register int values_printed
= 0;
786 fprintf_filtered (stream
, "No symbol table info available.\n");
791 b
= SYMBOL_BLOCK_VALUE (func
);
792 nsyms
= BLOCK_NSYMS (b
);
794 for (i
= 0; i
< nsyms
; i
++)
796 sym
= BLOCK_SYM (b
, i
);
797 if (SYMBOL_CLASS (sym
) == LOC_ARG
798 || SYMBOL_CLASS (sym
) == LOC_LOCAL_ARG
799 || SYMBOL_CLASS (sym
) == LOC_REF_ARG
800 || SYMBOL_CLASS (sym
) == LOC_REGPARM
)
803 fprint_symbol (stream
, SYMBOL_NAME (sym
));
804 fputs_filtered (" = ", stream
);
805 /* We have to look up the symbol because arguments often have
806 two entries (one a parameter, one a register) and the one
807 we want is the register, which lookup_symbol will find for
809 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
810 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
811 print_variable_value (sym2
, frame
, stream
);
812 fprintf_filtered (stream
, "\n");
819 fprintf_filtered (stream
, "No arguments.\n");
829 if (!target_has_stack
)
831 print_frame_arg_vars (selected_frame
, stdout
);
834 /* Select frame FRAME, and note that its stack level is LEVEL.
835 LEVEL may be -1 if an actual level number is not known. */
838 select_frame (frame
, level
)
842 selected_frame
= frame
;
843 selected_frame_level
= level
;
844 /* Ensure that symbols for this frame are readin. */
846 find_pc_symtab (get_frame_info (frame
)->pc
);
849 /* Store the selected frame and its level into *FRAMEP and *LEVELP. */
852 record_selected_frame (frameaddrp
, levelp
)
853 FRAME_ADDR
*frameaddrp
;
856 *frameaddrp
= FRAME_FP (selected_frame
);
857 *levelp
= selected_frame_level
;
860 /* Return the symbol-block in which the selected frame is executing.
861 Can return zero under various legitimate circumstances. */
864 get_selected_block ()
866 if (!target_has_stack
)
870 return get_current_block ();
871 return get_frame_block (selected_frame
);
874 /* Find a frame a certain number of levels away from FRAME.
875 LEVEL_OFFSET_PTR points to an int containing the number of levels.
876 Positive means go to earlier frames (up); negative, the reverse.
877 The int that contains the number of levels is counted toward
878 zero as the frames for those levels are found.
879 If the top or bottom frame is reached, that frame is returned,
880 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
881 how much farther the original request asked to go. */
884 find_relative_frame (frame
, level_offset_ptr
)
885 register FRAME frame
;
886 register int* level_offset_ptr
;
889 register FRAME frame1
, frame2
;
891 /* Going up is simple: just do get_prev_frame enough times
892 or until initial frame is reached. */
893 while (*level_offset_ptr
> 0)
895 prev
= get_prev_frame (frame
);
898 (*level_offset_ptr
)--;
901 /* Going down could be done by iterating get_frame_info to
902 find the next frame, but that would be quadratic
903 since get_frame_info must scan all the way from the current frame.
904 The following algorithm is linear. */
905 if (*level_offset_ptr
< 0)
907 /* First put frame1 at innermost frame
908 and frame2 N levels up from there. */
909 frame1
= get_current_frame ();
911 while (*level_offset_ptr
< 0 && frame2
!= frame
)
913 frame2
= get_prev_frame (frame2
);
914 (*level_offset_ptr
) ++;
916 /* Then slide frame1 and frame2 up in synchrony
917 and when frame2 reaches our starting point
918 frame1 must be N levels down from there. */
919 while (frame2
!= frame
)
921 frame1
= get_prev_frame (frame1
);
922 frame2
= get_prev_frame (frame2
);
929 /* The "frame" command. With no arg, print selected frame briefly.
930 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
931 valid level. Otherwise, treat level_exp as an address expression
932 and print it. See parse_frame_specification for more info on proper
933 frame expressions. */
936 frame_command (level_exp
, from_tty
)
940 register FRAME frame
, frame1
;
941 unsigned int level
= 0;
943 if (!target_has_stack
)
946 frame
= parse_frame_specification (level_exp
);
948 for (frame1
= get_prev_frame (0);
949 frame1
&& frame1
!= frame
;
950 frame1
= get_prev_frame (frame1
))
956 select_frame (frame
, level
);
961 print_stack_frame (selected_frame
, selected_frame_level
, 1);
964 /* Select the frame up one or COUNT stack levels
965 from the previously selected frame, and print it briefly. */
968 up_silently_command (count_exp
, from_tty
)
972 register FRAME frame
;
973 int count
= 1, count1
;
975 count
= parse_and_eval_address (count_exp
);
978 if (!target_has_stack
)
981 frame
= find_relative_frame (selected_frame
, &count1
);
982 if (count1
!= 0 && count_exp
== 0)
983 error ("Initial frame selected; you cannot go up.");
984 select_frame (frame
, selected_frame_level
+ count
- count1
);
988 up_command (count_exp
, from_tty
)
992 up_silently_command (count_exp
, from_tty
);
993 print_stack_frame (selected_frame
, selected_frame_level
, 1);
996 /* Select the frame down one or COUNT stack levels
997 from the previously selected frame, and print it briefly. */
1000 down_silently_command (count_exp
, from_tty
)
1004 register FRAME frame
;
1005 int count
= -1, count1
;
1007 count
= - parse_and_eval_address (count_exp
);
1010 frame
= find_relative_frame (selected_frame
, &count1
);
1011 if (count1
!= 0 && count_exp
== 0)
1012 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1013 select_frame (frame
, selected_frame_level
+ count
- count1
);
1018 down_command (count_exp
, from_tty
)
1022 down_silently_command (count_exp
, from_tty
);
1023 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1027 return_command (retval_exp
, from_tty
)
1031 struct symbol
*thisfun
= get_frame_function (selected_frame
);
1032 FRAME_ADDR selected_frame_addr
= FRAME_FP (selected_frame
);
1033 CORE_ADDR selected_frame_pc
= (get_frame_info (selected_frame
))->pc
;
1036 /* If interactive, require confirmation. */
1042 if (!query ("Make %s return now? ", SYMBOL_NAME (thisfun
)))
1043 error ("Not confirmed.");
1046 if (!query ("Make selected stack frame return now? "))
1047 error ("Not confirmed.");
1050 /* Do the real work. Pop until the specified frame is current. We
1051 use this method because the selected_frame is not valid after
1052 a POP_FRAME. The pc comparison makes this work even if the
1053 selected frame shares its fp with another frame. */
1055 while ( selected_frame_addr
!= FRAME_FP (frame
= get_current_frame())
1056 || selected_frame_pc
!= (get_frame_info (frame
))->pc
)
1059 /* Then pop that frame. */
1063 /* Compute the return value (if any) and store in the place
1064 for return values. */
1067 set_return_value (parse_and_eval (retval_exp
));
1069 /* If interactive, print the frame that is now current. */
1072 frame_command ("0", 1);
1076 _initialize_stack ()
1079 backtrace_limit
= 30;
1082 add_com ("return", class_stack
, return_command
,
1083 "Make selected stack frame return to its caller.\n\
1084 Control remains in the debugger, but when you continue\n\
1085 execution will resume in the frame above the one now selected.\n\
1086 If an argument is given, it is an expression for the value to return.");
1088 add_com ("up", class_stack
, up_command
,
1089 "Select and print stack frame that called this one.\n\
1090 An argument says how many frames up to go.");
1091 add_com ("up-silently", class_support
, up_silently_command
,
1092 "Same as the `up' command, but does not print anything.\n\
1093 This is useful in command scripts.");
1095 add_com ("down", class_stack
, down_command
,
1096 "Select and print stack frame called by this one.\n\
1097 An argument says how many frames down to go.");
1098 add_com_alias ("do", "down", class_stack
, 1);
1099 add_com ("down-silently", class_support
, down_silently_command
,
1100 "Same as the `down' command, but does not print anything.\n\
1101 This is useful in command scripts.");
1103 add_com ("frame", class_stack
, frame_command
,
1104 "Select and print a stack frame.\n\
1105 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1106 An argument specifies the frame to select.\n\
1107 It can be a stack frame number or the address of the frame.\n\
1108 With argument, nothing is printed if input is coming from\n\
1109 a command file or a user-defined command.");
1111 add_com_alias ("f", "frame", class_stack
, 1);
1113 add_com ("backtrace", class_stack
, backtrace_command
,
1114 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1115 With a negative argument, print outermost -COUNT frames.");
1116 add_com_alias ("bt", "backtrace", class_stack
, 0);
1117 add_com_alias ("where", "backtrace", class_alias
, 0);
1118 add_info ("stack", backtrace_command
,
1119 "Backtrace of the stack, or innermost COUNT frames.");
1120 add_info_alias ("s", "stack", 1);
1121 add_info ("frame", frame_info
,
1122 "All about selected stack frame, or frame at ADDR.");
1123 add_info_alias ("f", "frame", 1);
1124 add_info ("locals", locals_info
,
1125 "Local variables of current stack frame.");
1126 add_info ("args", args_info
,
1127 "Argument variables of current stack frame.");
1128 add_info ("catch", catch_info
,
1129 "Exceptions that can be caught in the current stack frame.");
1132 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
1133 "Specify maximum number of frames for \"backtrace\" to print by default.",
1135 add_info ("backtrace-limit", backtrace_limit_info
,
1136 "The maximum number of frames for \"backtrace\" to print by default.");