2007-06-13 Markus Deuling <deuling@de.ibm.com>
[deliverable/binutils-gdb.git] / gdb / stack.c
CommitLineData
c906108c 1/* Print and select stack frames for GDB, the GNU debugger.
8926118c 2
6aba47ca
DJ
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
0fd88904 5 Free Software Foundation, Inc.
c906108c 6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM
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.
c906108c 13
c5aa993b
JM
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.
c906108c 18
c5aa993b
JM
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
197e01b6
EZ
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
c906108c 23
c906108c 24#include "defs.h"
c906108c
SS
25#include "value.h"
26#include "symtab.h"
27#include "gdbtypes.h"
28#include "expression.h"
29#include "language.h"
30#include "frame.h"
31#include "gdbcmd.h"
32#include "gdbcore.h"
33#include "target.h"
0378c332 34#include "source.h"
c906108c
SS
35#include "breakpoint.h"
36#include "demangle.h"
37#include "inferior.h"
38#include "annotate.h"
8b93c638 39#include "ui-out.h"
fe898f56 40#include "block.h"
b9362cc7 41#include "stack.h"
de4f826b 42#include "dictionary.h"
60250e8b 43#include "exceptions.h"
898c62f5 44#include "reggroups.h"
fc70c2a0 45#include "regcache.h"
a77053c2 46#include "solib.h"
033a42c2 47#include "valprint.h"
c906108c 48
033a42c2
MK
49#include "gdb_assert.h"
50#include <ctype.h>
51#include "gdb_string.h"
c906108c 52
9a4105ab 53void (*deprecated_selected_frame_level_changed_hook) (int);
c906108c 54
a58dd373 55/* Prototypes for local functions. */
c906108c 56
d9fcf2fb
JM
57static void print_frame_local_vars (struct frame_info *, int,
58 struct ui_file *);
c906108c 59
033a42c2
MK
60static void print_frame (struct frame_info *frame, int print_level,
61 enum print_what print_what, int print_args,
c5394b80
JM
62 struct symtab_and_line sal);
63
c906108c
SS
64/* Zero means do things normally; we are interacting directly with the
65 user. One means print the full filename and linenumber when a
66 frame is printed, and do so in a format emacs18/emacs19.22 can
67 parse. Two means print similar annotations, but in many more
68 cases and in a slightly different syntax. */
69
70int annotation_level = 0;
c906108c 71\f
c5aa993b
JM
72
73struct print_stack_frame_args
033a42c2
MK
74{
75 struct frame_info *frame;
76 int print_level;
77 enum print_what print_what;
78 int print_args;
79};
80
81/* Show or print the frame arguments; stub for catch_errors. */
82
c906108c 83static int
fba45db2 84print_stack_frame_stub (void *args)
c906108c 85{
c789492a 86 struct print_stack_frame_args *p = args;
033a42c2 87 int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
c906108c 88
033a42c2
MK
89 print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
90 set_current_sal_from_frame (p->frame, center);
c906108c
SS
91 return 0;
92}
93
033a42c2 94/* Show or print a stack frame FRAME briefly. The output is format
d762c46a
AC
95 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
96 relative level, function name, argument list, and file name and
97 line number. If the frame's PC is not at the beginning of the
98 source line, the actual PC is printed at the beginning. */
c906108c
SS
99
100void
033a42c2 101print_stack_frame (struct frame_info *frame, int print_level,
0faf0076 102 enum print_what print_what)
c906108c
SS
103{
104 struct print_stack_frame_args args;
105
033a42c2 106 args.frame = frame;
0faf0076
AC
107 args.print_level = print_level;
108 args.print_what = print_what;
aaf9e9fd
DP
109 /* For mi, alway print location and address. */
110 args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
0faf0076 111 args.print_args = 1;
c906108c 112
033a42c2 113 catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ALL);
7789c6f5 114}
c906108c 115
c5aa993b
JM
116struct print_args_args
117{
c906108c 118 struct symbol *func;
033a42c2 119 struct frame_info *frame;
d9fcf2fb 120 struct ui_file *stream;
c906108c
SS
121};
122
033a42c2 123static int print_args_stub (void *args);
c906108c 124
033a42c2
MK
125/* Print nameless arguments of frame FRAME on STREAM, where START is
126 the offset of the first nameless argument, and NUM is the number of
127 nameless arguments to print. FIRST is nonzero if this is the first
128 argument (not just the first nameless argument). */
8d3b0994
AC
129
130static void
033a42c2 131print_frame_nameless_args (struct frame_info *frame, long start, int num,
8d3b0994
AC
132 int first, struct ui_file *stream)
133{
134 int i;
135 CORE_ADDR argsaddr;
136 long arg_value;
137
138 for (i = 0; i < num; i++)
139 {
140 QUIT;
033a42c2 141 argsaddr = get_frame_args_address (frame);
8d3b0994
AC
142 if (!argsaddr)
143 return;
144 arg_value = read_memory_integer (argsaddr + start, sizeof (int));
145 if (!first)
146 fprintf_filtered (stream, ", ");
147 fprintf_filtered (stream, "%ld", arg_value);
148 first = 0;
149 start += sizeof (int);
150 }
151}
152
033a42c2
MK
153/* Print the arguments of frame FRAME on STREAM, given the function
154 FUNC running in that frame (as a symbol), where NUM is the number
155 of arguments according to the stack frame (or -1 if the number of
156 arguments is unknown). */
8d3b0994 157
033a42c2
MK
158/* Note that currently the "number of argumentss according to the
159 stack frame" is only known on VAX where i refers to the "number of
160 ints of argumentss according to the stack frame". */
8d3b0994
AC
161
162static void
033a42c2
MK
163print_frame_args (struct symbol *func, struct frame_info *frame,
164 int num, struct ui_file *stream)
8d3b0994 165{
8d3b0994 166 int first = 1;
8d3b0994 167 /* Offset of next stack argument beyond the one we have seen that is
033a42c2
MK
168 at the highest offset, or -1 if we haven't come to a stack
169 argument yet. */
8d3b0994 170 long highest_offset = -1;
8d3b0994
AC
171 /* Number of ints of arguments that we have printed so far. */
172 int args_printed = 0;
173 struct cleanup *old_chain, *list_chain;
174 struct ui_stream *stb;
175
176 stb = ui_out_stream_new (uiout);
177 old_chain = make_cleanup_ui_out_stream_delete (stb);
178
179 if (func)
180 {
033a42c2
MK
181 struct block *b = SYMBOL_BLOCK_VALUE (func);
182 struct dict_iterator iter;
183 struct symbol *sym;
184 struct value *val;
8d3b0994 185
de4f826b 186 ALL_BLOCK_SYMBOLS (b, iter, sym)
8d3b0994
AC
187 {
188 QUIT;
189
190 /* Keep track of the highest stack argument offset seen, and
191 skip over any kinds of symbols we don't care about. */
192
193 switch (SYMBOL_CLASS (sym))
194 {
195 case LOC_ARG:
196 case LOC_REF_ARG:
197 {
198 long current_offset = SYMBOL_VALUE (sym);
033a42c2 199 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
8d3b0994
AC
200
201 /* Compute address of next argument by adding the size of
202 this argument and rounding to an int boundary. */
203 current_offset =
204 ((current_offset + arg_size + sizeof (int) - 1)
205 & ~(sizeof (int) - 1));
206
033a42c2
MK
207 /* If this is the highest offset seen yet, set
208 highest_offset. */
8d3b0994
AC
209 if (highest_offset == -1
210 || (current_offset > highest_offset))
211 highest_offset = current_offset;
212
033a42c2
MK
213 /* Add the number of ints we're about to print to
214 args_printed. */
8d3b0994
AC
215 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
216 }
217
033a42c2
MK
218 /* We care about types of symbols, but don't need to
219 keep track of stack offsets in them. */
8d3b0994
AC
220 case LOC_REGPARM:
221 case LOC_REGPARM_ADDR:
222 case LOC_LOCAL_ARG:
223 case LOC_BASEREG_ARG:
224 case LOC_COMPUTED_ARG:
225 break;
226
227 /* Other types of symbols we just skip over. */
228 default:
229 continue;
230 }
231
232 /* We have to look up the symbol because arguments can have
233 two entries (one a parameter, one a local) and the one we
234 want is the local, which lookup_symbol will find for us.
033a42c2 235 This includes gcc1 (not gcc2) on SPARC when passing a
8d3b0994
AC
236 small structure and gcc2 when the argument type is float
237 and it is passed as a double and converted to float by
238 the prologue (in the latter case the type of the LOC_ARG
239 symbol is double and the type of the LOC_LOCAL symbol is
240 float). */
033a42c2
MK
241 /* But if the parameter name is null, don't try it. Null
242 parameter names occur on the RS/6000, for traceback
243 tables. FIXME, should we even print them? */
8d3b0994
AC
244
245 if (*DEPRECATED_SYMBOL_NAME (sym))
246 {
247 struct symbol *nsym;
033a42c2
MK
248 nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
249 b, VAR_DOMAIN, NULL, NULL);
8d3b0994
AC
250 if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
251 {
033a42c2
MK
252 /* There is a LOC_ARG/LOC_REGISTER pair. This means
253 that it was passed on the stack and loaded into a
254 register, or passed in a register and stored in a
255 stack slot. GDB 3.x used the LOC_ARG; GDB
256 4.0-4.11 used the LOC_REGISTER.
8d3b0994
AC
257
258 Reasons for using the LOC_ARG:
033a42c2
MK
259
260 (1) Because find_saved_registers may be slow for
261 remote debugging.
262
263 (2) Because registers are often re-used and stack
264 slots rarely (never?) are. Therefore using
265 the stack slot is much less likely to print
266 garbage.
8d3b0994
AC
267
268 Reasons why we might want to use the LOC_REGISTER:
033a42c2
MK
269
270 (1) So that the backtrace prints the same value
271 as "print foo". I see no compelling reason
272 why this needs to be the case; having the
273 backtrace print the value which was passed
274 in, and "print foo" print the value as
275 modified within the called function, makes
276 perfect sense to me.
277
278 Additional note: It might be nice if "info args"
279 displayed both values.
280
281 One more note: There is a case with SPARC
282 structure passing where we need to use the
283 LOC_REGISTER, but this is dealt with by creating
284 a single LOC_REGPARM in symbol reading. */
8d3b0994
AC
285
286 /* Leave sym (the LOC_ARG) alone. */
287 ;
288 }
289 else
290 sym = nsym;
291 }
292
293 /* Print the current arg. */
294 if (!first)
295 ui_out_text (uiout, ", ");
296 ui_out_wrap_hint (uiout, " ");
297
298 annotate_arg_begin ();
299
300 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
301 fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
033a42c2
MK
302 SYMBOL_LANGUAGE (sym),
303 DMGL_PARAMS | DMGL_ANSI);
8d3b0994
AC
304 ui_out_field_stream (uiout, "name", stb);
305 annotate_arg_name_end ();
306 ui_out_text (uiout, "=");
307
033a42c2
MK
308 /* Avoid value_print because it will deref ref parameters.
309 We just want to print their addresses. Print ??? for
310 args whose address we do not know. We pass 2 as
311 "recurse" to val_print because our standard indentation
312 here is 4 spaces, and val_print indents 2 for each
313 recurse. */
314 val = read_var_value (sym, frame);
8d3b0994 315
df407dfe 316 annotate_arg_value (val == NULL ? NULL : value_type (val));
8d3b0994
AC
317
318 if (val)
319 {
806048c6 320 common_val_print (val, stb->stream, 0, 0, 2, Val_no_prettyprint);
8d3b0994
AC
321 ui_out_field_stream (uiout, "value", stb);
322 }
323 else
324 ui_out_text (uiout, "???");
325
326 /* Invoke ui_out_tuple_end. */
327 do_cleanups (list_chain);
328
329 annotate_arg_end ();
330
331 first = 0;
332 }
333 }
334
335 /* Don't print nameless args in situations where we don't know
336 enough about the stack to find them. */
337 if (num != -1)
338 {
339 long start;
340
341 if (highest_offset == -1)
bbcf301a 342 start = gdbarch_frame_args_skip (current_gdbarch);
8d3b0994
AC
343 else
344 start = highest_offset;
345
033a42c2 346 print_frame_nameless_args (frame, start, num - args_printed,
8d3b0994
AC
347 first, stream);
348 }
033a42c2 349
8d3b0994
AC
350 do_cleanups (old_chain);
351}
352
033a42c2 353/* Stub for catch_errors. */
c906108c
SS
354
355static int
4efb68b1 356print_args_stub (void *args)
c906108c 357{
033a42c2 358 struct print_args_args *p = args;
c906108c 359 int numargs;
c906108c 360
bbcf301a 361 if (gdbarch_frame_num_args_p (current_gdbarch))
983a287a 362 {
bbcf301a 363 numargs = gdbarch_frame_num_args (current_gdbarch, p->frame);
983a287a
AC
364 gdb_assert (numargs >= 0);
365 }
366 else
367 numargs = -1;
033a42c2 368 print_frame_args (p->func, p->frame, numargs, p->stream);
c906108c
SS
369 return 0;
370}
371
033a42c2
MK
372/* Set the current source and line to the location given by frame
373 FRAME, if possible. When CENTER is true, adjust so the relevant
374 line is in the center of the next 'list'. */
c789492a 375
7abfe014 376void
033a42c2 377set_current_sal_from_frame (struct frame_info *frame, int center)
c789492a
FL
378{
379 struct symtab_and_line sal;
380
033a42c2 381 find_frame_sal (frame, &sal);
c789492a
FL
382 if (sal.symtab)
383 {
384 if (center)
385 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
386 set_current_source_symtab_and_line (&sal);
387 }
388}
389
033a42c2
MK
390/* Print information about frame FRAME. The output is format according
391 to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
392 PRINT_WHAT is:
393
394 SRC_LINE: Print only source line.
395 LOCATION: Print only location.
396 LOC_AND_SRC: Print location and source line.
397
398 Used in "where" output, and to emit breakpoint or step
399 messages. */
c906108c 400
7789c6f5 401void
033a42c2 402print_frame_info (struct frame_info *frame, int print_level,
0faf0076 403 enum print_what print_what, int print_args)
c906108c
SS
404{
405 struct symtab_and_line sal;
c5394b80
JM
406 int source_print;
407 int location_print;
c906108c 408
033a42c2
MK
409 if (get_frame_type (frame) == DUMMY_FRAME
410 || get_frame_type (frame) == SIGTRAMP_FRAME)
c906108c 411 {
075559bc
AC
412 struct cleanup *uiout_cleanup
413 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
c906108c 414
033a42c2
MK
415 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
416 get_frame_pc (frame));
6a3fe0a4 417
c906108c 418 /* Do this regardless of SOURCE because we don't have any source
c5aa993b 419 to list for this frame. */
0faf0076 420 if (print_level)
52c6a6ac
JJ
421 {
422 ui_out_text (uiout, "#");
0faf0076 423 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
033a42c2 424 frame_relative_level (frame));
52c6a6ac 425 }
075559bc 426 if (ui_out_is_mi_like_p (uiout))
52c6a6ac 427 {
075559bc 428 annotate_frame_address ();
033a42c2 429 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
075559bc 430 annotate_frame_address_end ();
52c6a6ac 431 }
6a3fe0a4 432
033a42c2 433 if (get_frame_type (frame) == DUMMY_FRAME)
075559bc
AC
434 {
435 annotate_function_call ();
436 ui_out_field_string (uiout, "func", "<function called from gdb>");
437 }
033a42c2 438 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
075559bc
AC
439 {
440 annotate_signal_handler_caller ();
441 ui_out_field_string (uiout, "func", "<signal handler called>");
442 }
443 ui_out_text (uiout, "\n");
c906108c 444 annotate_frame_end ();
075559bc
AC
445
446 do_cleanups (uiout_cleanup);
c906108c
SS
447 return;
448 }
449
033a42c2
MK
450 /* If FRAME is not the innermost frame, that normally means that
451 FRAME->pc points to *after* the call instruction, and we want to
452 get the line containing the call, never the next line. But if
453 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
454 next frame was not entered as the result of a call, and we want
455 to get the line containing FRAME->pc. */
456 find_frame_sal (frame, &sal);
c906108c 457
0faf0076
AC
458 location_print = (print_what == LOCATION
459 || print_what == LOC_AND_ADDRESS
460 || print_what == SRC_AND_LOC);
c5394b80
JM
461
462 if (location_print || !sal.symtab)
033a42c2 463 print_frame (frame, print_level, print_what, print_args, sal);
c5394b80 464
0faf0076 465 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
0378c332 466
c5394b80
JM
467 if (source_print && sal.symtab)
468 {
469 int done = 0;
0faf0076 470 int mid_statement = ((print_what == SRC_LINE)
033a42c2 471 && (get_frame_pc (frame) != sal.pc));
c5394b80
JM
472
473 if (annotation_level)
474 done = identify_source_line (sal.symtab, sal.line, mid_statement,
033a42c2 475 get_frame_pc (frame));
c5394b80
JM
476 if (!done)
477 {
9a4105ab 478 if (deprecated_print_frame_info_listing_hook)
cbd3c883
MS
479 deprecated_print_frame_info_listing_hook (sal.symtab,
480 sal.line,
481 sal.line + 1, 0);
ba4bbdcb 482 else
c5394b80 483 {
ba4bbdcb
KS
484 /* We used to do this earlier, but that is clearly
485 wrong. This function is used by many different
486 parts of gdb, including normal_stop in infrun.c,
487 which uses this to print out the current PC
488 when we stepi/nexti into the middle of a source
489 line. Only the command line really wants this
490 behavior. Other UIs probably would like the
cbd3c883 491 ability to decide for themselves if it is desired. */
ba4bbdcb
KS
492 if (addressprint && mid_statement)
493 {
033a42c2 494 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
ba4bbdcb 495 ui_out_text (uiout, "\t");
ba4bbdcb
KS
496 }
497
498 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
c5394b80 499 }
c5394b80 500 }
c5394b80
JM
501 }
502
0faf0076 503 if (print_what != LOCATION)
033a42c2 504 set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line);
c5394b80
JM
505
506 annotate_frame_end ();
507
508 gdb_flush (gdb_stdout);
509}
510
511static void
033a42c2
MK
512print_frame (struct frame_info *frame, int print_level,
513 enum print_what print_what, int print_args,
c5394b80
JM
514 struct symtab_and_line sal)
515{
516 struct symbol *func;
033a42c2 517 char *funname = NULL;
c5394b80 518 enum language funlang = language_unknown;
8b93c638 519 struct ui_stream *stb;
033a42c2 520 struct cleanup *old_chain, *list_chain;
8b93c638
JM
521
522 stb = ui_out_stream_new (uiout);
b02eeafb 523 old_chain = make_cleanup_ui_out_stream_delete (stb);
c5394b80 524
033a42c2 525 func = find_pc_function (get_frame_address_in_block (frame));
c906108c
SS
526 if (func)
527 {
528 /* In certain pathological cases, the symtabs give the wrong
c5aa993b
JM
529 function (when we are in the first function in a file which
530 is compiled without debugging symbols, the previous function
531 is compiled with debugging symbols, and the "foo.o" symbol
033a42c2
MK
532 that is supposed to tell us where the file with debugging
533 symbols ends has been truncated by ar because it is longer
534 than 15 characters). This also occurs if the user uses asm()
535 to create a function but not stabs for it (in a file compiled
536 with -g).
c5aa993b
JM
537
538 So look in the minimal symbol tables as well, and if it comes
539 up with a larger address for the function use that instead.
033a42c2
MK
540 I don't think this can ever cause any problems; there
541 shouldn't be any minimal symbols in the middle of a function;
542 if this is ever changed many parts of GDB will need to be
543 changed (and we'll create a find_pc_minimal_function or some
544 such). */
545
546 struct minimal_symbol *msymbol =
547 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
c906108c 548
c906108c 549 if (msymbol != NULL
c5aa993b 550 && (SYMBOL_VALUE_ADDRESS (msymbol)
c906108c
SS
551 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
552 {
c906108c
SS
553 /* We also don't know anything about the function besides
554 its address and name. */
555 func = 0;
22abf04a 556 funname = DEPRECATED_SYMBOL_NAME (msymbol);
c906108c
SS
557 funlang = SYMBOL_LANGUAGE (msymbol);
558 }
559 else
560 {
22abf04a 561 funname = DEPRECATED_SYMBOL_NAME (func);
c906108c 562 funlang = SYMBOL_LANGUAGE (func);
c5aa993b
JM
563 if (funlang == language_cplus)
564 {
033a42c2
MK
565 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
566 to display the demangled name that we already have
567 stored in the symbol table, but we stored a version
568 with DMGL_PARAMS turned on, and here we don't want to
569 display parameters. So call the demangler again, with
570 DMGL_ANSI only.
571
572 Yes, printf_symbol_filtered() will again try to
573 demangle the name on the fly, but the issue is that
574 if cplus_demangle() fails here, it will fail there
575 too. So we want to catch the failure (where DEMANGLED
576 is NULL below) here, while we still have our hands on
577 the function symbol.) */
578 char *demangled = cplus_demangle (funname, DMGL_ANSI);
c5aa993b 579 if (demangled == NULL)
c5394b80 580 /* If the demangler fails, try the demangled name from
033a42c2
MK
581 the symbol table. That'll have parameters, but
582 that's preferable to displaying a mangled name. */
de5ad195 583 funname = SYMBOL_PRINT_NAME (func);
c5aa993b 584 }
c906108c
SS
585 }
586 }
587 else
588 {
033a42c2
MK
589 struct minimal_symbol *msymbol =
590 lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
591
c906108c
SS
592 if (msymbol != NULL)
593 {
22abf04a 594 funname = DEPRECATED_SYMBOL_NAME (msymbol);
c906108c
SS
595 funlang = SYMBOL_LANGUAGE (msymbol);
596 }
597 }
598
033a42c2
MK
599 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
600 get_frame_pc (frame));
c5394b80 601
666547aa 602 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
c5394b80 603
0faf0076 604 if (print_level)
8b93c638 605 {
8b93c638 606 ui_out_text (uiout, "#");
0faf0076 607 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
033a42c2 608 frame_relative_level (frame));
8b93c638 609 }
c5394b80 610 if (addressprint)
033a42c2 611 if (get_frame_pc (frame) != sal.pc || !sal.symtab
0faf0076 612 || print_what == LOC_AND_ADDRESS)
c5394b80
JM
613 {
614 annotate_frame_address ();
033a42c2 615 ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));
8b93c638
JM
616 annotate_frame_address_end ();
617 ui_out_text (uiout, " in ");
c5394b80
JM
618 }
619 annotate_frame_function_name ();
033a42c2
MK
620 fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
621 funlang, DMGL_ANSI);
8b93c638
JM
622 ui_out_field_stream (uiout, "func", stb);
623 ui_out_wrap_hint (uiout, " ");
c5394b80
JM
624 annotate_frame_args ();
625
8b93c638 626 ui_out_text (uiout, " (");
0faf0076 627 if (print_args)
c906108c 628 {
c5394b80 629 struct print_args_args args;
d493eb33 630 struct cleanup *args_list_chain;
033a42c2 631 args.frame = frame;
c5394b80
JM
632 args.func = func;
633 args.stream = gdb_stdout;
68c81b54 634 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
c5394b80 635 catch_errors (print_args_stub, &args, "", RETURN_MASK_ALL);
033a42c2
MK
636 /* FIXME: ARGS must be a list. If one argument is a string it
637 will have " that will not be properly escaped. */
666547aa 638 /* Invoke ui_out_tuple_end. */
d493eb33 639 do_cleanups (args_list_chain);
c5394b80
JM
640 QUIT;
641 }
8b93c638 642 ui_out_text (uiout, ")");
c5394b80
JM
643 if (sal.symtab && sal.symtab->filename)
644 {
645 annotate_frame_source_begin ();
8b93c638
JM
646 ui_out_wrap_hint (uiout, " ");
647 ui_out_text (uiout, " at ");
648 annotate_frame_source_file ();
649 ui_out_field_string (uiout, "file", sal.symtab->filename);
76ff342d
DJ
650 if (ui_out_is_mi_like_p (uiout))
651 {
652 const char *fullname = symtab_to_fullname (sal.symtab);
653 if (fullname != NULL)
654 ui_out_field_string (uiout, "fullname", fullname);
655 }
8b93c638
JM
656 annotate_frame_source_file_end ();
657 ui_out_text (uiout, ":");
658 annotate_frame_source_line ();
659 ui_out_field_int (uiout, "line", sal.line);
c5394b80
JM
660 annotate_frame_source_end ();
661 }
c906108c 662
c5394b80 663 if (!funname || (!sal.symtab || !sal.symtab->filename))
c906108c 664 {
a77053c2 665#ifdef PC_SOLIB
033a42c2 666 char *lib = PC_SOLIB (get_frame_pc (frame));
a77053c2 667#else
033a42c2 668 char *lib = solib_address (get_frame_pc (frame));
a77053c2 669#endif
c5394b80 670 if (lib)
c906108c 671 {
c5394b80 672 annotate_frame_where ();
8b93c638
JM
673 ui_out_wrap_hint (uiout, " ");
674 ui_out_text (uiout, " from ");
675 ui_out_field_string (uiout, "from", lib);
c906108c 676 }
c906108c 677 }
e514a9d6 678
666547aa 679 /* do_cleanups will call ui_out_tuple_end() for us. */
e6e0bfab 680 do_cleanups (list_chain);
8b93c638
JM
681 ui_out_text (uiout, "\n");
682 do_cleanups (old_chain);
c906108c
SS
683}
684\f
033a42c2
MK
685/* Show the frame info. If this is the tui, it will be shown in the
686 source display otherwise, nothing is done. */
687
c906108c 688void
033a42c2 689show_stack_frame (struct frame_info *frame)
c906108c 690{
c906108c 691}
c906108c 692\f
c5aa993b 693
033a42c2
MK
694/* Read a frame specification in whatever the appropriate format is
695 from FRAME_EXP. Call error(), printing MESSAGE, if the
696 specification is in any way invalid (so this function never returns
697 NULL). When SEPECTED_P is non-NULL set its target to indicate that
698 the default selected frame was used. */
c906108c 699
1c8831c5
AC
700static struct frame_info *
701parse_frame_specification_1 (const char *frame_exp, const char *message,
702 int *selected_frame_p)
c906108c 703{
1c8831c5
AC
704 int numargs;
705 struct value *args[4];
706 CORE_ADDR addrs[ARRAY_SIZE (args)];
c5aa993b 707
1c8831c5
AC
708 if (frame_exp == NULL)
709 numargs = 0;
710 else
c906108c 711 {
1c8831c5 712 char *addr_string;
c906108c
SS
713 struct cleanup *tmp_cleanup;
714
1c8831c5
AC
715 numargs = 0;
716 while (1)
c906108c 717 {
1c8831c5
AC
718 char *addr_string;
719 struct cleanup *cleanup;
720 const char *p;
721
722 /* Skip leading white space, bail of EOL. */
723 while (isspace (*frame_exp))
724 frame_exp++;
725 if (!*frame_exp)
726 break;
c906108c 727
1c8831c5
AC
728 /* Parse the argument, extract it, save it. */
729 for (p = frame_exp;
730 *p && !isspace (*p);
731 p++);
732 addr_string = savestring (frame_exp, p - frame_exp);
c906108c 733 frame_exp = p;
1c8831c5
AC
734 cleanup = make_cleanup (xfree, addr_string);
735
736 /* NOTE: Parse and evaluate expression, but do not use
737 functions such as parse_and_eval_long or
738 parse_and_eval_address to also extract the value.
739 Instead value_as_long and value_as_address are used.
740 This avoids problems with expressions that contain
741 side-effects. */
742 if (numargs >= ARRAY_SIZE (args))
8a3fe4f8 743 error (_("Too many args in frame specification"));
1c8831c5
AC
744 args[numargs++] = parse_and_eval (addr_string);
745
746 do_cleanups (cleanup);
c906108c
SS
747 }
748 }
749
1c8831c5
AC
750 /* If no args, default to the selected frame. */
751 if (numargs == 0)
c906108c 752 {
1c8831c5
AC
753 if (selected_frame_p != NULL)
754 (*selected_frame_p) = 1;
755 return get_selected_frame (message);
756 }
c906108c 757
1c8831c5
AC
758 /* None of the remaining use the selected frame. */
759 if (selected_frame_p != NULL)
98f276a0 760 (*selected_frame_p) = 0;
c906108c 761
1c8831c5
AC
762 /* Assume the single arg[0] is an integer, and try using that to
763 select a frame relative to current. */
764 if (numargs == 1)
765 {
766 struct frame_info *fid;
767 int level = value_as_long (args[0]);
768 fid = find_relative_frame (get_current_frame (), &level);
769 if (level == 0)
770 /* find_relative_frame was successful */
771 return fid;
772 }
c906108c 773
1c8831c5
AC
774 /* Convert each value into a corresponding address. */
775 {
776 int i;
777 for (i = 0; i < numargs; i++)
778 addrs[i] = value_as_address (args[0]);
779 }
c5aa993b 780
1c8831c5
AC
781 /* Assume that the single arg[0] is an address, use that to identify
782 a frame with a matching ID. Should this also accept stack/pc or
783 stack/pc/special. */
784 if (numargs == 1)
785 {
786 struct frame_id id = frame_id_build_wild (addrs[0]);
787 struct frame_info *fid;
788
1c8831c5
AC
789 /* If (s)he specifies the frame with an address, he deserves
790 what (s)he gets. Still, give the highest one that matches.
791 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
792 know). */
793 for (fid = get_current_frame ();
794 fid != NULL;
795 fid = get_prev_frame (fid))
796 {
797 if (frame_id_eq (id, get_frame_id (fid)))
798 {
799 while (frame_id_eq (id, frame_unwind_id (fid)))
800 fid = get_prev_frame (fid);
801 return fid;
802 }
803 }
c906108c
SS
804 }
805
1c8831c5
AC
806 /* We couldn't identify the frame as an existing frame, but
807 perhaps we can create one with a single argument. */
1c8831c5
AC
808 if (numargs == 1)
809 return create_new_frame (addrs[0], 0);
cd65c8f6
AC
810 else if (numargs == 2)
811 return create_new_frame (addrs[0], addrs[1]);
812 else
8a3fe4f8 813 error (_("Too many args in frame specification"));
1c8831c5
AC
814}
815
9c833c82 816static struct frame_info *
1c8831c5
AC
817parse_frame_specification (char *frame_exp)
818{
819 return parse_frame_specification_1 (frame_exp, NULL, NULL);
c906108c
SS
820}
821
033a42c2
MK
822/* Print verbosely the selected frame or the frame at address
823 ADDR_EXP. Absolutely all information in the frame is printed. */
c906108c
SS
824
825static void
fba45db2 826frame_info (char *addr_exp, int from_tty)
c906108c
SS
827{
828 struct frame_info *fi;
829 struct symtab_and_line sal;
830 struct symbol *func;
831 struct symtab *s;
832 struct frame_info *calling_frame_info;
833 int i, count, numregs;
834 char *funname = 0;
835 enum language funlang = language_unknown;
82de1e5b 836 const char *pc_regname;
1c8831c5 837 int selected_frame_p;
c906108c 838
1c8831c5 839 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
c906108c 840
82de1e5b
AC
841 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
842 is not a good name. */
843 if (PC_REGNUM >= 0)
844 /* OK, this is weird. The PC_REGNUM hardware register's value can
845 easily not match that of the internal value returned by
846 get_frame_pc(). */
c9f4d572 847 pc_regname = gdbarch_register_name (current_gdbarch, PC_REGNUM);
82de1e5b
AC
848 else
849 /* But then, this is weird to. Even without PC_REGNUM, an
850 architectures will often have a hardware register called "pc",
851 and that register's value, again, can easily not match
852 get_frame_pc(). */
853 pc_regname = "pc";
854
1058bca7 855 find_frame_sal (fi, &sal);
c906108c 856 func = get_frame_function (fi);
1058bca7 857 /* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
033a42c2 858 the same value? */
bdd78e62 859 s = find_pc_symtab (get_frame_pc (fi));
c906108c
SS
860 if (func)
861 {
033a42c2
MK
862 /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to
863 display the demangled name that we already have stored in the
864 symbol table, but we stored a version with DMGL_PARAMS turned
865 on, and here we don't want to display parameters. So call the
866 demangler again, with DMGL_ANSI only.
867
868 Yes, printf_symbol_filtered() will again try to demangle the
869 name on the fly, but the issue is that if cplus_demangle()
870 fails here, it will fail there too. So we want to catch the
871 failure (where DEMANGLED is NULL below) here, while we still
872 have our hands on the function symbol.) */
22abf04a 873 funname = DEPRECATED_SYMBOL_NAME (func);
c5aa993b
JM
874 funlang = SYMBOL_LANGUAGE (func);
875 if (funlang == language_cplus)
876 {
033a42c2
MK
877 char *demangled = cplus_demangle (funname, DMGL_ANSI);
878 /* If the demangler fails, try the demangled name from the
879 symbol table. That'll have parameters, but that's
880 preferable to displaying a mangled name. */
c5aa993b 881 if (demangled == NULL)
de5ad195 882 funname = SYMBOL_PRINT_NAME (func);
c5aa993b 883 }
c906108c
SS
884 }
885 else
886 {
033a42c2
MK
887 struct minimal_symbol *msymbol;
888
889 msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
c906108c
SS
890 if (msymbol != NULL)
891 {
22abf04a 892 funname = DEPRECATED_SYMBOL_NAME (msymbol);
c906108c
SS
893 funlang = SYMBOL_LANGUAGE (msymbol);
894 }
895 }
896 calling_frame_info = get_prev_frame (fi);
897
1c8831c5 898 if (selected_frame_p && frame_relative_level (fi) >= 0)
c906108c 899 {
a3f17187 900 printf_filtered (_("Stack level %d, frame at "),
1c8831c5 901 frame_relative_level (fi));
c906108c
SS
902 }
903 else
904 {
a3f17187 905 printf_filtered (_("Stack frame at "));
c906108c 906 }
9c833c82
FF
907 deprecated_print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
908 printf_filtered (":\n");
82de1e5b 909 printf_filtered (" %s = ", pc_regname);
66bf4b3a 910 deprecated_print_address_numeric (get_frame_pc (fi), 1, gdb_stdout);
c906108c
SS
911
912 wrap_here (" ");
913 if (funname)
914 {
915 printf_filtered (" in ");
916 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
917 DMGL_ANSI | DMGL_PARAMS);
918 }
919 wrap_here (" ");
920 if (sal.symtab)
921 printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
922 puts_filtered ("; ");
923 wrap_here (" ");
82de1e5b 924 printf_filtered ("saved %s ", pc_regname);
66bf4b3a 925 deprecated_print_address_numeric (frame_pc_unwind (fi), 1, gdb_stdout);
c906108c
SS
926 printf_filtered ("\n");
927
55feb689
DJ
928 if (calling_frame_info == NULL)
929 {
930 enum unwind_stop_reason reason;
931
932 reason = get_frame_unwind_stop_reason (fi);
933 if (reason != UNWIND_NO_REASON)
934 printf_filtered (_(" Outermost frame: %s\n"),
935 frame_stop_reason_string (reason));
936 }
937
c906108c
SS
938 if (calling_frame_info)
939 {
940 printf_filtered (" called by frame at ");
66bf4b3a 941 deprecated_print_address_numeric (get_frame_base (calling_frame_info),
8b36eed8 942 1, gdb_stdout);
c906108c 943 }
75e3c1f9 944 if (get_next_frame (fi) && calling_frame_info)
c906108c
SS
945 puts_filtered (",");
946 wrap_here (" ");
75e3c1f9 947 if (get_next_frame (fi))
c906108c
SS
948 {
949 printf_filtered (" caller of frame at ");
66bf4b3a 950 deprecated_print_address_numeric (get_frame_base (get_next_frame (fi)), 1,
8b36eed8 951 gdb_stdout);
c906108c 952 }
75e3c1f9 953 if (get_next_frame (fi) || calling_frame_info)
c906108c 954 puts_filtered ("\n");
55feb689 955
c906108c 956 if (s)
1058bca7
AC
957 printf_filtered (" source language %s.\n",
958 language_str (s->language));
c906108c 959
c906108c
SS
960 {
961 /* Address of the argument list for this frame, or 0. */
da62e633 962 CORE_ADDR arg_list = get_frame_args_address (fi);
c906108c
SS
963 /* Number of args for this frame, or -1 if unknown. */
964 int numargs;
965
966 if (arg_list == 0)
967 printf_filtered (" Arglist at unknown address.\n");
968 else
969 {
970 printf_filtered (" Arglist at ");
66bf4b3a 971 deprecated_print_address_numeric (arg_list, 1, gdb_stdout);
c906108c
SS
972 printf_filtered (",");
973
bbcf301a 974 if (!gdbarch_frame_num_args_p (current_gdbarch))
983a287a
AC
975 {
976 numargs = -1;
977 puts_filtered (" args: ");
978 }
c906108c 979 else
983a287a 980 {
bbcf301a 981 numargs = gdbarch_frame_num_args (current_gdbarch, fi);
983a287a
AC
982 gdb_assert (numargs >= 0);
983 if (numargs == 0)
984 puts_filtered (" no args.");
985 else if (numargs == 1)
986 puts_filtered (" 1 arg: ");
987 else
988 printf_filtered (" %d args: ", numargs);
989 }
c906108c
SS
990 print_frame_args (func, fi, numargs, gdb_stdout);
991 puts_filtered ("\n");
992 }
993 }
994 {
995 /* Address of the local variables for this frame, or 0. */
da62e633 996 CORE_ADDR arg_list = get_frame_locals_address (fi);
c906108c
SS
997
998 if (arg_list == 0)
999 printf_filtered (" Locals at unknown address,");
1000 else
1001 {
1002 printf_filtered (" Locals at ");
66bf4b3a 1003 deprecated_print_address_numeric (arg_list, 1, gdb_stdout);
c906108c
SS
1004 printf_filtered (",");
1005 }
1006 }
1007
4f460812
AC
1008 /* Print as much information as possible on the location of all the
1009 registers. */
1010 {
1011 enum lval_type lval;
1012 int optimized;
1013 CORE_ADDR addr;
1014 int realnum;
1015 int count;
1016 int i;
1017 int need_nl = 1;
1018
1019 /* The sp is special; what's displayed isn't the save address, but
1020 the value of the previous frame's sp. This is a legacy thing,
1021 at one stage the frame cached the previous frame's SP instead
1022 of its address, hence it was easiest to just display the cached
1023 value. */
1024 if (SP_REGNUM >= 0)
1025 {
1026 /* Find out the location of the saved stack pointer with out
1027 actually evaluating it. */
1028 frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
1029 &realnum, NULL);
1030 if (!optimized && lval == not_lval)
c906108c 1031 {
10c42a71 1032 gdb_byte value[MAX_REGISTER_SIZE];
4f460812
AC
1033 CORE_ADDR sp;
1034 frame_register_unwind (fi, SP_REGNUM, &optimized, &lval, &addr,
1035 &realnum, value);
af1342ab
AC
1036 /* NOTE: cagney/2003-05-22: This is assuming that the
1037 stack pointer was packed as an unsigned integer. That
1038 may or may not be valid. */
3acba339 1039 sp = extract_unsigned_integer (value, register_size (current_gdbarch, SP_REGNUM));
4f460812 1040 printf_filtered (" Previous frame's sp is ");
66bf4b3a 1041 deprecated_print_address_numeric (sp, 1, gdb_stdout);
4f460812
AC
1042 printf_filtered ("\n");
1043 need_nl = 0;
c906108c 1044 }
4f460812
AC
1045 else if (!optimized && lval == lval_memory)
1046 {
1047 printf_filtered (" Previous frame's sp at ");
66bf4b3a 1048 deprecated_print_address_numeric (addr, 1, gdb_stdout);
4f460812
AC
1049 printf_filtered ("\n");
1050 need_nl = 0;
1051 }
1052 else if (!optimized && lval == lval_register)
1053 {
1054 printf_filtered (" Previous frame's sp in %s\n",
c9f4d572 1055 gdbarch_register_name (current_gdbarch, realnum));
4f460812
AC
1056 need_nl = 0;
1057 }
1058 /* else keep quiet. */
1059 }
1060
1061 count = 0;
f57d151a
UW
1062 numregs = gdbarch_num_regs (current_gdbarch)
1063 + gdbarch_num_pseudo_regs (current_gdbarch);
4f460812 1064 for (i = 0; i < numregs; i++)
898c62f5
DJ
1065 if (i != SP_REGNUM
1066 && gdbarch_register_reggroup_p (current_gdbarch, i, all_reggroup))
4f460812
AC
1067 {
1068 /* Find out the location of the saved register without
1069 fetching the corresponding value. */
1070 frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
1071 NULL);
1072 /* For moment, only display registers that were saved on the
1073 stack. */
1074 if (!optimized && lval == lval_memory)
1075 {
1076 if (count == 0)
1077 puts_filtered (" Saved registers:\n ");
1078 else
1079 puts_filtered (",");
1080 wrap_here (" ");
c9f4d572
UW
1081 printf_filtered (" %s at ",
1082 gdbarch_register_name (current_gdbarch, i));
66bf4b3a 1083 deprecated_print_address_numeric (addr, 1, gdb_stdout);
4f460812
AC
1084 count++;
1085 }
1086 }
1087 if (count || need_nl)
c906108c 1088 puts_filtered ("\n");
4f460812 1089 }
c906108c
SS
1090}
1091
033a42c2
MK
1092/* Print briefly all stack frames or just the innermost COUNT_EXP
1093 frames. */
c906108c
SS
1094
1095static void
fba45db2 1096backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
c906108c
SS
1097{
1098 struct frame_info *fi;
52f0bd74
AC
1099 int count;
1100 int i;
1101 struct frame_info *trailing;
1102 int trailing_level;
c906108c
SS
1103
1104 if (!target_has_stack)
8a3fe4f8 1105 error (_("No stack."));
c906108c 1106
033a42c2
MK
1107 /* The following code must do two things. First, it must set the
1108 variable TRAILING to the frame from which we should start
c906108c
SS
1109 printing. Second, it must set the variable count to the number
1110 of frames which we should print, or -1 if all of them. */
1111 trailing = get_current_frame ();
d082b2bb
AC
1112
1113 /* The target can be in a state where there is no valid frames
1114 (e.g., just connected). */
1115 if (trailing == NULL)
8a3fe4f8 1116 error (_("No stack."));
d082b2bb 1117
c906108c
SS
1118 trailing_level = 0;
1119 if (count_exp)
1120 {
bb518678 1121 count = parse_and_eval_long (count_exp);
c906108c
SS
1122 if (count < 0)
1123 {
1124 struct frame_info *current;
1125
1126 count = -count;
1127
1128 current = trailing;
1129 while (current && count--)
1130 {
1131 QUIT;
1132 current = get_prev_frame (current);
1133 }
c5aa993b 1134
033a42c2
MK
1135 /* Will stop when CURRENT reaches the top of the stack.
1136 TRAILING will be COUNT below it. */
c906108c
SS
1137 while (current)
1138 {
1139 QUIT;
1140 trailing = get_prev_frame (trailing);
1141 current = get_prev_frame (current);
1142 trailing_level++;
1143 }
c5aa993b 1144
c906108c
SS
1145 count = -1;
1146 }
1147 }
1148 else
1149 count = -1;
1150
1151 if (info_verbose)
1152 {
1153 struct partial_symtab *ps;
c5aa993b 1154
033a42c2
MK
1155 /* Read in symbols for all of the frames. Need to do this in a
1156 separate pass so that "Reading in symbols for xxx" messages
1157 don't screw up the appearance of the backtrace. Also if
1158 people have strong opinions against reading symbols for
c5aa993b 1159 backtrace this may have to be an option. */
c906108c 1160 i = count;
033a42c2 1161 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
c906108c
SS
1162 {
1163 QUIT;
c4a09524 1164 ps = find_pc_psymtab (get_frame_address_in_block (fi));
c906108c 1165 if (ps)
033a42c2 1166 PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
c906108c
SS
1167 }
1168 }
1169
033a42c2 1170 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
c906108c
SS
1171 {
1172 QUIT;
1173
1174 /* Don't use print_stack_frame; if an error() occurs it probably
c5aa993b
JM
1175 means further attempts to backtrace would fail (on the other
1176 hand, perhaps the code does or could be fixed to make sure
1177 the frame->prev field gets set to NULL in that case). */
0faf0076 1178 print_frame_info (fi, 1, LOCATION, 1);
c906108c 1179 if (show_locals)
c5aa993b 1180 print_frame_local_vars (fi, 1, gdb_stdout);
55feb689
DJ
1181
1182 /* Save the last frame to check for error conditions. */
1183 trailing = fi;
c906108c
SS
1184 }
1185
1186 /* If we've stopped before the end, mention that. */
1187 if (fi && from_tty)
a3f17187 1188 printf_filtered (_("(More stack frames follow...)\n"));
55feb689
DJ
1189
1190 /* If we've run out of frames, and the reason appears to be an error
1191 condition, print it. */
1192 if (fi == NULL && trailing != NULL)
1193 {
1194 enum unwind_stop_reason reason;
1195
1196 reason = get_frame_unwind_stop_reason (trailing);
1197 if (reason > UNWIND_FIRST_ERROR)
1198 printf_filtered (_("Backtrace stopped: %s\n"),
1199 frame_stop_reason_string (reason));
1200 }
c906108c
SS
1201}
1202
d75e3c94 1203struct backtrace_command_args
033a42c2
MK
1204{
1205 char *count_exp;
1206 int show_locals;
1207 int from_tty;
1208};
1209
1210/* Stub for catch_errors. */
d75e3c94 1211
d75e3c94
JJ
1212static int
1213backtrace_command_stub (void *data)
1214{
033a42c2 1215 struct backtrace_command_args *args = data;
d75e3c94
JJ
1216 backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
1217 return 0;
1218}
1219
c906108c 1220static void
fba45db2 1221backtrace_command (char *arg, int from_tty)
c906108c 1222{
033a42c2
MK
1223 struct cleanup *old_chain = NULL;
1224 int fulltrace_arg = -1, arglen = 0, argc = 0;
d75e3c94 1225 struct backtrace_command_args btargs;
c906108c 1226
033a42c2 1227 if (arg)
c906108c 1228 {
033a42c2 1229 char **argv;
c906108c
SS
1230 int i;
1231
c5aa993b 1232 argv = buildargv (arg);
7a292a7a 1233 old_chain = make_cleanup_freeargv (argv);
c906108c 1234 argc = 0;
033a42c2 1235 for (i = 0; argv[i]; i++)
c5aa993b 1236 {
745b8ca0 1237 unsigned int j;
c5aa993b 1238
033a42c2 1239 for (j = 0; j < strlen (argv[i]); j++)
c5aa993b
JM
1240 argv[i][j] = tolower (argv[i][j]);
1241
033a42c2
MK
1242 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1243 fulltrace_arg = argc;
c5aa993b
JM
1244 else
1245 {
033a42c2 1246 arglen += strlen (argv[i]);
c5aa993b 1247 argc++;
c5aa993b
JM
1248 }
1249 }
033a42c2
MK
1250 arglen += argc;
1251 if (fulltrace_arg >= 0)
c5aa993b 1252 {
033a42c2 1253 if (arglen > 0)
c5aa993b 1254 {
033a42c2
MK
1255 arg = xmalloc (arglen + 1);
1256 memset (arg, 0, arglen + 1);
1257 for (i = 0; i < (argc + 1); i++)
c5aa993b 1258 {
033a42c2 1259 if (i != fulltrace_arg)
c5aa993b 1260 {
033a42c2
MK
1261 strcat (arg, argv[i]);
1262 strcat (arg, " ");
c5aa993b
JM
1263 }
1264 }
1265 }
1266 else
033a42c2 1267 arg = NULL;
c5aa993b 1268 }
c906108c
SS
1269 }
1270
033a42c2
MK
1271 btargs.count_exp = arg;
1272 btargs.show_locals = (fulltrace_arg >= 0);
d75e3c94 1273 btargs.from_tty = from_tty;
033a42c2 1274 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
c906108c 1275
033a42c2
MK
1276 if (fulltrace_arg >= 0 && arglen > 0)
1277 xfree (arg);
c906108c
SS
1278
1279 if (old_chain)
c5aa993b 1280 do_cleanups (old_chain);
c906108c
SS
1281}
1282
1283static void
fba45db2 1284backtrace_full_command (char *arg, int from_tty)
c906108c 1285{
d75e3c94
JJ
1286 struct backtrace_command_args btargs;
1287 btargs.count_exp = arg;
1288 btargs.show_locals = 1;
1289 btargs.from_tty = from_tty;
033a42c2 1290 catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
c906108c 1291}
c906108c 1292\f
c5aa993b 1293
033a42c2 1294/* Print the local variables of a block B active in FRAME on STREAM.
c906108c
SS
1295 Return 1 if any variables were printed; 0 otherwise. */
1296
1297static int
033a42c2 1298print_block_frame_locals (struct block *b, struct frame_info *frame,
de4f826b 1299 int num_tabs, struct ui_file *stream)
c906108c 1300{
de4f826b 1301 struct dict_iterator iter;
de4f826b
DC
1302 struct symbol *sym;
1303 int values_printed = 0;
033a42c2 1304 int j;
c906108c 1305
de4f826b 1306 ALL_BLOCK_SYMBOLS (b, iter, sym)
c906108c 1307 {
c906108c
SS
1308 switch (SYMBOL_CLASS (sym))
1309 {
1310 case LOC_LOCAL:
1311 case LOC_REGISTER:
1312 case LOC_STATIC:
1313 case LOC_BASEREG:
4c2df51b 1314 case LOC_COMPUTED:
c906108c
SS
1315 values_printed = 1;
1316 for (j = 0; j < num_tabs; j++)
c5aa993b 1317 fputs_filtered ("\t", stream);
de5ad195 1318 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
c906108c 1319 fputs_filtered (" = ", stream);
033a42c2 1320 print_variable_value (sym, frame, stream);
c906108c
SS
1321 fprintf_filtered (stream, "\n");
1322 break;
1323
1324 default:
1325 /* Ignore symbols which are not locals. */
1326 break;
1327 }
1328 }
033a42c2 1329
c906108c
SS
1330 return values_printed;
1331}
1332
1333/* Same, but print labels. */
1334
1335static int
fba45db2 1336print_block_frame_labels (struct block *b, int *have_default,
aa1ee363 1337 struct ui_file *stream)
c906108c 1338{
de4f826b 1339 struct dict_iterator iter;
52f0bd74
AC
1340 struct symbol *sym;
1341 int values_printed = 0;
c906108c 1342
de4f826b 1343 ALL_BLOCK_SYMBOLS (b, iter, sym)
c906108c 1344 {
acd8056e 1345 if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "default") == 0)
c906108c
SS
1346 {
1347 if (*have_default)
1348 continue;
1349 *have_default = 1;
1350 }
1351 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1352 {
1353 struct symtab_and_line sal;
1354 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1355 values_printed = 1;
de5ad195 1356 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
c906108c
SS
1357 if (addressprint)
1358 {
1359 fprintf_filtered (stream, " ");
66bf4b3a 1360 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream);
c906108c
SS
1361 }
1362 fprintf_filtered (stream, " in file %s, line %d\n",
1363 sal.symtab->filename, sal.line);
1364 }
1365 }
033a42c2 1366
c906108c
SS
1367 return values_printed;
1368}
1369
033a42c2
MK
1370/* Print on STREAM all the local variables in frame FRAME, including
1371 all the blocks active in that frame at its current PC.
c906108c 1372
033a42c2
MK
1373 Returns 1 if the job was done, or 0 if nothing was printed because
1374 we have no info on the function running in FRAME. */
c906108c
SS
1375
1376static void
033a42c2 1377print_frame_local_vars (struct frame_info *frame, int num_tabs,
aa1ee363 1378 struct ui_file *stream)
c906108c 1379{
033a42c2 1380 struct block *block = get_frame_block (frame, 0);
52f0bd74 1381 int values_printed = 0;
c906108c
SS
1382
1383 if (block == 0)
1384 {
1385 fprintf_filtered (stream, "No symbol table info available.\n");
1386 return;
1387 }
c5aa993b 1388
033a42c2 1389 while (block)
c906108c 1390 {
033a42c2 1391 if (print_block_frame_locals (block, frame, num_tabs, stream))
c906108c 1392 values_printed = 1;
033a42c2
MK
1393 /* After handling the function's top-level block, stop. Don't
1394 continue to its superblock, the block of per-file symbols. */
c906108c
SS
1395 if (BLOCK_FUNCTION (block))
1396 break;
1397 block = BLOCK_SUPERBLOCK (block);
1398 }
1399
1400 if (!values_printed)
033a42c2 1401 fprintf_filtered (stream, _("No locals.\n"));
c906108c
SS
1402}
1403
1404/* Same, but print labels. */
1405
1406static void
033a42c2 1407print_frame_label_vars (struct frame_info *frame, int this_level_only,
aa1ee363 1408 struct ui_file *stream)
c906108c 1409{
52f0bd74 1410 struct blockvector *bl;
033a42c2 1411 struct block *block = get_frame_block (frame, 0);
52f0bd74 1412 int values_printed = 0;
c906108c
SS
1413 int index, have_default = 0;
1414 char *blocks_printed;
033a42c2 1415 CORE_ADDR pc = get_frame_pc (frame);
c906108c
SS
1416
1417 if (block == 0)
1418 {
1419 fprintf_filtered (stream, "No symbol table info available.\n");
1420 return;
1421 }
1422
1423 bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
033a42c2 1424 blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
c906108c
SS
1425 memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
1426
1427 while (block != 0)
1428 {
1429 CORE_ADDR end = BLOCK_END (block) - 4;
1430 int last_index;
1431
1432 if (bl != blockvector_for_pc (end, &index))
8a3fe4f8 1433 error (_("blockvector blotch"));
c906108c 1434 if (BLOCKVECTOR_BLOCK (bl, index) != block)
8a3fe4f8 1435 error (_("blockvector botch"));
c906108c
SS
1436 last_index = BLOCKVECTOR_NBLOCKS (bl);
1437 index += 1;
1438
1439 /* Don't print out blocks that have gone by. */
1440 while (index < last_index
1441 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
1442 index++;
1443
1444 while (index < last_index
1445 && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
1446 {
1447 if (blocks_printed[index] == 0)
1448 {
033a42c2
MK
1449 if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index),
1450 &have_default, stream))
c906108c
SS
1451 values_printed = 1;
1452 blocks_printed[index] = 1;
1453 }
1454 index++;
1455 }
1456 if (have_default)
1457 return;
1458 if (values_printed && this_level_only)
1459 return;
1460
033a42c2
MK
1461 /* After handling the function's top-level block, stop. Don't
1462 continue to its superblock, the block of per-file symbols. */
c906108c
SS
1463 if (BLOCK_FUNCTION (block))
1464 break;
1465 block = BLOCK_SUPERBLOCK (block);
1466 }
1467
1468 if (!values_printed && !this_level_only)
033a42c2 1469 fprintf_filtered (stream, _("No catches.\n"));
c906108c
SS
1470}
1471
c906108c 1472void
fba45db2 1473locals_info (char *args, int from_tty)
c906108c 1474{
033a42c2 1475 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
b04f3ab4 1476 0, gdb_stdout);
c906108c
SS
1477}
1478
1479static void
fba45db2 1480catch_info (char *ignore, int from_tty)
c906108c 1481{
c5aa993b 1482 struct symtab_and_line *sal;
c906108c 1483
c5aa993b 1484 /* Check for target support for exception handling */
c906108c
SS
1485 sal = target_enable_exception_callback (EX_EVENT_CATCH, 1);
1486 if (sal)
1487 {
033a42c2
MK
1488 /* Currently not handling this. Ideally, here we should
1489 interact with the C++ runtime system to find the list of
1490 active handlers, etc. */
1491 fprintf_filtered (gdb_stdout, _("\
1492Info catch not supported with this target/compiler combination.\n"));
c906108c
SS
1493 }
1494 else
1495 {
033a42c2
MK
1496 /* Assume g++ compiled code; old GDB 4.16 behaviour. */
1497 print_frame_label_vars (get_selected_frame (_("No frame selected.")),
b04f3ab4 1498 0, gdb_stdout);
c906108c
SS
1499 }
1500}
1501
1502static void
033a42c2 1503print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
c906108c 1504{
033a42c2 1505 struct symbol *func = get_frame_function (frame);
52f0bd74 1506 struct block *b;
de4f826b 1507 struct dict_iterator iter;
52f0bd74
AC
1508 struct symbol *sym, *sym2;
1509 int values_printed = 0;
c906108c
SS
1510
1511 if (func == 0)
1512 {
033a42c2 1513 fprintf_filtered (stream, _("No symbol table info available.\n"));
c906108c
SS
1514 return;
1515 }
1516
1517 b = SYMBOL_BLOCK_VALUE (func);
de4f826b 1518 ALL_BLOCK_SYMBOLS (b, iter, sym)
c906108c 1519 {
c906108c
SS
1520 switch (SYMBOL_CLASS (sym))
1521 {
1522 case LOC_ARG:
1523 case LOC_LOCAL_ARG:
1524 case LOC_REF_ARG:
1525 case LOC_REGPARM:
1526 case LOC_REGPARM_ADDR:
1527 case LOC_BASEREG_ARG:
4c2df51b 1528 case LOC_COMPUTED_ARG:
c906108c 1529 values_printed = 1;
de5ad195 1530 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
c906108c
SS
1531 fputs_filtered (" = ", stream);
1532
1533 /* We have to look up the symbol because arguments can have
1534 two entries (one a parameter, one a local) and the one we
1535 want is the local, which lookup_symbol will find for us.
1536 This includes gcc1 (not gcc2) on the sparc when passing a
1537 small structure and gcc2 when the argument type is float
1538 and it is passed as a double and converted to float by
1539 the prologue (in the latter case the type of the LOC_ARG
1540 symbol is double and the type of the LOC_LOCAL symbol is
1541 float). There are also LOC_ARG/LOC_REGISTER pairs which
1542 are not combined in symbol-reading. */
1543
22abf04a 1544 sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
033a42c2
MK
1545 b, VAR_DOMAIN, NULL, NULL);
1546 print_variable_value (sym2, frame, stream);
c906108c
SS
1547 fprintf_filtered (stream, "\n");
1548 break;
1549
1550 default:
1551 /* Don't worry about things which aren't arguments. */
1552 break;
1553 }
1554 }
033a42c2 1555
c906108c 1556 if (!values_printed)
033a42c2 1557 fprintf_filtered (stream, _("No arguments.\n"));
c906108c
SS
1558}
1559
1560void
fba45db2 1561args_info (char *ignore, int from_tty)
c906108c 1562{
033a42c2 1563 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
b04f3ab4 1564 gdb_stdout);
c906108c
SS
1565}
1566
1567
1568static void
fba45db2 1569args_plus_locals_info (char *ignore, int from_tty)
c906108c 1570{
c5aa993b
JM
1571 args_info (ignore, from_tty);
1572 locals_info (ignore, from_tty);
c906108c 1573}
c906108c 1574\f
c5aa993b 1575
033a42c2
MK
1576/* Select frame FRAME. Also print the stack frame and show the source
1577 if this is the tui version. */
bedfa57b 1578static void
033a42c2 1579select_and_print_frame (struct frame_info *frame)
c906108c 1580{
033a42c2
MK
1581 select_frame (frame);
1582 if (frame)
1583 print_stack_frame (frame, 1, SRC_AND_LOC);
c906108c 1584}
c906108c 1585\f
c906108c 1586/* Return the symbol-block in which the selected frame is executing.
ae767bfb
JB
1587 Can return zero under various legitimate circumstances.
1588
1589 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
1590 code address within the block returned. We use this to decide
1591 which macros are in scope. */
c906108c
SS
1592
1593struct block *
ae767bfb 1594get_selected_block (CORE_ADDR *addr_in_block)
c906108c
SS
1595{
1596 if (!target_has_stack)
1597 return 0;
1598
206415a3 1599 return get_frame_block (get_selected_frame (NULL), addr_in_block);
c906108c
SS
1600}
1601
1602/* Find a frame a certain number of levels away from FRAME.
1603 LEVEL_OFFSET_PTR points to an int containing the number of levels.
1604 Positive means go to earlier frames (up); negative, the reverse.
1605 The int that contains the number of levels is counted toward
1606 zero as the frames for those levels are found.
1607 If the top or bottom frame is reached, that frame is returned,
1608 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
1609 how much farther the original request asked to go. */
1610
1611struct frame_info *
033a42c2 1612find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
c906108c 1613{
033a42c2
MK
1614 /* Going up is simple: just call get_prev_frame enough times or
1615 until the initial frame is reached. */
c906108c
SS
1616 while (*level_offset_ptr > 0)
1617 {
033a42c2
MK
1618 struct frame_info *prev = get_prev_frame (frame);
1619 if (!prev)
c906108c
SS
1620 break;
1621 (*level_offset_ptr)--;
1622 frame = prev;
1623 }
033a42c2 1624
c906108c 1625 /* Going down is just as simple. */
033a42c2 1626 while (*level_offset_ptr < 0)
c906108c 1627 {
033a42c2
MK
1628 struct frame_info *next = get_next_frame (frame);
1629 if (!next)
1630 break;
1631 (*level_offset_ptr)++;
1632 frame = next;
c906108c 1633 }
033a42c2 1634
c906108c
SS
1635 return frame;
1636}
1637
033a42c2
MK
1638/* The "select_frame" command. With no argument this is a NOP.
1639 Select the frame at level LEVEL_EXP if it is a valid level.
1640 Otherwise, treat LEVEL_EXP as an address expression and select it.
1641
1642 See parse_frame_specification for more info on proper frame
1643 expressions. */
c906108c 1644
8b93c638 1645void
fba45db2 1646select_frame_command (char *level_exp, int from_tty)
c906108c 1647{
1c8831c5 1648 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
c906108c
SS
1649}
1650
033a42c2
MK
1651/* The "frame" command. With no argument, print the selected frame
1652 briefly. With an argument, behave like select_frame and then print
1653 the selected frame. */
c906108c 1654
033a42c2 1655static void
fba45db2 1656frame_command (char *level_exp, int from_tty)
c906108c
SS
1657{
1658 select_frame_command (level_exp, from_tty);
b04f3ab4 1659 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
c906108c
SS
1660}
1661
033a42c2 1662/* The XDB Compatibility command to print the current frame. */
c906108c 1663
7a292a7a 1664static void
fba45db2 1665current_frame_command (char *level_exp, int from_tty)
c906108c 1666{
033a42c2 1667 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
7a292a7a 1668}
c906108c 1669
033a42c2
MK
1670/* Select the frame up one or COUNT_EXP stack levels from the
1671 previously selected frame, and print it briefly. */
c906108c 1672
c906108c 1673static void
fba45db2 1674up_silently_base (char *count_exp)
c906108c 1675{
033a42c2
MK
1676 struct frame_info *frame;
1677 int count = 1;
1678
c906108c 1679 if (count_exp)
bb518678 1680 count = parse_and_eval_long (count_exp);
c5aa993b 1681
033a42c2
MK
1682 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1683 if (count != 0 && count_exp == NULL)
8a3fe4f8 1684 error (_("Initial frame selected; you cannot go up."));
033a42c2 1685 select_frame (frame);
c906108c
SS
1686}
1687
1688static void
fba45db2 1689up_silently_command (char *count_exp, int from_tty)
c906108c 1690{
c5aa993b 1691 up_silently_base (count_exp);
c906108c
SS
1692}
1693
1694static void
fba45db2 1695up_command (char *count_exp, int from_tty)
c906108c
SS
1696{
1697 up_silently_base (count_exp);
b04f3ab4 1698 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
c906108c
SS
1699}
1700
033a42c2
MK
1701/* Select the frame down one or COUNT_EXP stack levels from the previously
1702 selected frame, and print it briefly. */
c906108c 1703
c906108c 1704static void
fba45db2 1705down_silently_base (char *count_exp)
c906108c 1706{
52f0bd74 1707 struct frame_info *frame;
033a42c2 1708 int count = -1;
c906108c 1709 if (count_exp)
bb518678 1710 count = -parse_and_eval_long (count_exp);
c5aa993b 1711
033a42c2
MK
1712 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
1713 if (count != 0 && count_exp == NULL)
c906108c 1714 {
033a42c2
MK
1715 /* We only do this if COUNT_EXP is not specified. That way
1716 "down" means to really go down (and let me know if that is
1717 impossible), but "down 9999" can be used to mean go all the
1718 way down without getting an error. */
c906108c 1719
033a42c2 1720 error (_("Bottom (innermost) frame selected; you cannot go down."));
c906108c
SS
1721 }
1722
0f7d239c 1723 select_frame (frame);
c906108c
SS
1724}
1725
c906108c 1726static void
fba45db2 1727down_silently_command (char *count_exp, int from_tty)
c906108c
SS
1728{
1729 down_silently_base (count_exp);
c906108c
SS
1730}
1731
1732static void
fba45db2 1733down_command (char *count_exp, int from_tty)
c906108c
SS
1734{
1735 down_silently_base (count_exp);
b04f3ab4 1736 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
c906108c
SS
1737}
1738\f
033a42c2 1739
8b93c638 1740void
fba45db2 1741return_command (char *retval_exp, int from_tty)
c906108c
SS
1742{
1743 struct symbol *thisfun;
3d6d86c6 1744 struct value *return_value = NULL;
fc70c2a0 1745 const char *query_prefix = "";
c906108c 1746
b04f3ab4 1747 thisfun = get_frame_function (get_selected_frame ("No selected frame."));
c906108c 1748
fc70c2a0
AC
1749 /* Compute the return value. If the computation triggers an error,
1750 let it bail. If the return type can't be handled, set
1751 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
1752 message. */
c906108c
SS
1753 if (retval_exp)
1754 {
1755 struct type *return_type = NULL;
1756
fc70c2a0
AC
1757 /* Compute the return value. Should the computation fail, this
1758 call throws an error. */
c906108c
SS
1759 return_value = parse_and_eval (retval_exp);
1760
fc70c2a0
AC
1761 /* Cast return value to the return type of the function. Should
1762 the cast fail, this call throws an error. */
c906108c
SS
1763 if (thisfun != NULL)
1764 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
1765 if (return_type == NULL)
1766 return_type = builtin_type_int;
3e9a183c 1767 CHECK_TYPEDEF (return_type);
c906108c
SS
1768 return_value = value_cast (return_type, return_value);
1769
fc70c2a0
AC
1770 /* Make sure the value is fully evaluated. It may live in the
1771 stack frame we're about to pop. */
d69fe07e 1772 if (value_lazy (return_value))
c906108c 1773 value_fetch_lazy (return_value);
c906108c 1774
667e784f
AC
1775 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
1776 /* If the return-type is "void", don't try to find the
1777 return-value's location. However, do still evaluate the
1778 return expression so that, even when the expression result
1779 is discarded, side effects such as "return i++" still
033a42c2 1780 occur. */
667e784f 1781 return_value = NULL;
74055713
AC
1782 /* FIXME: cagney/2004-01-17: If the architecture implements both
1783 return_value and extract_returned_value_address, should allow
1784 "return" to work - don't set return_value to NULL. */
667e784f
AC
1785 else if (!gdbarch_return_value_p (current_gdbarch)
1786 && (TYPE_CODE (return_type) == TYPE_CODE_STRUCT
1787 || TYPE_CODE (return_type) == TYPE_CODE_UNION))
c906108c 1788 {
667e784f
AC
1789 /* NOTE: cagney/2003-10-20: Compatibility hack for legacy
1790 code. Old architectures don't expect STORE_RETURN_VALUE
1791 to be called with with a small struct that needs to be
1792 stored in registers. Don't start doing it now. */
1793 query_prefix = "\
1794A structure or union return type is not supported by this architecture.\n\
1795If you continue, the return value that you specified will be ignored.\n";
1796 return_value = NULL;
c906108c 1797 }
667e784f 1798 else if (using_struct_return (return_type, 0))
fc70c2a0 1799 {
667e784f
AC
1800 query_prefix = "\
1801The location at which to store the function's return value is unknown.\n\
1802If you continue, the return value that you specified will be ignored.\n";
1803 return_value = NULL;
fc70c2a0 1804 }
c906108c
SS
1805 }
1806
fc70c2a0
AC
1807 /* Does an interactive user really want to do this? Include
1808 information, such as how well GDB can handle the return value, in
1809 the query message. */
1810 if (from_tty)
1811 {
1812 int confirmed;
1813 if (thisfun == NULL)
e2e0b3e5 1814 confirmed = query (_("%sMake selected stack frame return now? "),
fc70c2a0
AC
1815 query_prefix);
1816 else
e2e0b3e5 1817 confirmed = query (_("%sMake %s return now? "), query_prefix,
fc70c2a0
AC
1818 SYMBOL_PRINT_NAME (thisfun));
1819 if (!confirmed)
8a3fe4f8 1820 error (_("Not confirmed"));
fc70c2a0 1821 }
c906108c 1822
fc70c2a0
AC
1823 /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
1824 frame in turn, should this code just go straight to the relevant
1825 frame and pop that? */
c906108c 1826
fc70c2a0
AC
1827 /* First discard all frames inner-to the selected frame (making the
1828 selected frame current). */
1829 {
b04f3ab4 1830 struct frame_id selected_id = get_frame_id (get_selected_frame (NULL));
fc70c2a0
AC
1831 while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ())))
1832 {
1833 if (frame_id_inner (selected_id, get_frame_id (get_current_frame ())))
1834 /* Caught in the safety net, oops! We've gone way past the
1835 selected frame. */
8a3fe4f8 1836 error (_("Problem while popping stack frames (corrupt stack?)"));
fc70c2a0
AC
1837 frame_pop (get_current_frame ());
1838 }
1839 }
c906108c 1840
fc70c2a0
AC
1841 /* Second discard the selected frame (which is now also the current
1842 frame). */
dbe9fe58 1843 frame_pop (get_current_frame ());
c906108c 1844
a1f5b845 1845 /* Store RETURN_VALUE in the just-returned register set. */
fc70c2a0
AC
1846 if (return_value != NULL)
1847 {
df407dfe 1848 struct type *return_type = value_type (return_value);
750eb019
AC
1849 gdb_assert (gdbarch_return_value (current_gdbarch, return_type,
1850 NULL, NULL, NULL)
1851 == RETURN_VALUE_REGISTER_CONVENTION);
1852 gdbarch_return_value (current_gdbarch, return_type,
1853 current_regcache, NULL /*read*/,
0fd88904 1854 value_contents (return_value) /*write*/);
fc70c2a0 1855 }
1a2aab69 1856
fc70c2a0
AC
1857 /* If we are at the end of a call dummy now, pop the dummy frame
1858 too. */
e8bcf01f
AC
1859 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
1860 frame_pop (get_current_frame ());
1a2aab69 1861
c906108c 1862 /* If interactive, print the frame that is now current. */
c906108c
SS
1863 if (from_tty)
1864 frame_command ("0", 1);
1865 else
1866 select_frame_command ("0", 0);
1867}
1868
033a42c2
MK
1869/* Sets the scope to input function name, provided that the function
1870 is within the current stack frame */
c906108c
SS
1871
1872struct function_bounds
1873{
1874 CORE_ADDR low, high;
1875};
1876
1877static void
fba45db2 1878func_command (char *arg, int from_tty)
c906108c 1879{
033a42c2 1880 struct frame_info *frame;
c906108c
SS
1881 int found = 0;
1882 struct symtabs_and_lines sals;
1883 int i;
1884 int level = 1;
033a42c2 1885 struct function_bounds *func_bounds = NULL;
c906108c 1886
033a42c2 1887 if (arg != NULL)
c906108c
SS
1888 return;
1889
033a42c2 1890 frame = parse_frame_specification ("0");
c906108c
SS
1891 sals = decode_line_spec (arg, 1);
1892 func_bounds = (struct function_bounds *) xmalloc (
1893 sizeof (struct function_bounds) * sals.nelts);
1894 for (i = 0; (i < sals.nelts && !found); i++)
1895 {
033a42c2
MK
1896 if (sals.sals[i].pc == 0
1897 || find_pc_partial_function (sals.sals[i].pc, NULL,
1898 &func_bounds[i].low,
1899 &func_bounds[i].high) == 0)
c906108c 1900 {
033a42c2 1901 func_bounds[i].low = func_bounds[i].high = 0;
c906108c
SS
1902 }
1903 }
1904
1905 do
1906 {
1907 for (i = 0; (i < sals.nelts && !found); i++)
033a42c2
MK
1908 found = (get_frame_pc (frame) >= func_bounds[i].low
1909 && get_frame_pc (frame) < func_bounds[i].high);
c906108c
SS
1910 if (!found)
1911 {
1912 level = 1;
033a42c2 1913 frame = find_relative_frame (frame, &level);
c906108c
SS
1914 }
1915 }
1916 while (!found && level == 0);
1917
1918 if (func_bounds)
b8c9b27d 1919 xfree (func_bounds);
c906108c
SS
1920
1921 if (!found)
a3f17187 1922 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
206415a3 1923 else if (frame != get_selected_frame (NULL))
033a42c2 1924 select_and_print_frame (frame);
c906108c
SS
1925}
1926
1927/* Gets the language of the current frame. */
1928
1929enum language
fba45db2 1930get_frame_language (void)
c906108c 1931{
206415a3 1932 struct frame_info *frame = deprecated_safe_get_selected_frame ();
c5aa993b 1933
033a42c2 1934 if (frame)
c906108c 1935 {
7ae4c3a5 1936 /* We determine the current frame language by looking up its
033a42c2
MK
1937 associated symtab. To retrieve this symtab, we use the frame
1938 PC. However we cannot use the frame PC as is, because it
1939 usually points to the instruction following the "call", which
1940 is sometimes the first instruction of another function. So
1941 we rely on get_frame_address_in_block(), it provides us with
1942 a PC that is guaranteed to be inside the frame's code
1943 block. */
1944 CORE_ADDR pc = get_frame_address_in_block (frame);
1945 struct symtab *s = find_pc_symtab (pc);
1946
c906108c 1947 if (s)
033a42c2 1948 return s->language;
c906108c 1949 }
c906108c 1950
033a42c2 1951 return language_unknown;
c906108c
SS
1952}
1953\f
033a42c2
MK
1954
1955/* Provide a prototype to silence -Wmissing-prototypes. */
1956void _initialize_stack (void);
1957
c906108c 1958void
fba45db2 1959_initialize_stack (void)
c906108c 1960{
c5aa993b 1961#if 0
c906108c
SS
1962 backtrace_limit = 30;
1963#endif
1964
1bedd215
AC
1965 add_com ("return", class_stack, return_command, _("\
1966Make selected stack frame return to its caller.\n\
c906108c
SS
1967Control remains in the debugger, but when you continue\n\
1968execution will resume in the frame above the one now selected.\n\
1bedd215
AC
1969If an argument is given, it is an expression for the value to return."));
1970
1971 add_com ("up", class_stack, up_command, _("\
1972Select and print stack frame that called this one.\n\
1973An argument says how many frames up to go."));
1974 add_com ("up-silently", class_support, up_silently_command, _("\
1975Same as the `up' command, but does not print anything.\n\
1976This is useful in command scripts."));
1977
1978 add_com ("down", class_stack, down_command, _("\
1979Select and print stack frame called by this one.\n\
1980An argument says how many frames down to go."));
c906108c
SS
1981 add_com_alias ("do", "down", class_stack, 1);
1982 add_com_alias ("dow", "down", class_stack, 1);
1bedd215
AC
1983 add_com ("down-silently", class_support, down_silently_command, _("\
1984Same as the `down' command, but does not print anything.\n\
1985This is useful in command scripts."));
c906108c 1986
1bedd215
AC
1987 add_com ("frame", class_stack, frame_command, _("\
1988Select and print a stack frame.\n\
c906108c
SS
1989With no argument, print the selected stack frame. (See also \"info frame\").\n\
1990An argument specifies the frame to select.\n\
1991It can be a stack frame number or the address of the frame.\n\
1992With argument, nothing is printed if input is coming from\n\
1bedd215 1993a command file or a user-defined command."));
c906108c
SS
1994
1995 add_com_alias ("f", "frame", class_stack, 1);
1996
1997 if (xdb_commands)
1998 {
c5aa993b 1999 add_com ("L", class_stack, current_frame_command,
1bedd215 2000 _("Print the current stack frame.\n"));
c906108c
SS
2001 add_com_alias ("V", "frame", class_stack, 1);
2002 }
1bedd215
AC
2003 add_com ("select-frame", class_stack, select_frame_command, _("\
2004Select a stack frame without printing anything.\n\
c906108c 2005An argument specifies the frame to select.\n\
1bedd215 2006It can be a stack frame number or the address of the frame.\n"));
c906108c 2007
1bedd215
AC
2008 add_com ("backtrace", class_stack, backtrace_command, _("\
2009Print backtrace of all stack frames, or innermost COUNT frames.\n\
c906108c 2010With a negative argument, print outermost -COUNT frames.\n\
1bedd215 2011Use of the 'full' qualifier also prints the values of the local variables.\n"));
c906108c
SS
2012 add_com_alias ("bt", "backtrace", class_stack, 0);
2013 if (xdb_commands)
2014 {
2015 add_com_alias ("t", "backtrace", class_stack, 0);
1bedd215
AC
2016 add_com ("T", class_stack, backtrace_full_command, _("\
2017Print backtrace of all stack frames, or innermost COUNT frames \n\
c906108c
SS
2018and the values of the local variables.\n\
2019With a negative argument, print outermost -COUNT frames.\n\
1bedd215 2020Usage: T <count>\n"));
c906108c
SS
2021 }
2022
2023 add_com_alias ("where", "backtrace", class_alias, 0);
2024 add_info ("stack", backtrace_command,
1bedd215 2025 _("Backtrace of the stack, or innermost COUNT frames."));
c906108c
SS
2026 add_info_alias ("s", "stack", 1);
2027 add_info ("frame", frame_info,
1bedd215 2028 _("All about selected stack frame, or frame at ADDR."));
c906108c
SS
2029 add_info_alias ("f", "frame", 1);
2030 add_info ("locals", locals_info,
1bedd215 2031 _("Local variables of current stack frame."));
c906108c 2032 add_info ("args", args_info,
1bedd215 2033 _("Argument variables of current stack frame."));
c906108c 2034 if (xdb_commands)
c5aa993b 2035 add_com ("l", class_info, args_plus_locals_info,
1bedd215 2036 _("Argument and local variables of current stack frame."));
c906108c
SS
2037
2038 if (dbx_commands)
1bedd215
AC
2039 add_com ("func", class_stack, func_command, _("\
2040Select the stack frame that contains <func>.\n\
2041Usage: func <name>\n"));
c906108c
SS
2042
2043 add_info ("catch", catch_info,
1bedd215 2044 _("Exceptions that can be caught in the current stack frame."));
c906108c
SS
2045
2046#if 0
1a966eab
AC
2047 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
2048"Specify maximum number of frames for \"backtrace\" to print by default."),
c906108c 2049 &setlist);
1bedd215
AC
2050 add_info ("backtrace-limit", backtrace_limit_info, _("\
2051The maximum number of frames for \"backtrace\" to print by default."));
c906108c
SS
2052#endif
2053}
This page took 0.82993 seconds and 4 git commands to generate.