gdb: remove uses of iterate_over_inferiors in mi/mi-main.c

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

diff --git a/gdb/symtab.c b/gdb/symtab.c
index e5ed42a49b6d35b7e9d027fb1f75151b1de4d47d..d5ba249ced60986ba946f6c598f60388732323b2 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1,6 +1,6 @@
 /* Symbol table lookup for the GNU debugger, GDB.
 
 /* Symbol table lookup for the GNU debugger, GDB.
 

-   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.
 


@@ -183,6 +183,16 @@ struct symbol_cache_slot
   } value;
 };
 
   } value;
 };
 

+/* Clear out SLOT.  */
+
+static void
+symbol_cache_clear_slot (struct symbol_cache_slot *slot)
+{
+  if (slot->state == SYMBOL_SLOT_NOT_FOUND)
+    xfree (slot->value.not_found.name);
+  slot->state = SYMBOL_SLOT_UNUSED;
+}
+

 /* Symbols don't specify global vs static block.
    So keep them in separate caches.  */
 
 /* Symbols don't specify global vs static block.
    So keep them in separate caches.  */
 


@@ -201,6 +211,19 @@ struct block_symbol_cache
   struct symbol_cache_slot symbols[1];
 };
 
   struct symbol_cache_slot symbols[1];
 };
 

+/* Clear all slots of BSC and free BSC.  */
+
+static void
+destroy_block_symbol_cache (struct block_symbol_cache *bsc)
+{
+  if (bsc != nullptr)
+    {
+      for (unsigned int i = 0; i < bsc->size; i++)
+       symbol_cache_clear_slot (&bsc->symbols[i]);
+      xfree (bsc);
+    }
+}
+

 /* The symbol cache.
 
    Searching for symbols in the static and global blocks over multiple objfiles
 /* The symbol cache.
 
    Searching for symbols in the static and global blocks over multiple objfiles


@@ -217,8 +240,8 @@ struct symbol_cache
 
   ~symbol_cache ()
   {
 
   ~symbol_cache ()
   {

-    xfree (global_symbols);
-    xfree (static_symbols);
+    destroy_block_symbol_cache (global_symbols);
+    destroy_block_symbol_cache (static_symbols);

   }
 
   struct block_symbol_cache *global_symbols = nullptr;
   }
 
   struct block_symbol_cache *global_symbols = nullptr;


@@ -652,7 +675,7 @@ symbol_set_demangled_name (struct general_symbol_info *gsymbol,
                            const char *name,
                            struct obstack *obstack)
 {
                            const char *name,
                            struct obstack *obstack)
 {

-  if (gsymbol->language == language_ada)
+  if (gsymbol->language () == language_ada)

     {
       if (name == NULL)
        {
     {
       if (name == NULL)
        {


@@ -674,7 +697,7 @@ symbol_set_demangled_name (struct general_symbol_info *gsymbol,
 const char *
 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
 {
 const char *
 symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
 {

-  if (gsymbol->language == language_ada)
+  if (gsymbol->language () == language_ada)

     {
       if (!gsymbol->ada_mangled)
        return NULL;
     {
       if (!gsymbol->ada_mangled)
        return NULL;


@@ -689,28 +712,26 @@ symbol_get_demangled_name (const struct general_symbol_info *gsymbol)
    depending upon the language for the symbol.  */
 
 void
    depending upon the language for the symbol.  */
 
 void

-symbol_set_language (struct general_symbol_info *gsymbol,
-                     enum language language,
-                    struct obstack *obstack)
+general_symbol_info::set_language (enum language language,
+                                  struct obstack *obstack)

 {
 {

-  gsymbol->language = language;
-  if (gsymbol->language == language_cplus
-      || gsymbol->language == language_d
-      || gsymbol->language == language_go
-      || gsymbol->language == language_objc
-      || gsymbol->language == language_fortran)
+  m_language = language;
+  if (language == language_cplus
+      || language == language_d
+      || language == language_go
+      || language == language_objc
+      || language == language_fortran)

     {
     {

-      symbol_set_demangled_name (gsymbol, NULL, obstack);
+      symbol_set_demangled_name (this, NULL, obstack);

     }
     }

-  else if (gsymbol->language == language_ada)
+  else if (language == language_ada)

     {
     {

-      gdb_assert (gsymbol->ada_mangled == 0);
-      gsymbol->language_specific.obstack = obstack;
+      gdb_assert (ada_mangled == 0);
+      language_specific.obstack = obstack;

     }
   else
     {
     }
   else
     {

-      memset (&gsymbol->language_specific, 0,
-             sizeof (gsymbol->language_specific));
+      memset (&language_specific, 0, sizeof (language_specific));

     }
 }
 
     }
 }
 


@@ -796,12 +817,12 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
   char *demangled = NULL;
   int i;
 
   char *demangled = NULL;
   int i;
 

-  if (gsymbol->language == language_unknown)
-    gsymbol->language = language_auto;
+  if (gsymbol->language () == language_unknown)
+    gsymbol->m_language = language_auto;

 
 

-  if (gsymbol->language != language_auto)
+  if (gsymbol->language () != language_auto)

     {
     {

-      const struct language_defn *lang = language_def (gsymbol->language);
+      const struct language_defn *lang = language_def (gsymbol->language ());

 
       language_sniff_from_mangled_name (lang, mangled, &demangled);
       return demangled;
 
       language_sniff_from_mangled_name (lang, mangled, &demangled);
       return demangled;


@@ -814,7 +835,7 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
 
       if (language_sniff_from_mangled_name (lang, mangled, &demangled))
        {
 
       if (language_sniff_from_mangled_name (lang, mangled, &demangled))
        {

-         gsymbol->language = l;
+         gsymbol->m_language = l;

          return demangled;
        }
     }
          return demangled;
        }
     }


@@ -834,18 +855,19 @@ symbol_find_demangled_name (struct general_symbol_info *gsymbol,
    so the pointer can be discarded after calling this function.  */
 
 void
    so the pointer can be discarded after calling this function.  */
 
 void

-symbol_set_names (struct general_symbol_info *gsymbol,
-                 gdb::string_view linkage_name, bool copy_name,
-                 struct objfile_per_bfd_storage *per_bfd)
+general_symbol_info::compute_and_set_names (gdb::string_view linkage_name,
+                                           bool copy_name,
+                                           objfile_per_bfd_storage *per_bfd,
+                                           gdb::optional<hashval_t> hash)

 {
   struct demangled_name_entry **slot;
 
 {
   struct demangled_name_entry **slot;
 

-  if (gsymbol->language == language_ada)
+  if (language () == language_ada)

     {
       /* In Ada, we do the symbol lookups using the mangled name, so
          we can save some space by not storing the demangled name.  */
       if (!copy_name)
     {
       /* In Ada, we do the symbol lookups using the mangled name, so
          we can save some space by not storing the demangled name.  */
       if (!copy_name)

-       gsymbol->name = linkage_name.data ();
+       m_name = linkage_name.data ();

       else
        {
          char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,
       else
        {
          char *name = (char *) obstack_alloc (&per_bfd->storage_obstack,


@@ -853,9 +875,9 @@ symbol_set_names (struct general_symbol_info *gsymbol,
 
          memcpy (name, linkage_name.data (), linkage_name.length ());
          name[linkage_name.length ()] = '\0';
 
          memcpy (name, linkage_name.data (), linkage_name.length ());
          name[linkage_name.length ()] = '\0';

-         gsymbol->name = name;
+         m_name = name;

        }
        }

-      symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
+      symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack);

 
       return;
     }
 
       return;
     }


@@ -864,15 +886,27 @@ symbol_set_names (struct general_symbol_info *gsymbol,
     create_demangled_names_hash (per_bfd);
 
   struct demangled_name_entry entry (linkage_name);
     create_demangled_names_hash (per_bfd);
 
   struct demangled_name_entry entry (linkage_name);

+  if (!hash.has_value ())
+    hash = hash_demangled_name_entry (&entry);

   slot = ((struct demangled_name_entry **)
   slot = ((struct demangled_name_entry **)

-         htab_find_slot (per_bfd->demangled_names_hash.get (),
-                         &entry, INSERT));
+          htab_find_slot_with_hash (per_bfd->demangled_names_hash.get (),
+                                   &entry, *hash, INSERT));
+
+  /* The const_cast is safe because the only reason it is already
+     initialized is if we purposefully set it from a background
+     thread to avoid doing the work here.  However, it is still
+     allocated from the heap and needs to be freed by us, just
+     like if we called symbol_find_demangled_name here.  If this is
+     nullptr, we call symbol_find_demangled_name below, but we put
+     this smart pointer here to be sure that we don't leak this name.  */
+  gdb::unique_xmalloc_ptr<char> demangled_name
+    (const_cast<char *> (language_specific.demangled_name));

 
   /* If this name is not in the hash table, add it.  */
   if (*slot == NULL
       /* A C version of the symbol may have already snuck into the table.
         This happens to, e.g., main.init (__go_init_main).  Cope.  */
 
   /* If this name is not in the hash table, add it.  */
   if (*slot == NULL
       /* A C version of the symbol may have already snuck into the table.
         This happens to, e.g., main.init (__go_init_main).  Cope.  */

-      || (gsymbol->language == language_go && (*slot)->demangled == nullptr))
+      || (language () == language_go && (*slot)->demangled == nullptr))

     {
       /* A 0-terminated copy of the linkage name.  Callers must set COPY_NAME
          to true if the string might not be nullterminated.  We have to make
     {
       /* A 0-terminated copy of the linkage name.  Callers must set COPY_NAME
          to true if the string might not be nullterminated.  We have to make


@@ -890,15 +924,9 @@ symbol_set_names (struct general_symbol_info *gsymbol,
       else
        linkage_name_copy = linkage_name;
 
       else
        linkage_name_copy = linkage_name;
 

-      /* The const_cast is safe because the only reason it is already
-         initialized is if we purposefully set it from a background
-         thread to avoid doing the work here.  However, it is still
-         allocated from the heap and needs to be freed by us, just
-         like if we called symbol_find_demangled_name here.  */
-      gdb::unique_xmalloc_ptr<char> demangled_name
-       (gsymbol->language_specific.demangled_name
-        ? const_cast<char *> (gsymbol->language_specific.demangled_name)
-        : symbol_find_demangled_name (gsymbol, linkage_name_copy.data ()));
+      if (demangled_name.get () == nullptr)
+        demangled_name.reset
+          (symbol_find_demangled_name (this, linkage_name_copy.data ()));

 
       /* Suppose we have demangled_name==NULL, copy_name==0, and
         linkage_name_copy==linkage_name.  In this case, we already have the
 
       /* Suppose we have demangled_name==NULL, copy_name==0, and
         linkage_name_copy==linkage_name.  In this case, we already have the


@@ -933,18 +961,17 @@ symbol_set_names (struct general_symbol_info *gsymbol,
            (gdb::string_view (mangled_ptr, linkage_name.length ()));
        }
       (*slot)->demangled = std::move (demangled_name);
            (gdb::string_view (mangled_ptr, linkage_name.length ()));
        }
       (*slot)->demangled = std::move (demangled_name);

-      (*slot)->language = gsymbol->language;
+      (*slot)->language = language ();

     }
     }

-  else if (gsymbol->language == language_unknown
-          || gsymbol->language == language_auto)
-    gsymbol->language = (*slot)->language;
+  else if (language () == language_unknown || language () == language_auto)
+    m_language = (*slot)->language;

 
 

-  gsymbol->name = (*slot)->mangled.data ();
+  m_name = (*slot)->mangled.data ();

   if ((*slot)->demangled != nullptr)
   if ((*slot)->demangled != nullptr)

-    symbol_set_demangled_name (gsymbol, (*slot)->demangled.get (),
+    symbol_set_demangled_name (this, (*slot)->demangled.get (),

                               &per_bfd->storage_obstack);
   else
                               &per_bfd->storage_obstack);
   else

-    symbol_set_demangled_name (gsymbol, NULL, &per_bfd->storage_obstack);
+    symbol_set_demangled_name (this, NULL, &per_bfd->storage_obstack);

 }
 
 /* See symtab.h.  */
 }
 
 /* See symtab.h.  */


@@ -952,7 +979,7 @@ symbol_set_names (struct general_symbol_info *gsymbol,
 const char *
 general_symbol_info::natural_name () const
 {
 const char *
 general_symbol_info::natural_name () const
 {

-  switch (language)
+  switch (language ())

     {
     case language_cplus:
     case language_d:
     {
     case language_cplus:
     case language_d:


@@ -967,7 +994,7 @@ general_symbol_info::natural_name () const
     default:
       break;
     }
     default:
       break;
     }

-  return name;
+  return linkage_name ();

 }
 
 /* See symtab.h.  */
 }
 
 /* See symtab.h.  */


@@ -977,7 +1004,7 @@ general_symbol_info::demangled_name () const
 {
   const char *dem_name = NULL;
 
 {
   const char *dem_name = NULL;
 

-  switch (language)
+  switch (language ())

     {
     case language_cplus:
     case language_d:
     {
     case language_cplus:
     case language_d:


@@ -1000,8 +1027,8 @@ general_symbol_info::demangled_name () const
 const char *
 general_symbol_info::search_name () const
 {
 const char *
 general_symbol_info::search_name () const
 {

-  if (language == language_ada)
-    return name;
+  if (language () == language_ada)
+    return linkage_name ();

   else
     return natural_name ();
 }
   else
     return natural_name ();
 }


@@ -1013,7 +1040,7 @@ symbol_matches_search_name (const struct general_symbol_info *gsymbol,
                            const lookup_name_info &name)
 {
   symbol_name_matcher_ftype *name_match
                            const lookup_name_info &name)
 {
   symbol_name_matcher_ftype *name_match

-    = get_symbol_name_matcher (language_def (gsymbol->language), name);
+    = get_symbol_name_matcher (language_def (gsymbol->language ()), name);

   return name_match (gsymbol->search_name (), name, NULL);
 }
 
   return name_match (gsymbol->search_name (), name, NULL);
 }
 


@@ -1193,8 +1220,7 @@ eq_symbol_entry (const struct symbol_cache_slot *slot,
          if (!SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
            return 0;
 
          if (!SYMBOL_MATCHES_SEARCH_NAME (sym, lookup_name))
            return 0;
 

-         if (!symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                     slot_domain, domain))
+         if (!symbol_matches_domain (sym->language (), slot_domain, domain))

            return 0;
        }
     }
            return 0;
        }
     }


@@ -1231,8 +1257,8 @@ resize_symbol_cache (struct symbol_cache *cache, unsigned int new_size)
          && new_size == 0))
     return;
 
          && new_size == 0))
     return;
 

-  xfree (cache->global_symbols);
-  xfree (cache->static_symbols);
+  destroy_block_symbol_cache (cache->global_symbols);
+  destroy_block_symbol_cache (cache->static_symbols);

 
   if (new_size == 0)
     {
 
   if (new_size == 0)
     {


@@ -1370,16 +1396,6 @@ symbol_cache_lookup (struct symbol_cache *cache,
   return {};
 }
 
   return {};
 }
 

-/* Clear out SLOT.  */
-
-static void
-symbol_cache_clear_slot (struct symbol_cache_slot *slot)
-{
-  if (slot->state == SYMBOL_SLOT_NOT_FOUND)
-    xfree (slot->value.not_found.name);
-  slot->state = SYMBOL_SLOT_UNUSED;
-}
-

 /* Mark SYMBOL as found in SLOT.
    OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
    if it's not needed to distinguish lookups (STATIC_BLOCK).  It is *not*
 /* Mark SYMBOL as found in SLOT.
    OBJFILE_CONTEXT is the current objfile when the lookup was done, or NULL
    if it's not needed to distinguish lookups (STATIC_BLOCK).  It is *not*


@@ -1657,7 +1673,8 @@ fixup_section (struct general_symbol_info *ginfo,
      e.g. on PowerPC64, where the minimal symbol for a function will
      point to the function descriptor, while the debug symbol will
      point to the actual function code.  */
      e.g. on PowerPC64, where the minimal symbol for a function will
      point to the function descriptor, while the debug symbol will
      point to the actual function code.  */

-  msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->name, objfile);
+  msym = lookup_minimal_symbol_by_pc_name (addr, ginfo->linkage_name (),
+                                          objfile);

   if (msym)
     ginfo->section = MSYMBOL_SECTION (msym);
   else
   if (msym)
     ginfo->section = MSYMBOL_SECTION (msym);
   else


@@ -1674,11 +1691,10 @@ fixup_section (struct general_symbol_info *ginfo,
 
         So, instead, search the section table when lookup by name has
         failed.  The ``addr'' and ``endaddr'' fields may have already
 
         So, instead, search the section table when lookup by name has
         failed.  The ``addr'' and ``endaddr'' fields may have already

-        been relocated.  If so, the relocation offset (i.e. the
-        ANOFFSET value) needs to be subtracted from these values when
-        performing the comparison.  We unconditionally subtract it,
-        because, when no relocation has been performed, the ANOFFSET
-        value will simply be zero.
+        been relocated.  If so, the relocation offset needs to be
+        subtracted from these values when performing the comparison.
+        We unconditionally subtract it, because, when no relocation
+        has been performed, the value will simply be zero.

 
         The address of the symbol whose section we're fixing up HAS
         NOT BEEN adjusted (relocated) yet.  It can't have been since
 
         The address of the symbol whose section we're fixing up HAS
         NOT BEEN adjusted (relocated) yet.  It can't have been since


@@ -1704,7 +1720,7 @@ fixup_section (struct general_symbol_info *ginfo,
       ALL_OBJFILE_OSECTIONS (objfile, s)
        {
          int idx = s - objfile->sections;
       ALL_OBJFILE_OSECTIONS (objfile, s)
        {
          int idx = s - objfile->sections;

-         CORE_ADDR offset = ANOFFSET (objfile->section_offsets, idx);
+         CORE_ADDR offset = objfile->section_offsets[idx];

 
          if (fallback == -1)
            fallback = idx;
 
          if (fallback == -1)
            fallback = idx;


@@ -2830,8 +2846,7 @@ iterate_over_symbols (const struct block *block,
 
   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
     {
 
   ALL_BLOCK_SYMBOLS_WITH_NAME (block, name, iter, sym)
     {

-      if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-                                SYMBOL_DOMAIN (sym), domain))
+      if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain))

        {
          struct block_symbol block_sym = {sym, block};
 
        {
          struct block_symbol block_sym = {sym, block};
 


@@ -4367,8 +4382,8 @@ file_matches (const char *file, const std::vector<const char *> &filenames,
   return false;
 }
 
   return false;
 }
 

-/* Helper function for sort_search_symbols_remove_dups and qsort.  Can only
-   sort symbols, not minimal symbols.  */
+/* Helper function for std::sort on symbol_search objects.  Can only sort
+   symbols, not minimal symbols.  */

 
 int
 symbol_search::compare_search_syms (const symbol_search &sym_a,
 
 int
 symbol_search::compare_search_syms (const symbol_search &sym_a,


@@ -4429,15 +4444,233 @@ treg_matches_sym_type_name (const compiled_regex &treg,
   return treg.exec (printed_sym_type_name.c_str (), 0, NULL, 0) == 0;
 }
 
   return treg.exec (printed_sym_type_name.c_str (), 0, NULL, 0) == 0;
 }
 

+/* See symtab.h.  */
+
+bool
+global_symbol_searcher::is_suitable_msymbol
+       (const enum search_domain kind, const minimal_symbol *msymbol)
+{
+  switch (MSYMBOL_TYPE (msymbol))
+    {
+    case mst_data:
+    case mst_bss:
+    case mst_file_data:
+    case mst_file_bss:
+      return kind == VARIABLES_DOMAIN;
+    case mst_text:
+    case mst_file_text:
+    case mst_solib_trampoline:
+    case mst_text_gnu_ifunc:
+      return kind == FUNCTIONS_DOMAIN;
+    default:
+      return false;
+    }
+}
+
+/* See symtab.h.  */
+
+bool
+global_symbol_searcher::expand_symtabs
+       (objfile *objfile, const gdb::optional<compiled_regex> &preg) const
+{
+  enum search_domain kind = m_kind;
+  bool found_msymbol = false;
+
+  if (objfile->sf)
+    objfile->sf->qf->expand_symtabs_matching
+      (objfile,
+       [&] (const char *filename, bool basenames)
+       {
+        return file_matches (filename, filenames, basenames);
+       },
+       lookup_name_info::match_any (),
+       [&] (const char *symname)
+       {
+        return (!preg.has_value ()
+                || preg->exec (symname, 0, NULL, 0) == 0);
+       },
+       NULL,
+       kind);
+
+  /* Here, we search through the minimal symbol tables for functions and
+     variables that match, and force their symbols to be read.  This is in
+     particular necessary for demangled variable names, which are no longer
+     put into the partial symbol tables.  The symbol will then be found
+     during the scan of symtabs later.
+
+     For functions, find_pc_symtab should succeed if we have debug info for
+     the function, for variables we have to call
+     lookup_symbol_in_objfile_from_linkage_name to determine if the
+     variable has debug info.  If the lookup fails, set found_msymbol so
+     that we will rescan to print any matching symbols without debug info.
+     We only search the objfile the msymbol came from, we no longer search
+     all objfiles.  In large programs (1000s of shared libs) searching all
+     objfiles is not worth the pain.  */
+  if (filenames.empty ()
+      && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
+    {
+      for (minimal_symbol *msymbol : objfile->msymbols ())
+       {
+         QUIT;

 
 

-/* Sort the symbols in RESULT and remove duplicates.  */
+         if (msymbol->created_by_gdb)
+           continue;

 
 

-static void
-sort_search_symbols_remove_dups (std::vector<symbol_search> *result)
+         if (is_suitable_msymbol (kind, msymbol))
+           {
+             if (!preg.has_value ()
+                 || preg->exec (msymbol->natural_name (), 0,
+                                NULL, 0) == 0)
+               {
+                 /* An important side-effect of these lookup functions is
+                    to expand the symbol table if msymbol is found, later
+                    in the process we will add matching symbols or
+                    msymbols to the results list, and that requires that
+                    the symbols tables are expanded.  */
+                 if (kind == FUNCTIONS_DOMAIN
+                     ? (find_pc_compunit_symtab
+                        (MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
+                        == NULL)
+                     : (lookup_symbol_in_objfile_from_linkage_name
+                        (objfile, msymbol->linkage_name (),
+                         VAR_DOMAIN)
+                        .symbol == NULL))
+                   found_msymbol = true;
+               }
+           }
+       }
+    }
+
+  return found_msymbol;
+}
+
+/* See symtab.h.  */
+
+bool
+global_symbol_searcher::add_matching_symbols
+       (objfile *objfile,
+        const gdb::optional<compiled_regex> &preg,
+        const gdb::optional<compiled_regex> &treg,
+        std::set<symbol_search> *result_set) const

 {
 {

-  std::sort (result->begin (), result->end ());
-  result->erase (std::unique (result->begin (), result->end ()),
-                result->end ());
+  enum search_domain kind = m_kind;
+
+  /* Add matching symbols (if not already present).  */
+  for (compunit_symtab *cust : objfile->compunits ())
+    {
+      const struct blockvector *bv  = COMPUNIT_BLOCKVECTOR (cust);
+
+      for (block_enum block : { GLOBAL_BLOCK, STATIC_BLOCK })
+       {
+         struct block_iterator iter;
+         struct symbol *sym;
+         const struct block *b = BLOCKVECTOR_BLOCK (bv, block);
+
+         ALL_BLOCK_SYMBOLS (b, iter, sym)
+           {
+             struct symtab *real_symtab = symbol_symtab (sym);
+
+             QUIT;
+
+             /* Check first sole REAL_SYMTAB->FILENAME.  It does
+                not need to be a substring of symtab_to_fullname as
+                it may contain "./" etc.  */
+             if ((file_matches (real_symtab->filename, filenames, false)
+                  || ((basenames_may_differ
+                       || file_matches (lbasename (real_symtab->filename),
+                                        filenames, true))
+                      && file_matches (symtab_to_fullname (real_symtab),
+                                       filenames, false)))
+                 && ((!preg.has_value ()
+                      || preg->exec (sym->natural_name (), 0,
+                                     NULL, 0) == 0)
+                     && ((kind == VARIABLES_DOMAIN
+                          && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+                          && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
+                          && SYMBOL_CLASS (sym) != LOC_BLOCK
+                          /* LOC_CONST can be used for more than
+                             just enums, e.g., c++ static const
+                             members.  We only want to skip enums
+                             here.  */
+                          && !(SYMBOL_CLASS (sym) == LOC_CONST
+                               && (TYPE_CODE (SYMBOL_TYPE (sym))
+                                   == TYPE_CODE_ENUM))
+                          && (!treg.has_value ()
+                              || treg_matches_sym_type_name (*treg, sym)))
+                         || (kind == FUNCTIONS_DOMAIN
+                             && SYMBOL_CLASS (sym) == LOC_BLOCK
+                             && (!treg.has_value ()
+                                 || treg_matches_sym_type_name (*treg,
+                                                                sym)))
+                         || (kind == TYPES_DOMAIN
+                             && SYMBOL_CLASS (sym) == LOC_TYPEDEF
+                             && SYMBOL_DOMAIN (sym) != MODULE_DOMAIN)
+                         || (kind == MODULES_DOMAIN
+                             && SYMBOL_DOMAIN (sym) == MODULE_DOMAIN
+                             && SYMBOL_LINE (sym) != 0))))
+               {
+                 if (result_set->size () < m_max_search_results)
+                   {
+                     /* Match, insert if not already in the results.  */
+                     symbol_search ss (block, sym);
+                     if (result_set->find (ss) == result_set->end ())
+                       result_set->insert (ss);
+                   }
+                 else
+                   return false;
+               }
+           }
+       }
+    }
+
+  return true;
+}
+
+/* See symtab.h.  */
+
+bool
+global_symbol_searcher::add_matching_msymbols
+       (objfile *objfile, const gdb::optional<compiled_regex> &preg,
+        std::vector<symbol_search> *results) const
+{
+  enum search_domain kind = m_kind;
+
+  for (minimal_symbol *msymbol : objfile->msymbols ())
+    {
+      QUIT;
+
+      if (msymbol->created_by_gdb)
+       continue;
+
+      if (is_suitable_msymbol (kind, msymbol))
+       {
+         if (!preg.has_value ()
+             || preg->exec (msymbol->natural_name (), 0,
+                            NULL, 0) == 0)
+           {
+             /* For functions we can do a quick check of whether the
+                symbol might be found via find_pc_symtab.  */
+             if (kind != FUNCTIONS_DOMAIN
+                 || (find_pc_compunit_symtab
+                     (MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
+                     == NULL))
+               {
+                 if (lookup_symbol_in_objfile_from_linkage_name
+                     (objfile, msymbol->linkage_name (),
+                      VAR_DOMAIN).symbol == NULL)
+                   {
+                     /* Matching msymbol, add it to the results list.  */
+                     if (results->size () < m_max_search_results)
+                       results->emplace_back (GLOBAL_BLOCK, msymbol, objfile);
+                     else
+                       return false;
+                   }
+               }
+           }
+       }
+    }
+
+  return true;

 }
 
 /* See symtab.h.  */
 }
 
 /* See symtab.h.  */


@@ -4445,35 +4678,11 @@ sort_search_symbols_remove_dups (std::vector<symbol_search> *result)
 std::vector<symbol_search>
 global_symbol_searcher::search () const
 {
 std::vector<symbol_search>
 global_symbol_searcher::search () const
 {

-  const struct blockvector *bv;
-  const struct block *b;
-  int i = 0;
-  struct block_iterator iter;
-  struct symbol *sym;
-  int found_misc = 0;
-  static const enum minimal_symbol_type types[]
-    = {mst_data, mst_text, mst_unknown};
-  static const enum minimal_symbol_type types2[]
-    = {mst_bss, mst_file_text, mst_unknown};
-  static const enum minimal_symbol_type types3[]
-    = {mst_file_data, mst_solib_trampoline, mst_unknown};
-  static const enum minimal_symbol_type types4[]
-    = {mst_file_bss, mst_text_gnu_ifunc, mst_unknown};
-  enum minimal_symbol_type ourtype;
-  enum minimal_symbol_type ourtype2;
-  enum minimal_symbol_type ourtype3;
-  enum minimal_symbol_type ourtype4;
-  std::vector<symbol_search> result;

   gdb::optional<compiled_regex> preg;
   gdb::optional<compiled_regex> treg;
 
   gdb_assert (m_kind != ALL_DOMAIN);
 
   gdb::optional<compiled_regex> preg;
   gdb::optional<compiled_regex> treg;
 
   gdb_assert (m_kind != ALL_DOMAIN);
 

-  ourtype = types[m_kind];
-  ourtype2 = types2[m_kind];
-  ourtype3 = types3[m_kind];
-  ourtype4 = types4[m_kind];
-

   if (m_symbol_name_regexp != NULL)
     {
       const char *symbol_name_regexp = m_symbol_name_regexp;
   if (m_symbol_name_regexp != NULL)
     {
       const char *symbol_name_regexp = m_symbol_name_regexp;


@@ -4526,230 +4735,62 @@ global_symbol_searcher::search () const
                    _("Invalid regexp"));
     }
 
                    _("Invalid regexp"));
     }
 

-  /* Search through the partial symtabs *first* for all symbols matching
-     the m_symbol_name_regexp (in preg).  That way we don't have to
-     reproduce all of the machinery below.  */
-  expand_symtabs_matching ([&] (const char *filename, bool basenames)
-                          {
-                            return file_matches (filename, filenames,
-                                                 basenames);
-                          },
-                          lookup_name_info::match_any (),
-                          [&] (const char *symname)
-                          {
-                            return (!preg.has_value ()
-                                    || preg->exec (symname,
-                                                   0, NULL, 0) == 0);
-                          },
-                          NULL,
-                          m_kind);
-
-  /* Here, we search through the minimal symbol tables for functions
-     and variables that match, and force their symbols to be read.
-     This is in particular necessary for demangled variable names,
-     which are no longer put into the partial symbol tables.
-     The symbol will then be found during the scan of symtabs below.
-
-     For functions, find_pc_symtab should succeed if we have debug info
-     for the function, for variables we have to call
-     lookup_symbol_in_objfile_from_linkage_name to determine if the variable
-     has debug info.
-     If the lookup fails, set found_misc so that we will rescan to print
-     any matching symbols without debug info.
-     We only search the objfile the msymbol came from, we no longer search
-     all objfiles.  In large programs (1000s of shared libs) searching all
-     objfiles is not worth the pain.  */
-
-  if (filenames.empty () && (m_kind == VARIABLES_DOMAIN
-                            || m_kind == FUNCTIONS_DOMAIN))
-    {
-      for (objfile *objfile : current_program_space->objfiles ())
-       {
-         for (minimal_symbol *msymbol : objfile->msymbols ())
-           {
-             QUIT;
-
-             if (msymbol->created_by_gdb)
-               continue;
-
-             if (MSYMBOL_TYPE (msymbol) == ourtype
-                 || MSYMBOL_TYPE (msymbol) == ourtype2
-                 || MSYMBOL_TYPE (msymbol) == ourtype3
-                 || MSYMBOL_TYPE (msymbol) == ourtype4)
-               {
-                 if (!preg.has_value ()
-                     || preg->exec (msymbol->natural_name (), 0,
-                                    NULL, 0) == 0)
-                   {
-                     /* Note: An important side-effect of these
-                        lookup functions is to expand the symbol
-                        table if msymbol is found, for the benefit of
-                        the next loop on compunits.  */
-                     if (m_kind == FUNCTIONS_DOMAIN
-                         ? (find_pc_compunit_symtab
-                            (MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
-                            == NULL)
-                         : (lookup_symbol_in_objfile_from_linkage_name
-                            (objfile, msymbol->linkage_name (), VAR_DOMAIN)
-                            .symbol == NULL))
-                       found_misc = 1;
-                   }
-               }
-           }
-       }
-    }
-
+  bool found_msymbol = false;
+  std::set<symbol_search> result_set;

   for (objfile *objfile : current_program_space->objfiles ())
     {
   for (objfile *objfile : current_program_space->objfiles ())
     {

-      for (compunit_symtab *cust : objfile->compunits ())
-       {
-         bv = COMPUNIT_BLOCKVECTOR (cust);
-         for (i = GLOBAL_BLOCK; i <= STATIC_BLOCK; i++)
-           {
-             b = BLOCKVECTOR_BLOCK (bv, i);
-             ALL_BLOCK_SYMBOLS (b, iter, sym)
-               {
-                 struct symtab *real_symtab = symbol_symtab (sym);
-
-                 QUIT;
-
-                 /* Check first sole REAL_SYMTAB->FILENAME.  It does
-                    not need to be a substring of symtab_to_fullname as
-                    it may contain "./" etc.  */
-                 if ((file_matches (real_symtab->filename, filenames, false)
-                      || ((basenames_may_differ
-                           || file_matches (lbasename (real_symtab->filename),
-                                            filenames, true))
-                          && file_matches (symtab_to_fullname (real_symtab),
-                                           filenames, false)))
-                     && ((!preg.has_value ()
-                          || preg->exec (sym->natural_name (), 0,
-                                         NULL, 0) == 0)
-                         && ((m_kind == VARIABLES_DOMAIN
-                              && SYMBOL_CLASS (sym) != LOC_TYPEDEF
-                              && SYMBOL_CLASS (sym) != LOC_UNRESOLVED
-                              && SYMBOL_CLASS (sym) != LOC_BLOCK
-                              /* LOC_CONST can be used for more than
-                                 just enums, e.g., c++ static const
-                                 members.  We only want to skip enums
-                                 here.  */
-                              && !(SYMBOL_CLASS (sym) == LOC_CONST
-                                   && (TYPE_CODE (SYMBOL_TYPE (sym))
-                                       == TYPE_CODE_ENUM))
-                              && (!treg.has_value ()
-                                  || treg_matches_sym_type_name (*treg, sym)))
-                             || (m_kind == FUNCTIONS_DOMAIN
-                                 && SYMBOL_CLASS (sym) == LOC_BLOCK
-                                 && (!treg.has_value ()
-                                     || treg_matches_sym_type_name (*treg,
-                                                                    sym)))
-                             || (m_kind == TYPES_DOMAIN
-                                 && SYMBOL_CLASS (sym) == LOC_TYPEDEF
-                                 && SYMBOL_DOMAIN (sym) != MODULE_DOMAIN)
-                             || (m_kind == MODULES_DOMAIN
-                                 && SYMBOL_DOMAIN (sym) == MODULE_DOMAIN
-                                 && SYMBOL_LINE (sym) != 0))))
-                   {
-                     /* match */
-                     result.emplace_back (i, sym);
-                   }
-               }
-           }
-       }
+      /* Expand symtabs within objfile that possibly contain matching
+        symbols.  */
+      found_msymbol |= expand_symtabs (objfile, preg);
+
+      /* Find matching symbols within OBJFILE and add them in to the
+        RESULT_SET set.  Use a set here so that we can easily detect
+        duplicates as we go, and can therefore track how many unique
+        matches we have found so far.  */
+      if (!add_matching_symbols (objfile, preg, treg, &result_set))
+       break;

     }
 
     }
 

-  if (!result.empty ())
-    sort_search_symbols_remove_dups (&result);
+  /* Convert the result set into a sorted result list, as std::set is
+     defined to be sorted then no explicit call to std::sort is needed.  */
+  std::vector<symbol_search> result (result_set.begin (), result_set.end ());

 
   /* If there are no debug symbols, then add matching minsyms.  But if the
 
   /* If there are no debug symbols, then add matching minsyms.  But if the

-     user wants to see symbols matching a type m_symbol_type_regexp, then
-     never give a minimal symbol, as we assume that a minimal symbol does
-     not have a type.  */
-
-  if ((found_misc || (filenames.empty () && m_kind != FUNCTIONS_DOMAIN))
+     user wants to see symbols matching a type regexp, then never give a
+     minimal symbol, as we assume that a minimal symbol does not have a
+     type.  */
+  if ((found_msymbol || (filenames.empty () && m_kind == VARIABLES_DOMAIN))

       && !m_exclude_minsyms
       && !treg.has_value ())
     {
       && !m_exclude_minsyms
       && !treg.has_value ())
     {

+      gdb_assert (m_kind == VARIABLES_DOMAIN || m_kind == FUNCTIONS_DOMAIN);

       for (objfile *objfile : current_program_space->objfiles ())
       for (objfile *objfile : current_program_space->objfiles ())

-       {
-         for (minimal_symbol *msymbol : objfile->msymbols ())
-           {
-             QUIT;
-
-             if (msymbol->created_by_gdb)
-               continue;
-
-             if (MSYMBOL_TYPE (msymbol) == ourtype
-                 || MSYMBOL_TYPE (msymbol) == ourtype2
-                 || MSYMBOL_TYPE (msymbol) == ourtype3
-                 || MSYMBOL_TYPE (msymbol) == ourtype4)
-               {
-                 if (!preg.has_value ()
-                     || preg->exec (msymbol->natural_name (), 0,
-                                    NULL, 0) == 0)
-                   {
-                     /* For functions we can do a quick check of whether the
-                        symbol might be found via find_pc_symtab.  */
-                     if (m_kind != FUNCTIONS_DOMAIN
-                         || (find_pc_compunit_symtab
-                             (MSYMBOL_VALUE_ADDRESS (objfile, msymbol))
-                             == NULL))
-                       {
-                         if (lookup_symbol_in_objfile_from_linkage_name
-                             (objfile, msymbol->linkage_name (), VAR_DOMAIN)
-                             .symbol == NULL)
-                           {
-                             /* match */
-                             result.emplace_back (i, msymbol, objfile);
-                           }
-                       }
-                   }
-               }
-           }
-       }
+       if (!add_matching_msymbols (objfile, preg, &result))
+         break;

     }
 
   return result;
 }
 
     }
 
   return result;
 }
 

-/* Helper function for symtab_symbol_info, this function uses
-   the data returned from search_symbols() to print information
-   regarding the match to gdb_stdout.  If LAST is not NULL,
-   print file and line number information for the symbol as
-   well.  Skip printing the filename if it matches LAST.  */
+/* See symtab.h.  */

 
 

-static void
-print_symbol_info (enum search_domain kind,
-                  struct symbol *sym,
-                  int block, const char *last)
+std::string
+symbol_to_info_string (struct symbol *sym, int block,
+                      enum search_domain kind)

 {
 {

-  scoped_switch_to_sym_language_if_auto l (sym);
-  struct symtab *s = symbol_symtab (sym);
-
-  if (last != NULL)
-    {
-      const char *s_filename = symtab_to_filename_for_display (s);
-
-      if (filename_cmp (last, s_filename) != 0)
-       {
-         printf_filtered (_("\nFile %ps:\n"),
-                          styled_string (file_name_style.style (),
-                                         s_filename));
-       }
+  std::string str;

 
 

-      if (SYMBOL_LINE (sym) != 0)
-       printf_filtered ("%d:\t", SYMBOL_LINE (sym));
-      else
-       puts_filtered ("\t");
-    }
+  gdb_assert (block == GLOBAL_BLOCK || block == STATIC_BLOCK);

 
   if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
 
   if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)

-    printf_filtered ("static ");
+    str += "static ";

 
   /* Typedef that is not a C++ class.  */
   if (kind == TYPES_DOMAIN
       && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
     {
 
   /* Typedef that is not a C++ class.  */
   if (kind == TYPES_DOMAIN
       && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
     {

+      string_file tmp_stream;
+

       /* FIXME: For C (and C++) we end up with a difference in output here
         between how a typedef is printed, and non-typedefs are printed.
         The TYPEDEF_PRINT code places a ";" at the end in an attempt to
       /* FIXME: For C (and C++) we end up with a difference in output here
         between how a typedef is printed, and non-typedefs are printed.
         The TYPEDEF_PRINT code places a ";" at the end in an attempt to


@@ -4759,28 +4800,69 @@ print_symbol_info (enum search_domain kind,
         printing of the ";" in this function, which is going to be wrong
         for languages that don't require a ";" between statements.  */
       if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_TYPEDEF)
         printing of the ";" in this function, which is going to be wrong
         for languages that don't require a ";" between statements.  */
       if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_TYPEDEF)

-       typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
+       typedef_print (SYMBOL_TYPE (sym), sym, &tmp_stream);

       else
       else

-       type_print (SYMBOL_TYPE (sym), "", gdb_stdout, -1);
-      printf_filtered ("\n");
+       type_print (SYMBOL_TYPE (sym), "", &tmp_stream, -1);
+      str += tmp_stream.string ();

     }
   /* variable, func, or typedef-that-is-c++-class.  */
   else if (kind < TYPES_DOMAIN
           || (kind == TYPES_DOMAIN
               && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
     {
     }
   /* variable, func, or typedef-that-is-c++-class.  */
   else if (kind < TYPES_DOMAIN
           || (kind == TYPES_DOMAIN
               && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
     {

+      string_file tmp_stream;
+

       type_print (SYMBOL_TYPE (sym),
                  (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                   ? "" : sym->print_name ()),
       type_print (SYMBOL_TYPE (sym),
                  (SYMBOL_CLASS (sym) == LOC_TYPEDEF
                   ? "" : sym->print_name ()),

-                 gdb_stdout, 0);
+                 &tmp_stream, 0);

 
 

-      printf_filtered (";\n");
+      str += tmp_stream.string ();
+      str += ";";

     }
   /* Printing of modules is currently done here, maybe at some future
      point we might want a language specific method to print the module
      symbol so that we can customise the output more.  */
   else if (kind == MODULES_DOMAIN)
     }
   /* Printing of modules is currently done here, maybe at some future
      point we might want a language specific method to print the module
      symbol so that we can customise the output more.  */
   else if (kind == MODULES_DOMAIN)

-    printf_filtered ("%s\n", sym->print_name ());
+    str += sym->print_name ();
+
+  return str;
+}
+
+/* Helper function for symbol info commands, for example 'info functions',
+   'info variables', etc.  KIND is the kind of symbol we searched for, and
+   BLOCK is the type of block the symbols was found in, either GLOBAL_BLOCK
+   or STATIC_BLOCK.  SYM is the symbol we found.  If LAST is not NULL,
+   print file and line number information for the symbol as well.  Skip
+   printing the filename if it matches LAST.  */
+
+static void
+print_symbol_info (enum search_domain kind,
+                  struct symbol *sym,
+                  int block, const char *last)
+{
+  scoped_switch_to_sym_language_if_auto l (sym);
+  struct symtab *s = symbol_symtab (sym);
+
+  if (last != NULL)
+    {
+      const char *s_filename = symtab_to_filename_for_display (s);
+
+      if (filename_cmp (last, s_filename) != 0)
+       {
+         printf_filtered (_("\nFile %ps:\n"),
+                          styled_string (file_name_style.style (),
+                                         s_filename));
+       }
+
+      if (SYMBOL_LINE (sym) != 0)
+       printf_filtered ("%d:\t", SYMBOL_LINE (sym));
+      else
+       puts_filtered ("\t");
+    }
+
+  std::string str = symbol_to_info_string (sym, block, kind);
+  printf_filtered ("%s\n", str.c_str ());

 }
 
 /* This help function for symtab_symbol_info() prints information
 }
 
 /* This help function for symtab_symbol_info() prints information


@@ -5179,7 +5261,7 @@ completion_list_add_symbol (completion_tracker &tracker,
                            const lookup_name_info &lookup_name,
                            const char *text, const char *word)
 {
                            const lookup_name_info &lookup_name,
                            const char *text, const char *word)
 {

-  completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym),
+  completion_list_add_name (tracker, sym->language (),

                            sym->natural_name (),
                            lookup_name, text, word);
 }
                            sym->natural_name (),
                            lookup_name, text, word);
 }


@@ -5192,7 +5274,7 @@ completion_list_add_msymbol (completion_tracker &tracker,
                             const lookup_name_info &lookup_name,
                             const char *text, const char *word)
 {
                             const lookup_name_info &lookup_name,
                             const char *text, const char *word)
 {

-  completion_list_add_name (tracker, MSYMBOL_LANGUAGE (sym),
+  completion_list_add_name (tracker, sym->language (),

                            sym->natural_name (),
                            lookup_name, text, word);
 }
                            sym->natural_name (),
                            lookup_name, text, word);
 }


@@ -5326,7 +5408,7 @@ completion_list_add_fields (completion_tracker &tracker,
       if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
        for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
          if (TYPE_FIELD_NAME (t, j))
       if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
        for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
          if (TYPE_FIELD_NAME (t, j))

-           completion_list_add_name (tracker, SYMBOL_LANGUAGE (sym),
+           completion_list_add_name (tracker, sym->language (),

                                      TYPE_FIELD_NAME (t, j),
                                      lookup_name, text, word);
     }
                                      TYPE_FIELD_NAME (t, j),
                                      lookup_name, text, word);
     }


@@ -6294,8 +6376,7 @@ get_msymbol_address (struct objfile *objf, const struct minimal_symbol *minsym)
            return BMSYMBOL_VALUE_ADDRESS (found);
        }
     }
            return BMSYMBOL_VALUE_ADDRESS (found);
        }
     }

-  return (minsym->value.address
-         + ANOFFSET (objf->section_offsets, minsym->section));
+  return minsym->value.address + objf->section_offsets[minsym->section];

 }
 
 \f
 }
 
 \f


@@ -6608,8 +6689,9 @@ info_module_var_func_command_completer (struct cmd_list_element *ignore,
 
 \f
 
 
 \f
 

+void _initialize_symtab ();

 void
 void

-_initialize_symtab (void)
+_initialize_symtab ()

 {
   cmd_list_element *c;
 
 {
   cmd_list_element *c;