Use a member function to set a symbol's language

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

diff --git a/gdb/symtab.h b/gdb/symtab.h
index 83d0ff256967a3c51a79c87a292a1318dbc076db..e18cd65a3539eb2d3a65812f5844bcbad14e628b 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1,6 +1,6 @@
 /* Symbol table definitions for GDB.
 
 /* Symbol table definitions for GDB.
 

-   Copyright (C) 1986-2017 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.

 
    This file is part of GDB.
 
 
    This file is part of GDB.
 


@@ -23,12 +23,18 @@
 #include <array>
 #include <vector>
 #include <string>
 #include <array>
 #include <vector>
 #include <string>

-#include "gdb_vecs.h"
+#include <set>
+#include "gdbsupport/gdb_vecs.h"

 #include "gdbtypes.h"
 #include "gdbtypes.h"

-#include "common/enum-flags.h"
-#include "common/function-view.h"
-#include "common/gdb_optional.h"
+#include "gdb_obstack.h"
+#include "gdb_regex.h"
+#include "gdbsupport/enum-flags.h"
+#include "gdbsupport/function-view.h"
+#include "gdbsupport/gdb_optional.h"
+#include "gdbsupport/gdb_string_view.h"
+#include "gdbsupport/next-iterator.h"

 #include "completer.h"
 #include "completer.h"

+#include "gdb-demangle.h"

 
 /* Opaque declarations.  */
 struct ui_file;
 
 /* Opaque declarations.  */
 struct ui_file;


@@ -42,10 +48,10 @@ struct axs_value;
 struct agent_expr;
 struct program_space;
 struct language_defn;
 struct agent_expr;
 struct program_space;
 struct language_defn;

-struct probe;

 struct common_block;
 struct obj_section;
 struct cmd_list_element;
 struct common_block;
 struct obj_section;
 struct cmd_list_element;

+class probe;

 struct lookup_name_info;
 
 /* How to match a lookup name against a symbol search name.  */
 struct lookup_name_info;
 
 /* How to match a lookup name against a symbol search name.  */


@@ -60,6 +66,16 @@ enum class symbol_name_match_type
      namespace/module/package.  */
   FULL,
 
      namespace/module/package.  */
   FULL,
 

+  /* Search name matching.  This is like FULL, but the search name did
+     not come from the user; instead it is already a search name
+     retrieved from a search_name () call.
+     For Ada, this avoids re-encoding an already-encoded search name
+     (which would potentially incorrectly lowercase letters in the
+     linkage/search name that should remain uppercase).  For C++, it
+     avoids trying to demangle a name we already know is
+     demangled.  */
+  SEARCH_NAME,
+

   /* Expression matching.  The same as FULL matching in most
      languages.  The same as WILD matching in Ada.  */
   EXPRESSION,
   /* Expression matching.  The same as FULL matching in most
      languages.  The same as WILD matching in Ada.  */
   EXPRESSION,


@@ -84,7 +100,7 @@ class ada_lookup_name_info final
      otherwise.  If non-NULL, store the matching results in MATCH.  */
   bool matches (const char *symbol_search_name,
                symbol_name_match_type match_type,
      otherwise.  If non-NULL, store the matching results in MATCH.  */
   bool matches (const char *symbol_search_name,
                symbol_name_match_type match_type,

-               completion_match *match) const;
+               completion_match_result *comp_match_res) const;

 
   /* The Ada-encoded lookup name.  */
   const std::string &lookup_name () const
 
   /* The Ada-encoded lookup name.  */
   const std::string &lookup_name () const


@@ -100,7 +116,11 @@ class ada_lookup_name_info final
   bool standard_p () const
   { return m_standard_p; }
 
   bool standard_p () const
   { return m_standard_p; }
 

- private:
+  /* Return true if doing a verbatim match.  */
+  bool verbatim_p () const
+  { return m_verbatim_p; }
+
+private:

   /* The Ada-encoded lookup name.  */
   std::string m_encoded_name;
 
   /* The Ada-encoded lookup name.  */
   std::string m_encoded_name;
 


@@ -295,15 +315,21 @@ private:
 
    SYMBOL_SEARCH_NAME should be a symbol's "search" name.
 
 
    SYMBOL_SEARCH_NAME should be a symbol's "search" name.
 

-   On success and if non-NULL, MATCH is set to point to the symbol
-   name as should be presented to the user as a completion match list
-   element.  In most languages, this is the same as the symbol's
-   search name, but in some, like Ada, the display name is dynamically
-   computed within the comparison routine.  */
+   On success and if non-NULL, COMP_MATCH_RES->match is set to point
+   to the symbol name as should be presented to the user as a
+   completion match list element.  In most languages, this is the same
+   as the symbol's search name, but in some, like Ada, the display
+   name is dynamically computed within the comparison routine.
+
+   Also, on success and if non-NULL, COMP_MATCH_RES->match_for_lcd
+   points the part of SYMBOL_SEARCH_NAME that was considered to match
+   LOOKUP_NAME.  E.g., in C++, in linespec/wild mode, if the symbol is
+   "foo::function()" and LOOKUP_NAME is "function(", MATCH_FOR_LCD
+   points to "function()" inside SYMBOL_SEARCH_NAME.  */

 typedef bool (symbol_name_matcher_ftype)
   (const char *symbol_search_name,
    const lookup_name_info &lookup_name,
 typedef bool (symbol_name_matcher_ftype)
   (const char *symbol_search_name,
    const lookup_name_info &lookup_name,

-   completion_match *match);
+   completion_match_result *comp_match_res);

 
 /* Some of the structures in this file are space critical.
    The space-critical structures are:
 
 /* Some of the structures in this file are space critical.
    The space-critical structures are:


@@ -355,6 +381,57 @@ typedef bool (symbol_name_matcher_ftype)
 
 struct general_symbol_info
 {
 
 struct general_symbol_info
 {

+  /* Short version as to when to use which name accessor:
+     Use natural_name () to refer to the name of the symbol in the original
+     source code.  Use linkage_name () if you want to know what the linker
+     thinks the symbol's name is.  Use print_name () for output.  Use
+     demangled_name () if you specifically need to know whether natural_name ()
+     and linkage_name () are different.  */
+
+  const char *linkage_name () const
+  { return name; }
+
+  /* Return SYMBOL's "natural" name, i.e. the name that it was called in
+     the original source code.  In languages like C++ where symbols may
+     be mangled for ease of manipulation by the linker, this is the
+     demangled name.  */
+  const char *natural_name () const;
+
+  /* Returns a version of the name of a symbol that is
+     suitable for output.  In C++ this is the "demangled" form of the
+     name if demangle is on and the "mangled" form of the name if
+     demangle is off.  In other languages this is just the symbol name.
+     The result should never be NULL.  Don't use this for internal
+     purposes (e.g. storing in a hashtable): it's only suitable for output.  */
+  const char *print_name () const
+  { return demangle ? natural_name () : linkage_name (); }
+
+  /* Return the demangled name for a symbol based on the language for
+     that symbol.  If no demangled name exists, return NULL.  */
+  const char *demangled_name () const;
+
+  /* Returns the name to be used when sorting and searching symbols.
+     In C++, we search for the demangled form of a name,
+     and so sort symbols accordingly.  In Ada, however, we search by mangled
+     name.  If there is no distinct demangled name, then this
+     returns the same value (same pointer) as linkage_name ().  */
+  const char *search_name () const;
+
+  /* Set just the linkage name of a symbol; do not try to demangle
+     it.  Used for constructs which do not have a mangled name,
+     e.g. struct tags.  Unlike SYMBOL_SET_NAMES, linkage_name must
+     be terminated and either already on the objfile's obstack or
+     permanently allocated.  */
+  void set_linkage_name (const char *linkage_name)
+  { name = linkage_name; }
+
+  enum language language () const
+  { return m_language; }
+
+  /* Initializes the language dependent portion of a symbol
+     depending upon the language for the symbol.  */
+  void set_language (enum language language, struct obstack *obstack);
+

   /* Name of the symbol.  This is a required field.  Storage for the
      name is allocated on the objfile_obstack for the associated
      objfile.  For languages like C++ that make a distinction between
   /* Name of the symbol.  This is a required field.  Storage for the
      name is allocated on the objfile_obstack for the associated
      objfile.  For languages like C++ that make a distinction between


@@ -409,7 +486,7 @@ struct general_symbol_info
      This is used to select one of the fields from the language specific
      union above.  */
 
      This is used to select one of the fields from the language specific
      union above.  */
 

-  ENUM_BITFIELD(language) language : LANGUAGE_BITS;
+  ENUM_BITFIELD(language) m_language : LANGUAGE_BITS;

 
   /* This is only used by Ada.  If set, then the 'demangled_name' field
      of language_specific is valid.  Otherwise, the 'obstack' field is
 
   /* This is only used by Ada.  If set, then the 'demangled_name' field
      of language_specific is valid.  Otherwise, the 'obstack' field is


@@ -432,110 +509,57 @@ extern const char *symbol_get_demangled_name
 
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
 
 
 extern CORE_ADDR symbol_overlayed_address (CORE_ADDR, struct obj_section *);
 

-/* Note that all the following SYMBOL_* macros are used with the
-   SYMBOL argument being either a partial symbol or
-   a full symbol.  Both types have a ginfo field.  In particular
-   the SYMBOL_SET_LANGUAGE, SYMBOL_DEMANGLED_NAME, etc.
-   macros cannot be entirely substituted by
-   functions, unless the callers are changed to pass in the ginfo
-   field only, instead of the SYMBOL parameter.  */
-
-#define SYMBOL_VALUE(symbol)           (symbol)->ginfo.value.ivalue
-#define SYMBOL_VALUE_ADDRESS(symbol)   (symbol)->ginfo.value.address
-#define SYMBOL_VALUE_BYTES(symbol)     (symbol)->ginfo.value.bytes
-#define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->ginfo.value.common_block
-#define SYMBOL_BLOCK_VALUE(symbol)     (symbol)->ginfo.value.block
-#define SYMBOL_VALUE_CHAIN(symbol)     (symbol)->ginfo.value.chain
-#define SYMBOL_LANGUAGE(symbol)                (symbol)->ginfo.language
-#define SYMBOL_SECTION(symbol)         (symbol)->ginfo.section
+/* Return the address of SYM.  The MAYBE_COPIED flag must be set on
+   SYM.  If SYM appears in the main program's minimal symbols, then
+   that minsym's address is returned; otherwise, SYM's address is
+   returned.  This should generally only be used via the
+   SYMBOL_VALUE_ADDRESS macro.  */
+
+extern CORE_ADDR get_symbol_address (const struct symbol *sym);
+
+/* Note that these macros only work with symbol, not partial_symbol.  */
+
+#define SYMBOL_VALUE(symbol)           (symbol)->value.ivalue
+#define SYMBOL_VALUE_ADDRESS(symbol)                         \
+  (((symbol)->maybe_copied) ? get_symbol_address (symbol)     \
+   : ((symbol)->value.address))
+#define SET_SYMBOL_VALUE_ADDRESS(symbol, new_value)    \
+  ((symbol)->value.address = (new_value))
+#define SYMBOL_VALUE_BYTES(symbol)     (symbol)->value.bytes
+#define SYMBOL_VALUE_COMMON_BLOCK(symbol) (symbol)->value.common_block
+#define SYMBOL_BLOCK_VALUE(symbol)     (symbol)->value.block
+#define SYMBOL_VALUE_CHAIN(symbol)     (symbol)->value.chain
+#define SYMBOL_SECTION(symbol)         (symbol)->section

 #define SYMBOL_OBJ_SECTION(objfile, symbol)                    \
 #define SYMBOL_OBJ_SECTION(objfile, symbol)                    \

-  (((symbol)->ginfo.section >= 0)                              \
-   ? (&(((objfile)->sections)[(symbol)->ginfo.section]))       \
+  (((symbol)->section >= 0)                            \
+   ? (&(((objfile)->sections)[(symbol)->section]))     \

    : NULL)
 
    : NULL)
 

-/* Initializes the language dependent portion of a symbol
-   depending upon the language for the symbol.  */
-#define SYMBOL_SET_LANGUAGE(symbol,language,obstack)   \
-  (symbol_set_language (&(symbol)->ginfo, (language), (obstack)))
-extern void symbol_set_language (struct general_symbol_info *symbol,
-                                 enum language language,
-                                struct obstack *obstack);
-
-/* Set just the linkage name of a symbol; do not try to demangle
-   it.  Used for constructs which do not have a mangled name,
-   e.g. struct tags.  Unlike SYMBOL_SET_NAMES, linkage_name must
-   be terminated and either already on the objfile's obstack or
-   permanently allocated.  */
-#define SYMBOL_SET_LINKAGE_NAME(symbol,linkage_name) \
-  (symbol)->ginfo.name = (linkage_name)
+/* Try to determine the demangled name for a symbol, based on the
+   language of that symbol.  If the language is set to language_auto,
+   it will attempt to find any demangling algorithm that works and
+   then set the language appropriately.  The returned name is allocated
+   by the demangler and should be xfree'd.  */
+
+extern char *symbol_find_demangled_name (struct general_symbol_info *gsymbol,
+                                        const char *mangled);

 
 /* Set the linkage and natural names of a symbol, by demangling
 
 /* Set the linkage and natural names of a symbol, by demangling

-   the linkage name.  */
-#define SYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile)    \
-  symbol_set_names (&(symbol)->ginfo, linkage_name, len, copy_name, objfile)
+   the linkage name.  If linkage_name may not be nullterminated,
+   copy_name must be set to true.  */
+#define SYMBOL_SET_NAMES(symbol,linkage_name,copy_name,objfile)        \
+  symbol_set_names ((symbol), linkage_name, copy_name, \
+                   (objfile)->per_bfd)

 extern void symbol_set_names (struct general_symbol_info *symbol,
 extern void symbol_set_names (struct general_symbol_info *symbol,

-                             const char *linkage_name, int len, int copy_name,
-                             struct objfile *objfile);
-
-/* Now come lots of name accessor macros.  Short version as to when to
-   use which: Use SYMBOL_NATURAL_NAME to refer to the name of the
-   symbol in the original source code.  Use SYMBOL_LINKAGE_NAME if you
-   want to know what the linker thinks the symbol's name is.  Use
-   SYMBOL_PRINT_NAME for output.  Use SYMBOL_DEMANGLED_NAME if you
-   specifically need to know whether SYMBOL_NATURAL_NAME and
-   SYMBOL_LINKAGE_NAME are different.  */
-
-/* Return SYMBOL's "natural" name, i.e. the name that it was called in
-   the original source code.  In languages like C++ where symbols may
-   be mangled for ease of manipulation by the linker, this is the
-   demangled name.  */
-
-#define SYMBOL_NATURAL_NAME(symbol) \
-  (symbol_natural_name (&(symbol)->ginfo))
-extern const char *symbol_natural_name
-  (const struct general_symbol_info *symbol);
-
-/* Return SYMBOL's name from the point of view of the linker.  In
-   languages like C++ where symbols may be mangled for ease of
-   manipulation by the linker, this is the mangled name; otherwise,
-   it's the same as SYMBOL_NATURAL_NAME.  */
-
-#define SYMBOL_LINKAGE_NAME(symbol)    (symbol)->ginfo.name
-
-/* Return the demangled name for a symbol based on the language for
-   that symbol.  If no demangled name exists, return NULL.  */
-#define SYMBOL_DEMANGLED_NAME(symbol) \
-  (symbol_demangled_name (&(symbol)->ginfo))
-extern const char *symbol_demangled_name
-  (const struct general_symbol_info *symbol);
-
-/* Macro that returns a version of the name of a symbol that is
-   suitable for output.  In C++ this is the "demangled" form of the
-   name if demangle is on and the "mangled" form of the name if
-   demangle is off.  In other languages this is just the symbol name.
-   The result should never be NULL.  Don't use this for internal
-   purposes (e.g. storing in a hashtable): it's only suitable for output.
-
-   N.B. symbol may be anything with a ginfo member,
-   e.g., struct symbol or struct minimal_symbol.  */
-
-#define SYMBOL_PRINT_NAME(symbol)                                      \
-  (demangle ? SYMBOL_NATURAL_NAME (symbol) : SYMBOL_LINKAGE_NAME (symbol))
-extern int demangle;
-
-/* Macro that returns the name to be used when sorting and searching symbols.
-   In C++, we search for the demangled form of a name,
-   and so sort symbols accordingly.  In Ada, however, we search by mangled
-   name.  If there is no distinct demangled name, then SYMBOL_SEARCH_NAME
-   returns the same value (same pointer) as SYMBOL_LINKAGE_NAME.  */
-#define SYMBOL_SEARCH_NAME(symbol)                                      \
-   (symbol_search_name (&(symbol)->ginfo))
-extern const char *symbol_search_name (const struct general_symbol_info *ginfo);
+                             gdb::string_view linkage_name, bool copy_name,
+                             struct objfile_per_bfd_storage *per_bfd,
+                             gdb::optional<hashval_t> hash
+                               = gdb::optional<hashval_t> ());

 
 /* Return true if NAME matches the "search" name of SYMBOL, according
    to the symbol's language.  */
 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                       \
 
 /* Return true if NAME matches the "search" name of SYMBOL, according
    to the symbol's language.  */
 #define SYMBOL_MATCHES_SEARCH_NAME(symbol, name)                       \

-  symbol_matches_search_name (&(symbol)->ginfo, (name))
+  symbol_matches_search_name ((symbol), (name))

 
 /* Helper for SYMBOL_MATCHES_SEARCH_NAME that works with both symbols
    and psymbols.  */
 
 /* Helper for SYMBOL_MATCHES_SEARCH_NAME that works with both symbols
    and psymbols.  */


@@ -560,8 +584,26 @@ enum minimal_symbol_type
 {
   mst_unknown = 0,             /* Unknown type, the default */
   mst_text,                    /* Generally executable instructions */
 {
   mst_unknown = 0,             /* Unknown type, the default */
   mst_text,                    /* Generally executable instructions */

-  mst_text_gnu_ifunc,          /* Executable code returning address
+
+  /* A GNU ifunc symbol, in the .text section.  GDB uses to know
+     whether the user is setting a breakpoint on a GNU ifunc function,
+     and thus GDB needs to actually set the breakpoint on the target
+     function.  It is also used to know whether the program stepped
+     into an ifunc resolver -- the resolver may get a separate
+     symbol/alias under a different name, but it'll have the same
+     address as the ifunc symbol.  */
+  mst_text_gnu_ifunc,           /* Executable code returning address

                                   of executable code */
                                   of executable code */

+
+  /* A GNU ifunc function descriptor symbol, in a data section
+     (typically ".opd").  Seen on architectures that use function
+     descriptors, like PPC64/ELFv1.  In this case, this symbol's value
+     is the address of the descriptor.  There'll be a corresponding
+     mst_text_gnu_ifunc synthetic symbol for the text/entry
+     address.  */
+  mst_data_gnu_ifunc,          /* Executable code returning address
+                                  of executable code */
+

   mst_slot_got_plt,            /* GOT entries for .plt sections */
   mst_data,                    /* Generally initialized data */
   mst_bss,                     /* Generally uninitialized data */
   mst_slot_got_plt,            /* GOT entries for .plt sections */
   mst_data,                    /* Generally initialized data */
   mst_bss,                     /* Generally uninitialized data */


@@ -600,16 +642,8 @@ gdb_static_assert (nr_minsym_types <= (1 << MINSYM_TYPE_BITS));
    between names and addresses, and vice versa.  They are also sometimes
    used to figure out what full symbol table entries need to be read in.  */
 
    between names and addresses, and vice versa.  They are also sometimes
    used to figure out what full symbol table entries need to be read in.  */
 

-struct minimal_symbol
+struct minimal_symbol : public general_symbol_info

 {
 {

-
-  /* The general symbol info required for all types of symbols.
-
-     The SYMBOL_VALUE_ADDRESS contains the address that this symbol
-     corresponds to.  */
-
-  struct general_symbol_info mginfo;
-

   /* Size of this symbol.  dbx_end_psymtab in dbxread.c uses this
      information to calculate the end of the partial symtab based on the
      address of the last symbol plus the size of the last symbol.  */
   /* Size of this symbol.  dbx_end_psymtab in dbxread.c uses this
      information to calculate the end of the partial symtab based on the
      address of the last symbol plus the size of the last symbol.  */


@@ -636,6 +670,18 @@ struct minimal_symbol
      the object file format may not carry that piece of information.  */
   unsigned int has_size : 1;
 
      the object file format may not carry that piece of information.  */
   unsigned int has_size : 1;
 

+  /* For data symbols only, if this is set, then the symbol might be
+     subject to copy relocation.  In this case, a minimal symbol
+     matching the symbol's linkage name is first looked for in the
+     main objfile.  If found, then that address is used; otherwise the
+     address in this symbol is used.  */
+
+  unsigned maybe_copied : 1;
+
+  /* Non-zero if this symbol ever had its demangled name set (even if
+     it was set to NULL).  */
+  unsigned int name_set : 1;
+

   /* Minimal symbols with the same hash key are kept on a linked
      list.  This is the link.  */
 
   /* Minimal symbols with the same hash key are kept on a linked
      list.  This is the link.  */
 


@@ -645,8 +691,25 @@ struct minimal_symbol
      the `next' pointer for the demangled hash table.  */
 
   struct minimal_symbol *demangled_hash_next;
      the `next' pointer for the demangled hash table.  */
 
   struct minimal_symbol *demangled_hash_next;

+
+  /* True if this symbol is of some data type.  */
+
+  bool data_p () const;
+
+  /* True if MSYMBOL is of some text type.  */
+
+  bool text_p () const;

 };
 
 };
 

+/* Return the address of MINSYM, which comes from OBJF.  The
+   MAYBE_COPIED flag must be set on MINSYM.  If MINSYM appears in the
+   main program's minimal symbols, then that minsym's address is
+   returned; otherwise, MINSYM's address is returned.  This should
+   generally only be used via the MSYMBOL_VALUE_ADDRESS macro.  */
+
+extern CORE_ADDR get_msymbol_address (struct objfile *objf,
+                                     const struct minimal_symbol *minsym);
+

 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2
 #define MSYMBOL_SIZE(msymbol)          ((msymbol)->size + 0)
 #define MSYMBOL_TARGET_FLAG_1(msymbol)  (msymbol)->target_flag_1
 #define MSYMBOL_TARGET_FLAG_2(msymbol)  (msymbol)->target_flag_2
 #define MSYMBOL_SIZE(msymbol)          ((msymbol)->size + 0)


@@ -659,43 +722,29 @@ struct minimal_symbol
 #define MSYMBOL_HAS_SIZE(msymbol)      ((msymbol)->has_size + 0)
 #define MSYMBOL_TYPE(msymbol)          (msymbol)->type
 
 #define MSYMBOL_HAS_SIZE(msymbol)      ((msymbol)->has_size + 0)
 #define MSYMBOL_TYPE(msymbol)          (msymbol)->type
 

-#define MSYMBOL_VALUE(symbol)          (symbol)->mginfo.value.ivalue
+#define MSYMBOL_VALUE(symbol)          (symbol)->value.ivalue

 /* The unrelocated address of the minimal symbol.  */
 /* The unrelocated address of the minimal symbol.  */

-#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->mginfo.value.address + 0)
+#define MSYMBOL_VALUE_RAW_ADDRESS(symbol) ((symbol)->value.address + 0)

 /* The relocated address of the minimal symbol, using the section
    offsets from OBJFILE.  */
 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol)                         \
 /* The relocated address of the minimal symbol, using the section
    offsets from OBJFILE.  */
 #define MSYMBOL_VALUE_ADDRESS(objfile, symbol)                         \

-  ((symbol)->mginfo.value.address                                      \
-   + ANOFFSET ((objfile)->section_offsets, ((symbol)->mginfo.section)))
+  (((symbol)->maybe_copied) ? get_msymbol_address (objfile, symbol)    \
+   : ((symbol)->value.address                                          \
+      + ANOFFSET ((objfile)->section_offsets, ((symbol)->section))))

 /* For a bound minsym, we can easily compute the address directly.  */
 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
   MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
 #define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value)   \
 /* For a bound minsym, we can easily compute the address directly.  */
 #define BMSYMBOL_VALUE_ADDRESS(symbol) \
   MSYMBOL_VALUE_ADDRESS ((symbol).objfile, (symbol).minsym)
 #define SET_MSYMBOL_VALUE_ADDRESS(symbol, new_value)   \

-  ((symbol)->mginfo.value.address = (new_value))
-#define MSYMBOL_VALUE_BYTES(symbol)    (symbol)->mginfo.value.bytes
-#define MSYMBOL_BLOCK_VALUE(symbol)    (symbol)->mginfo.value.block
-#define MSYMBOL_VALUE_CHAIN(symbol)    (symbol)->mginfo.value.chain
-#define MSYMBOL_LANGUAGE(symbol)       (symbol)->mginfo.language
-#define MSYMBOL_SECTION(symbol)                (symbol)->mginfo.section
+  ((symbol)->value.address = (new_value))
+#define MSYMBOL_VALUE_BYTES(symbol)    (symbol)->value.bytes
+#define MSYMBOL_BLOCK_VALUE(symbol)    (symbol)->value.block
+#define MSYMBOL_VALUE_CHAIN(symbol)    (symbol)->value.chain
+#define MSYMBOL_SECTION(symbol)                (symbol)->section

 #define MSYMBOL_OBJ_SECTION(objfile, symbol)                   \
 #define MSYMBOL_OBJ_SECTION(objfile, symbol)                   \

-  (((symbol)->mginfo.section >= 0)                             \
-   ? (&(((objfile)->sections)[(symbol)->mginfo.section]))      \
+  (((symbol)->section >= 0)                            \
+   ? (&(((objfile)->sections)[(symbol)->section]))     \

    : NULL)
 
    : NULL)
 

-#define MSYMBOL_NATURAL_NAME(symbol) \
-  (symbol_natural_name (&(symbol)->mginfo))
-#define MSYMBOL_LINKAGE_NAME(symbol)   (symbol)->mginfo.name
-#define MSYMBOL_PRINT_NAME(symbol)                                     \
-  (demangle ? MSYMBOL_NATURAL_NAME (symbol) : MSYMBOL_LINKAGE_NAME (symbol))
-#define MSYMBOL_DEMANGLED_NAME(symbol) \
-  (symbol_demangled_name (&(symbol)->mginfo))
-#define MSYMBOL_SET_LANGUAGE(symbol,language,obstack)  \
-  (symbol_set_language (&(symbol)->mginfo, (language), (obstack)))
-#define MSYMBOL_SEARCH_NAME(symbol)                                     \
-   (symbol_search_name (&(symbol)->mginfo))
-#define MSYMBOL_SET_NAMES(symbol,linkage_name,len,copy_name,objfile)   \
-  symbol_set_names (&(symbol)->mginfo, linkage_name, len, copy_name, objfile)
-

 #include "minsyms.h"
 
 \f
 #include "minsyms.h"
 
 \f


@@ -747,7 +796,7 @@ gdb_static_assert (NR_DOMAINS <= (1 << SYMBOL_DOMAIN_BITS));
 
 extern const char *domain_name (domain_enum);
 
 
 extern const char *domain_name (domain_enum);
 

-/* Searching domains, used for `search_symbols'.  Element numbers are
+/* Searching domains, used when searching for symbols.  Element numbers are

    hardcoded in GDB, check all enum uses before changing it.  */
 
 enum search_domain
    hardcoded in GDB, check all enum uses before changing it.  */
 
 enum search_domain


@@ -762,8 +811,11 @@ enum search_domain
   /* All defined types */
   TYPES_DOMAIN = 2,
 
   /* All defined types */
   TYPES_DOMAIN = 2,
 

+  /* All modules.  */
+  MODULES_DOMAIN = 3,
+

   /* Any type.  */
   /* Any type.  */

-  ALL_DOMAIN = 3
+  ALL_DOMAIN = 4

 };
 
 extern const char *search_domain_name (enum search_domain);
 };
 
 extern const char *search_domain_name (enum search_domain);


@@ -945,7 +997,7 @@ struct symbol_computed_ops
      The generated C code must assign the location to a local
      variable; this variable's name is RESULT_NAME.  */
 
      The generated C code must assign the location to a local
      variable; this variable's name is RESULT_NAME.  */
 

-  void (*generate_c_location) (struct symbol *symbol, string_file &stream,
+  void (*generate_c_location) (struct symbol *symbol, string_file *stream,

                               struct gdbarch *gdbarch,
                               unsigned char *registers_used,
                               CORE_ADDR pc, const char *result_name);
                               struct gdbarch *gdbarch,
                               unsigned char *registers_used,
                               CORE_ADDR pc, const char *result_name);


@@ -977,7 +1029,7 @@ struct symbol_block_ops
      register, the CFA as defined by DWARF unwinding information, ...
 
      So this specific method is supposed to compute the frame base address such
      register, the CFA as defined by DWARF unwinding information, ...
 
      So this specific method is supposed to compute the frame base address such

-     as for nested fuctions, the static link computes the same address.  For
+     as for nested functions, the static link computes the same address.  For

      instance, considering DWARF debugging information, the static link is
      computed with DW_AT_static_link and this method must be used to compute
      the corresponding DW_AT_frame_base attribute.  */
      instance, considering DWARF debugging information, the static link is
      computed with DW_AT_static_link and this method must be used to compute
      the corresponding DW_AT_frame_base attribute.  */


@@ -1009,18 +1061,51 @@ struct symbol_impl
   const struct symbol_register_ops *ops_register;
 };
 
   const struct symbol_register_ops *ops_register;
 };
 

-/* This structure is space critical.  See space comments at the top.  */
+/* struct symbol has some subclasses.  This enum is used to
+   differentiate between them.  */

 
 

-struct symbol
+enum symbol_subclass_kind

 {
 {

+  /* Plain struct symbol.  */
+  SYMBOL_NONE,

 
 

-  /* The general symbol info required for all types of symbols.  */
+  /* struct template_symbol.  */
+  SYMBOL_TEMPLATE,

 
 

-  struct general_symbol_info ginfo;
+  /* struct rust_vtable_symbol.  */
+  SYMBOL_RUST_VTABLE
+};
+
+/* This structure is space critical.  See space comments at the top.  */
+
+struct symbol : public general_symbol_info, public allocate_on_obstack
+{
+  symbol ()
+    /* Class-initialization of bitfields is only allowed in C++20.  */
+    : domain (UNDEF_DOMAIN),
+      aclass_index (0),
+      is_objfile_owned (0),
+      is_argument (0),
+      is_inlined (0),
+      maybe_copied (0),
+      subclass (SYMBOL_NONE)
+    {
+      /* We can't use an initializer list for members of a base class, and
+         general_symbol_info needs to stay a POD type.  */
+      name = nullptr;
+      value.ivalue = 0;
+      language_specific.obstack = nullptr;
+      m_language = language_unknown;
+      ada_mangled = 0;
+      section = 0;
+      /* GCC 4.8.5 (on CentOS 7) does not correctly compile class-
+         initialization of unions, so we initialize it manually here.  */
+      owner.symtab = nullptr;
+    }

 
   /* Data type of value */
 
 
   /* Data type of value */
 

-  struct type *type;
+  struct type *type = nullptr;

 
   /* The owner of this symbol.
      Which one to use is defined by symbol.is_objfile_owned.  */
 
   /* The owner of this symbol.
      Which one to use is defined by symbol.is_objfile_owned.  */


@@ -1047,7 +1132,7 @@ struct symbol
   unsigned int aclass_index : SYMBOL_ACLASS_BITS;
 
   /* If non-zero then symbol is objfile-owned, use owner.symtab.
   unsigned int aclass_index : SYMBOL_ACLASS_BITS;
 
   /* If non-zero then symbol is objfile-owned, use owner.symtab.

-     Otherwise symbol is arch-owned, use owner.arch.  */
+       Otherwise symbol is arch-owned, use owner.arch.  */

 
   unsigned int is_objfile_owned : 1;
 
 
   unsigned int is_objfile_owned : 1;
 


@@ -1058,14 +1143,17 @@ struct symbol
   /* Whether this is an inlined function (class LOC_BLOCK only).  */
   unsigned is_inlined : 1;
 
   /* Whether this is an inlined function (class LOC_BLOCK only).  */
   unsigned is_inlined : 1;
 

-  /* True if this is a C++ function symbol with template arguments.
-     In this case the symbol is really a "struct template_symbol".  */
-  unsigned is_cplus_template_function : 1;
+  /* For LOC_STATIC only, if this is set, then the symbol might be
+     subject to copy relocation.  In this case, a minimal symbol
+     matching the symbol's linkage name is first looked for in the
+     main objfile.  If found, then that address is used; otherwise the
+     address in this symbol is used.  */
+
+  unsigned maybe_copied : 1;

 
 

-  /* True if this is a Rust virtual table.  In this case, the symbol
-     can be downcast to "struct rust_vtable_symbol".  */
+  /* The concrete type of this symbol.  */

 
 

-  unsigned is_rust_vtable : 1;
+  ENUM_BITFIELD (symbol_subclass_kind) subclass : 2;

 
   /* Line number of this symbol's definition, except for inlined
      functions.  For an inlined function (class LOC_BLOCK and
 
   /* Line number of this symbol's definition, except for inlined
      functions.  For an inlined function (class LOC_BLOCK and


@@ -1078,7 +1166,7 @@ struct symbol
      to debug files longer than 64K lines?  What about machine
      generated programs?  */
 
      to debug files longer than 64K lines?  What about machine
      generated programs?  */
 

-  unsigned short line;
+  unsigned short line = 0;

 
   /* An arbitrary data pointer, allowing symbol readers to record
      additional information on a per-symbol basis.  Note that this data
 
   /* An arbitrary data pointer, allowing symbol readers to record
      additional information on a per-symbol basis.  Note that this data


@@ -1092,9 +1180,9 @@ struct symbol
      to add a magic symbol to the block containing this information,
      or to have a generic debug info annotation slot for symbols.  */
 
      to add a magic symbol to the block containing this information,
      or to have a generic debug info annotation slot for symbols.  */
 

-  void *aux_value;
+  void *aux_value = nullptr;

 
 

-  struct symbol *hash_next;
+  struct symbol *hash_next = nullptr;

 };
 
 /* Several lookup functions return both a symbol and the block in which the
 };
 
 /* Several lookup functions return both a symbol and the block in which the


@@ -1112,10 +1200,6 @@ struct block_symbol
 
 extern const struct symbol_impl *symbol_impls;
 
 
 extern const struct symbol_impl *symbol_impls;
 

-/* For convenience.  All fields are NULL.  This means "there is no
-   symbol".  */
-extern const struct block_symbol null_block_symbol;
-

 /* Note: There is no accessor macro for symbol.owner because it is
    "private".  */
 
 /* Note: There is no accessor macro for symbol.owner because it is
    "private".  */
 


@@ -1127,7 +1211,7 @@ extern const struct block_symbol null_block_symbol;
 #define SYMBOL_IS_ARGUMENT(symbol)     (symbol)->is_argument
 #define SYMBOL_INLINED(symbol)         (symbol)->is_inlined
 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \
 #define SYMBOL_IS_ARGUMENT(symbol)     (symbol)->is_argument
 #define SYMBOL_INLINED(symbol)         (symbol)->is_inlined
 #define SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION(symbol) \

-  (symbol)->is_cplus_template_function
+  (((symbol)->subclass) == SYMBOL_TEMPLATE)

 #define SYMBOL_TYPE(symbol)            (symbol)->type
 #define SYMBOL_LINE(symbol)            (symbol)->line
 #define SYMBOL_COMPUTED_OPS(symbol)    (SYMBOL_IMPL (symbol).ops_computed)
 #define SYMBOL_TYPE(symbol)            (symbol)->type
 #define SYMBOL_LINE(symbol)            (symbol)->line
 #define SYMBOL_COMPUTED_OPS(symbol)    (SYMBOL_IMPL (symbol).ops_computed)


@@ -1173,11 +1257,11 @@ extern void symbol_set_symtab (struct symbol *symbol, struct symtab *symtab);
 struct template_symbol : public symbol
 {
   /* The number of template arguments.  */
 struct template_symbol : public symbol
 {
   /* The number of template arguments.  */

-  int n_template_arguments;
+  int n_template_arguments = 0;

 
   /* The template arguments.  This is an array with
      N_TEMPLATE_ARGUMENTS elements.  */
 
   /* The template arguments.  This is an array with
      N_TEMPLATE_ARGUMENTS elements.  */

-  struct symbol **template_arguments;
+  struct symbol **template_arguments = nullptr;

 };
 
 /* A symbol that represents a Rust virtual table object.  */
 };
 
 /* A symbol that represents a Rust virtual table object.  */


@@ -1186,7 +1270,7 @@ struct rust_vtable_symbol : public symbol
 {
   /* The concrete type for which this vtable was created; that is, in
      "impl Trait for Type", this is "Type".  */
 {
   /* The concrete type for which this vtable was created; that is, in
      "impl Trait for Type", this is "Type".  */

-  struct type *concrete_type;
+  struct type *concrete_type = nullptr;

 };
 
 \f
 };
 
 \f


@@ -1278,16 +1362,6 @@ struct symtab
 
   const char *filename;
 
 
   const char *filename;
 

-  /* Total number of lines found in source file.  */
-
-  int nlines;
-
-  /* line_charpos[N] is the position of the (N-1)th line of the
-     source file.  "position" means something we can lseek() to; it
-     is not guaranteed to be useful any other way.  */
-
-  int *line_charpos;
-

   /* Language of this source file.  */
 
   enum language language;
   /* Language of this source file.  */
 
   enum language language;


@@ -1309,9 +1383,6 @@ struct symtab
 #define SYMTAB_DIRNAME(symtab) \
   COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
 
 #define SYMTAB_DIRNAME(symtab) \
   COMPUNIT_DIRNAME (SYMTAB_COMPUNIT (symtab))
 

-typedef struct symtab *symtab_ptr;
-DEF_VEC_P (symtab_ptr);
-

 /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
    as the list of all source files (what gdb has historically associated with
    the term "symtab").
 /* Compunit symtabs contain the actual "symbol table", aka blockvector, as well
    as the list of all source files (what gdb has historically associated with
    the term "symtab").


@@ -1439,10 +1510,16 @@ struct compunit_symtab
 #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
 #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
 
 #define COMPUNIT_CALL_SITE_HTAB(cust) ((cust)->call_site_htab)
 #define COMPUNIT_MACRO_TABLE(cust) ((cust)->macro_table)
 

-/* Iterate over all file tables (struct symtab) within a compunit.  */
+/* A range adapter to allowing iterating over all the file tables
+   within a compunit.  */

 
 

-#define ALL_COMPUNIT_FILETABS(cu, s) \
-  for ((s) = (cu) -> filetabs; (s) != NULL; (s) = (s) -> next)
+struct compunit_filetabs : public next_adapter<struct symtab>
+{
+  compunit_filetabs (struct compunit_symtab *cu)
+    : next_adapter<struct symtab> (cu->filetabs)
+  {
+  }
+};

 
 /* Return the primary symtab of CUST.  */
 
 
 /* Return the primary symtab of CUST.  */
 


@@ -1453,9 +1530,6 @@ extern struct symtab *
 
 extern enum language compunit_language (const struct compunit_symtab *cust);
 
 
 extern enum language compunit_language (const struct compunit_symtab *cust);
 

-typedef struct compunit_symtab *compunit_symtab_ptr;
-DEF_VEC_P (compunit_symtab_ptr);
-

 \f
 
 /* The virtual function table is now an array of structures which have the
 \f
 
 /* The virtual function table is now an array of structures which have the


@@ -1485,9 +1559,9 @@ extern const char multiple_symbols_cancel[];
 
 const char *multiple_symbols_select_mode (void);
 
 
 const char *multiple_symbols_select_mode (void);
 

-int symbol_matches_domain (enum language symbol_language, 
-                          domain_enum symbol_domain,
-                          domain_enum domain);
+bool symbol_matches_domain (enum language symbol_language,
+                           domain_enum symbol_domain,
+                           domain_enum domain);

 
 /* lookup a symbol table by source file name.  */
 
 
 /* lookup a symbol table by source file name.  */
 


@@ -1538,6 +1612,19 @@ extern struct block_symbol lookup_symbol (const char *,
                                          const domain_enum,
                                          struct field_of_this_result *);
 
                                          const domain_enum,
                                          struct field_of_this_result *);
 

+/* Find the definition for a specified symbol search name in domain
+   DOMAIN, visible from lexical block BLOCK if non-NULL or from
+   global/static blocks if BLOCK is NULL.  The passed-in search name
+   should not come from the user; instead it should already be a
+   search name as retrieved from a search_name () call.  See definition of
+   symbol_name_match_type::SEARCH_NAME.  Returns the struct symbol
+   pointer, or NULL if no symbol is found.  The symbol's section is
+   fixed up if necessary.  */
+
+extern struct block_symbol lookup_symbol_search_name (const char *search_name,
+                                                     const struct block *block,
+                                                     domain_enum domain);
+

 /* A default version of lookup_symbol_nonlocal for use by languages
    that can't think of anything better to do.
    This implements the C lookup rules.  */
 /* A default version of lookup_symbol_nonlocal for use by languages
    that can't think of anything better to do.
    This implements the C lookup rules.  */


@@ -1587,6 +1674,7 @@ extern struct block_symbol
 
 extern struct symbol *
   lookup_symbol_in_block (const char *name,
 
 extern struct symbol *
   lookup_symbol_in_block (const char *name,

+                         symbol_name_match_type match_type,

                          const struct block *block,
                          const domain_enum domain);
 
                          const struct block *block,
                          const domain_enum domain);
 


@@ -1607,28 +1695,99 @@ extern struct type *lookup_enum (const char *, const struct block *);
 
 /* from blockframe.c: */
 
 
 /* from blockframe.c: */
 

-/* lookup the function symbol corresponding to the address.  */
+/* lookup the function symbol corresponding to the address.  The
+   return value will not be an inlined function; the containing
+   function will be returned instead.  */

 
 extern struct symbol *find_pc_function (CORE_ADDR);
 
 
 extern struct symbol *find_pc_function (CORE_ADDR);
 

-/* lookup the function corresponding to the address and section.  */
+/* lookup the function corresponding to the address and section.  The
+   return value will not be an inlined function; the containing
+   function will be returned instead.  */

 
 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
 
 
 extern struct symbol *find_pc_sect_function (CORE_ADDR, struct obj_section *);
 

+/* lookup the function symbol corresponding to the address and
+   section.  The return value will be the closest enclosing function,
+   which might be an inline function.  */
+
+extern struct symbol *find_pc_sect_containing_function
+  (CORE_ADDR pc, struct obj_section *section);
+

 /* Find the symbol at the given address.  Returns NULL if no symbol
    found.  Only exact matches for ADDRESS are considered.  */
 
 extern struct symbol *find_symbol_at_address (CORE_ADDR);
 
 /* Find the symbol at the given address.  Returns NULL if no symbol
    found.  Only exact matches for ADDRESS are considered.  */
 
 extern struct symbol *find_symbol_at_address (CORE_ADDR);
 

-extern int find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
+/* Finds the "function" (text symbol) that is smaller than PC but
+   greatest of all of the potential text symbols in SECTION.  Sets
+   *NAME and/or *ADDRESS conditionally if that pointer is non-null.
+   If ENDADDR is non-null, then set *ENDADDR to be the end of the
+   function (exclusive).  If the optional parameter BLOCK is non-null,
+   then set *BLOCK to the address of the block corresponding to the
+   function symbol, if such a symbol could be found during the lookup;
+   nullptr is used as a return value for *BLOCK if no block is found. 
+   This function either succeeds or fails (not halfway succeeds).  If
+   it succeeds, it sets *NAME, *ADDRESS, and *ENDADDR to real
+   information and returns true.  If it fails, it sets *NAME, *ADDRESS
+   and *ENDADDR to zero and returns false.
+   
+   If the function in question occupies non-contiguous ranges,
+   *ADDRESS and *ENDADDR are (subject to the conditions noted above) set
+   to the start and end of the range in which PC is found.  Thus
+   *ADDRESS <= PC < *ENDADDR with no intervening gaps (in which ranges
+   from other functions might be found).
+   
+   This property allows find_pc_partial_function to be used (as it had
+   been prior to the introduction of non-contiguous range support) by
+   various tdep files for finding a start address and limit address
+   for prologue analysis.  This still isn't ideal, however, because we
+   probably shouldn't be doing prologue analysis (in which
+   instructions are scanned to determine frame size and stack layout)
+   for any range that doesn't contain the entry pc.  Moreover, a good
+   argument can be made that prologue analysis ought to be performed
+   starting from the entry pc even when PC is within some other range.
+   This might suggest that *ADDRESS and *ENDADDR ought to be set to the
+   limits of the entry pc range, but that will cause the 
+   *ADDRESS <= PC < *ENDADDR condition to be violated; many of the
+   callers of find_pc_partial_function expect this condition to hold. 
+
+   Callers which require the start and/or end addresses for the range
+   containing the entry pc should instead call
+   find_function_entry_range_from_pc.  */
+
+extern bool find_pc_partial_function (CORE_ADDR pc, const char **name,
+                                     CORE_ADDR *address, CORE_ADDR *endaddr,
+                                     const struct block **block = nullptr);
+
+/* Like find_pc_partial_function, above, but *ADDRESS and *ENDADDR are
+   set to start and end addresses of the range containing the entry pc.
+
+   Note that it is not necessarily the case that (for non-NULL ADDRESS
+   and ENDADDR arguments) the *ADDRESS <= PC < *ENDADDR condition will
+   hold.
+
+   See comment for find_pc_partial_function, above, for further
+   explanation.  */
+
+extern bool find_function_entry_range_from_pc (CORE_ADDR pc,
+                                              const char **name,

                                               CORE_ADDR *address,
                                               CORE_ADDR *address,

-                                              CORE_ADDR *endaddr,
-                                              int *is_gnu_ifunc_p);
+                                              CORE_ADDR *endaddr);
+
+/* Return the type of a function with its first instruction exactly at
+   the PC address.  Return NULL otherwise.  */

 
 

-/* lookup function from address, return name, start addr and end addr.  */
+extern struct type *find_function_type (CORE_ADDR pc);

 
 

-extern int find_pc_partial_function (CORE_ADDR, const char **, CORE_ADDR *,
-                                    CORE_ADDR *);
+/* See if we can figure out the function's actual type from the type
+   that the resolver returns.  RESOLVER_FUNADDR is the address of the
+   ifunc resolver.  */
+
+extern struct type *find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr);
+
+/* Find the GNU ifunc minimal symbol that matches SYM.  */
+extern bound_minimal_symbol find_gnu_ifunc (const symbol *sym);

 
 extern void clear_pc_function_cache (void);
 
 
 extern void clear_pc_function_cache (void);
 


@@ -1645,7 +1804,7 @@ extern struct compunit_symtab *find_pc_compunit_symtab (CORE_ADDR);
 extern struct compunit_symtab *
   find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
 
 extern struct compunit_symtab *
   find_pc_sect_compunit_symtab (CORE_ADDR, struct obj_section *);
 

-extern int find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);
+extern bool find_pc_line_pc_range (CORE_ADDR, CORE_ADDR *, CORE_ADDR *);

 
 extern void reread_symbols (void);
 
 
 extern void reread_symbols (void);
 


@@ -1667,7 +1826,7 @@ extern struct type *basic_lookup_transparent_type (const char *);
 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
 #endif
 
 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
 #endif
 

-extern int in_gnu_ifunc_stub (CORE_ADDR pc);
+extern bool in_gnu_ifunc_stub (CORE_ADDR pc);

 
 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
    for ELF symbol files.  */
 
 /* Functions for resolving STT_GNU_IFUNC symbols which are implemented only
    for ELF symbol files.  */


@@ -1678,7 +1837,7 @@ struct gnu_ifunc_fns
   CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
 
   /* See elf_gnu_ifunc_resolve_name for its real implementation.  */
   CORE_ADDR (*gnu_ifunc_resolve_addr) (struct gdbarch *gdbarch, CORE_ADDR pc);
 
   /* See elf_gnu_ifunc_resolve_name for its real implementation.  */

-  int (*gnu_ifunc_resolve_name) (const char *function_name,
+  bool (*gnu_ifunc_resolve_name) (const char *function_name,

                                 CORE_ADDR *function_address_p);
 
   /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */
                                 CORE_ADDR *function_address_p);
 
   /* See elf_gnu_ifunc_resolver_stop for its real implementation.  */


@@ -1706,6 +1865,7 @@ struct symtab_and_line
   struct symtab *symtab = NULL;
   struct symbol *symbol = NULL;
   struct obj_section *section = NULL;
   struct symtab *symtab = NULL;
   struct symbol *symbol = NULL;
   struct obj_section *section = NULL;

+  struct minimal_symbol *msymbol = NULL;

   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
      0 is never a valid line number; it is used to indicate that line number
      information is not available.  */
   /* Line number.  Line numbers start at 1 and proceed through symtab->nlines.
      0 is never a valid line number; it is used to indicate that line number
      information is not available.  */


@@ -1717,7 +1877,7 @@ struct symtab_and_line
   bool explicit_line = false;
 
   /* The probe associated with this symtab_and_line.  */
   bool explicit_line = false;
 
   /* The probe associated with this symtab_and_line.  */

-  struct probe *probe = NULL;
+  probe *prob = NULL;

   /* If PROBE is not NULL, then this is the objfile in which the probe
      originated.  */
   struct objfile *objfile = NULL;
   /* If PROBE is not NULL, then this is the objfile in which the probe
      originated.  */
   struct objfile *objfile = NULL;


@@ -1741,10 +1901,10 @@ extern struct symtab *find_pc_line_symtab (CORE_ADDR);
 
 /* Given a symtab and line number, return the pc there.  */
 
 
 /* Given a symtab and line number, return the pc there.  */
 

-extern int find_line_pc (struct symtab *, int, CORE_ADDR *);
+extern bool find_line_pc (struct symtab *, int, CORE_ADDR *);

 
 

-extern int find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
-                              CORE_ADDR *);
+extern bool find_line_pc_range (struct symtab_and_line, CORE_ADDR *,
+                               CORE_ADDR *);

 
 extern void resolve_sal_pc (struct symtab_and_line *);
 
 
 extern void resolve_sal_pc (struct symtab_and_line *);
 


@@ -1752,30 +1912,6 @@ extern void resolve_sal_pc (struct symtab_and_line *);
 
 extern void clear_solib (void);
 
 
 extern void clear_solib (void);
 

-/* source.c */
-
-extern int identify_source_line (struct symtab *, int, int, CORE_ADDR);
-
-/* Flags passed as 4th argument to print_source_lines.  */
-
-enum print_source_lines_flag
-  {
-    /* Do not print an error message.  */
-    PRINT_SOURCE_LINES_NOERROR = (1 << 0),
-
-    /* Print the filename in front of the source lines.  */
-    PRINT_SOURCE_LINES_FILENAME = (1 << 1)
-  };
-DEF_ENUM_FLAGS_TYPE (enum print_source_lines_flag, print_source_lines_flags);
-
-extern void print_source_lines (struct symtab *, int, int,
-                               print_source_lines_flags);
-
-extern void forget_cached_source_info_for_objfile (struct objfile *);
-extern void forget_cached_source_info (void);
-
-extern void select_source_symtab (struct symtab *);
-

 /* The reason we're calling into a completion match list collector
    function.  */
 enum class complete_symbol_mode
 /* The reason we're calling into a completion match list collector
    function.  */
 enum class complete_symbol_mode


@@ -1840,12 +1976,21 @@ completion_skip_symbol (complete_symbol_mode mode, Symbol *sym)
 
 /* symtab.c */
 
 
 /* symtab.c */
 

-int matching_obj_sections (struct obj_section *, struct obj_section *);
+bool matching_obj_sections (struct obj_section *, struct obj_section *);
+
+extern struct symtab *find_line_symtab (struct symtab *, int, int *, bool *);

 
 

-extern struct symtab *find_line_symtab (struct symtab *, int, int *, int *);
+/* Given a function symbol SYM, find the symtab and line for the start
+   of the function.  If FUNFIRSTLINE is true, we want the first line
+   of real code inside the function.  */
+extern symtab_and_line find_function_start_sal (symbol *sym, bool
+                                               funfirstline);

 
 

-extern struct symtab_and_line find_function_start_sal (struct symbol *sym,
-                                                      int);
+/* Same, but start with a function address/section instead of a
+   symbol.  */
+extern symtab_and_line find_function_start_sal (CORE_ADDR func_addr,
+                                               obj_section *section,
+                                               bool funfirstline);

 
 extern void skip_prologue_sal (struct symtab_and_line *);
 
 
 extern void skip_prologue_sal (struct symtab_and_line *);
 


@@ -1865,11 +2010,9 @@ extern struct symbol *fixup_symbol_section (struct symbol *,
 extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
 
 /* Symbol searching */
 extern symbol *find_function_alias_target (bound_minimal_symbol msymbol);
 
 /* Symbol searching */

-/* Note: struct symbol_search, search_symbols, et.al. are declared here,
-   instead of making them local to symtab.c, for gdbtk's sake.  */

 
 

-/* When using search_symbols, a vector of the following structs is
-   returned.  */
+/* When using the symbol_searcher struct to search for symbols, a vector of
+   the following structs is returned.  */

 struct symbol_search
 {
   symbol_search (int block_, struct symbol *symbol_)
 struct symbol_search
 {
   symbol_search (int block_, struct symbol *symbol_)


@@ -1918,30 +2061,156 @@ private:
                                  const symbol_search &sym_b);
 };
 
                                  const symbol_search &sym_b);
 };
 

-extern std::vector<symbol_search> search_symbols (const char *,
-                                                 enum search_domain, int,
-                                                 const char **);
+/* In order to search for global symbols of a particular kind matching
+   particular regular expressions, create an instance of this structure and
+   call the SEARCH member function.  */
+class global_symbol_searcher
+{
+public:
+
+  /* Constructor.  */
+  global_symbol_searcher (enum search_domain kind,
+                         const char *symbol_name_regexp)
+    : m_kind (kind),
+      m_symbol_name_regexp (symbol_name_regexp)
+  {
+    /* The symbol searching is designed to only find one kind of thing.  */
+    gdb_assert (m_kind != ALL_DOMAIN);
+  }
+
+  /* Set the optional regexp that matches against the symbol type.  */
+  void set_symbol_type_regexp (const char *regexp)
+  {
+    m_symbol_type_regexp = regexp;
+  }
+
+  /* Set the flag to exclude minsyms from the search results.  */
+  void set_exclude_minsyms (bool exclude_minsyms)
+  {
+    m_exclude_minsyms = exclude_minsyms;
+  }
+
+  /* Set the maximum number of search results to be returned.  */
+  void set_max_search_results (size_t max_search_results)
+  {
+    m_max_search_results = max_search_results;
+  }
+
+  /* Search the symbols from all objfiles in the current program space
+     looking for matches as defined by the current state of this object.
+
+     Within each file the results are sorted locally; each symtab's global
+     and static blocks are separately alphabetized.  Duplicate entries are
+     removed.  */
+  std::vector<symbol_search> search () const;

 
 

-/* The name of the ``main'' function.
-   FIXME: cagney/2001-03-20: Can't make main_name() const since some
-   of the calling code currently assumes that the string isn't
-   const.  */
-extern /*const */ char *main_name (void);
+  /* The set of source files to search in for matching symbols.  This is
+     currently public so that it can be populated after this object has
+     been constructed.  */
+  std::vector<const char *> filenames;
+
+private:
+  /* The kind of symbols are we searching for.
+     VARIABLES_DOMAIN - Search all symbols, excluding functions, type
+                        names, and constants (enums).
+     FUNCTIONS_DOMAIN - Search all functions..
+     TYPES_DOMAIN     - Search all type names.
+     MODULES_DOMAIN   - Search all Fortran modules.
+     ALL_DOMAIN       - Not valid for this function.  */
+  enum search_domain m_kind;
+
+  /* Regular expression to match against the symbol name.  */
+  const char *m_symbol_name_regexp = nullptr;
+
+  /* Regular expression to match against the symbol type.  */
+  const char *m_symbol_type_regexp = nullptr;
+
+  /* When this flag is false then minsyms that match M_SYMBOL_REGEXP will
+     be included in the results, otherwise they are excluded.  */
+  bool m_exclude_minsyms = false;
+
+  /* Maximum number of search results.  We currently impose a hard limit
+     of SIZE_MAX, there is no "unlimited".  */
+  size_t m_max_search_results = SIZE_MAX;
+
+  /* Expand symtabs in OBJFILE that match PREG, are of type M_KIND.  Return
+     true if any msymbols were seen that we should later consider adding to
+     the results list.  */
+  bool expand_symtabs (objfile *objfile,
+                      const gdb::optional<compiled_regex> &preg) const;
+
+  /* Add symbols from symtabs in OBJFILE that match PREG, and TREG, and are
+     of type M_KIND, to the results set RESULTS_SET.  Return false if we
+     stop adding results early due to having already found too many results
+     (based on M_MAX_SEARCH_RESULTS limit), otherwise return true.
+     Returning true does not indicate that any results were added, just
+     that we didn't _not_ add a result due to reaching MAX_SEARCH_RESULTS.  */
+  bool add_matching_symbols (objfile *objfile,
+                            const gdb::optional<compiled_regex> &preg,
+                            const gdb::optional<compiled_regex> &treg,
+                            std::set<symbol_search> *result_set) const;
+
+  /* Add msymbols from OBJFILE that match PREG and M_KIND, to the results
+     vector RESULTS.  Return false if we stop adding results early due to
+     having already found too many results (based on max search results
+     limit M_MAX_SEARCH_RESULTS), otherwise return true.  Returning true
+     does not indicate that any results were added, just that we didn't
+     _not_ add a result due to reaching MAX_SEARCH_RESULTS.  */
+  bool add_matching_msymbols (objfile *objfile,
+                             const gdb::optional<compiled_regex> &preg,
+                             std::vector<symbol_search> *results) const;
+
+  /* Return true if MSYMBOL is of type KIND.  */
+  static bool is_suitable_msymbol (const enum search_domain kind,
+                                  const minimal_symbol *msymbol);
+};
+
+/* When searching for Fortran symbols within modules (functions/variables)
+   we return a vector of this type.  The first item in the pair is the
+   module symbol, and the second item is the symbol for the function or
+   variable we found.  */
+typedef std::pair<symbol_search, symbol_search> module_symbol_search;
+
+/* Searches the symbols to find function and variables symbols (depending
+   on KIND) within Fortran modules.  The MODULE_REGEXP matches against the
+   name of the module, REGEXP matches against the name of the symbol within
+   the module, and TYPE_REGEXP matches against the type of the symbol
+   within the module.  */
+extern std::vector<module_symbol_search> search_module_symbols
+       (const char *module_regexp, const char *regexp,
+        const char *type_regexp, search_domain kind);
+
+/* Convert a global or static symbol SYM (based on BLOCK, which should be
+   either GLOBAL_BLOCK or STATIC_BLOCK) into a string for use in 'info'
+   type commands (e.g. 'info variables', 'info functions', etc).  KIND is
+   the type of symbol that was searched for which gave us SYM.  */
+
+extern std::string symbol_to_info_string (struct symbol *sym, int block,
+                                         enum search_domain kind);
+
+extern bool treg_matches_sym_type_name (const compiled_regex &treg,
+                                       const struct symbol *sym);
+
+/* The name of the ``main'' function.  */
+extern const char *main_name ();

 extern enum language main_language (void);
 
 extern enum language main_language (void);
 

-/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global blocks.
+/* Lookup symbol NAME from DOMAIN in MAIN_OBJFILE's global or static blocks,
+   as specified by BLOCK_INDEX.

    This searches MAIN_OBJFILE as well as any associated separate debug info
    objfiles of MAIN_OBJFILE.
    This searches MAIN_OBJFILE as well as any associated separate debug info
    objfiles of MAIN_OBJFILE.

+   BLOCK_INDEX can be GLOBAL_BLOCK or STATIC_BLOCK.

    Upon success fixes up the symbol's section if necessary.  */
 
 extern struct block_symbol
   lookup_global_symbol_from_objfile (struct objfile *main_objfile,
    Upon success fixes up the symbol's section if necessary.  */
 
 extern struct block_symbol
   lookup_global_symbol_from_objfile (struct objfile *main_objfile,

+                                    enum block_enum block_index,

                                     const char *name,
                                     const domain_enum domain);
 
 /* Return 1 if the supplied producer string matches the ARM RealView
    compiler (armcc).  */
                                     const char *name,
                                     const domain_enum domain);
 
 /* Return 1 if the supplied producer string matches the ARM RealView
    compiler (armcc).  */

-int producer_is_realview (const char *producer);
+bool producer_is_realview (const char *producer);

 
 void fixup_section (struct general_symbol_info *ginfo,
                    CORE_ADDR addr, struct objfile *objfile);
 
 void fixup_section (struct general_symbol_info *ginfo,
                    CORE_ADDR addr, struct objfile *objfile);


@@ -1954,13 +2223,13 @@ extern unsigned int symtab_create_debug;
 
 extern unsigned int symbol_lookup_debug;
 
 
 extern unsigned int symbol_lookup_debug;
 

-extern int basenames_may_differ;
+extern bool basenames_may_differ;

 
 

-int compare_filenames_for_search (const char *filename,
-                                 const char *search_name);
+bool compare_filenames_for_search (const char *filename,
+                                  const char *search_name);

 
 

-int compare_glob_filenames_for_search (const char *filename,
-                                      const char *search_name);
+bool compare_glob_filenames_for_search (const char *filename,
+                                       const char *search_name);

 
 bool iterate_over_some_symtabs (const char *name,
                                const char *real_path,
 
 bool iterate_over_some_symtabs (const char *name,
                                const char *real_path,


@@ -1980,13 +2249,32 @@ std::vector<CORE_ADDR> find_pcs_for_symtab_line
    true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
    iterating, or false to indicate that the iteration should end.  */
 
    true to indicate that LA_ITERATE_OVER_SYMBOLS should continue
    iterating, or false to indicate that the iteration should end.  */
 

-typedef bool (symbol_found_callback_ftype) (symbol *sym);
+typedef bool (symbol_found_callback_ftype) (struct block_symbol *bsym);
+
+/* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
+
+   For each symbol that matches, CALLBACK is called.  The symbol is
+   passed to the callback.
+
+   If CALLBACK returns false, the iteration ends and this function
+   returns false.  Otherwise, the search continues, and the function
+   eventually returns true.  */

 
 

-void iterate_over_symbols (const struct block *block,
+bool iterate_over_symbols (const struct block *block,

                           const lookup_name_info &name,
                           const domain_enum domain,
                           gdb::function_view<symbol_found_callback_ftype> callback);
 
                           const lookup_name_info &name,
                           const domain_enum domain,
                           gdb::function_view<symbol_found_callback_ftype> callback);
 

+/* Like iterate_over_symbols, but if all calls to CALLBACK return
+   true, then calls CALLBACK one additional time with a block_symbol
+   that has a valid block but a NULL symbol.  */
+
+bool iterate_over_symbols_terminated
+  (const struct block *block,
+   const lookup_name_info &name,
+   const domain_enum domain,
+   gdb::function_view<symbol_found_callback_ftype> callback);
+

 /* Storage type used by demangle_for_lookup.  demangle_for_lookup
    either returns a const char * pointer that points to either of the
    fields of this type, or a pointer to the input NAME.  This is done
 /* Storage type used by demangle_for_lookup.  demangle_for_lookup
    either returns a const char * pointer that points to either of the
    fields of this type, or a pointer to the input NAME.  This is done


@@ -2041,4 +2329,47 @@ void completion_list_add_name (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);
 

+/* A simple symbol searching class.  */
+
+class symbol_searcher
+{
+public:
+  /* Returns the symbols found for the search.  */
+  const std::vector<block_symbol> &
+  matching_symbols () const
+  {
+    return m_symbols;
+  }
+
+  /* Returns the minimal symbols found for the search.  */
+  const std::vector<bound_minimal_symbol> &
+  matching_msymbols () const
+  {
+    return m_minimal_symbols;
+  }
+
+  /* Search for all symbols named NAME in LANGUAGE with DOMAIN, restricting
+     search to FILE_SYMTABS and SEARCH_PSPACE, both of which may be NULL
+     to search all symtabs and program spaces.  */
+  void find_all_symbols (const std::string &name,
+                        const struct language_defn *language,
+                        enum search_domain search_domain,
+                        std::vector<symtab *> *search_symtabs,
+                        struct program_space *search_pspace);
+
+  /* Reset this object to perform another search.  */
+  void reset ()
+  {
+    m_symbols.clear ();
+    m_minimal_symbols.clear ();
+  }
+
+private:
+  /* Matching debug symbols.  */
+  std::vector<block_symbol>  m_symbols;
+
+  /* Matching non-debug symbols.  */
+  std::vector<bound_minimal_symbol> m_minimal_symbols;
+};
+

 #endif /* !defined(SYMTAB_H) */
 #endif /* !defined(SYMTAB_H) */