projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
gdb: add target_ops::supports_displaced_step
[deliverable/binutils-gdb.git] / gdb / stack.c
diff --git a/gdb/stack.c b/gdb/stack.c
index 06431ea3543e786a89e6194a023f66b949bacb8b..265e764dc242dca48dda56da9ef5ea69fbf11d79 100644 (file)
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -1,6 +1,6 @@
 /* Print and select stack frames for GDB, the GNU debugger.
 
 /* Print and select stack frames for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2019 Free Software Foundation, Inc.
+   Copyright (C) 1986-2020 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
 
    This file is part of GDB.
 
@@ -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.  */
@@ -183,9 +184,9 @@ pretty-printers for that value.")
 
 struct backtrace_cmd_options
 {
 
 struct backtrace_cmd_options
 {
-  int full = 0;
-  int no_filters = 0;
-  int hide = 0;
+  bool full = false;
+  bool no_filters = false;
+  bool hide = false;
 };
 
 using bt_flag_option_def
 };
 
 using bt_flag_option_def
@@ -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,10 +327,10 @@ 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 || !sal.is_stmt;
 }
 
 /* See frame.h.  */
 }
 
 /* See frame.h.  */
@@ -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;
 
@@ -421,17 +486,18 @@ print_frame_arg (const frame_print_options &fp_opts,
              vp_opts.summary
                = fp_opts.print_frame_arguments == print_frame_arguments_scalars;
 
              vp_opts.summary
                = fp_opts.print_frame_arguments == print_frame_arguments_scalars;
 
-             common_val_print (arg->val, &stb, 2, &vp_opts, language);
+             common_val_print_checked (arg->val, &stb, 2, &vp_opts, language);
            }
          catch (const gdb_exception_error &except)
            {
              stb.printf (_("<error reading variable: %s>"),
                          except.what ());
            }
          catch (const gdb_exception_error &except)
            {
              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 ();
@@ -1060,10 +1126,25 @@ print_frame_info (const frame_print_options &fp_opts,
     {
       int mid_statement = ((print_what == SRC_LINE)
                           && frame_show_address (frame, sal));
     {
       int mid_statement = ((print_what == SRC_LINE)
                           && frame_show_address (frame, sal));
-      annotate_source_line (sal.symtab, sal.line, mid_statement,
-                           get_frame_pc (frame));
-
-      if (deprecated_print_frame_info_listing_hook)
+      if (annotation_level > 0
+         && annotate_source_line (sal.symtab, sal.line, mid_statement,
+                                  get_frame_pc (frame)))
+       {
+         /* The call to ANNOTATE_SOURCE_LINE already printed the
+            annotation for this source line, so we avoid the two cases
+            below and do not print the actual source line.  The
+            documentation for annotations makes it clear that the source
+            line annotation is printed __instead__ of printing the source
+            line, not as well as.
+
+            However, if we fail to print the source line, which usually
+            means either the source file is missing, or the requested
+            line is out of range of the file, then we don't print the
+            source annotation, and will pass through the "normal" print
+            source line code below, the expectation is that this code
+            will print an appropriate error.  */
+       }
+      else if (deprecated_print_frame_info_listing_hook)
        deprecated_print_frame_info_listing_hook (sal.symtab, sal.line,
                                                  sal.line + 1, 0);
       else
        deprecated_print_frame_info_listing_hook (sal.symtab, sal.line,
                                                  sal.line + 1, 0);
       else
@@ -1087,21 +1168,21 @@ print_frame_info (const frame_print_options &fp_opts,
 
          print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
        }
 
          print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
        }
-    }
 
 
-  /* If disassemble-next-line is set to on and there is line debug
-     messages, output assembly codes for next line.  */
-  if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
-    do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
+      /* If disassemble-next-line is set to on and there is line debug
+        messages, output assembly codes for next line.  */
+      if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
+       do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
+    }
 
   if (set_current_sal)
     {
       CORE_ADDR pc;
 
       if (get_frame_pc_if_available (frame, &pc))
 
   if (set_current_sal)
     {
       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 +1190,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 +1274,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 +1305,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 +1355,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 +1364,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 +1406,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 +1432,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 +1447,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 +1509,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 +1531,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 +1552,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 +1563,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 +1592,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;
            }
        }
@@ -2202,6 +2252,7 @@ iterate_over_block_locals (const struct block *b,
     {
       switch (SYMBOL_CLASS (sym))
        {
     {
       switch (SYMBOL_CLASS (sym))
        {
+       case LOC_CONST:
        case LOC_LOCAL:
        case LOC_REGISTER:
        case LOC_STATIC:
        case LOC_LOCAL:
        case LOC_REGISTER:
        case LOC_STATIC:
@@ -2211,7 +2262,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:
@@ -2221,56 +2272,6 @@ iterate_over_block_locals (const struct block *b,
     }
 }
 
     }
 }
 
-
-/* Same, but print labels.  */
-
-#if 0
-/* Commented out, as the code using this function has also been
-   commented out.  FIXME:brobecker/2009-01-13: Find out why the code
-   was commented out in the first place.  The discussion introducing
-   this change (2007-12-04: Support lexical blocks and function bodies
-   that occupy non-contiguous address ranges) did not explain why
-   this change was made.  */
-static int
-print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
-                         int *have_default, struct ui_file *stream)
-{
-  struct block_iterator iter;
-  struct symbol *sym;
-  int values_printed = 0;
-
-  ALL_BLOCK_SYMBOLS (b, iter, sym)
-    {
-      if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
-       {
-         if (*have_default)
-           continue;
-         *have_default = 1;
-       }
-      if (SYMBOL_CLASS (sym) == LOC_LABEL)
-       {
-         struct symtab_and_line sal;
-         struct value_print_options opts;
-
-         sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
-         values_printed = 1;
-         fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
-         get_user_print_options (&opts);
-         if (opts.addressprint)
-           {
-             fprintf_filtered (stream, " ");
-             fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
-                             stream);
-           }
-         fprintf_filtered (stream, " in file %s, line %d\n",
-                           sal.symtab->filename, sal.line);
-       }
-    }
-
-  return values_printed;
-}
-#endif
-
 /* Iterate over all the local variables in block B, including all its
    superblocks, stopping when the top-level block is reached.  */
 
 /* Iterate over all the local variables in block B, including all its
    superblocks, stopping when the top-level block is reached.  */
 
@@ -2316,8 +2317,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))
@@ -2417,13 +2417,76 @@ print_frame_local_vars (struct frame_info *frame,
     }
 }
 
     }
 }
 
+/* Structure to hold the values of the options used by the 'info
+   variables' command and other similar commands.  These correspond to the
+   -q and -t options.  */
+
+struct info_print_options
+{
+  bool quiet = false;
+  char *type_regexp = nullptr;
+
+  ~info_print_options ()
+  {
+    xfree (type_regexp);
+  }
+};
+
+/* The options used by the 'info locals' and 'info args' commands.  */
+
+static const gdb::option::option_def info_print_options_defs[] = {
+  gdb::option::boolean_option_def<info_print_options> {
+    "q",
+    [] (info_print_options *opt) { return &opt->quiet; },
+    nullptr, /* show_cmd_cb */
+    nullptr /* set_doc */
+  },
+
+  gdb::option::string_option_def<info_print_options> {
+    "t",
+    [] (info_print_options *opt) { return &opt->type_regexp; },
+    nullptr, /* show_cmd_cb */
+    nullptr /* set_doc */
+  }
+};
+
+/* Returns the option group used by 'info locals' and 'info args'
+   commands.  */
+
+static gdb::option::option_def_group
+make_info_print_options_def_group (info_print_options *opts)
+{
+  return {{info_print_options_defs}, opts};
+}
+
+/* Command completer for 'info locals' and 'info args'.  */
+
+static void
+info_print_command_completer (struct cmd_list_element *ignore,
+                             completion_tracker &tracker,
+                             const char *text, const char * /* word */)
+{
+  const auto group
+    = make_info_print_options_def_group (nullptr);
+  if (gdb::option::complete_options
+      (tracker, &text, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, group))
+    return;
+
+  const char *word = advance_to_expression_complete_word_point (tracker, text);
+  symbol_completer (ignore, tracker, text, word);
+}
+
 /* Implement the 'info locals' command.  */
 
 void
 info_locals_command (const char *args, int from_tty)
 {
   info_print_options opts;
 /* Implement the 'info locals' command.  */
 
 void
 info_locals_command (const char *args, int from_tty)
 {
   info_print_options opts;
-  extract_info_print_options (&opts, &args);
+  auto grp = make_info_print_options_def_group (&opts);
+  gdb::option::process_options
+    (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
+  if (args != nullptr && *args == '\0')
+    args = nullptr;
 
   print_frame_local_vars (get_selected_frame (_("No frame selected.")),
                          opts.quiet, args, opts.type_regexp,
 
   print_frame_local_vars (get_selected_frame (_("No frame selected.")),
                          opts.quiet, args, opts.type_regexp,
@@ -2456,9 +2519,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);
        }
     }
 }
        }
     }
 }
@@ -2530,7 +2593,11 @@ void
 info_args_command (const char *args, int from_tty)
 {
   info_print_options opts;
 info_args_command (const char *args, int from_tty)
 {
   info_print_options opts;
-  extract_info_print_options (&opts, &args);
+  auto grp = make_info_print_options_def_group (&opts);
+  gdb::option::process_options
+    (&args, gdb::option::PROCESS_OPTIONS_UNKNOWN_IS_OPERAND, grp);
+  if (args != nullptr && *args == '\0')
+    args = nullptr;
 
   print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
                        opts.quiet, args, opts.type_regexp, gdb_stdout);
 
   print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
                        opts.quiet, args, opts.type_regexp, gdb_stdout);
@@ -2717,7 +2784,7 @@ return_command (const char *retval_exp, int from_tty)
        function = read_var_value (thisfun, NULL, thisframe);
 
       rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
        function = read_var_value (thisfun, NULL, thisframe);
 
       rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
-      if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
+      if (return_type->code () == TYPE_CODE_VOID)
        /* If the return-type is "void", don't try to find the
            return-value's location.  However, do still evaluate the
            return expression so that, even when the expression result
        /* If the return-type is "void", don't try to find the
            return-value's location.  However, do still evaluate the
            return expression so that, even when the expression result
@@ -2754,7 +2821,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"));
@@ -3180,6 +3247,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);
 }
@@ -3236,8 +3305,9 @@ static struct cmd_list_element *select_frame_cmd_list = NULL;
 /* Commands with a prefix of `info frame'.  */
 static struct cmd_list_element *info_frame_cmd_list = NULL;
 
 /* Commands with a prefix of `info frame'.  */
 static struct cmd_list_element *info_frame_cmd_list = NULL;
 
+void _initialize_stack ();
 void
 void
-_initialize_stack (void)
+_initialize_stack ()
 {
   struct cmd_list_element *cmd;
 
 {
   struct cmd_list_element *cmd;
 
@@ -3269,7 +3339,6 @@ Select and print a stack frame.\n\
 With no argument, print the selected stack frame.  (See also \"info frame\").\n\
 A single numerical argument specifies the frame to select."),
                   &frame_cmd_list, "frame ", 1, &cmdlist);
 With no argument, print the selected stack frame.  (See also \"info frame\").\n\
 A single numerical argument specifies the frame to select."),
                   &frame_cmd_list, "frame ", 1, &cmdlist);
-
   add_com_alias ("f", "frame", class_stack, 1);
 
 #define FRAME_APPLY_OPTION_HELP "\
   add_com_alias ("f", "frame", class_stack, 1);
 
 #define FRAME_APPLY_OPTION_HELP "\
@@ -3329,14 +3398,6 @@ shortcut for 'frame apply all -s [OPTION]... COMMAND'\n\
 See \"help frame apply all\" for available options."));
   set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
 
 See \"help frame apply all\" for available options."));
   set_cmd_completer_handle_brkchars (cmd, frame_apply_all_cmd_completer);
 
-  add_prefix_cmd ("frame", class_stack,
-                 &frame_cmd.base_command, _("\
-Select and print a stack frame.\n\
-With no argument, print the selected stack frame.  (See also \"info frame\").\n\
-A single numerical argument specifies the frame to select."),
-                 &frame_cmd_list, "frame ", 1, &cmdlist);
-  add_com_alias ("f", "frame", class_stack, 1);
-
   add_cmd ("address", class_stack, &frame_cmd.address,
           _("\
 Select and print a stack frame by stack address.\n\
   add_cmd ("address", class_stack, &frame_cmd.address,
           _("\
 Select and print a stack frame by stack address.\n\
@@ -3439,7 +3500,7 @@ With a negative COUNT, print outermost -COUNT frames."),
 
   add_com_alias ("bt", "backtrace", class_stack, 0);
 
 
   add_com_alias ("bt", "backtrace", class_stack, 0);
 
-  add_com_alias ("where", "backtrace", class_alias, 0);
+  add_com_alias ("where", "backtrace", class_stack, 0);
   add_info ("stack", backtrace_command,
            _("Backtrace of the stack, or innermost COUNT frames."));
   add_info_alias ("s", "stack", 1);
   add_info ("stack", backtrace_command,
            _("Backtrace of the stack, or innermost COUNT frames."));
   add_info_alias ("s", "stack", 1);
@@ -3487,14 +3548,16 @@ Usage: info frame level LEVEL"),
 All local variables of current stack frame or those matching REGEXPs.\n\
 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
 Prints the local variables of the current stack frame.\n"),
 All local variables of current stack frame or those matching REGEXPs.\n\
 Usage: info locals [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
 Prints the local variables of the current stack frame.\n"),
-                                 _("local variables")));
+                                       _("local variables"),
+                                       false));
   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
   cmd = add_info ("args", info_args_command,
                  info_print_args_help (_("\
 All argument variables of current stack frame or those matching REGEXPs.\n\
 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
 Prints the argument variables of the current stack frame.\n"),
   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
   cmd = add_info ("args", info_args_command,
                  info_print_args_help (_("\
 All argument variables of current stack frame or those matching REGEXPs.\n\
 Usage: info args [-q] [-t TYPEREGEXP] [NAMEREGEXP]\n\
 Prints the argument variables of the current stack frame.\n"),
-                                 _("argument variables")));
+                                       _("argument variables"),
+                                       false));
   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
 
   if (dbx_commands)
   set_cmd_completer_handle_brkchars (cmd, info_print_command_completer);
 
   if (dbx_commands)
GDB Binutils - Deliverables
This page took 0.04078 seconds and 4 git commands to generate.