1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
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 3 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, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
33 #include "breakpoint.h"
40 #include "dictionary.h"
41 #include "exceptions.h"
42 #include "reggroups.h"
46 #include "gdbthread.h"
47 #include "cp-support.h"
49 #include "gdb_assert.h"
51 #include "gdb_string.h"
53 void (*deprecated_selected_frame_level_changed_hook) (int);
55 /* The possible choices of "set print frame-arguments, and the value
58 static const char *print_frame_arguments_choices[] =
59 {"all", "scalars", "none", NULL};
60 static const char *print_frame_arguments = "all";
62 /* Prototypes for local functions. */
64 static void print_frame_local_vars (struct frame_info *, int,
67 static void print_frame (struct frame_info *frame, int print_level,
68 enum print_what print_what, int print_args,
69 struct symtab_and_line sal);
71 /* Zero means do things normally; we are interacting directly with the
72 user. One means print the full filename and linenumber when a
73 frame is printed, and do so in a format emacs18/emacs19.22 can
74 parse. Two means print similar annotations, but in many more
75 cases and in a slightly different syntax. */
77 int annotation_level = 0;
80 struct print_stack_frame_args
82 struct frame_info *frame;
84 enum print_what print_what;
88 /* Show or print the frame arguments; stub for catch_errors. */
91 print_stack_frame_stub (void *args)
93 struct print_stack_frame_args *p = args;
94 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
96 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
97 set_current_sal_from_frame (p->frame, center);
101 /* Show or print a stack frame FRAME briefly. The output is format
102 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
103 relative level, function name, argument list, and file name and
104 line number. If the frame's PC is not at the beginning of the
105 source line, the actual PC is printed at the beginning. */
108 print_stack_frame (struct frame_info *frame, int print_level,
109 enum print_what print_what)
111 struct print_stack_frame_args args;
114 args.print_level = print_level;
115 args.print_what = print_what;
116 /* For mi, alway print location and address. */
117 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
120 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
123 struct print_args_args
126 struct frame_info *frame;
127 struct ui_file *stream;
130 static int print_args_stub (void *args);
132 /* Print nameless arguments of frame FRAME on STREAM, where START is
133 the offset of the first nameless argument, and NUM is the number of
134 nameless arguments to print. FIRST is nonzero if this is the first
135 argument (not just the first nameless argument). */
138 print_frame_nameless_args (struct frame_info *frame, long start, int num,
139 int first, struct ui_file *stream)
145 for (i = 0; i < num; i++)
148 argsaddr = get_frame_args_address (frame);
151 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
153 fprintf_filtered (stream, ", ");
154 fprintf_filtered (stream, "%ld", arg_value);
156 start += sizeof (int);
160 /* Return non-zero if the debugger should print the value of the provided
161 symbol parameter (SYM). */
164 print_this_frame_argument_p (struct symbol *sym)
168 /* If the user asked to print no argument at all, then obviously
169 do not print this argument. */
171 if (strcmp (print_frame_arguments, "none") == 0)
174 /* If the user asked to print all arguments, then we should print
177 if (strcmp (print_frame_arguments, "all") == 0)
180 /* The user asked to print only the scalar arguments, so do not
181 print the non-scalar ones. */
183 type = CHECK_TYPEDEF (SYMBOL_TYPE (sym));
184 while (TYPE_CODE (type) == TYPE_CODE_REF)
185 type = CHECK_TYPEDEF (TYPE_TARGET_TYPE (type));
186 switch (TYPE_CODE (type))
188 case TYPE_CODE_ARRAY:
189 case TYPE_CODE_STRUCT:
190 case TYPE_CODE_UNION:
192 case TYPE_CODE_STRING:
193 case TYPE_CODE_BITSTRING:
200 /* Print the arguments of frame FRAME on STREAM, given the function
201 FUNC running in that frame (as a symbol), where NUM is the number
202 of arguments according to the stack frame (or -1 if the number of
203 arguments is unknown). */
205 /* Note that currently the "number of argumentss according to the
206 stack frame" is only known on VAX where i refers to the "number of
207 ints of argumentss according to the stack frame". */
210 print_frame_args (struct symbol *func, struct frame_info *frame,
211 int num, struct ui_file *stream)
214 /* Offset of next stack argument beyond the one we have seen that is
215 at the highest offset, or -1 if we haven't come to a stack
217 long highest_offset = -1;
218 /* Number of ints of arguments that we have printed so far. */
219 int args_printed = 0;
220 struct cleanup *old_chain, *list_chain;
221 struct ui_stream *stb;
223 stb = ui_out_stream_new (uiout);
224 old_chain = make_cleanup_ui_out_stream_delete (stb);
228 struct block *b = SYMBOL_BLOCK_VALUE (func);
229 struct dict_iterator iter;
233 ALL_BLOCK_SYMBOLS (b, iter, sym)
237 /* Keep track of the highest stack argument offset seen, and
238 skip over any kinds of symbols we don't care about. */
240 if (!SYMBOL_IS_ARGUMENT (sym))
243 switch (SYMBOL_CLASS (sym))
248 long current_offset = SYMBOL_VALUE (sym);
249 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
251 /* Compute address of next argument by adding the size of
252 this argument and rounding to an int boundary. */
254 ((current_offset + arg_size + sizeof (int) - 1)
255 & ~(sizeof (int) - 1));
257 /* If this is the highest offset seen yet, set
259 if (highest_offset == -1
260 || (current_offset > highest_offset))
261 highest_offset = current_offset;
263 /* Add the number of ints we're about to print to
265 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
268 /* We care about types of symbols, but don't need to
269 keep track of stack offsets in them. */
271 case LOC_REGPARM_ADDR:
273 case LOC_OPTIMIZED_OUT:
278 /* We have to look up the symbol because arguments can have
279 two entries (one a parameter, one a local) and the one we
280 want is the local, which lookup_symbol will find for us.
281 This includes gcc1 (not gcc2) on SPARC when passing a
282 small structure and gcc2 when the argument type is float
283 and it is passed as a double and converted to float by
284 the prologue (in the latter case the type of the LOC_ARG
285 symbol is double and the type of the LOC_LOCAL symbol is
287 /* But if the parameter name is null, don't try it. Null
288 parameter names occur on the RS/6000, for traceback
289 tables. FIXME, should we even print them? */
291 if (*SYMBOL_LINKAGE_NAME (sym))
294 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
295 b, VAR_DOMAIN, NULL);
296 gdb_assert (nsym != NULL);
297 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
298 && !SYMBOL_IS_ARGUMENT (nsym))
300 /* There is a LOC_ARG/LOC_REGISTER pair. This means
301 that it was passed on the stack and loaded into a
302 register, or passed in a register and stored in a
303 stack slot. GDB 3.x used the LOC_ARG; GDB
304 4.0-4.11 used the LOC_REGISTER.
306 Reasons for using the LOC_ARG:
308 (1) Because find_saved_registers may be slow for
311 (2) Because registers are often re-used and stack
312 slots rarely (never?) are. Therefore using
313 the stack slot is much less likely to print
316 Reasons why we might want to use the LOC_REGISTER:
318 (1) So that the backtrace prints the same value
319 as "print foo". I see no compelling reason
320 why this needs to be the case; having the
321 backtrace print the value which was passed
322 in, and "print foo" print the value as
323 modified within the called function, makes
326 Additional note: It might be nice if "info args"
327 displayed both values.
329 One more note: There is a case with SPARC
330 structure passing where we need to use the
331 LOC_REGISTER, but this is dealt with by creating
332 a single LOC_REGPARM in symbol reading. */
334 /* Leave sym (the LOC_ARG) alone. */
341 /* Print the current arg. */
343 ui_out_text (uiout, ", ");
344 ui_out_wrap_hint (uiout, " ");
346 annotate_arg_begin ();
348 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
349 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
350 SYMBOL_LANGUAGE (sym),
351 DMGL_PARAMS | DMGL_ANSI);
352 ui_out_field_stream (uiout, "name", stb);
353 annotate_arg_name_end ();
354 ui_out_text (uiout, "=");
356 if (print_this_frame_argument_p (sym))
358 /* Avoid value_print because it will deref ref parameters.
359 We just want to print their addresses. Print ??? for
360 args whose address we do not know. We pass 2 as
361 "recurse" to val_print because our standard indentation
362 here is 4 spaces, and val_print indents 2 for each
364 val = read_var_value (sym, frame);
366 annotate_arg_value (val == NULL ? NULL : value_type (val));
370 const struct language_defn *language;
372 /* Use the appropriate language to display our symbol,
373 unless the user forced the language to a specific
375 if (language_mode == language_mode_auto)
376 language = language_def (SYMBOL_LANGUAGE (sym));
378 language = current_language;
380 common_val_print (val, stb->stream, 0, 0, 2,
381 Val_no_prettyprint, language);
382 ui_out_field_stream (uiout, "value", stb);
385 ui_out_text (uiout, "???");
388 ui_out_text (uiout, "...");
391 /* Invoke ui_out_tuple_end. */
392 do_cleanups (list_chain);
400 /* Don't print nameless args in situations where we don't know
401 enough about the stack to find them. */
406 if (highest_offset == -1)
407 start = gdbarch_frame_args_skip (get_frame_arch (frame));
409 start = highest_offset;
411 print_frame_nameless_args (frame, start, num - args_printed,
415 do_cleanups (old_chain);
418 /* Stub for catch_errors. */
421 print_args_stub (void *args)
423 struct print_args_args *p = args;
424 struct gdbarch *gdbarch = get_frame_arch (p->frame);
427 if (gdbarch_frame_num_args_p (gdbarch))
429 numargs = gdbarch_frame_num_args (gdbarch, p->frame);
430 gdb_assert (numargs >= 0);
434 print_frame_args (p->func, p->frame, numargs, p->stream);
438 /* Set the current source and line to the location given by frame
439 FRAME, if possible. When CENTER is true, adjust so the relevant
440 line is in the center of the next 'list'. */
443 set_current_sal_from_frame (struct frame_info *frame, int center)
445 struct symtab_and_line sal;
447 find_frame_sal (frame, &sal);
451 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
452 set_current_source_symtab_and_line (&sal);
456 /* Print information about frame FRAME. The output is format according
457 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
460 SRC_LINE: Print only source line.
461 LOCATION: Print only location.
462 LOC_AND_SRC: Print location and source line.
464 Used in "where" output, and to emit breakpoint or step
468 print_frame_info (struct frame_info *frame, int print_level,
469 enum print_what print_what, int print_args)
471 struct symtab_and_line sal;
475 if (get_frame_type (frame) == DUMMY_FRAME
476 || get_frame_type (frame) == SIGTRAMP_FRAME)
478 struct cleanup *uiout_cleanup
479 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
481 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
482 get_frame_pc (frame));
484 /* Do this regardless of SOURCE because we don't have any source
485 to list for this frame. */
488 ui_out_text (uiout, "#");
489 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
490 frame_relative_level (frame));
492 if (ui_out_is_mi_like_p (uiout))
494 annotate_frame_address ();
495 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
496 annotate_frame_address_end ();
499 if (get_frame_type (frame) == DUMMY_FRAME)
501 annotate_function_call ();
502 ui_out_field_string (uiout, "func", "<function called from gdb>");
504 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
506 annotate_signal_handler_caller ();
507 ui_out_field_string (uiout, "func", "<signal handler called>");
509 ui_out_text (uiout, "\n");
510 annotate_frame_end ();
512 do_cleanups (uiout_cleanup);
516 /* If FRAME is not the innermost frame, that normally means that
517 FRAME->pc points to *after* the call instruction, and we want to
518 get the line containing the call, never the next line. But if
519 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
520 next frame was not entered as the result of a call, and we want
521 to get the line containing FRAME->pc. */
522 find_frame_sal (frame, &sal);
524 location_print = (print_what == LOCATION
525 || print_what == LOC_AND_ADDRESS
526 || print_what == SRC_AND_LOC);
528 if (location_print || !sal.symtab)
529 print_frame (frame, print_level, print_what, print_args, sal);
531 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
533 if (source_print && sal.symtab)
536 int mid_statement = ((print_what == SRC_LINE)
537 && (get_frame_pc (frame) != sal.pc));
539 if (annotation_level)
540 done = identify_source_line (sal.symtab, sal.line, mid_statement,
541 get_frame_pc (frame));
544 if (deprecated_print_frame_info_listing_hook)
545 deprecated_print_frame_info_listing_hook (sal.symtab,
550 /* We used to do this earlier, but that is clearly
551 wrong. This function is used by many different
552 parts of gdb, including normal_stop in infrun.c,
553 which uses this to print out the current PC
554 when we stepi/nexti into the middle of a source
555 line. Only the command line really wants this
556 behavior. Other UIs probably would like the
557 ability to decide for themselves if it is desired. */
558 if (addressprint && mid_statement)
560 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
561 ui_out_text (uiout, "\t");
564 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
569 if (print_what != LOCATION)
570 set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line);
572 annotate_frame_end ();
574 gdb_flush (gdb_stdout);
578 print_frame (struct frame_info *frame, int print_level,
579 enum print_what print_what, int print_args,
580 struct symtab_and_line sal)
583 char *funname = NULL;
584 enum language funlang = language_unknown;
585 struct ui_stream *stb;
586 struct cleanup *old_chain, *list_chain;
588 stb = ui_out_stream_new (uiout);
589 old_chain = make_cleanup_ui_out_stream_delete (stb);
591 func = find_pc_function (get_frame_address_in_block (frame));
594 /* In certain pathological cases, the symtabs give the wrong
595 function (when we are in the first function in a file which
596 is compiled without debugging symbols, the previous function
597 is compiled with debugging symbols, and the "foo.o" symbol
598 that is supposed to tell us where the file with debugging
599 symbols ends has been truncated by ar because it is longer
600 than 15 characters). This also occurs if the user uses asm()
601 to create a function but not stabs for it (in a file compiled
604 So look in the minimal symbol tables as well, and if it comes
605 up with a larger address for the function use that instead.
606 I don't think this can ever cause any problems; there
607 shouldn't be any minimal symbols in the middle of a function;
608 if this is ever changed many parts of GDB will need to be
609 changed (and we'll create a find_pc_minimal_function or some
612 struct minimal_symbol *msymbol =
613 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
616 && (SYMBOL_VALUE_ADDRESS (msymbol)
617 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
619 /* We also don't know anything about the function besides
620 its address and name. */
622 funname = SYMBOL_PRINT_NAME (msymbol);
623 funlang = SYMBOL_LANGUAGE (msymbol);
627 funname = SYMBOL_PRINT_NAME (func);
628 funlang = SYMBOL_LANGUAGE (func);
629 if (funlang == language_cplus)
631 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
632 to display the demangled name that we already have
633 stored in the symbol table, but we stored a version
634 with DMGL_PARAMS turned on, and here we don't want to
635 display parameters. So remove the parameters. */
636 char *func_only = cp_remove_params (funname);
640 make_cleanup (xfree, func_only);
647 struct minimal_symbol *msymbol =
648 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
652 funname = SYMBOL_PRINT_NAME (msymbol);
653 funlang = SYMBOL_LANGUAGE (msymbol);
657 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
658 get_frame_pc (frame));
660 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
664 ui_out_text (uiout, "#");
665 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
666 frame_relative_level (frame));
669 if (get_frame_pc (frame) != sal.pc || !sal.symtab
670 || print_what == LOC_AND_ADDRESS)
672 annotate_frame_address ();
673 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
674 annotate_frame_address_end ();
675 ui_out_text (uiout, " in ");
677 annotate_frame_function_name ();
678 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
680 ui_out_field_stream (uiout, "func", stb);
681 ui_out_wrap_hint (uiout, " ");
682 annotate_frame_args ();
684 ui_out_text (uiout, " (");
687 struct print_args_args args;
688 struct cleanup *args_list_chain;
691 args.stream = gdb_stdout;
692 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
693 catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
694 /* FIXME: ARGS must be a list. If one argument is a string it
695 will have " that will not be properly escaped. */
696 /* Invoke ui_out_tuple_end. */
697 do_cleanups (args_list_chain);
700 ui_out_text (uiout, ")");
701 if (sal.symtab && sal.symtab->filename)
703 annotate_frame_source_begin ();
704 ui_out_wrap_hint (uiout, " ");
705 ui_out_text (uiout, " at ");
706 annotate_frame_source_file ();
707 ui_out_field_string (uiout, "file", sal.symtab->filename);
708 if (ui_out_is_mi_like_p (uiout))
710 const char *fullname = symtab_to_fullname (sal.symtab);
711 if (fullname != NULL)
712 ui_out_field_string (uiout, "fullname", fullname);
714 annotate_frame_source_file_end ();
715 ui_out_text (uiout, ":");
716 annotate_frame_source_line ();
717 ui_out_field_int (uiout, "line", sal.line);
718 annotate_frame_source_end ();
721 if (!funname || (!sal.symtab || !sal.symtab->filename))
724 char *lib = PC_SOLIB (get_frame_pc (frame));
726 char *lib = solib_address (get_frame_pc (frame));
730 annotate_frame_where ();
731 ui_out_wrap_hint (uiout, " ");
732 ui_out_text (uiout, " from ");
733 ui_out_field_string (uiout, "from", lib);
737 /* do_cleanups will call ui_out_tuple_end() for us. */
738 do_cleanups (list_chain);
739 ui_out_text (uiout, "\n");
740 do_cleanups (old_chain);
744 /* Read a frame specification in whatever the appropriate format is
745 from FRAME_EXP. Call error(), printing MESSAGE, if the
746 specification is in any way invalid (so this function never returns
747 NULL). When SEPECTED_P is non-NULL set its target to indicate that
748 the default selected frame was used. */
750 static struct frame_info *
751 parse_frame_specification_1 (const char *frame_exp, const char *message,
752 int *selected_frame_p)
755 struct value *args[4];
756 CORE_ADDR addrs[ARRAY_SIZE (args)];
758 if (frame_exp == NULL)
763 struct cleanup *tmp_cleanup;
769 struct cleanup *cleanup;
772 /* Skip leading white space, bail of EOL. */
773 while (isspace (*frame_exp))
778 /* Parse the argument, extract it, save it. */
782 addr_string = savestring (frame_exp, p - frame_exp);
784 cleanup = make_cleanup (xfree, addr_string);
786 /* NOTE: Parse and evaluate expression, but do not use
787 functions such as parse_and_eval_long or
788 parse_and_eval_address to also extract the value.
789 Instead value_as_long and value_as_address are used.
790 This avoids problems with expressions that contain
792 if (numargs >= ARRAY_SIZE (args))
793 error (_("Too many args in frame specification"));
794 args[numargs++] = parse_and_eval (addr_string);
796 do_cleanups (cleanup);
800 /* If no args, default to the selected frame. */
803 if (selected_frame_p != NULL)
804 (*selected_frame_p) = 1;
805 return get_selected_frame (message);
808 /* None of the remaining use the selected frame. */
809 if (selected_frame_p != NULL)
810 (*selected_frame_p) = 0;
812 /* Assume the single arg[0] is an integer, and try using that to
813 select a frame relative to current. */
816 struct frame_info *fid;
817 int level = value_as_long (args[0]);
818 fid = find_relative_frame (get_current_frame (), &level);
820 /* find_relative_frame was successful */
824 /* Convert each value into a corresponding address. */
827 for (i = 0; i < numargs; i++)
828 addrs[i] = value_as_address (args[0]);
831 /* Assume that the single arg[0] is an address, use that to identify
832 a frame with a matching ID. Should this also accept stack/pc or
836 struct frame_id id = frame_id_build_wild (addrs[0]);
837 struct frame_info *fid;
839 /* If (s)he specifies the frame with an address, he deserves
840 what (s)he gets. Still, give the highest one that matches.
841 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
843 for (fid = get_current_frame ();
845 fid = get_prev_frame (fid))
847 if (frame_id_eq (id, get_frame_id (fid)))
849 while (frame_id_eq (id, frame_unwind_id (fid)))
850 fid = get_prev_frame (fid);
856 /* We couldn't identify the frame as an existing frame, but
857 perhaps we can create one with a single argument. */
859 return create_new_frame (addrs[0], 0);
860 else if (numargs == 2)
861 return create_new_frame (addrs[0], addrs[1]);
863 error (_("Too many args in frame specification"));
866 static struct frame_info *
867 parse_frame_specification (char *frame_exp)
869 return parse_frame_specification_1 (frame_exp, NULL, NULL);
872 /* Print verbosely the selected frame or the frame at address
873 ADDR_EXP. Absolutely all information in the frame is printed. */
876 frame_info (char *addr_exp, int from_tty)
878 struct frame_info *fi;
879 struct symtab_and_line sal;
882 struct frame_info *calling_frame_info;
883 int i, count, numregs;
885 enum language funlang = language_unknown;
886 const char *pc_regname;
887 int selected_frame_p;
888 struct gdbarch *gdbarch;
889 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
891 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
892 gdbarch = get_frame_arch (fi);
894 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
895 is not a good name. */
896 if (gdbarch_pc_regnum (gdbarch) >= 0)
897 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
898 easily not match that of the internal value returned by
900 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
902 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
903 architectures will often have a hardware register called "pc",
904 and that register's value, again, can easily not match
908 find_frame_sal (fi, &sal);
909 func = get_frame_function (fi);
910 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
912 s = find_pc_symtab (get_frame_pc (fi));
915 funname = SYMBOL_PRINT_NAME (func);
916 funlang = SYMBOL_LANGUAGE (func);
917 if (funlang == language_cplus)
919 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
920 to display the demangled name that we already have
921 stored in the symbol table, but we stored a version
922 with DMGL_PARAMS turned on, and here we don't want to
923 display parameters. So remove the parameters. */
924 char *func_only = cp_remove_params (funname);
928 make_cleanup (xfree, func_only);
934 struct minimal_symbol *msymbol;
936 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
939 funname = SYMBOL_PRINT_NAME (msymbol);
940 funlang = SYMBOL_LANGUAGE (msymbol);
943 calling_frame_info = get_prev_frame (fi);
945 if (selected_frame_p && frame_relative_level (fi) >= 0)
947 printf_filtered (_("Stack level %d, frame at "),
948 frame_relative_level (fi));
952 printf_filtered (_("Stack frame at "));
954 fputs_filtered (paddress (get_frame_base (fi)), gdb_stdout);
955 printf_filtered (":\n");
956 printf_filtered (" %s = ", pc_regname);
957 fputs_filtered (paddress (get_frame_pc (fi)), gdb_stdout);
962 printf_filtered (" in ");
963 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
964 DMGL_ANSI | DMGL_PARAMS);
968 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
969 puts_filtered ("; ");
971 printf_filtered ("saved %s ", pc_regname);
972 fputs_filtered (paddress (frame_pc_unwind (fi)), gdb_stdout);
973 printf_filtered ("\n");
975 if (calling_frame_info == NULL)
977 enum unwind_stop_reason reason;
979 reason = get_frame_unwind_stop_reason (fi);
980 if (reason != UNWIND_NO_REASON)
981 printf_filtered (_(" Outermost frame: %s\n"),
982 frame_stop_reason_string (reason));
985 if (calling_frame_info)
987 printf_filtered (" called by frame at ");
988 fputs_filtered (paddress (get_frame_base (calling_frame_info)),
991 if (get_next_frame (fi) && calling_frame_info)
994 if (get_next_frame (fi))
996 printf_filtered (" caller of frame at ");
997 fputs_filtered (paddress (get_frame_base (get_next_frame (fi))),
1000 if (get_next_frame (fi) || calling_frame_info)
1001 puts_filtered ("\n");
1004 printf_filtered (" source language %s.\n",
1005 language_str (s->language));
1008 /* Address of the argument list for this frame, or 0. */
1009 CORE_ADDR arg_list = get_frame_args_address (fi);
1010 /* Number of args for this frame, or -1 if unknown. */
1014 printf_filtered (" Arglist at unknown address.\n");
1017 printf_filtered (" Arglist at ");
1018 fputs_filtered (paddress (arg_list), gdb_stdout);
1019 printf_filtered (",");
1021 if (!gdbarch_frame_num_args_p (gdbarch))
1024 puts_filtered (" args: ");
1028 numargs = gdbarch_frame_num_args (gdbarch, fi);
1029 gdb_assert (numargs >= 0);
1031 puts_filtered (" no args.");
1032 else if (numargs == 1)
1033 puts_filtered (" 1 arg: ");
1035 printf_filtered (" %d args: ", numargs);
1037 print_frame_args (func, fi, numargs, gdb_stdout);
1038 puts_filtered ("\n");
1042 /* Address of the local variables for this frame, or 0. */
1043 CORE_ADDR arg_list = get_frame_locals_address (fi);
1046 printf_filtered (" Locals at unknown address,");
1049 printf_filtered (" Locals at ");
1050 fputs_filtered (paddress (arg_list), gdb_stdout);
1051 printf_filtered (",");
1055 /* Print as much information as possible on the location of all the
1058 enum lval_type lval;
1066 /* The sp is special; what's displayed isn't the save address, but
1067 the value of the previous frame's sp. This is a legacy thing,
1068 at one stage the frame cached the previous frame's SP instead
1069 of its address, hence it was easiest to just display the cached
1071 if (gdbarch_sp_regnum (gdbarch) >= 0)
1073 /* Find out the location of the saved stack pointer with out
1074 actually evaluating it. */
1075 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1076 &optimized, &lval, &addr,
1078 if (!optimized && lval == not_lval)
1080 gdb_byte value[MAX_REGISTER_SIZE];
1082 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1083 &optimized, &lval, &addr,
1085 /* NOTE: cagney/2003-05-22: This is assuming that the
1086 stack pointer was packed as an unsigned integer. That
1087 may or may not be valid. */
1088 sp = extract_unsigned_integer (value,
1089 register_size (gdbarch,
1090 gdbarch_sp_regnum (gdbarch)));
1091 printf_filtered (" Previous frame's sp is ");
1092 fputs_filtered (paddress (sp), gdb_stdout);
1093 printf_filtered ("\n");
1096 else if (!optimized && lval == lval_memory)
1098 printf_filtered (" Previous frame's sp at ");
1099 fputs_filtered (paddress (addr), gdb_stdout);
1100 printf_filtered ("\n");
1103 else if (!optimized && lval == lval_register)
1105 printf_filtered (" Previous frame's sp in %s\n",
1106 gdbarch_register_name (gdbarch, realnum));
1109 /* else keep quiet. */
1113 numregs = gdbarch_num_regs (gdbarch)
1114 + gdbarch_num_pseudo_regs (gdbarch);
1115 for (i = 0; i < numregs; i++)
1116 if (i != gdbarch_sp_regnum (gdbarch)
1117 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1119 /* Find out the location of the saved register without
1120 fetching the corresponding value. */
1121 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1123 /* For moment, only display registers that were saved on the
1125 if (!optimized && lval == lval_memory)
1128 puts_filtered (" Saved registers:\n ");
1130 puts_filtered (",");
1132 printf_filtered (" %s at ",
1133 gdbarch_register_name (gdbarch, i));
1134 fputs_filtered (paddress (addr), gdb_stdout);
1138 if (count || need_nl)
1139 puts_filtered ("\n");
1142 do_cleanups (back_to);
1145 /* Print briefly all stack frames or just the innermost COUNT_EXP
1149 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1151 struct frame_info *fi;
1154 struct frame_info *trailing;
1157 if (!target_has_stack)
1158 error (_("No stack."));
1160 /* The following code must do two things. First, it must set the
1161 variable TRAILING to the frame from which we should start
1162 printing. Second, it must set the variable count to the number
1163 of frames which we should print, or -1 if all of them. */
1164 trailing = get_current_frame ();
1166 /* The target can be in a state where there is no valid frames
1167 (e.g., just connected). */
1168 if (trailing == NULL)
1169 error (_("No stack."));
1174 count = parse_and_eval_long (count_exp);
1177 struct frame_info *current;
1182 while (current && count--)
1185 current = get_prev_frame (current);
1188 /* Will stop when CURRENT reaches the top of the stack.
1189 TRAILING will be COUNT below it. */
1193 trailing = get_prev_frame (trailing);
1194 current = get_prev_frame (current);
1206 struct partial_symtab *ps;
1208 /* Read in symbols for all of the frames. Need to do this in a
1209 separate pass so that "Reading in symbols for xxx" messages
1210 don't screw up the appearance of the backtrace. Also if
1211 people have strong opinions against reading symbols for
1212 backtrace this may have to be an option. */
1214 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1217 ps = find_pc_psymtab (get_frame_address_in_block (fi));
1219 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
1223 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1227 /* Don't use print_stack_frame; if an error() occurs it probably
1228 means further attempts to backtrace would fail (on the other
1229 hand, perhaps the code does or could be fixed to make sure
1230 the frame->prev field gets set to NULL in that case). */
1231 print_frame_info (fi, 1, LOCATION, 1);
1233 print_frame_local_vars (fi, 1, gdb_stdout);
1235 /* Save the last frame to check for error conditions. */
1239 /* If we've stopped before the end, mention that. */
1241 printf_filtered (_("(More stack frames follow...)\n"));
1243 /* If we've run out of frames, and the reason appears to be an error
1244 condition, print it. */
1245 if (fi == NULL && trailing != NULL)
1247 enum unwind_stop_reason reason;
1249 reason = get_frame_unwind_stop_reason (trailing);
1250 if (reason > UNWIND_FIRST_ERROR)
1251 printf_filtered (_("Backtrace stopped: %s\n"),
1252 frame_stop_reason_string (reason));
1256 struct backtrace_command_args
1263 /* Stub for catch_errors. */
1266 backtrace_command_stub (void *data)
1268 struct backtrace_command_args *args = data;
1269 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1274 backtrace_command (char *arg, int from_tty)
1276 struct cleanup *old_chain = NULL;
1277 int fulltrace_arg = -1, arglen = 0, argc = 0;
1278 struct backtrace_command_args btargs;
1285 argv = buildargv (arg);
1286 old_chain = make_cleanup_freeargv (argv);
1288 for (i = 0; argv[i]; i++)
1292 for (j = 0; j < strlen (argv[i]); j++)
1293 argv[i][j] = tolower (argv[i][j]);
1295 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1296 fulltrace_arg = argc;
1299 arglen += strlen (argv[i]);
1304 if (fulltrace_arg >= 0)
1308 arg = xmalloc (arglen + 1);
1309 memset (arg, 0, arglen + 1);
1310 for (i = 0; i < (argc + 1); i++)
1312 if (i != fulltrace_arg)
1314 strcat (arg, argv[i]);
1324 btargs.count_exp = arg;
1325 btargs.show_locals = (fulltrace_arg >= 0);
1326 btargs.from_tty = from_tty;
1327 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1329 if (fulltrace_arg >= 0 && arglen > 0)
1333 do_cleanups (old_chain);
1337 backtrace_full_command (char *arg, int from_tty)
1339 struct backtrace_command_args btargs;
1340 btargs.count_exp = arg;
1341 btargs.show_locals = 1;
1342 btargs.from_tty = from_tty;
1343 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1347 /* Print the local variables of a block B active in FRAME on STREAM.
1348 Return 1 if any variables were printed; 0 otherwise. */
1351 print_block_frame_locals (struct block *b, struct frame_info *frame,
1352 int num_tabs, struct ui_file *stream)
1354 struct dict_iterator iter;
1356 int values_printed = 0;
1359 ALL_BLOCK_SYMBOLS (b, iter, sym)
1361 switch (SYMBOL_CLASS (sym))
1367 if (SYMBOL_IS_ARGUMENT (sym))
1370 for (j = 0; j < num_tabs; j++)
1371 fputs_filtered ("\t", stream);
1372 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1373 fputs_filtered (" = ", stream);
1374 print_variable_value (sym, frame, stream);
1375 fprintf_filtered (stream, "\n");
1379 /* Ignore symbols which are not locals. */
1384 return values_printed;
1387 /* Same, but print labels. */
1390 print_block_frame_labels (struct block *b, int *have_default,
1391 struct ui_file *stream)
1393 struct dict_iterator iter;
1395 int values_printed = 0;
1397 ALL_BLOCK_SYMBOLS (b, iter, sym)
1399 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1405 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1407 struct symtab_and_line sal;
1408 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1410 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1413 fprintf_filtered (stream, " ");
1414 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream);
1416 fprintf_filtered (stream, " in file %s, line %d\n",
1417 sal.symtab->filename, sal.line);
1421 return values_printed;
1424 /* Print on STREAM all the local variables in frame FRAME, including
1425 all the blocks active in that frame at its current PC.
1427 Returns 1 if the job was done, or 0 if nothing was printed because
1428 we have no info on the function running in FRAME. */
1431 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1432 struct ui_file *stream)
1434 struct block *block = get_frame_block (frame, 0);
1435 int values_printed = 0;
1439 fprintf_filtered (stream, "No symbol table info available.\n");
1445 if (print_block_frame_locals (block, frame, num_tabs, stream))
1447 /* After handling the function's top-level block, stop. Don't
1448 continue to its superblock, the block of per-file symbols. */
1449 if (BLOCK_FUNCTION (block))
1451 block = BLOCK_SUPERBLOCK (block);
1454 if (!values_printed)
1455 fprintf_filtered (stream, _("No locals.\n"));
1458 /* Same, but print labels. */
1461 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1462 struct ui_file *stream)
1465 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1467 struct blockvector *bl;
1468 struct block *block = get_frame_block (frame, 0);
1469 int values_printed = 0;
1470 int index, have_default = 0;
1471 char *blocks_printed;
1472 CORE_ADDR pc = get_frame_pc (frame);
1476 fprintf_filtered (stream, "No symbol table info available.\n");
1480 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1481 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1482 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1486 CORE_ADDR end = BLOCK_END (block) - 4;
1489 if (bl != blockvector_for_pc (end, &index))
1490 error (_("blockvector blotch"));
1491 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1492 error (_("blockvector botch"));
1493 last_index = BLOCKVECTOR_NBLOCKS (bl);
1496 /* Don't print out blocks that have gone by. */
1497 while (index < last_index
1498 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1501 while (index < last_index
1502 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1504 if (blocks_printed[index] == 0)
1506 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index),
1507 &have_default, stream))
1509 blocks_printed[index] = 1;
1515 if (values_printed && this_level_only)
1518 /* After handling the function's top-level block, stop. Don't
1519 continue to its superblock, the block of per-file symbols. */
1520 if (BLOCK_FUNCTION (block))
1522 block = BLOCK_SUPERBLOCK (block);
1525 if (!values_printed && !this_level_only)
1526 fprintf_filtered (stream, _("No catches.\n"));
1531 locals_info (char *args, int from_tty)
1533 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1538 catch_info (char *ignore, int from_tty)
1540 struct symtab_and_line *sal;
1542 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1543 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1548 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1550 struct symbol *func = get_frame_function (frame);
1552 struct dict_iterator iter;
1553 struct symbol *sym, *sym2;
1554 int values_printed = 0;
1558 fprintf_filtered (stream, _("No symbol table info available.\n"));
1562 b = SYMBOL_BLOCK_VALUE (func);
1563 ALL_BLOCK_SYMBOLS (b, iter, sym)
1565 /* Don't worry about things which aren't arguments. */
1566 if (SYMBOL_IS_ARGUMENT (sym))
1569 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1570 fputs_filtered (" = ", stream);
1572 /* We have to look up the symbol because arguments can have
1573 two entries (one a parameter, one a local) and the one we
1574 want is the local, which lookup_symbol will find for us.
1575 This includes gcc1 (not gcc2) on the sparc when passing a
1576 small structure and gcc2 when the argument type is float
1577 and it is passed as a double and converted to float by
1578 the prologue (in the latter case the type of the LOC_ARG
1579 symbol is double and the type of the LOC_LOCAL symbol is
1580 float). There are also LOC_ARG/LOC_REGISTER pairs which
1581 are not combined in symbol-reading. */
1583 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
1584 b, VAR_DOMAIN, NULL);
1585 print_variable_value (sym2, frame, stream);
1586 fprintf_filtered (stream, "\n");
1590 if (!values_printed)
1591 fprintf_filtered (stream, _("No arguments.\n"));
1595 args_info (char *ignore, int from_tty)
1597 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1603 args_plus_locals_info (char *ignore, int from_tty)
1605 args_info (ignore, from_tty);
1606 locals_info (ignore, from_tty);
1610 /* Select frame FRAME. Also print the stack frame and show the source
1611 if this is the tui version. */
1613 select_and_print_frame (struct frame_info *frame)
1615 select_frame (frame);
1617 print_stack_frame (frame, 1, SRC_AND_LOC);
1620 /* Return the symbol-block in which the selected frame is executing.
1621 Can return zero under various legitimate circumstances.
1623 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1624 code address within the block returned. We use this to decide
1625 which macros are in scope. */
1628 get_selected_block (CORE_ADDR *addr_in_block)
1630 if (!target_has_stack)
1633 if (is_exited (inferior_ptid))
1636 if (is_executing (inferior_ptid))
1639 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1642 /* Find a frame a certain number of levels away from FRAME.
1643 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1644 Positive means go to earlier frames (up); negative, the reverse.
1645 The int that contains the number of levels is counted toward
1646 zero as the frames for those levels are found.
1647 If the top or bottom frame is reached, that frame is returned,
1648 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1649 how much farther the original request asked to go. */
1652 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1654 /* Going up is simple: just call get_prev_frame enough times or
1655 until the initial frame is reached. */
1656 while (*level_offset_ptr > 0)
1658 struct frame_info *prev = get_prev_frame (frame);
1661 (*level_offset_ptr)--;
1665 /* Going down is just as simple. */
1666 while (*level_offset_ptr < 0)
1668 struct frame_info *next = get_next_frame (frame);
1671 (*level_offset_ptr)++;
1678 /* The "select_frame" command. With no argument this is a NOP.
1679 Select the frame at level LEVEL_EXP if it is a valid level.
1680 Otherwise, treat LEVEL_EXP as an address expression and select it.
1682 See parse_frame_specification for more info on proper frame
1686 select_frame_command (char *level_exp, int from_tty)
1688 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1691 /* The "frame" command. With no argument, print the selected frame
1692 briefly. With an argument, behave like select_frame and then print
1693 the selected frame. */
1696 frame_command (char *level_exp, int from_tty)
1698 select_frame_command (level_exp, from_tty);
1699 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1702 /* The XDB Compatibility command to print the current frame. */
1705 current_frame_command (char *level_exp, int from_tty)
1707 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1710 /* Select the frame up one or COUNT_EXP stack levels from the
1711 previously selected frame, and print it briefly. */
1714 up_silently_base (char *count_exp)
1716 struct frame_info *frame;
1720 count = parse_and_eval_long (count_exp);
1722 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1723 if (count != 0 && count_exp == NULL)
1724 error (_("Initial frame selected; you cannot go up."));
1725 select_frame (frame);
1729 up_silently_command (char *count_exp, int from_tty)
1731 up_silently_base (count_exp);
1735 up_command (char *count_exp, int from_tty)
1737 up_silently_base (count_exp);
1738 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1741 /* Select the frame down one or COUNT_EXP stack levels from the previously
1742 selected frame, and print it briefly. */
1745 down_silently_base (char *count_exp)
1747 struct frame_info *frame;
1750 count = -parse_and_eval_long (count_exp);
1752 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1753 if (count != 0 && count_exp == NULL)
1755 /* We only do this if COUNT_EXP is not specified. That way
1756 "down" means to really go down (and let me know if that is
1757 impossible), but "down 9999" can be used to mean go all the
1758 way down without getting an error. */
1760 error (_("Bottom (innermost) frame selected; you cannot go down."));
1763 select_frame (frame);
1767 down_silently_command (char *count_exp, int from_tty)
1769 down_silently_base (count_exp);
1773 down_command (char *count_exp, int from_tty)
1775 down_silently_base (count_exp);
1776 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1781 return_command (char *retval_exp, int from_tty)
1783 struct symbol *thisfun;
1784 struct value *return_value = NULL;
1785 const char *query_prefix = "";
1787 thisfun = get_frame_function (get_selected_frame ("No selected frame."));
1789 /* Compute the return value. If the computation triggers an error,
1790 let it bail. If the return type can't be handled, set
1791 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1795 struct type *return_type = NULL;
1797 /* Compute the return value. Should the computation fail, this
1798 call throws an error. */
1799 return_value = parse_and_eval (retval_exp);
1801 /* Cast return value to the return type of the function. Should
1802 the cast fail, this call throws an error. */
1803 if (thisfun != NULL)
1804 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1805 if (return_type == NULL)
1806 return_type = builtin_type_int;
1807 CHECK_TYPEDEF (return_type);
1808 return_value = value_cast (return_type, return_value);
1810 /* Make sure the value is fully evaluated. It may live in the
1811 stack frame we're about to pop. */
1812 if (value_lazy (return_value))
1813 value_fetch_lazy (return_value);
1815 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1816 /* If the return-type is "void", don't try to find the
1817 return-value's location. However, do still evaluate the
1818 return expression so that, even when the expression result
1819 is discarded, side effects such as "return i++" still
1821 return_value = NULL;
1822 else if (using_struct_return (SYMBOL_TYPE (thisfun), return_type))
1825 The location at which to store the function's return value is unknown.\n\
1826 If you continue, the return value that you specified will be ignored.\n";
1827 return_value = NULL;
1831 /* Does an interactive user really want to do this? Include
1832 information, such as how well GDB can handle the return value, in
1833 the query message. */
1837 if (thisfun == NULL)
1838 confirmed = query (_("%sMake selected stack frame return now? "),
1841 confirmed = query (_("%sMake %s return now? "), query_prefix,
1842 SYMBOL_PRINT_NAME (thisfun));
1844 error (_("Not confirmed"));
1847 /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
1848 frame in turn, should this code just go straight to the relevant
1849 frame and pop that? */
1851 /* First discard all frames inner-to the selected frame (making the
1852 selected frame current). */
1854 struct frame_id selected_id = get_frame_id (get_selected_frame (NULL));
1855 while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ())))
1857 struct frame_info *frame = get_current_frame ();
1858 if (frame_id_inner (get_frame_arch (frame), selected_id,
1859 get_frame_id (frame)))
1860 /* Caught in the safety net, oops! We've gone way past the
1862 error (_("Problem while popping stack frames (corrupt stack?)"));
1863 frame_pop (get_current_frame ());
1867 /* Second discard the selected frame (which is now also the current
1869 frame_pop (get_current_frame ());
1871 /* Store RETURN_VALUE in the just-returned register set. */
1872 if (return_value != NULL)
1874 struct type *return_type = value_type (return_value);
1875 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
1876 gdb_assert (gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun),
1877 return_type, NULL, NULL, NULL)
1878 == RETURN_VALUE_REGISTER_CONVENTION);
1879 gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun), return_type,
1880 get_current_regcache (), NULL /*read*/,
1881 value_contents (return_value) /*write*/);
1884 /* If we are at the end of a call dummy now, pop the dummy frame
1886 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1887 frame_pop (get_current_frame ());
1889 /* If interactive, print the frame that is now current. */
1891 frame_command ("0", 1);
1893 select_frame_command ("0", 0);
1896 /* Sets the scope to input function name, provided that the function
1897 is within the current stack frame */
1899 struct function_bounds
1901 CORE_ADDR low, high;
1905 func_command (char *arg, int from_tty)
1907 struct frame_info *frame;
1909 struct symtabs_and_lines sals;
1912 struct function_bounds *func_bounds = NULL;
1917 frame = parse_frame_specification ("0");
1918 sals = decode_line_spec (arg, 1);
1919 func_bounds = (struct function_bounds *) xmalloc (
1920 sizeof (struct function_bounds) * sals.nelts);
1921 for (i = 0; (i < sals.nelts && !found); i++)
1923 if (sals.sals[i].pc == 0
1924 || find_pc_partial_function (sals.sals[i].pc, NULL,
1925 &func_bounds[i].low,
1926 &func_bounds[i].high) == 0)
1928 func_bounds[i].low = func_bounds[i].high = 0;
1934 for (i = 0; (i < sals.nelts && !found); i++)
1935 found = (get_frame_pc (frame) >= func_bounds[i].low
1936 && get_frame_pc (frame) < func_bounds[i].high);
1940 frame = find_relative_frame (frame, &level);
1943 while (!found && level == 0);
1946 xfree (func_bounds);
1949 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
1950 else if (frame != get_selected_frame (NULL))
1951 select_and_print_frame (frame);
1954 /* Gets the language of the current frame. */
1957 get_frame_language (void)
1959 struct frame_info *frame = deprecated_safe_get_selected_frame ();
1963 /* We determine the current frame language by looking up its
1964 associated symtab. To retrieve this symtab, we use the frame
1965 PC. However we cannot use the frame PC as is, because it
1966 usually points to the instruction following the "call", which
1967 is sometimes the first instruction of another function. So
1968 we rely on get_frame_address_in_block(), it provides us with
1969 a PC that is guaranteed to be inside the frame's code
1971 CORE_ADDR pc = get_frame_address_in_block (frame);
1972 struct symtab *s = find_pc_symtab (pc);
1978 return language_unknown;
1982 /* Provide a prototype to silence -Wmissing-prototypes. */
1983 void _initialize_stack (void);
1986 _initialize_stack (void)
1989 backtrace_limit = 30;
1992 add_com ("return", class_stack, return_command, _("\
1993 Make selected stack frame return to its caller.\n\
1994 Control remains in the debugger, but when you continue\n\
1995 execution will resume in the frame above the one now selected.\n\
1996 If an argument is given, it is an expression for the value to return."));
1998 add_com ("up", class_stack, up_command, _("\
1999 Select and print stack frame that called this one.\n\
2000 An argument says how many frames up to go."));
2001 add_com ("up-silently", class_support, up_silently_command, _("\
2002 Same as the `up' command, but does not print anything.\n\
2003 This is useful in command scripts."));
2005 add_com ("down", class_stack, down_command, _("\
2006 Select and print stack frame called by this one.\n\
2007 An argument says how many frames down to go."));
2008 add_com_alias ("do", "down", class_stack, 1);
2009 add_com_alias ("dow", "down", class_stack, 1);
2010 add_com ("down-silently", class_support, down_silently_command, _("\
2011 Same as the `down' command, but does not print anything.\n\
2012 This is useful in command scripts."));
2014 add_com ("frame", class_stack, frame_command, _("\
2015 Select and print a stack frame.\n\
2016 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2017 An argument specifies the frame to select.\n\
2018 It can be a stack frame number or the address of the frame.\n\
2019 With argument, nothing is printed if input is coming from\n\
2020 a command file or a user-defined command."));
2022 add_com_alias ("f", "frame", class_stack, 1);
2026 add_com ("L", class_stack, current_frame_command,
2027 _("Print the current stack frame.\n"));
2028 add_com_alias ("V", "frame", class_stack, 1);
2030 add_com ("select-frame", class_stack, select_frame_command, _("\
2031 Select a stack frame without printing anything.\n\
2032 An argument specifies the frame to select.\n\
2033 It can be a stack frame number or the address of the frame.\n"));
2035 add_com ("backtrace", class_stack, backtrace_command, _("\
2036 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2037 With a negative argument, print outermost -COUNT frames.\n\
2038 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2039 add_com_alias ("bt", "backtrace", class_stack, 0);
2042 add_com_alias ("t", "backtrace", class_stack, 0);
2043 add_com ("T", class_stack, backtrace_full_command, _("\
2044 Print backtrace of all stack frames, or innermost COUNT frames \n\
2045 and the values of the local variables.\n\
2046 With a negative argument, print outermost -COUNT frames.\n\
2047 Usage: T <count>\n"));
2050 add_com_alias ("where", "backtrace", class_alias, 0);
2051 add_info ("stack", backtrace_command,
2052 _("Backtrace of the stack, or innermost COUNT frames."));
2053 add_info_alias ("s", "stack", 1);
2054 add_info ("frame", frame_info,
2055 _("All about selected stack frame, or frame at ADDR."));
2056 add_info_alias ("f", "frame", 1);
2057 add_info ("locals", locals_info,
2058 _("Local variables of current stack frame."));
2059 add_info ("args", args_info,
2060 _("Argument variables of current stack frame."));
2062 add_com ("l", class_info, args_plus_locals_info,
2063 _("Argument and local variables of current stack frame."));
2066 add_com ("func", class_stack, func_command, _("\
2067 Select the stack frame that contains <func>.\n\
2068 Usage: func <name>\n"));
2070 add_info ("catch", catch_info,
2071 _("Exceptions that can be caught in the current stack frame."));
2073 add_setshow_enum_cmd ("frame-arguments", class_stack,
2074 print_frame_arguments_choices, &print_frame_arguments,
2075 _("Set printing of non-scalar frame arguments"),
2076 _("Show printing of non-scalar frame arguments"),
2077 NULL, NULL, NULL, &setprintlist, &showprintlist);
2080 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2081 "Specify maximum number of frames for \"backtrace\" to print by default."),
2083 add_info ("backtrace-limit", backtrace_limit_info, _("\
2084 The maximum number of frames for \"backtrace\" to print by default."));