1 /* Print and select stack frames for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
5 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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
26 #include "gdb_string.h"
30 #include "expression.h"
37 #include "breakpoint.h"
44 #include "gdb_assert.h"
45 #include "dictionary.h"
46 #include "reggroups.h"
49 /* Prototypes for exported functions. */
51 void args_info (char *, int);
53 void locals_info (char *, int);
55 void (*deprecated_selected_frame_level_changed_hook
) (int);
57 void _initialize_stack (void);
59 /* Prototypes for local functions. */
61 static void down_command (char *, int);
63 static void down_silently_base (char *);
65 static void down_silently_command (char *, int);
67 static void up_command (char *, int);
69 static void up_silently_base (char *);
71 static void up_silently_command (char *, int);
73 void frame_command (char *, int);
75 static void current_frame_command (char *, int);
77 static void print_frame_arg_vars (struct frame_info
*, struct ui_file
*);
79 static void catch_info (char *, int);
81 static void args_plus_locals_info (char *, int);
83 static void print_frame_label_vars (struct frame_info
*, int,
86 static void print_frame_local_vars (struct frame_info
*, int,
89 static int print_block_frame_labels (struct block
*, int *,
92 static int print_block_frame_locals (struct block
*,
97 static void print_frame (struct frame_info
*fi
,
99 enum print_what print_what
,
101 struct symtab_and_line sal
);
103 static void backtrace_command (char *, int);
105 struct frame_info
*parse_frame_specification (char *);
107 static void frame_info (char *, int);
109 extern int addressprint
; /* Print addresses, or stay symbolic only? */
111 /* Zero means do things normally; we are interacting directly with the
112 user. One means print the full filename and linenumber when a
113 frame is printed, and do so in a format emacs18/emacs19.22 can
114 parse. Two means print similar annotations, but in many more
115 cases and in a slightly different syntax. */
117 int annotation_level
= 0;
120 struct print_stack_frame_args
122 struct frame_info
*fi
;
124 enum print_what print_what
;
128 /* Show or print the frame arguments.
129 Pass the args the way catch_errors wants them. */
131 print_stack_frame_stub (void *args
)
133 struct print_stack_frame_args
*p
= (struct print_stack_frame_args
*) args
;
135 print_frame_info (p
->fi
, p
->print_level
, p
->print_what
, p
->print_args
);
139 /* Show or print a stack frame FI briefly. The output is format
140 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
141 relative level, function name, argument list, and file name and
142 line number. If the frame's PC is not at the beginning of the
143 source line, the actual PC is printed at the beginning. */
146 print_stack_frame (struct frame_info
*fi
, int print_level
,
147 enum print_what print_what
)
149 struct print_stack_frame_args args
;
152 args
.print_level
= print_level
;
153 args
.print_what
= print_what
;
156 catch_errors (print_stack_frame_stub
, (char *) &args
, "", RETURN_MASK_ALL
);
159 struct print_args_args
162 struct frame_info
*fi
;
163 struct ui_file
*stream
;
166 static int print_args_stub (void *);
168 /* Print nameless args on STREAM.
169 FI is the frameinfo for this frame, START is the offset
170 of the first nameless arg, and NUM is the number of nameless args to
171 print. FIRST is nonzero if this is the first argument (not just
172 the first nameless arg). */
175 print_frame_nameless_args (struct frame_info
*fi
, long start
, int num
,
176 int first
, struct ui_file
*stream
)
182 for (i
= 0; i
< num
; i
++)
185 argsaddr
= get_frame_args_address (fi
);
188 arg_value
= read_memory_integer (argsaddr
+ start
, sizeof (int));
190 fprintf_filtered (stream
, ", ");
191 fprintf_filtered (stream
, "%ld", arg_value
);
193 start
+= sizeof (int);
197 /* Print the arguments of a stack frame, given the function FUNC
198 running in that frame (as a symbol), the info on the frame,
199 and the number of args according to the stack frame (or -1 if unknown). */
201 /* References here and elsewhere to "number of args according to the
202 stack frame" appear in all cases to refer to "number of ints of args
203 according to the stack frame". At least for VAX, i386, isi. */
206 print_frame_args (struct symbol
*func
, struct frame_info
*fi
, int num
,
207 struct ui_file
*stream
)
209 struct block
*b
= NULL
;
211 struct dict_iterator iter
;
214 /* Offset of next stack argument beyond the one we have seen that is
215 at the highest offset.
216 -1 if we haven't come to a stack argument yet. */
217 long highest_offset
= -1;
219 /* Number of ints of arguments that we have printed so far. */
220 int args_printed
= 0;
221 struct cleanup
*old_chain
, *list_chain
;
222 struct ui_stream
*stb
;
224 stb
= ui_out_stream_new (uiout
);
225 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
229 b
= SYMBOL_BLOCK_VALUE (func
);
231 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
235 /* Keep track of the highest stack argument offset seen, and
236 skip over any kinds of symbols we don't care about. */
238 switch (SYMBOL_CLASS (sym
))
243 long current_offset
= SYMBOL_VALUE (sym
);
244 arg_size
= TYPE_LENGTH (SYMBOL_TYPE (sym
));
246 /* Compute address of next argument by adding the size of
247 this argument and rounding to an int boundary. */
249 ((current_offset
+ arg_size
+ sizeof (int) - 1)
250 & ~(sizeof (int) - 1));
252 /* If this is the highest offset seen yet, set highest_offset. */
253 if (highest_offset
== -1
254 || (current_offset
> highest_offset
))
255 highest_offset
= current_offset
;
257 /* Add the number of ints we're about to print to args_printed. */
258 args_printed
+= (arg_size
+ sizeof (int) - 1) / sizeof (int);
261 /* We care about types of symbols, but don't need to keep track of
262 stack offsets in them. */
264 case LOC_REGPARM_ADDR
:
266 case LOC_BASEREG_ARG
:
267 case LOC_COMPUTED_ARG
:
270 /* Other types of symbols we just skip over. */
275 /* We have to look up the symbol because arguments can have
276 two entries (one a parameter, one a local) and the one we
277 want is the local, which lookup_symbol will find for us.
278 This includes gcc1 (not gcc2) on the sparc when passing a
279 small structure and gcc2 when the argument type is float
280 and it is passed as a double and converted to float by
281 the prologue (in the latter case the type of the LOC_ARG
282 symbol is double and the type of the LOC_LOCAL symbol is
284 /* But if the parameter name is null, don't try it.
285 Null parameter names occur on the RS/6000, for traceback tables.
286 FIXME, should we even print them? */
288 if (*DEPRECATED_SYMBOL_NAME (sym
))
292 (DEPRECATED_SYMBOL_NAME (sym
),
293 b
, VAR_DOMAIN
, (int *) NULL
, (struct symtab
**) NULL
);
294 if (SYMBOL_CLASS (nsym
) == LOC_REGISTER
)
296 /* There is a LOC_ARG/LOC_REGISTER pair. This means that
297 it was passed on the stack and loaded into a register,
298 or passed in a register and stored in a stack slot.
299 GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
301 Reasons for using the LOC_ARG:
302 (1) because find_saved_registers may be slow for remote
304 (2) because registers are often re-used and stack slots
305 rarely (never?) are. Therefore using the stack slot is
306 much less likely to print garbage.
308 Reasons why we might want to use the LOC_REGISTER:
309 (1) So that the backtrace prints the same value as
310 "print foo". I see no compelling reason why this needs
311 to be the case; having the backtrace print the value which
312 was passed in, and "print foo" print the value as modified
313 within the called function, makes perfect sense to me.
315 Additional note: It might be nice if "info args" displayed
317 One more note: There is a case with sparc structure passing
318 where we need to use the LOC_REGISTER, but this is dealt with
319 by creating a single LOC_REGPARM in symbol reading. */
321 /* Leave sym (the LOC_ARG) alone. */
328 /* Print the current arg. */
330 ui_out_text (uiout
, ", ");
331 ui_out_wrap_hint (uiout
, " ");
333 annotate_arg_begin ();
335 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
336 fprintf_symbol_filtered (stb
->stream
, SYMBOL_PRINT_NAME (sym
),
337 SYMBOL_LANGUAGE (sym
), DMGL_PARAMS
| DMGL_ANSI
);
338 ui_out_field_stream (uiout
, "name", stb
);
339 annotate_arg_name_end ();
340 ui_out_text (uiout
, "=");
342 /* Avoid value_print because it will deref ref parameters. We just
343 want to print their addresses. Print ??? for args whose address
344 we do not know. We pass 2 as "recurse" to val_print because our
345 standard indentation here is 4 spaces, and val_print indents
346 2 for each recurse. */
347 val
= read_var_value (sym
, fi
);
349 annotate_arg_value (val
== NULL
? NULL
: VALUE_TYPE (val
));
353 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
), 0,
355 stb
->stream
, 0, 0, 2, Val_no_prettyprint
);
356 ui_out_field_stream (uiout
, "value", stb
);
359 ui_out_text (uiout
, "???");
361 /* Invoke ui_out_tuple_end. */
362 do_cleanups (list_chain
);
370 /* Don't print nameless args in situations where we don't know
371 enough about the stack to find them. */
376 if (highest_offset
== -1)
377 start
= FRAME_ARGS_SKIP
;
379 start
= highest_offset
;
381 print_frame_nameless_args (fi
, start
, num
- args_printed
,
384 do_cleanups (old_chain
);
387 /* Pass the args the way catch_errors wants them. */
390 print_args_stub (void *args
)
393 struct print_args_args
*p
= (struct print_args_args
*) args
;
395 if (FRAME_NUM_ARGS_P ())
397 numargs
= FRAME_NUM_ARGS (p
->fi
);
398 gdb_assert (numargs
>= 0);
402 print_frame_args (p
->func
, p
->fi
, numargs
, p
->stream
);
406 /* Print information about a frame for frame "fi" at level "level".
407 Used in "where" output, also used to emit breakpoint or step
409 LEVEL is the level of the frame, or -1 if it is the
410 innermost frame but we don't want to print the level.
411 The meaning of the SOURCE argument is:
412 SRC_LINE: Print only source line
413 LOCATION: Print only location
414 LOC_AND_SRC: Print location and source line. */
417 print_frame_info (struct frame_info
*fi
, int print_level
,
418 enum print_what print_what
, int print_args
)
420 struct symtab_and_line sal
;
424 if (get_frame_type (fi
) == DUMMY_FRAME
425 || get_frame_type (fi
) == SIGTRAMP_FRAME
)
427 struct cleanup
*uiout_cleanup
428 = make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
430 annotate_frame_begin (print_level
? frame_relative_level (fi
) : 0,
433 /* Do this regardless of SOURCE because we don't have any source
434 to list for this frame. */
437 ui_out_text (uiout
, "#");
438 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
439 frame_relative_level (fi
));
441 if (ui_out_is_mi_like_p (uiout
))
443 annotate_frame_address ();
444 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (fi
));
445 annotate_frame_address_end ();
448 if (get_frame_type (fi
) == DUMMY_FRAME
)
450 annotate_function_call ();
451 ui_out_field_string (uiout
, "func", "<function called from gdb>");
453 else if (get_frame_type (fi
) == SIGTRAMP_FRAME
)
455 annotate_signal_handler_caller ();
456 ui_out_field_string (uiout
, "func", "<signal handler called>");
458 ui_out_text (uiout
, "\n");
459 annotate_frame_end ();
461 do_cleanups (uiout_cleanup
);
465 /* If fi is not the innermost frame, that normally means that fi->pc
466 points to *after* the call instruction, and we want to get the
467 line containing the call, never the next line. But if the next
468 frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the next frame
469 was not entered as the result of a call, and we want to get the
470 line containing fi->pc. */
471 find_frame_sal (fi
, &sal
);
473 location_print
= (print_what
== LOCATION
474 || print_what
== LOC_AND_ADDRESS
475 || print_what
== SRC_AND_LOC
);
477 if (location_print
|| !sal
.symtab
)
478 print_frame (fi
, print_level
, print_what
, print_args
, sal
);
480 source_print
= (print_what
== SRC_LINE
|| print_what
== SRC_AND_LOC
);
483 set_current_source_symtab_and_line (&sal
);
485 if (source_print
&& sal
.symtab
)
487 struct symtab_and_line cursal
;
489 int mid_statement
= ((print_what
== SRC_LINE
)
490 && (get_frame_pc (fi
) != sal
.pc
));
492 if (annotation_level
)
493 done
= identify_source_line (sal
.symtab
, sal
.line
, mid_statement
,
497 if (deprecated_print_frame_info_listing_hook
)
498 deprecated_print_frame_info_listing_hook (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
501 /* We used to do this earlier, but that is clearly
502 wrong. This function is used by many different
503 parts of gdb, including normal_stop in infrun.c,
504 which uses this to print out the current PC
505 when we stepi/nexti into the middle of a source
506 line. Only the command line really wants this
507 behavior. Other UIs probably would like the
508 ability to decide for themselves if it is desired. */
509 if (addressprint
&& mid_statement
)
511 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (fi
));
512 ui_out_text (uiout
, "\t");
515 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
518 /* Make sure we have at least a default source file */
519 set_default_source_symtab_and_line ();
520 cursal
= get_current_source_symtab_and_line ();
521 cursal
.line
= max (sal
.line
- get_lines_to_list () / 2, 1);
522 set_current_source_symtab_and_line (&cursal
);
525 if (print_what
!= LOCATION
)
526 set_default_breakpoint (1, get_frame_pc (fi
), sal
.symtab
, sal
.line
);
528 annotate_frame_end ();
530 gdb_flush (gdb_stdout
);
534 print_frame (struct frame_info
*fi
,
536 enum print_what print_what
,
538 struct symtab_and_line sal
)
542 enum language funlang
= language_unknown
;
543 struct ui_stream
*stb
;
544 struct cleanup
*old_chain
;
545 struct cleanup
*list_chain
;
547 stb
= ui_out_stream_new (uiout
);
548 old_chain
= make_cleanup_ui_out_stream_delete (stb
);
550 func
= find_pc_function (get_frame_address_in_block (fi
));
553 /* In certain pathological cases, the symtabs give the wrong
554 function (when we are in the first function in a file which
555 is compiled without debugging symbols, the previous function
556 is compiled with debugging symbols, and the "foo.o" symbol
557 that is supposed to tell us where the file with debugging symbols
558 ends has been truncated by ar because it is longer than 15
559 characters). This also occurs if the user uses asm() to create
560 a function but not stabs for it (in a file compiled -g).
562 So look in the minimal symbol tables as well, and if it comes
563 up with a larger address for the function use that instead.
564 I don't think this can ever cause any problems; there shouldn't
565 be any minimal symbols in the middle of a function; if this is
566 ever changed many parts of GDB will need to be changed (and we'll
567 create a find_pc_minimal_function or some such). */
569 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (get_frame_address_in_block (fi
));
571 && (SYMBOL_VALUE_ADDRESS (msymbol
)
572 > BLOCK_START (SYMBOL_BLOCK_VALUE (func
))))
574 /* We also don't know anything about the function besides
575 its address and name. */
577 funname
= DEPRECATED_SYMBOL_NAME (msymbol
);
578 funlang
= SYMBOL_LANGUAGE (msymbol
);
582 /* I'd like to use SYMBOL_PRINT_NAME() here, to display the
583 demangled name that we already have stored in the symbol
584 table, but we stored a version with DMGL_PARAMS turned
585 on, and here we don't want to display parameters. So call
586 the demangler again, with DMGL_ANSI only. (Yes, I know
587 that printf_symbol_filtered() will again try to demangle
588 the name on the fly, but the issue is that if
589 cplus_demangle() fails here, it'll fail there too. So we
590 want to catch the failure ("demangled==NULL" case below)
591 here, while we still have our hands on the function
594 funname
= DEPRECATED_SYMBOL_NAME (func
);
595 funlang
= SYMBOL_LANGUAGE (func
);
596 if (funlang
== language_cplus
)
598 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
599 if (demangled
== NULL
)
600 /* If the demangler fails, try the demangled name from
601 the symbol table. This'll have parameters, but
602 that's preferable to diplaying a mangled name. */
603 funname
= SYMBOL_PRINT_NAME (func
);
609 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (get_frame_address_in_block (fi
));
612 funname
= DEPRECATED_SYMBOL_NAME (msymbol
);
613 funlang
= SYMBOL_LANGUAGE (msymbol
);
617 annotate_frame_begin (print_level
? frame_relative_level (fi
) : 0,
620 list_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "frame");
624 ui_out_text (uiout
, "#");
625 ui_out_field_fmt_int (uiout
, 2, ui_left
, "level",
626 frame_relative_level (fi
));
629 if (get_frame_pc (fi
) != sal
.pc
631 || print_what
== LOC_AND_ADDRESS
)
633 annotate_frame_address ();
634 ui_out_field_core_addr (uiout
, "addr", get_frame_pc (fi
));
635 annotate_frame_address_end ();
636 ui_out_text (uiout
, " in ");
638 annotate_frame_function_name ();
639 fprintf_symbol_filtered (stb
->stream
, funname
? funname
: "??", funlang
,
641 ui_out_field_stream (uiout
, "func", stb
);
642 ui_out_wrap_hint (uiout
, " ");
643 annotate_frame_args ();
645 ui_out_text (uiout
, " (");
648 struct print_args_args args
;
649 struct cleanup
*args_list_chain
;
652 args
.stream
= gdb_stdout
;
653 args_list_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "args");
654 catch_errors (print_args_stub
, &args
, "", RETURN_MASK_ALL
);
655 /* FIXME: args must be a list. If one argument is a string it will
656 have " that will not be properly escaped. */
657 /* Invoke ui_out_tuple_end. */
658 do_cleanups (args_list_chain
);
661 ui_out_text (uiout
, ")");
662 if (sal
.symtab
&& sal
.symtab
->filename
)
664 annotate_frame_source_begin ();
665 ui_out_wrap_hint (uiout
, " ");
666 ui_out_text (uiout
, " at ");
667 annotate_frame_source_file ();
668 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
669 annotate_frame_source_file_end ();
670 ui_out_text (uiout
, ":");
671 annotate_frame_source_line ();
672 ui_out_field_int (uiout
, "line", sal
.line
);
673 annotate_frame_source_end ();
677 if (!funname
|| (!sal
.symtab
|| !sal
.symtab
->filename
))
679 char *lib
= PC_SOLIB (get_frame_pc (fi
));
682 annotate_frame_where ();
683 ui_out_wrap_hint (uiout
, " ");
684 ui_out_text (uiout
, " from ");
685 ui_out_field_string (uiout
, "from", lib
);
688 #endif /* PC_SOLIB */
690 /* do_cleanups will call ui_out_tuple_end() for us. */
691 do_cleanups (list_chain
);
692 ui_out_text (uiout
, "\n");
693 do_cleanups (old_chain
);
696 /* Show the frame info. If this is the tui, it will be shown in
697 the source display otherwise, nothing is done */
699 show_stack_frame (struct frame_info
*fi
)
704 /* Read a frame specification in whatever the appropriate format is.
705 Call error() if the specification is in any way invalid (i.e.
706 this function never returns NULL). */
709 parse_frame_specification (char *frame_exp
)
713 CORE_ADDR args
[MAXARGS
];
718 char *addr_string
, *p
;
719 struct cleanup
*tmp_cleanup
;
721 while (*frame_exp
== ' ')
726 if (numargs
> MAXARGS
)
727 error ("Too many args in frame specification");
728 /* Parse an argument. */
729 for (p
= frame_exp
; *p
&& *p
!= ' '; p
++)
731 addr_string
= savestring (frame_exp
, p
- frame_exp
);
736 tmp_cleanup
= make_cleanup (xfree
, addr_string
);
738 /* NOTE: we call parse_and_eval and then both
739 value_as_long and value_as_address rather than calling
740 parse_and_eval_long and parse_and_eval_address because
741 of the issue of potential side effects from evaluating
743 vp
= parse_and_eval (addr_string
);
745 level
= value_as_long (vp
);
747 args
[numargs
++] = value_as_address (vp
);
748 do_cleanups (tmp_cleanup
);
751 /* Skip spaces, move to possible next arg. */
761 if (deprecated_selected_frame
== NULL
)
762 error ("No selected frame.");
763 return deprecated_selected_frame
;
767 struct frame_info
*fid
=
768 find_relative_frame (get_current_frame (), &level
);
769 struct frame_info
*tfid
;
772 /* find_relative_frame was successful */
775 /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
776 take at least 2 addresses. It is important to detect this case
777 here so that "frame 100" does not give a confusing error message
778 like "frame specification requires two addresses". This of course
779 does not solve the "frame 100" problem for machines on which
780 a frame specification can be made with one address. To solve
781 that, we need a new syntax for a specifying a frame by address.
782 I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
783 two args, etc.), but people might think that is too much typing,
784 so I guess *0x23,0x45 would be a possible alternative (commas
785 really should be used instead of spaces to delimit; using spaces
786 normally works in an expression). */
787 #ifdef SETUP_ARBITRARY_FRAME
788 error ("No frame %s", paddr_d (args
[0]));
791 /* If (s)he specifies the frame with an address, he deserves what
792 (s)he gets. Still, give the highest one that matches. */
794 for (fid
= get_current_frame ();
795 fid
&& get_frame_base (fid
) != args
[0];
796 fid
= get_prev_frame (fid
))
800 while ((tfid
= get_prev_frame (fid
)) &&
801 (get_frame_base (tfid
) == args
[0]))
804 /* We couldn't identify the frame as an existing frame, but
805 perhaps we can create one with a single argument. */
809 #ifdef SETUP_ARBITRARY_FRAME
810 return SETUP_ARBITRARY_FRAME (numargs
, args
);
812 /* Usual case. Do it here rather than have everyone supply
813 a SETUP_ARBITRARY_FRAME that does this. */
815 return create_new_frame (args
[0], 0);
816 error ("Too many args in frame specification");
823 /* Print verbosely the selected frame or the frame at address ADDR.
824 This means absolutely all information in the frame is printed. */
827 frame_info (char *addr_exp
, int from_tty
)
829 struct frame_info
*fi
;
830 struct symtab_and_line sal
;
833 struct frame_info
*calling_frame_info
;
834 int i
, count
, numregs
;
836 enum language funlang
= language_unknown
;
837 const char *pc_regname
;
839 if (!target_has_stack
)
842 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
843 is not a good name. */
845 /* OK, this is weird. The PC_REGNUM hardware register's value can
846 easily not match that of the internal value returned by
848 pc_regname
= REGISTER_NAME (PC_REGNUM
);
850 /* But then, this is weird to. Even without PC_REGNUM, an
851 architectures will often have a hardware register called "pc",
852 and that register's value, again, can easily not match
856 fi
= parse_frame_specification (addr_exp
);
858 error ("Invalid frame specified.");
860 find_frame_sal (fi
, &sal
);
861 func
= get_frame_function (fi
);
862 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
864 s
= find_pc_symtab (get_frame_pc (fi
));
867 /* I'd like to use SYMBOL_PRINT_NAME() here, to display
868 * the demangled name that we already have stored in
869 * the symbol table, but we stored a version with
870 * DMGL_PARAMS turned on, and here we don't want
871 * to display parameters. So call the demangler again,
872 * with DMGL_ANSI only. RT
873 * (Yes, I know that printf_symbol_filtered() will
874 * again try to demangle the name on the fly, but
875 * the issue is that if cplus_demangle() fails here,
876 * it'll fail there too. So we want to catch the failure
877 * ("demangled==NULL" case below) here, while we still
878 * have our hands on the function symbol.)
881 funname
= DEPRECATED_SYMBOL_NAME (func
);
882 funlang
= SYMBOL_LANGUAGE (func
);
883 if (funlang
== language_cplus
)
885 demangled
= cplus_demangle (funname
, DMGL_ANSI
);
886 /* If the demangler fails, try the demangled name
887 * from the symbol table. This'll have parameters,
888 * but that's preferable to diplaying a mangled name.
890 if (demangled
== NULL
)
891 funname
= SYMBOL_PRINT_NAME (func
);
896 struct minimal_symbol
*msymbol
= lookup_minimal_symbol_by_pc (get_frame_pc (fi
));
899 funname
= DEPRECATED_SYMBOL_NAME (msymbol
);
900 funlang
= SYMBOL_LANGUAGE (msymbol
);
903 calling_frame_info
= get_prev_frame (fi
);
905 if (!addr_exp
&& frame_relative_level (deprecated_selected_frame
) >= 0)
907 printf_filtered ("Stack level %d, frame at ",
908 frame_relative_level (deprecated_selected_frame
));
909 print_address_numeric (get_frame_base (fi
), 1, gdb_stdout
);
910 printf_filtered (":\n");
914 printf_filtered ("Stack frame at ");
915 print_address_numeric (get_frame_base (fi
), 1, gdb_stdout
);
916 printf_filtered (":\n");
918 printf_filtered (" %s = ", pc_regname
);
919 print_address_numeric (get_frame_pc (fi
), 1, gdb_stdout
);
924 printf_filtered (" in ");
925 fprintf_symbol_filtered (gdb_stdout
, funname
, funlang
,
926 DMGL_ANSI
| DMGL_PARAMS
);
930 printf_filtered (" (%s:%d)", sal
.symtab
->filename
, sal
.line
);
931 puts_filtered ("; ");
933 printf_filtered ("saved %s ", pc_regname
);
934 print_address_numeric (frame_pc_unwind (fi
), 1, gdb_stdout
);
935 printf_filtered ("\n");
937 if (calling_frame_info
)
939 printf_filtered (" called by frame at ");
940 print_address_numeric (get_frame_base (calling_frame_info
),
943 if (get_next_frame (fi
) && calling_frame_info
)
946 if (get_next_frame (fi
))
948 printf_filtered (" caller of frame at ");
949 print_address_numeric (get_frame_base (get_next_frame (fi
)), 1,
952 if (get_next_frame (fi
) || calling_frame_info
)
953 puts_filtered ("\n");
955 printf_filtered (" source language %s.\n",
956 language_str (s
->language
));
959 /* Address of the argument list for this frame, or 0. */
960 CORE_ADDR arg_list
= get_frame_args_address (fi
);
961 /* Number of args for this frame, or -1 if unknown. */
965 printf_filtered (" Arglist at unknown address.\n");
968 printf_filtered (" Arglist at ");
969 print_address_numeric (arg_list
, 1, gdb_stdout
);
970 printf_filtered (",");
972 if (!FRAME_NUM_ARGS_P ())
975 puts_filtered (" args: ");
979 numargs
= FRAME_NUM_ARGS (fi
);
980 gdb_assert (numargs
>= 0);
982 puts_filtered (" no args.");
983 else if (numargs
== 1)
984 puts_filtered (" 1 arg: ");
986 printf_filtered (" %d args: ", numargs
);
988 print_frame_args (func
, fi
, numargs
, gdb_stdout
);
989 puts_filtered ("\n");
993 /* Address of the local variables for this frame, or 0. */
994 CORE_ADDR arg_list
= get_frame_locals_address (fi
);
997 printf_filtered (" Locals at unknown address,");
1000 printf_filtered (" Locals at ");
1001 print_address_numeric (arg_list
, 1, gdb_stdout
);
1002 printf_filtered (",");
1006 /* Print as much information as possible on the location of all the
1009 enum lval_type lval
;
1017 /* The sp is special; what's displayed isn't the save address, but
1018 the value of the previous frame's sp. This is a legacy thing,
1019 at one stage the frame cached the previous frame's SP instead
1020 of its address, hence it was easiest to just display the cached
1024 /* Find out the location of the saved stack pointer with out
1025 actually evaluating it. */
1026 frame_register_unwind (fi
, SP_REGNUM
, &optimized
, &lval
, &addr
,
1028 if (!optimized
&& lval
== not_lval
)
1030 char value
[MAX_REGISTER_SIZE
];
1032 frame_register_unwind (fi
, SP_REGNUM
, &optimized
, &lval
, &addr
,
1034 /* NOTE: cagney/2003-05-22: This is assuming that the
1035 stack pointer was packed as an unsigned integer. That
1036 may or may not be valid. */
1037 sp
= extract_unsigned_integer (value
, register_size (current_gdbarch
, SP_REGNUM
));
1038 printf_filtered (" Previous frame's sp is ");
1039 print_address_numeric (sp
, 1, gdb_stdout
);
1040 printf_filtered ("\n");
1043 else if (!optimized
&& lval
== lval_memory
)
1045 printf_filtered (" Previous frame's sp at ");
1046 print_address_numeric (addr
, 1, gdb_stdout
);
1047 printf_filtered ("\n");
1050 else if (!optimized
&& lval
== lval_register
)
1052 printf_filtered (" Previous frame's sp in %s\n",
1053 REGISTER_NAME (realnum
));
1056 /* else keep quiet. */
1060 numregs
= NUM_REGS
+ NUM_PSEUDO_REGS
;
1061 for (i
= 0; i
< numregs
; i
++)
1063 && gdbarch_register_reggroup_p (current_gdbarch
, i
, all_reggroup
))
1065 /* Find out the location of the saved register without
1066 fetching the corresponding value. */
1067 frame_register_unwind (fi
, i
, &optimized
, &lval
, &addr
, &realnum
,
1069 /* For moment, only display registers that were saved on the
1071 if (!optimized
&& lval
== lval_memory
)
1074 puts_filtered (" Saved registers:\n ");
1076 puts_filtered (",");
1078 printf_filtered (" %s at ", REGISTER_NAME (i
));
1079 print_address_numeric (addr
, 1, gdb_stdout
);
1083 if (count
|| need_nl
)
1084 puts_filtered ("\n");
1088 /* Print briefly all stack frames or just the innermost COUNT frames. */
1090 static void backtrace_command_1 (char *count_exp
, int show_locals
,
1093 backtrace_command_1 (char *count_exp
, int show_locals
, int from_tty
)
1095 struct frame_info
*fi
;
1098 struct frame_info
*trailing
;
1101 if (!target_has_stack
)
1102 error ("No stack.");
1104 /* The following code must do two things. First, it must
1105 set the variable TRAILING to the frame from which we should start
1106 printing. Second, it must set the variable count to the number
1107 of frames which we should print, or -1 if all of them. */
1108 trailing
= get_current_frame ();
1110 /* The target can be in a state where there is no valid frames
1111 (e.g., just connected). */
1112 if (trailing
== NULL
)
1113 error ("No stack.");
1118 count
= parse_and_eval_long (count_exp
);
1121 struct frame_info
*current
;
1126 while (current
&& count
--)
1129 current
= get_prev_frame (current
);
1132 /* Will stop when CURRENT reaches the top of the stack. TRAILING
1133 will be COUNT below it. */
1137 trailing
= get_prev_frame (trailing
);
1138 current
= get_prev_frame (current
);
1150 struct partial_symtab
*ps
;
1152 /* Read in symbols for all of the frames. Need to do this in
1153 a separate pass so that "Reading in symbols for xxx" messages
1154 don't screw up the appearance of the backtrace. Also
1155 if people have strong opinions against reading symbols for
1156 backtrace this may have to be an option. */
1160 fi
= get_prev_frame (fi
))
1163 ps
= find_pc_psymtab (get_frame_address_in_block (fi
));
1165 PSYMTAB_TO_SYMTAB (ps
); /* Force syms to come in */
1169 for (i
= 0, fi
= trailing
;
1171 i
++, fi
= get_prev_frame (fi
))
1175 /* Don't use print_stack_frame; if an error() occurs it probably
1176 means further attempts to backtrace would fail (on the other
1177 hand, perhaps the code does or could be fixed to make sure
1178 the frame->prev field gets set to NULL in that case). */
1179 print_frame_info (fi
, 1, LOCATION
, 1);
1181 print_frame_local_vars (fi
, 1, gdb_stdout
);
1184 /* If we've stopped before the end, mention that. */
1186 printf_filtered ("(More stack frames follow...)\n");
1190 backtrace_command (char *arg
, int from_tty
)
1192 struct cleanup
*old_chain
= (struct cleanup
*) NULL
;
1193 char **argv
= (char **) NULL
;
1194 int argIndicatingFullTrace
= (-1), totArgLen
= 0, argc
= 0;
1197 if (arg
!= (char *) NULL
)
1201 argv
= buildargv (arg
);
1202 old_chain
= make_cleanup_freeargv (argv
);
1204 for (i
= 0; (argv
[i
] != (char *) NULL
); i
++)
1208 for (j
= 0; (j
< strlen (argv
[i
])); j
++)
1209 argv
[i
][j
] = tolower (argv
[i
][j
]);
1211 if (argIndicatingFullTrace
< 0 && subset_compare (argv
[i
], "full"))
1212 argIndicatingFullTrace
= argc
;
1216 totArgLen
+= strlen (argv
[i
]);
1220 if (argIndicatingFullTrace
>= 0)
1224 argPtr
= (char *) xmalloc (totArgLen
+ 1);
1229 memset (argPtr
, 0, totArgLen
+ 1);
1230 for (i
= 0; (i
< (argc
+ 1)); i
++)
1232 if (i
!= argIndicatingFullTrace
)
1234 strcat (argPtr
, argv
[i
]);
1235 strcat (argPtr
, " ");
1241 argPtr
= (char *) NULL
;
1245 backtrace_command_1 (argPtr
, (argIndicatingFullTrace
>= 0), from_tty
);
1247 if (argIndicatingFullTrace
>= 0 && totArgLen
> 0)
1251 do_cleanups (old_chain
);
1254 static void backtrace_full_command (char *arg
, int from_tty
);
1256 backtrace_full_command (char *arg
, int from_tty
)
1258 backtrace_command_1 (arg
, 1, from_tty
);
1262 /* Print the local variables of a block B active in FRAME.
1263 Return 1 if any variables were printed; 0 otherwise. */
1266 print_block_frame_locals (struct block
*b
, struct frame_info
*fi
,
1267 int num_tabs
, struct ui_file
*stream
)
1269 struct dict_iterator iter
;
1272 int values_printed
= 0;
1274 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1276 switch (SYMBOL_CLASS (sym
))
1284 for (j
= 0; j
< num_tabs
; j
++)
1285 fputs_filtered ("\t", stream
);
1286 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1287 fputs_filtered (" = ", stream
);
1288 print_variable_value (sym
, fi
, stream
);
1289 fprintf_filtered (stream
, "\n");
1293 /* Ignore symbols which are not locals. */
1297 return values_printed
;
1300 /* Same, but print labels. */
1303 print_block_frame_labels (struct block
*b
, int *have_default
,
1304 struct ui_file
*stream
)
1306 struct dict_iterator iter
;
1308 int values_printed
= 0;
1310 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1312 if (strcmp (DEPRECATED_SYMBOL_NAME (sym
), "default") == 0)
1318 if (SYMBOL_CLASS (sym
) == LOC_LABEL
)
1320 struct symtab_and_line sal
;
1321 sal
= find_pc_line (SYMBOL_VALUE_ADDRESS (sym
), 0);
1323 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1326 fprintf_filtered (stream
, " ");
1327 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, stream
);
1329 fprintf_filtered (stream
, " in file %s, line %d\n",
1330 sal
.symtab
->filename
, sal
.line
);
1333 return values_printed
;
1336 /* Print on STREAM all the local variables in frame FRAME,
1337 including all the blocks active in that frame
1340 Returns 1 if the job was done,
1341 or 0 if nothing was printed because we have no info
1342 on the function running in FRAME. */
1345 print_frame_local_vars (struct frame_info
*fi
, int num_tabs
,
1346 struct ui_file
*stream
)
1348 struct block
*block
= get_frame_block (fi
, 0);
1349 int values_printed
= 0;
1353 fprintf_filtered (stream
, "No symbol table info available.\n");
1359 if (print_block_frame_locals (block
, fi
, num_tabs
, stream
))
1361 /* After handling the function's top-level block, stop.
1362 Don't continue to its superblock, the block of
1363 per-file symbols. */
1364 if (BLOCK_FUNCTION (block
))
1366 block
= BLOCK_SUPERBLOCK (block
);
1369 if (!values_printed
)
1371 fprintf_filtered (stream
, "No locals.\n");
1375 /* Same, but print labels. */
1378 print_frame_label_vars (struct frame_info
*fi
, int this_level_only
,
1379 struct ui_file
*stream
)
1381 struct blockvector
*bl
;
1382 struct block
*block
= get_frame_block (fi
, 0);
1383 int values_printed
= 0;
1384 int index
, have_default
= 0;
1385 char *blocks_printed
;
1386 CORE_ADDR pc
= get_frame_pc (fi
);
1390 fprintf_filtered (stream
, "No symbol table info available.\n");
1394 bl
= blockvector_for_pc (BLOCK_END (block
) - 4, &index
);
1395 blocks_printed
= (char *) alloca (BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1396 memset (blocks_printed
, 0, BLOCKVECTOR_NBLOCKS (bl
) * sizeof (char));
1400 CORE_ADDR end
= BLOCK_END (block
) - 4;
1403 if (bl
!= blockvector_for_pc (end
, &index
))
1404 error ("blockvector blotch");
1405 if (BLOCKVECTOR_BLOCK (bl
, index
) != block
)
1406 error ("blockvector botch");
1407 last_index
= BLOCKVECTOR_NBLOCKS (bl
);
1410 /* Don't print out blocks that have gone by. */
1411 while (index
< last_index
1412 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < pc
)
1415 while (index
< last_index
1416 && BLOCK_END (BLOCKVECTOR_BLOCK (bl
, index
)) < end
)
1418 if (blocks_printed
[index
] == 0)
1420 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl
, index
), &have_default
, stream
))
1422 blocks_printed
[index
] = 1;
1428 if (values_printed
&& this_level_only
)
1431 /* After handling the function's top-level block, stop.
1432 Don't continue to its superblock, the block of
1433 per-file symbols. */
1434 if (BLOCK_FUNCTION (block
))
1436 block
= BLOCK_SUPERBLOCK (block
);
1439 if (!values_printed
&& !this_level_only
)
1441 fprintf_filtered (stream
, "No catches.\n");
1446 locals_info (char *args
, int from_tty
)
1448 if (!deprecated_selected_frame
)
1449 error ("No frame selected.");
1450 print_frame_local_vars (deprecated_selected_frame
, 0, gdb_stdout
);
1454 catch_info (char *ignore
, int from_tty
)
1456 struct symtab_and_line
*sal
;
1458 /* Check for target support for exception handling */
1459 sal
= target_enable_exception_callback (EX_EVENT_CATCH
, 1);
1462 /* Currently not handling this */
1463 /* Ideally, here we should interact with the C++ runtime
1464 system to find the list of active handlers, etc. */
1465 fprintf_filtered (gdb_stdout
, "Info catch not supported with this target/compiler combination.\n");
1469 /* Assume g++ compiled code -- old v 4.16 behaviour */
1470 if (!deprecated_selected_frame
)
1471 error ("No frame selected.");
1473 print_frame_label_vars (deprecated_selected_frame
, 0, gdb_stdout
);
1478 print_frame_arg_vars (struct frame_info
*fi
,
1479 struct ui_file
*stream
)
1481 struct symbol
*func
= get_frame_function (fi
);
1483 struct dict_iterator iter
;
1484 struct symbol
*sym
, *sym2
;
1485 int values_printed
= 0;
1489 fprintf_filtered (stream
, "No symbol table info available.\n");
1493 b
= SYMBOL_BLOCK_VALUE (func
);
1494 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
1496 switch (SYMBOL_CLASS (sym
))
1502 case LOC_REGPARM_ADDR
:
1503 case LOC_BASEREG_ARG
:
1504 case LOC_COMPUTED_ARG
:
1506 fputs_filtered (SYMBOL_PRINT_NAME (sym
), stream
);
1507 fputs_filtered (" = ", stream
);
1509 /* We have to look up the symbol because arguments can have
1510 two entries (one a parameter, one a local) and the one we
1511 want is the local, which lookup_symbol will find for us.
1512 This includes gcc1 (not gcc2) on the sparc when passing a
1513 small structure and gcc2 when the argument type is float
1514 and it is passed as a double and converted to float by
1515 the prologue (in the latter case the type of the LOC_ARG
1516 symbol is double and the type of the LOC_LOCAL symbol is
1517 float). There are also LOC_ARG/LOC_REGISTER pairs which
1518 are not combined in symbol-reading. */
1520 sym2
= lookup_symbol (DEPRECATED_SYMBOL_NAME (sym
),
1521 b
, VAR_DOMAIN
, (int *) NULL
, (struct symtab
**) NULL
);
1522 print_variable_value (sym2
, fi
, stream
);
1523 fprintf_filtered (stream
, "\n");
1527 /* Don't worry about things which aren't arguments. */
1531 if (!values_printed
)
1533 fprintf_filtered (stream
, "No arguments.\n");
1538 args_info (char *ignore
, int from_tty
)
1540 if (!deprecated_selected_frame
)
1541 error ("No frame selected.");
1542 print_frame_arg_vars (deprecated_selected_frame
, gdb_stdout
);
1547 args_plus_locals_info (char *ignore
, int from_tty
)
1549 args_info (ignore
, from_tty
);
1550 locals_info (ignore
, from_tty
);
1554 /* Select frame FI. Also print the stack frame and show the source if
1555 this is the tui version. */
1557 select_and_print_frame (struct frame_info
*fi
)
1561 print_stack_frame (fi
, 1, SRC_AND_LOC
);
1564 /* Return the symbol-block in which the selected frame is executing.
1565 Can return zero under various legitimate circumstances.
1567 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1568 code address within the block returned. We use this to decide
1569 which macros are in scope. */
1572 get_selected_block (CORE_ADDR
*addr_in_block
)
1574 if (!target_has_stack
)
1577 /* NOTE: cagney/2002-11-28: Why go to all this effort to not create
1578 a selected/current frame? Perhaps this function is called,
1579 indirectly, by WFI in "infrun.c" where avoiding the creation of
1580 an inner most frame is very important (it slows down single
1581 step). I suspect, though that this was true in the deep dark
1582 past but is no longer the case. A mindless look at all the
1583 callers tends to support this theory. I think we should be able
1584 to assume that there is always a selcted frame. */
1585 /* gdb_assert (deprecated_selected_frame != NULL); So, do you feel
1587 if (!deprecated_selected_frame
)
1589 CORE_ADDR pc
= read_pc ();
1590 if (addr_in_block
!= NULL
)
1591 *addr_in_block
= pc
;
1592 return block_for_pc (pc
);
1594 return get_frame_block (deprecated_selected_frame
, addr_in_block
);
1597 /* Find a frame a certain number of levels away from FRAME.
1598 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1599 Positive means go to earlier frames (up); negative, the reverse.
1600 The int that contains the number of levels is counted toward
1601 zero as the frames for those levels are found.
1602 If the top or bottom frame is reached, that frame is returned,
1603 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1604 how much farther the original request asked to go. */
1607 find_relative_frame (struct frame_info
*frame
,
1608 int *level_offset_ptr
)
1610 struct frame_info
*prev
;
1611 struct frame_info
*frame1
;
1613 /* Going up is simple: just do get_prev_frame enough times
1614 or until initial frame is reached. */
1615 while (*level_offset_ptr
> 0)
1617 prev
= get_prev_frame (frame
);
1620 (*level_offset_ptr
)--;
1623 /* Going down is just as simple. */
1624 if (*level_offset_ptr
< 0)
1626 while (*level_offset_ptr
< 0)
1628 frame1
= get_next_frame (frame
);
1632 (*level_offset_ptr
)++;
1638 /* The "select_frame" command. With no arg, NOP.
1639 With arg LEVEL_EXP, select the frame at level LEVEL if it is a
1640 valid level. Otherwise, treat level_exp as an address expression
1641 and select it. See parse_frame_specification for more info on proper
1642 frame expressions. */
1645 select_frame_command (char *level_exp
, int from_tty
)
1647 struct frame_info
*frame
;
1649 if (!target_has_stack
)
1650 error ("No stack.");
1652 frame
= parse_frame_specification (level_exp
);
1654 select_frame (frame
);
1657 /* The "frame" command. With no arg, print selected frame briefly.
1658 With arg, behaves like select_frame and then prints the selected
1662 frame_command (char *level_exp
, int from_tty
)
1664 select_frame_command (level_exp
, from_tty
);
1665 print_stack_frame (get_selected_frame (), 1, SRC_AND_LOC
);
1668 /* The XDB Compatibility command to print the current frame. */
1671 current_frame_command (char *level_exp
, int from_tty
)
1673 if (target_has_stack
== 0 || deprecated_selected_frame
== 0)
1674 error ("No stack.");
1675 print_stack_frame (get_selected_frame (), 1, SRC_AND_LOC
);
1678 /* Select the frame up one or COUNT stack levels
1679 from the previously selected frame, and print it briefly. */
1682 up_silently_base (char *count_exp
)
1684 struct frame_info
*fi
;
1685 int count
= 1, count1
;
1687 count
= parse_and_eval_long (count_exp
);
1690 if (target_has_stack
== 0 || deprecated_selected_frame
== 0)
1691 error ("No stack.");
1693 fi
= find_relative_frame (deprecated_selected_frame
, &count1
);
1694 if (count1
!= 0 && count_exp
== 0)
1695 error ("Initial frame selected; you cannot go up.");
1700 up_silently_command (char *count_exp
, int from_tty
)
1702 up_silently_base (count_exp
);
1706 up_command (char *count_exp
, int from_tty
)
1708 up_silently_base (count_exp
);
1709 print_stack_frame (get_selected_frame (), 1, SRC_AND_LOC
);
1712 /* Select the frame down one or COUNT stack levels
1713 from the previously selected frame, and print it briefly. */
1716 down_silently_base (char *count_exp
)
1718 struct frame_info
*frame
;
1719 int count
= -1, count1
;
1721 count
= -parse_and_eval_long (count_exp
);
1724 if (target_has_stack
== 0 || deprecated_selected_frame
== 0)
1725 error ("No stack.");
1727 frame
= find_relative_frame (deprecated_selected_frame
, &count1
);
1728 if (count1
!= 0 && count_exp
== 0)
1731 /* We only do this if count_exp is not specified. That way "down"
1732 means to really go down (and let me know if that is
1733 impossible), but "down 9999" can be used to mean go all the way
1734 down without getting an error. */
1736 error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
1739 select_frame (frame
);
1743 down_silently_command (char *count_exp
, int from_tty
)
1745 down_silently_base (count_exp
);
1749 down_command (char *count_exp
, int from_tty
)
1751 down_silently_base (count_exp
);
1752 print_stack_frame (get_selected_frame (), 1, SRC_AND_LOC
);
1756 return_command (char *retval_exp
, int from_tty
)
1758 struct symbol
*thisfun
;
1759 struct value
*return_value
= NULL
;
1760 const char *query_prefix
= "";
1762 /* FIXME: cagney/2003-10-20: Perform a minimal existance test on the
1763 target. If that fails, error out. For the moment don't rely on
1764 get_selected_frame as it's error message is the the singularly
1765 obscure "No registers". */
1766 if (!target_has_registers
)
1767 error ("No selected frame.");
1768 thisfun
= get_frame_function (get_selected_frame ());
1770 /* Compute the return value. If the computation triggers an error,
1771 let it bail. If the return type can't be handled, set
1772 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1776 struct type
*return_type
= NULL
;
1778 /* Compute the return value. Should the computation fail, this
1779 call throws an error. */
1780 return_value
= parse_and_eval (retval_exp
);
1782 /* Cast return value to the return type of the function. Should
1783 the cast fail, this call throws an error. */
1784 if (thisfun
!= NULL
)
1785 return_type
= TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun
));
1786 if (return_type
== NULL
)
1787 return_type
= builtin_type_int
;
1788 CHECK_TYPEDEF (return_type
);
1789 return_value
= value_cast (return_type
, return_value
);
1791 /* Make sure the value is fully evaluated. It may live in the
1792 stack frame we're about to pop. */
1793 if (VALUE_LAZY (return_value
))
1794 value_fetch_lazy (return_value
);
1796 if (TYPE_CODE (return_type
) == TYPE_CODE_VOID
)
1797 /* If the return-type is "void", don't try to find the
1798 return-value's location. However, do still evaluate the
1799 return expression so that, even when the expression result
1800 is discarded, side effects such as "return i++" still
1802 return_value
= NULL
;
1803 /* FIXME: cagney/2004-01-17: If the architecture implements both
1804 return_value and extract_returned_value_address, should allow
1805 "return" to work - don't set return_value to NULL. */
1806 else if (!gdbarch_return_value_p (current_gdbarch
)
1807 && (TYPE_CODE (return_type
) == TYPE_CODE_STRUCT
1808 || TYPE_CODE (return_type
) == TYPE_CODE_UNION
))
1810 /* NOTE: cagney/2003-10-20: Compatibility hack for legacy
1811 code. Old architectures don't expect STORE_RETURN_VALUE
1812 to be called with with a small struct that needs to be
1813 stored in registers. Don't start doing it now. */
1815 A structure or union return type is not supported by this architecture.\n\
1816 If you continue, the return value that you specified will be ignored.\n";
1817 return_value
= NULL
;
1819 else if (using_struct_return (return_type
, 0))
1822 The location at which to store the function's return value is unknown.\n\
1823 If you continue, the return value that you specified will be ignored.\n";
1824 return_value
= NULL
;
1828 /* Does an interactive user really want to do this? Include
1829 information, such as how well GDB can handle the return value, in
1830 the query message. */
1834 if (thisfun
== NULL
)
1835 confirmed
= query ("%sMake selected stack frame return now? ",
1838 confirmed
= query ("%sMake %s return now? ", query_prefix
,
1839 SYMBOL_PRINT_NAME (thisfun
));
1841 error ("Not confirmed");
1844 /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
1845 frame in turn, should this code just go straight to the relevant
1846 frame and pop that? */
1848 /* First discard all frames inner-to the selected frame (making the
1849 selected frame current). */
1851 struct frame_id selected_id
= get_frame_id (get_selected_frame ());
1852 while (!frame_id_eq (selected_id
, get_frame_id (get_current_frame ())))
1854 if (frame_id_inner (selected_id
, get_frame_id (get_current_frame ())))
1855 /* Caught in the safety net, oops! We've gone way past the
1857 error ("Problem while popping stack frames (corrupt stack?)");
1858 frame_pop (get_current_frame ());
1862 /* Second discard the selected frame (which is now also the current
1864 frame_pop (get_current_frame ());
1866 /* Store RETURN_VAUE in the just-returned register set. */
1867 if (return_value
!= NULL
)
1869 struct type
*return_type
= VALUE_TYPE (return_value
);
1870 gdb_assert (gdbarch_return_value (current_gdbarch
, return_type
,
1872 == RETURN_VALUE_REGISTER_CONVENTION
);
1873 gdbarch_return_value (current_gdbarch
, return_type
,
1874 current_regcache
, NULL
/*read*/,
1875 VALUE_CONTENTS (return_value
) /*write*/);
1878 /* If we are at the end of a call dummy now, pop the dummy frame
1880 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME
)
1881 frame_pop (get_current_frame ());
1883 /* If interactive, print the frame that is now current. */
1885 frame_command ("0", 1);
1887 select_frame_command ("0", 0);
1890 /* Sets the scope to input function name, provided that the
1891 function is within the current stack frame */
1893 struct function_bounds
1895 CORE_ADDR low
, high
;
1898 static void func_command (char *arg
, int from_tty
);
1900 func_command (char *arg
, int from_tty
)
1902 struct frame_info
*fp
;
1904 struct symtabs_and_lines sals
;
1907 struct function_bounds
*func_bounds
= (struct function_bounds
*) NULL
;
1909 if (arg
!= (char *) NULL
)
1912 fp
= parse_frame_specification ("0");
1913 sals
= decode_line_spec (arg
, 1);
1914 func_bounds
= (struct function_bounds
*) xmalloc (
1915 sizeof (struct function_bounds
) * sals
.nelts
);
1916 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1918 if (sals
.sals
[i
].pc
== (CORE_ADDR
) 0 ||
1919 find_pc_partial_function (sals
.sals
[i
].pc
,
1921 &func_bounds
[i
].low
,
1922 &func_bounds
[i
].high
) == 0)
1924 func_bounds
[i
].low
=
1925 func_bounds
[i
].high
= (CORE_ADDR
) NULL
;
1931 for (i
= 0; (i
< sals
.nelts
&& !found
); i
++)
1932 found
= (get_frame_pc (fp
) >= func_bounds
[i
].low
&&
1933 get_frame_pc (fp
) < func_bounds
[i
].high
);
1937 fp
= find_relative_frame (fp
, &level
);
1940 while (!found
&& level
== 0);
1943 xfree (func_bounds
);
1946 printf_filtered ("'%s' not within current stack frame.\n", arg
);
1947 else if (fp
!= deprecated_selected_frame
)
1948 select_and_print_frame (fp
);
1951 /* Gets the language of the current frame. */
1954 get_frame_language (void)
1957 enum language flang
; /* The language of the current frame */
1959 if (deprecated_selected_frame
)
1961 /* We determine the current frame language by looking up its
1962 associated symtab. To retrieve this symtab, we use the frame PC.
1963 However we cannot use the frame pc as is, because it usually points
1964 to the instruction following the "call", which is sometimes the first
1965 instruction of another function. So we rely on
1966 get_frame_address_in_block(), it provides us with a PC which is
1967 guaranteed to be inside the frame's code block. */
1968 s
= find_pc_symtab (get_frame_address_in_block (deprecated_selected_frame
));
1970 flang
= s
->language
;
1972 flang
= language_unknown
;
1975 flang
= language_unknown
;
1981 _initialize_stack (void)
1984 backtrace_limit
= 30;
1987 add_com ("return", class_stack
, return_command
,
1988 "Make selected stack frame return to its caller.\n\
1989 Control remains in the debugger, but when you continue\n\
1990 execution will resume in the frame above the one now selected.\n\
1991 If an argument is given, it is an expression for the value to return.");
1993 add_com ("up", class_stack
, up_command
,
1994 "Select and print stack frame that called this one.\n\
1995 An argument says how many frames up to go.");
1996 add_com ("up-silently", class_support
, up_silently_command
,
1997 "Same as the `up' command, but does not print anything.\n\
1998 This is useful in command scripts.");
2000 add_com ("down", class_stack
, down_command
,
2001 "Select and print stack frame called by this one.\n\
2002 An argument says how many frames down to go.");
2003 add_com_alias ("do", "down", class_stack
, 1);
2004 add_com_alias ("dow", "down", class_stack
, 1);
2005 add_com ("down-silently", class_support
, down_silently_command
,
2006 "Same as the `down' command, but does not print anything.\n\
2007 This is useful in command scripts.");
2009 add_com ("frame", class_stack
, frame_command
,
2010 "Select and print a stack frame.\n\
2011 With no argument, print the selected stack frame. (See also \"info frame\").\n\
2012 An argument specifies the frame to select.\n\
2013 It can be a stack frame number or the address of the frame.\n\
2014 With argument, nothing is printed if input is coming from\n\
2015 a command file or a user-defined command.");
2017 add_com_alias ("f", "frame", class_stack
, 1);
2021 add_com ("L", class_stack
, current_frame_command
,
2022 "Print the current stack frame.\n");
2023 add_com_alias ("V", "frame", class_stack
, 1);
2025 add_com ("select-frame", class_stack
, select_frame_command
,
2026 "Select a stack frame without printing anything.\n\
2027 An argument specifies the frame to select.\n\
2028 It can be a stack frame number or the address of the frame.\n");
2030 add_com ("backtrace", class_stack
, backtrace_command
,
2031 "Print backtrace of all stack frames, or innermost COUNT frames.\n\
2032 With a negative argument, print outermost -COUNT frames.\n\
2033 Use of the 'full' qualifier also prints the values of the local variables.\n");
2034 add_com_alias ("bt", "backtrace", class_stack
, 0);
2037 add_com_alias ("t", "backtrace", class_stack
, 0);
2038 add_com ("T", class_stack
, backtrace_full_command
,
2039 "Print backtrace of all stack frames, or innermost COUNT frames \n\
2040 and the values of the local variables.\n\
2041 With a negative argument, print outermost -COUNT frames.\n\
2042 Usage: T <count>\n");
2045 add_com_alias ("where", "backtrace", class_alias
, 0);
2046 add_info ("stack", backtrace_command
,
2047 "Backtrace of the stack, or innermost COUNT frames.");
2048 add_info_alias ("s", "stack", 1);
2049 add_info ("frame", frame_info
,
2050 "All about selected stack frame, or frame at ADDR.");
2051 add_info_alias ("f", "frame", 1);
2052 add_info ("locals", locals_info
,
2053 "Local variables of current stack frame.");
2054 add_info ("args", args_info
,
2055 "Argument variables of current stack frame.");
2057 add_com ("l", class_info
, args_plus_locals_info
,
2058 "Argument and local variables of current stack frame.");
2061 add_com ("func", class_stack
, func_command
,
2062 "Select the stack frame that contains <func>.\nUsage: func <name>\n");
2064 add_info ("catch", catch_info
,
2065 "Exceptions that can be caught in the current stack frame.");
2068 add_cmd ("backtrace-limit", class_stack
, set_backtrace_limit_command
,
2069 "Specify maximum number of frames for \"backtrace\" to print by default.",
2071 add_info ("backtrace-limit", backtrace_limit_info
,
2072 "The maximum number of frames for \"backtrace\" to print by default.");