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
;
487 gdb_disassembly (p
->gdbarch
, uiout
, 0,
488 DISASSEMBLY_RAW_INSN
, p
->how_many
,
492 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
493 because it will be broken by filter sometime. */
496 do_gdb_disassembly (struct gdbarch
*gdbarch
,
497 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
499 volatile struct gdb_exception exception
;
500 struct gdb_disassembly_stub_args args
;
502 args
.gdbarch
= gdbarch
;
503 args
.how_many
= how_many
;
506 TRY_CATCH (exception
, RETURN_MASK_ALL
)
508 gdb_disassembly_stub (&args
);
510 /* If an exception was thrown while doing the disassembly, print
511 the error message, to give the user a clue of what happened. */
512 if (exception
.reason
== RETURN_ERROR
)
513 exception_print (gdb_stderr
, exception
);
516 /* Print information about frame FRAME. The output is format according
517 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
520 SRC_LINE: Print only source line.
521 LOCATION: Print only location.
522 LOC_AND_SRC: Print location and source line.
524 Used in "where" output, and to emit breakpoint or step
528 print_frame_info (struct frame_info
*frame
, int print_level
,
529 enum print_what print_what
, int print_args
)
531 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
532 struct symtab_and_line sal
;
536 if (get_frame_type (frame
) == DUMMY_FRAME
537 || get_frame_type (frame
) == SIGTRAMP_FRAME
538 || get_frame_type (frame
) == ARCH_FRAME
)
540 struct cleanup
*uiout_cleanup
541 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
543 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
544 gdbarch
, get_frame_pc (frame
));
546 /* Do this regardless of SOURCE because we don't have any source
547 to list for this frame. */
550 ui_out_text (uiout
, "#");
551 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
552 frame_relative_level (frame
));
554 if (ui_out_is_mi_like_p (uiout
))
556 annotate_frame_address ();
557 ui_out_field_core_addr (uiout
, "addr",
558 gdbarch
, get_frame_pc (frame
));
559 annotate_frame_address_end ();
562 if (get_frame_type (frame
) == DUMMY_FRAME
)
564 annotate_function_call ();
565 ui_out_field_string (uiout
, "func", "<function called from gdb>");
567 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
569 annotate_signal_handler_caller ();
570 ui_out_field_string (uiout
, "func", "<signal handler called>");
572 else if (get_frame_type (frame
) == ARCH_FRAME
)
574 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
576 ui_out_text (uiout
, "\n");
577 annotate_frame_end ();
579 do_cleanups (uiout_cleanup
);
583 /* If FRAME is not the innermost frame, that normally means that
584 FRAME->pc points to *after* the call instruction, and we want to
585 get the line containing the call, never the next line. But if
586 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
587 next frame was not entered as the result of a call, and we want
588 to get the line containing FRAME->pc. */
589 find_frame_sal (frame
, &sal
);
591 location_print
= (print_what
== LOCATION
592 || print_what
== LOC_AND_ADDRESS
593 || print_what
== SRC_AND_LOC
);
595 if (location_print
|| !sal
.symtab
)
596 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
598 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
600 /* If disassemble-next-line is set to auto or on and doesn't have
601 the line debug messages for $pc, output the next instruction. */
602 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
603 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
604 && source_print
&& !sal
.symtab
)
605 do_gdb_disassembly (get_frame_arch (frame
), 1,
606 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
608 if (source_print
&& sal
.symtab
)
611 int mid_statement
= ((print_what
== SRC_LINE
)
612 && frame_show_address (frame
, sal
));
614 if (annotation_level
)
615 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
616 get_frame_pc (frame
));
619 if (deprecated_print_frame_info_listing_hook
)
620 deprecated_print_frame_info_listing_hook (sal
.symtab
,
625 struct value_print_options opts
;
626 get_user_print_options (&opts
);
627 /* We used to do this earlier, but that is clearly
628 wrong. This function is used by many different
629 parts of gdb, including normal_stop in infrun.c,
630 which uses this to print out the current PC
631 when we stepi/nexti into the middle of a source
632 line. Only the command line really wants this
633 behavior. Other UIs probably would like the
634 ability to decide for themselves if it is desired. */
635 if (opts
.addressprint
&& mid_statement
)
637 ui_out_field_core_addr (uiout
, "addr",
638 gdbarch
, get_frame_pc (frame
));
639 ui_out_text (uiout
, "\t");
642 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
646 /* If disassemble-next-line is set to on and there is line debug
647 messages, output assembly codes for next line. */
648 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
649 do_gdb_disassembly (get_frame_arch (frame
), -1, sal
.pc
, sal
.end
);
652 if (print_what
!= LOCATION
)
653 set_default_breakpoint (1, sal
.pspace
,
654 get_frame_pc (frame
), sal
.symtab
, sal
.line
);
656 annotate_frame_end ();
658 gdb_flush (gdb_stdout
);
661 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
664 find_frame_funname (struct frame_info
*frame
, char **funname
,
665 enum language
*funlang
)
670 *funlang
= language_unknown
;
672 func
= get_frame_function (frame
);
675 /* In certain pathological cases, the symtabs give the wrong
676 function (when we are in the first function in a file which
677 is compiled without debugging symbols, the previous function
678 is compiled with debugging symbols, and the "foo.o" symbol
679 that is supposed to tell us where the file with debugging
680 symbols ends has been truncated by ar because it is longer
681 than 15 characters). This also occurs if the user uses asm()
682 to create a function but not stabs for it (in a file compiled
685 So look in the minimal symbol tables as well, and if it comes
686 up with a larger address for the function use that instead.
687 I don't think this can ever cause any problems; there
688 shouldn't be any minimal symbols in the middle of a function;
689 if this is ever changed many parts of GDB will need to be
690 changed (and we'll create a find_pc_minimal_function or some
693 struct minimal_symbol
*msymbol
= NULL
;
695 /* Don't attempt to do this for inlined functions, which do not
696 have a corresponding minimal symbol. */
697 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
699 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
702 && (SYMBOL_VALUE_ADDRESS (msymbol
)
703 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
705 /* We also don't know anything about the function besides
706 its address and name. */
708 *funname
= SYMBOL_PRINT_NAME (msymbol
);
709 *funlang
= SYMBOL_LANGUAGE (msymbol
);
713 *funname
= SYMBOL_PRINT_NAME (func
);
714 *funlang
= SYMBOL_LANGUAGE (func
);
715 if (*funlang
== language_cplus
)
717 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
718 to display the demangled name that we already have
719 stored in the symbol table, but we stored a version
720 with DMGL_PARAMS turned on, and here we don't want to
721 display parameters. So remove the parameters. */
722 char *func_only
= cp_remove_params (*funname
);
725 *funname
= func_only
;
726 make_cleanup (xfree
, func_only
);
733 struct minimal_symbol
*msymbol
=
734 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
738 *funname
= SYMBOL_PRINT_NAME (msymbol
);
739 *funlang
= SYMBOL_LANGUAGE (msymbol
);
745 print_frame (struct frame_info
*frame
, int print_level
,
746 enum print_what print_what
, int print_args
,
747 struct symtab_and_line sal
)
749 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
750 char *funname
= NULL
;
751 enum language funlang
= language_unknown
;
752 struct ui_stream
*stb
;
753 struct cleanup
*old_chain
, *list_chain
;
754 struct value_print_options opts
;
756 stb
= ui_out_stream_new (uiout
);
757 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
759 find_frame_funname (frame
, &funname
, &funlang
);
761 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
762 gdbarch
, get_frame_pc (frame
));
764 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
768 ui_out_text (uiout
, "#");
769 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
770 frame_relative_level (frame
));
772 get_user_print_options (&opts
);
773 if (opts
.addressprint
)
774 if (frame_show_address (frame
, sal
) || !sal
.symtab
775 || print_what
== LOC_AND_ADDRESS
)
777 annotate_frame_address ();
778 ui_out_field_core_addr (uiout
, "addr", gdbarch
, get_frame_pc (frame
));
779 annotate_frame_address_end ();
780 ui_out_text (uiout
, " in ");
782 annotate_frame_function_name ();
783 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
785 ui_out_field_stream (uiout
, "func", stb
);
786 ui_out_wrap_hint (uiout
, " ");
787 annotate_frame_args ();
789 ui_out_text (uiout
, " (");
792 struct print_args_args args
;
793 struct cleanup
*args_list_chain
;
795 args
.func
= find_pc_function (get_frame_address_in_block (frame
));
796 args
.stream
= gdb_stdout
;
797 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
798 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
799 /* FIXME: ARGS must be a list. If one argument is a string it
800 will have " that will not be properly escaped. */
801 /* Invoke ui_out_tuple_end. */
802 do_cleanups (args_list_chain
);
805 ui_out_text (uiout
, ")");
806 if (sal
.symtab
&& sal
.symtab
->filename
)
808 annotate_frame_source_begin ();
809 ui_out_wrap_hint (uiout
, " ");
810 ui_out_text (uiout
, " at ");
811 annotate_frame_source_file ();
812 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
813 if (ui_out_is_mi_like_p (uiout
))
815 const char *fullname
= symtab_to_fullname (sal
.symtab
);
816 if (fullname
!= NULL
)
817 ui_out_field_string (uiout
, "fullname", fullname
);
819 annotate_frame_source_file_end ();
820 ui_out_text (uiout
, ":");
821 annotate_frame_source_line ();
822 ui_out_field_int (uiout
, "line", sal
.line
);
823 annotate_frame_source_end ();
826 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
829 char *lib
= PC_SOLIB (get_frame_pc (frame
));
831 char *lib
= solib_name_from_address (get_frame_program_space (frame
),
832 get_frame_pc (frame
));
836 annotate_frame_where ();
837 ui_out_wrap_hint (uiout
, " ");
838 ui_out_text (uiout
, " from ");
839 ui_out_field_string (uiout
, "from", lib
);
843 /* do_cleanups will call ui_out_tuple_end() for us. */
844 do_cleanups (list_chain
);
845 ui_out_text (uiout
, "\n");
846 do_cleanups (old_chain
);
850 /* Read a frame specification in whatever the appropriate format is
851 from FRAME_EXP. Call error(), printing MESSAGE, if the
852 specification is in any way invalid (so this function never returns
853 NULL). When SEPECTED_P is non-NULL set its target to indicate that
854 the default selected frame was used. */
856 static struct frame_info
*
857 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
858 int *selected_frame_p
)
861 struct value
*args
[4];
862 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
864 if (frame_exp
== NULL
)
869 struct cleanup
*tmp_cleanup
;
875 struct cleanup
*cleanup
;
878 /* Skip leading white space, bail of EOL. */
879 while (isspace (*frame_exp
))
884 /* Parse the argument, extract it, save it. */
888 addr_string
= savestring (frame_exp
, p
- frame_exp
);
890 cleanup
= make_cleanup (xfree
, addr_string
);
892 /* NOTE: Parse and evaluate expression, but do not use
893 functions such as parse_and_eval_long or
894 parse_and_eval_address to also extract the value.
895 Instead value_as_long and value_as_address are used.
896 This avoids problems with expressions that contain
898 if (numargs
>= ARRAY_SIZE (args
))
899 error (_("Too many args in frame specification"));
900 args
[numargs
++] = parse_and_eval (addr_string
);
902 do_cleanups (cleanup
);
906 /* If no args, default to the selected frame. */
909 if (selected_frame_p
!= NULL
)
910 (*selected_frame_p
) = 1;
911 return get_selected_frame (message
);
914 /* None of the remaining use the selected frame. */
915 if (selected_frame_p
!= NULL
)
916 (*selected_frame_p
) = 0;
918 /* Assume the single arg[0] is an integer, and try using that to
919 select a frame relative to current. */
922 struct frame_info
*fid
;
923 int level
= value_as_long (args
[0]);
924 fid
= find_relative_frame (get_current_frame (), &level
);
926 /* find_relative_frame was successful */
930 /* Convert each value into a corresponding address. */
933 for (i
= 0; i
< numargs
; i
++)
934 addrs
[i
] = value_as_address (args
[i
]);
937 /* Assume that the single arg[0] is an address, use that to identify
938 a frame with a matching ID. Should this also accept stack/pc or
942 struct frame_id id
= frame_id_build_wild (addrs
[0]);
943 struct frame_info
*fid
;
945 /* If (s)he specifies the frame with an address, he deserves
946 what (s)he gets. Still, give the highest one that matches.
947 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
949 for (fid
= get_current_frame ();
951 fid
= get_prev_frame (fid
))
953 if (frame_id_eq (id
, get_frame_id (fid
)))
955 struct frame_info
*prev_frame
;
959 prev_frame
= get_prev_frame (fid
);
961 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
970 /* We couldn't identify the frame as an existing frame, but
971 perhaps we can create one with a single argument. */
973 return create_new_frame (addrs
[0], 0);
974 else if (numargs
== 2)
975 return create_new_frame (addrs
[0], addrs
[1]);
977 error (_("Too many args in frame specification"));
980 static struct frame_info
*
981 parse_frame_specification (char *frame_exp
)
983 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
986 /* Print verbosely the selected frame or the frame at address
987 ADDR_EXP. Absolutely all information in the frame is printed. */
990 frame_info (char *addr_exp
, int from_tty
)
992 struct frame_info
*fi
;
993 struct symtab_and_line sal
;
996 struct frame_info
*calling_frame_info
;
997 int i
, count
, numregs
;
999 enum language funlang
= language_unknown
;
1000 const char *pc_regname
;
1001 int selected_frame_p
;
1002 struct gdbarch
*gdbarch
;
1003 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
1005 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
1006 gdbarch
= get_frame_arch (fi
);
1008 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1009 is not a good name. */
1010 if (gdbarch_pc_regnum (gdbarch
) >= 0)
1011 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1012 easily not match that of the internal value returned by
1014 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1016 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1017 architectures will often have a hardware register called "pc",
1018 and that register's value, again, can easily not match
1022 find_frame_sal (fi
, &sal
);
1023 func
= get_frame_function (fi
);
1024 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1026 s
= find_pc_symtab (get_frame_pc (fi
));
1029 funname
= SYMBOL_PRINT_NAME (func
);
1030 funlang
= SYMBOL_LANGUAGE (func
);
1031 if (funlang
== language_cplus
)
1033 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1034 to display the demangled name that we already have
1035 stored in the symbol table, but we stored a version
1036 with DMGL_PARAMS turned on, and here we don't want to
1037 display parameters. So remove the parameters. */
1038 char *func_only
= cp_remove_params (funname
);
1041 funname
= func_only
;
1042 make_cleanup (xfree
, func_only
);
1048 struct minimal_symbol
*msymbol
;
1050 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1051 if (msymbol
!= NULL
)
1053 funname
= SYMBOL_PRINT_NAME (msymbol
);
1054 funlang
= SYMBOL_LANGUAGE (msymbol
);
1057 calling_frame_info
= get_prev_frame (fi
);
1059 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1061 printf_filtered (_("Stack level %d, frame at "),
1062 frame_relative_level (fi
));
1066 printf_filtered (_("Stack frame at "));
1068 fputs_filtered (paddress (gdbarch
, get_frame_base (fi
)), gdb_stdout
);
1069 printf_filtered (":\n");
1070 printf_filtered (" %s = ", pc_regname
);
1071 fputs_filtered (paddress (gdbarch
, get_frame_pc (fi
)), gdb_stdout
);
1076 printf_filtered (" in ");
1077 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1078 DMGL_ANSI
| DMGL_PARAMS
);
1082 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1083 puts_filtered ("; ");
1085 printf_filtered ("saved %s ", pc_regname
);
1086 fputs_filtered (paddress (gdbarch
, frame_unwind_caller_pc (fi
)), gdb_stdout
);
1087 printf_filtered ("\n");
1089 if (calling_frame_info
== NULL
)
1091 enum unwind_stop_reason reason
;
1093 reason
= get_frame_unwind_stop_reason (fi
);
1094 if (reason
!= UNWIND_NO_REASON
)
1095 printf_filtered (_(" Outermost frame: %s\n"),
1096 frame_stop_reason_string (reason
));
1098 else if (get_frame_type (fi
) == INLINE_FRAME
)
1099 printf_filtered (" inlined into frame %d",
1100 frame_relative_level (get_prev_frame (fi
)));
1103 printf_filtered (" called by frame at ");
1104 fputs_filtered (paddress (gdbarch
, get_frame_base (calling_frame_info
)),
1107 if (get_next_frame (fi
) && calling_frame_info
)
1108 puts_filtered (",");
1110 if (get_next_frame (fi
))
1112 printf_filtered (" caller of frame at ");
1113 fputs_filtered (paddress (gdbarch
, get_frame_base (get_next_frame (fi
))),
1116 if (get_next_frame (fi
) || calling_frame_info
)
1117 puts_filtered ("\n");
1120 printf_filtered (" source language %s.\n",
1121 language_str (s
->language
));
1124 /* Address of the argument list for this frame, or 0. */
1125 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1126 /* Number of args for this frame, or -1 if unknown. */
1130 printf_filtered (" Arglist at unknown address.\n");
1133 printf_filtered (" Arglist at ");
1134 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1135 printf_filtered (",");
1137 if (!gdbarch_frame_num_args_p (gdbarch
))
1140 puts_filtered (" args: ");
1144 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1145 gdb_assert (numargs
>= 0);
1147 puts_filtered (" no args.");
1148 else if (numargs
== 1)
1149 puts_filtered (" 1 arg: ");
1151 printf_filtered (" %d args: ", numargs
);
1153 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1154 puts_filtered ("\n");
1158 /* Address of the local variables for this frame, or 0. */
1159 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1162 printf_filtered (" Locals at unknown address,");
1165 printf_filtered (" Locals at ");
1166 fputs_filtered (paddress (gdbarch
, arg_list
), gdb_stdout
);
1167 printf_filtered (",");
1171 /* Print as much information as possible on the location of all the
1174 enum lval_type lval
;
1182 /* The sp is special; what's displayed isn't the save address, but
1183 the value of the previous frame's sp. This is a legacy thing,
1184 at one stage the frame cached the previous frame's SP instead
1185 of its address, hence it was easiest to just display the cached
1187 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1189 /* Find out the location of the saved stack pointer with out
1190 actually evaluating it. */
1191 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1192 &optimized
, &lval
, &addr
,
1194 if (!optimized
&& lval
== not_lval
)
1196 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1197 int sp_size
= register_size (gdbarch
, gdbarch_sp_regnum (gdbarch
));
1198 gdb_byte value
[MAX_REGISTER_SIZE
];
1200 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1201 &optimized
, &lval
, &addr
,
1203 /* NOTE: cagney/2003-05-22: This is assuming that the
1204 stack pointer was packed as an unsigned integer. That
1205 may or may not be valid. */
1206 sp
= extract_unsigned_integer (value
, sp_size
, byte_order
);
1207 printf_filtered (" Previous frame's sp is ");
1208 fputs_filtered (paddress (gdbarch
, sp
), gdb_stdout
);
1209 printf_filtered ("\n");
1212 else if (!optimized
&& lval
== lval_memory
)
1214 printf_filtered (" Previous frame's sp at ");
1215 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1216 printf_filtered ("\n");
1219 else if (!optimized
&& lval
== lval_register
)
1221 printf_filtered (" Previous frame's sp in %s\n",
1222 gdbarch_register_name (gdbarch
, realnum
));
1225 /* else keep quiet. */
1229 numregs
= gdbarch_num_regs (gdbarch
)
1230 + gdbarch_num_pseudo_regs (gdbarch
);
1231 for (i
= 0; i
< numregs
; i
++)
1232 if (i
!= gdbarch_sp_regnum (gdbarch
)
1233 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1235 /* Find out the location of the saved register without
1236 fetching the corresponding value. */
1237 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1239 /* For moment, only display registers that were saved on the
1241 if (!optimized
&& lval
== lval_memory
)
1244 puts_filtered (" Saved registers:\n ");
1246 puts_filtered (",");
1248 printf_filtered (" %s at ",
1249 gdbarch_register_name (gdbarch
, i
));
1250 fputs_filtered (paddress (gdbarch
, addr
), gdb_stdout
);
1254 if (count
|| need_nl
)
1255 puts_filtered ("\n");
1258 do_cleanups (back_to
);
1261 /* Print briefly all stack frames or just the innermost COUNT_EXP
1265 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1267 struct frame_info
*fi
;
1270 struct frame_info
*trailing
;
1273 if (!target_has_stack
)
1274 error (_("No stack."));
1276 /* The following code must do two things. First, it must set the
1277 variable TRAILING to the frame from which we should start
1278 printing. Second, it must set the variable count to the number
1279 of frames which we should print, or -1 if all of them. */
1280 trailing
= get_current_frame ();
1285 count
= parse_and_eval_long (count_exp
);
1288 struct frame_info
*current
;
1293 while (current
&& count
--)
1296 current
= get_prev_frame (current
);
1299 /* Will stop when CURRENT reaches the top of the stack.
1300 TRAILING will be COUNT below it. */
1304 trailing
= get_prev_frame (trailing
);
1305 current
= get_prev_frame (current
);
1317 struct partial_symtab
*ps
;
1319 /* Read in symbols for all of the frames. Need to do this in a
1320 separate pass so that "Reading in symbols for xxx" messages
1321 don't screw up the appearance of the backtrace. Also if
1322 people have strong opinions against reading symbols for
1323 backtrace this may have to be an option. */
1325 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1329 pc
= get_frame_address_in_block (fi
);
1330 find_pc_sect_symtab_via_partial (pc
, find_pc_mapped_section (pc
));
1334 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1338 /* Don't use print_stack_frame; if an error() occurs it probably
1339 means further attempts to backtrace would fail (on the other
1340 hand, perhaps the code does or could be fixed to make sure
1341 the frame->prev field gets set to NULL in that case). */
1342 print_frame_info (fi
, 1, LOCATION
, 1);
1344 print_frame_local_vars (fi
, 1, gdb_stdout
);
1346 /* Save the last frame to check for error conditions. */
1350 /* If we've stopped before the end, mention that. */
1352 printf_filtered (_("(More stack frames follow...)\n"));
1354 /* If we've run out of frames, and the reason appears to be an error
1355 condition, print it. */
1356 if (fi
== NULL
&& trailing
!= NULL
)
1358 enum unwind_stop_reason reason
;
1360 reason
= get_frame_unwind_stop_reason (trailing
);
1361 if (reason
> UNWIND_FIRST_ERROR
)
1362 printf_filtered (_("Backtrace stopped: %s\n"),
1363 frame_stop_reason_string (reason
));
1367 struct backtrace_command_args
1374 /* Stub for catch_errors. */
1377 backtrace_command_stub (void *data
)
1379 struct backtrace_command_args
*args
= data
;
1380 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1385 backtrace_command (char *arg
, int from_tty
)
1387 struct cleanup
*old_chain
= NULL
;
1388 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1389 struct backtrace_command_args btargs
;
1396 argv
= gdb_buildargv (arg
);
1397 old_chain
= make_cleanup_freeargv (argv
);
1399 for (i
= 0; argv
[i
]; i
++)
1403 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1404 argv
[i
][j
] = tolower (argv
[i
][j
]);
1406 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1407 fulltrace_arg
= argc
;
1410 arglen
+= strlen (argv
[i
]);
1415 if (fulltrace_arg
>= 0)
1419 arg
= xmalloc (arglen
+ 1);
1420 memset (arg
, 0, arglen
+ 1);
1421 for (i
= 0; i
< (argc
+ 1); i
++)
1423 if (i
!= fulltrace_arg
)
1425 strcat (arg
, argv
[i
]);
1435 btargs
.count_exp
= arg
;
1436 btargs
.show_locals
= (fulltrace_arg
>= 0);
1437 btargs
.from_tty
= from_tty
;
1438 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1440 if (fulltrace_arg
>= 0 && arglen
> 0)
1444 do_cleanups (old_chain
);
1448 backtrace_full_command (char *arg
, int from_tty
)
1450 struct backtrace_command_args btargs
;
1451 btargs
.count_exp
= arg
;
1452 btargs
.show_locals
= 1;
1453 btargs
.from_tty
= from_tty
;
1454 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1458 /* Print the local variables of a block B active in FRAME on STREAM.
1459 Return 1 if any variables were printed; 0 otherwise. */
1462 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1463 int num_tabs
, struct ui_file
*stream
)
1465 struct dict_iterator iter
;
1467 int values_printed
= 0;
1470 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1472 switch (SYMBOL_CLASS (sym
))
1478 if (SYMBOL_IS_ARGUMENT (sym
))
1481 print_variable_and_value (NULL
, sym
, frame
, stream
, 4 * num_tabs
);
1485 /* Ignore symbols which are not locals. */
1490 return values_printed
;
1494 /* Same, but print labels. */
1497 /* Commented out, as the code using this function has also been
1498 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1499 was commented out in the first place. The discussion introducing
1500 this change (2007-12-04: Support lexical blocks and function bodies
1501 that occupy non-contiguous address ranges) did not explain why
1502 this change was made. */
1504 print_block_frame_labels (struct gdbarch
*gdbarch
, struct block
*b
,
1505 int *have_default
, struct ui_file
*stream
)
1507 struct dict_iterator iter
;
1509 int values_printed
= 0;
1511 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1513 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1519 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1521 struct symtab_and_line sal
;
1522 struct value_print_options opts
;
1523 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1525 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1526 get_user_print_options (&opts
);
1527 if (opts
.addressprint
)
1529 fprintf_filtered (stream
, " ");
1530 fputs_filtered (paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (sym
)),
1533 fprintf_filtered (stream
, " in file %s, line %d\n",
1534 sal
.symtab
->filename
, sal
.line
);
1538 return values_printed
;
1542 /* Print on STREAM all the local variables in frame FRAME, including
1543 all the blocks active in that frame at its current PC.
1545 Returns 1 if the job was done, or 0 if nothing was printed because
1546 we have no info on the function running in FRAME. */
1549 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1550 struct ui_file
*stream
)
1552 struct block
*block
= get_frame_block (frame
, 0);
1553 int values_printed
= 0;
1557 fprintf_filtered (stream
, "No symbol table info available.\n");
1563 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1565 /* After handling the function's top-level block, stop. Don't
1566 continue to its superblock, the block of per-file symbols.
1567 Also do not continue to the containing function of an inlined
1569 if (BLOCK_FUNCTION (block
))
1571 block
= BLOCK_SUPERBLOCK (block
);
1574 if (!values_printed
)
1575 fprintf_filtered (stream
, _("No locals.\n"));
1578 /* Same, but print labels. */
1581 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1582 struct ui_file
*stream
)
1585 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1587 struct blockvector
*bl
;
1588 struct block
*block
= get_frame_block (frame
, 0);
1589 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1590 int values_printed
= 0;
1591 int index
, have_default
= 0;
1592 char *blocks_printed
;
1593 CORE_ADDR pc
= get_frame_pc (frame
);
1597 fprintf_filtered (stream
, "No symbol table info available.\n");
1601 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1602 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1603 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1607 CORE_ADDR end
= BLOCK_END (block
) - 4;
1610 if (bl
!= blockvector_for_pc (end
, &index
))
1611 error (_("blockvector blotch"));
1612 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1613 error (_("blockvector botch"));
1614 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1617 /* Don't print out blocks that have gone by. */
1618 while (index
< last_index
1619 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1622 while (index
< last_index
1623 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1625 if (blocks_printed
[index
] == 0)
1627 if (print_block_frame_labels (gdbarch
,
1628 BLOCKVECTOR_BLOCK (bl
, index
),
1629 &have_default
, stream
))
1631 blocks_printed
[index
] = 1;
1637 if (values_printed
&& this_level_only
)
1640 /* After handling the function's top-level block, stop. Don't
1641 continue to its superblock, the block of per-file symbols.
1642 Also do not continue to the containing function of an inlined
1644 if (BLOCK_FUNCTION (block
))
1646 block
= BLOCK_SUPERBLOCK (block
);
1649 if (!values_printed
&& !this_level_only
)
1650 fprintf_filtered (stream
, _("No catches.\n"));
1655 locals_info (char *args
, int from_tty
)
1657 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1662 catch_info (char *ignore
, int from_tty
)
1664 struct symtab_and_line
*sal
;
1666 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1667 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1672 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1674 struct symbol
*func
= get_frame_function (frame
);
1676 struct dict_iterator iter
;
1677 struct symbol
*sym
, *sym2
;
1678 int values_printed
= 0;
1682 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1686 b
= SYMBOL_BLOCK_VALUE (func
);
1687 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1689 /* Don't worry about things which aren't arguments. */
1690 if (SYMBOL_IS_ARGUMENT (sym
))
1694 /* We have to look up the symbol because arguments can have
1695 two entries (one a parameter, one a local) and the one we
1696 want is the local, which lookup_symbol will find for us.
1697 This includes gcc1 (not gcc2) on the sparc when passing a
1698 small structure and gcc2 when the argument type is float
1699 and it is passed as a double and converted to float by
1700 the prologue (in the latter case the type of the LOC_ARG
1701 symbol is double and the type of the LOC_LOCAL symbol is
1702 float). There are also LOC_ARG/LOC_REGISTER pairs which
1703 are not combined in symbol-reading. */
1705 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1706 b
, VAR_DOMAIN
, NULL
);
1707 print_variable_and_value (SYMBOL_PRINT_NAME (sym
), sym2
,
1712 if (!values_printed
)
1713 fprintf_filtered (stream
, _("No arguments.\n"));
1717 args_info (char *ignore
, int from_tty
)
1719 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1725 args_plus_locals_info (char *ignore
, int from_tty
)
1727 args_info (ignore
, from_tty
);
1728 locals_info (ignore
, from_tty
);
1732 /* Select frame FRAME. Also print the stack frame and show the source
1733 if this is the tui version. */
1735 select_and_print_frame (struct frame_info
*frame
)
1737 select_frame (frame
);
1739 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1742 /* Return the symbol-block in which the selected frame is executing.
1743 Can return zero under various legitimate circumstances.
1745 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1746 code address within the block returned. We use this to decide
1747 which macros are in scope. */
1750 get_selected_block (CORE_ADDR
*addr_in_block
)
1752 if (!has_stack_frames ())
1755 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1758 /* Find a frame a certain number of levels away from FRAME.
1759 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1760 Positive means go to earlier frames (up); negative, the reverse.
1761 The int that contains the number of levels is counted toward
1762 zero as the frames for those levels are found.
1763 If the top or bottom frame is reached, that frame is returned,
1764 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1765 how much farther the original request asked to go. */
1768 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1770 /* Going up is simple: just call get_prev_frame enough times or
1771 until the initial frame is reached. */
1772 while (*level_offset_ptr
> 0)
1774 struct frame_info
*prev
= get_prev_frame (frame
);
1777 (*level_offset_ptr
)--;
1781 /* Going down is just as simple. */
1782 while (*level_offset_ptr
< 0)
1784 struct frame_info
*next
= get_next_frame (frame
);
1787 (*level_offset_ptr
)++;
1794 /* The "select_frame" command. With no argument this is a NOP.
1795 Select the frame at level LEVEL_EXP if it is a valid level.
1796 Otherwise, treat LEVEL_EXP as an address expression and select it.
1798 See parse_frame_specification for more info on proper frame
1802 select_frame_command (char *level_exp
, int from_tty
)
1804 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1807 /* The "frame" command. With no argument, print the selected frame
1808 briefly. With an argument, behave like select_frame and then print
1809 the selected frame. */
1812 frame_command (char *level_exp
, int from_tty
)
1814 select_frame_command (level_exp
, from_tty
);
1815 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1818 /* The XDB Compatibility command to print the current frame. */
1821 current_frame_command (char *level_exp
, int from_tty
)
1823 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1826 /* Select the frame up one or COUNT_EXP stack levels from the
1827 previously selected frame, and print it briefly. */
1830 up_silently_base (char *count_exp
)
1832 struct frame_info
*frame
;
1836 count
= parse_and_eval_long (count_exp
);
1838 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1839 if (count
!= 0 && count_exp
== NULL
)
1840 error (_("Initial frame selected; you cannot go up."));
1841 select_frame (frame
);
1845 up_silently_command (char *count_exp
, int from_tty
)
1847 up_silently_base (count_exp
);
1851 up_command (char *count_exp
, int from_tty
)
1853 up_silently_base (count_exp
);
1854 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1857 /* Select the frame down one or COUNT_EXP stack levels from the previously
1858 selected frame, and print it briefly. */
1861 down_silently_base (char *count_exp
)
1863 struct frame_info
*frame
;
1866 count
= -parse_and_eval_long (count_exp
);
1868 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1869 if (count
!= 0 && count_exp
== NULL
)
1871 /* We only do this if COUNT_EXP is not specified. That way
1872 "down" means to really go down (and let me know if that is
1873 impossible), but "down 9999" can be used to mean go all the
1874 way down without getting an error. */
1876 error (_("Bottom (innermost) frame selected; you cannot go down."));
1879 select_frame (frame
);
1883 down_silently_command (char *count_exp
, int from_tty
)
1885 down_silently_base (count_exp
);
1889 down_command (char *count_exp
, int from_tty
)
1891 down_silently_base (count_exp
);
1892 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1897 return_command (char *retval_exp
, int from_tty
)
1899 struct frame_info
*thisframe
;
1900 struct gdbarch
*gdbarch
;
1901 struct symbol
*thisfun
;
1902 struct value
*return_value
= NULL
;
1903 const char *query_prefix
= "";
1905 thisframe
= get_selected_frame ("No selected frame.");
1906 thisfun
= get_frame_function (thisframe
);
1907 gdbarch
= get_frame_arch (thisframe
);
1909 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
1910 error (_("Can not force return from an inlined function."));
1912 /* Compute the return value. If the computation triggers an error,
1913 let it bail. If the return type can't be handled, set
1914 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1918 struct expression
*retval_expr
= parse_expression (retval_exp
);
1919 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1920 struct type
*return_type
= NULL
;
1922 /* Compute the return value. Should the computation fail, this
1923 call throws an error. */
1924 return_value
= evaluate_expression (retval_expr
);
1926 /* Cast return value to the return type of the function. Should
1927 the cast fail, this call throws an error. */
1928 if (thisfun
!= NULL
)
1929 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1930 if (return_type
== NULL
)
1932 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1933 error (_("Return value type not available for selected "
1935 "Please use an explicit cast of the value to return."));
1936 return_type
= value_type (return_value
);
1938 do_cleanups (old_chain
);
1939 CHECK_TYPEDEF (return_type
);
1940 return_value
= value_cast (return_type
, return_value
);
1942 /* Make sure the value is fully evaluated. It may live in the
1943 stack frame we're about to pop. */
1944 if (value_lazy (return_value
))
1945 value_fetch_lazy (return_value
);
1947 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1948 /* If the return-type is "void", don't try to find the
1949 return-value's location. However, do still evaluate the
1950 return expression so that, even when the expression result
1951 is discarded, side effects such as "return i++" still
1953 return_value
= NULL
;
1954 else if (thisfun
!= NULL
1955 && using_struct_return (gdbarch
,
1956 SYMBOL_TYPE (thisfun
), return_type
))
1959 The location at which to store the function's return value is unknown.\n\
1960 If you continue, the return value that you specified will be ignored.\n";
1961 return_value
= NULL
;
1965 /* Does an interactive user really want to do this? Include
1966 information, such as how well GDB can handle the return value, in
1967 the query message. */
1971 if (thisfun
== NULL
)
1972 confirmed
= query (_("%sMake selected stack frame return now? "),
1975 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1976 SYMBOL_PRINT_NAME (thisfun
));
1978 error (_("Not confirmed"));
1981 /* Discard the selected frame and all frames inner-to it. */
1982 frame_pop (get_selected_frame (NULL
));
1984 /* Store RETURN_VALUE in the just-returned register set. */
1985 if (return_value
!= NULL
)
1987 struct type
*return_type
= value_type (return_value
);
1988 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1989 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
1991 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
1993 == RETURN_VALUE_REGISTER_CONVENTION
);
1994 gdbarch_return_value (gdbarch
, func_type
, return_type
,
1995 get_current_regcache (), NULL
/*read*/,
1996 value_contents (return_value
) /*write*/);
1999 /* If we are at the end of a call dummy now, pop the dummy frame
2001 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
2002 frame_pop (get_current_frame ());
2004 /* If interactive, print the frame that is now current. */
2006 frame_command ("0", 1);
2008 select_frame_command ("0", 0);
2011 /* Sets the scope to input function name, provided that the function
2012 is within the current stack frame */
2014 struct function_bounds
2016 CORE_ADDR low
, high
;
2020 func_command (char *arg
, int from_tty
)
2022 struct frame_info
*frame
;
2024 struct symtabs_and_lines sals
;
2027 struct function_bounds
*func_bounds
= NULL
;
2032 frame
= parse_frame_specification ("0");
2033 sals
= decode_line_spec (arg
, 1);
2034 func_bounds
= (struct function_bounds
*) xmalloc (
2035 sizeof (struct function_bounds
) * sals
.nelts
);
2036 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2038 if (sals
.sals
[i
].pc
== 0
2039 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2040 &func_bounds
[i
].low
,
2041 &func_bounds
[i
].high
) == 0)
2043 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2049 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2050 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2051 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2055 frame
= find_relative_frame (frame
, &level
);
2058 while (!found
&& level
== 0);
2061 xfree (func_bounds
);
2064 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2065 else if (frame
!= get_selected_frame (NULL
))
2066 select_and_print_frame (frame
);
2069 /* Gets the language of the current frame. */
2072 get_frame_language (void)
2074 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2078 /* We determine the current frame language by looking up its
2079 associated symtab. To retrieve this symtab, we use the frame
2080 PC. However we cannot use the frame PC as is, because it
2081 usually points to the instruction following the "call", which
2082 is sometimes the first instruction of another function. So
2083 we rely on get_frame_address_in_block(), it provides us with
2084 a PC that is guaranteed to be inside the frame's code
2086 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2087 struct symtab
*s
= find_pc_symtab (pc
);
2093 return language_unknown
;
2097 /* Provide a prototype to silence -Wmissing-prototypes. */
2098 void _initialize_stack (void);
2101 _initialize_stack (void)
2104 backtrace_limit
= 30;
2107 add_com ("return", class_stack
, return_command
, _("\
2108 Make selected stack frame return to its caller.\n\
2109 Control remains in the debugger, but when you continue\n\
2110 execution will resume in the frame above the one now selected.\n\
2111 If an argument is given, it is an expression for the value to return."));
2113 add_com ("up", class_stack
, up_command
, _("\
2114 Select and print stack frame that called this one.\n\
2115 An argument says how many frames up to go."));
2116 add_com ("up-silently", class_support
, up_silently_command
, _("\
2117 Same as the `up' command, but does not print anything.\n\
2118 This is useful in command scripts."));
2120 add_com ("down", class_stack
, down_command
, _("\
2121 Select and print stack frame called by this one.\n\
2122 An argument says how many frames down to go."));
2123 add_com_alias ("do", "down", class_stack
, 1);
2124 add_com_alias ("dow", "down", class_stack
, 1);
2125 add_com ("down-silently", class_support
, down_silently_command
, _("\
2126 Same as the `down' command, but does not print anything.\n\
2127 This is useful in command scripts."));
2129 add_com ("frame", class_stack
, frame_command
, _("\
2130 Select and print a stack frame.\n\
2131 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2132 An argument specifies the frame to select.\n\
2133 It can be a stack frame number or the address of the frame.\n\
2134 With argument, nothing is printed if input is coming from\n\
2135 a command file or a user-defined command."));
2137 add_com_alias ("f", "frame", class_stack
, 1);
2141 add_com ("L", class_stack
, current_frame_command
,
2142 _("Print the current stack frame.\n"));
2143 add_com_alias ("V", "frame", class_stack
, 1);
2145 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2146 Select a stack frame without printing anything.\n\
2147 An argument specifies the frame to select.\n\
2148 It can be a stack frame number or the address of the frame.\n"));
2150 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2151 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2152 With a negative argument, print outermost -COUNT frames.\n\
2153 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2154 add_com_alias ("bt", "backtrace", class_stack
, 0);
2157 add_com_alias ("t", "backtrace", class_stack
, 0);
2158 add_com ("T", class_stack
, backtrace_full_command
, _("\
2159 Print backtrace of all stack frames, or innermost COUNT frames \n\
2160 and the values of the local variables.\n\
2161 With a negative argument, print outermost -COUNT frames.\n\
2162 Usage: T <count>\n"));
2165 add_com_alias ("where", "backtrace", class_alias
, 0);
2166 add_info ("stack", backtrace_command
,
2167 _("Backtrace of the stack, or innermost COUNT frames."));
2168 add_info_alias ("s", "stack", 1);
2169 add_info ("frame", frame_info
,
2170 _("All about selected stack frame, or frame at ADDR."));
2171 add_info_alias ("f", "frame", 1);
2172 add_info ("locals", locals_info
,
2173 _("Local variables of current stack frame."));
2174 add_info ("args", args_info
,
2175 _("Argument variables of current stack frame."));
2177 add_com ("l", class_info
, args_plus_locals_info
,
2178 _("Argument and local variables of current stack frame."));
2181 add_com ("func", class_stack
, func_command
, _("\
2182 Select the stack frame that contains <func>.\n\
2183 Usage: func <name>\n"));
2185 add_info ("catch", catch_info
,
2186 _("Exceptions that can be caught in the current stack frame."));
2188 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2189 print_frame_arguments_choices
, &print_frame_arguments
,
2190 _("Set printing of non-scalar frame arguments"),
2191 _("Show printing of non-scalar frame arguments"),
2192 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2194 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2195 &disassemble_next_line
, _("\
2196 Set whether to disassemble next source line or insn when execution stops."), _("\
2197 Show whether to disassemble next source line or insn when execution stops."), _("\
2198 If ON, GDB will display disassembly of the next source line, in addition\n\
2199 to displaying the source line itself. If the next source line cannot\n\
2200 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2201 will display disassembly of next instruction instead of showing the\n\
2203 If AUTO, display disassembly of next instruction only if the source line\n\
2204 cannot be displayed.\n\
2205 If OFF (which is the default), never display the disassembly of the next\n\
2208 show_disassemble_next_line
,
2209 &setlist
, &showlist
);
2210 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2213 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2214 "Specify maximum number of frames for \"backtrace\" to print by default."),
2216 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2217 The maximum number of frames for \"backtrace\" to print by default."));