bfd_get_filename
[external/binutils.git] / gdb / stack.c
1 /* Print and select stack frames for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2019 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 #include "annotate.h"
51
52 #include "symfile.h"
53 #include "extension.h"
54 #include "observable.h"
55 #include "gdbsupport/def-vector.h"
56 #include "cli/cli-option.h"
57
58 /* The possible choices of "set print frame-arguments", and the value
59    of this setting.  */
60
61 const char print_frame_arguments_all[] = "all";
62 const char print_frame_arguments_scalars[] = "scalars";
63 const char print_frame_arguments_none[] = "none";
64 const char print_frame_arguments_presence[] = "presence";
65
66 static const char *const print_frame_arguments_choices[] =
67 {
68   print_frame_arguments_all,
69   print_frame_arguments_scalars,
70   print_frame_arguments_none,
71   print_frame_arguments_presence,
72   NULL
73 };
74
75 /* The possible choices of "set print frame-info", and the value
76    of this setting.  */
77
78 const char print_frame_info_auto[] = "auto";
79 const char print_frame_info_source_line[] = "source-line";
80 const char print_frame_info_location[] = "location";
81 const char print_frame_info_source_and_location[] = "source-and-location";
82 const char print_frame_info_location_and_address[] = "location-and-address";
83 const char print_frame_info_short_location[] = "short-location";
84
85 static const char *const print_frame_info_choices[] =
86 {
87   print_frame_info_auto,
88   print_frame_info_source_line,
89   print_frame_info_location,
90   print_frame_info_source_and_location,
91   print_frame_info_location_and_address,
92   print_frame_info_short_location,
93   NULL
94 };
95
96 /* print_frame_info_print_what[i] maps a choice to the corresponding
97    print_what enum.  */
98 static const gdb::optional<enum print_what> print_frame_info_print_what[] =
99   {{}, /* Empty value for "auto".  */
100    SRC_LINE, LOCATION, SRC_AND_LOC, LOC_AND_ADDRESS, SHORT_LOCATION};
101
102 /* The possible choices of "set print entry-values", and the value
103    of this setting.  */
104
105 const char print_entry_values_no[] = "no";
106 const char print_entry_values_only[] = "only";
107 const char print_entry_values_preferred[] = "preferred";
108 const char print_entry_values_if_needed[] = "if-needed";
109 const char print_entry_values_both[] = "both";
110 const char print_entry_values_compact[] = "compact";
111 const char print_entry_values_default[] = "default";
112 static const char *const print_entry_values_choices[] =
113 {
114   print_entry_values_no,
115   print_entry_values_only,
116   print_entry_values_preferred,
117   print_entry_values_if_needed,
118   print_entry_values_both,
119   print_entry_values_compact,
120   print_entry_values_default,
121   NULL
122 };
123
124 /* See frame.h.  */
125 frame_print_options user_frame_print_options;
126
127 /* Option definitions for some frame-related "set print ..."
128    settings.  */
129
130 using boolean_option_def
131   = gdb::option::boolean_option_def<frame_print_options>;
132 using enum_option_def
133   = gdb::option::enum_option_def<frame_print_options>;
134
135 static const gdb::option::option_def frame_print_option_defs[] = {
136
137   enum_option_def {
138     "entry-values",
139     print_entry_values_choices,
140     [] (frame_print_options *opt) { return &opt->print_entry_values; },
141     NULL, /* show_cmd_cb */
142     N_("Set printing of function arguments at function entry."),
143     N_("Show printing of function arguments at function entry."),
144     N_("GDB can sometimes determine the values of function arguments at entry,\n\
145 in addition to their current values.  This option tells GDB whether\n\
146 to print the current value, the value at entry (marked as val@entry),\n\
147 or both.  Note that one or both of these values may be <optimized out>."),
148   },
149
150   enum_option_def {
151     "frame-arguments",
152     print_frame_arguments_choices,
153     [] (frame_print_options *opt) { return &opt->print_frame_arguments; },
154     NULL, /* show_cmd_cb */
155     N_("Set printing of non-scalar frame arguments."),
156     N_("Show printing of non-scalar frame arguments."),
157     NULL /* help_doc */
158   },
159
160   boolean_option_def {
161     "raw-frame-arguments",
162     [] (frame_print_options *opt) { return &opt->print_raw_frame_arguments; },
163     NULL, /* show_cmd_cb */
164     N_("Set whether to print frame arguments in raw form."),
165     N_("Show whether to print frame arguments in raw form."),
166     N_("If set, frame arguments are printed in raw form, bypassing any\n\
167 pretty-printers for that value.")
168   },
169
170   enum_option_def {
171     "frame-info",
172     print_frame_info_choices,
173     [] (frame_print_options *opt) { return &opt->print_frame_info; },
174     NULL, /* show_cmd_cb */
175     N_("Set printing of frame information."),
176     N_("Show printing of frame information."),
177     NULL /* help_doc */
178   }
179
180 };
181
182 /* Options for the "backtrace" command.  */
183
184 struct backtrace_cmd_options
185 {
186   int full = 0;
187   int no_filters = 0;
188   int hide = 0;
189 };
190
191 using bt_flag_option_def
192   = gdb::option::flag_option_def<backtrace_cmd_options>;
193
194 static const gdb::option::option_def backtrace_command_option_defs[] = {
195   bt_flag_option_def {
196     "full",
197     [] (backtrace_cmd_options *opt) { return &opt->full; },
198     N_("Print values of local variables.")
199   },
200
201   bt_flag_option_def {
202     "no-filters",
203     [] (backtrace_cmd_options *opt) { return &opt->no_filters; },
204     N_("Prohibit frame filters from executing on a backtrace."),
205   },
206
207   bt_flag_option_def {
208     "hide",
209     [] (backtrace_cmd_options *opt) { return &opt->hide; },
210     N_("Causes Python frame filter elided frames to not be printed."),
211   },
212 };
213
214 /* Prototypes for local functions.  */
215
216 static void print_frame_local_vars (struct frame_info *frame,
217                                     bool quiet,
218                                     const char *regexp, const char *t_regexp,
219                                     int num_tabs, struct ui_file *stream);
220
221 static void print_frame (const frame_print_options &opts,
222                          frame_info *frame, int print_level,
223                          enum print_what print_what,  int print_args,
224                          struct symtab_and_line sal);
225
226 static void set_last_displayed_sal (int valid,
227                                     struct program_space *pspace,
228                                     CORE_ADDR addr,
229                                     struct symtab *symtab,
230                                     int line);
231
232 static struct frame_info *find_frame_for_function (const char *);
233 static struct frame_info *find_frame_for_address (CORE_ADDR);
234
235 /* Zero means do things normally; we are interacting directly with the
236    user.  One means print the full filename and linenumber when a
237    frame is printed, and do so in a format emacs18/emacs19.22 can
238    parse.  Two means print similar annotations, but in many more
239    cases and in a slightly different syntax.  */
240
241 int annotation_level = 0;
242
243 /* These variables hold the last symtab and line we displayed to the user.
244  * This is where we insert a breakpoint or a skiplist entry by default.  */
245 static int last_displayed_sal_valid = 0;
246 static struct program_space *last_displayed_pspace = 0;
247 static CORE_ADDR last_displayed_addr = 0;
248 static struct symtab *last_displayed_symtab = 0;
249 static int last_displayed_line = 0;
250 \f
251
252 /* See stack.h.  */
253
254 int
255 frame_show_address (struct frame_info *frame,
256                     struct symtab_and_line sal)
257 {
258   /* If there is a line number, but no PC, then there is no location
259      information associated with this sal.  The only way that should
260      happen is for the call sites of inlined functions (SAL comes from
261      find_frame_sal).  Otherwise, we would have some PC range if the
262      SAL came from a line table.  */
263   if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
264     {
265       if (get_next_frame (frame) == NULL)
266         gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
267       else
268         gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
269       return 0;
270     }
271
272   return get_frame_pc (frame) != sal.pc;
273 }
274
275 /* See frame.h.  */
276
277 void
278 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
279                             int print_level, enum print_what print_what,
280                             int set_current_sal)
281 {
282   scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
283
284   print_stack_frame (frame, print_level, print_what, set_current_sal);
285 }
286
287 /* Show or print a stack frame FRAME briefly.  The output is formatted
288    according to PRINT_LEVEL and PRINT_WHAT printing the frame's
289    relative level, function name, argument list, and file name and
290    line number.  If the frame's PC is not at the beginning of the
291    source line, the actual PC is printed at the beginning.  */
292
293 void
294 print_stack_frame (struct frame_info *frame, int print_level,
295                    enum print_what print_what,
296                    int set_current_sal)
297 {
298
299   /* For mi, alway print location and address.  */
300   if (current_uiout->is_mi_like_p ())
301     print_what = LOC_AND_ADDRESS;
302
303   try
304     {
305       print_frame_info (user_frame_print_options,
306                         frame, print_level, print_what, 1 /* print_args */,
307                         set_current_sal);
308       if (set_current_sal)
309         set_current_sal_from_frame (frame);
310     }
311   catch (const gdb_exception_error &e)
312     {
313     }
314 }
315
316 /* Print nameless arguments of frame FRAME on STREAM, where START is
317    the offset of the first nameless argument, and NUM is the number of
318    nameless arguments to print.  FIRST is nonzero if this is the first
319    argument (not just the first nameless argument).  */
320
321 static void
322 print_frame_nameless_args (struct frame_info *frame, long start, int num,
323                            int first, struct ui_file *stream)
324 {
325   struct gdbarch *gdbarch = get_frame_arch (frame);
326   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
327   int i;
328   CORE_ADDR argsaddr;
329   long arg_value;
330
331   for (i = 0; i < num; i++)
332     {
333       QUIT;
334       argsaddr = get_frame_args_address (frame);
335       if (!argsaddr)
336         return;
337       arg_value = read_memory_integer (argsaddr + start,
338                                        sizeof (int), byte_order);
339       if (!first)
340         fprintf_filtered (stream, ", ");
341       fprintf_filtered (stream, "%ld", arg_value);
342       first = 0;
343       start += sizeof (int);
344     }
345 }
346
347 /* Print single argument of inferior function.  ARG must be already
348    read in.
349
350    Errors are printed as if they would be the parameter value.  Use zeroed ARG
351    iff it should not be printed accoring to user settings.  */
352
353 static void
354 print_frame_arg (const frame_print_options &fp_opts,
355                  const struct frame_arg *arg)
356 {
357   struct ui_out *uiout = current_uiout;
358
359   string_file stb;
360
361   gdb_assert (!arg->val || !arg->error);
362   gdb_assert (arg->entry_kind == print_entry_values_no
363               || arg->entry_kind == print_entry_values_only
364               || (!uiout->is_mi_like_p ()
365                   && arg->entry_kind == print_entry_values_compact));
366
367   annotate_arg_emitter arg_emitter;
368   ui_out_emit_tuple tuple_emitter (uiout, NULL);
369   fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
370                            SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
371   if (arg->entry_kind == print_entry_values_compact)
372     {
373       /* It is OK to provide invalid MI-like stream as with
374          PRINT_ENTRY_VALUE_COMPACT we never use MI.  */
375       stb.puts ("=");
376
377       fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
378                                SYMBOL_LANGUAGE (arg->sym),
379                                DMGL_PARAMS | DMGL_ANSI);
380     }
381   if (arg->entry_kind == print_entry_values_only
382       || arg->entry_kind == print_entry_values_compact)
383     stb.puts ("@entry");
384   uiout->field_stream ("name", stb, ui_out_style_kind::VARIABLE);
385   annotate_arg_name_end ();
386   uiout->text ("=");
387
388   if (!arg->val && !arg->error)
389     uiout->text ("...");
390   else
391     {
392       if (arg->error)
393         stb.printf (_("<error reading variable: %s>"), arg->error.get ());
394       else
395         {
396           try
397             {
398               const struct language_defn *language;
399               struct value_print_options vp_opts;
400
401               /* Avoid value_print because it will deref ref parameters.  We
402                  just want to print their addresses.  Print ??? for args whose
403                  address we do not know.  We pass 2 as "recurse" to val_print
404                  because our standard indentation here is 4 spaces, and
405                  val_print indents 2 for each recurse.  */ 
406
407               annotate_arg_value (value_type (arg->val));
408
409               /* Use the appropriate language to display our symbol, unless the
410                  user forced the language to a specific language.  */
411               if (language_mode == language_mode_auto)
412                 language = language_def (SYMBOL_LANGUAGE (arg->sym));
413               else
414                 language = current_language;
415
416               get_no_prettyformat_print_options (&vp_opts);
417               vp_opts.deref_ref = 1;
418               vp_opts.raw = fp_opts.print_raw_frame_arguments;
419
420               /* True in "summary" mode, false otherwise.  */
421               vp_opts.summary
422                 = fp_opts.print_frame_arguments == print_frame_arguments_scalars;
423
424               common_val_print (arg->val, &stb, 2, &vp_opts, language);
425             }
426           catch (const gdb_exception_error &except)
427             {
428               stb.printf (_("<error reading variable: %s>"),
429                           except.what ());
430             }
431         }
432     }
433
434   uiout->field_stream ("value", stb);
435 }
436
437 /* Read in inferior function local SYM at FRAME into ARGP.  Caller is
438    responsible for xfree of ARGP->ERROR.  This function never throws an
439    exception.  */
440
441 void
442 read_frame_local (struct symbol *sym, struct frame_info *frame,
443                   struct frame_arg *argp)
444 {
445   argp->sym = sym;
446   argp->val = NULL;
447   argp->error = NULL;
448
449   try
450     {
451       argp->val = read_var_value (sym, NULL, frame);
452     }
453   catch (const gdb_exception_error &except)
454     {
455       argp->error.reset (xstrdup (except.what ()));
456     }
457 }
458
459 /* Read in inferior function parameter SYM at FRAME into ARGP.  This
460    function never throws an exception.  */
461
462 void
463 read_frame_arg (const frame_print_options &fp_opts,
464                 symbol *sym, frame_info *frame,
465                 struct frame_arg *argp, struct frame_arg *entryargp)
466 {
467   struct value *val = NULL, *entryval = NULL;
468   char *val_error = NULL, *entryval_error = NULL;
469   int val_equal = 0;
470
471   if (fp_opts.print_entry_values != print_entry_values_only
472       && fp_opts.print_entry_values != print_entry_values_preferred)
473     {
474       try
475         {
476           val = read_var_value (sym, NULL, frame);
477         }
478       catch (const gdb_exception_error &except)
479         {
480           val_error = (char *) alloca (except.message->size () + 1);
481           strcpy (val_error, except.what ());
482         }
483     }
484
485   if (SYMBOL_COMPUTED_OPS (sym) != NULL
486       && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
487       && fp_opts.print_entry_values != print_entry_values_no
488       && (fp_opts.print_entry_values != print_entry_values_if_needed
489           || !val || value_optimized_out (val)))
490     {
491       try
492         {
493           const struct symbol_computed_ops *ops;
494
495           ops = SYMBOL_COMPUTED_OPS (sym);
496           entryval = ops->read_variable_at_entry (sym, frame);
497         }
498       catch (const gdb_exception_error &except)
499         {
500           if (except.error != NO_ENTRY_VALUE_ERROR)
501             {
502               entryval_error = (char *) alloca (except.message->size () + 1);
503               strcpy (entryval_error, except.what ());
504             }
505         }
506
507       if (entryval != NULL && value_optimized_out (entryval))
508         entryval = NULL;
509
510       if (fp_opts.print_entry_values == print_entry_values_compact
511           || fp_opts.print_entry_values == print_entry_values_default)
512         {
513           /* For MI do not try to use print_entry_values_compact for ARGP.  */
514
515           if (val && entryval && !current_uiout->is_mi_like_p ())
516             {
517               struct type *type = value_type (val);
518
519               if (value_lazy (val))
520                 value_fetch_lazy (val);
521               if (value_lazy (entryval))
522                 value_fetch_lazy (entryval);
523
524               if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
525                 {
526                   /* Initialize it just to avoid a GCC false warning.  */
527                   struct value *val_deref = NULL, *entryval_deref;
528
529                   /* DW_AT_call_value does match with the current
530                      value.  If it is a reference still try to verify if
531                      dereferenced DW_AT_call_data_value does not differ.  */
532
533                   try
534                     {
535                       struct type *type_deref;
536
537                       val_deref = coerce_ref (val);
538                       if (value_lazy (val_deref))
539                         value_fetch_lazy (val_deref);
540                       type_deref = value_type (val_deref);
541
542                       entryval_deref = coerce_ref (entryval);
543                       if (value_lazy (entryval_deref))
544                         value_fetch_lazy (entryval_deref);
545
546                       /* If the reference addresses match but dereferenced
547                          content does not match print them.  */
548                       if (val != val_deref
549                           && value_contents_eq (val_deref, 0,
550                                                 entryval_deref, 0,
551                                                 TYPE_LENGTH (type_deref)))
552                         val_equal = 1;
553                     }
554                   catch (const gdb_exception_error &except)
555                     {
556                       /* If the dereferenced content could not be
557                          fetched do not display anything.  */
558                       if (except.error == NO_ENTRY_VALUE_ERROR)
559                         val_equal = 1;
560                       else if (except.message != NULL)
561                         {
562                           entryval_error
563                             = (char *) alloca (except.message->size () + 1);
564                           strcpy (entryval_error, except.what ());
565                         }
566                     }
567
568                   /* Value was not a reference; and its content matches.  */
569                   if (val == val_deref)
570                     val_equal = 1;
571
572                   if (val_equal)
573                     entryval = NULL;
574                 }
575             }
576
577           /* Try to remove possibly duplicate error message for ENTRYARGP even
578              in MI mode.  */
579
580           if (val_error && entryval_error
581               && strcmp (val_error, entryval_error) == 0)
582             {
583               entryval_error = NULL;
584
585               /* Do not se VAL_EQUAL as the same error message may be shown for
586                  the entry value even if no entry values are present in the
587                  inferior.  */
588             }
589         }
590     }
591
592   if (entryval == NULL)
593     {
594       if (fp_opts.print_entry_values == print_entry_values_preferred)
595         {
596           gdb_assert (val == NULL);
597
598           try
599             {
600               val = read_var_value (sym, NULL, frame);
601             }
602           catch (const gdb_exception_error &except)
603             {
604               val_error = (char *) alloca (except.message->size () + 1);
605               strcpy (val_error, except.what ());
606             }
607         }
608       if (fp_opts.print_entry_values == print_entry_values_only
609           || fp_opts.print_entry_values == print_entry_values_both
610           || (fp_opts.print_entry_values == print_entry_values_preferred
611               && (!val || value_optimized_out (val))))
612         {
613           entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
614           entryval_error = NULL;
615         }
616     }
617   if ((fp_opts.print_entry_values == print_entry_values_compact
618        || fp_opts.print_entry_values == print_entry_values_if_needed
619        || fp_opts.print_entry_values == print_entry_values_preferred)
620       && (!val || value_optimized_out (val)) && entryval != NULL)
621     {
622       val = NULL;
623       val_error = NULL;
624     }
625
626   argp->sym = sym;
627   argp->val = val;
628   argp->error.reset (val_error ? xstrdup (val_error) : NULL);
629   if (!val && !val_error)
630     argp->entry_kind = print_entry_values_only;
631   else if ((fp_opts.print_entry_values == print_entry_values_compact
632            || fp_opts.print_entry_values == print_entry_values_default)
633            && val_equal)
634     {
635       argp->entry_kind = print_entry_values_compact;
636       gdb_assert (!current_uiout->is_mi_like_p ());
637     }
638   else
639     argp->entry_kind = print_entry_values_no;
640
641   entryargp->sym = sym;
642   entryargp->val = entryval;
643   entryargp->error.reset (entryval_error ? xstrdup (entryval_error) : NULL);
644   if (!entryval && !entryval_error)
645     entryargp->entry_kind = print_entry_values_no;
646   else
647     entryargp->entry_kind = print_entry_values_only;
648 }
649
650 /* Print the arguments of frame FRAME on STREAM, given the function
651    FUNC running in that frame (as a symbol), where NUM is the number
652    of arguments according to the stack frame (or -1 if the number of
653    arguments is unknown).  */
654
655 /* Note that currently the "number of arguments according to the
656    stack frame" is only known on VAX where i refers to the "number of
657    ints of arguments according to the stack frame".  */
658
659 static void
660 print_frame_args (const frame_print_options &fp_opts,
661                   struct symbol *func, struct frame_info *frame,
662                   int num, struct ui_file *stream)
663 {
664   struct ui_out *uiout = current_uiout;
665   int first = 1;
666   /* Offset of next stack argument beyond the one we have seen that is
667      at the highest offset, or -1 if we haven't come to a stack
668      argument yet.  */
669   long highest_offset = -1;
670   /* Number of ints of arguments that we have printed so far.  */
671   int args_printed = 0;
672   /* True if we should print arg names.  If false, we only indicate
673      the presence of arguments by printing ellipsis.  */
674   bool print_names
675     = fp_opts.print_frame_arguments != print_frame_arguments_presence;
676   /* True if we should print arguments, false otherwise.  */
677   bool print_args
678     = (print_names
679        && fp_opts.print_frame_arguments != print_frame_arguments_none);
680
681   if (func)
682     {
683       const struct block *b = SYMBOL_BLOCK_VALUE (func);
684       struct block_iterator iter;
685       struct symbol *sym;
686
687       ALL_BLOCK_SYMBOLS (b, iter, sym)
688         {
689           struct frame_arg arg, entryarg;
690
691           QUIT;
692
693           /* Keep track of the highest stack argument offset seen, and
694              skip over any kinds of symbols we don't care about.  */
695
696           if (!SYMBOL_IS_ARGUMENT (sym))
697             continue;
698
699           if (!print_names)
700             {
701               uiout->text ("...");
702               first = 0;
703               break;
704             }
705
706           switch (SYMBOL_CLASS (sym))
707             {
708             case LOC_ARG:
709             case LOC_REF_ARG:
710               {
711                 long current_offset = SYMBOL_VALUE (sym);
712                 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
713
714                 /* Compute address of next argument by adding the size of
715                    this argument and rounding to an int boundary.  */
716                 current_offset =
717                   ((current_offset + arg_size + sizeof (int) - 1)
718                    & ~(sizeof (int) - 1));
719
720                 /* If this is the highest offset seen yet, set
721                    highest_offset.  */
722                 if (highest_offset == -1
723                     || (current_offset > highest_offset))
724                   highest_offset = current_offset;
725
726                 /* Add the number of ints we're about to print to
727                    args_printed.  */
728                 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
729               }
730
731               /* We care about types of symbols, but don't need to
732                  keep track of stack offsets in them.  */
733             case LOC_REGISTER:
734             case LOC_REGPARM_ADDR:
735             case LOC_COMPUTED:
736             case LOC_OPTIMIZED_OUT:
737             default:
738               break;
739             }
740
741           /* We have to look up the symbol because arguments can have
742              two entries (one a parameter, one a local) and the one we
743              want is the local, which lookup_symbol will find for us.
744              This includes gcc1 (not gcc2) on SPARC when passing a
745              small structure and gcc2 when the argument type is float
746              and it is passed as a double and converted to float by
747              the prologue (in the latter case the type of the LOC_ARG
748              symbol is double and the type of the LOC_LOCAL symbol is
749              float).  */
750           /* But if the parameter name is null, don't try it.  Null
751              parameter names occur on the RS/6000, for traceback
752              tables.  FIXME, should we even print them?  */
753
754           if (*SYMBOL_LINKAGE_NAME (sym))
755             {
756               struct symbol *nsym;
757
758               nsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
759                                                 b, VAR_DOMAIN).symbol;
760               gdb_assert (nsym != NULL);
761               if (SYMBOL_CLASS (nsym) == LOC_REGISTER
762                   && !SYMBOL_IS_ARGUMENT (nsym))
763                 {
764                   /* There is a LOC_ARG/LOC_REGISTER pair.  This means
765                      that it was passed on the stack and loaded into a
766                      register, or passed in a register and stored in a
767                      stack slot.  GDB 3.x used the LOC_ARG; GDB
768                      4.0-4.11 used the LOC_REGISTER.
769
770                      Reasons for using the LOC_ARG:
771
772                      (1) Because find_saved_registers may be slow for
773                          remote debugging.
774
775                      (2) Because registers are often re-used and stack
776                          slots rarely (never?) are.  Therefore using
777                          the stack slot is much less likely to print
778                          garbage.
779
780                      Reasons why we might want to use the LOC_REGISTER:
781
782                      (1) So that the backtrace prints the same value
783                          as "print foo".  I see no compelling reason
784                          why this needs to be the case; having the
785                          backtrace print the value which was passed
786                          in, and "print foo" print the value as
787                          modified within the called function, makes
788                          perfect sense to me.
789
790                      Additional note: It might be nice if "info args"
791                      displayed both values.
792
793                      One more note: There is a case with SPARC
794                      structure passing where we need to use the
795                      LOC_REGISTER, but this is dealt with by creating
796                      a single LOC_REGPARM in symbol reading.  */
797
798                   /* Leave sym (the LOC_ARG) alone.  */
799                   ;
800                 }
801               else
802                 sym = nsym;
803             }
804
805           /* Print the current arg.  */
806           if (!first)
807             uiout->text (", ");
808           uiout->wrap_hint ("    ");
809
810           if (!print_args)
811             {
812               arg.sym = sym;
813               arg.entry_kind = print_entry_values_no;
814               entryarg.sym = sym;
815               entryarg.entry_kind = print_entry_values_no;
816             }
817           else
818             read_frame_arg (fp_opts, sym, frame, &arg, &entryarg);
819
820           if (arg.entry_kind != print_entry_values_only)
821             print_frame_arg (fp_opts, &arg);
822
823           if (entryarg.entry_kind != print_entry_values_no)
824             {
825               if (arg.entry_kind != print_entry_values_only)
826                 {
827                   uiout->text (", ");
828                   uiout->wrap_hint ("    ");
829                 }
830
831               print_frame_arg (fp_opts, &entryarg);
832             }
833
834           first = 0;
835         }
836     }
837
838   /* Don't print nameless args in situations where we don't know
839      enough about the stack to find them.  */
840   if (num != -1)
841     {
842       long start;
843
844       if (highest_offset == -1)
845         start = gdbarch_frame_args_skip (get_frame_arch (frame));
846       else
847         start = highest_offset;
848
849       if (!print_names && !first && num > 0)
850         uiout->text ("...");
851       else
852         print_frame_nameless_args (frame, start, num - args_printed,
853                                    first, stream);
854     }
855 }
856
857 /* Set the current source and line to the location given by frame
858    FRAME, if possible.  When CENTER is true, adjust so the relevant
859    line is in the center of the next 'list'.  */
860
861 void
862 set_current_sal_from_frame (struct frame_info *frame)
863 {
864   symtab_and_line sal = find_frame_sal (frame);
865   if (sal.symtab != NULL)
866     set_current_source_symtab_and_line (sal);
867 }
868
869 /* If ON, GDB will display disassembly of the next source line when
870    execution of the program being debugged stops.
871    If AUTO (which is the default), or there's no line info to determine
872    the source line of the next instruction, display disassembly of next
873    instruction instead.  */
874
875 static enum auto_boolean disassemble_next_line;
876
877 static void
878 show_disassemble_next_line (struct ui_file *file, int from_tty,
879                                  struct cmd_list_element *c,
880                                  const char *value)
881 {
882   fprintf_filtered (file,
883                     _("Debugger's willingness to use "
884                       "disassemble-next-line is %s.\n"),
885                     value);
886 }
887
888 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
889    because it will be broken by filter sometime.  */
890
891 static void
892 do_gdb_disassembly (struct gdbarch *gdbarch,
893                     int how_many, CORE_ADDR low, CORE_ADDR high)
894 {
895
896   try
897     {
898       gdb_disassembly (gdbarch, current_uiout,
899                        DISASSEMBLY_RAW_INSN, how_many,
900                        low, high);
901     }
902   catch (const gdb_exception_error &exception)
903     {
904       /* If an exception was thrown while doing the disassembly, print
905          the error message, to give the user a clue of what happened.  */
906       exception_print (gdb_stderr, exception);
907     }
908 }
909
910 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
911    Value not present indicates to the caller to use default values
912    specific to the command being executed.  */
913
914 static gdb::optional<enum print_what>
915 print_frame_info_to_print_what (const char *print_frame_info)
916 {
917   for (int i = 0; print_frame_info_choices[i] != NULL; i++)
918     if (print_frame_info == print_frame_info_choices[i])
919       return print_frame_info_print_what[i];
920
921   internal_error (__FILE__, __LINE__,
922                   "Unexpected print frame-info value `%s'.",
923                   print_frame_info);
924 }
925
926 /* Print the PC from FRAME, plus any flags, to UIOUT.  */
927
928 static void
929 print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info *frame,
930           CORE_ADDR pc)
931 {
932   uiout->field_core_addr ("addr", gdbarch, pc);
933
934   std::string flags = gdbarch_get_pc_address_flags (gdbarch, frame, pc);
935   if (!flags.empty ())
936   {
937     uiout->text (" [");
938     uiout->field_string ("addr_flags", flags);
939     uiout->text ("]");
940   }
941 }
942
943 /* See stack.h.  */
944
945 void
946 get_user_print_what_frame_info (gdb::optional<enum print_what> *what)
947 {
948   *what
949     = print_frame_info_to_print_what
950         (user_frame_print_options.print_frame_info);
951 }
952
953 /* Print information about frame FRAME.  The output is format according
954    to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS.  For the meaning of
955    PRINT_WHAT, see enum print_what comments in frame.h.
956    Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info
957    != print_frame_info_auto.
958
959    Used in "where" output, and to emit breakpoint or step
960    messages.  */
961
962 void
963 print_frame_info (const frame_print_options &fp_opts,
964                   frame_info *frame, int print_level,
965                   enum print_what print_what, int print_args,
966                   int set_current_sal)
967 {
968   struct gdbarch *gdbarch = get_frame_arch (frame);
969   int source_print;
970   int location_print;
971   struct ui_out *uiout = current_uiout;
972
973   if (!current_uiout->is_mi_like_p ()
974       && fp_opts.print_frame_info != print_frame_info_auto)
975     {
976       /* Use the specific frame information desired by the user.  */
977       print_what = *print_frame_info_to_print_what (fp_opts.print_frame_info);
978     }
979
980   if (get_frame_type (frame) == DUMMY_FRAME
981       || get_frame_type (frame) == SIGTRAMP_FRAME
982       || get_frame_type (frame) == ARCH_FRAME)
983     {
984       ui_out_emit_tuple tuple_emitter (uiout, "frame");
985
986       annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
987                             gdbarch, get_frame_pc (frame));
988
989       /* Do this regardless of SOURCE because we don't have any source
990          to list for this frame.  */
991       if (print_level)
992         {
993           uiout->text ("#");
994           uiout->field_fmt_signed (2, ui_left, "level",
995                                    frame_relative_level (frame));
996         }
997       if (uiout->is_mi_like_p ())
998         {
999           annotate_frame_address ();
1000           print_pc (uiout, gdbarch, frame, get_frame_pc (frame));
1001           annotate_frame_address_end ();
1002         }
1003
1004       if (get_frame_type (frame) == DUMMY_FRAME)
1005         {
1006           annotate_function_call ();
1007           uiout->field_string ("func", "<function called from gdb>",
1008                                ui_out_style_kind::FUNCTION);
1009         }
1010       else if (get_frame_type (frame) == SIGTRAMP_FRAME)
1011         {
1012           annotate_signal_handler_caller ();
1013           uiout->field_string ("func", "<signal handler called>",
1014                                ui_out_style_kind::FUNCTION);
1015         }
1016       else if (get_frame_type (frame) == ARCH_FRAME)
1017         {
1018           uiout->field_string ("func", "<cross-architecture call>",
1019                                ui_out_style_kind::FUNCTION);
1020         }
1021       uiout->text ("\n");
1022       annotate_frame_end ();
1023
1024       /* If disassemble-next-line is set to auto or on output the next
1025          instruction.  */
1026       if (disassemble_next_line == AUTO_BOOLEAN_AUTO
1027           || disassemble_next_line == AUTO_BOOLEAN_TRUE)
1028         do_gdb_disassembly (get_frame_arch (frame), 1,
1029                             get_frame_pc (frame), get_frame_pc (frame) + 1);
1030
1031       return;
1032     }
1033
1034   /* If FRAME is not the innermost frame, that normally means that
1035      FRAME->pc points to *after* the call instruction, and we want to
1036      get the line containing the call, never the next line.  But if
1037      the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1038      next frame was not entered as the result of a call, and we want
1039      to get the line containing FRAME->pc.  */
1040   symtab_and_line sal = find_frame_sal (frame);
1041
1042   location_print = (print_what == LOCATION
1043                     || print_what == SRC_AND_LOC
1044                     || print_what == LOC_AND_ADDRESS
1045                     || print_what == SHORT_LOCATION);
1046   if (location_print || !sal.symtab)
1047     print_frame (fp_opts, frame, print_level, print_what, print_args, sal);
1048
1049   source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
1050
1051   /* If disassemble-next-line is set to auto or on and doesn't have
1052      the line debug messages for $pc, output the next instruction.  */
1053   if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
1054        || disassemble_next_line == AUTO_BOOLEAN_TRUE)
1055       && source_print && !sal.symtab)
1056     do_gdb_disassembly (get_frame_arch (frame), 1,
1057                         get_frame_pc (frame), get_frame_pc (frame) + 1);
1058
1059   if (source_print && sal.symtab)
1060     {
1061       int mid_statement = ((print_what == SRC_LINE)
1062                            && frame_show_address (frame, sal));
1063       annotate_source_line (sal.symtab, sal.line, mid_statement,
1064                             get_frame_pc (frame));
1065
1066       if (deprecated_print_frame_info_listing_hook)
1067         deprecated_print_frame_info_listing_hook (sal.symtab, sal.line,
1068                                                   sal.line + 1, 0);
1069       else
1070         {
1071           struct value_print_options opts;
1072
1073           get_user_print_options (&opts);
1074           /* We used to do this earlier, but that is clearly
1075              wrong.  This function is used by many different
1076              parts of gdb, including normal_stop in infrun.c,
1077              which uses this to print out the current PC
1078              when we stepi/nexti into the middle of a source
1079              line.  Only the command line really wants this
1080              behavior.  Other UIs probably would like the
1081              ability to decide for themselves if it is desired.  */
1082           if (opts.addressprint && mid_statement)
1083             {
1084               print_pc (uiout, gdbarch, frame, get_frame_pc (frame));
1085               uiout->text ("\t");
1086             }
1087
1088           print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1089         }
1090     }
1091
1092   /* If disassemble-next-line is set to on and there is line debug
1093      messages, output assembly codes for next line.  */
1094   if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
1095     do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
1096
1097   if (set_current_sal)
1098     {
1099       CORE_ADDR pc;
1100
1101       if (get_frame_pc_if_available (frame, &pc))
1102         set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
1103       else
1104         set_last_displayed_sal (0, 0, 0, 0, 0);
1105     }
1106
1107   annotate_frame_end ();
1108
1109   gdb_flush (gdb_stdout);
1110 }
1111
1112 /* Remember the last symtab and line we displayed, which we use e.g.
1113  * as the place to put a breakpoint when the `break' command is
1114  * invoked with no arguments.  */
1115
1116 static void
1117 set_last_displayed_sal (int valid, struct program_space *pspace,
1118                         CORE_ADDR addr, struct symtab *symtab,
1119                         int line)
1120 {
1121   last_displayed_sal_valid = valid;
1122   last_displayed_pspace = pspace;
1123   last_displayed_addr = addr;
1124   last_displayed_symtab = symtab;
1125   last_displayed_line = line;
1126   if (valid && pspace == NULL)
1127     {
1128       clear_last_displayed_sal ();
1129       internal_error (__FILE__, __LINE__,
1130                       _("Trying to set NULL pspace."));
1131     }
1132 }
1133
1134 /* Forget the last sal we displayed.  */
1135
1136 void
1137 clear_last_displayed_sal (void)
1138 {
1139   last_displayed_sal_valid = 0;
1140   last_displayed_pspace = 0;
1141   last_displayed_addr = 0;
1142   last_displayed_symtab = 0;
1143   last_displayed_line = 0;
1144 }
1145
1146 /* Is our record of the last sal we displayed valid?  If not,
1147  * the get_last_displayed_* functions will return NULL or 0, as
1148  * appropriate.  */
1149
1150 int
1151 last_displayed_sal_is_valid (void)
1152 {
1153   return last_displayed_sal_valid;
1154 }
1155
1156 /* Get the pspace of the last sal we displayed, if it's valid.  */
1157
1158 struct program_space *
1159 get_last_displayed_pspace (void)
1160 {
1161   if (last_displayed_sal_valid)
1162     return last_displayed_pspace;
1163   return 0;
1164 }
1165
1166 /* Get the address of the last sal we displayed, if it's valid.  */
1167
1168 CORE_ADDR
1169 get_last_displayed_addr (void)
1170 {
1171   if (last_displayed_sal_valid)
1172     return last_displayed_addr;
1173   return 0;
1174 }
1175
1176 /* Get the symtab of the last sal we displayed, if it's valid.  */
1177
1178 struct symtab*
1179 get_last_displayed_symtab (void)
1180 {
1181   if (last_displayed_sal_valid)
1182     return last_displayed_symtab;
1183   return 0;
1184 }
1185
1186 /* Get the line of the last sal we displayed, if it's valid.  */
1187
1188 int
1189 get_last_displayed_line (void)
1190 {
1191   if (last_displayed_sal_valid)
1192     return last_displayed_line;
1193   return 0;
1194 }
1195
1196 /* Get the last sal we displayed, if it's valid.  */
1197
1198 symtab_and_line
1199 get_last_displayed_sal ()
1200 {
1201   symtab_and_line sal;
1202
1203   if (last_displayed_sal_valid)
1204     {
1205       sal.pspace = last_displayed_pspace;
1206       sal.pc = last_displayed_addr;
1207       sal.symtab = last_displayed_symtab;
1208       sal.line = last_displayed_line;
1209     }
1210
1211   return sal;
1212 }
1213
1214
1215 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1216    corresponding to FRAME.  */
1217
1218 gdb::unique_xmalloc_ptr<char>
1219 find_frame_funname (struct frame_info *frame, enum language *funlang,
1220                     struct symbol **funcp)
1221 {
1222   struct symbol *func;
1223   gdb::unique_xmalloc_ptr<char> funname;
1224
1225   *funlang = language_unknown;
1226   if (funcp)
1227     *funcp = NULL;
1228
1229   func = get_frame_function (frame);
1230   if (func)
1231     {
1232       const char *print_name = SYMBOL_PRINT_NAME (func);
1233
1234       *funlang = SYMBOL_LANGUAGE (func);
1235       if (funcp)
1236         *funcp = func;
1237       if (*funlang == language_cplus)
1238         {
1239           /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1240              to display the demangled name that we already have
1241              stored in the symbol table, but we stored a version
1242              with DMGL_PARAMS turned on, and here we don't want to
1243              display parameters.  So remove the parameters.  */
1244           funname = cp_remove_params (print_name);
1245         }
1246
1247       /* If we didn't hit the C++ case above, set *funname
1248          here.  */
1249       if (funname == NULL)
1250         funname.reset (xstrdup (print_name));
1251     }
1252   else
1253     {
1254       struct bound_minimal_symbol msymbol;
1255       CORE_ADDR pc;
1256
1257       if (!get_frame_address_in_block_if_available (frame, &pc))
1258         return funname;
1259
1260       msymbol = lookup_minimal_symbol_by_pc (pc);
1261       if (msymbol.minsym != NULL)
1262         {
1263           funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
1264           *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1265         }
1266     }
1267
1268   return funname;
1269 }
1270
1271 static void
1272 print_frame (const frame_print_options &fp_opts,
1273              frame_info *frame, int print_level,
1274              enum print_what print_what, int print_args,
1275              struct symtab_and_line sal)
1276 {
1277   struct gdbarch *gdbarch = get_frame_arch (frame);
1278   struct ui_out *uiout = current_uiout;
1279   enum language funlang = language_unknown;
1280   struct value_print_options opts;
1281   struct symbol *func;
1282   CORE_ADDR pc = 0;
1283   int pc_p;
1284
1285   pc_p = get_frame_pc_if_available (frame, &pc);
1286
1287   gdb::unique_xmalloc_ptr<char> funname
1288     = find_frame_funname (frame, &funlang, &func);
1289
1290   annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1291                         gdbarch, pc);
1292
1293   {
1294     ui_out_emit_tuple tuple_emitter (uiout, "frame");
1295
1296     if (print_level)
1297       {
1298         uiout->text ("#");
1299         uiout->field_fmt_signed (2, ui_left, "level",
1300                                  frame_relative_level (frame));
1301       }
1302     get_user_print_options (&opts);
1303     if (opts.addressprint)
1304       if (!sal.symtab
1305           || frame_show_address (frame, sal)
1306           || print_what == LOC_AND_ADDRESS)
1307         {
1308           annotate_frame_address ();
1309           if (pc_p)
1310             print_pc (uiout, gdbarch, frame, pc);
1311           else
1312             uiout->field_string ("addr", "<unavailable>",
1313                                  ui_out_style_kind::ADDRESS);
1314           annotate_frame_address_end ();
1315           uiout->text (" in ");
1316         }
1317     annotate_frame_function_name ();
1318
1319     string_file stb;
1320     fprintf_symbol_filtered (&stb, funname ? funname.get () : "??",
1321                              funlang, DMGL_ANSI);
1322     uiout->field_stream ("func", stb, ui_out_style_kind::FUNCTION);
1323     uiout->wrap_hint ("   ");
1324     annotate_frame_args ();
1325
1326     uiout->text (" (");
1327     if (print_args)
1328       {
1329         int numargs;
1330
1331         if (gdbarch_frame_num_args_p (gdbarch))
1332           {
1333             numargs = gdbarch_frame_num_args (gdbarch, frame);
1334             gdb_assert (numargs >= 0);
1335           }
1336         else
1337           numargs = -1;
1338     
1339         {
1340           ui_out_emit_list list_emitter (uiout, "args");
1341           try
1342             {
1343               print_frame_args (fp_opts, func, frame, numargs, gdb_stdout);
1344             }
1345           catch (const gdb_exception_error &e)
1346             {
1347             }
1348
1349             /* FIXME: ARGS must be a list.  If one argument is a string it
1350                will have " that will not be properly escaped.  */
1351             }
1352         QUIT;
1353       }
1354     uiout->text (")");
1355     if (print_what != SHORT_LOCATION && sal.symtab)
1356       {
1357         const char *filename_display;
1358       
1359         filename_display = symtab_to_filename_for_display (sal.symtab);
1360         annotate_frame_source_begin ();
1361         uiout->wrap_hint ("   ");
1362         uiout->text (" at ");
1363         annotate_frame_source_file ();
1364         uiout->field_string ("file", filename_display, ui_out_style_kind::FILE);
1365         if (uiout->is_mi_like_p ())
1366           {
1367             const char *fullname = symtab_to_fullname (sal.symtab);
1368
1369             uiout->field_string ("fullname", fullname);
1370           }
1371         annotate_frame_source_file_end ();
1372         uiout->text (":");
1373         annotate_frame_source_line ();
1374         uiout->field_signed ("line", sal.line);
1375         annotate_frame_source_end ();
1376       }
1377
1378     if (print_what != SHORT_LOCATION
1379         && pc_p && (funname == NULL || sal.symtab == NULL))
1380       {
1381         char *lib = solib_name_from_address (get_frame_program_space (frame),
1382                                              get_frame_pc (frame));
1383
1384         if (lib)
1385           {
1386             annotate_frame_where ();
1387             uiout->wrap_hint ("  ");
1388             uiout->text (" from ");
1389             uiout->field_string ("from", lib);
1390           }
1391       }
1392     if (uiout->is_mi_like_p ())
1393       uiout->field_string ("arch",
1394                            (gdbarch_bfd_arch_info (gdbarch))->printable_name);
1395   }
1396
1397   uiout->text ("\n");
1398 }
1399 \f
1400
1401 /* Completion function for "frame function", "info frame function", and
1402    "select-frame function" commands.  */
1403
1404 void
1405 frame_selection_by_function_completer (struct cmd_list_element *ignore,
1406                                        completion_tracker &tracker,
1407                                        const char *text, const char *word)
1408 {
1409   /* This is used to complete function names within a stack.  It would be
1410      nice if we only offered functions that were actually in the stack.
1411      However, this would mean unwinding the stack to completion, which
1412      could take too long, or on a corrupted stack, possibly not end.
1413      Instead, we offer all symbol names as a safer choice.  */
1414   collect_symbol_completion_matches (tracker,
1415                                      complete_symbol_mode::EXPRESSION,
1416                                      symbol_name_match_type::EXPRESSION,
1417                                      text, word);
1418 }
1419
1420 /* Core of all the "info frame" sub-commands.  Print information about a
1421    frame FI.  If SELECTED_FRAME_P is true then the user didn't provide a
1422    frame specification, they just entered 'info frame'.  If the user did
1423    provide a frame specification (for example 'info frame 0', 'info frame
1424    level 1') then SELECTED_FRAME_P will be false.  */
1425
1426 static void
1427 info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
1428 {
1429   struct symbol *func;
1430   struct symtab *s;
1431   struct frame_info *calling_frame_info;
1432   int numregs;
1433   const char *funname = 0;
1434   enum language funlang = language_unknown;
1435   const char *pc_regname;
1436   struct gdbarch *gdbarch;
1437   CORE_ADDR frame_pc;
1438   int frame_pc_p;
1439   /* Initialize it to avoid "may be used uninitialized" warning.  */
1440   CORE_ADDR caller_pc = 0;
1441   int caller_pc_p = 0;
1442
1443   gdbarch = get_frame_arch (fi);
1444
1445   /* Name of the value returned by get_frame_pc().  Per comments, "pc"
1446      is not a good name.  */
1447   if (gdbarch_pc_regnum (gdbarch) >= 0)
1448     /* OK, this is weird.  The gdbarch_pc_regnum hardware register's value can
1449        easily not match that of the internal value returned by
1450        get_frame_pc().  */
1451     pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1452   else
1453     /* But then, this is weird to.  Even without gdbarch_pc_regnum, an
1454        architectures will often have a hardware register called "pc",
1455        and that register's value, again, can easily not match
1456        get_frame_pc().  */
1457     pc_regname = "pc";
1458
1459   frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1460   func = get_frame_function (fi);
1461   symtab_and_line sal = find_frame_sal (fi);
1462   s = sal.symtab;
1463   gdb::unique_xmalloc_ptr<char> func_only;
1464   if (func)
1465     {
1466       funname = SYMBOL_PRINT_NAME (func);
1467       funlang = SYMBOL_LANGUAGE (func);
1468       if (funlang == language_cplus)
1469         {
1470           /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
1471              to display the demangled name that we already have
1472              stored in the symbol table, but we stored a version
1473              with DMGL_PARAMS turned on, and here we don't want to
1474              display parameters.  So remove the parameters.  */
1475           func_only = cp_remove_params (funname);
1476
1477           if (func_only)
1478             funname = func_only.get ();
1479         }
1480     }
1481   else if (frame_pc_p)
1482     {
1483       struct bound_minimal_symbol msymbol;
1484
1485       msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1486       if (msymbol.minsym != NULL)
1487         {
1488           funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
1489           funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
1490         }
1491     }
1492   calling_frame_info = get_prev_frame (fi);
1493
1494   if (selected_frame_p && frame_relative_level (fi) >= 0)
1495     {
1496       printf_filtered (_("Stack level %d, frame at "),
1497                        frame_relative_level (fi));
1498     }
1499   else
1500     {
1501       printf_filtered (_("Stack frame at "));
1502     }
1503   fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
1504   printf_filtered (":\n");
1505   printf_filtered (" %s = ", pc_regname);
1506   if (frame_pc_p)
1507     fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
1508   else
1509     fputs_filtered ("<unavailable>", gdb_stdout);
1510
1511   wrap_here ("   ");
1512   if (funname)
1513     {
1514       printf_filtered (" in ");
1515       fprintf_symbol_filtered (gdb_stdout, funname, funlang,
1516                                DMGL_ANSI | DMGL_PARAMS);
1517     }
1518   wrap_here ("   ");
1519   if (sal.symtab)
1520     printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
1521                      sal.line);
1522   puts_filtered ("; ");
1523   wrap_here ("    ");
1524   printf_filtered ("saved %s = ", pc_regname);
1525
1526   if (!frame_id_p (frame_unwind_caller_id (fi)))
1527     val_print_not_saved (gdb_stdout);
1528   else
1529     {
1530       try
1531         {
1532           caller_pc = frame_unwind_caller_pc (fi);
1533           caller_pc_p = 1;
1534         }
1535       catch (const gdb_exception_error &ex)
1536         {
1537           switch (ex.error)
1538             {
1539             case NOT_AVAILABLE_ERROR:
1540               val_print_unavailable (gdb_stdout);
1541               break;
1542             case OPTIMIZED_OUT_ERROR:
1543               val_print_not_saved (gdb_stdout);
1544               break;
1545             default:
1546               fprintf_filtered (gdb_stdout, _("<error: %s>"),
1547                                 ex.what ());
1548               break;
1549             }
1550         }
1551     }
1552
1553   if (caller_pc_p)
1554     fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
1555   printf_filtered ("\n");
1556
1557   if (calling_frame_info == NULL)
1558     {
1559       enum unwind_stop_reason reason;
1560
1561       reason = get_frame_unwind_stop_reason (fi);
1562       if (reason != UNWIND_NO_REASON)
1563         printf_filtered (_(" Outermost frame: %s\n"),
1564                          frame_stop_reason_string (fi));
1565     }
1566   else if (get_frame_type (fi) == TAILCALL_FRAME)
1567     puts_filtered (" tail call frame");
1568   else if (get_frame_type (fi) == INLINE_FRAME)
1569     printf_filtered (" inlined into frame %d",
1570                      frame_relative_level (get_prev_frame (fi)));
1571   else
1572     {
1573       printf_filtered (" called by frame at ");
1574       fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
1575                       gdb_stdout);
1576     }
1577   if (get_next_frame (fi) && calling_frame_info)
1578     puts_filtered (",");
1579   wrap_here ("   ");
1580   if (get_next_frame (fi))
1581     {
1582       printf_filtered (" caller of frame at ");
1583       fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
1584                       gdb_stdout);
1585     }
1586   if (get_next_frame (fi) || calling_frame_info)
1587     puts_filtered ("\n");
1588
1589   if (s)
1590     printf_filtered (" source language %s.\n",
1591                      language_str (s->language));
1592
1593   {
1594     /* Address of the argument list for this frame, or 0.  */
1595     CORE_ADDR arg_list = get_frame_args_address (fi);
1596     /* Number of args for this frame, or -1 if unknown.  */
1597     int numargs;
1598
1599     if (arg_list == 0)
1600       printf_filtered (" Arglist at unknown address.\n");
1601     else
1602       {
1603         printf_filtered (" Arglist at ");
1604         fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1605         printf_filtered (",");
1606
1607         if (!gdbarch_frame_num_args_p (gdbarch))
1608           {
1609             numargs = -1;
1610             puts_filtered (" args: ");
1611           }
1612         else
1613           {
1614             numargs = gdbarch_frame_num_args (gdbarch, fi);
1615             gdb_assert (numargs >= 0);
1616             if (numargs == 0)
1617               puts_filtered (" no args.");
1618             else if (numargs == 1)
1619               puts_filtered (" 1 arg: ");
1620             else
1621               printf_filtered (" %d args: ", numargs);
1622           }
1623         print_frame_args (user_frame_print_options,
1624                           func, fi, numargs, gdb_stdout);
1625         puts_filtered ("\n");
1626       }
1627   }
1628   {
1629     /* Address of the local variables for this frame, or 0.  */
1630     CORE_ADDR arg_list = get_frame_locals_address (fi);
1631
1632     if (arg_list == 0)
1633       printf_filtered (" Locals at unknown address,");
1634     else
1635       {
1636         printf_filtered (" Locals at ");
1637         fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
1638         printf_filtered (",");
1639       }
1640   }
1641
1642   /* Print as much information as possible on the location of all the
1643      registers.  */
1644   {
1645     int count;
1646     int i;
1647     int need_nl = 1;
1648     int sp_regnum = gdbarch_sp_regnum (gdbarch);
1649
1650     /* The sp is special; what's displayed isn't the save address, but
1651        the value of the previous frame's sp.  This is a legacy thing,
1652        at one stage the frame cached the previous frame's SP instead
1653        of its address, hence it was easiest to just display the cached
1654        value.  */
1655     if (sp_regnum >= 0)
1656       {
1657         struct value *value = frame_unwind_register_value (fi, sp_regnum);
1658         gdb_assert (value != NULL);
1659
1660         if (!value_optimized_out (value) && value_entirely_available (value))
1661           {
1662             if (VALUE_LVAL (value) == not_lval)
1663               {
1664                 CORE_ADDR sp;
1665                 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1666                 int sp_size = register_size (gdbarch, sp_regnum);
1667
1668                 sp = extract_unsigned_integer (value_contents_all (value),
1669                                                sp_size, byte_order);
1670
1671                 printf_filtered (" Previous frame's sp is ");
1672                 fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
1673                 printf_filtered ("\n");
1674               }
1675             else if (VALUE_LVAL (value) == lval_memory)
1676               {
1677                 printf_filtered (" Previous frame's sp at ");
1678                 fputs_filtered (paddress (gdbarch, value_address (value)),
1679                                 gdb_stdout);
1680                 printf_filtered ("\n");
1681               }
1682             else if (VALUE_LVAL (value) == lval_register)
1683               {
1684                 printf_filtered (" Previous frame's sp in %s\n",
1685                                  gdbarch_register_name (gdbarch,
1686                                                         VALUE_REGNUM (value)));
1687               }
1688
1689             release_value (value);
1690             need_nl = 0;
1691           }
1692         /* else keep quiet.  */
1693       }
1694
1695     count = 0;
1696     numregs = gdbarch_num_cooked_regs (gdbarch);
1697     for (i = 0; i < numregs; i++)
1698       if (i != sp_regnum
1699           && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1700         {
1701           enum lval_type lval;
1702           int optimized;
1703           int unavailable;
1704           CORE_ADDR addr;
1705           int realnum;
1706
1707           /* Find out the location of the saved register without
1708              fetching the corresponding value.  */
1709           frame_register_unwind (fi, i, &optimized, &unavailable,
1710                                  &lval, &addr, &realnum, NULL);
1711           /* For moment, only display registers that were saved on the
1712              stack.  */
1713           if (!optimized && !unavailable && lval == lval_memory)
1714             {
1715               if (count == 0)
1716                 puts_filtered (" Saved registers:\n ");
1717               else
1718                 puts_filtered (",");
1719               wrap_here (" ");
1720               printf_filtered (" %s at ",
1721                                gdbarch_register_name (gdbarch, i));
1722               fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
1723               count++;
1724             }
1725         }
1726     if (count || need_nl)
1727       puts_filtered ("\n");
1728   }
1729 }
1730
1731 /* Return the innermost frame at level LEVEL.  */
1732
1733 static struct frame_info *
1734 leading_innermost_frame (int level)
1735 {
1736   struct frame_info *leading;
1737
1738   leading = get_current_frame ();
1739
1740   gdb_assert (level >= 0);
1741
1742   while (leading != nullptr && level)
1743     {
1744       QUIT;
1745       leading = get_prev_frame (leading);
1746       level--;
1747     }
1748
1749   return leading;
1750 }
1751
1752 /* Return the starting frame needed to handle COUNT outermost frames.  */
1753
1754 static struct frame_info *
1755 trailing_outermost_frame (int count)
1756 {
1757   struct frame_info *current;
1758   struct frame_info *trailing;
1759
1760   trailing = get_current_frame ();
1761
1762   gdb_assert (count > 0);
1763
1764   current = trailing;
1765   while (current != nullptr && count--)
1766     {
1767       QUIT;
1768       current = get_prev_frame (current);
1769     }
1770
1771   /* Will stop when CURRENT reaches the top of the stack.
1772      TRAILING will be COUNT below it.  */
1773   while (current != nullptr)
1774     {
1775       QUIT;
1776       trailing = get_prev_frame (trailing);
1777       current = get_prev_frame (current);
1778     }
1779
1780   return trailing;
1781 }
1782
1783 /* The core of all the "select-frame" sub-commands.  Just wraps a call to
1784    SELECT_FRAME.  */
1785
1786 static void
1787 select_frame_command_core (struct frame_info *fi, bool ignored)
1788 {
1789   struct frame_info *prev_frame = get_selected_frame_if_set ();
1790   select_frame (fi);
1791   if (get_selected_frame_if_set () != prev_frame)
1792     gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1793 }
1794
1795 /* See stack.h.  */
1796
1797 void
1798 select_frame_for_mi (struct frame_info *fi)
1799 {
1800   select_frame_command_core (fi, false /* Ignored.  */);
1801 }
1802
1803 /* The core of all the "frame" sub-commands.  Select frame FI, and if this
1804    means we change frame send out a change notification (otherwise, just
1805    reprint the current frame summary).   */
1806
1807 static void
1808 frame_command_core (struct frame_info *fi, bool ignored)
1809 {
1810   struct frame_info *prev_frame = get_selected_frame_if_set ();
1811
1812   select_frame (fi);
1813   if (get_selected_frame_if_set () != prev_frame)
1814     gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1815   else
1816     print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
1817 }
1818
1819 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1820    common set of sub-commands that allow a specific frame to be selected.
1821    All of the sub-command functions are static methods within this class
1822    template which is then instantiated below.  The template parameter is a
1823    callback used to implement the functionality of the base command
1824    ('frame', 'select-frame', or 'info frame').
1825
1826    In the template parameter FI is the frame being selected.  The
1827    SELECTED_FRAME_P flag is true if the frame being selected was done by
1828    default, which happens when the user uses the base command with no
1829    arguments.  For example the commands 'info frame', 'select-frame',
1830    'frame' will all cause SELECTED_FRAME_P to be true.  In all other cases
1831    SELECTED_FRAME_P is false.  */
1832
1833 template <void (*FPTR) (struct frame_info *fi, bool selected_frame_p)>
1834 class frame_command_helper
1835 {
1836 public:
1837
1838   /* The "frame level" family of commands.  The ARG is an integer that is
1839      the frame's level in the stack.  */
1840   static void
1841   level (const char *arg, int from_tty)
1842   {
1843     int level = value_as_long (parse_and_eval (arg));
1844     struct frame_info *fid
1845       = find_relative_frame (get_current_frame (), &level);
1846     if (level != 0)
1847       error (_("No frame at level %s."), arg);
1848     FPTR (fid, false);
1849   }
1850
1851   /* The "frame address" family of commands.  ARG is a stack-pointer
1852      address for an existing frame.  This command does not allow new
1853      frames to be created.  */
1854
1855   static void
1856   address (const char *arg, int from_tty)
1857   {
1858     CORE_ADDR addr = value_as_address (parse_and_eval (arg));
1859     struct frame_info *fid = find_frame_for_address (addr);
1860     if (fid == NULL)
1861       error (_("No frame at address %s."), arg);
1862     FPTR (fid, false);
1863   }
1864
1865   /* The "frame view" family of commands.  ARG is one or two addresses and
1866      is used to view a frame that might be outside the current backtrace.
1867      The addresses are stack-pointer address, and (optional) pc-address.  */
1868
1869   static void
1870   view (const char *args, int from_tty)
1871   {
1872     struct frame_info *fid;
1873
1874     if (args == NULL)
1875     error (_("Missing address argument to view a frame"));
1876
1877     gdb_argv argv (args);
1878
1879     if (argv.count () == 2)
1880       {
1881         CORE_ADDR addr[2];
1882
1883         addr [0] = value_as_address (parse_and_eval (argv[0]));
1884         addr [1] = value_as_address (parse_and_eval (argv[1]));
1885         fid = create_new_frame (addr[0], addr[1]);
1886       }
1887     else
1888       {
1889         CORE_ADDR addr = value_as_address (parse_and_eval (argv[0]));
1890         fid = create_new_frame (addr, false);
1891       }
1892     FPTR (fid, false);
1893   }
1894
1895   /* The "frame function" family of commands.  ARG is the name of a
1896      function within the stack, the first function (searching from frame
1897      0) with that name will be selected.  */
1898
1899   static void
1900   function (const char *arg, int from_tty)
1901   {
1902     if (arg == NULL)
1903       error (_("Missing function name argument"));
1904     struct frame_info *fid = find_frame_for_function (arg);
1905     if (fid == NULL)
1906       error (_("No frame for function \"%s\"."), arg);
1907     FPTR (fid, false);
1908   }
1909
1910   /* The "frame" base command, that is, when no sub-command is specified.
1911      If one argument is provided then we assume that this is a frame's
1912      level as historically, this was the supported command syntax that was
1913      used most often.
1914
1915      If no argument is provided, then the current frame is selected.  */
1916
1917   static void
1918   base_command (const char *arg, int from_tty)
1919   {
1920     if (arg == NULL)
1921       FPTR (get_selected_frame (_("No stack.")), true);
1922     else
1923       level (arg, from_tty);
1924   }
1925 };
1926
1927 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1928    sub-commands for 'info frame', 'frame', and 'select-frame' commands.  */
1929
1930 static frame_command_helper <info_frame_command_core> info_frame_cmd;
1931 static frame_command_helper <frame_command_core> frame_cmd;
1932 static frame_command_helper <select_frame_command_core> select_frame_cmd;
1933
1934 /* Print briefly all stack frames or just the innermost COUNT_EXP
1935    frames.  */
1936
1937 static void
1938 backtrace_command_1 (const frame_print_options &fp_opts,
1939                      const backtrace_cmd_options &bt_opts,
1940                      const char *count_exp, int from_tty)
1941
1942 {
1943   struct frame_info *fi;
1944   int count;
1945   int py_start = 0, py_end = 0;
1946   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1947
1948   if (!target_has_stack)
1949     error (_("No stack."));
1950
1951   if (count_exp)
1952     {
1953       count = parse_and_eval_long (count_exp);
1954       if (count < 0)
1955         py_start = count;
1956       else
1957         {
1958           py_start = 0;
1959           /* The argument to apply_ext_lang_frame_filter is the number
1960              of the final frame to print, and frames start at 0.  */
1961           py_end = count - 1;
1962         }
1963     }
1964   else
1965     {
1966       py_end = -1;
1967       count = -1;
1968     }
1969
1970   frame_filter_flags flags = 0;
1971
1972   if (bt_opts.full)
1973     flags |= PRINT_LOCALS;
1974   if (bt_opts.hide)
1975     flags |= PRINT_HIDE;
1976
1977   if (!bt_opts.no_filters)
1978     {
1979       enum ext_lang_frame_args arg_type;
1980
1981       flags |= PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
1982       if (from_tty)
1983         flags |= PRINT_MORE_FRAMES;
1984
1985       if (fp_opts.print_frame_arguments == print_frame_arguments_scalars)
1986         arg_type = CLI_SCALAR_VALUES;
1987       else if (fp_opts.print_frame_arguments == print_frame_arguments_all)
1988         arg_type = CLI_ALL_VALUES;
1989       else if (fp_opts.print_frame_arguments == print_frame_arguments_presence)
1990         arg_type = CLI_PRESENCE;
1991       else if (fp_opts.print_frame_arguments == print_frame_arguments_none)
1992         arg_type = NO_VALUES;
1993       else
1994         gdb_assert (0);
1995
1996       result = apply_ext_lang_frame_filter (get_current_frame (), flags,
1997                                             arg_type, current_uiout,
1998                                             py_start, py_end);
1999     }
2000
2001   /* Run the inbuilt backtrace if there are no filters registered, or
2002      "-no-filters" has been specified from the command.  */
2003   if (bt_opts.no_filters || result == EXT_LANG_BT_NO_FILTERS)
2004     {
2005       struct frame_info *trailing;
2006
2007       /* The following code must do two things.  First, it must set the
2008          variable TRAILING to the frame from which we should start
2009          printing.  Second, it must set the variable count to the number
2010          of frames which we should print, or -1 if all of them.  */
2011
2012       if (count_exp != NULL && count < 0)
2013         {
2014           trailing = trailing_outermost_frame (-count);
2015           count = -1;
2016         }
2017       else
2018         trailing = get_current_frame ();
2019
2020       for (fi = trailing; fi && count--; fi = get_prev_frame (fi))
2021         {
2022           QUIT;
2023
2024           /* Don't use print_stack_frame; if an error() occurs it probably
2025              means further attempts to backtrace would fail (on the other
2026              hand, perhaps the code does or could be fixed to make sure
2027              the frame->prev field gets set to NULL in that case).  */
2028
2029           print_frame_info (fp_opts, fi, 1, LOCATION, 1, 0);
2030           if ((flags & PRINT_LOCALS) != 0)
2031             {
2032               struct frame_id frame_id = get_frame_id (fi);
2033
2034               print_frame_local_vars (fi, false, NULL, NULL, 1, gdb_stdout);
2035
2036               /* print_frame_local_vars invalidates FI.  */
2037               fi = frame_find_by_id (frame_id);
2038               if (fi == NULL)
2039                 {
2040                   trailing = NULL;
2041                   warning (_("Unable to restore previously selected frame."));
2042                   break;
2043                 }
2044             }
2045
2046           /* Save the last frame to check for error conditions.  */
2047           trailing = fi;
2048         }
2049
2050       /* If we've stopped before the end, mention that.  */
2051       if (fi && from_tty)
2052         printf_filtered (_("(More stack frames follow...)\n"));
2053
2054       /* If we've run out of frames, and the reason appears to be an error
2055          condition, print it.  */
2056       if (fi == NULL && trailing != NULL)
2057         {
2058           enum unwind_stop_reason reason;
2059
2060           reason = get_frame_unwind_stop_reason (trailing);
2061           if (reason >= UNWIND_FIRST_ERROR)
2062             printf_filtered (_("Backtrace stopped: %s\n"),
2063                              frame_stop_reason_string (trailing));
2064         }
2065     }
2066 }
2067
2068 /* Create an option_def_group array grouping all the "backtrace"
2069    options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts.  */
2070
2071 static inline std::array<gdb::option::option_def_group, 3>
2072 make_backtrace_options_def_group (frame_print_options *fp_opts,
2073                                   backtrace_cmd_options *bt_cmd_opts,
2074                                   set_backtrace_options *set_bt_opts)
2075 {
2076   return {{
2077     { {frame_print_option_defs}, fp_opts },
2078     { {set_backtrace_option_defs}, set_bt_opts },
2079     { {backtrace_command_option_defs}, bt_cmd_opts }
2080   }};
2081 }
2082
2083 /* Parse the backtrace command's qualifiers.  Returns ARG advanced
2084    past the qualifiers, if any.  BT_CMD_OPTS, if not null, is used to
2085    store the parsed qualifiers.  */
2086
2087 static const char *
2088 parse_backtrace_qualifiers (const char *arg,
2089                             backtrace_cmd_options *bt_cmd_opts = nullptr)
2090 {
2091   while (true)
2092     {
2093       const char *save_arg = arg;
2094       std::string this_arg = extract_arg (&arg);
2095
2096       if (this_arg.empty ())
2097         return arg;
2098
2099       if (subset_compare (this_arg.c_str (), "no-filters"))
2100         {
2101           if (bt_cmd_opts != nullptr)
2102             bt_cmd_opts->no_filters = true;
2103         }
2104       else if (subset_compare (this_arg.c_str (), "full"))
2105         {
2106           if (bt_cmd_opts != nullptr)
2107             bt_cmd_opts->full = true;
2108         }
2109       else if (subset_compare (this_arg.c_str (), "hide"))
2110         {
2111           if (bt_cmd_opts != nullptr)
2112             bt_cmd_opts->hide = true;
2113         }
2114       else
2115         {
2116           /* Not a recognized qualifier, so stop.  */
2117           return save_arg;
2118         }
2119     }
2120 }
2121
2122 static void
2123 backtrace_command (const char *arg, int from_tty)
2124 {
2125   frame_print_options fp_opts = user_frame_print_options;
2126   backtrace_cmd_options bt_cmd_opts;
2127   set_backtrace_options set_bt_opts = user_set_backtrace_options;
2128
2129   auto grp
2130     = make_backtrace_options_def_group (&fp_opts, &bt_cmd_opts, &set_bt_opts);
2131   gdb::option::process_options
2132     (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2133
2134   /* Parse non-'-'-prefixed qualifiers, for backwards
2135      compatibility.  */
2136   if (arg != NULL)
2137     {
2138       arg = parse_backtrace_qualifiers (arg, &bt_cmd_opts);
2139       if (*arg == '\0')
2140         arg = NULL;
2141     }
2142
2143   /* These options are handled quite deep in the unwind machinery, so
2144      we get to pass them down by swapping globals.  */
2145   scoped_restore restore_set_backtrace_options
2146     = make_scoped_restore (&user_set_backtrace_options, set_bt_opts);
2147
2148   backtrace_command_1 (fp_opts, bt_cmd_opts, arg, from_tty);
2149 }
2150
2151 /* Completer for the "backtrace" command.  */
2152
2153 static void
2154 backtrace_command_completer (struct cmd_list_element *ignore,
2155                              completion_tracker &tracker,
2156                              const char *text, const char */*word*/)
2157 {
2158   const auto group
2159     = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2160   if (gdb::option::complete_options
2161       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
2162     return;
2163
2164   if (*text != '\0')
2165     {
2166       const char *p = skip_to_space (text);
2167       if (*p == '\0')
2168         {
2169           static const char *const backtrace_cmd_qualifier_choices[] = {
2170             "full", "no-filters", "hide", nullptr,
2171           };
2172           complete_on_enum (tracker, backtrace_cmd_qualifier_choices,
2173                             text, text);
2174
2175           if (tracker.have_completions ())
2176             return;
2177         }
2178       else
2179         {
2180           const char *cmd = parse_backtrace_qualifiers (text);
2181           tracker.advance_custom_word_point_by (cmd - text);
2182           text = cmd;
2183         }
2184     }
2185
2186   const char *word = advance_to_expression_complete_word_point (tracker, text);
2187   expression_completer (ignore, tracker, text, word);
2188 }
2189
2190 /* Iterate over the local variables of a block B, calling CB with
2191    CB_DATA.  */
2192
2193 static void
2194 iterate_over_block_locals (const struct block *b,
2195                            iterate_over_block_arg_local_vars_cb cb,
2196                            void *cb_data)
2197 {
2198   struct block_iterator iter;
2199   struct symbol *sym;
2200
2201   ALL_BLOCK_SYMBOLS (b, iter, sym)
2202     {
2203       switch (SYMBOL_CLASS (sym))
2204         {
2205         case LOC_LOCAL:
2206         case LOC_REGISTER:
2207         case LOC_STATIC:
2208         case LOC_COMPUTED:
2209         case LOC_OPTIMIZED_OUT:
2210           if (SYMBOL_IS_ARGUMENT (sym))
2211             break;
2212           if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
2213             break;
2214           (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
2215           break;
2216
2217         default:
2218           /* Ignore symbols which are not locals.  */
2219           break;
2220         }
2221     }
2222 }
2223
2224
2225 /* Same, but print labels.  */
2226
2227 #if 0
2228 /* Commented out, as the code using this function has also been
2229    commented out.  FIXME:brobecker/2009-01-13: Find out why the code
2230    was commented out in the first place.  The discussion introducing
2231    this change (2007-12-04: Support lexical blocks and function bodies
2232    that occupy non-contiguous address ranges) did not explain why
2233    this change was made.  */
2234 static int
2235 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
2236                           int *have_default, struct ui_file *stream)
2237 {
2238   struct block_iterator iter;
2239   struct symbol *sym;
2240   int values_printed = 0;
2241
2242   ALL_BLOCK_SYMBOLS (b, iter, sym)
2243     {
2244       if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
2245         {
2246           if (*have_default)
2247             continue;
2248           *have_default = 1;
2249         }
2250       if (SYMBOL_CLASS (sym) == LOC_LABEL)
2251         {
2252           struct symtab_and_line sal;
2253           struct value_print_options opts;
2254
2255           sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
2256           values_printed = 1;
2257           fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
2258           get_user_print_options (&opts);
2259           if (opts.addressprint)
2260             {
2261               fprintf_filtered (stream, " ");
2262               fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
2263                               stream);
2264             }
2265           fprintf_filtered (stream, " in file %s, line %d\n",
2266                             sal.symtab->filename, sal.line);
2267         }
2268     }
2269
2270   return values_printed;
2271 }
2272 #endif
2273
2274 /* Iterate over all the local variables in block B, including all its
2275    superblocks, stopping when the top-level block is reached.  */
2276
2277 void
2278 iterate_over_block_local_vars (const struct block *block,
2279                                iterate_over_block_arg_local_vars_cb cb,
2280                                void *cb_data)
2281 {
2282   while (block)
2283     {
2284       iterate_over_block_locals (block, cb, cb_data);
2285       /* After handling the function's top-level block, stop.  Don't
2286          continue to its superblock, the block of per-file
2287          symbols.  */
2288       if (BLOCK_FUNCTION (block))
2289         break;
2290       block = BLOCK_SUPERBLOCK (block);
2291     }
2292 }
2293
2294 /* Data to be passed around in the calls to the locals and args
2295    iterators.  */
2296
2297 struct print_variable_and_value_data
2298 {
2299   gdb::optional<compiled_regex> preg;
2300   gdb::optional<compiled_regex> treg;
2301   struct frame_id frame_id;
2302   int num_tabs;
2303   struct ui_file *stream;
2304   int values_printed;
2305 };
2306
2307 /* The callback for the locals and args iterators.  */
2308
2309 static void
2310 do_print_variable_and_value (const char *print_name,
2311                              struct symbol *sym,
2312                              void *cb_data)
2313 {
2314   struct print_variable_and_value_data *p
2315     = (struct print_variable_and_value_data *) cb_data;
2316   struct frame_info *frame;
2317
2318   if (p->preg.has_value ()
2319       && p->preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
2320                         NULL, 0) != 0)
2321     return;
2322   if (p->treg.has_value ()
2323       && !treg_matches_sym_type_name (*p->treg, sym))
2324     return;
2325
2326   frame = frame_find_by_id (p->frame_id);
2327   if (frame == NULL)
2328     {
2329       warning (_("Unable to restore previously selected frame."));
2330       return;
2331     }
2332
2333   print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
2334
2335   /* print_variable_and_value invalidates FRAME.  */
2336   frame = NULL;
2337
2338   p->values_printed = 1;
2339 }
2340
2341 /* Prepares the regular expression REG from REGEXP.
2342    If REGEXP is NULL, it results in an empty regular expression.  */
2343
2344 static void
2345 prepare_reg (const char *regexp, gdb::optional<compiled_regex> *reg)
2346 {
2347   if (regexp != NULL)
2348     {
2349       int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
2350                                 ? REG_ICASE : 0);
2351       reg->emplace (regexp, cflags, _("Invalid regexp"));
2352     }
2353   else
2354     reg->reset ();
2355 }
2356
2357 /* Print all variables from the innermost up to the function block of FRAME.
2358    Print them with values to STREAM indented by NUM_TABS.
2359    If REGEXP is not NULL, only print local variables whose name
2360    matches REGEXP.
2361    If T_REGEXP is not NULL, only print local variables whose type
2362    matches T_REGEXP.
2363    If no local variables have been printed and !QUIET, prints a message
2364    explaining why no local variables could be printed.
2365
2366    This function will invalidate FRAME.  */
2367
2368 static void
2369 print_frame_local_vars (struct frame_info *frame,
2370                         bool quiet,
2371                         const char *regexp, const char *t_regexp,
2372                         int num_tabs, struct ui_file *stream)
2373 {
2374   struct print_variable_and_value_data cb_data;
2375   const struct block *block;
2376   CORE_ADDR pc;
2377
2378   if (!get_frame_pc_if_available (frame, &pc))
2379     {
2380       if (!quiet)
2381         fprintf_filtered (stream,
2382                           _("PC unavailable, cannot determine locals.\n"));
2383       return;
2384     }
2385
2386   block = get_frame_block (frame, 0);
2387   if (block == 0)
2388     {
2389       if (!quiet)
2390         fprintf_filtered (stream, "No symbol table info available.\n");
2391       return;
2392     }
2393
2394   prepare_reg (regexp, &cb_data.preg);
2395   prepare_reg (t_regexp, &cb_data.treg);
2396   cb_data.frame_id = get_frame_id (frame);
2397   cb_data.num_tabs = 4 * num_tabs;
2398   cb_data.stream = stream;
2399   cb_data.values_printed = 0;
2400
2401   /* Temporarily change the selected frame to the given FRAME.
2402      This allows routines that rely on the selected frame instead
2403      of being given a frame as parameter to use the correct frame.  */
2404   scoped_restore_selected_frame restore_selected_frame;
2405   select_frame (frame);
2406
2407   iterate_over_block_local_vars (block,
2408                                  do_print_variable_and_value,
2409                                  &cb_data);
2410
2411   if (!cb_data.values_printed && !quiet)
2412     {
2413       if (regexp == NULL && t_regexp == NULL)
2414         fprintf_filtered (stream, _("No locals.\n"));
2415       else
2416         fprintf_filtered (stream, _("No matching locals.\n"));
2417     }
2418 }
2419
2420 /* Structure to hold the values of the options used by the 'info
2421    variables' command and other similar commands.  These correspond to the
2422    -q and -t options.  */
2423
2424 struct info_print_options
2425 {
2426   int quiet = false;
2427   char *type_regexp = nullptr;
2428
2429   ~info_print_options ()
2430   {
2431     xfree (type_regexp);
2432   }
2433 };
2434
2435 /* The options used by the 'info locals' and 'info args' commands.  */
2436
2437 static const gdb::option::option_def info_print_options_defs[] = {
2438   gdb::option::boolean_option_def<info_print_options> {
2439     "q",
2440     [] (info_print_options *opt) { return &opt->quiet; },
2441     nullptr, /* show_cmd_cb */
2442     nullptr /* set_doc */
2443   },
2444
2445   gdb::option::string_option_def<info_print_options> {
2446     "t",
2447     [] (info_print_options *opt) { return &opt->type_regexp; },
2448     nullptr, /* show_cmd_cb */
2449     nullptr /* set_doc */
2450   }
2451 };
2452
2453 /* Returns the option group used by 'info locals' and 'info args'
2454    commands.  */
2455
2456 static gdb::option::option_def_group
2457 make_info_print_options_def_group (info_print_options *opts)
2458 {
2459   return {{info_print_options_defs}, opts};
2460 }
2461
2462 /* Command completer for 'info locals' and 'info args'.  */
2463
2464 static void
2465 info_print_command_completer (struct cmd_list_element *ignore,
2466                               completion_tracker &tracker,
2467                               const char *text, const char * /* word */)
2468 {
2469   const auto group
2470     = make_info_print_options_def_group (nullptr);
2471   if (gdb::option::complete_options
2472       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
2473     return;
2474
2475   const char *word = advance_to_expression_complete_word_point (tracker, text);
2476   symbol_completer (ignore, tracker, text, word);
2477 }
2478
2479 /* Implement the 'info locals' command.  */
2480
2481 void
2482 info_locals_command (const char *args, int from_tty)
2483 {
2484   info_print_options opts;
2485   auto grp = make_info_print_options_def_group (&opts);
2486   gdb::option::process_options
2487     (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2488   if (args != nullptr && *args == '\0')
2489     args = nullptr;
2490
2491   print_frame_local_vars (get_selected_frame (_("No frame selected.")),
2492                           opts.quiet, args, opts.type_regexp,
2493                           0, gdb_stdout);
2494 }
2495
2496 /* Iterate over all the argument variables in block B.  */
2497
2498 void
2499 iterate_over_block_arg_vars (const struct block *b,
2500                              iterate_over_block_arg_local_vars_cb cb,
2501                              void *cb_data)
2502 {
2503   struct block_iterator iter;
2504   struct symbol *sym, *sym2;
2505
2506   ALL_BLOCK_SYMBOLS (b, iter, sym)
2507     {
2508       /* Don't worry about things which aren't arguments.  */
2509       if (SYMBOL_IS_ARGUMENT (sym))
2510         {
2511           /* We have to look up the symbol because arguments can have
2512              two entries (one a parameter, one a local) and the one we
2513              want is the local, which lookup_symbol will find for us.
2514              This includes gcc1 (not gcc2) on the sparc when passing a
2515              small structure and gcc2 when the argument type is float
2516              and it is passed as a double and converted to float by
2517              the prologue (in the latter case the type of the LOC_ARG
2518              symbol is double and the type of the LOC_LOCAL symbol is
2519              float).  There are also LOC_ARG/LOC_REGISTER pairs which
2520              are not combined in symbol-reading.  */
2521
2522           sym2 = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
2523                                             b, VAR_DOMAIN).symbol;
2524           (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
2525         }
2526     }
2527 }
2528
2529 /* Print all argument variables of the function of FRAME.
2530    Print them with values to STREAM.
2531    If REGEXP is not NULL, only print argument variables whose name
2532    matches REGEXP.
2533    If T_REGEXP is not NULL, only print argument variables whose type
2534    matches T_REGEXP.
2535    If no argument variables have been printed and !QUIET, prints a message
2536    explaining why no argument variables could be printed.
2537
2538    This function will invalidate FRAME.  */
2539
2540 static void
2541 print_frame_arg_vars (struct frame_info *frame,
2542                       bool quiet,
2543                       const char *regexp, const char *t_regexp,
2544                       struct ui_file *stream)
2545 {
2546   struct print_variable_and_value_data cb_data;
2547   struct symbol *func;
2548   CORE_ADDR pc;
2549   gdb::optional<compiled_regex> preg;
2550   gdb::optional<compiled_regex> treg;
2551
2552   if (!get_frame_pc_if_available (frame, &pc))
2553     {
2554       if (!quiet)
2555         fprintf_filtered (stream,
2556                           _("PC unavailable, cannot determine args.\n"));
2557       return;
2558     }
2559
2560   func = get_frame_function (frame);
2561   if (func == NULL)
2562     {
2563       if (!quiet)
2564         fprintf_filtered (stream, _("No symbol table info available.\n"));
2565       return;
2566     }
2567
2568   prepare_reg (regexp, &cb_data.preg);
2569   prepare_reg (t_regexp, &cb_data.treg);
2570   cb_data.frame_id = get_frame_id (frame);
2571   cb_data.num_tabs = 0;
2572   cb_data.stream = stream;
2573   cb_data.values_printed = 0;
2574
2575   iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2576                                do_print_variable_and_value, &cb_data);
2577
2578   /* do_print_variable_and_value invalidates FRAME.  */
2579   frame = NULL;
2580
2581   if (!cb_data.values_printed && !quiet)
2582     {
2583       if (regexp == NULL && t_regexp == NULL)
2584         fprintf_filtered (stream, _("No arguments.\n"));
2585       else
2586         fprintf_filtered (stream, _("No matching arguments.\n"));
2587     }
2588 }
2589
2590 /* Implement the 'info args' command.  */
2591
2592 void
2593 info_args_command (const char *args, int from_tty)
2594 {
2595   info_print_options opts;
2596   auto grp = make_info_print_options_def_group (&opts);
2597   gdb::option::process_options
2598     (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2599   if (args != nullptr && *args == '\0')
2600     args = nullptr;
2601
2602   print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
2603                         opts.quiet, args, opts.type_regexp, gdb_stdout);
2604 }
2605 \f
2606 /* Return the symbol-block in which the selected frame is executing.
2607    Can return zero under various legitimate circumstances.
2608
2609    If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
2610    code address within the block returned.  We use this to decide
2611    which macros are in scope.  */
2612
2613 const struct block *
2614 get_selected_block (CORE_ADDR *addr_in_block)
2615 {
2616   if (!has_stack_frames ())
2617     return 0;
2618
2619   return get_frame_block (get_selected_frame (NULL), addr_in_block);
2620 }
2621
2622 /* Find a frame a certain number of levels away from FRAME.
2623    LEVEL_OFFSET_PTR points to an int containing the number of levels.
2624    Positive means go to earlier frames (up); negative, the reverse.
2625    The int that contains the number of levels is counted toward
2626    zero as the frames for those levels are found.
2627    If the top or bottom frame is reached, that frame is returned,
2628    but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
2629    how much farther the original request asked to go.  */
2630
2631 struct frame_info *
2632 find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
2633 {
2634   /* Going up is simple: just call get_prev_frame enough times or
2635      until the initial frame is reached.  */
2636   while (*level_offset_ptr > 0)
2637     {
2638       struct frame_info *prev = get_prev_frame (frame);
2639
2640       if (!prev)
2641         break;
2642       (*level_offset_ptr)--;
2643       frame = prev;
2644     }
2645
2646   /* Going down is just as simple.  */
2647   while (*level_offset_ptr < 0)
2648     {
2649       struct frame_info *next = get_next_frame (frame);
2650
2651       if (!next)
2652         break;
2653       (*level_offset_ptr)++;
2654       frame = next;
2655     }
2656
2657   return frame;
2658 }
2659
2660 /* Select the frame up one or COUNT_EXP stack levels from the
2661    previously selected frame, and print it briefly.  */
2662
2663 static void
2664 up_silently_base (const char *count_exp)
2665 {
2666   struct frame_info *frame;
2667   int count = 1;
2668
2669   if (count_exp)
2670     count = parse_and_eval_long (count_exp);
2671
2672   frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2673   if (count != 0 && count_exp == NULL)
2674     error (_("Initial frame selected; you cannot go up."));
2675   select_frame (frame);
2676 }
2677
2678 static void
2679 up_silently_command (const char *count_exp, int from_tty)
2680 {
2681   up_silently_base (count_exp);
2682 }
2683
2684 static void
2685 up_command (const char *count_exp, int from_tty)
2686 {
2687   up_silently_base (count_exp);
2688   gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
2689 }
2690
2691 /* Select the frame down one or COUNT_EXP stack levels from the previously
2692    selected frame, and print it briefly.  */
2693
2694 static void
2695 down_silently_base (const char *count_exp)
2696 {
2697   struct frame_info *frame;
2698   int count = -1;
2699
2700   if (count_exp)
2701     count = -parse_and_eval_long (count_exp);
2702
2703   frame = find_relative_frame (get_selected_frame ("No stack."), &count);
2704   if (count != 0 && count_exp == NULL)
2705     {
2706       /* We only do this if COUNT_EXP is not specified.  That way
2707          "down" means to really go down (and let me know if that is
2708          impossible), but "down 9999" can be used to mean go all the
2709          way down without getting an error.  */
2710
2711       error (_("Bottom (innermost) frame selected; you cannot go down."));
2712     }
2713
2714   select_frame (frame);
2715 }
2716
2717 static void
2718 down_silently_command (const char *count_exp, int from_tty)
2719 {
2720   down_silently_base (count_exp);
2721 }
2722
2723 static void
2724 down_command (const char *count_exp, int from_tty)
2725 {
2726   down_silently_base (count_exp);
2727   gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
2728 }
2729
2730 void
2731 return_command (const char *retval_exp, int from_tty)
2732 {
2733   /* Initialize it just to avoid a GCC false warning.  */
2734   enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
2735   struct frame_info *thisframe;
2736   struct gdbarch *gdbarch;
2737   struct symbol *thisfun;
2738   struct value *return_value = NULL;
2739   struct value *function = NULL;
2740   const char *query_prefix = "";
2741
2742   thisframe = get_selected_frame ("No selected frame.");
2743   thisfun = get_frame_function (thisframe);
2744   gdbarch = get_frame_arch (thisframe);
2745
2746   if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
2747     error (_("Can not force return from an inlined function."));
2748
2749   /* Compute the return value.  If the computation triggers an error,
2750      let it bail.  If the return type can't be handled, set
2751      RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
2752      message.  */
2753   if (retval_exp)
2754     {
2755       expression_up retval_expr = parse_expression (retval_exp);
2756       struct type *return_type = NULL;
2757
2758       /* Compute the return value.  Should the computation fail, this
2759          call throws an error.  */
2760       return_value = evaluate_expression (retval_expr.get ());
2761
2762       /* Cast return value to the return type of the function.  Should
2763          the cast fail, this call throws an error.  */
2764       if (thisfun != NULL)
2765         return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
2766       if (return_type == NULL)
2767         {
2768           if (retval_expr->elts[0].opcode != UNOP_CAST
2769               && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
2770             error (_("Return value type not available for selected "
2771                      "stack frame.\n"
2772                      "Please use an explicit cast of the value to return."));
2773           return_type = value_type (return_value);
2774         }
2775       return_type = check_typedef (return_type);
2776       return_value = value_cast (return_type, return_value);
2777
2778       /* Make sure the value is fully evaluated.  It may live in the
2779          stack frame we're about to pop.  */
2780       if (value_lazy (return_value))
2781         value_fetch_lazy (return_value);
2782
2783       if (thisfun != NULL)
2784         function = read_var_value (thisfun, NULL, thisframe);
2785
2786       rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
2787       if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
2788         /* If the return-type is "void", don't try to find the
2789            return-value's location.  However, do still evaluate the
2790            return expression so that, even when the expression result
2791            is discarded, side effects such as "return i++" still
2792            occur.  */
2793         return_value = NULL;
2794       else if (thisfun != NULL)
2795         {
2796           rv_conv = struct_return_convention (gdbarch, function, return_type);
2797           if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
2798               || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
2799             {
2800               query_prefix = "The location at which to store the "
2801                 "function's return value is unknown.\n"
2802                 "If you continue, the return value "
2803                 "that you specified will be ignored.\n";
2804               return_value = NULL;
2805             }
2806         }
2807     }
2808
2809   /* Does an interactive user really want to do this?  Include
2810      information, such as how well GDB can handle the return value, in
2811      the query message.  */
2812   if (from_tty)
2813     {
2814       int confirmed;
2815
2816       if (thisfun == NULL)
2817         confirmed = query (_("%sMake selected stack frame return now? "),
2818                            query_prefix);
2819       else
2820         {
2821           if (TYPE_NO_RETURN (thisfun->type))
2822             warning (_("Function does not return normally to caller."));
2823           confirmed = query (_("%sMake %s return now? "), query_prefix,
2824                              SYMBOL_PRINT_NAME (thisfun));
2825         }
2826       if (!confirmed)
2827         error (_("Not confirmed"));
2828     }
2829
2830   /* Discard the selected frame and all frames inner-to it.  */
2831   frame_pop (get_selected_frame (NULL));
2832
2833   /* Store RETURN_VALUE in the just-returned register set.  */
2834   if (return_value != NULL)
2835     {
2836       struct type *return_type = value_type (return_value);
2837       struct gdbarch *cache_arch = get_current_regcache ()->arch ();
2838
2839       gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
2840                   && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
2841       gdbarch_return_value (cache_arch, function, return_type,
2842                             get_current_regcache (), NULL /*read*/,
2843                             value_contents (return_value) /*write*/);
2844     }
2845
2846   /* If we are at the end of a call dummy now, pop the dummy frame
2847      too.  */
2848   if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
2849     frame_pop (get_current_frame ());
2850
2851   select_frame (get_current_frame ());
2852   /* If interactive, print the frame that is now current.  */
2853   if (from_tty)
2854     print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2855 }
2856
2857 /* Find the most inner frame in the current stack for a function called
2858    FUNCTION_NAME.  If no matching frame is found return NULL.  */
2859
2860 static struct frame_info *
2861 find_frame_for_function (const char *function_name)
2862 {
2863   /* Used to hold the lower and upper addresses for each of the
2864      SYMTAB_AND_LINEs found for functions matching FUNCTION_NAME.  */
2865   struct function_bounds
2866   {
2867     CORE_ADDR low, high;
2868   };
2869   struct frame_info *frame;
2870   bool found = false;
2871   int level = 1;
2872
2873   gdb_assert (function_name != NULL);
2874
2875   frame = get_current_frame ();
2876   std::vector<symtab_and_line> sals
2877     = decode_line_with_current_source (function_name,
2878                                        DECODE_LINE_FUNFIRSTLINE);
2879   gdb::def_vector<function_bounds> func_bounds (sals.size ());
2880   for (size_t i = 0; i < sals.size (); i++)
2881     {
2882       if (sals[i].pspace != current_program_space)
2883         func_bounds[i].low = func_bounds[i].high = 0;
2884       else if (sals[i].pc == 0
2885                || find_pc_partial_function (sals[i].pc, NULL,
2886                                             &func_bounds[i].low,
2887                                             &func_bounds[i].high) == 0)
2888         func_bounds[i].low = func_bounds[i].high = 0;
2889     }
2890
2891   do
2892     {
2893       for (size_t i = 0; (i < sals.size () && !found); i++)
2894         found = (get_frame_pc (frame) >= func_bounds[i].low
2895                  && get_frame_pc (frame) < func_bounds[i].high);
2896       if (!found)
2897         {
2898           level = 1;
2899           frame = find_relative_frame (frame, &level);
2900         }
2901     }
2902   while (!found && level == 0);
2903
2904   if (!found)
2905     frame = NULL;
2906
2907   return frame;
2908 }
2909
2910 /* Implements the dbx 'func' command.  */
2911
2912 static void
2913 func_command (const char *arg, int from_tty)
2914 {
2915   if (arg == NULL)
2916     return;
2917
2918   struct frame_info *frame = find_frame_for_function (arg);
2919   if (frame == NULL)
2920     error (_("'%s' not within current stack frame."), arg);
2921   if (frame != get_selected_frame (NULL))
2922     {
2923       select_frame (frame);
2924       print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
2925     }
2926 }
2927
2928 /* The qcs command line flags for the "frame apply" commands.  Keep
2929    this in sync with the "thread apply" commands.  */
2930
2931 using qcs_flag_option_def
2932   = gdb::option::flag_option_def<qcs_flags>;
2933
2934 static const gdb::option::option_def fr_qcs_flags_option_defs[] = {
2935   qcs_flag_option_def {
2936     "q", [] (qcs_flags *opt) { return &opt->quiet; },
2937     N_("Disables printing the frame location information."),
2938   },
2939
2940   qcs_flag_option_def {
2941     "c", [] (qcs_flags *opt) { return &opt->cont; },
2942     N_("Print any error raised by COMMAND and continue."),
2943   },
2944
2945   qcs_flag_option_def {
2946     "s", [] (qcs_flags *opt) { return &opt->silent; },
2947     N_("Silently ignore any errors or empty output produced by COMMAND."),
2948   },
2949 };
2950
2951 /* Create an option_def_group array for all the "frame apply" options,
2952    with FLAGS and SET_BT_OPTS as context.  */
2953
2954 static inline std::array<gdb::option::option_def_group, 2>
2955 make_frame_apply_options_def_group (qcs_flags *flags,
2956                                     set_backtrace_options *set_bt_opts)
2957 {
2958   return {{
2959     { {fr_qcs_flags_option_defs}, flags },
2960     { {set_backtrace_option_defs}, set_bt_opts },
2961   }};
2962 }
2963
2964 /* Apply a GDB command to all stack frames, or a set of identified frames,
2965    or innermost COUNT frames.
2966    With a negative COUNT, apply command on outermost -COUNT frames.
2967
2968    frame apply 3 info frame     Apply 'info frame' to frames 0, 1, 2
2969    frame apply -3 info frame    Apply 'info frame' to outermost 3 frames.
2970    frame apply all x/i $pc      Apply 'x/i $pc' cmd to all frames.
2971    frame apply all -s p local_var_no_idea_in_which_frame
2972                 If a frame has a local variable called
2973                 local_var_no_idea_in_which_frame, print frame
2974                 and value of local_var_no_idea_in_which_frame.
2975    frame apply all -s -q p local_var_no_idea_in_which_frame
2976                 Same as before, but only print the variable value.
2977    frame apply level 2-5 0 4-7 -s p i = i + 1
2978                 Adds 1 to the variable i in the specified frames.
2979                 Note that i will be incremented twice in
2980                 frames 4 and 5.  */
2981
2982 /* Apply a GDB command to COUNT stack frames, starting at TRAILING.
2983    CMD starts with 0 or more qcs flags followed by the GDB command to apply.
2984    COUNT -1 means all frames starting at TRAILING.  WHICH_COMMAND is used
2985    for error messages.  */
2986
2987 static void
2988 frame_apply_command_count (const char *which_command,
2989                            const char *cmd, int from_tty,
2990                            struct frame_info *trailing, int count)
2991 {
2992   qcs_flags flags;
2993   set_backtrace_options set_bt_opts = user_set_backtrace_options;
2994
2995   auto group = make_frame_apply_options_def_group (&flags, &set_bt_opts);
2996   gdb::option::process_options
2997     (&cmd, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group);
2998
2999   validate_flags_qcs (which_command, &flags);
3000
3001   if (cmd == NULL || *cmd == '\0')
3002     error (_("Please specify a command to apply on the selected frames"));
3003
3004   /* The below will restore the current inferior/thread/frame.
3005      Usually, only the frame is effectively to be restored.
3006      But in case CMD switches of inferior/thread, better restore
3007      these also.  */
3008   scoped_restore_current_thread restore_thread;
3009
3010   /* These options are handled quite deep in the unwind machinery, so
3011      we get to pass them down by swapping globals.  */
3012   scoped_restore restore_set_backtrace_options
3013     = make_scoped_restore (&user_set_backtrace_options, set_bt_opts);
3014
3015   for (frame_info *fi = trailing; fi && count--; fi = get_prev_frame (fi))
3016     {
3017       QUIT;
3018
3019       select_frame (fi);
3020       try
3021         {
3022           std::string cmd_result;
3023           {
3024             /* In case CMD switches of inferior/thread/frame, the below
3025                restores the inferior/thread/frame.  FI can then be
3026                set to the selected frame.  */
3027             scoped_restore_current_thread restore_fi_current_frame;
3028
3029             cmd_result = execute_command_to_string
3030               (cmd, from_tty, gdb_stdout->term_out ());
3031           }
3032           fi = get_selected_frame (_("frame apply "
3033                                      "unable to get selected frame."));
3034           if (!flags.silent || cmd_result.length () > 0)
3035             {
3036               if (!flags.quiet)
3037                 print_stack_frame (fi, 1, LOCATION, 0);
3038               printf_filtered ("%s", cmd_result.c_str ());
3039             }
3040         }
3041       catch (const gdb_exception_error &ex)
3042         {
3043           fi = get_selected_frame (_("frame apply "
3044                                      "unable to get selected frame."));
3045           if (!flags.silent)
3046             {
3047               if (!flags.quiet)
3048                 print_stack_frame (fi, 1, LOCATION, 0);
3049               if (flags.cont)
3050                 printf_filtered ("%s\n", ex.what ());
3051               else
3052                 throw;
3053             }
3054         }
3055     }
3056 }
3057
3058 /* Completer for the "frame apply ..." commands.  */
3059
3060 static void
3061 frame_apply_completer (completion_tracker &tracker, const char *text)
3062 {
3063   const auto group = make_frame_apply_options_def_group (nullptr, nullptr);
3064   if (gdb::option::complete_options
3065       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
3066     return;
3067
3068   complete_nested_command_line (tracker, text);
3069 }
3070
3071 /* Completer for the "frame apply" commands.  */
3072
3073 static void
3074 frame_apply_level_cmd_completer (struct cmd_list_element *ignore,
3075                                  completion_tracker &tracker,
3076                                  const char *text, const char */*word*/)
3077 {
3078   /* Do this explicitly because there's an early return below.  */
3079   tracker.set_use_custom_word_point (true);
3080
3081   number_or_range_parser levels (text);
3082
3083   /* Skip the LEVEL list to find the options and command args.  */
3084   try
3085     {
3086       while (!levels.finished ())
3087         {
3088           /* Call for effect.  */
3089           levels.get_number ();
3090
3091           if (levels.in_range ())
3092             levels.skip_range ();
3093         }
3094     }
3095   catch (const gdb_exception_error &ex)
3096     {
3097       /* get_number throws if it parses a negative number, for
3098          example.  But a seemingly negative number may be the start of
3099          an option instead.  */
3100     }
3101
3102   const char *cmd = levels.cur_tok ();
3103
3104   if (cmd == text)
3105     {
3106       /* No level list yet.  */
3107       return;
3108     }
3109
3110   /* Check if we're past a valid LEVEL already.  */
3111   if (levels.finished ()
3112       && cmd > text && !isspace (cmd[-1]))
3113     return;
3114
3115   /* We're past LEVELs, advance word point.  */
3116   tracker.advance_custom_word_point_by (cmd - text);
3117   text = cmd;
3118
3119   frame_apply_completer (tracker, text);
3120 }
3121
3122 /* Completer for the "frame apply all" command.  */
3123
3124 void
3125 frame_apply_all_cmd_completer (struct cmd_list_element *ignore,
3126                                completion_tracker &tracker,
3127                                const char *text, const char */*word*/)
3128 {
3129   frame_apply_completer (tracker, text);
3130 }
3131
3132 /* Completer for the "frame apply COUNT" command.  */
3133
3134 static void
3135 frame_apply_cmd_completer (struct cmd_list_element *ignore,
3136                            completion_tracker &tracker,
3137                            const char *text, const char */*word*/)
3138 {
3139   const char *cmd = text;
3140
3141   int count = get_number_trailer (&cmd, 0);
3142   if (count == 0)
3143     return;
3144
3145   /* Check if we're past a valid COUNT already.  */
3146   if (cmd > text && !isspace (cmd[-1]))
3147     return;
3148
3149   /* We're past COUNT, advance word point.  */
3150   tracker.advance_custom_word_point_by (cmd - text);
3151   text = cmd;
3152
3153   frame_apply_completer (tracker, text);
3154 }
3155
3156 /* Implementation of the "frame apply level" command.  */
3157
3158 static void
3159 frame_apply_level_command (const char *cmd, int from_tty)
3160 {
3161   if (!target_has_stack)
3162     error (_("No stack."));
3163
3164   bool level_found = false;
3165   const char *levels_str = cmd;
3166   number_or_range_parser levels (levels_str);
3167
3168   /* Skip the LEVEL list to find the flags and command args.  */
3169   while (!levels.finished ())
3170     {
3171       /* Call for effect.  */
3172       levels.get_number ();
3173
3174       level_found = true;
3175       if (levels.in_range ())
3176         levels.skip_range ();
3177     }
3178
3179   if (!level_found)
3180     error (_("Missing or invalid LEVEL... argument"));
3181
3182   cmd = levels.cur_tok ();
3183
3184   /* Redo the LEVELS parsing, but applying COMMAND.  */
3185   levels.init (levels_str);
3186   while (!levels.finished ())
3187     {
3188       const int level_beg = levels.get_number ();
3189       int n_frames;
3190
3191       if (levels.in_range ())
3192         {
3193           n_frames = levels.end_value () - level_beg + 1;
3194           levels.skip_range ();
3195         }
3196       else
3197         n_frames = 1;
3198
3199       frame_apply_command_count ("frame apply level", cmd, from_tty,
3200                                  leading_innermost_frame (level_beg), n_frames);
3201     }
3202 }
3203
3204 /* Implementation of the "frame apply all" command.  */
3205
3206 static void
3207 frame_apply_all_command (const char *cmd, int from_tty)
3208 {
3209   if (!target_has_stack)
3210     error (_("No stack."));
3211
3212   frame_apply_command_count ("frame apply all", cmd, from_tty,
3213                              get_current_frame (), INT_MAX);
3214 }
3215
3216 /* Implementation of the "frame apply" command.  */
3217
3218 static void
3219 frame_apply_command (const char* cmd, int from_tty)
3220 {
3221   int count;
3222   struct frame_info *trailing;
3223
3224   if (!target_has_stack)
3225     error (_("No stack."));
3226
3227   if (cmd == NULL)
3228     error (_("Missing COUNT argument."));
3229   count = get_number_trailer (&cmd, 0);
3230   if (count == 0)
3231     error (_("Invalid COUNT argument."));
3232
3233   if (count < 0)
3234     {
3235       trailing = trailing_outermost_frame (-count);
3236       count = -1;
3237     }
3238   else
3239     trailing = get_current_frame ();
3240
3241   frame_apply_command_count ("frame apply", cmd, from_tty,
3242                              trailing, count);
3243 }
3244
3245 /* Implementation of the "faas" command.  */
3246
3247 static void
3248 faas_command (const char *cmd, int from_tty)
3249 {
3250   std::string expanded = std::string ("frame apply all -s ") + cmd;
3251   execute_command (expanded.c_str (), from_tty);
3252 }
3253
3254
3255 /* Find inner-mode frame with frame address ADDRESS.  Return NULL if no
3256    matching frame can be found.  */
3257
3258 static struct frame_info *
3259 find_frame_for_address (CORE_ADDR address)
3260 {
3261   struct frame_id id;
3262   struct frame_info *fid;
3263
3264   id = frame_id_build_wild (address);
3265
3266   /* If (s)he specifies the frame with an address, he deserves
3267      what (s)he gets.  Still, give the highest one that matches.
3268      (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3269      know).  */
3270   for (fid = get_current_frame ();
3271        fid != NULL;
3272        fid = get_prev_frame (fid))
3273     {
3274       if (frame_id_eq (id, get_frame_id (fid)))
3275         {
3276           struct frame_info *prev_frame;
3277
3278           while (1)
3279             {
3280               prev_frame = get_prev_frame (fid);
3281               if (!prev_frame
3282                   || !frame_id_eq (id, get_frame_id (prev_frame)))
3283                 break;
3284               fid = prev_frame;
3285             }
3286           return fid;
3287         }
3288     }
3289   return NULL;
3290 }
3291
3292 \f
3293
3294 /* Commands with a prefix of `frame apply'.  */
3295 static struct cmd_list_element *frame_apply_cmd_list = NULL;
3296
3297 /* Commands with a prefix of `frame'.  */
3298 static struct cmd_list_element *frame_cmd_list = NULL;
3299
3300 /* Commands with a prefix of `select frame'.  */
3301 static struct cmd_list_element *select_frame_cmd_list = NULL;
3302
3303 /* Commands with a prefix of `info frame'.  */
3304 static struct cmd_list_element *info_frame_cmd_list = NULL;
3305
3306 void
3307 _initialize_stack (void)
3308 {
3309   struct cmd_list_element *cmd;
3310
3311   add_com ("return", class_stack, return_command, _("\
3312 Make selected stack frame return to its caller.\n\
3313 Control remains in the debugger, but when you continue\n\
3314 execution will resume in the frame above the one now selected.\n\
3315 If an argument is given, it is an expression for the value to return."));
3316
3317   add_com ("up", class_stack, up_command, _("\
3318 Select and print stack frame that called this one.\n\
3319 An argument says how many frames up to go."));
3320   add_com ("up-silently", class_support, up_silently_command, _("\
3321 Same as the `up' command, but does not print anything.\n\
3322 This is useful in command scripts."));
3323
3324   add_com ("down", class_stack, down_command, _("\
3325 Select and print stack frame called by this one.\n\
3326 An argument says how many frames down to go."));
3327   add_com_alias ("do", "down", class_stack, 1);
3328   add_com_alias ("dow", "down", class_stack, 1);
3329   add_com ("down-silently", class_support, down_silently_command, _("\
3330 Same as the `down' command, but does not print anything.\n\
3331 This is useful in command scripts."));
3332
3333   add_prefix_cmd ("frame", class_stack,
3334                   &frame_cmd.base_command, _("\
3335 Select and print a stack frame.\n\
3336 With no argument, print the selected stack frame.  (See also \"info frame\").\n\
3337 A single numerical argument specifies the frame to select."),
3338                   &frame_cmd_list, "frame ", 1, &cmdlist);
3339
3340   add_com_alias ("f", "frame", class_stack, 1);
3341
3342 #define FRAME_APPLY_OPTION_HELP "\
3343 Prints the frame location information followed by COMMAND output.\n\
3344 \n\
3345 By default, an error raised during the execution of COMMAND\n\
3346 aborts \"frame apply\".\n\
3347 \n\
3348 Options:\n\
3349 %OPTIONS%"
3350
3351   const auto frame_apply_opts
3352     = make_frame_apply_options_def_group (nullptr, nullptr);
3353
3354   static std::string frame_apply_cmd_help = gdb::option::build_help (_("\
3355 Apply a command to a number of frames.\n\
3356 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3357 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3358                                   FRAME_APPLY_OPTION_HELP),
3359                                frame_apply_opts);
3360
3361   cmd = add_prefix_cmd ("apply", class_stack, frame_apply_command,
3362                         frame_apply_cmd_help.c_str (),
3363                         &frame_apply_cmd_list, "frame apply ", 1,
3364                         &frame_cmd_list);
3365   set_cmd_completer_handle_brkchars (cmd, frame_apply_cmd_completer);
3366
3367   static std::string frame_apply_all_cmd_help = gdb::option::build_help (_("\
3368 Apply a command to all frames.\n\
3369 \n\
3370 Usage: frame apply all [OPTION]... COMMAND\n"
3371                                   FRAME_APPLY_OPTION_HELP),
3372                                frame_apply_opts);
3373
3374   cmd = add_cmd ("all", class_stack, frame_apply_all_command,
3375                  frame_apply_all_cmd_help.c_str (),
3376                  &frame_apply_cmd_list);
3377   set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
3378
3379   static std::string frame_apply_level_cmd_help = gdb::option::build_help (_("\
3380 Apply a command to a list of frames.\n\
3381 \n\
3382 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3383 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3384                                   FRAME_APPLY_OPTION_HELP),
3385                                frame_apply_opts);
3386
3387   cmd = add_cmd ("level", class_stack, frame_apply_level_command,
3388            frame_apply_level_cmd_help.c_str (),
3389            &frame_apply_cmd_list);
3390   set_cmd_completer_handle_brkchars (cmd, frame_apply_level_cmd_completer);
3391
3392   cmd = add_com ("faas", class_stack, faas_command, _("\
3393 Apply a command to all frames (ignoring errors and empty output).\n\
3394 Usage: faas [OPTION]... COMMAND\n\
3395 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3396 See \"help frame apply all\" for available options."));
3397   set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
3398
3399   add_prefix_cmd ("frame", class_stack,
3400                   &frame_cmd.base_command, _("\
3401 Select and print a stack frame.\n\
3402 With no argument, print the selected stack frame.  (See also \"info frame\").\n\
3403 A single numerical argument specifies the frame to select."),
3404                   &frame_cmd_list, "frame ", 1, &cmdlist);
3405   add_com_alias ("f", "frame", class_stack, 1);
3406
3407   add_cmd ("address", class_stack, &frame_cmd.address,
3408            _("\
3409 Select and print a stack frame by stack address.\n\
3410 \n\
3411 Usage: frame address STACK-ADDRESS"),
3412            &frame_cmd_list);
3413
3414   add_cmd ("view", class_stack, &frame_cmd.view,
3415            _("\
3416 View a stack frame that might be outside the current backtrace.\n\
3417 \n\
3418 Usage: frame view STACK-ADDRESS\n\
3419        frame view STACK-ADDRESS PC-ADDRESS"),
3420            &frame_cmd_list);
3421
3422   cmd = add_cmd ("function", class_stack, &frame_cmd.function,
3423            _("\
3424 Select and print a stack frame by function name.\n\
3425 \n\
3426 Usage: frame function NAME\n\
3427 \n\
3428 The innermost frame that visited function NAME is selected."),
3429            &frame_cmd_list);
3430   set_cmd_completer (cmd, frame_selection_by_function_completer);
3431
3432
3433   add_cmd ("level", class_stack, &frame_cmd.level,
3434            _("\
3435 Select and print a stack frame by level.\n\
3436 \n\
3437 Usage: frame level LEVEL"),
3438            &frame_cmd_list);
3439
3440   cmd = add_prefix_cmd_suppress_notification ("select-frame", class_stack,
3441                       &select_frame_cmd.base_command, _("\
3442 Select a stack frame without printing anything.\n\
3443 A single numerical argument specifies the frame to select."),
3444                       &select_frame_cmd_list, "select-frame ", 1, &cmdlist,
3445                       &cli_suppress_notification.user_selected_context);
3446
3447   add_cmd_suppress_notification ("address", class_stack,
3448                          &select_frame_cmd.address, _("\
3449 Select a stack frame by stack address.\n\
3450 \n\
3451 Usage: select-frame address STACK-ADDRESS"),
3452                          &select_frame_cmd_list,
3453                          &cli_suppress_notification.user_selected_context);
3454
3455
3456   add_cmd_suppress_notification ("view", class_stack,
3457                  &select_frame_cmd.view, _("\
3458 Select a stack frame that might be outside the current backtrace.\n\
3459 \n\
3460 Usage: select-frame view STACK-ADDRESS\n\
3461        select-frame view STACK-ADDRESS PC-ADDRESS"),
3462                  &select_frame_cmd_list,
3463                  &cli_suppress_notification.user_selected_context);
3464
3465   cmd = add_cmd_suppress_notification ("function", class_stack,
3466                &select_frame_cmd.function, _("\
3467 Select a stack frame by function name.\n\
3468 \n\
3469 Usage: select-frame function NAME"),
3470                &select_frame_cmd_list,
3471                &cli_suppress_notification.user_selected_context);
3472   set_cmd_completer (cmd, frame_selection_by_function_completer);
3473
3474   add_cmd_suppress_notification ("level", class_stack,
3475                          &select_frame_cmd.level, _("\
3476 Select a stack frame by level.\n\
3477 \n\
3478 Usage: select-frame level LEVEL"),
3479                          &select_frame_cmd_list,
3480                          &cli_suppress_notification.user_selected_context);
3481
3482   const auto backtrace_opts
3483     = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3484
3485   static std::string backtrace_help
3486     = gdb::option::build_help (_("\
3487 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3488 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3489 \n\
3490 Options:\n\
3491 %OPTIONS%\n\
3492 \n\
3493 For backward compatibility, the following qualifiers are supported:\n\
3494 \n\
3495    full       - same as -full option.\n\
3496    no-filters - same as -no-filters option.\n\
3497    hide       - same as -hide.\n\
3498 \n\
3499 With a negative COUNT, print outermost -COUNT frames."),
3500                                backtrace_opts);
3501
3502   cmd_list_element *c = add_com ("backtrace", class_stack,
3503                                  backtrace_command,
3504                                  backtrace_help.c_str ());
3505   set_cmd_completer_handle_brkchars (c, backtrace_command_completer);
3506
3507   add_com_alias ("bt", "backtrace", class_stack, 0);
3508
3509   add_com_alias ("where", "backtrace", class_alias, 0);
3510   add_info ("stack", backtrace_command,
3511             _("Backtrace of the stack, or innermost COUNT frames."));
3512   add_info_alias ("s", "stack", 1);
3513
3514   add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command,
3515                   _("All about the selected stack frame.\n\
3516 With no arguments, displays information about the currently selected stack\n\
3517 frame.  Alternatively a frame specification may be provided (See \"frame\")\n\
3518 the information is then printed about the specified frame."),
3519                   &info_frame_cmd_list, "info frame ", 1, &infolist);
3520   add_info_alias ("f", "frame", 1);
3521
3522   add_cmd ("address", class_stack, &info_frame_cmd.address,
3523            _("\
3524 Print information about a stack frame selected by stack address.\n\
3525 \n\
3526 Usage: info frame address STACK-ADDRESS"),
3527            &info_frame_cmd_list);
3528
3529   add_cmd ("view", class_stack, &info_frame_cmd.view,
3530            _("\
3531 Print information about a stack frame outside the current backtrace.\n\
3532 \n\
3533 Usage: info frame view STACK-ADDRESS\n\
3534        info frame view STACK-ADDRESS PC-ADDRESS"),
3535            &info_frame_cmd_list);
3536
3537   cmd = add_cmd ("function", class_stack, &info_frame_cmd.function,
3538            _("\
3539 Print information about a stack frame selected by function name.\n\
3540 \n\
3541 Usage: info frame function NAME"),
3542            &info_frame_cmd_list);
3543   set_cmd_completer (cmd, frame_selection_by_function_completer);
3544
3545   add_cmd ("level", class_stack, &info_frame_cmd.level,
3546            _("\
3547 Print information about a stack frame selected by level.\n\
3548 \n\
3549 Usage: info frame level LEVEL"),
3550            &info_frame_cmd_list);
3551
3552   cmd = add_info ("locals", info_locals_command,
3553                   info_print_args_help (_("\
3554 All local variables of current stack frame or those matching REGEXPs.\n\
3555 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3556 Prints the local variables of the current stack frame.\n"),
3557                                         _("local variables"),
3558                                         false));
3559   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
3560   cmd = add_info ("args", info_args_command,
3561                   info_print_args_help (_("\
3562 All argument variables of current stack frame or those matching REGEXPs.\n\
3563 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3564 Prints the argument variables of the current stack frame.\n"),
3565                                         _("argument variables"),
3566                                         false));
3567   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
3568
3569   if (dbx_commands)
3570     add_com ("func", class_stack, func_command, _("\
3571 Select the stack frame that contains NAME.\n\
3572 Usage: func NAME"));
3573
3574   /* Install "set print raw frame-arguments", a deprecated spelling of
3575      "set print raw-frame-arguments".  */
3576   cmd = add_setshow_boolean_cmd
3577     ("frame-arguments", no_class,
3578      &user_frame_print_options.print_raw_frame_arguments,
3579      _("\
3580 Set whether to print frame arguments in raw form."), _("\
3581 Show whether to print frame arguments in raw form."), _("\
3582 If set, frame arguments are printed in raw form, bypassing any\n\
3583 pretty-printers for that value."),
3584      NULL, NULL,
3585      &setprintrawlist, &showprintrawlist);
3586   deprecate_cmd (cmd, "set print raw-frame-arguments");
3587
3588   add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
3589                                 &disassemble_next_line, _("\
3590 Set whether to disassemble next source line or insn when execution stops."),
3591                                 _("\
3592 Show whether to disassemble next source line or insn when execution stops."),
3593                                 _("\
3594 If ON, GDB will display disassembly of the next source line, in addition\n\
3595 to displaying the source line itself.  If the next source line cannot\n\
3596 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3597 will display disassembly of next instruction instead of showing the\n\
3598 source line.\n\
3599 If AUTO, display disassembly of next instruction only if the source line\n\
3600 cannot be displayed.\n\
3601 If OFF (which is the default), never display the disassembly of the next\n\
3602 source line."),
3603                                 NULL,
3604                                 show_disassemble_next_line,
3605                                 &setlist, &showlist);
3606   disassemble_next_line = AUTO_BOOLEAN_FALSE;
3607
3608   gdb::option::add_setshow_cmds_for_options
3609     (class_stack, &user_frame_print_options,
3610      frame_print_option_defs, &setprintlist, &showprintlist);
3611 }