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, 2003, 2004, 2005
5 Free Software Foundation, Inc.
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"
37 #include "breakpoint.h"
44 #include "gdb_assert.h"
45 #include "dictionary.h"
46 #include "exceptions.h"
47 #include "reggroups.h"
50 /* Prototypes for exported functions. */
52 void args_info (char *, int);
54 void locals_info (char *, int);
56 void (*deprecated_selected_frame_level_changed_hook) (int);
58 void _initialize_stack (void);
60 /* Prototypes for local functions. */
62 static void down_command (char *, int);
64 static void down_silently_base (char *);
66 static void down_silently_command (char *, int);
68 static void up_command (char *, int);
70 static void up_silently_base (char *);
72 static void up_silently_command (char *, int);
74 void frame_command (char *, int);
76 static void current_frame_command (char *, int);
78 static void print_frame_arg_vars (struct frame_info *, struct ui_file *);
80 static void catch_info (char *, int);
82 static void args_plus_locals_info (char *, int);
84 static void print_frame_label_vars (struct frame_info *, int,
87 static void print_frame_local_vars (struct frame_info *, int,
90 static int print_block_frame_labels (struct block *, int *,
93 static int print_block_frame_locals (struct block *,
98 static void print_frame (struct frame_info *fi,
100 enum print_what print_what,
102 struct symtab_and_line sal);
104 static void set_current_sal_from_frame (struct frame_info *, int);
106 static void backtrace_command (char *, int);
108 static void frame_info (char *, int);
110 extern int addressprint; /* Print addresses, or stay symbolic only? */
112 /* Zero means do things normally; we are interacting directly with the
113 user. One means print the full filename and linenumber when a
114 frame is printed, and do so in a format emacs18/emacs19.22 can
115 parse. Two means print similar annotations, but in many more
116 cases and in a slightly different syntax. */
118 int annotation_level = 0;
121 struct print_stack_frame_args
123 struct frame_info *fi;
125 enum print_what print_what;
129 /* Show or print the frame arguments.
130 Pass the args the way catch_errors wants them. */
132 print_stack_frame_stub (void *args)
134 struct print_stack_frame_args *p = args;
135 int center = (p->print_what == SRC_LINE
136 || p->print_what == SRC_AND_LOC);
138 print_frame_info (p->fi, p->print_level, p->print_what, p->print_args);
139 set_current_sal_from_frame (p->fi, center);
143 /* Show or print a stack frame FI briefly. The output is format
144 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
145 relative level, function name, argument list, and file name and
146 line number. If the frame's PC is not at the beginning of the
147 source line, the actual PC is printed at the beginning. */
150 print_stack_frame (struct frame_info *fi, int print_level,
151 enum print_what print_what)
153 struct print_stack_frame_args args;
156 args.print_level = print_level;
157 args.print_what = print_what;
160 catch_errors (print_stack_frame_stub, (char *) &args, "", RETURN_MASK_ALL);
163 struct print_args_args
166 struct frame_info *fi;
167 struct ui_file *stream;
170 static int print_args_stub (void *);
172 /* Print nameless args on STREAM.
173 FI is the frameinfo for this frame, START is the offset
174 of the first nameless arg, and NUM is the number of nameless args to
175 print. FIRST is nonzero if this is the first argument (not just
176 the first nameless arg). */
179 print_frame_nameless_args (struct frame_info *fi, long start, int num,
180 int first, struct ui_file *stream)
186 for (i = 0; i < num; i++)
189 argsaddr = get_frame_args_address (fi);
192 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
194 fprintf_filtered (stream, ", ");
195 fprintf_filtered (stream, "%ld", arg_value);
197 start += sizeof (int);
201 /* Print the arguments of a stack frame, given the function FUNC
202 running in that frame (as a symbol), the info on the frame,
203 and the number of args according to the stack frame (or -1 if unknown). */
205 /* References here and elsewhere to "number of args according to the
206 stack frame" appear in all cases to refer to "number of ints of args
207 according to the stack frame". At least for VAX, i386, isi. */
210 print_frame_args (struct symbol *func, struct frame_info *fi, int num,
211 struct ui_file *stream)
213 struct block *b = NULL;
215 struct dict_iterator iter;
218 /* Offset of next stack argument beyond the one we have seen that is
219 at the highest offset.
220 -1 if we haven't come to a stack argument yet. */
221 long highest_offset = -1;
223 /* Number of ints of arguments that we have printed so far. */
224 int args_printed = 0;
225 struct cleanup *old_chain, *list_chain;
226 struct ui_stream *stb;
228 stb = ui_out_stream_new (uiout);
229 old_chain = make_cleanup_ui_out_stream_delete (stb);
233 b = SYMBOL_BLOCK_VALUE (func);
235 ALL_BLOCK_SYMBOLS (b, iter, sym)
239 /* Keep track of the highest stack argument offset seen, and
240 skip over any kinds of symbols we don't care about. */
242 switch (SYMBOL_CLASS (sym))
247 long current_offset = SYMBOL_VALUE (sym);
248 arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
250 /* Compute address of next argument by adding the size of
251 this argument and rounding to an int boundary. */
253 ((current_offset + arg_size + sizeof (int) - 1)
254 & ~(sizeof (int) - 1));
256 /* If this is the highest offset seen yet, set highest_offset. */
257 if (highest_offset == -1
258 || (current_offset > highest_offset))
259 highest_offset = current_offset;
261 /* Add the number of ints we're about to print to args_printed. */
262 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
265 /* We care about types of symbols, but don't need to keep track of
266 stack offsets in them. */
268 case LOC_REGPARM_ADDR:
270 case LOC_BASEREG_ARG:
271 case LOC_COMPUTED_ARG:
274 /* Other types of symbols we just skip over. */
279 /* We have to look up the symbol because arguments can have
280 two entries (one a parameter, one a local) and the one we
281 want is the local, which lookup_symbol will find for us.
282 This includes gcc1 (not gcc2) on the sparc when passing a
283 small structure and gcc2 when the argument type is float
284 and it is passed as a double and converted to float by
285 the prologue (in the latter case the type of the LOC_ARG
286 symbol is double and the type of the LOC_LOCAL symbol is
288 /* But if the parameter name is null, don't try it.
289 Null parameter names occur on the RS/6000, for traceback tables.
290 FIXME, should we even print them? */
292 if (*DEPRECATED_SYMBOL_NAME (sym))
296 (DEPRECATED_SYMBOL_NAME (sym),
297 b, VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
298 if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
300 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
301 it was passed on the stack and loaded into a register,
302 or passed in a register and stored in a stack slot.
303 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
305 Reasons for using the LOC_ARG:
306 (1) because find_saved_registers may be slow for remote
308 (2) because registers are often re-used and stack slots
309 rarely (never?) are. Therefore using the stack slot is
310 much less likely to print garbage.
312 Reasons why we might want to use the LOC_REGISTER:
313 (1) So that the backtrace prints the same value as
314 "print foo". I see no compelling reason why this needs
315 to be the case; having the backtrace print the value which
316 was passed in, and "print foo" print the value as modified
317 within the called function, makes perfect sense to me.
319 Additional note: It might be nice if "info args" displayed
321 One more note: There is a case with sparc structure passing
322 where we need to use the LOC_REGISTER, but this is dealt with
323 by creating a single LOC_REGPARM in symbol reading. */
325 /* Leave sym (the LOC_ARG) alone. */
332 /* Print the current arg. */
334 ui_out_text (uiout, ", ");
335 ui_out_wrap_hint (uiout, " ");
337 annotate_arg_begin ();
339 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
340 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
341 SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
342 ui_out_field_stream (uiout, "name", stb);
343 annotate_arg_name_end ();
344 ui_out_text (uiout, "=");
346 /* Avoid value_print because it will deref ref parameters. We just
347 want to print their addresses. Print ??? for args whose address
348 we do not know. We pass 2 as "recurse" to val_print because our
349 standard indentation here is 4 spaces, and val_print indents
350 2 for each recurse. */
351 val = read_var_value (sym, fi);
353 annotate_arg_value (val == NULL ? NULL : value_type (val));
357 val_print (value_type (val), value_contents (val), 0,
359 stb->stream, 0, 0, 2, Val_no_prettyprint);
360 ui_out_field_stream (uiout, "value", stb);
363 ui_out_text (uiout, "???");
365 /* Invoke ui_out_tuple_end. */
366 do_cleanups (list_chain);
374 /* Don't print nameless args in situations where we don't know
375 enough about the stack to find them. */
380 if (highest_offset == -1)
381 start = FRAME_ARGS_SKIP;
383 start = highest_offset;
385 print_frame_nameless_args (fi, start, num - args_printed,
388 do_cleanups (old_chain);
391 /* Pass the args the way catch_errors wants them. */
394 print_args_stub (void *args)
397 struct print_args_args *p = (struct print_args_args *) args;
399 if (FRAME_NUM_ARGS_P ())
401 numargs = FRAME_NUM_ARGS (p->fi);
402 gdb_assert (numargs >= 0);
406 print_frame_args (p->func, p->fi, numargs, p->stream);
410 /* Set the current source and line to the location of the given
411 frame, if possible. When CENTER is true, adjust so the
412 relevant line is in the center of the next 'list'. */
415 set_current_sal_from_frame (struct frame_info *fi, int center)
417 struct symtab_and_line sal;
419 find_frame_sal (fi, &sal);
423 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
424 set_current_source_symtab_and_line (&sal);
428 /* Print information about a frame for frame "fi" at level "level".
429 Used in "where" output, also used to emit breakpoint or step
431 LEVEL is the level of the frame, or -1 if it is the
432 innermost frame but we don't want to print the level.
433 The meaning of the SOURCE argument is:
434 SRC_LINE: Print only source line
435 LOCATION: Print only location
436 LOC_AND_SRC: Print location and source line. */
439 print_frame_info (struct frame_info *fi, int print_level,
440 enum print_what print_what, int print_args)
442 struct symtab_and_line sal;
446 if (get_frame_type (fi) == DUMMY_FRAME
447 || get_frame_type (fi) == SIGTRAMP_FRAME)
449 struct cleanup *uiout_cleanup
450 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
452 annotate_frame_begin (print_level ? frame_relative_level (fi) : 0,
455 /* Do this regardless of SOURCE because we don't have any source
456 to list for this frame. */
459 ui_out_text (uiout, "#");
460 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
461 frame_relative_level (fi));
463 if (ui_out_is_mi_like_p (uiout))
465 annotate_frame_address ();
466 ui_out_field_core_addr (uiout, "addr", get_frame_pc (fi));
467 annotate_frame_address_end ();
470 if (get_frame_type (fi) == DUMMY_FRAME)
472 annotate_function_call ();
473 ui_out_field_string (uiout, "func", "<function called from gdb>");
475 else if (get_frame_type (fi) == SIGTRAMP_FRAME)
477 annotate_signal_handler_caller ();
478 ui_out_field_string (uiout, "func", "<signal handler called>");
480 ui_out_text (uiout, "\n");
481 annotate_frame_end ();
483 do_cleanups (uiout_cleanup);
487 /* If fi is not the innermost frame, that normally means that fi->pc
488 points to *after* the call instruction, and we want to get the
489 line containing the call, never the next line. But if the next
490 frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the next frame
491 was not entered as the result of a call, and we want to get the
492 line containing fi->pc. */
493 find_frame_sal (fi, &sal);
495 location_print = (print_what == LOCATION
496 || print_what == LOC_AND_ADDRESS
497 || print_what == SRC_AND_LOC);
499 if (location_print || !sal.symtab)
500 print_frame (fi, print_level, print_what, print_args, sal);
502 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
504 if (source_print && sal.symtab)
507 int mid_statement = ((print_what == SRC_LINE)
508 && (get_frame_pc (fi) != sal.pc));
510 if (annotation_level)
511 done = identify_source_line (sal.symtab, sal.line, mid_statement,
515 if (deprecated_print_frame_info_listing_hook)
516 deprecated_print_frame_info_listing_hook (sal.symtab,
521 /* We used to do this earlier, but that is clearly
522 wrong. This function is used by many different
523 parts of gdb, including normal_stop in infrun.c,
524 which uses this to print out the current PC
525 when we stepi/nexti into the middle of a source
526 line. Only the command line really wants this
527 behavior. Other UIs probably would like the
528 ability to decide for themselves if it is desired. */
529 if (addressprint && mid_statement)
531 ui_out_field_core_addr (uiout, "addr", get_frame_pc (fi));
532 ui_out_text (uiout, "\t");
535 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
540 if (print_what != LOCATION)
541 set_default_breakpoint (1, get_frame_pc (fi), sal.symtab, sal.line);
543 annotate_frame_end ();
545 gdb_flush (gdb_stdout);
549 print_frame (struct frame_info *fi,
551 enum print_what print_what,
553 struct symtab_and_line sal)
557 enum language funlang = language_unknown;
558 struct ui_stream *stb;
559 struct cleanup *old_chain;
560 struct cleanup *list_chain;
562 stb = ui_out_stream_new (uiout);
563 old_chain = make_cleanup_ui_out_stream_delete (stb);
565 func = find_pc_function (get_frame_address_in_block (fi));
568 /* In certain pathological cases, the symtabs give the wrong
569 function (when we are in the first function in a file which
570 is compiled without debugging symbols, the previous function
571 is compiled with debugging symbols, and the "foo.o" symbol
572 that is supposed to tell us where the file with debugging symbols
573 ends has been truncated by ar because it is longer than 15
574 characters). This also occurs if the user uses asm() to create
575 a function but not stabs for it (in a file compiled -g).
577 So look in the minimal symbol tables as well, and if it comes
578 up with a larger address for the function use that instead.
579 I don't think this can ever cause any problems; there shouldn't
580 be any minimal symbols in the middle of a function; if this is
581 ever changed many parts of GDB will need to be changed (and we'll
582 create a find_pc_minimal_function or some such). */
584 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (get_frame_address_in_block (fi));
586 && (SYMBOL_VALUE_ADDRESS (msymbol)
587 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
589 /* We also don't know anything about the function besides
590 its address and name. */
592 funname = DEPRECATED_SYMBOL_NAME (msymbol);
593 funlang = SYMBOL_LANGUAGE (msymbol);
597 /* I'd like to use SYMBOL_PRINT_NAME() here, to display the
598 demangled name that we already have stored in the symbol
599 table, but we stored a version with DMGL_PARAMS turned
600 on, and here we don't want to display parameters. So call
601 the demangler again, with DMGL_ANSI only. (Yes, I know
602 that printf_symbol_filtered() will again try to demangle
603 the name on the fly, but the issue is that if
604 cplus_demangle() fails here, it'll fail there too. So we
605 want to catch the failure ("demangled==NULL" case below)
606 here, while we still have our hands on the function
609 funname = DEPRECATED_SYMBOL_NAME (func);
610 funlang = SYMBOL_LANGUAGE (func);
611 if (funlang == language_cplus)
613 demangled = cplus_demangle (funname, DMGL_ANSI);
614 if (demangled == NULL)
615 /* If the demangler fails, try the demangled name from
616 the symbol table. This'll have parameters, but
617 that's preferable to diplaying a mangled name. */
618 funname = SYMBOL_PRINT_NAME (func);
624 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (get_frame_address_in_block (fi));
627 funname = DEPRECATED_SYMBOL_NAME (msymbol);
628 funlang = SYMBOL_LANGUAGE (msymbol);
632 annotate_frame_begin (print_level ? frame_relative_level (fi) : 0,
635 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
639 ui_out_text (uiout, "#");
640 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
641 frame_relative_level (fi));
644 if (get_frame_pc (fi) != sal.pc
646 || print_what == LOC_AND_ADDRESS)
648 annotate_frame_address ();
649 ui_out_field_core_addr (uiout, "addr", get_frame_pc (fi));
650 annotate_frame_address_end ();
651 ui_out_text (uiout, " in ");
653 annotate_frame_function_name ();
654 fprintf_symbol_filtered (stb->stream, funname ? funname : "??", funlang,
656 ui_out_field_stream (uiout, "func", stb);
657 ui_out_wrap_hint (uiout, " ");
658 annotate_frame_args ();
660 ui_out_text (uiout, " (");
663 struct print_args_args args;
664 struct cleanup *args_list_chain;
667 args.stream = gdb_stdout;
668 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
669 catch_errors (print_args_stub, &args, "", RETURN_MASK_ALL);
670 /* FIXME: args must be a list. If one argument is a string it will
671 have " that will not be properly escaped. */
672 /* Invoke ui_out_tuple_end. */
673 do_cleanups (args_list_chain);
676 ui_out_text (uiout, ")");
677 if (sal.symtab && sal.symtab->filename)
679 annotate_frame_source_begin ();
680 ui_out_wrap_hint (uiout, " ");
681 ui_out_text (uiout, " at ");
682 annotate_frame_source_file ();
683 ui_out_field_string (uiout, "file", sal.symtab->filename);
684 annotate_frame_source_file_end ();
685 ui_out_text (uiout, ":");
686 annotate_frame_source_line ();
687 ui_out_field_int (uiout, "line", sal.line);
688 annotate_frame_source_end ();
692 if (!funname || (!sal.symtab || !sal.symtab->filename))
694 char *lib = PC_SOLIB (get_frame_pc (fi));
697 annotate_frame_where ();
698 ui_out_wrap_hint (uiout, " ");
699 ui_out_text (uiout, " from ");
700 ui_out_field_string (uiout, "from", lib);
703 #endif /* PC_SOLIB */
705 /* do_cleanups will call ui_out_tuple_end() for us. */
706 do_cleanups (list_chain);
707 ui_out_text (uiout, "\n");
708 do_cleanups (old_chain);
711 /* Show the frame info. If this is the tui, it will be shown in
712 the source display otherwise, nothing is done */
714 show_stack_frame (struct frame_info *fi)
719 /* Read a frame specification in whatever the appropriate format is.
720 Call error() if the specification is in any way invalid (i.e. this
721 function never returns NULL). When SEPECTED_P is non-NULL set it's
722 target to indicate that the default selected frame was used. */
724 static struct frame_info *
725 parse_frame_specification_1 (const char *frame_exp, const char *message,
726 int *selected_frame_p)
729 struct value *args[4];
730 CORE_ADDR addrs[ARRAY_SIZE (args)];
732 if (frame_exp == NULL)
737 struct cleanup *tmp_cleanup;
743 struct cleanup *cleanup;
746 /* Skip leading white space, bail of EOL. */
747 while (isspace (*frame_exp))
752 /* Parse the argument, extract it, save it. */
756 addr_string = savestring (frame_exp, p - frame_exp);
758 cleanup = make_cleanup (xfree, addr_string);
760 /* NOTE: Parse and evaluate expression, but do not use
761 functions such as parse_and_eval_long or
762 parse_and_eval_address to also extract the value.
763 Instead value_as_long and value_as_address are used.
764 This avoids problems with expressions that contain
766 if (numargs >= ARRAY_SIZE (args))
767 error (_("Too many args in frame specification"));
768 args[numargs++] = parse_and_eval (addr_string);
770 do_cleanups (cleanup);
774 /* If no args, default to the selected frame. */
777 if (selected_frame_p != NULL)
778 (*selected_frame_p) = 1;
779 return get_selected_frame (message);
782 /* None of the remaining use the selected frame. */
783 if (selected_frame_p != NULL)
784 (*selected_frame_p) = 0;
786 /* Assume the single arg[0] is an integer, and try using that to
787 select a frame relative to current. */
790 struct frame_info *fid;
791 int level = value_as_long (args[0]);
792 fid = find_relative_frame (get_current_frame (), &level);
794 /* find_relative_frame was successful */
798 /* Convert each value into a corresponding address. */
801 for (i = 0; i < numargs; i++)
802 addrs[i] = value_as_address (args[0]);
805 /* Assume that the single arg[0] is an address, use that to identify
806 a frame with a matching ID. Should this also accept stack/pc or
810 struct frame_id id = frame_id_build_wild (addrs[0]);
811 struct frame_info *fid;
813 /* If SETUP_ARBITRARY_FRAME is defined, then frame
814 specifications take at least 2 addresses. It is important to
815 detect this case here so that "frame 100" does not give a
816 confusing error message like "frame specification requires
817 two addresses". This of course does not solve the "frame
818 100" problem for machines on which a frame specification can
819 be made with one address. To solve that, we need a new
820 syntax for a specifying a frame by address. I think the
821 cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for two
822 args, etc.), but people might think that is too much typing,
823 so I guess *0x23,0x45 would be a possible alternative (commas
824 really should be used instead of spaces to delimit; using
825 spaces normally works in an expression). */
826 #ifdef SETUP_ARBITRARY_FRAME
827 error (_("No frame %s"), paddr_d (addrs[0]));
829 /* If (s)he specifies the frame with an address, he deserves
830 what (s)he gets. Still, give the highest one that matches.
831 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
833 for (fid = get_current_frame ();
835 fid = get_prev_frame (fid))
837 if (frame_id_eq (id, get_frame_id (fid)))
839 while (frame_id_eq (id, frame_unwind_id (fid)))
840 fid = get_prev_frame (fid);
846 /* We couldn't identify the frame as an existing frame, but
847 perhaps we can create one with a single argument. */
849 return create_new_frame (addrs[0], 0);
850 else if (numargs == 2)
851 return create_new_frame (addrs[0], addrs[1]);
853 error (_("Too many args in frame specification"));
857 parse_frame_specification (char *frame_exp)
859 return parse_frame_specification_1 (frame_exp, NULL, NULL);
862 /* Print verbosely the selected frame or the frame at address ADDR.
863 This means absolutely all information in the frame is printed. */
866 frame_info (char *addr_exp, int from_tty)
868 struct frame_info *fi;
869 struct symtab_and_line sal;
872 struct frame_info *calling_frame_info;
873 int i, count, numregs;
875 enum language funlang = language_unknown;
876 const char *pc_regname;
877 int selected_frame_p;
879 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
881 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
882 is not a good name. */
884 /* OK, this is weird. The PC_REGNUM hardware register's value can
885 easily not match that of the internal value returned by
887 pc_regname = REGISTER_NAME (PC_REGNUM);
889 /* But then, this is weird to. Even without PC_REGNUM, an
890 architectures will often have a hardware register called "pc",
891 and that register's value, again, can easily not match
895 find_frame_sal (fi, &sal);
896 func = get_frame_function (fi);
897 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
899 s = find_pc_symtab (get_frame_pc (fi));
902 /* I'd like to use SYMBOL_PRINT_NAME() here, to display
903 * the demangled name that we already have stored in
904 * the symbol table, but we stored a version with
905 * DMGL_PARAMS turned on, and here we don't want
906 * to display parameters. So call the demangler again,
907 * with DMGL_ANSI only. RT
908 * (Yes, I know that printf_symbol_filtered() will
909 * again try to demangle the name on the fly, but
910 * the issue is that if cplus_demangle() fails here,
911 * it'll fail there too. So we want to catch the failure
912 * ("demangled==NULL" case below) here, while we still
913 * have our hands on the function symbol.)
916 funname = DEPRECATED_SYMBOL_NAME (func);
917 funlang = SYMBOL_LANGUAGE (func);
918 if (funlang == language_cplus)
920 demangled = cplus_demangle (funname, DMGL_ANSI);
921 /* If the demangler fails, try the demangled name
922 * from the symbol table. This'll have parameters,
923 * but that's preferable to diplaying a mangled name.
925 if (demangled == NULL)
926 funname = SYMBOL_PRINT_NAME (func);
931 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
934 funname = DEPRECATED_SYMBOL_NAME (msymbol);
935 funlang = SYMBOL_LANGUAGE (msymbol);
938 calling_frame_info = get_prev_frame (fi);
940 if (selected_frame_p && frame_relative_level (fi) >= 0)
942 printf_filtered (_("Stack level %d, frame at "),
943 frame_relative_level (fi));
944 deprecated_print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
945 printf_filtered (":\n");
949 printf_filtered (_("Stack frame at "));
950 deprecated_print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
951 printf_filtered (":\n");
953 printf_filtered (" %s = ", pc_regname);
954 deprecated_print_address_numeric (get_frame_pc (fi), 1, gdb_stdout);
959 printf_filtered (" in ");
960 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
961 DMGL_ANSI | DMGL_PARAMS);
965 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
966 puts_filtered ("; ");
968 printf_filtered ("saved %s ", pc_regname);
969 deprecated_print_address_numeric (frame_pc_unwind (fi), 1, gdb_stdout);
970 printf_filtered ("\n");
972 if (calling_frame_info)
974 printf_filtered (" called by frame at ");
975 deprecated_print_address_numeric (get_frame_base (calling_frame_info),
978 if (get_next_frame (fi) && calling_frame_info)
981 if (get_next_frame (fi))
983 printf_filtered (" caller of frame at ");
984 deprecated_print_address_numeric (get_frame_base (get_next_frame (fi)), 1,
987 if (get_next_frame (fi) || calling_frame_info)
988 puts_filtered ("\n");
990 printf_filtered (" source language %s.\n",
991 language_str (s->language));
994 /* Address of the argument list for this frame, or 0. */
995 CORE_ADDR arg_list = get_frame_args_address (fi);
996 /* Number of args for this frame, or -1 if unknown. */
1000 printf_filtered (" Arglist at unknown address.\n");
1003 printf_filtered (" Arglist at ");
1004 deprecated_print_address_numeric (arg_list, 1, gdb_stdout);
1005 printf_filtered (",");
1007 if (!FRAME_NUM_ARGS_P ())
1010 puts_filtered (" args: ");
1014 numargs = FRAME_NUM_ARGS (fi);
1015 gdb_assert (numargs >= 0);
1017 puts_filtered (" no args.");
1018 else if (numargs == 1)
1019 puts_filtered (" 1 arg: ");
1021 printf_filtered (" %d args: ", numargs);
1023 print_frame_args (func, fi, numargs, gdb_stdout);
1024 puts_filtered ("\n");
1028 /* Address of the local variables for this frame, or 0. */
1029 CORE_ADDR arg_list = get_frame_locals_address (fi);
1032 printf_filtered (" Locals at unknown address,");
1035 printf_filtered (" Locals at ");
1036 deprecated_print_address_numeric (arg_list, 1, gdb_stdout);
1037 printf_filtered (",");
1041 /* Print as much information as possible on the location of all the
1044 enum lval_type lval;
1052 /* The sp is special; what's displayed isn't the save address, but
1053 the value of the previous frame's sp. This is a legacy thing,
1054 at one stage the frame cached the previous frame's SP instead
1055 of its address, hence it was easiest to just display the cached
1059 /* Find out the location of the saved stack pointer with out
1060 actually evaluating it. */
1061 frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
1063 if (!optimized && lval == not_lval)
1065 char value[MAX_REGISTER_SIZE];
1067 frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
1069 /* NOTE: cagney/2003-05-22: This is assuming that the
1070 stack pointer was packed as an unsigned integer. That
1071 may or may not be valid. */
1072 sp = extract_unsigned_integer (value, register_size (current_gdbarch, SP_REGNUM));
1073 printf_filtered (" Previous frame's sp is ");
1074 deprecated_print_address_numeric (sp, 1, gdb_stdout);
1075 printf_filtered ("\n");
1078 else if (!optimized && lval == lval_memory)
1080 printf_filtered (" Previous frame's sp at ");
1081 deprecated_print_address_numeric (addr, 1, gdb_stdout);
1082 printf_filtered ("\n");
1085 else if (!optimized && lval == lval_register)
1087 printf_filtered (" Previous frame's sp in %s\n",
1088 REGISTER_NAME (realnum));
1091 /* else keep quiet. */
1095 numregs = NUM_REGS + NUM_PSEUDO_REGS;
1096 for (i = 0; i < numregs; i++)
1098 && gdbarch_register_reggroup_p (current_gdbarch, i, all_reggroup))
1100 /* Find out the location of the saved register without
1101 fetching the corresponding value. */
1102 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1104 /* For moment, only display registers that were saved on the
1106 if (!optimized && lval == lval_memory)
1109 puts_filtered (" Saved registers:\n ");
1111 puts_filtered (",");
1113 printf_filtered (" %s at ", REGISTER_NAME (i));
1114 deprecated_print_address_numeric (addr, 1, gdb_stdout);
1118 if (count || need_nl)
1119 puts_filtered ("\n");
1123 /* Print briefly all stack frames or just the innermost COUNT frames. */
1125 static void backtrace_command_1 (char *count_exp, int show_locals,
1128 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1130 struct frame_info *fi;
1133 struct frame_info *trailing;
1136 if (!target_has_stack)
1137 error (_("No stack."));
1139 /* The following code must do two things. First, it must
1140 set the variable TRAILING to the frame from which we should start
1141 printing. Second, it must set the variable count to the number
1142 of frames which we should print, or -1 if all of them. */
1143 trailing = get_current_frame ();
1145 /* The target can be in a state where there is no valid frames
1146 (e.g., just connected). */
1147 if (trailing == NULL)
1148 error (_("No stack."));
1153 count = parse_and_eval_long (count_exp);
1156 struct frame_info *current;
1161 while (current && count--)
1164 current = get_prev_frame (current);
1167 /* Will stop when CURRENT reaches the top of the stack. TRAILING
1168 will be COUNT below it. */
1172 trailing = get_prev_frame (trailing);
1173 current = get_prev_frame (current);
1185 struct partial_symtab *ps;
1187 /* Read in symbols for all of the frames. Need to do this in
1188 a separate pass so that "Reading in symbols for xxx" messages
1189 don't screw up the appearance of the backtrace. Also
1190 if people have strong opinions against reading symbols for
1191 backtrace this may have to be an option. */
1195 fi = get_prev_frame (fi))
1198 ps = find_pc_psymtab (get_frame_address_in_block (fi));
1200 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in */
1204 for (i = 0, fi = trailing;
1206 i++, fi = get_prev_frame (fi))
1210 /* Don't use print_stack_frame; if an error() occurs it probably
1211 means further attempts to backtrace would fail (on the other
1212 hand, perhaps the code does or could be fixed to make sure
1213 the frame->prev field gets set to NULL in that case). */
1214 print_frame_info (fi, 1, LOCATION, 1);
1216 print_frame_local_vars (fi, 1, gdb_stdout);
1219 /* If we've stopped before the end, mention that. */
1221 printf_filtered (_("(More stack frames follow...)\n"));
1224 struct backtrace_command_args
1231 /* Stub to call backtrace_command_1 by way of an error catcher. */
1233 backtrace_command_stub (void *data)
1235 struct backtrace_command_args *args = (struct backtrace_command_args *)data;
1236 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1241 backtrace_command (char *arg, int from_tty)
1243 struct cleanup *old_chain = (struct cleanup *) NULL;
1244 char **argv = (char **) NULL;
1245 int argIndicatingFullTrace = (-1), totArgLen = 0, argc = 0;
1247 struct backtrace_command_args btargs;
1249 if (arg != (char *) NULL)
1253 argv = buildargv (arg);
1254 old_chain = make_cleanup_freeargv (argv);
1256 for (i = 0; (argv[i] != (char *) NULL); i++)
1260 for (j = 0; (j < strlen (argv[i])); j++)
1261 argv[i][j] = tolower (argv[i][j]);
1263 if (argIndicatingFullTrace < 0 && subset_compare (argv[i], "full"))
1264 argIndicatingFullTrace = argc;
1268 totArgLen += strlen (argv[i]);
1272 if (argIndicatingFullTrace >= 0)
1276 argPtr = (char *) xmalloc (totArgLen + 1);
1281 memset (argPtr, 0, totArgLen + 1);
1282 for (i = 0; (i < (argc + 1)); i++)
1284 if (i != argIndicatingFullTrace)
1286 strcat (argPtr, argv[i]);
1287 strcat (argPtr, " ");
1293 argPtr = (char *) NULL;
1297 btargs.count_exp = argPtr;
1298 btargs.show_locals = (argIndicatingFullTrace >= 0);
1299 btargs.from_tty = from_tty;
1300 catch_errors (backtrace_command_stub, (char *)&btargs, "", RETURN_MASK_ERROR);
1302 if (argIndicatingFullTrace >= 0 && totArgLen > 0)
1306 do_cleanups (old_chain);
1309 static void backtrace_full_command (char *arg, int from_tty);
1311 backtrace_full_command (char *arg, int from_tty)
1313 struct backtrace_command_args btargs;
1314 btargs.count_exp = arg;
1315 btargs.show_locals = 1;
1316 btargs.from_tty = from_tty;
1317 catch_errors (backtrace_command_stub, (char *)&btargs, "", RETURN_MASK_ERROR);
1321 /* Print the local variables of a block B active in FRAME.
1322 Return 1 if any variables were printed; 0 otherwise. */
1325 print_block_frame_locals (struct block *b, struct frame_info *fi,
1326 int num_tabs, struct ui_file *stream)
1328 struct dict_iterator iter;
1331 int values_printed = 0;
1333 ALL_BLOCK_SYMBOLS (b, iter, sym)
1335 switch (SYMBOL_CLASS (sym))
1343 for (j = 0; j < num_tabs; j++)
1344 fputs_filtered ("\t", stream);
1345 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1346 fputs_filtered (" = ", stream);
1347 print_variable_value (sym, fi, stream);
1348 fprintf_filtered (stream, "\n");
1352 /* Ignore symbols which are not locals. */
1356 return values_printed;
1359 /* Same, but print labels. */
1362 print_block_frame_labels (struct block *b, int *have_default,
1363 struct ui_file *stream)
1365 struct dict_iterator iter;
1367 int values_printed = 0;
1369 ALL_BLOCK_SYMBOLS (b, iter, sym)
1371 if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "default") == 0)
1377 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1379 struct symtab_and_line sal;
1380 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1382 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1385 fprintf_filtered (stream, " ");
1386 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream);
1388 fprintf_filtered (stream, " in file %s, line %d\n",
1389 sal.symtab->filename, sal.line);
1392 return values_printed;
1395 /* Print on STREAM all the local variables in frame FRAME,
1396 including all the blocks active in that frame
1399 Returns 1 if the job was done,
1400 or 0 if nothing was printed because we have no info
1401 on the function running in FRAME. */
1404 print_frame_local_vars (struct frame_info *fi, int num_tabs,
1405 struct ui_file *stream)
1407 struct block *block = get_frame_block (fi, 0);
1408 int values_printed = 0;
1412 fprintf_filtered (stream, "No symbol table info available.\n");
1418 if (print_block_frame_locals (block, fi, num_tabs, stream))
1420 /* After handling the function's top-level block, stop.
1421 Don't continue to its superblock, the block of
1422 per-file symbols. */
1423 if (BLOCK_FUNCTION (block))
1425 block = BLOCK_SUPERBLOCK (block);
1428 if (!values_printed)
1430 fprintf_filtered (stream, "No locals.\n");
1434 /* Same, but print labels. */
1437 print_frame_label_vars (struct frame_info *fi, int this_level_only,
1438 struct ui_file *stream)
1440 struct blockvector *bl;
1441 struct block *block = get_frame_block (fi, 0);
1442 int values_printed = 0;
1443 int index, have_default = 0;
1444 char *blocks_printed;
1445 CORE_ADDR pc = get_frame_pc (fi);
1449 fprintf_filtered (stream, "No symbol table info available.\n");
1453 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1454 blocks_printed = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1455 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1459 CORE_ADDR end = BLOCK_END (block) - 4;
1462 if (bl != blockvector_for_pc (end, &index))
1463 error (_("blockvector blotch"));
1464 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1465 error (_("blockvector botch"));
1466 last_index = BLOCKVECTOR_NBLOCKS (bl);
1469 /* Don't print out blocks that have gone by. */
1470 while (index < last_index
1471 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1474 while (index < last_index
1475 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1477 if (blocks_printed[index] == 0)
1479 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index), &have_default, stream))
1481 blocks_printed[index] = 1;
1487 if (values_printed && this_level_only)
1490 /* After handling the function's top-level block, stop.
1491 Don't continue to its superblock, the block of
1492 per-file symbols. */
1493 if (BLOCK_FUNCTION (block))
1495 block = BLOCK_SUPERBLOCK (block);
1498 if (!values_printed && !this_level_only)
1500 fprintf_filtered (stream, "No catches.\n");
1505 locals_info (char *args, int from_tty)
1507 print_frame_local_vars (get_selected_frame ("No frame selected."),
1512 catch_info (char *ignore, int from_tty)
1514 struct symtab_and_line *sal;
1516 /* Check for target support for exception handling */
1517 sal = target_enable_exception_callback (EX_EVENT_CATCH, 1);
1520 /* Currently not handling this */
1521 /* Ideally, here we should interact with the C++ runtime
1522 system to find the list of active handlers, etc. */
1523 fprintf_filtered (gdb_stdout, "Info catch not supported with this target/compiler combination.\n");
1527 /* Assume g++ compiled code -- old v 4.16 behaviour */
1528 print_frame_label_vars (get_selected_frame ("No frame selected."),
1534 print_frame_arg_vars (struct frame_info *fi,
1535 struct ui_file *stream)
1537 struct symbol *func = get_frame_function (fi);
1539 struct dict_iterator iter;
1540 struct symbol *sym, *sym2;
1541 int values_printed = 0;
1545 fprintf_filtered (stream, "No symbol table info available.\n");
1549 b = SYMBOL_BLOCK_VALUE (func);
1550 ALL_BLOCK_SYMBOLS (b, iter, sym)
1552 switch (SYMBOL_CLASS (sym))
1558 case LOC_REGPARM_ADDR:
1559 case LOC_BASEREG_ARG:
1560 case LOC_COMPUTED_ARG:
1562 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1563 fputs_filtered (" = ", stream);
1565 /* We have to look up the symbol because arguments can have
1566 two entries (one a parameter, one a local) and the one we
1567 want is the local, which lookup_symbol will find for us.
1568 This includes gcc1 (not gcc2) on the sparc when passing a
1569 small structure and gcc2 when the argument type is float
1570 and it is passed as a double and converted to float by
1571 the prologue (in the latter case the type of the LOC_ARG
1572 symbol is double and the type of the LOC_LOCAL symbol is
1573 float). There are also LOC_ARG/LOC_REGISTER pairs which
1574 are not combined in symbol-reading. */
1576 sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
1577 b, VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL);
1578 print_variable_value (sym2, fi, stream);
1579 fprintf_filtered (stream, "\n");
1583 /* Don't worry about things which aren't arguments. */
1587 if (!values_printed)
1589 fprintf_filtered (stream, "No arguments.\n");
1594 args_info (char *ignore, int from_tty)
1596 print_frame_arg_vars (get_selected_frame ("No frame selected."),
1602 args_plus_locals_info (char *ignore, int from_tty)
1604 args_info (ignore, from_tty);
1605 locals_info (ignore, from_tty);
1609 /* Select frame FI. Also print the stack frame and show the source if
1610 this is the tui version. */
1612 select_and_print_frame (struct frame_info *fi)
1616 print_stack_frame (fi, 1, SRC_AND_LOC);
1619 /* Return the symbol-block in which the selected frame is executing.
1620 Can return zero under various legitimate circumstances.
1622 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1623 code address within the block returned. We use this to decide
1624 which macros are in scope. */
1627 get_selected_block (CORE_ADDR *addr_in_block)
1629 if (!target_has_stack)
1632 /* NOTE: cagney/2002-11-28: Why go to all this effort to not create
1633 a selected/current frame? Perhaps this function is called,
1634 indirectly, by WFI in "infrun.c" where avoiding the creation of
1635 an inner most frame is very important (it slows down single
1636 step). I suspect, though that this was true in the deep dark
1637 past but is no longer the case. A mindless look at all the
1638 callers tends to support this theory. I think we should be able
1639 to assume that there is always a selcted frame. */
1640 /* gdb_assert (deprecated_selected_frame != NULL); So, do you feel
1642 if (!deprecated_selected_frame)
1644 CORE_ADDR pc = read_pc ();
1645 if (addr_in_block != NULL)
1646 *addr_in_block = pc;
1647 return block_for_pc (pc);
1649 return get_frame_block (deprecated_selected_frame, addr_in_block);
1652 /* Find a frame a certain number of levels away from FRAME.
1653 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1654 Positive means go to earlier frames (up); negative, the reverse.
1655 The int that contains the number of levels is counted toward
1656 zero as the frames for those levels are found.
1657 If the top or bottom frame is reached, that frame is returned,
1658 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1659 how much farther the original request asked to go. */
1662 find_relative_frame (struct frame_info *frame,
1663 int *level_offset_ptr)
1665 struct frame_info *prev;
1666 struct frame_info *frame1;
1668 /* Going up is simple: just do get_prev_frame enough times
1669 or until initial frame is reached. */
1670 while (*level_offset_ptr > 0)
1672 prev = get_prev_frame (frame);
1675 (*level_offset_ptr)--;
1678 /* Going down is just as simple. */
1679 if (*level_offset_ptr < 0)
1681 while (*level_offset_ptr < 0)
1683 frame1 = get_next_frame (frame);
1687 (*level_offset_ptr)++;
1693 /* The "select_frame" command. With no arg, NOP.
1694 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1695 valid level. Otherwise, treat level_exp as an address expression
1696 and select it. See parse_frame_specification for more info on proper
1697 frame expressions. */
1700 select_frame_command (char *level_exp, int from_tty)
1702 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1705 /* The "frame" command. With no arg, print selected frame briefly.
1706 With arg, behaves like select_frame and then prints the selected
1710 frame_command (char *level_exp, int from_tty)
1712 select_frame_command (level_exp, from_tty);
1713 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1716 /* The XDB Compatibility command to print the current frame. */
1719 current_frame_command (char *level_exp, int from_tty)
1721 print_stack_frame (get_selected_frame ("No stack."), 1, SRC_AND_LOC);
1724 /* Select the frame up one or COUNT stack levels
1725 from the previously selected frame, and print it briefly. */
1728 up_silently_base (char *count_exp)
1730 struct frame_info *fi;
1731 int count = 1, count1;
1733 count = parse_and_eval_long (count_exp);
1736 fi = find_relative_frame (get_selected_frame ("No stack."), &count1);
1737 if (count1 != 0 && count_exp == 0)
1738 error (_("Initial frame selected; you cannot go up."));
1743 up_silently_command (char *count_exp, int from_tty)
1745 up_silently_base (count_exp);
1749 up_command (char *count_exp, int from_tty)
1751 up_silently_base (count_exp);
1752 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1755 /* Select the frame down one or COUNT stack levels
1756 from the previously selected frame, and print it briefly. */
1759 down_silently_base (char *count_exp)
1761 struct frame_info *frame;
1762 int count = -1, count1;
1764 count = -parse_and_eval_long (count_exp);
1767 frame = find_relative_frame (get_selected_frame ("No stack."), &count1);
1768 if (count1 != 0 && count_exp == 0)
1771 /* We only do this if count_exp is not specified. That way "down"
1772 means to really go down (and let me know if that is
1773 impossible), but "down 9999" can be used to mean go all the way
1774 down without getting an error. */
1776 error (_("Bottom (i.e., innermost) frame selected; you cannot go down."));
1779 select_frame (frame);
1783 down_silently_command (char *count_exp, int from_tty)
1785 down_silently_base (count_exp);
1789 down_command (char *count_exp, int from_tty)
1791 down_silently_base (count_exp);
1792 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1796 return_command (char *retval_exp, int from_tty)
1798 struct symbol *thisfun;
1799 struct value *return_value = NULL;
1800 const char *query_prefix = "";
1802 thisfun = get_frame_function (get_selected_frame ("No selected frame."));
1804 /* Compute the return value. If the computation triggers an error,
1805 let it bail. If the return type can't be handled, set
1806 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1810 struct type *return_type = NULL;
1812 /* Compute the return value. Should the computation fail, this
1813 call throws an error. */
1814 return_value = parse_and_eval (retval_exp);
1816 /* Cast return value to the return type of the function. Should
1817 the cast fail, this call throws an error. */
1818 if (thisfun != NULL)
1819 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1820 if (return_type == NULL)
1821 return_type = builtin_type_int;
1822 CHECK_TYPEDEF (return_type);
1823 return_value = value_cast (return_type, return_value);
1825 /* Make sure the value is fully evaluated. It may live in the
1826 stack frame we're about to pop. */
1827 if (value_lazy (return_value))
1828 value_fetch_lazy (return_value);
1830 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1831 /* If the return-type is "void", don't try to find the
1832 return-value's location. However, do still evaluate the
1833 return expression so that, even when the expression result
1834 is discarded, side effects such as "return i++" still
1836 return_value = NULL;
1837 /* FIXME: cagney/2004-01-17: If the architecture implements both
1838 return_value and extract_returned_value_address, should allow
1839 "return" to work - don't set return_value to NULL. */
1840 else if (!gdbarch_return_value_p (current_gdbarch)
1841 && (TYPE_CODE (return_type) == TYPE_CODE_STRUCT
1842 || TYPE_CODE (return_type) == TYPE_CODE_UNION))
1844 /* NOTE: cagney/2003-10-20: Compatibility hack for legacy
1845 code. Old architectures don't expect STORE_RETURN_VALUE
1846 to be called with with a small struct that needs to be
1847 stored in registers. Don't start doing it now. */
1849 A structure or union return type is not supported by this architecture.\n\
1850 If you continue, the return value that you specified will be ignored.\n";
1851 return_value = NULL;
1853 else if (using_struct_return (return_type, 0))
1856 The location at which to store the function's return value is unknown.\n\
1857 If you continue, the return value that you specified will be ignored.\n";
1858 return_value = NULL;
1862 /* Does an interactive user really want to do this? Include
1863 information, such as how well GDB can handle the return value, in
1864 the query message. */
1868 if (thisfun == NULL)
1869 confirmed = query (_("%sMake selected stack frame return now? "),
1872 confirmed = query (_("%sMake %s return now? "), query_prefix,
1873 SYMBOL_PRINT_NAME (thisfun));
1875 error (_("Not confirmed"));
1878 /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
1879 frame in turn, should this code just go straight to the relevant
1880 frame and pop that? */
1882 /* First discard all frames inner-to the selected frame (making the
1883 selected frame current). */
1885 struct frame_id selected_id = get_frame_id (get_selected_frame (NULL));
1886 while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ())))
1888 if (frame_id_inner (selected_id, get_frame_id (get_current_frame ())))
1889 /* Caught in the safety net, oops! We've gone way past the
1891 error (_("Problem while popping stack frames (corrupt stack?)"));
1892 frame_pop (get_current_frame ());
1896 /* Second discard the selected frame (which is now also the current
1898 frame_pop (get_current_frame ());
1900 /* Store RETURN_VAUE in the just-returned register set. */
1901 if (return_value != NULL)
1903 struct type *return_type = value_type (return_value);
1904 gdb_assert (gdbarch_return_value (current_gdbarch, return_type,
1906 == RETURN_VALUE_REGISTER_CONVENTION);
1907 gdbarch_return_value (current_gdbarch, return_type,
1908 current_regcache, NULL /*read*/,
1909 value_contents (return_value) /*write*/);
1912 /* If we are at the end of a call dummy now, pop the dummy frame
1914 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1915 frame_pop (get_current_frame ());
1917 /* If interactive, print the frame that is now current. */
1919 frame_command ("0", 1);
1921 select_frame_command ("0", 0);
1924 /* Sets the scope to input function name, provided that the
1925 function is within the current stack frame */
1927 struct function_bounds
1929 CORE_ADDR low, high;
1932 static void func_command (char *arg, int from_tty);
1934 func_command (char *arg, int from_tty)
1936 struct frame_info *fp;
1938 struct symtabs_and_lines sals;
1941 struct function_bounds *func_bounds = (struct function_bounds *) NULL;
1943 if (arg != (char *) NULL)
1946 fp = parse_frame_specification ("0");
1947 sals = decode_line_spec (arg, 1);
1948 func_bounds = (struct function_bounds *) xmalloc (
1949 sizeof (struct function_bounds) * sals.nelts);
1950 for (i = 0; (i < sals.nelts && !found); i++)
1952 if (sals.sals[i].pc == (CORE_ADDR) 0 ||
1953 find_pc_partial_function (sals.sals[i].pc,
1955 &func_bounds[i].low,
1956 &func_bounds[i].high) == 0)
1958 func_bounds[i].low =
1959 func_bounds[i].high = (CORE_ADDR) NULL;
1965 for (i = 0; (i < sals.nelts && !found); i++)
1966 found = (get_frame_pc (fp) >= func_bounds[i].low &&
1967 get_frame_pc (fp) < func_bounds[i].high);
1971 fp = find_relative_frame (fp, &level);
1974 while (!found && level == 0);
1977 xfree (func_bounds);
1980 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
1981 else if (fp != deprecated_selected_frame)
1982 select_and_print_frame (fp);
1985 /* Gets the language of the current frame. */
1988 get_frame_language (void)
1991 enum language flang; /* The language of the current frame */
1993 if (deprecated_selected_frame)
1995 /* We determine the current frame language by looking up its
1996 associated symtab. To retrieve this symtab, we use the frame PC.
1997 However we cannot use the frame pc as is, because it usually points
1998 to the instruction following the "call", which is sometimes the first
1999 instruction of another function. So we rely on
2000 get_frame_address_in_block(), it provides us with a PC which is
2001 guaranteed to be inside the frame's code block. */
2002 s = find_pc_symtab (get_frame_address_in_block (deprecated_selected_frame));
2004 flang = s->language;
2006 flang = language_unknown;
2009 flang = language_unknown;
2015 _initialize_stack (void)
2018 backtrace_limit = 30;
2021 add_com ("return", class_stack, return_command,
2022 "Make selected stack frame return to its caller.\n\
2023 Control remains in the debugger, but when you continue\n\
2024 execution will resume in the frame above the one now selected.\n\
2025 If an argument is given, it is an expression for the value to return.");
2027 add_com ("up", class_stack, up_command,
2028 "Select and print stack frame that called this one.\n\
2029 An argument says how many frames up to go.");
2030 add_com ("up-silently", class_support, up_silently_command,
2031 "Same as the `up' command, but does not print anything.\n\
2032 This is useful in command scripts.");
2034 add_com ("down", class_stack, down_command,
2035 "Select and print stack frame called by this one.\n\
2036 An argument says how many frames down to go.");
2037 add_com_alias ("do", "down", class_stack, 1);
2038 add_com_alias ("dow", "down", class_stack, 1);
2039 add_com ("down-silently", class_support, down_silently_command,
2040 "Same as the `down' command, but does not print anything.\n\
2041 This is useful in command scripts.");
2043 add_com ("frame", class_stack, frame_command,
2044 "Select and print a stack frame.\n\
2045 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2046 An argument specifies the frame to select.\n\
2047 It can be a stack frame number or the address of the frame.\n\
2048 With argument, nothing is printed if input is coming from\n\
2049 a command file or a user-defined command.");
2051 add_com_alias ("f", "frame", class_stack, 1);
2055 add_com ("L", class_stack, current_frame_command,
2056 "Print the current stack frame.\n");
2057 add_com_alias ("V", "frame", class_stack, 1);
2059 add_com ("select-frame", class_stack, select_frame_command,
2060 "Select a stack frame without printing anything.\n\
2061 An argument specifies the frame to select.\n\
2062 It can be a stack frame number or the address of the frame.\n");
2064 add_com ("backtrace", class_stack, backtrace_command,
2065 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
2066 With a negative argument, print outermost -COUNT frames.\n\
2067 Use of the 'full' qualifier also prints the values of the local variables.\n");
2068 add_com_alias ("bt", "backtrace", class_stack, 0);
2071 add_com_alias ("t", "backtrace", class_stack, 0);
2072 add_com ("T", class_stack, backtrace_full_command,
2073 "Print backtrace of all stack frames, or innermost COUNT frames \n\
2074 and the values of the local variables.\n\
2075 With a negative argument, print outermost -COUNT frames.\n\
2076 Usage: T <count>\n");
2079 add_com_alias ("where", "backtrace", class_alias, 0);
2080 add_info ("stack", backtrace_command,
2081 "Backtrace of the stack, or innermost COUNT frames.");
2082 add_info_alias ("s", "stack", 1);
2083 add_info ("frame", frame_info,
2084 "All about selected stack frame, or frame at ADDR.");
2085 add_info_alias ("f", "frame", 1);
2086 add_info ("locals", locals_info,
2087 "Local variables of current stack frame.");
2088 add_info ("args", args_info,
2089 "Argument variables of current stack frame.");
2091 add_com ("l", class_info, args_plus_locals_info,
2092 "Argument and local variables of current stack frame.");
2095 add_com ("func", class_stack, func_command,
2096 "Select the stack frame that contains <func>.\nUsage: func <name>\n");
2098 add_info ("catch", catch_info,
2099 "Exceptions that can be caught in the current stack frame.");
2102 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2103 "Specify maximum number of frames for \"backtrace\" to print by default."),
2105 add_info ("backtrace-limit", backtrace_limit_info,
2106 "The maximum number of frames for \"backtrace\" to print by default.");