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"
50 #include "gdb_assert.h"
52 #include "gdb_string.h"
54 void (*deprecated_selected_frame_level_changed_hook) (int);
56 /* The possible choices of "set print frame-arguments, and the value
59 static const char *print_frame_arguments_choices[] =
60 {"all", "scalars", "none", NULL};
61 static const char *print_frame_arguments = "scalars";
63 /* Prototypes for local functions. */
65 static void print_frame_local_vars (struct frame_info *, int,
68 static void print_frame (struct frame_info *frame, int print_level,
69 enum print_what print_what, int print_args,
70 struct symtab_and_line sal);
72 /* Zero means do things normally; we are interacting directly with the
73 user. One means print the full filename and linenumber when a
74 frame is printed, and do so in a format emacs18/emacs19.22 can
75 parse. Two means print similar annotations, but in many more
76 cases and in a slightly different syntax. */
78 int annotation_level = 0;
81 struct print_stack_frame_args
83 struct frame_info *frame;
85 enum print_what print_what;
89 /* Show or print the frame arguments; stub for catch_errors. */
92 print_stack_frame_stub (void *args)
94 struct print_stack_frame_args *p = args;
95 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
97 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
98 set_current_sal_from_frame (p->frame, center);
102 /* Show or print a stack frame FRAME briefly. The output is format
103 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
104 relative level, function name, argument list, and file name and
105 line number. If the frame's PC is not at the beginning of the
106 source line, the actual PC is printed at the beginning. */
109 print_stack_frame (struct frame_info *frame, int print_level,
110 enum print_what print_what)
112 struct print_stack_frame_args args;
115 args.print_level = print_level;
116 args.print_what = print_what;
117 /* For mi, alway print location and address. */
118 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
121 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
124 struct print_args_args
127 struct frame_info *frame;
128 struct ui_file *stream;
131 static int print_args_stub (void *args);
133 /* Print nameless arguments of frame FRAME on STREAM, where START is
134 the offset of the first nameless argument, and NUM is the number of
135 nameless arguments to print. FIRST is nonzero if this is the first
136 argument (not just the first nameless argument). */
139 print_frame_nameless_args (struct frame_info *frame, long start, int num,
140 int first, struct ui_file *stream)
146 for (i = 0; i < num; i++)
149 argsaddr = get_frame_args_address (frame);
152 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
154 fprintf_filtered (stream, ", ");
155 fprintf_filtered (stream, "%ld", arg_value);
157 start += sizeof (int);
161 /* Print the arguments of frame FRAME on STREAM, given the function
162 FUNC running in that frame (as a symbol), where NUM is the number
163 of arguments according to the stack frame (or -1 if the number of
164 arguments is unknown). */
166 /* Note that currently the "number of arguments according to the
167 stack frame" is only known on VAX where i refers to the "number of
168 ints of arguments according to the stack frame". */
171 print_frame_args (struct symbol *func, struct frame_info *frame,
172 int num, struct ui_file *stream)
175 /* Offset of next stack argument beyond the one we have seen that is
176 at the highest offset, or -1 if we haven't come to a stack
178 long highest_offset = -1;
179 /* Number of ints of arguments that we have printed so far. */
180 int args_printed = 0;
181 struct cleanup *old_chain, *list_chain;
182 struct ui_stream *stb;
183 /* True if we should print arguments, false otherwise. */
184 int print_args = strcmp (print_frame_arguments, "none");
185 /* True in "summary" mode, false otherwise. */
186 int summary = !strcmp (print_frame_arguments, "scalars");
188 stb = ui_out_stream_new (uiout);
189 old_chain = make_cleanup_ui_out_stream_delete (stb);
193 struct block *b = SYMBOL_BLOCK_VALUE (func);
194 struct dict_iterator iter;
198 ALL_BLOCK_SYMBOLS (b, iter, sym)
202 /* Keep track of the highest stack argument offset seen, and
203 skip over any kinds of symbols we don't care about. */
205 if (!SYMBOL_IS_ARGUMENT (sym))
208 switch (SYMBOL_CLASS (sym))
213 long current_offset = SYMBOL_VALUE (sym);
214 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
216 /* Compute address of next argument by adding the size of
217 this argument and rounding to an int boundary. */
219 ((current_offset + arg_size + sizeof (int) - 1)
220 & ~(sizeof (int) - 1));
222 /* If this is the highest offset seen yet, set
224 if (highest_offset == -1
225 || (current_offset > highest_offset))
226 highest_offset = current_offset;
228 /* Add the number of ints we're about to print to
230 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
233 /* We care about types of symbols, but don't need to
234 keep track of stack offsets in them. */
236 case LOC_REGPARM_ADDR:
238 case LOC_OPTIMIZED_OUT:
243 /* We have to look up the symbol because arguments can have
244 two entries (one a parameter, one a local) and the one we
245 want is the local, which lookup_symbol will find for us.
246 This includes gcc1 (not gcc2) on SPARC when passing a
247 small structure and gcc2 when the argument type is float
248 and it is passed as a double and converted to float by
249 the prologue (in the latter case the type of the LOC_ARG
250 symbol is double and the type of the LOC_LOCAL symbol is
252 /* But if the parameter name is null, don't try it. Null
253 parameter names occur on the RS/6000, for traceback
254 tables. FIXME, should we even print them? */
256 if (*SYMBOL_LINKAGE_NAME (sym))
259 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
260 b, VAR_DOMAIN, NULL);
261 gdb_assert (nsym != NULL);
262 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
263 && !SYMBOL_IS_ARGUMENT (nsym))
265 /* There is a LOC_ARG/LOC_REGISTER pair. This means
266 that it was passed on the stack and loaded into a
267 register, or passed in a register and stored in a
268 stack slot. GDB 3.x used the LOC_ARG; GDB
269 4.0-4.11 used the LOC_REGISTER.
271 Reasons for using the LOC_ARG:
273 (1) Because find_saved_registers may be slow for
276 (2) Because registers are often re-used and stack
277 slots rarely (never?) are. Therefore using
278 the stack slot is much less likely to print
281 Reasons why we might want to use the LOC_REGISTER:
283 (1) So that the backtrace prints the same value
284 as "print foo". I see no compelling reason
285 why this needs to be the case; having the
286 backtrace print the value which was passed
287 in, and "print foo" print the value as
288 modified within the called function, makes
291 Additional note: It might be nice if "info args"
292 displayed both values.
294 One more note: There is a case with SPARC
295 structure passing where we need to use the
296 LOC_REGISTER, but this is dealt with by creating
297 a single LOC_REGPARM in symbol reading. */
299 /* Leave sym (the LOC_ARG) alone. */
306 /* Print the current arg. */
308 ui_out_text (uiout, ", ");
309 ui_out_wrap_hint (uiout, " ");
311 annotate_arg_begin ();
313 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
314 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
315 SYMBOL_LANGUAGE (sym),
316 DMGL_PARAMS | DMGL_ANSI);
317 ui_out_field_stream (uiout, "name", stb);
318 annotate_arg_name_end ();
319 ui_out_text (uiout, "=");
323 /* Avoid value_print because it will deref ref parameters.
324 We just want to print their addresses. Print ??? for
325 args whose address we do not know. We pass 2 as
326 "recurse" to val_print because our standard indentation
327 here is 4 spaces, and val_print indents 2 for each
329 val = read_var_value (sym, frame);
331 annotate_arg_value (val == NULL ? NULL : value_type (val));
335 const struct language_defn *language;
336 struct value_print_options opts;
338 /* Use the appropriate language to display our symbol,
339 unless the user forced the language to a specific
341 if (language_mode == language_mode_auto)
342 language = language_def (SYMBOL_LANGUAGE (sym));
344 language = current_language;
346 get_raw_print_options (&opts);
348 opts.summary = summary;
349 common_val_print (val, stb->stream, 2, &opts, language);
350 ui_out_field_stream (uiout, "value", stb);
353 ui_out_text (uiout, "???");
356 ui_out_text (uiout, "...");
359 /* Invoke ui_out_tuple_end. */
360 do_cleanups (list_chain);
368 /* Don't print nameless args in situations where we don't know
369 enough about the stack to find them. */
374 if (highest_offset == -1)
375 start = gdbarch_frame_args_skip (get_frame_arch (frame));
377 start = highest_offset;
379 print_frame_nameless_args (frame, start, num - args_printed,
383 do_cleanups (old_chain);
386 /* Stub for catch_errors. */
389 print_args_stub (void *args)
391 struct print_args_args *p = args;
392 struct gdbarch *gdbarch = get_frame_arch (p->frame);
395 if (gdbarch_frame_num_args_p (gdbarch))
397 numargs = gdbarch_frame_num_args (gdbarch, p->frame);
398 gdb_assert (numargs >= 0);
402 print_frame_args (p->func, p->frame, numargs, p->stream);
406 /* Set the current source and line to the location given by frame
407 FRAME, if possible. When CENTER is true, adjust so the relevant
408 line is in the center of the next 'list'. */
411 set_current_sal_from_frame (struct frame_info *frame, int center)
413 struct symtab_and_line sal;
415 find_frame_sal (frame, &sal);
419 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
420 set_current_source_symtab_and_line (&sal);
424 /* If ON, GDB will display disassembly of the next source line when
425 execution of the program being debugged stops.
426 If AUTO (which is the default), or there's no line info to determine
427 the source line of the next instruction, display disassembly of next
428 instruction instead. */
430 static enum auto_boolean disassemble_next_line;
433 show_disassemble_next_line (struct ui_file *file, int from_tty,
434 struct cmd_list_element *c,
437 fprintf_filtered (file, _("\
438 Debugger's willingness to use disassemble-next-line is %s.\n"),
442 /* Show assembly codes; stub for catch_errors. */
444 struct gdb_disassembly_stub_args
452 gdb_disassembly_stub (void *args)
454 struct gdb_disassembly_stub_args *p = args;
455 gdb_disassembly (uiout, 0, 0, p->how_many, p->low, p->high);
458 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
459 because it will be broken by filter sometime. */
462 do_gdb_disassembly (int how_many, CORE_ADDR low, CORE_ADDR high)
464 volatile struct gdb_exception exception;
465 struct gdb_disassembly_stub_args args;
467 args.how_many = how_many;
470 TRY_CATCH (exception, RETURN_MASK_ALL)
472 gdb_disassembly_stub (&args);
474 /* If an exception was thrown while doing the disassembly, print
475 the error message, to give the user a clue of what happened. */
476 if (exception.reason == RETURN_ERROR)
477 exception_print (gdb_stderr, exception);
480 /* Print information about frame FRAME. The output is format according
481 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
484 SRC_LINE: Print only source line.
485 LOCATION: Print only location.
486 LOC_AND_SRC: Print location and source line.
488 Used in "where" output, and to emit breakpoint or step
492 print_frame_info (struct frame_info *frame, int print_level,
493 enum print_what print_what, int print_args)
495 struct symtab_and_line sal;
499 if (get_frame_type (frame) == DUMMY_FRAME
500 || get_frame_type (frame) == SIGTRAMP_FRAME)
502 struct cleanup *uiout_cleanup
503 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
505 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
506 get_frame_pc (frame));
508 /* Do this regardless of SOURCE because we don't have any source
509 to list for this frame. */
512 ui_out_text (uiout, "#");
513 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
514 frame_relative_level (frame));
516 if (ui_out_is_mi_like_p (uiout))
518 annotate_frame_address ();
519 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
520 annotate_frame_address_end ();
523 if (get_frame_type (frame) == DUMMY_FRAME)
525 annotate_function_call ();
526 ui_out_field_string (uiout, "func", "<function called from gdb>");
528 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
530 annotate_signal_handler_caller ();
531 ui_out_field_string (uiout, "func", "<signal handler called>");
533 ui_out_text (uiout, "\n");
534 annotate_frame_end ();
536 do_cleanups (uiout_cleanup);
540 /* If FRAME is not the innermost frame, that normally means that
541 FRAME->pc points to *after* the call instruction, and we want to
542 get the line containing the call, never the next line. But if
543 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
544 next frame was not entered as the result of a call, and we want
545 to get the line containing FRAME->pc. */
546 find_frame_sal (frame, &sal);
548 location_print = (print_what == LOCATION
549 || print_what == LOC_AND_ADDRESS
550 || print_what == SRC_AND_LOC);
552 if (location_print || !sal.symtab)
553 print_frame (frame, print_level, print_what, print_args, sal);
555 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
557 /* If disassemble-next-line is set to auto or on and doesn't have
558 the line debug messages for $pc, output the next instruction. */
559 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
560 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
561 && source_print && !sal.symtab)
562 do_gdb_disassembly (1, get_frame_pc (frame), get_frame_pc (frame) + 1);
564 if (source_print && sal.symtab)
567 int mid_statement = ((print_what == SRC_LINE)
568 && (get_frame_pc (frame) != sal.pc));
570 if (annotation_level)
571 done = identify_source_line (sal.symtab, sal.line, mid_statement,
572 get_frame_pc (frame));
575 if (deprecated_print_frame_info_listing_hook)
576 deprecated_print_frame_info_listing_hook (sal.symtab,
581 struct value_print_options opts;
582 get_user_print_options (&opts);
583 /* We used to do this earlier, but that is clearly
584 wrong. This function is used by many different
585 parts of gdb, including normal_stop in infrun.c,
586 which uses this to print out the current PC
587 when we stepi/nexti into the middle of a source
588 line. Only the command line really wants this
589 behavior. Other UIs probably would like the
590 ability to decide for themselves if it is desired. */
591 if (opts.addressprint && mid_statement)
593 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
594 ui_out_text (uiout, "\t");
597 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
601 /* If disassemble-next-line is set to on and there is line debug
602 messages, output assembly codes for next line. */
603 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
604 do_gdb_disassembly (-1, get_frame_pc (frame), sal.end);
607 if (print_what != LOCATION)
608 set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line);
610 annotate_frame_end ();
612 gdb_flush (gdb_stdout);
615 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
618 find_frame_funname (struct frame_info *frame, char **funname,
619 enum language *funlang)
624 *funlang = language_unknown;
626 func = find_pc_function (get_frame_address_in_block (frame));
629 /* In certain pathological cases, the symtabs give the wrong
630 function (when we are in the first function in a file which
631 is compiled without debugging symbols, the previous function
632 is compiled with debugging symbols, and the "foo.o" symbol
633 that is supposed to tell us where the file with debugging
634 symbols ends has been truncated by ar because it is longer
635 than 15 characters). This also occurs if the user uses asm()
636 to create a function but not stabs for it (in a file compiled
639 So look in the minimal symbol tables as well, and if it comes
640 up with a larger address for the function use that instead.
641 I don't think this can ever cause any problems; there
642 shouldn't be any minimal symbols in the middle of a function;
643 if this is ever changed many parts of GDB will need to be
644 changed (and we'll create a find_pc_minimal_function or some
647 struct minimal_symbol *msymbol =
648 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
651 && (SYMBOL_VALUE_ADDRESS (msymbol)
652 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
654 /* We also don't know anything about the function besides
655 its address and name. */
657 *funname = SYMBOL_PRINT_NAME (msymbol);
658 *funlang = SYMBOL_LANGUAGE (msymbol);
662 *funname = SYMBOL_PRINT_NAME (func);
663 *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);
674 *funname = func_only;
675 make_cleanup (xfree, func_only);
682 struct minimal_symbol *msymbol =
683 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
687 *funname = SYMBOL_PRINT_NAME (msymbol);
688 *funlang = SYMBOL_LANGUAGE (msymbol);
694 print_frame (struct frame_info *frame, int print_level,
695 enum print_what print_what, int print_args,
696 struct symtab_and_line sal)
698 char *funname = NULL;
699 enum language funlang = language_unknown;
700 struct ui_stream *stb;
701 struct cleanup *old_chain, *list_chain;
702 struct value_print_options opts;
704 stb = ui_out_stream_new (uiout);
705 old_chain = make_cleanup_ui_out_stream_delete (stb);
707 find_frame_funname (frame, &funname, &funlang);
709 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
710 get_frame_pc (frame));
712 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
716 ui_out_text (uiout, "#");
717 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
718 frame_relative_level (frame));
720 get_user_print_options (&opts);
721 if (opts.addressprint)
722 if (get_frame_pc (frame) != sal.pc || !sal.symtab
723 || print_what == LOC_AND_ADDRESS)
725 annotate_frame_address ();
726 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
727 annotate_frame_address_end ();
728 ui_out_text (uiout, " in ");
730 annotate_frame_function_name ();
731 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
733 ui_out_field_stream (uiout, "func", stb);
734 ui_out_wrap_hint (uiout, " ");
735 annotate_frame_args ();
737 ui_out_text (uiout, " (");
740 struct print_args_args args;
741 struct cleanup *args_list_chain;
743 args.func = find_pc_function (get_frame_address_in_block (frame));
744 args.stream = gdb_stdout;
745 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
746 catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
747 /* FIXME: ARGS must be a list. If one argument is a string it
748 will have " that will not be properly escaped. */
749 /* Invoke ui_out_tuple_end. */
750 do_cleanups (args_list_chain);
753 ui_out_text (uiout, ")");
754 if (sal.symtab && sal.symtab->filename)
756 annotate_frame_source_begin ();
757 ui_out_wrap_hint (uiout, " ");
758 ui_out_text (uiout, " at ");
759 annotate_frame_source_file ();
760 ui_out_field_string (uiout, "file", sal.symtab->filename);
761 if (ui_out_is_mi_like_p (uiout))
763 const char *fullname = symtab_to_fullname (sal.symtab);
764 if (fullname != NULL)
765 ui_out_field_string (uiout, "fullname", fullname);
767 annotate_frame_source_file_end ();
768 ui_out_text (uiout, ":");
769 annotate_frame_source_line ();
770 ui_out_field_int (uiout, "line", sal.line);
771 annotate_frame_source_end ();
774 if (!funname || (!sal.symtab || !sal.symtab->filename))
777 char *lib = PC_SOLIB (get_frame_pc (frame));
779 char *lib = solib_name_from_address (get_frame_pc (frame));
783 annotate_frame_where ();
784 ui_out_wrap_hint (uiout, " ");
785 ui_out_text (uiout, " from ");
786 ui_out_field_string (uiout, "from", lib);
790 /* do_cleanups will call ui_out_tuple_end() for us. */
791 do_cleanups (list_chain);
792 ui_out_text (uiout, "\n");
793 do_cleanups (old_chain);
797 /* Read a frame specification in whatever the appropriate format is
798 from FRAME_EXP. Call error(), printing MESSAGE, if the
799 specification is in any way invalid (so this function never returns
800 NULL). When SEPECTED_P is non-NULL set its target to indicate that
801 the default selected frame was used. */
803 static struct frame_info *
804 parse_frame_specification_1 (const char *frame_exp, const char *message,
805 int *selected_frame_p)
808 struct value *args[4];
809 CORE_ADDR addrs[ARRAY_SIZE (args)];
811 if (frame_exp == NULL)
816 struct cleanup *tmp_cleanup;
822 struct cleanup *cleanup;
825 /* Skip leading white space, bail of EOL. */
826 while (isspace (*frame_exp))
831 /* Parse the argument, extract it, save it. */
835 addr_string = savestring (frame_exp, p - frame_exp);
837 cleanup = make_cleanup (xfree, addr_string);
839 /* NOTE: Parse and evaluate expression, but do not use
840 functions such as parse_and_eval_long or
841 parse_and_eval_address to also extract the value.
842 Instead value_as_long and value_as_address are used.
843 This avoids problems with expressions that contain
845 if (numargs >= ARRAY_SIZE (args))
846 error (_("Too many args in frame specification"));
847 args[numargs++] = parse_and_eval (addr_string);
849 do_cleanups (cleanup);
853 /* If no args, default to the selected frame. */
856 if (selected_frame_p != NULL)
857 (*selected_frame_p) = 1;
858 return get_selected_frame (message);
861 /* None of the remaining use the selected frame. */
862 if (selected_frame_p != NULL)
863 (*selected_frame_p) = 0;
865 /* Assume the single arg[0] is an integer, and try using that to
866 select a frame relative to current. */
869 struct frame_info *fid;
870 int level = value_as_long (args[0]);
871 fid = find_relative_frame (get_current_frame (), &level);
873 /* find_relative_frame was successful */
877 /* Convert each value into a corresponding address. */
880 for (i = 0; i < numargs; i++)
881 addrs[i] = value_as_address (args[i]);
884 /* Assume that the single arg[0] is an address, use that to identify
885 a frame with a matching ID. Should this also accept stack/pc or
889 struct frame_id id = frame_id_build_wild (addrs[0]);
890 struct frame_info *fid;
892 /* If (s)he specifies the frame with an address, he deserves
893 what (s)he gets. Still, give the highest one that matches.
894 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
896 for (fid = get_current_frame ();
898 fid = get_prev_frame (fid))
900 if (frame_id_eq (id, get_frame_id (fid)))
902 while (frame_id_eq (id, frame_unwind_id (fid)))
903 fid = get_prev_frame (fid);
909 /* We couldn't identify the frame as an existing frame, but
910 perhaps we can create one with a single argument. */
912 return create_new_frame (addrs[0], 0);
913 else if (numargs == 2)
914 return create_new_frame (addrs[0], addrs[1]);
916 error (_("Too many args in frame specification"));
919 static struct frame_info *
920 parse_frame_specification (char *frame_exp)
922 return parse_frame_specification_1 (frame_exp, NULL, NULL);
925 /* Print verbosely the selected frame or the frame at address
926 ADDR_EXP. Absolutely all information in the frame is printed. */
929 frame_info (char *addr_exp, int from_tty)
931 struct frame_info *fi;
932 struct symtab_and_line sal;
935 struct frame_info *calling_frame_info;
936 int i, count, numregs;
938 enum language funlang = language_unknown;
939 const char *pc_regname;
940 int selected_frame_p;
941 struct gdbarch *gdbarch;
942 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
944 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
945 gdbarch = get_frame_arch (fi);
947 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
948 is not a good name. */
949 if (gdbarch_pc_regnum (gdbarch) >= 0)
950 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
951 easily not match that of the internal value returned by
953 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
955 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
956 architectures will often have a hardware register called "pc",
957 and that register's value, again, can easily not match
961 find_frame_sal (fi, &sal);
962 func = get_frame_function (fi);
963 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
965 s = find_pc_symtab (get_frame_pc (fi));
968 funname = SYMBOL_PRINT_NAME (func);
969 funlang = SYMBOL_LANGUAGE (func);
970 if (funlang == language_cplus)
972 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
973 to display the demangled name that we already have
974 stored in the symbol table, but we stored a version
975 with DMGL_PARAMS turned on, and here we don't want to
976 display parameters. So remove the parameters. */
977 char *func_only = cp_remove_params (funname);
981 make_cleanup (xfree, func_only);
987 struct minimal_symbol *msymbol;
989 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
992 funname = SYMBOL_PRINT_NAME (msymbol);
993 funlang = SYMBOL_LANGUAGE (msymbol);
996 calling_frame_info = get_prev_frame (fi);
998 if (selected_frame_p && frame_relative_level (fi) >= 0)
1000 printf_filtered (_("Stack level %d, frame at "),
1001 frame_relative_level (fi));
1005 printf_filtered (_("Stack frame at "));
1007 fputs_filtered (paddress (get_frame_base (fi)), gdb_stdout);
1008 printf_filtered (":\n");
1009 printf_filtered (" %s = ", pc_regname);
1010 fputs_filtered (paddress (get_frame_pc (fi)), gdb_stdout);
1015 printf_filtered (" in ");
1016 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1017 DMGL_ANSI | DMGL_PARAMS);
1021 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
1022 puts_filtered ("; ");
1024 printf_filtered ("saved %s ", pc_regname);
1025 fputs_filtered (paddress (frame_pc_unwind (fi)), gdb_stdout);
1026 printf_filtered ("\n");
1028 if (calling_frame_info == NULL)
1030 enum unwind_stop_reason reason;
1032 reason = get_frame_unwind_stop_reason (fi);
1033 if (reason != UNWIND_NO_REASON)
1034 printf_filtered (_(" Outermost frame: %s\n"),
1035 frame_stop_reason_string (reason));
1038 if (calling_frame_info)
1040 printf_filtered (" called by frame at ");
1041 fputs_filtered (paddress (get_frame_base (calling_frame_info)),
1044 if (get_next_frame (fi) && calling_frame_info)
1045 puts_filtered (",");
1047 if (get_next_frame (fi))
1049 printf_filtered (" caller of frame at ");
1050 fputs_filtered (paddress (get_frame_base (get_next_frame (fi))),
1053 if (get_next_frame (fi) || calling_frame_info)
1054 puts_filtered ("\n");
1057 printf_filtered (" source language %s.\n",
1058 language_str (s->language));
1061 /* Address of the argument list for this frame, or 0. */
1062 CORE_ADDR arg_list = get_frame_args_address (fi);
1063 /* Number of args for this frame, or -1 if unknown. */
1067 printf_filtered (" Arglist at unknown address.\n");
1070 printf_filtered (" Arglist at ");
1071 fputs_filtered (paddress (arg_list), gdb_stdout);
1072 printf_filtered (",");
1074 if (!gdbarch_frame_num_args_p (gdbarch))
1077 puts_filtered (" args: ");
1081 numargs = gdbarch_frame_num_args (gdbarch, fi);
1082 gdb_assert (numargs >= 0);
1084 puts_filtered (" no args.");
1085 else if (numargs == 1)
1086 puts_filtered (" 1 arg: ");
1088 printf_filtered (" %d args: ", numargs);
1090 print_frame_args (func, fi, numargs, gdb_stdout);
1091 puts_filtered ("\n");
1095 /* Address of the local variables for this frame, or 0. */
1096 CORE_ADDR arg_list = get_frame_locals_address (fi);
1099 printf_filtered (" Locals at unknown address,");
1102 printf_filtered (" Locals at ");
1103 fputs_filtered (paddress (arg_list), gdb_stdout);
1104 printf_filtered (",");
1108 /* Print as much information as possible on the location of all the
1111 enum lval_type lval;
1119 /* The sp is special; what's displayed isn't the save address, but
1120 the value of the previous frame's sp. This is a legacy thing,
1121 at one stage the frame cached the previous frame's SP instead
1122 of its address, hence it was easiest to just display the cached
1124 if (gdbarch_sp_regnum (gdbarch) >= 0)
1126 /* Find out the location of the saved stack pointer with out
1127 actually evaluating it. */
1128 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1129 &optimized, &lval, &addr,
1131 if (!optimized && lval == not_lval)
1133 gdb_byte value[MAX_REGISTER_SIZE];
1135 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
1136 &optimized, &lval, &addr,
1138 /* NOTE: cagney/2003-05-22: This is assuming that the
1139 stack pointer was packed as an unsigned integer. That
1140 may or may not be valid. */
1141 sp = extract_unsigned_integer (value,
1142 register_size (gdbarch,
1143 gdbarch_sp_regnum (gdbarch)));
1144 printf_filtered (" Previous frame's sp is ");
1145 fputs_filtered (paddress (sp), gdb_stdout);
1146 printf_filtered ("\n");
1149 else if (!optimized && lval == lval_memory)
1151 printf_filtered (" Previous frame's sp at ");
1152 fputs_filtered (paddress (addr), gdb_stdout);
1153 printf_filtered ("\n");
1156 else if (!optimized && lval == lval_register)
1158 printf_filtered (" Previous frame's sp in %s\n",
1159 gdbarch_register_name (gdbarch, realnum));
1162 /* else keep quiet. */
1166 numregs = gdbarch_num_regs (gdbarch)
1167 + gdbarch_num_pseudo_regs (gdbarch);
1168 for (i = 0; i < numregs; i++)
1169 if (i != gdbarch_sp_regnum (gdbarch)
1170 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1172 /* Find out the location of the saved register without
1173 fetching the corresponding value. */
1174 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1176 /* For moment, only display registers that were saved on the
1178 if (!optimized && lval == lval_memory)
1181 puts_filtered (" Saved registers:\n ");
1183 puts_filtered (",");
1185 printf_filtered (" %s at ",
1186 gdbarch_register_name (gdbarch, i));
1187 fputs_filtered (paddress (addr), gdb_stdout);
1191 if (count || need_nl)
1192 puts_filtered ("\n");
1195 do_cleanups (back_to);
1198 /* Print briefly all stack frames or just the innermost COUNT_EXP
1202 backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1204 struct frame_info *fi;
1207 struct frame_info *trailing;
1210 if (!target_has_stack)
1211 error (_("No stack."));
1213 /* The following code must do two things. First, it must set the
1214 variable TRAILING to the frame from which we should start
1215 printing. Second, it must set the variable count to the number
1216 of frames which we should print, or -1 if all of them. */
1217 trailing = get_current_frame ();
1219 /* The target can be in a state where there is no valid frames
1220 (e.g., just connected). */
1221 if (trailing == NULL)
1222 error (_("No stack."));
1227 count = parse_and_eval_long (count_exp);
1230 struct frame_info *current;
1235 while (current && count--)
1238 current = get_prev_frame (current);
1241 /* Will stop when CURRENT reaches the top of the stack.
1242 TRAILING will be COUNT below it. */
1246 trailing = get_prev_frame (trailing);
1247 current = get_prev_frame (current);
1259 struct partial_symtab *ps;
1261 /* Read in symbols for all of the frames. Need to do this in a
1262 separate pass so that "Reading in symbols for xxx" messages
1263 don't screw up the appearance of the backtrace. Also if
1264 people have strong opinions against reading symbols for
1265 backtrace this may have to be an option. */
1267 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1270 ps = find_pc_psymtab (get_frame_address_in_block (fi));
1272 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
1276 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1280 /* Don't use print_stack_frame; if an error() occurs it probably
1281 means further attempts to backtrace would fail (on the other
1282 hand, perhaps the code does or could be fixed to make sure
1283 the frame->prev field gets set to NULL in that case). */
1284 print_frame_info (fi, 1, LOCATION, 1);
1286 print_frame_local_vars (fi, 1, gdb_stdout);
1288 /* Save the last frame to check for error conditions. */
1292 /* If we've stopped before the end, mention that. */
1294 printf_filtered (_("(More stack frames follow...)\n"));
1296 /* If we've run out of frames, and the reason appears to be an error
1297 condition, print it. */
1298 if (fi == NULL && trailing != NULL)
1300 enum unwind_stop_reason reason;
1302 reason = get_frame_unwind_stop_reason (trailing);
1303 if (reason > UNWIND_FIRST_ERROR)
1304 printf_filtered (_("Backtrace stopped: %s\n"),
1305 frame_stop_reason_string (reason));
1309 struct backtrace_command_args
1316 /* Stub for catch_errors. */
1319 backtrace_command_stub (void *data)
1321 struct backtrace_command_args *args = data;
1322 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1327 backtrace_command (char *arg, int from_tty)
1329 struct cleanup *old_chain = NULL;
1330 int fulltrace_arg = -1, arglen = 0, argc = 0;
1331 struct backtrace_command_args btargs;
1338 argv = gdb_buildargv (arg);
1339 old_chain = make_cleanup_freeargv (argv);
1341 for (i = 0; argv[i]; i++)
1345 for (j = 0; j < strlen (argv[i]); j++)
1346 argv[i][j] = tolower (argv[i][j]);
1348 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1349 fulltrace_arg = argc;
1352 arglen += strlen (argv[i]);
1357 if (fulltrace_arg >= 0)
1361 arg = xmalloc (arglen + 1);
1362 memset (arg, 0, arglen + 1);
1363 for (i = 0; i < (argc + 1); i++)
1365 if (i != fulltrace_arg)
1367 strcat (arg, argv[i]);
1377 btargs.count_exp = arg;
1378 btargs.show_locals = (fulltrace_arg >= 0);
1379 btargs.from_tty = from_tty;
1380 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1382 if (fulltrace_arg >= 0 && arglen > 0)
1386 do_cleanups (old_chain);
1390 backtrace_full_command (char *arg, int from_tty)
1392 struct backtrace_command_args btargs;
1393 btargs.count_exp = arg;
1394 btargs.show_locals = 1;
1395 btargs.from_tty = from_tty;
1396 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
1400 /* Print the local variables of a block B active in FRAME on STREAM.
1401 Return 1 if any variables were printed; 0 otherwise. */
1404 print_block_frame_locals (struct block *b, struct frame_info *frame,
1405 int num_tabs, struct ui_file *stream)
1407 struct dict_iterator iter;
1409 int values_printed = 0;
1412 ALL_BLOCK_SYMBOLS (b, iter, sym)
1414 switch (SYMBOL_CLASS (sym))
1420 if (SYMBOL_IS_ARGUMENT (sym))
1423 print_variable_and_value (NULL, sym, frame, stream, 4 * num_tabs);
1427 /* Ignore symbols which are not locals. */
1432 return values_printed;
1435 /* Same, but print labels. */
1438 print_block_frame_labels (struct block *b, int *have_default,
1439 struct ui_file *stream)
1441 struct dict_iterator iter;
1443 int values_printed = 0;
1445 ALL_BLOCK_SYMBOLS (b, iter, sym)
1447 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1453 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1455 struct symtab_and_line sal;
1456 struct value_print_options opts;
1457 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1459 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1460 get_user_print_options (&opts);
1461 if (opts.addressprint)
1463 fprintf_filtered (stream, " ");
1464 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream);
1466 fprintf_filtered (stream, " in file %s, line %d\n",
1467 sal.symtab->filename, sal.line);
1471 return values_printed;
1474 /* Print on STREAM all the local variables in frame FRAME, including
1475 all the blocks active in that frame at its current PC.
1477 Returns 1 if the job was done, or 0 if nothing was printed because
1478 we have no info on the function running in FRAME. */
1481 print_frame_local_vars (struct frame_info *frame, int num_tabs,
1482 struct ui_file *stream)
1484 struct block *block = get_frame_block (frame, 0);
1485 int values_printed = 0;
1489 fprintf_filtered (stream, "No symbol table info available.\n");
1495 if (print_block_frame_locals (block, frame, num_tabs, stream))
1497 /* After handling the function's top-level block, stop. Don't
1498 continue to its superblock, the block of per-file symbols. */
1499 if (BLOCK_FUNCTION (block))
1501 block = BLOCK_SUPERBLOCK (block);
1504 if (!values_printed)
1505 fprintf_filtered (stream, _("No locals.\n"));
1508 /* Same, but print labels. */
1511 print_frame_label_vars (struct frame_info *frame, int this_level_only,
1512 struct ui_file *stream)
1515 fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
1517 struct blockvector *bl;
1518 struct block *block = get_frame_block (frame, 0);
1519 int values_printed = 0;
1520 int index, have_default = 0;
1521 char *blocks_printed;
1522 CORE_ADDR pc = get_frame_pc (frame);
1526 fprintf_filtered (stream, "No symbol table info available.\n");
1530 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
1531 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1532 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1536 CORE_ADDR end = BLOCK_END (block) - 4;
1539 if (bl != blockvector_for_pc (end, &index))
1540 error (_("blockvector blotch"));
1541 if (BLOCKVECTOR_BLOCK (bl, index) != block)
1542 error (_("blockvector botch"));
1543 last_index = BLOCKVECTOR_NBLOCKS (bl);
1546 /* Don't print out blocks that have gone by. */
1547 while (index < last_index
1548 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1551 while (index < last_index
1552 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1554 if (blocks_printed[index] == 0)
1556 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index),
1557 &have_default, stream))
1559 blocks_printed[index] = 1;
1565 if (values_printed && this_level_only)
1568 /* After handling the function's top-level block, stop. Don't
1569 continue to its superblock, the block of per-file symbols. */
1570 if (BLOCK_FUNCTION (block))
1572 block = BLOCK_SUPERBLOCK (block);
1575 if (!values_printed && !this_level_only)
1576 fprintf_filtered (stream, _("No catches.\n"));
1581 locals_info (char *args, int from_tty)
1583 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1588 catch_info (char *ignore, int from_tty)
1590 struct symtab_and_line *sal;
1592 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1593 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1598 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
1600 struct symbol *func = get_frame_function (frame);
1602 struct dict_iterator iter;
1603 struct symbol *sym, *sym2;
1604 int values_printed = 0;
1608 fprintf_filtered (stream, _("No symbol table info available.\n"));
1612 b = SYMBOL_BLOCK_VALUE (func);
1613 ALL_BLOCK_SYMBOLS (b, iter, sym)
1615 /* Don't worry about things which aren't arguments. */
1616 if (SYMBOL_IS_ARGUMENT (sym))
1620 /* We have to look up the symbol because arguments can have
1621 two entries (one a parameter, one a local) and the one we
1622 want is the local, which lookup_symbol will find for us.
1623 This includes gcc1 (not gcc2) on the sparc when passing a
1624 small structure and gcc2 when the argument type is float
1625 and it is passed as a double and converted to float by
1626 the prologue (in the latter case the type of the LOC_ARG
1627 symbol is double and the type of the LOC_LOCAL symbol is
1628 float). There are also LOC_ARG/LOC_REGISTER pairs which
1629 are not combined in symbol-reading. */
1631 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
1632 b, VAR_DOMAIN, NULL);
1633 print_variable_and_value (SYMBOL_PRINT_NAME (sym), sym2,
1638 if (!values_printed)
1639 fprintf_filtered (stream, _("No arguments.\n"));
1643 args_info (char *ignore, int from_tty)
1645 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1651 args_plus_locals_info (char *ignore, int from_tty)
1653 args_info (ignore, from_tty);
1654 locals_info (ignore, from_tty);
1658 /* Select frame FRAME. Also print the stack frame and show the source
1659 if this is the tui version. */
1661 select_and_print_frame (struct frame_info *frame)
1663 select_frame (frame);
1665 print_stack_frame (frame, 1, SRC_AND_LOC);
1668 /* Return the symbol-block in which the selected frame is executing.
1669 Can return zero under various legitimate circumstances.
1671 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1672 code address within the block returned. We use this to decide
1673 which macros are in scope. */
1676 get_selected_block (CORE_ADDR *addr_in_block)
1678 if (!has_stack_frames ())
1681 return get_frame_block (get_selected_frame (NULL), addr_in_block);
1684 /* Find a frame a certain number of levels away from FRAME.
1685 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1686 Positive means go to earlier frames (up); negative, the reverse.
1687 The int that contains the number of levels is counted toward
1688 zero as the frames for those levels are found.
1689 If the top or bottom frame is reached, that frame is returned,
1690 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1691 how much farther the original request asked to go. */
1694 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
1696 /* Going up is simple: just call get_prev_frame enough times or
1697 until the initial frame is reached. */
1698 while (*level_offset_ptr > 0)
1700 struct frame_info *prev = get_prev_frame (frame);
1703 (*level_offset_ptr)--;
1707 /* Going down is just as simple. */
1708 while (*level_offset_ptr < 0)
1710 struct frame_info *next = get_next_frame (frame);
1713 (*level_offset_ptr)++;
1720 /* The "select_frame" command. With no argument this is a NOP.
1721 Select the frame at level LEVEL_EXP if it is a valid level.
1722 Otherwise, treat LEVEL_EXP as an address expression and select it.
1724 See parse_frame_specification for more info on proper frame
1728 select_frame_command (char *level_exp, int from_tty)
1730 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
1733 /* The "frame" command. With no argument, print the selected frame
1734 briefly. With an argument, behave like select_frame and then print
1735 the selected frame. */
1738 frame_command (char *level_exp, int from_tty)
1740 select_frame_command (level_exp, from_tty);
1741 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1744 /* The XDB Compatibility command to print the current frame. */
1747 current_frame_command (char *level_exp, int from_tty)
1749 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
1752 /* Select the frame up one or COUNT_EXP stack levels from the
1753 previously selected frame, and print it briefly. */
1756 up_silently_base (char *count_exp)
1758 struct frame_info *frame;
1762 count = parse_and_eval_long (count_exp);
1764 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1765 if (count != 0 && count_exp == NULL)
1766 error (_("Initial frame selected; you cannot go up."));
1767 select_frame (frame);
1771 up_silently_command (char *count_exp, int from_tty)
1773 up_silently_base (count_exp);
1777 up_command (char *count_exp, int from_tty)
1779 up_silently_base (count_exp);
1780 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1783 /* Select the frame down one or COUNT_EXP stack levels from the previously
1784 selected frame, and print it briefly. */
1787 down_silently_base (char *count_exp)
1789 struct frame_info *frame;
1792 count = -parse_and_eval_long (count_exp);
1794 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1795 if (count != 0 && count_exp == NULL)
1797 /* We only do this if COUNT_EXP is not specified. That way
1798 "down" means to really go down (and let me know if that is
1799 impossible), but "down 9999" can be used to mean go all the
1800 way down without getting an error. */
1802 error (_("Bottom (innermost) frame selected; you cannot go down."));
1805 select_frame (frame);
1809 down_silently_command (char *count_exp, int from_tty)
1811 down_silently_base (count_exp);
1815 down_command (char *count_exp, int from_tty)
1817 down_silently_base (count_exp);
1818 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
1823 return_command (char *retval_exp, int from_tty)
1825 struct frame_info *thisframe;
1826 struct gdbarch *gdbarch;
1827 struct symbol *thisfun;
1828 struct value *return_value = NULL;
1829 const char *query_prefix = "";
1831 thisframe = get_selected_frame ("No selected frame.");
1832 thisfun = get_frame_function (thisframe);
1833 gdbarch = get_frame_arch (thisframe);
1835 /* Compute the return value. If the computation triggers an error,
1836 let it bail. If the return type can't be handled, set
1837 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1841 struct expression *retval_expr = parse_expression (retval_exp);
1842 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
1843 struct type *return_type = NULL;
1845 /* Compute the return value. Should the computation fail, this
1846 call throws an error. */
1847 return_value = evaluate_expression (retval_expr);
1849 /* Cast return value to the return type of the function. Should
1850 the cast fail, this call throws an error. */
1851 if (thisfun != NULL)
1852 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1853 if (return_type == NULL)
1855 if (retval_expr->elts[0].opcode != UNOP_CAST)
1856 error (_("Return value type not available for selected "
1858 "Please use an explicit cast of the value to return."));
1859 return_type = value_type (return_value);
1861 do_cleanups (old_chain);
1862 CHECK_TYPEDEF (return_type);
1863 return_value = value_cast (return_type, return_value);
1865 /* Make sure the value is fully evaluated. It may live in the
1866 stack frame we're about to pop. */
1867 if (value_lazy (return_value))
1868 value_fetch_lazy (return_value);
1870 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1871 /* If the return-type is "void", don't try to find the
1872 return-value's location. However, do still evaluate the
1873 return expression so that, even when the expression result
1874 is discarded, side effects such as "return i++" still
1876 return_value = NULL;
1877 else if (thisfun != NULL
1878 && using_struct_return (gdbarch,
1879 SYMBOL_TYPE (thisfun), return_type))
1882 The location at which to store the function's return value is unknown.\n\
1883 If you continue, the return value that you specified will be ignored.\n";
1884 return_value = NULL;
1888 /* Does an interactive user really want to do this? Include
1889 information, such as how well GDB can handle the return value, in
1890 the query message. */
1894 if (thisfun == NULL)
1895 confirmed = query (_("%sMake selected stack frame return now? "),
1898 confirmed = query (_("%sMake %s return now? "), query_prefix,
1899 SYMBOL_PRINT_NAME (thisfun));
1901 error (_("Not confirmed"));
1904 /* Discard the selected frame and all frames inner-to it. */
1905 frame_pop (get_selected_frame (NULL));
1907 /* Store RETURN_VALUE in the just-returned register set. */
1908 if (return_value != NULL)
1910 struct type *return_type = value_type (return_value);
1911 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
1912 struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
1914 gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
1916 == RETURN_VALUE_REGISTER_CONVENTION);
1917 gdbarch_return_value (gdbarch, func_type, return_type,
1918 get_current_regcache (), NULL /*read*/,
1919 value_contents (return_value) /*write*/);
1922 /* If we are at the end of a call dummy now, pop the dummy frame
1924 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1925 frame_pop (get_current_frame ());
1927 /* If interactive, print the frame that is now current. */
1929 frame_command ("0", 1);
1931 select_frame_command ("0", 0);
1934 /* Sets the scope to input function name, provided that the function
1935 is within the current stack frame */
1937 struct function_bounds
1939 CORE_ADDR low, high;
1943 func_command (char *arg, int from_tty)
1945 struct frame_info *frame;
1947 struct symtabs_and_lines sals;
1950 struct function_bounds *func_bounds = NULL;
1955 frame = parse_frame_specification ("0");
1956 sals = decode_line_spec (arg, 1);
1957 func_bounds = (struct function_bounds *) xmalloc (
1958 sizeof (struct function_bounds) * sals.nelts);
1959 for (i = 0; (i < sals.nelts && !found); i++)
1961 if (sals.sals[i].pc == 0
1962 || find_pc_partial_function (sals.sals[i].pc, NULL,
1963 &func_bounds[i].low,
1964 &func_bounds[i].high) == 0)
1966 func_bounds[i].low = func_bounds[i].high = 0;
1972 for (i = 0; (i < sals.nelts && !found); i++)
1973 found = (get_frame_pc (frame) >= func_bounds[i].low
1974 && get_frame_pc (frame) < func_bounds[i].high);
1978 frame = find_relative_frame (frame, &level);
1981 while (!found && level == 0);
1984 xfree (func_bounds);
1987 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
1988 else if (frame != get_selected_frame (NULL))
1989 select_and_print_frame (frame);
1992 /* Gets the language of the current frame. */
1995 get_frame_language (void)
1997 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2001 /* We determine the current frame language by looking up its
2002 associated symtab. To retrieve this symtab, we use the frame
2003 PC. However we cannot use the frame PC as is, because it
2004 usually points to the instruction following the "call", which
2005 is sometimes the first instruction of another function. So
2006 we rely on get_frame_address_in_block(), it provides us with
2007 a PC that is guaranteed to be inside the frame's code
2009 CORE_ADDR pc = get_frame_address_in_block (frame);
2010 struct symtab *s = find_pc_symtab (pc);
2016 return language_unknown;
2020 /* Provide a prototype to silence -Wmissing-prototypes. */
2021 void _initialize_stack (void);
2024 _initialize_stack (void)
2027 backtrace_limit = 30;
2030 add_com ("return", class_stack, return_command, _("\
2031 Make selected stack frame return to its caller.\n\
2032 Control remains in the debugger, but when you continue\n\
2033 execution will resume in the frame above the one now selected.\n\
2034 If an argument is given, it is an expression for the value to return."));
2036 add_com ("up", class_stack, up_command, _("\
2037 Select and print stack frame that called this one.\n\
2038 An argument says how many frames up to go."));
2039 add_com ("up-silently", class_support, up_silently_command, _("\
2040 Same as the `up' command, but does not print anything.\n\
2041 This is useful in command scripts."));
2043 add_com ("down", class_stack, down_command, _("\
2044 Select and print stack frame called by this one.\n\
2045 An argument says how many frames down to go."));
2046 add_com_alias ("do", "down", class_stack, 1);
2047 add_com_alias ("dow", "down", class_stack, 1);
2048 add_com ("down-silently", class_support, down_silently_command, _("\
2049 Same as the `down' command, but does not print anything.\n\
2050 This is useful in command scripts."));
2052 add_com ("frame", class_stack, frame_command, _("\
2053 Select and print a stack frame.\n\
2054 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2055 An argument specifies the frame to select.\n\
2056 It can be a stack frame number or the address of the frame.\n\
2057 With argument, nothing is printed if input is coming from\n\
2058 a command file or a user-defined command."));
2060 add_com_alias ("f", "frame", class_stack, 1);
2064 add_com ("L", class_stack, current_frame_command,
2065 _("Print the current stack frame.\n"));
2066 add_com_alias ("V", "frame", class_stack, 1);
2068 add_com ("select-frame", class_stack, select_frame_command, _("\
2069 Select a stack frame without printing anything.\n\
2070 An argument specifies the frame to select.\n\
2071 It can be a stack frame number or the address of the frame.\n"));
2073 add_com ("backtrace", class_stack, backtrace_command, _("\
2074 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2075 With a negative argument, print outermost -COUNT frames.\n\
2076 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2077 add_com_alias ("bt", "backtrace", class_stack, 0);
2080 add_com_alias ("t", "backtrace", class_stack, 0);
2081 add_com ("T", class_stack, backtrace_full_command, _("\
2082 Print backtrace of all stack frames, or innermost COUNT frames \n\
2083 and the values of the local variables.\n\
2084 With a negative argument, print outermost -COUNT frames.\n\
2085 Usage: T <count>\n"));
2088 add_com_alias ("where", "backtrace", class_alias, 0);
2089 add_info ("stack", backtrace_command,
2090 _("Backtrace of the stack, or innermost COUNT frames."));
2091 add_info_alias ("s", "stack", 1);
2092 add_info ("frame", frame_info,
2093 _("All about selected stack frame, or frame at ADDR."));
2094 add_info_alias ("f", "frame", 1);
2095 add_info ("locals", locals_info,
2096 _("Local variables of current stack frame."));
2097 add_info ("args", args_info,
2098 _("Argument variables of current stack frame."));
2100 add_com ("l", class_info, args_plus_locals_info,
2101 _("Argument and local variables of current stack frame."));
2104 add_com ("func", class_stack, func_command, _("\
2105 Select the stack frame that contains <func>.\n\
2106 Usage: func <name>\n"));
2108 add_info ("catch", catch_info,
2109 _("Exceptions that can be caught in the current stack frame."));
2111 add_setshow_enum_cmd ("frame-arguments", class_stack,
2112 print_frame_arguments_choices, &print_frame_arguments,
2113 _("Set printing of non-scalar frame arguments"),
2114 _("Show printing of non-scalar frame arguments"),
2115 NULL, NULL, NULL, &setprintlist, &showprintlist);
2117 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2118 &disassemble_next_line, _("\
2119 Set whether to disassemble next source line or insn when execution stops."), _("\
2120 Show whether to disassemble next source line or insn when execution stops."), _("\
2121 If ON, GDB will display disassembly of the next source line, in addition\n\
2122 to displaying the source line itself. If the next source line cannot\n\
2123 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2124 will display disassembly of next instruction instead of showing the\n\
2126 If AUTO, display disassembly of next instruction only if the source line\n\
2127 cannot be displayed.\n\
2128 If OFF (which is the default), never display the disassembly of the next\n\
2131 show_disassemble_next_line,
2132 &setlist, &showlist);
2133 disassemble_next_line = AUTO_BOOLEAN_FALSE;
2136 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2137 "Specify maximum number of frames for \"backtrace\" to print by default."),
2139 add_info ("backtrace-limit", backtrace_limit_info, _("\
2140 The maximum number of frames for \"backtrace\" to print by default."));