]> Git Repo - binutils.git/blob - gdb/stack.c
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / gdb / stack.c
1 /* Print and select stack frames for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2022 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 #include "cli/cli-style.h"
58 #include "gdbsupport/buildargv.h"
59
60 /* The possible choices of "set print frame-arguments", and the value
61    of this setting.  */
62
63 const char print_frame_arguments_all[] = "all";
64 const char print_frame_arguments_scalars[] = "scalars";
65 const char print_frame_arguments_none[] = "none";
66 const char print_frame_arguments_presence[] = "presence";
67
68 static const char *const print_frame_arguments_choices[] =
69 {
70   print_frame_arguments_all,
71   print_frame_arguments_scalars,
72   print_frame_arguments_none,
73   print_frame_arguments_presence,
74   NULL
75 };
76
77 /* The possible choices of "set print frame-info", and the value
78    of this setting.  */
79
80 const char print_frame_info_auto[] = "auto";
81 const char print_frame_info_source_line[] = "source-line";
82 const char print_frame_info_location[] = "location";
83 const char print_frame_info_source_and_location[] = "source-and-location";
84 const char print_frame_info_location_and_address[] = "location-and-address";
85 const char print_frame_info_short_location[] = "short-location";
86
87 static const char *const print_frame_info_choices[] =
88 {
89   print_frame_info_auto,
90   print_frame_info_source_line,
91   print_frame_info_location,
92   print_frame_info_source_and_location,
93   print_frame_info_location_and_address,
94   print_frame_info_short_location,
95   NULL
96 };
97
98 /* print_frame_info_print_what[i] maps a choice to the corresponding
99    print_what enum.  */
100 static const gdb::optional<enum print_what> print_frame_info_print_what[] =
101   {{}, /* Empty value for "auto".  */
102    SRC_LINE, LOCATION, SRC_AND_LOC, LOC_AND_ADDRESS, SHORT_LOCATION};
103
104 /* The possible choices of "set print entry-values", and the value
105    of this setting.  */
106
107 const char print_entry_values_no[] = "no";
108 const char print_entry_values_only[] = "only";
109 const char print_entry_values_preferred[] = "preferred";
110 const char print_entry_values_if_needed[] = "if-needed";
111 const char print_entry_values_both[] = "both";
112 const char print_entry_values_compact[] = "compact";
113 const char print_entry_values_default[] = "default";
114 static const char *const print_entry_values_choices[] =
115 {
116   print_entry_values_no,
117   print_entry_values_only,
118   print_entry_values_preferred,
119   print_entry_values_if_needed,
120   print_entry_values_both,
121   print_entry_values_compact,
122   print_entry_values_default,
123   NULL
124 };
125
126 /* See frame.h.  */
127 frame_print_options user_frame_print_options;
128
129 /* Option definitions for some frame-related "set print ..."
130    settings.  */
131
132 using boolean_option_def
133   = gdb::option::boolean_option_def<frame_print_options>;
134 using enum_option_def
135   = gdb::option::enum_option_def<frame_print_options>;
136
137 static const gdb::option::option_def frame_print_option_defs[] = {
138
139   enum_option_def {
140     "entry-values",
141     print_entry_values_choices,
142     [] (frame_print_options *opt) { return &opt->print_entry_values; },
143     NULL, /* show_cmd_cb */
144     N_("Set printing of function arguments at function entry."),
145     N_("Show printing of function arguments at function entry."),
146     N_("GDB can sometimes determine the values of function arguments at entry,\n\
147 in addition to their current values.  This option tells GDB whether\n\
148 to print the current value, the value at entry (marked as val@entry),\n\
149 or both.  Note that one or both of these values may be <optimized out>."),
150   },
151
152   enum_option_def {
153     "frame-arguments",
154     print_frame_arguments_choices,
155     [] (frame_print_options *opt) { return &opt->print_frame_arguments; },
156     NULL, /* show_cmd_cb */
157     N_("Set printing of non-scalar frame arguments."),
158     N_("Show printing of non-scalar frame arguments."),
159     NULL /* help_doc */
160   },
161
162   boolean_option_def {
163     "raw-frame-arguments",
164     [] (frame_print_options *opt) { return &opt->print_raw_frame_arguments; },
165     NULL, /* show_cmd_cb */
166     N_("Set whether to print frame arguments in raw form."),
167     N_("Show whether to print frame arguments in raw form."),
168     N_("If set, frame arguments are printed in raw form, bypassing any\n\
169 pretty-printers for that value.")
170   },
171
172   enum_option_def {
173     "frame-info",
174     print_frame_info_choices,
175     [] (frame_print_options *opt) { return &opt->print_frame_info; },
176     NULL, /* show_cmd_cb */
177     N_("Set printing of frame information."),
178     N_("Show printing of frame information."),
179     NULL /* help_doc */
180   }
181
182 };
183
184 /* Options for the "backtrace" command.  */
185
186 struct backtrace_cmd_options
187 {
188   bool full = false;
189   bool no_filters = false;
190   bool hide = false;
191 };
192
193 using bt_flag_option_def
194   = gdb::option::flag_option_def<backtrace_cmd_options>;
195
196 static const gdb::option::option_def backtrace_command_option_defs[] = {
197   bt_flag_option_def {
198     "full",
199     [] (backtrace_cmd_options *opt) { return &opt->full; },
200     N_("Print values of local variables.")
201   },
202
203   bt_flag_option_def {
204     "no-filters",
205     [] (backtrace_cmd_options *opt) { return &opt->no_filters; },
206     N_("Prohibit frame filters from executing on a backtrace."),
207   },
208
209   bt_flag_option_def {
210     "hide",
211     [] (backtrace_cmd_options *opt) { return &opt->hide; },
212     N_("Causes Python frame filter elided frames to not be printed."),
213   },
214 };
215
216 /* Prototypes for local functions.  */
217
218 static void print_frame_local_vars (struct frame_info *frame,
219                                     bool quiet,
220                                     const char *regexp, const char *t_regexp,
221                                     int num_tabs, struct ui_file *stream);
222
223 static void print_frame (const frame_print_options &opts,
224                          frame_info *frame, int print_level,
225                          enum print_what print_what,  int print_args,
226                          struct symtab_and_line sal);
227
228 static struct frame_info *find_frame_for_function (const char *);
229 static struct frame_info *find_frame_for_address (CORE_ADDR);
230
231 /* Zero means do things normally; we are interacting directly with the
232    user.  One means print the full filename and linenumber when a
233    frame is printed, and do so in a format emacs18/emacs19.22 can
234    parse.  Two means print similar annotations, but in many more
235    cases and in a slightly different syntax.  */
236
237 int annotation_level = 0;
238
239 /* Class used to manage tracking the last symtab we displayed.  */
240
241 class last_displayed_symtab_info_type
242 {
243 public:
244   /* True if the cached information is valid.  */
245   bool is_valid () const
246   { return m_valid; }
247
248   /* Return the cached program_space.  If the cache is invalid nullptr is
249      returned.  */
250   struct program_space *pspace () const
251   { return m_pspace; }
252
253   /* Return the cached CORE_ADDR address.  If the cache is invalid 0 is
254      returned.  */
255   CORE_ADDR address () const
256   { return m_address; }
257
258   /* Return the cached symtab.  If the cache is invalid nullptr is
259      returned.  */
260   struct symtab *symtab () const
261   { return m_symtab; }
262
263   /* Return the cached line number.  If the cache is invalid 0 is
264      returned.  */
265   int line () const
266   { return m_line; }
267
268   /* Invalidate the cache, reset all the members to their default value.  */
269   void invalidate ()
270   {
271     m_valid = false;
272     m_pspace = nullptr;
273     m_address = 0;
274     m_symtab = nullptr;
275     m_line = 0;
276   }
277
278   /* Store a new set of values in the cache.  */
279   void set (struct program_space *pspace, CORE_ADDR address,
280             struct symtab *symtab, int line)
281   {
282     gdb_assert (pspace != nullptr);
283
284     m_valid = true;
285     m_pspace = pspace;
286     m_address = address;
287     m_symtab = symtab;
288     m_line = line;
289   }
290
291 private:
292   /* True when the cache is valid.  */
293   bool m_valid = false;
294
295   /* The last program space displayed.  */
296   struct program_space *m_pspace = nullptr;
297
298   /* The last address displayed.  */
299   CORE_ADDR m_address = 0;
300
301   /* The last symtab displayed.  */
302   struct symtab *m_symtab = nullptr;
303
304   /* The last line number displayed.  */
305   int m_line = 0;
306 };
307
308 /* An actual instance of the cache, holds information about the last symtab
309    displayed.  */
310 static last_displayed_symtab_info_type last_displayed_symtab_info;
311
312 \f
313
314 /* See stack.h.  */
315
316 bool
317 frame_show_address (struct frame_info *frame,
318                     struct symtab_and_line sal)
319 {
320   /* If there is a line number, but no PC, then there is no location
321      information associated with this sal.  The only way that should
322      happen is for the call sites of inlined functions (SAL comes from
323      find_frame_sal).  Otherwise, we would have some PC range if the
324      SAL came from a line table.  */
325   if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
326     {
327       if (get_next_frame (frame) == NULL)
328         gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
329       else
330         gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
331       return false;
332     }
333
334   return get_frame_pc (frame) != sal.pc || !sal.is_stmt;
335 }
336
337 /* See frame.h.  */
338
339 void
340 print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
341                             int print_level, enum print_what print_what,
342                             int set_current_sal)
343 {
344   scoped_restore save_uiout = make_scoped_restore (&current_uiout, uiout);
345
346   print_stack_frame (frame, print_level, print_what, set_current_sal);
347 }
348
349 /* Show or print a stack frame FRAME briefly.  The output is formatted
350    according to PRINT_LEVEL and PRINT_WHAT printing the frame's
351    relative level, function name, argument list, and file name and
352    line number.  If the frame's PC is not at the beginning of the
353    source line, the actual PC is printed at the beginning.  */
354
355 void
356 print_stack_frame (struct frame_info *frame, int print_level,
357                    enum print_what print_what,
358                    int set_current_sal)
359 {
360
361   /* For mi, always print location and address.  */
362   if (current_uiout->is_mi_like_p ())
363     print_what = LOC_AND_ADDRESS;
364
365   try
366     {
367       print_frame_info (user_frame_print_options,
368                         frame, print_level, print_what, 1 /* print_args */,
369                         set_current_sal);
370       if (set_current_sal)
371         set_current_sal_from_frame (frame);
372     }
373   catch (const gdb_exception_error &e)
374     {
375     }
376 }
377
378 /* Print nameless arguments of frame FRAME on STREAM, where START is
379    the offset of the first nameless argument, and NUM is the number of
380    nameless arguments to print.  FIRST is nonzero if this is the first
381    argument (not just the first nameless argument).  */
382
383 static void
384 print_frame_nameless_args (struct frame_info *frame, long start, int num,
385                            int first, struct ui_file *stream)
386 {
387   struct gdbarch *gdbarch = get_frame_arch (frame);
388   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
389   int i;
390   CORE_ADDR argsaddr;
391   long arg_value;
392
393   for (i = 0; i < num; i++)
394     {
395       QUIT;
396       argsaddr = get_frame_args_address (frame);
397       if (!argsaddr)
398         return;
399       arg_value = read_memory_integer (argsaddr + start,
400                                        sizeof (int), byte_order);
401       if (!first)
402         fprintf_filtered (stream, ", ");
403       fprintf_filtered (stream, "%ld", arg_value);
404       first = 0;
405       start += sizeof (int);
406     }
407 }
408
409 /* Print single argument of inferior function.  ARG must be already
410    read in.
411
412    Errors are printed as if they would be the parameter value.  Use zeroed ARG
413    iff it should not be printed according to user settings.  */
414
415 static void
416 print_frame_arg (const frame_print_options &fp_opts,
417                  const struct frame_arg *arg)
418 {
419   struct ui_out *uiout = current_uiout;
420
421   string_file stb;
422
423   gdb_assert (!arg->val || !arg->error);
424   gdb_assert (arg->entry_kind == print_entry_values_no
425               || arg->entry_kind == print_entry_values_only
426               || (!uiout->is_mi_like_p ()
427                   && arg->entry_kind == print_entry_values_compact));
428
429   annotate_arg_emitter arg_emitter;
430   ui_out_emit_tuple tuple_emitter (uiout, NULL);
431   fputs_filtered (arg->sym->print_name (), &stb);
432   if (arg->entry_kind == print_entry_values_compact)
433     {
434       /* It is OK to provide invalid MI-like stream as with
435          PRINT_ENTRY_VALUE_COMPACT we never use MI.  */
436       stb.puts ("=");
437
438       fputs_filtered (arg->sym->print_name (), &stb);
439     }
440   if (arg->entry_kind == print_entry_values_only
441       || arg->entry_kind == print_entry_values_compact)
442     stb.puts ("@entry");
443   uiout->field_stream ("name", stb, variable_name_style.style ());
444   annotate_arg_name_end ();
445   uiout->text ("=");
446
447   ui_file_style style;
448   if (!arg->val && !arg->error)
449     uiout->text ("...");
450   else
451     {
452       if (arg->error)
453         {
454           stb.printf (_("<error reading variable: %s>"), arg->error.get ());
455           style = metadata_style.style ();
456         }
457       else
458         {
459           try
460             {
461               const struct language_defn *language;
462               struct value_print_options vp_opts;
463
464               /* Avoid value_print because it will deref ref parameters.  We
465                  just want to print their addresses.  Print ??? for args whose
466                  address we do not know.  We pass 2 as "recurse" to val_print
467                  because our standard indentation here is 4 spaces, and
468                  val_print indents 2 for each recurse.  */ 
469
470               annotate_arg_value (value_type (arg->val));
471
472               /* Use the appropriate language to display our symbol, unless the
473                  user forced the language to a specific language.  */
474               if (language_mode == language_mode_auto)
475                 language = language_def (arg->sym->language ());
476               else
477                 language = current_language;
478
479               get_no_prettyformat_print_options (&vp_opts);
480               vp_opts.deref_ref = 1;
481               vp_opts.raw = fp_opts.print_raw_frame_arguments;
482
483               /* True in "summary" mode, false otherwise.  */
484               vp_opts.summary
485                 = fp_opts.print_frame_arguments == print_frame_arguments_scalars;
486
487               common_val_print_checked (arg->val, &stb, 2, &vp_opts, language);
488             }
489           catch (const gdb_exception_error &except)
490             {
491               stb.printf (_("<error reading variable: %s>"),
492                           except.what ());
493               style = metadata_style.style ();
494             }
495         }
496     }
497
498   uiout->field_stream ("value", stb, style);
499 }
500
501 /* Read in inferior function local SYM at FRAME into ARGP.  Caller is
502    responsible for xfree of ARGP->ERROR.  This function never throws an
503    exception.  */
504
505 void
506 read_frame_local (struct symbol *sym, struct frame_info *frame,
507                   struct frame_arg *argp)
508 {
509   argp->sym = sym;
510   argp->val = NULL;
511   argp->error = NULL;
512
513   try
514     {
515       argp->val = read_var_value (sym, NULL, frame);
516     }
517   catch (const gdb_exception_error &except)
518     {
519       argp->error.reset (xstrdup (except.what ()));
520     }
521 }
522
523 /* Read in inferior function parameter SYM at FRAME into ARGP.  This
524    function never throws an exception.  */
525
526 void
527 read_frame_arg (const frame_print_options &fp_opts,
528                 symbol *sym, frame_info *frame,
529                 struct frame_arg *argp, struct frame_arg *entryargp)
530 {
531   struct value *val = NULL, *entryval = NULL;
532   char *val_error = NULL, *entryval_error = NULL;
533   int val_equal = 0;
534
535   if (fp_opts.print_entry_values != print_entry_values_only
536       && fp_opts.print_entry_values != print_entry_values_preferred)
537     {
538       try
539         {
540           val = read_var_value (sym, NULL, frame);
541         }
542       catch (const gdb_exception_error &except)
543         {
544           val_error = (char *) alloca (except.message->size () + 1);
545           strcpy (val_error, except.what ());
546         }
547     }
548
549   if (SYMBOL_COMPUTED_OPS (sym) != NULL
550       && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
551       && fp_opts.print_entry_values != print_entry_values_no
552       && (fp_opts.print_entry_values != print_entry_values_if_needed
553           || !val || value_optimized_out (val)))
554     {
555       try
556         {
557           const struct symbol_computed_ops *ops;
558
559           ops = SYMBOL_COMPUTED_OPS (sym);
560           entryval = ops->read_variable_at_entry (sym, frame);
561         }
562       catch (const gdb_exception_error &except)
563         {
564           if (except.error != NO_ENTRY_VALUE_ERROR)
565             {
566               entryval_error = (char *) alloca (except.message->size () + 1);
567               strcpy (entryval_error, except.what ());
568             }
569         }
570
571       if (entryval != NULL && value_optimized_out (entryval))
572         entryval = NULL;
573
574       if (fp_opts.print_entry_values == print_entry_values_compact
575           || fp_opts.print_entry_values == print_entry_values_default)
576         {
577           /* For MI do not try to use print_entry_values_compact for ARGP.  */
578
579           if (val && entryval && !current_uiout->is_mi_like_p ())
580             {
581               struct type *type = value_type (val);
582
583               if (value_lazy (val))
584                 value_fetch_lazy (val);
585               if (value_lazy (entryval))
586                 value_fetch_lazy (entryval);
587
588               if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type)))
589                 {
590                   /* Initialize it just to avoid a GCC false warning.  */
591                   struct value *val_deref = NULL, *entryval_deref;
592
593                   /* DW_AT_call_value does match with the current
594                      value.  If it is a reference still try to verify if
595                      dereferenced DW_AT_call_data_value does not differ.  */
596
597                   try
598                     {
599                       struct type *type_deref;
600
601                       val_deref = coerce_ref (val);
602                       if (value_lazy (val_deref))
603                         value_fetch_lazy (val_deref);
604                       type_deref = value_type (val_deref);
605
606                       entryval_deref = coerce_ref (entryval);
607                       if (value_lazy (entryval_deref))
608                         value_fetch_lazy (entryval_deref);
609
610                       /* If the reference addresses match but dereferenced
611                          content does not match print them.  */
612                       if (val != val_deref
613                           && value_contents_eq (val_deref, 0,
614                                                 entryval_deref, 0,
615                                                 TYPE_LENGTH (type_deref)))
616                         val_equal = 1;
617                     }
618                   catch (const gdb_exception_error &except)
619                     {
620                       /* If the dereferenced content could not be
621                          fetched do not display anything.  */
622                       if (except.error == NO_ENTRY_VALUE_ERROR)
623                         val_equal = 1;
624                       else if (except.message != NULL)
625                         {
626                           entryval_error
627                             = (char *) alloca (except.message->size () + 1);
628                           strcpy (entryval_error, except.what ());
629                         }
630                     }
631
632                   /* Value was not a reference; and its content matches.  */
633                   if (val == val_deref)
634                     val_equal = 1;
635
636                   if (val_equal)
637                     entryval = NULL;
638                 }
639             }
640
641           /* Try to remove possibly duplicate error message for ENTRYARGP even
642              in MI mode.  */
643
644           if (val_error && entryval_error
645               && strcmp (val_error, entryval_error) == 0)
646             {
647               entryval_error = NULL;
648
649               /* Do not se VAL_EQUAL as the same error message may be shown for
650                  the entry value even if no entry values are present in the
651                  inferior.  */
652             }
653         }
654     }
655
656   if (entryval == NULL)
657     {
658       if (fp_opts.print_entry_values == print_entry_values_preferred)
659         {
660           gdb_assert (val == NULL);
661
662           try
663             {
664               val = read_var_value (sym, NULL, frame);
665             }
666           catch (const gdb_exception_error &except)
667             {
668               val_error = (char *) alloca (except.message->size () + 1);
669               strcpy (val_error, except.what ());
670             }
671         }
672       if (fp_opts.print_entry_values == print_entry_values_only
673           || fp_opts.print_entry_values == print_entry_values_both
674           || (fp_opts.print_entry_values == print_entry_values_preferred
675               && (!val || value_optimized_out (val))))
676         {
677           entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym));
678           entryval_error = NULL;
679         }
680     }
681   if ((fp_opts.print_entry_values == print_entry_values_compact
682        || fp_opts.print_entry_values == print_entry_values_if_needed
683        || fp_opts.print_entry_values == print_entry_values_preferred)
684       && (!val || value_optimized_out (val)) && entryval != NULL)
685     {
686       val = NULL;
687       val_error = NULL;
688     }
689
690   argp->sym = sym;
691   argp->val = val;
692   argp->error.reset (val_error ? xstrdup (val_error) : NULL);
693   if (!val && !val_error)
694     argp->entry_kind = print_entry_values_only;
695   else if ((fp_opts.print_entry_values == print_entry_values_compact
696            || fp_opts.print_entry_values == print_entry_values_default)
697            && val_equal)
698     {
699       argp->entry_kind = print_entry_values_compact;
700       gdb_assert (!current_uiout->is_mi_like_p ());
701     }
702   else
703     argp->entry_kind = print_entry_values_no;
704
705   entryargp->sym = sym;
706   entryargp->val = entryval;
707   entryargp->error.reset (entryval_error ? xstrdup (entryval_error) : NULL);
708   if (!entryval && !entryval_error)
709     entryargp->entry_kind = print_entry_values_no;
710   else
711     entryargp->entry_kind = print_entry_values_only;
712 }
713
714 /* Print the arguments of frame FRAME on STREAM, given the function
715    FUNC running in that frame (as a symbol), where NUM is the number
716    of arguments according to the stack frame (or -1 if the number of
717    arguments is unknown).  */
718
719 /* Note that currently the "number of arguments according to the
720    stack frame" is only known on VAX where i refers to the "number of
721    ints of arguments according to the stack frame".  */
722
723 static void
724 print_frame_args (const frame_print_options &fp_opts,
725                   struct symbol *func, struct frame_info *frame,
726                   int num, struct ui_file *stream)
727 {
728   struct ui_out *uiout = current_uiout;
729   int first = 1;
730   /* Offset of next stack argument beyond the one we have seen that is
731      at the highest offset, or -1 if we haven't come to a stack
732      argument yet.  */
733   long highest_offset = -1;
734   /* Number of ints of arguments that we have printed so far.  */
735   int args_printed = 0;
736   /* True if we should print arg names.  If false, we only indicate
737      the presence of arguments by printing ellipsis.  */
738   bool print_names
739     = fp_opts.print_frame_arguments != print_frame_arguments_presence;
740   /* True if we should print arguments, false otherwise.  */
741   bool print_args
742     = (print_names
743        && fp_opts.print_frame_arguments != print_frame_arguments_none);
744
745   /* Temporarily change the selected frame to the given FRAME.
746      This allows routines that rely on the selected frame instead
747      of being given a frame as parameter to use the correct frame.  */
748   scoped_restore_selected_frame restore_selected_frame;
749   select_frame (frame);
750
751   if (func)
752     {
753       const struct block *b = SYMBOL_BLOCK_VALUE (func);
754       struct block_iterator iter;
755       struct symbol *sym;
756
757       ALL_BLOCK_SYMBOLS (b, iter, sym)
758         {
759           struct frame_arg arg, entryarg;
760
761           QUIT;
762
763           /* Keep track of the highest stack argument offset seen, and
764              skip over any kinds of symbols we don't care about.  */
765
766           if (!SYMBOL_IS_ARGUMENT (sym))
767             continue;
768
769           if (!print_names)
770             {
771               uiout->text ("...");
772               first = 0;
773               break;
774             }
775
776           switch (sym->aclass ())
777             {
778             case LOC_ARG:
779             case LOC_REF_ARG:
780               {
781                 long current_offset = SYMBOL_VALUE (sym);
782                 int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
783
784                 /* Compute address of next argument by adding the size of
785                    this argument and rounding to an int boundary.  */
786                 current_offset =
787                   ((current_offset + arg_size + sizeof (int) - 1)
788                    & ~(sizeof (int) - 1));
789
790                 /* If this is the highest offset seen yet, set
791                    highest_offset.  */
792                 if (highest_offset == -1
793                     || (current_offset > highest_offset))
794                   highest_offset = current_offset;
795
796                 /* Add the number of ints we're about to print to
797                    args_printed.  */
798                 args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
799               }
800
801               /* We care about types of symbols, but don't need to
802                  keep track of stack offsets in them.  */
803             case LOC_REGISTER:
804             case LOC_REGPARM_ADDR:
805             case LOC_COMPUTED:
806             case LOC_OPTIMIZED_OUT:
807             default:
808               break;
809             }
810
811           /* We have to look up the symbol because arguments can have
812              two entries (one a parameter, one a local) and the one we
813              want is the local, which lookup_symbol will find for us.
814              This includes gcc1 (not gcc2) on SPARC when passing a
815              small structure and gcc2 when the argument type is float
816              and it is passed as a double and converted to float by
817              the prologue (in the latter case the type of the LOC_ARG
818              symbol is double and the type of the LOC_LOCAL symbol is
819              float).  */
820           /* But if the parameter name is null, don't try it.  Null
821              parameter names occur on the RS/6000, for traceback
822              tables.  FIXME, should we even print them?  */
823
824           if (*sym->linkage_name ())
825             {
826               struct symbol *nsym;
827
828               nsym = lookup_symbol_search_name (sym->search_name (),
829                                                 b, VAR_DOMAIN).symbol;
830               gdb_assert (nsym != NULL);
831               if (nsym->aclass () == LOC_REGISTER
832                   && !SYMBOL_IS_ARGUMENT (nsym))
833                 {
834                   /* There is a LOC_ARG/LOC_REGISTER pair.  This means
835                      that it was passed on the stack and loaded into a
836                      register, or passed in a register and stored in a
837                      stack slot.  GDB 3.x used the LOC_ARG; GDB
838                      4.0-4.11 used the LOC_REGISTER.
839
840                      Reasons for using the LOC_ARG:
841
842                      (1) Because find_saved_registers may be slow for
843                          remote debugging.
844
845                      (2) Because registers are often re-used and stack
846                          slots rarely (never?) are.  Therefore using
847                          the stack slot is much less likely to print
848                          garbage.
849
850                      Reasons why we might want to use the LOC_REGISTER:
851
852                      (1) So that the backtrace prints the same value
853                          as "print foo".  I see no compelling reason
854                          why this needs to be the case; having the
855                          backtrace print the value which was passed
856                          in, and "print foo" print the value as
857                          modified within the called function, makes
858                          perfect sense to me.
859
860                      Additional note: It might be nice if "info args"
861                      displayed both values.
862
863                      One more note: There is a case with SPARC
864                      structure passing where we need to use the
865                      LOC_REGISTER, but this is dealt with by creating
866                      a single LOC_REGPARM in symbol reading.  */
867
868                   /* Leave sym (the LOC_ARG) alone.  */
869                   ;
870                 }
871               else
872                 sym = nsym;
873             }
874
875           /* Print the current arg.  */
876           if (!first)
877             uiout->text (", ");
878           uiout->wrap_hint (4);
879
880           if (!print_args)
881             {
882               arg.sym = sym;
883               arg.entry_kind = print_entry_values_no;
884               entryarg.sym = sym;
885               entryarg.entry_kind = print_entry_values_no;
886             }
887           else
888             read_frame_arg (fp_opts, sym, frame, &arg, &entryarg);
889
890           if (arg.entry_kind != print_entry_values_only)
891             print_frame_arg (fp_opts, &arg);
892
893           if (entryarg.entry_kind != print_entry_values_no)
894             {
895               if (arg.entry_kind != print_entry_values_only)
896                 {
897                   uiout->text (", ");
898                   uiout->wrap_hint (4);
899                 }
900
901               print_frame_arg (fp_opts, &entryarg);
902             }
903
904           first = 0;
905         }
906     }
907
908   /* Don't print nameless args in situations where we don't know
909      enough about the stack to find them.  */
910   if (num != -1)
911     {
912       long start;
913
914       if (highest_offset == -1)
915         start = gdbarch_frame_args_skip (get_frame_arch (frame));
916       else
917         start = highest_offset;
918
919       if (!print_names && !first && num > 0)
920         uiout->text ("...");
921       else
922         print_frame_nameless_args (frame, start, num - args_printed,
923                                    first, stream);
924     }
925 }
926
927 /* Set the current source and line to the location given by frame
928    FRAME, if possible.  When CENTER is true, adjust so the relevant
929    line is in the center of the next 'list'.  */
930
931 void
932 set_current_sal_from_frame (struct frame_info *frame)
933 {
934   symtab_and_line sal = find_frame_sal (frame);
935   if (sal.symtab != NULL)
936     set_current_source_symtab_and_line (sal);
937 }
938
939 /* If ON, GDB will display disassembly of the next source line when
940    execution of the program being debugged stops.
941    If AUTO (which is the default), or there's no line info to determine
942    the source line of the next instruction, display disassembly of next
943    instruction instead.  */
944
945 static enum auto_boolean disassemble_next_line;
946
947 static void
948 show_disassemble_next_line (struct ui_file *file, int from_tty,
949                                  struct cmd_list_element *c,
950                                  const char *value)
951 {
952   fprintf_filtered (file,
953                     _("Debugger's willingness to use "
954                       "disassemble-next-line is %s.\n"),
955                     value);
956 }
957
958 /* Use TRY_CATCH to catch the exception from the gdb_disassembly
959    because it will be broken by filter sometime.  */
960
961 static void
962 do_gdb_disassembly (struct gdbarch *gdbarch,
963                     int how_many, CORE_ADDR low, CORE_ADDR high)
964 {
965
966   try
967     {
968       gdb_disassembly (gdbarch, current_uiout,
969                        DISASSEMBLY_RAW_INSN, how_many,
970                        low, high);
971     }
972   catch (const gdb_exception_error &exception)
973     {
974       /* If an exception was thrown while doing the disassembly, print
975          the error message, to give the user a clue of what happened.  */
976       exception_print (gdb_stderr, exception);
977     }
978 }
979
980 /* Converts the PRINT_FRAME_INFO choice to an optional enum print_what.
981    Value not present indicates to the caller to use default values
982    specific to the command being executed.  */
983
984 static gdb::optional<enum print_what>
985 print_frame_info_to_print_what (const char *print_frame_info)
986 {
987   for (int i = 0; print_frame_info_choices[i] != NULL; i++)
988     if (print_frame_info == print_frame_info_choices[i])
989       return print_frame_info_print_what[i];
990
991   internal_error (__FILE__, __LINE__,
992                   "Unexpected print frame-info value `%s'.",
993                   print_frame_info);
994 }
995
996 /* Print the PC from FRAME, plus any flags, to UIOUT.  */
997
998 static void
999 print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info *frame,
1000           CORE_ADDR pc)
1001 {
1002   uiout->field_core_addr ("addr", gdbarch, pc);
1003
1004   std::string flags = gdbarch_get_pc_address_flags (gdbarch, frame, pc);
1005   if (!flags.empty ())
1006     {
1007       uiout->text (" [");
1008       uiout->field_string ("addr_flags", flags);
1009       uiout->text ("]");
1010     }
1011 }
1012
1013 /* See stack.h.  */
1014
1015 void
1016 get_user_print_what_frame_info (gdb::optional<enum print_what> *what)
1017 {
1018   *what
1019     = print_frame_info_to_print_what
1020         (user_frame_print_options.print_frame_info);
1021 }
1022
1023 /* Print information about frame FRAME.  The output is format according
1024    to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS.  For the meaning of
1025    PRINT_WHAT, see enum print_what comments in frame.h.
1026    Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info
1027    != print_frame_info_auto.
1028
1029    Used in "where" output, and to emit breakpoint or step
1030    messages.  */
1031
1032 void
1033 print_frame_info (const frame_print_options &fp_opts,
1034                   frame_info *frame, int print_level,
1035                   enum print_what print_what, int print_args,
1036                   int set_current_sal)
1037 {
1038   struct gdbarch *gdbarch = get_frame_arch (frame);
1039   int source_print;
1040   int location_print;
1041   struct ui_out *uiout = current_uiout;
1042
1043   if (!current_uiout->is_mi_like_p ()
1044       && fp_opts.print_frame_info != print_frame_info_auto)
1045     {
1046       /* Use the specific frame information desired by the user.  */
1047       print_what = *print_frame_info_to_print_what (fp_opts.print_frame_info);
1048     }
1049
1050   if (get_frame_type (frame) == DUMMY_FRAME
1051       || get_frame_type (frame) == SIGTRAMP_FRAME
1052       || get_frame_type (frame) == ARCH_FRAME)
1053     {
1054       ui_out_emit_tuple tuple_emitter (uiout, "frame");
1055
1056       annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1057                             gdbarch, get_frame_pc (frame));
1058
1059       /* Do this regardless of SOURCE because we don't have any source
1060          to list for this frame.  */
1061       if (print_level)
1062         {
1063           uiout->text ("#");
1064           uiout->field_fmt_signed (2, ui_left, "level",
1065                                    frame_relative_level (frame));
1066         }
1067       if (uiout->is_mi_like_p ())
1068         {
1069           annotate_frame_address ();
1070           print_pc (uiout, gdbarch, frame, get_frame_pc (frame));
1071           annotate_frame_address_end ();
1072         }
1073
1074       if (get_frame_type (frame) == DUMMY_FRAME)
1075         {
1076           annotate_function_call ();
1077           uiout->field_string ("func", "<function called from gdb>",
1078                                metadata_style.style ());
1079         }
1080       else if (get_frame_type (frame) == SIGTRAMP_FRAME)
1081         {
1082           annotate_signal_handler_caller ();
1083           uiout->field_string ("func", "<signal handler called>",
1084                                metadata_style.style ());
1085         }
1086       else if (get_frame_type (frame) == ARCH_FRAME)
1087         {
1088           uiout->field_string ("func", "<cross-architecture call>",
1089                                metadata_style.style ());
1090         }
1091       uiout->text ("\n");
1092       annotate_frame_end ();
1093
1094       /* If disassemble-next-line is set to auto or on output the next
1095          instruction.  */
1096       if (disassemble_next_line == AUTO_BOOLEAN_AUTO
1097           || disassemble_next_line == AUTO_BOOLEAN_TRUE)
1098         do_gdb_disassembly (get_frame_arch (frame), 1,
1099                             get_frame_pc (frame), get_frame_pc (frame) + 1);
1100
1101       return;
1102     }
1103
1104   /* If FRAME is not the innermost frame, that normally means that
1105      FRAME->pc points to *after* the call instruction, and we want to
1106      get the line containing the call, never the next line.  But if
1107      the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
1108      next frame was not entered as the result of a call, and we want
1109      to get the line containing FRAME->pc.  */
1110   symtab_and_line sal = find_frame_sal (frame);
1111
1112   location_print = (print_what == LOCATION
1113                     || print_what == SRC_AND_LOC
1114                     || print_what == LOC_AND_ADDRESS
1115                     || print_what == SHORT_LOCATION);
1116   if (location_print || !sal.symtab)
1117     print_frame (fp_opts, frame, print_level, print_what, print_args, sal);
1118
1119   source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
1120
1121   /* If disassemble-next-line is set to auto or on and doesn't have
1122      the line debug messages for $pc, output the next instruction.  */
1123   if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
1124        || disassemble_next_line == AUTO_BOOLEAN_TRUE)
1125       && source_print && !sal.symtab)
1126     do_gdb_disassembly (get_frame_arch (frame), 1,
1127                         get_frame_pc (frame), get_frame_pc (frame) + 1);
1128
1129   if (source_print && sal.symtab)
1130     {
1131       int mid_statement = ((print_what == SRC_LINE)
1132                            && frame_show_address (frame, sal));
1133       if (annotation_level > 0
1134           && annotate_source_line (sal.symtab, sal.line, mid_statement,
1135                                    get_frame_pc (frame)))
1136         {
1137           /* The call to ANNOTATE_SOURCE_LINE already printed the
1138              annotation for this source line, so we avoid the two cases
1139              below and do not print the actual source line.  The
1140              documentation for annotations makes it clear that the source
1141              line annotation is printed __instead__ of printing the source
1142              line, not as well as.
1143
1144              However, if we fail to print the source line, which usually
1145              means either the source file is missing, or the requested
1146              line is out of range of the file, then we don't print the
1147              source annotation, and will pass through the "normal" print
1148              source line code below, the expectation is that this code
1149              will print an appropriate error.  */
1150         }
1151       else if (deprecated_print_frame_info_listing_hook)
1152         deprecated_print_frame_info_listing_hook (sal.symtab, sal.line,
1153                                                   sal.line + 1, 0);
1154       else
1155         {
1156           struct value_print_options opts;
1157
1158           get_user_print_options (&opts);
1159           /* We used to do this earlier, but that is clearly
1160              wrong.  This function is used by many different
1161              parts of gdb, including normal_stop in infrun.c,
1162              which uses this to print out the current PC
1163              when we stepi/nexti into the middle of a source
1164              line.  Only the command line really wants this
1165              behavior.  Other UIs probably would like the
1166              ability to decide for themselves if it is desired.  */
1167           if (opts.addressprint && mid_statement)
1168             {
1169               print_pc (uiout, gdbarch, frame, get_frame_pc (frame));
1170               uiout->text ("\t");
1171             }
1172
1173           print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1174         }
1175
1176       /* If disassemble-next-line is set to on and there is line debug
1177          messages, output assembly codes for next line.  */
1178       if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
1179         do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
1180     }
1181
1182   if (set_current_sal)
1183     {
1184       CORE_ADDR pc;
1185
1186       if (get_frame_pc_if_available (frame, &pc))
1187         last_displayed_symtab_info.set (sal.pspace, pc, sal.symtab, sal.line);
1188       else
1189         last_displayed_symtab_info.invalidate ();
1190     }
1191
1192   annotate_frame_end ();
1193
1194   gdb_flush (gdb_stdout);
1195 }
1196
1197 /* See stack.h.  */
1198
1199 void
1200 clear_last_displayed_sal (void)
1201 {
1202   last_displayed_symtab_info.invalidate ();
1203 }
1204
1205 /* See stack.h.  */
1206
1207 bool
1208 last_displayed_sal_is_valid (void)
1209 {
1210   return last_displayed_symtab_info.is_valid ();
1211 }
1212
1213 /* See stack.h.  */
1214
1215 struct program_space *
1216 get_last_displayed_pspace (void)
1217 {
1218   return last_displayed_symtab_info.pspace ();
1219 }
1220
1221 /* See stack.h.  */
1222
1223 CORE_ADDR
1224 get_last_displayed_addr (void)
1225 {
1226   return last_displayed_symtab_info.address ();
1227 }
1228
1229 /* See stack.h.  */
1230
1231 struct symtab*
1232 get_last_displayed_symtab (void)
1233 {
1234   return last_displayed_symtab_info.symtab ();
1235 }
1236
1237 /* See stack.h.  */
1238
1239 int
1240 get_last_displayed_line (void)
1241 {
1242   return last_displayed_symtab_info.line ();
1243 }
1244
1245 /* See stack.h.  */
1246
1247 symtab_and_line
1248 get_last_displayed_sal ()
1249 {
1250   symtab_and_line sal;
1251
1252   if (last_displayed_symtab_info.is_valid ())
1253     {
1254       sal.pspace = last_displayed_symtab_info.pspace ();
1255       sal.pc = last_displayed_symtab_info.address ();
1256       sal.symtab = last_displayed_symtab_info.symtab ();
1257       sal.line = last_displayed_symtab_info.line ();
1258     }
1259
1260   return sal;
1261 }
1262
1263
1264 /* Attempt to obtain the name, FUNLANG and optionally FUNCP of the function
1265    corresponding to FRAME.  */
1266
1267 gdb::unique_xmalloc_ptr<char>
1268 find_frame_funname (struct frame_info *frame, enum language *funlang,
1269                     struct symbol **funcp)
1270 {
1271   struct symbol *func;
1272   gdb::unique_xmalloc_ptr<char> funname;
1273
1274   *funlang = language_unknown;
1275   if (funcp)
1276     *funcp = NULL;
1277
1278   func = get_frame_function (frame);
1279   if (func)
1280     {
1281       const char *print_name = func->print_name ();
1282
1283       *funlang = func->language ();
1284       if (funcp)
1285         *funcp = func;
1286       if (*funlang == language_cplus)
1287         {
1288           /* It seems appropriate to use print_name() here,
1289              to display the demangled name that we already have
1290              stored in the symbol table, but we stored a version
1291              with DMGL_PARAMS turned on, and here we don't want to
1292              display parameters.  So remove the parameters.  */
1293           funname = cp_remove_params (print_name);
1294         }
1295
1296       /* If we didn't hit the C++ case above, set *funname
1297          here.  */
1298       if (funname == NULL)
1299         funname.reset (xstrdup (print_name));
1300     }
1301   else
1302     {
1303       struct bound_minimal_symbol msymbol;
1304       CORE_ADDR pc;
1305
1306       if (!get_frame_address_in_block_if_available (frame, &pc))
1307         return funname;
1308
1309       msymbol = lookup_minimal_symbol_by_pc (pc);
1310       if (msymbol.minsym != NULL)
1311         {
1312           funname.reset (xstrdup (msymbol.minsym->print_name ()));
1313           *funlang = msymbol.minsym->language ();
1314         }
1315     }
1316
1317   return funname;
1318 }
1319
1320 static void
1321 print_frame (const frame_print_options &fp_opts,
1322              frame_info *frame, int print_level,
1323              enum print_what print_what, int print_args,
1324              struct symtab_and_line sal)
1325 {
1326   struct gdbarch *gdbarch = get_frame_arch (frame);
1327   struct ui_out *uiout = current_uiout;
1328   enum language funlang = language_unknown;
1329   struct value_print_options opts;
1330   struct symbol *func;
1331   CORE_ADDR pc = 0;
1332   int pc_p;
1333
1334   pc_p = get_frame_pc_if_available (frame, &pc);
1335
1336   gdb::unique_xmalloc_ptr<char> funname
1337     = find_frame_funname (frame, &funlang, &func);
1338
1339   annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
1340                         gdbarch, pc);
1341
1342   {
1343     ui_out_emit_tuple tuple_emitter (uiout, "frame");
1344
1345     if (print_level)
1346       {
1347         uiout->text ("#");
1348         uiout->field_fmt_signed (2, ui_left, "level",
1349                                  frame_relative_level (frame));
1350       }
1351     get_user_print_options (&opts);
1352     if (opts.addressprint)
1353       if (!sal.symtab
1354           || frame_show_address (frame, sal)
1355           || print_what == LOC_AND_ADDRESS)
1356         {
1357           annotate_frame_address ();
1358           if (pc_p)
1359             print_pc (uiout, gdbarch, frame, pc);
1360           else
1361             uiout->field_string ("addr", "<unavailable>",
1362                                  metadata_style.style ());
1363           annotate_frame_address_end ();
1364           uiout->text (" in ");
1365         }
1366     annotate_frame_function_name ();
1367
1368     string_file stb;
1369     fputs_filtered (funname ? funname.get () : "??", &stb);
1370     uiout->field_stream ("func", stb, function_name_style.style ());
1371     uiout->wrap_hint (3);
1372     annotate_frame_args ();
1373
1374     uiout->text (" (");
1375     if (print_args)
1376       {
1377         int numargs;
1378
1379         if (gdbarch_frame_num_args_p (gdbarch))
1380           {
1381             numargs = gdbarch_frame_num_args (gdbarch, frame);
1382             gdb_assert (numargs >= 0);
1383           }
1384         else
1385           numargs = -1;
1386     
1387         {
1388           ui_out_emit_list list_emitter (uiout, "args");
1389           try
1390             {
1391               print_frame_args (fp_opts, func, frame, numargs, gdb_stdout);
1392             }
1393           catch (const gdb_exception_error &e)
1394             {
1395             }
1396
1397             /* FIXME: ARGS must be a list.  If one argument is a string it
1398                will have " that will not be properly escaped.  */
1399             }
1400         QUIT;
1401       }
1402     uiout->text (")");
1403     if (print_what != SHORT_LOCATION && sal.symtab)
1404       {
1405         const char *filename_display;
1406       
1407         filename_display = symtab_to_filename_for_display (sal.symtab);
1408         annotate_frame_source_begin ();
1409         uiout->wrap_hint (3);
1410         uiout->text (" at ");
1411         annotate_frame_source_file ();
1412         uiout->field_string ("file", filename_display,
1413                              file_name_style.style ());
1414         if (uiout->is_mi_like_p ())
1415           {
1416             const char *fullname = symtab_to_fullname (sal.symtab);
1417
1418             uiout->field_string ("fullname", fullname);
1419           }
1420         annotate_frame_source_file_end ();
1421         uiout->text (":");
1422         annotate_frame_source_line ();
1423         uiout->field_signed ("line", sal.line);
1424         annotate_frame_source_end ();
1425       }
1426
1427     if (print_what != SHORT_LOCATION
1428         && pc_p && (funname == NULL || sal.symtab == NULL))
1429       {
1430         char *lib = solib_name_from_address (get_frame_program_space (frame),
1431                                              get_frame_pc (frame));
1432
1433         if (lib)
1434           {
1435             annotate_frame_where ();
1436             uiout->wrap_hint (2);
1437             uiout->text (" from ");
1438             uiout->field_string ("from", lib, file_name_style.style ());
1439           }
1440       }
1441     if (uiout->is_mi_like_p ())
1442       uiout->field_string ("arch",
1443                            (gdbarch_bfd_arch_info (gdbarch))->printable_name);
1444   }
1445
1446   uiout->text ("\n");
1447 }
1448 \f
1449
1450 /* Completion function for "frame function", "info frame function", and
1451    "select-frame function" commands.  */
1452
1453 static void
1454 frame_selection_by_function_completer (struct cmd_list_element *ignore,
1455                                        completion_tracker &tracker,
1456                                        const char *text, const char *word)
1457 {
1458   /* This is used to complete function names within a stack.  It would be
1459      nice if we only offered functions that were actually in the stack.
1460      However, this would mean unwinding the stack to completion, which
1461      could take too long, or on a corrupted stack, possibly not end.
1462      Instead, we offer all symbol names as a safer choice.  */
1463   collect_symbol_completion_matches (tracker,
1464                                      complete_symbol_mode::EXPRESSION,
1465                                      symbol_name_match_type::EXPRESSION,
1466                                      text, word);
1467 }
1468
1469 /* Core of all the "info frame" sub-commands.  Print information about a
1470    frame FI.  If SELECTED_FRAME_P is true then the user didn't provide a
1471    frame specification, they just entered 'info frame'.  If the user did
1472    provide a frame specification (for example 'info frame 0', 'info frame
1473    level 1') then SELECTED_FRAME_P will be false.  */
1474
1475 static void
1476 info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
1477 {
1478   struct symbol *func;
1479   struct symtab *s;
1480   struct frame_info *calling_frame_info;
1481   int numregs;
1482   const char *funname = 0;
1483   enum language funlang = language_unknown;
1484   const char *pc_regname;
1485   struct gdbarch *gdbarch;
1486   CORE_ADDR frame_pc;
1487   int frame_pc_p;
1488   /* Initialize it to avoid "may be used uninitialized" warning.  */
1489   CORE_ADDR caller_pc = 0;
1490   int caller_pc_p = 0;
1491
1492   gdbarch = get_frame_arch (fi);
1493
1494   /* Name of the value returned by get_frame_pc().  Per comments, "pc"
1495      is not a good name.  */
1496   if (gdbarch_pc_regnum (gdbarch) >= 0)
1497     /* OK, this is weird.  The gdbarch_pc_regnum hardware register's value can
1498        easily not match that of the internal value returned by
1499        get_frame_pc().  */
1500     pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
1501   else
1502     /* But then, this is weird to.  Even without gdbarch_pc_regnum, an
1503        architectures will often have a hardware register called "pc",
1504        and that register's value, again, can easily not match
1505        get_frame_pc().  */
1506     pc_regname = "pc";
1507
1508   frame_pc_p = get_frame_pc_if_available (fi, &frame_pc);
1509   func = get_frame_function (fi);
1510   symtab_and_line sal = find_frame_sal (fi);
1511   s = sal.symtab;
1512   gdb::unique_xmalloc_ptr<char> func_only;
1513   if (func)
1514     {
1515       funname = func->print_name ();
1516       funlang = func->language ();
1517       if (funlang == language_cplus)
1518         {
1519           /* It seems appropriate to use print_name() here,
1520              to display the demangled name that we already have
1521              stored in the symbol table, but we stored a version
1522              with DMGL_PARAMS turned on, and here we don't want to
1523              display parameters.  So remove the parameters.  */
1524           func_only = cp_remove_params (funname);
1525
1526           if (func_only)
1527             funname = func_only.get ();
1528         }
1529     }
1530   else if (frame_pc_p)
1531     {
1532       struct bound_minimal_symbol msymbol;
1533
1534       msymbol = lookup_minimal_symbol_by_pc (frame_pc);
1535       if (msymbol.minsym != NULL)
1536         {
1537           funname = msymbol.minsym->print_name ();
1538           funlang = msymbol.minsym->language ();
1539         }
1540     }
1541   calling_frame_info = get_prev_frame (fi);
1542
1543   if (selected_frame_p && frame_relative_level (fi) >= 0)
1544     {
1545       printf_filtered (_("Stack level %d, frame at "),
1546                        frame_relative_level (fi));
1547     }
1548   else
1549     {
1550       printf_filtered (_("Stack frame at "));
1551     }
1552   puts_filtered (paddress (gdbarch, get_frame_base (fi)));
1553   printf_filtered (":\n");
1554   printf_filtered (" %s = ", pc_regname);
1555   if (frame_pc_p)
1556     puts_filtered (paddress (gdbarch, get_frame_pc (fi)));
1557   else
1558     fputs_styled ("<unavailable>", metadata_style.style (), gdb_stdout);
1559
1560   gdb_stdout->wrap_here (3);
1561   if (funname)
1562     {
1563       printf_filtered (" in ");
1564       puts_filtered (funname);
1565     }
1566   gdb_stdout->wrap_here (3);
1567   if (sal.symtab)
1568     printf_filtered
1569       (" (%ps:%d)",
1570        styled_string (file_name_style.style (),
1571                       symtab_to_filename_for_display (sal.symtab)),
1572        sal.line);
1573   puts_filtered ("; ");
1574   gdb_stdout->wrap_here (4);
1575   printf_filtered ("saved %s = ", pc_regname);
1576
1577   if (!frame_id_p (frame_unwind_caller_id (fi)))
1578     val_print_not_saved (gdb_stdout);
1579   else
1580     {
1581       try
1582         {
1583           caller_pc = frame_unwind_caller_pc (fi);
1584           caller_pc_p = 1;
1585         }
1586       catch (const gdb_exception_error &ex)
1587         {
1588           switch (ex.error)
1589             {
1590             case NOT_AVAILABLE_ERROR:
1591               val_print_unavailable (gdb_stdout);
1592               break;
1593             case OPTIMIZED_OUT_ERROR:
1594               val_print_not_saved (gdb_stdout);
1595               break;
1596             default:
1597               fprintf_styled (gdb_stdout, metadata_style.style (),
1598                               _("<error: %s>"),
1599                               ex.what ());
1600               break;
1601             }
1602         }
1603     }
1604
1605   if (caller_pc_p)
1606     puts_filtered (paddress (gdbarch, caller_pc));
1607   printf_filtered ("\n");
1608
1609   if (calling_frame_info == NULL)
1610     {
1611       enum unwind_stop_reason reason;
1612
1613       reason = get_frame_unwind_stop_reason (fi);
1614       if (reason != UNWIND_NO_REASON)
1615         printf_filtered (_(" Outermost frame: %s\n"),
1616                          frame_stop_reason_string (fi));
1617     }
1618   else if (get_frame_type (fi) == TAILCALL_FRAME)
1619     puts_filtered (" tail call frame");
1620   else if (get_frame_type (fi) == INLINE_FRAME)
1621     printf_filtered (" inlined into frame %d",
1622                      frame_relative_level (get_prev_frame (fi)));
1623   else
1624     {
1625       printf_filtered (" called by frame at ");
1626       puts_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)));
1627     }
1628   if (get_next_frame (fi) && calling_frame_info)
1629     puts_filtered (",");
1630   gdb_stdout->wrap_here (3);
1631   if (get_next_frame (fi))
1632     {
1633       printf_filtered (" caller of frame at ");
1634       puts_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))));
1635     }
1636   if (get_next_frame (fi) || calling_frame_info)
1637     puts_filtered ("\n");
1638
1639   if (s)
1640     printf_filtered (" source language %s.\n",
1641                      language_str (s->language ()));
1642
1643   {
1644     /* Address of the argument list for this frame, or 0.  */
1645     CORE_ADDR arg_list = get_frame_args_address (fi);
1646     /* Number of args for this frame, or -1 if unknown.  */
1647     int numargs;
1648
1649     if (arg_list == 0)
1650       printf_filtered (" Arglist at unknown address.\n");
1651     else
1652       {
1653         printf_filtered (" Arglist at ");
1654         puts_filtered (paddress (gdbarch, arg_list));
1655         printf_filtered (",");
1656
1657         if (!gdbarch_frame_num_args_p (gdbarch))
1658           {
1659             numargs = -1;
1660             puts_filtered (" args: ");
1661           }
1662         else
1663           {
1664             numargs = gdbarch_frame_num_args (gdbarch, fi);
1665             gdb_assert (numargs >= 0);
1666             if (numargs == 0)
1667               puts_filtered (" no args.");
1668             else if (numargs == 1)
1669               puts_filtered (" 1 arg: ");
1670             else
1671               printf_filtered (" %d args: ", numargs);
1672           }
1673         print_frame_args (user_frame_print_options,
1674                           func, fi, numargs, gdb_stdout);
1675         puts_filtered ("\n");
1676       }
1677   }
1678   {
1679     /* Address of the local variables for this frame, or 0.  */
1680     CORE_ADDR arg_list = get_frame_locals_address (fi);
1681
1682     if (arg_list == 0)
1683       printf_filtered (" Locals at unknown address,");
1684     else
1685       {
1686         printf_filtered (" Locals at ");
1687         puts_filtered (paddress (gdbarch, arg_list));
1688         printf_filtered (",");
1689       }
1690   }
1691
1692   /* Print as much information as possible on the location of all the
1693      registers.  */
1694   {
1695     int count;
1696     int i;
1697     int need_nl = 1;
1698     int sp_regnum = gdbarch_sp_regnum (gdbarch);
1699
1700     /* The sp is special; what's displayed isn't the save address, but
1701        the value of the previous frame's sp.  This is a legacy thing,
1702        at one stage the frame cached the previous frame's SP instead
1703        of its address, hence it was easiest to just display the cached
1704        value.  */
1705     if (sp_regnum >= 0)
1706       {
1707         struct value *value = frame_unwind_register_value (fi, sp_regnum);
1708         gdb_assert (value != NULL);
1709
1710         if (!value_optimized_out (value) && value_entirely_available (value))
1711           {
1712             if (VALUE_LVAL (value) == not_lval)
1713               {
1714                 CORE_ADDR sp;
1715                 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1716                 int sp_size = register_size (gdbarch, sp_regnum);
1717
1718                 sp = extract_unsigned_integer
1719                   (value_contents_all (value).data (), sp_size, byte_order);
1720
1721                 printf_filtered (" Previous frame's sp is ");
1722                 puts_filtered (paddress (gdbarch, sp));
1723                 printf_filtered ("\n");
1724               }
1725             else if (VALUE_LVAL (value) == lval_memory)
1726               {
1727                 printf_filtered (" Previous frame's sp at ");
1728                 puts_filtered (paddress (gdbarch, value_address (value)));
1729                 printf_filtered ("\n");
1730               }
1731             else if (VALUE_LVAL (value) == lval_register)
1732               {
1733                 printf_filtered (" Previous frame's sp in %s\n",
1734                                  gdbarch_register_name (gdbarch,
1735                                                         VALUE_REGNUM (value)));
1736               }
1737
1738             release_value (value);
1739             need_nl = 0;
1740           }
1741         /* else keep quiet.  */
1742       }
1743
1744     count = 0;
1745     numregs = gdbarch_num_cooked_regs (gdbarch);
1746     for (i = 0; i < numregs; i++)
1747       if (i != sp_regnum
1748           && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
1749         {
1750           enum lval_type lval;
1751           int optimized;
1752           int unavailable;
1753           CORE_ADDR addr;
1754           int realnum;
1755
1756           /* Find out the location of the saved register without
1757              fetching the corresponding value.  */
1758           frame_register_unwind (fi, i, &optimized, &unavailable,
1759                                  &lval, &addr, &realnum, NULL);
1760           /* For moment, only display registers that were saved on the
1761              stack.  */
1762           if (!optimized && !unavailable && lval == lval_memory)
1763             {
1764               if (count == 0)
1765                 puts_filtered (" Saved registers:\n ");
1766               else
1767                 puts_filtered (",");
1768               gdb_stdout->wrap_here (1);
1769               printf_filtered (" %s at ",
1770                                gdbarch_register_name (gdbarch, i));
1771               puts_filtered (paddress (gdbarch, addr));
1772               count++;
1773             }
1774         }
1775     if (count || need_nl)
1776       puts_filtered ("\n");
1777   }
1778 }
1779
1780 /* Return the innermost frame at level LEVEL.  */
1781
1782 static struct frame_info *
1783 leading_innermost_frame (int level)
1784 {
1785   struct frame_info *leading;
1786
1787   leading = get_current_frame ();
1788
1789   gdb_assert (level >= 0);
1790
1791   while (leading != nullptr && level)
1792     {
1793       QUIT;
1794       leading = get_prev_frame (leading);
1795       level--;
1796     }
1797
1798   return leading;
1799 }
1800
1801 /* Return the starting frame needed to handle COUNT outermost frames.  */
1802
1803 static struct frame_info *
1804 trailing_outermost_frame (int count)
1805 {
1806   struct frame_info *current;
1807   struct frame_info *trailing;
1808
1809   trailing = get_current_frame ();
1810
1811   gdb_assert (count > 0);
1812
1813   current = trailing;
1814   while (current != nullptr && count--)
1815     {
1816       QUIT;
1817       current = get_prev_frame (current);
1818     }
1819
1820   /* Will stop when CURRENT reaches the top of the stack.
1821      TRAILING will be COUNT below it.  */
1822   while (current != nullptr)
1823     {
1824       QUIT;
1825       trailing = get_prev_frame (trailing);
1826       current = get_prev_frame (current);
1827     }
1828
1829   return trailing;
1830 }
1831
1832 /* The core of all the "select-frame" sub-commands.  Just wraps a call to
1833    SELECT_FRAME.  */
1834
1835 static void
1836 select_frame_command_core (struct frame_info *fi, bool ignored)
1837 {
1838   frame_info *prev_frame = get_selected_frame ();
1839   select_frame (fi);
1840   if (get_selected_frame () != prev_frame)
1841     gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1842 }
1843
1844 /* See stack.h.  */
1845
1846 void
1847 select_frame_for_mi (struct frame_info *fi)
1848 {
1849   select_frame_command_core (fi, false /* Ignored.  */);
1850 }
1851
1852 /* The core of all the "frame" sub-commands.  Select frame FI, and if this
1853    means we change frame send out a change notification (otherwise, just
1854    reprint the current frame summary).   */
1855
1856 static void
1857 frame_command_core (struct frame_info *fi, bool ignored)
1858 {
1859   frame_info *prev_frame = get_selected_frame ();
1860   select_frame (fi);
1861   if (get_selected_frame () != prev_frame)
1862     gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME);
1863   else
1864     print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
1865 }
1866
1867 /* The three commands 'frame', 'select-frame', and 'info frame' all have a
1868    common set of sub-commands that allow a specific frame to be selected.
1869    All of the sub-command functions are static methods within this class
1870    template which is then instantiated below.  The template parameter is a
1871    callback used to implement the functionality of the base command
1872    ('frame', 'select-frame', or 'info frame').
1873
1874    In the template parameter FI is the frame being selected.  The
1875    SELECTED_FRAME_P flag is true if the frame being selected was done by
1876    default, which happens when the user uses the base command with no
1877    arguments.  For example the commands 'info frame', 'select-frame',
1878    'frame' will all cause SELECTED_FRAME_P to be true.  In all other cases
1879    SELECTED_FRAME_P is false.  */
1880
1881 template <void (*FPTR) (struct frame_info *fi, bool selected_frame_p)>
1882 class frame_command_helper
1883 {
1884 public:
1885
1886   /* The "frame level" family of commands.  The ARG is an integer that is
1887      the frame's level in the stack.  */
1888   static void
1889   level (const char *arg, int from_tty)
1890   {
1891     int level = value_as_long (parse_and_eval (arg));
1892     struct frame_info *fid
1893       = find_relative_frame (get_current_frame (), &level);
1894     if (level != 0)
1895       error (_("No frame at level %s."), arg);
1896     FPTR (fid, false);
1897   }
1898
1899   /* The "frame address" family of commands.  ARG is a stack-pointer
1900      address for an existing frame.  This command does not allow new
1901      frames to be created.  */
1902
1903   static void
1904   address (const char *arg, int from_tty)
1905   {
1906     CORE_ADDR addr = value_as_address (parse_and_eval (arg));
1907     struct frame_info *fid = find_frame_for_address (addr);
1908     if (fid == NULL)
1909       error (_("No frame at address %s."), arg);
1910     FPTR (fid, false);
1911   }
1912
1913   /* The "frame view" family of commands.  ARG is one or two addresses and
1914      is used to view a frame that might be outside the current backtrace.
1915      The addresses are stack-pointer address, and (optional) pc-address.  */
1916
1917   static void
1918   view (const char *args, int from_tty)
1919   {
1920     struct frame_info *fid;
1921
1922     if (args == NULL)
1923       error (_("Missing address argument to view a frame"));
1924
1925     gdb_argv argv (args);
1926
1927     if (argv.count () == 2)
1928       {
1929         CORE_ADDR addr[2];
1930
1931         addr [0] = value_as_address (parse_and_eval (argv[0]));
1932         addr [1] = value_as_address (parse_and_eval (argv[1]));
1933         fid = create_new_frame (addr[0], addr[1]);
1934       }
1935     else
1936       {
1937         CORE_ADDR addr = value_as_address (parse_and_eval (argv[0]));
1938         fid = create_new_frame (addr, false);
1939       }
1940     FPTR (fid, false);
1941   }
1942
1943   /* The "frame function" family of commands.  ARG is the name of a
1944      function within the stack, the first function (searching from frame
1945      0) with that name will be selected.  */
1946
1947   static void
1948   function (const char *arg, int from_tty)
1949   {
1950     if (arg == NULL)
1951       error (_("Missing function name argument"));
1952     struct frame_info *fid = find_frame_for_function (arg);
1953     if (fid == NULL)
1954       error (_("No frame for function \"%s\"."), arg);
1955     FPTR (fid, false);
1956   }
1957
1958   /* The "frame" base command, that is, when no sub-command is specified.
1959      If one argument is provided then we assume that this is a frame's
1960      level as historically, this was the supported command syntax that was
1961      used most often.
1962
1963      If no argument is provided, then the current frame is selected.  */
1964
1965   static void
1966   base_command (const char *arg, int from_tty)
1967   {
1968     if (arg == NULL)
1969       FPTR (get_selected_frame (_("No stack.")), true);
1970     else
1971       level (arg, from_tty);
1972   }
1973 };
1974
1975 /* Instantiate three FRAME_COMMAND_HELPER instances to implement the
1976    sub-commands for 'info frame', 'frame', and 'select-frame' commands.  */
1977
1978 static frame_command_helper <info_frame_command_core> info_frame_cmd;
1979 static frame_command_helper <frame_command_core> frame_cmd;
1980 static frame_command_helper <select_frame_command_core> select_frame_cmd;
1981
1982 /* Print briefly all stack frames or just the innermost COUNT_EXP
1983    frames.  */
1984
1985 static void
1986 backtrace_command_1 (const frame_print_options &fp_opts,
1987                      const backtrace_cmd_options &bt_opts,
1988                      const char *count_exp, int from_tty)
1989
1990 {
1991   struct frame_info *fi;
1992   int count;
1993   int py_start = 0, py_end = 0;
1994   enum ext_lang_bt_status result = EXT_LANG_BT_ERROR;
1995
1996   if (!target_has_stack ())
1997     error (_("No stack."));
1998
1999   if (count_exp)
2000     {
2001       count = parse_and_eval_long (count_exp);
2002       if (count < 0)
2003         py_start = count;
2004       else
2005         {
2006           py_start = 0;
2007           /* The argument to apply_ext_lang_frame_filter is the number
2008              of the final frame to print, and frames start at 0.  */
2009           py_end = count - 1;
2010         }
2011     }
2012   else
2013     {
2014       py_end = -1;
2015       count = -1;
2016     }
2017
2018   frame_filter_flags flags = 0;
2019
2020   if (bt_opts.full)
2021     flags |= PRINT_LOCALS;
2022   if (bt_opts.hide)
2023     flags |= PRINT_HIDE;
2024
2025   if (!bt_opts.no_filters)
2026     {
2027       enum ext_lang_frame_args arg_type;
2028
2029       flags |= PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS;
2030       if (from_tty)
2031         flags |= PRINT_MORE_FRAMES;
2032
2033       if (fp_opts.print_frame_arguments == print_frame_arguments_scalars)
2034         arg_type = CLI_SCALAR_VALUES;
2035       else if (fp_opts.print_frame_arguments == print_frame_arguments_all)
2036         arg_type = CLI_ALL_VALUES;
2037       else if (fp_opts.print_frame_arguments == print_frame_arguments_presence)
2038         arg_type = CLI_PRESENCE;
2039       else if (fp_opts.print_frame_arguments == print_frame_arguments_none)
2040         arg_type = NO_VALUES;
2041       else
2042         gdb_assert (0);
2043
2044       result = apply_ext_lang_frame_filter (get_current_frame (), flags,
2045                                             arg_type, current_uiout,
2046                                             py_start, py_end);
2047     }
2048
2049   /* Run the inbuilt backtrace if there are no filters registered, or
2050      "-no-filters" has been specified from the command.  */
2051   if (bt_opts.no_filters || result == EXT_LANG_BT_NO_FILTERS)
2052     {
2053       struct frame_info *trailing;
2054
2055       /* The following code must do two things.  First, it must set the
2056          variable TRAILING to the frame from which we should start
2057          printing.  Second, it must set the variable count to the number
2058          of frames which we should print, or -1 if all of them.  */
2059
2060       if (count_exp != NULL && count < 0)
2061         {
2062           trailing = trailing_outermost_frame (-count);
2063           count = -1;
2064         }
2065       else
2066         trailing = get_current_frame ();
2067
2068       for (fi = trailing; fi && count--; fi = get_prev_frame (fi))
2069         {
2070           QUIT;
2071
2072           /* Don't use print_stack_frame; if an error() occurs it probably
2073              means further attempts to backtrace would fail (on the other
2074              hand, perhaps the code does or could be fixed to make sure
2075              the frame->prev field gets set to NULL in that case).  */
2076
2077           print_frame_info (fp_opts, fi, 1, LOCATION, 1, 0);
2078           if ((flags & PRINT_LOCALS) != 0)
2079             {
2080               struct frame_id frame_id = get_frame_id (fi);
2081
2082               print_frame_local_vars (fi, false, NULL, NULL, 1, gdb_stdout);
2083
2084               /* print_frame_local_vars invalidates FI.  */
2085               fi = frame_find_by_id (frame_id);
2086               if (fi == NULL)
2087                 {
2088                   trailing = NULL;
2089                   warning (_("Unable to restore previously selected frame."));
2090                   break;
2091                 }
2092             }
2093
2094           /* Save the last frame to check for error conditions.  */
2095           trailing = fi;
2096         }
2097
2098       /* If we've stopped before the end, mention that.  */
2099       if (fi && from_tty)
2100         printf_filtered (_("(More stack frames follow...)\n"));
2101
2102       /* If we've run out of frames, and the reason appears to be an error
2103          condition, print it.  */
2104       if (fi == NULL && trailing != NULL)
2105         {
2106           enum unwind_stop_reason reason;
2107
2108           reason = get_frame_unwind_stop_reason (trailing);
2109           if (reason >= UNWIND_FIRST_ERROR)
2110             printf_filtered (_("Backtrace stopped: %s\n"),
2111                              frame_stop_reason_string (trailing));
2112         }
2113     }
2114 }
2115
2116 /* Create an option_def_group array grouping all the "backtrace"
2117    options, with FP_OPTS, BT_CMD_OPT, SET_BT_OPTS as contexts.  */
2118
2119 static inline std::array<gdb::option::option_def_group, 3>
2120 make_backtrace_options_def_group (frame_print_options *fp_opts,
2121                                   backtrace_cmd_options *bt_cmd_opts,
2122                                   set_backtrace_options *set_bt_opts)
2123 {
2124   return {{
2125     { {frame_print_option_defs}, fp_opts },
2126     { {set_backtrace_option_defs}, set_bt_opts },
2127     { {backtrace_command_option_defs}, bt_cmd_opts }
2128   }};
2129 }
2130
2131 /* Parse the backtrace command's qualifiers.  Returns ARG advanced
2132    past the qualifiers, if any.  BT_CMD_OPTS, if not null, is used to
2133    store the parsed qualifiers.  */
2134
2135 static const char *
2136 parse_backtrace_qualifiers (const char *arg,
2137                             backtrace_cmd_options *bt_cmd_opts = nullptr)
2138 {
2139   while (true)
2140     {
2141       const char *save_arg = arg;
2142       std::string this_arg = extract_arg (&arg);
2143
2144       if (this_arg.empty ())
2145         return arg;
2146
2147       if (subset_compare (this_arg.c_str (), "no-filters"))
2148         {
2149           if (bt_cmd_opts != nullptr)
2150             bt_cmd_opts->no_filters = true;
2151         }
2152       else if (subset_compare (this_arg.c_str (), "full"))
2153         {
2154           if (bt_cmd_opts != nullptr)
2155             bt_cmd_opts->full = true;
2156         }
2157       else if (subset_compare (this_arg.c_str (), "hide"))
2158         {
2159           if (bt_cmd_opts != nullptr)
2160             bt_cmd_opts->hide = true;
2161         }
2162       else
2163         {
2164           /* Not a recognized qualifier, so stop.  */
2165           return save_arg;
2166         }
2167     }
2168 }
2169
2170 static void
2171 backtrace_command (const char *arg, int from_tty)
2172 {
2173   frame_print_options fp_opts = user_frame_print_options;
2174   backtrace_cmd_options bt_cmd_opts;
2175   set_backtrace_options set_bt_opts = user_set_backtrace_options;
2176
2177   auto grp
2178     = make_backtrace_options_def_group (&fp_opts, &bt_cmd_opts, &set_bt_opts);
2179   gdb::option::process_options
2180     (&arg, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2181
2182   /* Parse non-'-'-prefixed qualifiers, for backwards
2183      compatibility.  */
2184   if (arg != NULL)
2185     {
2186       arg = parse_backtrace_qualifiers (arg, &bt_cmd_opts);
2187       if (*arg == '\0')
2188         arg = NULL;
2189     }
2190
2191   /* These options are handled quite deep in the unwind machinery, so
2192      we get to pass them down by swapping globals.  */
2193   scoped_restore restore_set_backtrace_options
2194     = make_scoped_restore (&user_set_backtrace_options, set_bt_opts);
2195
2196   backtrace_command_1 (fp_opts, bt_cmd_opts, arg, from_tty);
2197 }
2198
2199 /* Completer for the "backtrace" command.  */
2200
2201 static void
2202 backtrace_command_completer (struct cmd_list_element *ignore,
2203                              completion_tracker &tracker,
2204                              const char *text, const char */*word*/)
2205 {
2206   const auto group
2207     = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
2208   if (gdb::option::complete_options
2209       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
2210     return;
2211
2212   if (*text != '\0')
2213     {
2214       const char *p = skip_to_space (text);
2215       if (*p == '\0')
2216         {
2217           static const char *const backtrace_cmd_qualifier_choices[] = {
2218             "full", "no-filters", "hide", nullptr,
2219           };
2220           complete_on_enum (tracker, backtrace_cmd_qualifier_choices,
2221                             text, text);
2222
2223           if (tracker.have_completions ())
2224             return;
2225         }
2226       else
2227         {
2228           const char *cmd = parse_backtrace_qualifiers (text);
2229           tracker.advance_custom_word_point_by (cmd - text);
2230           text = cmd;
2231         }
2232     }
2233
2234   const char *word = advance_to_expression_complete_word_point (tracker, text);
2235   expression_completer (ignore, tracker, text, word);
2236 }
2237
2238 /* Iterate over the local variables of a block B, calling CB with
2239    CB_DATA.  */
2240
2241 static void
2242 iterate_over_block_locals (const struct block *b,
2243                            iterate_over_block_arg_local_vars_cb cb,
2244                            void *cb_data)
2245 {
2246   struct block_iterator iter;
2247   struct symbol *sym;
2248
2249   ALL_BLOCK_SYMBOLS (b, iter, sym)
2250     {
2251       switch (sym->aclass ())
2252         {
2253         case LOC_CONST:
2254         case LOC_LOCAL:
2255         case LOC_REGISTER:
2256         case LOC_STATIC:
2257         case LOC_COMPUTED:
2258         case LOC_OPTIMIZED_OUT:
2259           if (SYMBOL_IS_ARGUMENT (sym))
2260             break;
2261           if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
2262             break;
2263           (*cb) (sym->print_name (), sym, cb_data);
2264           break;
2265
2266         default:
2267           /* Ignore symbols which are not locals.  */
2268           break;
2269         }
2270     }
2271 }
2272
2273 /* Iterate over all the local variables in block B, including all its
2274    superblocks, stopping when the top-level block is reached.  */
2275
2276 void
2277 iterate_over_block_local_vars (const struct block *block,
2278                                iterate_over_block_arg_local_vars_cb cb,
2279                                void *cb_data)
2280 {
2281   while (block)
2282     {
2283       iterate_over_block_locals (block, cb, cb_data);
2284       /* After handling the function's top-level block, stop.  Don't
2285          continue to its superblock, the block of per-file
2286          symbols.  */
2287       if (BLOCK_FUNCTION (block))
2288         break;
2289       block = BLOCK_SUPERBLOCK (block);
2290     }
2291 }
2292
2293 /* Data to be passed around in the calls to the locals and args
2294    iterators.  */
2295
2296 struct print_variable_and_value_data
2297 {
2298   gdb::optional<compiled_regex> preg;
2299   gdb::optional<compiled_regex> treg;
2300   struct frame_id frame_id;
2301   int num_tabs;
2302   struct ui_file *stream;
2303   int values_printed;
2304 };
2305
2306 /* The callback for the locals and args iterators.  */
2307
2308 static void
2309 do_print_variable_and_value (const char *print_name,
2310                              struct symbol *sym,
2311                              void *cb_data)
2312 {
2313   struct print_variable_and_value_data *p
2314     = (struct print_variable_and_value_data *) cb_data;
2315   struct frame_info *frame;
2316
2317   if (p->preg.has_value ()
2318       && p->preg->exec (sym->natural_name (), 0, NULL, 0) != 0)
2319     return;
2320   if (p->treg.has_value ()
2321       && !treg_matches_sym_type_name (*p->treg, sym))
2322     return;
2323   if (language_def (sym->language ())->symbol_printing_suppressed (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   bool quiet = false;
2427   std::string type_regexp;
2428 };
2429
2430 /* The options used by the 'info locals' and 'info args' commands.  */
2431
2432 static const gdb::option::option_def info_print_options_defs[] = {
2433   gdb::option::boolean_option_def<info_print_options> {
2434     "q",
2435     [] (info_print_options *opt) { return &opt->quiet; },
2436     nullptr, /* show_cmd_cb */
2437     nullptr /* set_doc */
2438   },
2439
2440   gdb::option::string_option_def<info_print_options> {
2441     "t",
2442     [] (info_print_options *opt) { return &opt->type_regexp; },
2443     nullptr, /* show_cmd_cb */
2444     nullptr /* set_doc */
2445   }
2446 };
2447
2448 /* Returns the option group used by 'info locals' and 'info args'
2449    commands.  */
2450
2451 static gdb::option::option_def_group
2452 make_info_print_options_def_group (info_print_options *opts)
2453 {
2454   return {{info_print_options_defs}, opts};
2455 }
2456
2457 /* Command completer for 'info locals' and 'info args'.  */
2458
2459 static void
2460 info_print_command_completer (struct cmd_list_element *ignore,
2461                               completion_tracker &tracker,
2462                               const char *text, const char * /* word */)
2463 {
2464   const auto group
2465     = make_info_print_options_def_group (nullptr);
2466   if (gdb::option::complete_options
2467       (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
2468     return;
2469
2470   const char *word = advance_to_expression_complete_word_point (tracker, text);
2471   symbol_completer (ignore, tracker, text, word);
2472 }
2473
2474 /* Implement the 'info locals' command.  */
2475
2476 void
2477 info_locals_command (const char *args, int from_tty)
2478 {
2479   info_print_options opts;
2480   auto grp = make_info_print_options_def_group (&opts);
2481   gdb::option::process_options
2482     (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2483   if (args != nullptr && *args == '\0')
2484     args = nullptr;
2485
2486   print_frame_local_vars
2487     (get_selected_frame (_("No frame selected.")),
2488      opts.quiet, args,
2489      opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
2490      0, gdb_stdout);
2491 }
2492
2493 /* Iterate over all the argument variables in block B.  */
2494
2495 void
2496 iterate_over_block_arg_vars (const struct block *b,
2497                              iterate_over_block_arg_local_vars_cb cb,
2498                              void *cb_data)
2499 {
2500   struct block_iterator iter;
2501   struct symbol *sym, *sym2;
2502
2503   ALL_BLOCK_SYMBOLS (b, iter, sym)
2504     {
2505       /* Don't worry about things which aren't arguments.  */
2506       if (SYMBOL_IS_ARGUMENT (sym))
2507         {
2508           /* We have to look up the symbol because arguments can have
2509              two entries (one a parameter, one a local) and the one we
2510              want is the local, which lookup_symbol will find for us.
2511              This includes gcc1 (not gcc2) on the sparc when passing a
2512              small structure and gcc2 when the argument type is float
2513              and it is passed as a double and converted to float by
2514              the prologue (in the latter case the type of the LOC_ARG
2515              symbol is double and the type of the LOC_LOCAL symbol is
2516              float).  There are also LOC_ARG/LOC_REGISTER pairs which
2517              are not combined in symbol-reading.  */
2518
2519           sym2 = lookup_symbol_search_name (sym->search_name (),
2520                                             b, VAR_DOMAIN).symbol;
2521           (*cb) (sym->print_name (), sym2, cb_data);
2522         }
2523     }
2524 }
2525
2526 /* Print all argument variables of the function of FRAME.
2527    Print them with values to STREAM.
2528    If REGEXP is not NULL, only print argument variables whose name
2529    matches REGEXP.
2530    If T_REGEXP is not NULL, only print argument variables whose type
2531    matches T_REGEXP.
2532    If no argument variables have been printed and !QUIET, prints a message
2533    explaining why no argument variables could be printed.
2534
2535    This function will invalidate FRAME.  */
2536
2537 static void
2538 print_frame_arg_vars (struct frame_info *frame,
2539                       bool quiet,
2540                       const char *regexp, const char *t_regexp,
2541                       struct ui_file *stream)
2542 {
2543   struct print_variable_and_value_data cb_data;
2544   struct symbol *func;
2545   CORE_ADDR pc;
2546   gdb::optional<compiled_regex> preg;
2547   gdb::optional<compiled_regex> treg;
2548
2549   if (!get_frame_pc_if_available (frame, &pc))
2550     {
2551       if (!quiet)
2552         fprintf_filtered (stream,
2553                           _("PC unavailable, cannot determine args.\n"));
2554       return;
2555     }
2556
2557   func = get_frame_function (frame);
2558   if (func == NULL)
2559     {
2560       if (!quiet)
2561         fprintf_filtered (stream, _("No symbol table info available.\n"));
2562       return;
2563     }
2564
2565   prepare_reg (regexp, &cb_data.preg);
2566   prepare_reg (t_regexp, &cb_data.treg);
2567   cb_data.frame_id = get_frame_id (frame);
2568   cb_data.num_tabs = 0;
2569   cb_data.stream = stream;
2570   cb_data.values_printed = 0;
2571
2572   iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
2573                                do_print_variable_and_value, &cb_data);
2574
2575   /* do_print_variable_and_value invalidates FRAME.  */
2576   frame = NULL;
2577
2578   if (!cb_data.values_printed && !quiet)
2579     {
2580       if (regexp == NULL && t_regexp == NULL)
2581         fprintf_filtered (stream, _("No arguments.\n"));
2582       else
2583         fprintf_filtered (stream, _("No matching arguments.\n"));
2584     }
2585 }
2586
2587 /* Implement the 'info args' command.  */
2588
2589 void
2590 info_args_command (const char *args, int from_tty)
2591 {
2592   info_print_options opts;
2593   auto grp = make_info_print_options_def_group (&opts);
2594   gdb::option::process_options
2595     (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
2596   if (args != nullptr && *args == '\0')
2597     args = nullptr;
2598
2599   print_frame_arg_vars
2600     (get_selected_frame (_("No frame selected.")),
2601      opts.quiet, args,
2602      opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (),
2603      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->first_opcode () != UNOP_CAST
2769               && retval_expr->first_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 (return_type->code () == 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                              thisfun->print_name ());
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).data () /*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             execute_command_to_string
3030               (cmd_result, 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   if (cmd == NULL || *cmd == '\0')
3251     error (_("Please specify a command to apply on all frames"));
3252   std::string expanded = std::string ("frame apply all -s ") + cmd;
3253   execute_command (expanded.c_str (), from_tty);
3254 }
3255
3256
3257 /* Find inner-mode frame with frame address ADDRESS.  Return NULL if no
3258    matching frame can be found.  */
3259
3260 static struct frame_info *
3261 find_frame_for_address (CORE_ADDR address)
3262 {
3263   struct frame_id id;
3264   struct frame_info *fid;
3265
3266   id = frame_id_build_wild (address);
3267
3268   /* If (s)he specifies the frame with an address, he deserves
3269      what (s)he gets.  Still, give the highest one that matches.
3270      (NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
3271      know).  */
3272   for (fid = get_current_frame ();
3273        fid != NULL;
3274        fid = get_prev_frame (fid))
3275     {
3276       if (frame_id_eq (id, get_frame_id (fid)))
3277         {
3278           struct frame_info *prev_frame;
3279
3280           while (1)
3281             {
3282               prev_frame = get_prev_frame (fid);
3283               if (!prev_frame
3284                   || !frame_id_eq (id, get_frame_id (prev_frame)))
3285                 break;
3286               fid = prev_frame;
3287             }
3288           return fid;
3289         }
3290     }
3291   return NULL;
3292 }
3293
3294 \f
3295
3296 /* Commands with a prefix of `frame apply'.  */
3297 static struct cmd_list_element *frame_apply_cmd_list = NULL;
3298
3299 /* Commands with a prefix of `frame'.  */
3300 static struct cmd_list_element *frame_cmd_list = NULL;
3301
3302 /* Commands with a prefix of `select frame'.  */
3303 static struct cmd_list_element *select_frame_cmd_list = NULL;
3304
3305 /* Commands with a prefix of `info frame'.  */
3306 static struct cmd_list_element *info_frame_cmd_list = NULL;
3307
3308 void _initialize_stack ();
3309 void
3310 _initialize_stack ()
3311 {
3312   struct cmd_list_element *cmd;
3313
3314   add_com ("return", class_stack, return_command, _("\
3315 Make selected stack frame return to its caller.\n\
3316 Control remains in the debugger, but when you continue\n\
3317 execution will resume in the frame above the one now selected.\n\
3318 If an argument is given, it is an expression for the value to return."));
3319
3320   add_com ("up", class_stack, up_command, _("\
3321 Select and print stack frame that called this one.\n\
3322 An argument says how many frames up to go."));
3323   add_com ("up-silently", class_support, up_silently_command, _("\
3324 Same as the `up' command, but does not print anything.\n\
3325 This is useful in command scripts."));
3326
3327   cmd_list_element *down_cmd
3328     = add_com ("down", class_stack, down_command, _("\
3329 Select and print stack frame called by this one.\n\
3330 An argument says how many frames down to go."));
3331   add_com_alias ("do", down_cmd, class_stack, 1);
3332   add_com_alias ("dow", down_cmd, class_stack, 1);
3333   add_com ("down-silently", class_support, down_silently_command, _("\
3334 Same as the `down' command, but does not print anything.\n\
3335 This is useful in command scripts."));
3336
3337   cmd_list_element *frame_cmd_el
3338     = add_prefix_cmd ("frame", class_stack,
3339                       &frame_cmd.base_command, _("\
3340 Select and print a stack frame.\n\
3341 With no argument, print the selected stack frame.  (See also \"info frame\").\n\
3342 A single numerical argument specifies the frame to select."),
3343                       &frame_cmd_list, 1, &cmdlist);
3344   add_com_alias ("f", frame_cmd_el, class_stack, 1);
3345
3346 #define FRAME_APPLY_OPTION_HELP "\
3347 Prints the frame location information followed by COMMAND output.\n\
3348 \n\
3349 By default, an error raised during the execution of COMMAND\n\
3350 aborts \"frame apply\".\n\
3351 \n\
3352 Options:\n\
3353 %OPTIONS%"
3354
3355   const auto frame_apply_opts
3356     = make_frame_apply_options_def_group (nullptr, nullptr);
3357
3358   static std::string frame_apply_cmd_help = gdb::option::build_help (_("\
3359 Apply a command to a number of frames.\n\
3360 Usage: frame apply COUNT [OPTION]... COMMAND\n\
3361 With a negative COUNT argument, applies the command on outermost -COUNT frames.\n"
3362                                   FRAME_APPLY_OPTION_HELP),
3363                                frame_apply_opts);
3364
3365   cmd = add_prefix_cmd ("apply", class_stack, frame_apply_command,
3366                         frame_apply_cmd_help.c_str (),
3367                         &frame_apply_cmd_list, 1,
3368                         &frame_cmd_list);
3369   set_cmd_completer_handle_brkchars (cmd, frame_apply_cmd_completer);
3370
3371   static std::string frame_apply_all_cmd_help = gdb::option::build_help (_("\
3372 Apply a command to all frames.\n\
3373 \n\
3374 Usage: frame apply all [OPTION]... COMMAND\n"
3375                                   FRAME_APPLY_OPTION_HELP),
3376                                frame_apply_opts);
3377
3378   cmd = add_cmd ("all", class_stack, frame_apply_all_command,
3379                  frame_apply_all_cmd_help.c_str (),
3380                  &frame_apply_cmd_list);
3381   set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
3382
3383   static std::string frame_apply_level_cmd_help = gdb::option::build_help (_("\
3384 Apply a command to a list of frames.\n\
3385 \n\
3386 Usage: frame apply level LEVEL... [OPTION]... COMMAND\n\
3387 LEVEL is a space-separated list of levels of frames to apply COMMAND on.\n"
3388                                   FRAME_APPLY_OPTION_HELP),
3389                                frame_apply_opts);
3390
3391   cmd = add_cmd ("level", class_stack, frame_apply_level_command,
3392            frame_apply_level_cmd_help.c_str (),
3393            &frame_apply_cmd_list);
3394   set_cmd_completer_handle_brkchars (cmd, frame_apply_level_cmd_completer);
3395
3396   cmd = add_com ("faas", class_stack, faas_command, _("\
3397 Apply a command to all frames (ignoring errors and empty output).\n\
3398 Usage: faas [OPTION]... COMMAND\n\
3399 shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
3400 See \"help frame apply all\" for available options."));
3401   set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
3402
3403   add_cmd ("address", class_stack, &frame_cmd.address,
3404            _("\
3405 Select and print a stack frame by stack address.\n\
3406 \n\
3407 Usage: frame address STACK-ADDRESS"),
3408            &frame_cmd_list);
3409
3410   add_cmd ("view", class_stack, &frame_cmd.view,
3411            _("\
3412 View a stack frame that might be outside the current backtrace.\n\
3413 \n\
3414 Usage: frame view STACK-ADDRESS\n\
3415        frame view STACK-ADDRESS PC-ADDRESS"),
3416            &frame_cmd_list);
3417
3418   cmd = add_cmd ("function", class_stack, &frame_cmd.function,
3419            _("\
3420 Select and print a stack frame by function name.\n\
3421 \n\
3422 Usage: frame function NAME\n\
3423 \n\
3424 The innermost frame that visited function NAME is selected."),
3425            &frame_cmd_list);
3426   set_cmd_completer (cmd, frame_selection_by_function_completer);
3427
3428
3429   add_cmd ("level", class_stack, &frame_cmd.level,
3430            _("\
3431 Select and print a stack frame by level.\n\
3432 \n\
3433 Usage: frame level LEVEL"),
3434            &frame_cmd_list);
3435
3436   cmd = add_prefix_cmd_suppress_notification ("select-frame", class_stack,
3437                       &select_frame_cmd.base_command, _("\
3438 Select a stack frame without printing anything.\n\
3439 A single numerical argument specifies the frame to select."),
3440                       &select_frame_cmd_list, 1, &cmdlist,
3441                       &cli_suppress_notification.user_selected_context);
3442
3443   add_cmd_suppress_notification ("address", class_stack,
3444                          &select_frame_cmd.address, _("\
3445 Select a stack frame by stack address.\n\
3446 \n\
3447 Usage: select-frame address STACK-ADDRESS"),
3448                          &select_frame_cmd_list,
3449                          &cli_suppress_notification.user_selected_context);
3450
3451
3452   add_cmd_suppress_notification ("view", class_stack,
3453                  &select_frame_cmd.view, _("\
3454 Select a stack frame that might be outside the current backtrace.\n\
3455 \n\
3456 Usage: select-frame view STACK-ADDRESS\n\
3457        select-frame view STACK-ADDRESS PC-ADDRESS"),
3458                  &select_frame_cmd_list,
3459                  &cli_suppress_notification.user_selected_context);
3460
3461   cmd = add_cmd_suppress_notification ("function", class_stack,
3462                &select_frame_cmd.function, _("\
3463 Select a stack frame by function name.\n\
3464 \n\
3465 Usage: select-frame function NAME"),
3466                &select_frame_cmd_list,
3467                &cli_suppress_notification.user_selected_context);
3468   set_cmd_completer (cmd, frame_selection_by_function_completer);
3469
3470   add_cmd_suppress_notification ("level", class_stack,
3471                          &select_frame_cmd.level, _("\
3472 Select a stack frame by level.\n\
3473 \n\
3474 Usage: select-frame level LEVEL"),
3475                          &select_frame_cmd_list,
3476                          &cli_suppress_notification.user_selected_context);
3477
3478   const auto backtrace_opts
3479     = make_backtrace_options_def_group (nullptr, nullptr, nullptr);
3480
3481   static std::string backtrace_help
3482     = gdb::option::build_help (_("\
3483 Print backtrace of all stack frames, or innermost COUNT frames.\n\
3484 Usage: backtrace [OPTION]... [QUALIFIER]... [COUNT | -COUNT]\n\
3485 \n\
3486 Options:\n\
3487 %OPTIONS%\n\
3488 \n\
3489 For backward compatibility, the following qualifiers are supported:\n\
3490 \n\
3491    full       - same as -full option.\n\
3492    no-filters - same as -no-filters option.\n\
3493    hide       - same as -hide.\n\
3494 \n\
3495 With a negative COUNT, print outermost -COUNT frames."),
3496                                backtrace_opts);
3497
3498   cmd_list_element *backtrace_cmd
3499     = add_com ("backtrace", class_stack, backtrace_command,
3500                backtrace_help.c_str ());
3501   set_cmd_completer_handle_brkchars (backtrace_cmd, backtrace_command_completer);
3502
3503   add_com_alias ("bt", backtrace_cmd, class_stack, 0);
3504
3505   add_com_alias ("where", backtrace_cmd, class_stack, 0);
3506   cmd_list_element *info_stack_cmd
3507     = add_info ("stack", backtrace_command,
3508                 _("Backtrace of the stack, or innermost COUNT frames."));
3509   add_info_alias ("s", info_stack_cmd, 1);
3510
3511   cmd_list_element *info_frame_cmd_el
3512     = add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command,
3513                       _("All about the selected stack frame.\n\
3514 With no arguments, displays information about the currently selected stack\n\
3515 frame.  Alternatively a frame specification may be provided (See \"frame\")\n\
3516 the information is then printed about the specified frame."),
3517                       &info_frame_cmd_list, 1, &infolist);
3518   add_info_alias ("f", info_frame_cmd_el, 1);
3519
3520   add_cmd ("address", class_stack, &info_frame_cmd.address,
3521            _("\
3522 Print information about a stack frame selected by stack address.\n\
3523 \n\
3524 Usage: info frame address STACK-ADDRESS"),
3525            &info_frame_cmd_list);
3526
3527   add_cmd ("view", class_stack, &info_frame_cmd.view,
3528            _("\
3529 Print information about a stack frame outside the current backtrace.\n\
3530 \n\
3531 Usage: info frame view STACK-ADDRESS\n\
3532        info frame view STACK-ADDRESS PC-ADDRESS"),
3533            &info_frame_cmd_list);
3534
3535   cmd = add_cmd ("function", class_stack, &info_frame_cmd.function,
3536            _("\
3537 Print information about a stack frame selected by function name.\n\
3538 \n\
3539 Usage: info frame function NAME"),
3540            &info_frame_cmd_list);
3541   set_cmd_completer (cmd, frame_selection_by_function_completer);
3542
3543   add_cmd ("level", class_stack, &info_frame_cmd.level,
3544            _("\
3545 Print information about a stack frame selected by level.\n\
3546 \n\
3547 Usage: info frame level LEVEL"),
3548            &info_frame_cmd_list);
3549
3550   cmd = add_info ("locals", info_locals_command,
3551                   info_print_args_help (_("\
3552 All local variables of current stack frame or those matching REGEXPs.\n\
3553 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3554 Prints the local variables of the current stack frame.\n"),
3555                                         _("local variables"),
3556                                         false));
3557   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
3558   cmd = add_info ("args", info_args_command,
3559                   info_print_args_help (_("\
3560 All argument variables of current stack frame or those matching REGEXPs.\n\
3561 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
3562 Prints the argument variables of the current stack frame.\n"),
3563                                         _("argument variables"),
3564                                         false));
3565   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
3566
3567   if (dbx_commands)
3568     add_com ("func", class_stack, func_command, _("\
3569 Select the stack frame that contains NAME.\n\
3570 Usage: func NAME"));
3571
3572   /* Install "set print raw frame-arguments", a deprecated spelling of
3573      "set print raw-frame-arguments".  */
3574   set_show_commands set_show_frame_args
3575     = add_setshow_boolean_cmd
3576       ("frame-arguments", no_class,
3577        &user_frame_print_options.print_raw_frame_arguments,
3578        _("\
3579 Set whether to print frame arguments in raw form."), _("\
3580 Show whether to print frame arguments in raw form."), _("\
3581 If set, frame arguments are printed in raw form, bypassing any\n\
3582 pretty-printers for that value."),
3583        NULL, NULL,
3584        &setprintrawlist, &showprintrawlist);
3585   deprecate_cmd (set_show_frame_args.set, "set print raw-frame-arguments");
3586
3587   add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
3588                                 &disassemble_next_line, _("\
3589 Set whether to disassemble next source line or insn when execution stops."),
3590                                 _("\
3591 Show whether to disassemble next source line or insn when execution stops."),
3592                                 _("\
3593 If ON, GDB will display disassembly of the next source line, in addition\n\
3594 to displaying the source line itself.  If the next source line cannot\n\
3595 be displayed (e.g., source is unavailable or there's no line info), GDB\n\
3596 will display disassembly of next instruction instead of showing the\n\
3597 source line.\n\
3598 If AUTO, display disassembly of next instruction only if the source line\n\
3599 cannot be displayed.\n\
3600 If OFF (which is the default), never display the disassembly of the next\n\
3601 source line."),
3602                                 NULL,
3603                                 show_disassemble_next_line,
3604                                 &setlist, &showlist);
3605   disassemble_next_line = AUTO_BOOLEAN_FALSE;
3606
3607   gdb::option::add_setshow_cmds_for_options
3608     (class_stack, &user_frame_print_options,
3609      frame_print_option_defs, &setprintlist, &showprintlist);
3610 }
This page took 0.224594 seconds and 4 git commands to generate.