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 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
))
290 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
291 b
, VAR_DOMAIN
, NULL
);
292 gdb_assert (nsym
!= NULL
);
293 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
294 && !SYMBOL_IS_ARGUMENT (nsym
))
296 /* There is a LOC_ARG/LOC_REGISTER pair. This means
297 that it was passed on the stack and loaded into a
298 register, or passed in a register and stored in a
299 stack slot. GDB 3.x used the LOC_ARG; GDB
300 4.0-4.11 used the LOC_REGISTER.
302 Reasons for using the LOC_ARG:
304 (1) Because find_saved_registers may be slow for
307 (2) Because registers are often re-used and stack
308 slots rarely (never?) are. Therefore using
309 the stack slot is much less likely to print
312 Reasons why we might want to use the LOC_REGISTER:
314 (1) So that the backtrace prints the same value
315 as "print foo". I see no compelling reason
316 why this needs to be the case; having the
317 backtrace print the value which was passed
318 in, and "print foo" print the value as
319 modified within the called function, makes
322 Additional note: It might be nice if "info args"
323 displayed both values.
325 One more note: There is a case with SPARC
326 structure passing where we need to use the
327 LOC_REGISTER, but this is dealt with by creating
328 a single LOC_REGPARM in symbol reading. */
330 /* Leave sym (the LOC_ARG) alone. */
337 /* Print the current arg. */
339 ui_out_text (uiout
, ", ");
340 ui_out_wrap_hint (uiout
, " ");
342 annotate_arg_begin ();
344 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
345 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
346 SYMBOL_LANGUAGE (sym
),
347 DMGL_PARAMS
| DMGL_ANSI
);
348 ui_out_field_stream (uiout
, "name", stb
);
349 annotate_arg_name_end ();
350 ui_out_text (uiout
, "=");
354 /* Avoid value_print because it will deref ref parameters.
355 We just want to print their addresses. Print ??? for
356 args whose address we do not know. We pass 2 as
357 "recurse" to val_print because our standard indentation
358 here is 4 spaces, and val_print indents 2 for each
360 val
= read_var_value (sym
, frame
);
362 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
366 const struct language_defn
*language
;
367 struct value_print_options opts
;
369 /* Use the appropriate language to display our symbol,
370 unless the user forced the language to a specific
372 if (language_mode
== language_mode_auto
)
373 language
= language_def (SYMBOL_LANGUAGE (sym
));
375 language
= current_language
;
377 get_raw_print_options (&opts
);
379 opts
.summary
= summary
;
380 common_val_print (val
, stb
->stream
, 2, &opts
, language
);
381 ui_out_field_stream (uiout
, "value", stb
);
384 ui_out_text (uiout
, "???");
387 ui_out_text (uiout
, "...");
390 /* Invoke ui_out_tuple_end. */
391 do_cleanups (list_chain
);
399 /* Don't print nameless args in situations where we don't know
400 enough about the stack to find them. */
405 if (highest_offset
== -1)
406 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
408 start
= highest_offset
;
410 print_frame_nameless_args (frame
, start
, num
- args_printed
,
414 do_cleanups (old_chain
);
417 /* Stub for catch_errors. */
420 print_args_stub (void *args
)
422 struct print_args_args
*p
= args
;
423 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
426 if (gdbarch_frame_num_args_p (gdbarch
))
428 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
429 gdb_assert (numargs
>= 0);
433 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
437 /* Set the current source and line to the location given by frame
438 FRAME, if possible. When CENTER is true, adjust so the relevant
439 line is in the center of the next 'list'. */
442 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
444 struct symtab_and_line sal
;
446 find_frame_sal (frame
, &sal
);
450 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
451 set_current_source_symtab_and_line (&sal
);
455 /* If ON, GDB will display disassembly of the next source line when
456 execution of the program being debugged stops.
457 If AUTO (which is the default), or there's no line info to determine
458 the source line of the next instruction, display disassembly of next
459 instruction instead. */
461 static enum auto_boolean disassemble_next_line
;
464 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
465 struct cmd_list_element
*c
,
468 fprintf_filtered (file
, _("\
469 Debugger's willingness to use disassemble-next-line is %s.\n"),
473 /* Show assembly codes; stub for catch_errors. */
475 struct gdb_disassembly_stub_args
477 struct gdbarch
*gdbarch
;
484 gdb_disassembly_stub (void *args
)
486 struct gdb_disassembly_stub_args
*p
= args
;
488 gdb_disassembly (p
->gdbarch
, uiout
, 0,
489 DISASSEMBLY_RAW_INSN
, p
->how_many
,
493 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
494 because it will be broken by filter sometime. */
497 do_gdb_disassembly (struct gdbarch
*gdbarch
,
498 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
500 volatile struct gdb_exception exception
;
501 struct gdb_disassembly_stub_args args
;
503 args
.gdbarch
= gdbarch
;
504 args
.how_many
= how_many
;
507 TRY_CATCH (exception
, RETURN_MASK_ALL
)
509 gdb_disassembly_stub (&args
);
511 /* If an exception was thrown while doing the disassembly, print
512 the error message, to give the user a clue of what happened. */
513 if (exception
.reason
== RETURN_ERROR
)
514 exception_print (gdb_stderr
, exception
);
517 /* Print information about frame FRAME. The output is format according
518 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
521 SRC_LINE: Print only source line.
522 LOCATION: Print only location.
523 LOC_AND_SRC: Print location and source line.
525 Used in "where" output, and to emit breakpoint or step
529 print_frame_info (struct frame_info
*frame
, int print_level
,
530 enum print_what print_what
, int print_args
)
532 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
533 struct symtab_and_line sal
;
537 if (get_frame_type (frame
) == DUMMY_FRAME
538 || get_frame_type (frame
) == SIGTRAMP_FRAME
539 || get_frame_type (frame
) == ARCH_FRAME
)
541 struct cleanup
*uiout_cleanup
542 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
544 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
545 gdbarch
, get_frame_pc (frame
));
547 /* Do this regardless of SOURCE because we don't have any source
548 to list for this frame. */
551 ui_out_text (uiout
, "#");
552 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
553 frame_relative_level (frame
));
555 if (ui_out_is_mi_like_p (uiout
))
557 annotate_frame_address ();
558 ui_out_field_core_addr (uiout
, "addr",
559 gdbarch
, get_frame_pc (frame
));
560 annotate_frame_address_end ();
563 if (get_frame_type (frame
) == DUMMY_FRAME
)
565 annotate_function_call ();
566 ui_out_field_string (uiout
, "func", "<function called from gdb>");
568 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
570 annotate_signal_handler_caller ();
571 ui_out_field_string (uiout
, "func", "<signal handler called>");
573 else if (get_frame_type (frame
) == ARCH_FRAME
)
575 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
577 ui_out_text (uiout
, "\n");
578 annotate_frame_end ();
580 do_cleanups (uiout_cleanup
);
584 /* If FRAME is not the innermost frame, that normally means that
585 FRAME->pc points to *after* the call instruction, and we want to
586 get the line containing the call, never the next line. But if
587 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
588 next frame was not entered as the result of a call, and we want
589 to get the line containing FRAME->pc. */
590 find_frame_sal (frame
, &sal
);
592 location_print
= (print_what
== LOCATION
593 || print_what
== LOC_AND_ADDRESS
594 || print_what
== SRC_AND_LOC
);
596 if (location_print
|| !sal
.symtab
)
597 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
599 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
601 /* If disassemble-next-line is set to auto or on and doesn't have
602 the line debug messages for $pc, output the next instruction. */
603 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
604 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
605 && source_print
&& !sal
.symtab
)
606 do_gdb_disassembly (get_frame_arch (frame
), 1,
607 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
609 if (source_print
&& sal
.symtab
)
612 int mid_statement
= ((print_what
== SRC_LINE
)
613 && frame_show_address (frame
, sal
));
615 if (annotation_level
)
616 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
617 get_frame_pc (frame
));
620 if (deprecated_print_frame_info_listing_hook
)
621 deprecated_print_frame_info_listing_hook (sal
.symtab
,
626 struct value_print_options opts
;
627 get_user_print_options (&opts
);
628 /* We used to do this earlier, but that is clearly
629 wrong. This function is used by many different
630 parts of gdb, including normal_stop in infrun.c,
631 which uses this to print out the current PC
632 when we stepi/nexti into the middle of a source
633 line. Only the command line really wants this
634 behavior. Other UIs probably would like the
635 ability to decide for themselves if it is desired. */
636 if (opts
.addressprint
&& mid_statement
)
638 ui_out_field_core_addr (uiout
, "addr",
639 gdbarch
, get_frame_pc (frame
));
640 ui_out_text (uiout
, "\t");
643 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
647 /* If disassemble-next-line is set to on and there is line debug
648 messages, output assembly codes for next line. */
649 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
650 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
653 if (print_what
!= LOCATION
)
654 set_default_breakpoint (1, sal
.pspace
,
655 get_frame_pc (frame
), sal
.symtab
, sal
.line
);
657 annotate_frame_end ();
659 gdb_flush (gdb_stdout
);
662 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
665 find_frame_funname (struct frame_info
*frame
, char **funname
,
666 enum language
*funlang
)
671 *funlang
= language_unknown
;
673 func
= get_frame_function (frame
);
676 /* In certain pathological cases, the symtabs give the wrong
677 function (when we are in the first function in a file which
678 is compiled without debugging symbols, the previous function
679 is compiled with debugging symbols, and the "foo.o" symbol
680 that is supposed to tell us where the file with debugging
681 symbols ends has been truncated by ar because it is longer
682 than 15 characters). This also occurs if the user uses asm()
683 to create a function but not stabs for it (in a file compiled
686 So look in the minimal symbol tables as well, and if it comes
687 up with a larger address for the function use that instead.
688 I don't think this can ever cause any problems; there
689 shouldn't be any minimal symbols in the middle of a function;
690 if this is ever changed many parts of GDB will need to be
691 changed (and we'll create a find_pc_minimal_function or some
694 struct minimal_symbol
*msymbol
= NULL
;
696 /* Don't attempt to do this for inlined functions, which do not
697 have a corresponding minimal symbol. */
698 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
700 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
703 && (SYMBOL_VALUE_ADDRESS (msymbol
)
704 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
706 /* We also don't know anything about the function besides
707 its address and name. */
709 *funname
= SYMBOL_PRINT_NAME (msymbol
);
710 *funlang
= SYMBOL_LANGUAGE (msymbol
);
714 *funname
= SYMBOL_PRINT_NAME (func
);
715 *funlang
= SYMBOL_LANGUAGE (func
);
716 if (*funlang
== language_cplus
)
718 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
719 to display the demangled name that we already have
720 stored in the symbol table, but we stored a version
721 with DMGL_PARAMS turned on, and here we don't want to
722 display parameters. So remove the parameters. */
723 char *func_only
= cp_remove_params (*funname
);
726 *funname
= func_only
;
727 make_cleanup (xfree
, func_only
);
734 struct minimal_symbol
*msymbol
=
735 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
739 *funname
= SYMBOL_PRINT_NAME (msymbol
);
740 *funlang
= SYMBOL_LANGUAGE (msymbol
);
746 print_frame (struct frame_info
*frame
, int print_level
,
747 enum print_what print_what
, int print_args
,
748 struct symtab_and_line sal
)
750 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
751 char *funname
= NULL
;
752 enum language funlang
= language_unknown
;
753 struct ui_stream
*stb
;
754 struct cleanup
*old_chain
, *list_chain
;
755 struct value_print_options opts
;
757 stb
= ui_out_stream_new (uiout
);
758 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
760 find_frame_funname (frame
, &funname
, &funlang
);
762 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
763 gdbarch
, get_frame_pc (frame
));
765 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
769 ui_out_text (uiout
, "#");
770 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
771 frame_relative_level (frame
));
773 get_user_print_options (&opts
);
774 if (opts
.addressprint
)
775 if (frame_show_address (frame
, sal
) || !sal
.symtab
776 || print_what
== LOC_AND_ADDRESS
)
778 annotate_frame_address ();
779 ui_out_field_core_addr (uiout
, "addr", gdbarch
, get_frame_pc (frame
));
780 annotate_frame_address_end ();
781 ui_out_text (uiout
, " in ");
783 annotate_frame_function_name ();
784 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
786 ui_out_field_stream (uiout
, "func", stb
);
787 ui_out_wrap_hint (uiout
, " ");
788 annotate_frame_args ();
790 ui_out_text (uiout
, " (");
793 struct print_args_args args
;
794 struct cleanup
*args_list_chain
;
796 args
.func
= find_pc_function (get_frame_address_in_block (frame
));
797 args
.stream
= gdb_stdout
;
798 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
799 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
800 /* FIXME: ARGS must be a list. If one argument is a string it
801 will have " that will not be properly escaped. */
802 /* Invoke ui_out_tuple_end. */
803 do_cleanups (args_list_chain
);
806 ui_out_text (uiout
, ")");
807 if (sal
.symtab
&& sal
.symtab
->filename
)
809 annotate_frame_source_begin ();
810 ui_out_wrap_hint (uiout
, " ");
811 ui_out_text (uiout
, " at ");
812 annotate_frame_source_file ();
813 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
814 if (ui_out_is_mi_like_p (uiout
))
816 const char *fullname
= symtab_to_fullname (sal
.symtab
);
817 if (fullname
!= NULL
)
818 ui_out_field_string (uiout
, "fullname", fullname
);
820 annotate_frame_source_file_end ();
821 ui_out_text (uiout
, ":");
822 annotate_frame_source_line ();
823 ui_out_field_int (uiout
, "line", sal
.line
);
824 annotate_frame_source_end ();
827 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
830 char *lib
= PC_SOLIB (get_frame_pc (frame
));
832 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
833 get_frame_pc (frame
));
837 annotate_frame_where ();
838 ui_out_wrap_hint (uiout
, " ");
839 ui_out_text (uiout
, " from ");
840 ui_out_field_string (uiout
, "from", lib
);
844 /* do_cleanups will call ui_out_tuple_end() for us. */
845 do_cleanups (list_chain
);
846 ui_out_text (uiout
, "\n");
847 do_cleanups (old_chain
);
851 /* Read a frame specification in whatever the appropriate format is
852 from FRAME_EXP. Call error(), printing MESSAGE, if the
853 specification is in any way invalid (so this function never returns
854 NULL). When SEPECTED_P is non-NULL set its target to indicate that
855 the default selected frame was used. */
857 static struct frame_info
*
858 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
859 int *selected_frame_p
)
862 struct value
*args
[4];
863 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
865 if (frame_exp
== NULL
)
873 struct cleanup
*cleanup
;
876 /* Skip leading white space, bail of EOL. */
877 while (isspace (*frame_exp
))
882 /* Parse the argument, extract it, save it. */
886 addr_string
= savestring (frame_exp
, p
- frame_exp
);
888 cleanup
= make_cleanup (xfree
, addr_string
);
890 /* NOTE: Parse and evaluate expression, but do not use
891 functions such as parse_and_eval_long or
892 parse_and_eval_address to also extract the value.
893 Instead value_as_long and value_as_address are used.
894 This avoids problems with expressions that contain
896 if (numargs
>= ARRAY_SIZE (args
))
897 error (_("Too many args in frame specification"));
898 args
[numargs
++] = parse_and_eval (addr_string
);
900 do_cleanups (cleanup
);
904 /* If no args, default to the selected frame. */
907 if (selected_frame_p
!= NULL
)
908 (*selected_frame_p
) = 1;
909 return get_selected_frame (message
);
912 /* None of the remaining use the selected frame. */
913 if (selected_frame_p
!= NULL
)
914 (*selected_frame_p
) = 0;
916 /* Assume the single arg[0] is an integer, and try using that to
917 select a frame relative to current. */
920 struct frame_info
*fid
;
921 int level
= value_as_long (args
[0]);
922 fid
= find_relative_frame (get_current_frame (), &level
);
924 /* find_relative_frame was successful */
928 /* Convert each value into a corresponding address. */
931 for (i
= 0; i
< numargs
; i
++)
932 addrs
[i
] = value_as_address (args
[i
]);
935 /* Assume that the single arg[0] is an address, use that to identify
936 a frame with a matching ID. Should this also accept stack/pc or
940 struct frame_id id
= frame_id_build_wild (addrs
[0]);
941 struct frame_info
*fid
;
943 /* If (s)he specifies the frame with an address, he deserves
944 what (s)he gets. Still, give the highest one that matches.
945 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
947 for (fid
= get_current_frame ();
949 fid
= get_prev_frame (fid
))
951 if (frame_id_eq (id
, get_frame_id (fid
)))
953 struct frame_info
*prev_frame
;
957 prev_frame
= get_prev_frame (fid
);
959 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
968 /* We couldn't identify the frame as an existing frame, but
969 perhaps we can create one with a single argument. */
971 return create_new_frame (addrs
[0], 0);
972 else if (numargs
== 2)
973 return create_new_frame (addrs
[0], addrs
[1]);
975 error (_("Too many args in frame specification"));
978 static struct frame_info
*
979 parse_frame_specification (char *frame_exp
)
981 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
984 /* Print verbosely the selected frame or the frame at address
985 ADDR_EXP. Absolutely all information in the frame is printed. */
988 frame_info (char *addr_exp
, int from_tty
)
990 struct frame_info
*fi
;
991 struct symtab_and_line sal
;
994 struct frame_info
*calling_frame_info
;
997 enum language funlang
= language_unknown
;
998 const char *pc_regname
;
999 int selected_frame_p
;
1000 struct gdbarch
*gdbarch
;
1001 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1003 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1004 gdbarch
= get_frame_arch (fi
);
1006 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1007 is not a good name. */
1008 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1009 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1010 easily not match that of the internal value returned by
1012 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1014 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1015 architectures will often have a hardware register called "pc",
1016 and that register's value, again, can easily not match
1020 find_frame_sal (fi
, &sal
);
1021 func
= get_frame_function (fi
);
1022 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1024 s
= find_pc_symtab (get_frame_pc (fi
));
1027 funname
= SYMBOL_PRINT_NAME (func
);
1028 funlang
= SYMBOL_LANGUAGE (func
);
1029 if (funlang
== language_cplus
)
1031 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1032 to display the demangled name that we already have
1033 stored in the symbol table, but we stored a version
1034 with DMGL_PARAMS turned on, and here we don't want to
1035 display parameters. So remove the parameters. */
1036 char *func_only
= cp_remove_params (funname
);
1039 funname
= func_only
;
1040 make_cleanup (xfree
, func_only
);
1046 struct minimal_symbol
*msymbol
;
1048 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1049 if (msymbol
!= NULL
)
1051 funname
= SYMBOL_PRINT_NAME (msymbol
);
1052 funlang
= SYMBOL_LANGUAGE (msymbol
);
1055 calling_frame_info
= get_prev_frame (fi
);
1057 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1059 printf_filtered (_("Stack level %d, frame at "),
1060 frame_relative_level (fi
));
1064 printf_filtered (_("Stack frame at "));
1066 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1067 printf_filtered (":\n");
1068 printf_filtered (" %s = ", pc_regname
);
1069 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1074 printf_filtered (" in ");
1075 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1076 DMGL_ANSI
| DMGL_PARAMS
);
1080 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1081 puts_filtered ("; ");
1083 printf_filtered ("saved %s ", pc_regname
);
1084 fputs_filtered (paddress (gdbarch
, frame_unwind_caller_pc (fi
)), gdb_stdout
);
1085 printf_filtered ("\n");
1087 if (calling_frame_info
== NULL
)
1089 enum unwind_stop_reason reason
;
1091 reason
= get_frame_unwind_stop_reason (fi
);
1092 if (reason
!= UNWIND_NO_REASON
)
1093 printf_filtered (_(" Outermost frame: %s\n"),
1094 frame_stop_reason_string (reason
));
1096 else if (get_frame_type (fi
) == INLINE_FRAME
)
1097 printf_filtered (" inlined into frame %d",
1098 frame_relative_level (get_prev_frame (fi
)));
1101 printf_filtered (" called by frame at ");
1102 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1105 if (get_next_frame (fi
) && calling_frame_info
)
1106 puts_filtered (",");
1108 if (get_next_frame (fi
))
1110 printf_filtered (" caller of frame at ");
1111 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1114 if (get_next_frame (fi
) || calling_frame_info
)
1115 puts_filtered ("\n");
1118 printf_filtered (" source language %s.\n",
1119 language_str (s
->language
));
1122 /* Address of the argument list for this frame, or 0. */
1123 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1124 /* Number of args for this frame, or -1 if unknown. */
1128 printf_filtered (" Arglist at unknown address.\n");
1131 printf_filtered (" Arglist at ");
1132 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1133 printf_filtered (",");
1135 if (!gdbarch_frame_num_args_p (gdbarch
))
1138 puts_filtered (" args: ");
1142 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1143 gdb_assert (numargs
>= 0);
1145 puts_filtered (" no args.");
1146 else if (numargs
== 1)
1147 puts_filtered (" 1 arg: ");
1149 printf_filtered (" %d args: ", numargs
);
1151 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1152 puts_filtered ("\n");
1156 /* Address of the local variables for this frame, or 0. */
1157 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1160 printf_filtered (" Locals at unknown address,");
1163 printf_filtered (" Locals at ");
1164 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1165 printf_filtered (",");
1169 /* Print as much information as possible on the location of all the
1172 enum lval_type lval
;
1180 /* The sp is special; what's displayed isn't the save address, but
1181 the value of the previous frame's sp. This is a legacy thing,
1182 at one stage the frame cached the previous frame's SP instead
1183 of its address, hence it was easiest to just display the cached
1185 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1187 /* Find out the location of the saved stack pointer with out
1188 actually evaluating it. */
1189 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1190 &optimized
, &lval
, &addr
,
1192 if (!optimized
&& lval
== not_lval
)
1194 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1195 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1196 gdb_byte value
[MAX_REGISTER_SIZE
];
1198 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1199 &optimized
, &lval
, &addr
,
1201 /* NOTE: cagney/2003-05-22: This is assuming that the
1202 stack pointer was packed as an unsigned integer. That
1203 may or may not be valid. */
1204 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1205 printf_filtered (" Previous frame's sp is ");
1206 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1207 printf_filtered ("\n");
1210 else if (!optimized
&& lval
== lval_memory
)
1212 printf_filtered (" Previous frame's sp at ");
1213 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1214 printf_filtered ("\n");
1217 else if (!optimized
&& lval
== lval_register
)
1219 printf_filtered (" Previous frame's sp in %s\n",
1220 gdbarch_register_name (gdbarch
, realnum
));
1223 /* else keep quiet. */
1227 numregs
= gdbarch_num_regs (gdbarch
)
1228 + gdbarch_num_pseudo_regs (gdbarch
);
1229 for (i
= 0; i
< numregs
; i
++)
1230 if (i
!= gdbarch_sp_regnum (gdbarch
)
1231 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1233 /* Find out the location of the saved register without
1234 fetching the corresponding value. */
1235 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1237 /* For moment, only display registers that were saved on the
1239 if (!optimized
&& lval
== lval_memory
)
1242 puts_filtered (" Saved registers:\n ");
1244 puts_filtered (",");
1246 printf_filtered (" %s at ",
1247 gdbarch_register_name (gdbarch
, i
));
1248 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1252 if (count
|| need_nl
)
1253 puts_filtered ("\n");
1256 do_cleanups (back_to
);
1259 /* Print briefly all stack frames or just the innermost COUNT_EXP
1263 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1265 struct frame_info
*fi
;
1268 struct frame_info
*trailing
;
1271 if (!target_has_stack
)
1272 error (_("No stack."));
1274 /* The following code must do two things. First, it must set the
1275 variable TRAILING to the frame from which we should start
1276 printing. Second, it must set the variable count to the number
1277 of frames which we should print, or -1 if all of them. */
1278 trailing
= get_current_frame ();
1283 count
= parse_and_eval_long (count_exp
);
1286 struct frame_info
*current
;
1291 while (current
&& count
--)
1294 current
= get_prev_frame (current
);
1297 /* Will stop when CURRENT reaches the top of the stack.
1298 TRAILING will be COUNT below it. */
1302 trailing
= get_prev_frame (trailing
);
1303 current
= get_prev_frame (current
);
1315 /* Read in symbols for all of the frames. Need to do this in a
1316 separate pass so that "Reading in symbols for xxx" messages
1317 don't screw up the appearance of the backtrace. Also if
1318 people have strong opinions against reading symbols for
1319 backtrace this may have to be an option. */
1321 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1325 pc
= get_frame_address_in_block (fi
);
1326 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1330 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1334 /* Don't use print_stack_frame; if an error() occurs it probably
1335 means further attempts to backtrace would fail (on the other
1336 hand, perhaps the code does or could be fixed to make sure
1337 the frame->prev field gets set to NULL in that case). */
1338 print_frame_info (fi
, 1, LOCATION
, 1);
1340 print_frame_local_vars (fi
, 1, gdb_stdout
);
1342 /* Save the last frame to check for error conditions. */
1346 /* If we've stopped before the end, mention that. */
1348 printf_filtered (_("(More stack frames follow...)\n"));
1350 /* If we've run out of frames, and the reason appears to be an error
1351 condition, print it. */
1352 if (fi
== NULL
&& trailing
!= NULL
)
1354 enum unwind_stop_reason reason
;
1356 reason
= get_frame_unwind_stop_reason (trailing
);
1357 if (reason
> UNWIND_FIRST_ERROR
)
1358 printf_filtered (_("Backtrace stopped: %s\n"),
1359 frame_stop_reason_string (reason
));
1363 struct backtrace_command_args
1370 /* Stub for catch_errors. */
1373 backtrace_command_stub (void *data
)
1375 struct backtrace_command_args
*args
= data
;
1377 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1382 backtrace_command (char *arg
, int from_tty
)
1384 struct cleanup
*old_chain
= NULL
;
1385 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1386 struct backtrace_command_args btargs
;
1393 argv
= gdb_buildargv (arg
);
1394 old_chain
= make_cleanup_freeargv (argv
);
1396 for (i
= 0; argv
[i
]; i
++)
1400 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1401 argv
[i
][j
] = tolower (argv
[i
][j
]);
1403 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1404 fulltrace_arg
= argc
;
1407 arglen
+= strlen (argv
[i
]);
1412 if (fulltrace_arg
>= 0)
1416 arg
= xmalloc (arglen
+ 1);
1417 memset (arg
, 0, arglen
+ 1);
1418 for (i
= 0; i
< (argc
+ 1); i
++)
1420 if (i
!= fulltrace_arg
)
1422 strcat (arg
, argv
[i
]);
1432 btargs
.count_exp
= arg
;
1433 btargs
.show_locals
= (fulltrace_arg
>= 0);
1434 btargs
.from_tty
= from_tty
;
1435 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1437 if (fulltrace_arg
>= 0 && arglen
> 0)
1441 do_cleanups (old_chain
);
1445 backtrace_full_command (char *arg
, int from_tty
)
1447 struct backtrace_command_args btargs
;
1449 btargs
.count_exp
= arg
;
1450 btargs
.show_locals
= 1;
1451 btargs
.from_tty
= from_tty
;
1452 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1456 /* Iterate over the local variables of a block B, calling CB with
1460 iterate_over_block_locals (struct block
*b
,
1461 iterate_over_block_arg_local_vars_cb cb
,
1464 struct dict_iterator iter
;
1467 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1469 switch (SYMBOL_CLASS (sym
))
1475 if (SYMBOL_IS_ARGUMENT (sym
))
1477 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym
, cb_data
);
1481 /* Ignore symbols which are not locals. */
1488 /* Same, but print labels. */
1491 /* Commented out, as the code using this function has also been
1492 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1493 was commented out in the first place. The discussion introducing
1494 this change (2007-12-04: Support lexical blocks and function bodies
1495 that occupy non-contiguous address ranges) did not explain why
1496 this change was made. */
1498 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1499 int *have_default
, struct ui_file
*stream
)
1501 struct dict_iterator iter
;
1503 int values_printed
= 0;
1505 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1507 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1513 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1515 struct symtab_and_line sal
;
1516 struct value_print_options opts
;
1517 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1519 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1520 get_user_print_options (&opts
);
1521 if (opts
.addressprint
)
1523 fprintf_filtered (stream
, " ");
1524 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1527 fprintf_filtered (stream
, " in file %s, line %d\n",
1528 sal
.symtab
->filename
, sal
.line
);
1532 return values_printed
;
1536 /* Iterate over all the local variables in block B, including all its
1537 superblocks, stopping when the top-level block is reached. */
1540 iterate_over_block_local_vars (struct block
*block
,
1541 iterate_over_block_arg_local_vars_cb cb
,
1546 iterate_over_block_locals (block
, cb
, cb_data
);
1547 /* After handling the function's top-level block, stop. Don't
1548 continue to its superblock, the block of per-file
1550 if (BLOCK_FUNCTION (block
))
1552 block
= BLOCK_SUPERBLOCK (block
);
1556 /* Data to be passed around in the calls to the locals and args
1559 struct print_variable_and_value_data
1561 struct frame_info
*frame
;
1563 struct ui_file
*stream
;
1567 /* The callback for the locals and args iterators */
1570 do_print_variable_and_value (const char *print_name
,
1574 struct print_variable_and_value_data
*p
= cb_data
;
1576 print_variable_and_value (print_name
, sym
,
1577 p
->frame
, p
->stream
, p
->num_tabs
);
1578 p
->values_printed
= 1;
1582 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1583 struct ui_file
*stream
)
1585 struct print_variable_and_value_data cb_data
;
1586 struct block
*block
;
1588 block
= get_frame_block (frame
, 0);
1591 fprintf_filtered (stream
, "No symbol table info available.\n");
1595 cb_data
.frame
= frame
;
1596 cb_data
.num_tabs
= 4 * num_tabs
;
1597 cb_data
.stream
= stream
;
1598 cb_data
.values_printed
= 0;
1600 iterate_over_block_local_vars (block
,
1601 do_print_variable_and_value
,
1604 if (!cb_data
.values_printed
)
1605 fprintf_filtered (stream
, _("No locals.\n"));
1608 /* Same, but print labels. */
1611 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1612 struct ui_file
*stream
)
1615 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1617 struct blockvector
*bl
;
1618 struct block
*block
= get_frame_block (frame
, 0);
1619 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1620 int values_printed
= 0;
1621 int index
, have_default
= 0;
1622 char *blocks_printed
;
1623 CORE_ADDR pc
= get_frame_pc (frame
);
1627 fprintf_filtered (stream
, "No symbol table info available.\n");
1631 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1632 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1633 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1637 CORE_ADDR end
= BLOCK_END (block
) - 4;
1640 if (bl
!= blockvector_for_pc (end
, &index
))
1641 error (_("blockvector blotch"));
1642 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1643 error (_("blockvector botch"));
1644 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1647 /* Don't print out blocks that have gone by. */
1648 while (index
< last_index
1649 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1652 while (index
< last_index
1653 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1655 if (blocks_printed
[index
] == 0)
1657 if (print_block_frame_labels (gdbarch
,
1658 BLOCKVECTOR_BLOCK (bl
, index
),
1659 &have_default
, stream
))
1661 blocks_printed
[index
] = 1;
1667 if (values_printed
&& this_level_only
)
1670 /* After handling the function's top-level block, stop. Don't
1671 continue to its superblock, the block of per-file symbols.
1672 Also do not continue to the containing function of an inlined
1674 if (BLOCK_FUNCTION (block
))
1676 block
= BLOCK_SUPERBLOCK (block
);
1679 if (!values_printed
&& !this_level_only
)
1680 fprintf_filtered (stream
, _("No catches.\n"));
1685 locals_info (char *args
, int from_tty
)
1687 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1692 catch_info (char *ignore
, int from_tty
)
1694 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1695 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1699 /* Iterate over all the argument variables in block B.
1701 Returns 1 if any argument was walked; 0 otherwise. */
1704 iterate_over_block_arg_vars (struct block
*b
,
1705 iterate_over_block_arg_local_vars_cb cb
,
1708 struct dict_iterator iter
;
1709 struct symbol
*sym
, *sym2
;
1711 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1713 /* Don't worry about things which aren't arguments. */
1714 if (SYMBOL_IS_ARGUMENT (sym
))
1716 /* We have to look up the symbol because arguments can have
1717 two entries (one a parameter, one a local) and the one we
1718 want is the local, which lookup_symbol will find for us.
1719 This includes gcc1 (not gcc2) on the sparc when passing a
1720 small structure and gcc2 when the argument type is float
1721 and it is passed as a double and converted to float by
1722 the prologue (in the latter case the type of the LOC_ARG
1723 symbol is double and the type of the LOC_LOCAL symbol is
1724 float). There are also LOC_ARG/LOC_REGISTER pairs which
1725 are not combined in symbol-reading. */
1727 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1728 b
, VAR_DOMAIN
, NULL
);
1729 (*cb
) (SYMBOL_PRINT_NAME (sym
), sym2
, cb_data
);
1735 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1737 struct print_variable_and_value_data cb_data
;
1738 struct symbol
*func
;
1740 func
= get_frame_function (frame
);
1743 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1747 cb_data
.frame
= frame
;
1748 cb_data
.num_tabs
= 0;
1749 cb_data
.stream
= gdb_stdout
;
1750 cb_data
.values_printed
= 0;
1752 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func
),
1753 do_print_variable_and_value
, &cb_data
);
1755 if (!cb_data
.values_printed
)
1756 fprintf_filtered (stream
, _("No arguments.\n"));
1760 args_info (char *ignore
, int from_tty
)
1762 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1768 args_plus_locals_info (char *ignore
, int from_tty
)
1770 args_info (ignore
, from_tty
);
1771 locals_info (ignore
, from_tty
);
1775 /* Select frame FRAME. Also print the stack frame and show the source
1776 if this is the tui version. */
1778 select_and_print_frame (struct frame_info
*frame
)
1780 select_frame (frame
);
1782 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1785 /* Return the symbol-block in which the selected frame is executing.
1786 Can return zero under various legitimate circumstances.
1788 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1789 code address within the block returned. We use this to decide
1790 which macros are in scope. */
1793 get_selected_block (CORE_ADDR
*addr_in_block
)
1795 if (!has_stack_frames ())
1798 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1801 /* Find a frame a certain number of levels away from FRAME.
1802 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1803 Positive means go to earlier frames (up); negative, the reverse.
1804 The int that contains the number of levels is counted toward
1805 zero as the frames for those levels are found.
1806 If the top or bottom frame is reached, that frame is returned,
1807 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1808 how much farther the original request asked to go. */
1811 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1813 /* Going up is simple: just call get_prev_frame enough times or
1814 until the initial frame is reached. */
1815 while (*level_offset_ptr
> 0)
1817 struct frame_info
*prev
= get_prev_frame (frame
);
1820 (*level_offset_ptr
)--;
1824 /* Going down is just as simple. */
1825 while (*level_offset_ptr
< 0)
1827 struct frame_info
*next
= get_next_frame (frame
);
1830 (*level_offset_ptr
)++;
1837 /* The "select_frame" command. With no argument this is a NOP.
1838 Select the frame at level LEVEL_EXP if it is a valid level.
1839 Otherwise, treat LEVEL_EXP as an address expression and select it.
1841 See parse_frame_specification for more info on proper frame
1845 select_frame_command (char *level_exp
, int from_tty
)
1847 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1850 /* The "frame" command. With no argument, print the selected frame
1851 briefly. With an argument, behave like select_frame and then print
1852 the selected frame. */
1855 frame_command (char *level_exp
, int from_tty
)
1857 select_frame_command (level_exp
, from_tty
);
1858 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1861 /* The XDB Compatibility command to print the current frame. */
1864 current_frame_command (char *level_exp
, int from_tty
)
1866 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1869 /* Select the frame up one or COUNT_EXP stack levels from the
1870 previously selected frame, and print it briefly. */
1873 up_silently_base (char *count_exp
)
1875 struct frame_info
*frame
;
1879 count
= parse_and_eval_long (count_exp
);
1881 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1882 if (count
!= 0 && count_exp
== NULL
)
1883 error (_("Initial frame selected; you cannot go up."));
1884 select_frame (frame
);
1888 up_silently_command (char *count_exp
, int from_tty
)
1890 up_silently_base (count_exp
);
1894 up_command (char *count_exp
, int from_tty
)
1896 up_silently_base (count_exp
);
1897 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1900 /* Select the frame down one or COUNT_EXP stack levels from the previously
1901 selected frame, and print it briefly. */
1904 down_silently_base (char *count_exp
)
1906 struct frame_info
*frame
;
1910 count
= -parse_and_eval_long (count_exp
);
1912 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1913 if (count
!= 0 && count_exp
== NULL
)
1915 /* We only do this if COUNT_EXP is not specified. That way
1916 "down" means to really go down (and let me know if that is
1917 impossible), but "down 9999" can be used to mean go all the
1918 way down without getting an error. */
1920 error (_("Bottom (innermost) frame selected; you cannot go down."));
1923 select_frame (frame
);
1927 down_silently_command (char *count_exp
, int from_tty
)
1929 down_silently_base (count_exp
);
1933 down_command (char *count_exp
, int from_tty
)
1935 down_silently_base (count_exp
);
1936 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1941 return_command (char *retval_exp
, int from_tty
)
1943 struct frame_info
*thisframe
;
1944 struct gdbarch
*gdbarch
;
1945 struct symbol
*thisfun
;
1946 struct value
*return_value
= NULL
;
1947 const char *query_prefix
= "";
1949 thisframe
= get_selected_frame ("No selected frame.");
1950 thisfun
= get_frame_function (thisframe
);
1951 gdbarch
= get_frame_arch (thisframe
);
1953 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
1954 error (_("Can not force return from an inlined function."));
1956 /* Compute the return value. If the computation triggers an error,
1957 let it bail. If the return type can't be handled, set
1958 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1962 struct expression
*retval_expr
= parse_expression (retval_exp
);
1963 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1964 struct type
*return_type
= NULL
;
1966 /* Compute the return value. Should the computation fail, this
1967 call throws an error. */
1968 return_value
= evaluate_expression (retval_expr
);
1970 /* Cast return value to the return type of the function. Should
1971 the cast fail, this call throws an error. */
1972 if (thisfun
!= NULL
)
1973 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1974 if (return_type
== NULL
)
1976 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1977 error (_("Return value type not available for selected "
1979 "Please use an explicit cast of the value to return."));
1980 return_type
= value_type (return_value
);
1982 do_cleanups (old_chain
);
1983 CHECK_TYPEDEF (return_type
);
1984 return_value
= value_cast (return_type
, return_value
);
1986 /* Make sure the value is fully evaluated. It may live in the
1987 stack frame we're about to pop. */
1988 if (value_lazy (return_value
))
1989 value_fetch_lazy (return_value
);
1991 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1992 /* If the return-type is "void", don't try to find the
1993 return-value's location. However, do still evaluate the
1994 return expression so that, even when the expression result
1995 is discarded, side effects such as "return i++" still
1997 return_value
= NULL
;
1998 else if (thisfun
!= NULL
1999 && using_struct_return (gdbarch
,
2000 SYMBOL_TYPE (thisfun
), return_type
))
2003 The location at which to store the function's return value is unknown.\n\
2004 If you continue, the return value that you specified will be ignored.\n";
2005 return_value
= NULL
;
2009 /* Does an interactive user really want to do this? Include
2010 information, such as how well GDB can handle the return value, in
2011 the query message. */
2015 if (thisfun
== NULL
)
2016 confirmed
= query (_("%sMake selected stack frame return now? "),
2019 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
2020 SYMBOL_PRINT_NAME (thisfun
));
2022 error (_("Not confirmed"));
2025 /* Discard the selected frame and all frames inner-to it. */
2026 frame_pop (get_selected_frame (NULL
));
2028 /* Store RETURN_VALUE in the just-returned register set. */
2029 if (return_value
!= NULL
)
2031 struct type
*return_type
= value_type (return_value
);
2032 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
2033 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
2035 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
2037 == RETURN_VALUE_REGISTER_CONVENTION
);
2038 gdbarch_return_value (gdbarch
, func_type
, return_type
,
2039 get_current_regcache (), NULL
/*read*/,
2040 value_contents (return_value
) /*write*/);
2043 /* If we are at the end of a call dummy now, pop the dummy frame
2045 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2046 frame_pop (get_current_frame ());
2048 /* If interactive, print the frame that is now current. */
2050 frame_command ("0", 1);
2052 select_frame_command ("0", 0);
2055 /* Sets the scope to input function name, provided that the function
2056 is within the current stack frame */
2058 struct function_bounds
2060 CORE_ADDR low
, high
;
2064 func_command (char *arg
, int from_tty
)
2066 struct frame_info
*frame
;
2068 struct symtabs_and_lines sals
;
2071 struct function_bounds
*func_bounds
= NULL
;
2076 frame
= parse_frame_specification ("0");
2077 sals
= decode_line_spec (arg
, 1);
2078 func_bounds
= (struct function_bounds
*) xmalloc (
2079 sizeof (struct function_bounds
) * sals
.nelts
);
2080 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2082 if (sals
.sals
[i
].pc
== 0
2083 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2084 &func_bounds
[i
].low
,
2085 &func_bounds
[i
].high
) == 0)
2087 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2093 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2094 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2095 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2099 frame
= find_relative_frame (frame
, &level
);
2102 while (!found
&& level
== 0);
2105 xfree (func_bounds
);
2108 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2109 else if (frame
!= get_selected_frame (NULL
))
2110 select_and_print_frame (frame
);
2113 /* Gets the language of the current frame. */
2116 get_frame_language (void)
2118 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2122 /* We determine the current frame language by looking up its
2123 associated symtab. To retrieve this symtab, we use the frame
2124 PC. However we cannot use the frame PC as is, because it
2125 usually points to the instruction following the "call", which
2126 is sometimes the first instruction of another function. So
2127 we rely on get_frame_address_in_block(), it provides us with
2128 a PC that is guaranteed to be inside the frame's code
2130 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2131 struct symtab
*s
= find_pc_symtab (pc
);
2137 return language_unknown
;
2141 /* Provide a prototype to silence -Wmissing-prototypes. */
2142 void _initialize_stack (void);
2145 _initialize_stack (void)
2147 add_com ("return", class_stack
, return_command
, _("\
2148 Make selected stack frame return to its caller.\n\
2149 Control remains in the debugger, but when you continue\n\
2150 execution will resume in the frame above the one now selected.\n\
2151 If an argument is given, it is an expression for the value to return."));
2153 add_com ("up", class_stack
, up_command
, _("\
2154 Select and print stack frame that called this one.\n\
2155 An argument says how many frames up to go."));
2156 add_com ("up-silently", class_support
, up_silently_command
, _("\
2157 Same as the `up' command, but does not print anything.\n\
2158 This is useful in command scripts."));
2160 add_com ("down", class_stack
, down_command
, _("\
2161 Select and print stack frame called by this one.\n\
2162 An argument says how many frames down to go."));
2163 add_com_alias ("do", "down", class_stack
, 1);
2164 add_com_alias ("dow", "down", class_stack
, 1);
2165 add_com ("down-silently", class_support
, down_silently_command
, _("\
2166 Same as the `down' command, but does not print anything.\n\
2167 This is useful in command scripts."));
2169 add_com ("frame", class_stack
, frame_command
, _("\
2170 Select and print a stack frame.\n\
2171 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2172 An argument specifies the frame to select.\n\
2173 It can be a stack frame number or the address of the frame.\n\
2174 With argument, nothing is printed if input is coming from\n\
2175 a command file or a user-defined command."));
2177 add_com_alias ("f", "frame", class_stack
, 1);
2181 add_com ("L", class_stack
, current_frame_command
,
2182 _("Print the current stack frame.\n"));
2183 add_com_alias ("V", "frame", class_stack
, 1);
2185 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2186 Select a stack frame without printing anything.\n\
2187 An argument specifies the frame to select.\n\
2188 It can be a stack frame number or the address of the frame.\n"));
2190 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2191 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2192 With a negative argument, print outermost -COUNT frames.\n\
2193 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2194 add_com_alias ("bt", "backtrace", class_stack
, 0);
2197 add_com_alias ("t", "backtrace", class_stack
, 0);
2198 add_com ("T", class_stack
, backtrace_full_command
, _("\
2199 Print backtrace of all stack frames, or innermost COUNT frames \n\
2200 and the values of the local variables.\n\
2201 With a negative argument, print outermost -COUNT frames.\n\
2202 Usage: T <count>\n"));
2205 add_com_alias ("where", "backtrace", class_alias
, 0);
2206 add_info ("stack", backtrace_command
,
2207 _("Backtrace of the stack, or innermost COUNT frames."));
2208 add_info_alias ("s", "stack", 1);
2209 add_info ("frame", frame_info
,
2210 _("All about selected stack frame, or frame at ADDR."));
2211 add_info_alias ("f", "frame", 1);
2212 add_info ("locals", locals_info
,
2213 _("Local variables of current stack frame."));
2214 add_info ("args", args_info
,
2215 _("Argument variables of current stack frame."));
2217 add_com ("l", class_info
, args_plus_locals_info
,
2218 _("Argument and local variables of current stack frame."));
2221 add_com ("func", class_stack
, func_command
, _("\
2222 Select the stack frame that contains <func>.\n\
2223 Usage: func <name>\n"));
2225 add_info ("catch", catch_info
,
2226 _("Exceptions that can be caught in the current stack frame."));
2228 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2229 print_frame_arguments_choices
, &print_frame_arguments
,
2230 _("Set printing of non-scalar frame arguments"),
2231 _("Show printing of non-scalar frame arguments"),
2232 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2234 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2235 &disassemble_next_line
, _("\
2236 Set whether to disassemble next source line or insn when execution stops."), _("\
2237 Show whether to disassemble next source line or insn when execution stops."), _("\
2238 If ON, GDB will display disassembly of the next source line, in addition\n\
2239 to displaying the source line itself. If the next source line cannot\n\
2240 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2241 will display disassembly of next instruction instead of showing the\n\
2243 If AUTO, display disassembly of next instruction only if the source line\n\
2244 cannot be displayed.\n\
2245 If OFF (which is the default), never display the disassembly of the next\n\
2248 show_disassemble_next_line
,
2249 &setlist
, &showlist
);
2250 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;