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 /* Avoid value_print because it will deref ref parameters.
330 We just want to print their addresses. Print ??? for
331 args whose address we do not know. We pass 2 as
332 "recurse" to val_print because our standard indentation
333 here is 4 spaces, and val_print indents 2 for each
335 val = read_var_value (sym, frame);
337 annotate_arg_value (val == NULL ? NULL : value_type (val));
341 const struct language_defn *language;
342 struct value_print_options opts;
344 /* Use the appropriate language to display our symbol,
345 unless the user forced the language to a specific
347 if (language_mode == language_mode_auto)
348 language = language_def (SYMBOL_LANGUAGE (sym));
350 language = current_language;
352 get_raw_print_options (&opts);
354 opts.summary = summary;
355 common_val_print (val, stb->stream, 2, &opts, language);
356 ui_out_field_stream (uiout, "value", stb);
359 ui_out_text (uiout, "???");
362 ui_out_text (uiout, "...");
365 /* Invoke ui_out_tuple_end. */
366 do_cleanups (list_chain);
374 /* Don't print nameless args in situations where we don't know
375 enough about the stack to find them. */
380 if (highest_offset == -1)
381 start = gdbarch_frame_args_skip (get_frame_arch (frame));
383 start = highest_offset;
385 print_frame_nameless_args (frame, start, num - args_printed,
389 do_cleanups (old_chain);
392 /* Set the current source and line to the location given by frame
393 FRAME, if possible. When CENTER is true, adjust so the relevant
394 line is in the center of the next 'list'. */
397 set_current_sal_from_frame (struct frame_info *frame, int center)
399 struct symtab_and_line sal;
401 find_frame_sal (frame, &sal);
405 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
406 set_current_source_symtab_and_line (&sal);
410 /* If ON, GDB will display disassembly of the next source line when
411 execution of the program being debugged stops.
412 If AUTO (which is the default), or there's no line info to determine
413 the source line of the next instruction, display disassembly of next
414 instruction instead. */
416 static enum auto_boolean disassemble_next_line;
419 show_disassemble_next_line (struct ui_file *file, int from_tty,
420 struct cmd_list_element *c,
423 fprintf_filtered (file,
424 _("Debugger's willingness to use "
425 "disassemble-next-line is %s.\n"),
429 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
430 because it will be broken by filter sometime. */
433 do_gdb_disassembly (struct gdbarch *gdbarch,
434 int how_many, CORE_ADDR low, CORE_ADDR high)
436 volatile struct gdb_exception exception;
438 TRY_CATCH (exception, RETURN_MASK_ERROR)
440 gdb_disassembly (gdbarch, current_uiout, 0,
441 DISASSEMBLY_RAW_INSN, how_many,
444 if (exception.reason < 0)
446 /* If an exception was thrown while doing the disassembly, print
447 the error message, to give the user a clue of what happened. */
448 exception_print (gdb_stderr, exception);
452 /* Print information about frame FRAME. The output is format according
453 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
456 SRC_LINE: Print only source line.
457 LOCATION: Print only location.
458 LOC_AND_SRC: Print location and source line.
460 Used in "where" output, and to emit breakpoint or step
464 print_frame_info (struct frame_info *frame, int print_level,
465 enum print_what print_what, int print_args)
467 struct gdbarch *gdbarch = get_frame_arch (frame);
468 struct symtab_and_line sal;
471 struct ui_out *uiout = current_uiout;
473 if (get_frame_type (frame) == DUMMY_FRAME
474 || get_frame_type (frame) == SIGTRAMP_FRAME
475 || get_frame_type (frame) == ARCH_FRAME)
477 struct cleanup *uiout_cleanup
478 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
480 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
481 gdbarch, get_frame_pc (frame));
483 /* Do this regardless of SOURCE because we don't have any source
484 to list for this frame. */
487 ui_out_text (uiout, "#");
488 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
489 frame_relative_level (frame));
491 if (ui_out_is_mi_like_p (uiout))
493 annotate_frame_address ();
494 ui_out_field_core_addr (uiout, "addr",
495 gdbarch, get_frame_pc (frame));
496 annotate_frame_address_end ();
499 if (get_frame_type (frame) == DUMMY_FRAME)
501 annotate_function_call ();
502 ui_out_field_string (uiout, "func", "<function called from gdb>");
504 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
506 annotate_signal_handler_caller ();
507 ui_out_field_string (uiout, "func", "<signal handler called>");
509 else if (get_frame_type (frame) == ARCH_FRAME)
511 ui_out_field_string (uiout, "func", "<cross-architecture call>");
513 ui_out_text (uiout, "\n");
514 annotate_frame_end ();
516 do_cleanups (uiout_cleanup);
520 /* If FRAME is not the innermost frame, that normally means that
521 FRAME->pc points to *after* the call instruction, and we want to
522 get the line containing the call, never the next line. But if
523 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
524 next frame was not entered as the result of a call, and we want
525 to get the line containing FRAME->pc. */
526 find_frame_sal (frame, &sal);
528 location_print = (print_what == LOCATION
529 || print_what == LOC_AND_ADDRESS
530 || print_what == SRC_AND_LOC);
532 if (location_print || !sal.symtab)
533 print_frame (frame, print_level, print_what, print_args, sal);
535 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
537 /* If disassemble-next-line is set to auto or on and doesn't have
538 the line debug messages for $pc, output the next instruction. */
539 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
540 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
541 && source_print && !sal.symtab)
542 do_gdb_disassembly (get_frame_arch (frame), 1,
543 get_frame_pc (frame), get_frame_pc (frame) + 1);
545 if (source_print && sal.symtab)
548 int mid_statement = ((print_what == SRC_LINE)
549 && frame_show_address (frame, sal));
551 if (annotation_level)
552 done = identify_source_line (sal.symtab, sal.line, mid_statement,
553 get_frame_pc (frame));
556 if (deprecated_print_frame_info_listing_hook)
557 deprecated_print_frame_info_listing_hook (sal.symtab,
562 struct value_print_options opts;
564 get_user_print_options (&opts);
565 /* We used to do this earlier, but that is clearly
566 wrong. This function is used by many different
567 parts of gdb, including normal_stop in infrun.c,
568 which uses this to print out the current PC
569 when we stepi/nexti into the middle of a source
570 line. Only the command line really wants this
571 behavior. Other UIs probably would like the
572 ability to decide for themselves if it is desired. */
573 if (opts.addressprint && mid_statement)
575 ui_out_field_core_addr (uiout, "addr",
576 gdbarch, get_frame_pc (frame));
577 ui_out_text (uiout, "\t");
580 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
584 /* If disassemble-next-line is set to on and there is line debug
585 messages, output assembly codes for next line. */
586 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
587 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
590 if (print_what != LOCATION)
594 if (get_frame_pc_if_available (frame, &pc))
595 set_default_breakpoint (1, sal.pspace, pc, sal.symtab, sal.line);
597 set_default_breakpoint (0, 0, 0, 0, 0);
600 annotate_frame_end ();
602 gdb_flush (gdb_stdout);
605 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
606 corresponding to FRAME. */
609 find_frame_funname (struct frame_info *frame, char **funname,
610 enum language *funlang, struct symbol **funcp)
615 *funlang = language_unknown;
619 func = get_frame_function (frame);
622 /* In certain pathological cases, the symtabs give the wrong
623 function (when we are in the first function in a file which
624 is compiled without debugging symbols, the previous function
625 is compiled with debugging symbols, and the "foo.o" symbol
626 that is supposed to tell us where the file with debugging
627 symbols ends has been truncated by ar because it is longer
628 than 15 characters). This also occurs if the user uses asm()
629 to create a function but not stabs for it (in a file compiled
632 So look in the minimal symbol tables as well, and if it comes
633 up with a larger address for the function use that instead.
634 I don't think this can ever cause any problems; there
635 shouldn't be any minimal symbols in the middle of a function;
636 if this is ever changed many parts of GDB will need to be
637 changed (and we'll create a find_pc_minimal_function or some
640 struct minimal_symbol *msymbol = NULL;
642 /* Don't attempt to do this for inlined functions, which do not
643 have a corresponding minimal symbol. */
644 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
646 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
649 && (SYMBOL_VALUE_ADDRESS (msymbol)
650 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
652 /* We also don't know anything about the function besides
653 its address and name. */
655 *funname = SYMBOL_PRINT_NAME (msymbol);
656 *funlang = SYMBOL_LANGUAGE (msymbol);
660 *funname = SYMBOL_PRINT_NAME (func);
661 *funlang = SYMBOL_LANGUAGE (func);
664 if (*funlang == language_cplus)
666 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
667 to display the demangled name that we already have
668 stored in the symbol table, but we stored a version
669 with DMGL_PARAMS turned on, and here we don't want to
670 display parameters. So remove the parameters. */
671 char *func_only = cp_remove_params (*funname);
675 *funname = func_only;
676 make_cleanup (xfree, func_only);
683 struct minimal_symbol *msymbol;
686 if (!get_frame_address_in_block_if_available (frame, &pc))
689 msymbol = lookup_minimal_symbol_by_pc (pc);
692 *funname = SYMBOL_PRINT_NAME (msymbol);
693 *funlang = SYMBOL_LANGUAGE (msymbol);
699 print_frame (struct frame_info *frame, int print_level,
700 enum print_what print_what, int print_args,
701 struct symtab_and_line sal)
703 struct gdbarch *gdbarch = get_frame_arch (frame);
704 struct ui_out *uiout = current_uiout;
705 char *funname = NULL;
706 enum language funlang = language_unknown;
707 struct ui_stream *stb;
708 struct cleanup *old_chain, *list_chain;
709 struct value_print_options opts;
714 pc_p = get_frame_pc_if_available (frame, &pc);
716 stb = ui_out_stream_new (uiout);
717 old_chain = make_cleanup_ui_out_stream_delete (stb);
719 find_frame_funname (frame, &funname, &funlang, &func);
721 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
724 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
728 ui_out_text (uiout, "#");
729 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
730 frame_relative_level (frame));
732 get_user_print_options (&opts);
733 if (opts.addressprint)
735 || frame_show_address (frame, sal)
736 || print_what == LOC_AND_ADDRESS)
738 annotate_frame_address ();
740 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
742 ui_out_field_string (uiout, "addr", "<unavailable>");
743 annotate_frame_address_end ();
744 ui_out_text (uiout, " in ");
746 annotate_frame_function_name ();
747 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
749 ui_out_field_stream (uiout, "func", stb);
750 ui_out_wrap_hint (uiout, " ");
751 annotate_frame_args ();
753 ui_out_text (uiout, " (");
756 struct gdbarch *gdbarch = get_frame_arch (frame);
758 struct cleanup *args_list_chain;
759 volatile struct gdb_exception e;
761 if (gdbarch_frame_num_args_p (gdbarch))
763 numargs = gdbarch_frame_num_args (gdbarch, frame);
764 gdb_assert (numargs >= 0);
769 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
770 TRY_CATCH (e, RETURN_MASK_ERROR)
772 print_frame_args (func, frame, numargs, gdb_stdout);
774 /* FIXME: ARGS must be a list. If one argument is a string it
775 will have " that will not be properly escaped. */
776 /* Invoke ui_out_tuple_end. */
777 do_cleanups (args_list_chain);
780 ui_out_text (uiout, ")");
781 if (sal.symtab && sal.symtab->filename)
783 annotate_frame_source_begin ();
784 ui_out_wrap_hint (uiout, " ");
785 ui_out_text (uiout, " at ");
786 annotate_frame_source_file ();
787 ui_out_field_string (uiout, "file", sal.symtab->filename);
788 if (ui_out_is_mi_like_p (uiout))
790 const char *fullname = symtab_to_fullname (sal.symtab);
792 if (fullname != NULL)
793 ui_out_field_string (uiout, "fullname", fullname);
795 annotate_frame_source_file_end ();
796 ui_out_text (uiout, ":");
797 annotate_frame_source_line ();
798 ui_out_field_int (uiout, "line", sal.line);
799 annotate_frame_source_end ();
802 if (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename)))
805 char *lib = PC_SOLIB (get_frame_pc (frame));
807 char *lib = solib_name_from_address (get_frame_program_space (frame),
808 get_frame_pc (frame));
812 annotate_frame_where ();
813 ui_out_wrap_hint (uiout, " ");
814 ui_out_text (uiout, " from ");
815 ui_out_field_string (uiout, "from", lib);
819 /* do_cleanups will call ui_out_tuple_end() for us. */
820 do_cleanups (list_chain);
821 ui_out_text (uiout, "\n");
822 do_cleanups (old_chain);
826 /* Read a frame specification in whatever the appropriate format is
827 from FRAME_EXP. Call error(), printing MESSAGE, if the
828 specification is in any way invalid (so this function never returns
829 NULL). When SEPECTED_P is non-NULL set its target to indicate that
830 the default selected frame was used. */
832 static struct frame_info *
833 parse_frame_specification_1 (const char *frame_exp, const char *message,
834 int *selected_frame_p)
837 struct value *args[4];
838 CORE_ADDR addrs[ARRAY_SIZE (args)];
840 if (frame_exp == NULL)
848 struct cleanup *cleanup;
851 /* Skip leading white space, bail of EOL. */
852 while (isspace (*frame_exp))
857 /* Parse the argument, extract it, save it. */
861 addr_string = savestring (frame_exp, p - frame_exp);
863 cleanup = make_cleanup (xfree, addr_string);
865 /* NOTE: Parse and evaluate expression, but do not use
866 functions such as parse_and_eval_long or
867 parse_and_eval_address to also extract the value.
868 Instead value_as_long and value_as_address are used.
869 This avoids problems with expressions that contain
871 if (numargs >= ARRAY_SIZE (args))
872 error (_("Too many args in frame specification"));
873 args[numargs++] = parse_and_eval (addr_string);
875 do_cleanups (cleanup);
879 /* If no args, default to the selected frame. */
882 if (selected_frame_p != NULL)
883 (*selected_frame_p) = 1;
884 return get_selected_frame (message);
887 /* None of the remaining use the selected frame. */
888 if (selected_frame_p != NULL)
889 (*selected_frame_p) = 0;
891 /* Assume the single arg[0] is an integer, and try using that to
892 select a frame relative to current. */
895 struct frame_info *fid;
896 int level = value_as_long (args[0]);
898 fid = find_relative_frame (get_current_frame (), &level);
900 /* find_relative_frame was successful. */
904 /* Convert each value into a corresponding address. */
908 for (i = 0; i < numargs; i++)
909 addrs[i] = value_as_address (args[i]);
912 /* Assume that the single arg[0] is an address, use that to identify
913 a frame with a matching ID. Should this also accept stack/pc or
917 struct frame_id id = frame_id_build_wild (addrs[0]);
918 struct frame_info *fid;
920 /* If (s)he specifies the frame with an address, he deserves
921 what (s)he gets. Still, give the highest one that matches.
922 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
924 for (fid = get_current_frame ();
926 fid = get_prev_frame (fid))
928 if (frame_id_eq (id, get_frame_id (fid)))
930 struct frame_info *prev_frame;
934 prev_frame = get_prev_frame (fid);
936 || !frame_id_eq (id, get_frame_id (prev_frame)))
945 /* We couldn't identify the frame as an existing frame, but
946 perhaps we can create one with a single argument. */
948 return create_new_frame (addrs[0], 0);
949 else if (numargs == 2)
950 return create_new_frame (addrs[0], addrs[1]);
952 error (_("Too many args in frame specification"));
955 static struct frame_info *
956 parse_frame_specification (char *frame_exp)
958 return parse_frame_specification_1 (frame_exp, NULL, NULL);
961 /* Print verbosely the selected frame or the frame at address
962 ADDR_EXP. Absolutely all information in the frame is printed. */
965 frame_info (char *addr_exp, int from_tty)
967 struct frame_info *fi;
968 struct symtab_and_line sal;
971 struct frame_info *calling_frame_info;
974 enum language funlang = language_unknown;
975 const char *pc_regname;
976 int selected_frame_p;
977 struct gdbarch *gdbarch;
978 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
983 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
984 gdbarch = get_frame_arch (fi);
986 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
987 is not a good name. */
988 if (gdbarch_pc_regnum (gdbarch) >= 0)
989 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
990 easily not match that of the internal value returned by
992 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
994 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
995 architectures will often have a hardware register called "pc",
996 and that register's value, again, can easily not match
1000 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1001 find_frame_sal (fi, &sal);
1002 func = get_frame_function (fi);
1006 funname = SYMBOL_PRINT_NAME (func);
1007 funlang = SYMBOL_LANGUAGE (func);
1008 if (funlang == language_cplus)
1010 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1011 to display the demangled name that we already have
1012 stored in the symbol table, but we stored a version
1013 with DMGL_PARAMS turned on, and here we don't want to
1014 display parameters. So remove the parameters. */
1015 char *func_only = cp_remove_params (funname);
1019 funname = func_only;
1020 make_cleanup (xfree, func_only);
1024 else if (frame_pc_p)
1026 struct minimal_symbol *msymbol;
1028 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1029 if (msymbol != NULL)
1031 funname = SYMBOL_PRINT_NAME (msymbol);
1032 funlang = SYMBOL_LANGUAGE (msymbol);
1035 calling_frame_info = get_prev_frame (fi);
1037 if (selected_frame_p && frame_relative_level (fi) >= 0)
1039 printf_filtered (_("Stack level %d, frame at "),
1040 frame_relative_level (fi));
1044 printf_filtered (_("Stack frame at "));
1046 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1047 printf_filtered (":\n");
1048 printf_filtered (" %s = ", pc_regname);
1050 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1052 fputs_filtered ("<unavailable>", gdb_stdout);
1057 printf_filtered (" in ");
1058 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1059 DMGL_ANSI | DMGL_PARAMS);
1063 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
1064 puts_filtered ("; ");
1066 printf_filtered ("saved %s ", pc_regname);
1067 if (frame_unwind_caller_pc_if_available (fi, &caller_pc))
1068 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1070 fputs_filtered ("<unavailable>", gdb_stdout);
1071 printf_filtered ("\n");
1073 if (calling_frame_info == NULL)
1075 enum unwind_stop_reason reason;
1077 reason = get_frame_unwind_stop_reason (fi);
1078 if (reason != UNWIND_NO_REASON)
1079 printf_filtered (_(" Outermost frame: %s\n"),
1080 frame_stop_reason_string (reason));
1082 else if (get_frame_type (fi) == INLINE_FRAME)
1083 printf_filtered (" inlined into frame %d",
1084 frame_relative_level (get_prev_frame (fi)));
1087 printf_filtered (" called by frame at ");
1088 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1091 if (get_next_frame (fi) && calling_frame_info)
1092 puts_filtered (",");
1094 if (get_next_frame (fi))
1096 printf_filtered (" caller of frame at ");
1097 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1100 if (get_next_frame (fi) || calling_frame_info)
1101 puts_filtered ("\n");
1104 printf_filtered (" source language %s.\n",
1105 language_str (s->language));
1108 /* Address of the argument list for this frame, or 0. */
1109 CORE_ADDR arg_list = get_frame_args_address (fi);
1110 /* Number of args for this frame, or -1 if unknown. */
1114 printf_filtered (" Arglist at unknown address.\n");
1117 printf_filtered (" Arglist at ");
1118 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1119 printf_filtered (",");
1121 if (!gdbarch_frame_num_args_p (gdbarch))
1124 puts_filtered (" args: ");
1128 numargs = gdbarch_frame_num_args (gdbarch, fi);
1129 gdb_assert (numargs >= 0);
1131 puts_filtered (" no args.");
1132 else if (numargs == 1)
1133 puts_filtered (" 1 arg: ");
1135 printf_filtered (" %d args: ", numargs);
1137 print_frame_args (func, fi, numargs, gdb_stdout);
1138 puts_filtered ("\n");
1142 /* Address of the local variables for this frame, or 0. */
1143 CORE_ADDR arg_list = get_frame_locals_address (fi);
1146 printf_filtered (" Locals at unknown address,");
1149 printf_filtered (" Locals at ");
1150 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1151 printf_filtered (",");
1155 /* Print as much information as possible on the location of all the
1158 enum lval_type lval;
1167 /* The sp is special; what's displayed isn't the save address, but
1168 the value of the previous frame's sp. This is a legacy thing,
1169 at one stage the frame cached the previous frame's SP instead
1170 of its address, hence it was easiest to just display the cached
1172 if (gdbarch_sp_regnum (gdbarch) >= 0)
1174 /* Find out the location of the saved stack pointer with out
1175 actually evaluating it. */
1176 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1177 &optimized, &unavailable, &lval, &addr,
1179 if (!optimized && !unavailable && lval == not_lval)
1181 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1182 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1183 gdb_byte value[MAX_REGISTER_SIZE];
1186 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1187 &optimized, &unavailable, &lval, &addr,
1189 /* NOTE: cagney/2003-05-22: This is assuming that the
1190 stack pointer was packed as an unsigned integer. That
1191 may or may not be valid. */
1192 sp = extract_unsigned_integer (value, sp_size, byte_order);
1193 printf_filtered (" Previous frame's sp is ");
1194 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1195 printf_filtered ("\n");
1198 else if (!optimized && !unavailable && lval == lval_memory)
1200 printf_filtered (" Previous frame's sp at ");
1201 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1202 printf_filtered ("\n");
1205 else if (!optimized && !unavailable && lval == lval_register)
1207 printf_filtered (" Previous frame's sp in %s\n",
1208 gdbarch_register_name (gdbarch, realnum));
1211 /* else keep quiet. */
1215 numregs = gdbarch_num_regs (gdbarch)
1216 + gdbarch_num_pseudo_regs (gdbarch);
1217 for (i = 0; i < numregs; i++)
1218 if (i != gdbarch_sp_regnum (gdbarch)
1219 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1221 /* Find out the location of the saved register without
1222 fetching the corresponding value. */
1223 frame_register_unwind (fi, i, &optimized, &unavailable,
1224 &lval, &addr, &realnum, NULL);
1225 /* For moment, only display registers that were saved on the
1227 if (!optimized && !unavailable && lval == lval_memory)
1230 puts_filtered (" Saved registers:\n ");
1232 puts_filtered (",");
1234 printf_filtered (" %s at ",
1235 gdbarch_register_name (gdbarch, i));
1236 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1240 if (count || need_nl)
1241 puts_filtered ("\n");
1244 do_cleanups (back_to);
1247 /* Print briefly all stack frames or just the innermost COUNT_EXP
1251 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1253 struct frame_info *fi;
1256 struct frame_info *trailing;
1259 if (!target_has_stack)
1260 error (_("No stack."));
1262 /* The following code must do two things. First, it must set the
1263 variable TRAILING to the frame from which we should start
1264 printing. Second, it must set the variable count to the number
1265 of frames which we should print, or -1 if all of them. */
1266 trailing = get_current_frame ();
1271 count = parse_and_eval_long (count_exp);
1274 struct frame_info *current;
1279 while (current && count--)
1282 current = get_prev_frame (current);
1285 /* Will stop when CURRENT reaches the top of the stack.
1286 TRAILING will be COUNT below it. */
1290 trailing = get_prev_frame (trailing);
1291 current = get_prev_frame (current);
1303 /* Read in symbols for all of the frames. Need to do this in a
1304 separate pass so that "Reading in symbols for xxx" messages
1305 don't screw up the appearance of the backtrace. Also if
1306 people have strong opinions against reading symbols for
1307 backtrace this may have to be an option. */
1309 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1314 pc = get_frame_address_in_block (fi);
1315 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc));
1319 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1323 /* Don't use print_stack_frame; if an error() occurs it probably
1324 means further attempts to backtrace would fail (on the other
1325 hand, perhaps the code does or could be fixed to make sure
1326 the frame->prev field gets set to NULL in that case). */
1327 print_frame_info (fi, 1, LOCATION, 1);
1329 print_frame_local_vars (fi, 1, gdb_stdout);
1331 /* Save the last frame to check for error conditions. */
1335 /* If we've stopped before the end, mention that. */
1337 printf_filtered (_("(More stack frames follow...)\n"));
1339 /* If we've run out of frames, and the reason appears to be an error
1340 condition, print it. */
1341 if (fi == NULL && trailing != NULL)
1343 enum unwind_stop_reason reason;
1345 reason = get_frame_unwind_stop_reason (trailing);
1346 if (reason > UNWIND_FIRST_ERROR)
1347 printf_filtered (_("Backtrace stopped: %s\n"),
1348 frame_stop_reason_string (reason));
1353 backtrace_command (char *arg, int from_tty)
1355 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
1356 int fulltrace_arg = -1, arglen = 0, argc = 0;
1363 argv = gdb_buildargv (arg);
1364 make_cleanup_freeargv (argv);
1366 for (i = 0; argv[i]; i++)
1370 for (j = 0; j < strlen (argv[i]); j++)
1371 argv[i][j] = tolower (argv[i][j]);
1373 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1374 fulltrace_arg = argc;
1377 arglen += strlen (argv[i]);
1382 if (fulltrace_arg >= 0)
1386 arg = xmalloc (arglen + 1);
1387 make_cleanup (xfree, arg);
1389 for (i = 0; i < (argc + 1); i++)
1391 if (i != fulltrace_arg)
1393 strcat (arg, argv[i]);
1403 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, from_tty);
1405 do_cleanups (old_chain);
1409 backtrace_full_command (char *arg, int from_tty)
1411 backtrace_command_1 (arg, 1 /* show_locals */, from_tty);
1415 /* Iterate over the local variables of a block B, calling CB with
1419 iterate_over_block_locals (struct block *b,
1420 iterate_over_block_arg_local_vars_cb cb,
1423 struct dict_iterator iter;
1426 ALL_BLOCK_SYMBOLS (b, iter, sym)
1428 switch (SYMBOL_CLASS (sym))
1434 if (SYMBOL_IS_ARGUMENT (sym))
1436 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
1440 /* Ignore symbols which are not locals. */
1447 /* Same, but print labels. */
1450 /* Commented out, as the code using this function has also been
1451 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1452 was commented out in the first place. The discussion introducing
1453 this change (2007-12-04: Support lexical blocks and function bodies
1454 that occupy non-contiguous address ranges) did not explain why
1455 this change was made. */
1457 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1458 int *have_default, struct ui_file *stream)
1460 struct dict_iterator iter;
1462 int values_printed = 0;
1464 ALL_BLOCK_SYMBOLS (b, iter, sym)
1466 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1472 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1474 struct symtab_and_line sal;
1475 struct value_print_options opts;
1477 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1479 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1480 get_user_print_options (&opts);
1481 if (opts.addressprint)
1483 fprintf_filtered (stream, " ");
1484 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1487 fprintf_filtered (stream, " in file %s, line %d\n",
1488 sal.symtab->filename, sal.line);
1492 return values_printed;
1496 /* Iterate over all the local variables in block B, including all its
1497 superblocks, stopping when the top-level block is reached. */
1500 iterate_over_block_local_vars (struct block *block,
1501 iterate_over_block_arg_local_vars_cb cb,
1506 iterate_over_block_locals (block, cb, cb_data);
1507 /* After handling the function's top-level block, stop. Don't
1508 continue to its superblock, the block of per-file
1510 if (BLOCK_FUNCTION (block))
1512 block = BLOCK_SUPERBLOCK (block);
1516 /* Data to be passed around in the calls to the locals and args
1519 struct print_variable_and_value_data
1521 struct frame_info *frame;
1523 struct ui_file *stream;
1527 /* The callback for the locals and args iterators. */
1530 do_print_variable_and_value (const char *print_name,
1534 struct print_variable_and_value_data *p = cb_data;
1536 print_variable_and_value (print_name, sym,
1537 p->frame, p->stream, p->num_tabs);
1538 p->values_printed = 1;
1542 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1543 struct ui_file *stream)
1545 struct print_variable_and_value_data cb_data;
1546 struct block *block;
1549 if (!get_frame_pc_if_available (frame, &pc))
1551 fprintf_filtered (stream,
1552 _("PC unavailable, cannot determine locals.\n"));
1556 block = get_frame_block (frame, 0);
1559 fprintf_filtered (stream, "No symbol table info available.\n");
1563 cb_data.frame = frame;
1564 cb_data.num_tabs = 4 * num_tabs;
1565 cb_data.stream = stream;
1566 cb_data.values_printed = 0;
1568 iterate_over_block_local_vars (block,
1569 do_print_variable_and_value,
1572 if (!cb_data.values_printed)
1573 fprintf_filtered (stream, _("No locals.\n"));
1576 /* Same, but print labels. */
1579 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1580 struct ui_file *stream)
1583 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1585 struct blockvector *bl;
1586 struct block *block = get_frame_block (frame, 0);
1587 struct gdbarch *gdbarch = get_frame_arch (frame);
1588 int values_printed = 0;
1589 int index, have_default = 0;
1590 char *blocks_printed;
1591 CORE_ADDR pc = get_frame_pc (frame);
1595 fprintf_filtered (stream, "No symbol table info available.\n");
1599 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1600 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1601 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1605 CORE_ADDR end = BLOCK_END (block) - 4;
1608 if (bl != blockvector_for_pc (end, &index))
1609 error (_("blockvector blotch"));
1610 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1611 error (_("blockvector botch"));
1612 last_index = BLOCKVECTOR_NBLOCKS (bl);
1615 /* Don't print out blocks that have gone by. */
1616 while (index < last_index
1617 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1620 while (index < last_index
1621 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1623 if (blocks_printed[index] == 0)
1625 if (print_block_frame_labels (gdbarch,
1626 BLOCKVECTOR_BLOCK (bl, index),
1627 &have_default, stream))
1629 blocks_printed[index] = 1;
1635 if (values_printed && this_level_only)
1638 /* After handling the function's top-level block, stop. Don't
1639 continue to its superblock, the block of per-file symbols.
1640 Also do not continue to the containing function of an inlined
1642 if (BLOCK_FUNCTION (block))
1644 block = BLOCK_SUPERBLOCK (block);
1647 if (!values_printed && !this_level_only)
1648 fprintf_filtered (stream, _("No catches.\n"));
1653 locals_info (char *args, int from_tty)
1655 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1660 catch_info (char *ignore, int from_tty)
1662 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1663 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1667 /* Iterate over all the argument variables in block B.
1669 Returns 1 if any argument was walked; 0 otherwise. */
1672 iterate_over_block_arg_vars (struct block *b,
1673 iterate_over_block_arg_local_vars_cb cb,
1676 struct dict_iterator iter;
1677 struct symbol *sym, *sym2;
1679 ALL_BLOCK_SYMBOLS (b, iter, sym)
1681 /* Don't worry about things which aren't arguments. */
1682 if (SYMBOL_IS_ARGUMENT (sym))
1684 /* We have to look up the symbol because arguments can have
1685 two entries (one a parameter, one a local) and the one we
1686 want is the local, which lookup_symbol will find for us.
1687 This includes gcc1 (not gcc2) on the sparc when passing a
1688 small structure and gcc2 when the argument type is float
1689 and it is passed as a double and converted to float by
1690 the prologue (in the latter case the type of the LOC_ARG
1691 symbol is double and the type of the LOC_LOCAL symbol is
1692 float). There are also LOC_ARG/LOC_REGISTER pairs which
1693 are not combined in symbol-reading. */
1695 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
1696 b, VAR_DOMAIN, NULL);
1697 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
1703 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1705 struct print_variable_and_value_data cb_data;
1706 struct symbol *func;
1709 if (!get_frame_pc_if_available (frame, &pc))
1711 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
1715 func = get_frame_function (frame);
1718 fprintf_filtered (stream, _("No symbol table info available.\n"));
1722 cb_data.frame = frame;
1723 cb_data.num_tabs = 0;
1724 cb_data.stream = gdb_stdout;
1725 cb_data.values_printed = 0;
1727 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
1728 do_print_variable_and_value, &cb_data);
1730 if (!cb_data.values_printed)
1731 fprintf_filtered (stream, _("No arguments.\n"));
1735 args_info (char *ignore, int from_tty)
1737 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1743 args_plus_locals_info (char *ignore, int from_tty)
1745 args_info (ignore, from_tty);
1746 locals_info (ignore, from_tty);
1750 /* Select frame FRAME. Also print the stack frame and show the source
1751 if this is the tui version. */
1753 select_and_print_frame (struct frame_info *frame)
1755 select_frame (frame);
1757 print_stack_frame (frame, 1, SRC_AND_LOC);
1760 /* Return the symbol-block in which the selected frame is executing.
1761 Can return zero under various legitimate circumstances.
1763 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1764 code address within the block returned. We use this to decide
1765 which macros are in scope. */
1768 get_selected_block (CORE_ADDR *addr_in_block)
1770 if (!has_stack_frames ())
1773 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1776 /* Find a frame a certain number of levels away from FRAME.
1777 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1778 Positive means go to earlier frames (up); negative, the reverse.
1779 The int that contains the number of levels is counted toward
1780 zero as the frames for those levels are found.
1781 If the top or bottom frame is reached, that frame is returned,
1782 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1783 how much farther the original request asked to go. */
1786 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1788 /* Going up is simple: just call get_prev_frame enough times or
1789 until the initial frame is reached. */
1790 while (*level_offset_ptr > 0)
1792 struct frame_info *prev = get_prev_frame (frame);
1796 (*level_offset_ptr)--;
1800 /* Going down is just as simple. */
1801 while (*level_offset_ptr < 0)
1803 struct frame_info *next = get_next_frame (frame);
1807 (*level_offset_ptr)++;
1814 /* The "select_frame" command. With no argument this is a NOP.
1815 Select the frame at level LEVEL_EXP if it is a valid level.
1816 Otherwise, treat LEVEL_EXP as an address expression and select it.
1818 See parse_frame_specification for more info on proper frame
1822 select_frame_command (char *level_exp, int from_tty)
1824 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1827 /* The "frame" command. With no argument, print the selected frame
1828 briefly. With an argument, behave like select_frame and then print
1829 the selected frame. */
1832 frame_command (char *level_exp, int from_tty)
1834 select_frame_command (level_exp, from_tty);
1835 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1838 /* The XDB Compatibility command to print the current frame. */
1841 current_frame_command (char *level_exp, int from_tty)
1843 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1846 /* Select the frame up one or COUNT_EXP stack levels from the
1847 previously selected frame, and print it briefly. */
1850 up_silently_base (char *count_exp)
1852 struct frame_info *frame;
1856 count = parse_and_eval_long (count_exp);
1858 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1859 if (count != 0 && count_exp == NULL)
1860 error (_("Initial frame selected; you cannot go up."));
1861 select_frame (frame);
1865 up_silently_command (char *count_exp, int from_tty)
1867 up_silently_base (count_exp);
1871 up_command (char *count_exp, int from_tty)
1873 up_silently_base (count_exp);
1874 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1877 /* Select the frame down one or COUNT_EXP stack levels from the previously
1878 selected frame, and print it briefly. */
1881 down_silently_base (char *count_exp)
1883 struct frame_info *frame;
1887 count = -parse_and_eval_long (count_exp);
1889 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1890 if (count != 0 && count_exp == NULL)
1892 /* We only do this if COUNT_EXP is not specified. That way
1893 "down" means to really go down (and let me know if that is
1894 impossible), but "down 9999" can be used to mean go all the
1895 way down without getting an error. */
1897 error (_("Bottom (innermost) frame selected; you cannot go down."));
1900 select_frame (frame);
1904 down_silently_command (char *count_exp, int from_tty)
1906 down_silently_base (count_exp);
1910 down_command (char *count_exp, int from_tty)
1912 down_silently_base (count_exp);
1913 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1918 return_command (char *retval_exp, int from_tty)
1920 struct frame_info *thisframe;
1921 struct gdbarch *gdbarch;
1922 struct symbol *thisfun;
1923 struct value *return_value = NULL;
1924 const char *query_prefix = "";
1926 thisframe = get_selected_frame ("No selected frame.");
1927 thisfun = get_frame_function (thisframe);
1928 gdbarch = get_frame_arch (thisframe);
1930 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
1931 error (_("Can not force return from an inlined function."));
1933 /* Compute the return value. If the computation triggers an error,
1934 let it bail. If the return type can't be handled, set
1935 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1939 struct expression *retval_expr = parse_expression (retval_exp);
1940 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
1941 struct type *return_type = NULL;
1943 /* Compute the return value. Should the computation fail, this
1944 call throws an error. */
1945 return_value = evaluate_expression (retval_expr);
1947 /* Cast return value to the return type of the function. Should
1948 the cast fail, this call throws an error. */
1949 if (thisfun != NULL)
1950 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1951 if (return_type == NULL)
1953 if (retval_expr->elts[0].opcode != UNOP_CAST)
1954 error (_("Return value type not available for selected "
1956 "Please use an explicit cast of the value to return."));
1957 return_type = value_type (return_value);
1959 do_cleanups (old_chain);
1960 CHECK_TYPEDEF (return_type);
1961 return_value = value_cast (return_type, return_value);
1963 /* Make sure the value is fully evaluated. It may live in the
1964 stack frame we're about to pop. */
1965 if (value_lazy (return_value))
1966 value_fetch_lazy (return_value);
1968 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1969 /* If the return-type is "void", don't try to find the
1970 return-value's location. However, do still evaluate the
1971 return expression so that, even when the expression result
1972 is discarded, side effects such as "return i++" still
1974 return_value = NULL;
1975 else if (thisfun != NULL
1976 && using_struct_return (gdbarch,
1977 SYMBOL_TYPE (thisfun), return_type))
1979 query_prefix = "The location at which to store the "
1980 "function's return value is unknown.\n"
1981 "If you continue, the return value "
1982 "that you specified will be ignored.\n";
1983 return_value = NULL;
1987 /* Does an interactive user really want to do this? Include
1988 information, such as how well GDB can handle the return value, in
1989 the query message. */
1994 if (thisfun == NULL)
1995 confirmed = query (_("%sMake selected stack frame return now? "),
1998 confirmed = query (_("%sMake %s return now? "), query_prefix,
1999 SYMBOL_PRINT_NAME (thisfun));
2001 error (_("Not confirmed"));
2004 /* Discard the selected frame and all frames inner-to it. */
2005 frame_pop (get_selected_frame (NULL));
2007 /* Store RETURN_VALUE in the just-returned register set. */
2008 if (return_value != NULL)
2010 struct type *return_type = value_type (return_value);
2011 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
2012 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
2014 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
2016 == RETURN_VALUE_REGISTER_CONVENTION);
2017 gdbarch_return_value (gdbarch, func_type, return_type,
2018 get_current_regcache (), NULL /*read*/,
2019 value_contents (return_value) /*write*/);
2022 /* If we are at the end of a call dummy now, pop the dummy frame
2024 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2025 frame_pop (get_current_frame ());
2027 /* If interactive, print the frame that is now current. */
2029 frame_command ("0", 1);
2031 select_frame_command ("0", 0);
2034 /* Sets the scope to input function name, provided that the function
2035 is within the current stack frame. */
2037 struct function_bounds
2039 CORE_ADDR low, high;
2043 func_command (char *arg, int from_tty)
2045 struct frame_info *frame;
2047 struct symtabs_and_lines sals;
2050 struct function_bounds *func_bounds = NULL;
2055 frame = parse_frame_specification ("0");
2056 sals = decode_line_spec (arg, 1);
2057 func_bounds = (struct function_bounds *) xmalloc (
2058 sizeof (struct function_bounds) * sals.nelts);
2059 for (i = 0; (i < sals.nelts && !found); i++)
2061 if (sals.sals[i].pc == 0
2062 || find_pc_partial_function (sals.sals[i].pc, NULL,
2063 &func_bounds[i].low,
2064 &func_bounds[i].high) == 0)
2066 func_bounds[i].low = func_bounds[i].high = 0;
2072 for (i = 0; (i < sals.nelts && !found); i++)
2073 found = (get_frame_pc (frame) >= func_bounds[i].low
2074 && get_frame_pc (frame) < func_bounds[i].high);
2078 frame = find_relative_frame (frame, &level);
2081 while (!found && level == 0);
2084 xfree (func_bounds);
2087 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2088 else if (frame != get_selected_frame (NULL))
2089 select_and_print_frame (frame);
2092 /* Gets the language of the current frame. */
2095 get_frame_language (void)
2097 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2101 volatile struct gdb_exception ex;
2105 /* We determine the current frame language by looking up its
2106 associated symtab. To retrieve this symtab, we use the frame
2107 PC. However we cannot use the frame PC as is, because it
2108 usually points to the instruction following the "call", which
2109 is sometimes the first instruction of another function. So
2110 we rely on get_frame_address_in_block(), it provides us with
2111 a PC that is guaranteed to be inside the frame's code
2114 TRY_CATCH (ex, RETURN_MASK_ERROR)
2116 pc = get_frame_address_in_block (frame);
2120 if (ex.error != NOT_AVAILABLE_ERROR)
2121 throw_exception (ex);
2125 s = find_pc_symtab (pc);
2131 return language_unknown;
2135 /* Provide a prototype to silence -Wmissing-prototypes. */
2136 void _initialize_stack (void);
2139 _initialize_stack (void)
2141 add_com ("return", class_stack, return_command, _("\
2142 Make selected stack frame return to its caller.\n\
2143 Control remains in the debugger, but when you continue\n\
2144 execution will resume in the frame above the one now selected.\n\
2145 If an argument is given, it is an expression for the value to return."));
2147 add_com ("up", class_stack, up_command, _("\
2148 Select and print stack frame that called this one.\n\
2149 An argument says how many frames up to go."));
2150 add_com ("up-silently", class_support, up_silently_command, _("\
2151 Same as the `up' command, but does not print anything.\n\
2152 This is useful in command scripts."));
2154 add_com ("down", class_stack, down_command, _("\
2155 Select and print stack frame called by this one.\n\
2156 An argument says how many frames down to go."));
2157 add_com_alias ("do", "down", class_stack, 1);
2158 add_com_alias ("dow", "down", class_stack, 1);
2159 add_com ("down-silently", class_support, down_silently_command, _("\
2160 Same as the `down' command, but does not print anything.\n\
2161 This is useful in command scripts."));
2163 add_com ("frame", class_stack, frame_command, _("\
2164 Select and print a stack frame.\nWith no argument, \
2165 print the selected stack frame. (See also \"info frame\").\n\
2166 An argument specifies the frame to select.\n\
2167 It can be a stack frame number or the address of the frame.\n\
2168 With argument, nothing is printed if input is coming from\n\
2169 a command file or a user-defined command."));
2171 add_com_alias ("f", "frame", class_stack, 1);
2175 add_com ("L", class_stack, current_frame_command,
2176 _("Print the current stack frame.\n"));
2177 add_com_alias ("V", "frame", class_stack, 1);
2179 add_com ("select-frame", class_stack, select_frame_command, _("\
2180 Select a stack frame without printing anything.\n\
2181 An argument specifies the frame to select.\n\
2182 It can be a stack frame number or the address of the frame.\n"));
2184 add_com ("backtrace", class_stack, backtrace_command, _("\
2185 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2186 With a negative argument, print outermost -COUNT frames.\nUse of the \
2187 'full' qualifier also prints the values of the local variables.\n"));
2188 add_com_alias ("bt", "backtrace", class_stack, 0);
2191 add_com_alias ("t", "backtrace", class_stack, 0);
2192 add_com ("T", class_stack, backtrace_full_command, _("\
2193 Print backtrace of all stack frames, or innermost COUNT frames\n\
2194 and the values of the local variables.\n\
2195 With a negative argument, print outermost -COUNT frames.\n\
2196 Usage: T <count>\n"));
2199 add_com_alias ("where", "backtrace", class_alias, 0);
2200 add_info ("stack", backtrace_command,
2201 _("Backtrace of the stack, or innermost COUNT frames."));
2202 add_info_alias ("s", "stack", 1);
2203 add_info ("frame", frame_info,
2204 _("All about selected stack frame, or frame at ADDR."));
2205 add_info_alias ("f", "frame", 1);
2206 add_info ("locals", locals_info,
2207 _("Local variables of current stack frame."));
2208 add_info ("args", args_info,
2209 _("Argument variables of current stack frame."));
2211 add_com ("l", class_info, args_plus_locals_info,
2212 _("Argument and local variables of current stack frame."));
2215 add_com ("func", class_stack, func_command, _("\
2216 Select the stack frame that contains <func>.\n\
2217 Usage: func <name>\n"));
2219 add_info ("catch", catch_info,
2220 _("Exceptions that can be caught in the current stack frame."));
2222 add_setshow_enum_cmd ("frame-arguments", class_stack,
2223 print_frame_arguments_choices, &print_frame_arguments,
2224 _("Set printing of non-scalar frame arguments"),
2225 _("Show printing of non-scalar frame arguments"),
2226 NULL, NULL, NULL, &setprintlist, &showprintlist);
2228 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2229 &disassemble_next_line, _("\
2230 Set whether to disassemble next source line or insn when execution stops."),
2232 Show whether to disassemble next source line or insn when execution stops."),
2234 If ON, GDB will display disassembly of the next source line, in addition\n\
2235 to displaying the source line itself. If the next source line cannot\n\
2236 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2237 will display disassembly of next instruction instead of showing the\n\
2239 If AUTO, display disassembly of next instruction only if the source line\n\
2240 cannot be displayed.\n\
2241 If OFF (which is the default), never display the disassembly of the next\n\
2244 show_disassemble_next_line,
2245 &setlist, &showlist);
2246 disassemble_next_line = AUTO_BOOLEAN_FALSE;