Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / stack.c
CommitLineData
5796c8dc
SS
1/* Print and select stack frames for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "value.h"
22#include "symtab.h"
23#include "gdbtypes.h"
24#include "expression.h"
25#include "language.h"
26#include "frame.h"
27#include "gdbcmd.h"
28#include "gdbcore.h"
29#include "target.h"
30#include "source.h"
31#include "breakpoint.h"
32#include "demangle.h"
33#include "inferior.h"
34#include "annotate.h"
35#include "ui-out.h"
36#include "block.h"
37#include "stack.h"
38#include "dictionary.h"
39#include "exceptions.h"
40#include "reggroups.h"
41#include "regcache.h"
42#include "solib.h"
43#include "valprint.h"
44#include "gdbthread.h"
45#include "cp-support.h"
46#include "disasm.h"
47#include "inline-frame.h"
a45ae5f8 48#include "linespec.h"
ef5ccd6c 49#include "cli/cli-utils.h"
5796c8dc
SS
50
51#include "gdb_assert.h"
52#include <ctype.h>
53#include "gdb_string.h"
54
cf7f2e2d
JM
55#include "psymtab.h"
56#include "symfile.h"
57
5796c8dc
SS
58void (*deprecated_selected_frame_level_changed_hook) (int);
59
a45ae5f8 60/* The possible choices of "set print frame-arguments", and the value
5796c8dc
SS
61 of this setting. */
62
ef5ccd6c 63static const char *const print_frame_arguments_choices[] =
5796c8dc
SS
64 {"all", "scalars", "none", NULL};
65static const char *print_frame_arguments = "scalars";
66
a45ae5f8
JM
67/* The possible choices of "set print entry-values", and the value
68 of this setting. */
69
70const char print_entry_values_no[] = "no";
71const char print_entry_values_only[] = "only";
72const char print_entry_values_preferred[] = "preferred";
73const char print_entry_values_if_needed[] = "if-needed";
74const char print_entry_values_both[] = "both";
75const char print_entry_values_compact[] = "compact";
76const char print_entry_values_default[] = "default";
ef5ccd6c 77static const char *const print_entry_values_choices[] =
a45ae5f8
JM
78{
79 print_entry_values_no,
80 print_entry_values_only,
81 print_entry_values_preferred,
82 print_entry_values_if_needed,
83 print_entry_values_both,
84 print_entry_values_compact,
85 print_entry_values_default,
86 NULL
87};
88const char *print_entry_values = print_entry_values_default;
89
c50c785c 90/* Prototypes for local functions. */
5796c8dc
SS
91
92static void print_frame_local_vars (struct frame_info *, int,
93 struct ui_file *);
94
95static void print_frame (struct frame_info *frame, int print_level,
96 enum print_what print_what, int print_args,
97 struct symtab_and_line sal);
98
a45ae5f8
JM
99static void set_last_displayed_sal (int valid,
100 struct program_space *pspace,
101 CORE_ADDR addr,
102 struct symtab *symtab,
103 int line);
104
5796c8dc
SS
105/* Zero means do things normally; we are interacting directly with the
106 user. One means print the full filename and linenumber when a
107 frame is printed, and do so in a format emacs18/emacs19.22 can
108 parse. Two means print similar annotations, but in many more
109 cases and in a slightly different syntax. */
110
111int annotation_level = 0;
5796c8dc 112
a45ae5f8
JM
113/* These variables hold the last symtab and line we displayed to the user.
114 * This is where we insert a breakpoint or a skiplist entry by default. */
115static int last_displayed_sal_valid = 0;
116static struct program_space *last_displayed_pspace = 0;
117static CORE_ADDR last_displayed_addr = 0;
118static struct symtab *last_displayed_symtab = 0;
119static int last_displayed_line = 0;
120\f
5796c8dc
SS
121
122/* Return 1 if we should display the address in addition to the location,
123 because we are in the middle of a statement. */
124
125static int
126frame_show_address (struct frame_info *frame,
127 struct symtab_and_line sal)
128{
129 /* If there is a line number, but no PC, then there is no location
130 information associated with this sal. The only way that should
131 happen is for the call sites of inlined functions (SAL comes from
132 find_frame_sal). Otherwise, we would have some PC range if the
133 SAL came from a line table. */
134 if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
135 {
136 if (get_next_frame (frame) == NULL)
137 gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
138 else
139 gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
140 return 0;
141 }
142
143 return get_frame_pc (frame) != sal.pc;
144}
145
146/* Show or print a stack frame FRAME briefly. The output is format
147 according to PRINT_LEVEL and PRINT_WHAT printing the frame's
148 relative level, function name, argument list, and file name and
149 line number. If the frame's PC is not at the beginning of the
150 source line, the actual PC is printed at the beginning. */
151
152void
153print_stack_frame (struct frame_info *frame, int print_level,
154 enum print_what print_what)
155{
a45ae5f8 156 volatile struct gdb_exception e;
5796c8dc 157
5796c8dc 158 /* For mi, alway print location and address. */
a45ae5f8
JM
159 if (ui_out_is_mi_like_p (current_uiout))
160 print_what = LOC_AND_ADDRESS;
5796c8dc 161
a45ae5f8
JM
162 TRY_CATCH (e, RETURN_MASK_ERROR)
163 {
164 int center = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
5796c8dc 165
a45ae5f8
JM
166 print_frame_info (frame, print_level, print_what, 1 /* print_args */);
167 set_current_sal_from_frame (frame, center);
168 }
169}
5796c8dc
SS
170
171/* Print nameless arguments of frame FRAME on STREAM, where START is
172 the offset of the first nameless argument, and NUM is the number of
173 nameless arguments to print. FIRST is nonzero if this is the first
174 argument (not just the first nameless argument). */
175
176static void
177print_frame_nameless_args (struct frame_info *frame, long start, int num,
178 int first, struct ui_file *stream)
179{
180 struct gdbarch *gdbarch = get_frame_arch (frame);
181 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
182 int i;
183 CORE_ADDR argsaddr;
184 long arg_value;
185
186 for (i = 0; i < num; i++)
187 {
188 QUIT;
189 argsaddr = get_frame_args_address (frame);
190 if (!argsaddr)
191 return;
192 arg_value = read_memory_integer (argsaddr + start,
193 sizeof (int), byte_order);
194 if (!first)
195 fprintf_filtered (stream, ", ");
196 fprintf_filtered (stream, "%ld", arg_value);
197 first = 0;
198 start += sizeof (int);
199 }
200}
201
a45ae5f8
JM
202/* Print single argument of inferior function. ARG must be already
203 read in.
204
205 Errors are printed as if they would be the parameter value. Use zeroed ARG
206 iff it should not be printed accoring to user settings. */
207
208static void
209print_frame_arg (const struct frame_arg *arg)
210{
211 struct ui_out *uiout = current_uiout;
212 volatile struct gdb_exception except;
213 struct cleanup *old_chain;
ef5ccd6c 214 struct ui_file *stb;
a45ae5f8 215
ef5ccd6c
JM
216 stb = mem_fileopen ();
217 old_chain = make_cleanup_ui_file_delete (stb);
a45ae5f8
JM
218
219 gdb_assert (!arg->val || !arg->error);
220 gdb_assert (arg->entry_kind == print_entry_values_no
221 || arg->entry_kind == print_entry_values_only
222 || (!ui_out_is_mi_like_p (uiout)
223 && arg->entry_kind == print_entry_values_compact));
224
225 annotate_arg_begin ();
226
227 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ef5ccd6c 228 fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
a45ae5f8
JM
229 SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
230 if (arg->entry_kind == print_entry_values_compact)
231 {
232 /* It is OK to provide invalid MI-like stream as with
233 PRINT_ENTRY_VALUE_COMPACT we never use MI. */
ef5ccd6c 234 fputs_filtered ("=", stb);
a45ae5f8 235
ef5ccd6c 236 fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
a45ae5f8
JM
237 SYMBOL_LANGUAGE (arg->sym),
238 DMGL_PARAMS | DMGL_ANSI);
239 }
240 if (arg->entry_kind == print_entry_values_only
241 || arg->entry_kind == print_entry_values_compact)
ef5ccd6c 242 fputs_filtered ("@entry", stb);
a45ae5f8
JM
243 ui_out_field_stream (uiout, "name", stb);
244 annotate_arg_name_end ();
245 ui_out_text (uiout, "=");
246
247 if (!arg->val && !arg->error)
248 ui_out_text (uiout, "...");
249 else
250 {
251 if (arg->error)
252 except.message = arg->error;
253 else
254 {
255 /* TRY_CATCH has two statements, wrap it in a block. */
256
257 TRY_CATCH (except, RETURN_MASK_ERROR)
258 {
259 const struct language_defn *language;
260 struct value_print_options opts;
261
262 /* Avoid value_print because it will deref ref parameters. We
263 just want to print their addresses. Print ??? for args whose
264 address we do not know. We pass 2 as "recurse" to val_print
265 because our standard indentation here is 4 spaces, and
266 val_print indents 2 for each recurse. */
267
268 annotate_arg_value (value_type (arg->val));
269
270 /* Use the appropriate language to display our symbol, unless the
271 user forced the language to a specific language. */
272 if (language_mode == language_mode_auto)
273 language = language_def (SYMBOL_LANGUAGE (arg->sym));
274 else
275 language = current_language;
276
277 get_raw_print_options (&opts);
278 opts.deref_ref = 1;
279
280 /* True in "summary" mode, false otherwise. */
281 opts.summary = !strcmp (print_frame_arguments, "scalars");
282
ef5ccd6c 283 common_val_print (arg->val, stb, 2, &opts, language);
a45ae5f8
JM
284 }
285 }
286 if (except.message)
ef5ccd6c 287 fprintf_filtered (stb, _("<error reading variable: %s>"),
a45ae5f8
JM
288 except.message);
289 }
290
291 ui_out_field_stream (uiout, "value", stb);
292
ef5ccd6c 293 /* Also invoke ui_out_tuple_end. */
a45ae5f8
JM
294 do_cleanups (old_chain);
295
296 annotate_arg_end ();
297}
298
ef5ccd6c
JM
299/* Read in inferior function local SYM at FRAME into ARGP. Caller is
300 responsible for xfree of ARGP->ERROR. This function never throws an
301 exception. */
302
303void
304read_frame_local (struct symbol *sym, struct frame_info *frame,
305 struct frame_arg *argp)
306{
307 volatile struct gdb_exception except;
308 struct value *val = NULL;
309
310 TRY_CATCH (except, RETURN_MASK_ERROR)
311 {
312 val = read_var_value (sym, frame);
313 }
314
315 argp->error = (val == NULL) ? xstrdup (except.message) : NULL;
316 argp->sym = sym;
317 argp->val = val;
318}
319
a45ae5f8
JM
320/* Read in inferior function parameter SYM at FRAME into ARGP. Caller is
321 responsible for xfree of ARGP->ERROR. This function never throws an
322 exception. */
323
324void
325read_frame_arg (struct symbol *sym, struct frame_info *frame,
326 struct frame_arg *argp, struct frame_arg *entryargp)
327{
328 struct value *val = NULL, *entryval = NULL;
329 char *val_error = NULL, *entryval_error = NULL;
330 int val_equal = 0;
331 volatile struct gdb_exception except;
332
333 if (print_entry_values != print_entry_values_only
334 && print_entry_values != print_entry_values_preferred)
335 {
336 TRY_CATCH (except, RETURN_MASK_ERROR)
337 {
338 val = read_var_value (sym, frame);
339 }
340 if (!val)
341 {
342 val_error = alloca (strlen (except.message) + 1);
343 strcpy (val_error, except.message);
344 }
345 }
346
347 if (SYMBOL_CLASS (sym) == LOC_COMPUTED
348 && print_entry_values != print_entry_values_no
349 && (print_entry_values != print_entry_values_if_needed
350 || !val || value_optimized_out (val)))
351 {
352 TRY_CATCH (except, RETURN_MASK_ERROR)
353 {
354 const struct symbol_computed_ops *ops;
355
356 ops = SYMBOL_COMPUTED_OPS (sym);
357 entryval = ops->read_variable_at_entry (sym, frame);
358 }
359 if (!entryval)
360 {
361 entryval_error = alloca (strlen (except.message) + 1);
362 strcpy (entryval_error, except.message);
363 }
364
365 if (except.error == NO_ENTRY_VALUE_ERROR
366 || (entryval && value_optimized_out (entryval)))
367 {
368 entryval = NULL;
369 entryval_error = NULL;
370 }
371
372 if (print_entry_values == print_entry_values_compact
373 || print_entry_values == print_entry_values_default)
374 {
375 /* For MI do not try to use print_entry_values_compact for ARGP. */
376
377 if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
378 {
ef5ccd6c 379 struct type *type = value_type (val);
a45ae5f8
JM
380
381 if (!value_optimized_out (val) && value_lazy (val))
382 value_fetch_lazy (val);
383 if (!value_optimized_out (val) && value_lazy (entryval))
384 value_fetch_lazy (entryval);
385 if (!value_optimized_out (val)
ef5ccd6c
JM
386 && value_available_contents_eq (val, 0, entryval, 0,
387 TYPE_LENGTH (type)))
a45ae5f8
JM
388 {
389 /* Initialize it just to avoid a GCC false warning. */
390 struct value *val_deref = NULL, *entryval_deref;
391
392 /* DW_AT_GNU_call_site_value does match with the current
393 value. If it is a reference still try to verify if
394 dereferenced DW_AT_GNU_call_site_data_value does not
395 differ. */
396
397 TRY_CATCH (except, RETURN_MASK_ERROR)
398 {
ef5ccd6c 399 struct type *type_deref;
a45ae5f8
JM
400
401 val_deref = coerce_ref (val);
402 if (value_lazy (val_deref))
403 value_fetch_lazy (val_deref);
ef5ccd6c 404 type_deref = value_type (val_deref);
a45ae5f8
JM
405
406 entryval_deref = coerce_ref (entryval);
407 if (value_lazy (entryval_deref))
408 value_fetch_lazy (entryval_deref);
409
410 /* If the reference addresses match but dereferenced
411 content does not match print them. */
412 if (val != val_deref
413 && value_available_contents_eq (val_deref, 0,
414 entryval_deref, 0,
ef5ccd6c 415 TYPE_LENGTH (type_deref)))
a45ae5f8
JM
416 val_equal = 1;
417 }
418
419 /* Value was not a reference; and its content matches. */
420 if (val == val_deref)
421 val_equal = 1;
422 /* If the dereferenced content could not be fetched do not
423 display anything. */
424 else if (except.error == NO_ENTRY_VALUE_ERROR)
425 val_equal = 1;
426 else if (except.message)
427 {
428 entryval_error = alloca (strlen (except.message) + 1);
429 strcpy (entryval_error, except.message);
430 }
431
432 if (val_equal)
433 entryval = NULL;
434 }
435 }
436
437 /* Try to remove possibly duplicate error message for ENTRYARGP even
438 in MI mode. */
439
440 if (val_error && entryval_error
441 && strcmp (val_error, entryval_error) == 0)
442 {
443 entryval_error = NULL;
444
445 /* Do not se VAL_EQUAL as the same error message may be shown for
446 the entry value even if no entry values are present in the
447 inferior. */
448 }
449 }
450 }
451
452 if (entryval == NULL)
453 {
454 if (print_entry_values == print_entry_values_preferred)
455 {
456 TRY_CATCH (except, RETURN_MASK_ERROR)
457 {
458 val = read_var_value (sym, frame);
459 }
460 if (!val)
461 {
462 val_error = alloca (strlen (except.message) + 1);
463 strcpy (val_error, except.message);
464 }
465 }
466 if (print_entry_values == print_entry_values_only
467 || print_entry_values == print_entry_values_both
468 || (print_entry_values == print_entry_values_preferred
469 && (!val || value_optimized_out (val))))
470 entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
471 }
472 if ((print_entry_values == print_entry_values_compact
473 || print_entry_values == print_entry_values_if_needed
474 || print_entry_values == print_entry_values_preferred)
475 && (!val || value_optimized_out (val)) && entryval != NULL)
476 {
477 val = NULL;
478 val_error = NULL;
479 }
480
481 argp->sym = sym;
482 argp->val = val;
483 argp->error = val_error ? xstrdup (val_error) : NULL;
484 if (!val && !val_error)
485 argp->entry_kind = print_entry_values_only;
486 else if ((print_entry_values == print_entry_values_compact
487 || print_entry_values == print_entry_values_default) && val_equal)
488 {
489 argp->entry_kind = print_entry_values_compact;
490 gdb_assert (!ui_out_is_mi_like_p (current_uiout));
491 }
492 else
493 argp->entry_kind = print_entry_values_no;
494
495 entryargp->sym = sym;
496 entryargp->val = entryval;
497 entryargp->error = entryval_error ? xstrdup (entryval_error) : NULL;
498 if (!entryval && !entryval_error)
499 entryargp->entry_kind = print_entry_values_no;
500 else
501 entryargp->entry_kind = print_entry_values_only;
502}
503
5796c8dc
SS
504/* Print the arguments of frame FRAME on STREAM, given the function
505 FUNC running in that frame (as a symbol), where NUM is the number
506 of arguments according to the stack frame (or -1 if the number of
507 arguments is unknown). */
508
509/* Note that currently the "number of arguments according to the
510 stack frame" is only known on VAX where i refers to the "number of
511 ints of arguments according to the stack frame". */
512
513static void
514print_frame_args (struct symbol *func, struct frame_info *frame,
515 int num, struct ui_file *stream)
516{
a45ae5f8 517 struct ui_out *uiout = current_uiout;
5796c8dc
SS
518 int first = 1;
519 /* Offset of next stack argument beyond the one we have seen that is
520 at the highest offset, or -1 if we haven't come to a stack
521 argument yet. */
522 long highest_offset = -1;
523 /* Number of ints of arguments that we have printed so far. */
524 int args_printed = 0;
ef5ccd6c
JM
525 struct cleanup *old_chain;
526 struct ui_file *stb;
5796c8dc
SS
527 /* True if we should print arguments, false otherwise. */
528 int print_args = strcmp (print_frame_arguments, "none");
5796c8dc 529
ef5ccd6c
JM
530 stb = mem_fileopen ();
531 old_chain = make_cleanup_ui_file_delete (stb);
5796c8dc
SS
532
533 if (func)
534 {
535 struct block *b = SYMBOL_BLOCK_VALUE (func);
ef5ccd6c 536 struct block_iterator iter;
5796c8dc 537 struct symbol *sym;
5796c8dc
SS
538
539 ALL_BLOCK_SYMBOLS (b, iter, sym)
540 {
a45ae5f8
JM
541 struct frame_arg arg, entryarg;
542
5796c8dc
SS
543 QUIT;
544
545 /* Keep track of the highest stack argument offset seen, and
546 skip over any kinds of symbols we don't care about. */
547
548 if (!SYMBOL_IS_ARGUMENT (sym))
549 continue;
550
551 switch (SYMBOL_CLASS (sym))
552 {
553 case LOC_ARG:
554 case LOC_REF_ARG:
555 {
556 long current_offset = SYMBOL_VALUE (sym);
557 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
558
559 /* Compute address of next argument by adding the size of
560 this argument and rounding to an int boundary. */
561 current_offset =
562 ((current_offset + arg_size + sizeof (int) - 1)
563 & ~(sizeof (int) - 1));
564
565 /* If this is the highest offset seen yet, set
566 highest_offset. */
567 if (highest_offset == -1
568 || (current_offset > highest_offset))
569 highest_offset = current_offset;
570
571 /* Add the number of ints we're about to print to
572 args_printed. */
573 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
574 }
575
576 /* We care about types of symbols, but don't need to
577 keep track of stack offsets in them. */
578 case LOC_REGISTER:
579 case LOC_REGPARM_ADDR:
580 case LOC_COMPUTED:
581 case LOC_OPTIMIZED_OUT:
582 default:
583 break;
584 }
585
586 /* We have to look up the symbol because arguments can have
587 two entries (one a parameter, one a local) and the one we
588 want is the local, which lookup_symbol will find for us.
589 This includes gcc1 (not gcc2) on SPARC when passing a
590 small structure and gcc2 when the argument type is float
591 and it is passed as a double and converted to float by
592 the prologue (in the latter case the type of the LOC_ARG
593 symbol is double and the type of the LOC_LOCAL symbol is
594 float). */
595 /* But if the parameter name is null, don't try it. Null
596 parameter names occur on the RS/6000, for traceback
597 tables. FIXME, should we even print them? */
598
599 if (*SYMBOL_LINKAGE_NAME (sym))
600 {
601 struct symbol *nsym;
cf7f2e2d 602
5796c8dc
SS
603 nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
604 b, VAR_DOMAIN, NULL);
605 gdb_assert (nsym != NULL);
606 if (SYMBOL_CLASS (nsym) == LOC_REGISTER
607 && !SYMBOL_IS_ARGUMENT (nsym))
608 {
609 /* There is a LOC_ARG/LOC_REGISTER pair. This means
610 that it was passed on the stack and loaded into a
611 register, or passed in a register and stored in a
612 stack slot. GDB 3.x used the LOC_ARG; GDB
613 4.0-4.11 used the LOC_REGISTER.
614
615 Reasons for using the LOC_ARG:
616
617 (1) Because find_saved_registers may be slow for
618 remote debugging.
619
620 (2) Because registers are often re-used and stack
621 slots rarely (never?) are. Therefore using
622 the stack slot is much less likely to print
623 garbage.
624
625 Reasons why we might want to use the LOC_REGISTER:
626
627 (1) So that the backtrace prints the same value
628 as "print foo". I see no compelling reason
629 why this needs to be the case; having the
630 backtrace print the value which was passed
631 in, and "print foo" print the value as
632 modified within the called function, makes
633 perfect sense to me.
634
635 Additional note: It might be nice if "info args"
636 displayed both values.
637
638 One more note: There is a case with SPARC
639 structure passing where we need to use the
640 LOC_REGISTER, but this is dealt with by creating
641 a single LOC_REGPARM in symbol reading. */
642
643 /* Leave sym (the LOC_ARG) alone. */
644 ;
645 }
646 else
647 sym = nsym;
648 }
649
650 /* Print the current arg. */
651 if (!first)
652 ui_out_text (uiout, ", ");
653 ui_out_wrap_hint (uiout, " ");
654
a45ae5f8
JM
655 if (!print_args)
656 {
657 memset (&arg, 0, sizeof (arg));
658 arg.sym = sym;
659 arg.entry_kind = print_entry_values_no;
660 memset (&entryarg, 0, sizeof (entryarg));
661 entryarg.sym = sym;
662 entryarg.entry_kind = print_entry_values_no;
663 }
664 else
665 read_frame_arg (sym, frame, &arg, &entryarg);
5796c8dc 666
a45ae5f8
JM
667 if (arg.entry_kind != print_entry_values_only)
668 print_frame_arg (&arg);
5796c8dc 669
a45ae5f8
JM
670 if (entryarg.entry_kind != print_entry_values_no)
671 {
672 if (arg.entry_kind != print_entry_values_only)
673 {
674 ui_out_text (uiout, ", ");
675 ui_out_wrap_hint (uiout, " ");
676 }
5796c8dc 677
a45ae5f8
JM
678 print_frame_arg (&entryarg);
679 }
5796c8dc 680
a45ae5f8
JM
681 xfree (arg.error);
682 xfree (entryarg.error);
5796c8dc
SS
683
684 first = 0;
685 }
686 }
687
688 /* Don't print nameless args in situations where we don't know
689 enough about the stack to find them. */
690 if (num != -1)
691 {
692 long start;
693
694 if (highest_offset == -1)
695 start = gdbarch_frame_args_skip (get_frame_arch (frame));
696 else
697 start = highest_offset;
698
699 print_frame_nameless_args (frame, start, num - args_printed,
700 first, stream);
701 }
702
703 do_cleanups (old_chain);
704}
705
5796c8dc
SS
706/* Set the current source and line to the location given by frame
707 FRAME, if possible. When CENTER is true, adjust so the relevant
708 line is in the center of the next 'list'. */
709
710void
711set_current_sal_from_frame (struct frame_info *frame, int center)
712{
713 struct symtab_and_line sal;
714
715 find_frame_sal (frame, &sal);
716 if (sal.symtab)
717 {
718 if (center)
719 sal.line = max (sal.line - get_lines_to_list () / 2, 1);
720 set_current_source_symtab_and_line (&sal);
721 }
722}
723
724/* If ON, GDB will display disassembly of the next source line when
725 execution of the program being debugged stops.
726 If AUTO (which is the default), or there's no line info to determine
727 the source line of the next instruction, display disassembly of next
728 instruction instead. */
729
730static enum auto_boolean disassemble_next_line;
731
732static void
733show_disassemble_next_line (struct ui_file *file, int from_tty,
734 struct cmd_list_element *c,
735 const char *value)
736{
c50c785c
JM
737 fprintf_filtered (file,
738 _("Debugger's willingness to use "
739 "disassemble-next-line is %s.\n"),
5796c8dc
SS
740 value);
741}
742
5796c8dc
SS
743/* Use TRY_CATCH to catch the exception from the gdb_disassembly
744 because it will be broken by filter sometime. */
745
746static void
747do_gdb_disassembly (struct gdbarch *gdbarch,
748 int how_many, CORE_ADDR low, CORE_ADDR high)
749{
750 volatile struct gdb_exception exception;
5796c8dc 751
a45ae5f8 752 TRY_CATCH (exception, RETURN_MASK_ERROR)
5796c8dc 753 {
a45ae5f8
JM
754 gdb_disassembly (gdbarch, current_uiout, 0,
755 DISASSEMBLY_RAW_INSN, how_many,
756 low, high);
757 }
758 if (exception.reason < 0)
759 {
760 /* If an exception was thrown while doing the disassembly, print
761 the error message, to give the user a clue of what happened. */
762 exception_print (gdb_stderr, exception);
5796c8dc 763 }
5796c8dc
SS
764}
765
766/* Print information about frame FRAME. The output is format according
a45ae5f8 767 to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS. The meaning of
5796c8dc
SS
768 PRINT_WHAT is:
769
770 SRC_LINE: Print only source line.
771 LOCATION: Print only location.
772 LOC_AND_SRC: Print location and source line.
773
774 Used in "where" output, and to emit breakpoint or step
775 messages. */
776
777void
778print_frame_info (struct frame_info *frame, int print_level,
779 enum print_what print_what, int print_args)
780{
781 struct gdbarch *gdbarch = get_frame_arch (frame);
782 struct symtab_and_line sal;
783 int source_print;
784 int location_print;
a45ae5f8 785 struct ui_out *uiout = current_uiout;
5796c8dc
SS
786
787 if (get_frame_type (frame) == DUMMY_FRAME
788 || get_frame_type (frame) == SIGTRAMP_FRAME
789 || get_frame_type (frame) == ARCH_FRAME)
790 {
791 struct cleanup *uiout_cleanup
792 = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
793
794 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
795 gdbarch, get_frame_pc (frame));
796
797 /* Do this regardless of SOURCE because we don't have any source
798 to list for this frame. */
799 if (print_level)
800 {
801 ui_out_text (uiout, "#");
802 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
803 frame_relative_level (frame));
804 }
805 if (ui_out_is_mi_like_p (uiout))
806 {
807 annotate_frame_address ();
808 ui_out_field_core_addr (uiout, "addr",
809 gdbarch, get_frame_pc (frame));
810 annotate_frame_address_end ();
811 }
812
813 if (get_frame_type (frame) == DUMMY_FRAME)
814 {
815 annotate_function_call ();
816 ui_out_field_string (uiout, "func", "<function called from gdb>");
817 }
818 else if (get_frame_type (frame) == SIGTRAMP_FRAME)
819 {
820 annotate_signal_handler_caller ();
821 ui_out_field_string (uiout, "func", "<signal handler called>");
822 }
823 else if (get_frame_type (frame) == ARCH_FRAME)
824 {
825 ui_out_field_string (uiout, "func", "<cross-architecture call>");
826 }
827 ui_out_text (uiout, "\n");
828 annotate_frame_end ();
829
830 do_cleanups (uiout_cleanup);
831 return;
832 }
833
834 /* If FRAME is not the innermost frame, that normally means that
835 FRAME->pc points to *after* the call instruction, and we want to
836 get the line containing the call, never the next line. But if
837 the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
838 next frame was not entered as the result of a call, and we want
839 to get the line containing FRAME->pc. */
840 find_frame_sal (frame, &sal);
841
842 location_print = (print_what == LOCATION
843 || print_what == LOC_AND_ADDRESS
844 || print_what == SRC_AND_LOC);
845
846 if (location_print || !sal.symtab)
847 print_frame (frame, print_level, print_what, print_args, sal);
848
849 source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
850
851 /* If disassemble-next-line is set to auto or on and doesn't have
852 the line debug messages for $pc, output the next instruction. */
853 if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
854 || disassemble_next_line == AUTO_BOOLEAN_TRUE)
855 && source_print && !sal.symtab)
856 do_gdb_disassembly (get_frame_arch (frame), 1,
857 get_frame_pc (frame), get_frame_pc (frame) + 1);
858
859 if (source_print && sal.symtab)
860 {
861 int done = 0;
862 int mid_statement = ((print_what == SRC_LINE)
863 && frame_show_address (frame, sal));
864
865 if (annotation_level)
866 done = identify_source_line (sal.symtab, sal.line, mid_statement,
867 get_frame_pc (frame));
868 if (!done)
869 {
870 if (deprecated_print_frame_info_listing_hook)
871 deprecated_print_frame_info_listing_hook (sal.symtab,
872 sal.line,
873 sal.line + 1, 0);
874 else
875 {
876 struct value_print_options opts;
cf7f2e2d 877
5796c8dc
SS
878 get_user_print_options (&opts);
879 /* We used to do this earlier, but that is clearly
c50c785c 880 wrong. This function is used by many different
5796c8dc
SS
881 parts of gdb, including normal_stop in infrun.c,
882 which uses this to print out the current PC
883 when we stepi/nexti into the middle of a source
c50c785c
JM
884 line. Only the command line really wants this
885 behavior. Other UIs probably would like the
5796c8dc
SS
886 ability to decide for themselves if it is desired. */
887 if (opts.addressprint && mid_statement)
888 {
889 ui_out_field_core_addr (uiout, "addr",
890 gdbarch, get_frame_pc (frame));
891 ui_out_text (uiout, "\t");
892 }
893
894 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
895 }
896 }
897
898 /* If disassemble-next-line is set to on and there is line debug
899 messages, output assembly codes for next line. */
900 if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
cf7f2e2d 901 do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
5796c8dc
SS
902 }
903
904 if (print_what != LOCATION)
c50c785c
JM
905 {
906 CORE_ADDR pc;
907
908 if (get_frame_pc_if_available (frame, &pc))
a45ae5f8 909 set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
c50c785c 910 else
a45ae5f8 911 set_last_displayed_sal (0, 0, 0, 0, 0);
c50c785c 912 }
5796c8dc
SS
913
914 annotate_frame_end ();
915
916 gdb_flush (gdb_stdout);
917}
918
a45ae5f8
JM
919/* Remember the last symtab and line we displayed, which we use e.g.
920 * as the place to put a breakpoint when the `break' command is
921 * invoked with no arguments. */
922
923static void
924set_last_displayed_sal (int valid, struct program_space *pspace,
925 CORE_ADDR addr, struct symtab *symtab,
926 int line)
927{
928 last_displayed_sal_valid = valid;
929 last_displayed_pspace = pspace;
930 last_displayed_addr = addr;
931 last_displayed_symtab = symtab;
932 last_displayed_line = line;
ef5ccd6c
JM
933 if (valid && pspace == NULL)
934 {
935 clear_last_displayed_sal ();
936 internal_error (__FILE__, __LINE__,
937 _("Trying to set NULL pspace."));
938 }
a45ae5f8
JM
939}
940
941/* Forget the last sal we displayed. */
942
943void
944clear_last_displayed_sal (void)
945{
946 last_displayed_sal_valid = 0;
947 last_displayed_pspace = 0;
948 last_displayed_addr = 0;
949 last_displayed_symtab = 0;
950 last_displayed_line = 0;
951}
952
953/* Is our record of the last sal we displayed valid? If not,
954 * the get_last_displayed_* functions will return NULL or 0, as
955 * appropriate. */
956
957int
958last_displayed_sal_is_valid (void)
959{
960 return last_displayed_sal_valid;
961}
962
963/* Get the pspace of the last sal we displayed, if it's valid. */
964
965struct program_space *
966get_last_displayed_pspace (void)
967{
968 if (last_displayed_sal_valid)
969 return last_displayed_pspace;
970 return 0;
971}
972
973/* Get the address of the last sal we displayed, if it's valid. */
974
975CORE_ADDR
976get_last_displayed_addr (void)
977{
978 if (last_displayed_sal_valid)
979 return last_displayed_addr;
980 return 0;
981}
982
983/* Get the symtab of the last sal we displayed, if it's valid. */
984
985struct symtab*
986get_last_displayed_symtab (void)
987{
988 if (last_displayed_sal_valid)
989 return last_displayed_symtab;
990 return 0;
991}
992
993/* Get the line of the last sal we displayed, if it's valid. */
994
995int
996get_last_displayed_line (void)
997{
998 if (last_displayed_sal_valid)
999 return last_displayed_line;
1000 return 0;
1001}
1002
1003/* Get the last sal we displayed, if it's valid. */
1004
1005void
1006get_last_displayed_sal (struct symtab_and_line *sal)
1007{
1008 if (last_displayed_sal_valid)
1009 {
1010 sal->pspace = last_displayed_pspace;
1011 sal->pc = last_displayed_addr;
1012 sal->symtab = last_displayed_symtab;
1013 sal->line = last_displayed_line;
1014 }
1015 else
1016 {
1017 sal->pspace = 0;
1018 sal->pc = 0;
1019 sal->symtab = 0;
1020 sal->line = 0;
1021 }
1022}
1023
1024
c50c785c
JM
1025/* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function
1026 corresponding to FRAME. */
1027
5796c8dc 1028void
ef5ccd6c 1029find_frame_funname (struct frame_info *frame, const char **funname,
c50c785c 1030 enum language *funlang, struct symbol **funcp)
5796c8dc
SS
1031{
1032 struct symbol *func;
1033
1034 *funname = NULL;
1035 *funlang = language_unknown;
c50c785c
JM
1036 if (funcp)
1037 *funcp = NULL;
5796c8dc
SS
1038
1039 func = get_frame_function (frame);
1040 if (func)
1041 {
1042 /* In certain pathological cases, the symtabs give the wrong
1043 function (when we are in the first function in a file which
1044 is compiled without debugging symbols, the previous function
1045 is compiled with debugging symbols, and the "foo.o" symbol
1046 that is supposed to tell us where the file with debugging
1047 symbols ends has been truncated by ar because it is longer
1048 than 15 characters). This also occurs if the user uses asm()
1049 to create a function but not stabs for it (in a file compiled
1050 with -g).
1051
1052 So look in the minimal symbol tables as well, and if it comes
1053 up with a larger address for the function use that instead.
1054 I don't think this can ever cause any problems; there
1055 shouldn't be any minimal symbols in the middle of a function;
1056 if this is ever changed many parts of GDB will need to be
1057 changed (and we'll create a find_pc_minimal_function or some
1058 such). */
1059
1060 struct minimal_symbol *msymbol = NULL;
1061
1062 /* Don't attempt to do this for inlined functions, which do not
1063 have a corresponding minimal symbol. */
1064 if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
1065 msymbol
1066 = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
1067
1068 if (msymbol != NULL
1069 && (SYMBOL_VALUE_ADDRESS (msymbol)
1070 > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
1071 {
1072 /* We also don't know anything about the function besides
1073 its address and name. */
1074 func = 0;
1075 *funname = SYMBOL_PRINT_NAME (msymbol);
1076 *funlang = SYMBOL_LANGUAGE (msymbol);
1077 }
1078 else
1079 {
1080 *funname = SYMBOL_PRINT_NAME (func);
1081 *funlang = SYMBOL_LANGUAGE (func);
c50c785c
JM
1082 if (funcp)
1083 *funcp = func;
5796c8dc
SS
1084 if (*funlang == language_cplus)
1085 {
1086 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1087 to display the demangled name that we already have
1088 stored in the symbol table, but we stored a version
1089 with DMGL_PARAMS turned on, and here we don't want to
1090 display parameters. So remove the parameters. */
1091 char *func_only = cp_remove_params (*funname);
cf7f2e2d 1092
5796c8dc
SS
1093 if (func_only)
1094 {
1095 *funname = func_only;
1096 make_cleanup (xfree, func_only);
1097 }
1098 }
1099 }
1100 }
1101 else
1102 {
c50c785c
JM
1103 struct minimal_symbol *msymbol;
1104 CORE_ADDR pc;
1105
1106 if (!get_frame_address_in_block_if_available (frame, &pc))
1107 return;
5796c8dc 1108
c50c785c 1109 msymbol = lookup_minimal_symbol_by_pc (pc);
5796c8dc
SS
1110 if (msymbol != NULL)
1111 {
1112 *funname = SYMBOL_PRINT_NAME (msymbol);
1113 *funlang = SYMBOL_LANGUAGE (msymbol);
1114 }
1115 }
1116}
1117
1118static void
1119print_frame (struct frame_info *frame, int print_level,
1120 enum print_what print_what, int print_args,
1121 struct symtab_and_line sal)
1122{
1123 struct gdbarch *gdbarch = get_frame_arch (frame);
a45ae5f8 1124 struct ui_out *uiout = current_uiout;
ef5ccd6c 1125 const char *funname = NULL;
5796c8dc 1126 enum language funlang = language_unknown;
ef5ccd6c 1127 struct ui_file *stb;
5796c8dc
SS
1128 struct cleanup *old_chain, *list_chain;
1129 struct value_print_options opts;
c50c785c
JM
1130 struct symbol *func;
1131 CORE_ADDR pc = 0;
1132 int pc_p;
1133
1134 pc_p = get_frame_pc_if_available (frame, &pc);
5796c8dc 1135
ef5ccd6c
JM
1136 stb = mem_fileopen ();
1137 old_chain = make_cleanup_ui_file_delete (stb);
5796c8dc 1138
c50c785c 1139 find_frame_funname (frame, &funname, &funlang, &func);
5796c8dc
SS
1140
1141 annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
c50c785c 1142 gdbarch, pc);
5796c8dc
SS
1143
1144 list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
1145
1146 if (print_level)
1147 {
1148 ui_out_text (uiout, "#");
1149 ui_out_field_fmt_int (uiout, 2, ui_left, "level",
1150 frame_relative_level (frame));
1151 }
1152 get_user_print_options (&opts);
1153 if (opts.addressprint)
c50c785c
JM
1154 if (!sal.symtab
1155 || frame_show_address (frame, sal)
5796c8dc
SS
1156 || print_what == LOC_AND_ADDRESS)
1157 {
1158 annotate_frame_address ();
c50c785c
JM
1159 if (pc_p)
1160 ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
1161 else
1162 ui_out_field_string (uiout, "addr", "<unavailable>");
5796c8dc
SS
1163 annotate_frame_address_end ();
1164 ui_out_text (uiout, " in ");
1165 }
1166 annotate_frame_function_name ();
ef5ccd6c 1167 fprintf_symbol_filtered (stb, funname ? funname : "??",
5796c8dc
SS
1168 funlang, DMGL_ANSI);
1169 ui_out_field_stream (uiout, "func", stb);
1170 ui_out_wrap_hint (uiout, " ");
1171 annotate_frame_args ();
1172
1173 ui_out_text (uiout, " (");
1174 if (print_args)
1175 {
a45ae5f8
JM
1176 struct gdbarch *gdbarch = get_frame_arch (frame);
1177 int numargs;
5796c8dc 1178 struct cleanup *args_list_chain;
a45ae5f8 1179 volatile struct gdb_exception e;
cf7f2e2d 1180
a45ae5f8
JM
1181 if (gdbarch_frame_num_args_p (gdbarch))
1182 {
1183 numargs = gdbarch_frame_num_args (gdbarch, frame);
1184 gdb_assert (numargs >= 0);
1185 }
1186 else
1187 numargs = -1;
1188
5796c8dc 1189 args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
a45ae5f8
JM
1190 TRY_CATCH (e, RETURN_MASK_ERROR)
1191 {
1192 print_frame_args (func, frame, numargs, gdb_stdout);
1193 }
c50c785c 1194 /* FIXME: ARGS must be a list. If one argument is a string it
5796c8dc
SS
1195 will have " that will not be properly escaped. */
1196 /* Invoke ui_out_tuple_end. */
1197 do_cleanups (args_list_chain);
1198 QUIT;
1199 }
1200 ui_out_text (uiout, ")");
ef5ccd6c 1201 if (sal.symtab)
5796c8dc 1202 {
ef5ccd6c
JM
1203 const char *filename_display;
1204
1205 filename_display = symtab_to_filename_for_display (sal.symtab);
5796c8dc
SS
1206 annotate_frame_source_begin ();
1207 ui_out_wrap_hint (uiout, " ");
1208 ui_out_text (uiout, " at ");
1209 annotate_frame_source_file ();
ef5ccd6c 1210 ui_out_field_string (uiout, "file", filename_display);
5796c8dc
SS
1211 if (ui_out_is_mi_like_p (uiout))
1212 {
1213 const char *fullname = symtab_to_fullname (sal.symtab);
cf7f2e2d 1214
ef5ccd6c 1215 ui_out_field_string (uiout, "fullname", fullname);
5796c8dc
SS
1216 }
1217 annotate_frame_source_file_end ();
1218 ui_out_text (uiout, ":");
1219 annotate_frame_source_line ();
1220 ui_out_field_int (uiout, "line", sal.line);
1221 annotate_frame_source_end ();
1222 }
1223
ef5ccd6c 1224 if (pc_p && (funname == NULL || sal.symtab == NULL))
5796c8dc
SS
1225 {
1226#ifdef PC_SOLIB
1227 char *lib = PC_SOLIB (get_frame_pc (frame));
1228#else
cf7f2e2d
JM
1229 char *lib = solib_name_from_address (get_frame_program_space (frame),
1230 get_frame_pc (frame));
5796c8dc
SS
1231#endif
1232 if (lib)
1233 {
1234 annotate_frame_where ();
1235 ui_out_wrap_hint (uiout, " ");
1236 ui_out_text (uiout, " from ");
1237 ui_out_field_string (uiout, "from", lib);
1238 }
1239 }
1240
1241 /* do_cleanups will call ui_out_tuple_end() for us. */
1242 do_cleanups (list_chain);
1243 ui_out_text (uiout, "\n");
1244 do_cleanups (old_chain);
1245}
1246\f
1247
1248/* Read a frame specification in whatever the appropriate format is
1249 from FRAME_EXP. Call error(), printing MESSAGE, if the
1250 specification is in any way invalid (so this function never returns
1251 NULL). When SEPECTED_P is non-NULL set its target to indicate that
1252 the default selected frame was used. */
1253
1254static struct frame_info *
1255parse_frame_specification_1 (const char *frame_exp, const char *message,
1256 int *selected_frame_p)
1257{
1258 int numargs;
1259 struct value *args[4];
1260 CORE_ADDR addrs[ARRAY_SIZE (args)];
1261
1262 if (frame_exp == NULL)
1263 numargs = 0;
1264 else
1265 {
5796c8dc
SS
1266 numargs = 0;
1267 while (1)
1268 {
1269 char *addr_string;
1270 struct cleanup *cleanup;
1271 const char *p;
1272
1273 /* Skip leading white space, bail of EOL. */
ef5ccd6c 1274 frame_exp = skip_spaces_const (frame_exp);
5796c8dc
SS
1275 if (!*frame_exp)
1276 break;
1277
1278 /* Parse the argument, extract it, save it. */
1279 for (p = frame_exp;
1280 *p && !isspace (*p);
1281 p++);
1282 addr_string = savestring (frame_exp, p - frame_exp);
1283 frame_exp = p;
1284 cleanup = make_cleanup (xfree, addr_string);
1285
1286 /* NOTE: Parse and evaluate expression, but do not use
1287 functions such as parse_and_eval_long or
1288 parse_and_eval_address to also extract the value.
1289 Instead value_as_long and value_as_address are used.
1290 This avoids problems with expressions that contain
1291 side-effects. */
1292 if (numargs >= ARRAY_SIZE (args))
1293 error (_("Too many args in frame specification"));
1294 args[numargs++] = parse_and_eval (addr_string);
1295
1296 do_cleanups (cleanup);
1297 }
1298 }
1299
1300 /* If no args, default to the selected frame. */
1301 if (numargs == 0)
1302 {
1303 if (selected_frame_p != NULL)
1304 (*selected_frame_p) = 1;
1305 return get_selected_frame (message);
1306 }
1307
1308 /* None of the remaining use the selected frame. */
1309 if (selected_frame_p != NULL)
1310 (*selected_frame_p) = 0;
1311
1312 /* Assume the single arg[0] is an integer, and try using that to
1313 select a frame relative to current. */
1314 if (numargs == 1)
1315 {
1316 struct frame_info *fid;
1317 int level = value_as_long (args[0]);
cf7f2e2d 1318
5796c8dc
SS
1319 fid = find_relative_frame (get_current_frame (), &level);
1320 if (level == 0)
c50c785c 1321 /* find_relative_frame was successful. */
5796c8dc
SS
1322 return fid;
1323 }
1324
1325 /* Convert each value into a corresponding address. */
1326 {
1327 int i;
cf7f2e2d 1328
5796c8dc
SS
1329 for (i = 0; i < numargs; i++)
1330 addrs[i] = value_as_address (args[i]);
1331 }
1332
1333 /* Assume that the single arg[0] is an address, use that to identify
1334 a frame with a matching ID. Should this also accept stack/pc or
1335 stack/pc/special. */
1336 if (numargs == 1)
1337 {
1338 struct frame_id id = frame_id_build_wild (addrs[0]);
1339 struct frame_info *fid;
1340
1341 /* If (s)he specifies the frame with an address, he deserves
1342 what (s)he gets. Still, give the highest one that matches.
1343 (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
1344 know). */
1345 for (fid = get_current_frame ();
1346 fid != NULL;
1347 fid = get_prev_frame (fid))
1348 {
1349 if (frame_id_eq (id, get_frame_id (fid)))
1350 {
1351 struct frame_info *prev_frame;
1352
1353 while (1)
1354 {
1355 prev_frame = get_prev_frame (fid);
1356 if (!prev_frame
1357 || !frame_id_eq (id, get_frame_id (prev_frame)))
1358 break;
1359 fid = prev_frame;
1360 }
1361 return fid;
1362 }
1363 }
1364 }
1365
1366 /* We couldn't identify the frame as an existing frame, but
1367 perhaps we can create one with a single argument. */
1368 if (numargs == 1)
1369 return create_new_frame (addrs[0], 0);
1370 else if (numargs == 2)
1371 return create_new_frame (addrs[0], addrs[1]);
1372 else
1373 error (_("Too many args in frame specification"));
1374}
1375
1376static struct frame_info *
1377parse_frame_specification (char *frame_exp)
1378{
1379 return parse_frame_specification_1 (frame_exp, NULL, NULL);
1380}
1381
1382/* Print verbosely the selected frame or the frame at address
1383 ADDR_EXP. Absolutely all information in the frame is printed. */
1384
1385static void
1386frame_info (char *addr_exp, int from_tty)
1387{
1388 struct frame_info *fi;
1389 struct symtab_and_line sal;
1390 struct symbol *func;
1391 struct symtab *s;
1392 struct frame_info *calling_frame_info;
cf7f2e2d 1393 int numregs;
ef5ccd6c 1394 const char *funname = 0;
5796c8dc
SS
1395 enum language funlang = language_unknown;
1396 const char *pc_regname;
1397 int selected_frame_p;
1398 struct gdbarch *gdbarch;
1399 struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
c50c785c
JM
1400 CORE_ADDR frame_pc;
1401 int frame_pc_p;
1402 CORE_ADDR caller_pc;
5796c8dc
SS
1403
1404 fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
1405 gdbarch = get_frame_arch (fi);
1406
1407 /* Name of the value returned by get_frame_pc(). Per comments, "pc"
1408 is not a good name. */
1409 if (gdbarch_pc_regnum (gdbarch) >= 0)
1410 /* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
1411 easily not match that of the internal value returned by
1412 get_frame_pc(). */
1413 pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1414 else
1415 /* But then, this is weird to. Even without gdbarch_pc_regnum, an
1416 architectures will often have a hardware register called "pc",
1417 and that register's value, again, can easily not match
1418 get_frame_pc(). */
1419 pc_regname = "pc";
1420
c50c785c 1421 frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
5796c8dc
SS
1422 find_frame_sal (fi, &sal);
1423 func = get_frame_function (fi);
c50c785c 1424 s = sal.symtab;
5796c8dc
SS
1425 if (func)
1426 {
1427 funname = SYMBOL_PRINT_NAME (func);
1428 funlang = SYMBOL_LANGUAGE (func);
1429 if (funlang == language_cplus)
1430 {
1431 /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1432 to display the demangled name that we already have
1433 stored in the symbol table, but we stored a version
1434 with DMGL_PARAMS turned on, and here we don't want to
1435 display parameters. So remove the parameters. */
1436 char *func_only = cp_remove_params (funname);
cf7f2e2d 1437
5796c8dc
SS
1438 if (func_only)
1439 {
1440 funname = func_only;
1441 make_cleanup (xfree, func_only);
1442 }
1443 }
1444 }
c50c785c 1445 else if (frame_pc_p)
5796c8dc
SS
1446 {
1447 struct minimal_symbol *msymbol;
1448
c50c785c 1449 msymbol = lookup_minimal_symbol_by_pc (frame_pc);
5796c8dc
SS
1450 if (msymbol != NULL)
1451 {
1452 funname = SYMBOL_PRINT_NAME (msymbol);
1453 funlang = SYMBOL_LANGUAGE (msymbol);
1454 }
1455 }
1456 calling_frame_info = get_prev_frame (fi);
1457
1458 if (selected_frame_p && frame_relative_level (fi) >= 0)
1459 {
1460 printf_filtered (_("Stack level %d, frame at "),
1461 frame_relative_level (fi));
1462 }
1463 else
1464 {
1465 printf_filtered (_("Stack frame at "));
1466 }
1467 fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1468 printf_filtered (":\n");
1469 printf_filtered (" %s = ", pc_regname);
c50c785c
JM
1470 if (frame_pc_p)
1471 fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1472 else
1473 fputs_filtered ("<unavailable>", gdb_stdout);
5796c8dc
SS
1474
1475 wrap_here (" ");
1476 if (funname)
1477 {
1478 printf_filtered (" in ");
1479 fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1480 DMGL_ANSI | DMGL_PARAMS);
1481 }
1482 wrap_here (" ");
1483 if (sal.symtab)
ef5ccd6c
JM
1484 printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1485 sal.line);
5796c8dc
SS
1486 puts_filtered ("; ");
1487 wrap_here (" ");
1488 printf_filtered ("saved %s ", pc_regname);
c50c785c
JM
1489 if (frame_unwind_caller_pc_if_available (fi, &caller_pc))
1490 fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1491 else
1492 fputs_filtered ("<unavailable>", gdb_stdout);
5796c8dc
SS
1493 printf_filtered ("\n");
1494
1495 if (calling_frame_info == NULL)
1496 {
1497 enum unwind_stop_reason reason;
1498
1499 reason = get_frame_unwind_stop_reason (fi);
1500 if (reason != UNWIND_NO_REASON)
1501 printf_filtered (_(" Outermost frame: %s\n"),
1502 frame_stop_reason_string (reason));
1503 }
a45ae5f8
JM
1504 else if (get_frame_type (fi) == TAILCALL_FRAME)
1505 puts_filtered (" tail call frame");
5796c8dc
SS
1506 else if (get_frame_type (fi) == INLINE_FRAME)
1507 printf_filtered (" inlined into frame %d",
1508 frame_relative_level (get_prev_frame (fi)));
1509 else
1510 {
1511 printf_filtered (" called by frame at ");
1512 fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1513 gdb_stdout);
1514 }
1515 if (get_next_frame (fi) && calling_frame_info)
1516 puts_filtered (",");
1517 wrap_here (" ");
1518 if (get_next_frame (fi))
1519 {
1520 printf_filtered (" caller of frame at ");
1521 fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1522 gdb_stdout);
1523 }
1524 if (get_next_frame (fi) || calling_frame_info)
1525 puts_filtered ("\n");
1526
1527 if (s)
1528 printf_filtered (" source language %s.\n",
1529 language_str (s->language));
1530
1531 {
1532 /* Address of the argument list for this frame, or 0. */
1533 CORE_ADDR arg_list = get_frame_args_address (fi);
1534 /* Number of args for this frame, or -1 if unknown. */
1535 int numargs;
1536
1537 if (arg_list == 0)
1538 printf_filtered (" Arglist at unknown address.\n");
1539 else
1540 {
1541 printf_filtered (" Arglist at ");
1542 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1543 printf_filtered (",");
1544
1545 if (!gdbarch_frame_num_args_p (gdbarch))
1546 {
1547 numargs = -1;
1548 puts_filtered (" args: ");
1549 }
1550 else
1551 {
1552 numargs = gdbarch_frame_num_args (gdbarch, fi);
1553 gdb_assert (numargs >= 0);
1554 if (numargs == 0)
1555 puts_filtered (" no args.");
1556 else if (numargs == 1)
1557 puts_filtered (" 1 arg: ");
1558 else
1559 printf_filtered (" %d args: ", numargs);
1560 }
1561 print_frame_args (func, fi, numargs, gdb_stdout);
1562 puts_filtered ("\n");
1563 }
1564 }
1565 {
1566 /* Address of the local variables for this frame, or 0. */
1567 CORE_ADDR arg_list = get_frame_locals_address (fi);
1568
1569 if (arg_list == 0)
1570 printf_filtered (" Locals at unknown address,");
1571 else
1572 {
1573 printf_filtered (" Locals at ");
1574 fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1575 printf_filtered (",");
1576 }
1577 }
1578
1579 /* Print as much information as possible on the location of all the
1580 registers. */
1581 {
1582 enum lval_type lval;
1583 int optimized;
c50c785c 1584 int unavailable;
5796c8dc
SS
1585 CORE_ADDR addr;
1586 int realnum;
1587 int count;
1588 int i;
1589 int need_nl = 1;
1590
1591 /* The sp is special; what's displayed isn't the save address, but
1592 the value of the previous frame's sp. This is a legacy thing,
1593 at one stage the frame cached the previous frame's SP instead
1594 of its address, hence it was easiest to just display the cached
1595 value. */
1596 if (gdbarch_sp_regnum (gdbarch) >= 0)
1597 {
1598 /* Find out the location of the saved stack pointer with out
1599 actually evaluating it. */
1600 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
c50c785c 1601 &optimized, &unavailable, &lval, &addr,
5796c8dc 1602 &realnum, NULL);
c50c785c 1603 if (!optimized && !unavailable && lval == not_lval)
5796c8dc
SS
1604 {
1605 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1606 int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
1607 gdb_byte value[MAX_REGISTER_SIZE];
1608 CORE_ADDR sp;
cf7f2e2d 1609
5796c8dc 1610 frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
c50c785c 1611 &optimized, &unavailable, &lval, &addr,
5796c8dc
SS
1612 &realnum, value);
1613 /* NOTE: cagney/2003-05-22: This is assuming that the
1614 stack pointer was packed as an unsigned integer. That
1615 may or may not be valid. */
1616 sp = extract_unsigned_integer (value, sp_size, byte_order);
1617 printf_filtered (" Previous frame's sp is ");
1618 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1619 printf_filtered ("\n");
1620 need_nl = 0;
1621 }
c50c785c 1622 else if (!optimized && !unavailable && lval == lval_memory)
5796c8dc
SS
1623 {
1624 printf_filtered (" Previous frame's sp at ");
1625 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1626 printf_filtered ("\n");
1627 need_nl = 0;
1628 }
c50c785c 1629 else if (!optimized && !unavailable && lval == lval_register)
5796c8dc
SS
1630 {
1631 printf_filtered (" Previous frame's sp in %s\n",
1632 gdbarch_register_name (gdbarch, realnum));
1633 need_nl = 0;
1634 }
1635 /* else keep quiet. */
1636 }
1637
1638 count = 0;
1639 numregs = gdbarch_num_regs (gdbarch)
1640 + gdbarch_num_pseudo_regs (gdbarch);
1641 for (i = 0; i < numregs; i++)
1642 if (i != gdbarch_sp_regnum (gdbarch)
1643 && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1644 {
1645 /* Find out the location of the saved register without
1646 fetching the corresponding value. */
c50c785c
JM
1647 frame_register_unwind (fi, i, &optimized, &unavailable,
1648 &lval, &addr, &realnum, NULL);
5796c8dc
SS
1649 /* For moment, only display registers that were saved on the
1650 stack. */
c50c785c 1651 if (!optimized && !unavailable && lval == lval_memory)
5796c8dc
SS
1652 {
1653 if (count == 0)
1654 puts_filtered (" Saved registers:\n ");
1655 else
1656 puts_filtered (",");
1657 wrap_here (" ");
1658 printf_filtered (" %s at ",
1659 gdbarch_register_name (gdbarch, i));
1660 fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1661 count++;
1662 }
1663 }
1664 if (count || need_nl)
1665 puts_filtered ("\n");
1666 }
1667
1668 do_cleanups (back_to);
1669}
1670
1671/* Print briefly all stack frames or just the innermost COUNT_EXP
1672 frames. */
1673
1674static void
1675backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
1676{
1677 struct frame_info *fi;
1678 int count;
1679 int i;
1680 struct frame_info *trailing;
1681 int trailing_level;
1682
1683 if (!target_has_stack)
1684 error (_("No stack."));
1685
1686 /* The following code must do two things. First, it must set the
1687 variable TRAILING to the frame from which we should start
1688 printing. Second, it must set the variable count to the number
1689 of frames which we should print, or -1 if all of them. */
1690 trailing = get_current_frame ();
1691
1692 trailing_level = 0;
1693 if (count_exp)
1694 {
1695 count = parse_and_eval_long (count_exp);
1696 if (count < 0)
1697 {
1698 struct frame_info *current;
1699
1700 count = -count;
1701
1702 current = trailing;
1703 while (current && count--)
1704 {
1705 QUIT;
1706 current = get_prev_frame (current);
1707 }
1708
1709 /* Will stop when CURRENT reaches the top of the stack.
1710 TRAILING will be COUNT below it. */
1711 while (current)
1712 {
1713 QUIT;
1714 trailing = get_prev_frame (trailing);
1715 current = get_prev_frame (current);
1716 trailing_level++;
1717 }
1718
1719 count = -1;
1720 }
1721 }
1722 else
1723 count = -1;
1724
1725 if (info_verbose)
1726 {
5796c8dc
SS
1727 /* Read in symbols for all of the frames. Need to do this in a
1728 separate pass so that "Reading in symbols for xxx" messages
1729 don't screw up the appearance of the backtrace. Also if
1730 people have strong opinions against reading symbols for
1731 backtrace this may have to be an option. */
1732 i = count;
1733 for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
1734 {
cf7f2e2d
JM
1735 CORE_ADDR pc;
1736
5796c8dc 1737 QUIT;
cf7f2e2d
JM
1738 pc = get_frame_address_in_block (fi);
1739 find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc));
5796c8dc
SS
1740 }
1741 }
1742
1743 for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
1744 {
1745 QUIT;
1746
1747 /* Don't use print_stack_frame; if an error() occurs it probably
1748 means further attempts to backtrace would fail (on the other
1749 hand, perhaps the code does or could be fixed to make sure
1750 the frame->prev field gets set to NULL in that case). */
1751 print_frame_info (fi, 1, LOCATION, 1);
1752 if (show_locals)
ef5ccd6c
JM
1753 {
1754 struct frame_id frame_id = get_frame_id (fi);
1755
1756 print_frame_local_vars (fi, 1, gdb_stdout);
1757
1758 /* print_frame_local_vars invalidates FI. */
1759 fi = frame_find_by_id (frame_id);
1760 if (fi == NULL)
1761 {
1762 trailing = NULL;
1763 warning (_("Unable to restore previously selected frame."));
1764 break;
1765 }
1766 }
5796c8dc
SS
1767
1768 /* Save the last frame to check for error conditions. */
1769 trailing = fi;
1770 }
1771
1772 /* If we've stopped before the end, mention that. */
1773 if (fi && from_tty)
1774 printf_filtered (_("(More stack frames follow...)\n"));
1775
1776 /* If we've run out of frames, and the reason appears to be an error
1777 condition, print it. */
1778 if (fi == NULL && trailing != NULL)
1779 {
1780 enum unwind_stop_reason reason;
1781
1782 reason = get_frame_unwind_stop_reason (trailing);
a45ae5f8 1783 if (reason >= UNWIND_FIRST_ERROR)
5796c8dc
SS
1784 printf_filtered (_("Backtrace stopped: %s\n"),
1785 frame_stop_reason_string (reason));
1786 }
1787}
1788
5796c8dc
SS
1789static void
1790backtrace_command (char *arg, int from_tty)
1791{
a45ae5f8 1792 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
5796c8dc 1793 int fulltrace_arg = -1, arglen = 0, argc = 0;
5796c8dc
SS
1794
1795 if (arg)
1796 {
1797 char **argv;
1798 int i;
1799
1800 argv = gdb_buildargv (arg);
a45ae5f8 1801 make_cleanup_freeargv (argv);
5796c8dc
SS
1802 argc = 0;
1803 for (i = 0; argv[i]; i++)
1804 {
1805 unsigned int j;
1806
1807 for (j = 0; j < strlen (argv[i]); j++)
1808 argv[i][j] = tolower (argv[i][j]);
1809
1810 if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
1811 fulltrace_arg = argc;
1812 else
1813 {
1814 arglen += strlen (argv[i]);
1815 argc++;
1816 }
1817 }
1818 arglen += argc;
1819 if (fulltrace_arg >= 0)
1820 {
1821 if (arglen > 0)
1822 {
1823 arg = xmalloc (arglen + 1);
a45ae5f8
JM
1824 make_cleanup (xfree, arg);
1825 arg[0] = 0;
5796c8dc
SS
1826 for (i = 0; i < (argc + 1); i++)
1827 {
1828 if (i != fulltrace_arg)
1829 {
1830 strcat (arg, argv[i]);
1831 strcat (arg, " ");
1832 }
1833 }
1834 }
1835 else
1836 arg = NULL;
1837 }
1838 }
1839
a45ae5f8 1840 backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, from_tty);
5796c8dc 1841
a45ae5f8 1842 do_cleanups (old_chain);
5796c8dc
SS
1843}
1844
1845static void
1846backtrace_full_command (char *arg, int from_tty)
1847{
a45ae5f8 1848 backtrace_command_1 (arg, 1 /* show_locals */, from_tty);
5796c8dc
SS
1849}
1850\f
1851
cf7f2e2d
JM
1852/* Iterate over the local variables of a block B, calling CB with
1853 CB_DATA. */
5796c8dc 1854
cf7f2e2d
JM
1855static void
1856iterate_over_block_locals (struct block *b,
1857 iterate_over_block_arg_local_vars_cb cb,
1858 void *cb_data)
5796c8dc 1859{
ef5ccd6c 1860 struct block_iterator iter;
5796c8dc 1861 struct symbol *sym;
5796c8dc
SS
1862
1863 ALL_BLOCK_SYMBOLS (b, iter, sym)
1864 {
1865 switch (SYMBOL_CLASS (sym))
1866 {
1867 case LOC_LOCAL:
1868 case LOC_REGISTER:
1869 case LOC_STATIC:
1870 case LOC_COMPUTED:
1871 if (SYMBOL_IS_ARGUMENT (sym))
1872 break;
ef5ccd6c
JM
1873 if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
1874 break;
cf7f2e2d 1875 (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
5796c8dc
SS
1876 break;
1877
1878 default:
1879 /* Ignore symbols which are not locals. */
1880 break;
1881 }
1882 }
5796c8dc
SS
1883}
1884
cf7f2e2d 1885
5796c8dc
SS
1886/* Same, but print labels. */
1887
cf7f2e2d
JM
1888#if 0
1889/* Commented out, as the code using this function has also been
1890 commented out. FIXME:brobecker/2009-01-13: Find out why the code
1891 was commented out in the first place. The discussion introducing
1892 this change (2007-12-04: Support lexical blocks and function bodies
1893 that occupy non-contiguous address ranges) did not explain why
1894 this change was made. */
5796c8dc
SS
1895static int
1896print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
1897 int *have_default, struct ui_file *stream)
1898{
ef5ccd6c 1899 struct block_iterator iter;
5796c8dc
SS
1900 struct symbol *sym;
1901 int values_printed = 0;
1902
1903 ALL_BLOCK_SYMBOLS (b, iter, sym)
1904 {
1905 if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
1906 {
1907 if (*have_default)
1908 continue;
1909 *have_default = 1;
1910 }
1911 if (SYMBOL_CLASS (sym) == LOC_LABEL)
1912 {
1913 struct symtab_and_line sal;
1914 struct value_print_options opts;
cf7f2e2d 1915
5796c8dc
SS
1916 sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
1917 values_printed = 1;
1918 fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
1919 get_user_print_options (&opts);
1920 if (opts.addressprint)
1921 {
1922 fprintf_filtered (stream, " ");
1923 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
1924 stream);
1925 }
1926 fprintf_filtered (stream, " in file %s, line %d\n",
1927 sal.symtab->filename, sal.line);
1928 }
1929 }
1930
1931 return values_printed;
1932}
cf7f2e2d 1933#endif
5796c8dc 1934
cf7f2e2d
JM
1935/* Iterate over all the local variables in block B, including all its
1936 superblocks, stopping when the top-level block is reached. */
5796c8dc 1937
cf7f2e2d
JM
1938void
1939iterate_over_block_local_vars (struct block *block,
1940 iterate_over_block_arg_local_vars_cb cb,
1941 void *cb_data)
1942{
1943 while (block)
1944 {
1945 iterate_over_block_locals (block, cb, cb_data);
1946 /* After handling the function's top-level block, stop. Don't
1947 continue to its superblock, the block of per-file
1948 symbols. */
1949 if (BLOCK_FUNCTION (block))
1950 break;
1951 block = BLOCK_SUPERBLOCK (block);
1952 }
1953}
1954
1955/* Data to be passed around in the calls to the locals and args
1956 iterators. */
1957
1958struct print_variable_and_value_data
1959{
ef5ccd6c 1960 struct frame_id frame_id;
cf7f2e2d
JM
1961 int num_tabs;
1962 struct ui_file *stream;
1963 int values_printed;
1964};
1965
c50c785c 1966/* The callback for the locals and args iterators. */
cf7f2e2d
JM
1967
1968static void
1969do_print_variable_and_value (const char *print_name,
1970 struct symbol *sym,
1971 void *cb_data)
1972{
1973 struct print_variable_and_value_data *p = cb_data;
ef5ccd6c
JM
1974 struct frame_info *frame;
1975
1976 frame = frame_find_by_id (p->frame_id);
1977 if (frame == NULL)
1978 {
1979 warning (_("Unable to restore previously selected frame."));
1980 return;
1981 }
1982
1983 print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
1984
1985 /* print_variable_and_value invalidates FRAME. */
1986 frame = NULL;
cf7f2e2d 1987
cf7f2e2d
JM
1988 p->values_printed = 1;
1989}
5796c8dc 1990
ef5ccd6c
JM
1991/* Print all variables from the innermost up to the function block of FRAME.
1992 Print them with values to STREAM indented by NUM_TABS.
1993
1994 This function will invalidate FRAME. */
1995
5796c8dc
SS
1996static void
1997print_frame_local_vars (struct frame_info *frame, int num_tabs,
1998 struct ui_file *stream)
1999{
cf7f2e2d
JM
2000 struct print_variable_and_value_data cb_data;
2001 struct block *block;
c50c785c
JM
2002 CORE_ADDR pc;
2003
2004 if (!get_frame_pc_if_available (frame, &pc))
2005 {
2006 fprintf_filtered (stream,
2007 _("PC unavailable, cannot determine locals.\n"));
2008 return;
2009 }
5796c8dc 2010
cf7f2e2d 2011 block = get_frame_block (frame, 0);
5796c8dc
SS
2012 if (block == 0)
2013 {
2014 fprintf_filtered (stream, "No symbol table info available.\n");
2015 return;
2016 }
2017
ef5ccd6c 2018 cb_data.frame_id = get_frame_id (frame);
cf7f2e2d
JM
2019 cb_data.num_tabs = 4 * num_tabs;
2020 cb_data.stream = stream;
2021 cb_data.values_printed = 0;
5796c8dc 2022
cf7f2e2d
JM
2023 iterate_over_block_local_vars (block,
2024 do_print_variable_and_value,
2025 &cb_data);
2026
ef5ccd6c
JM
2027 /* do_print_variable_and_value invalidates FRAME. */
2028 frame = NULL;
2029
cf7f2e2d 2030 if (!cb_data.values_printed)
5796c8dc
SS
2031 fprintf_filtered (stream, _("No locals.\n"));
2032}
2033
5796c8dc
SS
2034void
2035locals_info (char *args, int from_tty)
2036{
2037 print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2038 0, gdb_stdout);
2039}
2040
cf7f2e2d
JM
2041/* Iterate over all the argument variables in block B.
2042
2043 Returns 1 if any argument was walked; 0 otherwise. */
2044
2045void
2046iterate_over_block_arg_vars (struct block *b,
2047 iterate_over_block_arg_local_vars_cb cb,
2048 void *cb_data)
5796c8dc 2049{
ef5ccd6c 2050 struct block_iterator iter;
5796c8dc 2051 struct symbol *sym, *sym2;
5796c8dc 2052
5796c8dc
SS
2053 ALL_BLOCK_SYMBOLS (b, iter, sym)
2054 {
2055 /* Don't worry about things which aren't arguments. */
2056 if (SYMBOL_IS_ARGUMENT (sym))
2057 {
5796c8dc
SS
2058 /* We have to look up the symbol because arguments can have
2059 two entries (one a parameter, one a local) and the one we
2060 want is the local, which lookup_symbol will find for us.
2061 This includes gcc1 (not gcc2) on the sparc when passing a
2062 small structure and gcc2 when the argument type is float
2063 and it is passed as a double and converted to float by
2064 the prologue (in the latter case the type of the LOC_ARG
2065 symbol is double and the type of the LOC_LOCAL symbol is
2066 float). There are also LOC_ARG/LOC_REGISTER pairs which
2067 are not combined in symbol-reading. */
2068
2069 sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
2070 b, VAR_DOMAIN, NULL);
cf7f2e2d 2071 (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
5796c8dc
SS
2072 }
2073 }
cf7f2e2d
JM
2074}
2075
ef5ccd6c
JM
2076/* Print all argument variables of the function of FRAME.
2077 Print them with values to STREAM.
2078
2079 This function will invalidate FRAME. */
2080
cf7f2e2d
JM
2081static void
2082print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
2083{
2084 struct print_variable_and_value_data cb_data;
2085 struct symbol *func;
c50c785c
JM
2086 CORE_ADDR pc;
2087
2088 if (!get_frame_pc_if_available (frame, &pc))
2089 {
2090 fprintf_filtered (stream, _("PC unavailable, cannot determine args.\n"));
2091 return;
2092 }
cf7f2e2d
JM
2093
2094 func = get_frame_function (frame);
2095 if (func == NULL)
2096 {
2097 fprintf_filtered (stream, _("No symbol table info available.\n"));
2098 return;
2099 }
5796c8dc 2100
ef5ccd6c 2101 cb_data.frame_id = get_frame_id (frame);
cf7f2e2d
JM
2102 cb_data.num_tabs = 0;
2103 cb_data.stream = gdb_stdout;
2104 cb_data.values_printed = 0;
2105
2106 iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2107 do_print_variable_and_value, &cb_data);
2108
ef5ccd6c
JM
2109 /* do_print_variable_and_value invalidates FRAME. */
2110 frame = NULL;
2111
cf7f2e2d 2112 if (!cb_data.values_printed)
5796c8dc
SS
2113 fprintf_filtered (stream, _("No arguments.\n"));
2114}
2115
2116void
2117args_info (char *ignore, int from_tty)
2118{
2119 print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2120 gdb_stdout);
2121}
2122
2123
2124static void
2125args_plus_locals_info (char *ignore, int from_tty)
2126{
2127 args_info (ignore, from_tty);
2128 locals_info (ignore, from_tty);
2129}
2130\f
2131
2132/* Select frame FRAME. Also print the stack frame and show the source
2133 if this is the tui version. */
2134static void
2135select_and_print_frame (struct frame_info *frame)
2136{
2137 select_frame (frame);
2138 if (frame)
2139 print_stack_frame (frame, 1, SRC_AND_LOC);
2140}
2141\f
2142/* Return the symbol-block in which the selected frame is executing.
2143 Can return zero under various legitimate circumstances.
2144
2145 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2146 code address within the block returned. We use this to decide
2147 which macros are in scope. */
2148
2149struct block *
2150get_selected_block (CORE_ADDR *addr_in_block)
2151{
2152 if (!has_stack_frames ())
2153 return 0;
2154
2155 return get_frame_block (get_selected_frame (NULL), addr_in_block);
2156}
2157
2158/* Find a frame a certain number of levels away from FRAME.
2159 LEVEL_OFFSET_PTR points to an int containing the number of levels.
2160 Positive means go to earlier frames (up); negative, the reverse.
2161 The int that contains the number of levels is counted toward
2162 zero as the frames for those levels are found.
2163 If the top or bottom frame is reached, that frame is returned,
2164 but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2165 how much farther the original request asked to go. */
2166
2167struct frame_info *
2168find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2169{
2170 /* Going up is simple: just call get_prev_frame enough times or
2171 until the initial frame is reached. */
2172 while (*level_offset_ptr > 0)
2173 {
2174 struct frame_info *prev = get_prev_frame (frame);
cf7f2e2d 2175
5796c8dc
SS
2176 if (!prev)
2177 break;
2178 (*level_offset_ptr)--;
2179 frame = prev;
2180 }
2181
2182 /* Going down is just as simple. */
2183 while (*level_offset_ptr < 0)
2184 {
2185 struct frame_info *next = get_next_frame (frame);
cf7f2e2d 2186
5796c8dc
SS
2187 if (!next)
2188 break;
2189 (*level_offset_ptr)++;
2190 frame = next;
2191 }
2192
2193 return frame;
2194}
2195
2196/* The "select_frame" command. With no argument this is a NOP.
2197 Select the frame at level LEVEL_EXP if it is a valid level.
2198 Otherwise, treat LEVEL_EXP as an address expression and select it.
2199
2200 See parse_frame_specification for more info on proper frame
2201 expressions. */
2202
2203void
2204select_frame_command (char *level_exp, int from_tty)
2205{
2206 select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
2207}
2208
2209/* The "frame" command. With no argument, print the selected frame
2210 briefly. With an argument, behave like select_frame and then print
2211 the selected frame. */
2212
2213static void
2214frame_command (char *level_exp, int from_tty)
2215{
2216 select_frame_command (level_exp, from_tty);
2217 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2218}
2219
2220/* The XDB Compatibility command to print the current frame. */
2221
2222static void
2223current_frame_command (char *level_exp, int from_tty)
2224{
2225 print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
2226}
2227
2228/* Select the frame up one or COUNT_EXP stack levels from the
2229 previously selected frame, and print it briefly. */
2230
2231static void
2232up_silently_base (char *count_exp)
2233{
2234 struct frame_info *frame;
2235 int count = 1;
2236
2237 if (count_exp)
2238 count = parse_and_eval_long (count_exp);
2239
2240 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2241 if (count != 0 && count_exp == NULL)
2242 error (_("Initial frame selected; you cannot go up."));
2243 select_frame (frame);
2244}
2245
2246static void
2247up_silently_command (char *count_exp, int from_tty)
2248{
2249 up_silently_base (count_exp);
2250}
2251
2252static void
2253up_command (char *count_exp, int from_tty)
2254{
2255 up_silently_base (count_exp);
2256 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2257}
2258
2259/* Select the frame down one or COUNT_EXP stack levels from the previously
2260 selected frame, and print it briefly. */
2261
2262static void
2263down_silently_base (char *count_exp)
2264{
2265 struct frame_info *frame;
2266 int count = -1;
cf7f2e2d 2267
5796c8dc
SS
2268 if (count_exp)
2269 count = -parse_and_eval_long (count_exp);
2270
2271 frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2272 if (count != 0 && count_exp == NULL)
2273 {
2274 /* We only do this if COUNT_EXP is not specified. That way
2275 "down" means to really go down (and let me know if that is
2276 impossible), but "down 9999" can be used to mean go all the
2277 way down without getting an error. */
2278
2279 error (_("Bottom (innermost) frame selected; you cannot go down."));
2280 }
2281
2282 select_frame (frame);
2283}
2284
2285static void
2286down_silently_command (char *count_exp, int from_tty)
2287{
2288 down_silently_base (count_exp);
2289}
2290
2291static void
2292down_command (char *count_exp, int from_tty)
2293{
2294 down_silently_base (count_exp);
2295 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2296}
2297\f
2298
2299void
2300return_command (char *retval_exp, int from_tty)
2301{
ef5ccd6c
JM
2302 /* Initialize it just to avoid a GCC false warning. */
2303 enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
5796c8dc
SS
2304 struct frame_info *thisframe;
2305 struct gdbarch *gdbarch;
2306 struct symbol *thisfun;
2307 struct value *return_value = NULL;
ef5ccd6c 2308 struct value *function = NULL;
5796c8dc
SS
2309 const char *query_prefix = "";
2310
2311 thisframe = get_selected_frame ("No selected frame.");
2312 thisfun = get_frame_function (thisframe);
2313 gdbarch = get_frame_arch (thisframe);
2314
2315 if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2316 error (_("Can not force return from an inlined function."));
2317
2318 /* Compute the return value. If the computation triggers an error,
2319 let it bail. If the return type can't be handled, set
2320 RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2321 message. */
2322 if (retval_exp)
2323 {
2324 struct expression *retval_expr = parse_expression (retval_exp);
2325 struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
2326 struct type *return_type = NULL;
2327
2328 /* Compute the return value. Should the computation fail, this
2329 call throws an error. */
2330 return_value = evaluate_expression (retval_expr);
2331
2332 /* Cast return value to the return type of the function. Should
2333 the cast fail, this call throws an error. */
2334 if (thisfun != NULL)
2335 return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2336 if (return_type == NULL)
2337 {
ef5ccd6c
JM
2338 if (retval_expr->elts[0].opcode != UNOP_CAST
2339 && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
5796c8dc
SS
2340 error (_("Return value type not available for selected "
2341 "stack frame.\n"
2342 "Please use an explicit cast of the value to return."));
2343 return_type = value_type (return_value);
2344 }
2345 do_cleanups (old_chain);
2346 CHECK_TYPEDEF (return_type);
2347 return_value = value_cast (return_type, return_value);
2348
2349 /* Make sure the value is fully evaluated. It may live in the
2350 stack frame we're about to pop. */
2351 if (value_lazy (return_value))
2352 value_fetch_lazy (return_value);
2353
ef5ccd6c
JM
2354 if (thisfun != NULL)
2355 function = read_var_value (thisfun, thisframe);
2356
2357 rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
5796c8dc
SS
2358 if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2359 /* If the return-type is "void", don't try to find the
2360 return-value's location. However, do still evaluate the
2361 return expression so that, even when the expression result
2362 is discarded, side effects such as "return i++" still
2363 occur. */
2364 return_value = NULL;
ef5ccd6c 2365 else if (thisfun != NULL)
5796c8dc 2366 {
ef5ccd6c
JM
2367 rv_conv = struct_return_convention (gdbarch, function, return_type);
2368 if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2369 || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2370 {
2371 query_prefix = "The location at which to store the "
2372 "function's return value is unknown.\n"
2373 "If you continue, the return value "
2374 "that you specified will be ignored.\n";
2375 return_value = NULL;
2376 }
5796c8dc
SS
2377 }
2378 }
2379
2380 /* Does an interactive user really want to do this? Include
2381 information, such as how well GDB can handle the return value, in
2382 the query message. */
2383 if (from_tty)
2384 {
2385 int confirmed;
cf7f2e2d 2386
5796c8dc
SS
2387 if (thisfun == NULL)
2388 confirmed = query (_("%sMake selected stack frame return now? "),
2389 query_prefix);
2390 else
2391 confirmed = query (_("%sMake %s return now? "), query_prefix,
2392 SYMBOL_PRINT_NAME (thisfun));
2393 if (!confirmed)
2394 error (_("Not confirmed"));
2395 }
2396
2397 /* Discard the selected frame and all frames inner-to it. */
2398 frame_pop (get_selected_frame (NULL));
2399
2400 /* Store RETURN_VALUE in the just-returned register set. */
2401 if (return_value != NULL)
2402 {
2403 struct type *return_type = value_type (return_value);
2404 struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
5796c8dc 2405
ef5ccd6c
JM
2406 gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2407 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2408 gdbarch_return_value (gdbarch, function, return_type,
5796c8dc
SS
2409 get_current_regcache (), NULL /*read*/,
2410 value_contents (return_value) /*write*/);
2411 }
2412
2413 /* If we are at the end of a call dummy now, pop the dummy frame
2414 too. */
2415 if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2416 frame_pop (get_current_frame ());
2417
2418 /* If interactive, print the frame that is now current. */
2419 if (from_tty)
2420 frame_command ("0", 1);
2421 else
2422 select_frame_command ("0", 0);
2423}
2424
2425/* Sets the scope to input function name, provided that the function
c50c785c 2426 is within the current stack frame. */
5796c8dc
SS
2427
2428struct function_bounds
2429{
2430 CORE_ADDR low, high;
2431};
2432
2433static void
2434func_command (char *arg, int from_tty)
2435{
2436 struct frame_info *frame;
2437 int found = 0;
2438 struct symtabs_and_lines sals;
2439 int i;
2440 int level = 1;
2441 struct function_bounds *func_bounds = NULL;
a45ae5f8 2442 struct cleanup *cleanups;
5796c8dc
SS
2443
2444 if (arg != NULL)
2445 return;
2446
2447 frame = parse_frame_specification ("0");
ef5ccd6c 2448 sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
a45ae5f8 2449 cleanups = make_cleanup (xfree, sals.sals);
5796c8dc
SS
2450 func_bounds = (struct function_bounds *) xmalloc (
2451 sizeof (struct function_bounds) * sals.nelts);
a45ae5f8 2452 make_cleanup (xfree, func_bounds);
5796c8dc
SS
2453 for (i = 0; (i < sals.nelts && !found); i++)
2454 {
a45ae5f8
JM
2455 if (sals.sals[i].pspace != current_program_space)
2456 func_bounds[i].low = func_bounds[i].high = 0;
2457 else if (sals.sals[i].pc == 0
2458 || find_pc_partial_function (sals.sals[i].pc, NULL,
2459 &func_bounds[i].low,
2460 &func_bounds[i].high) == 0)
5796c8dc
SS
2461 {
2462 func_bounds[i].low = func_bounds[i].high = 0;
2463 }
2464 }
2465
2466 do
2467 {
2468 for (i = 0; (i < sals.nelts && !found); i++)
2469 found = (get_frame_pc (frame) >= func_bounds[i].low
2470 && get_frame_pc (frame) < func_bounds[i].high);
2471 if (!found)
2472 {
2473 level = 1;
2474 frame = find_relative_frame (frame, &level);
2475 }
2476 }
2477 while (!found && level == 0);
2478
a45ae5f8 2479 do_cleanups (cleanups);
5796c8dc
SS
2480
2481 if (!found)
2482 printf_filtered (_("'%s' not within current stack frame.\n"), arg);
2483 else if (frame != get_selected_frame (NULL))
2484 select_and_print_frame (frame);
2485}
2486
2487/* Gets the language of the current frame. */
2488
2489enum language
2490get_frame_language (void)
2491{
2492 struct frame_info *frame = deprecated_safe_get_selected_frame ();
2493
2494 if (frame)
2495 {
c50c785c
JM
2496 volatile struct gdb_exception ex;
2497 CORE_ADDR pc = 0;
2498 struct symtab *s;
2499
5796c8dc
SS
2500 /* We determine the current frame language by looking up its
2501 associated symtab. To retrieve this symtab, we use the frame
2502 PC. However we cannot use the frame PC as is, because it
2503 usually points to the instruction following the "call", which
2504 is sometimes the first instruction of another function. So
2505 we rely on get_frame_address_in_block(), it provides us with
2506 a PC that is guaranteed to be inside the frame's code
2507 block. */
5796c8dc 2508
c50c785c
JM
2509 TRY_CATCH (ex, RETURN_MASK_ERROR)
2510 {
2511 pc = get_frame_address_in_block (frame);
2512 }
2513 if (ex.reason < 0)
2514 {
2515 if (ex.error != NOT_AVAILABLE_ERROR)
2516 throw_exception (ex);
2517 }
2518 else
2519 {
2520 s = find_pc_symtab (pc);
2521 if (s != NULL)
2522 return s->language;
2523 }
5796c8dc
SS
2524 }
2525
2526 return language_unknown;
2527}
2528\f
2529
2530/* Provide a prototype to silence -Wmissing-prototypes. */
2531void _initialize_stack (void);
2532
2533void
2534_initialize_stack (void)
2535{
5796c8dc
SS
2536 add_com ("return", class_stack, return_command, _("\
2537Make selected stack frame return to its caller.\n\
2538Control remains in the debugger, but when you continue\n\
2539execution will resume in the frame above the one now selected.\n\
2540If an argument is given, it is an expression for the value to return."));
2541
2542 add_com ("up", class_stack, up_command, _("\
2543Select and print stack frame that called this one.\n\
2544An argument says how many frames up to go."));
2545 add_com ("up-silently", class_support, up_silently_command, _("\
2546Same as the `up' command, but does not print anything.\n\
2547This is useful in command scripts."));
2548
2549 add_com ("down", class_stack, down_command, _("\
2550Select and print stack frame called by this one.\n\
2551An argument says how many frames down to go."));
2552 add_com_alias ("do", "down", class_stack, 1);
2553 add_com_alias ("dow", "down", class_stack, 1);
2554 add_com ("down-silently", class_support, down_silently_command, _("\
2555Same as the `down' command, but does not print anything.\n\
2556This is useful in command scripts."));
2557
2558 add_com ("frame", class_stack, frame_command, _("\
c50c785c
JM
2559Select and print a stack frame.\nWith no argument, \
2560print the selected stack frame. (See also \"info frame\").\n\
5796c8dc
SS
2561An argument specifies the frame to select.\n\
2562It can be a stack frame number or the address of the frame.\n\
2563With argument, nothing is printed if input is coming from\n\
2564a command file or a user-defined command."));
2565
2566 add_com_alias ("f", "frame", class_stack, 1);
2567
2568 if (xdb_commands)
2569 {
2570 add_com ("L", class_stack, current_frame_command,
2571 _("Print the current stack frame.\n"));
2572 add_com_alias ("V", "frame", class_stack, 1);
2573 }
2574 add_com ("select-frame", class_stack, select_frame_command, _("\
2575Select a stack frame without printing anything.\n\
2576An argument specifies the frame to select.\n\
2577It can be a stack frame number or the address of the frame.\n"));
2578
2579 add_com ("backtrace", class_stack, backtrace_command, _("\
2580Print backtrace of all stack frames, or innermost COUNT frames.\n\
c50c785c
JM
2581With a negative argument, print outermost -COUNT frames.\nUse of the \
2582'full' qualifier also prints the values of the local variables.\n"));
5796c8dc
SS
2583 add_com_alias ("bt", "backtrace", class_stack, 0);
2584 if (xdb_commands)
2585 {
2586 add_com_alias ("t", "backtrace", class_stack, 0);
2587 add_com ("T", class_stack, backtrace_full_command, _("\
cf7f2e2d 2588Print backtrace of all stack frames, or innermost COUNT frames\n\
5796c8dc
SS
2589and the values of the local variables.\n\
2590With a negative argument, print outermost -COUNT frames.\n\
2591Usage: T <count>\n"));
2592 }
2593
2594 add_com_alias ("where", "backtrace", class_alias, 0);
2595 add_info ("stack", backtrace_command,
2596 _("Backtrace of the stack, or innermost COUNT frames."));
2597 add_info_alias ("s", "stack", 1);
2598 add_info ("frame", frame_info,
2599 _("All about selected stack frame, or frame at ADDR."));
2600 add_info_alias ("f", "frame", 1);
2601 add_info ("locals", locals_info,
2602 _("Local variables of current stack frame."));
2603 add_info ("args", args_info,
2604 _("Argument variables of current stack frame."));
2605 if (xdb_commands)
2606 add_com ("l", class_info, args_plus_locals_info,
2607 _("Argument and local variables of current stack frame."));
2608
2609 if (dbx_commands)
2610 add_com ("func", class_stack, func_command, _("\
2611Select the stack frame that contains <func>.\n\
2612Usage: func <name>\n"));
2613
5796c8dc
SS
2614 add_setshow_enum_cmd ("frame-arguments", class_stack,
2615 print_frame_arguments_choices, &print_frame_arguments,
2616 _("Set printing of non-scalar frame arguments"),
2617 _("Show printing of non-scalar frame arguments"),
2618 NULL, NULL, NULL, &setprintlist, &showprintlist);
2619
2620 add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
2621 &disassemble_next_line, _("\
c50c785c
JM
2622Set whether to disassemble next source line or insn when execution stops."),
2623 _("\
2624Show whether to disassemble next source line or insn when execution stops."),
2625 _("\
5796c8dc
SS
2626If ON, GDB will display disassembly of the next source line, in addition\n\
2627to displaying the source line itself. If the next source line cannot\n\
2628be displayed (e.g., source is unavailable or there's no line info), GDB\n\
2629will display disassembly of next instruction instead of showing the\n\
2630source line.\n\
2631If AUTO, display disassembly of next instruction only if the source line\n\
2632cannot be displayed.\n\
2633If OFF (which is the default), never display the disassembly of the next\n\
2634source line."),
2635 NULL,
2636 show_disassemble_next_line,
2637 &setlist, &showlist);
2638 disassemble_next_line = AUTO_BOOLEAN_FALSE;
a45ae5f8
JM
2639
2640 add_setshow_enum_cmd ("entry-values", class_stack,
2641 print_entry_values_choices, &print_entry_values,
2642 _("Set printing of function arguments at function "
2643 "entry"),
2644 _("Show printing of function arguments at function "
2645 "entry"),
2646 _("\
2647GDB can sometimes determine the values of function arguments at entry,\n\
2648in addition to their current values. This option tells GDB whether\n\
2649to print the current value, the value at entry (marked as val@entry),\n\
2650or both. Note that one or both of these values may be <optimized out>."),
2651 NULL, NULL, &setprintlist, &showprintlist);
5796c8dc 2652}