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
;
1195 /* The sp is special; what's displayed isn't the save address, but
1196 the value of the previous frame's sp. This is a legacy thing,
1197 at one stage the frame cached the previous frame's SP instead
1198 of its address, hence it was easiest to just display the cached
1200 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1202 /* Find out the location of the saved stack pointer with out
1203 actually evaluating it. */
1204 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1205 &optimized
, &lval
, &addr
,
1207 if (!optimized
&& lval
== not_lval
)
1209 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1210 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1211 gdb_byte value
[MAX_REGISTER_SIZE
];
1214 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1215 &optimized
, &lval
, &addr
,
1217 /* NOTE: cagney/2003-05-22: This is assuming that the
1218 stack pointer was packed as an unsigned integer. That
1219 may or may not be valid. */
1220 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1221 printf_filtered (" Previous frame's sp is ");
1222 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1223 printf_filtered ("\n");
1226 else if (!optimized
&& lval
== lval_memory
)
1228 printf_filtered (" Previous frame's sp at ");
1229 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1230 printf_filtered ("\n");
1233 else if (!optimized
&& lval
== lval_register
)
1235 printf_filtered (" Previous frame's sp in %s\n",
1236 gdbarch_register_name (gdbarch
, realnum
));
1239 /* else keep quiet. */
1243 numregs
= gdbarch_num_regs (gdbarch
)
1244 + gdbarch_num_pseudo_regs (gdbarch
);
1245 for (i
= 0; i
< numregs
; i
++)
1246 if (i
!= gdbarch_sp_regnum (gdbarch
)
1247 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1249 /* Find out the location of the saved register without
1250 fetching the corresponding value. */
1251 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1253 /* For moment, only display registers that were saved on the
1255 if (!optimized
&& lval
== lval_memory
)
1258 puts_filtered (" Saved registers:\n ");
1260 puts_filtered (",");
1262 printf_filtered (" %s at ",
1263 gdbarch_register_name (gdbarch
, i
));
1264 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1268 if (count
|| need_nl
)
1269 puts_filtered ("\n");
1272 do_cleanups (back_to
);
1275 /* Print briefly all stack frames or just the innermost COUNT_EXP
1279 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1281 struct frame_info
*fi
;
1284 struct frame_info
*trailing
;
1287 if (!target_has_stack
)
1288 error (_("No stack."));
1290 /* The following code must do two things. First, it must set the
1291 variable TRAILING to the frame from which we should start
1292 printing. Second, it must set the variable count to the number
1293 of frames which we should print, or -1 if all of them. */
1294 trailing
= get_current_frame ();
1299 count
= parse_and_eval_long (count_exp
);
1302 struct frame_info
*current
;
1307 while (current
&& count
--)
1310 current
= get_prev_frame (current
);
1313 /* Will stop when CURRENT reaches the top of the stack.
1314 TRAILING will be COUNT below it. */
1318 trailing
= get_prev_frame (trailing
);
1319 current
= get_prev_frame (current
);
1331 /* Read in symbols for all of the frames. Need to do this in a
1332 separate pass so that "Reading in symbols for xxx" messages
1333 don't screw up the appearance of the backtrace. Also if
1334 people have strong opinions against reading symbols for
1335 backtrace this may have to be an option. */
1337 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1342 pc
= get_frame_address_in_block (fi
);
1343 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1347 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1351 /* Don't use print_stack_frame; if an error() occurs it probably
1352 means further attempts to backtrace would fail (on the other
1353 hand, perhaps the code does or could be fixed to make sure
1354 the frame->prev field gets set to NULL in that case). */
1355 print_frame_info (fi
, 1, LOCATION
, 1);
1357 print_frame_local_vars (fi
, 1, gdb_stdout
);
1359 /* Save the last frame to check for error conditions. */
1363 /* If we've stopped before the end, mention that. */
1365 printf_filtered (_("(More stack frames follow...)\n"));
1367 /* If we've run out of frames, and the reason appears to be an error
1368 condition, print it. */
1369 if (fi
== NULL
&& trailing
!= NULL
)
1371 enum unwind_stop_reason reason
;
1373 reason
= get_frame_unwind_stop_reason (trailing
);
1374 if (reason
> UNWIND_FIRST_ERROR
)
1375 printf_filtered (_("Backtrace stopped: %s\n"),
1376 frame_stop_reason_string (reason
));
1380 struct backtrace_command_args
1387 /* Stub for catch_errors. */
1390 backtrace_command_stub (void *data
)
1392 struct backtrace_command_args
*args
= data
;
1394 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1399 backtrace_command (char *arg
, int from_tty
)
1401 struct cleanup
*old_chain
= NULL
;
1402 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1403 struct backtrace_command_args btargs
;
1410 argv
= gdb_buildargv (arg
);
1411 old_chain
= make_cleanup_freeargv (argv
);
1413 for (i
= 0; argv
[i
]; i
++)
1417 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1418 argv
[i
][j
] = tolower (argv
[i
][j
]);
1420 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1421 fulltrace_arg
= argc
;
1424 arglen
+= strlen (argv
[i
]);
1429 if (fulltrace_arg
>= 0)
1433 arg
= xmalloc (arglen
+ 1);
1434 memset (arg
, 0, arglen
+ 1);
1435 for (i
= 0; i
< (argc
+ 1); i
++)
1437 if (i
!= fulltrace_arg
)
1439 strcat (arg
, argv
[i
]);
1449 btargs
.count_exp
= arg
;
1450 btargs
.show_locals
= (fulltrace_arg
>= 0);
1451 btargs
.from_tty
= from_tty
;
1452 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1454 if (fulltrace_arg
>= 0 && arglen
> 0)
1458 do_cleanups (old_chain
);
1462 backtrace_full_command (char *arg
, int from_tty
)
1464 struct backtrace_command_args btargs
;
1466 btargs
.count_exp
= arg
;
1467 btargs
.show_locals
= 1;
1468 btargs
.from_tty
= from_tty
;
1469 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1473 /* Iterate over the local variables of a block B, calling CB with
1477 iterate_over_block_locals (struct block
*b
,
1478 iterate_over_block_arg_local_vars_cb cb
,
1481 struct dict_iterator iter
;
1484 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1486 switch (SYMBOL_CLASS (sym
))
1492 if (SYMBOL_IS_ARGUMENT (sym
))
1494 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1498 /* Ignore symbols which are not locals. */
1505 /* Same, but print labels. */
1508 /* Commented out, as the code using this function has also been
1509 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1510 was commented out in the first place. The discussion introducing
1511 this change (2007-12-04: Support lexical blocks and function bodies
1512 that occupy non-contiguous address ranges) did not explain why
1513 this change was made. */
1515 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1516 int *have_default
, struct ui_file
*stream
)
1518 struct dict_iterator iter
;
1520 int values_printed
= 0;
1522 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1524 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1530 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1532 struct symtab_and_line sal
;
1533 struct value_print_options opts
;
1535 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1537 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1538 get_user_print_options (&opts
);
1539 if (opts
.addressprint
)
1541 fprintf_filtered (stream
, " ");
1542 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1545 fprintf_filtered (stream
, " in file %s, line %d\n",
1546 sal
.symtab
->filename
, sal
.line
);
1550 return values_printed
;
1554 /* Iterate over all the local variables in block B, including all its
1555 superblocks, stopping when the top-level block is reached. */
1558 iterate_over_block_local_vars (struct block
*block
,
1559 iterate_over_block_arg_local_vars_cb cb
,
1564 iterate_over_block_locals (block
, cb
, cb_data
);
1565 /* After handling the function's top-level block, stop. Don't
1566 continue to its superblock, the block of per-file
1568 if (BLOCK_FUNCTION (block
))
1570 block
= BLOCK_SUPERBLOCK (block
);
1574 /* Data to be passed around in the calls to the locals and args
1577 struct print_variable_and_value_data
1579 struct frame_info
*frame
;
1581 struct ui_file
*stream
;
1585 /* The callback for the locals and args iterators */
1588 do_print_variable_and_value (const char *print_name
,
1592 struct print_variable_and_value_data
*p
= cb_data
;
1594 print_variable_and_value (print_name
, sym
,
1595 p
->frame
, p
->stream
, p
->num_tabs
);
1596 p
->values_printed
= 1;
1600 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1601 struct ui_file
*stream
)
1603 struct print_variable_and_value_data cb_data
;
1604 struct block
*block
;
1606 block
= get_frame_block (frame
, 0);
1609 fprintf_filtered (stream
, "No symbol table info available.\n");
1613 cb_data
.frame
= frame
;
1614 cb_data
.num_tabs
= 4 * num_tabs
;
1615 cb_data
.stream
= stream
;
1616 cb_data
.values_printed
= 0;
1618 iterate_over_block_local_vars (block
,
1619 do_print_variable_and_value
,
1622 if (!cb_data
.values_printed
)
1623 fprintf_filtered (stream
, _("No locals.\n"));
1626 /* Same, but print labels. */
1629 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1630 struct ui_file
*stream
)
1633 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1635 struct blockvector
*bl
;
1636 struct block
*block
= get_frame_block (frame
, 0);
1637 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1638 int values_printed
= 0;
1639 int index
, have_default
= 0;
1640 char *blocks_printed
;
1641 CORE_ADDR pc
= get_frame_pc (frame
);
1645 fprintf_filtered (stream
, "No symbol table info available.\n");
1649 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1650 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1651 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1655 CORE_ADDR end
= BLOCK_END (block
) - 4;
1658 if (bl
!= blockvector_for_pc (end
, &index
))
1659 error (_("blockvector blotch"));
1660 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1661 error (_("blockvector botch"));
1662 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1665 /* Don't print out blocks that have gone by. */
1666 while (index
< last_index
1667 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1670 while (index
< last_index
1671 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1673 if (blocks_printed
[index
] == 0)
1675 if (print_block_frame_labels (gdbarch
,
1676 BLOCKVECTOR_BLOCK (bl
, index
),
1677 &have_default
, stream
))
1679 blocks_printed
[index
] = 1;
1685 if (values_printed
&& this_level_only
)
1688 /* After handling the function's top-level block, stop. Don't
1689 continue to its superblock, the block of per-file symbols.
1690 Also do not continue to the containing function of an inlined
1692 if (BLOCK_FUNCTION (block
))
1694 block
= BLOCK_SUPERBLOCK (block
);
1697 if (!values_printed
&& !this_level_only
)
1698 fprintf_filtered (stream
, _("No catches.\n"));
1703 locals_info (char *args
, int from_tty
)
1705 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1710 catch_info (char *ignore
, int from_tty
)
1712 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1713 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1717 /* Iterate over all the argument variables in block B.
1719 Returns 1 if any argument was walked; 0 otherwise. */
1722 iterate_over_block_arg_vars (struct block
*b
,
1723 iterate_over_block_arg_local_vars_cb cb
,
1726 struct dict_iterator iter
;
1727 struct symbol
*sym
, *sym2
;
1729 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1731 /* Don't worry about things which aren't arguments. */
1732 if (SYMBOL_IS_ARGUMENT (sym
))
1734 /* We have to look up the symbol because arguments can have
1735 two entries (one a parameter, one a local) and the one we
1736 want is the local, which lookup_symbol will find for us.
1737 This includes gcc1 (not gcc2) on the sparc when passing a
1738 small structure and gcc2 when the argument type is float
1739 and it is passed as a double and converted to float by
1740 the prologue (in the latter case the type of the LOC_ARG
1741 symbol is double and the type of the LOC_LOCAL symbol is
1742 float). There are also LOC_ARG/LOC_REGISTER pairs which
1743 are not combined in symbol-reading. */
1745 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1746 b
, VAR_DOMAIN
, NULL
);
1747 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
1753 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1755 struct print_variable_and_value_data cb_data
;
1756 struct symbol
*func
;
1758 func
= get_frame_function (frame
);
1761 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1765 cb_data
.frame
= frame
;
1766 cb_data
.num_tabs
= 0;
1767 cb_data
.stream
= gdb_stdout
;
1768 cb_data
.values_printed
= 0;
1770 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
1771 do_print_variable_and_value
, &cb_data
);
1773 if (!cb_data
.values_printed
)
1774 fprintf_filtered (stream
, _("No arguments.\n"));
1778 args_info (char *ignore
, int from_tty
)
1780 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1786 args_plus_locals_info (char *ignore
, int from_tty
)
1788 args_info (ignore
, from_tty
);
1789 locals_info (ignore
, from_tty
);
1793 /* Select frame FRAME. Also print the stack frame and show the source
1794 if this is the tui version. */
1796 select_and_print_frame (struct frame_info
*frame
)
1798 select_frame (frame
);
1800 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1803 /* Return the symbol-block in which the selected frame is executing.
1804 Can return zero under various legitimate circumstances.
1806 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1807 code address within the block returned. We use this to decide
1808 which macros are in scope. */
1811 get_selected_block (CORE_ADDR
*addr_in_block
)
1813 if (!has_stack_frames ())
1816 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1819 /* Find a frame a certain number of levels away from FRAME.
1820 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1821 Positive means go to earlier frames (up); negative, the reverse.
1822 The int that contains the number of levels is counted toward
1823 zero as the frames for those levels are found.
1824 If the top or bottom frame is reached, that frame is returned,
1825 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1826 how much farther the original request asked to go. */
1829 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1831 /* Going up is simple: just call get_prev_frame enough times or
1832 until the initial frame is reached. */
1833 while (*level_offset_ptr
> 0)
1835 struct frame_info
*prev
= get_prev_frame (frame
);
1839 (*level_offset_ptr
)--;
1843 /* Going down is just as simple. */
1844 while (*level_offset_ptr
< 0)
1846 struct frame_info
*next
= get_next_frame (frame
);
1850 (*level_offset_ptr
)++;
1857 /* The "select_frame" command. With no argument this is a NOP.
1858 Select the frame at level LEVEL_EXP if it is a valid level.
1859 Otherwise, treat LEVEL_EXP as an address expression and select it.
1861 See parse_frame_specification for more info on proper frame
1865 select_frame_command (char *level_exp
, int from_tty
)
1867 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1870 /* The "frame" command. With no argument, print the selected frame
1871 briefly. With an argument, behave like select_frame and then print
1872 the selected frame. */
1875 frame_command (char *level_exp
, int from_tty
)
1877 select_frame_command (level_exp
, from_tty
);
1878 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1881 /* The XDB Compatibility command to print the current frame. */
1884 current_frame_command (char *level_exp
, int from_tty
)
1886 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1889 /* Select the frame up one or COUNT_EXP stack levels from the
1890 previously selected frame, and print it briefly. */
1893 up_silently_base (char *count_exp
)
1895 struct frame_info
*frame
;
1899 count
= parse_and_eval_long (count_exp
);
1901 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1902 if (count
!= 0 && count_exp
== NULL
)
1903 error (_("Initial frame selected; you cannot go up."));
1904 select_frame (frame
);
1908 up_silently_command (char *count_exp
, int from_tty
)
1910 up_silently_base (count_exp
);
1914 up_command (char *count_exp
, int from_tty
)
1916 up_silently_base (count_exp
);
1917 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1920 /* Select the frame down one or COUNT_EXP stack levels from the previously
1921 selected frame, and print it briefly. */
1924 down_silently_base (char *count_exp
)
1926 struct frame_info
*frame
;
1930 count
= -parse_and_eval_long (count_exp
);
1932 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1933 if (count
!= 0 && count_exp
== NULL
)
1935 /* We only do this if COUNT_EXP is not specified. That way
1936 "down" means to really go down (and let me know if that is
1937 impossible), but "down 9999" can be used to mean go all the
1938 way down without getting an error. */
1940 error (_("Bottom (innermost) frame selected; you cannot go down."));
1943 select_frame (frame
);
1947 down_silently_command (char *count_exp
, int from_tty
)
1949 down_silently_base (count_exp
);
1953 down_command (char *count_exp
, int from_tty
)
1955 down_silently_base (count_exp
);
1956 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1961 return_command (char *retval_exp
, int from_tty
)
1963 struct frame_info
*thisframe
;
1964 struct gdbarch
*gdbarch
;
1965 struct symbol
*thisfun
;
1966 struct value
*return_value
= NULL
;
1967 const char *query_prefix
= "";
1969 thisframe
= get_selected_frame ("No selected frame.");
1970 thisfun
= get_frame_function (thisframe
);
1971 gdbarch
= get_frame_arch (thisframe
);
1973 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
1974 error (_("Can not force return from an inlined function."));
1976 /* Compute the return value. If the computation triggers an error,
1977 let it bail. If the return type can't be handled, set
1978 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1982 struct expression
*retval_expr
= parse_expression (retval_exp
);
1983 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1984 struct type
*return_type
= NULL
;
1986 /* Compute the return value. Should the computation fail, this
1987 call throws an error. */
1988 return_value
= evaluate_expression (retval_expr
);
1990 /* Cast return value to the return type of the function. Should
1991 the cast fail, this call throws an error. */
1992 if (thisfun
!= NULL
)
1993 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1994 if (return_type
== NULL
)
1996 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1997 error (_("Return value type not available for selected "
1999 "Please use an explicit cast of the value to return."));
2000 return_type
= value_type (return_value
);
2002 do_cleanups (old_chain
);
2003 CHECK_TYPEDEF (return_type
);
2004 return_value
= value_cast (return_type
, return_value
);
2006 /* Make sure the value is fully evaluated. It may live in the
2007 stack frame we're about to pop. */
2008 if (value_lazy (return_value
))
2009 value_fetch_lazy (return_value
);
2011 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
2012 /* If the return-type is "void", don't try to find the
2013 return-value's location. However, do still evaluate the
2014 return expression so that, even when the expression result
2015 is discarded, side effects such as "return i++" still
2017 return_value
= NULL
;
2018 else if (thisfun
!= NULL
2019 && using_struct_return (gdbarch
,
2020 SYMBOL_TYPE (thisfun
), return_type
))
2022 query_prefix
= "The location at which to store the "
2023 "function's return value is unknown.\n"
2024 "If you continue, the return value "
2025 "that you specified will be ignored.\n";
2026 return_value
= NULL
;
2030 /* Does an interactive user really want to do this? Include
2031 information, such as how well GDB can handle the return value, in
2032 the query message. */
2037 if (thisfun
== NULL
)
2038 confirmed
= query (_("%sMake selected stack frame return now? "),
2041 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2042 SYMBOL_PRINT_NAME (thisfun
));
2044 error (_("Not confirmed"));
2047 /* Discard the selected frame and all frames inner-to it. */
2048 frame_pop (get_selected_frame (NULL
));
2050 /* Store RETURN_VALUE in the just-returned register set. */
2051 if (return_value
!= NULL
)
2053 struct type
*return_type
= value_type (return_value
);
2054 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2055 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2057 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2059 == RETURN_VALUE_REGISTER_CONVENTION
);
2060 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2061 get_current_regcache (), NULL
/*read*/,
2062 value_contents (return_value
) /*write*/);
2065 /* If we are at the end of a call dummy now, pop the dummy frame
2067 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2068 frame_pop (get_current_frame ());
2070 /* If interactive, print the frame that is now current. */
2072 frame_command ("0", 1);
2074 select_frame_command ("0", 0);
2077 /* Sets the scope to input function name, provided that the function
2078 is within the current stack frame */
2080 struct function_bounds
2082 CORE_ADDR low
, high
;
2086 func_command (char *arg
, int from_tty
)
2088 struct frame_info
*frame
;
2090 struct symtabs_and_lines sals
;
2093 struct function_bounds
*func_bounds
= NULL
;
2098 frame
= parse_frame_specification ("0");
2099 sals
= decode_line_spec (arg
, 1);
2100 func_bounds
= (struct function_bounds
*) xmalloc (
2101 sizeof (struct function_bounds
) * sals
.nelts
);
2102 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2104 if (sals
.sals
[i
].pc
== 0
2105 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2106 &func_bounds
[i
].low
,
2107 &func_bounds
[i
].high
) == 0)
2109 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2115 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2116 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2117 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2121 frame
= find_relative_frame (frame
, &level
);
2124 while (!found
&& level
== 0);
2127 xfree (func_bounds
);
2130 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2131 else if (frame
!= get_selected_frame (NULL
))
2132 select_and_print_frame (frame
);
2135 /* Gets the language of the current frame. */
2138 get_frame_language (void)
2140 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2144 /* We determine the current frame language by looking up its
2145 associated symtab. To retrieve this symtab, we use the frame
2146 PC. However we cannot use the frame PC as is, because it
2147 usually points to the instruction following the "call", which
2148 is sometimes the first instruction of another function. So
2149 we rely on get_frame_address_in_block(), it provides us with
2150 a PC that is guaranteed to be inside the frame's code
2152 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2153 struct symtab
*s
= find_pc_symtab (pc
);
2159 return language_unknown
;
2163 /* Provide a prototype to silence -Wmissing-prototypes. */
2164 void _initialize_stack (void);
2167 _initialize_stack (void)
2169 add_com ("return", class_stack
, return_command
, _("\
2170 Make selected stack frame return to its caller.\n\
2171 Control remains in the debugger, but when you continue\n\
2172 execution will resume in the frame above the one now selected.\n\
2173 If an argument is given, it is an expression for the value to return."));
2175 add_com ("up", class_stack
, up_command
, _("\
2176 Select and print stack frame that called this one.\n\
2177 An argument says how many frames up to go."));
2178 add_com ("up-silently", class_support
, up_silently_command
, _("\
2179 Same as the `up' command, but does not print anything.\n\
2180 This is useful in command scripts."));
2182 add_com ("down", class_stack
, down_command
, _("\
2183 Select and print stack frame called by this one.\n\
2184 An argument says how many frames down to go."));
2185 add_com_alias ("do", "down", class_stack
, 1);
2186 add_com_alias ("dow", "down", class_stack
, 1);
2187 add_com ("down-silently", class_support
, down_silently_command
, _("\
2188 Same as the `down' command, but does not print anything.\n\
2189 This is useful in command scripts."));
2191 add_com ("frame", class_stack
, frame_command
, _("\
2192 Select and print a stack frame.\nWith no argument, \
2193 print the selected stack frame. (See also \"info frame\").\n\
2194 An argument specifies the frame to select.\n\
2195 It can be a stack frame number or the address of the frame.\n\
2196 With argument, nothing is printed if input is coming from\n\
2197 a command file or a user-defined command."));
2199 add_com_alias ("f", "frame", class_stack
, 1);
2203 add_com ("L", class_stack
, current_frame_command
,
2204 _("Print the current stack frame.\n"));
2205 add_com_alias ("V", "frame", class_stack
, 1);
2207 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2208 Select a stack frame without printing anything.\n\
2209 An argument specifies the frame to select.\n\
2210 It can be a stack frame number or the address of the frame.\n"));
2212 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2213 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2214 With a negative argument, print outermost -COUNT frames.\nUse of the \
2215 'full' qualifier also prints the values of the local variables.\n"));
2216 add_com_alias ("bt", "backtrace", class_stack
, 0);
2219 add_com_alias ("t", "backtrace", class_stack
, 0);
2220 add_com ("T", class_stack
, backtrace_full_command
, _("\
2221 Print backtrace of all stack frames, or innermost COUNT frames\n\
2222 and the values of the local variables.\n\
2223 With a negative argument, print outermost -COUNT frames.\n\
2224 Usage: T <count>\n"));
2227 add_com_alias ("where", "backtrace", class_alias
, 0);
2228 add_info ("stack", backtrace_command
,
2229 _("Backtrace of the stack, or innermost COUNT frames."));
2230 add_info_alias ("s", "stack", 1);
2231 add_info ("frame", frame_info
,
2232 _("All about selected stack frame, or frame at ADDR."));
2233 add_info_alias ("f", "frame", 1);
2234 add_info ("locals", locals_info
,
2235 _("Local variables of current stack frame."));
2236 add_info ("args", args_info
,
2237 _("Argument variables of current stack frame."));
2239 add_com ("l", class_info
, args_plus_locals_info
,
2240 _("Argument and local variables of current stack frame."));
2243 add_com ("func", class_stack
, func_command
, _("\
2244 Select the stack frame that contains <func>.\n\
2245 Usage: func <name>\n"));
2247 add_info ("catch", catch_info
,
2248 _("Exceptions that can be caught in the current stack frame."));
2250 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2251 print_frame_arguments_choices
, &print_frame_arguments
,
2252 _("Set printing of non-scalar frame arguments"),
2253 _("Show printing of non-scalar frame arguments"),
2254 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2256 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2257 &disassemble_next_line
, _("\
2258 Set whether to disassemble next source line or insn when execution stops."),
2260 Show whether to disassemble next source line or insn when execution stops."),
2262 If ON, GDB will display disassembly of the next source line, in addition\n\
2263 to displaying the source line itself. If the next source line cannot\n\
2264 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2265 will display disassembly of next instruction instead of showing the\n\
2267 If AUTO, display disassembly of next instruction only if the source line\n\
2268 cannot be displayed.\n\
2269 If OFF (which is the default), never display the disassembly of the next\n\
2272 show_disassemble_next_line
,
2273 &setlist
, &showlist
);
2274 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;