xcoff slurp_armap bounds checking

[deliverable/binutils-gdb.git] / gdb / stack.c

diff --git a/gdb/stack.c b/gdb/stack.c
index 0f7fbf5e6efc531aaad968edaf34916be2642061..228205248710d32cac4454f40c2cd5e11f0b5685 100644 (file)
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -54,6 +54,7 @@
 #include "observable.h"
 #include "gdbsupport/def-vector.h"
 #include "cli/cli-option.h"
 #include "observable.h"
 #include "gdbsupport/def-vector.h"
 #include "cli/cli-option.h"

+#include "cli/cli-style.h"

 
 /* The possible choices of "set print frame-arguments", and the value
    of this setting.  */
 
 /* The possible choices of "set print frame-arguments", and the value
    of this setting.  */


@@ -223,12 +224,6 @@ static void print_frame (const frame_print_options &opts,
                         enum print_what print_what,  int print_args,
                         struct symtab_and_line sal);
 
                         enum print_what print_what,  int print_args,
                         struct symtab_and_line sal);
 

-static void set_last_displayed_sal (int valid,
-                                   struct program_space *pspace,
-                                   CORE_ADDR addr,
-                                   struct symtab *symtab,
-                                   int line);
-

 static struct frame_info *find_frame_for_function (const char *);
 static struct frame_info *find_frame_for_address (CORE_ADDR);
 
 static struct frame_info *find_frame_for_function (const char *);
 static struct frame_info *find_frame_for_address (CORE_ADDR);
 


@@ -240,18 +235,84 @@ static struct frame_info *find_frame_for_address (CORE_ADDR);
 
 int annotation_level = 0;
 
 
 int annotation_level = 0;
 

-/* These variables hold the last symtab and line we displayed to the user.
- * This is where we insert a breakpoint or a skiplist entry by default.  */
-static int last_displayed_sal_valid = 0;
-static struct program_space *last_displayed_pspace = 0;
-static CORE_ADDR last_displayed_addr = 0;
-static struct symtab *last_displayed_symtab = 0;
-static int last_displayed_line = 0;
+/* Class used to manage tracking the last symtab we displayed.  */
+
+class last_displayed_symtab_info_type
+{
+public:
+  /* True if the cached information is valid.  */
+  bool is_valid () const
+  { return m_valid; }
+
+  /* Return the cached program_space.  If the cache is invalid nullptr is
+     returned.  */
+  struct program_space *pspace () const
+  { return m_pspace; }
+
+  /* Return the cached CORE_ADDR address.  If the cache is invalid 0 is
+     returned.  */
+  CORE_ADDR address () const
+  { return m_address; }
+
+  /* Return the cached symtab.  If the cache is invalid nullptr is
+     returned.  */
+  struct symtab *symtab () const
+  { return m_symtab; }
+
+  /* Return the cached line number.  If the cache is invalid 0 is
+     returned.  */
+  int line () const
+  { return m_line; }
+
+  /* Invalidate the cache, reset all the members to their default value.  */
+  void invalidate ()
+  {
+    m_valid = false;
+    m_pspace = nullptr;
+    m_address = 0;
+    m_symtab = nullptr;
+    m_line = 0;
+  }
+
+  /* Store a new set of values in the cache.  */
+  void set (struct program_space *pspace, CORE_ADDR address,
+           struct symtab *symtab, int line)
+  {
+    gdb_assert (pspace != nullptr);
+
+    m_valid = true;
+    m_pspace = pspace;
+    m_address = address;
+    m_symtab = symtab;
+    m_line = line;
+  }
+
+private:
+  /* True when the cache is valid.  */
+  bool m_valid = false;
+
+  /* The last program space displayed.  */
+  struct program_space *m_pspace = nullptr;
+
+  /* The last address displayed.  */
+  CORE_ADDR m_address = 0;
+
+  /* The last symtab displayed.  */
+  struct symtab *m_symtab = nullptr;
+
+  /* The last line number displayed.  */
+  int m_line = 0;
+};
+
+/* An actual instance of the cache, holds information about the last symtab
+   displayed.  */
+static last_displayed_symtab_info_type last_displayed_symtab_info;
+

 \f
 
 /* See stack.h.  */
 
 \f
 
 /* See stack.h.  */
 

-int
+bool

 frame_show_address (struct frame_info *frame,
                    struct symtab_and_line sal)
 {
 frame_show_address (struct frame_info *frame,
                    struct symtab_and_line sal)
 {


@@ -266,7 +327,7 @@ frame_show_address (struct frame_info *frame,
        gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
       else
        gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
        gdb_assert (inline_skipped_frames (inferior_thread ()) > 0);
       else
        gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);

-      return 0;
+      return false;

     }
 
   return get_frame_pc (frame) != sal.pc;
     }
 
   return get_frame_pc (frame) != sal.pc;


@@ -296,7 +357,7 @@ print_stack_frame (struct frame_info *frame, int print_level,
                   int set_current_sal)
 {
 
                   int set_current_sal)
 {
 

-  /* For mi, alway print location and address.  */
+  /* For mi, always print location and address.  */

   if (current_uiout->is_mi_like_p ())
     print_what = LOC_AND_ADDRESS;
 
   if (current_uiout->is_mi_like_p ())
     print_what = LOC_AND_ADDRESS;
 


@@ -348,7 +409,7 @@ print_frame_nameless_args (struct frame_info *frame, long start, int num,
    read in.
 
    Errors are printed as if they would be the parameter value.  Use zeroed ARG
    read in.
 
    Errors are printed as if they would be the parameter value.  Use zeroed ARG

-   iff it should not be printed accoring to user settings.  */
+   iff it should not be printed according to user settings.  */

 
 static void
 print_frame_arg (const frame_print_options &fp_opts,
 
 static void
 print_frame_arg (const frame_print_options &fp_opts,


@@ -366,31 +427,35 @@ print_frame_arg (const frame_print_options &fp_opts,
 
   annotate_arg_emitter arg_emitter;
   ui_out_emit_tuple tuple_emitter (uiout, NULL);
 
   annotate_arg_emitter arg_emitter;
   ui_out_emit_tuple tuple_emitter (uiout, NULL);

-  fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
-                          SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
+  fprintf_symbol_filtered (&stb, arg->sym->print_name (),
+                          arg->sym->language (), DMGL_PARAMS | DMGL_ANSI);

   if (arg->entry_kind == print_entry_values_compact)
     {
       /* It is OK to provide invalid MI-like stream as with
         PRINT_ENTRY_VALUE_COMPACT we never use MI.  */
       stb.puts ("=");
 
   if (arg->entry_kind == print_entry_values_compact)
     {
       /* It is OK to provide invalid MI-like stream as with
         PRINT_ENTRY_VALUE_COMPACT we never use MI.  */
       stb.puts ("=");
 

-      fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym),
-                              SYMBOL_LANGUAGE (arg->sym),
+      fprintf_symbol_filtered (&stb, arg->sym->print_name (),
+                              arg->sym->language (),

                               DMGL_PARAMS | DMGL_ANSI);
     }
   if (arg->entry_kind == print_entry_values_only
       || arg->entry_kind == print_entry_values_compact)
     stb.puts ("@entry");
                               DMGL_PARAMS | DMGL_ANSI);
     }
   if (arg->entry_kind == print_entry_values_only
       || arg->entry_kind == print_entry_values_compact)
     stb.puts ("@entry");

-  uiout->field_stream ("name", stb, ui_out_style_kind::VARIABLE);
+  uiout->field_stream ("name", stb, variable_name_style.style ());

   annotate_arg_name_end ();
   uiout->text ("=");
 
   annotate_arg_name_end ();
   uiout->text ("=");
 

+  ui_file_style style;

   if (!arg->val && !arg->error)
     uiout->text ("...");
   else
     {
       if (arg->error)
   if (!arg->val && !arg->error)
     uiout->text ("...");
   else
     {
       if (arg->error)

-       stb.printf (_("<error reading variable: %s>"), arg->error.get ());
+       {
+         stb.printf (_("<error reading variable: %s>"), arg->error.get ());
+         style = metadata_style.style ();
+       }

       else
        {
          try
       else
        {
          try


@@ -409,7 +474,7 @@ print_frame_arg (const frame_print_options &fp_opts,
              /* Use the appropriate language to display our symbol, unless the
                 user forced the language to a specific language.  */
              if (language_mode == language_mode_auto)
              /* Use the appropriate language to display our symbol, unless the
                 user forced the language to a specific language.  */
              if (language_mode == language_mode_auto)

-               language = language_def (SYMBOL_LANGUAGE (arg->sym));
+               language = language_def (arg->sym->language ());

              else
                language = current_language;
 
              else
                language = current_language;
 


@@ -427,11 +492,12 @@ print_frame_arg (const frame_print_options &fp_opts,
            {
              stb.printf (_("<error reading variable: %s>"),
                          except.what ());
            {
              stb.printf (_("<error reading variable: %s>"),
                          except.what ());

+             style = metadata_style.style ();

            }
        }
     }
 
            }
        }
     }
 

-  uiout->field_stream ("value", stb);
+  uiout->field_stream ("value", stb, style);

 }
 
 /* Read in inferior function local SYM at FRAME into ARGP.  Caller is
 }
 
 /* Read in inferior function local SYM at FRAME into ARGP.  Caller is


@@ -751,11 +817,11 @@ print_frame_args (const frame_print_options &fp_opts,
             parameter names occur on the RS/6000, for traceback
             tables.  FIXME, should we even print them?  */
 
             parameter names occur on the RS/6000, for traceback
             tables.  FIXME, should we even print them?  */
 

-         if (*SYMBOL_LINKAGE_NAME (sym))
+         if (*sym->linkage_name ())

            {
              struct symbol *nsym;
 
            {
              struct symbol *nsym;
 

-             nsym = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
+             nsym = lookup_symbol_search_name (sym->search_name (),

                                                b, VAR_DOMAIN).symbol;
              gdb_assert (nsym != NULL);
              if (SYMBOL_CLASS (nsym) == LOC_REGISTER
                                                b, VAR_DOMAIN).symbol;
              gdb_assert (nsym != NULL);
              if (SYMBOL_CLASS (nsym) == LOC_REGISTER


@@ -953,7 +1019,7 @@ get_user_print_what_frame_info (gdb::optional<enum print_what> *what)
 /* Print information about frame FRAME.  The output is format according
    to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS.  For the meaning of
    PRINT_WHAT, see enum print_what comments in frame.h.
 /* Print information about frame FRAME.  The output is format according
    to PRINT_LEVEL and PRINT_WHAT and PRINT_ARGS.  For the meaning of
    PRINT_WHAT, see enum print_what comments in frame.h.

-   Note that PRINT_WHAT is overriden if FP_OPTS.print_frame_info
+   Note that PRINT_WHAT is overridden if FP_OPTS.print_frame_info

    != print_frame_info_auto.
 
    Used in "where" output, and to emit breakpoint or step
    != print_frame_info_auto.
 
    Used in "where" output, and to emit breakpoint or step


@@ -1005,18 +1071,18 @@ print_frame_info (const frame_print_options &fp_opts,
         {
           annotate_function_call ();
           uiout->field_string ("func", "<function called from gdb>",
         {
           annotate_function_call ();
           uiout->field_string ("func", "<function called from gdb>",

-                              ui_out_style_kind::FUNCTION);
+                              metadata_style.style ());

        }
       else if (get_frame_type (frame) == SIGTRAMP_FRAME)
         {
          annotate_signal_handler_caller ();
           uiout->field_string ("func", "<signal handler called>",
        }
       else if (get_frame_type (frame) == SIGTRAMP_FRAME)
         {
          annotate_signal_handler_caller ();
           uiout->field_string ("func", "<signal handler called>",

-                              ui_out_style_kind::FUNCTION);
+                              metadata_style.style ());

         }
       else if (get_frame_type (frame) == ARCH_FRAME)
         {
           uiout->field_string ("func", "<cross-architecture call>",
         }
       else if (get_frame_type (frame) == ARCH_FRAME)
         {
           uiout->field_string ("func", "<cross-architecture call>",

-                              ui_out_style_kind::FUNCTION);
+                              metadata_style.style ());

        }
       uiout->text ("\n");
       annotate_frame_end ();
        }
       uiout->text ("\n");
       annotate_frame_end ();


@@ -1099,9 +1165,9 @@ print_frame_info (const frame_print_options &fp_opts,
       CORE_ADDR pc;
 
       if (get_frame_pc_if_available (frame, &pc))
       CORE_ADDR pc;
 
       if (get_frame_pc_if_available (frame, &pc))

-       set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line);
+       last_displayed_symtab_info.set (sal.pspace, pc, sal.symtab, sal.line);

       else
       else

-       set_last_displayed_sal (0, 0, 0, 0, 0);
+       last_displayed_symtab_info.invalidate ();

     }
 
   annotate_frame_end ();
     }
 
   annotate_frame_end ();


@@ -1109,103 +1175,67 @@ print_frame_info (const frame_print_options &fp_opts,
   gdb_flush (gdb_stdout);
 }
 
   gdb_flush (gdb_stdout);
 }
 

-/* Remember the last symtab and line we displayed, which we use e.g.
- * as the place to put a breakpoint when the `break' command is
- * invoked with no arguments.  */
-
-static void
-set_last_displayed_sal (int valid, struct program_space *pspace,
-                       CORE_ADDR addr, struct symtab *symtab,
-                       int line)
-{
-  last_displayed_sal_valid = valid;
-  last_displayed_pspace = pspace;
-  last_displayed_addr = addr;
-  last_displayed_symtab = symtab;
-  last_displayed_line = line;
-  if (valid && pspace == NULL)
-    {
-      clear_last_displayed_sal ();
-      internal_error (__FILE__, __LINE__,
-                     _("Trying to set NULL pspace."));
-    }
-}
-
-/* Forget the last sal we displayed.  */
+/* See stack.h.  */

 
 void
 clear_last_displayed_sal (void)
 {
 
 void
 clear_last_displayed_sal (void)
 {

-  last_displayed_sal_valid = 0;
-  last_displayed_pspace = 0;
-  last_displayed_addr = 0;
-  last_displayed_symtab = 0;
-  last_displayed_line = 0;
+  last_displayed_symtab_info.invalidate ();

 }
 
 }
 

-/* Is our record of the last sal we displayed valid?  If not,
- * the get_last_displayed_* functions will return NULL or 0, as
- * appropriate.  */
+/* See stack.h.  */

 
 

-int
+bool

 last_displayed_sal_is_valid (void)
 {
 last_displayed_sal_is_valid (void)
 {

-  return last_displayed_sal_valid;
+  return last_displayed_symtab_info.is_valid ();

 }
 
 }
 

-/* Get the pspace of the last sal we displayed, if it's valid.  */
+/* See stack.h.  */

 
 struct program_space *
 get_last_displayed_pspace (void)
 {
 
 struct program_space *
 get_last_displayed_pspace (void)
 {

-  if (last_displayed_sal_valid)
-    return last_displayed_pspace;
-  return 0;
+  return last_displayed_symtab_info.pspace ();

 }
 
 }
 

-/* Get the address of the last sal we displayed, if it's valid.  */
+/* See stack.h.  */

 
 CORE_ADDR
 get_last_displayed_addr (void)
 {
 
 CORE_ADDR
 get_last_displayed_addr (void)
 {

-  if (last_displayed_sal_valid)
-    return last_displayed_addr;
-  return 0;
+  return last_displayed_symtab_info.address ();

 }
 
 }
 

-/* Get the symtab of the last sal we displayed, if it's valid.  */
+/* See stack.h.  */

 
 struct symtab*
 get_last_displayed_symtab (void)
 {
 
 struct symtab*
 get_last_displayed_symtab (void)
 {

-  if (last_displayed_sal_valid)
-    return last_displayed_symtab;
-  return 0;
+  return last_displayed_symtab_info.symtab ();

 }
 
 }
 

-/* Get the line of the last sal we displayed, if it's valid.  */
+/* See stack.h.  */

 
 int
 get_last_displayed_line (void)
 {
 
 int
 get_last_displayed_line (void)
 {

-  if (last_displayed_sal_valid)
-    return last_displayed_line;
-  return 0;
+  return last_displayed_symtab_info.line ();

 }
 
 }
 

-/* Get the last sal we displayed, if it's valid.  */
+/* See stack.h.  */

 
 symtab_and_line
 get_last_displayed_sal ()
 {
   symtab_and_line sal;
 
 
 symtab_and_line
 get_last_displayed_sal ()
 {
   symtab_and_line sal;
 

-  if (last_displayed_sal_valid)
+  if (last_displayed_symtab_info.is_valid ())

     {
     {

-      sal.pspace = last_displayed_pspace;
-      sal.pc = last_displayed_addr;
-      sal.symtab = last_displayed_symtab;
-      sal.line = last_displayed_line;
+      sal.pspace = last_displayed_symtab_info.pspace ();
+      sal.pc = last_displayed_symtab_info.address ();
+      sal.symtab = last_displayed_symtab_info.symtab ();
+      sal.line = last_displayed_symtab_info.line ();

     }
 
   return sal;
     }
 
   return sal;


@@ -1229,14 +1259,14 @@ find_frame_funname (struct frame_info *frame, enum language *funlang,
   func = get_frame_function (frame);
   if (func)
     {
   func = get_frame_function (frame);
   if (func)
     {

-      const char *print_name = SYMBOL_PRINT_NAME (func);
+      const char *print_name = func->print_name ();

 
 

-      *funlang = SYMBOL_LANGUAGE (func);
+      *funlang = func->language ();

       if (funcp)
        *funcp = func;
       if (*funlang == language_cplus)
        {
       if (funcp)
        *funcp = func;
       if (*funlang == language_cplus)
        {

-         /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
+         /* It seems appropriate to use print_name() here,

             to display the demangled name that we already have
             stored in the symbol table, but we stored a version
             with DMGL_PARAMS turned on, and here we don't want to
             to display the demangled name that we already have
             stored in the symbol table, but we stored a version
             with DMGL_PARAMS turned on, and here we don't want to


@@ -1260,8 +1290,8 @@ find_frame_funname (struct frame_info *frame, enum language *funlang,
       msymbol = lookup_minimal_symbol_by_pc (pc);
       if (msymbol.minsym != NULL)
        {
       msymbol = lookup_minimal_symbol_by_pc (pc);
       if (msymbol.minsym != NULL)
        {

-         funname.reset (xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)));
-         *funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
+         funname.reset (xstrdup (msymbol.minsym->print_name ()));
+         *funlang = msymbol.minsym->language ();

        }
     }
 
        }
     }
 


@@ -1310,7 +1340,7 @@ print_frame (const frame_print_options &fp_opts,
            print_pc (uiout, gdbarch, frame, pc);
          else
            uiout->field_string ("addr", "<unavailable>",
            print_pc (uiout, gdbarch, frame, pc);
          else
            uiout->field_string ("addr", "<unavailable>",

-                                ui_out_style_kind::ADDRESS);
+                                metadata_style.style ());

          annotate_frame_address_end ();
          uiout->text (" in ");
        }
          annotate_frame_address_end ();
          uiout->text (" in ");
        }


@@ -1319,7 +1349,7 @@ print_frame (const frame_print_options &fp_opts,
     string_file stb;
     fprintf_symbol_filtered (&stb, funname ? funname.get () : "??",
                             funlang, DMGL_ANSI);
     string_file stb;
     fprintf_symbol_filtered (&stb, funname ? funname.get () : "??",
                             funlang, DMGL_ANSI);

-    uiout->field_stream ("func", stb, ui_out_style_kind::FUNCTION);
+    uiout->field_stream ("func", stb, function_name_style.style ());

     uiout->wrap_hint ("   ");
     annotate_frame_args ();
 
     uiout->wrap_hint ("   ");
     annotate_frame_args ();
 


@@ -1361,7 +1391,8 @@ print_frame (const frame_print_options &fp_opts,
        uiout->wrap_hint ("   ");
        uiout->text (" at ");
        annotate_frame_source_file ();
        uiout->wrap_hint ("   ");
        uiout->text (" at ");
        annotate_frame_source_file ();

-       uiout->field_string ("file", filename_display, ui_out_style_kind::FILE);
+       uiout->field_string ("file", filename_display,
+                            file_name_style.style ());

        if (uiout->is_mi_like_p ())
          {
            const char *fullname = symtab_to_fullname (sal.symtab);
        if (uiout->is_mi_like_p ())
          {
            const char *fullname = symtab_to_fullname (sal.symtab);


@@ -1386,7 +1417,7 @@ print_frame (const frame_print_options &fp_opts,
            annotate_frame_where ();
            uiout->wrap_hint ("  ");
            uiout->text (" from ");
            annotate_frame_where ();
            uiout->wrap_hint ("  ");
            uiout->text (" from ");

-           uiout->field_string ("from", lib);
+           uiout->field_string ("from", lib, file_name_style.style ());

          }
       }
     if (uiout->is_mi_like_p ())
          }
       }
     if (uiout->is_mi_like_p ())


@@ -1401,7 +1432,7 @@ print_frame (const frame_print_options &fp_opts,
 /* Completion function for "frame function", "info frame function", and
    "select-frame function" commands.  */
 
 /* Completion function for "frame function", "info frame function", and
    "select-frame function" commands.  */
 

-void
+static void

 frame_selection_by_function_completer (struct cmd_list_element *ignore,
                                       completion_tracker &tracker,
                                       const char *text, const char *word)
 frame_selection_by_function_completer (struct cmd_list_element *ignore,
                                       completion_tracker &tracker,
                                       const char *text, const char *word)


@@ -1463,11 +1494,11 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
   gdb::unique_xmalloc_ptr<char> func_only;
   if (func)
     {
   gdb::unique_xmalloc_ptr<char> func_only;
   if (func)
     {

-      funname = SYMBOL_PRINT_NAME (func);
-      funlang = SYMBOL_LANGUAGE (func);
+      funname = func->print_name ();
+      funlang = func->language ();

       if (funlang == language_cplus)
        {
       if (funlang == language_cplus)
        {

-         /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
+         /* It seems appropriate to use print_name() here,

             to display the demangled name that we already have
             stored in the symbol table, but we stored a version
             with DMGL_PARAMS turned on, and here we don't want to
             to display the demangled name that we already have
             stored in the symbol table, but we stored a version
             with DMGL_PARAMS turned on, and here we don't want to


@@ -1485,8 +1516,8 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
       msymbol = lookup_minimal_symbol_by_pc (frame_pc);
       if (msymbol.minsym != NULL)
        {
       msymbol = lookup_minimal_symbol_by_pc (frame_pc);
       if (msymbol.minsym != NULL)
        {

-         funname = MSYMBOL_PRINT_NAME (msymbol.minsym);
-         funlang = MSYMBOL_LANGUAGE (msymbol.minsym);
+         funname = msymbol.minsym->print_name ();
+         funlang = msymbol.minsym->language ();

        }
     }
   calling_frame_info = get_prev_frame (fi);
        }
     }
   calling_frame_info = get_prev_frame (fi);


@@ -1506,7 +1537,7 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
   if (frame_pc_p)
     fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
   else
   if (frame_pc_p)
     fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
   else

-    fputs_filtered ("<unavailable>", gdb_stdout);
+    fputs_styled ("<unavailable>", metadata_style.style (), gdb_stdout);

 
   wrap_here ("   ");
   if (funname)
 
   wrap_here ("   ");
   if (funname)


@@ -1517,8 +1548,11 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
     }
   wrap_here ("   ");
   if (sal.symtab)
     }
   wrap_here ("   ");
   if (sal.symtab)

-    printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
-                    sal.line);
+    printf_filtered
+      (" (%ps:%d)",
+       styled_string (file_name_style.style (),
+                     symtab_to_filename_for_display (sal.symtab)),
+       sal.line);

   puts_filtered ("; ");
   wrap_here ("    ");
   printf_filtered ("saved %s = ", pc_regname);
   puts_filtered ("; ");
   wrap_here ("    ");
   printf_filtered ("saved %s = ", pc_regname);


@@ -1543,8 +1577,9 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p)
              val_print_not_saved (gdb_stdout);
              break;
            default:
              val_print_not_saved (gdb_stdout);
              break;
            default:

-             fprintf_filtered (gdb_stdout, _("<error: %s>"),
-                               ex.what ());
+             fprintf_styled (gdb_stdout, metadata_style.style (),
+                             _("<error: %s>"),
+                             ex.what ());

              break;
            }
        }
              break;
            }
        }


@@ -2211,7 +2246,7 @@ iterate_over_block_locals (const struct block *b,
            break;
          if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
            break;
            break;
          if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
            break;

-         (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
+         (*cb) (sym->print_name (), sym, cb_data);

          break;
 
        default:
          break;
 
        default:


@@ -2241,7 +2276,7 @@ print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
 
   ALL_BLOCK_SYMBOLS (b, iter, sym)
     {
 
   ALL_BLOCK_SYMBOLS (b, iter, sym)
     {

-      if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
+      if (strcmp (sym->linkage_name (), "default") == 0)

        {
          if (*have_default)
            continue;
        {
          if (*have_default)
            continue;


@@ -2254,7 +2289,7 @@ print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
 
          sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
          values_printed = 1;
 
          sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
          values_printed = 1;

-         fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
+         fputs_filtered (sym->print_name (), stream);

          get_user_print_options (&opts);
          if (opts.addressprint)
            {
          get_user_print_options (&opts);
          if (opts.addressprint)
            {


@@ -2316,8 +2351,7 @@ do_print_variable_and_value (const char *print_name,
   struct frame_info *frame;
 
   if (p->preg.has_value ()
   struct frame_info *frame;
 
   if (p->preg.has_value ()

-      && p->preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
-                       NULL, 0) != 0)
+      && p->preg->exec (sym->natural_name (), 0, NULL, 0) != 0)

     return;
   if (p->treg.has_value ()
       && !treg_matches_sym_type_name (*p->treg, sym))
     return;
   if (p->treg.has_value ()
       && !treg_matches_sym_type_name (*p->treg, sym))


@@ -2519,9 +2553,9 @@ iterate_over_block_arg_vars (const struct block *b,
             float).  There are also LOC_ARG/LOC_REGISTER pairs which
             are not combined in symbol-reading.  */
 
             float).  There are also LOC_ARG/LOC_REGISTER pairs which
             are not combined in symbol-reading.  */
 

-         sym2 = lookup_symbol_search_name (SYMBOL_SEARCH_NAME (sym),
+         sym2 = lookup_symbol_search_name (sym->search_name (),

                                            b, VAR_DOMAIN).symbol;
                                            b, VAR_DOMAIN).symbol;

-         (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data);
+         (*cb) (sym->print_name (), sym2, cb_data);

        }
     }
 }
        }
     }
 }


@@ -2821,7 +2855,7 @@ return_command (const char *retval_exp, int from_tty)
          if (TYPE_NO_RETURN (thisfun->type))
            warning (_("Function does not return normally to caller."));
          confirmed = query (_("%sMake %s return now? "), query_prefix,
          if (TYPE_NO_RETURN (thisfun->type))
            warning (_("Function does not return normally to caller."));
          confirmed = query (_("%sMake %s return now? "), query_prefix,

-                            SYMBOL_PRINT_NAME (thisfun));
+                            thisfun->print_name ());

        }
       if (!confirmed)
        error (_("Not confirmed"));
        }
       if (!confirmed)
        error (_("Not confirmed"));


@@ -3247,6 +3281,8 @@ frame_apply_command (const char* cmd, int from_tty)
 static void
 faas_command (const char *cmd, int from_tty)
 {
 static void
 faas_command (const char *cmd, int from_tty)
 {

+  if (cmd == NULL || *cmd == '\0')
+    error (_("Please specify a command to apply on all frames"));

   std::string expanded = std::string ("frame apply all -s ") + cmd;
   execute_command (expanded.c_str (), from_tty);
 }
   std::string expanded = std::string ("frame apply all -s ") + cmd;
   execute_command (expanded.c_str (), from_tty);
 }