1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
5 2009 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
33 #include "breakpoint.h"
40 #include "dictionary.h"
41 #include "exceptions.h"
42 #include "reggroups.h"
46 #include "gdbthread.h"
47 #include "cp-support.h"
49 #include "inline-frame.h"
51 #include "gdb_assert.h"
53 #include "gdb_string.h"
55 void (*deprecated_selected_frame_level_changed_hook
) (int);
57 /* The possible choices of "set print frame-arguments, and the value
60 static const char *print_frame_arguments_choices
[] =
61 {"all", "scalars", "none", NULL
};
62 static const char *print_frame_arguments
= "scalars";
64 /* Prototypes for local functions. */
66 static void print_frame_local_vars (struct frame_info
*, int,
69 static void print_frame (struct frame_info
*frame
, int print_level
,
70 enum print_what print_what
, int print_args
,
71 struct symtab_and_line sal
);
73 /* Zero means do things normally; we are interacting directly with the
74 user. One means print the full filename and linenumber when a
75 frame is printed, and do so in a format emacs18/emacs19.22 can
76 parse. Two means print similar annotations, but in many more
77 cases and in a slightly different syntax. */
79 int annotation_level
= 0;
82 struct print_stack_frame_args
84 struct frame_info
*frame
;
86 enum print_what print_what
;
90 /* Show or print the frame arguments; stub for catch_errors. */
93 print_stack_frame_stub (void *args
)
95 struct print_stack_frame_args
*p
= args
;
96 int center
= (p
->print_what
== SRC_LINE
|| p
->print_what
== SRC_AND_LOC
);
98 print_frame_info (p
->frame
, p
->print_level
, p
->print_what
, p
->print_args
);
99 set_current_sal_from_frame (p
->frame
, center
);
103 /* Return 1 if we should display the address in addition to the location,
104 because we are in the middle of a statement. */
107 frame_show_address (struct frame_info
*frame
,
108 struct symtab_and_line sal
)
110 /* If there is a line number, but no PC, then there is no location
111 information associated with this sal. The only way that should
112 happen is for the call sites of inlined functions (SAL comes from
113 find_frame_sal). Otherwise, we would have some PC range if the
114 SAL came from a line table. */
115 if (sal
.line
!= 0 && sal
.pc
== 0 && sal
.end
== 0)
117 if (get_next_frame (frame
) == NULL
)
118 gdb_assert (inline_skipped_frames (inferior_ptid
) > 0);
120 gdb_assert (get_frame_type (get_next_frame (frame
)) == INLINE_FRAME
);
124 return get_frame_pc (frame
) != sal
.pc
;
127 /* Show or print a stack frame FRAME briefly. The output is format
128 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
129 relative level, function name, argument list, and file name and
130 line number. If the frame's PC is not at the beginning of the
131 source line, the actual PC is printed at the beginning. */
134 print_stack_frame (struct frame_info
*frame
, int print_level
,
135 enum print_what print_what
)
137 struct print_stack_frame_args args
;
140 args
.print_level
= print_level
;
141 args
.print_what
= print_what
;
142 /* For mi, alway print location and address. */
143 args
.print_what
= ui_out_is_mi_like_p (uiout
) ? LOC_AND_ADDRESS
: print_what
;
146 catch_errors (print_stack_frame_stub
, &args
, "", RETURN_MASK_ERROR
);
149 struct print_args_args
152 struct frame_info
*frame
;
153 struct ui_file
*stream
;
156 static int print_args_stub (void *args
);
158 /* Print nameless arguments of frame FRAME on STREAM, where START is
159 the offset of the first nameless argument, and NUM is the number of
160 nameless arguments to print. FIRST is nonzero if this is the first
161 argument (not just the first nameless argument). */
164 print_frame_nameless_args (struct frame_info
*frame
, long start
, int num
,
165 int first
, struct ui_file
*stream
)
167 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
168 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
173 for (i
= 0; i
< num
; i
++)
176 argsaddr
= get_frame_args_address (frame
);
179 arg_value
= read_memory_integer (argsaddr
+ start
,
180 sizeof (int), byte_order
);
182 fprintf_filtered (stream
, ", ");
183 fprintf_filtered (stream
, "%ld", arg_value
);
185 start
+= sizeof (int);
189 /* Print the arguments of frame FRAME on STREAM, given the function
190 FUNC running in that frame (as a symbol), where NUM is the number
191 of arguments according to the stack frame (or -1 if the number of
192 arguments is unknown). */
194 /* Note that currently the "number of arguments according to the
195 stack frame" is only known on VAX where i refers to the "number of
196 ints of arguments according to the stack frame". */
199 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
200 int num
, struct ui_file
*stream
)
203 /* Offset of next stack argument beyond the one we have seen that is
204 at the highest offset, or -1 if we haven't come to a stack
206 long highest_offset
= -1;
207 /* Number of ints of arguments that we have printed so far. */
208 int args_printed
= 0;
209 struct cleanup
*old_chain
, *list_chain
;
210 struct ui_stream
*stb
;
211 /* True if we should print arguments, false otherwise. */
212 int print_args
= strcmp (print_frame_arguments
, "none");
213 /* True in "summary" mode, false otherwise. */
214 int summary
= !strcmp (print_frame_arguments
, "scalars");
216 stb
= ui_out_stream_new (uiout
);
217 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
221 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
222 struct dict_iterator iter
;
226 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
230 /* Keep track of the highest stack argument offset seen, and
231 skip over any kinds of symbols we don't care about. */
233 if (!SYMBOL_IS_ARGUMENT (sym
))
236 switch (SYMBOL_CLASS (sym
))
241 long current_offset
= SYMBOL_VALUE (sym
);
242 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
244 /* Compute address of next argument by adding the size of
245 this argument and rounding to an int boundary. */
247 ((current_offset
+ arg_size
+ sizeof (int) - 1)
248 & ~(sizeof (int) - 1));
250 /* If this is the highest offset seen yet, set
252 if (highest_offset
== -1
253 || (current_offset
> highest_offset
))
254 highest_offset
= current_offset
;
256 /* Add the number of ints we're about to print to
258 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
261 /* We care about types of symbols, but don't need to
262 keep track of stack offsets in them. */
264 case LOC_REGPARM_ADDR
:
266 case LOC_OPTIMIZED_OUT
:
271 /* We have to look up the symbol because arguments can have
272 two entries (one a parameter, one a local) and the one we
273 want is the local, which lookup_symbol will find for us.
274 This includes gcc1 (not gcc2) on SPARC when passing a
275 small structure and gcc2 when the argument type is float
276 and it is passed as a double and converted to float by
277 the prologue (in the latter case the type of the LOC_ARG
278 symbol is double and the type of the LOC_LOCAL symbol is
280 /* But if the parameter name is null, don't try it. Null
281 parameter names occur on the RS/6000, for traceback
282 tables. FIXME, should we even print them? */
284 if (*SYMBOL_LINKAGE_NAME (sym
))
287 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
288 b
, VAR_DOMAIN
, NULL
);
289 gdb_assert (nsym
!= NULL
);
290 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
291 && !SYMBOL_IS_ARGUMENT (nsym
))
293 /* There is a LOC_ARG/LOC_REGISTER pair. This means
294 that it was passed on the stack and loaded into a
295 register, or passed in a register and stored in a
296 stack slot. GDB 3.x used the LOC_ARG; GDB
297 4.0-4.11 used the LOC_REGISTER.
299 Reasons for using the LOC_ARG:
301 (1) Because find_saved_registers may be slow for
304 (2) Because registers are often re-used and stack
305 slots rarely (never?) are. Therefore using
306 the stack slot is much less likely to print
309 Reasons why we might want to use the LOC_REGISTER:
311 (1) So that the backtrace prints the same value
312 as "print foo". I see no compelling reason
313 why this needs to be the case; having the
314 backtrace print the value which was passed
315 in, and "print foo" print the value as
316 modified within the called function, makes
319 Additional note: It might be nice if "info args"
320 displayed both values.
322 One more note: There is a case with SPARC
323 structure passing where we need to use the
324 LOC_REGISTER, but this is dealt with by creating
325 a single LOC_REGPARM in symbol reading. */
327 /* Leave sym (the LOC_ARG) alone. */
334 /* Print the current arg. */
336 ui_out_text (uiout
, ", ");
337 ui_out_wrap_hint (uiout
, " ");
339 annotate_arg_begin ();
341 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
342 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
343 SYMBOL_LANGUAGE (sym
),
344 DMGL_PARAMS
| DMGL_ANSI
);
345 ui_out_field_stream (uiout
, "name", stb
);
346 annotate_arg_name_end ();
347 ui_out_text (uiout
, "=");
351 /* Avoid value_print because it will deref ref parameters.
352 We just want to print their addresses. Print ??? for
353 args whose address we do not know. We pass 2 as
354 "recurse" to val_print because our standard indentation
355 here is 4 spaces, and val_print indents 2 for each
357 val
= read_var_value (sym
, frame
);
359 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
363 const struct language_defn
*language
;
364 struct value_print_options opts
;
366 /* Use the appropriate language to display our symbol,
367 unless the user forced the language to a specific
369 if (language_mode
== language_mode_auto
)
370 language
= language_def (SYMBOL_LANGUAGE (sym
));
372 language
= current_language
;
374 get_raw_print_options (&opts
);
376 opts
.summary
= summary
;
377 common_val_print (val
, stb
->stream
, 2, &opts
, language
);
378 ui_out_field_stream (uiout
, "value", stb
);
381 ui_out_text (uiout
, "???");
384 ui_out_text (uiout
, "...");
387 /* Invoke ui_out_tuple_end. */
388 do_cleanups (list_chain
);
396 /* Don't print nameless args in situations where we don't know
397 enough about the stack to find them. */
402 if (highest_offset
== -1)
403 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
405 start
= highest_offset
;
407 print_frame_nameless_args (frame
, start
, num
- args_printed
,
411 do_cleanups (old_chain
);
414 /* Stub for catch_errors. */
417 print_args_stub (void *args
)
419 struct print_args_args
*p
= args
;
420 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
423 if (gdbarch_frame_num_args_p (gdbarch
))
425 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
426 gdb_assert (numargs
>= 0);
430 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
434 /* Set the current source and line to the location given by frame
435 FRAME, if possible. When CENTER is true, adjust so the relevant
436 line is in the center of the next 'list'. */
439 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
441 struct symtab_and_line sal
;
443 find_frame_sal (frame
, &sal
);
447 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
448 set_current_source_symtab_and_line (&sal
);
452 /* If ON, GDB will display disassembly of the next source line when
453 execution of the program being debugged stops.
454 If AUTO (which is the default), or there's no line info to determine
455 the source line of the next instruction, display disassembly of next
456 instruction instead. */
458 static enum auto_boolean disassemble_next_line
;
461 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
462 struct cmd_list_element
*c
,
465 fprintf_filtered (file
, _("\
466 Debugger's willingness to use disassemble-next-line is %s.\n"),
470 /* Show assembly codes; stub for catch_errors. */
472 struct gdb_disassembly_stub_args
474 struct gdbarch
*gdbarch
;
481 gdb_disassembly_stub (void *args
)
483 struct gdb_disassembly_stub_args
*p
= args
;
484 gdb_disassembly (p
->gdbarch
, uiout
, 0,
485 DISASSEMBLY_RAW_INSN
, p
->how_many
,
489 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
490 because it will be broken by filter sometime. */
493 do_gdb_disassembly (struct gdbarch
*gdbarch
,
494 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
496 volatile struct gdb_exception exception
;
497 struct gdb_disassembly_stub_args args
;
499 args
.gdbarch
= gdbarch
;
500 args
.how_many
= how_many
;
503 TRY_CATCH (exception
, RETURN_MASK_ALL
)
505 gdb_disassembly_stub (&args
);
507 /* If an exception was thrown while doing the disassembly, print
508 the error message, to give the user a clue of what happened. */
509 if (exception
.reason
== RETURN_ERROR
)
510 exception_print (gdb_stderr
, exception
);
513 /* Print information about frame FRAME. The output is format according
514 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
517 SRC_LINE: Print only source line.
518 LOCATION: Print only location.
519 LOC_AND_SRC: Print location and source line.
521 Used in "where" output, and to emit breakpoint or step
525 print_frame_info (struct frame_info
*frame
, int print_level
,
526 enum print_what print_what
, int print_args
)
528 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
529 struct symtab_and_line sal
;
533 if (get_frame_type (frame
) == DUMMY_FRAME
534 || get_frame_type (frame
) == SIGTRAMP_FRAME
535 || get_frame_type (frame
) == ARCH_FRAME
)
537 struct cleanup
*uiout_cleanup
538 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
540 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
541 gdbarch
, get_frame_pc (frame
));
543 /* Do this regardless of SOURCE because we don't have any source
544 to list for this frame. */
547 ui_out_text (uiout
, "#");
548 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
549 frame_relative_level (frame
));
551 if (ui_out_is_mi_like_p (uiout
))
553 annotate_frame_address ();
554 ui_out_field_core_addr (uiout
, "addr",
555 gdbarch
, get_frame_pc (frame
));
556 annotate_frame_address_end ();
559 if (get_frame_type (frame
) == DUMMY_FRAME
)
561 annotate_function_call ();
562 ui_out_field_string (uiout
, "func", "<function called from gdb>");
564 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
566 annotate_signal_handler_caller ();
567 ui_out_field_string (uiout
, "func", "<signal handler called>");
569 else if (get_frame_type (frame
) == ARCH_FRAME
)
571 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
573 ui_out_text (uiout
, "\n");
574 annotate_frame_end ();
576 do_cleanups (uiout_cleanup
);
580 /* If FRAME is not the innermost frame, that normally means that
581 FRAME->pc points to *after* the call instruction, and we want to
582 get the line containing the call, never the next line. But if
583 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
584 next frame was not entered as the result of a call, and we want
585 to get the line containing FRAME->pc. */
586 find_frame_sal (frame
, &sal
);
588 location_print
= (print_what
== LOCATION
589 || print_what
== LOC_AND_ADDRESS
590 || print_what
== SRC_AND_LOC
);
592 if (location_print
|| !sal
.symtab
)
593 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
595 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
597 /* If disassemble-next-line is set to auto or on and doesn't have
598 the line debug messages for $pc, output the next instruction. */
599 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
600 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
601 && source_print
&& !sal
.symtab
)
602 do_gdb_disassembly (get_frame_arch (frame
), 1,
603 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
605 if (source_print
&& sal
.symtab
)
608 int mid_statement
= ((print_what
== SRC_LINE
)
609 && frame_show_address (frame
, sal
));
611 if (annotation_level
)
612 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
613 get_frame_pc (frame
));
616 if (deprecated_print_frame_info_listing_hook
)
617 deprecated_print_frame_info_listing_hook (sal
.symtab
,
622 struct value_print_options opts
;
623 get_user_print_options (&opts
);
624 /* We used to do this earlier, but that is clearly
625 wrong. This function is used by many different
626 parts of gdb, including normal_stop in infrun.c,
627 which uses this to print out the current PC
628 when we stepi/nexti into the middle of a source
629 line. Only the command line really wants this
630 behavior. Other UIs probably would like the
631 ability to decide for themselves if it is desired. */
632 if (opts
.addressprint
&& mid_statement
)
634 ui_out_field_core_addr (uiout
, "addr",
635 gdbarch
, get_frame_pc (frame
));
636 ui_out_text (uiout
, "\t");
639 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
643 /* If disassemble-next-line is set to on and there is line debug
644 messages, output assembly codes for next line. */
645 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
646 do_gdb_disassembly (get_frame_arch (frame
), -1,
647 get_frame_pc (frame
), sal
.end
);
650 if (print_what
!= LOCATION
)
651 set_default_breakpoint (1, sal
.pspace
,
652 get_frame_pc (frame
), sal
.symtab
, sal
.line
);
654 annotate_frame_end ();
656 gdb_flush (gdb_stdout
);
659 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
662 find_frame_funname (struct frame_info
*frame
, char **funname
,
663 enum language
*funlang
)
668 *funlang
= language_unknown
;
670 func
= get_frame_function (frame
);
673 /* In certain pathological cases, the symtabs give the wrong
674 function (when we are in the first function in a file which
675 is compiled without debugging symbols, the previous function
676 is compiled with debugging symbols, and the "foo.o" symbol
677 that is supposed to tell us where the file with debugging
678 symbols ends has been truncated by ar because it is longer
679 than 15 characters). This also occurs if the user uses asm()
680 to create a function but not stabs for it (in a file compiled
683 So look in the minimal symbol tables as well, and if it comes
684 up with a larger address for the function use that instead.
685 I don't think this can ever cause any problems; there
686 shouldn't be any minimal symbols in the middle of a function;
687 if this is ever changed many parts of GDB will need to be
688 changed (and we'll create a find_pc_minimal_function or some
691 struct minimal_symbol
*msymbol
= NULL
;
693 /* Don't attempt to do this for inlined functions, which do not
694 have a corresponding minimal symbol. */
695 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
697 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
700 && (SYMBOL_VALUE_ADDRESS (msymbol
)
701 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
703 /* We also don't know anything about the function besides
704 its address and name. */
706 *funname
= SYMBOL_PRINT_NAME (msymbol
);
707 *funlang
= SYMBOL_LANGUAGE (msymbol
);
711 *funname
= SYMBOL_PRINT_NAME (func
);
712 *funlang
= SYMBOL_LANGUAGE (func
);
713 if (*funlang
== language_cplus
)
715 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
716 to display the demangled name that we already have
717 stored in the symbol table, but we stored a version
718 with DMGL_PARAMS turned on, and here we don't want to
719 display parameters. So remove the parameters. */
720 char *func_only
= cp_remove_params (*funname
);
723 *funname
= func_only
;
724 make_cleanup (xfree
, func_only
);
731 struct minimal_symbol
*msymbol
=
732 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
736 *funname
= SYMBOL_PRINT_NAME (msymbol
);
737 *funlang
= SYMBOL_LANGUAGE (msymbol
);
743 print_frame (struct frame_info
*frame
, int print_level
,
744 enum print_what print_what
, int print_args
,
745 struct symtab_and_line sal
)
747 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
748 char *funname
= NULL
;
749 enum language funlang
= language_unknown
;
750 struct ui_stream
*stb
;
751 struct cleanup
*old_chain
, *list_chain
;
752 struct value_print_options opts
;
754 stb
= ui_out_stream_new (uiout
);
755 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
757 find_frame_funname (frame
, &funname
, &funlang
);
759 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
760 gdbarch
, get_frame_pc (frame
));
762 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
766 ui_out_text (uiout
, "#");
767 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
768 frame_relative_level (frame
));
770 get_user_print_options (&opts
);
771 if (opts
.addressprint
)
772 if (frame_show_address (frame
, sal
) || !sal
.symtab
773 || print_what
== LOC_AND_ADDRESS
)
775 annotate_frame_address ();
776 ui_out_field_core_addr (uiout
, "addr", gdbarch
, get_frame_pc (frame
));
777 annotate_frame_address_end ();
778 ui_out_text (uiout
, " in ");
780 annotate_frame_function_name ();
781 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
783 ui_out_field_stream (uiout
, "func", stb
);
784 ui_out_wrap_hint (uiout
, " ");
785 annotate_frame_args ();
787 ui_out_text (uiout
, " (");
790 struct print_args_args args
;
791 struct cleanup
*args_list_chain
;
793 args
.func
= find_pc_function (get_frame_address_in_block (frame
));
794 args
.stream
= gdb_stdout
;
795 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
796 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
797 /* FIXME: ARGS must be a list. If one argument is a string it
798 will have " that will not be properly escaped. */
799 /* Invoke ui_out_tuple_end. */
800 do_cleanups (args_list_chain
);
803 ui_out_text (uiout
, ")");
804 if (sal
.symtab
&& sal
.symtab
->filename
)
806 annotate_frame_source_begin ();
807 ui_out_wrap_hint (uiout
, " ");
808 ui_out_text (uiout
, " at ");
809 annotate_frame_source_file ();
810 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
811 if (ui_out_is_mi_like_p (uiout
))
813 const char *fullname
= symtab_to_fullname (sal
.symtab
);
814 if (fullname
!= NULL
)
815 ui_out_field_string (uiout
, "fullname", fullname
);
817 annotate_frame_source_file_end ();
818 ui_out_text (uiout
, ":");
819 annotate_frame_source_line ();
820 ui_out_field_int (uiout
, "line", sal
.line
);
821 annotate_frame_source_end ();
824 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
827 char *lib
= PC_SOLIB (get_frame_pc (frame
));
829 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
830 get_frame_pc (frame
));
834 annotate_frame_where ();
835 ui_out_wrap_hint (uiout
, " ");
836 ui_out_text (uiout
, " from ");
837 ui_out_field_string (uiout
, "from", lib
);
841 /* do_cleanups will call ui_out_tuple_end() for us. */
842 do_cleanups (list_chain
);
843 ui_out_text (uiout
, "\n");
844 do_cleanups (old_chain
);
848 /* Read a frame specification in whatever the appropriate format is
849 from FRAME_EXP. Call error(), printing MESSAGE, if the
850 specification is in any way invalid (so this function never returns
851 NULL). When SEPECTED_P is non-NULL set its target to indicate that
852 the default selected frame was used. */
854 static struct frame_info
*
855 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
856 int *selected_frame_p
)
859 struct value
*args
[4];
860 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
862 if (frame_exp
== NULL
)
867 struct cleanup
*tmp_cleanup
;
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
;
995 int i
, count
, numregs
;
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 struct partial_symtab
*ps
;
1317 /* Read in symbols for all of the frames. Need to do this in a
1318 separate pass so that "Reading in symbols for xxx" messages
1319 don't screw up the appearance of the backtrace. Also if
1320 people have strong opinions against reading symbols for
1321 backtrace this may have to be an option. */
1323 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1326 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1328 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in. */
1332 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1336 /* Don't use print_stack_frame; if an error() occurs it probably
1337 means further attempts to backtrace would fail (on the other
1338 hand, perhaps the code does or could be fixed to make sure
1339 the frame->prev field gets set to NULL in that case). */
1340 print_frame_info (fi
, 1, LOCATION
, 1);
1342 print_frame_local_vars (fi
, 1, gdb_stdout
);
1344 /* Save the last frame to check for error conditions. */
1348 /* If we've stopped before the end, mention that. */
1350 printf_filtered (_("(More stack frames follow...)\n"));
1352 /* If we've run out of frames, and the reason appears to be an error
1353 condition, print it. */
1354 if (fi
== NULL
&& trailing
!= NULL
)
1356 enum unwind_stop_reason reason
;
1358 reason
= get_frame_unwind_stop_reason (trailing
);
1359 if (reason
> UNWIND_FIRST_ERROR
)
1360 printf_filtered (_("Backtrace stopped: %s\n"),
1361 frame_stop_reason_string (reason
));
1365 struct backtrace_command_args
1372 /* Stub for catch_errors. */
1375 backtrace_command_stub (void *data
)
1377 struct backtrace_command_args
*args
= data
;
1378 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1383 backtrace_command (char *arg
, int from_tty
)
1385 struct cleanup
*old_chain
= NULL
;
1386 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1387 struct backtrace_command_args btargs
;
1394 argv
= gdb_buildargv (arg
);
1395 old_chain
= make_cleanup_freeargv (argv
);
1397 for (i
= 0; argv
[i
]; i
++)
1401 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1402 argv
[i
][j
] = tolower (argv
[i
][j
]);
1404 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1405 fulltrace_arg
= argc
;
1408 arglen
+= strlen (argv
[i
]);
1413 if (fulltrace_arg
>= 0)
1417 arg
= xmalloc (arglen
+ 1);
1418 memset (arg
, 0, arglen
+ 1);
1419 for (i
= 0; i
< (argc
+ 1); i
++)
1421 if (i
!= fulltrace_arg
)
1423 strcat (arg
, argv
[i
]);
1433 btargs
.count_exp
= arg
;
1434 btargs
.show_locals
= (fulltrace_arg
>= 0);
1435 btargs
.from_tty
= from_tty
;
1436 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1438 if (fulltrace_arg
>= 0 && arglen
> 0)
1442 do_cleanups (old_chain
);
1446 backtrace_full_command (char *arg
, int from_tty
)
1448 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 /* Print the local variables of a block B active in FRAME on STREAM.
1457 Return 1 if any variables were printed; 0 otherwise. */
1460 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1461 int num_tabs
, struct ui_file
*stream
)
1463 struct dict_iterator iter
;
1465 int values_printed
= 0;
1468 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1470 switch (SYMBOL_CLASS (sym
))
1476 if (SYMBOL_IS_ARGUMENT (sym
))
1479 print_variable_and_value (NULL
, sym
, frame
, stream
, 4 * num_tabs
);
1483 /* Ignore symbols which are not locals. */
1488 return values_printed
;
1491 /* Same, but print labels. */
1494 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1495 int *have_default
, struct ui_file
*stream
)
1497 struct dict_iterator iter
;
1499 int values_printed
= 0;
1501 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1503 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1509 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1511 struct symtab_and_line sal
;
1512 struct value_print_options opts
;
1513 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1515 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1516 get_user_print_options (&opts
);
1517 if (opts
.addressprint
)
1519 fprintf_filtered (stream
, " ");
1520 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1523 fprintf_filtered (stream
, " in file %s, line %d\n",
1524 sal
.symtab
->filename
, sal
.line
);
1528 return values_printed
;
1531 /* Print on STREAM all the local variables in frame FRAME, including
1532 all the blocks active in that frame at its current PC.
1534 Returns 1 if the job was done, or 0 if nothing was printed because
1535 we have no info on the function running in FRAME. */
1538 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1539 struct ui_file
*stream
)
1541 struct block
*block
= get_frame_block (frame
, 0);
1542 int values_printed
= 0;
1546 fprintf_filtered (stream
, "No symbol table info available.\n");
1552 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1554 /* After handling the function's top-level block, stop. Don't
1555 continue to its superblock, the block of per-file symbols.
1556 Also do not continue to the containing function of an inlined
1558 if (BLOCK_FUNCTION (block
))
1560 block
= BLOCK_SUPERBLOCK (block
);
1563 if (!values_printed
)
1564 fprintf_filtered (stream
, _("No locals.\n"));
1567 /* Same, but print labels. */
1570 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1571 struct ui_file
*stream
)
1574 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1576 struct blockvector
*bl
;
1577 struct block
*block
= get_frame_block (frame
, 0);
1578 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1579 int values_printed
= 0;
1580 int index
, have_default
= 0;
1581 char *blocks_printed
;
1582 CORE_ADDR pc
= get_frame_pc (frame
);
1586 fprintf_filtered (stream
, "No symbol table info available.\n");
1590 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1591 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1592 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1596 CORE_ADDR end
= BLOCK_END (block
) - 4;
1599 if (bl
!= blockvector_for_pc (end
, &index
))
1600 error (_("blockvector blotch"));
1601 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1602 error (_("blockvector botch"));
1603 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1606 /* Don't print out blocks that have gone by. */
1607 while (index
< last_index
1608 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1611 while (index
< last_index
1612 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1614 if (blocks_printed
[index
] == 0)
1616 if (print_block_frame_labels (gdbarch
,
1617 BLOCKVECTOR_BLOCK (bl
, index
),
1618 &have_default
, stream
))
1620 blocks_printed
[index
] = 1;
1626 if (values_printed
&& this_level_only
)
1629 /* After handling the function's top-level block, stop. Don't
1630 continue to its superblock, the block of per-file symbols.
1631 Also do not continue to the containing function of an inlined
1633 if (BLOCK_FUNCTION (block
))
1635 block
= BLOCK_SUPERBLOCK (block
);
1638 if (!values_printed
&& !this_level_only
)
1639 fprintf_filtered (stream
, _("No catches.\n"));
1644 locals_info (char *args
, int from_tty
)
1646 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1651 catch_info (char *ignore
, int from_tty
)
1653 struct symtab_and_line
*sal
;
1655 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1656 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1661 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1663 struct symbol
*func
= get_frame_function (frame
);
1665 struct dict_iterator iter
;
1666 struct symbol
*sym
, *sym2
;
1667 int values_printed
= 0;
1671 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1675 b
= SYMBOL_BLOCK_VALUE (func
);
1676 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1678 /* Don't worry about things which aren't arguments. */
1679 if (SYMBOL_IS_ARGUMENT (sym
))
1683 /* We have to look up the symbol because arguments can have
1684 two entries (one a parameter, one a local) and the one we
1685 want is the local, which lookup_symbol will find for us.
1686 This includes gcc1 (not gcc2) on the sparc when passing a
1687 small structure and gcc2 when the argument type is float
1688 and it is passed as a double and converted to float by
1689 the prologue (in the latter case the type of the LOC_ARG
1690 symbol is double and the type of the LOC_LOCAL symbol is
1691 float). There are also LOC_ARG/LOC_REGISTER pairs which
1692 are not combined in symbol-reading. */
1694 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1695 b
, VAR_DOMAIN
, NULL
);
1696 print_variable_and_value (SYMBOL_PRINT_NAME (sym
), sym2
,
1701 if (!values_printed
)
1702 fprintf_filtered (stream
, _("No arguments.\n"));
1706 args_info (char *ignore
, int from_tty
)
1708 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1714 args_plus_locals_info (char *ignore
, int from_tty
)
1716 args_info (ignore
, from_tty
);
1717 locals_info (ignore
, from_tty
);
1721 /* Select frame FRAME. Also print the stack frame and show the source
1722 if this is the tui version. */
1724 select_and_print_frame (struct frame_info
*frame
)
1726 select_frame (frame
);
1728 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1731 /* Return the symbol-block in which the selected frame is executing.
1732 Can return zero under various legitimate circumstances.
1734 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1735 code address within the block returned. We use this to decide
1736 which macros are in scope. */
1739 get_selected_block (CORE_ADDR
*addr_in_block
)
1741 if (!has_stack_frames ())
1744 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1747 /* Find a frame a certain number of levels away from FRAME.
1748 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1749 Positive means go to earlier frames (up); negative, the reverse.
1750 The int that contains the number of levels is counted toward
1751 zero as the frames for those levels are found.
1752 If the top or bottom frame is reached, that frame is returned,
1753 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1754 how much farther the original request asked to go. */
1757 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1759 /* Going up is simple: just call get_prev_frame enough times or
1760 until the initial frame is reached. */
1761 while (*level_offset_ptr
> 0)
1763 struct frame_info
*prev
= get_prev_frame (frame
);
1766 (*level_offset_ptr
)--;
1770 /* Going down is just as simple. */
1771 while (*level_offset_ptr
< 0)
1773 struct frame_info
*next
= get_next_frame (frame
);
1776 (*level_offset_ptr
)++;
1783 /* The "select_frame" command. With no argument this is a NOP.
1784 Select the frame at level LEVEL_EXP if it is a valid level.
1785 Otherwise, treat LEVEL_EXP as an address expression and select it.
1787 See parse_frame_specification for more info on proper frame
1791 select_frame_command (char *level_exp
, int from_tty
)
1793 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1796 /* The "frame" command. With no argument, print the selected frame
1797 briefly. With an argument, behave like select_frame and then print
1798 the selected frame. */
1801 frame_command (char *level_exp
, int from_tty
)
1803 select_frame_command (level_exp
, from_tty
);
1804 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1807 /* The XDB Compatibility command to print the current frame. */
1810 current_frame_command (char *level_exp
, int from_tty
)
1812 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1815 /* Select the frame up one or COUNT_EXP stack levels from the
1816 previously selected frame, and print it briefly. */
1819 up_silently_base (char *count_exp
)
1821 struct frame_info
*frame
;
1825 count
= parse_and_eval_long (count_exp
);
1827 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1828 if (count
!= 0 && count_exp
== NULL
)
1829 error (_("Initial frame selected; you cannot go up."));
1830 select_frame (frame
);
1834 up_silently_command (char *count_exp
, int from_tty
)
1836 up_silently_base (count_exp
);
1840 up_command (char *count_exp
, int from_tty
)
1842 up_silently_base (count_exp
);
1843 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1846 /* Select the frame down one or COUNT_EXP stack levels from the previously
1847 selected frame, and print it briefly. */
1850 down_silently_base (char *count_exp
)
1852 struct frame_info
*frame
;
1855 count
= -parse_and_eval_long (count_exp
);
1857 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1858 if (count
!= 0 && count_exp
== NULL
)
1860 /* We only do this if COUNT_EXP is not specified. That way
1861 "down" means to really go down (and let me know if that is
1862 impossible), but "down 9999" can be used to mean go all the
1863 way down without getting an error. */
1865 error (_("Bottom (innermost) frame selected; you cannot go down."));
1868 select_frame (frame
);
1872 down_silently_command (char *count_exp
, int from_tty
)
1874 down_silently_base (count_exp
);
1878 down_command (char *count_exp
, int from_tty
)
1880 down_silently_base (count_exp
);
1881 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1886 return_command (char *retval_exp
, int from_tty
)
1888 struct frame_info
*thisframe
;
1889 struct gdbarch
*gdbarch
;
1890 struct symbol
*thisfun
;
1891 struct value
*return_value
= NULL
;
1892 const char *query_prefix
= "";
1894 thisframe
= get_selected_frame ("No selected frame.");
1895 thisfun
= get_frame_function (thisframe
);
1896 gdbarch
= get_frame_arch (thisframe
);
1898 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
1899 error (_("Can not force return from an inlined function."));
1901 /* Compute the return value. If the computation triggers an error,
1902 let it bail. If the return type can't be handled, set
1903 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1907 struct expression
*retval_expr
= parse_expression (retval_exp
);
1908 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1909 struct type
*return_type
= NULL
;
1911 /* Compute the return value. Should the computation fail, this
1912 call throws an error. */
1913 return_value
= evaluate_expression (retval_expr
);
1915 /* Cast return value to the return type of the function. Should
1916 the cast fail, this call throws an error. */
1917 if (thisfun
!= NULL
)
1918 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1919 if (return_type
== NULL
)
1921 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1922 error (_("Return value type not available for selected "
1924 "Please use an explicit cast of the value to return."));
1925 return_type
= value_type (return_value
);
1927 do_cleanups (old_chain
);
1928 CHECK_TYPEDEF (return_type
);
1929 return_value
= value_cast (return_type
, return_value
);
1931 /* Make sure the value is fully evaluated. It may live in the
1932 stack frame we're about to pop. */
1933 if (value_lazy (return_value
))
1934 value_fetch_lazy (return_value
);
1936 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1937 /* If the return-type is "void", don't try to find the
1938 return-value's location. However, do still evaluate the
1939 return expression so that, even when the expression result
1940 is discarded, side effects such as "return i++" still
1942 return_value
= NULL
;
1943 else if (thisfun
!= NULL
1944 && using_struct_return (gdbarch
,
1945 SYMBOL_TYPE (thisfun
), return_type
))
1948 The location at which to store the function's return value is unknown.\n\
1949 If you continue, the return value that you specified will be ignored.\n";
1950 return_value
= NULL
;
1954 /* Does an interactive user really want to do this? Include
1955 information, such as how well GDB can handle the return value, in
1956 the query message. */
1960 if (thisfun
== NULL
)
1961 confirmed
= query (_("%sMake selected stack frame return now? "),
1964 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1965 SYMBOL_PRINT_NAME (thisfun
));
1967 error (_("Not confirmed"));
1970 /* Discard the selected frame and all frames inner-to it. */
1971 frame_pop (get_selected_frame (NULL
));
1973 /* Store RETURN_VALUE in the just-returned register set. */
1974 if (return_value
!= NULL
)
1976 struct type
*return_type
= value_type (return_value
);
1977 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1978 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
1980 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
1982 == RETURN_VALUE_REGISTER_CONVENTION
);
1983 gdbarch_return_value (gdbarch
, func_type
, return_type
,
1984 get_current_regcache (), NULL
/*read*/,
1985 value_contents (return_value
) /*write*/);
1988 /* If we are at the end of a call dummy now, pop the dummy frame
1990 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1991 frame_pop (get_current_frame ());
1993 /* If interactive, print the frame that is now current. */
1995 frame_command ("0", 1);
1997 select_frame_command ("0", 0);
2000 /* Sets the scope to input function name, provided that the function
2001 is within the current stack frame */
2003 struct function_bounds
2005 CORE_ADDR low
, high
;
2009 func_command (char *arg
, int from_tty
)
2011 struct frame_info
*frame
;
2013 struct symtabs_and_lines sals
;
2016 struct function_bounds
*func_bounds
= NULL
;
2021 frame
= parse_frame_specification ("0");
2022 sals
= decode_line_spec (arg
, 1);
2023 func_bounds
= (struct function_bounds
*) xmalloc (
2024 sizeof (struct function_bounds
) * sals
.nelts
);
2025 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2027 if (sals
.sals
[i
].pc
== 0
2028 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2029 &func_bounds
[i
].low
,
2030 &func_bounds
[i
].high
) == 0)
2032 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2038 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2039 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2040 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2044 frame
= find_relative_frame (frame
, &level
);
2047 while (!found
&& level
== 0);
2050 xfree (func_bounds
);
2053 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2054 else if (frame
!= get_selected_frame (NULL
))
2055 select_and_print_frame (frame
);
2058 /* Gets the language of the current frame. */
2061 get_frame_language (void)
2063 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2067 /* We determine the current frame language by looking up its
2068 associated symtab. To retrieve this symtab, we use the frame
2069 PC. However we cannot use the frame PC as is, because it
2070 usually points to the instruction following the "call", which
2071 is sometimes the first instruction of another function. So
2072 we rely on get_frame_address_in_block(), it provides us with
2073 a PC that is guaranteed to be inside the frame's code
2075 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2076 struct symtab
*s
= find_pc_symtab (pc
);
2082 return language_unknown
;
2086 /* Provide a prototype to silence -Wmissing-prototypes. */
2087 void _initialize_stack (void);
2090 _initialize_stack (void)
2093 backtrace_limit
= 30;
2096 add_com ("return", class_stack
, return_command
, _("\
2097 Make selected stack frame return to its caller.\n\
2098 Control remains in the debugger, but when you continue\n\
2099 execution will resume in the frame above the one now selected.\n\
2100 If an argument is given, it is an expression for the value to return."));
2102 add_com ("up", class_stack
, up_command
, _("\
2103 Select and print stack frame that called this one.\n\
2104 An argument says how many frames up to go."));
2105 add_com ("up-silently", class_support
, up_silently_command
, _("\
2106 Same as the `up' command, but does not print anything.\n\
2107 This is useful in command scripts."));
2109 add_com ("down", class_stack
, down_command
, _("\
2110 Select and print stack frame called by this one.\n\
2111 An argument says how many frames down to go."));
2112 add_com_alias ("do", "down", class_stack
, 1);
2113 add_com_alias ("dow", "down", class_stack
, 1);
2114 add_com ("down-silently", class_support
, down_silently_command
, _("\
2115 Same as the `down' command, but does not print anything.\n\
2116 This is useful in command scripts."));
2118 add_com ("frame", class_stack
, frame_command
, _("\
2119 Select and print a stack frame.\n\
2120 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2121 An argument specifies the frame to select.\n\
2122 It can be a stack frame number or the address of the frame.\n\
2123 With argument, nothing is printed if input is coming from\n\
2124 a command file or a user-defined command."));
2126 add_com_alias ("f", "frame", class_stack
, 1);
2130 add_com ("L", class_stack
, current_frame_command
,
2131 _("Print the current stack frame.\n"));
2132 add_com_alias ("V", "frame", class_stack
, 1);
2134 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2135 Select a stack frame without printing anything.\n\
2136 An argument specifies the frame to select.\n\
2137 It can be a stack frame number or the address of the frame.\n"));
2139 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2140 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2141 With a negative argument, print outermost -COUNT frames.\n\
2142 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2143 add_com_alias ("bt", "backtrace", class_stack
, 0);
2146 add_com_alias ("t", "backtrace", class_stack
, 0);
2147 add_com ("T", class_stack
, backtrace_full_command
, _("\
2148 Print backtrace of all stack frames, or innermost COUNT frames \n\
2149 and the values of the local variables.\n\
2150 With a negative argument, print outermost -COUNT frames.\n\
2151 Usage: T <count>\n"));
2154 add_com_alias ("where", "backtrace", class_alias
, 0);
2155 add_info ("stack", backtrace_command
,
2156 _("Backtrace of the stack, or innermost COUNT frames."));
2157 add_info_alias ("s", "stack", 1);
2158 add_info ("frame", frame_info
,
2159 _("All about selected stack frame, or frame at ADDR."));
2160 add_info_alias ("f", "frame", 1);
2161 add_info ("locals", locals_info
,
2162 _("Local variables of current stack frame."));
2163 add_info ("args", args_info
,
2164 _("Argument variables of current stack frame."));
2166 add_com ("l", class_info
, args_plus_locals_info
,
2167 _("Argument and local variables of current stack frame."));
2170 add_com ("func", class_stack
, func_command
, _("\
2171 Select the stack frame that contains <func>.\n\
2172 Usage: func <name>\n"));
2174 add_info ("catch", catch_info
,
2175 _("Exceptions that can be caught in the current stack frame."));
2177 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2178 print_frame_arguments_choices
, &print_frame_arguments
,
2179 _("Set printing of non-scalar frame arguments"),
2180 _("Show printing of non-scalar frame arguments"),
2181 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2183 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2184 &disassemble_next_line
, _("\
2185 Set whether to disassemble next source line or insn when execution stops."), _("\
2186 Show whether to disassemble next source line or insn when execution stops."), _("\
2187 If ON, GDB will display disassembly of the next source line, in addition\n\
2188 to displaying the source line itself. If the next source line cannot\n\
2189 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2190 will display disassembly of next instruction instead of showing the\n\
2192 If AUTO, display disassembly of next instruction only if the source line\n\
2193 cannot be displayed.\n\
2194 If OFF (which is the default), never display the disassembly of the next\n\
2197 show_disassemble_next_line
,
2198 &setlist
, &showlist
);
2199 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2202 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2203 "Specify maximum number of frames for \"backtrace\" to print by default."),
2205 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2206 The maximum number of frames for \"backtrace\" to print by default."));