1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
33 #include "breakpoint.h"
40 #include "dictionary.h"
41 #include "exceptions.h"
42 #include "reggroups.h"
46 #include "gdbthread.h"
47 #include "cp-support.h"
49 #include "inline-frame.h"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
58 void (*deprecated_selected_frame_level_changed_hook
) (int);
60 /* The possible choices of "set print frame-arguments, and the value
63 static const char *print_frame_arguments_choices
[] =
64 {"all", "scalars", "none", NULL
};
65 static const char *print_frame_arguments
= "scalars";
67 /* Prototypes for local functions. */
69 static void print_frame_local_vars (struct frame_info
*, int,
72 static void print_frame (struct frame_info
*frame
, int print_level
,
73 enum print_what print_what
, int print_args
,
74 struct symtab_and_line sal
);
76 /* Zero means do things normally; we are interacting directly with the
77 user. One means print the full filename and linenumber when a
78 frame is printed, and do so in a format emacs18/emacs19.22 can
79 parse. Two means print similar annotations, but in many more
80 cases and in a slightly different syntax. */
82 int annotation_level
= 0;
85 struct print_stack_frame_args
87 struct frame_info
*frame
;
89 enum print_what print_what
;
93 /* Show or print the frame arguments; stub for catch_errors. */
96 print_stack_frame_stub (void *args
)
98 struct print_stack_frame_args
*p
= args
;
99 int center
= (p
->print_what
== SRC_LINE
|| p
->print_what
== SRC_AND_LOC
);
101 print_frame_info (p
->frame
, p
->print_level
, p
->print_what
, p
->print_args
);
102 set_current_sal_from_frame (p
->frame
, center
);
106 /* Return 1 if we should display the address in addition to the location,
107 because we are in the middle of a statement. */
110 frame_show_address (struct frame_info
*frame
,
111 struct symtab_and_line sal
)
113 /* If there is a line number, but no PC, then there is no location
114 information associated with this sal. The only way that should
115 happen is for the call sites of inlined functions (SAL comes from
116 find_frame_sal). Otherwise, we would have some PC range if the
117 SAL came from a line table. */
118 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
120 if (get_next_frame (frame
) == NULL
)
121 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
123 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
127 return get_frame_pc (frame
) != sal
.pc
;
130 /* Show or print a stack frame FRAME briefly. The output is format
131 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
132 relative level, function name, argument list, and file name and
133 line number. If the frame's PC is not at the beginning of the
134 source line, the actual PC is printed at the beginning. */
137 print_stack_frame (struct frame_info
*frame
, int print_level
,
138 enum print_what print_what
)
140 struct print_stack_frame_args args
;
143 args
.print_level
= print_level
;
144 args
.print_what
= print_what
;
145 /* For mi, alway print location and address. */
146 args
.print_what
= ui_out_is_mi_like_p (uiout
) ? LOC_AND_ADDRESS
: print_what
;
149 catch_errors (print_stack_frame_stub
, &args
, "", RETURN_MASK_ERROR
);
152 struct print_args_args
155 struct frame_info
*frame
;
156 struct ui_file
*stream
;
159 static int print_args_stub (void *args
);
161 /* Print nameless arguments of frame FRAME on STREAM, where START is
162 the offset of the first nameless argument, and NUM is the number of
163 nameless arguments to print. FIRST is nonzero if this is the first
164 argument (not just the first nameless argument). */
167 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
168 int first
, struct ui_file
*stream
)
170 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
171 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
176 for (i
= 0; i
< num
; i
++)
179 argsaddr
= get_frame_args_address (frame
);
182 arg_value
= read_memory_integer (argsaddr
+ start
,
183 sizeof (int), byte_order
);
185 fprintf_filtered (stream
, ", ");
186 fprintf_filtered (stream
, "%ld", arg_value
);
188 start
+= sizeof (int);
192 /* Print the arguments of frame FRAME on STREAM, given the function
193 FUNC running in that frame (as a symbol), where NUM is the number
194 of arguments according to the stack frame (or -1 if the number of
195 arguments is unknown). */
197 /* Note that currently the "number of arguments according to the
198 stack frame" is only known on VAX where i refers to the "number of
199 ints of arguments according to the stack frame". */
202 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
203 int num
, struct ui_file
*stream
)
206 /* Offset of next stack argument beyond the one we have seen that is
207 at the highest offset, or -1 if we haven't come to a stack
209 long highest_offset
= -1;
210 /* Number of ints of arguments that we have printed so far. */
211 int args_printed
= 0;
212 struct cleanup
*old_chain
, *list_chain
;
213 struct ui_stream
*stb
;
214 /* True if we should print arguments, false otherwise. */
215 int print_args
= strcmp (print_frame_arguments
, "none");
216 /* True in "summary" mode, false otherwise. */
217 int summary
= !strcmp (print_frame_arguments
, "scalars");
219 stb
= ui_out_stream_new (uiout
);
220 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
224 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
225 struct dict_iterator iter
;
229 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
233 /* Keep track of the highest stack argument offset seen, and
234 skip over any kinds of symbols we don't care about. */
236 if (!SYMBOL_IS_ARGUMENT (sym
))
239 switch (SYMBOL_CLASS (sym
))
244 long current_offset
= SYMBOL_VALUE (sym
);
245 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
247 /* Compute address of next argument by adding the size of
248 this argument and rounding to an int boundary. */
250 ((current_offset
+ arg_size
+ sizeof (int) - 1)
251 & ~(sizeof (int) - 1));
253 /* If this is the highest offset seen yet, set
255 if (highest_offset
== -1
256 || (current_offset
> highest_offset
))
257 highest_offset
= current_offset
;
259 /* Add the number of ints we're about to print to
261 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
264 /* We care about types of symbols, but don't need to
265 keep track of stack offsets in them. */
267 case LOC_REGPARM_ADDR
:
269 case LOC_OPTIMIZED_OUT
:
274 /* We have to look up the symbol because arguments can have
275 two entries (one a parameter, one a local) and the one we
276 want is the local, which lookup_symbol will find for us.
277 This includes gcc1 (not gcc2) on SPARC when passing a
278 small structure and gcc2 when the argument type is float
279 and it is passed as a double and converted to float by
280 the prologue (in the latter case the type of the LOC_ARG
281 symbol is double and the type of the LOC_LOCAL symbol is
283 /* But if the parameter name is null, don't try it. Null
284 parameter names occur on the RS/6000, for traceback
285 tables. FIXME, should we even print them? */
287 if (*SYMBOL_LINKAGE_NAME (sym
))
291 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
292 b
, VAR_DOMAIN
, NULL
);
293 gdb_assert (nsym
!= NULL
);
294 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
295 && !SYMBOL_IS_ARGUMENT (nsym
))
297 /* There is a LOC_ARG/LOC_REGISTER pair. This means
298 that it was passed on the stack and loaded into a
299 register, or passed in a register and stored in a
300 stack slot. GDB 3.x used the LOC_ARG; GDB
301 4.0-4.11 used the LOC_REGISTER.
303 Reasons for using the LOC_ARG:
305 (1) Because find_saved_registers may be slow for
308 (2) Because registers are often re-used and stack
309 slots rarely (never?) are. Therefore using
310 the stack slot is much less likely to print
313 Reasons why we might want to use the LOC_REGISTER:
315 (1) So that the backtrace prints the same value
316 as "print foo". I see no compelling reason
317 why this needs to be the case; having the
318 backtrace print the value which was passed
319 in, and "print foo" print the value as
320 modified within the called function, makes
323 Additional note: It might be nice if "info args"
324 displayed both values.
326 One more note: There is a case with SPARC
327 structure passing where we need to use the
328 LOC_REGISTER, but this is dealt with by creating
329 a single LOC_REGPARM in symbol reading. */
331 /* Leave sym (the LOC_ARG) alone. */
338 /* Print the current arg. */
340 ui_out_text (uiout
, ", ");
341 ui_out_wrap_hint (uiout
, " ");
343 annotate_arg_begin ();
345 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
346 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
347 SYMBOL_LANGUAGE (sym
),
348 DMGL_PARAMS
| DMGL_ANSI
);
349 ui_out_field_stream (uiout
, "name", stb
);
350 annotate_arg_name_end ();
351 ui_out_text (uiout
, "=");
355 /* Avoid value_print because it will deref ref parameters.
356 We just want to print their addresses. Print ??? for
357 args whose address we do not know. We pass 2 as
358 "recurse" to val_print because our standard indentation
359 here is 4 spaces, and val_print indents 2 for each
361 val
= read_var_value (sym
, frame
);
363 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
367 const struct language_defn
*language
;
368 struct value_print_options opts
;
370 /* Use the appropriate language to display our symbol,
371 unless the user forced the language to a specific
373 if (language_mode
== language_mode_auto
)
374 language
= language_def (SYMBOL_LANGUAGE (sym
));
376 language
= current_language
;
378 get_raw_print_options (&opts
);
380 opts
.summary
= summary
;
381 common_val_print (val
, stb
->stream
, 2, &opts
, language
);
382 ui_out_field_stream (uiout
, "value", stb
);
385 ui_out_text (uiout
, "???");
388 ui_out_text (uiout
, "...");
391 /* Invoke ui_out_tuple_end. */
392 do_cleanups (list_chain
);
400 /* Don't print nameless args in situations where we don't know
401 enough about the stack to find them. */
406 if (highest_offset
== -1)
407 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
409 start
= highest_offset
;
411 print_frame_nameless_args (frame
, start
, num
- args_printed
,
415 do_cleanups (old_chain
);
418 /* Stub for catch_errors. */
421 print_args_stub (void *args
)
423 struct print_args_args
*p
= args
;
424 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
427 if (gdbarch_frame_num_args_p (gdbarch
))
429 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
430 gdb_assert (numargs
>= 0);
434 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
438 /* Set the current source and line to the location given by frame
439 FRAME, if possible. When CENTER is true, adjust so the relevant
440 line is in the center of the next 'list'. */
443 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
445 struct symtab_and_line sal
;
447 find_frame_sal (frame
, &sal
);
451 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
452 set_current_source_symtab_and_line (&sal
);
456 /* If ON, GDB will display disassembly of the next source line when
457 execution of the program being debugged stops.
458 If AUTO (which is the default), or there's no line info to determine
459 the source line of the next instruction, display disassembly of next
460 instruction instead. */
462 static enum auto_boolean disassemble_next_line
;
465 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
466 struct cmd_list_element
*c
,
469 fprintf_filtered (file
,
470 _("Debugger's willingness to use "
471 "disassemble-next-line is %s.\n"),
475 /* Show assembly codes; stub for catch_errors. */
477 struct gdb_disassembly_stub_args
479 struct gdbarch
*gdbarch
;
486 gdb_disassembly_stub (void *args
)
488 struct gdb_disassembly_stub_args
*p
= args
;
490 gdb_disassembly (p
->gdbarch
, uiout
, 0,
491 DISASSEMBLY_RAW_INSN
, p
->how_many
,
495 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
496 because it will be broken by filter sometime. */
499 do_gdb_disassembly (struct gdbarch
*gdbarch
,
500 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
502 volatile struct gdb_exception exception
;
503 struct gdb_disassembly_stub_args args
;
505 args
.gdbarch
= gdbarch
;
506 args
.how_many
= how_many
;
509 TRY_CATCH (exception
, RETURN_MASK_ALL
)
511 gdb_disassembly_stub (&args
);
513 /* If an exception was thrown while doing the disassembly, print
514 the error message, to give the user a clue of what happened. */
515 if (exception
.reason
== RETURN_ERROR
)
516 exception_print (gdb_stderr
, exception
);
519 /* Print information about frame FRAME. The output is format according
520 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
523 SRC_LINE: Print only source line.
524 LOCATION: Print only location.
525 LOC_AND_SRC: Print location and source line.
527 Used in "where" output, and to emit breakpoint or step
531 print_frame_info (struct frame_info
*frame
, int print_level
,
532 enum print_what print_what
, int print_args
)
534 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
535 struct symtab_and_line sal
;
539 if (get_frame_type (frame
) == DUMMY_FRAME
540 || get_frame_type (frame
) == SIGTRAMP_FRAME
541 || get_frame_type (frame
) == ARCH_FRAME
)
543 struct cleanup
*uiout_cleanup
544 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
546 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
547 gdbarch
, get_frame_pc (frame
));
549 /* Do this regardless of SOURCE because we don't have any source
550 to list for this frame. */
553 ui_out_text (uiout
, "#");
554 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
555 frame_relative_level (frame
));
557 if (ui_out_is_mi_like_p (uiout
))
559 annotate_frame_address ();
560 ui_out_field_core_addr (uiout
, "addr",
561 gdbarch
, get_frame_pc (frame
));
562 annotate_frame_address_end ();
565 if (get_frame_type (frame
) == DUMMY_FRAME
)
567 annotate_function_call ();
568 ui_out_field_string (uiout
, "func", "<function called from gdb>");
570 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
572 annotate_signal_handler_caller ();
573 ui_out_field_string (uiout
, "func", "<signal handler called>");
575 else if (get_frame_type (frame
) == ARCH_FRAME
)
577 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
579 ui_out_text (uiout
, "\n");
580 annotate_frame_end ();
582 do_cleanups (uiout_cleanup
);
586 /* If FRAME is not the innermost frame, that normally means that
587 FRAME->pc points to *after* the call instruction, and we want to
588 get the line containing the call, never the next line. But if
589 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
590 next frame was not entered as the result of a call, and we want
591 to get the line containing FRAME->pc. */
592 find_frame_sal (frame
, &sal
);
594 location_print
= (print_what
== LOCATION
595 || print_what
== LOC_AND_ADDRESS
596 || print_what
== SRC_AND_LOC
);
598 if (location_print
|| !sal
.symtab
)
599 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
601 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
603 /* If disassemble-next-line is set to auto or on and doesn't have
604 the line debug messages for $pc, output the next instruction. */
605 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
606 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
607 && source_print
&& !sal
.symtab
)
608 do_gdb_disassembly (get_frame_arch (frame
), 1,
609 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
611 if (source_print
&& sal
.symtab
)
614 int mid_statement
= ((print_what
== SRC_LINE
)
615 && frame_show_address (frame
, sal
));
617 if (annotation_level
)
618 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
619 get_frame_pc (frame
));
622 if (deprecated_print_frame_info_listing_hook
)
623 deprecated_print_frame_info_listing_hook (sal
.symtab
,
628 struct value_print_options opts
;
630 get_user_print_options (&opts
);
631 /* We used to do this earlier, but that is clearly
632 wrong. This function is used by many different
633 parts of gdb, including normal_stop in infrun.c,
634 which uses this to print out the current PC
635 when we stepi/nexti into the middle of a source
636 line. Only the command line really wants this
637 behavior. Other UIs probably would like the
638 ability to decide for themselves if it is desired. */
639 if (opts
.addressprint
&& mid_statement
)
641 ui_out_field_core_addr (uiout
, "addr",
642 gdbarch
, get_frame_pc (frame
));
643 ui_out_text (uiout
, "\t");
646 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
650 /* If disassemble-next-line is set to on and there is line debug
651 messages, output assembly codes for next line. */
652 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
653 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
656 if (print_what
!= LOCATION
)
657 set_default_breakpoint (1, sal
.pspace
,
658 get_frame_pc (frame
), sal
.symtab
, sal
.line
);
660 annotate_frame_end ();
662 gdb_flush (gdb_stdout
);
665 /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
666 corresponding to FRAME. */
669 find_frame_funname (struct frame_info
*frame
, char **funname
,
670 enum language
*funlang
, struct symbol
**funcp
)
675 *funlang
= language_unknown
;
679 func
= get_frame_function (frame
);
682 /* In certain pathological cases, the symtabs give the wrong
683 function (when we are in the first function in a file which
684 is compiled without debugging symbols, the previous function
685 is compiled with debugging symbols, and the "foo.o" symbol
686 that is supposed to tell us where the file with debugging
687 symbols ends has been truncated by ar because it is longer
688 than 15 characters). This also occurs if the user uses asm()
689 to create a function but not stabs for it (in a file compiled
692 So look in the minimal symbol tables as well, and if it comes
693 up with a larger address for the function use that instead.
694 I don't think this can ever cause any problems; there
695 shouldn't be any minimal symbols in the middle of a function;
696 if this is ever changed many parts of GDB will need to be
697 changed (and we'll create a find_pc_minimal_function or some
700 struct minimal_symbol
*msymbol
= NULL
;
702 /* Don't attempt to do this for inlined functions, which do not
703 have a corresponding minimal symbol. */
704 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
706 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
709 && (SYMBOL_VALUE_ADDRESS (msymbol
)
710 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
712 /* We also don't know anything about the function besides
713 its address and name. */
715 *funname
= SYMBOL_PRINT_NAME (msymbol
);
716 *funlang
= SYMBOL_LANGUAGE (msymbol
);
720 *funname
= SYMBOL_PRINT_NAME (func
);
721 *funlang
= SYMBOL_LANGUAGE (func
);
724 if (*funlang
== language_cplus
)
726 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
727 to display the demangled name that we already have
728 stored in the symbol table, but we stored a version
729 with DMGL_PARAMS turned on, and here we don't want to
730 display parameters. So remove the parameters. */
731 char *func_only
= cp_remove_params (*funname
);
735 *funname
= func_only
;
736 make_cleanup (xfree
, func_only
);
743 struct minimal_symbol
*msymbol
=
744 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
748 *funname
= SYMBOL_PRINT_NAME (msymbol
);
749 *funlang
= SYMBOL_LANGUAGE (msymbol
);
755 print_frame (struct frame_info
*frame
, int print_level
,
756 enum print_what print_what
, int print_args
,
757 struct symtab_and_line sal
)
759 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
760 char *funname
= NULL
;
761 enum language funlang
= language_unknown
;
762 struct ui_stream
*stb
;
763 struct cleanup
*old_chain
, *list_chain
;
764 struct value_print_options opts
;
767 stb
= ui_out_stream_new (uiout
);
768 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
770 find_frame_funname (frame
, &funname
, &funlang
, &func
);
772 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
773 gdbarch
, get_frame_pc (frame
));
775 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
779 ui_out_text (uiout
, "#");
780 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
781 frame_relative_level (frame
));
783 get_user_print_options (&opts
);
784 if (opts
.addressprint
)
785 if (frame_show_address (frame
, sal
) || !sal
.symtab
786 || print_what
== LOC_AND_ADDRESS
)
788 annotate_frame_address ();
789 ui_out_field_core_addr (uiout
, "addr", gdbarch
, get_frame_pc (frame
));
790 annotate_frame_address_end ();
791 ui_out_text (uiout
, " in ");
793 annotate_frame_function_name ();
794 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
796 ui_out_field_stream (uiout
, "func", stb
);
797 ui_out_wrap_hint (uiout
, " ");
798 annotate_frame_args ();
800 ui_out_text (uiout
, " (");
803 struct print_args_args args
;
804 struct cleanup
*args_list_chain
;
808 args
.stream
= gdb_stdout
;
809 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
810 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
811 /* FIXME: ARGS must be a list. If one argument is a string it
812 will have " that will not be properly escaped. */
813 /* Invoke ui_out_tuple_end. */
814 do_cleanups (args_list_chain
);
817 ui_out_text (uiout
, ")");
818 if (sal
.symtab
&& sal
.symtab
->filename
)
820 annotate_frame_source_begin ();
821 ui_out_wrap_hint (uiout
, " ");
822 ui_out_text (uiout
, " at ");
823 annotate_frame_source_file ();
824 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
825 if (ui_out_is_mi_like_p (uiout
))
827 const char *fullname
= symtab_to_fullname (sal
.symtab
);
829 if (fullname
!= NULL
)
830 ui_out_field_string (uiout
, "fullname", fullname
);
832 annotate_frame_source_file_end ();
833 ui_out_text (uiout
, ":");
834 annotate_frame_source_line ();
835 ui_out_field_int (uiout
, "line", sal
.line
);
836 annotate_frame_source_end ();
839 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
842 char *lib
= PC_SOLIB (get_frame_pc (frame
));
844 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
845 get_frame_pc (frame
));
849 annotate_frame_where ();
850 ui_out_wrap_hint (uiout
, " ");
851 ui_out_text (uiout
, " from ");
852 ui_out_field_string (uiout
, "from", lib
);
856 /* do_cleanups will call ui_out_tuple_end() for us. */
857 do_cleanups (list_chain
);
858 ui_out_text (uiout
, "\n");
859 do_cleanups (old_chain
);
863 /* Read a frame specification in whatever the appropriate format is
864 from FRAME_EXP. Call error(), printing MESSAGE, if the
865 specification is in any way invalid (so this function never returns
866 NULL). When SEPECTED_P is non-NULL set its target to indicate that
867 the default selected frame was used. */
869 static struct frame_info
*
870 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
871 int *selected_frame_p
)
874 struct value
*args
[4];
875 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
877 if (frame_exp
== NULL
)
885 struct cleanup
*cleanup
;
888 /* Skip leading white space, bail of EOL. */
889 while (isspace (*frame_exp
))
894 /* Parse the argument, extract it, save it. */
898 addr_string
= savestring (frame_exp
, p
- frame_exp
);
900 cleanup
= make_cleanup (xfree
, addr_string
);
902 /* NOTE: Parse and evaluate expression, but do not use
903 functions such as parse_and_eval_long or
904 parse_and_eval_address to also extract the value.
905 Instead value_as_long and value_as_address are used.
906 This avoids problems with expressions that contain
908 if (numargs
>= ARRAY_SIZE (args
))
909 error (_("Too many args in frame specification"));
910 args
[numargs
++] = parse_and_eval (addr_string
);
912 do_cleanups (cleanup
);
916 /* If no args, default to the selected frame. */
919 if (selected_frame_p
!= NULL
)
920 (*selected_frame_p
) = 1;
921 return get_selected_frame (message
);
924 /* None of the remaining use the selected frame. */
925 if (selected_frame_p
!= NULL
)
926 (*selected_frame_p
) = 0;
928 /* Assume the single arg[0] is an integer, and try using that to
929 select a frame relative to current. */
932 struct frame_info
*fid
;
933 int level
= value_as_long (args
[0]);
935 fid
= find_relative_frame (get_current_frame (), &level
);
937 /* find_relative_frame was successful. */
941 /* Convert each value into a corresponding address. */
945 for (i
= 0; i
< numargs
; i
++)
946 addrs
[i
] = value_as_address (args
[i
]);
949 /* Assume that the single arg[0] is an address, use that to identify
950 a frame with a matching ID. Should this also accept stack/pc or
954 struct frame_id id
= frame_id_build_wild (addrs
[0]);
955 struct frame_info
*fid
;
957 /* If (s)he specifies the frame with an address, he deserves
958 what (s)he gets. Still, give the highest one that matches.
959 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
961 for (fid
= get_current_frame ();
963 fid
= get_prev_frame (fid
))
965 if (frame_id_eq (id
, get_frame_id (fid
)))
967 struct frame_info
*prev_frame
;
971 prev_frame
= get_prev_frame (fid
);
973 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
982 /* We couldn't identify the frame as an existing frame, but
983 perhaps we can create one with a single argument. */
985 return create_new_frame (addrs
[0], 0);
986 else if (numargs
== 2)
987 return create_new_frame (addrs
[0], addrs
[1]);
989 error (_("Too many args in frame specification"));
992 static struct frame_info
*
993 parse_frame_specification (char *frame_exp
)
995 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
998 /* Print verbosely the selected frame or the frame at address
999 ADDR_EXP. Absolutely all information in the frame is printed. */
1002 frame_info (char *addr_exp
, int from_tty
)
1004 struct frame_info
*fi
;
1005 struct symtab_and_line sal
;
1006 struct symbol
*func
;
1008 struct frame_info
*calling_frame_info
;
1011 enum language funlang
= language_unknown
;
1012 const char *pc_regname
;
1013 int selected_frame_p
;
1014 struct gdbarch
*gdbarch
;
1015 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1017 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1018 gdbarch
= get_frame_arch (fi
);
1020 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1021 is not a good name. */
1022 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1023 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1024 easily not match that of the internal value returned by
1026 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1028 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1029 architectures will often have a hardware register called "pc",
1030 and that register's value, again, can easily not match
1034 find_frame_sal (fi
, &sal
);
1035 func
= get_frame_function (fi
);
1036 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1038 s
= find_pc_symtab (get_frame_pc (fi
));
1041 funname
= SYMBOL_PRINT_NAME (func
);
1042 funlang
= SYMBOL_LANGUAGE (func
);
1043 if (funlang
== language_cplus
)
1045 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1046 to display the demangled name that we already have
1047 stored in the symbol table, but we stored a version
1048 with DMGL_PARAMS turned on, and here we don't want to
1049 display parameters. So remove the parameters. */
1050 char *func_only
= cp_remove_params (funname
);
1054 funname
= func_only
;
1055 make_cleanup (xfree
, func_only
);
1061 struct minimal_symbol
*msymbol
;
1063 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1064 if (msymbol
!= NULL
)
1066 funname
= SYMBOL_PRINT_NAME (msymbol
);
1067 funlang
= SYMBOL_LANGUAGE (msymbol
);
1070 calling_frame_info
= get_prev_frame (fi
);
1072 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1074 printf_filtered (_("Stack level %d, frame at "),
1075 frame_relative_level (fi
));
1079 printf_filtered (_("Stack frame at "));
1081 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1082 printf_filtered (":\n");
1083 printf_filtered (" %s = ", pc_regname
);
1084 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1089 printf_filtered (" in ");
1090 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1091 DMGL_ANSI
| DMGL_PARAMS
);
1095 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1096 puts_filtered ("; ");
1098 printf_filtered ("saved %s ", pc_regname
);
1099 fputs_filtered (paddress (gdbarch
, frame_unwind_caller_pc (fi
)), gdb_stdout
);
1100 printf_filtered ("\n");
1102 if (calling_frame_info
== NULL
)
1104 enum unwind_stop_reason reason
;
1106 reason
= get_frame_unwind_stop_reason (fi
);
1107 if (reason
!= UNWIND_NO_REASON
)
1108 printf_filtered (_(" Outermost frame: %s\n"),
1109 frame_stop_reason_string (reason
));
1111 else if (get_frame_type (fi
) == INLINE_FRAME
)
1112 printf_filtered (" inlined into frame %d",
1113 frame_relative_level (get_prev_frame (fi
)));
1116 printf_filtered (" called by frame at ");
1117 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1120 if (get_next_frame (fi
) && calling_frame_info
)
1121 puts_filtered (",");
1123 if (get_next_frame (fi
))
1125 printf_filtered (" caller of frame at ");
1126 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1129 if (get_next_frame (fi
) || calling_frame_info
)
1130 puts_filtered ("\n");
1133 printf_filtered (" source language %s.\n",
1134 language_str (s
->language
));
1137 /* Address of the argument list for this frame, or 0. */
1138 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1139 /* Number of args for this frame, or -1 if unknown. */
1143 printf_filtered (" Arglist at unknown address.\n");
1146 printf_filtered (" Arglist at ");
1147 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1148 printf_filtered (",");
1150 if (!gdbarch_frame_num_args_p (gdbarch
))
1153 puts_filtered (" args: ");
1157 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1158 gdb_assert (numargs
>= 0);
1160 puts_filtered (" no args.");
1161 else if (numargs
== 1)
1162 puts_filtered (" 1 arg: ");
1164 printf_filtered (" %d args: ", numargs
);
1166 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1167 puts_filtered ("\n");
1171 /* Address of the local variables for this frame, or 0. */
1172 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1175 printf_filtered (" Locals at unknown address,");
1178 printf_filtered (" Locals at ");
1179 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1180 printf_filtered (",");
1184 /* Print as much information as possible on the location of all the
1187 enum lval_type lval
;
1196 /* The sp is special; what's displayed isn't the save address, but
1197 the value of the previous frame's sp. This is a legacy thing,
1198 at one stage the frame cached the previous frame's SP instead
1199 of its address, hence it was easiest to just display the cached
1201 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1203 /* Find out the location of the saved stack pointer with out
1204 actually evaluating it. */
1205 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1206 &optimized
, &unavailable
, &lval
, &addr
,
1208 if (!optimized
&& !unavailable
&& lval
== not_lval
)
1210 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1211 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1212 gdb_byte value
[MAX_REGISTER_SIZE
];
1215 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1216 &optimized
, &unavailable
, &lval
, &addr
,
1218 /* NOTE: cagney/2003-05-22: This is assuming that the
1219 stack pointer was packed as an unsigned integer. That
1220 may or may not be valid. */
1221 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1222 printf_filtered (" Previous frame's sp is ");
1223 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1224 printf_filtered ("\n");
1227 else if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1229 printf_filtered (" Previous frame's sp at ");
1230 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1231 printf_filtered ("\n");
1234 else if (!optimized
&& !unavailable
&& lval
== lval_register
)
1236 printf_filtered (" Previous frame's sp in %s\n",
1237 gdbarch_register_name (gdbarch
, realnum
));
1240 /* else keep quiet. */
1244 numregs
= gdbarch_num_regs (gdbarch
)
1245 + gdbarch_num_pseudo_regs (gdbarch
);
1246 for (i
= 0; i
< numregs
; i
++)
1247 if (i
!= gdbarch_sp_regnum (gdbarch
)
1248 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1250 /* Find out the location of the saved register without
1251 fetching the corresponding value. */
1252 frame_register_unwind (fi
, i
, &optimized
, &unavailable
,
1253 &lval
, &addr
, &realnum
, NULL
);
1254 /* For moment, only display registers that were saved on the
1256 if (!optimized
&& !unavailable
&& lval
== lval_memory
)
1259 puts_filtered (" Saved registers:\n ");
1261 puts_filtered (",");
1263 printf_filtered (" %s at ",
1264 gdbarch_register_name (gdbarch
, i
));
1265 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1269 if (count
|| need_nl
)
1270 puts_filtered ("\n");
1273 do_cleanups (back_to
);
1276 /* Print briefly all stack frames or just the innermost COUNT_EXP
1280 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1282 struct frame_info
*fi
;
1285 struct frame_info
*trailing
;
1288 if (!target_has_stack
)
1289 error (_("No stack."));
1291 /* The following code must do two things. First, it must set the
1292 variable TRAILING to the frame from which we should start
1293 printing. Second, it must set the variable count to the number
1294 of frames which we should print, or -1 if all of them. */
1295 trailing
= get_current_frame ();
1300 count
= parse_and_eval_long (count_exp
);
1303 struct frame_info
*current
;
1308 while (current
&& count
--)
1311 current
= get_prev_frame (current
);
1314 /* Will stop when CURRENT reaches the top of the stack.
1315 TRAILING will be COUNT below it. */
1319 trailing
= get_prev_frame (trailing
);
1320 current
= get_prev_frame (current
);
1332 /* Read in symbols for all of the frames. Need to do this in a
1333 separate pass so that "Reading in symbols for xxx" messages
1334 don't screw up the appearance of the backtrace. Also if
1335 people have strong opinions against reading symbols for
1336 backtrace this may have to be an option. */
1338 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1343 pc
= get_frame_address_in_block (fi
);
1344 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1348 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1352 /* Don't use print_stack_frame; if an error() occurs it probably
1353 means further attempts to backtrace would fail (on the other
1354 hand, perhaps the code does or could be fixed to make sure
1355 the frame->prev field gets set to NULL in that case). */
1356 print_frame_info (fi
, 1, LOCATION
, 1);
1358 print_frame_local_vars (fi
, 1, gdb_stdout
);
1360 /* Save the last frame to check for error conditions. */
1364 /* If we've stopped before the end, mention that. */
1366 printf_filtered (_("(More stack frames follow...)\n"));
1368 /* If we've run out of frames, and the reason appears to be an error
1369 condition, print it. */
1370 if (fi
== NULL
&& trailing
!= NULL
)
1372 enum unwind_stop_reason reason
;
1374 reason
= get_frame_unwind_stop_reason (trailing
);
1375 if (reason
> UNWIND_FIRST_ERROR
)
1376 printf_filtered (_("Backtrace stopped: %s\n"),
1377 frame_stop_reason_string (reason
));
1381 struct backtrace_command_args
1388 /* Stub for catch_errors. */
1391 backtrace_command_stub (void *data
)
1393 struct backtrace_command_args
*args
= data
;
1395 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1400 backtrace_command (char *arg
, int from_tty
)
1402 struct cleanup
*old_chain
= NULL
;
1403 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1404 struct backtrace_command_args btargs
;
1411 argv
= gdb_buildargv (arg
);
1412 old_chain
= make_cleanup_freeargv (argv
);
1414 for (i
= 0; argv
[i
]; i
++)
1418 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1419 argv
[i
][j
] = tolower (argv
[i
][j
]);
1421 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1422 fulltrace_arg
= argc
;
1425 arglen
+= strlen (argv
[i
]);
1430 if (fulltrace_arg
>= 0)
1434 arg
= xmalloc (arglen
+ 1);
1435 memset (arg
, 0, arglen
+ 1);
1436 for (i
= 0; i
< (argc
+ 1); i
++)
1438 if (i
!= fulltrace_arg
)
1440 strcat (arg
, argv
[i
]);
1450 btargs
.count_exp
= arg
;
1451 btargs
.show_locals
= (fulltrace_arg
>= 0);
1452 btargs
.from_tty
= from_tty
;
1453 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1455 if (fulltrace_arg
>= 0 && arglen
> 0)
1459 do_cleanups (old_chain
);
1463 backtrace_full_command (char *arg
, int from_tty
)
1465 struct backtrace_command_args btargs
;
1467 btargs
.count_exp
= arg
;
1468 btargs
.show_locals
= 1;
1469 btargs
.from_tty
= from_tty
;
1470 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1474 /* Iterate over the local variables of a block B, calling CB with
1478 iterate_over_block_locals (struct block
*b
,
1479 iterate_over_block_arg_local_vars_cb cb
,
1482 struct dict_iterator iter
;
1485 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1487 switch (SYMBOL_CLASS (sym
))
1493 if (SYMBOL_IS_ARGUMENT (sym
))
1495 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1499 /* Ignore symbols which are not locals. */
1506 /* Same, but print labels. */
1509 /* Commented out, as the code using this function has also been
1510 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1511 was commented out in the first place. The discussion introducing
1512 this change (2007-12-04: Support lexical blocks and function bodies
1513 that occupy non-contiguous address ranges) did not explain why
1514 this change was made. */
1516 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1517 int *have_default
, struct ui_file
*stream
)
1519 struct dict_iterator iter
;
1521 int values_printed
= 0;
1523 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1525 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1531 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1533 struct symtab_and_line sal
;
1534 struct value_print_options opts
;
1536 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1538 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1539 get_user_print_options (&opts
);
1540 if (opts
.addressprint
)
1542 fprintf_filtered (stream
, " ");
1543 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1546 fprintf_filtered (stream
, " in file %s, line %d\n",
1547 sal
.symtab
->filename
, sal
.line
);
1551 return values_printed
;
1555 /* Iterate over all the local variables in block B, including all its
1556 superblocks, stopping when the top-level block is reached. */
1559 iterate_over_block_local_vars (struct block
*block
,
1560 iterate_over_block_arg_local_vars_cb cb
,
1565 iterate_over_block_locals (block
, cb
, cb_data
);
1566 /* After handling the function's top-level block, stop. Don't
1567 continue to its superblock, the block of per-file
1569 if (BLOCK_FUNCTION (block
))
1571 block
= BLOCK_SUPERBLOCK (block
);
1575 /* Data to be passed around in the calls to the locals and args
1578 struct print_variable_and_value_data
1580 struct frame_info
*frame
;
1582 struct ui_file
*stream
;
1586 /* The callback for the locals and args iterators. */
1589 do_print_variable_and_value (const char *print_name
,
1593 struct print_variable_and_value_data
*p
= cb_data
;
1595 print_variable_and_value (print_name
, sym
,
1596 p
->frame
, p
->stream
, p
->num_tabs
);
1597 p
->values_printed
= 1;
1601 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1602 struct ui_file
*stream
)
1604 struct print_variable_and_value_data cb_data
;
1605 struct block
*block
;
1607 block
= get_frame_block (frame
, 0);
1610 fprintf_filtered (stream
, "No symbol table info available.\n");
1614 cb_data
.frame
= frame
;
1615 cb_data
.num_tabs
= 4 * num_tabs
;
1616 cb_data
.stream
= stream
;
1617 cb_data
.values_printed
= 0;
1619 iterate_over_block_local_vars (block
,
1620 do_print_variable_and_value
,
1623 if (!cb_data
.values_printed
)
1624 fprintf_filtered (stream
, _("No locals.\n"));
1627 /* Same, but print labels. */
1630 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1631 struct ui_file
*stream
)
1634 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1636 struct blockvector
*bl
;
1637 struct block
*block
= get_frame_block (frame
, 0);
1638 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1639 int values_printed
= 0;
1640 int index
, have_default
= 0;
1641 char *blocks_printed
;
1642 CORE_ADDR pc
= get_frame_pc (frame
);
1646 fprintf_filtered (stream
, "No symbol table info available.\n");
1650 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1651 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1652 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1656 CORE_ADDR end
= BLOCK_END (block
) - 4;
1659 if (bl
!= blockvector_for_pc (end
, &index
))
1660 error (_("blockvector blotch"));
1661 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1662 error (_("blockvector botch"));
1663 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1666 /* Don't print out blocks that have gone by. */
1667 while (index
< last_index
1668 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1671 while (index
< last_index
1672 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1674 if (blocks_printed
[index
] == 0)
1676 if (print_block_frame_labels (gdbarch
,
1677 BLOCKVECTOR_BLOCK (bl
, index
),
1678 &have_default
, stream
))
1680 blocks_printed
[index
] = 1;
1686 if (values_printed
&& this_level_only
)
1689 /* After handling the function's top-level block, stop. Don't
1690 continue to its superblock, the block of per-file symbols.
1691 Also do not continue to the containing function of an inlined
1693 if (BLOCK_FUNCTION (block
))
1695 block
= BLOCK_SUPERBLOCK (block
);
1698 if (!values_printed
&& !this_level_only
)
1699 fprintf_filtered (stream
, _("No catches.\n"));
1704 locals_info (char *args
, int from_tty
)
1706 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1711 catch_info (char *ignore
, int from_tty
)
1713 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1714 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1718 /* Iterate over all the argument variables in block B.
1720 Returns 1 if any argument was walked; 0 otherwise. */
1723 iterate_over_block_arg_vars (struct block
*b
,
1724 iterate_over_block_arg_local_vars_cb cb
,
1727 struct dict_iterator iter
;
1728 struct symbol
*sym
, *sym2
;
1730 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1732 /* Don't worry about things which aren't arguments. */
1733 if (SYMBOL_IS_ARGUMENT (sym
))
1735 /* We have to look up the symbol because arguments can have
1736 two entries (one a parameter, one a local) and the one we
1737 want is the local, which lookup_symbol will find for us.
1738 This includes gcc1 (not gcc2) on the sparc when passing a
1739 small structure and gcc2 when the argument type is float
1740 and it is passed as a double and converted to float by
1741 the prologue (in the latter case the type of the LOC_ARG
1742 symbol is double and the type of the LOC_LOCAL symbol is
1743 float). There are also LOC_ARG/LOC_REGISTER pairs which
1744 are not combined in symbol-reading. */
1746 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1747 b
, VAR_DOMAIN
, NULL
);
1748 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
1754 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1756 struct print_variable_and_value_data cb_data
;
1757 struct symbol
*func
;
1759 func
= get_frame_function (frame
);
1762 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1766 cb_data
.frame
= frame
;
1767 cb_data
.num_tabs
= 0;
1768 cb_data
.stream
= gdb_stdout
;
1769 cb_data
.values_printed
= 0;
1771 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
1772 do_print_variable_and_value
, &cb_data
);
1774 if (!cb_data
.values_printed
)
1775 fprintf_filtered (stream
, _("No arguments.\n"));
1779 args_info (char *ignore
, int from_tty
)
1781 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1787 args_plus_locals_info (char *ignore
, int from_tty
)
1789 args_info (ignore
, from_tty
);
1790 locals_info (ignore
, from_tty
);
1794 /* Select frame FRAME. Also print the stack frame and show the source
1795 if this is the tui version. */
1797 select_and_print_frame (struct frame_info
*frame
)
1799 select_frame (frame
);
1801 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1804 /* Return the symbol-block in which the selected frame is executing.
1805 Can return zero under various legitimate circumstances.
1807 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1808 code address within the block returned. We use this to decide
1809 which macros are in scope. */
1812 get_selected_block (CORE_ADDR
*addr_in_block
)
1814 if (!has_stack_frames ())
1817 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1820 /* Find a frame a certain number of levels away from FRAME.
1821 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1822 Positive means go to earlier frames (up); negative, the reverse.
1823 The int that contains the number of levels is counted toward
1824 zero as the frames for those levels are found.
1825 If the top or bottom frame is reached, that frame is returned,
1826 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1827 how much farther the original request asked to go. */
1830 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1832 /* Going up is simple: just call get_prev_frame enough times or
1833 until the initial frame is reached. */
1834 while (*level_offset_ptr
> 0)
1836 struct frame_info
*prev
= get_prev_frame (frame
);
1840 (*level_offset_ptr
)--;
1844 /* Going down is just as simple. */
1845 while (*level_offset_ptr
< 0)
1847 struct frame_info
*next
= get_next_frame (frame
);
1851 (*level_offset_ptr
)++;
1858 /* The "select_frame" command. With no argument this is a NOP.
1859 Select the frame at level LEVEL_EXP if it is a valid level.
1860 Otherwise, treat LEVEL_EXP as an address expression and select it.
1862 See parse_frame_specification for more info on proper frame
1866 select_frame_command (char *level_exp
, int from_tty
)
1868 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1871 /* The "frame" command. With no argument, print the selected frame
1872 briefly. With an argument, behave like select_frame and then print
1873 the selected frame. */
1876 frame_command (char *level_exp
, int from_tty
)
1878 select_frame_command (level_exp
, from_tty
);
1879 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1882 /* The XDB Compatibility command to print the current frame. */
1885 current_frame_command (char *level_exp
, int from_tty
)
1887 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1890 /* Select the frame up one or COUNT_EXP stack levels from the
1891 previously selected frame, and print it briefly. */
1894 up_silently_base (char *count_exp
)
1896 struct frame_info
*frame
;
1900 count
= parse_and_eval_long (count_exp
);
1902 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1903 if (count
!= 0 && count_exp
== NULL
)
1904 error (_("Initial frame selected; you cannot go up."));
1905 select_frame (frame
);
1909 up_silently_command (char *count_exp
, int from_tty
)
1911 up_silently_base (count_exp
);
1915 up_command (char *count_exp
, int from_tty
)
1917 up_silently_base (count_exp
);
1918 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1921 /* Select the frame down one or COUNT_EXP stack levels from the previously
1922 selected frame, and print it briefly. */
1925 down_silently_base (char *count_exp
)
1927 struct frame_info
*frame
;
1931 count
= -parse_and_eval_long (count_exp
);
1933 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1934 if (count
!= 0 && count_exp
== NULL
)
1936 /* We only do this if COUNT_EXP is not specified. That way
1937 "down" means to really go down (and let me know if that is
1938 impossible), but "down 9999" can be used to mean go all the
1939 way down without getting an error. */
1941 error (_("Bottom (innermost) frame selected; you cannot go down."));
1944 select_frame (frame
);
1948 down_silently_command (char *count_exp
, int from_tty
)
1950 down_silently_base (count_exp
);
1954 down_command (char *count_exp
, int from_tty
)
1956 down_silently_base (count_exp
);
1957 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1962 return_command (char *retval_exp
, int from_tty
)
1964 struct frame_info
*thisframe
;
1965 struct gdbarch
*gdbarch
;
1966 struct symbol
*thisfun
;
1967 struct value
*return_value
= NULL
;
1968 const char *query_prefix
= "";
1970 thisframe
= get_selected_frame ("No selected frame.");
1971 thisfun
= get_frame_function (thisframe
);
1972 gdbarch
= get_frame_arch (thisframe
);
1974 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
1975 error (_("Can not force return from an inlined function."));
1977 /* Compute the return value. If the computation triggers an error,
1978 let it bail. If the return type can't be handled, set
1979 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1983 struct expression
*retval_expr
= parse_expression (retval_exp
);
1984 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1985 struct type
*return_type
= NULL
;
1987 /* Compute the return value. Should the computation fail, this
1988 call throws an error. */
1989 return_value
= evaluate_expression (retval_expr
);
1991 /* Cast return value to the return type of the function. Should
1992 the cast fail, this call throws an error. */
1993 if (thisfun
!= NULL
)
1994 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1995 if (return_type
== NULL
)
1997 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1998 error (_("Return value type not available for selected "
2000 "Please use an explicit cast of the value to return."));
2001 return_type
= value_type (return_value
);
2003 do_cleanups (old_chain
);
2004 CHECK_TYPEDEF (return_type
);
2005 return_value
= value_cast (return_type
, return_value
);
2007 /* Make sure the value is fully evaluated. It may live in the
2008 stack frame we're about to pop. */
2009 if (value_lazy (return_value
))
2010 value_fetch_lazy (return_value
);
2012 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2013 /* If the return-type is "void", don't try to find the
2014 return-value's location. However, do still evaluate the
2015 return expression so that, even when the expression result
2016 is discarded, side effects such as "return i++" still
2018 return_value
= NULL
;
2019 else if (thisfun
!= NULL
2020 && using_struct_return (gdbarch
,
2021 SYMBOL_TYPE (thisfun
), return_type
))
2023 query_prefix
= "The location at which to store the "
2024 "function's return value is unknown.\n"
2025 "If you continue, the return value "
2026 "that you specified will be ignored.\n";
2027 return_value
= NULL
;
2031 /* Does an interactive user really want to do this? Include
2032 information, such as how well GDB can handle the return value, in
2033 the query message. */
2038 if (thisfun
== NULL
)
2039 confirmed
= query (_("%sMake selected stack frame return now? "),
2042 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2043 SYMBOL_PRINT_NAME (thisfun
));
2045 error (_("Not confirmed"));
2048 /* Discard the selected frame and all frames inner-to it. */
2049 frame_pop (get_selected_frame (NULL
));
2051 /* Store RETURN_VALUE in the just-returned register set. */
2052 if (return_value
!= NULL
)
2054 struct type
*return_type
= value_type (return_value
);
2055 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2056 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2058 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2060 == RETURN_VALUE_REGISTER_CONVENTION
);
2061 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2062 get_current_regcache (), NULL
/*read*/,
2063 value_contents (return_value
) /*write*/);
2066 /* If we are at the end of a call dummy now, pop the dummy frame
2068 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2069 frame_pop (get_current_frame ());
2071 /* If interactive, print the frame that is now current. */
2073 frame_command ("0", 1);
2075 select_frame_command ("0", 0);
2078 /* Sets the scope to input function name, provided that the function
2079 is within the current stack frame. */
2081 struct function_bounds
2083 CORE_ADDR low
, high
;
2087 func_command (char *arg
, int from_tty
)
2089 struct frame_info
*frame
;
2091 struct symtabs_and_lines sals
;
2094 struct function_bounds
*func_bounds
= NULL
;
2099 frame
= parse_frame_specification ("0");
2100 sals
= decode_line_spec (arg
, 1);
2101 func_bounds
= (struct function_bounds
*) xmalloc (
2102 sizeof (struct function_bounds
) * sals
.nelts
);
2103 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2105 if (sals
.sals
[i
].pc
== 0
2106 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2107 &func_bounds
[i
].low
,
2108 &func_bounds
[i
].high
) == 0)
2110 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2116 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2117 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2118 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2122 frame
= find_relative_frame (frame
, &level
);
2125 while (!found
&& level
== 0);
2128 xfree (func_bounds
);
2131 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2132 else if (frame
!= get_selected_frame (NULL
))
2133 select_and_print_frame (frame
);
2136 /* Gets the language of the current frame. */
2139 get_frame_language (void)
2141 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2145 /* We determine the current frame language by looking up its
2146 associated symtab. To retrieve this symtab, we use the frame
2147 PC. However we cannot use the frame PC as is, because it
2148 usually points to the instruction following the "call", which
2149 is sometimes the first instruction of another function. So
2150 we rely on get_frame_address_in_block(), it provides us with
2151 a PC that is guaranteed to be inside the frame's code
2153 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2154 struct symtab
*s
= find_pc_symtab (pc
);
2160 return language_unknown
;
2164 /* Provide a prototype to silence -Wmissing-prototypes. */
2165 void _initialize_stack (void);
2168 _initialize_stack (void)
2170 add_com ("return", class_stack
, return_command
, _("\
2171 Make selected stack frame return to its caller.\n\
2172 Control remains in the debugger, but when you continue\n\
2173 execution will resume in the frame above the one now selected.\n\
2174 If an argument is given, it is an expression for the value to return."));
2176 add_com ("up", class_stack
, up_command
, _("\
2177 Select and print stack frame that called this one.\n\
2178 An argument says how many frames up to go."));
2179 add_com ("up-silently", class_support
, up_silently_command
, _("\
2180 Same as the `up' command, but does not print anything.\n\
2181 This is useful in command scripts."));
2183 add_com ("down", class_stack
, down_command
, _("\
2184 Select and print stack frame called by this one.\n\
2185 An argument says how many frames down to go."));
2186 add_com_alias ("do", "down", class_stack
, 1);
2187 add_com_alias ("dow", "down", class_stack
, 1);
2188 add_com ("down-silently", class_support
, down_silently_command
, _("\
2189 Same as the `down' command, but does not print anything.\n\
2190 This is useful in command scripts."));
2192 add_com ("frame", class_stack
, frame_command
, _("\
2193 Select and print a stack frame.\nWith no argument, \
2194 print the selected stack frame. (See also \"info frame\").\n\
2195 An argument specifies the frame to select.\n\
2196 It can be a stack frame number or the address of the frame.\n\
2197 With argument, nothing is printed if input is coming from\n\
2198 a command file or a user-defined command."));
2200 add_com_alias ("f", "frame", class_stack
, 1);
2204 add_com ("L", class_stack
, current_frame_command
,
2205 _("Print the current stack frame.\n"));
2206 add_com_alias ("V", "frame", class_stack
, 1);
2208 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2209 Select a stack frame without printing anything.\n\
2210 An argument specifies the frame to select.\n\
2211 It can be a stack frame number or the address of the frame.\n"));
2213 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2214 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2215 With a negative argument, print outermost -COUNT frames.\nUse of the \
2216 'full' qualifier also prints the values of the local variables.\n"));
2217 add_com_alias ("bt", "backtrace", class_stack
, 0);
2220 add_com_alias ("t", "backtrace", class_stack
, 0);
2221 add_com ("T", class_stack
, backtrace_full_command
, _("\
2222 Print backtrace of all stack frames, or innermost COUNT frames\n\
2223 and the values of the local variables.\n\
2224 With a negative argument, print outermost -COUNT frames.\n\
2225 Usage: T <count>\n"));
2228 add_com_alias ("where", "backtrace", class_alias
, 0);
2229 add_info ("stack", backtrace_command
,
2230 _("Backtrace of the stack, or innermost COUNT frames."));
2231 add_info_alias ("s", "stack", 1);
2232 add_info ("frame", frame_info
,
2233 _("All about selected stack frame, or frame at ADDR."));
2234 add_info_alias ("f", "frame", 1);
2235 add_info ("locals", locals_info
,
2236 _("Local variables of current stack frame."));
2237 add_info ("args", args_info
,
2238 _("Argument variables of current stack frame."));
2240 add_com ("l", class_info
, args_plus_locals_info
,
2241 _("Argument and local variables of current stack frame."));
2244 add_com ("func", class_stack
, func_command
, _("\
2245 Select the stack frame that contains <func>.\n\
2246 Usage: func <name>\n"));
2248 add_info ("catch", catch_info
,
2249 _("Exceptions that can be caught in the current stack frame."));
2251 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2252 print_frame_arguments_choices
, &print_frame_arguments
,
2253 _("Set printing of non-scalar frame arguments"),
2254 _("Show printing of non-scalar frame arguments"),
2255 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2257 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2258 &disassemble_next_line
, _("\
2259 Set whether to disassemble next source line or insn when execution stops."),
2261 Show whether to disassemble next source line or insn when execution stops."),
2263 If ON, GDB will display disassembly of the next source line, in addition\n\
2264 to displaying the source line itself. If the next source line cannot\n\
2265 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2266 will display disassembly of next instruction instead of showing the\n\
2268 If AUTO, display disassembly of next instruction only if the source line\n\
2269 cannot be displayed.\n\
2270 If OFF (which is the default), never display the disassembly of the next\n\
2273 show_disassemble_next_line
,
2274 &setlist
, &showlist
);
2275 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;