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 2009, 2010, 2011 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 "inline-frame.h"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
58 void (*deprecated_selected_frame_level_changed_hook) (int);
60 /* The possible choices of "set print frame-arguments", and the value
63 static const char *print_frame_arguments_choices[] =
64 {"all", "scalars", "none", NULL};
65 static const char *print_frame_arguments = "scalars";
67 /* Prototypes for local functions. */
69 static void print_frame_local_vars (struct frame_info *, int,
72 static void print_frame (struct frame_info *frame, int print_level,
73 enum print_what print_what, int print_args,
74 struct symtab_and_line sal);
76 /* Zero means do things normally; we are interacting directly with the
77 user. One means print the full filename and linenumber when a
78 frame is printed, and do so in a format emacs18/emacs19.22 can
79 parse. Two means print similar annotations, but in many more
80 cases and in a slightly different syntax. */
82 int annotation_level = 0;
85 /* Return 1 if we should display the address in addition to the location,
86 because we are in the middle of a statement. */
89 frame_show_address (struct frame_info *frame,
90 struct symtab_and_line sal)
92 /* If there is a line number, but no PC, then there is no location
93 information associated with this sal. The only way that should
94 happen is for the call sites of inlined functions (SAL comes from
95 find_frame_sal). Otherwise, we would have some PC range if the
96 SAL came from a line table. */
97 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
99 if (get_next_frame (frame) == NULL)
100 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
102 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
106 return get_frame_pc (frame) != sal.pc;
109 /* Show or print a stack frame FRAME briefly. The output is format
110 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
111 relative level, function name, argument list, and file name and
112 line number. If the frame's PC is not at the beginning of the
113 source line, the actual PC is printed at the beginning. */
116 print_stack_frame (struct frame_info *frame, int print_level,
117 enum print_what print_what)
119 volatile struct gdb_exception e;
121 /* For mi, alway print location and address. */
122 if (ui_out_is_mi_like_p (current_uiout))
123 print_what = LOC_AND_ADDRESS;
125 TRY_CATCH (e, RETURN_MASK_ERROR)
127 int center = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
129 print_frame_info (frame, print_level, print_what, 1 /* print_args */);
130 set_current_sal_from_frame (frame, center);
134 /* Print nameless arguments of frame FRAME on STREAM, where START is
135 the offset of the first nameless argument, and NUM is the number of
136 nameless arguments to print. FIRST is nonzero if this is the first
137 argument (not just the first nameless argument). */
140 print_frame_nameless_args (struct frame_info *frame, long start, int num,
141 int first, struct ui_file *stream)
143 struct gdbarch *gdbarch = get_frame_arch (frame);
144 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
149 for (i = 0; i < num; i++)
152 argsaddr = get_frame_args_address (frame);
155 arg_value = read_memory_integer (argsaddr + start,
156 sizeof (int), byte_order);
158 fprintf_filtered (stream, ", ");
159 fprintf_filtered (stream, "%ld", arg_value);
161 start += sizeof (int);
165 /* Print the arguments of frame FRAME on STREAM, given the function
166 FUNC running in that frame (as a symbol), where NUM is the number
167 of arguments according to the stack frame (or -1 if the number of
168 arguments is unknown). */
170 /* Note that currently the "number of arguments according to the
171 stack frame" is only known on VAX where i refers to the "number of
172 ints of arguments according to the stack frame". */
175 print_frame_args (struct symbol *func, struct frame_info *frame,
176 int num, struct ui_file *stream)
178 struct ui_out *uiout = current_uiout;
180 /* Offset of next stack argument beyond the one we have seen that is
181 at the highest offset, or -1 if we haven't come to a stack
183 long highest_offset = -1;
184 /* Number of ints of arguments that we have printed so far. */
185 int args_printed = 0;
186 struct cleanup *old_chain, *list_chain;
187 struct ui_stream *stb;
188 /* True if we should print arguments, false otherwise. */
189 int print_args = strcmp (print_frame_arguments, "none");
190 /* True in "summary" mode, false otherwise. */
191 int summary = !strcmp (print_frame_arguments, "scalars");
193 stb = ui_out_stream_new (uiout);
194 old_chain = make_cleanup_ui_out_stream_delete (stb);
198 struct block *b = SYMBOL_BLOCK_VALUE (func);
199 struct dict_iterator iter;
203 ALL_BLOCK_SYMBOLS (b, iter, sym)
207 /* Keep track of the highest stack argument offset seen, and
208 skip over any kinds of symbols we don't care about. */
210 if (!SYMBOL_IS_ARGUMENT (sym))
213 switch (SYMBOL_CLASS (sym))
218 long current_offset = SYMBOL_VALUE (sym);
219 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
221 /* Compute address of next argument by adding the size of
222 this argument and rounding to an int boundary. */
224 ((current_offset + arg_size + sizeof (int) - 1)
225 & ~(sizeof (int) - 1));
227 /* If this is the highest offset seen yet, set
229 if (highest_offset == -1
230 || (current_offset > highest_offset))
231 highest_offset = current_offset;
233 /* Add the number of ints we're about to print to
235 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
238 /* We care about types of symbols, but don't need to
239 keep track of stack offsets in them. */
241 case LOC_REGPARM_ADDR:
243 case LOC_OPTIMIZED_OUT:
248 /* We have to look up the symbol because arguments can have
249 two entries (one a parameter, one a local) and the one we
250 want is the local, which lookup_symbol will find for us.
251 This includes gcc1 (not gcc2) on SPARC when passing a
252 small structure and gcc2 when the argument type is float
253 and it is passed as a double and converted to float by
254 the prologue (in the latter case the type of the LOC_ARG
255 symbol is double and the type of the LOC_LOCAL symbol is
257 /* But if the parameter name is null, don't try it. Null
258 parameter names occur on the RS/6000, for traceback
259 tables. FIXME, should we even print them? */
261 if (*SYMBOL_LINKAGE_NAME (sym))
265 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
266 b, VAR_DOMAIN, NULL);
267 gdb_assert (nsym != NULL);
268 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
269 && !SYMBOL_IS_ARGUMENT (nsym))
271 /* There is a LOC_ARG/LOC_REGISTER pair. This means
272 that it was passed on the stack and loaded into a
273 register, or passed in a register and stored in a
274 stack slot. GDB 3.x used the LOC_ARG; GDB
275 4.0-4.11 used the LOC_REGISTER.
277 Reasons for using the LOC_ARG:
279 (1) Because find_saved_registers may be slow for
282 (2) Because registers are often re-used and stack
283 slots rarely (never?) are. Therefore using
284 the stack slot is much less likely to print
287 Reasons why we might want to use the LOC_REGISTER:
289 (1) So that the backtrace prints the same value
290 as "print foo". I see no compelling reason
291 why this needs to be the case; having the
292 backtrace print the value which was passed
293 in, and "print foo" print the value as
294 modified within the called function, makes
297 Additional note: It might be nice if "info args"
298 displayed both values.
300 One more note: There is a case with SPARC
301 structure passing where we need to use the
302 LOC_REGISTER, but this is dealt with by creating
303 a single LOC_REGPARM in symbol reading. */
305 /* Leave sym (the LOC_ARG) alone. */
312 /* Print the current arg. */
314 ui_out_text (uiout, ", ");
315 ui_out_wrap_hint (uiout, " ");
317 annotate_arg_begin ();
319 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
320 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
321 SYMBOL_LANGUAGE (sym),
322 DMGL_PARAMS | DMGL_ANSI);
323 ui_out_field_stream (uiout, "name", stb);
324 annotate_arg_name_end ();
325 ui_out_text (uiout, "=");
329 volatile struct gdb_exception except;
331 TRY_CATCH (except, RETURN_MASK_ERROR)
333 /* Avoid value_print because it will deref ref parameters.
334 We just want to print their addresses. Print ??? for
335 args whose address we do not know. We pass 2 as
336 "recurse" to val_print because our standard indentation
337 here is 4 spaces, and val_print indents 2 for each
339 val = read_var_value (sym, frame);
341 annotate_arg_value (val == NULL ? NULL : value_type (val));
345 const struct language_defn *language;
346 struct value_print_options opts;
348 /* Use the appropriate language to display our symbol,
349 unless the user forced the language to a specific
351 if (language_mode == language_mode_auto)
352 language = language_def (SYMBOL_LANGUAGE (sym));
354 language = current_language;
356 get_raw_print_options (&opts);
358 opts.summary = summary;
359 common_val_print (val, stb->stream, 2, &opts, language);
360 ui_out_field_stream (uiout, "value", stb);
363 ui_out_text (uiout, "???");
365 if (except.reason < 0)
367 fprintf_filtered (stb->stream,
368 _("<error reading variable: %s>"),
370 ui_out_field_stream (uiout, "value", stb);
374 ui_out_text (uiout, "...");
377 /* Invoke ui_out_tuple_end. */
378 do_cleanups (list_chain);
386 /* Don't print nameless args in situations where we don't know
387 enough about the stack to find them. */
392 if (highest_offset == -1)
393 start = gdbarch_frame_args_skip (get_frame_arch (frame));
395 start = highest_offset;
397 print_frame_nameless_args (frame, start, num - args_printed,
401 do_cleanups (old_chain);
404 /* Set the current source and line to the location given by frame
405 FRAME, if possible. When CENTER is true, adjust so the relevant
406 line is in the center of the next 'list'. */
409 set_current_sal_from_frame (struct frame_info *frame, int center)
411 struct symtab_and_line sal;
413 find_frame_sal (frame, &sal);
417 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
418 set_current_source_symtab_and_line (&sal);
422 /* If ON, GDB will display disassembly of the next source line when
423 execution of the program being debugged stops.
424 If AUTO (which is the default), or there's no line info to determine
425 the source line of the next instruction, display disassembly of next
426 instruction instead. */
428 static enum auto_boolean disassemble_next_line;
431 show_disassemble_next_line (struct ui_file *file, int from_tty,
432 struct cmd_list_element *c,
435 fprintf_filtered (file,
436 _("Debugger's willingness to use "
437 "disassemble-next-line is %s.\n"),
441 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
442 because it will be broken by filter sometime. */
445 do_gdb_disassembly (struct gdbarch *gdbarch,
446 int how_many, CORE_ADDR low, CORE_ADDR high)
448 volatile struct gdb_exception exception;
450 TRY_CATCH (exception, RETURN_MASK_ERROR)
452 gdb_disassembly (gdbarch, current_uiout, 0,
453 DISASSEMBLY_RAW_INSN, how_many,
456 if (exception.reason < 0)
458 /* If an exception was thrown while doing the disassembly, print
459 the error message, to give the user a clue of what happened. */
460 exception_print (gdb_stderr, exception);
464 /* Print information about frame FRAME. The output is format according
465 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
468 SRC_LINE: Print only source line.
469 LOCATION: Print only location.
470 LOC_AND_SRC: Print location and source line.
472 Used in "where" output, and to emit breakpoint or step
476 print_frame_info (struct frame_info *frame, int print_level,
477 enum print_what print_what, int print_args)
479 struct gdbarch *gdbarch = get_frame_arch (frame);
480 struct symtab_and_line sal;
483 struct ui_out *uiout = current_uiout;
485 if (get_frame_type (frame) == DUMMY_FRAME
486 || get_frame_type (frame) == SIGTRAMP_FRAME
487 || get_frame_type (frame) == ARCH_FRAME)
489 struct cleanup *uiout_cleanup
490 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
492 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
493 gdbarch, get_frame_pc (frame));
495 /* Do this regardless of SOURCE because we don't have any source
496 to list for this frame. */
499 ui_out_text (uiout, "#");
500 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
501 frame_relative_level (frame));
503 if (ui_out_is_mi_like_p (uiout))
505 annotate_frame_address ();
506 ui_out_field_core_addr (uiout, "addr",
507 gdbarch, get_frame_pc (frame));
508 annotate_frame_address_end ();
511 if (get_frame_type (frame) == DUMMY_FRAME)
513 annotate_function_call ();
514 ui_out_field_string (uiout, "func", "<function called from gdb>");
516 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
518 annotate_signal_handler_caller ();
519 ui_out_field_string (uiout, "func", "<signal handler called>");
521 else if (get_frame_type (frame) == ARCH_FRAME)
523 ui_out_field_string (uiout, "func", "<cross-architecture call>");
525 ui_out_text (uiout, "\n");
526 annotate_frame_end ();
528 do_cleanups (uiout_cleanup);
532 /* If FRAME is not the innermost frame, that normally means that
533 FRAME->pc points to *after* the call instruction, and we want to
534 get the line containing the call, never the next line. But if
535 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
536 next frame was not entered as the result of a call, and we want
537 to get the line containing FRAME->pc. */
538 find_frame_sal (frame, &sal);
540 location_print = (print_what == LOCATION
541 || print_what == LOC_AND_ADDRESS
542 || print_what == SRC_AND_LOC);
544 if (location_print || !sal.symtab)
545 print_frame (frame, print_level, print_what, print_args, sal);
547 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
549 /* If disassemble-next-line is set to auto or on and doesn't have
550 the line debug messages for $pc, output the next instruction. */
551 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
552 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
553 && source_print && !sal.symtab)
554 do_gdb_disassembly (get_frame_arch (frame), 1,
555 get_frame_pc (frame), get_frame_pc (frame) + 1);
557 if (source_print && sal.symtab)
560 int mid_statement = ((print_what == SRC_LINE)
561 && frame_show_address (frame, sal));
563 if (annotation_level)
564 done = identify_source_line (sal.symtab, sal.line, mid_statement,
565 get_frame_pc (frame));
568 if (deprecated_print_frame_info_listing_hook)
569 deprecated_print_frame_info_listing_hook (sal.symtab,
574 struct value_print_options opts;
576 get_user_print_options (&opts);
577 /* We used to do this earlier, but that is clearly
578 wrong. This function is used by many different
579 parts of gdb, including normal_stop in infrun.c,
580 which uses this to print out the current PC
581 when we stepi/nexti into the middle of a source
582 line. Only the command line really wants this
583 behavior. Other UIs probably would like the
584 ability to decide for themselves if it is desired. */
585 if (opts.addressprint && mid_statement)
587 ui_out_field_core_addr (uiout, "addr",
588 gdbarch, get_frame_pc (frame));
589 ui_out_text (uiout, "\t");
592 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
596 /* If disassemble-next-line is set to on and there is line debug
597 messages, output assembly codes for next line. */
598 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
599 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
602 if (print_what != LOCATION)
606 if (get_frame_pc_if_available (frame, &pc))
607 set_default_breakpoint (1, sal.pspace, pc, sal.symtab, sal.line);
609 set_default_breakpoint (0, 0, 0, 0, 0);
612 annotate_frame_end ();
614 gdb_flush (gdb_stdout);
617 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
618 corresponding to FRAME. */
621 find_frame_funname (struct frame_info *frame, char **funname,
622 enum language *funlang, struct symbol **funcp)
627 *funlang = language_unknown;
631 func = get_frame_function (frame);
634 /* In certain pathological cases, the symtabs give the wrong
635 function (when we are in the first function in a file which
636 is compiled without debugging symbols, the previous function
637 is compiled with debugging symbols, and the "foo.o" symbol
638 that is supposed to tell us where the file with debugging
639 symbols ends has been truncated by ar because it is longer
640 than 15 characters). This also occurs if the user uses asm()
641 to create a function but not stabs for it (in a file compiled
644 So look in the minimal symbol tables as well, and if it comes
645 up with a larger address for the function use that instead.
646 I don't think this can ever cause any problems; there
647 shouldn't be any minimal symbols in the middle of a function;
648 if this is ever changed many parts of GDB will need to be
649 changed (and we'll create a find_pc_minimal_function or some
652 struct minimal_symbol *msymbol = NULL;
654 /* Don't attempt to do this for inlined functions, which do not
655 have a corresponding minimal symbol. */
656 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
658 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
661 && (SYMBOL_VALUE_ADDRESS (msymbol)
662 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
664 /* We also don't know anything about the function besides
665 its address and name. */
667 *funname = SYMBOL_PRINT_NAME (msymbol);
668 *funlang = SYMBOL_LANGUAGE (msymbol);
672 *funname = SYMBOL_PRINT_NAME (func);
673 *funlang = SYMBOL_LANGUAGE (func);
676 if (*funlang == language_cplus)
678 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
679 to display the demangled name that we already have
680 stored in the symbol table, but we stored a version
681 with DMGL_PARAMS turned on, and here we don't want to
682 display parameters. So remove the parameters. */
683 char *func_only = cp_remove_params (*funname);
687 *funname = func_only;
688 make_cleanup (xfree, func_only);
695 struct minimal_symbol *msymbol;
698 if (!get_frame_address_in_block_if_available (frame, &pc))
701 msymbol = lookup_minimal_symbol_by_pc (pc);
704 *funname = SYMBOL_PRINT_NAME (msymbol);
705 *funlang = SYMBOL_LANGUAGE (msymbol);
711 print_frame (struct frame_info *frame, int print_level,
712 enum print_what print_what, int print_args,
713 struct symtab_and_line sal)
715 struct gdbarch *gdbarch = get_frame_arch (frame);
716 struct ui_out *uiout = current_uiout;
717 char *funname = NULL;
718 enum language funlang = language_unknown;
719 struct ui_stream *stb;
720 struct cleanup *old_chain, *list_chain;
721 struct value_print_options opts;
726 pc_p = get_frame_pc_if_available (frame, &pc);
728 stb = ui_out_stream_new (uiout);
729 old_chain = make_cleanup_ui_out_stream_delete (stb);
731 find_frame_funname (frame, &funname, &funlang, &func);
733 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
736 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
740 ui_out_text (uiout, "#");
741 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
742 frame_relative_level (frame));
744 get_user_print_options (&opts);
745 if (opts.addressprint)
747 || frame_show_address (frame, sal)
748 || print_what == LOC_AND_ADDRESS)
750 annotate_frame_address ();
752 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
754 ui_out_field_string (uiout, "addr", "<unavailable>");
755 annotate_frame_address_end ();
756 ui_out_text (uiout, " in ");
758 annotate_frame_function_name ();
759 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
761 ui_out_field_stream (uiout, "func", stb);
762 ui_out_wrap_hint (uiout, " ");
763 annotate_frame_args ();
765 ui_out_text (uiout, " (");
768 struct gdbarch *gdbarch = get_frame_arch (frame);
770 struct cleanup *args_list_chain;
771 volatile struct gdb_exception e;
773 if (gdbarch_frame_num_args_p (gdbarch))
775 numargs = gdbarch_frame_num_args (gdbarch, frame);
776 gdb_assert (numargs >= 0);
781 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
782 TRY_CATCH (e, RETURN_MASK_ERROR)
784 print_frame_args (func, frame, numargs, gdb_stdout);
786 /* FIXME: ARGS must be a list. If one argument is a string it
787 will have " that will not be properly escaped. */
788 /* Invoke ui_out_tuple_end. */
789 do_cleanups (args_list_chain);
792 ui_out_text (uiout, ")");
793 if (sal.symtab && sal.symtab->filename)
795 annotate_frame_source_begin ();
796 ui_out_wrap_hint (uiout, " ");
797 ui_out_text (uiout, " at ");
798 annotate_frame_source_file ();
799 ui_out_field_string (uiout, "file", sal.symtab->filename);
800 if (ui_out_is_mi_like_p (uiout))
802 const char *fullname = symtab_to_fullname (sal.symtab);
804 if (fullname != NULL)
805 ui_out_field_string (uiout, "fullname", fullname);
807 annotate_frame_source_file_end ();
808 ui_out_text (uiout, ":");
809 annotate_frame_source_line ();
810 ui_out_field_int (uiout, "line", sal.line);
811 annotate_frame_source_end ();
814 if (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename)))
817 char *lib = PC_SOLIB (get_frame_pc (frame));
819 char *lib = solib_name_from_address (get_frame_program_space (frame),
820 get_frame_pc (frame));
824 annotate_frame_where ();
825 ui_out_wrap_hint (uiout, " ");
826 ui_out_text (uiout, " from ");
827 ui_out_field_string (uiout, "from", lib);
831 /* do_cleanups will call ui_out_tuple_end() for us. */
832 do_cleanups (list_chain);
833 ui_out_text (uiout, "\n");
834 do_cleanups (old_chain);
838 /* Read a frame specification in whatever the appropriate format is
839 from FRAME_EXP. Call error(), printing MESSAGE, if the
840 specification is in any way invalid (so this function never returns
841 NULL). When SEPECTED_P is non-NULL set its target to indicate that
842 the default selected frame was used. */
844 static struct frame_info *
845 parse_frame_specification_1 (const char *frame_exp, const char *message,
846 int *selected_frame_p)
849 struct value *args[4];
850 CORE_ADDR addrs[ARRAY_SIZE (args)];
852 if (frame_exp == NULL)
860 struct cleanup *cleanup;
863 /* Skip leading white space, bail of EOL. */
864 while (isspace (*frame_exp))
869 /* Parse the argument, extract it, save it. */
873 addr_string = savestring (frame_exp, p - frame_exp);
875 cleanup = make_cleanup (xfree, addr_string);
877 /* NOTE: Parse and evaluate expression, but do not use
878 functions such as parse_and_eval_long or
879 parse_and_eval_address to also extract the value.
880 Instead value_as_long and value_as_address are used.
881 This avoids problems with expressions that contain
883 if (numargs >= ARRAY_SIZE (args))
884 error (_("Too many args in frame specification"));
885 args[numargs++] = parse_and_eval (addr_string);
887 do_cleanups (cleanup);
891 /* If no args, default to the selected frame. */
894 if (selected_frame_p != NULL)
895 (*selected_frame_p) = 1;
896 return get_selected_frame (message);
899 /* None of the remaining use the selected frame. */
900 if (selected_frame_p != NULL)
901 (*selected_frame_p) = 0;
903 /* Assume the single arg[0] is an integer, and try using that to
904 select a frame relative to current. */
907 struct frame_info *fid;
908 int level = value_as_long (args[0]);
910 fid = find_relative_frame (get_current_frame (), &level);
912 /* find_relative_frame was successful. */
916 /* Convert each value into a corresponding address. */
920 for (i = 0; i < numargs; i++)
921 addrs[i] = value_as_address (args[i]);
924 /* Assume that the single arg[0] is an address, use that to identify
925 a frame with a matching ID. Should this also accept stack/pc or
929 struct frame_id id = frame_id_build_wild (addrs[0]);
930 struct frame_info *fid;
932 /* If (s)he specifies the frame with an address, he deserves
933 what (s)he gets. Still, give the highest one that matches.
934 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
936 for (fid = get_current_frame ();
938 fid = get_prev_frame (fid))
940 if (frame_id_eq (id, get_frame_id (fid)))
942 struct frame_info *prev_frame;
946 prev_frame = get_prev_frame (fid);
948 || !frame_id_eq (id, get_frame_id (prev_frame)))
957 /* We couldn't identify the frame as an existing frame, but
958 perhaps we can create one with a single argument. */
960 return create_new_frame (addrs[0], 0);
961 else if (numargs == 2)
962 return create_new_frame (addrs[0], addrs[1]);
964 error (_("Too many args in frame specification"));
967 static struct frame_info *
968 parse_frame_specification (char *frame_exp)
970 return parse_frame_specification_1 (frame_exp, NULL, NULL);
973 /* Print verbosely the selected frame or the frame at address
974 ADDR_EXP. Absolutely all information in the frame is printed. */
977 frame_info (char *addr_exp, int from_tty)
979 struct frame_info *fi;
980 struct symtab_and_line sal;
983 struct frame_info *calling_frame_info;
986 enum language funlang = language_unknown;
987 const char *pc_regname;
988 int selected_frame_p;
989 struct gdbarch *gdbarch;
990 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
995 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
996 gdbarch = get_frame_arch (fi);
998 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
999 is not a good name. */
1000 if (gdbarch_pc_regnum (gdbarch) >= 0)
1001 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1002 easily not match that of the internal value returned by
1004 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1006 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1007 architectures will often have a hardware register called "pc",
1008 and that register's value, again, can easily not match
1012 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1013 find_frame_sal (fi, &sal);
1014 func = get_frame_function (fi);
1018 funname = SYMBOL_PRINT_NAME (func);
1019 funlang = SYMBOL_LANGUAGE (func);
1020 if (funlang == language_cplus)
1022 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1023 to display the demangled name that we already have
1024 stored in the symbol table, but we stored a version
1025 with DMGL_PARAMS turned on, and here we don't want to
1026 display parameters. So remove the parameters. */
1027 char *func_only = cp_remove_params (funname);
1031 funname = func_only;
1032 make_cleanup (xfree, func_only);
1036 else if (frame_pc_p)
1038 struct minimal_symbol *msymbol;
1040 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1041 if (msymbol != NULL)
1043 funname = SYMBOL_PRINT_NAME (msymbol);
1044 funlang = SYMBOL_LANGUAGE (msymbol);
1047 calling_frame_info = get_prev_frame (fi);
1049 if (selected_frame_p && frame_relative_level (fi) >= 0)
1051 printf_filtered (_("Stack level %d, frame at "),
1052 frame_relative_level (fi));
1056 printf_filtered (_("Stack frame at "));
1058 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1059 printf_filtered (":\n");
1060 printf_filtered (" %s = ", pc_regname);
1062 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1064 fputs_filtered ("<unavailable>", gdb_stdout);
1069 printf_filtered (" in ");
1070 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1071 DMGL_ANSI | DMGL_PARAMS);
1075 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
1076 puts_filtered ("; ");
1078 printf_filtered ("saved %s ", pc_regname);
1079 if (frame_unwind_caller_pc_if_available (fi, &caller_pc))
1080 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1082 fputs_filtered ("<unavailable>", gdb_stdout);
1083 printf_filtered ("\n");
1085 if (calling_frame_info == NULL)
1087 enum unwind_stop_reason reason;
1089 reason = get_frame_unwind_stop_reason (fi);
1090 if (reason != UNWIND_NO_REASON)
1091 printf_filtered (_(" Outermost frame: %s\n"),
1092 frame_stop_reason_string (reason));
1094 else if (get_frame_type (fi) == INLINE_FRAME)
1095 printf_filtered (" inlined into frame %d",
1096 frame_relative_level (get_prev_frame (fi)));
1099 printf_filtered (" called by frame at ");
1100 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1103 if (get_next_frame (fi) && calling_frame_info)
1104 puts_filtered (",");
1106 if (get_next_frame (fi))
1108 printf_filtered (" caller of frame at ");
1109 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1112 if (get_next_frame (fi) || calling_frame_info)
1113 puts_filtered ("\n");
1116 printf_filtered (" source language %s.\n",
1117 language_str (s->language));
1120 /* Address of the argument list for this frame, or 0. */
1121 CORE_ADDR arg_list = get_frame_args_address (fi);
1122 /* Number of args for this frame, or -1 if unknown. */
1126 printf_filtered (" Arglist at unknown address.\n");
1129 printf_filtered (" Arglist at ");
1130 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1131 printf_filtered (",");
1133 if (!gdbarch_frame_num_args_p (gdbarch))
1136 puts_filtered (" args: ");
1140 numargs = gdbarch_frame_num_args (gdbarch, fi);
1141 gdb_assert (numargs >= 0);
1143 puts_filtered (" no args.");
1144 else if (numargs == 1)
1145 puts_filtered (" 1 arg: ");
1147 printf_filtered (" %d args: ", numargs);
1149 print_frame_args (func, fi, numargs, gdb_stdout);
1150 puts_filtered ("\n");
1154 /* Address of the local variables for this frame, or 0. */
1155 CORE_ADDR arg_list = get_frame_locals_address (fi);
1158 printf_filtered (" Locals at unknown address,");
1161 printf_filtered (" Locals at ");
1162 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1163 printf_filtered (",");
1167 /* Print as much information as possible on the location of all the
1170 enum lval_type lval;
1179 /* The sp is special; what's displayed isn't the save address, but
1180 the value of the previous frame's sp. This is a legacy thing,
1181 at one stage the frame cached the previous frame's SP instead
1182 of its address, hence it was easiest to just display the cached
1184 if (gdbarch_sp_regnum (gdbarch) >= 0)
1186 /* Find out the location of the saved stack pointer with out
1187 actually evaluating it. */
1188 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1189 &optimized, &unavailable, &lval, &addr,
1191 if (!optimized && !unavailable && lval == not_lval)
1193 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1194 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1195 gdb_byte value[MAX_REGISTER_SIZE];
1198 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1199 &optimized, &unavailable, &lval, &addr,
1201 /* NOTE: cagney/2003-05-22: This is assuming that the
1202 stack pointer was packed as an unsigned integer. That
1203 may or may not be valid. */
1204 sp = extract_unsigned_integer (value, sp_size, byte_order);
1205 printf_filtered (" Previous frame's sp is ");
1206 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1207 printf_filtered ("\n");
1210 else if (!optimized && !unavailable && lval == lval_memory)
1212 printf_filtered (" Previous frame's sp at ");
1213 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1214 printf_filtered ("\n");
1217 else if (!optimized && !unavailable && lval == lval_register)
1219 printf_filtered (" Previous frame's sp in %s\n",
1220 gdbarch_register_name (gdbarch, realnum));
1223 /* else keep quiet. */
1227 numregs = gdbarch_num_regs (gdbarch)
1228 + gdbarch_num_pseudo_regs (gdbarch);
1229 for (i = 0; i < numregs; i++)
1230 if (i != gdbarch_sp_regnum (gdbarch)
1231 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1233 /* Find out the location of the saved register without
1234 fetching the corresponding value. */
1235 frame_register_unwind (fi, i, &optimized, &unavailable,
1236 &lval, &addr, &realnum, NULL);
1237 /* For moment, only display registers that were saved on the
1239 if (!optimized && !unavailable && lval == lval_memory)
1242 puts_filtered (" Saved registers:\n ");
1244 puts_filtered (",");
1246 printf_filtered (" %s at ",
1247 gdbarch_register_name (gdbarch, i));
1248 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1252 if (count || need_nl)
1253 puts_filtered ("\n");
1256 do_cleanups (back_to);
1259 /* Print briefly all stack frames or just the innermost COUNT_EXP
1263 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1265 struct frame_info *fi;
1268 struct frame_info *trailing;
1271 if (!target_has_stack)
1272 error (_("No stack."));
1274 /* The following code must do two things. First, it must set the
1275 variable TRAILING to the frame from which we should start
1276 printing. Second, it must set the variable count to the number
1277 of frames which we should print, or -1 if all of them. */
1278 trailing = get_current_frame ();
1283 count = parse_and_eval_long (count_exp);
1286 struct frame_info *current;
1291 while (current && count--)
1294 current = get_prev_frame (current);
1297 /* Will stop when CURRENT reaches the top of the stack.
1298 TRAILING will be COUNT below it. */
1302 trailing = get_prev_frame (trailing);
1303 current = get_prev_frame (current);
1315 /* Read in symbols for all of the frames. Need to do this in a
1316 separate pass so that "Reading in symbols for xxx" messages
1317 don't screw up the appearance of the backtrace. Also if
1318 people have strong opinions against reading symbols for
1319 backtrace this may have to be an option. */
1321 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1326 pc = get_frame_address_in_block (fi);
1327 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc));
1331 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1335 /* Don't use print_stack_frame; if an error() occurs it probably
1336 means further attempts to backtrace would fail (on the other
1337 hand, perhaps the code does or could be fixed to make sure
1338 the frame->prev field gets set to NULL in that case). */
1339 print_frame_info (fi, 1, LOCATION, 1);
1341 print_frame_local_vars (fi, 1, gdb_stdout);
1343 /* Save the last frame to check for error conditions. */
1347 /* If we've stopped before the end, mention that. */
1349 printf_filtered (_("(More stack frames follow...)\n"));
1351 /* If we've run out of frames, and the reason appears to be an error
1352 condition, print it. */
1353 if (fi == NULL && trailing != NULL)
1355 enum unwind_stop_reason reason;
1357 reason = get_frame_unwind_stop_reason (trailing);
1358 if (reason > UNWIND_FIRST_ERROR)
1359 printf_filtered (_("Backtrace stopped: %s\n"),
1360 frame_stop_reason_string (reason));
1365 backtrace_command (char *arg, int from_tty)
1367 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1368 int fulltrace_arg = -1, arglen = 0, argc = 0;
1375 argv = gdb_buildargv (arg);
1376 make_cleanup_freeargv (argv);
1378 for (i = 0; argv[i]; i++)
1382 for (j = 0; j < strlen (argv[i]); j++)
1383 argv[i][j] = tolower (argv[i][j]);
1385 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1386 fulltrace_arg = argc;
1389 arglen += strlen (argv[i]);
1394 if (fulltrace_arg >= 0)
1398 arg = xmalloc (arglen + 1);
1399 make_cleanup (xfree, arg);
1401 for (i = 0; i < (argc + 1); i++)
1403 if (i != fulltrace_arg)
1405 strcat (arg, argv[i]);
1415 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, from_tty);
1417 do_cleanups (old_chain);
1421 backtrace_full_command (char *arg, int from_tty)
1423 backtrace_command_1 (arg, 1 /* show_locals */, from_tty);
1427 /* Iterate over the local variables of a block B, calling CB with
1431 iterate_over_block_locals (struct block *b,
1432 iterate_over_block_arg_local_vars_cb cb,
1435 struct dict_iterator iter;
1438 ALL_BLOCK_SYMBOLS (b, iter, sym)
1440 switch (SYMBOL_CLASS (sym))
1446 if (SYMBOL_IS_ARGUMENT (sym))
1448 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1452 /* Ignore symbols which are not locals. */
1459 /* Same, but print labels. */
1462 /* Commented out, as the code using this function has also been
1463 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1464 was commented out in the first place. The discussion introducing
1465 this change (2007-12-04: Support lexical blocks and function bodies
1466 that occupy non-contiguous address ranges) did not explain why
1467 this change was made. */
1469 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1470 int *have_default, struct ui_file *stream)
1472 struct dict_iterator iter;
1474 int values_printed = 0;
1476 ALL_BLOCK_SYMBOLS (b, iter, sym)
1478 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1484 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1486 struct symtab_and_line sal;
1487 struct value_print_options opts;
1489 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1491 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1492 get_user_print_options (&opts);
1493 if (opts.addressprint)
1495 fprintf_filtered (stream, " ");
1496 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1499 fprintf_filtered (stream, " in file %s, line %d\n",
1500 sal.symtab->filename, sal.line);
1504 return values_printed;
1508 /* Iterate over all the local variables in block B, including all its
1509 superblocks, stopping when the top-level block is reached. */
1512 iterate_over_block_local_vars (struct block *block,
1513 iterate_over_block_arg_local_vars_cb cb,
1518 iterate_over_block_locals (block, cb, cb_data);
1519 /* After handling the function's top-level block, stop. Don't
1520 continue to its superblock, the block of per-file
1522 if (BLOCK_FUNCTION (block))
1524 block = BLOCK_SUPERBLOCK (block);
1528 /* Data to be passed around in the calls to the locals and args
1531 struct print_variable_and_value_data
1533 struct frame_info *frame;
1535 struct ui_file *stream;
1539 /* The callback for the locals and args iterators. */
1542 do_print_variable_and_value (const char *print_name,
1546 struct print_variable_and_value_data *p = cb_data;
1548 print_variable_and_value (print_name, sym,
1549 p->frame, p->stream, p->num_tabs);
1550 p->values_printed = 1;
1554 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1555 struct ui_file *stream)
1557 struct print_variable_and_value_data cb_data;
1558 struct block *block;
1561 if (!get_frame_pc_if_available (frame, &pc))
1563 fprintf_filtered (stream,
1564 _("PC unavailable, cannot determine locals.\n"));
1568 block = get_frame_block (frame, 0);
1571 fprintf_filtered (stream, "No symbol table info available.\n");
1575 cb_data.frame = frame;
1576 cb_data.num_tabs = 4 * num_tabs;
1577 cb_data.stream = stream;
1578 cb_data.values_printed = 0;
1580 iterate_over_block_local_vars (block,
1581 do_print_variable_and_value,
1584 if (!cb_data.values_printed)
1585 fprintf_filtered (stream, _("No locals.\n"));
1588 /* Same, but print labels. */
1591 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1592 struct ui_file *stream)
1595 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1597 struct blockvector *bl;
1598 struct block *block = get_frame_block (frame, 0);
1599 struct gdbarch *gdbarch = get_frame_arch (frame);
1600 int values_printed = 0;
1601 int index, have_default = 0;
1602 char *blocks_printed;
1603 CORE_ADDR pc = get_frame_pc (frame);
1607 fprintf_filtered (stream, "No symbol table info available.\n");
1611 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1612 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1613 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1617 CORE_ADDR end = BLOCK_END (block) - 4;
1620 if (bl != blockvector_for_pc (end, &index))
1621 error (_("blockvector blotch"));
1622 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1623 error (_("blockvector botch"));
1624 last_index = BLOCKVECTOR_NBLOCKS (bl);
1627 /* Don't print out blocks that have gone by. */
1628 while (index < last_index
1629 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1632 while (index < last_index
1633 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1635 if (blocks_printed[index] == 0)
1637 if (print_block_frame_labels (gdbarch,
1638 BLOCKVECTOR_BLOCK (bl, index),
1639 &have_default, stream))
1641 blocks_printed[index] = 1;
1647 if (values_printed && this_level_only)
1650 /* After handling the function's top-level block, stop. Don't
1651 continue to its superblock, the block of per-file symbols.
1652 Also do not continue to the containing function of an inlined
1654 if (BLOCK_FUNCTION (block))
1656 block = BLOCK_SUPERBLOCK (block);
1659 if (!values_printed && !this_level_only)
1660 fprintf_filtered (stream, _("No catches.\n"));
1665 locals_info (char *args, int from_tty)
1667 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1672 catch_info (char *ignore, int from_tty)
1674 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1675 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1679 /* Iterate over all the argument variables in block B.
1681 Returns 1 if any argument was walked; 0 otherwise. */
1684 iterate_over_block_arg_vars (struct block *b,
1685 iterate_over_block_arg_local_vars_cb cb,
1688 struct dict_iterator iter;
1689 struct symbol *sym, *sym2;
1691 ALL_BLOCK_SYMBOLS (b, iter, sym)
1693 /* Don't worry about things which aren't arguments. */
1694 if (SYMBOL_IS_ARGUMENT (sym))
1696 /* We have to look up the symbol because arguments can have
1697 two entries (one a parameter, one a local) and the one we
1698 want is the local, which lookup_symbol will find for us.
1699 This includes gcc1 (not gcc2) on the sparc when passing a
1700 small structure and gcc2 when the argument type is float
1701 and it is passed as a double and converted to float by
1702 the prologue (in the latter case the type of the LOC_ARG
1703 symbol is double and the type of the LOC_LOCAL symbol is
1704 float). There are also LOC_ARG/LOC_REGISTER pairs which
1705 are not combined in symbol-reading. */
1707 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
1708 b, VAR_DOMAIN, NULL);
1709 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
1715 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1717 struct print_variable_and_value_data cb_data;
1718 struct symbol *func;
1721 if (!get_frame_pc_if_available (frame, &pc))
1723 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
1727 func = get_frame_function (frame);
1730 fprintf_filtered (stream, _("No symbol table info available.\n"));
1734 cb_data.frame = frame;
1735 cb_data.num_tabs = 0;
1736 cb_data.stream = gdb_stdout;
1737 cb_data.values_printed = 0;
1739 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
1740 do_print_variable_and_value, &cb_data);
1742 if (!cb_data.values_printed)
1743 fprintf_filtered (stream, _("No arguments.\n"));
1747 args_info (char *ignore, int from_tty)
1749 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1755 args_plus_locals_info (char *ignore, int from_tty)
1757 args_info (ignore, from_tty);
1758 locals_info (ignore, from_tty);
1762 /* Select frame FRAME. Also print the stack frame and show the source
1763 if this is the tui version. */
1765 select_and_print_frame (struct frame_info *frame)
1767 select_frame (frame);
1769 print_stack_frame (frame, 1, SRC_AND_LOC);
1772 /* Return the symbol-block in which the selected frame is executing.
1773 Can return zero under various legitimate circumstances.
1775 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1776 code address within the block returned. We use this to decide
1777 which macros are in scope. */
1780 get_selected_block (CORE_ADDR *addr_in_block)
1782 if (!has_stack_frames ())
1785 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1788 /* Find a frame a certain number of levels away from FRAME.
1789 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1790 Positive means go to earlier frames (up); negative, the reverse.
1791 The int that contains the number of levels is counted toward
1792 zero as the frames for those levels are found.
1793 If the top or bottom frame is reached, that frame is returned,
1794 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1795 how much farther the original request asked to go. */
1798 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1800 /* Going up is simple: just call get_prev_frame enough times or
1801 until the initial frame is reached. */
1802 while (*level_offset_ptr > 0)
1804 struct frame_info *prev = get_prev_frame (frame);
1808 (*level_offset_ptr)--;
1812 /* Going down is just as simple. */
1813 while (*level_offset_ptr < 0)
1815 struct frame_info *next = get_next_frame (frame);
1819 (*level_offset_ptr)++;
1826 /* The "select_frame" command. With no argument this is a NOP.
1827 Select the frame at level LEVEL_EXP if it is a valid level.
1828 Otherwise, treat LEVEL_EXP as an address expression and select it.
1830 See parse_frame_specification for more info on proper frame
1834 select_frame_command (char *level_exp, int from_tty)
1836 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1839 /* The "frame" command. With no argument, print the selected frame
1840 briefly. With an argument, behave like select_frame and then print
1841 the selected frame. */
1844 frame_command (char *level_exp, int from_tty)
1846 select_frame_command (level_exp, from_tty);
1847 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1850 /* The XDB Compatibility command to print the current frame. */
1853 current_frame_command (char *level_exp, int from_tty)
1855 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1858 /* Select the frame up one or COUNT_EXP stack levels from the
1859 previously selected frame, and print it briefly. */
1862 up_silently_base (char *count_exp)
1864 struct frame_info *frame;
1868 count = parse_and_eval_long (count_exp);
1870 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1871 if (count != 0 && count_exp == NULL)
1872 error (_("Initial frame selected; you cannot go up."));
1873 select_frame (frame);
1877 up_silently_command (char *count_exp, int from_tty)
1879 up_silently_base (count_exp);
1883 up_command (char *count_exp, int from_tty)
1885 up_silently_base (count_exp);
1886 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1889 /* Select the frame down one or COUNT_EXP stack levels from the previously
1890 selected frame, and print it briefly. */
1893 down_silently_base (char *count_exp)
1895 struct frame_info *frame;
1899 count = -parse_and_eval_long (count_exp);
1901 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1902 if (count != 0 && count_exp == NULL)
1904 /* We only do this if COUNT_EXP is not specified. That way
1905 "down" means to really go down (and let me know if that is
1906 impossible), but "down 9999" can be used to mean go all the
1907 way down without getting an error. */
1909 error (_("Bottom (innermost) frame selected; you cannot go down."));
1912 select_frame (frame);
1916 down_silently_command (char *count_exp, int from_tty)
1918 down_silently_base (count_exp);
1922 down_command (char *count_exp, int from_tty)
1924 down_silently_base (count_exp);
1925 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1930 return_command (char *retval_exp, int from_tty)
1932 struct frame_info *thisframe;
1933 struct gdbarch *gdbarch;
1934 struct symbol *thisfun;
1935 struct value *return_value = NULL;
1936 const char *query_prefix = "";
1938 thisframe = get_selected_frame ("No selected frame.");
1939 thisfun = get_frame_function (thisframe);
1940 gdbarch = get_frame_arch (thisframe);
1942 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
1943 error (_("Can not force return from an inlined function."));
1945 /* Compute the return value. If the computation triggers an error,
1946 let it bail. If the return type can't be handled, set
1947 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1951 struct expression *retval_expr = parse_expression (retval_exp);
1952 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
1953 struct type *return_type = NULL;
1955 /* Compute the return value. Should the computation fail, this
1956 call throws an error. */
1957 return_value = evaluate_expression (retval_expr);
1959 /* Cast return value to the return type of the function. Should
1960 the cast fail, this call throws an error. */
1961 if (thisfun != NULL)
1962 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1963 if (return_type == NULL)
1965 if (retval_expr->elts[0].opcode != UNOP_CAST)
1966 error (_("Return value type not available for selected "
1968 "Please use an explicit cast of the value to return."));
1969 return_type = value_type (return_value);
1971 do_cleanups (old_chain);
1972 CHECK_TYPEDEF (return_type);
1973 return_value = value_cast (return_type, return_value);
1975 /* Make sure the value is fully evaluated. It may live in the
1976 stack frame we're about to pop. */
1977 if (value_lazy (return_value))
1978 value_fetch_lazy (return_value);
1980 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1981 /* If the return-type is "void", don't try to find the
1982 return-value's location. However, do still evaluate the
1983 return expression so that, even when the expression result
1984 is discarded, side effects such as "return i++" still
1986 return_value = NULL;
1987 else if (thisfun != NULL
1988 && using_struct_return (gdbarch,
1989 SYMBOL_TYPE (thisfun), return_type))
1991 query_prefix = "The location at which to store the "
1992 "function's return value is unknown.\n"
1993 "If you continue, the return value "
1994 "that you specified will be ignored.\n";
1995 return_value = NULL;
1999 /* Does an interactive user really want to do this? Include
2000 information, such as how well GDB can handle the return value, in
2001 the query message. */
2006 if (thisfun == NULL)
2007 confirmed = query (_("%sMake selected stack frame return now? "),
2010 confirmed = query (_("%sMake %s return now? "), query_prefix,
2011 SYMBOL_PRINT_NAME (thisfun));
2013 error (_("Not confirmed"));
2016 /* Discard the selected frame and all frames inner-to it. */
2017 frame_pop (get_selected_frame (NULL));
2019 /* Store RETURN_VALUE in the just-returned register set. */
2020 if (return_value != NULL)
2022 struct type *return_type = value_type (return_value);
2023 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2024 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
2026 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
2028 == RETURN_VALUE_REGISTER_CONVENTION);
2029 gdbarch_return_value (gdbarch, func_type, return_type,
2030 get_current_regcache (), NULL /*read*/,
2031 value_contents (return_value) /*write*/);
2034 /* If we are at the end of a call dummy now, pop the dummy frame
2036 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2037 frame_pop (get_current_frame ());
2039 /* If interactive, print the frame that is now current. */
2041 frame_command ("0", 1);
2043 select_frame_command ("0", 0);
2046 /* Sets the scope to input function name, provided that the function
2047 is within the current stack frame. */
2049 struct function_bounds
2051 CORE_ADDR low, high;
2055 func_command (char *arg, int from_tty)
2057 struct frame_info *frame;
2059 struct symtabs_and_lines sals;
2062 struct function_bounds *func_bounds = NULL;
2067 frame = parse_frame_specification ("0");
2068 sals = decode_line_spec (arg, 1);
2069 func_bounds = (struct function_bounds *) xmalloc (
2070 sizeof (struct function_bounds) * sals.nelts);
2071 for (i = 0; (i < sals.nelts && !found); i++)
2073 if (sals.sals[i].pc == 0
2074 || find_pc_partial_function (sals.sals[i].pc, NULL,
2075 &func_bounds[i].low,
2076 &func_bounds[i].high) == 0)
2078 func_bounds[i].low = func_bounds[i].high = 0;
2084 for (i = 0; (i < sals.nelts && !found); i++)
2085 found = (get_frame_pc (frame) >= func_bounds[i].low
2086 && get_frame_pc (frame) < func_bounds[i].high);
2090 frame = find_relative_frame (frame, &level);
2093 while (!found && level == 0);
2096 xfree (func_bounds);
2099 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2100 else if (frame != get_selected_frame (NULL))
2101 select_and_print_frame (frame);
2104 /* Gets the language of the current frame. */
2107 get_frame_language (void)
2109 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2113 volatile struct gdb_exception ex;
2117 /* We determine the current frame language by looking up its
2118 associated symtab. To retrieve this symtab, we use the frame
2119 PC. However we cannot use the frame PC as is, because it
2120 usually points to the instruction following the "call", which
2121 is sometimes the first instruction of another function. So
2122 we rely on get_frame_address_in_block(), it provides us with
2123 a PC that is guaranteed to be inside the frame's code
2126 TRY_CATCH (ex, RETURN_MASK_ERROR)
2128 pc = get_frame_address_in_block (frame);
2132 if (ex.error != NOT_AVAILABLE_ERROR)
2133 throw_exception (ex);
2137 s = find_pc_symtab (pc);
2143 return language_unknown;
2147 /* Provide a prototype to silence -Wmissing-prototypes. */
2148 void _initialize_stack (void);
2151 _initialize_stack (void)
2153 add_com ("return", class_stack, return_command, _("\
2154 Make selected stack frame return to its caller.\n\
2155 Control remains in the debugger, but when you continue\n\
2156 execution will resume in the frame above the one now selected.\n\
2157 If an argument is given, it is an expression for the value to return."));
2159 add_com ("up", class_stack, up_command, _("\
2160 Select and print stack frame that called this one.\n\
2161 An argument says how many frames up to go."));
2162 add_com ("up-silently", class_support, up_silently_command, _("\
2163 Same as the `up' command, but does not print anything.\n\
2164 This is useful in command scripts."));
2166 add_com ("down", class_stack, down_command, _("\
2167 Select and print stack frame called by this one.\n\
2168 An argument says how many frames down to go."));
2169 add_com_alias ("do", "down", class_stack, 1);
2170 add_com_alias ("dow", "down", class_stack, 1);
2171 add_com ("down-silently", class_support, down_silently_command, _("\
2172 Same as the `down' command, but does not print anything.\n\
2173 This is useful in command scripts."));
2175 add_com ("frame", class_stack, frame_command, _("\
2176 Select and print a stack frame.\nWith no argument, \
2177 print the selected stack frame. (See also \"info frame\").\n\
2178 An argument specifies the frame to select.\n\
2179 It can be a stack frame number or the address of the frame.\n\
2180 With argument, nothing is printed if input is coming from\n\
2181 a command file or a user-defined command."));
2183 add_com_alias ("f", "frame", class_stack, 1);
2187 add_com ("L", class_stack, current_frame_command,
2188 _("Print the current stack frame.\n"));
2189 add_com_alias ("V", "frame", class_stack, 1);
2191 add_com ("select-frame", class_stack, select_frame_command, _("\
2192 Select a stack frame without printing anything.\n\
2193 An argument specifies the frame to select.\n\
2194 It can be a stack frame number or the address of the frame.\n"));
2196 add_com ("backtrace", class_stack, backtrace_command, _("\
2197 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2198 With a negative argument, print outermost -COUNT frames.\nUse of the \
2199 'full' qualifier also prints the values of the local variables.\n"));
2200 add_com_alias ("bt", "backtrace", class_stack, 0);
2203 add_com_alias ("t", "backtrace", class_stack, 0);
2204 add_com ("T", class_stack, backtrace_full_command, _("\
2205 Print backtrace of all stack frames, or innermost COUNT frames\n\
2206 and the values of the local variables.\n\
2207 With a negative argument, print outermost -COUNT frames.\n\
2208 Usage: T <count>\n"));
2211 add_com_alias ("where", "backtrace", class_alias, 0);
2212 add_info ("stack", backtrace_command,
2213 _("Backtrace of the stack, or innermost COUNT frames."));
2214 add_info_alias ("s", "stack", 1);
2215 add_info ("frame", frame_info,
2216 _("All about selected stack frame, or frame at ADDR."));
2217 add_info_alias ("f", "frame", 1);
2218 add_info ("locals", locals_info,
2219 _("Local variables of current stack frame."));
2220 add_info ("args", args_info,
2221 _("Argument variables of current stack frame."));
2223 add_com ("l", class_info, args_plus_locals_info,
2224 _("Argument and local variables of current stack frame."));
2227 add_com ("func", class_stack, func_command, _("\
2228 Select the stack frame that contains <func>.\n\
2229 Usage: func <name>\n"));
2231 add_info ("catch", catch_info,
2232 _("Exceptions that can be caught in the current stack frame."));
2234 add_setshow_enum_cmd ("frame-arguments", class_stack,
2235 print_frame_arguments_choices, &print_frame_arguments,
2236 _("Set printing of non-scalar frame arguments"),
2237 _("Show printing of non-scalar frame arguments"),
2238 NULL, NULL, NULL, &setprintlist, &showprintlist);
2240 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2241 &disassemble_next_line, _("\
2242 Set whether to disassemble next source line or insn when execution stops."),
2244 Show whether to disassemble next source line or insn when execution stops."),
2246 If ON, GDB will display disassembly of the next source line, in addition\n\
2247 to displaying the source line itself. If the next source line cannot\n\
2248 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2249 will display disassembly of next instruction instead of showing the\n\
2251 If AUTO, display disassembly of next instruction only if the source line\n\
2252 cannot be displayed.\n\
2253 If OFF (which is the default), never display the disassembly of the next\n\
2256 show_disassemble_next_line,
2257 &setlist, &showlist);
2258 disassemble_next_line = AUTO_BOOLEAN_FALSE;