1 /* Print and select stack frames for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "gdb_string.h"
28 #include "expression.h"
34 #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
)
403 print_frame_info_listing_hook (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
406 /* We used to do this earlier, but that is clearly
407 wrong. This function is used by many different
408 parts of gdb, including normal_stop in infrun.c,
409 which uses this to print out the current PC
410 when we stepi/nexti into the middle of a source
411 line. Only the command line really wants this
412 behavior. Other UIs probably would like the
413 ability to decide for themselves if it is desired. */
414 if (addressprint
&& mid_statement
)
417 ui_out_field_core_addr (uiout
, "addr", fi
->pc
);
418 ui_out_text (uiout
, "\t");
420 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
421 printf_filtered ("\t");
425 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
428 current_source_line
= max (sal
.line
- lines_to_list
/ 2, 1);
432 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
434 annotate_frame_end ();
436 gdb_flush (gdb_stdout
);
440 print_frame (struct frame_info
*fi
,
444 struct symtab_and_line sal
)
447 register char *funname
= 0;
448 enum language funlang
= language_unknown
;
450 struct ui_stream
*stb
;
451 struct cleanup
*old_chain
;
452 struct cleanup
*list_chain
;
454 stb
= ui_out_stream_new (uiout
);
455 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
458 func
= find_pc_function (fi
->pc
);
461 /* In certain pathological cases, the symtabs give the wrong
462 function (when we are in the first function in a file which
463 is compiled without debugging symbols, the previous function
464 is compiled with debugging symbols, and the "foo.o" symbol
465 that is supposed to tell us where the file with debugging symbols
466 ends has been truncated by ar because it is longer than 15
467 characters). This also occurs if the user uses asm() to create
468 a function but not stabs for it (in a file compiled -g).
470 So look in the minimal symbol tables as well, and if it comes
471 up with a larger address for the function use that instead.
472 I don't think this can ever cause any problems; there shouldn't
473 be any minimal symbols in the middle of a function; if this is
474 ever changed many parts of GDB will need to be changed (and we'll
475 create a find_pc_minimal_function or some such). */
477 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
479 && (SYMBOL_VALUE_ADDRESS (msymbol
)
480 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
483 /* There is no particular reason to think the line number
484 information is wrong. Someone might have just put in
485 a label with asm() but left the line numbers alone. */
486 /* In this case we have no way of knowing the source file
487 and line number, so don't print them. */
490 /* We also don't know anything about the function besides
491 its address and name. */
493 funname
= SYMBOL_NAME (msymbol
);
494 funlang
= SYMBOL_LANGUAGE (msymbol
);
498 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display the
499 demangled name that we already have stored in the symbol
500 table, but we stored a version with DMGL_PARAMS turned
501 on, and here we don't want to display parameters. So call
502 the demangler again, with DMGL_ANSI only. (Yes, I know
503 that printf_symbol_filtered() will again try to demangle
504 the name on the fly, but the issue is that if
505 cplus_demangle() fails here, it'll fail there too. So we
506 want to catch the failure ("demangled==NULL" case below)
507 here, while we still have our hands on the function
510 funname
= SYMBOL_NAME (func
);
511 funlang
= SYMBOL_LANGUAGE (func
);
512 if (funlang
== language_cplus
)
514 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
515 if (demangled
== NULL
)
516 /* If the demangler fails, try the demangled name from
517 the symbol table. This'll have parameters, but
518 that's preferable to diplaying a mangled name. */
519 funname
= SYMBOL_SOURCE_NAME (func
);
525 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
528 funname
= SYMBOL_NAME (msymbol
);
529 funlang
= SYMBOL_LANGUAGE (msymbol
);
533 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
536 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
542 ui_out_text (uiout
, "#");
543 ui_out_field_fmt (uiout
, "level", "%-2d", level
);
544 ui_out_spaces (uiout
, 1);
546 printf_filtered ("#%-2d ", level
);
550 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
|| source
== LOC_AND_ADDRESS
)
552 annotate_frame_address ();
554 ui_out_field_core_addr (uiout
, "addr", fi
->pc
);
555 annotate_frame_address_end ();
556 ui_out_text (uiout
, " in ");
558 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
559 annotate_frame_address_end ();
560 printf_filtered (" in ");
563 annotate_frame_function_name ();
565 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??", funlang
,
567 ui_out_field_stream (uiout
, "func", stb
);
568 ui_out_wrap_hint (uiout
, " ");
570 fprintf_symbol_filtered (gdb_stdout
, funname
? funname
: "??", funlang
,
574 annotate_frame_args ();
577 ui_out_text (uiout
, " (");
579 fputs_filtered (" (", gdb_stdout
);
583 struct print_args_args args
;
585 struct cleanup
*args_list_chain
;
589 args
.stream
= gdb_stdout
;
591 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
592 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ALL
);
593 /* FIXME: args must be a list. If one argument is a string it will
594 have " that will not be properly escaped. */
595 /* Invoke ui_out_tuple_end. */
596 do_cleanups (args_list_chain
);
598 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ALL
);
603 ui_out_text (uiout
, ")");
605 printf_filtered (")");
607 if (sal
.symtab
&& sal
.symtab
->filename
)
609 annotate_frame_source_begin ();
611 ui_out_wrap_hint (uiout
, " ");
612 ui_out_text (uiout
, " at ");
613 annotate_frame_source_file ();
614 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
615 annotate_frame_source_file_end ();
616 ui_out_text (uiout
, ":");
617 annotate_frame_source_line ();
618 ui_out_field_int (uiout
, "line", sal
.line
);
621 printf_filtered (" at ");
622 annotate_frame_source_file ();
623 printf_filtered ("%s", sal
.symtab
->filename
);
624 annotate_frame_source_file_end ();
625 printf_filtered (":");
626 annotate_frame_source_line ();
627 printf_filtered ("%d", sal
.line
);
629 annotate_frame_source_end ();
633 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
635 char *lib
= PC_SOLIB (fi
->pc
);
638 annotate_frame_where ();
640 ui_out_wrap_hint (uiout
, " ");
641 ui_out_text (uiout
, " from ");
642 ui_out_field_string (uiout
, "from", lib
);
645 printf_filtered (" from %s", lib
);
649 #endif /* PC_SOLIB */
652 /* do_cleanups will call ui_out_tuple_end() for us. */
653 do_cleanups (list_chain
);
654 ui_out_text (uiout
, "\n");
655 do_cleanups (old_chain
);
657 printf_filtered ("\n");
662 /* Show or print the frame info. If this is the tui, it will be shown in
663 the source display */
665 print_frame_info (struct frame_info
*fi
, register int level
, int source
,
668 print_frame_info_base (fi
, level
, source
, args
);
671 /* Show the frame info. If this is the tui, it will be shown in
672 the source display otherwise, nothing is done */
674 show_stack_frame (struct frame_info
*fi
)
679 /* Read a frame specification in whatever the appropriate format is.
680 Call error() if the specification is in any way invalid (i.e.
681 this function never returns NULL). */
684 parse_frame_specification (char *frame_exp
)
688 CORE_ADDR args
[MAXARGS
];
693 char *addr_string
, *p
;
694 struct cleanup
*tmp_cleanup
;
696 while (*frame_exp
== ' ')
701 if (numargs
> MAXARGS
)
702 error ("Too many args in frame specification");
703 /* Parse an argument. */
704 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
706 addr_string
= savestring (frame_exp
, p
- frame_exp
);
711 tmp_cleanup
= make_cleanup (xfree
, addr_string
);
713 /* NOTE: we call parse_and_eval and then both
714 value_as_long and value_as_address rather than calling
715 parse_and_eval_long and parse_and_eval_address because
716 of the issue of potential side effects from evaluating
718 vp
= parse_and_eval (addr_string
);
720 level
= value_as_long (vp
);
722 args
[numargs
++] = value_as_address (vp
);
723 do_cleanups (tmp_cleanup
);
726 /* Skip spaces, move to possible next arg. */
736 if (selected_frame
== NULL
)
737 error ("No selected frame.");
738 return selected_frame
;
742 struct frame_info
*fid
=
743 find_relative_frame (get_current_frame (), &level
);
744 struct frame_info
*tfid
;
747 /* find_relative_frame was successful */
750 /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
751 take at least 2 addresses. It is important to detect this case
752 here so that "frame 100" does not give a confusing error message
753 like "frame specification requires two addresses". This of course
754 does not solve the "frame 100" problem for machines on which
755 a frame specification can be made with one address. To solve
756 that, we need a new syntax for a specifying a frame by address.
757 I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
758 two args, etc.), but people might think that is too much typing,
759 so I guess *0x23,0x45 would be a possible alternative (commas
760 really should be used instead of spaces to delimit; using spaces
761 normally works in an expression). */
762 #ifdef SETUP_ARBITRARY_FRAME
763 error ("No frame %d", args
[0]);
766 /* If (s)he specifies the frame with an address, he deserves what
767 (s)he gets. Still, give the highest one that matches. */
769 for (fid
= get_current_frame ();
770 fid
&& fid
->frame
!= args
[0];
771 fid
= get_prev_frame (fid
))
775 while ((tfid
= get_prev_frame (fid
)) &&
776 (tfid
->frame
== args
[0]))
779 /* We couldn't identify the frame as an existing frame, but
780 perhaps we can create one with a single argument. */
784 #ifdef SETUP_ARBITRARY_FRAME
785 return SETUP_ARBITRARY_FRAME (numargs
, args
);
787 /* Usual case. Do it here rather than have everyone supply
788 a SETUP_ARBITRARY_FRAME that does this. */
790 return create_new_frame (args
[0], 0);
791 error ("Too many args in frame specification");
798 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
799 that if it is unsure about the answer, it returns 0
800 instead of guessing (this happens on the VAX and i960, for example).
802 On most machines, we never have to guess about the args address,
803 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
804 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
805 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
808 /* Print verbosely the selected frame or the frame at address ADDR.
809 This means absolutely all information in the frame is printed. */
812 frame_info (char *addr_exp
, int from_tty
)
814 struct frame_info
*fi
;
815 struct symtab_and_line sal
;
818 struct frame_info
*calling_frame_info
;
819 int i
, count
, numregs
;
821 enum language funlang
= language_unknown
;
823 if (!target_has_stack
)
826 fi
= parse_frame_specification (addr_exp
);
828 error ("Invalid frame specified.");
830 sal
= find_pc_line (fi
->pc
,
832 && !fi
->next
->signal_handler_caller
833 && !frame_in_dummy (fi
->next
));
834 func
= get_frame_function (fi
);
835 s
= find_pc_symtab (fi
->pc
);
838 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display
839 * the demangled name that we already have stored in
840 * the symbol table, but we stored a version with
841 * DMGL_PARAMS turned on, and here we don't want
842 * to display parameters. So call the demangler again,
843 * with DMGL_ANSI only. RT
844 * (Yes, I know that printf_symbol_filtered() will
845 * again try to demangle the name on the fly, but
846 * the issue is that if cplus_demangle() fails here,
847 * it'll fail there too. So we want to catch the failure
848 * ("demangled==NULL" case below) here, while we still
849 * have our hands on the function symbol.)
852 funname
= SYMBOL_NAME (func
);
853 funlang
= SYMBOL_LANGUAGE (func
);
854 if (funlang
== language_cplus
)
856 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
857 /* If the demangler fails, try the demangled name
858 * from the symbol table. This'll have parameters,
859 * but that's preferable to diplaying a mangled name.
861 if (demangled
== NULL
)
862 funname
= SYMBOL_SOURCE_NAME (func
);
867 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
870 funname
= SYMBOL_NAME (msymbol
);
871 funlang
= SYMBOL_LANGUAGE (msymbol
);
874 calling_frame_info
= get_prev_frame (fi
);
876 if (!addr_exp
&& selected_frame_level
>= 0)
878 printf_filtered ("Stack level %d, frame at ", selected_frame_level
);
879 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
880 printf_filtered (":\n");
884 printf_filtered ("Stack frame at ");
885 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
886 printf_filtered (":\n");
888 printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM
));
889 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
894 printf_filtered (" in ");
895 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
896 DMGL_ANSI
| DMGL_PARAMS
);
900 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
901 puts_filtered ("; ");
903 printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM
));
904 print_address_numeric (FRAME_SAVED_PC (fi
), 1, gdb_stdout
);
905 printf_filtered ("\n");
909 frameless
= FRAMELESS_FUNCTION_INVOCATION (fi
);
911 printf_filtered (" (FRAMELESS),");
914 if (calling_frame_info
)
916 printf_filtered (" called by frame at ");
917 print_address_numeric (calling_frame_info
->frame
, 1, gdb_stdout
);
919 if (fi
->next
&& calling_frame_info
)
924 printf_filtered (" caller of frame at ");
925 print_address_numeric (fi
->next
->frame
, 1, gdb_stdout
);
927 if (fi
->next
|| calling_frame_info
)
928 puts_filtered ("\n");
930 printf_filtered (" source language %s.\n", language_str (s
->language
));
932 #ifdef PRINT_EXTRA_FRAME_INFO
933 PRINT_EXTRA_FRAME_INFO (fi
);
937 /* Address of the argument list for this frame, or 0. */
938 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
939 /* Number of args for this frame, or -1 if unknown. */
943 printf_filtered (" Arglist at unknown address.\n");
946 printf_filtered (" Arglist at ");
947 print_address_numeric (arg_list
, 1, gdb_stdout
);
948 printf_filtered (",");
950 numargs
= FRAME_NUM_ARGS (fi
);
952 puts_filtered (" args: ");
953 else if (numargs
== 0)
954 puts_filtered (" no args.");
955 else if (numargs
== 1)
956 puts_filtered (" 1 arg: ");
958 printf_filtered (" %d args: ", numargs
);
959 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
960 puts_filtered ("\n");
964 /* Address of the local variables for this frame, or 0. */
965 CORE_ADDR arg_list
= FRAME_LOCALS_ADDRESS (fi
);
968 printf_filtered (" Locals at unknown address,");
971 printf_filtered (" Locals at ");
972 print_address_numeric (arg_list
, 1, gdb_stdout
);
973 printf_filtered (",");
977 FRAME_INIT_SAVED_REGS (fi
);
978 if (fi
->saved_regs
!= NULL
)
980 /* The sp is special; what's returned isn't the save address, but
981 actually the value of the previous frame's sp. */
982 printf_filtered (" Previous frame's sp is ");
983 print_address_numeric (fi
->saved_regs
[SP_REGNUM
], 1, gdb_stdout
);
984 printf_filtered ("\n");
986 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
987 for (i
= 0; i
< numregs
; i
++)
988 if (fi
->saved_regs
[i
] && i
!= SP_REGNUM
)
991 puts_filtered (" Saved registers:\n ");
995 printf_filtered (" %s at ", REGISTER_NAME (i
));
996 print_address_numeric (fi
->saved_regs
[i
], 1, gdb_stdout
);
1000 puts_filtered ("\n");
1004 /* We could get some information about saved registers by
1005 calling get_saved_register on each register. Which info goes
1006 with which frame is necessarily lost, however, and I suspect
1007 that the users don't care whether they get the info. */
1008 puts_filtered ("\n");
1013 /* Set a limit on the number of frames printed by default in a
1016 static int backtrace_limit
;
1019 set_backtrace_limit_command (char *count_exp
, int from_tty
)
1021 int count
= parse_and_eval_long (count_exp
);
1024 error ("Negative argument not meaningful as backtrace limit.");
1026 backtrace_limit
= count
;
1030 backtrace_limit_info (char *arg
, int from_tty
)
1033 error ("\"Info backtrace-limit\" takes no arguments.");
1035 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit
);
1039 /* Print briefly all stack frames or just the innermost COUNT frames. */
1041 static void backtrace_command_1 (char *count_exp
, int show_locals
,
1044 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1046 struct frame_info
*fi
;
1049 register struct frame_info
*trailing
;
1050 register int trailing_level
;
1052 if (!target_has_stack
)
1053 error ("No stack.");
1055 /* The following code must do two things. First, it must
1056 set the variable TRAILING to the frame from which we should start
1057 printing. Second, it must set the variable count to the number
1058 of frames which we should print, or -1 if all of them. */
1059 trailing
= get_current_frame ();
1061 /* The target can be in a state where there is no valid frames
1062 (e.g., just connected). */
1063 if (trailing
== NULL
)
1064 error ("No stack.");
1069 count
= parse_and_eval_long (count_exp
);
1072 struct frame_info
*current
;
1077 while (current
&& count
--)
1080 current
= get_prev_frame (current
);
1083 /* Will stop when CURRENT reaches the top of the stack. TRAILING
1084 will be COUNT below it. */
1088 trailing
= get_prev_frame (trailing
);
1089 current
= get_prev_frame (current
);
1101 struct partial_symtab
*ps
;
1103 /* Read in symbols for all of the frames. Need to do this in
1104 a separate pass so that "Reading in symbols for xxx" messages
1105 don't screw up the appearance of the backtrace. Also
1106 if people have strong opinions against reading symbols for
1107 backtrace this may have to be an option. */
1111 fi
= get_prev_frame (fi
))
1114 ps
= find_pc_psymtab (fi
->pc
);
1116 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
1120 for (i
= 0, fi
= trailing
;
1122 i
++, fi
= get_prev_frame (fi
))
1126 /* Don't use print_stack_frame; if an error() occurs it probably
1127 means further attempts to backtrace would fail (on the other
1128 hand, perhaps the code does or could be fixed to make sure
1129 the frame->prev field gets set to NULL in that case). */
1130 print_frame_info_base (fi
, trailing_level
+ i
, 0, 1);
1132 print_frame_local_vars (fi
, 1, gdb_stdout
);
1135 /* If we've stopped before the end, mention that. */
1137 printf_filtered ("(More stack frames follow...)\n");
1141 backtrace_command (char *arg
, int from_tty
)
1143 struct cleanup
*old_chain
= (struct cleanup
*) NULL
;
1144 char **argv
= (char **) NULL
;
1145 int argIndicatingFullTrace
= (-1), totArgLen
= 0, argc
= 0;
1148 if (arg
!= (char *) NULL
)
1152 argv
= buildargv (arg
);
1153 old_chain
= make_cleanup_freeargv (argv
);
1155 for (i
= 0; (argv
[i
] != (char *) NULL
); i
++)
1159 for (j
= 0; (j
< strlen (argv
[i
])); j
++)
1160 argv
[i
][j
] = tolower (argv
[i
][j
]);
1162 if (argIndicatingFullTrace
< 0 && subset_compare (argv
[i
], "full"))
1163 argIndicatingFullTrace
= argc
;
1167 totArgLen
+= strlen (argv
[i
]);
1171 if (argIndicatingFullTrace
>= 0)
1175 argPtr
= (char *) xmalloc (totArgLen
+ 1);
1180 memset (argPtr
, 0, totArgLen
+ 1);
1181 for (i
= 0; (i
< (argc
+ 1)); i
++)
1183 if (i
!= argIndicatingFullTrace
)
1185 strcat (argPtr
, argv
[i
]);
1186 strcat (argPtr
, " ");
1192 argPtr
= (char *) NULL
;
1196 backtrace_command_1 (argPtr
, (argIndicatingFullTrace
>= 0), from_tty
);
1198 if (argIndicatingFullTrace
>= 0 && totArgLen
> 0)
1202 do_cleanups (old_chain
);
1205 static void backtrace_full_command (char *arg
, int from_tty
);
1207 backtrace_full_command (char *arg
, int from_tty
)
1209 backtrace_command_1 (arg
, 1, from_tty
);
1213 /* Print the local variables of a block B active in FRAME.
1214 Return 1 if any variables were printed; 0 otherwise. */
1217 print_block_frame_locals (struct block
*b
, register struct frame_info
*fi
,
1218 int num_tabs
, register struct ui_file
*stream
)
1221 register struct symbol
*sym
;
1222 register int values_printed
= 0;
1224 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1226 switch (SYMBOL_CLASS (sym
))
1233 for (j
= 0; j
< num_tabs
; j
++)
1234 fputs_filtered ("\t", stream
);
1235 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1236 fputs_filtered (" = ", stream
);
1237 print_variable_value (sym
, fi
, stream
);
1238 fprintf_filtered (stream
, "\n");
1242 /* Ignore symbols which are not locals. */
1246 return values_printed
;
1249 /* Same, but print labels. */
1252 print_block_frame_labels (struct block
*b
, int *have_default
,
1253 register struct ui_file
*stream
)
1256 register struct symbol
*sym
;
1257 register int values_printed
= 0;
1259 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1261 if (STREQ (SYMBOL_NAME (sym
), "default"))
1267 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1269 struct symtab_and_line sal
;
1270 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1272 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1275 fprintf_filtered (stream
, " ");
1276 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, stream
);
1278 fprintf_filtered (stream
, " in file %s, line %d\n",
1279 sal
.symtab
->filename
, sal
.line
);
1282 return values_printed
;
1285 /* Print on STREAM all the local variables in frame FRAME,
1286 including all the blocks active in that frame
1289 Returns 1 if the job was done,
1290 or 0 if nothing was printed because we have no info
1291 on the function running in FRAME. */
1294 print_frame_local_vars (register struct frame_info
*fi
, register int num_tabs
,
1295 register struct ui_file
*stream
)
1297 register struct block
*block
= get_frame_block (fi
);
1298 register int values_printed
= 0;
1302 fprintf_filtered (stream
, "No symbol table info available.\n");
1308 if (print_block_frame_locals (block
, fi
, num_tabs
, stream
))
1310 /* After handling the function's top-level block, stop.
1311 Don't continue to its superblock, the block of
1312 per-file symbols. */
1313 if (BLOCK_FUNCTION (block
))
1315 block
= BLOCK_SUPERBLOCK (block
);
1318 if (!values_printed
)
1320 fprintf_filtered (stream
, "No locals.\n");
1324 /* Same, but print labels. */
1327 print_frame_label_vars (register struct frame_info
*fi
, int this_level_only
,
1328 register struct ui_file
*stream
)
1330 register struct blockvector
*bl
;
1331 register struct block
*block
= get_frame_block (fi
);
1332 register int values_printed
= 0;
1333 int index
, have_default
= 0;
1334 char *blocks_printed
;
1335 CORE_ADDR pc
= fi
->pc
;
1339 fprintf_filtered (stream
, "No symbol table info available.\n");
1343 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1344 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1345 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1349 CORE_ADDR end
= BLOCK_END (block
) - 4;
1352 if (bl
!= blockvector_for_pc (end
, &index
))
1353 error ("blockvector blotch");
1354 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1355 error ("blockvector botch");
1356 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1359 /* Don't print out blocks that have gone by. */
1360 while (index
< last_index
1361 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1364 while (index
< last_index
1365 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1367 if (blocks_printed
[index
] == 0)
1369 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
1371 blocks_printed
[index
] = 1;
1377 if (values_printed
&& this_level_only
)
1380 /* After handling the function's top-level block, stop.
1381 Don't continue to its superblock, the block of
1382 per-file symbols. */
1383 if (BLOCK_FUNCTION (block
))
1385 block
= BLOCK_SUPERBLOCK (block
);
1388 if (!values_printed
&& !this_level_only
)
1390 fprintf_filtered (stream
, "No catches.\n");
1396 locals_info (char *args
, int from_tty
)
1398 if (!selected_frame
)
1399 error ("No frame selected.");
1400 print_frame_local_vars (selected_frame
, 0, gdb_stdout
);
1404 catch_info (char *ignore
, int from_tty
)
1406 struct symtab_and_line
*sal
;
1408 /* Check for target support for exception handling */
1409 sal
= target_enable_exception_callback (EX_EVENT_CATCH
, 1);
1412 /* Currently not handling this */
1413 /* Ideally, here we should interact with the C++ runtime
1414 system to find the list of active handlers, etc. */
1415 fprintf_filtered (gdb_stdout
, "Info catch not supported with this target/compiler combination.\n");
1417 if (!selected_frame
)
1418 error ("No frame selected.");
1423 /* Assume g++ compiled code -- old v 4.16 behaviour */
1424 if (!selected_frame
)
1425 error ("No frame selected.");
1427 print_frame_label_vars (selected_frame
, 0, gdb_stdout
);
1432 print_frame_arg_vars (register struct frame_info
*fi
,
1433 register struct ui_file
*stream
)
1435 struct symbol
*func
= get_frame_function (fi
);
1436 register struct block
*b
;
1438 register struct symbol
*sym
, *sym2
;
1439 register int values_printed
= 0;
1443 fprintf_filtered (stream
, "No symbol table info available.\n");
1447 b
= SYMBOL_BLOCK_VALUE (func
);
1448 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1450 switch (SYMBOL_CLASS (sym
))
1456 case LOC_REGPARM_ADDR
:
1457 case LOC_BASEREG_ARG
:
1459 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1460 fputs_filtered (" = ", stream
);
1462 /* We have to look up the symbol because arguments can have
1463 two entries (one a parameter, one a local) and the one we
1464 want is the local, which lookup_symbol will find for us.
1465 This includes gcc1 (not gcc2) on the sparc when passing a
1466 small structure and gcc2 when the argument type is float
1467 and it is passed as a double and converted to float by
1468 the prologue (in the latter case the type of the LOC_ARG
1469 symbol is double and the type of the LOC_LOCAL symbol is
1470 float). There are also LOC_ARG/LOC_REGISTER pairs which
1471 are not combined in symbol-reading. */
1473 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
1474 b
, VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
1475 print_variable_value (sym2
, fi
, stream
);
1476 fprintf_filtered (stream
, "\n");
1480 /* Don't worry about things which aren't arguments. */
1484 if (!values_printed
)
1486 fprintf_filtered (stream
, "No arguments.\n");
1491 args_info (char *ignore
, int from_tty
)
1493 if (!selected_frame
)
1494 error ("No frame selected.");
1495 print_frame_arg_vars (selected_frame
, gdb_stdout
);
1500 args_plus_locals_info (char *ignore
, int from_tty
)
1502 args_info (ignore
, from_tty
);
1503 locals_info (ignore
, from_tty
);
1507 /* Select frame FI, and note that its stack level is LEVEL.
1508 LEVEL may be -1 if an actual level number is not known. */
1511 select_frame (struct frame_info
*fi
, int level
)
1513 register struct symtab
*s
;
1515 selected_frame
= fi
;
1516 selected_frame_level
= level
;
1517 if (selected_frame_level_changed_hook
)
1518 selected_frame_level_changed_hook (level
);
1520 /* Ensure that symbols for this frame are read in. Also, determine the
1521 source language of this frame, and switch to it if desired. */
1524 s
= find_pc_symtab (fi
->pc
);
1526 && s
->language
!= current_language
->la_language
1527 && s
->language
!= language_unknown
1528 && language_mode
== language_mode_auto
)
1530 set_language (s
->language
);
1536 /* Select frame FI, noting that its stack level is LEVEL. Also print
1537 the stack frame and show the source if this is the tui version. */
1539 select_and_print_frame (struct frame_info
*fi
, int level
)
1541 select_frame (fi
, level
);
1544 print_stack_frame (fi
, level
, 1);
1549 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
1550 If there is no selected frame, *FRAMEP is set to NULL. */
1553 record_selected_frame (CORE_ADDR
*frameaddrp
, int *levelp
)
1555 *frameaddrp
= selected_frame
? selected_frame
->frame
: 0;
1556 *levelp
= selected_frame_level
;
1559 /* Return the symbol-block in which the selected frame is executing.
1560 Can return zero under various legitimate circumstances. */
1563 get_selected_block (void)
1565 if (!target_has_stack
)
1568 if (!selected_frame
)
1569 return get_current_block ();
1570 return get_frame_block (selected_frame
);
1573 /* Find a frame a certain number of levels away from FRAME.
1574 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1575 Positive means go to earlier frames (up); negative, the reverse.
1576 The int that contains the number of levels is counted toward
1577 zero as the frames for those levels are found.
1578 If the top or bottom frame is reached, that frame is returned,
1579 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1580 how much farther the original request asked to go. */
1583 find_relative_frame (register struct frame_info
*frame
,
1584 register int *level_offset_ptr
)
1586 register struct frame_info
*prev
;
1587 register struct frame_info
*frame1
;
1589 /* Going up is simple: just do get_prev_frame enough times
1590 or until initial frame is reached. */
1591 while (*level_offset_ptr
> 0)
1593 prev
= get_prev_frame (frame
);
1596 (*level_offset_ptr
)--;
1599 /* Going down is just as simple. */
1600 if (*level_offset_ptr
< 0)
1602 while (*level_offset_ptr
< 0)
1604 frame1
= get_next_frame (frame
);
1608 (*level_offset_ptr
)++;
1614 /* The "select_frame" command. With no arg, NOP.
1615 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1616 valid level. Otherwise, treat level_exp as an address expression
1617 and select it. See parse_frame_specification for more info on proper
1618 frame expressions. */
1623 select_frame_command_wrapper (char *level_exp
, int from_tty
)
1625 select_frame_command (level_exp
, from_tty
);
1629 select_frame_command (char *level_exp
, int from_tty
)
1631 register struct frame_info
*frame
, *frame1
;
1632 unsigned int level
= 0;
1634 if (!target_has_stack
)
1635 error ("No stack.");
1637 frame
= parse_frame_specification (level_exp
);
1639 /* Try to figure out what level this frame is. But if there is
1640 no current stack, don't error out -- let the user set one. */
1642 if (get_current_frame ())
1644 for (frame1
= get_prev_frame (0);
1645 frame1
&& frame1
!= frame
;
1646 frame1
= get_prev_frame (frame1
))
1653 select_frame (frame
, level
);
1656 /* The "frame" command. With no arg, print selected frame briefly.
1657 With arg, behaves like select_frame and then prints the selected
1661 frame_command (char *level_exp
, int from_tty
)
1663 select_frame_command (level_exp
, from_tty
);
1664 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1667 /* The XDB Compatibility command to print the current frame. */
1670 current_frame_command (char *level_exp
, int from_tty
)
1672 if (target_has_stack
== 0 || selected_frame
== 0)
1673 error ("No stack.");
1674 print_only_stack_frame (selected_frame
, selected_frame_level
, 1);
1677 /* Select the frame up one or COUNT stack levels
1678 from the previously selected frame, and print it briefly. */
1682 up_silently_base (char *count_exp
)
1684 register struct frame_info
*fi
;
1685 int count
= 1, count1
;
1687 count
= parse_and_eval_long (count_exp
);
1690 if (target_has_stack
== 0 || selected_frame
== 0)
1691 error ("No stack.");
1693 fi
= find_relative_frame (selected_frame
, &count1
);
1694 if (count1
!= 0 && count_exp
== 0)
1695 error ("Initial frame selected; you cannot go up.");
1696 select_frame (fi
, selected_frame_level
+ count
- count1
);
1700 up_silently_command (char *count_exp
, int from_tty
)
1702 up_silently_base (count_exp
);
1706 up_command (char *count_exp
, int from_tty
)
1708 up_silently_base (count_exp
);
1709 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1712 /* Select the frame down one or COUNT stack levels
1713 from the previously selected frame, and print it briefly. */
1717 down_silently_base (char *count_exp
)
1719 register struct frame_info
*frame
;
1720 int count
= -1, count1
;
1722 count
= -parse_and_eval_long (count_exp
);
1725 if (target_has_stack
== 0 || selected_frame
== 0)
1726 error ("No stack.");
1728 frame
= find_relative_frame (selected_frame
, &count1
);
1729 if (count1
!= 0 && count_exp
== 0)
1732 /* We only do this if count_exp is not specified. That way "down"
1733 means to really go down (and let me know if that is
1734 impossible), but "down 9999" can be used to mean go all the way
1735 down without getting an error. */
1737 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1740 select_frame (frame
, selected_frame_level
+ count
- count1
);
1745 down_silently_command (char *count_exp
, int from_tty
)
1747 down_silently_base (count_exp
);
1751 down_command (char *count_exp
, int from_tty
)
1753 down_silently_base (count_exp
);
1754 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1759 return_command_wrapper (char *retval_exp
, int from_tty
)
1761 return_command (retval_exp
, from_tty
);
1765 return_command (char *retval_exp
, int from_tty
)
1767 struct symbol
*thisfun
;
1768 CORE_ADDR selected_frame_addr
;
1769 CORE_ADDR selected_frame_pc
;
1770 struct frame_info
*frame
;
1771 struct value
*return_value
= NULL
;
1773 if (selected_frame
== NULL
)
1774 error ("No selected frame.");
1775 thisfun
= get_frame_function (selected_frame
);
1776 selected_frame_addr
= FRAME_FP (selected_frame
);
1777 selected_frame_pc
= selected_frame
->pc
;
1779 /* Compute the return value (if any -- possibly getting errors here). */
1783 struct type
*return_type
= NULL
;
1785 return_value
= parse_and_eval (retval_exp
);
1787 /* Cast return value to the return type of the function. */
1788 if (thisfun
!= NULL
)
1789 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1790 if (return_type
== NULL
)
1791 return_type
= builtin_type_int
;
1792 return_value
= value_cast (return_type
, return_value
);
1794 /* Make sure we have fully evaluated it, since
1795 it might live in the stack frame we're about to pop. */
1796 if (VALUE_LAZY (return_value
))
1797 value_fetch_lazy (return_value
);
1800 /* If interactive, require confirmation. */
1806 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun
)))
1808 error ("Not confirmed.");
1812 else if (!query ("Make selected stack frame return now? "))
1813 error ("Not confirmed.");
1816 /* Do the real work. Pop until the specified frame is current. We
1817 use this method because the selected_frame is not valid after
1818 a POP_FRAME. The pc comparison makes this work even if the
1819 selected frame shares its fp with another frame. */
1821 while (selected_frame_addr
!= (frame
= get_current_frame ())->frame
1822 || selected_frame_pc
!= frame
->pc
)
1825 /* Then pop that frame. */
1829 /* Compute the return value (if any) and store in the place
1830 for return values. */
1833 set_return_value (return_value
);
1835 /* If we are at the end of a call dummy now, pop the dummy frame too. */
1837 if (CALL_DUMMY_HAS_COMPLETED (read_pc(), read_sp (),
1838 FRAME_FP (get_current_frame ())))
1841 /* If interactive, print the frame that is now current. */
1844 frame_command ("0", 1);
1846 select_frame_command ("0", 0);
1849 /* Sets the scope to input function name, provided that the
1850 function is within the current stack frame */
1852 struct function_bounds
1854 CORE_ADDR low
, high
;
1857 static void func_command (char *arg
, int from_tty
);
1859 func_command (char *arg
, int from_tty
)
1861 struct frame_info
*fp
;
1863 struct symtabs_and_lines sals
;
1866 struct function_bounds
*func_bounds
= (struct function_bounds
*) NULL
;
1868 if (arg
!= (char *) NULL
)
1871 fp
= parse_frame_specification ("0");
1872 sals
= decode_line_spec (arg
, 1);
1873 func_bounds
= (struct function_bounds
*) xmalloc (
1874 sizeof (struct function_bounds
) * sals
.nelts
);
1875 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1877 if (sals
.sals
[i
].pc
== (CORE_ADDR
) 0 ||
1878 find_pc_partial_function (sals
.sals
[i
].pc
,
1880 &func_bounds
[i
].low
,
1881 &func_bounds
[i
].high
) == 0)
1883 func_bounds
[i
].low
=
1884 func_bounds
[i
].high
= (CORE_ADDR
) NULL
;
1890 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1891 found
= (fp
->pc
>= func_bounds
[i
].low
&&
1892 fp
->pc
< func_bounds
[i
].high
);
1896 fp
= find_relative_frame (fp
, &level
);
1899 while (!found
&& level
== 0);
1902 xfree (func_bounds
);
1905 printf_filtered ("'%s' not within current stack frame.\n", arg
);
1906 else if (fp
!= selected_frame
)
1907 select_and_print_frame (fp
, level
);
1910 /* Gets the language of the current frame. */
1913 get_frame_language (void)
1915 register struct symtab
*s
;
1916 enum language flang
; /* The language of the current frame */
1920 s
= find_pc_symtab (selected_frame
->pc
);
1922 flang
= s
->language
;
1924 flang
= language_unknown
;
1927 flang
= language_unknown
;
1933 _initialize_stack (void)
1936 backtrace_limit
= 30;
1939 add_com ("return", class_stack
, return_command
,
1940 "Make selected stack frame return to its caller.\n\
1941 Control remains in the debugger, but when you continue\n\
1942 execution will resume in the frame above the one now selected.\n\
1943 If an argument is given, it is an expression for the value to return.");
1945 add_com ("up", class_stack
, up_command
,
1946 "Select and print stack frame that called this one.\n\
1947 An argument says how many frames up to go.");
1948 add_com ("up-silently", class_support
, up_silently_command
,
1949 "Same as the `up' command, but does not print anything.\n\
1950 This is useful in command scripts.");
1952 add_com ("down", class_stack
, down_command
,
1953 "Select and print stack frame called by this one.\n\
1954 An argument says how many frames down to go.");
1955 add_com_alias ("do", "down", class_stack
, 1);
1956 add_com_alias ("dow", "down", class_stack
, 1);
1957 add_com ("down-silently", class_support
, down_silently_command
,
1958 "Same as the `down' command, but does not print anything.\n\
1959 This is useful in command scripts.");
1961 add_com ("frame", class_stack
, frame_command
,
1962 "Select and print a stack frame.\n\
1963 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1964 An argument specifies the frame to select.\n\
1965 It can be a stack frame number or the address of the frame.\n\
1966 With argument, nothing is printed if input is coming from\n\
1967 a command file or a user-defined command.");
1969 add_com_alias ("f", "frame", class_stack
, 1);
1973 add_com ("L", class_stack
, current_frame_command
,
1974 "Print the current stack frame.\n");
1975 add_com_alias ("V", "frame", class_stack
, 1);
1977 add_com ("select-frame", class_stack
, select_frame_command
,
1978 "Select a stack frame without printing anything.\n\
1979 An argument specifies the frame to select.\n\
1980 It can be a stack frame number or the address of the frame.\n");
1982 add_com ("backtrace", class_stack
, backtrace_command
,
1983 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1984 With a negative argument, print outermost -COUNT frames.\n\
1985 Use of the 'full' qualifier also prints the values of the local variables.\n");
1986 add_com_alias ("bt", "backtrace", class_stack
, 0);
1989 add_com_alias ("t", "backtrace", class_stack
, 0);
1990 add_com ("T", class_stack
, backtrace_full_command
,
1991 "Print backtrace of all stack frames, or innermost COUNT frames \n\
1992 and the values of the local variables.\n\
1993 With a negative argument, print outermost -COUNT frames.\n\
1994 Usage: T <count>\n");
1997 add_com_alias ("where", "backtrace", class_alias
, 0);
1998 add_info ("stack", backtrace_command
,
1999 "Backtrace of the stack, or innermost COUNT frames.");
2000 add_info_alias ("s", "stack", 1);
2001 add_info ("frame", frame_info
,
2002 "All about selected stack frame, or frame at ADDR.");
2003 add_info_alias ("f", "frame", 1);
2004 add_info ("locals", locals_info
,
2005 "Local variables of current stack frame.");
2006 add_info ("args", args_info
,
2007 "Argument variables of current stack frame.");
2009 add_com ("l", class_info
, args_plus_locals_info
,
2010 "Argument and local variables of current stack frame.");
2013 add_com ("func", class_stack
, func_command
,
2014 "Select the stack frame that contains <func>.\nUsage: func <name>\n");
2016 add_info ("catch", catch_info
,
2017 "Exceptions that can be caught in the current stack frame.");
2020 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
2021 "Specify maximum number of frames for \"backtrace\" to print by default.",
2023 add_info ("backtrace-limit", backtrace_limit_info
,
2024 "The maximum number of frames for \"backtrace\" to print by default.");