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
)
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
)
416 ui_out_field_core_addr (uiout
, "addr", fi
->pc
);
417 ui_out_text (uiout
, "\t");
420 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
423 current_source_line
= max (sal
.line
- lines_to_list
/ 2, 1);
427 set_default_breakpoint (1, fi
->pc
, sal
.symtab
, sal
.line
);
429 annotate_frame_end ();
431 gdb_flush (gdb_stdout
);
435 print_frame (struct frame_info
*fi
,
439 struct symtab_and_line sal
)
442 register char *funname
= 0;
443 enum language funlang
= language_unknown
;
444 struct ui_stream
*stb
;
445 struct cleanup
*old_chain
;
446 struct cleanup
*list_chain
;
448 stb
= ui_out_stream_new (uiout
);
449 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
451 func
= find_pc_function (fi
->pc
);
454 /* In certain pathological cases, the symtabs give the wrong
455 function (when we are in the first function in a file which
456 is compiled without debugging symbols, the previous function
457 is compiled with debugging symbols, and the "foo.o" symbol
458 that is supposed to tell us where the file with debugging symbols
459 ends has been truncated by ar because it is longer than 15
460 characters). This also occurs if the user uses asm() to create
461 a function but not stabs for it (in a file compiled -g).
463 So look in the minimal symbol tables as well, and if it comes
464 up with a larger address for the function use that instead.
465 I don't think this can ever cause any problems; there shouldn't
466 be any minimal symbols in the middle of a function; if this is
467 ever changed many parts of GDB will need to be changed (and we'll
468 create a find_pc_minimal_function or some such). */
470 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
472 && (SYMBOL_VALUE_ADDRESS (msymbol
)
473 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
476 /* There is no particular reason to think the line number
477 information is wrong. Someone might have just put in
478 a label with asm() but left the line numbers alone. */
479 /* In this case we have no way of knowing the source file
480 and line number, so don't print them. */
483 /* We also don't know anything about the function besides
484 its address and name. */
486 funname
= SYMBOL_NAME (msymbol
);
487 funlang
= SYMBOL_LANGUAGE (msymbol
);
491 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display the
492 demangled name that we already have stored in the symbol
493 table, but we stored a version with DMGL_PARAMS turned
494 on, and here we don't want to display parameters. So call
495 the demangler again, with DMGL_ANSI only. (Yes, I know
496 that printf_symbol_filtered() will again try to demangle
497 the name on the fly, but the issue is that if
498 cplus_demangle() fails here, it'll fail there too. So we
499 want to catch the failure ("demangled==NULL" case below)
500 here, while we still have our hands on the function
503 funname
= SYMBOL_NAME (func
);
504 funlang
= SYMBOL_LANGUAGE (func
);
505 if (funlang
== language_cplus
)
507 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
508 if (demangled
== NULL
)
509 /* If the demangler fails, try the demangled name from
510 the symbol table. This'll have parameters, but
511 that's preferable to diplaying a mangled name. */
512 funname
= SYMBOL_SOURCE_NAME (func
);
518 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
521 funname
= SYMBOL_NAME (msymbol
);
522 funlang
= SYMBOL_LANGUAGE (msymbol
);
526 annotate_frame_begin (level
== -1 ? 0 : level
, fi
->pc
);
528 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
532 ui_out_text (uiout
, "#");
533 ui_out_field_fmt (uiout
, "level", "%-2d", level
);
534 ui_out_spaces (uiout
, 1);
537 if (fi
->pc
!= sal
.pc
|| !sal
.symtab
|| source
== LOC_AND_ADDRESS
)
539 annotate_frame_address ();
540 ui_out_field_core_addr (uiout
, "addr", fi
->pc
);
541 annotate_frame_address_end ();
542 ui_out_text (uiout
, " in ");
544 annotate_frame_function_name ();
545 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??", funlang
,
547 ui_out_field_stream (uiout
, "func", stb
);
548 ui_out_wrap_hint (uiout
, " ");
549 annotate_frame_args ();
551 ui_out_text (uiout
, " (");
554 struct print_args_args args
;
555 struct cleanup
*args_list_chain
;
558 args
.stream
= gdb_stdout
;
559 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
560 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ALL
);
561 /* FIXME: args must be a list. If one argument is a string it will
562 have " that will not be properly escaped. */
563 /* Invoke ui_out_tuple_end. */
564 do_cleanups (args_list_chain
);
567 ui_out_text (uiout
, ")");
568 if (sal
.symtab
&& sal
.symtab
->filename
)
570 annotate_frame_source_begin ();
571 ui_out_wrap_hint (uiout
, " ");
572 ui_out_text (uiout
, " at ");
573 annotate_frame_source_file ();
574 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
575 annotate_frame_source_file_end ();
576 ui_out_text (uiout
, ":");
577 annotate_frame_source_line ();
578 ui_out_field_int (uiout
, "line", sal
.line
);
579 annotate_frame_source_end ();
583 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
585 char *lib
= PC_SOLIB (fi
->pc
);
588 annotate_frame_where ();
589 ui_out_wrap_hint (uiout
, " ");
590 ui_out_text (uiout
, " from ");
591 ui_out_field_string (uiout
, "from", lib
);
594 #endif /* PC_SOLIB */
596 /* do_cleanups will call ui_out_tuple_end() for us. */
597 do_cleanups (list_chain
);
598 ui_out_text (uiout
, "\n");
599 do_cleanups (old_chain
);
603 /* Show or print the frame info. If this is the tui, it will be shown in
604 the source display */
606 print_frame_info (struct frame_info
*fi
, register int level
, int source
,
609 print_frame_info_base (fi
, level
, source
, args
);
612 /* Show the frame info. If this is the tui, it will be shown in
613 the source display otherwise, nothing is done */
615 show_stack_frame (struct frame_info
*fi
)
620 /* Read a frame specification in whatever the appropriate format is.
621 Call error() if the specification is in any way invalid (i.e.
622 this function never returns NULL). */
625 parse_frame_specification (char *frame_exp
)
629 CORE_ADDR args
[MAXARGS
];
634 char *addr_string
, *p
;
635 struct cleanup
*tmp_cleanup
;
637 while (*frame_exp
== ' ')
642 if (numargs
> MAXARGS
)
643 error ("Too many args in frame specification");
644 /* Parse an argument. */
645 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
647 addr_string
= savestring (frame_exp
, p
- frame_exp
);
652 tmp_cleanup
= make_cleanup (xfree
, addr_string
);
654 /* NOTE: we call parse_and_eval and then both
655 value_as_long and value_as_address rather than calling
656 parse_and_eval_long and parse_and_eval_address because
657 of the issue of potential side effects from evaluating
659 vp
= parse_and_eval (addr_string
);
661 level
= value_as_long (vp
);
663 args
[numargs
++] = value_as_address (vp
);
664 do_cleanups (tmp_cleanup
);
667 /* Skip spaces, move to possible next arg. */
677 if (selected_frame
== NULL
)
678 error ("No selected frame.");
679 return selected_frame
;
683 struct frame_info
*fid
=
684 find_relative_frame (get_current_frame (), &level
);
685 struct frame_info
*tfid
;
688 /* find_relative_frame was successful */
691 /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
692 take at least 2 addresses. It is important to detect this case
693 here so that "frame 100" does not give a confusing error message
694 like "frame specification requires two addresses". This of course
695 does not solve the "frame 100" problem for machines on which
696 a frame specification can be made with one address. To solve
697 that, we need a new syntax for a specifying a frame by address.
698 I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
699 two args, etc.), but people might think that is too much typing,
700 so I guess *0x23,0x45 would be a possible alternative (commas
701 really should be used instead of spaces to delimit; using spaces
702 normally works in an expression). */
703 #ifdef SETUP_ARBITRARY_FRAME
704 error ("No frame %d", args
[0]);
707 /* If (s)he specifies the frame with an address, he deserves what
708 (s)he gets. Still, give the highest one that matches. */
710 for (fid
= get_current_frame ();
711 fid
&& fid
->frame
!= args
[0];
712 fid
= get_prev_frame (fid
))
716 while ((tfid
= get_prev_frame (fid
)) &&
717 (tfid
->frame
== args
[0]))
720 /* We couldn't identify the frame as an existing frame, but
721 perhaps we can create one with a single argument. */
725 #ifdef SETUP_ARBITRARY_FRAME
726 return SETUP_ARBITRARY_FRAME (numargs
, args
);
728 /* Usual case. Do it here rather than have everyone supply
729 a SETUP_ARBITRARY_FRAME that does this. */
731 return create_new_frame (args
[0], 0);
732 error ("Too many args in frame specification");
739 /* FRAME_ARGS_ADDRESS_CORRECT is just like FRAME_ARGS_ADDRESS except
740 that if it is unsure about the answer, it returns 0
741 instead of guessing (this happens on the VAX and i960, for example).
743 On most machines, we never have to guess about the args address,
744 so FRAME_ARGS_ADDRESS{,_CORRECT} are the same. */
745 #if !defined (FRAME_ARGS_ADDRESS_CORRECT)
746 #define FRAME_ARGS_ADDRESS_CORRECT FRAME_ARGS_ADDRESS
749 /* Print verbosely the selected frame or the frame at address ADDR.
750 This means absolutely all information in the frame is printed. */
753 frame_info (char *addr_exp
, int from_tty
)
755 struct frame_info
*fi
;
756 struct symtab_and_line sal
;
759 struct frame_info
*calling_frame_info
;
760 int i
, count
, numregs
;
762 enum language funlang
= language_unknown
;
764 if (!target_has_stack
)
767 fi
= parse_frame_specification (addr_exp
);
769 error ("Invalid frame specified.");
771 sal
= find_pc_line (fi
->pc
,
773 && !fi
->next
->signal_handler_caller
774 && !frame_in_dummy (fi
->next
));
775 func
= get_frame_function (fi
);
776 s
= find_pc_symtab (fi
->pc
);
779 /* I'd like to use SYMBOL_SOURCE_NAME() here, to display
780 * the demangled name that we already have stored in
781 * the symbol table, but we stored a version with
782 * DMGL_PARAMS turned on, and here we don't want
783 * to display parameters. So call the demangler again,
784 * with DMGL_ANSI only. RT
785 * (Yes, I know that printf_symbol_filtered() will
786 * again try to demangle the name on the fly, but
787 * the issue is that if cplus_demangle() fails here,
788 * it'll fail there too. So we want to catch the failure
789 * ("demangled==NULL" case below) here, while we still
790 * have our hands on the function symbol.)
793 funname
= SYMBOL_NAME (func
);
794 funlang
= SYMBOL_LANGUAGE (func
);
795 if (funlang
== language_cplus
)
797 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
798 /* If the demangler fails, try the demangled name
799 * from the symbol table. This'll have parameters,
800 * but that's preferable to diplaying a mangled name.
802 if (demangled
== NULL
)
803 funname
= SYMBOL_SOURCE_NAME (func
);
808 register struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (fi
->pc
);
811 funname
= SYMBOL_NAME (msymbol
);
812 funlang
= SYMBOL_LANGUAGE (msymbol
);
815 calling_frame_info
= get_prev_frame (fi
);
817 if (!addr_exp
&& selected_frame_level
>= 0)
819 printf_filtered ("Stack level %d, frame at ", selected_frame_level
);
820 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
821 printf_filtered (":\n");
825 printf_filtered ("Stack frame at ");
826 print_address_numeric (fi
->frame
, 1, gdb_stdout
);
827 printf_filtered (":\n");
829 printf_filtered (" %s = ", REGISTER_NAME (PC_REGNUM
));
830 print_address_numeric (fi
->pc
, 1, gdb_stdout
);
835 printf_filtered (" in ");
836 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
837 DMGL_ANSI
| DMGL_PARAMS
);
841 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
842 puts_filtered ("; ");
844 printf_filtered ("saved %s ", REGISTER_NAME (PC_REGNUM
));
845 print_address_numeric (FRAME_SAVED_PC (fi
), 1, gdb_stdout
);
846 printf_filtered ("\n");
850 frameless
= FRAMELESS_FUNCTION_INVOCATION (fi
);
852 printf_filtered (" (FRAMELESS),");
855 if (calling_frame_info
)
857 printf_filtered (" called by frame at ");
858 print_address_numeric (calling_frame_info
->frame
, 1, gdb_stdout
);
860 if (fi
->next
&& calling_frame_info
)
865 printf_filtered (" caller of frame at ");
866 print_address_numeric (fi
->next
->frame
, 1, gdb_stdout
);
868 if (fi
->next
|| calling_frame_info
)
869 puts_filtered ("\n");
871 printf_filtered (" source language %s.\n", language_str (s
->language
));
873 #ifdef PRINT_EXTRA_FRAME_INFO
874 PRINT_EXTRA_FRAME_INFO (fi
);
878 /* Address of the argument list for this frame, or 0. */
879 CORE_ADDR arg_list
= FRAME_ARGS_ADDRESS_CORRECT (fi
);
880 /* Number of args for this frame, or -1 if unknown. */
884 printf_filtered (" Arglist at unknown address.\n");
887 printf_filtered (" Arglist at ");
888 print_address_numeric (arg_list
, 1, gdb_stdout
);
889 printf_filtered (",");
891 numargs
= FRAME_NUM_ARGS (fi
);
893 puts_filtered (" args: ");
894 else if (numargs
== 0)
895 puts_filtered (" no args.");
896 else if (numargs
== 1)
897 puts_filtered (" 1 arg: ");
899 printf_filtered (" %d args: ", numargs
);
900 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
901 puts_filtered ("\n");
905 /* Address of the local variables for this frame, or 0. */
906 CORE_ADDR arg_list
= FRAME_LOCALS_ADDRESS (fi
);
909 printf_filtered (" Locals at unknown address,");
912 printf_filtered (" Locals at ");
913 print_address_numeric (arg_list
, 1, gdb_stdout
);
914 printf_filtered (",");
918 FRAME_INIT_SAVED_REGS (fi
);
919 if (fi
->saved_regs
!= NULL
)
921 /* The sp is special; what's returned isn't the save address, but
922 actually the value of the previous frame's sp. */
923 printf_filtered (" Previous frame's sp is ");
924 print_address_numeric (fi
->saved_regs
[SP_REGNUM
], 1, gdb_stdout
);
925 printf_filtered ("\n");
927 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
928 for (i
= 0; i
< numregs
; i
++)
929 if (fi
->saved_regs
[i
] && i
!= SP_REGNUM
)
932 puts_filtered (" Saved registers:\n ");
936 printf_filtered (" %s at ", REGISTER_NAME (i
));
937 print_address_numeric (fi
->saved_regs
[i
], 1, gdb_stdout
);
941 puts_filtered ("\n");
945 /* We could get some information about saved registers by
946 calling get_saved_register on each register. Which info goes
947 with which frame is necessarily lost, however, and I suspect
948 that the users don't care whether they get the info. */
949 puts_filtered ("\n");
954 /* Set a limit on the number of frames printed by default in a
957 static int backtrace_limit
;
960 set_backtrace_limit_command (char *count_exp
, int from_tty
)
962 int count
= parse_and_eval_long (count_exp
);
965 error ("Negative argument not meaningful as backtrace limit.");
967 backtrace_limit
= count
;
971 backtrace_limit_info (char *arg
, int from_tty
)
974 error ("\"Info backtrace-limit\" takes no arguments.");
976 printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit
);
980 /* Print briefly all stack frames or just the innermost COUNT frames. */
982 static void backtrace_command_1 (char *count_exp
, int show_locals
,
985 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
987 struct frame_info
*fi
;
990 register struct frame_info
*trailing
;
991 register int trailing_level
;
993 if (!target_has_stack
)
996 /* The following code must do two things. First, it must
997 set the variable TRAILING to the frame from which we should start
998 printing. Second, it must set the variable count to the number
999 of frames which we should print, or -1 if all of them. */
1000 trailing
= get_current_frame ();
1002 /* The target can be in a state where there is no valid frames
1003 (e.g., just connected). */
1004 if (trailing
== NULL
)
1005 error ("No stack.");
1010 count
= parse_and_eval_long (count_exp
);
1013 struct frame_info
*current
;
1018 while (current
&& count
--)
1021 current
= get_prev_frame (current
);
1024 /* Will stop when CURRENT reaches the top of the stack. TRAILING
1025 will be COUNT below it. */
1029 trailing
= get_prev_frame (trailing
);
1030 current
= get_prev_frame (current
);
1042 struct partial_symtab
*ps
;
1044 /* Read in symbols for all of the frames. Need to do this in
1045 a separate pass so that "Reading in symbols for xxx" messages
1046 don't screw up the appearance of the backtrace. Also
1047 if people have strong opinions against reading symbols for
1048 backtrace this may have to be an option. */
1052 fi
= get_prev_frame (fi
))
1055 ps
= find_pc_psymtab (fi
->pc
);
1057 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
1061 for (i
= 0, fi
= trailing
;
1063 i
++, fi
= get_prev_frame (fi
))
1067 /* Don't use print_stack_frame; if an error() occurs it probably
1068 means further attempts to backtrace would fail (on the other
1069 hand, perhaps the code does or could be fixed to make sure
1070 the frame->prev field gets set to NULL in that case). */
1071 print_frame_info_base (fi
, trailing_level
+ i
, 0, 1);
1073 print_frame_local_vars (fi
, 1, gdb_stdout
);
1076 /* If we've stopped before the end, mention that. */
1078 printf_filtered ("(More stack frames follow...)\n");
1082 backtrace_command (char *arg
, int from_tty
)
1084 struct cleanup
*old_chain
= (struct cleanup
*) NULL
;
1085 char **argv
= (char **) NULL
;
1086 int argIndicatingFullTrace
= (-1), totArgLen
= 0, argc
= 0;
1089 if (arg
!= (char *) NULL
)
1093 argv
= buildargv (arg
);
1094 old_chain
= make_cleanup_freeargv (argv
);
1096 for (i
= 0; (argv
[i
] != (char *) NULL
); i
++)
1100 for (j
= 0; (j
< strlen (argv
[i
])); j
++)
1101 argv
[i
][j
] = tolower (argv
[i
][j
]);
1103 if (argIndicatingFullTrace
< 0 && subset_compare (argv
[i
], "full"))
1104 argIndicatingFullTrace
= argc
;
1108 totArgLen
+= strlen (argv
[i
]);
1112 if (argIndicatingFullTrace
>= 0)
1116 argPtr
= (char *) xmalloc (totArgLen
+ 1);
1121 memset (argPtr
, 0, totArgLen
+ 1);
1122 for (i
= 0; (i
< (argc
+ 1)); i
++)
1124 if (i
!= argIndicatingFullTrace
)
1126 strcat (argPtr
, argv
[i
]);
1127 strcat (argPtr
, " ");
1133 argPtr
= (char *) NULL
;
1137 backtrace_command_1 (argPtr
, (argIndicatingFullTrace
>= 0), from_tty
);
1139 if (argIndicatingFullTrace
>= 0 && totArgLen
> 0)
1143 do_cleanups (old_chain
);
1146 static void backtrace_full_command (char *arg
, int from_tty
);
1148 backtrace_full_command (char *arg
, int from_tty
)
1150 backtrace_command_1 (arg
, 1, from_tty
);
1154 /* Print the local variables of a block B active in FRAME.
1155 Return 1 if any variables were printed; 0 otherwise. */
1158 print_block_frame_locals (struct block
*b
, register struct frame_info
*fi
,
1159 int num_tabs
, register struct ui_file
*stream
)
1162 register struct symbol
*sym
;
1163 register int values_printed
= 0;
1165 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1167 switch (SYMBOL_CLASS (sym
))
1174 for (j
= 0; j
< num_tabs
; j
++)
1175 fputs_filtered ("\t", stream
);
1176 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1177 fputs_filtered (" = ", stream
);
1178 print_variable_value (sym
, fi
, stream
);
1179 fprintf_filtered (stream
, "\n");
1183 /* Ignore symbols which are not locals. */
1187 return values_printed
;
1190 /* Same, but print labels. */
1193 print_block_frame_labels (struct block
*b
, int *have_default
,
1194 register struct ui_file
*stream
)
1197 register struct symbol
*sym
;
1198 register int values_printed
= 0;
1200 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1202 if (STREQ (SYMBOL_NAME (sym
), "default"))
1208 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1210 struct symtab_and_line sal
;
1211 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1213 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1216 fprintf_filtered (stream
, " ");
1217 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, stream
);
1219 fprintf_filtered (stream
, " in file %s, line %d\n",
1220 sal
.symtab
->filename
, sal
.line
);
1223 return values_printed
;
1226 /* Print on STREAM all the local variables in frame FRAME,
1227 including all the blocks active in that frame
1230 Returns 1 if the job was done,
1231 or 0 if nothing was printed because we have no info
1232 on the function running in FRAME. */
1235 print_frame_local_vars (register struct frame_info
*fi
, register int num_tabs
,
1236 register struct ui_file
*stream
)
1238 register struct block
*block
= get_frame_block (fi
);
1239 register int values_printed
= 0;
1243 fprintf_filtered (stream
, "No symbol table info available.\n");
1249 if (print_block_frame_locals (block
, fi
, num_tabs
, stream
))
1251 /* After handling the function's top-level block, stop.
1252 Don't continue to its superblock, the block of
1253 per-file symbols. */
1254 if (BLOCK_FUNCTION (block
))
1256 block
= BLOCK_SUPERBLOCK (block
);
1259 if (!values_printed
)
1261 fprintf_filtered (stream
, "No locals.\n");
1265 /* Same, but print labels. */
1268 print_frame_label_vars (register struct frame_info
*fi
, int this_level_only
,
1269 register struct ui_file
*stream
)
1271 register struct blockvector
*bl
;
1272 register struct block
*block
= get_frame_block (fi
);
1273 register int values_printed
= 0;
1274 int index
, have_default
= 0;
1275 char *blocks_printed
;
1276 CORE_ADDR pc
= fi
->pc
;
1280 fprintf_filtered (stream
, "No symbol table info available.\n");
1284 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1285 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1286 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1290 CORE_ADDR end
= BLOCK_END (block
) - 4;
1293 if (bl
!= blockvector_for_pc (end
, &index
))
1294 error ("blockvector blotch");
1295 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1296 error ("blockvector botch");
1297 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1300 /* Don't print out blocks that have gone by. */
1301 while (index
< last_index
1302 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1305 while (index
< last_index
1306 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1308 if (blocks_printed
[index
] == 0)
1310 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
1312 blocks_printed
[index
] = 1;
1318 if (values_printed
&& this_level_only
)
1321 /* After handling the function's top-level block, stop.
1322 Don't continue to its superblock, the block of
1323 per-file symbols. */
1324 if (BLOCK_FUNCTION (block
))
1326 block
= BLOCK_SUPERBLOCK (block
);
1329 if (!values_printed
&& !this_level_only
)
1331 fprintf_filtered (stream
, "No catches.\n");
1337 locals_info (char *args
, int from_tty
)
1339 if (!selected_frame
)
1340 error ("No frame selected.");
1341 print_frame_local_vars (selected_frame
, 0, gdb_stdout
);
1345 catch_info (char *ignore
, int from_tty
)
1347 struct symtab_and_line
*sal
;
1349 /* Check for target support for exception handling */
1350 sal
= target_enable_exception_callback (EX_EVENT_CATCH
, 1);
1353 /* Currently not handling this */
1354 /* Ideally, here we should interact with the C++ runtime
1355 system to find the list of active handlers, etc. */
1356 fprintf_filtered (gdb_stdout
, "Info catch not supported with this target/compiler combination.\n");
1358 if (!selected_frame
)
1359 error ("No frame selected.");
1364 /* Assume g++ compiled code -- old v 4.16 behaviour */
1365 if (!selected_frame
)
1366 error ("No frame selected.");
1368 print_frame_label_vars (selected_frame
, 0, gdb_stdout
);
1373 print_frame_arg_vars (register struct frame_info
*fi
,
1374 register struct ui_file
*stream
)
1376 struct symbol
*func
= get_frame_function (fi
);
1377 register struct block
*b
;
1379 register struct symbol
*sym
, *sym2
;
1380 register int values_printed
= 0;
1384 fprintf_filtered (stream
, "No symbol table info available.\n");
1388 b
= SYMBOL_BLOCK_VALUE (func
);
1389 ALL_BLOCK_SYMBOLS (b
, i
, sym
)
1391 switch (SYMBOL_CLASS (sym
))
1397 case LOC_REGPARM_ADDR
:
1398 case LOC_BASEREG_ARG
:
1400 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), stream
);
1401 fputs_filtered (" = ", stream
);
1403 /* We have to look up the symbol because arguments can have
1404 two entries (one a parameter, one a local) and the one we
1405 want is the local, which lookup_symbol will find for us.
1406 This includes gcc1 (not gcc2) on the sparc when passing a
1407 small structure and gcc2 when the argument type is float
1408 and it is passed as a double and converted to float by
1409 the prologue (in the latter case the type of the LOC_ARG
1410 symbol is double and the type of the LOC_LOCAL symbol is
1411 float). There are also LOC_ARG/LOC_REGISTER pairs which
1412 are not combined in symbol-reading. */
1414 sym2
= lookup_symbol (SYMBOL_NAME (sym
),
1415 b
, VAR_NAMESPACE
, (int *) NULL
, (struct symtab
**) NULL
);
1416 print_variable_value (sym2
, fi
, stream
);
1417 fprintf_filtered (stream
, "\n");
1421 /* Don't worry about things which aren't arguments. */
1425 if (!values_printed
)
1427 fprintf_filtered (stream
, "No arguments.\n");
1432 args_info (char *ignore
, int from_tty
)
1434 if (!selected_frame
)
1435 error ("No frame selected.");
1436 print_frame_arg_vars (selected_frame
, gdb_stdout
);
1441 args_plus_locals_info (char *ignore
, int from_tty
)
1443 args_info (ignore
, from_tty
);
1444 locals_info (ignore
, from_tty
);
1448 /* Select frame FI, and note that its stack level is LEVEL.
1449 LEVEL may be -1 if an actual level number is not known. */
1452 select_frame (struct frame_info
*fi
, int level
)
1454 register struct symtab
*s
;
1456 selected_frame
= fi
;
1457 selected_frame_level
= level
;
1458 if (selected_frame_level_changed_hook
)
1459 selected_frame_level_changed_hook (level
);
1461 /* Ensure that symbols for this frame are read in. Also, determine the
1462 source language of this frame, and switch to it if desired. */
1465 s
= find_pc_symtab (fi
->pc
);
1467 && s
->language
!= current_language
->la_language
1468 && s
->language
!= language_unknown
1469 && language_mode
== language_mode_auto
)
1471 set_language (s
->language
);
1477 /* Select frame FI, noting that its stack level is LEVEL. Also print
1478 the stack frame and show the source if this is the tui version. */
1480 select_and_print_frame (struct frame_info
*fi
, int level
)
1482 select_frame (fi
, level
);
1485 print_stack_frame (fi
, level
, 1);
1490 /* Store the selected frame and its level into *FRAMEP and *LEVELP.
1491 If there is no selected frame, *FRAMEP is set to NULL. */
1494 record_selected_frame (CORE_ADDR
*frameaddrp
, int *levelp
)
1496 *frameaddrp
= selected_frame
? selected_frame
->frame
: 0;
1497 *levelp
= selected_frame_level
;
1500 /* Return the symbol-block in which the selected frame is executing.
1501 Can return zero under various legitimate circumstances. */
1504 get_selected_block (void)
1506 if (!target_has_stack
)
1509 if (!selected_frame
)
1510 return get_current_block ();
1511 return get_frame_block (selected_frame
);
1514 /* Find a frame a certain number of levels away from FRAME.
1515 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1516 Positive means go to earlier frames (up); negative, the reverse.
1517 The int that contains the number of levels is counted toward
1518 zero as the frames for those levels are found.
1519 If the top or bottom frame is reached, that frame is returned,
1520 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1521 how much farther the original request asked to go. */
1524 find_relative_frame (register struct frame_info
*frame
,
1525 register int *level_offset_ptr
)
1527 register struct frame_info
*prev
;
1528 register struct frame_info
*frame1
;
1530 /* Going up is simple: just do get_prev_frame enough times
1531 or until initial frame is reached. */
1532 while (*level_offset_ptr
> 0)
1534 prev
= get_prev_frame (frame
);
1537 (*level_offset_ptr
)--;
1540 /* Going down is just as simple. */
1541 if (*level_offset_ptr
< 0)
1543 while (*level_offset_ptr
< 0)
1545 frame1
= get_next_frame (frame
);
1549 (*level_offset_ptr
)++;
1555 /* The "select_frame" command. With no arg, NOP.
1556 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1557 valid level. Otherwise, treat level_exp as an address expression
1558 and select it. See parse_frame_specification for more info on proper
1559 frame expressions. */
1563 select_frame_command_wrapper (char *level_exp
, int from_tty
)
1565 select_frame_command (level_exp
, from_tty
);
1569 select_frame_command (char *level_exp
, int from_tty
)
1571 register struct frame_info
*frame
, *frame1
;
1572 unsigned int level
= 0;
1574 if (!target_has_stack
)
1575 error ("No stack.");
1577 frame
= parse_frame_specification (level_exp
);
1579 /* Try to figure out what level this frame is. But if there is
1580 no current stack, don't error out -- let the user set one. */
1582 if (get_current_frame ())
1584 for (frame1
= get_prev_frame (0);
1585 frame1
&& frame1
!= frame
;
1586 frame1
= get_prev_frame (frame1
))
1593 select_frame (frame
, level
);
1596 /* The "frame" command. With no arg, print selected frame briefly.
1597 With arg, behaves like select_frame and then prints the selected
1601 frame_command (char *level_exp
, int from_tty
)
1603 select_frame_command (level_exp
, from_tty
);
1604 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1607 /* The XDB Compatibility command to print the current frame. */
1610 current_frame_command (char *level_exp
, int from_tty
)
1612 if (target_has_stack
== 0 || selected_frame
== 0)
1613 error ("No stack.");
1614 print_only_stack_frame (selected_frame
, selected_frame_level
, 1);
1617 /* Select the frame up one or COUNT stack levels
1618 from the previously selected frame, and print it briefly. */
1622 up_silently_base (char *count_exp
)
1624 register struct frame_info
*fi
;
1625 int count
= 1, count1
;
1627 count
= parse_and_eval_long (count_exp
);
1630 if (target_has_stack
== 0 || selected_frame
== 0)
1631 error ("No stack.");
1633 fi
= find_relative_frame (selected_frame
, &count1
);
1634 if (count1
!= 0 && count_exp
== 0)
1635 error ("Initial frame selected; you cannot go up.");
1636 select_frame (fi
, selected_frame_level
+ count
- count1
);
1640 up_silently_command (char *count_exp
, int from_tty
)
1642 up_silently_base (count_exp
);
1646 up_command (char *count_exp
, int from_tty
)
1648 up_silently_base (count_exp
);
1649 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1652 /* Select the frame down one or COUNT stack levels
1653 from the previously selected frame, and print it briefly. */
1657 down_silently_base (char *count_exp
)
1659 register struct frame_info
*frame
;
1660 int count
= -1, count1
;
1662 count
= -parse_and_eval_long (count_exp
);
1665 if (target_has_stack
== 0 || selected_frame
== 0)
1666 error ("No stack.");
1668 frame
= find_relative_frame (selected_frame
, &count1
);
1669 if (count1
!= 0 && count_exp
== 0)
1672 /* We only do this if count_exp is not specified. That way "down"
1673 means to really go down (and let me know if that is
1674 impossible), but "down 9999" can be used to mean go all the way
1675 down without getting an error. */
1677 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1680 select_frame (frame
, selected_frame_level
+ count
- count1
);
1685 down_silently_command (char *count_exp
, int from_tty
)
1687 down_silently_base (count_exp
);
1691 down_command (char *count_exp
, int from_tty
)
1693 down_silently_base (count_exp
);
1694 show_and_print_stack_frame (selected_frame
, selected_frame_level
, 1);
1698 return_command_wrapper (char *retval_exp
, int from_tty
)
1700 return_command (retval_exp
, from_tty
);
1704 return_command (char *retval_exp
, int from_tty
)
1706 struct symbol
*thisfun
;
1707 CORE_ADDR selected_frame_addr
;
1708 CORE_ADDR selected_frame_pc
;
1709 struct frame_info
*frame
;
1710 struct value
*return_value
= NULL
;
1712 if (selected_frame
== NULL
)
1713 error ("No selected frame.");
1714 thisfun
= get_frame_function (selected_frame
);
1715 selected_frame_addr
= FRAME_FP (selected_frame
);
1716 selected_frame_pc
= selected_frame
->pc
;
1718 /* Compute the return value (if any -- possibly getting errors here). */
1722 struct type
*return_type
= NULL
;
1724 return_value
= parse_and_eval (retval_exp
);
1726 /* Cast return value to the return type of the function. */
1727 if (thisfun
!= NULL
)
1728 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1729 if (return_type
== NULL
)
1730 return_type
= builtin_type_int
;
1731 return_value
= value_cast (return_type
, return_value
);
1733 /* Make sure we have fully evaluated it, since
1734 it might live in the stack frame we're about to pop. */
1735 if (VALUE_LAZY (return_value
))
1736 value_fetch_lazy (return_value
);
1739 /* If interactive, require confirmation. */
1745 if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun
)))
1747 error ("Not confirmed.");
1751 else if (!query ("Make selected stack frame return now? "))
1752 error ("Not confirmed.");
1755 /* Do the real work. Pop until the specified frame is current. We
1756 use this method because the selected_frame is not valid after
1757 a POP_FRAME. The pc comparison makes this work even if the
1758 selected frame shares its fp with another frame. */
1760 while (selected_frame_addr
!= (frame
= get_current_frame ())->frame
1761 || selected_frame_pc
!= frame
->pc
)
1764 /* Then pop that frame. */
1768 /* Compute the return value (if any) and store in the place
1769 for return values. */
1772 set_return_value (return_value
);
1774 /* If we are at the end of a call dummy now, pop the dummy frame too. */
1776 if (CALL_DUMMY_HAS_COMPLETED (read_pc(), read_sp (),
1777 FRAME_FP (get_current_frame ())))
1780 /* If interactive, print the frame that is now current. */
1783 frame_command ("0", 1);
1785 select_frame_command ("0", 0);
1788 /* Sets the scope to input function name, provided that the
1789 function is within the current stack frame */
1791 struct function_bounds
1793 CORE_ADDR low
, high
;
1796 static void func_command (char *arg
, int from_tty
);
1798 func_command (char *arg
, int from_tty
)
1800 struct frame_info
*fp
;
1802 struct symtabs_and_lines sals
;
1805 struct function_bounds
*func_bounds
= (struct function_bounds
*) NULL
;
1807 if (arg
!= (char *) NULL
)
1810 fp
= parse_frame_specification ("0");
1811 sals
= decode_line_spec (arg
, 1);
1812 func_bounds
= (struct function_bounds
*) xmalloc (
1813 sizeof (struct function_bounds
) * sals
.nelts
);
1814 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1816 if (sals
.sals
[i
].pc
== (CORE_ADDR
) 0 ||
1817 find_pc_partial_function (sals
.sals
[i
].pc
,
1819 &func_bounds
[i
].low
,
1820 &func_bounds
[i
].high
) == 0)
1822 func_bounds
[i
].low
=
1823 func_bounds
[i
].high
= (CORE_ADDR
) NULL
;
1829 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1830 found
= (fp
->pc
>= func_bounds
[i
].low
&&
1831 fp
->pc
< func_bounds
[i
].high
);
1835 fp
= find_relative_frame (fp
, &level
);
1838 while (!found
&& level
== 0);
1841 xfree (func_bounds
);
1844 printf_filtered ("'%s' not within current stack frame.\n", arg
);
1845 else if (fp
!= selected_frame
)
1846 select_and_print_frame (fp
, level
);
1849 /* Gets the language of the current frame. */
1852 get_frame_language (void)
1854 register struct symtab
*s
;
1855 enum language flang
; /* The language of the current frame */
1859 s
= find_pc_symtab (selected_frame
->pc
);
1861 flang
= s
->language
;
1863 flang
= language_unknown
;
1866 flang
= language_unknown
;
1872 _initialize_stack (void)
1875 backtrace_limit
= 30;
1878 add_com ("return", class_stack
, return_command
,
1879 "Make selected stack frame return to its caller.\n\
1880 Control remains in the debugger, but when you continue\n\
1881 execution will resume in the frame above the one now selected.\n\
1882 If an argument is given, it is an expression for the value to return.");
1884 add_com ("up", class_stack
, up_command
,
1885 "Select and print stack frame that called this one.\n\
1886 An argument says how many frames up to go.");
1887 add_com ("up-silently", class_support
, up_silently_command
,
1888 "Same as the `up' command, but does not print anything.\n\
1889 This is useful in command scripts.");
1891 add_com ("down", class_stack
, down_command
,
1892 "Select and print stack frame called by this one.\n\
1893 An argument says how many frames down to go.");
1894 add_com_alias ("do", "down", class_stack
, 1);
1895 add_com_alias ("dow", "down", class_stack
, 1);
1896 add_com ("down-silently", class_support
, down_silently_command
,
1897 "Same as the `down' command, but does not print anything.\n\
1898 This is useful in command scripts.");
1900 add_com ("frame", class_stack
, frame_command
,
1901 "Select and print a stack frame.\n\
1902 With no argument, print the selected stack frame. (See also \"info frame\").\n\
1903 An argument specifies the frame to select.\n\
1904 It can be a stack frame number or the address of the frame.\n\
1905 With argument, nothing is printed if input is coming from\n\
1906 a command file or a user-defined command.");
1908 add_com_alias ("f", "frame", class_stack
, 1);
1912 add_com ("L", class_stack
, current_frame_command
,
1913 "Print the current stack frame.\n");
1914 add_com_alias ("V", "frame", class_stack
, 1);
1916 add_com ("select-frame", class_stack
, select_frame_command
,
1917 "Select a stack frame without printing anything.\n\
1918 An argument specifies the frame to select.\n\
1919 It can be a stack frame number or the address of the frame.\n");
1921 add_com ("backtrace", class_stack
, backtrace_command
,
1922 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
1923 With a negative argument, print outermost -COUNT frames.\n\
1924 Use of the 'full' qualifier also prints the values of the local variables.\n");
1925 add_com_alias ("bt", "backtrace", class_stack
, 0);
1928 add_com_alias ("t", "backtrace", class_stack
, 0);
1929 add_com ("T", class_stack
, backtrace_full_command
,
1930 "Print backtrace of all stack frames, or innermost COUNT frames \n\
1931 and the values of the local variables.\n\
1932 With a negative argument, print outermost -COUNT frames.\n\
1933 Usage: T <count>\n");
1936 add_com_alias ("where", "backtrace", class_alias
, 0);
1937 add_info ("stack", backtrace_command
,
1938 "Backtrace of the stack, or innermost COUNT frames.");
1939 add_info_alias ("s", "stack", 1);
1940 add_info ("frame", frame_info
,
1941 "All about selected stack frame, or frame at ADDR.");
1942 add_info_alias ("f", "frame", 1);
1943 add_info ("locals", locals_info
,
1944 "Local variables of current stack frame.");
1945 add_info ("args", args_info
,
1946 "Argument variables of current stack frame.");
1948 add_com ("l", class_info
, args_plus_locals_info
,
1949 "Argument and local variables of current stack frame.");
1952 add_com ("func", class_stack
, func_command
,
1953 "Select the stack frame that contains <func>.\nUsage: func <name>\n");
1955 add_info ("catch", catch_info
,
1956 "Exceptions that can be caught in the current stack frame.");
1959 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
1960 "Specify maximum number of frames for \"backtrace\" to print by default.",
1962 add_info ("backtrace-limit", backtrace_limit_info
,
1963 "The maximum number of frames for \"backtrace\" to print by default.");