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"
48 #include "gdb_assert.h"
50 #include "gdb_string.h"
52 void (*deprecated_selected_frame_level_changed_hook) (int);
54 /* The possible choices of "set print frame-arguments, and the value
57 static const char *print_frame_arguments_choices[] =
58 {"all", "scalars", "none", NULL};
59 static const char *print_frame_arguments = "all";
61 /* Prototypes for local functions. */
63 static void print_frame_local_vars (struct frame_info *, int,
66 static void print_frame (struct frame_info *frame, int print_level,
67 enum print_what print_what, int print_args,
68 struct symtab_and_line sal);
70 /* Zero means do things normally; we are interacting directly with the
71 user. One means print the full filename and linenumber when a
72 frame is printed, and do so in a format emacs18/emacs19.22 can
73 parse. Two means print similar annotations, but in many more
74 cases and in a slightly different syntax. */
76 int annotation_level = 0;
79 struct print_stack_frame_args
81 struct frame_info *frame;
83 enum print_what print_what;
87 /* Show or print the frame arguments; stub for catch_errors. */
90 print_stack_frame_stub (void *args)
92 struct print_stack_frame_args *p = args;
93 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
95 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
96 set_current_sal_from_frame (p->frame, center);
100 /* Show or print a stack frame FRAME briefly. The output is format
101 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
102 relative level, function name, argument list, and file name and
103 line number. If the frame's PC is not at the beginning of the
104 source line, the actual PC is printed at the beginning. */
107 print_stack_frame (struct frame_info *frame, int print_level,
108 enum print_what print_what)
110 struct print_stack_frame_args args;
113 args.print_level = print_level;
114 args.print_what = print_what;
115 /* For mi, alway print location and address. */
116 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
119 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
122 struct print_args_args
125 struct frame_info *frame;
126 struct ui_file *stream;
129 static int print_args_stub (void *args);
131 /* Print nameless arguments of frame FRAME on STREAM, where START is
132 the offset of the first nameless argument, and NUM is the number of
133 nameless arguments to print. FIRST is nonzero if this is the first
134 argument (not just the first nameless argument). */
137 print_frame_nameless_args (struct frame_info *frame, long start, int num,
138 int first, struct ui_file *stream)
144 for (i = 0; i < num; i++)
147 argsaddr = get_frame_args_address (frame);
150 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
152 fprintf_filtered (stream, ", ");
153 fprintf_filtered (stream, "%ld", arg_value);
155 start += sizeof (int);
159 /* Return non-zero if the debugger should print the value of the provided
160 symbol parameter (SYM). */
163 print_this_frame_argument_p (struct symbol *sym)
167 /* If the user asked to print no argument at all, then obviously
168 do not print this argument. */
170 if (strcmp (print_frame_arguments, "none") == 0)
173 /* If the user asked to print all arguments, then we should print
176 if (strcmp (print_frame_arguments, "all") == 0)
179 /* The user asked to print only the scalar arguments, so do not
180 print the non-scalar ones. */
182 type = CHECK_TYPEDEF (SYMBOL_TYPE (sym));
183 while (TYPE_CODE (type) == TYPE_CODE_REF)
184 type = CHECK_TYPEDEF (TYPE_TARGET_TYPE (type));
185 switch (TYPE_CODE (type))
187 case TYPE_CODE_ARRAY:
188 case TYPE_CODE_STRUCT:
189 case TYPE_CODE_UNION:
191 case TYPE_CODE_STRING:
192 case TYPE_CODE_BITSTRING:
199 /* Print the arguments of frame FRAME on STREAM, given the function
200 FUNC running in that frame (as a symbol), where NUM is the number
201 of arguments according to the stack frame (or -1 if the number of
202 arguments is unknown). */
204 /* Note that currently the "number of argumentss according to the
205 stack frame" is only known on VAX where i refers to the "number of
206 ints of argumentss according to the stack frame". */
209 print_frame_args (struct symbol *func, struct frame_info *frame,
210 int num, struct ui_file *stream)
213 /* Offset of next stack argument beyond the one we have seen that is
214 at the highest offset, or -1 if we haven't come to a stack
216 long highest_offset = -1;
217 /* Number of ints of arguments that we have printed so far. */
218 int args_printed = 0;
219 struct cleanup *old_chain, *list_chain;
220 struct ui_stream *stb;
222 stb = ui_out_stream_new (uiout);
223 old_chain = make_cleanup_ui_out_stream_delete (stb);
227 struct block *b = SYMBOL_BLOCK_VALUE (func);
228 struct dict_iterator iter;
232 ALL_BLOCK_SYMBOLS (b, iter, sym)
236 /* Keep track of the highest stack argument offset seen, and
237 skip over any kinds of symbols we don't care about. */
239 if (!SYMBOL_IS_ARGUMENT (sym))
242 switch (SYMBOL_CLASS (sym))
247 long current_offset = SYMBOL_VALUE (sym);
248 int 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
258 if (highest_offset == -1
259 || (current_offset > highest_offset))
260 highest_offset = current_offset;
262 /* Add the number of ints we're about to print to
264 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
267 /* We care about types of symbols, but don't need to
268 keep track of stack offsets in them. */
270 case LOC_REGPARM_ADDR:
272 case LOC_OPTIMIZED_OUT:
277 /* We have to look up the symbol because arguments can have
278 two entries (one a parameter, one a local) and the one we
279 want is the local, which lookup_symbol will find for us.
280 This includes gcc1 (not gcc2) on SPARC when passing a
281 small structure and gcc2 when the argument type is float
282 and it is passed as a double and converted to float by
283 the prologue (in the latter case the type of the LOC_ARG
284 symbol is double and the type of the LOC_LOCAL symbol is
286 /* But if the parameter name is null, don't try it. Null
287 parameter names occur on the RS/6000, for traceback
288 tables. FIXME, should we even print them? */
290 if (*DEPRECATED_SYMBOL_NAME (sym))
293 nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
294 b, VAR_DOMAIN, NULL);
295 gdb_assert (nsym != NULL);
296 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
297 && !SYMBOL_IS_ARGUMENT (nsym))
299 /* There is a LOC_ARG/LOC_REGISTER pair. This means
300 that it was passed on the stack and loaded into a
301 register, or passed in a register and stored in a
302 stack slot. GDB 3.x used the LOC_ARG; GDB
303 4.0-4.11 used the LOC_REGISTER.
305 Reasons for using the LOC_ARG:
307 (1) Because find_saved_registers may be slow for
310 (2) Because registers are often re-used and stack
311 slots rarely (never?) are. Therefore using
312 the stack slot is much less likely to print
315 Reasons why we might want to use the LOC_REGISTER:
317 (1) So that the backtrace prints the same value
318 as "print foo". I see no compelling reason
319 why this needs to be the case; having the
320 backtrace print the value which was passed
321 in, and "print foo" print the value as
322 modified within the called function, makes
325 Additional note: It might be nice if "info args"
326 displayed both values.
328 One more note: There is a case with SPARC
329 structure passing where we need to use the
330 LOC_REGISTER, but this is dealt with by creating
331 a single LOC_REGPARM in symbol reading. */
333 /* Leave sym (the LOC_ARG) alone. */
340 /* Print the current arg. */
342 ui_out_text (uiout, ", ");
343 ui_out_wrap_hint (uiout, " ");
345 annotate_arg_begin ();
347 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
348 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
349 SYMBOL_LANGUAGE (sym),
350 DMGL_PARAMS | DMGL_ANSI);
351 ui_out_field_stream (uiout, "name", stb);
352 annotate_arg_name_end ();
353 ui_out_text (uiout, "=");
355 if (print_this_frame_argument_p (sym))
357 /* Avoid value_print because it will deref ref parameters.
358 We just want to print their addresses. Print ??? for
359 args whose address we do not know. We pass 2 as
360 "recurse" to val_print because our standard indentation
361 here is 4 spaces, and val_print indents 2 for each
363 val = read_var_value (sym, frame);
365 annotate_arg_value (val == NULL ? NULL : value_type (val));
369 const struct language_defn *language;
371 /* Use the appropriate language to display our symbol,
372 unless the user forced the language to a specific
374 if (language_mode == language_mode_auto)
375 language = language_def (SYMBOL_LANGUAGE (sym));
377 language = current_language;
379 common_val_print (val, stb->stream, 0, 0, 2,
380 Val_no_prettyprint, language);
381 ui_out_field_stream (uiout, "value", stb);
384 ui_out_text (uiout, "???");
387 ui_out_text (uiout, "...");
390 /* Invoke ui_out_tuple_end. */
391 do_cleanups (list_chain);
399 /* Don't print nameless args in situations where we don't know
400 enough about the stack to find them. */
405 if (highest_offset == -1)
406 start = gdbarch_frame_args_skip (get_frame_arch (frame));
408 start = highest_offset;
410 print_frame_nameless_args (frame, start, num - args_printed,
414 do_cleanups (old_chain);
417 /* Stub for catch_errors. */
420 print_args_stub (void *args)
422 struct print_args_args *p = args;
423 struct gdbarch *gdbarch = get_frame_arch (p->frame);
426 if (gdbarch_frame_num_args_p (gdbarch))
428 numargs = gdbarch_frame_num_args (gdbarch, p->frame);
429 gdb_assert (numargs >= 0);
433 print_frame_args (p->func, p->frame, numargs, p->stream);
437 /* Set the current source and line to the location given by frame
438 FRAME, if possible. When CENTER is true, adjust so the relevant
439 line is in the center of the next 'list'. */
442 set_current_sal_from_frame (struct frame_info *frame, int center)
444 struct symtab_and_line sal;
446 find_frame_sal (frame, &sal);
450 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
451 set_current_source_symtab_and_line (&sal);
455 /* Print information about frame FRAME. The output is format according
456 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
459 SRC_LINE: Print only source line.
460 LOCATION: Print only location.
461 LOC_AND_SRC: Print location and source line.
463 Used in "where" output, and to emit breakpoint or step
467 print_frame_info (struct frame_info *frame, int print_level,
468 enum print_what print_what, int print_args)
470 struct symtab_and_line sal;
474 if (get_frame_type (frame) == DUMMY_FRAME
475 || get_frame_type (frame) == SIGTRAMP_FRAME)
477 struct cleanup *uiout_cleanup
478 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
480 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
481 get_frame_pc (frame));
483 /* Do this regardless of SOURCE because we don't have any source
484 to list for this frame. */
487 ui_out_text (uiout, "#");
488 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
489 frame_relative_level (frame));
491 if (ui_out_is_mi_like_p (uiout))
493 annotate_frame_address ();
494 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
495 annotate_frame_address_end ();
498 if (get_frame_type (frame) == DUMMY_FRAME)
500 annotate_function_call ();
501 ui_out_field_string (uiout, "func", "<function called from gdb>");
503 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
505 annotate_signal_handler_caller ();
506 ui_out_field_string (uiout, "func", "<signal handler called>");
508 ui_out_text (uiout, "\n");
509 annotate_frame_end ();
511 do_cleanups (uiout_cleanup);
515 /* If FRAME is not the innermost frame, that normally means that
516 FRAME->pc points to *after* the call instruction, and we want to
517 get the line containing the call, never the next line. But if
518 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
519 next frame was not entered as the result of a call, and we want
520 to get the line containing FRAME->pc. */
521 find_frame_sal (frame, &sal);
523 location_print = (print_what == LOCATION
524 || print_what == LOC_AND_ADDRESS
525 || print_what == SRC_AND_LOC);
527 if (location_print || !sal.symtab)
528 print_frame (frame, print_level, print_what, print_args, sal);
530 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
532 if (source_print && sal.symtab)
535 int mid_statement = ((print_what == SRC_LINE)
536 && (get_frame_pc (frame) != sal.pc));
538 if (annotation_level)
539 done = identify_source_line (sal.symtab, sal.line, mid_statement,
540 get_frame_pc (frame));
543 if (deprecated_print_frame_info_listing_hook)
544 deprecated_print_frame_info_listing_hook (sal.symtab,
549 /* We used to do this earlier, but that is clearly
550 wrong. This function is used by many different
551 parts of gdb, including normal_stop in infrun.c,
552 which uses this to print out the current PC
553 when we stepi/nexti into the middle of a source
554 line. Only the command line really wants this
555 behavior. Other UIs probably would like the
556 ability to decide for themselves if it is desired. */
557 if (addressprint && mid_statement)
559 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
560 ui_out_text (uiout, "\t");
563 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
568 if (print_what != LOCATION)
569 set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line);
571 annotate_frame_end ();
573 gdb_flush (gdb_stdout);
577 print_frame (struct frame_info *frame, int print_level,
578 enum print_what print_what, int print_args,
579 struct symtab_and_line sal)
582 char *funname = NULL;
583 enum language funlang = language_unknown;
584 struct ui_stream *stb;
585 struct cleanup *old_chain, *list_chain;
587 stb = ui_out_stream_new (uiout);
588 old_chain = make_cleanup_ui_out_stream_delete (stb);
590 func = find_pc_function (get_frame_address_in_block (frame));
593 /* In certain pathological cases, the symtabs give the wrong
594 function (when we are in the first function in a file which
595 is compiled without debugging symbols, the previous function
596 is compiled with debugging symbols, and the "foo.o" symbol
597 that is supposed to tell us where the file with debugging
598 symbols ends has been truncated by ar because it is longer
599 than 15 characters). This also occurs if the user uses asm()
600 to create a function but not stabs for it (in a file compiled
603 So look in the minimal symbol tables as well, and if it comes
604 up with a larger address for the function use that instead.
605 I don't think this can ever cause any problems; there
606 shouldn't be any minimal symbols in the middle of a function;
607 if this is ever changed many parts of GDB will need to be
608 changed (and we'll create a find_pc_minimal_function or some
611 struct minimal_symbol *msymbol =
612 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
615 && (SYMBOL_VALUE_ADDRESS (msymbol)
616 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
618 /* We also don't know anything about the function besides
619 its address and name. */
621 funname = DEPRECATED_SYMBOL_NAME (msymbol);
622 funlang = SYMBOL_LANGUAGE (msymbol);
626 funname = DEPRECATED_SYMBOL_NAME (func);
627 funlang = SYMBOL_LANGUAGE (func);
628 if (funlang == language_cplus)
630 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
631 to display the demangled name that we already have
632 stored in the symbol table, but we stored a version
633 with DMGL_PARAMS turned on, and here we don't want to
634 display parameters. So call the demangler again, with
637 Yes, printf_symbol_filtered() will again try to
638 demangle the name on the fly, but the issue is that
639 if cplus_demangle() fails here, it will fail there
640 too. So we want to catch the failure (where DEMANGLED
641 is NULL below) here, while we still have our hands on
642 the function symbol.) */
643 char *demangled = cplus_demangle (funname, DMGL_ANSI);
644 if (demangled == NULL)
645 /* If the demangler fails, try the demangled name from
646 the symbol table. That'll have parameters, but
647 that's preferable to displaying a mangled name. */
648 funname = SYMBOL_PRINT_NAME (func);
656 struct minimal_symbol *msymbol =
657 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
661 funname = DEPRECATED_SYMBOL_NAME (msymbol);
662 funlang = SYMBOL_LANGUAGE (msymbol);
666 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
667 get_frame_pc (frame));
669 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
673 ui_out_text (uiout, "#");
674 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
675 frame_relative_level (frame));
678 if (get_frame_pc (frame) != sal.pc || !sal.symtab
679 || print_what == LOC_AND_ADDRESS)
681 annotate_frame_address ();
682 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
683 annotate_frame_address_end ();
684 ui_out_text (uiout, " in ");
686 annotate_frame_function_name ();
687 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
689 ui_out_field_stream (uiout, "func", stb);
690 ui_out_wrap_hint (uiout, " ");
691 annotate_frame_args ();
693 ui_out_text (uiout, " (");
696 struct print_args_args args;
697 struct cleanup *args_list_chain;
700 args.stream = gdb_stdout;
701 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
702 catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
703 /* FIXME: ARGS must be a list. If one argument is a string it
704 will have " that will not be properly escaped. */
705 /* Invoke ui_out_tuple_end. */
706 do_cleanups (args_list_chain);
709 ui_out_text (uiout, ")");
710 if (sal.symtab && sal.symtab->filename)
712 annotate_frame_source_begin ();
713 ui_out_wrap_hint (uiout, " ");
714 ui_out_text (uiout, " at ");
715 annotate_frame_source_file ();
716 ui_out_field_string (uiout, "file", sal.symtab->filename);
717 if (ui_out_is_mi_like_p (uiout))
719 const char *fullname = symtab_to_fullname (sal.symtab);
720 if (fullname != NULL)
721 ui_out_field_string (uiout, "fullname", fullname);
723 annotate_frame_source_file_end ();
724 ui_out_text (uiout, ":");
725 annotate_frame_source_line ();
726 ui_out_field_int (uiout, "line", sal.line);
727 annotate_frame_source_end ();
730 if (!funname || (!sal.symtab || !sal.symtab->filename))
733 char *lib = PC_SOLIB (get_frame_pc (frame));
735 char *lib = solib_address (get_frame_pc (frame));
739 annotate_frame_where ();
740 ui_out_wrap_hint (uiout, " ");
741 ui_out_text (uiout, " from ");
742 ui_out_field_string (uiout, "from", lib);
746 /* do_cleanups will call ui_out_tuple_end() for us. */
747 do_cleanups (list_chain);
748 ui_out_text (uiout, "\n");
749 do_cleanups (old_chain);
753 /* Read a frame specification in whatever the appropriate format is
754 from FRAME_EXP. Call error(), printing MESSAGE, if the
755 specification is in any way invalid (so this function never returns
756 NULL). When SEPECTED_P is non-NULL set its target to indicate that
757 the default selected frame was used. */
759 static struct frame_info *
760 parse_frame_specification_1 (const char *frame_exp, const char *message,
761 int *selected_frame_p)
764 struct value *args[4];
765 CORE_ADDR addrs[ARRAY_SIZE (args)];
767 if (frame_exp == NULL)
772 struct cleanup *tmp_cleanup;
778 struct cleanup *cleanup;
781 /* Skip leading white space, bail of EOL. */
782 while (isspace (*frame_exp))
787 /* Parse the argument, extract it, save it. */
791 addr_string = savestring (frame_exp, p - frame_exp);
793 cleanup = make_cleanup (xfree, addr_string);
795 /* NOTE: Parse and evaluate expression, but do not use
796 functions such as parse_and_eval_long or
797 parse_and_eval_address to also extract the value.
798 Instead value_as_long and value_as_address are used.
799 This avoids problems with expressions that contain
801 if (numargs >= ARRAY_SIZE (args))
802 error (_("Too many args in frame specification"));
803 args[numargs++] = parse_and_eval (addr_string);
805 do_cleanups (cleanup);
809 /* If no args, default to the selected frame. */
812 if (selected_frame_p != NULL)
813 (*selected_frame_p) = 1;
814 return get_selected_frame (message);
817 /* None of the remaining use the selected frame. */
818 if (selected_frame_p != NULL)
819 (*selected_frame_p) = 0;
821 /* Assume the single arg[0] is an integer, and try using that to
822 select a frame relative to current. */
825 struct frame_info *fid;
826 int level = value_as_long (args[0]);
827 fid = find_relative_frame (get_current_frame (), &level);
829 /* find_relative_frame was successful */
833 /* Convert each value into a corresponding address. */
836 for (i = 0; i < numargs; i++)
837 addrs[i] = value_as_address (args[0]);
840 /* Assume that the single arg[0] is an address, use that to identify
841 a frame with a matching ID. Should this also accept stack/pc or
845 struct frame_id id = frame_id_build_wild (addrs[0]);
846 struct frame_info *fid;
848 /* If (s)he specifies the frame with an address, he deserves
849 what (s)he gets. Still, give the highest one that matches.
850 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
852 for (fid = get_current_frame ();
854 fid = get_prev_frame (fid))
856 if (frame_id_eq (id, get_frame_id (fid)))
858 struct frame_info *prev_frame;
862 prev_frame = get_prev_frame (fid);
864 || !frame_id_eq (id, get_frame_id (prev_frame)))
873 /* We couldn't identify the frame as an existing frame, but
874 perhaps we can create one with a single argument. */
876 return create_new_frame (addrs[0], 0);
877 else if (numargs == 2)
878 return create_new_frame (addrs[0], addrs[1]);
880 error (_("Too many args in frame specification"));
883 static struct frame_info *
884 parse_frame_specification (char *frame_exp)
886 return parse_frame_specification_1 (frame_exp, NULL, NULL);
889 /* Print verbosely the selected frame or the frame at address
890 ADDR_EXP. Absolutely all information in the frame is printed. */
893 frame_info (char *addr_exp, int from_tty)
895 struct frame_info *fi;
896 struct symtab_and_line sal;
899 struct frame_info *calling_frame_info;
900 int i, count, numregs;
902 enum language funlang = language_unknown;
903 const char *pc_regname;
904 int selected_frame_p;
905 struct gdbarch *gdbarch;
907 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
908 gdbarch = get_frame_arch (fi);
910 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
911 is not a good name. */
912 if (gdbarch_pc_regnum (gdbarch) >= 0)
913 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
914 easily not match that of the internal value returned by
916 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
918 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
919 architectures will often have a hardware register called "pc",
920 and that register's value, again, can easily not match
924 find_frame_sal (fi, &sal);
925 func = get_frame_function (fi);
926 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
928 s = find_pc_symtab (get_frame_pc (fi));
931 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to
932 display the demangled name that we already have stored in the
933 symbol table, but we stored a version with DMGL_PARAMS turned
934 on, and here we don't want to display parameters. So call the
935 demangler again, with DMGL_ANSI only.
937 Yes, printf_symbol_filtered() will again try to demangle the
938 name on the fly, but the issue is that if cplus_demangle()
939 fails here, it will fail there too. So we want to catch the
940 failure (where DEMANGLED is NULL below) here, while we still
941 have our hands on the function symbol.) */
942 funname = DEPRECATED_SYMBOL_NAME (func);
943 funlang = SYMBOL_LANGUAGE (func);
944 if (funlang == language_cplus)
946 char *demangled = cplus_demangle (funname, DMGL_ANSI);
947 /* If the demangler fails, try the demangled name from the
948 symbol table. That'll have parameters, but that's
949 preferable to displaying a mangled name. */
950 if (demangled == NULL)
951 funname = SYMBOL_PRINT_NAME (func);
958 struct minimal_symbol *msymbol;
960 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
963 funname = DEPRECATED_SYMBOL_NAME (msymbol);
964 funlang = SYMBOL_LANGUAGE (msymbol);
967 calling_frame_info = get_prev_frame (fi);
969 if (selected_frame_p && frame_relative_level (fi) >= 0)
971 printf_filtered (_("Stack level %d, frame at "),
972 frame_relative_level (fi));
976 printf_filtered (_("Stack frame at "));
978 fputs_filtered (paddress (get_frame_base (fi)), gdb_stdout);
979 printf_filtered (":\n");
980 printf_filtered (" %s = ", pc_regname);
981 fputs_filtered (paddress (get_frame_pc (fi)), gdb_stdout);
986 printf_filtered (" in ");
987 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
988 DMGL_ANSI | DMGL_PARAMS);
992 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
993 puts_filtered ("; ");
995 printf_filtered ("saved %s ", pc_regname);
996 fputs_filtered (paddress (frame_unwind_caller_pc (fi)), gdb_stdout);
997 printf_filtered ("\n");
999 if (calling_frame_info == NULL)
1001 enum unwind_stop_reason reason;
1003 reason = get_frame_unwind_stop_reason (fi);
1004 if (reason != UNWIND_NO_REASON)
1005 printf_filtered (_(" Outermost frame: %s\n"),
1006 frame_stop_reason_string (reason));
1009 if (calling_frame_info)
1011 printf_filtered (" called by frame at ");
1012 fputs_filtered (paddress (get_frame_base (calling_frame_info)),
1015 if (get_next_frame (fi) && calling_frame_info)
1016 puts_filtered (",");
1018 if (get_next_frame (fi))
1020 printf_filtered (" caller of frame at ");
1021 fputs_filtered (paddress (get_frame_base (get_next_frame (fi))),
1024 if (get_next_frame (fi) || calling_frame_info)
1025 puts_filtered ("\n");
1028 printf_filtered (" source language %s.\n",
1029 language_str (s->language));
1032 /* Address of the argument list for this frame, or 0. */
1033 CORE_ADDR arg_list = get_frame_args_address (fi);
1034 /* Number of args for this frame, or -1 if unknown. */
1038 printf_filtered (" Arglist at unknown address.\n");
1041 printf_filtered (" Arglist at ");
1042 fputs_filtered (paddress (arg_list), gdb_stdout);
1043 printf_filtered (",");
1045 if (!gdbarch_frame_num_args_p (gdbarch))
1048 puts_filtered (" args: ");
1052 numargs = gdbarch_frame_num_args (gdbarch, fi);
1053 gdb_assert (numargs >= 0);
1055 puts_filtered (" no args.");
1056 else if (numargs == 1)
1057 puts_filtered (" 1 arg: ");
1059 printf_filtered (" %d args: ", numargs);
1061 print_frame_args (func, fi, numargs, gdb_stdout);
1062 puts_filtered ("\n");
1066 /* Address of the local variables for this frame, or 0. */
1067 CORE_ADDR arg_list = get_frame_locals_address (fi);
1070 printf_filtered (" Locals at unknown address,");
1073 printf_filtered (" Locals at ");
1074 fputs_filtered (paddress (arg_list), gdb_stdout);
1075 printf_filtered (",");
1079 /* Print as much information as possible on the location of all the
1082 enum lval_type lval;
1090 /* The sp is special; what's displayed isn't the save address, but
1091 the value of the previous frame's sp. This is a legacy thing,
1092 at one stage the frame cached the previous frame's SP instead
1093 of its address, hence it was easiest to just display the cached
1095 if (gdbarch_sp_regnum (gdbarch) >= 0)
1097 /* Find out the location of the saved stack pointer with out
1098 actually evaluating it. */
1099 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1100 &optimized, &lval, &addr,
1102 if (!optimized && lval == not_lval)
1104 gdb_byte value[MAX_REGISTER_SIZE];
1106 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1107 &optimized, &lval, &addr,
1109 /* NOTE: cagney/2003-05-22: This is assuming that the
1110 stack pointer was packed as an unsigned integer. That
1111 may or may not be valid. */
1112 sp = extract_unsigned_integer (value,
1113 register_size (gdbarch,
1114 gdbarch_sp_regnum (gdbarch)));
1115 printf_filtered (" Previous frame's sp is ");
1116 fputs_filtered (paddress (sp), gdb_stdout);
1117 printf_filtered ("\n");
1120 else if (!optimized && lval == lval_memory)
1122 printf_filtered (" Previous frame's sp at ");
1123 fputs_filtered (paddress (addr), gdb_stdout);
1124 printf_filtered ("\n");
1127 else if (!optimized && lval == lval_register)
1129 printf_filtered (" Previous frame's sp in %s\n",
1130 gdbarch_register_name (gdbarch, realnum));
1133 /* else keep quiet. */
1137 numregs = gdbarch_num_regs (gdbarch)
1138 + gdbarch_num_pseudo_regs (gdbarch);
1139 for (i = 0; i < numregs; i++)
1140 if (i != gdbarch_sp_regnum (gdbarch)
1141 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1143 /* Find out the location of the saved register without
1144 fetching the corresponding value. */
1145 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1147 /* For moment, only display registers that were saved on the
1149 if (!optimized && lval == lval_memory)
1152 puts_filtered (" Saved registers:\n ");
1154 puts_filtered (",");
1156 printf_filtered (" %s at ",
1157 gdbarch_register_name (gdbarch, i));
1158 fputs_filtered (paddress (addr), gdb_stdout);
1162 if (count || need_nl)
1163 puts_filtered ("\n");
1167 /* Print briefly all stack frames or just the innermost COUNT_EXP
1171 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1173 struct frame_info *fi;
1176 struct frame_info *trailing;
1179 if (!target_has_stack)
1180 error (_("No stack."));
1182 /* The following code must do two things. First, it must set the
1183 variable TRAILING to the frame from which we should start
1184 printing. Second, it must set the variable count to the number
1185 of frames which we should print, or -1 if all of them. */
1186 trailing = get_current_frame ();
1188 /* The target can be in a state where there is no valid frames
1189 (e.g., just connected). */
1190 if (trailing == NULL)
1191 error (_("No stack."));
1196 count = parse_and_eval_long (count_exp);
1199 struct frame_info *current;
1204 while (current && count--)
1207 current = get_prev_frame (current);
1210 /* Will stop when CURRENT reaches the top of the stack.
1211 TRAILING will be COUNT below it. */
1215 trailing = get_prev_frame (trailing);
1216 current = get_prev_frame (current);
1228 struct partial_symtab *ps;
1230 /* Read in symbols for all of the frames. Need to do this in a
1231 separate pass so that "Reading in symbols for xxx" messages
1232 don't screw up the appearance of the backtrace. Also if
1233 people have strong opinions against reading symbols for
1234 backtrace this may have to be an option. */
1236 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1239 ps = find_pc_psymtab (get_frame_address_in_block (fi));
1241 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
1245 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1249 /* Don't use print_stack_frame; if an error() occurs it probably
1250 means further attempts to backtrace would fail (on the other
1251 hand, perhaps the code does or could be fixed to make sure
1252 the frame->prev field gets set to NULL in that case). */
1253 print_frame_info (fi, 1, LOCATION, 1);
1255 print_frame_local_vars (fi, 1, gdb_stdout);
1257 /* Save the last frame to check for error conditions. */
1261 /* If we've stopped before the end, mention that. */
1263 printf_filtered (_("(More stack frames follow...)\n"));
1265 /* If we've run out of frames, and the reason appears to be an error
1266 condition, print it. */
1267 if (fi == NULL && trailing != NULL)
1269 enum unwind_stop_reason reason;
1271 reason = get_frame_unwind_stop_reason (trailing);
1272 if (reason > UNWIND_FIRST_ERROR)
1273 printf_filtered (_("Backtrace stopped: %s\n"),
1274 frame_stop_reason_string (reason));
1278 struct backtrace_command_args
1285 /* Stub for catch_errors. */
1288 backtrace_command_stub (void *data)
1290 struct backtrace_command_args *args = data;
1291 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1296 backtrace_command (char *arg, int from_tty)
1298 struct cleanup *old_chain = NULL;
1299 int fulltrace_arg = -1, arglen = 0, argc = 0;
1300 struct backtrace_command_args btargs;
1307 argv = buildargv (arg);
1308 old_chain = make_cleanup_freeargv (argv);
1310 for (i = 0; argv[i]; i++)
1314 for (j = 0; j < strlen (argv[i]); j++)
1315 argv[i][j] = tolower (argv[i][j]);
1317 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1318 fulltrace_arg = argc;
1321 arglen += strlen (argv[i]);
1326 if (fulltrace_arg >= 0)
1330 arg = xmalloc (arglen + 1);
1331 memset (arg, 0, arglen + 1);
1332 for (i = 0; i < (argc + 1); i++)
1334 if (i != fulltrace_arg)
1336 strcat (arg, argv[i]);
1346 btargs.count_exp = arg;
1347 btargs.show_locals = (fulltrace_arg >= 0);
1348 btargs.from_tty = from_tty;
1349 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1351 if (fulltrace_arg >= 0 && arglen > 0)
1355 do_cleanups (old_chain);
1359 backtrace_full_command (char *arg, int from_tty)
1361 struct backtrace_command_args btargs;
1362 btargs.count_exp = arg;
1363 btargs.show_locals = 1;
1364 btargs.from_tty = from_tty;
1365 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1369 /* Print the local variables of a block B active in FRAME on STREAM.
1370 Return 1 if any variables were printed; 0 otherwise. */
1373 print_block_frame_locals (struct block *b, struct frame_info *frame,
1374 int num_tabs, struct ui_file *stream)
1376 struct dict_iterator iter;
1378 int values_printed = 0;
1381 ALL_BLOCK_SYMBOLS (b, iter, sym)
1383 switch (SYMBOL_CLASS (sym))
1389 if (SYMBOL_IS_ARGUMENT (sym))
1392 for (j = 0; j < num_tabs; j++)
1393 fputs_filtered ("\t", stream);
1394 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1395 fputs_filtered (" = ", stream);
1396 print_variable_value (sym, frame, stream);
1397 fprintf_filtered (stream, "\n");
1401 /* Ignore symbols which are not locals. */
1406 return values_printed;
1409 /* Same, but print labels. */
1412 print_block_frame_labels (struct block *b, int *have_default,
1413 struct ui_file *stream)
1415 struct dict_iterator iter;
1417 int values_printed = 0;
1419 ALL_BLOCK_SYMBOLS (b, iter, sym)
1421 if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "default") == 0)
1427 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1429 struct symtab_and_line sal;
1430 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1432 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1435 fprintf_filtered (stream, " ");
1436 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream);
1438 fprintf_filtered (stream, " in file %s, line %d\n",
1439 sal.symtab->filename, sal.line);
1443 return values_printed;
1446 /* Print on STREAM all the local variables in frame FRAME, including
1447 all the blocks active in that frame at its current PC.
1449 Returns 1 if the job was done, or 0 if nothing was printed because
1450 we have no info on the function running in FRAME. */
1453 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1454 struct ui_file *stream)
1456 struct block *block = get_frame_block (frame, 0);
1457 int values_printed = 0;
1461 fprintf_filtered (stream, "No symbol table info available.\n");
1467 if (print_block_frame_locals (block, frame, num_tabs, stream))
1469 /* After handling the function's top-level block, stop. Don't
1470 continue to its superblock, the block of per-file symbols. */
1471 if (BLOCK_FUNCTION (block))
1473 block = BLOCK_SUPERBLOCK (block);
1476 if (!values_printed)
1477 fprintf_filtered (stream, _("No locals.\n"));
1480 /* Same, but print labels. */
1483 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1484 struct ui_file *stream)
1487 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1489 struct blockvector *bl;
1490 struct block *block = get_frame_block (frame, 0);
1491 int values_printed = 0;
1492 int index, have_default = 0;
1493 char *blocks_printed;
1494 CORE_ADDR pc = get_frame_pc (frame);
1498 fprintf_filtered (stream, "No symbol table info available.\n");
1502 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1503 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1504 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1508 CORE_ADDR end = BLOCK_END (block) - 4;
1511 if (bl != blockvector_for_pc (end, &index))
1512 error (_("blockvector blotch"));
1513 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1514 error (_("blockvector botch"));
1515 last_index = BLOCKVECTOR_NBLOCKS (bl);
1518 /* Don't print out blocks that have gone by. */
1519 while (index < last_index
1520 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1523 while (index < last_index
1524 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1526 if (blocks_printed[index] == 0)
1528 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index),
1529 &have_default, stream))
1531 blocks_printed[index] = 1;
1537 if (values_printed && this_level_only)
1540 /* After handling the function's top-level block, stop. Don't
1541 continue to its superblock, the block of per-file symbols. */
1542 if (BLOCK_FUNCTION (block))
1544 block = BLOCK_SUPERBLOCK (block);
1547 if (!values_printed && !this_level_only)
1548 fprintf_filtered (stream, _("No catches.\n"));
1553 locals_info (char *args, int from_tty)
1555 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1560 catch_info (char *ignore, int from_tty)
1562 struct symtab_and_line *sal;
1564 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1565 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1570 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1572 struct symbol *func = get_frame_function (frame);
1574 struct dict_iterator iter;
1575 struct symbol *sym, *sym2;
1576 int values_printed = 0;
1580 fprintf_filtered (stream, _("No symbol table info available.\n"));
1584 b = SYMBOL_BLOCK_VALUE (func);
1585 ALL_BLOCK_SYMBOLS (b, iter, sym)
1587 /* Don't worry about things which aren't arguments. */
1588 if (SYMBOL_IS_ARGUMENT (sym))
1591 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1592 fputs_filtered (" = ", stream);
1594 /* We have to look up the symbol because arguments can have
1595 two entries (one a parameter, one a local) and the one we
1596 want is the local, which lookup_symbol will find for us.
1597 This includes gcc1 (not gcc2) on the sparc when passing a
1598 small structure and gcc2 when the argument type is float
1599 and it is passed as a double and converted to float by
1600 the prologue (in the latter case the type of the LOC_ARG
1601 symbol is double and the type of the LOC_LOCAL symbol is
1602 float). There are also LOC_ARG/LOC_REGISTER pairs which
1603 are not combined in symbol-reading. */
1605 sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
1606 b, VAR_DOMAIN, NULL);
1607 print_variable_value (sym2, frame, stream);
1608 fprintf_filtered (stream, "\n");
1612 if (!values_printed)
1613 fprintf_filtered (stream, _("No arguments.\n"));
1617 args_info (char *ignore, int from_tty)
1619 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1625 args_plus_locals_info (char *ignore, int from_tty)
1627 args_info (ignore, from_tty);
1628 locals_info (ignore, from_tty);
1632 /* Select frame FRAME. Also print the stack frame and show the source
1633 if this is the tui version. */
1635 select_and_print_frame (struct frame_info *frame)
1637 select_frame (frame);
1639 print_stack_frame (frame, 1, SRC_AND_LOC);
1642 /* Return the symbol-block in which the selected frame is executing.
1643 Can return zero under various legitimate circumstances.
1645 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1646 code address within the block returned. We use this to decide
1647 which macros are in scope. */
1650 get_selected_block (CORE_ADDR *addr_in_block)
1652 if (!target_has_stack)
1655 if (is_executing (inferior_ptid))
1658 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1661 /* Find a frame a certain number of levels away from FRAME.
1662 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1663 Positive means go to earlier frames (up); negative, the reverse.
1664 The int that contains the number of levels is counted toward
1665 zero as the frames for those levels are found.
1666 If the top or bottom frame is reached, that frame is returned,
1667 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1668 how much farther the original request asked to go. */
1671 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1673 /* Going up is simple: just call get_prev_frame enough times or
1674 until the initial frame is reached. */
1675 while (*level_offset_ptr > 0)
1677 struct frame_info *prev = get_prev_frame (frame);
1680 (*level_offset_ptr)--;
1684 /* Going down is just as simple. */
1685 while (*level_offset_ptr < 0)
1687 struct frame_info *next = get_next_frame (frame);
1690 (*level_offset_ptr)++;
1697 /* The "select_frame" command. With no argument this is a NOP.
1698 Select the frame at level LEVEL_EXP if it is a valid level.
1699 Otherwise, treat LEVEL_EXP as an address expression and select it.
1701 See parse_frame_specification for more info on proper frame
1705 select_frame_command (char *level_exp, int from_tty)
1707 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1710 /* The "frame" command. With no argument, print the selected frame
1711 briefly. With an argument, behave like select_frame and then print
1712 the selected frame. */
1715 frame_command (char *level_exp, int from_tty)
1717 select_frame_command (level_exp, from_tty);
1718 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1721 /* The XDB Compatibility command to print the current frame. */
1724 current_frame_command (char *level_exp, int from_tty)
1726 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1729 /* Select the frame up one or COUNT_EXP stack levels from the
1730 previously selected frame, and print it briefly. */
1733 up_silently_base (char *count_exp)
1735 struct frame_info *frame;
1739 count = parse_and_eval_long (count_exp);
1741 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1742 if (count != 0 && count_exp == NULL)
1743 error (_("Initial frame selected; you cannot go up."));
1744 select_frame (frame);
1748 up_silently_command (char *count_exp, int from_tty)
1750 up_silently_base (count_exp);
1754 up_command (char *count_exp, int from_tty)
1756 up_silently_base (count_exp);
1757 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1760 /* Select the frame down one or COUNT_EXP stack levels from the previously
1761 selected frame, and print it briefly. */
1764 down_silently_base (char *count_exp)
1766 struct frame_info *frame;
1769 count = -parse_and_eval_long (count_exp);
1771 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1772 if (count != 0 && count_exp == NULL)
1774 /* We only do this if COUNT_EXP is not specified. That way
1775 "down" means to really go down (and let me know if that is
1776 impossible), but "down 9999" can be used to mean go all the
1777 way down without getting an error. */
1779 error (_("Bottom (innermost) frame selected; you cannot go down."));
1782 select_frame (frame);
1786 down_silently_command (char *count_exp, int from_tty)
1788 down_silently_base (count_exp);
1792 down_command (char *count_exp, int from_tty)
1794 down_silently_base (count_exp);
1795 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1800 return_command (char *retval_exp, int from_tty)
1802 struct symbol *thisfun;
1803 struct value *return_value = NULL;
1804 const char *query_prefix = "";
1806 thisfun = get_frame_function (get_selected_frame ("No selected frame."));
1808 /* Compute the return value. If the computation triggers an error,
1809 let it bail. If the return type can't be handled, set
1810 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1814 struct type *return_type = NULL;
1816 /* Compute the return value. Should the computation fail, this
1817 call throws an error. */
1818 return_value = parse_and_eval (retval_exp);
1820 /* Cast return value to the return type of the function. Should
1821 the cast fail, this call throws an error. */
1822 if (thisfun != NULL)
1823 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1824 if (return_type == NULL)
1825 return_type = builtin_type_int;
1826 CHECK_TYPEDEF (return_type);
1827 return_value = value_cast (return_type, return_value);
1829 /* Make sure the value is fully evaluated. It may live in the
1830 stack frame we're about to pop. */
1831 if (value_lazy (return_value))
1832 value_fetch_lazy (return_value);
1834 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1835 /* If the return-type is "void", don't try to find the
1836 return-value's location. However, do still evaluate the
1837 return expression so that, even when the expression result
1838 is discarded, side effects such as "return i++" still
1840 return_value = NULL;
1841 else if (using_struct_return (SYMBOL_TYPE (thisfun), return_type))
1844 The location at which to store the function's return value is unknown.\n\
1845 If you continue, the return value that you specified will be ignored.\n";
1846 return_value = NULL;
1850 /* Does an interactive user really want to do this? Include
1851 information, such as how well GDB can handle the return value, in
1852 the query message. */
1856 if (thisfun == NULL)
1857 confirmed = query (_("%sMake selected stack frame return now? "),
1860 confirmed = query (_("%sMake %s return now? "), query_prefix,
1861 SYMBOL_PRINT_NAME (thisfun));
1863 error (_("Not confirmed"));
1866 /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
1867 frame in turn, should this code just go straight to the relevant
1868 frame and pop that? */
1870 /* First discard all frames inner-to the selected frame (making the
1871 selected frame current). */
1873 struct frame_id selected_id = get_frame_id (get_selected_frame (NULL));
1874 while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ())))
1876 struct frame_info *frame = get_current_frame ();
1877 if (frame_id_inner (get_frame_arch (frame), selected_id,
1878 get_frame_id (frame)))
1879 /* Caught in the safety net, oops! We've gone way past the
1881 error (_("Problem while popping stack frames (corrupt stack?)"));
1882 frame_pop (get_current_frame ());
1886 /* Second discard the selected frame (which is now also the current
1888 frame_pop (get_current_frame ());
1890 /* Store RETURN_VALUE in the just-returned register set. */
1891 if (return_value != NULL)
1893 struct type *return_type = value_type (return_value);
1894 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
1895 gdb_assert (gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun),
1896 return_type, NULL, NULL, NULL)
1897 == RETURN_VALUE_REGISTER_CONVENTION);
1898 gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun), return_type,
1899 get_current_regcache (), NULL /*read*/,
1900 value_contents (return_value) /*write*/);
1903 /* If we are at the end of a call dummy now, pop the dummy frame
1905 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1906 frame_pop (get_current_frame ());
1908 /* If interactive, print the frame that is now current. */
1910 frame_command ("0", 1);
1912 select_frame_command ("0", 0);
1915 /* Sets the scope to input function name, provided that the function
1916 is within the current stack frame */
1918 struct function_bounds
1920 CORE_ADDR low, high;
1924 func_command (char *arg, int from_tty)
1926 struct frame_info *frame;
1928 struct symtabs_and_lines sals;
1931 struct function_bounds *func_bounds = NULL;
1936 frame = parse_frame_specification ("0");
1937 sals = decode_line_spec (arg, 1);
1938 func_bounds = (struct function_bounds *) xmalloc (
1939 sizeof (struct function_bounds) * sals.nelts);
1940 for (i = 0; (i < sals.nelts && !found); i++)
1942 if (sals.sals[i].pc == 0
1943 || find_pc_partial_function (sals.sals[i].pc, NULL,
1944 &func_bounds[i].low,
1945 &func_bounds[i].high) == 0)
1947 func_bounds[i].low = func_bounds[i].high = 0;
1953 for (i = 0; (i < sals.nelts && !found); i++)
1954 found = (get_frame_pc (frame) >= func_bounds[i].low
1955 && get_frame_pc (frame) < func_bounds[i].high);
1959 frame = find_relative_frame (frame, &level);
1962 while (!found && level == 0);
1965 xfree (func_bounds);
1968 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
1969 else if (frame != get_selected_frame (NULL))
1970 select_and_print_frame (frame);
1973 /* Gets the language of the current frame. */
1976 get_frame_language (void)
1978 struct frame_info *frame = deprecated_safe_get_selected_frame ();
1982 /* We determine the current frame language by looking up its
1983 associated symtab. To retrieve this symtab, we use the frame
1984 PC. However we cannot use the frame PC as is, because it
1985 usually points to the instruction following the "call", which
1986 is sometimes the first instruction of another function. So
1987 we rely on get_frame_address_in_block(), it provides us with
1988 a PC that is guaranteed to be inside the frame's code
1990 CORE_ADDR pc = get_frame_address_in_block (frame);
1991 struct symtab *s = find_pc_symtab (pc);
1997 return language_unknown;
2001 /* Provide a prototype to silence -Wmissing-prototypes. */
2002 void _initialize_stack (void);
2005 _initialize_stack (void)
2008 backtrace_limit = 30;
2011 add_com ("return", class_stack, return_command, _("\
2012 Make selected stack frame return to its caller.\n\
2013 Control remains in the debugger, but when you continue\n\
2014 execution will resume in the frame above the one now selected.\n\
2015 If an argument is given, it is an expression for the value to return."));
2017 add_com ("up", class_stack, up_command, _("\
2018 Select and print stack frame that called this one.\n\
2019 An argument says how many frames up to go."));
2020 add_com ("up-silently", class_support, up_silently_command, _("\
2021 Same as the `up' command, but does not print anything.\n\
2022 This is useful in command scripts."));
2024 add_com ("down", class_stack, down_command, _("\
2025 Select and print stack frame called by this one.\n\
2026 An argument says how many frames down to go."));
2027 add_com_alias ("do", "down", class_stack, 1);
2028 add_com_alias ("dow", "down", class_stack, 1);
2029 add_com ("down-silently", class_support, down_silently_command, _("\
2030 Same as the `down' command, but does not print anything.\n\
2031 This is useful in command scripts."));
2033 add_com ("frame", class_stack, frame_command, _("\
2034 Select and print a stack frame.\n\
2035 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2036 An argument specifies the frame to select.\n\
2037 It can be a stack frame number or the address of the frame.\n\
2038 With argument, nothing is printed if input is coming from\n\
2039 a command file or a user-defined command."));
2041 add_com_alias ("f", "frame", class_stack, 1);
2045 add_com ("L", class_stack, current_frame_command,
2046 _("Print the current stack frame.\n"));
2047 add_com_alias ("V", "frame", class_stack, 1);
2049 add_com ("select-frame", class_stack, select_frame_command, _("\
2050 Select a stack frame without printing anything.\n\
2051 An argument specifies the frame to select.\n\
2052 It can be a stack frame number or the address of the frame.\n"));
2054 add_com ("backtrace", class_stack, backtrace_command, _("\
2055 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2056 With a negative argument, print outermost -COUNT frames.\n\
2057 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2058 add_com_alias ("bt", "backtrace", class_stack, 0);
2061 add_com_alias ("t", "backtrace", class_stack, 0);
2062 add_com ("T", class_stack, backtrace_full_command, _("\
2063 Print backtrace of all stack frames, or innermost COUNT frames \n\
2064 and the values of the local variables.\n\
2065 With a negative argument, print outermost -COUNT frames.\n\
2066 Usage: T <count>\n"));
2069 add_com_alias ("where", "backtrace", class_alias, 0);
2070 add_info ("stack", backtrace_command,
2071 _("Backtrace of the stack, or innermost COUNT frames."));
2072 add_info_alias ("s", "stack", 1);
2073 add_info ("frame", frame_info,
2074 _("All about selected stack frame, or frame at ADDR."));
2075 add_info_alias ("f", "frame", 1);
2076 add_info ("locals", locals_info,
2077 _("Local variables of current stack frame."));
2078 add_info ("args", args_info,
2079 _("Argument variables of current stack frame."));
2081 add_com ("l", class_info, args_plus_locals_info,
2082 _("Argument and local variables of current stack frame."));
2085 add_com ("func", class_stack, func_command, _("\
2086 Select the stack frame that contains <func>.\n\
2087 Usage: func <name>\n"));
2089 add_info ("catch", catch_info,
2090 _("Exceptions that can be caught in the current stack frame."));
2092 add_setshow_enum_cmd ("frame-arguments", class_stack,
2093 print_frame_arguments_choices, &print_frame_arguments,
2094 _("Set printing of non-scalar frame arguments"),
2095 _("Show printing of non-scalar frame arguments"),
2096 NULL, NULL, NULL, &setprintlist, &showprintlist);
2099 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2100 "Specify maximum number of frames for \"backtrace\" to print by default."),
2102 add_info ("backtrace-limit", backtrace_limit_info, _("\
2103 The maximum number of frames for \"backtrace\" to print by default."));