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