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
];
188 /* Get the value of SP_REGNUM relative to the frame. */
189 get_saved_register (buf
, (int *)NULL
, (CORE_ADDR
*)NULL
,
190 FRAME_INFO_ID (fi
), SP_REGNUM
, (enum lval_type
*)NULL
);
191 sp
= extract_address (buf
, REGISTER_RAW_SIZE (SP_REGNUM
));
193 /* This is not a perfect test, because if a function alloca's some
194 memory, puts some code there, and then jumps into it, then the test
195 will succeed even though there is no call dummy. Probably best is
196 to check for a bp_call_dummy breakpoint. */
197 if (PC_IN_CALL_DUMMY (fi
->pc
, sp
, fi
->frame
))
199 /* Do this regardless of SOURCE because we don't have any source
200 to list for this frame. */
202 printf_filtered ("#%-2d ", level
);
203 printf_filtered ("<function called from gdb>\n");
206 if (fi
->signal_handler_caller
)
208 /* Do this regardless of SOURCE because we don't have any source
209 to list for this frame. */
211 printf_filtered ("#%-2d ", level
);
212 printf_filtered ("<signal handler called>\n");
216 /* If fi is not the innermost frame, that normally means that fi->pc
217 points to *after* the call instruction, and we want to get the line
218 containing the call, never the next line. But if the next frame is
219 a signal_handler_caller frame, then the next frame was not entered
220 as the result of a call, and we want to get the line containing
223 find_pc_line (fi
->pc
,
224 fi
->next
!= NULL
&& fi
->next
->signal_handler_caller
== 0);
226 func
= find_pc_function (fi
->pc
);
229 /* In certain pathological cases, the symtabs give the wrong
230 function (when we are in the first function in a file which
231 is compiled without debugging symbols, the previous function
232 is compiled with debugging symbols, and the "foo.o" symbol
233 that is supposed to tell us where the file with debugging symbols
234 ends has been truncated by ar because it is longer than 15
235 characters). This also occurs if the user uses asm() to create
236 a function but not stabs for it (in a file compiled -g).
238 So look in the minimal symbol tables as well, and if it comes
239 up with a larger address for the function use that instead.
240 I don't think this can ever cause any problems; there shouldn't
241 be any minimal symbols in the middle of a function; if this is
242 ever changed many parts of GDB will need to be changed (and we'll
243 create a find_pc_minimal_function or some such). */
245 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
247 && (SYMBOL_VALUE_ADDRESS (msymbol
)
248 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
250 /* In this case we have no way of knowing the source file
251 and line number, so don't print them. */
253 /* We also don't know anything about the function besides
254 its address and name. */
256 funname
= SYMBOL_NAME (msymbol
);
257 funlang
= SYMBOL_LANGUAGE (msymbol
);
261 funname
= SYMBOL_NAME (func
);
262 funlang
= SYMBOL_LANGUAGE (func
);
267 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
270 funname
= SYMBOL_NAME (msymbol
);
271 funlang
= SYMBOL_LANGUAGE (msymbol
);
275 if (source
>= 0 || !sal
.symtab
)
278 printf_filtered ("#%-2d ", level
);
280 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
)
281 printf_filtered ("%s in ", local_hex_string((unsigned long) fi
->pc
));
282 fprintf_symbol_filtered (gdb_stdout
, funname
? funname
: "??", funlang
,
285 fputs_filtered (" (", gdb_stdout
);
288 struct print_args_args args
;
291 catch_errors (print_args_stub
, (char *)&args
, "", RETURN_MASK_ERROR
);
293 printf_filtered (")");
294 if (sal
.symtab
&& sal
.symtab
->filename
)
297 printf_filtered (" at %s:%d", sal
.symtab
->filename
, sal
.line
);
300 #ifdef PC_LOAD_SEGMENT
301 /* If we couldn't print out function name but if can figure out what
302 load segment this pc value is from, at least print out some info
303 about its load segment. */
306 printf_filtered (" from %s", PC_LOAD_SEGMENT (fi
->pc
));
309 printf_filtered ("\n");
312 if ((source
!= 0) && sal
.symtab
)
315 int mid_statement
= source
< 0 && fi
->pc
!= sal
.pc
;
316 if (frame_file_full_name
)
317 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
321 if (addressprint
&& mid_statement
)
322 printf_filtered ("%s\t", local_hex_string((unsigned long) fi
->pc
));
323 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
325 current_source_line
= max (sal
.line
- lines_to_list
/2, 1);
328 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
330 gdb_flush (gdb_stdout
);
334 * Read a frame specification in whatever the appropriate format is.
335 * Call error() if the specification is in any way invalid (i.e.
336 * this function never returns NULL).
339 parse_frame_specification (frame_exp
)
344 CORE_ADDR args
[MAXARGS
];
348 char *addr_string
, *p
;
349 struct cleanup
*tmp_cleanup
;
351 while (*frame_exp
== ' ') frame_exp
++;
355 if (numargs
> MAXARGS
)
356 error ("Too many args in frame specification");
357 /* Parse an argument. */
358 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
360 addr_string
= savestring(frame_exp
, p
- frame_exp
);
363 tmp_cleanup
= make_cleanup (free
, addr_string
);
364 args
[numargs
++] = parse_and_eval_address (addr_string
);
365 do_cleanups (tmp_cleanup
);
368 /* Skip spaces, move to possible next arg. */
369 while (*p
== ' ') p
++;
377 if (selected_frame
== NULL
)
378 error ("No selected frame.");
379 return selected_frame
;
384 FRAME fid
= find_relative_frame (get_current_frame (), &level
);
388 /* find_relative_frame was successful */
391 /* If (s)he specifies the frame with an address, he deserves what
392 (s)he gets. Still, give the highest one that matches. */
394 for (fid
= get_current_frame ();
395 fid
&& FRAME_FP (fid
) != args
[0];
396 fid
= get_prev_frame (fid
))
400 while ((tfid
= get_prev_frame (fid
)) &&
401 (FRAME_FP (tfid
) == args
[0]))
404 /* We couldn't identify the frame as an existing frame, but
405 perhaps we can create one with a single argument.
406 Fall through to default case; it's up to SETUP_ARBITRARY_FRAME
407 to complain if it doesn't like a single arg. */
411 #ifdef SETUP_ARBITRARY_FRAME
412 return SETUP_ARBITRARY_FRAME (numargs
, args
);
414 /* Usual case. Do it here rather than have everyone supply
415 a SETUP_ARBITRARY_FRAME that does this. */
417 return create_new_frame (args
[0], 0);
418 error ("Too many args in frame specification");
425 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
426 that if it is unsure about the answer, it returns 0
427 instead of guessing (this happens on the VAX and i960, for example).
429 On most machines, we never have to guess about the args address,
430 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
431 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
432 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
435 /* Print verbosely the selected frame or the frame at address ADDR.
436 This means absolutely all information in the frame is printed. */
439 frame_info (addr_exp
, from_tty
)
444 struct frame_info
*fi
;
445 struct frame_saved_regs fsr
;
446 struct symtab_and_line sal
;
452 enum language funlang
= language_unknown
;
454 if (!target_has_stack
)
457 frame
= parse_frame_specification (addr_exp
);
459 error ("Invalid frame specified.");
461 fi
= get_frame_info (frame
);
462 sal
= find_pc_line (fi
->pc
,
463 fi
->next
!= NULL
&& fi
->next
->signal_handler_caller
== 0);
464 func
= get_frame_function (frame
);
465 s
= find_pc_symtab(fi
->pc
);
468 funname
= SYMBOL_NAME (func
);
469 funlang
= SYMBOL_LANGUAGE (func
);
473 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
476 funname
= SYMBOL_NAME (msymbol
);
477 funlang
= SYMBOL_LANGUAGE (msymbol
);
480 calling_frame
= get_prev_frame (frame
);
482 if (!addr_exp
&& selected_frame_level
>= 0) {
483 printf_filtered ("Stack level %d, frame at %s:\n",
484 selected_frame_level
,
485 local_hex_string((unsigned long) FRAME_FP(frame
)));
487 printf_filtered ("Stack frame at %s:\n",
488 local_hex_string((unsigned long) FRAME_FP(frame
)));
490 printf_filtered (" %s = %s",
491 reg_names
[PC_REGNUM
],
492 local_hex_string((unsigned long) fi
->pc
));
497 printf_filtered (" in ");
498 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
499 DMGL_ANSI
| DMGL_PARAMS
);
503 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
504 puts_filtered ("; ");
506 printf_filtered ("saved %s %s\n", reg_names
[PC_REGNUM
],
507 local_hex_string((unsigned long) FRAME_SAVED_PC (frame
)));
511 #ifdef FRAMELESS_FUNCTION_INVOCATION
512 FRAMELESS_FUNCTION_INVOCATION (fi
, frameless
);
515 printf_filtered (" (FRAMELESS),");
519 printf_filtered (" called by frame at %s",
520 local_hex_string((unsigned long) FRAME_FP (calling_frame
)));
521 if (fi
->next
&& calling_frame
)
525 printf_filtered (" caller of frame at %s",
526 local_hex_string ((unsigned long) fi
->next
->frame
));
527 if (fi
->next
|| calling_frame
)
528 puts_filtered ("\n");
530 printf_filtered(" source language %s.\n", language_str(s
->language
));
532 #ifdef PRINT_EXTRA_FRAME_INFO
533 PRINT_EXTRA_FRAME_INFO (fi
);
537 /* Address of the argument list for this frame, or 0. */
538 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
539 /* Number of args for this frame, or -1 if unknown. */
543 printf_filtered (" Arglist at unknown address.\n");
546 printf_filtered (" Arglist at %s,",
547 local_hex_string((unsigned long) arg_list
));
549 FRAME_NUM_ARGS (numargs
, fi
);
551 puts_filtered (" args: ");
552 else if (numargs
== 0)
553 puts_filtered (" no args.");
554 else if (numargs
== 1)
555 puts_filtered (" 1 arg: ");
557 printf_filtered (" %d args: ", numargs
);
558 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
559 puts_filtered ("\n");
563 /* Address of the local variables for this frame, or 0. */
564 CORE_ADDR arg_list
= FRAME_LOCALS_ADDRESS (fi
);
567 printf_filtered (" Locals at unknown address,");
569 printf_filtered (" Locals at %s,",
570 local_hex_string((unsigned long) arg_list
));
573 #if defined (FRAME_FIND_SAVED_REGS)
574 get_frame_saved_regs (fi
, &fsr
);
575 /* The sp is special; what's returned isn't the save address, but
576 actually the value of the previous frame's sp. */
577 printf_filtered (" Previous frame's sp is %s\n",
578 local_hex_string((unsigned long) fsr
.regs
[SP_REGNUM
]));
580 for (i
= 0; i
< NUM_REGS
; i
++)
581 if (fsr
.regs
[i
] && i
!= SP_REGNUM
)
584 puts_filtered (" Saved registers:\n ");
588 printf_filtered (" %s at %s", reg_names
[i
],
589 local_hex_string((unsigned long) fsr
.regs
[i
]));
593 puts_filtered ("\n");
594 #endif /* Have FRAME_FIND_SAVED_REGS. */
598 /* Set a limit on the number of frames printed by default in a
601 static int backtrace_limit
;
604 set_backtrace_limit_command (count_exp
, from_tty
)
608 int count
= parse_and_eval_address (count_exp
);
611 error ("Negative argument not meaningful as backtrace limit.");
613 backtrace_limit
= count
;
617 backtrace_limit_info (arg
, from_tty
)
622 error ("\"Info backtrace-limit\" takes no arguments.");
624 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit
);
628 /* Print briefly all stack frames or just the innermost COUNT frames. */
631 backtrace_command (count_exp
, from_tty
)
635 struct frame_info
*fi
;
637 register FRAME frame
;
639 register FRAME trailing
;
640 register int trailing_level
;
642 if (!target_has_stack
)
645 /* The following code must do two things. First, it must
646 set the variable TRAILING to the frame from which we should start
647 printing. Second, it must set the variable count to the number
648 of frames which we should print, or -1 if all of them. */
649 trailing
= get_current_frame ();
653 count
= parse_and_eval_address (count_exp
);
661 while (current
&& count
--)
664 current
= get_prev_frame (current
);
667 /* Will stop when CURRENT reaches the top of the stack. TRAILING
668 will be COUNT below it. */
672 trailing
= get_prev_frame (trailing
);
673 current
= get_prev_frame (current
);
685 struct partial_symtab
*ps
;
687 /* Read in symbols for all of the frames. Need to do this in
688 a separate pass so that "Reading in symbols for xxx" messages
689 don't screw up the appearance of the backtrace. Also
690 if people have strong opinions against reading symbols for
691 backtrace this may have to be an option. */
693 for (frame
= trailing
;
694 frame
!= NULL
&& i
--;
695 frame
= get_prev_frame (frame
))
698 fi
= get_frame_info (frame
);
699 ps
= find_pc_psymtab (fi
->pc
);
701 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
705 for (i
= 0, frame
= trailing
;
707 i
++, frame
= get_prev_frame (frame
))
710 fi
= get_frame_info (frame
);
712 /* Don't use print_stack_frame; if an error() occurs it probably
713 means further attempts to backtrace would fail (on the other
714 hand, perhaps the code does or could be fixed to make sure
715 the frame->prev field gets set to NULL in that case). */
716 print_frame_info (fi
, trailing_level
+ i
, 0, 1);
719 /* If we've stopped before the end, mention that. */
720 if (frame
&& from_tty
)
721 printf_filtered ("(More stack frames follow...)\n");
724 /* Print the local variables of a block B active in FRAME.
725 Return 1 if any variables were printed; 0 otherwise. */
728 print_block_frame_locals (b
, frame
, stream
)
730 register FRAME frame
;
731 register GDB_FILE
*stream
;
735 register struct symbol
*sym
;
736 register int values_printed
= 0;
738 nsyms
= BLOCK_NSYMS (b
);
740 for (i
= 0; i
< nsyms
; i
++)
742 sym
= BLOCK_SYM (b
, i
);
743 if (SYMBOL_CLASS (sym
) == LOC_LOCAL
744 || SYMBOL_CLASS (sym
) == LOC_REGISTER
745 || SYMBOL_CLASS (sym
) == LOC_STATIC
)
748 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
749 fputs_filtered (" = ", stream
);
750 print_variable_value (sym
, frame
, stream
);
751 fprintf_filtered (stream
, "\n");
754 return values_printed
;
757 /* Same, but print labels. */
760 print_block_frame_labels (b
, have_default
, stream
)
763 register GDB_FILE
*stream
;
767 register struct symbol
*sym
;
768 register int values_printed
= 0;
770 nsyms
= BLOCK_NSYMS (b
);
772 for (i
= 0; i
< nsyms
; i
++)
774 sym
= BLOCK_SYM (b
, i
);
775 if (STREQ (SYMBOL_NAME (sym
), "default"))
781 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
783 struct symtab_and_line sal
;
784 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
786 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
788 fprintf_filtered (stream
, " %s",
789 local_hex_string((unsigned long) SYMBOL_VALUE_ADDRESS (sym
)));
790 fprintf_filtered (stream
, " in file %s, line %d\n",
791 sal
.symtab
->filename
, sal
.line
);
794 return values_printed
;
797 /* Print on STREAM all the local variables in frame FRAME,
798 including all the blocks active in that frame
801 Returns 1 if the job was done,
802 or 0 if nothing was printed because we have no info
803 on the function running in FRAME. */
806 print_frame_local_vars (frame
, stream
)
807 register FRAME frame
;
808 register GDB_FILE
*stream
;
810 register struct block
*block
= get_frame_block (frame
);
811 register int values_printed
= 0;
815 fprintf_filtered (stream
, "No symbol table info available.\n");
821 if (print_block_frame_locals (block
, frame
, stream
))
823 /* After handling the function's top-level block, stop.
824 Don't continue to its superblock, the block of
826 if (BLOCK_FUNCTION (block
))
828 block
= BLOCK_SUPERBLOCK (block
);
833 fprintf_filtered (stream
, "No locals.\n");
837 /* Same, but print labels. */
840 print_frame_label_vars (frame
, this_level_only
, stream
)
841 register FRAME frame
;
843 register GDB_FILE
*stream
;
845 register struct blockvector
*bl
;
846 register struct block
*block
= get_frame_block (frame
);
847 register int values_printed
= 0;
848 int index
, have_default
= 0;
849 char *blocks_printed
;
850 struct frame_info
*fi
= get_frame_info (frame
);
851 CORE_ADDR pc
= fi
->pc
;
855 fprintf_filtered (stream
, "No symbol table info available.\n");
859 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
860 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
861 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
865 CORE_ADDR end
= BLOCK_END (block
) - 4;
868 if (bl
!= blockvector_for_pc (end
, &index
))
869 error ("blockvector blotch");
870 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
871 error ("blockvector botch");
872 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
875 /* Don't print out blocks that have gone by. */
876 while (index
< last_index
877 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
880 while (index
< last_index
881 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
883 if (blocks_printed
[index
] == 0)
885 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
887 blocks_printed
[index
] = 1;
893 if (values_printed
&& this_level_only
)
896 /* After handling the function's top-level block, stop.
897 Don't continue to its superblock, the block of
899 if (BLOCK_FUNCTION (block
))
901 block
= BLOCK_SUPERBLOCK (block
);
904 if (!values_printed
&& !this_level_only
)
906 fprintf_filtered (stream
, "No catches.\n");
912 locals_info (args
, from_tty
)
917 error ("No frame selected.");
918 print_frame_local_vars (selected_frame
, gdb_stdout
);
922 catch_info (ignore
, from_tty
)
927 error ("No frame selected.");
928 print_frame_label_vars (selected_frame
, 0, gdb_stdout
);
932 print_frame_arg_vars (frame
, stream
)
933 register FRAME frame
;
934 register GDB_FILE
*stream
;
936 struct symbol
*func
= get_frame_function (frame
);
937 register struct block
*b
;
940 register struct symbol
*sym
, *sym2
;
941 register int values_printed
= 0;
945 fprintf_filtered (stream
, "No symbol table info available.\n");
949 b
= SYMBOL_BLOCK_VALUE (func
);
950 nsyms
= BLOCK_NSYMS (b
);
952 for (i
= 0; i
< nsyms
; i
++)
954 sym
= BLOCK_SYM (b
, i
);
955 switch (SYMBOL_CLASS (sym
))
961 case LOC_REGPARM_ADDR
:
962 case LOC_BASEREG_ARG
:
964 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
965 fputs_filtered (" = ", stream
);
967 /* We have to look up the symbol because arguments can have
968 two entries (one a parameter, one a local) and the one we
969 want is the local, which lookup_symbol will find for us.
970 This includes gcc1 (not gcc2) on the sparc when passing a
971 small structure and gcc2 when the argument type is float
972 and it is passed as a double and converted to float by
973 the prologue (in the latter case the type of the LOC_ARG
974 symbol is double and the type of the LOC_LOCAL symbol is
975 float). There are also LOC_ARG/LOC_REGISTER pairs which
976 are not combined in symbol-reading. */
978 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
979 b
, VAR_NAMESPACE
, (int *)NULL
, (struct symtab
**)NULL
);
980 print_variable_value (sym2
, frame
, stream
);
981 fprintf_filtered (stream
, "\n");
985 /* Don't worry about things which aren't arguments. */
992 fprintf_filtered (stream
, "No arguments.\n");
997 args_info (ignore
, from_tty
)
1001 if (!selected_frame
)
1002 error ("No frame selected.");
1003 print_frame_arg_vars (selected_frame
, gdb_stdout
);
1006 /* Select frame FRAME, and note that its stack level is LEVEL.
1007 LEVEL may be -1 if an actual level number is not known. */
1010 select_frame (frame
, level
)
1014 register struct symtab
*s
;
1016 selected_frame
= frame
;
1017 selected_frame_level
= level
;
1019 /* Ensure that symbols for this frame are read in. Also, determine the
1020 source language of this frame, and switch to it if desired. */
1023 s
= find_pc_symtab (get_frame_info (frame
)->pc
);
1025 && s
->language
!= current_language
->la_language
1026 && s
->language
!= language_unknown
1027 && language_mode
== language_mode_auto
) {
1028 set_language(s
->language
);
1033 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
1034 If there is no selected frame, *FRAMEP is set to NULL. */
1037 record_selected_frame (frameaddrp
, levelp
)
1038 FRAME_ADDR
*frameaddrp
;
1041 *frameaddrp
= selected_frame
? FRAME_FP (selected_frame
) : 0;
1042 *levelp
= selected_frame_level
;
1045 /* Return the symbol-block in which the selected frame is executing.
1046 Can return zero under various legitimate circumstances. */
1049 get_selected_block ()
1051 if (!target_has_stack
)
1054 if (!selected_frame
)
1055 return get_current_block ();
1056 return get_frame_block (selected_frame
);
1059 /* Find a frame a certain number of levels away from FRAME.
1060 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1061 Positive means go to earlier frames (up); negative, the reverse.
1062 The int that contains the number of levels is counted toward
1063 zero as the frames for those levels are found.
1064 If the top or bottom frame is reached, that frame is returned,
1065 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1066 how much farther the original request asked to go. */
1069 find_relative_frame (frame
, level_offset_ptr
)
1070 register FRAME frame
;
1071 register int* level_offset_ptr
;
1073 register FRAME prev
;
1074 register FRAME frame1
;
1076 /* Going up is simple: just do get_prev_frame enough times
1077 or until initial frame is reached. */
1078 while (*level_offset_ptr
> 0)
1080 prev
= get_prev_frame (frame
);
1083 (*level_offset_ptr
)--;
1086 /* Going down is just as simple. */
1087 if (*level_offset_ptr
< 0)
1089 while (*level_offset_ptr
< 0) {
1090 frame1
= get_next_frame (frame
);
1094 (*level_offset_ptr
)++;
1100 /* The "select_frame" command. With no arg, NOP.
1101 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1102 valid level. Otherwise, treat level_exp as an address expression
1103 and select it. See parse_frame_specification for more info on proper
1104 frame expressions. */
1108 select_frame_command (level_exp
, from_tty
)
1112 register FRAME frame
, frame1
;
1113 unsigned int level
= 0;
1115 if (!target_has_stack
)
1116 error ("No stack.");
1118 frame
= parse_frame_specification (level_exp
);
1120 /* Try to figure out what level this frame is. But if there is
1121 no current stack, don't error out -- let the user set one. */
1123 if (get_current_frame()) {
1124 for (frame1
= get_prev_frame (0);
1125 frame1
&& frame1
!= frame
;
1126 frame1
= get_prev_frame (frame1
))
1133 select_frame (frame
, level
);
1136 /* The "frame" command. With no arg, print selected frame briefly.
1137 With arg, behaves like select_frame and then prints the selected
1141 frame_command (level_exp
, from_tty
)
1145 select_frame_command (level_exp
, from_tty
);
1146 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1149 /* Select the frame up one or COUNT stack levels
1150 from the previously selected frame, and print it briefly. */
1154 up_silently_command (count_exp
, from_tty
)
1158 register FRAME frame
;
1159 int count
= 1, count1
;
1161 count
= parse_and_eval_address (count_exp
);
1164 if (target_has_stack
== 0 || selected_frame
== 0)
1165 error ("No stack.");
1167 frame
= find_relative_frame (selected_frame
, &count1
);
1168 if (count1
!= 0 && count_exp
== 0)
1169 error ("Initial frame selected; you cannot go up.");
1170 select_frame (frame
, selected_frame_level
+ count
- count1
);
1174 up_command (count_exp
, from_tty
)
1178 up_silently_command (count_exp
, from_tty
);
1179 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1182 /* Select the frame down one or COUNT stack levels
1183 from the previously selected frame, and print it briefly. */
1187 down_silently_command (count_exp
, from_tty
)
1191 register FRAME frame
;
1192 int count
= -1, count1
;
1194 count
= - parse_and_eval_address (count_exp
);
1197 if (target_has_stack
== 0 || selected_frame
== 0)
1198 error ("No stack.");
1200 frame
= find_relative_frame (selected_frame
, &count1
);
1201 if (count1
!= 0 && count_exp
== 0)
1202 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1203 select_frame (frame
, selected_frame_level
+ count
- count1
);
1208 down_command (count_exp
, from_tty
)
1212 down_silently_command (count_exp
, from_tty
);
1213 print_stack_frame (selected_frame
, selected_frame_level
, 1);
1217 return_command (retval_exp
, from_tty
)
1221 struct symbol
*thisfun
;
1222 FRAME_ADDR selected_frame_addr
;
1223 CORE_ADDR selected_frame_pc
;
1225 value return_value
= NULL
;
1227 if (selected_frame
== NULL
)
1228 error ("No selected frame.");
1229 thisfun
= get_frame_function (selected_frame
);
1230 selected_frame_addr
= FRAME_FP (selected_frame
);
1231 selected_frame_pc
= (get_frame_info (selected_frame
))->pc
;
1233 /* Compute the return value (if any -- possibly getting errors here). */
1237 return_value
= parse_and_eval (retval_exp
);
1239 /* Make sure we have fully evaluated it, since
1240 it might live in the stack frame we're about to pop. */
1241 if (VALUE_LAZY (return_value
))
1242 value_fetch_lazy (return_value
);
1245 /* If interactive, require confirmation. */
1251 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun
)))
1253 error ("Not confirmed.");
1258 if (!query ("Make selected stack frame return now? "))
1259 error ("Not confirmed.");
1262 /* Do the real work. Pop until the specified frame is current. We
1263 use this method because the selected_frame is not valid after
1264 a POP_FRAME. The pc comparison makes this work even if the
1265 selected frame shares its fp with another frame. */
1267 while ( selected_frame_addr
!= FRAME_FP (frame
= get_current_frame())
1268 || selected_frame_pc
!= (get_frame_info (frame
))->pc
)
1271 /* Then pop that frame. */
1275 /* Compute the return value (if any) and store in the place
1276 for return values. */
1279 set_return_value (return_value
);
1281 /* If interactive, print the frame that is now current. */
1284 frame_command ("0", 1);
1287 /* Gets the language of the current frame. */
1289 get_frame_language()
1291 register struct symtab
*s
;
1293 enum language flang
; /* The language of the current frame */
1295 fr
= get_frame_info(selected_frame
);
1298 s
= find_pc_symtab(fr
->pc
);
1300 flang
= s
->language
;
1302 flang
= language_unknown
;
1305 flang
= language_unknown
;
1311 _initialize_stack ()
1314 backtrace_limit
= 30;
1317 add_com ("return", class_stack
, return_command
,
1318 "Make selected stack frame return to its caller.\n\
1319 Control remains in the debugger, but when you continue\n\
1320 execution will resume in the frame above the one now selected.\n\
1321 If an argument is given, it is an expression for the value to return.");
1323 add_com ("up", class_stack
, up_command
,
1324 "Select and print stack frame that called this one.\n\
1325 An argument says how many frames up to go.");
1326 add_com ("up-silently", class_support
, up_silently_command
,
1327 "Same as the `up' command, but does not print anything.\n\
1328 This is useful in command scripts.");
1330 add_com ("down", class_stack
, down_command
,
1331 "Select and print stack frame called by this one.\n\
1332 An argument says how many frames down to go.");
1333 add_com_alias ("do", "down", class_stack
, 1);
1334 add_com_alias ("dow", "down", class_stack
, 1);
1335 add_com ("down-silently", class_support
, down_silently_command
,
1336 "Same as the `down' command, but does not print anything.\n\
1337 This is useful in command scripts.");
1339 add_com ("frame", class_stack
, frame_command
,
1340 "Select and print a stack frame.\n\
1341 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1342 An argument specifies the frame to select.\n\
1343 It can be a stack frame number or the address of the frame.\n\
1344 With argument, nothing is printed if input is coming from\n\
1345 a command file or a user-defined command.");
1347 add_com_alias ("f", "frame", class_stack
, 1);
1349 add_com ("select-frame", class_stack
, select_frame_command
,
1350 "Select a stack frame without printing anything.\n\
1351 An argument specifies the frame to select.\n\
1352 It can be a stack frame number or the address of the frame.\n");
1354 add_com ("backtrace", class_stack
, backtrace_command
,
1355 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1356 With a negative argument, print outermost -COUNT frames.");
1357 add_com_alias ("bt", "backtrace", class_stack
, 0);
1358 add_com_alias ("where", "backtrace", class_alias
, 0);
1359 add_info ("stack", backtrace_command
,
1360 "Backtrace of the stack, or innermost COUNT frames.");
1361 add_info_alias ("s", "stack", 1);
1362 add_info ("frame", frame_info
,
1363 "All about selected stack frame, or frame at ADDR.");
1364 add_info_alias ("f", "frame", 1);
1365 add_info ("locals", locals_info
,
1366 "Local variables of current stack frame.");
1367 add_info ("args", args_info
,
1368 "Argument variables of current stack frame.");
1369 add_info ("catch", catch_info
,
1370 "Exceptions that can be caught in the current stack frame.");
1373 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
1374 "Specify maximum number of frames for \"backtrace\" to print by default.",
1376 add_info ("backtrace-limit", backtrace_limit_info
,
1377 "The maximum number of frames for \"backtrace\" to print by default.");