1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
30 #include "expression.h"
36 #include "breakpoint.h"
42 /* Prototypes for exported functions. */
44 void args_info (char *, int);
46 void locals_info (char *, int);
48 void (*selected_frame_level_changed_hook
) (int);
50 void _initialize_stack (void);
52 /* Prototypes for local functions. */
54 static void return_command (char *, int);
56 static void down_command (char *, int);
58 static void down_silently_base (char *);
60 static void down_silently_command (char *, int);
62 static void up_command (char *, int);
64 static void up_silently_base (char *);
66 static void up_silently_command (char *, int);
68 void frame_command (char *, int);
70 static void current_frame_command (char *, int);
72 static void select_frame_command (char *, int);
74 static void print_frame_arg_vars (struct frame_info
*, struct ui_file
*);
76 static void catch_info (char *, int);
78 static void args_plus_locals_info (char *, int);
80 static void print_frame_label_vars (struct frame_info
*, int,
83 static void print_frame_local_vars (struct frame_info
*, int,
86 static int print_block_frame_labels (struct block
*, int *,
89 static int print_block_frame_locals (struct block
*,
94 static void print_frame (struct frame_info
*fi
,
98 struct symtab_and_line sal
);
100 static void print_frame_info_base (struct frame_info
*, int, int, int);
102 static void print_stack_frame_base (struct frame_info
*, int, int);
104 static void backtrace_command (char *, int);
106 struct frame_info
*parse_frame_specification (char *);
108 static void frame_info (char *, int);
110 extern int addressprint
; /* Print addresses, or stay symbolic only? */
111 extern int lines_to_list
; /* # of lines "list" command shows by default */
113 /* The "selected" stack frame is used by default for local and arg access.
114 May be zero, for no selected frame. */
116 struct frame_info
*selected_frame
;
118 /* Level of the selected frame:
119 0 for innermost, 1 for its caller, ...
120 or -1 for frame specified by address with no defined level. */
122 int selected_frame_level
;
124 /* Zero means do things normally; we are interacting directly with the
125 user. One means print the full filename and linenumber when a
126 frame is printed, and do so in a format emacs18/emacs19.22 can
127 parse. Two means print similar annotations, but in many more
128 cases and in a slightly different syntax. */
130 int annotation_level
= 0;
133 struct print_stack_frame_args
135 struct frame_info
*fi
;
141 static int print_stack_frame_base_stub (char *);
143 /* Show and print the frame arguments.
144 Pass the args the way catch_errors wants them. */
145 static int show_and_print_stack_frame_stub (void *args
);
147 show_and_print_stack_frame_stub (void *args
)
149 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*) args
;
151 print_frame_info (p
->fi
, p
->level
, p
->source
, p
->args
);
156 /* Show or print the frame arguments.
157 Pass the args the way catch_errors wants them. */
158 static int print_stack_frame_stub (void *args
);
160 print_stack_frame_stub (void *args
)
162 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*) args
;
164 print_frame_info_base (p
->fi
, p
->level
, p
->source
, p
->args
);
168 /* Print a stack frame briefly. FRAME_INFI should be the frame info
169 and LEVEL should be its level in the stack (or -1 for level not
172 /* Pass the args the way catch_errors wants them. */
174 print_stack_frame_base_stub (char *args
)
176 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*) args
;
178 print_frame_info_base (p
->fi
, p
->level
, p
->source
, p
->args
);
182 /* print the frame arguments to the terminal.
183 Pass the args the way catch_errors wants them. */
184 static int print_only_stack_frame_stub (void *);
186 print_only_stack_frame_stub (void *args
)
188 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*) args
;
190 print_frame_info_base (p
->fi
, p
->level
, p
->source
, p
->args
);
194 /* Print a stack frame briefly. FRAME_INFI should be the frame info
195 and LEVEL should be its level in the stack (or -1 for level not defined).
196 This prints the level, the function executing, the arguments,
197 and the file name and line number.
198 If the pc is not at the beginning of the source line,
199 the actual pc is printed at the beginning.
201 If SOURCE is 1, print the source line as well.
202 If SOURCE is -1, print ONLY the source line. */
205 print_stack_frame_base (struct frame_info
*fi
, int level
, int source
)
207 struct print_stack_frame_args args
;
211 args
.source
= source
;
214 catch_errors (print_stack_frame_stub
, &args
, "", RETURN_MASK_ALL
);
217 /* Show and print a stack frame briefly. FRAME_INFI should be the frame info
218 and LEVEL should be its level in the stack (or -1 for level not defined).
219 This prints the level, the function executing, the arguments,
220 and the file name and line number.
221 If the pc is not at the beginning of the source line,
222 the actual pc is printed at the beginning.
224 If SOURCE is 1, print the source line as well.
225 If SOURCE is -1, print ONLY the source line. */
228 show_and_print_stack_frame (struct frame_info
*fi
, int level
, int source
)
230 struct print_stack_frame_args args
;
234 args
.source
= source
;
237 catch_errors (show_and_print_stack_frame_stub
, &args
, "", RETURN_MASK_ALL
);
241 /* Show or print a stack frame briefly. FRAME_INFI should be the frame info
242 and LEVEL should be its level in the stack (or -1 for level not defined).
243 This prints the level, the function executing, the arguments,
244 and the file name and line number.
245 If the pc is not at the beginning of the source line,
246 the actual pc is printed at the beginning.
248 If SOURCE is 1, print the source line as well.
249 If SOURCE is -1, print ONLY the source line. */
252 print_stack_frame (struct frame_info
*fi
, int level
, int source
)
254 struct print_stack_frame_args args
;
258 args
.source
= source
;
261 catch_errors (print_stack_frame_stub
, (char *) &args
, "", RETURN_MASK_ALL
);
264 /* Print a stack frame briefly. FRAME_INFI should be the frame info
265 and LEVEL should be its level in the stack (or -1 for level not defined).
266 This prints the level, the function executing, the arguments,
267 and the file name and line number.
268 If the pc is not at the beginning of the source line,
269 the actual pc is printed at the beginning.
271 If SOURCE is 1, print the source line as well.
272 If SOURCE is -1, print ONLY the source line. */
275 print_only_stack_frame (struct frame_info
*fi
, int level
, int source
)
277 struct print_stack_frame_args args
;
281 args
.source
= source
;
284 catch_errors (print_only_stack_frame_stub
, &args
, "", RETURN_MASK_ALL
);
287 struct print_args_args
290 struct frame_info
*fi
;
291 struct ui_file
*stream
;
294 static int print_args_stub (PTR
);
296 /* Pass the args the way catch_errors wants them. */
299 print_args_stub (PTR args
)
302 struct print_args_args
*p
= (struct print_args_args
*) args
;
304 numargs
= FRAME_NUM_ARGS (p
->fi
);
305 print_frame_args (p
->func
, p
->fi
, numargs
, p
->stream
);
309 /* Print information about a frame for frame "fi" at level "level".
310 Used in "where" output, also used to emit breakpoint or step
312 LEVEL is the level of the frame, or -1 if it is the
313 innermost frame but we don't want to print the level.
314 The meaning of the SOURCE argument is:
315 SRC_LINE: Print only source line
316 LOCATION: Print only location
317 LOC_AND_SRC: Print location and source line. */
320 print_frame_info_base (struct frame_info
*fi
, int level
, int source
, int args
)
322 struct symtab_and_line sal
;
327 char buf
[MAX_REGISTER_RAW_SIZE
];
330 /* On the 68k, this spends too much time in m68k_find_saved_regs. */
332 /* Get the value of SP_REGNUM relative to the frame. */
333 get_saved_register (buf
, (int *) NULL
, (CORE_ADDR
*) NULL
,
334 FRAME_INFO_ID (fi
), SP_REGNUM
, (enum lval_type
*) NULL
);
335 sp
= extract_address (buf
, REGISTER_RAW_SIZE (SP_REGNUM
));
337 /* This is not a perfect test, because if a function alloca's some
338 memory, puts some code there, and then jumps into it, then the test
339 will succeed even though there is no call dummy. Probably best is
340 to check for a bp_call_dummy breakpoint. */
341 if (PC_IN_CALL_DUMMY (fi
->pc
, sp
, fi
->frame
))
343 if (frame_in_dummy (fi
))
346 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
348 /* Do this regardless of SOURCE because we don't have any source
349 to list for this frame. */
351 printf_filtered ("#%-2d ", level
);
352 annotate_function_call ();
353 printf_filtered ("<function called from gdb>\n");
354 annotate_frame_end ();
357 if (fi
->signal_handler_caller
)
359 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
361 /* Do this regardless of SOURCE because we don't have any source
362 to list for this frame. */
364 printf_filtered ("#%-2d ", level
);
365 annotate_signal_handler_caller ();
366 printf_filtered ("<signal handler called>\n");
367 annotate_frame_end ();
371 /* If fi is not the innermost frame, that normally means that fi->pc
372 points to *after* the call instruction, and we want to get the line
373 containing the call, never the next line. But if the next frame is
374 a signal_handler_caller or a dummy frame, then the next frame was
375 not entered as the result of a call, and we want to get the line
376 containing fi->pc. */
378 find_pc_line (fi
->pc
,
380 && !fi
->next
->signal_handler_caller
381 && !frame_in_dummy (fi
->next
));
383 location_print
= (source
== LOCATION
384 || source
== LOC_AND_ADDRESS
385 || source
== SRC_AND_LOC
);
387 if (location_print
|| !sal
.symtab
)
388 print_frame (fi
, level
, source
, args
, sal
);
390 source_print
= (source
== SRC_LINE
|| source
== SRC_AND_LOC
);
392 if (source_print
&& sal
.symtab
)
395 int mid_statement
= (source
== SRC_LINE
) && (fi
->pc
!= sal
.pc
);
397 if (annotation_level
)
398 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
402 if (print_frame_info_listing_hook
)
404 print_frame_info_listing_hook (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
405 current_source_symtab
= sal
.symtab
;
409 /* We used to do this earlier, but that is clearly
410 wrong. This function is used by many different
411 parts of gdb, including normal_stop in infrun.c,
412 which uses this to print out the current PC
413 when we stepi/nexti into the middle of a source
414 line. Only the command line really wants this
415 behavior. Other UIs probably would like the
416 ability to decide for themselves if it is desired. */
417 if (addressprint
&& mid_statement
)
419 ui_out_field_core_addr (uiout
, "addr", fi
->pc
);
420 ui_out_text (uiout
, "\t");
423 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
426 current_source_line
= max (sal
.line
- lines_to_list
/ 2, 1);
430 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
432 annotate_frame_end ();
434 gdb_flush (gdb_stdout
);
438 print_frame (struct frame_info
*fi
,
442 struct symtab_and_line sal
)
445 register char *funname
= 0;
446 enum language funlang
= language_unknown
;
447 struct ui_stream
*stb
;
448 struct cleanup
*old_chain
;
449 struct cleanup
*list_chain
;
451 stb
= ui_out_stream_new (uiout
);
452 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
454 func
= find_pc_function (fi
->pc
);
457 /* In certain pathological cases, the symtabs give the wrong
458 function (when we are in the first function in a file which
459 is compiled without debugging symbols, the previous function
460 is compiled with debugging symbols, and the "foo.o" symbol
461 that is supposed to tell us where the file with debugging symbols
462 ends has been truncated by ar because it is longer than 15
463 characters). This also occurs if the user uses asm() to create
464 a function but not stabs for it (in a file compiled -g).
466 So look in the minimal symbol tables as well, and if it comes
467 up with a larger address for the function use that instead.
468 I don't think this can ever cause any problems; there shouldn't
469 be any minimal symbols in the middle of a function; if this is
470 ever changed many parts of GDB will need to be changed (and we'll
471 create a find_pc_minimal_function or some such). */
473 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
475 && (SYMBOL_VALUE_ADDRESS (msymbol
)
476 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
479 /* There is no particular reason to think the line number
480 information is wrong. Someone might have just put in
481 a label with asm() but left the line numbers alone. */
482 /* In this case we have no way of knowing the source file
483 and line number, so don't print them. */
486 /* We also don't know anything about the function besides
487 its address and name. */
489 funname
= SYMBOL_NAME (msymbol
);
490 funlang
= SYMBOL_LANGUAGE (msymbol
);
494 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display the
495 demangled name that we already have stored in the symbol
496 table, but we stored a version with DMGL_PARAMS turned
497 on, and here we don't want to display parameters. So call
498 the demangler again, with DMGL_ANSI only. (Yes, I know
499 that printf_symbol_filtered() will again try to demangle
500 the name on the fly, but the issue is that if
501 cplus_demangle() fails here, it'll fail there too. So we
502 want to catch the failure ("demangled==NULL" case below)
503 here, while we still have our hands on the function
506 funname
= SYMBOL_NAME (func
);
507 funlang
= SYMBOL_LANGUAGE (func
);
508 if (funlang
== language_cplus
)
510 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
511 if (demangled
== NULL
)
512 /* If the demangler fails, try the demangled name from
513 the symbol table. This'll have parameters, but
514 that's preferable to diplaying a mangled name. */
515 funname
= SYMBOL_SOURCE_NAME (func
);
521 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
524 funname
= SYMBOL_NAME (msymbol
);
525 funlang
= SYMBOL_LANGUAGE (msymbol
);
529 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
531 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
535 ui_out_text (uiout
, "#");
536 ui_out_field_fmt (uiout
, "level", "%-2d", level
);
537 ui_out_spaces (uiout
, 1);
540 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
|| source
== LOC_AND_ADDRESS
)
542 annotate_frame_address ();
543 ui_out_field_core_addr (uiout
, "addr", fi
->pc
);
544 annotate_frame_address_end ();
545 ui_out_text (uiout
, " in ");
547 annotate_frame_function_name ();
548 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??", funlang
,
550 ui_out_field_stream (uiout
, "func", stb
);
551 ui_out_wrap_hint (uiout
, " ");
552 annotate_frame_args ();
554 ui_out_text (uiout
, " (");
557 struct print_args_args args
;
558 struct cleanup
*args_list_chain
;
561 args
.stream
= gdb_stdout
;
562 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
563 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ALL
);
564 /* FIXME: args must be a list. If one argument is a string it will
565 have " that will not be properly escaped. */
566 /* Invoke ui_out_tuple_end. */
567 do_cleanups (args_list_chain
);
570 ui_out_text (uiout
, ")");
571 if (sal
.symtab
&& sal
.symtab
->filename
)
573 annotate_frame_source_begin ();
574 ui_out_wrap_hint (uiout
, " ");
575 ui_out_text (uiout
, " at ");
576 annotate_frame_source_file ();
577 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
578 annotate_frame_source_file_end ();
579 ui_out_text (uiout
, ":");
580 annotate_frame_source_line ();
581 ui_out_field_int (uiout
, "line", sal
.line
);
582 annotate_frame_source_end ();
586 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
588 char *lib
= PC_SOLIB (fi
->pc
);
591 annotate_frame_where ();
592 ui_out_wrap_hint (uiout
, " ");
593 ui_out_text (uiout
, " from ");
594 ui_out_field_string (uiout
, "from", lib
);
597 #endif /* PC_SOLIB */
599 /* do_cleanups will call ui_out_tuple_end() for us. */
600 do_cleanups (list_chain
);
601 ui_out_text (uiout
, "\n");
602 do_cleanups (old_chain
);
606 /* Show or print the frame info. If this is the tui, it will be shown in
607 the source display */
609 print_frame_info (struct frame_info
*fi
, register int level
, int source
,
612 print_frame_info_base (fi
, level
, source
, args
);
615 /* Show the frame info. If this is the tui, it will be shown in
616 the source display otherwise, nothing is done */
618 show_stack_frame (struct frame_info
*fi
)
623 /* Read a frame specification in whatever the appropriate format is.
624 Call error() if the specification is in any way invalid (i.e.
625 this function never returns NULL). */
628 parse_frame_specification (char *frame_exp
)
632 CORE_ADDR args
[MAXARGS
];
637 char *addr_string
, *p
;
638 struct cleanup
*tmp_cleanup
;
640 while (*frame_exp
== ' ')
645 if (numargs
> MAXARGS
)
646 error ("Too many args in frame specification");
647 /* Parse an argument. */
648 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
650 addr_string
= savestring (frame_exp
, p
- frame_exp
);
655 tmp_cleanup
= make_cleanup (xfree
, addr_string
);
657 /* NOTE: we call parse_and_eval and then both
658 value_as_long and value_as_address rather than calling
659 parse_and_eval_long and parse_and_eval_address because
660 of the issue of potential side effects from evaluating
662 vp
= parse_and_eval (addr_string
);
664 level
= value_as_long (vp
);
666 args
[numargs
++] = value_as_address (vp
);
667 do_cleanups (tmp_cleanup
);
670 /* Skip spaces, move to possible next arg. */
680 if (selected_frame
== NULL
)
681 error ("No selected frame.");
682 return selected_frame
;
686 struct frame_info
*fid
=
687 find_relative_frame (get_current_frame (), &level
);
688 struct frame_info
*tfid
;
691 /* find_relative_frame was successful */
694 /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
695 take at least 2 addresses. It is important to detect this case
696 here so that "frame 100" does not give a confusing error message
697 like "frame specification requires two addresses". This of course
698 does not solve the "frame 100" problem for machines on which
699 a frame specification can be made with one address. To solve
700 that, we need a new syntax for a specifying a frame by address.
701 I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
702 two args, etc.), but people might think that is too much typing,
703 so I guess *0x23,0x45 would be a possible alternative (commas
704 really should be used instead of spaces to delimit; using spaces
705 normally works in an expression). */
706 #ifdef SETUP_ARBITRARY_FRAME
707 error ("No frame %s", paddr_d (args
[0]));
710 /* If (s)he specifies the frame with an address, he deserves what
711 (s)he gets. Still, give the highest one that matches. */
713 for (fid
= get_current_frame ();
714 fid
&& fid
->frame
!= args
[0];
715 fid
= get_prev_frame (fid
))
719 while ((tfid
= get_prev_frame (fid
)) &&
720 (tfid
->frame
== args
[0]))
723 /* We couldn't identify the frame as an existing frame, but
724 perhaps we can create one with a single argument. */
728 #ifdef SETUP_ARBITRARY_FRAME
729 return SETUP_ARBITRARY_FRAME (numargs
, args
);
731 /* Usual case. Do it here rather than have everyone supply
732 a SETUP_ARBITRARY_FRAME that does this. */
734 return create_new_frame (args
[0], 0);
735 error ("Too many args in frame specification");
742 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
743 that if it is unsure about the answer, it returns 0
744 instead of guessing (this happens on the VAX and i960, for example).
746 On most machines, we never have to guess about the args address,
747 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
748 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
749 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
752 /* Print verbosely the selected frame or the frame at address ADDR.
753 This means absolutely all information in the frame is printed. */
756 frame_info (char *addr_exp
, int from_tty
)
758 struct frame_info
*fi
;
759 struct symtab_and_line sal
;
762 struct frame_info
*calling_frame_info
;
763 int i
, count
, numregs
;
765 enum language funlang
= language_unknown
;
767 if (!target_has_stack
)
770 fi
= parse_frame_specification (addr_exp
);
772 error ("Invalid frame specified.");
774 sal
= find_pc_line (fi
->pc
,
776 && !fi
->next
->signal_handler_caller
777 && !frame_in_dummy (fi
->next
));
778 func
= get_frame_function (fi
);
779 s
= find_pc_symtab (fi
->pc
);
782 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display
783 * the demangled name that we already have stored in
784 * the symbol table, but we stored a version with
785 * DMGL_PARAMS turned on, and here we don't want
786 * to display parameters. So call the demangler again,
787 * with DMGL_ANSI only. RT
788 * (Yes, I know that printf_symbol_filtered() will
789 * again try to demangle the name on the fly, but
790 * the issue is that if cplus_demangle() fails here,
791 * it'll fail there too. So we want to catch the failure
792 * ("demangled==NULL" case below) here, while we still
793 * have our hands on the function symbol.)
796 funname
= SYMBOL_NAME (func
);
797 funlang
= SYMBOL_LANGUAGE (func
);
798 if (funlang
== language_cplus
)
800 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
801 /* If the demangler fails, try the demangled name
802 * from the symbol table. This'll have parameters,
803 * but that's preferable to diplaying a mangled name.
805 if (demangled
== NULL
)
806 funname
= SYMBOL_SOURCE_NAME (func
);
811 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
814 funname
= SYMBOL_NAME (msymbol
);
815 funlang
= SYMBOL_LANGUAGE (msymbol
);
818 calling_frame_info
= get_prev_frame (fi
);
820 if (!addr_exp
&& selected_frame_level
>= 0)
822 printf_filtered ("Stack level %d, frame at ", selected_frame_level
);
823 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
824 printf_filtered (":\n");
828 printf_filtered ("Stack frame at ");
829 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
830 printf_filtered (":\n");
832 printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM
));
833 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
838 printf_filtered (" in ");
839 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
840 DMGL_ANSI
| DMGL_PARAMS
);
844 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
845 puts_filtered ("; ");
847 printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM
));
848 print_address_numeric (FRAME_SAVED_PC (fi
), 1, gdb_stdout
);
849 printf_filtered ("\n");
853 frameless
= FRAMELESS_FUNCTION_INVOCATION (fi
);
855 printf_filtered (" (FRAMELESS),");
858 if (calling_frame_info
)
860 printf_filtered (" called by frame at ");
861 print_address_numeric (calling_frame_info
->frame
, 1, gdb_stdout
);
863 if (fi
->next
&& calling_frame_info
)
868 printf_filtered (" caller of frame at ");
869 print_address_numeric (fi
->next
->frame
, 1, gdb_stdout
);
871 if (fi
->next
|| calling_frame_info
)
872 puts_filtered ("\n");
874 printf_filtered (" source language %s.\n", language_str (s
->language
));
876 #ifdef PRINT_EXTRA_FRAME_INFO
877 PRINT_EXTRA_FRAME_INFO (fi
);
881 /* Address of the argument list for this frame, or 0. */
882 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
883 /* Number of args for this frame, or -1 if unknown. */
887 printf_filtered (" Arglist at unknown address.\n");
890 printf_filtered (" Arglist at ");
891 print_address_numeric (arg_list
, 1, gdb_stdout
);
892 printf_filtered (",");
894 numargs
= FRAME_NUM_ARGS (fi
);
896 puts_filtered (" args: ");
897 else if (numargs
== 0)
898 puts_filtered (" no args.");
899 else if (numargs
== 1)
900 puts_filtered (" 1 arg: ");
902 printf_filtered (" %d args: ", numargs
);
903 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
904 puts_filtered ("\n");
908 /* Address of the local variables for this frame, or 0. */
909 CORE_ADDR arg_list
= FRAME_LOCALS_ADDRESS (fi
);
912 printf_filtered (" Locals at unknown address,");
915 printf_filtered (" Locals at ");
916 print_address_numeric (arg_list
, 1, gdb_stdout
);
917 printf_filtered (",");
921 FRAME_INIT_SAVED_REGS (fi
);
922 if (fi
->saved_regs
!= NULL
)
924 /* The sp is special; what's returned isn't the save address, but
925 actually the value of the previous frame's sp. */
926 printf_filtered (" Previous frame's sp is ");
927 print_address_numeric (fi
->saved_regs
[SP_REGNUM
], 1, gdb_stdout
);
928 printf_filtered ("\n");
930 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
931 for (i
= 0; i
< numregs
; i
++)
932 if (fi
->saved_regs
[i
] && i
!= SP_REGNUM
)
935 puts_filtered (" Saved registers:\n ");
939 printf_filtered (" %s at ", REGISTER_NAME (i
));
940 print_address_numeric (fi
->saved_regs
[i
], 1, gdb_stdout
);
944 puts_filtered ("\n");
948 /* We could get some information about saved registers by
949 calling get_saved_register on each register. Which info goes
950 with which frame is necessarily lost, however, and I suspect
951 that the users don't care whether they get the info. */
952 puts_filtered ("\n");
957 /* Set a limit on the number of frames printed by default in a
960 static int backtrace_limit
;
963 set_backtrace_limit_command (char *count_exp
, int from_tty
)
965 int count
= parse_and_eval_long (count_exp
);
968 error ("Negative argument not meaningful as backtrace limit.");
970 backtrace_limit
= count
;
974 backtrace_limit_info (char *arg
, int from_tty
)
977 error ("\"Info backtrace-limit\" takes no arguments.");
979 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit
);
983 /* Print briefly all stack frames or just the innermost COUNT frames. */
985 static void backtrace_command_1 (char *count_exp
, int show_locals
,
988 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
990 struct frame_info
*fi
;
993 register struct frame_info
*trailing
;
994 register int trailing_level
;
996 if (!target_has_stack
)
999 /* The following code must do two things. First, it must
1000 set the variable TRAILING to the frame from which we should start
1001 printing. Second, it must set the variable count to the number
1002 of frames which we should print, or -1 if all of them. */
1003 trailing
= get_current_frame ();
1005 /* The target can be in a state where there is no valid frames
1006 (e.g., just connected). */
1007 if (trailing
== NULL
)
1008 error ("No stack.");
1013 count
= parse_and_eval_long (count_exp
);
1016 struct frame_info
*current
;
1021 while (current
&& count
--)
1024 current
= get_prev_frame (current
);
1027 /* Will stop when CURRENT reaches the top of the stack. TRAILING
1028 will be COUNT below it. */
1032 trailing
= get_prev_frame (trailing
);
1033 current
= get_prev_frame (current
);
1045 struct partial_symtab
*ps
;
1047 /* Read in symbols for all of the frames. Need to do this in
1048 a separate pass so that "Reading in symbols for xxx" messages
1049 don't screw up the appearance of the backtrace. Also
1050 if people have strong opinions against reading symbols for
1051 backtrace this may have to be an option. */
1055 fi
= get_prev_frame (fi
))
1058 ps
= find_pc_psymtab (fi
->pc
);
1060 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
1064 for (i
= 0, fi
= trailing
;
1066 i
++, fi
= get_prev_frame (fi
))
1070 /* Don't use print_stack_frame; if an error() occurs it probably
1071 means further attempts to backtrace would fail (on the other
1072 hand, perhaps the code does or could be fixed to make sure
1073 the frame->prev field gets set to NULL in that case). */
1074 print_frame_info_base (fi
, trailing_level
+ i
, 0, 1);
1076 print_frame_local_vars (fi
, 1, gdb_stdout
);
1079 /* If we've stopped before the end, mention that. */
1081 printf_filtered ("(More stack frames follow...)\n");
1085 backtrace_command (char *arg
, int from_tty
)
1087 struct cleanup
*old_chain
= (struct cleanup
*) NULL
;
1088 char **argv
= (char **) NULL
;
1089 int argIndicatingFullTrace
= (-1), totArgLen
= 0, argc
= 0;
1092 if (arg
!= (char *) NULL
)
1096 argv
= buildargv (arg
);
1097 old_chain
= make_cleanup_freeargv (argv
);
1099 for (i
= 0; (argv
[i
] != (char *) NULL
); i
++)
1103 for (j
= 0; (j
< strlen (argv
[i
])); j
++)
1104 argv
[i
][j
] = tolower (argv
[i
][j
]);
1106 if (argIndicatingFullTrace
< 0 && subset_compare (argv
[i
], "full"))
1107 argIndicatingFullTrace
= argc
;
1111 totArgLen
+= strlen (argv
[i
]);
1115 if (argIndicatingFullTrace
>= 0)
1119 argPtr
= (char *) xmalloc (totArgLen
+ 1);
1124 memset (argPtr
, 0, totArgLen
+ 1);
1125 for (i
= 0; (i
< (argc
+ 1)); i
++)
1127 if (i
!= argIndicatingFullTrace
)
1129 strcat (argPtr
, argv
[i
]);
1130 strcat (argPtr
, " ");
1136 argPtr
= (char *) NULL
;
1140 backtrace_command_1 (argPtr
, (argIndicatingFullTrace
>= 0), from_tty
);
1142 if (argIndicatingFullTrace
>= 0 && totArgLen
> 0)
1146 do_cleanups (old_chain
);
1149 static void backtrace_full_command (char *arg
, int from_tty
);
1151 backtrace_full_command (char *arg
, int from_tty
)
1153 backtrace_command_1 (arg
, 1, from_tty
);
1157 /* Print the local variables of a block B active in FRAME.
1158 Return 1 if any variables were printed; 0 otherwise. */
1161 print_block_frame_locals (struct block
*b
, register struct frame_info
*fi
,
1162 int num_tabs
, register struct ui_file
*stream
)
1165 register struct symbol
*sym
;
1166 register int values_printed
= 0;
1168 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1170 switch (SYMBOL_CLASS (sym
))
1177 for (j
= 0; j
< num_tabs
; j
++)
1178 fputs_filtered ("\t", stream
);
1179 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1180 fputs_filtered (" = ", stream
);
1181 print_variable_value (sym
, fi
, stream
);
1182 fprintf_filtered (stream
, "\n");
1186 /* Ignore symbols which are not locals. */
1190 return values_printed
;
1193 /* Same, but print labels. */
1196 print_block_frame_labels (struct block
*b
, int *have_default
,
1197 register struct ui_file
*stream
)
1200 register struct symbol
*sym
;
1201 register int values_printed
= 0;
1203 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1205 if (STREQ (SYMBOL_NAME (sym
), "default"))
1211 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1213 struct symtab_and_line sal
;
1214 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1216 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1219 fprintf_filtered (stream
, " ");
1220 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, stream
);
1222 fprintf_filtered (stream
, " in file %s, line %d\n",
1223 sal
.symtab
->filename
, sal
.line
);
1226 return values_printed
;
1229 /* Print on STREAM all the local variables in frame FRAME,
1230 including all the blocks active in that frame
1233 Returns 1 if the job was done,
1234 or 0 if nothing was printed because we have no info
1235 on the function running in FRAME. */
1238 print_frame_local_vars (register struct frame_info
*fi
, register int num_tabs
,
1239 register struct ui_file
*stream
)
1241 register struct block
*block
= get_frame_block (fi
, 0);
1242 register int values_printed
= 0;
1246 fprintf_filtered (stream
, "No symbol table info available.\n");
1252 if (print_block_frame_locals (block
, fi
, num_tabs
, stream
))
1254 /* After handling the function's top-level block, stop.
1255 Don't continue to its superblock, the block of
1256 per-file symbols. */
1257 if (BLOCK_FUNCTION (block
))
1259 block
= BLOCK_SUPERBLOCK (block
);
1262 if (!values_printed
)
1264 fprintf_filtered (stream
, "No locals.\n");
1268 /* Same, but print labels. */
1271 print_frame_label_vars (register struct frame_info
*fi
, int this_level_only
,
1272 register struct ui_file
*stream
)
1274 register struct blockvector
*bl
;
1275 register struct block
*block
= get_frame_block (fi
, 0);
1276 register int values_printed
= 0;
1277 int index
, have_default
= 0;
1278 char *blocks_printed
;
1279 CORE_ADDR pc
= fi
->pc
;
1283 fprintf_filtered (stream
, "No symbol table info available.\n");
1287 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1288 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1289 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1293 CORE_ADDR end
= BLOCK_END (block
) - 4;
1296 if (bl
!= blockvector_for_pc (end
, &index
))
1297 error ("blockvector blotch");
1298 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1299 error ("blockvector botch");
1300 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1303 /* Don't print out blocks that have gone by. */
1304 while (index
< last_index
1305 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1308 while (index
< last_index
1309 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1311 if (blocks_printed
[index
] == 0)
1313 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
1315 blocks_printed
[index
] = 1;
1321 if (values_printed
&& this_level_only
)
1324 /* After handling the function's top-level block, stop.
1325 Don't continue to its superblock, the block of
1326 per-file symbols. */
1327 if (BLOCK_FUNCTION (block
))
1329 block
= BLOCK_SUPERBLOCK (block
);
1332 if (!values_printed
&& !this_level_only
)
1334 fprintf_filtered (stream
, "No catches.\n");
1340 locals_info (char *args
, int from_tty
)
1342 if (!selected_frame
)
1343 error ("No frame selected.");
1344 print_frame_local_vars (selected_frame
, 0, gdb_stdout
);
1348 catch_info (char *ignore
, int from_tty
)
1350 struct symtab_and_line
*sal
;
1352 /* Check for target support for exception handling */
1353 sal
= target_enable_exception_callback (EX_EVENT_CATCH
, 1);
1356 /* Currently not handling this */
1357 /* Ideally, here we should interact with the C++ runtime
1358 system to find the list of active handlers, etc. */
1359 fprintf_filtered (gdb_stdout
, "Info catch not supported with this target/compiler combination.\n");
1361 if (!selected_frame
)
1362 error ("No frame selected.");
1367 /* Assume g++ compiled code -- old v 4.16 behaviour */
1368 if (!selected_frame
)
1369 error ("No frame selected.");
1371 print_frame_label_vars (selected_frame
, 0, gdb_stdout
);
1376 print_frame_arg_vars (register struct frame_info
*fi
,
1377 register struct ui_file
*stream
)
1379 struct symbol
*func
= get_frame_function (fi
);
1380 register struct block
*b
;
1382 register struct symbol
*sym
, *sym2
;
1383 register int values_printed
= 0;
1387 fprintf_filtered (stream
, "No symbol table info available.\n");
1391 b
= SYMBOL_BLOCK_VALUE (func
);
1392 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1394 switch (SYMBOL_CLASS (sym
))
1400 case LOC_REGPARM_ADDR
:
1401 case LOC_BASEREG_ARG
:
1403 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1404 fputs_filtered (" = ", stream
);
1406 /* We have to look up the symbol because arguments can have
1407 two entries (one a parameter, one a local) and the one we
1408 want is the local, which lookup_symbol will find for us.
1409 This includes gcc1 (not gcc2) on the sparc when passing a
1410 small structure and gcc2 when the argument type is float
1411 and it is passed as a double and converted to float by
1412 the prologue (in the latter case the type of the LOC_ARG
1413 symbol is double and the type of the LOC_LOCAL symbol is
1414 float). There are also LOC_ARG/LOC_REGISTER pairs which
1415 are not combined in symbol-reading. */
1417 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
1418 b
, VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
1419 print_variable_value (sym2
, fi
, stream
);
1420 fprintf_filtered (stream
, "\n");
1424 /* Don't worry about things which aren't arguments. */
1428 if (!values_printed
)
1430 fprintf_filtered (stream
, "No arguments.\n");
1435 args_info (char *ignore
, int from_tty
)
1437 if (!selected_frame
)
1438 error ("No frame selected.");
1439 print_frame_arg_vars (selected_frame
, gdb_stdout
);
1444 args_plus_locals_info (char *ignore
, int from_tty
)
1446 args_info (ignore
, from_tty
);
1447 locals_info (ignore
, from_tty
);
1451 /* Select frame FI, and note that its stack level is LEVEL.
1452 LEVEL may be -1 if an actual level number is not known. */
1455 select_frame (struct frame_info
*fi
, int level
)
1457 register struct symtab
*s
;
1459 selected_frame
= fi
;
1460 selected_frame_level
= level
;
1461 if (selected_frame_level_changed_hook
)
1462 selected_frame_level_changed_hook (level
);
1464 /* Ensure that symbols for this frame are read in. Also, determine the
1465 source language of this frame, and switch to it if desired. */
1468 s
= find_pc_symtab (fi
->pc
);
1470 && s
->language
!= current_language
->la_language
1471 && s
->language
!= language_unknown
1472 && language_mode
== language_mode_auto
)
1474 set_language (s
->language
);
1480 /* Select frame FI, noting that its stack level is LEVEL. Also print
1481 the stack frame and show the source if this is the tui version. */
1483 select_and_print_frame (struct frame_info
*fi
, int level
)
1485 select_frame (fi
, level
);
1488 print_stack_frame (fi
, level
, 1);
1493 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
1494 If there is no selected frame, *FRAMEP is set to NULL. */
1497 record_selected_frame (CORE_ADDR
*frameaddrp
, int *levelp
)
1499 *frameaddrp
= selected_frame
? selected_frame
->frame
: 0;
1500 *levelp
= selected_frame_level
;
1503 /* Return the symbol-block in which the selected frame is executing.
1504 Can return zero under various legitimate circumstances.
1506 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1507 code address within the block returned. We use this to decide
1508 which macros are in scope. */
1511 get_selected_block (CORE_ADDR
*addr_in_block
)
1513 if (!target_has_stack
)
1516 if (!selected_frame
)
1517 return get_current_block (addr_in_block
);
1518 return get_frame_block (selected_frame
, addr_in_block
);
1521 /* Find a frame a certain number of levels away from FRAME.
1522 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1523 Positive means go to earlier frames (up); negative, the reverse.
1524 The int that contains the number of levels is counted toward
1525 zero as the frames for those levels are found.
1526 If the top or bottom frame is reached, that frame is returned,
1527 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1528 how much farther the original request asked to go. */
1531 find_relative_frame (register struct frame_info
*frame
,
1532 register int *level_offset_ptr
)
1534 register struct frame_info
*prev
;
1535 register struct frame_info
*frame1
;
1537 /* Going up is simple: just do get_prev_frame enough times
1538 or until initial frame is reached. */
1539 while (*level_offset_ptr
> 0)
1541 prev
= get_prev_frame (frame
);
1544 (*level_offset_ptr
)--;
1547 /* Going down is just as simple. */
1548 if (*level_offset_ptr
< 0)
1550 while (*level_offset_ptr
< 0)
1552 frame1
= get_next_frame (frame
);
1556 (*level_offset_ptr
)++;
1562 /* The "select_frame" command. With no arg, NOP.
1563 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1564 valid level. Otherwise, treat level_exp as an address expression
1565 and select it. See parse_frame_specification for more info on proper
1566 frame expressions. */
1570 select_frame_command_wrapper (char *level_exp
, int from_tty
)
1572 select_frame_command (level_exp
, from_tty
);
1576 select_frame_command (char *level_exp
, int from_tty
)
1578 register struct frame_info
*frame
, *frame1
;
1579 unsigned int level
= 0;
1581 if (!target_has_stack
)
1582 error ("No stack.");
1584 frame
= parse_frame_specification (level_exp
);
1586 /* Try to figure out what level this frame is. But if there is
1587 no current stack, don't error out -- let the user set one. */
1589 if (get_current_frame ())
1591 for (frame1
= get_prev_frame (0);
1592 frame1
&& frame1
!= frame
;
1593 frame1
= get_prev_frame (frame1
))
1600 select_frame (frame
, level
);
1603 /* The "frame" command. With no arg, print selected frame briefly.
1604 With arg, behaves like select_frame and then prints the selected
1608 frame_command (char *level_exp
, int from_tty
)
1610 select_frame_command (level_exp
, from_tty
);
1611 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1614 /* The XDB Compatibility command to print the current frame. */
1617 current_frame_command (char *level_exp
, int from_tty
)
1619 if (target_has_stack
== 0 || selected_frame
== 0)
1620 error ("No stack.");
1621 print_only_stack_frame (selected_frame
, selected_frame_level
, 1);
1624 /* Select the frame up one or COUNT stack levels
1625 from the previously selected frame, and print it briefly. */
1629 up_silently_base (char *count_exp
)
1631 register struct frame_info
*fi
;
1632 int count
= 1, count1
;
1634 count
= parse_and_eval_long (count_exp
);
1637 if (target_has_stack
== 0 || selected_frame
== 0)
1638 error ("No stack.");
1640 fi
= find_relative_frame (selected_frame
, &count1
);
1641 if (count1
!= 0 && count_exp
== 0)
1642 error ("Initial frame selected; you cannot go up.");
1643 select_frame (fi
, selected_frame_level
+ count
- count1
);
1647 up_silently_command (char *count_exp
, int from_tty
)
1649 up_silently_base (count_exp
);
1653 up_command (char *count_exp
, int from_tty
)
1655 up_silently_base (count_exp
);
1656 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1659 /* Select the frame down one or COUNT stack levels
1660 from the previously selected frame, and print it briefly. */
1664 down_silently_base (char *count_exp
)
1666 register struct frame_info
*frame
;
1667 int count
= -1, count1
;
1669 count
= -parse_and_eval_long (count_exp
);
1672 if (target_has_stack
== 0 || selected_frame
== 0)
1673 error ("No stack.");
1675 frame
= find_relative_frame (selected_frame
, &count1
);
1676 if (count1
!= 0 && count_exp
== 0)
1679 /* We only do this if count_exp is not specified. That way "down"
1680 means to really go down (and let me know if that is
1681 impossible), but "down 9999" can be used to mean go all the way
1682 down without getting an error. */
1684 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1687 select_frame (frame
, selected_frame_level
+ count
- count1
);
1692 down_silently_command (char *count_exp
, int from_tty
)
1694 down_silently_base (count_exp
);
1698 down_command (char *count_exp
, int from_tty
)
1700 down_silently_base (count_exp
);
1701 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1705 return_command_wrapper (char *retval_exp
, int from_tty
)
1707 return_command (retval_exp
, from_tty
);
1711 return_command (char *retval_exp
, int from_tty
)
1713 struct symbol
*thisfun
;
1714 CORE_ADDR selected_frame_addr
;
1715 CORE_ADDR selected_frame_pc
;
1716 struct frame_info
*frame
;
1717 struct value
*return_value
= NULL
;
1719 if (selected_frame
== NULL
)
1720 error ("No selected frame.");
1721 thisfun
= get_frame_function (selected_frame
);
1722 selected_frame_addr
= FRAME_FP (selected_frame
);
1723 selected_frame_pc
= selected_frame
->pc
;
1725 /* Compute the return value (if any -- possibly getting errors here). */
1729 struct type
*return_type
= NULL
;
1731 return_value
= parse_and_eval (retval_exp
);
1733 /* Cast return value to the return type of the function. */
1734 if (thisfun
!= NULL
)
1735 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1736 if (return_type
== NULL
)
1737 return_type
= builtin_type_int
;
1738 return_value
= value_cast (return_type
, return_value
);
1740 /* Make sure we have fully evaluated it, since
1741 it might live in the stack frame we're about to pop. */
1742 if (VALUE_LAZY (return_value
))
1743 value_fetch_lazy (return_value
);
1746 /* If interactive, require confirmation. */
1752 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun
)))
1754 error ("Not confirmed.");
1758 else if (!query ("Make selected stack frame return now? "))
1759 error ("Not confirmed.");
1762 /* Do the real work. Pop until the specified frame is current. We
1763 use this method because the selected_frame is not valid after
1764 a POP_FRAME. The pc comparison makes this work even if the
1765 selected frame shares its fp with another frame. */
1767 while (selected_frame_addr
!= (frame
= get_current_frame ())->frame
1768 || selected_frame_pc
!= frame
->pc
)
1771 /* Then pop that frame. */
1775 /* Compute the return value (if any) and store in the place
1776 for return values. */
1779 set_return_value (return_value
);
1781 /* If we are at the end of a call dummy now, pop the dummy frame too. */
1783 if (CALL_DUMMY_HAS_COMPLETED (read_pc(), read_sp (),
1784 FRAME_FP (get_current_frame ())))
1787 /* If interactive, print the frame that is now current. */
1790 frame_command ("0", 1);
1792 select_frame_command ("0", 0);
1795 /* Sets the scope to input function name, provided that the
1796 function is within the current stack frame */
1798 struct function_bounds
1800 CORE_ADDR low
, high
;
1803 static void func_command (char *arg
, int from_tty
);
1805 func_command (char *arg
, int from_tty
)
1807 struct frame_info
*fp
;
1809 struct symtabs_and_lines sals
;
1812 struct function_bounds
*func_bounds
= (struct function_bounds
*) NULL
;
1814 if (arg
!= (char *) NULL
)
1817 fp
= parse_frame_specification ("0");
1818 sals
= decode_line_spec (arg
, 1);
1819 func_bounds
= (struct function_bounds
*) xmalloc (
1820 sizeof (struct function_bounds
) * sals
.nelts
);
1821 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1823 if (sals
.sals
[i
].pc
== (CORE_ADDR
) 0 ||
1824 find_pc_partial_function (sals
.sals
[i
].pc
,
1826 &func_bounds
[i
].low
,
1827 &func_bounds
[i
].high
) == 0)
1829 func_bounds
[i
].low
=
1830 func_bounds
[i
].high
= (CORE_ADDR
) NULL
;
1836 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1837 found
= (fp
->pc
>= func_bounds
[i
].low
&&
1838 fp
->pc
< func_bounds
[i
].high
);
1842 fp
= find_relative_frame (fp
, &level
);
1845 while (!found
&& level
== 0);
1848 xfree (func_bounds
);
1851 printf_filtered ("'%s' not within current stack frame.\n", arg
);
1852 else if (fp
!= selected_frame
)
1853 select_and_print_frame (fp
, level
);
1856 /* Gets the language of the current frame. */
1859 get_frame_language (void)
1861 register struct symtab
*s
;
1862 enum language flang
; /* The language of the current frame */
1866 s
= find_pc_symtab (selected_frame
->pc
);
1868 flang
= s
->language
;
1870 flang
= language_unknown
;
1873 flang
= language_unknown
;
1879 _initialize_stack (void)
1882 backtrace_limit
= 30;
1885 add_com ("return", class_stack
, return_command
,
1886 "Make selected stack frame return to its caller.\n\
1887 Control remains in the debugger, but when you continue\n\
1888 execution will resume in the frame above the one now selected.\n\
1889 If an argument is given, it is an expression for the value to return.");
1891 add_com ("up", class_stack
, up_command
,
1892 "Select and print stack frame that called this one.\n\
1893 An argument says how many frames up to go.");
1894 add_com ("up-silently", class_support
, up_silently_command
,
1895 "Same as the `up' command, but does not print anything.\n\
1896 This is useful in command scripts.");
1898 add_com ("down", class_stack
, down_command
,
1899 "Select and print stack frame called by this one.\n\
1900 An argument says how many frames down to go.");
1901 add_com_alias ("do", "down", class_stack
, 1);
1902 add_com_alias ("dow", "down", class_stack
, 1);
1903 add_com ("down-silently", class_support
, down_silently_command
,
1904 "Same as the `down' command, but does not print anything.\n\
1905 This is useful in command scripts.");
1907 add_com ("frame", class_stack
, frame_command
,
1908 "Select and print a stack frame.\n\
1909 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1910 An argument specifies the frame to select.\n\
1911 It can be a stack frame number or the address of the frame.\n\
1912 With argument, nothing is printed if input is coming from\n\
1913 a command file or a user-defined command.");
1915 add_com_alias ("f", "frame", class_stack
, 1);
1919 add_com ("L", class_stack
, current_frame_command
,
1920 "Print the current stack frame.\n");
1921 add_com_alias ("V", "frame", class_stack
, 1);
1923 add_com ("select-frame", class_stack
, select_frame_command
,
1924 "Select a stack frame without printing anything.\n\
1925 An argument specifies the frame to select.\n\
1926 It can be a stack frame number or the address of the frame.\n");
1928 add_com ("backtrace", class_stack
, backtrace_command
,
1929 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1930 With a negative argument, print outermost -COUNT frames.\n\
1931 Use of the 'full' qualifier also prints the values of the local variables.\n");
1932 add_com_alias ("bt", "backtrace", class_stack
, 0);
1935 add_com_alias ("t", "backtrace", class_stack
, 0);
1936 add_com ("T", class_stack
, backtrace_full_command
,
1937 "Print backtrace of all stack frames, or innermost COUNT frames \n\
1938 and the values of the local variables.\n\
1939 With a negative argument, print outermost -COUNT frames.\n\
1940 Usage: T <count>\n");
1943 add_com_alias ("where", "backtrace", class_alias
, 0);
1944 add_info ("stack", backtrace_command
,
1945 "Backtrace of the stack, or innermost COUNT frames.");
1946 add_info_alias ("s", "stack", 1);
1947 add_info ("frame", frame_info
,
1948 "All about selected stack frame, or frame at ADDR.");
1949 add_info_alias ("f", "frame", 1);
1950 add_info ("locals", locals_info
,
1951 "Local variables of current stack frame.");
1952 add_info ("args", args_info
,
1953 "Argument variables of current stack frame.");
1955 add_com ("l", class_info
, args_plus_locals_info
,
1956 "Argument and local variables of current stack frame.");
1959 add_com ("func", class_stack
, func_command
,
1960 "Select the stack frame that contains <func>.\nUsage: func <name>\n");
1962 add_info ("catch", catch_info
,
1963 "Exceptions that can be caught in the current stack frame.");
1966 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
1967 "Specify maximum number of frames for \"backtrace\" to print by default.",
1969 add_info ("backtrace-limit", backtrace_limit_info
,
1970 "The maximum number of frames for \"backtrace\" to print by default.");