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 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"
55 void (*deprecated_selected_frame_level_changed_hook) (int);
57 /* The possible choices of "set print frame-arguments, and the value
60 static const char *print_frame_arguments_choices[] =
61 {"all", "scalars", "none", NULL};
62 static const char *print_frame_arguments = "scalars";
64 /* Prototypes for local functions. */
66 static void print_frame_local_vars (struct frame_info *, int,
69 static void print_frame (struct frame_info *frame, int print_level,
70 enum print_what print_what, int print_args,
71 struct symtab_and_line sal);
73 /* Zero means do things normally; we are interacting directly with the
74 user. One means print the full filename and linenumber when a
75 frame is printed, and do so in a format emacs18/emacs19.22 can
76 parse. Two means print similar annotations, but in many more
77 cases and in a slightly different syntax. */
79 int annotation_level = 0;
82 struct print_stack_frame_args
84 struct frame_info *frame;
86 enum print_what print_what;
90 /* Show or print the frame arguments; stub for catch_errors. */
93 print_stack_frame_stub (void *args)
95 struct print_stack_frame_args *p = args;
96 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
98 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
99 set_current_sal_from_frame (p->frame, center);
103 /* Return 1 if we should display the address in addition to the location,
104 because we are in the middle of a statement. */
107 frame_show_address (struct frame_info *frame,
108 struct symtab_and_line sal)
110 /* If there is a line number, but no PC, then there is no location
111 information associated with this sal. The only way that should
112 happen is for the call sites of inlined functions (SAL comes from
113 find_frame_sal). Otherwise, we would have some PC range if the
114 SAL came from a line table. */
115 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
117 if (get_next_frame (frame) == NULL)
118 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
120 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
124 return get_frame_pc (frame) != sal.pc;
127 /* Show or print a stack frame FRAME briefly. The output is format
128 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
129 relative level, function name, argument list, and file name and
130 line number. If the frame's PC is not at the beginning of the
131 source line, the actual PC is printed at the beginning. */
134 print_stack_frame (struct frame_info *frame, int print_level,
135 enum print_what print_what)
137 struct print_stack_frame_args args;
140 args.print_level = print_level;
141 args.print_what = print_what;
142 /* For mi, alway print location and address. */
143 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
146 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
149 struct print_args_args
152 struct frame_info *frame;
153 struct ui_file *stream;
156 static int print_args_stub (void *args);
158 /* Print nameless arguments of frame FRAME on STREAM, where START is
159 the offset of the first nameless argument, and NUM is the number of
160 nameless arguments to print. FIRST is nonzero if this is the first
161 argument (not just the first nameless argument). */
164 print_frame_nameless_args (struct frame_info *frame, long start, int num,
165 int first, struct ui_file *stream)
171 for (i = 0; i < num; i++)
174 argsaddr = get_frame_args_address (frame);
177 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
179 fprintf_filtered (stream, ", ");
180 fprintf_filtered (stream, "%ld", arg_value);
182 start += sizeof (int);
186 /* Print the arguments of frame FRAME on STREAM, given the function
187 FUNC running in that frame (as a symbol), where NUM is the number
188 of arguments according to the stack frame (or -1 if the number of
189 arguments is unknown). */
191 /* Note that currently the "number of arguments according to the
192 stack frame" is only known on VAX where i refers to the "number of
193 ints of arguments according to the stack frame". */
196 print_frame_args (struct symbol *func, struct frame_info *frame,
197 int num, struct ui_file *stream)
200 /* Offset of next stack argument beyond the one we have seen that is
201 at the highest offset, or -1 if we haven't come to a stack
203 long highest_offset = -1;
204 /* Number of ints of arguments that we have printed so far. */
205 int args_printed = 0;
206 struct cleanup *old_chain, *list_chain;
207 struct ui_stream *stb;
208 /* True if we should print arguments, false otherwise. */
209 int print_args = strcmp (print_frame_arguments, "none");
210 /* True in "summary" mode, false otherwise. */
211 int summary = !strcmp (print_frame_arguments, "scalars");
213 stb = ui_out_stream_new (uiout);
214 old_chain = make_cleanup_ui_out_stream_delete (stb);
218 struct block *b = SYMBOL_BLOCK_VALUE (func);
219 struct dict_iterator iter;
223 ALL_BLOCK_SYMBOLS (b, iter, sym)
227 /* Keep track of the highest stack argument offset seen, and
228 skip over any kinds of symbols we don't care about. */
230 if (!SYMBOL_IS_ARGUMENT (sym))
233 switch (SYMBOL_CLASS (sym))
238 long current_offset = SYMBOL_VALUE (sym);
239 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
241 /* Compute address of next argument by adding the size of
242 this argument and rounding to an int boundary. */
244 ((current_offset + arg_size + sizeof (int) - 1)
245 & ~(sizeof (int) - 1));
247 /* If this is the highest offset seen yet, set
249 if (highest_offset == -1
250 || (current_offset > highest_offset))
251 highest_offset = current_offset;
253 /* Add the number of ints we're about to print to
255 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
258 /* We care about types of symbols, but don't need to
259 keep track of stack offsets in them. */
261 case LOC_REGPARM_ADDR:
263 case LOC_OPTIMIZED_OUT:
268 /* We have to look up the symbol because arguments can have
269 two entries (one a parameter, one a local) and the one we
270 want is the local, which lookup_symbol will find for us.
271 This includes gcc1 (not gcc2) on SPARC when passing a
272 small structure and gcc2 when the argument type is float
273 and it is passed as a double and converted to float by
274 the prologue (in the latter case the type of the LOC_ARG
275 symbol is double and the type of the LOC_LOCAL symbol is
277 /* But if the parameter name is null, don't try it. Null
278 parameter names occur on the RS/6000, for traceback
279 tables. FIXME, should we even print them? */
281 if (*SYMBOL_LINKAGE_NAME (sym))
284 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
285 b, VAR_DOMAIN, NULL);
286 gdb_assert (nsym != NULL);
287 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
288 && !SYMBOL_IS_ARGUMENT (nsym))
290 /* There is a LOC_ARG/LOC_REGISTER pair. This means
291 that it was passed on the stack and loaded into a
292 register, or passed in a register and stored in a
293 stack slot. GDB 3.x used the LOC_ARG; GDB
294 4.0-4.11 used the LOC_REGISTER.
296 Reasons for using the LOC_ARG:
298 (1) Because find_saved_registers may be slow for
301 (2) Because registers are often re-used and stack
302 slots rarely (never?) are. Therefore using
303 the stack slot is much less likely to print
306 Reasons why we might want to use the LOC_REGISTER:
308 (1) So that the backtrace prints the same value
309 as "print foo". I see no compelling reason
310 why this needs to be the case; having the
311 backtrace print the value which was passed
312 in, and "print foo" print the value as
313 modified within the called function, makes
316 Additional note: It might be nice if "info args"
317 displayed both values.
319 One more note: There is a case with SPARC
320 structure passing where we need to use the
321 LOC_REGISTER, but this is dealt with by creating
322 a single LOC_REGPARM in symbol reading. */
324 /* Leave sym (the LOC_ARG) alone. */
331 /* Print the current arg. */
333 ui_out_text (uiout, ", ");
334 ui_out_wrap_hint (uiout, " ");
336 annotate_arg_begin ();
338 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
339 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
340 SYMBOL_LANGUAGE (sym),
341 DMGL_PARAMS | DMGL_ANSI);
342 ui_out_field_stream (uiout, "name", stb);
343 annotate_arg_name_end ();
344 ui_out_text (uiout, "=");
348 /* Avoid value_print because it will deref ref parameters.
349 We just want to print their addresses. Print ??? for
350 args whose address we do not know. We pass 2 as
351 "recurse" to val_print because our standard indentation
352 here is 4 spaces, and val_print indents 2 for each
354 val = read_var_value (sym, frame);
356 annotate_arg_value (val == NULL ? NULL : value_type (val));
360 const struct language_defn *language;
361 struct value_print_options opts;
363 /* Use the appropriate language to display our symbol,
364 unless the user forced the language to a specific
366 if (language_mode == language_mode_auto)
367 language = language_def (SYMBOL_LANGUAGE (sym));
369 language = current_language;
371 get_raw_print_options (&opts);
373 opts.summary = summary;
374 common_val_print (val, stb->stream, 2, &opts, language);
375 ui_out_field_stream (uiout, "value", stb);
378 ui_out_text (uiout, "???");
381 ui_out_text (uiout, "...");
384 /* Invoke ui_out_tuple_end. */
385 do_cleanups (list_chain);
393 /* Don't print nameless args in situations where we don't know
394 enough about the stack to find them. */
399 if (highest_offset == -1)
400 start = gdbarch_frame_args_skip (get_frame_arch (frame));
402 start = highest_offset;
404 print_frame_nameless_args (frame, start, num - args_printed,
408 do_cleanups (old_chain);
411 /* Stub for catch_errors. */
414 print_args_stub (void *args)
416 struct print_args_args *p = args;
417 struct gdbarch *gdbarch = get_frame_arch (p->frame);
420 if (gdbarch_frame_num_args_p (gdbarch))
422 numargs = gdbarch_frame_num_args (gdbarch, p->frame);
423 gdb_assert (numargs >= 0);
427 print_frame_args (p->func, p->frame, numargs, p->stream);
431 /* Set the current source and line to the location given by frame
432 FRAME, if possible. When CENTER is true, adjust so the relevant
433 line is in the center of the next 'list'. */
436 set_current_sal_from_frame (struct frame_info *frame, int center)
438 struct symtab_and_line sal;
440 find_frame_sal (frame, &sal);
444 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
445 set_current_source_symtab_and_line (&sal);
449 /* If ON, GDB will display disassembly of the next source line when
450 execution of the program being debugged stops.
451 If AUTO (which is the default), or there's no line info to determine
452 the source line of the next instruction, display disassembly of next
453 instruction instead. */
455 static enum auto_boolean disassemble_next_line;
458 show_disassemble_next_line (struct ui_file *file, int from_tty,
459 struct cmd_list_element *c,
462 fprintf_filtered (file, _("\
463 Debugger's willingness to use disassemble-next-line is %s.\n"),
467 /* Show assembly codes; stub for catch_errors. */
469 struct gdb_disassembly_stub_args
471 struct gdbarch *gdbarch;
478 gdb_disassembly_stub (void *args)
480 struct gdb_disassembly_stub_args *p = args;
481 gdb_disassembly (p->gdbarch, uiout, 0, 0, p->how_many, p->low, p->high);
484 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
485 because it will be broken by filter sometime. */
488 do_gdb_disassembly (struct gdbarch *gdbarch,
489 int how_many, CORE_ADDR low, CORE_ADDR high)
491 volatile struct gdb_exception exception;
492 struct gdb_disassembly_stub_args args;
494 args.gdbarch = gdbarch;
495 args.how_many = how_many;
498 TRY_CATCH (exception, RETURN_MASK_ALL)
500 gdb_disassembly_stub (&args);
502 /* If an exception was thrown while doing the disassembly, print
503 the error message, to give the user a clue of what happened. */
504 if (exception.reason == RETURN_ERROR)
505 exception_print (gdb_stderr, exception);
508 /* Print information about frame FRAME. The output is format according
509 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
512 SRC_LINE: Print only source line.
513 LOCATION: Print only location.
514 LOC_AND_SRC: Print location and source line.
516 Used in "where" output, and to emit breakpoint or step
520 print_frame_info (struct frame_info *frame, int print_level,
521 enum print_what print_what, int print_args)
523 struct gdbarch *gdbarch = get_frame_arch (frame);
524 struct symtab_and_line sal;
528 if (get_frame_type (frame) == DUMMY_FRAME
529 || get_frame_type (frame) == SIGTRAMP_FRAME
530 || get_frame_type (frame) == ARCH_FRAME)
532 struct cleanup *uiout_cleanup
533 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
535 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
536 gdbarch, get_frame_pc (frame));
538 /* Do this regardless of SOURCE because we don't have any source
539 to list for this frame. */
542 ui_out_text (uiout, "#");
543 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
544 frame_relative_level (frame));
546 if (ui_out_is_mi_like_p (uiout))
548 annotate_frame_address ();
549 ui_out_field_core_addr (uiout, "addr",
550 gdbarch, get_frame_pc (frame));
551 annotate_frame_address_end ();
554 if (get_frame_type (frame) == DUMMY_FRAME)
556 annotate_function_call ();
557 ui_out_field_string (uiout, "func", "<function called from gdb>");
559 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
561 annotate_signal_handler_caller ();
562 ui_out_field_string (uiout, "func", "<signal handler called>");
564 else if (get_frame_type (frame) == ARCH_FRAME)
566 ui_out_field_string (uiout, "func", "<cross-architecture call>");
568 ui_out_text (uiout, "\n");
569 annotate_frame_end ();
571 do_cleanups (uiout_cleanup);
575 /* If FRAME is not the innermost frame, that normally means that
576 FRAME->pc points to *after* the call instruction, and we want to
577 get the line containing the call, never the next line. But if
578 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
579 next frame was not entered as the result of a call, and we want
580 to get the line containing FRAME->pc. */
581 find_frame_sal (frame, &sal);
583 location_print = (print_what == LOCATION
584 || print_what == LOC_AND_ADDRESS
585 || print_what == SRC_AND_LOC);
587 if (location_print || !sal.symtab)
588 print_frame (frame, print_level, print_what, print_args, sal);
590 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
592 /* If disassemble-next-line is set to auto or on and doesn't have
593 the line debug messages for $pc, output the next instruction. */
594 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
595 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
596 && source_print && !sal.symtab)
597 do_gdb_disassembly (get_frame_arch (frame), 1,
598 get_frame_pc (frame), get_frame_pc (frame) + 1);
600 if (source_print && sal.symtab)
603 int mid_statement = ((print_what == SRC_LINE)
604 && frame_show_address (frame, sal));
606 if (annotation_level)
607 done = identify_source_line (sal.symtab, sal.line, mid_statement,
608 get_frame_pc (frame));
611 if (deprecated_print_frame_info_listing_hook)
612 deprecated_print_frame_info_listing_hook (sal.symtab,
617 struct value_print_options opts;
618 get_user_print_options (&opts);
619 /* We used to do this earlier, but that is clearly
620 wrong. This function is used by many different
621 parts of gdb, including normal_stop in infrun.c,
622 which uses this to print out the current PC
623 when we stepi/nexti into the middle of a source
624 line. Only the command line really wants this
625 behavior. Other UIs probably would like the
626 ability to decide for themselves if it is desired. */
627 if (opts.addressprint && mid_statement)
629 ui_out_field_core_addr (uiout, "addr",
630 gdbarch, get_frame_pc (frame));
631 ui_out_text (uiout, "\t");
634 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
638 /* If disassemble-next-line is set to on and there is line debug
639 messages, output assembly codes for next line. */
640 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
641 do_gdb_disassembly (get_frame_arch (frame), -1,
642 get_frame_pc (frame), sal.end);
645 if (print_what != LOCATION)
646 set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line);
648 annotate_frame_end ();
650 gdb_flush (gdb_stdout);
653 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
656 find_frame_funname (struct frame_info *frame, char **funname,
657 enum language *funlang)
662 *funlang = language_unknown;
664 func = get_frame_function (frame);
667 /* In certain pathological cases, the symtabs give the wrong
668 function (when we are in the first function in a file which
669 is compiled without debugging symbols, the previous function
670 is compiled with debugging symbols, and the "foo.o" symbol
671 that is supposed to tell us where the file with debugging
672 symbols ends has been truncated by ar because it is longer
673 than 15 characters). This also occurs if the user uses asm()
674 to create a function but not stabs for it (in a file compiled
677 So look in the minimal symbol tables as well, and if it comes
678 up with a larger address for the function use that instead.
679 I don't think this can ever cause any problems; there
680 shouldn't be any minimal symbols in the middle of a function;
681 if this is ever changed many parts of GDB will need to be
682 changed (and we'll create a find_pc_minimal_function or some
685 struct minimal_symbol *msymbol = NULL;
687 /* Don't attempt to do this for inlined functions, which do not
688 have a corresponding minimal symbol. */
689 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
691 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
694 && (SYMBOL_VALUE_ADDRESS (msymbol)
695 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
697 /* We also don't know anything about the function besides
698 its address and name. */
700 *funname = SYMBOL_PRINT_NAME (msymbol);
701 *funlang = SYMBOL_LANGUAGE (msymbol);
705 *funname = SYMBOL_PRINT_NAME (func);
706 *funlang = SYMBOL_LANGUAGE (func);
707 if (*funlang == language_cplus)
709 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
710 to display the demangled name that we already have
711 stored in the symbol table, but we stored a version
712 with DMGL_PARAMS turned on, and here we don't want to
713 display parameters. So remove the parameters. */
714 char *func_only = cp_remove_params (*funname);
717 *funname = func_only;
718 make_cleanup (xfree, func_only);
725 struct minimal_symbol *msymbol =
726 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
730 *funname = SYMBOL_PRINT_NAME (msymbol);
731 *funlang = SYMBOL_LANGUAGE (msymbol);
737 print_frame (struct frame_info *frame, int print_level,
738 enum print_what print_what, int print_args,
739 struct symtab_and_line sal)
741 struct gdbarch *gdbarch = get_frame_arch (frame);
742 char *funname = NULL;
743 enum language funlang = language_unknown;
744 struct ui_stream *stb;
745 struct cleanup *old_chain, *list_chain;
746 struct value_print_options opts;
748 stb = ui_out_stream_new (uiout);
749 old_chain = make_cleanup_ui_out_stream_delete (stb);
751 find_frame_funname (frame, &funname, &funlang);
753 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
754 gdbarch, get_frame_pc (frame));
756 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
760 ui_out_text (uiout, "#");
761 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
762 frame_relative_level (frame));
764 get_user_print_options (&opts);
765 if (opts.addressprint)
766 if (frame_show_address (frame, sal) || !sal.symtab
767 || print_what == LOC_AND_ADDRESS)
769 annotate_frame_address ();
770 ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame));
771 annotate_frame_address_end ();
772 ui_out_text (uiout, " in ");
774 annotate_frame_function_name ();
775 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
777 ui_out_field_stream (uiout, "func", stb);
778 ui_out_wrap_hint (uiout, " ");
779 annotate_frame_args ();
781 ui_out_text (uiout, " (");
784 struct print_args_args args;
785 struct cleanup *args_list_chain;
787 args.func = find_pc_function (get_frame_address_in_block (frame));
788 args.stream = gdb_stdout;
789 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
790 catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
791 /* FIXME: ARGS must be a list. If one argument is a string it
792 will have " that will not be properly escaped. */
793 /* Invoke ui_out_tuple_end. */
794 do_cleanups (args_list_chain);
797 ui_out_text (uiout, ")");
798 if (sal.symtab && sal.symtab->filename)
800 annotate_frame_source_begin ();
801 ui_out_wrap_hint (uiout, " ");
802 ui_out_text (uiout, " at ");
803 annotate_frame_source_file ();
804 ui_out_field_string (uiout, "file", sal.symtab->filename);
805 if (ui_out_is_mi_like_p (uiout))
807 const char *fullname = symtab_to_fullname (sal.symtab);
808 if (fullname != NULL)
809 ui_out_field_string (uiout, "fullname", fullname);
811 annotate_frame_source_file_end ();
812 ui_out_text (uiout, ":");
813 annotate_frame_source_line ();
814 ui_out_field_int (uiout, "line", sal.line);
815 annotate_frame_source_end ();
818 if (!funname || (!sal.symtab || !sal.symtab->filename))
821 char *lib = PC_SOLIB (get_frame_pc (frame));
823 char *lib = solib_name_from_address (get_frame_pc (frame));
827 annotate_frame_where ();
828 ui_out_wrap_hint (uiout, " ");
829 ui_out_text (uiout, " from ");
830 ui_out_field_string (uiout, "from", lib);
834 /* do_cleanups will call ui_out_tuple_end() for us. */
835 do_cleanups (list_chain);
836 ui_out_text (uiout, "\n");
837 do_cleanups (old_chain);
841 /* Read a frame specification in whatever the appropriate format is
842 from FRAME_EXP. Call error(), printing MESSAGE, if the
843 specification is in any way invalid (so this function never returns
844 NULL). When SEPECTED_P is non-NULL set its target to indicate that
845 the default selected frame was used. */
847 static struct frame_info *
848 parse_frame_specification_1 (const char *frame_exp, const char *message,
849 int *selected_frame_p)
852 struct value *args[4];
853 CORE_ADDR addrs[ARRAY_SIZE (args)];
855 if (frame_exp == NULL)
860 struct cleanup *tmp_cleanup;
866 struct cleanup *cleanup;
869 /* Skip leading white space, bail of EOL. */
870 while (isspace (*frame_exp))
875 /* Parse the argument, extract it, save it. */
879 addr_string = savestring (frame_exp, p - frame_exp);
881 cleanup = make_cleanup (xfree, addr_string);
883 /* NOTE: Parse and evaluate expression, but do not use
884 functions such as parse_and_eval_long or
885 parse_and_eval_address to also extract the value.
886 Instead value_as_long and value_as_address are used.
887 This avoids problems with expressions that contain
889 if (numargs >= ARRAY_SIZE (args))
890 error (_("Too many args in frame specification"));
891 args[numargs++] = parse_and_eval (addr_string);
893 do_cleanups (cleanup);
897 /* If no args, default to the selected frame. */
900 if (selected_frame_p != NULL)
901 (*selected_frame_p) = 1;
902 return get_selected_frame (message);
905 /* None of the remaining use the selected frame. */
906 if (selected_frame_p != NULL)
907 (*selected_frame_p) = 0;
909 /* Assume the single arg[0] is an integer, and try using that to
910 select a frame relative to current. */
913 struct frame_info *fid;
914 int level = value_as_long (args[0]);
915 fid = find_relative_frame (get_current_frame (), &level);
917 /* find_relative_frame was successful */
921 /* Convert each value into a corresponding address. */
924 for (i = 0; i < numargs; i++)
925 addrs[i] = value_as_address (args[i]);
928 /* Assume that the single arg[0] is an address, use that to identify
929 a frame with a matching ID. Should this also accept stack/pc or
933 struct frame_id id = frame_id_build_wild (addrs[0]);
934 struct frame_info *fid;
936 /* If (s)he specifies the frame with an address, he deserves
937 what (s)he gets. Still, give the highest one that matches.
938 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
940 for (fid = get_current_frame ();
942 fid = get_prev_frame (fid))
944 if (frame_id_eq (id, get_frame_id (fid)))
946 struct frame_info *prev_frame;
950 prev_frame = get_prev_frame (fid);
952 || !frame_id_eq (id, get_frame_id (prev_frame)))
961 /* We couldn't identify the frame as an existing frame, but
962 perhaps we can create one with a single argument. */
964 return create_new_frame (addrs[0], 0);
965 else if (numargs == 2)
966 return create_new_frame (addrs[0], addrs[1]);
968 error (_("Too many args in frame specification"));
971 static struct frame_info *
972 parse_frame_specification (char *frame_exp)
974 return parse_frame_specification_1 (frame_exp, NULL, NULL);
977 /* Print verbosely the selected frame or the frame at address
978 ADDR_EXP. Absolutely all information in the frame is printed. */
981 frame_info (char *addr_exp, int from_tty)
983 struct frame_info *fi;
984 struct symtab_and_line sal;
987 struct frame_info *calling_frame_info;
988 int i, count, numregs;
990 enum language funlang = language_unknown;
991 const char *pc_regname;
992 int selected_frame_p;
993 struct gdbarch *gdbarch;
994 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
996 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
997 gdbarch = get_frame_arch (fi);
999 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1000 is not a good name. */
1001 if (gdbarch_pc_regnum (gdbarch) >= 0)
1002 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1003 easily not match that of the internal value returned by
1005 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1007 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1008 architectures will often have a hardware register called "pc",
1009 and that register's value, again, can easily not match
1013 find_frame_sal (fi, &sal);
1014 func = get_frame_function (fi);
1015 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1017 s = find_pc_symtab (get_frame_pc (fi));
1020 funname = SYMBOL_PRINT_NAME (func);
1021 funlang = SYMBOL_LANGUAGE (func);
1022 if (funlang == language_cplus)
1024 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1025 to display the demangled name that we already have
1026 stored in the symbol table, but we stored a version
1027 with DMGL_PARAMS turned on, and here we don't want to
1028 display parameters. So remove the parameters. */
1029 char *func_only = cp_remove_params (funname);
1032 funname = func_only;
1033 make_cleanup (xfree, func_only);
1039 struct minimal_symbol *msymbol;
1041 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
1042 if (msymbol != NULL)
1044 funname = SYMBOL_PRINT_NAME (msymbol);
1045 funlang = SYMBOL_LANGUAGE (msymbol);
1048 calling_frame_info = get_prev_frame (fi);
1050 if (selected_frame_p && frame_relative_level (fi) >= 0)
1052 printf_filtered (_("Stack level %d, frame at "),
1053 frame_relative_level (fi));
1057 printf_filtered (_("Stack frame at "));
1059 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1060 printf_filtered (":\n");
1061 printf_filtered (" %s = ", pc_regname);
1062 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1067 printf_filtered (" in ");
1068 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1069 DMGL_ANSI | DMGL_PARAMS);
1073 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
1074 puts_filtered ("; ");
1076 printf_filtered ("saved %s ", pc_regname);
1077 fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout);
1078 printf_filtered ("\n");
1080 if (calling_frame_info == NULL)
1082 enum unwind_stop_reason reason;
1084 reason = get_frame_unwind_stop_reason (fi);
1085 if (reason != UNWIND_NO_REASON)
1086 printf_filtered (_(" Outermost frame: %s\n"),
1087 frame_stop_reason_string (reason));
1089 else if (get_frame_type (fi) == INLINE_FRAME)
1090 printf_filtered (" inlined into frame %d",
1091 frame_relative_level (get_prev_frame (fi)));
1094 printf_filtered (" called by frame at ");
1095 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1098 if (get_next_frame (fi) && calling_frame_info)
1099 puts_filtered (",");
1101 if (get_next_frame (fi))
1103 printf_filtered (" caller of frame at ");
1104 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1107 if (get_next_frame (fi) || calling_frame_info)
1108 puts_filtered ("\n");
1111 printf_filtered (" source language %s.\n",
1112 language_str (s->language));
1115 /* Address of the argument list for this frame, or 0. */
1116 CORE_ADDR arg_list = get_frame_args_address (fi);
1117 /* Number of args for this frame, or -1 if unknown. */
1121 printf_filtered (" Arglist at unknown address.\n");
1124 printf_filtered (" Arglist at ");
1125 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1126 printf_filtered (",");
1128 if (!gdbarch_frame_num_args_p (gdbarch))
1131 puts_filtered (" args: ");
1135 numargs = gdbarch_frame_num_args (gdbarch, fi);
1136 gdb_assert (numargs >= 0);
1138 puts_filtered (" no args.");
1139 else if (numargs == 1)
1140 puts_filtered (" 1 arg: ");
1142 printf_filtered (" %d args: ", numargs);
1144 print_frame_args (func, fi, numargs, gdb_stdout);
1145 puts_filtered ("\n");
1149 /* Address of the local variables for this frame, or 0. */
1150 CORE_ADDR arg_list = get_frame_locals_address (fi);
1153 printf_filtered (" Locals at unknown address,");
1156 printf_filtered (" Locals at ");
1157 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1158 printf_filtered (",");
1162 /* Print as much information as possible on the location of all the
1165 enum lval_type lval;
1173 /* The sp is special; what's displayed isn't the save address, but
1174 the value of the previous frame's sp. This is a legacy thing,
1175 at one stage the frame cached the previous frame's SP instead
1176 of its address, hence it was easiest to just display the cached
1178 if (gdbarch_sp_regnum (gdbarch) >= 0)
1180 /* Find out the location of the saved stack pointer with out
1181 actually evaluating it. */
1182 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1183 &optimized, &lval, &addr,
1185 if (!optimized && lval == not_lval)
1187 gdb_byte value[MAX_REGISTER_SIZE];
1189 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1190 &optimized, &lval, &addr,
1192 /* NOTE: cagney/2003-05-22: This is assuming that the
1193 stack pointer was packed as an unsigned integer. That
1194 may or may not be valid. */
1195 sp = extract_unsigned_integer (value,
1196 register_size (gdbarch,
1197 gdbarch_sp_regnum (gdbarch)));
1198 printf_filtered (" Previous frame's sp is ");
1199 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1200 printf_filtered ("\n");
1203 else if (!optimized && lval == lval_memory)
1205 printf_filtered (" Previous frame's sp at ");
1206 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1207 printf_filtered ("\n");
1210 else if (!optimized && lval == lval_register)
1212 printf_filtered (" Previous frame's sp in %s\n",
1213 gdbarch_register_name (gdbarch, realnum));
1216 /* else keep quiet. */
1220 numregs = gdbarch_num_regs (gdbarch)
1221 + gdbarch_num_pseudo_regs (gdbarch);
1222 for (i = 0; i < numregs; i++)
1223 if (i != gdbarch_sp_regnum (gdbarch)
1224 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1226 /* Find out the location of the saved register without
1227 fetching the corresponding value. */
1228 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1230 /* For moment, only display registers that were saved on the
1232 if (!optimized && lval == lval_memory)
1235 puts_filtered (" Saved registers:\n ");
1237 puts_filtered (",");
1239 printf_filtered (" %s at ",
1240 gdbarch_register_name (gdbarch, i));
1241 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1245 if (count || need_nl)
1246 puts_filtered ("\n");
1249 do_cleanups (back_to);
1252 /* Print briefly all stack frames or just the innermost COUNT_EXP
1256 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1258 struct frame_info *fi;
1261 struct frame_info *trailing;
1264 if (!target_has_stack)
1265 error (_("No stack."));
1267 /* The following code must do two things. First, it must set the
1268 variable TRAILING to the frame from which we should start
1269 printing. Second, it must set the variable count to the number
1270 of frames which we should print, or -1 if all of them. */
1271 trailing = get_current_frame ();
1273 /* The target can be in a state where there is no valid frames
1274 (e.g., just connected). */
1275 if (trailing == NULL)
1276 error (_("No stack."));
1281 count = parse_and_eval_long (count_exp);
1284 struct frame_info *current;
1289 while (current && count--)
1292 current = get_prev_frame (current);
1295 /* Will stop when CURRENT reaches the top of the stack.
1296 TRAILING will be COUNT below it. */
1300 trailing = get_prev_frame (trailing);
1301 current = get_prev_frame (current);
1313 struct partial_symtab *ps;
1315 /* Read in symbols for all of the frames. Need to do this in a
1316 separate pass so that "Reading in symbols for xxx" messages
1317 don't screw up the appearance of the backtrace. Also if
1318 people have strong opinions against reading symbols for
1319 backtrace this may have to be an option. */
1321 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1324 ps = find_pc_psymtab (get_frame_address_in_block (fi));
1326 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
1330 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1334 /* Don't use print_stack_frame; if an error() occurs it probably
1335 means further attempts to backtrace would fail (on the other
1336 hand, perhaps the code does or could be fixed to make sure
1337 the frame->prev field gets set to NULL in that case). */
1338 print_frame_info (fi, 1, LOCATION, 1);
1340 print_frame_local_vars (fi, 1, gdb_stdout);
1342 /* Save the last frame to check for error conditions. */
1346 /* If we've stopped before the end, mention that. */
1348 printf_filtered (_("(More stack frames follow...)\n"));
1350 /* If we've run out of frames, and the reason appears to be an error
1351 condition, print it. */
1352 if (fi == NULL && trailing != NULL)
1354 enum unwind_stop_reason reason;
1356 reason = get_frame_unwind_stop_reason (trailing);
1357 if (reason > UNWIND_FIRST_ERROR)
1358 printf_filtered (_("Backtrace stopped: %s\n"),
1359 frame_stop_reason_string (reason));
1363 struct backtrace_command_args
1370 /* Stub for catch_errors. */
1373 backtrace_command_stub (void *data)
1375 struct backtrace_command_args *args = data;
1376 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1381 backtrace_command (char *arg, int from_tty)
1383 struct cleanup *old_chain = NULL;
1384 int fulltrace_arg = -1, arglen = 0, argc = 0;
1385 struct backtrace_command_args btargs;
1392 argv = gdb_buildargv (arg);
1393 old_chain = make_cleanup_freeargv (argv);
1395 for (i = 0; argv[i]; i++)
1399 for (j = 0; j < strlen (argv[i]); j++)
1400 argv[i][j] = tolower (argv[i][j]);
1402 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1403 fulltrace_arg = argc;
1406 arglen += strlen (argv[i]);
1411 if (fulltrace_arg >= 0)
1415 arg = xmalloc (arglen + 1);
1416 memset (arg, 0, arglen + 1);
1417 for (i = 0; i < (argc + 1); i++)
1419 if (i != fulltrace_arg)
1421 strcat (arg, argv[i]);
1431 btargs.count_exp = arg;
1432 btargs.show_locals = (fulltrace_arg >= 0);
1433 btargs.from_tty = from_tty;
1434 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1436 if (fulltrace_arg >= 0 && arglen > 0)
1440 do_cleanups (old_chain);
1444 backtrace_full_command (char *arg, int from_tty)
1446 struct backtrace_command_args btargs;
1447 btargs.count_exp = arg;
1448 btargs.show_locals = 1;
1449 btargs.from_tty = from_tty;
1450 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1454 /* Print the local variables of a block B active in FRAME on STREAM.
1455 Return 1 if any variables were printed; 0 otherwise. */
1458 print_block_frame_locals (struct block *b, struct frame_info *frame,
1459 int num_tabs, struct ui_file *stream)
1461 struct dict_iterator iter;
1463 int values_printed = 0;
1466 ALL_BLOCK_SYMBOLS (b, iter, sym)
1468 switch (SYMBOL_CLASS (sym))
1474 if (SYMBOL_IS_ARGUMENT (sym))
1477 print_variable_and_value (NULL, sym, frame, stream, 4 * num_tabs);
1481 /* Ignore symbols which are not locals. */
1486 return values_printed;
1489 /* Same, but print labels. */
1492 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1493 int *have_default, struct ui_file *stream)
1495 struct dict_iterator iter;
1497 int values_printed = 0;
1499 ALL_BLOCK_SYMBOLS (b, iter, sym)
1501 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1507 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1509 struct symtab_and_line sal;
1510 struct value_print_options opts;
1511 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1513 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1514 get_user_print_options (&opts);
1515 if (opts.addressprint)
1517 fprintf_filtered (stream, " ");
1518 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1521 fprintf_filtered (stream, " in file %s, line %d\n",
1522 sal.symtab->filename, sal.line);
1526 return values_printed;
1529 /* Print on STREAM all the local variables in frame FRAME, including
1530 all the blocks active in that frame at its current PC.
1532 Returns 1 if the job was done, or 0 if nothing was printed because
1533 we have no info on the function running in FRAME. */
1536 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1537 struct ui_file *stream)
1539 struct block *block = get_frame_block (frame, 0);
1540 int values_printed = 0;
1544 fprintf_filtered (stream, "No symbol table info available.\n");
1550 if (print_block_frame_locals (block, frame, num_tabs, stream))
1552 /* After handling the function's top-level block, stop. Don't
1553 continue to its superblock, the block of per-file symbols.
1554 Also do not continue to the containing function of an inlined
1556 if (BLOCK_FUNCTION (block))
1558 block = BLOCK_SUPERBLOCK (block);
1561 if (!values_printed)
1562 fprintf_filtered (stream, _("No locals.\n"));
1565 /* Same, but print labels. */
1568 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1569 struct ui_file *stream)
1572 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1574 struct blockvector *bl;
1575 struct block *block = get_frame_block (frame, 0);
1576 struct gdbarch *gdbarch = get_frame_arch (frame);
1577 int values_printed = 0;
1578 int index, have_default = 0;
1579 char *blocks_printed;
1580 CORE_ADDR pc = get_frame_pc (frame);
1584 fprintf_filtered (stream, "No symbol table info available.\n");
1588 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1589 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1590 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1594 CORE_ADDR end = BLOCK_END (block) - 4;
1597 if (bl != blockvector_for_pc (end, &index))
1598 error (_("blockvector blotch"));
1599 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1600 error (_("blockvector botch"));
1601 last_index = BLOCKVECTOR_NBLOCKS (bl);
1604 /* Don't print out blocks that have gone by. */
1605 while (index < last_index
1606 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1609 while (index < last_index
1610 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1612 if (blocks_printed[index] == 0)
1614 if (print_block_frame_labels (gdbarch,
1615 BLOCKVECTOR_BLOCK (bl, index),
1616 &have_default, stream))
1618 blocks_printed[index] = 1;
1624 if (values_printed && this_level_only)
1627 /* After handling the function's top-level block, stop. Don't
1628 continue to its superblock, the block of per-file symbols.
1629 Also do not continue to the containing function of an inlined
1631 if (BLOCK_FUNCTION (block))
1633 block = BLOCK_SUPERBLOCK (block);
1636 if (!values_printed && !this_level_only)
1637 fprintf_filtered (stream, _("No catches.\n"));
1642 locals_info (char *args, int from_tty)
1644 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1649 catch_info (char *ignore, int from_tty)
1651 struct symtab_and_line *sal;
1653 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1654 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1659 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1661 struct symbol *func = get_frame_function (frame);
1663 struct dict_iterator iter;
1664 struct symbol *sym, *sym2;
1665 int values_printed = 0;
1669 fprintf_filtered (stream, _("No symbol table info available.\n"));
1673 b = SYMBOL_BLOCK_VALUE (func);
1674 ALL_BLOCK_SYMBOLS (b, iter, sym)
1676 /* Don't worry about things which aren't arguments. */
1677 if (SYMBOL_IS_ARGUMENT (sym))
1681 /* We have to look up the symbol because arguments can have
1682 two entries (one a parameter, one a local) and the one we
1683 want is the local, which lookup_symbol will find for us.
1684 This includes gcc1 (not gcc2) on the sparc when passing a
1685 small structure and gcc2 when the argument type is float
1686 and it is passed as a double and converted to float by
1687 the prologue (in the latter case the type of the LOC_ARG
1688 symbol is double and the type of the LOC_LOCAL symbol is
1689 float). There are also LOC_ARG/LOC_REGISTER pairs which
1690 are not combined in symbol-reading. */
1692 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
1693 b, VAR_DOMAIN, NULL);
1694 print_variable_and_value (SYMBOL_PRINT_NAME (sym), sym2,
1699 if (!values_printed)
1700 fprintf_filtered (stream, _("No arguments.\n"));
1704 args_info (char *ignore, int from_tty)
1706 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1712 args_plus_locals_info (char *ignore, int from_tty)
1714 args_info (ignore, from_tty);
1715 locals_info (ignore, from_tty);
1719 /* Select frame FRAME. Also print the stack frame and show the source
1720 if this is the tui version. */
1722 select_and_print_frame (struct frame_info *frame)
1724 select_frame (frame);
1726 print_stack_frame (frame, 1, SRC_AND_LOC);
1729 /* Return the symbol-block in which the selected frame is executing.
1730 Can return zero under various legitimate circumstances.
1732 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1733 code address within the block returned. We use this to decide
1734 which macros are in scope. */
1737 get_selected_block (CORE_ADDR *addr_in_block)
1739 if (!has_stack_frames ())
1742 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1745 /* Find a frame a certain number of levels away from FRAME.
1746 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1747 Positive means go to earlier frames (up); negative, the reverse.
1748 The int that contains the number of levels is counted toward
1749 zero as the frames for those levels are found.
1750 If the top or bottom frame is reached, that frame is returned,
1751 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1752 how much farther the original request asked to go. */
1755 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1757 /* Going up is simple: just call get_prev_frame enough times or
1758 until the initial frame is reached. */
1759 while (*level_offset_ptr > 0)
1761 struct frame_info *prev = get_prev_frame (frame);
1764 (*level_offset_ptr)--;
1768 /* Going down is just as simple. */
1769 while (*level_offset_ptr < 0)
1771 struct frame_info *next = get_next_frame (frame);
1774 (*level_offset_ptr)++;
1781 /* The "select_frame" command. With no argument this is a NOP.
1782 Select the frame at level LEVEL_EXP if it is a valid level.
1783 Otherwise, treat LEVEL_EXP as an address expression and select it.
1785 See parse_frame_specification for more info on proper frame
1789 select_frame_command (char *level_exp, int from_tty)
1791 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1794 /* The "frame" command. With no argument, print the selected frame
1795 briefly. With an argument, behave like select_frame and then print
1796 the selected frame. */
1799 frame_command (char *level_exp, int from_tty)
1801 select_frame_command (level_exp, from_tty);
1802 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1805 /* The XDB Compatibility command to print the current frame. */
1808 current_frame_command (char *level_exp, int from_tty)
1810 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1813 /* Select the frame up one or COUNT_EXP stack levels from the
1814 previously selected frame, and print it briefly. */
1817 up_silently_base (char *count_exp)
1819 struct frame_info *frame;
1823 count = parse_and_eval_long (count_exp);
1825 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1826 if (count != 0 && count_exp == NULL)
1827 error (_("Initial frame selected; you cannot go up."));
1828 select_frame (frame);
1832 up_silently_command (char *count_exp, int from_tty)
1834 up_silently_base (count_exp);
1838 up_command (char *count_exp, int from_tty)
1840 up_silently_base (count_exp);
1841 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1844 /* Select the frame down one or COUNT_EXP stack levels from the previously
1845 selected frame, and print it briefly. */
1848 down_silently_base (char *count_exp)
1850 struct frame_info *frame;
1853 count = -parse_and_eval_long (count_exp);
1855 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1856 if (count != 0 && count_exp == NULL)
1858 /* We only do this if COUNT_EXP is not specified. That way
1859 "down" means to really go down (and let me know if that is
1860 impossible), but "down 9999" can be used to mean go all the
1861 way down without getting an error. */
1863 error (_("Bottom (innermost) frame selected; you cannot go down."));
1866 select_frame (frame);
1870 down_silently_command (char *count_exp, int from_tty)
1872 down_silently_base (count_exp);
1876 down_command (char *count_exp, int from_tty)
1878 down_silently_base (count_exp);
1879 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1884 return_command (char *retval_exp, int from_tty)
1886 struct frame_info *thisframe;
1887 struct gdbarch *gdbarch;
1888 struct symbol *thisfun;
1889 struct value *return_value = NULL;
1890 const char *query_prefix = "";
1892 thisframe = get_selected_frame ("No selected frame.");
1893 thisfun = get_frame_function (thisframe);
1894 gdbarch = get_frame_arch (thisframe);
1896 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
1897 error (_("Can not force return from an inlined function."));
1899 /* Compute the return value. If the computation triggers an error,
1900 let it bail. If the return type can't be handled, set
1901 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1905 struct expression *retval_expr = parse_expression (retval_exp);
1906 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
1907 struct type *return_type = NULL;
1909 /* Compute the return value. Should the computation fail, this
1910 call throws an error. */
1911 return_value = evaluate_expression (retval_expr);
1913 /* Cast return value to the return type of the function. Should
1914 the cast fail, this call throws an error. */
1915 if (thisfun != NULL)
1916 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1917 if (return_type == NULL)
1919 if (retval_expr->elts[0].opcode != UNOP_CAST)
1920 error (_("Return value type not available for selected "
1922 "Please use an explicit cast of the value to return."));
1923 return_type = value_type (return_value);
1925 do_cleanups (old_chain);
1926 CHECK_TYPEDEF (return_type);
1927 return_value = value_cast (return_type, return_value);
1929 /* Make sure the value is fully evaluated. It may live in the
1930 stack frame we're about to pop. */
1931 if (value_lazy (return_value))
1932 value_fetch_lazy (return_value);
1934 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1935 /* If the return-type is "void", don't try to find the
1936 return-value's location. However, do still evaluate the
1937 return expression so that, even when the expression result
1938 is discarded, side effects such as "return i++" still
1940 return_value = NULL;
1941 else if (thisfun != NULL
1942 && using_struct_return (gdbarch,
1943 SYMBOL_TYPE (thisfun), return_type))
1946 The location at which to store the function's return value is unknown.\n\
1947 If you continue, the return value that you specified will be ignored.\n";
1948 return_value = NULL;
1952 /* Does an interactive user really want to do this? Include
1953 information, such as how well GDB can handle the return value, in
1954 the query message. */
1958 if (thisfun == NULL)
1959 confirmed = query (_("%sMake selected stack frame return now? "),
1962 confirmed = query (_("%sMake %s return now? "), query_prefix,
1963 SYMBOL_PRINT_NAME (thisfun));
1965 error (_("Not confirmed"));
1968 /* Discard the selected frame and all frames inner-to it. */
1969 frame_pop (get_selected_frame (NULL));
1971 /* Store RETURN_VALUE in the just-returned register set. */
1972 if (return_value != NULL)
1974 struct type *return_type = value_type (return_value);
1975 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
1976 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
1978 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
1980 == RETURN_VALUE_REGISTER_CONVENTION);
1981 gdbarch_return_value (gdbarch, func_type, return_type,
1982 get_current_regcache (), NULL /*read*/,
1983 value_contents (return_value) /*write*/);
1986 /* If we are at the end of a call dummy now, pop the dummy frame
1988 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1989 frame_pop (get_current_frame ());
1991 /* If interactive, print the frame that is now current. */
1993 frame_command ("0", 1);
1995 select_frame_command ("0", 0);
1998 /* Sets the scope to input function name, provided that the function
1999 is within the current stack frame */
2001 struct function_bounds
2003 CORE_ADDR low, high;
2007 func_command (char *arg, int from_tty)
2009 struct frame_info *frame;
2011 struct symtabs_and_lines sals;
2014 struct function_bounds *func_bounds = NULL;
2019 frame = parse_frame_specification ("0");
2020 sals = decode_line_spec (arg, 1);
2021 func_bounds = (struct function_bounds *) xmalloc (
2022 sizeof (struct function_bounds) * sals.nelts);
2023 for (i = 0; (i < sals.nelts && !found); i++)
2025 if (sals.sals[i].pc == 0
2026 || find_pc_partial_function (sals.sals[i].pc, NULL,
2027 &func_bounds[i].low,
2028 &func_bounds[i].high) == 0)
2030 func_bounds[i].low = func_bounds[i].high = 0;
2036 for (i = 0; (i < sals.nelts && !found); i++)
2037 found = (get_frame_pc (frame) >= func_bounds[i].low
2038 && get_frame_pc (frame) < func_bounds[i].high);
2042 frame = find_relative_frame (frame, &level);
2045 while (!found && level == 0);
2048 xfree (func_bounds);
2051 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2052 else if (frame != get_selected_frame (NULL))
2053 select_and_print_frame (frame);
2056 /* Gets the language of the current frame. */
2059 get_frame_language (void)
2061 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2065 /* We determine the current frame language by looking up its
2066 associated symtab. To retrieve this symtab, we use the frame
2067 PC. However we cannot use the frame PC as is, because it
2068 usually points to the instruction following the "call", which
2069 is sometimes the first instruction of another function. So
2070 we rely on get_frame_address_in_block(), it provides us with
2071 a PC that is guaranteed to be inside the frame's code
2073 CORE_ADDR pc = get_frame_address_in_block (frame);
2074 struct symtab *s = find_pc_symtab (pc);
2080 return language_unknown;
2084 /* Provide a prototype to silence -Wmissing-prototypes. */
2085 void _initialize_stack (void);
2088 _initialize_stack (void)
2091 backtrace_limit = 30;
2094 add_com ("return", class_stack, return_command, _("\
2095 Make selected stack frame return to its caller.\n\
2096 Control remains in the debugger, but when you continue\n\
2097 execution will resume in the frame above the one now selected.\n\
2098 If an argument is given, it is an expression for the value to return."));
2100 add_com ("up", class_stack, up_command, _("\
2101 Select and print stack frame that called this one.\n\
2102 An argument says how many frames up to go."));
2103 add_com ("up-silently", class_support, up_silently_command, _("\
2104 Same as the `up' command, but does not print anything.\n\
2105 This is useful in command scripts."));
2107 add_com ("down", class_stack, down_command, _("\
2108 Select and print stack frame called by this one.\n\
2109 An argument says how many frames down to go."));
2110 add_com_alias ("do", "down", class_stack, 1);
2111 add_com_alias ("dow", "down", class_stack, 1);
2112 add_com ("down-silently", class_support, down_silently_command, _("\
2113 Same as the `down' command, but does not print anything.\n\
2114 This is useful in command scripts."));
2116 add_com ("frame", class_stack, frame_command, _("\
2117 Select and print a stack frame.\n\
2118 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2119 An argument specifies the frame to select.\n\
2120 It can be a stack frame number or the address of the frame.\n\
2121 With argument, nothing is printed if input is coming from\n\
2122 a command file or a user-defined command."));
2124 add_com_alias ("f", "frame", class_stack, 1);
2128 add_com ("L", class_stack, current_frame_command,
2129 _("Print the current stack frame.\n"));
2130 add_com_alias ("V", "frame", class_stack, 1);
2132 add_com ("select-frame", class_stack, select_frame_command, _("\
2133 Select a stack frame without printing anything.\n\
2134 An argument specifies the frame to select.\n\
2135 It can be a stack frame number or the address of the frame.\n"));
2137 add_com ("backtrace", class_stack, backtrace_command, _("\
2138 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2139 With a negative argument, print outermost -COUNT frames.\n\
2140 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2141 add_com_alias ("bt", "backtrace", class_stack, 0);
2144 add_com_alias ("t", "backtrace", class_stack, 0);
2145 add_com ("T", class_stack, backtrace_full_command, _("\
2146 Print backtrace of all stack frames, or innermost COUNT frames \n\
2147 and the values of the local variables.\n\
2148 With a negative argument, print outermost -COUNT frames.\n\
2149 Usage: T <count>\n"));
2152 add_com_alias ("where", "backtrace", class_alias, 0);
2153 add_info ("stack", backtrace_command,
2154 _("Backtrace of the stack, or innermost COUNT frames."));
2155 add_info_alias ("s", "stack", 1);
2156 add_info ("frame", frame_info,
2157 _("All about selected stack frame, or frame at ADDR."));
2158 add_info_alias ("f", "frame", 1);
2159 add_info ("locals", locals_info,
2160 _("Local variables of current stack frame."));
2161 add_info ("args", args_info,
2162 _("Argument variables of current stack frame."));
2164 add_com ("l", class_info, args_plus_locals_info,
2165 _("Argument and local variables of current stack frame."));
2168 add_com ("func", class_stack, func_command, _("\
2169 Select the stack frame that contains <func>.\n\
2170 Usage: func <name>\n"));
2172 add_info ("catch", catch_info,
2173 _("Exceptions that can be caught in the current stack frame."));
2175 add_setshow_enum_cmd ("frame-arguments", class_stack,
2176 print_frame_arguments_choices, &print_frame_arguments,
2177 _("Set printing of non-scalar frame arguments"),
2178 _("Show printing of non-scalar frame arguments"),
2179 NULL, NULL, NULL, &setprintlist, &showprintlist);
2181 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2182 &disassemble_next_line, _("\
2183 Set whether to disassemble next source line or insn when execution stops."), _("\
2184 Show whether to disassemble next source line or insn when execution stops."), _("\
2185 If ON, GDB will display disassembly of the next source line, in addition\n\
2186 to displaying the source line itself. If the next source line cannot\n\
2187 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2188 will display disassembly of next instruction instead of showing the\n\
2190 If AUTO, display disassembly of next instruction only if the source line\n\
2191 cannot be displayed.\n\
2192 If OFF (which is the default), never display the disassembly of the next\n\
2195 show_disassemble_next_line,
2196 &setlist, &showlist);
2197 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2200 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2201 "Specify maximum number of frames for \"backtrace\" to print by default."),
2203 add_info ("backtrace-limit", backtrace_limit_info, _("\
2204 The maximum number of frames for \"backtrace\" to print by default."));