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
)
171 for (i
= 0; i
< num
; i
++)
174 argsaddr
= get_frame_args_address (frame
);
177 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
179 fprintf_filtered (stream
, ", ");
180 fprintf_filtered (stream
, "%ld", arg_value
);
182 start
+= sizeof (int);
186 /* Print the arguments of frame FRAME on STREAM, given the function
187 FUNC running in that frame (as a symbol), where NUM is the number
188 of arguments according to the stack frame (or -1 if the number of
189 arguments is unknown). */
191 /* Note that currently the "number of arguments according to the
192 stack frame" is only known on VAX where i refers to the "number of
193 ints of arguments according to the stack frame". */
196 print_frame_args (struct symbol
*func
, struct frame_info
*frame
,
197 int num
, struct ui_file
*stream
)
200 /* Offset of next stack argument beyond the one we have seen that is
201 at the highest offset, or -1 if we haven't come to a stack
203 long highest_offset
= -1;
204 /* Number of ints of arguments that we have printed so far. */
205 int args_printed
= 0;
206 struct cleanup
*old_chain
, *list_chain
;
207 struct ui_stream
*stb
;
208 /* True if we should print arguments, false otherwise. */
209 int print_args
= strcmp (print_frame_arguments
, "none");
210 /* True in "summary" mode, false otherwise. */
211 int summary
= !strcmp (print_frame_arguments
, "scalars");
213 stb
= ui_out_stream_new (uiout
);
214 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
218 struct block
*b
= SYMBOL_BLOCK_VALUE (func
);
219 struct dict_iterator iter
;
223 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
227 /* Keep track of the highest stack argument offset seen, and
228 skip over any kinds of symbols we don't care about. */
230 if (!SYMBOL_IS_ARGUMENT (sym
))
233 switch (SYMBOL_CLASS (sym
))
238 long current_offset
= SYMBOL_VALUE (sym
);
239 int arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
241 /* Compute address of next argument by adding the size of
242 this argument and rounding to an int boundary. */
244 ((current_offset
+ arg_size
+ sizeof (int) - 1)
245 & ~(sizeof (int) - 1));
247 /* If this is the highest offset seen yet, set
249 if (highest_offset
== -1
250 || (current_offset
> highest_offset
))
251 highest_offset
= current_offset
;
253 /* Add the number of ints we're about to print to
255 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
258 /* We care about types of symbols, but don't need to
259 keep track of stack offsets in them. */
261 case LOC_REGPARM_ADDR
:
263 case LOC_OPTIMIZED_OUT
:
268 /* We have to look up the symbol because arguments can have
269 two entries (one a parameter, one a local) and the one we
270 want is the local, which lookup_symbol will find for us.
271 This includes gcc1 (not gcc2) on SPARC when passing a
272 small structure and gcc2 when the argument type is float
273 and it is passed as a double and converted to float by
274 the prologue (in the latter case the type of the LOC_ARG
275 symbol is double and the type of the LOC_LOCAL symbol is
277 /* But if the parameter name is null, don't try it. Null
278 parameter names occur on the RS/6000, for traceback
279 tables. FIXME, should we even print them? */
281 if (*SYMBOL_LINKAGE_NAME (sym
))
284 nsym
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
285 b
, VAR_DOMAIN
, NULL
);
286 gdb_assert (nsym
!= NULL
);
287 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
288 && !SYMBOL_IS_ARGUMENT (nsym
))
290 /* There is a LOC_ARG/LOC_REGISTER pair. This means
291 that it was passed on the stack and loaded into a
292 register, or passed in a register and stored in a
293 stack slot. GDB 3.x used the LOC_ARG; GDB
294 4.0-4.11 used the LOC_REGISTER.
296 Reasons for using the LOC_ARG:
298 (1) Because find_saved_registers may be slow for
301 (2) Because registers are often re-used and stack
302 slots rarely (never?) are. Therefore using
303 the stack slot is much less likely to print
306 Reasons why we might want to use the LOC_REGISTER:
308 (1) So that the backtrace prints the same value
309 as "print foo". I see no compelling reason
310 why this needs to be the case; having the
311 backtrace print the value which was passed
312 in, and "print foo" print the value as
313 modified within the called function, makes
316 Additional note: It might be nice if "info args"
317 displayed both values.
319 One more note: There is a case with SPARC
320 structure passing where we need to use the
321 LOC_REGISTER, but this is dealt with by creating
322 a single LOC_REGPARM in symbol reading. */
324 /* Leave sym (the LOC_ARG) alone. */
331 /* Print the current arg. */
333 ui_out_text (uiout
, ", ");
334 ui_out_wrap_hint (uiout
, " ");
336 annotate_arg_begin ();
338 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
339 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
340 SYMBOL_LANGUAGE (sym
),
341 DMGL_PARAMS
| DMGL_ANSI
);
342 ui_out_field_stream (uiout
, "name", stb
);
343 annotate_arg_name_end ();
344 ui_out_text (uiout
, "=");
348 /* Avoid value_print because it will deref ref parameters.
349 We just want to print their addresses. Print ??? for
350 args whose address we do not know. We pass 2 as
351 "recurse" to val_print because our standard indentation
352 here is 4 spaces, and val_print indents 2 for each
354 val
= read_var_value (sym
, frame
);
356 annotate_arg_value (val
== NULL
? NULL
: value_type (val
));
360 const struct language_defn
*language
;
361 struct value_print_options opts
;
363 /* Use the appropriate language to display our symbol,
364 unless the user forced the language to a specific
366 if (language_mode
== language_mode_auto
)
367 language
= language_def (SYMBOL_LANGUAGE (sym
));
369 language
= current_language
;
371 get_raw_print_options (&opts
);
373 opts
.summary
= summary
;
374 common_val_print (val
, stb
->stream
, 2, &opts
, language
);
375 ui_out_field_stream (uiout
, "value", stb
);
378 ui_out_text (uiout
, "???");
381 ui_out_text (uiout
, "...");
384 /* Invoke ui_out_tuple_end. */
385 do_cleanups (list_chain
);
393 /* Don't print nameless args in situations where we don't know
394 enough about the stack to find them. */
399 if (highest_offset
== -1)
400 start
= gdbarch_frame_args_skip (get_frame_arch (frame
));
402 start
= highest_offset
;
404 print_frame_nameless_args (frame
, start
, num
- args_printed
,
408 do_cleanups (old_chain
);
411 /* Stub for catch_errors. */
414 print_args_stub (void *args
)
416 struct print_args_args
*p
= args
;
417 struct gdbarch
*gdbarch
= get_frame_arch (p
->frame
);
420 if (gdbarch_frame_num_args_p (gdbarch
))
422 numargs
= gdbarch_frame_num_args (gdbarch
, p
->frame
);
423 gdb_assert (numargs
>= 0);
427 print_frame_args (p
->func
, p
->frame
, numargs
, p
->stream
);
431 /* Set the current source and line to the location given by frame
432 FRAME, if possible. When CENTER is true, adjust so the relevant
433 line is in the center of the next 'list'. */
436 set_current_sal_from_frame (struct frame_info
*frame
, int center
)
438 struct symtab_and_line sal
;
440 find_frame_sal (frame
, &sal
);
444 sal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
445 set_current_source_symtab_and_line (&sal
);
449 /* If ON, GDB will display disassembly of the next source line when
450 execution of the program being debugged stops.
451 If AUTO (which is the default), or there's no line info to determine
452 the source line of the next instruction, display disassembly of next
453 instruction instead. */
455 static enum auto_boolean disassemble_next_line
;
458 show_disassemble_next_line (struct ui_file
*file
, int from_tty
,
459 struct cmd_list_element
*c
,
462 fprintf_filtered (file
, _("\
463 Debugger's willingness to use disassemble-next-line is %s.\n"),
467 /* Show assembly codes; stub for catch_errors. */
469 struct gdb_disassembly_stub_args
471 struct gdbarch
*gdbarch
;
478 gdb_disassembly_stub (void *args
)
480 struct gdb_disassembly_stub_args
*p
= args
;
481 gdb_disassembly (p
->gdbarch
, uiout
, 0, 0, p
->how_many
, p
->low
, p
->high
);
484 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
485 because it will be broken by filter sometime. */
488 do_gdb_disassembly (struct gdbarch
*gdbarch
,
489 int how_many
, CORE_ADDR low
, CORE_ADDR high
)
491 volatile struct gdb_exception exception
;
492 struct gdb_disassembly_stub_args args
;
494 args
.gdbarch
= gdbarch
;
495 args
.how_many
= how_many
;
498 TRY_CATCH (exception
, RETURN_MASK_ALL
)
500 gdb_disassembly_stub (&args
);
502 /* If an exception was thrown while doing the disassembly, print
503 the error message, to give the user a clue of what happened. */
504 if (exception
.reason
== RETURN_ERROR
)
505 exception_print (gdb_stderr
, exception
);
508 /* Print information about frame FRAME. The output is format according
509 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
512 SRC_LINE: Print only source line.
513 LOCATION: Print only location.
514 LOC_AND_SRC: Print location and source line.
516 Used in "where" output, and to emit breakpoint or step
520 print_frame_info (struct frame_info
*frame
, int print_level
,
521 enum print_what print_what
, int print_args
)
523 struct symtab_and_line sal
;
527 if (get_frame_type (frame
) == DUMMY_FRAME
528 || get_frame_type (frame
) == SIGTRAMP_FRAME
529 || get_frame_type (frame
) == ARCH_FRAME
)
531 struct cleanup
*uiout_cleanup
532 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
534 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
535 get_frame_pc (frame
));
537 /* Do this regardless of SOURCE because we don't have any source
538 to list for this frame. */
541 ui_out_text (uiout
, "#");
542 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
543 frame_relative_level (frame
));
545 if (ui_out_is_mi_like_p (uiout
))
547 annotate_frame_address ();
548 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
549 annotate_frame_address_end ();
552 if (get_frame_type (frame
) == DUMMY_FRAME
)
554 annotate_function_call ();
555 ui_out_field_string (uiout
, "func", "<function called from gdb>");
557 else if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
559 annotate_signal_handler_caller ();
560 ui_out_field_string (uiout
, "func", "<signal handler called>");
562 else if (get_frame_type (frame
) == ARCH_FRAME
)
564 ui_out_field_string (uiout
, "func", "<cross-architecture call>");
566 ui_out_text (uiout
, "\n");
567 annotate_frame_end ();
569 do_cleanups (uiout_cleanup
);
573 /* If FRAME is not the innermost frame, that normally means that
574 FRAME->pc points to *after* the call instruction, and we want to
575 get the line containing the call, never the next line. But if
576 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
577 next frame was not entered as the result of a call, and we want
578 to get the line containing FRAME->pc. */
579 find_frame_sal (frame
, &sal
);
581 location_print
= (print_what
== LOCATION
582 || print_what
== LOC_AND_ADDRESS
583 || print_what
== SRC_AND_LOC
);
585 if (location_print
|| !sal
.symtab
)
586 print_frame (frame
, print_level
, print_what
, print_args
, sal
);
588 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
590 /* If disassemble-next-line is set to auto or on and doesn't have
591 the line debug messages for $pc, output the next instruction. */
592 if ((disassemble_next_line
== AUTO_BOOLEAN_AUTO
593 || disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
594 && source_print
&& !sal
.symtab
)
595 do_gdb_disassembly (get_frame_arch (frame
), 1,
596 get_frame_pc (frame
), get_frame_pc (frame
) + 1);
598 if (source_print
&& sal
.symtab
)
601 int mid_statement
= ((print_what
== SRC_LINE
)
602 && frame_show_address (frame
, sal
));
604 if (annotation_level
)
605 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
606 get_frame_pc (frame
));
609 if (deprecated_print_frame_info_listing_hook
)
610 deprecated_print_frame_info_listing_hook (sal
.symtab
,
615 struct value_print_options opts
;
616 get_user_print_options (&opts
);
617 /* We used to do this earlier, but that is clearly
618 wrong. This function is used by many different
619 parts of gdb, including normal_stop in infrun.c,
620 which uses this to print out the current PC
621 when we stepi/nexti into the middle of a source
622 line. Only the command line really wants this
623 behavior. Other UIs probably would like the
624 ability to decide for themselves if it is desired. */
625 if (opts
.addressprint
&& mid_statement
)
627 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
628 ui_out_text (uiout
, "\t");
631 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
635 /* If disassemble-next-line is set to on and there is line debug
636 messages, output assembly codes for next line. */
637 if (disassemble_next_line
== AUTO_BOOLEAN_TRUE
)
638 do_gdb_disassembly (get_frame_arch (frame
), -1,
639 get_frame_pc (frame
), sal
.end
);
642 if (print_what
!= LOCATION
)
643 set_default_breakpoint (1, get_frame_pc (frame
), sal
.symtab
, sal
.line
);
645 annotate_frame_end ();
647 gdb_flush (gdb_stdout
);
650 /* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
653 find_frame_funname (struct frame_info
*frame
, char **funname
,
654 enum language
*funlang
)
659 *funlang
= language_unknown
;
661 func
= get_frame_function (frame
);
664 /* In certain pathological cases, the symtabs give the wrong
665 function (when we are in the first function in a file which
666 is compiled without debugging symbols, the previous function
667 is compiled with debugging symbols, and the "foo.o" symbol
668 that is supposed to tell us where the file with debugging
669 symbols ends has been truncated by ar because it is longer
670 than 15 characters). This also occurs if the user uses asm()
671 to create a function but not stabs for it (in a file compiled
674 So look in the minimal symbol tables as well, and if it comes
675 up with a larger address for the function use that instead.
676 I don't think this can ever cause any problems; there
677 shouldn't be any minimal symbols in the middle of a function;
678 if this is ever changed many parts of GDB will need to be
679 changed (and we'll create a find_pc_minimal_function or some
682 struct minimal_symbol
*msymbol
= NULL
;
684 /* Don't attempt to do this for inlined functions, which do not
685 have a corresponding minimal symbol. */
686 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func
)))
688 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
691 && (SYMBOL_VALUE_ADDRESS (msymbol
)
692 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
694 /* We also don't know anything about the function besides
695 its address and name. */
697 *funname
= SYMBOL_PRINT_NAME (msymbol
);
698 *funlang
= SYMBOL_LANGUAGE (msymbol
);
702 *funname
= SYMBOL_PRINT_NAME (func
);
703 *funlang
= SYMBOL_LANGUAGE (func
);
704 if (*funlang
== language_cplus
)
706 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
707 to display the demangled name that we already have
708 stored in the symbol table, but we stored a version
709 with DMGL_PARAMS turned on, and here we don't want to
710 display parameters. So remove the parameters. */
711 char *func_only
= cp_remove_params (*funname
);
714 *funname
= func_only
;
715 make_cleanup (xfree
, func_only
);
722 struct minimal_symbol
*msymbol
=
723 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame
));
727 *funname
= SYMBOL_PRINT_NAME (msymbol
);
728 *funlang
= SYMBOL_LANGUAGE (msymbol
);
734 print_frame (struct frame_info
*frame
, int print_level
,
735 enum print_what print_what
, int print_args
,
736 struct symtab_and_line sal
)
738 char *funname
= NULL
;
739 enum language funlang
= language_unknown
;
740 struct ui_stream
*stb
;
741 struct cleanup
*old_chain
, *list_chain
;
742 struct value_print_options opts
;
744 stb
= ui_out_stream_new (uiout
);
745 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
747 find_frame_funname (frame
, &funname
, &funlang
);
749 annotate_frame_begin (print_level
? frame_relative_level (frame
) : 0,
750 get_frame_pc (frame
));
752 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
756 ui_out_text (uiout
, "#");
757 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
758 frame_relative_level (frame
));
760 get_user_print_options (&opts
);
761 if (opts
.addressprint
)
762 if (frame_show_address (frame
, sal
) || !sal
.symtab
763 || print_what
== LOC_AND_ADDRESS
)
765 annotate_frame_address ();
766 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (frame
));
767 annotate_frame_address_end ();
768 ui_out_text (uiout
, " in ");
770 annotate_frame_function_name ();
771 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??",
773 ui_out_field_stream (uiout
, "func", stb
);
774 ui_out_wrap_hint (uiout
, " ");
775 annotate_frame_args ();
777 ui_out_text (uiout
, " (");
780 struct print_args_args args
;
781 struct cleanup
*args_list_chain
;
783 args
.func
= find_pc_function (get_frame_address_in_block (frame
));
784 args
.stream
= gdb_stdout
;
785 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
786 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ERROR
);
787 /* FIXME: ARGS must be a list. If one argument is a string it
788 will have " that will not be properly escaped. */
789 /* Invoke ui_out_tuple_end. */
790 do_cleanups (args_list_chain
);
793 ui_out_text (uiout
, ")");
794 if (sal
.symtab
&& sal
.symtab
->filename
)
796 annotate_frame_source_begin ();
797 ui_out_wrap_hint (uiout
, " ");
798 ui_out_text (uiout
, " at ");
799 annotate_frame_source_file ();
800 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
801 if (ui_out_is_mi_like_p (uiout
))
803 const char *fullname
= symtab_to_fullname (sal
.symtab
);
804 if (fullname
!= NULL
)
805 ui_out_field_string (uiout
, "fullname", fullname
);
807 annotate_frame_source_file_end ();
808 ui_out_text (uiout
, ":");
809 annotate_frame_source_line ();
810 ui_out_field_int (uiout
, "line", sal
.line
);
811 annotate_frame_source_end ();
814 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
817 char *lib
= PC_SOLIB (get_frame_pc (frame
));
819 char *lib
= solib_name_from_address (get_frame_pc (frame
));
823 annotate_frame_where ();
824 ui_out_wrap_hint (uiout
, " ");
825 ui_out_text (uiout
, " from ");
826 ui_out_field_string (uiout
, "from", lib
);
830 /* do_cleanups will call ui_out_tuple_end() for us. */
831 do_cleanups (list_chain
);
832 ui_out_text (uiout
, "\n");
833 do_cleanups (old_chain
);
837 /* Read a frame specification in whatever the appropriate format is
838 from FRAME_EXP. Call error(), printing MESSAGE, if the
839 specification is in any way invalid (so this function never returns
840 NULL). When SEPECTED_P is non-NULL set its target to indicate that
841 the default selected frame was used. */
843 static struct frame_info
*
844 parse_frame_specification_1 (const char *frame_exp
, const char *message
,
845 int *selected_frame_p
)
848 struct value
*args
[4];
849 CORE_ADDR addrs
[ARRAY_SIZE (args
)];
851 if (frame_exp
== NULL
)
856 struct cleanup
*tmp_cleanup
;
862 struct cleanup
*cleanup
;
865 /* Skip leading white space, bail of EOL. */
866 while (isspace (*frame_exp
))
871 /* Parse the argument, extract it, save it. */
875 addr_string
= savestring (frame_exp
, p
- frame_exp
);
877 cleanup
= make_cleanup (xfree
, addr_string
);
879 /* NOTE: Parse and evaluate expression, but do not use
880 functions such as parse_and_eval_long or
881 parse_and_eval_address to also extract the value.
882 Instead value_as_long and value_as_address are used.
883 This avoids problems with expressions that contain
885 if (numargs
>= ARRAY_SIZE (args
))
886 error (_("Too many args in frame specification"));
887 args
[numargs
++] = parse_and_eval (addr_string
);
889 do_cleanups (cleanup
);
893 /* If no args, default to the selected frame. */
896 if (selected_frame_p
!= NULL
)
897 (*selected_frame_p
) = 1;
898 return get_selected_frame (message
);
901 /* None of the remaining use the selected frame. */
902 if (selected_frame_p
!= NULL
)
903 (*selected_frame_p
) = 0;
905 /* Assume the single arg[0] is an integer, and try using that to
906 select a frame relative to current. */
909 struct frame_info
*fid
;
910 int level
= value_as_long (args
[0]);
911 fid
= find_relative_frame (get_current_frame (), &level
);
913 /* find_relative_frame was successful */
917 /* Convert each value into a corresponding address. */
920 for (i
= 0; i
< numargs
; i
++)
921 addrs
[i
] = value_as_address (args
[i
]);
924 /* Assume that the single arg[0] is an address, use that to identify
925 a frame with a matching ID. Should this also accept stack/pc or
929 struct frame_id id
= frame_id_build_wild (addrs
[0]);
930 struct frame_info
*fid
;
932 /* If (s)he specifies the frame with an address, he deserves
933 what (s)he gets. Still, give the highest one that matches.
934 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
936 for (fid
= get_current_frame ();
938 fid
= get_prev_frame (fid
))
940 if (frame_id_eq (id
, get_frame_id (fid
)))
942 struct frame_info
*prev_frame
;
946 prev_frame
= get_prev_frame (fid
);
948 || !frame_id_eq (id
, get_frame_id (prev_frame
)))
957 /* We couldn't identify the frame as an existing frame, but
958 perhaps we can create one with a single argument. */
960 return create_new_frame (addrs
[0], 0);
961 else if (numargs
== 2)
962 return create_new_frame (addrs
[0], addrs
[1]);
964 error (_("Too many args in frame specification"));
967 static struct frame_info
*
968 parse_frame_specification (char *frame_exp
)
970 return parse_frame_specification_1 (frame_exp
, NULL
, NULL
);
973 /* Print verbosely the selected frame or the frame at address
974 ADDR_EXP. Absolutely all information in the frame is printed. */
977 frame_info (char *addr_exp
, int from_tty
)
979 struct frame_info
*fi
;
980 struct symtab_and_line sal
;
983 struct frame_info
*calling_frame_info
;
984 int i
, count
, numregs
;
986 enum language funlang
= language_unknown
;
987 const char *pc_regname
;
988 int selected_frame_p
;
989 struct gdbarch
*gdbarch
;
990 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
992 fi
= parse_frame_specification_1 (addr_exp
, "No stack.", &selected_frame_p
);
993 gdbarch
= get_frame_arch (fi
);
995 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
996 is not a good name. */
997 if (gdbarch_pc_regnum (gdbarch
) >= 0)
998 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
999 easily not match that of the internal value returned by
1001 pc_regname
= gdbarch_register_name (gdbarch
, gdbarch_pc_regnum (gdbarch
));
1003 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1004 architectures will often have a hardware register called "pc",
1005 and that register's value, again, can easily not match
1009 find_frame_sal (fi
, &sal
);
1010 func
= get_frame_function (fi
);
1011 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
1013 s
= find_pc_symtab (get_frame_pc (fi
));
1016 funname
= SYMBOL_PRINT_NAME (func
);
1017 funlang
= SYMBOL_LANGUAGE (func
);
1018 if (funlang
== language_cplus
)
1020 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1021 to display the demangled name that we already have
1022 stored in the symbol table, but we stored a version
1023 with DMGL_PARAMS turned on, and here we don't want to
1024 display parameters. So remove the parameters. */
1025 char *func_only
= cp_remove_params (funname
);
1028 funname
= func_only
;
1029 make_cleanup (xfree
, func_only
);
1035 struct minimal_symbol
*msymbol
;
1037 msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
1038 if (msymbol
!= NULL
)
1040 funname
= SYMBOL_PRINT_NAME (msymbol
);
1041 funlang
= SYMBOL_LANGUAGE (msymbol
);
1044 calling_frame_info
= get_prev_frame (fi
);
1046 if (selected_frame_p
&& frame_relative_level (fi
) >= 0)
1048 printf_filtered (_("Stack level %d, frame at "),
1049 frame_relative_level (fi
));
1053 printf_filtered (_("Stack frame at "));
1055 fputs_filtered (paddress (get_frame_base (fi
)), gdb_stdout
);
1056 printf_filtered (":\n");
1057 printf_filtered (" %s = ", pc_regname
);
1058 fputs_filtered (paddress (get_frame_pc (fi
)), gdb_stdout
);
1063 printf_filtered (" in ");
1064 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
1065 DMGL_ANSI
| DMGL_PARAMS
);
1069 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
1070 puts_filtered ("; ");
1072 printf_filtered ("saved %s ", pc_regname
);
1073 fputs_filtered (paddress (frame_unwind_caller_pc (fi
)), gdb_stdout
);
1074 printf_filtered ("\n");
1076 if (calling_frame_info
== NULL
)
1078 enum unwind_stop_reason reason
;
1080 reason
= get_frame_unwind_stop_reason (fi
);
1081 if (reason
!= UNWIND_NO_REASON
)
1082 printf_filtered (_(" Outermost frame: %s\n"),
1083 frame_stop_reason_string (reason
));
1085 else if (get_frame_type (fi
) == INLINE_FRAME
)
1086 printf_filtered (" inlined into frame %d",
1087 frame_relative_level (get_prev_frame (fi
)));
1090 printf_filtered (" called by frame at ");
1091 fputs_filtered (paddress (get_frame_base (calling_frame_info
)),
1094 if (get_next_frame (fi
) && calling_frame_info
)
1095 puts_filtered (",");
1097 if (get_next_frame (fi
))
1099 printf_filtered (" caller of frame at ");
1100 fputs_filtered (paddress (get_frame_base (get_next_frame (fi
))),
1103 if (get_next_frame (fi
) || calling_frame_info
)
1104 puts_filtered ("\n");
1107 printf_filtered (" source language %s.\n",
1108 language_str (s
->language
));
1111 /* Address of the argument list for this frame, or 0. */
1112 CORE_ADDR arg_list
= get_frame_args_address (fi
);
1113 /* Number of args for this frame, or -1 if unknown. */
1117 printf_filtered (" Arglist at unknown address.\n");
1120 printf_filtered (" Arglist at ");
1121 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1122 printf_filtered (",");
1124 if (!gdbarch_frame_num_args_p (gdbarch
))
1127 puts_filtered (" args: ");
1131 numargs
= gdbarch_frame_num_args (gdbarch
, fi
);
1132 gdb_assert (numargs
>= 0);
1134 puts_filtered (" no args.");
1135 else if (numargs
== 1)
1136 puts_filtered (" 1 arg: ");
1138 printf_filtered (" %d args: ", numargs
);
1140 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
1141 puts_filtered ("\n");
1145 /* Address of the local variables for this frame, or 0. */
1146 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
1149 printf_filtered (" Locals at unknown address,");
1152 printf_filtered (" Locals at ");
1153 fputs_filtered (paddress (arg_list
), gdb_stdout
);
1154 printf_filtered (",");
1158 /* Print as much information as possible on the location of all the
1161 enum lval_type lval
;
1169 /* The sp is special; what's displayed isn't the save address, but
1170 the value of the previous frame's sp. This is a legacy thing,
1171 at one stage the frame cached the previous frame's SP instead
1172 of its address, hence it was easiest to just display the cached
1174 if (gdbarch_sp_regnum (gdbarch
) >= 0)
1176 /* Find out the location of the saved stack pointer with out
1177 actually evaluating it. */
1178 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1179 &optimized
, &lval
, &addr
,
1181 if (!optimized
&& lval
== not_lval
)
1183 gdb_byte value
[MAX_REGISTER_SIZE
];
1185 frame_register_unwind (fi
, gdbarch_sp_regnum (gdbarch
),
1186 &optimized
, &lval
, &addr
,
1188 /* NOTE: cagney/2003-05-22: This is assuming that the
1189 stack pointer was packed as an unsigned integer. That
1190 may or may not be valid. */
1191 sp
= extract_unsigned_integer (value
,
1192 register_size (gdbarch
,
1193 gdbarch_sp_regnum (gdbarch
)));
1194 printf_filtered (" Previous frame's sp is ");
1195 fputs_filtered (paddress (sp
), gdb_stdout
);
1196 printf_filtered ("\n");
1199 else if (!optimized
&& lval
== lval_memory
)
1201 printf_filtered (" Previous frame's sp at ");
1202 fputs_filtered (paddress (addr
), gdb_stdout
);
1203 printf_filtered ("\n");
1206 else if (!optimized
&& lval
== lval_register
)
1208 printf_filtered (" Previous frame's sp in %s\n",
1209 gdbarch_register_name (gdbarch
, realnum
));
1212 /* else keep quiet. */
1216 numregs
= gdbarch_num_regs (gdbarch
)
1217 + gdbarch_num_pseudo_regs (gdbarch
);
1218 for (i
= 0; i
< numregs
; i
++)
1219 if (i
!= gdbarch_sp_regnum (gdbarch
)
1220 && gdbarch_register_reggroup_p (gdbarch
, i
, all_reggroup
))
1222 /* Find out the location of the saved register without
1223 fetching the corresponding value. */
1224 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1226 /* For moment, only display registers that were saved on the
1228 if (!optimized
&& lval
== lval_memory
)
1231 puts_filtered (" Saved registers:\n ");
1233 puts_filtered (",");
1235 printf_filtered (" %s at ",
1236 gdbarch_register_name (gdbarch
, i
));
1237 fputs_filtered (paddress (addr
), gdb_stdout
);
1241 if (count
|| need_nl
)
1242 puts_filtered ("\n");
1245 do_cleanups (back_to
);
1248 /* Print briefly all stack frames or just the innermost COUNT_EXP
1252 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1254 struct frame_info
*fi
;
1257 struct frame_info
*trailing
;
1260 if (!target_has_stack
)
1261 error (_("No stack."));
1263 /* The following code must do two things. First, it must set the
1264 variable TRAILING to the frame from which we should start
1265 printing. Second, it must set the variable count to the number
1266 of frames which we should print, or -1 if all of them. */
1267 trailing
= get_current_frame ();
1269 /* The target can be in a state where there is no valid frames
1270 (e.g., just connected). */
1271 if (trailing
== NULL
)
1272 error (_("No stack."));
1277 count
= parse_and_eval_long (count_exp
);
1280 struct frame_info
*current
;
1285 while (current
&& count
--)
1288 current
= get_prev_frame (current
);
1291 /* Will stop when CURRENT reaches the top of the stack.
1292 TRAILING will be COUNT below it. */
1296 trailing
= get_prev_frame (trailing
);
1297 current
= get_prev_frame (current
);
1309 struct partial_symtab
*ps
;
1311 /* Read in symbols for all of the frames. Need to do this in a
1312 separate pass so that "Reading in symbols for xxx" messages
1313 don't screw up the appearance of the backtrace. Also if
1314 people have strong opinions against reading symbols for
1315 backtrace this may have to be an option. */
1317 for (fi
= trailing
; fi
!= NULL
&& i
--; fi
= get_prev_frame (fi
))
1320 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1322 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in. */
1326 for (i
= 0, fi
= trailing
; fi
&& count
--; i
++, fi
= get_prev_frame (fi
))
1330 /* Don't use print_stack_frame; if an error() occurs it probably
1331 means further attempts to backtrace would fail (on the other
1332 hand, perhaps the code does or could be fixed to make sure
1333 the frame->prev field gets set to NULL in that case). */
1334 print_frame_info (fi
, 1, LOCATION
, 1);
1336 print_frame_local_vars (fi
, 1, gdb_stdout
);
1338 /* Save the last frame to check for error conditions. */
1342 /* If we've stopped before the end, mention that. */
1344 printf_filtered (_("(More stack frames follow...)\n"));
1346 /* If we've run out of frames, and the reason appears to be an error
1347 condition, print it. */
1348 if (fi
== NULL
&& trailing
!= NULL
)
1350 enum unwind_stop_reason reason
;
1352 reason
= get_frame_unwind_stop_reason (trailing
);
1353 if (reason
> UNWIND_FIRST_ERROR
)
1354 printf_filtered (_("Backtrace stopped: %s\n"),
1355 frame_stop_reason_string (reason
));
1359 struct backtrace_command_args
1366 /* Stub for catch_errors. */
1369 backtrace_command_stub (void *data
)
1371 struct backtrace_command_args
*args
= data
;
1372 backtrace_command_1 (args
->count_exp
, args
->show_locals
, args
->from_tty
);
1377 backtrace_command (char *arg
, int from_tty
)
1379 struct cleanup
*old_chain
= NULL
;
1380 int fulltrace_arg
= -1, arglen
= 0, argc
= 0;
1381 struct backtrace_command_args btargs
;
1388 argv
= gdb_buildargv (arg
);
1389 old_chain
= make_cleanup_freeargv (argv
);
1391 for (i
= 0; argv
[i
]; i
++)
1395 for (j
= 0; j
< strlen (argv
[i
]); j
++)
1396 argv
[i
][j
] = tolower (argv
[i
][j
]);
1398 if (fulltrace_arg
< 0 && subset_compare (argv
[i
], "full"))
1399 fulltrace_arg
= argc
;
1402 arglen
+= strlen (argv
[i
]);
1407 if (fulltrace_arg
>= 0)
1411 arg
= xmalloc (arglen
+ 1);
1412 memset (arg
, 0, arglen
+ 1);
1413 for (i
= 0; i
< (argc
+ 1); i
++)
1415 if (i
!= fulltrace_arg
)
1417 strcat (arg
, argv
[i
]);
1427 btargs
.count_exp
= arg
;
1428 btargs
.show_locals
= (fulltrace_arg
>= 0);
1429 btargs
.from_tty
= from_tty
;
1430 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1432 if (fulltrace_arg
>= 0 && arglen
> 0)
1436 do_cleanups (old_chain
);
1440 backtrace_full_command (char *arg
, int from_tty
)
1442 struct backtrace_command_args btargs
;
1443 btargs
.count_exp
= arg
;
1444 btargs
.show_locals
= 1;
1445 btargs
.from_tty
= from_tty
;
1446 catch_errors (backtrace_command_stub
, &btargs
, "", RETURN_MASK_ERROR
);
1450 /* Print the local variables of a block B active in FRAME on STREAM.
1451 Return 1 if any variables were printed; 0 otherwise. */
1454 print_block_frame_locals (struct block
*b
, struct frame_info
*frame
,
1455 int num_tabs
, struct ui_file
*stream
)
1457 struct dict_iterator iter
;
1459 int values_printed
= 0;
1462 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1464 switch (SYMBOL_CLASS (sym
))
1470 if (SYMBOL_IS_ARGUMENT (sym
))
1473 print_variable_and_value (NULL
, sym
, frame
, stream
, 4 * num_tabs
);
1477 /* Ignore symbols which are not locals. */
1482 return values_printed
;
1485 /* Same, but print labels. */
1488 print_block_frame_labels (struct block
*b
, int *have_default
,
1489 struct ui_file
*stream
)
1491 struct dict_iterator iter
;
1493 int values_printed
= 0;
1495 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1497 if (strcmp (SYMBOL_LINKAGE_NAME (sym
), "default") == 0)
1503 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1505 struct symtab_and_line sal
;
1506 struct value_print_options opts
;
1507 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1509 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1510 get_user_print_options (&opts
);
1511 if (opts
.addressprint
)
1513 fprintf_filtered (stream
, " ");
1514 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym
)), stream
);
1516 fprintf_filtered (stream
, " in file %s, line %d\n",
1517 sal
.symtab
->filename
, sal
.line
);
1521 return values_printed
;
1524 /* Print on STREAM all the local variables in frame FRAME, including
1525 all the blocks active in that frame at its current PC.
1527 Returns 1 if the job was done, or 0 if nothing was printed because
1528 we have no info on the function running in FRAME. */
1531 print_frame_local_vars (struct frame_info
*frame
, int num_tabs
,
1532 struct ui_file
*stream
)
1534 struct block
*block
= get_frame_block (frame
, 0);
1535 int values_printed
= 0;
1539 fprintf_filtered (stream
, "No symbol table info available.\n");
1545 if (print_block_frame_locals (block
, frame
, num_tabs
, stream
))
1547 /* After handling the function's top-level block, stop. Don't
1548 continue to its superblock, the block of per-file symbols.
1549 Also do not continue to the containing function of an inlined
1551 if (BLOCK_FUNCTION (block
))
1553 block
= BLOCK_SUPERBLOCK (block
);
1556 if (!values_printed
)
1557 fprintf_filtered (stream
, _("No locals.\n"));
1560 /* Same, but print labels. */
1563 print_frame_label_vars (struct frame_info
*frame
, int this_level_only
,
1564 struct ui_file
*stream
)
1567 fprintf_filtered (stream
, "print_frame_label_vars disabled.\n");
1569 struct blockvector
*bl
;
1570 struct block
*block
= get_frame_block (frame
, 0);
1571 int values_printed
= 0;
1572 int index
, have_default
= 0;
1573 char *blocks_printed
;
1574 CORE_ADDR pc
= get_frame_pc (frame
);
1578 fprintf_filtered (stream
, "No symbol table info available.\n");
1582 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1583 blocks_printed
= alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1584 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1588 CORE_ADDR end
= BLOCK_END (block
) - 4;
1591 if (bl
!= blockvector_for_pc (end
, &index
))
1592 error (_("blockvector blotch"));
1593 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1594 error (_("blockvector botch"));
1595 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1598 /* Don't print out blocks that have gone by. */
1599 while (index
< last_index
1600 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1603 while (index
< last_index
1604 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1606 if (blocks_printed
[index
] == 0)
1608 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
),
1609 &have_default
, stream
))
1611 blocks_printed
[index
] = 1;
1617 if (values_printed
&& this_level_only
)
1620 /* After handling the function's top-level block, stop. Don't
1621 continue to its superblock, the block of per-file symbols.
1622 Also do not continue to the containing function of an inlined
1624 if (BLOCK_FUNCTION (block
))
1626 block
= BLOCK_SUPERBLOCK (block
);
1629 if (!values_printed
&& !this_level_only
)
1630 fprintf_filtered (stream
, _("No catches.\n"));
1635 locals_info (char *args
, int from_tty
)
1637 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
1642 catch_info (char *ignore
, int from_tty
)
1644 struct symtab_and_line
*sal
;
1646 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1647 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
1652 print_frame_arg_vars (struct frame_info
*frame
, struct ui_file
*stream
)
1654 struct symbol
*func
= get_frame_function (frame
);
1656 struct dict_iterator iter
;
1657 struct symbol
*sym
, *sym2
;
1658 int values_printed
= 0;
1662 fprintf_filtered (stream
, _("No symbol table info available.\n"));
1666 b
= SYMBOL_BLOCK_VALUE (func
);
1667 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1669 /* Don't worry about things which aren't arguments. */
1670 if (SYMBOL_IS_ARGUMENT (sym
))
1674 /* We have to look up the symbol because arguments can have
1675 two entries (one a parameter, one a local) and the one we
1676 want is the local, which lookup_symbol will find for us.
1677 This includes gcc1 (not gcc2) on the sparc when passing a
1678 small structure and gcc2 when the argument type is float
1679 and it is passed as a double and converted to float by
1680 the prologue (in the latter case the type of the LOC_ARG
1681 symbol is double and the type of the LOC_LOCAL symbol is
1682 float). There are also LOC_ARG/LOC_REGISTER pairs which
1683 are not combined in symbol-reading. */
1685 sym2
= lookup_symbol (SYMBOL_LINKAGE_NAME (sym
),
1686 b
, VAR_DOMAIN
, NULL
);
1687 print_variable_and_value (SYMBOL_PRINT_NAME (sym
), sym2
,
1692 if (!values_printed
)
1693 fprintf_filtered (stream
, _("No arguments.\n"));
1697 args_info (char *ignore
, int from_tty
)
1699 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
1705 args_plus_locals_info (char *ignore
, int from_tty
)
1707 args_info (ignore
, from_tty
);
1708 locals_info (ignore
, from_tty
);
1712 /* Select frame FRAME. Also print the stack frame and show the source
1713 if this is the tui version. */
1715 select_and_print_frame (struct frame_info
*frame
)
1717 select_frame (frame
);
1719 print_stack_frame (frame
, 1, SRC_AND_LOC
);
1722 /* Return the symbol-block in which the selected frame is executing.
1723 Can return zero under various legitimate circumstances.
1725 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1726 code address within the block returned. We use this to decide
1727 which macros are in scope. */
1730 get_selected_block (CORE_ADDR
*addr_in_block
)
1732 if (!has_stack_frames ())
1735 return get_frame_block (get_selected_frame (NULL
), addr_in_block
);
1738 /* Find a frame a certain number of levels away from FRAME.
1739 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1740 Positive means go to earlier frames (up); negative, the reverse.
1741 The int that contains the number of levels is counted toward
1742 zero as the frames for those levels are found.
1743 If the top or bottom frame is reached, that frame is returned,
1744 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1745 how much farther the original request asked to go. */
1748 find_relative_frame (struct frame_info
*frame
, int *level_offset_ptr
)
1750 /* Going up is simple: just call get_prev_frame enough times or
1751 until the initial frame is reached. */
1752 while (*level_offset_ptr
> 0)
1754 struct frame_info
*prev
= get_prev_frame (frame
);
1757 (*level_offset_ptr
)--;
1761 /* Going down is just as simple. */
1762 while (*level_offset_ptr
< 0)
1764 struct frame_info
*next
= get_next_frame (frame
);
1767 (*level_offset_ptr
)++;
1774 /* The "select_frame" command. With no argument this is a NOP.
1775 Select the frame at level LEVEL_EXP if it is a valid level.
1776 Otherwise, treat LEVEL_EXP as an address expression and select it.
1778 See parse_frame_specification for more info on proper frame
1782 select_frame_command (char *level_exp
, int from_tty
)
1784 select_frame (parse_frame_specification_1 (level_exp
, "No stack.", NULL
));
1787 /* The "frame" command. With no argument, print the selected frame
1788 briefly. With an argument, behave like select_frame and then print
1789 the selected frame. */
1792 frame_command (char *level_exp
, int from_tty
)
1794 select_frame_command (level_exp
, from_tty
);
1795 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1798 /* The XDB Compatibility command to print the current frame. */
1801 current_frame_command (char *level_exp
, int from_tty
)
1803 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC
);
1806 /* Select the frame up one or COUNT_EXP stack levels from the
1807 previously selected frame, and print it briefly. */
1810 up_silently_base (char *count_exp
)
1812 struct frame_info
*frame
;
1816 count
= parse_and_eval_long (count_exp
);
1818 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1819 if (count
!= 0 && count_exp
== NULL
)
1820 error (_("Initial frame selected; you cannot go up."));
1821 select_frame (frame
);
1825 up_silently_command (char *count_exp
, int from_tty
)
1827 up_silently_base (count_exp
);
1831 up_command (char *count_exp
, int from_tty
)
1833 up_silently_base (count_exp
);
1834 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1837 /* Select the frame down one or COUNT_EXP stack levels from the previously
1838 selected frame, and print it briefly. */
1841 down_silently_base (char *count_exp
)
1843 struct frame_info
*frame
;
1846 count
= -parse_and_eval_long (count_exp
);
1848 frame
= find_relative_frame (get_selected_frame ("No stack."), &count
);
1849 if (count
!= 0 && count_exp
== NULL
)
1851 /* We only do this if COUNT_EXP is not specified. That way
1852 "down" means to really go down (and let me know if that is
1853 impossible), but "down 9999" can be used to mean go all the
1854 way down without getting an error. */
1856 error (_("Bottom (innermost) frame selected; you cannot go down."));
1859 select_frame (frame
);
1863 down_silently_command (char *count_exp
, int from_tty
)
1865 down_silently_base (count_exp
);
1869 down_command (char *count_exp
, int from_tty
)
1871 down_silently_base (count_exp
);
1872 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
1877 return_command (char *retval_exp
, int from_tty
)
1879 struct frame_info
*thisframe
;
1880 struct gdbarch
*gdbarch
;
1881 struct symbol
*thisfun
;
1882 struct value
*return_value
= NULL
;
1883 const char *query_prefix
= "";
1885 thisframe
= get_selected_frame ("No selected frame.");
1886 thisfun
= get_frame_function (thisframe
);
1887 gdbarch
= get_frame_arch (thisframe
);
1889 if (get_frame_type (get_current_frame ()) == INLINE_FRAME
)
1890 error (_("Can not force return from an inlined function."));
1892 /* Compute the return value. If the computation triggers an error,
1893 let it bail. If the return type can't be handled, set
1894 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1898 struct expression
*retval_expr
= parse_expression (retval_exp
);
1899 struct cleanup
*old_chain
= make_cleanup (xfree
, retval_expr
);
1900 struct type
*return_type
= NULL
;
1902 /* Compute the return value. Should the computation fail, this
1903 call throws an error. */
1904 return_value
= evaluate_expression (retval_expr
);
1906 /* Cast return value to the return type of the function. Should
1907 the cast fail, this call throws an error. */
1908 if (thisfun
!= NULL
)
1909 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1910 if (return_type
== NULL
)
1912 if (retval_expr
->elts
[0].opcode
!= UNOP_CAST
)
1913 error (_("Return value type not available for selected "
1915 "Please use an explicit cast of the value to return."));
1916 return_type
= value_type (return_value
);
1918 do_cleanups (old_chain
);
1919 CHECK_TYPEDEF (return_type
);
1920 return_value
= value_cast (return_type
, return_value
);
1922 /* Make sure the value is fully evaluated. It may live in the
1923 stack frame we're about to pop. */
1924 if (value_lazy (return_value
))
1925 value_fetch_lazy (return_value
);
1927 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1928 /* If the return-type is "void", don't try to find the
1929 return-value's location. However, do still evaluate the
1930 return expression so that, even when the expression result
1931 is discarded, side effects such as "return i++" still
1933 return_value
= NULL
;
1934 else if (thisfun
!= NULL
1935 && using_struct_return (gdbarch
,
1936 SYMBOL_TYPE (thisfun
), return_type
))
1939 The location at which to store the function's return value is unknown.\n\
1940 If you continue, the return value that you specified will be ignored.\n";
1941 return_value
= NULL
;
1945 /* Does an interactive user really want to do this? Include
1946 information, such as how well GDB can handle the return value, in
1947 the query message. */
1951 if (thisfun
== NULL
)
1952 confirmed
= query (_("%sMake selected stack frame return now? "),
1955 confirmed
= query (_("%sMake %s return now? "), query_prefix
,
1956 SYMBOL_PRINT_NAME (thisfun
));
1958 error (_("Not confirmed"));
1961 /* Discard the selected frame and all frames inner-to it. */
1962 frame_pop (get_selected_frame (NULL
));
1964 /* Store RETURN_VALUE in the just-returned register set. */
1965 if (return_value
!= NULL
)
1967 struct type
*return_type
= value_type (return_value
);
1968 struct gdbarch
*gdbarch
= get_regcache_arch (get_current_regcache ());
1969 struct type
*func_type
= thisfun
== NULL
? NULL
: SYMBOL_TYPE (thisfun
);
1971 gdb_assert (gdbarch_return_value (gdbarch
, func_type
, return_type
, NULL
,
1973 == RETURN_VALUE_REGISTER_CONVENTION
);
1974 gdbarch_return_value (gdbarch
, func_type
, return_type
,
1975 get_current_regcache (), NULL
/*read*/,
1976 value_contents (return_value
) /*write*/);
1979 /* If we are at the end of a call dummy now, pop the dummy frame
1981 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1982 frame_pop (get_current_frame ());
1984 /* If interactive, print the frame that is now current. */
1986 frame_command ("0", 1);
1988 select_frame_command ("0", 0);
1991 /* Sets the scope to input function name, provided that the function
1992 is within the current stack frame */
1994 struct function_bounds
1996 CORE_ADDR low
, high
;
2000 func_command (char *arg
, int from_tty
)
2002 struct frame_info
*frame
;
2004 struct symtabs_and_lines sals
;
2007 struct function_bounds
*func_bounds
= NULL
;
2012 frame
= parse_frame_specification ("0");
2013 sals
= decode_line_spec (arg
, 1);
2014 func_bounds
= (struct function_bounds
*) xmalloc (
2015 sizeof (struct function_bounds
) * sals
.nelts
);
2016 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2018 if (sals
.sals
[i
].pc
== 0
2019 || find_pc_partial_function (sals
.sals
[i
].pc
, NULL
,
2020 &func_bounds
[i
].low
,
2021 &func_bounds
[i
].high
) == 0)
2023 func_bounds
[i
].low
= func_bounds
[i
].high
= 0;
2029 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
2030 found
= (get_frame_pc (frame
) >= func_bounds
[i
].low
2031 && get_frame_pc (frame
) < func_bounds
[i
].high
);
2035 frame
= find_relative_frame (frame
, &level
);
2038 while (!found
&& level
== 0);
2041 xfree (func_bounds
);
2044 printf_filtered (_("'%s' not within current stack frame.\n"), arg
);
2045 else if (frame
!= get_selected_frame (NULL
))
2046 select_and_print_frame (frame
);
2049 /* Gets the language of the current frame. */
2052 get_frame_language (void)
2054 struct frame_info
*frame
= deprecated_safe_get_selected_frame ();
2058 /* We determine the current frame language by looking up its
2059 associated symtab. To retrieve this symtab, we use the frame
2060 PC. However we cannot use the frame PC as is, because it
2061 usually points to the instruction following the "call", which
2062 is sometimes the first instruction of another function. So
2063 we rely on get_frame_address_in_block(), it provides us with
2064 a PC that is guaranteed to be inside the frame's code
2066 CORE_ADDR pc
= get_frame_address_in_block (frame
);
2067 struct symtab
*s
= find_pc_symtab (pc
);
2073 return language_unknown
;
2077 /* Provide a prototype to silence -Wmissing-prototypes. */
2078 void _initialize_stack (void);
2081 _initialize_stack (void)
2084 backtrace_limit
= 30;
2087 add_com ("return", class_stack
, return_command
, _("\
2088 Make selected stack frame return to its caller.\n\
2089 Control remains in the debugger, but when you continue\n\
2090 execution will resume in the frame above the one now selected.\n\
2091 If an argument is given, it is an expression for the value to return."));
2093 add_com ("up", class_stack
, up_command
, _("\
2094 Select and print stack frame that called this one.\n\
2095 An argument says how many frames up to go."));
2096 add_com ("up-silently", class_support
, up_silently_command
, _("\
2097 Same as the `up' command, but does not print anything.\n\
2098 This is useful in command scripts."));
2100 add_com ("down", class_stack
, down_command
, _("\
2101 Select and print stack frame called by this one.\n\
2102 An argument says how many frames down to go."));
2103 add_com_alias ("do", "down", class_stack
, 1);
2104 add_com_alias ("dow", "down", class_stack
, 1);
2105 add_com ("down-silently", class_support
, down_silently_command
, _("\
2106 Same as the `down' command, but does not print anything.\n\
2107 This is useful in command scripts."));
2109 add_com ("frame", class_stack
, frame_command
, _("\
2110 Select and print a stack frame.\n\
2111 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2112 An argument specifies the frame to select.\n\
2113 It can be a stack frame number or the address of the frame.\n\
2114 With argument, nothing is printed if input is coming from\n\
2115 a command file or a user-defined command."));
2117 add_com_alias ("f", "frame", class_stack
, 1);
2121 add_com ("L", class_stack
, current_frame_command
,
2122 _("Print the current stack frame.\n"));
2123 add_com_alias ("V", "frame", class_stack
, 1);
2125 add_com ("select-frame", class_stack
, select_frame_command
, _("\
2126 Select a stack frame without printing anything.\n\
2127 An argument specifies the frame to select.\n\
2128 It can be a stack frame number or the address of the frame.\n"));
2130 add_com ("backtrace", class_stack
, backtrace_command
, _("\
2131 Print backtrace of all stack frames, or innermost COUNT frames.\n\
2132 With a negative argument, print outermost -COUNT frames.\n\
2133 Use of the 'full' qualifier also prints the values of the local variables.\n"));
2134 add_com_alias ("bt", "backtrace", class_stack
, 0);
2137 add_com_alias ("t", "backtrace", class_stack
, 0);
2138 add_com ("T", class_stack
, backtrace_full_command
, _("\
2139 Print backtrace of all stack frames, or innermost COUNT frames \n\
2140 and the values of the local variables.\n\
2141 With a negative argument, print outermost -COUNT frames.\n\
2142 Usage: T <count>\n"));
2145 add_com_alias ("where", "backtrace", class_alias
, 0);
2146 add_info ("stack", backtrace_command
,
2147 _("Backtrace of the stack, or innermost COUNT frames."));
2148 add_info_alias ("s", "stack", 1);
2149 add_info ("frame", frame_info
,
2150 _("All about selected stack frame, or frame at ADDR."));
2151 add_info_alias ("f", "frame", 1);
2152 add_info ("locals", locals_info
,
2153 _("Local variables of current stack frame."));
2154 add_info ("args", args_info
,
2155 _("Argument variables of current stack frame."));
2157 add_com ("l", class_info
, args_plus_locals_info
,
2158 _("Argument and local variables of current stack frame."));
2161 add_com ("func", class_stack
, func_command
, _("\
2162 Select the stack frame that contains <func>.\n\
2163 Usage: func <name>\n"));
2165 add_info ("catch", catch_info
,
2166 _("Exceptions that can be caught in the current stack frame."));
2168 add_setshow_enum_cmd ("frame-arguments", class_stack
,
2169 print_frame_arguments_choices
, &print_frame_arguments
,
2170 _("Set printing of non-scalar frame arguments"),
2171 _("Show printing of non-scalar frame arguments"),
2172 NULL
, NULL
, NULL
, &setprintlist
, &showprintlist
);
2174 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack
,
2175 &disassemble_next_line
, _("\
2176 Set whether to disassemble next source line or insn when execution stops."), _("\
2177 Show whether to disassemble next source line or insn when execution stops."), _("\
2178 If ON, GDB will display disassembly of the next source line, in addition\n\
2179 to displaying the source line itself. If the next source line cannot\n\
2180 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2181 will display disassembly of next instruction instead of showing the\n\
2183 If AUTO, display disassembly of next instruction only if the source line\n\
2184 cannot be displayed.\n\
2185 If OFF (which is the default), never display the disassembly of the next\n\
2188 show_disassemble_next_line
,
2189 &setlist
, &showlist
);
2190 disassemble_next_line
= AUTO_BOOLEAN_FALSE
;
2193 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
, _(\
2194 "Specify maximum number of frames for \"backtrace\" to print by default."),
2196 add_info ("backtrace-limit", backtrace_limit_info
, _("\
2197 The maximum number of frames for \"backtrace\" to print by default."));