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