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 struct print_stack_frame_args
87 struct frame_info *frame;
89 enum print_what print_what;
93 /* Show or print the frame arguments; stub for catch_errors. */
96 print_stack_frame_stub (void *args)
98 struct print_stack_frame_args *p = args;
99 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
101 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
102 set_current_sal_from_frame (p->frame, center);
106 /* Return 1 if we should display the address in addition to the location,
107 because we are in the middle of a statement. */
110 frame_show_address (struct frame_info *frame,
111 struct symtab_and_line sal)
113 /* If there is a line number, but no PC, then there is no location
114 information associated with this sal. The only way that should
115 happen is for the call sites of inlined functions (SAL comes from
116 find_frame_sal). Otherwise, we would have some PC range if the
117 SAL came from a line table. */
118 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
120 if (get_next_frame (frame) == NULL)
121 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
123 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
127 return get_frame_pc (frame) != sal.pc;
130 /* Show or print a stack frame FRAME briefly. The output is format
131 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
132 relative level, function name, argument list, and file name and
133 line number. If the frame's PC is not at the beginning of the
134 source line, the actual PC is printed at the beginning. */
137 print_stack_frame (struct frame_info *frame, int print_level,
138 enum print_what print_what)
140 struct print_stack_frame_args args;
143 args.print_level = print_level;
144 args.print_what = print_what;
145 /* For mi, alway print location and address. */
146 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
149 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
152 struct print_args_args
155 struct frame_info *frame;
156 struct ui_file *stream;
159 static int print_args_stub (void *args);
161 /* Print nameless arguments of frame FRAME on STREAM, where START is
162 the offset of the first nameless argument, and NUM is the number of
163 nameless arguments to print. FIRST is nonzero if this is the first
164 argument (not just the first nameless argument). */
167 print_frame_nameless_args (struct frame_info *frame, long start, int num,
168 int first, struct ui_file *stream)
170 struct gdbarch *gdbarch = get_frame_arch (frame);
171 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
176 for (i = 0; i < num; i++)
179 argsaddr = get_frame_args_address (frame);
182 arg_value = read_memory_integer (argsaddr + start,
183 sizeof (int), byte_order);
185 fprintf_filtered (stream, ", ");
186 fprintf_filtered (stream, "%ld", arg_value);
188 start += sizeof (int);
192 /* Print the arguments of frame FRAME on STREAM, given the function
193 FUNC running in that frame (as a symbol), where NUM is the number
194 of arguments according to the stack frame (or -1 if the number of
195 arguments is unknown). */
197 /* Note that currently the "number of arguments according to the
198 stack frame" is only known on VAX where i refers to the "number of
199 ints of arguments according to the stack frame". */
202 print_frame_args (struct symbol *func, struct frame_info *frame,
203 int num, struct ui_file *stream)
206 /* Offset of next stack argument beyond the one we have seen that is
207 at the highest offset, or -1 if we haven't come to a stack
209 long highest_offset = -1;
210 /* Number of ints of arguments that we have printed so far. */
211 int args_printed = 0;
212 struct cleanup *old_chain, *list_chain;
213 struct ui_stream *stb;
214 /* True if we should print arguments, false otherwise. */
215 int print_args = strcmp (print_frame_arguments, "none");
216 /* True in "summary" mode, false otherwise. */
217 int summary = !strcmp (print_frame_arguments, "scalars");
219 stb = ui_out_stream_new (uiout);
220 old_chain = make_cleanup_ui_out_stream_delete (stb);
224 struct block *b = SYMBOL_BLOCK_VALUE (func);
225 struct dict_iterator iter;
229 ALL_BLOCK_SYMBOLS (b, iter, sym)
233 /* Keep track of the highest stack argument offset seen, and
234 skip over any kinds of symbols we don't care about. */
236 if (!SYMBOL_IS_ARGUMENT (sym))
239 switch (SYMBOL_CLASS (sym))
244 long current_offset = SYMBOL_VALUE (sym);
245 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
247 /* Compute address of next argument by adding the size of
248 this argument and rounding to an int boundary. */
250 ((current_offset + arg_size + sizeof (int) - 1)
251 & ~(sizeof (int) - 1));
253 /* If this is the highest offset seen yet, set
255 if (highest_offset == -1
256 || (current_offset > highest_offset))
257 highest_offset = current_offset;
259 /* Add the number of ints we're about to print to
261 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
264 /* We care about types of symbols, but don't need to
265 keep track of stack offsets in them. */
267 case LOC_REGPARM_ADDR:
269 case LOC_OPTIMIZED_OUT:
274 /* We have to look up the symbol because arguments can have
275 two entries (one a parameter, one a local) and the one we
276 want is the local, which lookup_symbol will find for us.
277 This includes gcc1 (not gcc2) on SPARC when passing a
278 small structure and gcc2 when the argument type is float
279 and it is passed as a double and converted to float by
280 the prologue (in the latter case the type of the LOC_ARG
281 symbol is double and the type of the LOC_LOCAL symbol is
283 /* But if the parameter name is null, don't try it. Null
284 parameter names occur on the RS/6000, for traceback
285 tables. FIXME, should we even print them? */
287 if (*SYMBOL_LINKAGE_NAME (sym))
291 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
292 b, VAR_DOMAIN, NULL);
293 gdb_assert (nsym != NULL);
294 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
295 && !SYMBOL_IS_ARGUMENT (nsym))
297 /* There is a LOC_ARG/LOC_REGISTER pair. This means
298 that it was passed on the stack and loaded into a
299 register, or passed in a register and stored in a
300 stack slot. GDB 3.x used the LOC_ARG; GDB
301 4.0-4.11 used the LOC_REGISTER.
303 Reasons for using the LOC_ARG:
305 (1) Because find_saved_registers may be slow for
308 (2) Because registers are often re-used and stack
309 slots rarely (never?) are. Therefore using
310 the stack slot is much less likely to print
313 Reasons why we might want to use the LOC_REGISTER:
315 (1) So that the backtrace prints the same value
316 as "print foo". I see no compelling reason
317 why this needs to be the case; having the
318 backtrace print the value which was passed
319 in, and "print foo" print the value as
320 modified within the called function, makes
323 Additional note: It might be nice if "info args"
324 displayed both values.
326 One more note: There is a case with SPARC
327 structure passing where we need to use the
328 LOC_REGISTER, but this is dealt with by creating
329 a single LOC_REGPARM in symbol reading. */
331 /* Leave sym (the LOC_ARG) alone. */
338 /* Print the current arg. */
340 ui_out_text (uiout, ", ");
341 ui_out_wrap_hint (uiout, " ");
343 annotate_arg_begin ();
345 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
346 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
347 SYMBOL_LANGUAGE (sym),
348 DMGL_PARAMS | DMGL_ANSI);
349 ui_out_field_stream (uiout, "name", stb);
350 annotate_arg_name_end ();
351 ui_out_text (uiout, "=");
355 /* Avoid value_print because it will deref ref parameters.
356 We just want to print their addresses. Print ??? for
357 args whose address we do not know. We pass 2 as
358 "recurse" to val_print because our standard indentation
359 here is 4 spaces, and val_print indents 2 for each
361 val = read_var_value (sym, frame);
363 annotate_arg_value (val == NULL ? NULL : value_type (val));
367 const struct language_defn *language;
368 struct value_print_options opts;
370 /* Use the appropriate language to display our symbol,
371 unless the user forced the language to a specific
373 if (language_mode == language_mode_auto)
374 language = language_def (SYMBOL_LANGUAGE (sym));
376 language = current_language;
378 get_raw_print_options (&opts);
380 opts.summary = summary;
381 common_val_print (val, stb->stream, 2, &opts, language);
382 ui_out_field_stream (uiout, "value", stb);
385 ui_out_text (uiout, "???");
388 ui_out_text (uiout, "...");
391 /* Invoke ui_out_tuple_end. */
392 do_cleanups (list_chain);
400 /* Don't print nameless args in situations where we don't know
401 enough about the stack to find them. */
406 if (highest_offset == -1)
407 start = gdbarch_frame_args_skip (get_frame_arch (frame));
409 start = highest_offset;
411 print_frame_nameless_args (frame, start, num - args_printed,
415 do_cleanups (old_chain);
418 /* Stub for catch_errors. */
421 print_args_stub (void *args)
423 struct print_args_args *p = args;
424 struct gdbarch *gdbarch = get_frame_arch (p->frame);
427 if (gdbarch_frame_num_args_p (gdbarch))
429 numargs = gdbarch_frame_num_args (gdbarch, p->frame);
430 gdb_assert (numargs >= 0);
434 print_frame_args (p->func, p->frame, numargs, p->stream);
438 /* Set the current source and line to the location given by frame
439 FRAME, if possible. When CENTER is true, adjust so the relevant
440 line is in the center of the next 'list'. */
443 set_current_sal_from_frame (struct frame_info *frame, int center)
445 struct symtab_and_line sal;
447 find_frame_sal (frame, &sal);
451 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
452 set_current_source_symtab_and_line (&sal);
456 /* If ON, GDB will display disassembly of the next source line when
457 execution of the program being debugged stops.
458 If AUTO (which is the default), or there's no line info to determine
459 the source line of the next instruction, display disassembly of next
460 instruction instead. */
462 static enum auto_boolean disassemble_next_line;
465 show_disassemble_next_line (struct ui_file *file, int from_tty,
466 struct cmd_list_element *c,
469 fprintf_filtered (file,
470 _("Debugger's willingness to use "
471 "disassemble-next-line is %s.\n"),
475 /* Show assembly codes; stub for catch_errors. */
477 struct gdb_disassembly_stub_args
479 struct gdbarch *gdbarch;
486 gdb_disassembly_stub (void *args)
488 struct gdb_disassembly_stub_args *p = args;
490 gdb_disassembly (p->gdbarch, uiout, 0,
491 DISASSEMBLY_RAW_INSN, p->how_many,
495 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
496 because it will be broken by filter sometime. */
499 do_gdb_disassembly (struct gdbarch *gdbarch,
500 int how_many, CORE_ADDR low, CORE_ADDR high)
502 volatile struct gdb_exception exception;
503 struct gdb_disassembly_stub_args args;
505 args.gdbarch = gdbarch;
506 args.how_many = how_many;
509 TRY_CATCH (exception, RETURN_MASK_ALL)
511 gdb_disassembly_stub (&args);
513 /* If an exception was thrown while doing the disassembly, print
514 the error message, to give the user a clue of what happened. */
515 if (exception.reason == RETURN_ERROR)
516 exception_print (gdb_stderr, exception);
519 /* Print information about frame FRAME. The output is format according
520 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
523 SRC_LINE: Print only source line.
524 LOCATION: Print only location.
525 LOC_AND_SRC: Print location and source line.
527 Used in "where" output, and to emit breakpoint or step
531 print_frame_info (struct frame_info *frame, int print_level,
532 enum print_what print_what, int print_args)
534 struct gdbarch *gdbarch = get_frame_arch (frame);
535 struct symtab_and_line sal;
539 if (get_frame_type (frame) == DUMMY_FRAME
540 || get_frame_type (frame) == SIGTRAMP_FRAME
541 || get_frame_type (frame) == ARCH_FRAME)
543 struct cleanup *uiout_cleanup
544 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
546 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
547 gdbarch, get_frame_pc (frame));
549 /* Do this regardless of SOURCE because we don't have any source
550 to list for this frame. */
553 ui_out_text (uiout, "#");
554 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
555 frame_relative_level (frame));
557 if (ui_out_is_mi_like_p (uiout))
559 annotate_frame_address ();
560 ui_out_field_core_addr (uiout, "addr",
561 gdbarch, get_frame_pc (frame));
562 annotate_frame_address_end ();
565 if (get_frame_type (frame) == DUMMY_FRAME)
567 annotate_function_call ();
568 ui_out_field_string (uiout, "func", "<function called from gdb>");
570 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
572 annotate_signal_handler_caller ();
573 ui_out_field_string (uiout, "func", "<signal handler called>");
575 else if (get_frame_type (frame) == ARCH_FRAME)
577 ui_out_field_string (uiout, "func", "<cross-architecture call>");
579 ui_out_text (uiout, "\n");
580 annotate_frame_end ();
582 do_cleanups (uiout_cleanup);
586 /* If FRAME is not the innermost frame, that normally means that
587 FRAME->pc points to *after* the call instruction, and we want to
588 get the line containing the call, never the next line. But if
589 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
590 next frame was not entered as the result of a call, and we want
591 to get the line containing FRAME->pc. */
592 find_frame_sal (frame, &sal);
594 location_print = (print_what == LOCATION
595 || print_what == LOC_AND_ADDRESS
596 || print_what == SRC_AND_LOC);
598 if (location_print || !sal.symtab)
599 print_frame (frame, print_level, print_what, print_args, sal);
601 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
603 /* If disassemble-next-line is set to auto or on and doesn't have
604 the line debug messages for $pc, output the next instruction. */
605 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
606 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
607 && source_print && !sal.symtab)
608 do_gdb_disassembly (get_frame_arch (frame), 1,
609 get_frame_pc (frame), get_frame_pc (frame) + 1);
611 if (source_print && sal.symtab)
614 int mid_statement = ((print_what == SRC_LINE)
615 && frame_show_address (frame, sal));
617 if (annotation_level)
618 done = identify_source_line (sal.symtab, sal.line, mid_statement,
619 get_frame_pc (frame));
622 if (deprecated_print_frame_info_listing_hook)
623 deprecated_print_frame_info_listing_hook (sal.symtab,
628 struct value_print_options opts;
630 get_user_print_options (&opts);
631 /* We used to do this earlier, but that is clearly
632 wrong. This function is used by many different
633 parts of gdb, including normal_stop in infrun.c,
634 which uses this to print out the current PC
635 when we stepi/nexti into the middle of a source
636 line. Only the command line really wants this
637 behavior. Other UIs probably would like the
638 ability to decide for themselves if it is desired. */
639 if (opts.addressprint && mid_statement)
641 ui_out_field_core_addr (uiout, "addr",
642 gdbarch, get_frame_pc (frame));
643 ui_out_text (uiout, "\t");
646 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
650 /* If disassemble-next-line is set to on and there is line debug
651 messages, output assembly codes for next line. */
652 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
653 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
656 if (print_what != LOCATION)
660 if (get_frame_pc_if_available (frame, &pc))
661 set_default_breakpoint (1, sal.pspace, pc, sal.symtab, sal.line);
663 set_default_breakpoint (0, 0, 0, 0, 0);
666 annotate_frame_end ();
668 gdb_flush (gdb_stdout);
671 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
672 corresponding to FRAME. */
675 find_frame_funname (struct frame_info *frame, char **funname,
676 enum language *funlang, struct symbol **funcp)
681 *funlang = language_unknown;
685 func = get_frame_function (frame);
688 /* In certain pathological cases, the symtabs give the wrong
689 function (when we are in the first function in a file which
690 is compiled without debugging symbols, the previous function
691 is compiled with debugging symbols, and the "foo.o" symbol
692 that is supposed to tell us where the file with debugging
693 symbols ends has been truncated by ar because it is longer
694 than 15 characters). This also occurs if the user uses asm()
695 to create a function but not stabs for it (in a file compiled
698 So look in the minimal symbol tables as well, and if it comes
699 up with a larger address for the function use that instead.
700 I don't think this can ever cause any problems; there
701 shouldn't be any minimal symbols in the middle of a function;
702 if this is ever changed many parts of GDB will need to be
703 changed (and we'll create a find_pc_minimal_function or some
706 struct minimal_symbol *msymbol = NULL;
708 /* Don't attempt to do this for inlined functions, which do not
709 have a corresponding minimal symbol. */
710 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
712 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
715 && (SYMBOL_VALUE_ADDRESS (msymbol)
716 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
718 /* We also don't know anything about the function besides
719 its address and name. */
721 *funname = SYMBOL_PRINT_NAME (msymbol);
722 *funlang = SYMBOL_LANGUAGE (msymbol);
726 *funname = SYMBOL_PRINT_NAME (func);
727 *funlang = SYMBOL_LANGUAGE (func);
730 if (*funlang == language_cplus)
732 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
733 to display the demangled name that we already have
734 stored in the symbol table, but we stored a version
735 with DMGL_PARAMS turned on, and here we don't want to
736 display parameters. So remove the parameters. */
737 char *func_only = cp_remove_params (*funname);
741 *funname = func_only;
742 make_cleanup (xfree, func_only);
749 struct minimal_symbol *msymbol;
752 if (!get_frame_address_in_block_if_available (frame, &pc))
755 msymbol = lookup_minimal_symbol_by_pc (pc);
758 *funname = SYMBOL_PRINT_NAME (msymbol);
759 *funlang = SYMBOL_LANGUAGE (msymbol);
765 print_frame (struct frame_info *frame, int print_level,
766 enum print_what print_what, int print_args,
767 struct symtab_and_line sal)
769 struct gdbarch *gdbarch = get_frame_arch (frame);
770 char *funname = NULL;
771 enum language funlang = language_unknown;
772 struct ui_stream *stb;
773 struct cleanup *old_chain, *list_chain;
774 struct value_print_options opts;
779 pc_p = get_frame_pc_if_available (frame, &pc);
781 stb = ui_out_stream_new (uiout);
782 old_chain = make_cleanup_ui_out_stream_delete (stb);
784 find_frame_funname (frame, &funname, &funlang, &func);
786 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
789 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
793 ui_out_text (uiout, "#");
794 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
795 frame_relative_level (frame));
797 get_user_print_options (&opts);
798 if (opts.addressprint)
800 || frame_show_address (frame, sal)
801 || print_what == LOC_AND_ADDRESS)
803 annotate_frame_address ();
805 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
807 ui_out_field_string (uiout, "addr", "<unavailable>");
808 annotate_frame_address_end ();
809 ui_out_text (uiout, " in ");
811 annotate_frame_function_name ();
812 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
814 ui_out_field_stream (uiout, "func", stb);
815 ui_out_wrap_hint (uiout, " ");
816 annotate_frame_args ();
818 ui_out_text (uiout, " (");
821 struct print_args_args args;
822 struct cleanup *args_list_chain;
826 args.stream = gdb_stdout;
827 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
828 catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
829 /* FIXME: ARGS must be a list. If one argument is a string it
830 will have " that will not be properly escaped. */
831 /* Invoke ui_out_tuple_end. */
832 do_cleanups (args_list_chain);
835 ui_out_text (uiout, ")");
836 if (sal.symtab && sal.symtab->filename)
838 annotate_frame_source_begin ();
839 ui_out_wrap_hint (uiout, " ");
840 ui_out_text (uiout, " at ");
841 annotate_frame_source_file ();
842 ui_out_field_string (uiout, "file", sal.symtab->filename);
843 if (ui_out_is_mi_like_p (uiout))
845 const char *fullname = symtab_to_fullname (sal.symtab);
847 if (fullname != NULL)
848 ui_out_field_string (uiout, "fullname", fullname);
850 annotate_frame_source_file_end ();
851 ui_out_text (uiout, ":");
852 annotate_frame_source_line ();
853 ui_out_field_int (uiout, "line", sal.line);
854 annotate_frame_source_end ();
857 if (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename)))
860 char *lib = PC_SOLIB (get_frame_pc (frame));
862 char *lib = solib_name_from_address (get_frame_program_space (frame),
863 get_frame_pc (frame));
867 annotate_frame_where ();
868 ui_out_wrap_hint (uiout, " ");
869 ui_out_text (uiout, " from ");
870 ui_out_field_string (uiout, "from", lib);
874 /* do_cleanups will call ui_out_tuple_end() for us. */
875 do_cleanups (list_chain);
876 ui_out_text (uiout, "\n");
877 do_cleanups (old_chain);
881 /* Read a frame specification in whatever the appropriate format is
882 from FRAME_EXP. Call error(), printing MESSAGE, if the
883 specification is in any way invalid (so this function never returns
884 NULL). When SEPECTED_P is non-NULL set its target to indicate that
885 the default selected frame was used. */
887 static struct frame_info *
888 parse_frame_specification_1 (const char *frame_exp, const char *message,
889 int *selected_frame_p)
892 struct value *args[4];
893 CORE_ADDR addrs[ARRAY_SIZE (args)];
895 if (frame_exp == NULL)
903 struct cleanup *cleanup;
906 /* Skip leading white space, bail of EOL. */
907 while (isspace (*frame_exp))
912 /* Parse the argument, extract it, save it. */
916 addr_string = savestring (frame_exp, p - frame_exp);
918 cleanup = make_cleanup (xfree, addr_string);
920 /* NOTE: Parse and evaluate expression, but do not use
921 functions such as parse_and_eval_long or
922 parse_and_eval_address to also extract the value.
923 Instead value_as_long and value_as_address are used.
924 This avoids problems with expressions that contain
926 if (numargs >= ARRAY_SIZE (args))
927 error (_("Too many args in frame specification"));
928 args[numargs++] = parse_and_eval (addr_string);
930 do_cleanups (cleanup);
934 /* If no args, default to the selected frame. */
937 if (selected_frame_p != NULL)
938 (*selected_frame_p) = 1;
939 return get_selected_frame (message);
942 /* None of the remaining use the selected frame. */
943 if (selected_frame_p != NULL)
944 (*selected_frame_p) = 0;
946 /* Assume the single arg[0] is an integer, and try using that to
947 select a frame relative to current. */
950 struct frame_info *fid;
951 int level = value_as_long (args[0]);
953 fid = find_relative_frame (get_current_frame (), &level);
955 /* find_relative_frame was successful. */
959 /* Convert each value into a corresponding address. */
963 for (i = 0; i < numargs; i++)
964 addrs[i] = value_as_address (args[i]);
967 /* Assume that the single arg[0] is an address, use that to identify
968 a frame with a matching ID. Should this also accept stack/pc or
972 struct frame_id id = frame_id_build_wild (addrs[0]);
973 struct frame_info *fid;
975 /* If (s)he specifies the frame with an address, he deserves
976 what (s)he gets. Still, give the highest one that matches.
977 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
979 for (fid = get_current_frame ();
981 fid = get_prev_frame (fid))
983 if (frame_id_eq (id, get_frame_id (fid)))
985 struct frame_info *prev_frame;
989 prev_frame = get_prev_frame (fid);
991 || !frame_id_eq (id, get_frame_id (prev_frame)))
1000 /* We couldn't identify the frame as an existing frame, but
1001 perhaps we can create one with a single argument. */
1003 return create_new_frame (addrs[0], 0);
1004 else if (numargs == 2)
1005 return create_new_frame (addrs[0], addrs[1]);
1007 error (_("Too many args in frame specification"));
1010 static struct frame_info *
1011 parse_frame_specification (char *frame_exp)
1013 return parse_frame_specification_1 (frame_exp, NULL, NULL);
1016 /* Print verbosely the selected frame or the frame at address
1017 ADDR_EXP. Absolutely all information in the frame is printed. */
1020 frame_info (char *addr_exp, int from_tty)
1022 struct frame_info *fi;
1023 struct symtab_and_line sal;
1024 struct symbol *func;
1026 struct frame_info *calling_frame_info;
1029 enum language funlang = language_unknown;
1030 const char *pc_regname;
1031 int selected_frame_p;
1032 struct gdbarch *gdbarch;
1033 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
1035 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
1036 gdbarch = get_frame_arch (fi);
1038 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1039 is not a good name. */
1040 if (gdbarch_pc_regnum (gdbarch) >= 0)
1041 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1042 easily not match that of the internal value returned by
1044 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1046 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1047 architectures will often have a hardware register called "pc",
1048 and that register's value, again, can easily not match
1052 find_frame_sal (fi, &sal);
1053 func = get_frame_function (fi);
1054 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1056 s = find_pc_symtab (get_frame_pc (fi));
1059 funname = SYMBOL_PRINT_NAME (func);
1060 funlang = SYMBOL_LANGUAGE (func);
1061 if (funlang == language_cplus)
1063 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1064 to display the demangled name that we already have
1065 stored in the symbol table, but we stored a version
1066 with DMGL_PARAMS turned on, and here we don't want to
1067 display parameters. So remove the parameters. */
1068 char *func_only = cp_remove_params (funname);
1072 funname = func_only;
1073 make_cleanup (xfree, func_only);
1079 struct minimal_symbol *msymbol;
1081 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
1082 if (msymbol != NULL)
1084 funname = SYMBOL_PRINT_NAME (msymbol);
1085 funlang = SYMBOL_LANGUAGE (msymbol);
1088 calling_frame_info = get_prev_frame (fi);
1090 if (selected_frame_p && frame_relative_level (fi) >= 0)
1092 printf_filtered (_("Stack level %d, frame at "),
1093 frame_relative_level (fi));
1097 printf_filtered (_("Stack frame at "));
1099 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1100 printf_filtered (":\n");
1101 printf_filtered (" %s = ", pc_regname);
1102 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1107 printf_filtered (" in ");
1108 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1109 DMGL_ANSI | DMGL_PARAMS);
1113 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
1114 puts_filtered ("; ");
1116 printf_filtered ("saved %s ", pc_regname);
1117 fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout);
1118 printf_filtered ("\n");
1120 if (calling_frame_info == NULL)
1122 enum unwind_stop_reason reason;
1124 reason = get_frame_unwind_stop_reason (fi);
1125 if (reason != UNWIND_NO_REASON)
1126 printf_filtered (_(" Outermost frame: %s\n"),
1127 frame_stop_reason_string (reason));
1129 else if (get_frame_type (fi) == INLINE_FRAME)
1130 printf_filtered (" inlined into frame %d",
1131 frame_relative_level (get_prev_frame (fi)));
1134 printf_filtered (" called by frame at ");
1135 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1138 if (get_next_frame (fi) && calling_frame_info)
1139 puts_filtered (",");
1141 if (get_next_frame (fi))
1143 printf_filtered (" caller of frame at ");
1144 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1147 if (get_next_frame (fi) || calling_frame_info)
1148 puts_filtered ("\n");
1151 printf_filtered (" source language %s.\n",
1152 language_str (s->language));
1155 /* Address of the argument list for this frame, or 0. */
1156 CORE_ADDR arg_list = get_frame_args_address (fi);
1157 /* Number of args for this frame, or -1 if unknown. */
1161 printf_filtered (" Arglist at unknown address.\n");
1164 printf_filtered (" Arglist at ");
1165 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1166 printf_filtered (",");
1168 if (!gdbarch_frame_num_args_p (gdbarch))
1171 puts_filtered (" args: ");
1175 numargs = gdbarch_frame_num_args (gdbarch, fi);
1176 gdb_assert (numargs >= 0);
1178 puts_filtered (" no args.");
1179 else if (numargs == 1)
1180 puts_filtered (" 1 arg: ");
1182 printf_filtered (" %d args: ", numargs);
1184 print_frame_args (func, fi, numargs, gdb_stdout);
1185 puts_filtered ("\n");
1189 /* Address of the local variables for this frame, or 0. */
1190 CORE_ADDR arg_list = get_frame_locals_address (fi);
1193 printf_filtered (" Locals at unknown address,");
1196 printf_filtered (" Locals at ");
1197 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1198 printf_filtered (",");
1202 /* Print as much information as possible on the location of all the
1205 enum lval_type lval;
1214 /* The sp is special; what's displayed isn't the save address, but
1215 the value of the previous frame's sp. This is a legacy thing,
1216 at one stage the frame cached the previous frame's SP instead
1217 of its address, hence it was easiest to just display the cached
1219 if (gdbarch_sp_regnum (gdbarch) >= 0)
1221 /* Find out the location of the saved stack pointer with out
1222 actually evaluating it. */
1223 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1224 &optimized, &unavailable, &lval, &addr,
1226 if (!optimized && !unavailable && lval == not_lval)
1228 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1229 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1230 gdb_byte value[MAX_REGISTER_SIZE];
1233 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1234 &optimized, &unavailable, &lval, &addr,
1236 /* NOTE: cagney/2003-05-22: This is assuming that the
1237 stack pointer was packed as an unsigned integer. That
1238 may or may not be valid. */
1239 sp = extract_unsigned_integer (value, sp_size, byte_order);
1240 printf_filtered (" Previous frame's sp is ");
1241 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1242 printf_filtered ("\n");
1245 else if (!optimized && !unavailable && lval == lval_memory)
1247 printf_filtered (" Previous frame's sp at ");
1248 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1249 printf_filtered ("\n");
1252 else if (!optimized && !unavailable && lval == lval_register)
1254 printf_filtered (" Previous frame's sp in %s\n",
1255 gdbarch_register_name (gdbarch, realnum));
1258 /* else keep quiet. */
1262 numregs = gdbarch_num_regs (gdbarch)
1263 + gdbarch_num_pseudo_regs (gdbarch);
1264 for (i = 0; i < numregs; i++)
1265 if (i != gdbarch_sp_regnum (gdbarch)
1266 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1268 /* Find out the location of the saved register without
1269 fetching the corresponding value. */
1270 frame_register_unwind (fi, i, &optimized, &unavailable,
1271 &lval, &addr, &realnum, NULL);
1272 /* For moment, only display registers that were saved on the
1274 if (!optimized && !unavailable && lval == lval_memory)
1277 puts_filtered (" Saved registers:\n ");
1279 puts_filtered (",");
1281 printf_filtered (" %s at ",
1282 gdbarch_register_name (gdbarch, i));
1283 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1287 if (count || need_nl)
1288 puts_filtered ("\n");
1291 do_cleanups (back_to);
1294 /* Print briefly all stack frames or just the innermost COUNT_EXP
1298 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1300 struct frame_info *fi;
1303 struct frame_info *trailing;
1306 if (!target_has_stack)
1307 error (_("No stack."));
1309 /* The following code must do two things. First, it must set the
1310 variable TRAILING to the frame from which we should start
1311 printing. Second, it must set the variable count to the number
1312 of frames which we should print, or -1 if all of them. */
1313 trailing = get_current_frame ();
1318 count = parse_and_eval_long (count_exp);
1321 struct frame_info *current;
1326 while (current && count--)
1329 current = get_prev_frame (current);
1332 /* Will stop when CURRENT reaches the top of the stack.
1333 TRAILING will be COUNT below it. */
1337 trailing = get_prev_frame (trailing);
1338 current = get_prev_frame (current);
1350 /* Read in symbols for all of the frames. Need to do this in a
1351 separate pass so that "Reading in symbols for xxx" messages
1352 don't screw up the appearance of the backtrace. Also if
1353 people have strong opinions against reading symbols for
1354 backtrace this may have to be an option. */
1356 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1361 pc = get_frame_address_in_block (fi);
1362 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc));
1366 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1370 /* Don't use print_stack_frame; if an error() occurs it probably
1371 means further attempts to backtrace would fail (on the other
1372 hand, perhaps the code does or could be fixed to make sure
1373 the frame->prev field gets set to NULL in that case). */
1374 print_frame_info (fi, 1, LOCATION, 1);
1376 print_frame_local_vars (fi, 1, gdb_stdout);
1378 /* Save the last frame to check for error conditions. */
1382 /* If we've stopped before the end, mention that. */
1384 printf_filtered (_("(More stack frames follow...)\n"));
1386 /* If we've run out of frames, and the reason appears to be an error
1387 condition, print it. */
1388 if (fi == NULL && trailing != NULL)
1390 enum unwind_stop_reason reason;
1392 reason = get_frame_unwind_stop_reason (trailing);
1393 if (reason > UNWIND_FIRST_ERROR)
1394 printf_filtered (_("Backtrace stopped: %s\n"),
1395 frame_stop_reason_string (reason));
1399 struct backtrace_command_args
1406 /* Stub for catch_errors. */
1409 backtrace_command_stub (void *data)
1411 struct backtrace_command_args *args = data;
1413 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1418 backtrace_command (char *arg, int from_tty)
1420 struct cleanup *old_chain = NULL;
1421 int fulltrace_arg = -1, arglen = 0, argc = 0;
1422 struct backtrace_command_args btargs;
1429 argv = gdb_buildargv (arg);
1430 old_chain = make_cleanup_freeargv (argv);
1432 for (i = 0; argv[i]; i++)
1436 for (j = 0; j < strlen (argv[i]); j++)
1437 argv[i][j] = tolower (argv[i][j]);
1439 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1440 fulltrace_arg = argc;
1443 arglen += strlen (argv[i]);
1448 if (fulltrace_arg >= 0)
1452 arg = xmalloc (arglen + 1);
1453 memset (arg, 0, arglen + 1);
1454 for (i = 0; i < (argc + 1); i++)
1456 if (i != fulltrace_arg)
1458 strcat (arg, argv[i]);
1468 btargs.count_exp = arg;
1469 btargs.show_locals = (fulltrace_arg >= 0);
1470 btargs.from_tty = from_tty;
1471 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1473 if (fulltrace_arg >= 0 && arglen > 0)
1477 do_cleanups (old_chain);
1481 backtrace_full_command (char *arg, int from_tty)
1483 struct backtrace_command_args btargs;
1485 btargs.count_exp = arg;
1486 btargs.show_locals = 1;
1487 btargs.from_tty = from_tty;
1488 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1492 /* Iterate over the local variables of a block B, calling CB with
1496 iterate_over_block_locals (struct block *b,
1497 iterate_over_block_arg_local_vars_cb cb,
1500 struct dict_iterator iter;
1503 ALL_BLOCK_SYMBOLS (b, iter, sym)
1505 switch (SYMBOL_CLASS (sym))
1511 if (SYMBOL_IS_ARGUMENT (sym))
1513 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1517 /* Ignore symbols which are not locals. */
1524 /* Same, but print labels. */
1527 /* Commented out, as the code using this function has also been
1528 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1529 was commented out in the first place. The discussion introducing
1530 this change (2007-12-04: Support lexical blocks and function bodies
1531 that occupy non-contiguous address ranges) did not explain why
1532 this change was made. */
1534 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1535 int *have_default, struct ui_file *stream)
1537 struct dict_iterator iter;
1539 int values_printed = 0;
1541 ALL_BLOCK_SYMBOLS (b, iter, sym)
1543 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1549 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1551 struct symtab_and_line sal;
1552 struct value_print_options opts;
1554 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1556 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1557 get_user_print_options (&opts);
1558 if (opts.addressprint)
1560 fprintf_filtered (stream, " ");
1561 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1564 fprintf_filtered (stream, " in file %s, line %d\n",
1565 sal.symtab->filename, sal.line);
1569 return values_printed;
1573 /* Iterate over all the local variables in block B, including all its
1574 superblocks, stopping when the top-level block is reached. */
1577 iterate_over_block_local_vars (struct block *block,
1578 iterate_over_block_arg_local_vars_cb cb,
1583 iterate_over_block_locals (block, cb, cb_data);
1584 /* After handling the function's top-level block, stop. Don't
1585 continue to its superblock, the block of per-file
1587 if (BLOCK_FUNCTION (block))
1589 block = BLOCK_SUPERBLOCK (block);
1593 /* Data to be passed around in the calls to the locals and args
1596 struct print_variable_and_value_data
1598 struct frame_info *frame;
1600 struct ui_file *stream;
1604 /* The callback for the locals and args iterators. */
1607 do_print_variable_and_value (const char *print_name,
1611 struct print_variable_and_value_data *p = cb_data;
1613 print_variable_and_value (print_name, sym,
1614 p->frame, p->stream, p->num_tabs);
1615 p->values_printed = 1;
1619 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1620 struct ui_file *stream)
1622 struct print_variable_and_value_data cb_data;
1623 struct block *block;
1625 block = get_frame_block (frame, 0);
1628 fprintf_filtered (stream, "No symbol table info available.\n");
1632 cb_data.frame = frame;
1633 cb_data.num_tabs = 4 * num_tabs;
1634 cb_data.stream = stream;
1635 cb_data.values_printed = 0;
1637 iterate_over_block_local_vars (block,
1638 do_print_variable_and_value,
1641 if (!cb_data.values_printed)
1642 fprintf_filtered (stream, _("No locals.\n"));
1645 /* Same, but print labels. */
1648 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1649 struct ui_file *stream)
1652 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1654 struct blockvector *bl;
1655 struct block *block = get_frame_block (frame, 0);
1656 struct gdbarch *gdbarch = get_frame_arch (frame);
1657 int values_printed = 0;
1658 int index, have_default = 0;
1659 char *blocks_printed;
1660 CORE_ADDR pc = get_frame_pc (frame);
1664 fprintf_filtered (stream, "No symbol table info available.\n");
1668 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1669 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1670 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1674 CORE_ADDR end = BLOCK_END (block) - 4;
1677 if (bl != blockvector_for_pc (end, &index))
1678 error (_("blockvector blotch"));
1679 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1680 error (_("blockvector botch"));
1681 last_index = BLOCKVECTOR_NBLOCKS (bl);
1684 /* Don't print out blocks that have gone by. */
1685 while (index < last_index
1686 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1689 while (index < last_index
1690 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1692 if (blocks_printed[index] == 0)
1694 if (print_block_frame_labels (gdbarch,
1695 BLOCKVECTOR_BLOCK (bl, index),
1696 &have_default, stream))
1698 blocks_printed[index] = 1;
1704 if (values_printed && this_level_only)
1707 /* After handling the function's top-level block, stop. Don't
1708 continue to its superblock, the block of per-file symbols.
1709 Also do not continue to the containing function of an inlined
1711 if (BLOCK_FUNCTION (block))
1713 block = BLOCK_SUPERBLOCK (block);
1716 if (!values_printed && !this_level_only)
1717 fprintf_filtered (stream, _("No catches.\n"));
1722 locals_info (char *args, int from_tty)
1724 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1729 catch_info (char *ignore, int from_tty)
1731 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1732 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1736 /* Iterate over all the argument variables in block B.
1738 Returns 1 if any argument was walked; 0 otherwise. */
1741 iterate_over_block_arg_vars (struct block *b,
1742 iterate_over_block_arg_local_vars_cb cb,
1745 struct dict_iterator iter;
1746 struct symbol *sym, *sym2;
1748 ALL_BLOCK_SYMBOLS (b, iter, sym)
1750 /* Don't worry about things which aren't arguments. */
1751 if (SYMBOL_IS_ARGUMENT (sym))
1753 /* We have to look up the symbol because arguments can have
1754 two entries (one a parameter, one a local) and the one we
1755 want is the local, which lookup_symbol will find for us.
1756 This includes gcc1 (not gcc2) on the sparc when passing a
1757 small structure and gcc2 when the argument type is float
1758 and it is passed as a double and converted to float by
1759 the prologue (in the latter case the type of the LOC_ARG
1760 symbol is double and the type of the LOC_LOCAL symbol is
1761 float). There are also LOC_ARG/LOC_REGISTER pairs which
1762 are not combined in symbol-reading. */
1764 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
1765 b, VAR_DOMAIN, NULL);
1766 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
1772 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1774 struct print_variable_and_value_data cb_data;
1775 struct symbol *func;
1777 func = get_frame_function (frame);
1780 fprintf_filtered (stream, _("No symbol table info available.\n"));
1784 cb_data.frame = frame;
1785 cb_data.num_tabs = 0;
1786 cb_data.stream = gdb_stdout;
1787 cb_data.values_printed = 0;
1789 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
1790 do_print_variable_and_value, &cb_data);
1792 if (!cb_data.values_printed)
1793 fprintf_filtered (stream, _("No arguments.\n"));
1797 args_info (char *ignore, int from_tty)
1799 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1805 args_plus_locals_info (char *ignore, int from_tty)
1807 args_info (ignore, from_tty);
1808 locals_info (ignore, from_tty);
1812 /* Select frame FRAME. Also print the stack frame and show the source
1813 if this is the tui version. */
1815 select_and_print_frame (struct frame_info *frame)
1817 select_frame (frame);
1819 print_stack_frame (frame, 1, SRC_AND_LOC);
1822 /* Return the symbol-block in which the selected frame is executing.
1823 Can return zero under various legitimate circumstances.
1825 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1826 code address within the block returned. We use this to decide
1827 which macros are in scope. */
1830 get_selected_block (CORE_ADDR *addr_in_block)
1832 if (!has_stack_frames ())
1835 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1838 /* Find a frame a certain number of levels away from FRAME.
1839 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1840 Positive means go to earlier frames (up); negative, the reverse.
1841 The int that contains the number of levels is counted toward
1842 zero as the frames for those levels are found.
1843 If the top or bottom frame is reached, that frame is returned,
1844 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1845 how much farther the original request asked to go. */
1848 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1850 /* Going up is simple: just call get_prev_frame enough times or
1851 until the initial frame is reached. */
1852 while (*level_offset_ptr > 0)
1854 struct frame_info *prev = get_prev_frame (frame);
1858 (*level_offset_ptr)--;
1862 /* Going down is just as simple. */
1863 while (*level_offset_ptr < 0)
1865 struct frame_info *next = get_next_frame (frame);
1869 (*level_offset_ptr)++;
1876 /* The "select_frame" command. With no argument this is a NOP.
1877 Select the frame at level LEVEL_EXP if it is a valid level.
1878 Otherwise, treat LEVEL_EXP as an address expression and select it.
1880 See parse_frame_specification for more info on proper frame
1884 select_frame_command (char *level_exp, int from_tty)
1886 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1889 /* The "frame" command. With no argument, print the selected frame
1890 briefly. With an argument, behave like select_frame and then print
1891 the selected frame. */
1894 frame_command (char *level_exp, int from_tty)
1896 select_frame_command (level_exp, from_tty);
1897 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1900 /* The XDB Compatibility command to print the current frame. */
1903 current_frame_command (char *level_exp, int from_tty)
1905 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1908 /* Select the frame up one or COUNT_EXP stack levels from the
1909 previously selected frame, and print it briefly. */
1912 up_silently_base (char *count_exp)
1914 struct frame_info *frame;
1918 count = parse_and_eval_long (count_exp);
1920 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1921 if (count != 0 && count_exp == NULL)
1922 error (_("Initial frame selected; you cannot go up."));
1923 select_frame (frame);
1927 up_silently_command (char *count_exp, int from_tty)
1929 up_silently_base (count_exp);
1933 up_command (char *count_exp, int from_tty)
1935 up_silently_base (count_exp);
1936 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1939 /* Select the frame down one or COUNT_EXP stack levels from the previously
1940 selected frame, and print it briefly. */
1943 down_silently_base (char *count_exp)
1945 struct frame_info *frame;
1949 count = -parse_and_eval_long (count_exp);
1951 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1952 if (count != 0 && count_exp == NULL)
1954 /* We only do this if COUNT_EXP is not specified. That way
1955 "down" means to really go down (and let me know if that is
1956 impossible), but "down 9999" can be used to mean go all the
1957 way down without getting an error. */
1959 error (_("Bottom (innermost) frame selected; you cannot go down."));
1962 select_frame (frame);
1966 down_silently_command (char *count_exp, int from_tty)
1968 down_silently_base (count_exp);
1972 down_command (char *count_exp, int from_tty)
1974 down_silently_base (count_exp);
1975 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1980 return_command (char *retval_exp, int from_tty)
1982 struct frame_info *thisframe;
1983 struct gdbarch *gdbarch;
1984 struct symbol *thisfun;
1985 struct value *return_value = NULL;
1986 const char *query_prefix = "";
1988 thisframe = get_selected_frame ("No selected frame.");
1989 thisfun = get_frame_function (thisframe);
1990 gdbarch = get_frame_arch (thisframe);
1992 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
1993 error (_("Can not force return from an inlined function."));
1995 /* Compute the return value. If the computation triggers an error,
1996 let it bail. If the return type can't be handled, set
1997 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2001 struct expression *retval_expr = parse_expression (retval_exp);
2002 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
2003 struct type *return_type = NULL;
2005 /* Compute the return value. Should the computation fail, this
2006 call throws an error. */
2007 return_value = evaluate_expression (retval_expr);
2009 /* Cast return value to the return type of the function. Should
2010 the cast fail, this call throws an error. */
2011 if (thisfun != NULL)
2012 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2013 if (return_type == NULL)
2015 if (retval_expr->elts[0].opcode != UNOP_CAST)
2016 error (_("Return value type not available for selected "
2018 "Please use an explicit cast of the value to return."));
2019 return_type = value_type (return_value);
2021 do_cleanups (old_chain);
2022 CHECK_TYPEDEF (return_type);
2023 return_value = value_cast (return_type, return_value);
2025 /* Make sure the value is fully evaluated. It may live in the
2026 stack frame we're about to pop. */
2027 if (value_lazy (return_value))
2028 value_fetch_lazy (return_value);
2030 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2031 /* If the return-type is "void", don't try to find the
2032 return-value's location. However, do still evaluate the
2033 return expression so that, even when the expression result
2034 is discarded, side effects such as "return i++" still
2036 return_value = NULL;
2037 else if (thisfun != NULL
2038 && using_struct_return (gdbarch,
2039 SYMBOL_TYPE (thisfun), return_type))
2041 query_prefix = "The location at which to store the "
2042 "function's return value is unknown.\n"
2043 "If you continue, the return value "
2044 "that you specified will be ignored.\n";
2045 return_value = NULL;
2049 /* Does an interactive user really want to do this? Include
2050 information, such as how well GDB can handle the return value, in
2051 the query message. */
2056 if (thisfun == NULL)
2057 confirmed = query (_("%sMake selected stack frame return now? "),
2060 confirmed = query (_("%sMake %s return now? "), query_prefix,
2061 SYMBOL_PRINT_NAME (thisfun));
2063 error (_("Not confirmed"));
2066 /* Discard the selected frame and all frames inner-to it. */
2067 frame_pop (get_selected_frame (NULL));
2069 /* Store RETURN_VALUE in the just-returned register set. */
2070 if (return_value != NULL)
2072 struct type *return_type = value_type (return_value);
2073 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2074 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
2076 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
2078 == RETURN_VALUE_REGISTER_CONVENTION);
2079 gdbarch_return_value (gdbarch, func_type, return_type,
2080 get_current_regcache (), NULL /*read*/,
2081 value_contents (return_value) /*write*/);
2084 /* If we are at the end of a call dummy now, pop the dummy frame
2086 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2087 frame_pop (get_current_frame ());
2089 /* If interactive, print the frame that is now current. */
2091 frame_command ("0", 1);
2093 select_frame_command ("0", 0);
2096 /* Sets the scope to input function name, provided that the function
2097 is within the current stack frame. */
2099 struct function_bounds
2101 CORE_ADDR low, high;
2105 func_command (char *arg, int from_tty)
2107 struct frame_info *frame;
2109 struct symtabs_and_lines sals;
2112 struct function_bounds *func_bounds = NULL;
2117 frame = parse_frame_specification ("0");
2118 sals = decode_line_spec (arg, 1);
2119 func_bounds = (struct function_bounds *) xmalloc (
2120 sizeof (struct function_bounds) * sals.nelts);
2121 for (i = 0; (i < sals.nelts && !found); i++)
2123 if (sals.sals[i].pc == 0
2124 || find_pc_partial_function (sals.sals[i].pc, NULL,
2125 &func_bounds[i].low,
2126 &func_bounds[i].high) == 0)
2128 func_bounds[i].low = func_bounds[i].high = 0;
2134 for (i = 0; (i < sals.nelts && !found); i++)
2135 found = (get_frame_pc (frame) >= func_bounds[i].low
2136 && get_frame_pc (frame) < func_bounds[i].high);
2140 frame = find_relative_frame (frame, &level);
2143 while (!found && level == 0);
2146 xfree (func_bounds);
2149 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2150 else if (frame != get_selected_frame (NULL))
2151 select_and_print_frame (frame);
2154 /* Gets the language of the current frame. */
2157 get_frame_language (void)
2159 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2163 volatile struct gdb_exception ex;
2167 /* We determine the current frame language by looking up its
2168 associated symtab. To retrieve this symtab, we use the frame
2169 PC. However we cannot use the frame PC as is, because it
2170 usually points to the instruction following the "call", which
2171 is sometimes the first instruction of another function. So
2172 we rely on get_frame_address_in_block(), it provides us with
2173 a PC that is guaranteed to be inside the frame's code
2176 TRY_CATCH (ex, RETURN_MASK_ERROR)
2178 pc = get_frame_address_in_block (frame);
2182 if (ex.error != NOT_AVAILABLE_ERROR)
2183 throw_exception (ex);
2187 s = find_pc_symtab (pc);
2193 return language_unknown;
2197 /* Provide a prototype to silence -Wmissing-prototypes. */
2198 void _initialize_stack (void);
2201 _initialize_stack (void)
2203 add_com ("return", class_stack, return_command, _("\
2204 Make selected stack frame return to its caller.\n\
2205 Control remains in the debugger, but when you continue\n\
2206 execution will resume in the frame above the one now selected.\n\
2207 If an argument is given, it is an expression for the value to return."));
2209 add_com ("up", class_stack, up_command, _("\
2210 Select and print stack frame that called this one.\n\
2211 An argument says how many frames up to go."));
2212 add_com ("up-silently", class_support, up_silently_command, _("\
2213 Same as the `up' command, but does not print anything.\n\
2214 This is useful in command scripts."));
2216 add_com ("down", class_stack, down_command, _("\
2217 Select and print stack frame called by this one.\n\
2218 An argument says how many frames down to go."));
2219 add_com_alias ("do", "down", class_stack, 1);
2220 add_com_alias ("dow", "down", class_stack, 1);
2221 add_com ("down-silently", class_support, down_silently_command, _("\
2222 Same as the `down' command, but does not print anything.\n\
2223 This is useful in command scripts."));
2225 add_com ("frame", class_stack, frame_command, _("\
2226 Select and print a stack frame.\nWith no argument, \
2227 print the selected stack frame. (See also \"info frame\").\n\
2228 An argument specifies the frame to select.\n\
2229 It can be a stack frame number or the address of the frame.\n\
2230 With argument, nothing is printed if input is coming from\n\
2231 a command file or a user-defined command."));
2233 add_com_alias ("f", "frame", class_stack, 1);
2237 add_com ("L", class_stack, current_frame_command,
2238 _("Print the current stack frame.\n"));
2239 add_com_alias ("V", "frame", class_stack, 1);
2241 add_com ("select-frame", class_stack, select_frame_command, _("\
2242 Select a stack frame without printing anything.\n\
2243 An argument specifies the frame to select.\n\
2244 It can be a stack frame number or the address of the frame.\n"));
2246 add_com ("backtrace", class_stack, backtrace_command, _("\
2247 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2248 With a negative argument, print outermost -COUNT frames.\nUse of the \
2249 'full' qualifier also prints the values of the local variables.\n"));
2250 add_com_alias ("bt", "backtrace", class_stack, 0);
2253 add_com_alias ("t", "backtrace", class_stack, 0);
2254 add_com ("T", class_stack, backtrace_full_command, _("\
2255 Print backtrace of all stack frames, or innermost COUNT frames\n\
2256 and the values of the local variables.\n\
2257 With a negative argument, print outermost -COUNT frames.\n\
2258 Usage: T <count>\n"));
2261 add_com_alias ("where", "backtrace", class_alias, 0);
2262 add_info ("stack", backtrace_command,
2263 _("Backtrace of the stack, or innermost COUNT frames."));
2264 add_info_alias ("s", "stack", 1);
2265 add_info ("frame", frame_info,
2266 _("All about selected stack frame, or frame at ADDR."));
2267 add_info_alias ("f", "frame", 1);
2268 add_info ("locals", locals_info,
2269 _("Local variables of current stack frame."));
2270 add_info ("args", args_info,
2271 _("Argument variables of current stack frame."));
2273 add_com ("l", class_info, args_plus_locals_info,
2274 _("Argument and local variables of current stack frame."));
2277 add_com ("func", class_stack, func_command, _("\
2278 Select the stack frame that contains <func>.\n\
2279 Usage: func <name>\n"));
2281 add_info ("catch", catch_info,
2282 _("Exceptions that can be caught in the current stack frame."));
2284 add_setshow_enum_cmd ("frame-arguments", class_stack,
2285 print_frame_arguments_choices, &print_frame_arguments,
2286 _("Set printing of non-scalar frame arguments"),
2287 _("Show printing of non-scalar frame arguments"),
2288 NULL, NULL, NULL, &setprintlist, &showprintlist);
2290 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2291 &disassemble_next_line, _("\
2292 Set whether to disassemble next source line or insn when execution stops."),
2294 Show whether to disassemble next source line or insn when execution stops."),
2296 If ON, GDB will display disassembly of the next source line, in addition\n\
2297 to displaying the source line itself. If the next source line cannot\n\
2298 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2299 will display disassembly of next instruction instead of showing the\n\
2301 If AUTO, display disassembly of next instruction only if the source line\n\
2302 cannot be displayed.\n\
2303 If OFF (which is the default), never display the disassembly of the next\n\
2306 show_disassemble_next_line,
2307 &setlist, &showlist);
2308 disassemble_next_line = AUTO_BOOLEAN_FALSE;