combine bfd_lookup_symbol in solib-*.c

[Yao Qi <yao at codesourcery dot com>]

>> > +static CORE_ADDR
>> > +bfd_lookup_symbol (bfd *abfd, char *symname)
> I now notice that we already have copies of this
> function in solib-svr4.c, solib-frv.c and solib-pa64.c
> could could be combined.  Given the precedent, it's okay
> to leave that for a follow up.
>

During the tic6x patches review, Pedro pointed out the duplication of
bfd_lookup_symbol cross solib-svr4.c, solib-frv.c and solib-pa64.c.
This patch is to remove the duplication.

Four instances of bfd_lookup_symbol is not exactly the same, and can be
grouped into three 1) solib-svr4.c 2) solib-frv.c and solib-dsbt.c, 3)
solib-pa64.  In this patch, I split original version into two functions
bfd_lookup_symbol_from_symtab and bfd_lookup_symbol_from_dyn_symtab, and
move them to solib.c, so that they can be reused easily.  A helper
function, as a parameter, is introduced to hide the difference on
comparing symbol name and checking section flag.

There is still minor duplications in this new patch, which is helper
function (cmp_name) defined in each solib-{frv,pa64,dsbt}.c
respectively.  Since I don't want helper_function be visible out of
file, so this duplication is acceptable to me.

Regression tested x86_64-pc-linux-gnu.  OK for mainline?

-- 
Yao (éå)

        gdb/
        * solib-dsbt.c (bfd_lookup_symbol): Removed.
        (cmp_name): New.
        (enable_break2): Update caller.
        * solib-frv.c (bfd_lookup_symbol): Removed.
        (cmp_name): New.
        (enable_break2): Update caller.
        * solib-pa64.c (bfd_lookup_symbol): Removed.
        (cmp_name): New.
        * solib-svr4.c (bfd_lookup_symbol): Removed.
        (cmp_name_and_sec_flags): New.
        (enable_break): Update caller.
        * solib.c (bfd_lookup_symbol_from_symtab): New.
        (bfd_lookup_symbol_from_dyn_symtab): New.
        (bfd_lookup_symbol): New.
        * solib.h: Functions declarations.
---
 gdb/solib-dsbt.c |   80 +++++-----------------------------------------
 gdb/solib-frv.c  |   82 ++++++-----------------------------------------
 gdb/solib-pa64.c |   48 +++------------------------
 gdb/solib-svr4.c |   91 ++++++-----------------------------------------------
 gdb/solib.c      |   93 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 gdb/solib.h      |   12 +++++++
 6 files changed, 140 insertions(+), 266 deletions(-)

diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c
index 2569395..2922731 100644
--- a/gdb/solib-dsbt.c
+++ b/gdb/solib-dsbt.c
@@ -508,76 +508,6 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
   return 0;
 }
 
-/* An expensive way to lookup the value of a single symbol for
-   bfd's that are only temporary anyway.  This is used by the
-   shared library support to find the address of the debugger
-   interface structures in the shared library.
-
-   Note that 0 is specifically allowed as an error return (no
-   such symbol).  */
-
-static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, char *symname)
-{
-  long storage_needed;
-  asymbol *sym;
-  asymbol **symbol_table;
-  unsigned int number_of_symbols;
-  unsigned int i;
-  struct cleanup *back_to;
-  CORE_ADDR symaddr = 0;
-
-  storage_needed = bfd_get_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-	  if (strcmp (sym->name, symname) == 0)
-	    {
-	      /* Bfd symbols are section relative. */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-
-  if (symaddr)
-    return symaddr;
-
-  /* Look for the symbol in the dynamic string table too.  */
-
-  storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-	  if (strcmp (sym->name, symname) == 0)
-	    {
-	      /* Bfd symbols are section relative. */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-
-  return symaddr;
-}
-
-
 /* If no open symbol file, attempt to locate and open the main symbol
    file.
 
@@ -852,6 +782,14 @@ enable_break_failure_warning (void)
 	   "and track explicitly loaded dynamic code."));
 }
 
+/* Helper function for bfd_lookup_symbol.  */
+
+static int
+cmp_name (asymbol *sym, const char *name)
+{
+  return (strcmp (sym->name, symname) == 0);
+}
+
 /* The dynamic linkers has, as part of its debugger interface, support
    for arranging for the inferior to hit a breakpoint after mapping in
    the shared libraries.  This function enables that breakpoint.
@@ -957,7 +895,7 @@ enable_break2 (void)
 	    info->interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
 	}
 
-      addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr");
+      addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr", cmp_name);
       if (addr == 0)
 	{
 	  warning (_("Could not find symbol _dl_debug_addr in dynamic linker"));
diff --git a/gdb/solib-frv.c b/gdb/solib-frv.c
index e1c16d9..d412b61 100644
--- a/gdb/solib-frv.c
+++ b/gdb/solib-frv.c
@@ -239,77 +239,6 @@ static void frv_relocate_main_executable (void);
 static CORE_ADDR main_got (void);
 static int enable_break2 (void);
 
-/* Lookup the value for a specific symbol.
-
-   An expensive way to lookup the value of a single symbol for
-   bfd's that are only temporary anyway.  This is used by the
-   shared library support to find the address of the debugger
-   interface structures in the shared library.
-
-   Note that 0 is specifically allowed as an error return (no
-   such symbol).  */
-
-static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, char *symname)
-{
-  long storage_needed;
-  asymbol *sym;
-  asymbol **symbol_table;
-  unsigned int number_of_symbols;
-  unsigned int i;
-  struct cleanup *back_to;
-  CORE_ADDR symaddr = 0;
-
-  storage_needed = bfd_get_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-	  if (strcmp (sym->name, symname) == 0)
-	    {
-	      /* Bfd symbols are section relative.  */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-
-  if (symaddr)
-    return symaddr;
-
-  /* Look for the symbol in the dynamic string table too.  */
-
-  storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-	  if (strcmp (sym->name, symname) == 0)
-	    {
-	      /* Bfd symbols are section relative.  */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-
-  return symaddr;
-}
-
 /* Implement the "open_symbol_file_object" target_so_ops method.  */
 
 static int
@@ -554,6 +483,14 @@ enable_break_failure_warning (void)
 	   "and track explicitly loaded dynamic code."));
 }
 
+/* Helper function for bfd_lookup_symbol.  */
+
+static int
+cmp_name (asymbol *sym, const char *name)
+{
+  return (strcmp (sym->name, name) == 0);
+}
+
 /* Arrange for dynamic linker to hit breakpoint.
 
    The dynamic linkers has, as part of its debugger interface, support
@@ -680,7 +617,8 @@ enable_break2 (void)
 	    interp_plt_sect_low + bfd_section_size (tmp_bfd, interp_sect);
 	}
 
-      addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr");
+      addr = bfd_lookup_symbol (tmp_bfd, "_dl_debug_addr", cmp_name);
+
       if (addr == 0)
 	{
 	  warning (_("Could not find symbol _dl_debug_addr "
diff --git a/gdb/solib-pa64.c b/gdb/solib-pa64.c
index cd38728..83e179d 100644
--- a/gdb/solib-pa64.c
+++ b/gdb/solib-pa64.c
@@ -269,51 +269,14 @@ read_dynamic_info (asection *dyninfo_sect, dld_cache_t *dld_cache_p)
   return 1;
 }
 
-/* bfd_lookup_symbol -- lookup the value for a specific symbol
+/* Helper function for bfd_lookup_symbol_from_symtab.  */
 
-   An expensive way to lookup the value of a single symbol for
-   bfd's that are only temporary anyway.  This is used by the
-   shared library support to find the address of the debugger
-   interface structures in the shared library.
-
-   Note that 0 is specifically allowed as an error return (no
-   such symbol).  */
-
-static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, char *symname)
+static int
+cmp_name (asymbol *sym, const char *name)
 {
-  unsigned int storage_needed;
-  asymbol *sym;
-  asymbol **symbol_table;
-  unsigned int number_of_symbols;
-  unsigned int i;
-  struct cleanup *back_to;
-  CORE_ADDR symaddr = 0;
-
-  storage_needed = bfd_get_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-	  if (strcmp (sym->name, symname) == 0)
-	    {
-	      /* Bfd symbols are section relative.  */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-  return (symaddr);
+  return (strcmp (sym->name, symname) == 0);
 }
 
-
 /* This hook gets called just before the first instruction in the
    inferior process is executed.
 
@@ -421,7 +384,8 @@ manpage for methods to privately map shared library text."));
 	 routine.  */
       load_addr = regcache_read_pc (get_current_regcache ())
 		  - tmp_bfd->start_address;
-      sym_addr = bfd_lookup_symbol (tmp_bfd, "__dld_break");
+      sym_addr = bfd_lookup_symbol_from_symtab (tmp_bfd, "__dld_break",
+						cmp_name);
       sym_addr = load_addr + sym_addr + 4;
       
       /* Create the shared library breakpoint.  */
diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
index f643a24..d199af4 100644
--- a/gdb/solib-svr4.c
+++ b/gdb/solib-svr4.c
@@ -370,86 +370,6 @@ get_svr4_info (void)
 
 static int match_main (const char *);
 
-/* Lookup the value for a specific symbol.
-
-   An expensive way to lookup the value of a single symbol for
-   bfd's that are only temporary anyway.  This is used by the
-   shared library support to find the address of the debugger
-   notification routine in the shared library.
-
-   The returned symbol may be in a code or data section; functions
-   will normally be in a code section, but may be in a data section
-   if this architecture uses function descriptors.
-
-   Note that 0 is specifically allowed as an error return (no
-   such symbol).  */
-
-static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, const char *symname)
-{
-  long storage_needed;
-  asymbol *sym;
-  asymbol **symbol_table;
-  unsigned int number_of_symbols;
-  unsigned int i;
-  struct cleanup *back_to;
-  CORE_ADDR symaddr = 0;
-
-  storage_needed = bfd_get_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-	  if (strcmp (sym->name, symname) == 0
-              && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
-	    {
-	      /* BFD symbols are section relative.  */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-
-  if (symaddr)
-    return symaddr;
-
-  /* On FreeBSD, the dynamic linker is stripped by default.  So we'll
-     have to check the dynamic string table too.  */
-
-  storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
-
-  if (storage_needed > 0)
-    {
-      symbol_table = (asymbol **) xmalloc (storage_needed);
-      back_to = make_cleanup (xfree, symbol_table);
-      number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
-
-      for (i = 0; i < number_of_symbols; i++)
-	{
-	  sym = *symbol_table++;
-
-	  if (strcmp (sym->name, symname) == 0
-              && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
-	    {
-	      /* BFD symbols are section relative.  */
-	      symaddr = sym->value + sym->section->vma;
-	      break;
-	    }
-	}
-      do_cleanups (back_to);
-    }
-
-  return symaddr;
-}
-
-
 /* Read program header TYPE from inferior memory.  The header is found
    by scanning the OS auxillary vector.
 
@@ -1253,6 +1173,14 @@ exec_entry_point (struct bfd *abfd, struct target_ops *targ)
 					     targ);
 }
 
+/* Helper function for bfd_lookup_symbol.  */
+
+static int
+cmp_name_and_sec_flags (asymbol *sym, const char *name)
+{
+  return (strcmp (sym->name, name) == 0
+	  && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0);
+}
 /* Arrange for dynamic linker to hit breakpoint.
 
    Both the SunOS and the SVR4 dynamic linkers have, as part of their
@@ -1501,7 +1429,8 @@ enable_break (struct svr4_info *info, int from_tty)
       /* Now try to set a breakpoint in the dynamic linker.  */
       for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
 	{
-	  sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
+	  sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep,
+					cmp_name_and_sec_flags);
 	  if (sym_addr != 0)
 	    break;
 	}
diff --git a/gdb/solib.c b/gdb/solib.c
index f843723..9fffa49 100644
--- a/gdb/solib.c
+++ b/gdb/solib.c
@@ -1336,6 +1336,99 @@ solib_global_lookup (const struct objfile *objfile,
   return NULL;
 }
 
+CORE_ADDR
+bfd_lookup_symbol_from_symtab (bfd *abfd, const char *symname,
+			       int (*is_right_sym) (asymbol *, const char *))
+{
+  long storage_needed = bfd_get_symtab_upper_bound (abfd);
+  CORE_ADDR symaddr = 0;
+
+  if (storage_needed > 0)
+    {
+      unsigned int i;
+
+      asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
+      struct cleanup *back_to = make_cleanup (xfree, symbol_table);
+      unsigned int number_of_symbols =
+	bfd_canonicalize_symtab (abfd, symbol_table);
+
+      for (i = 0; i < number_of_symbols; i++)
+	{
+	  asymbol *sym  = *symbol_table++;
+
+	  if (is_right_sym (sym, symname))
+	    {
+	      /* BFD symbols are section relative.  */
+	      symaddr = sym->value + sym->section->vma;
+	      break;
+	    }
+	}
+      do_cleanups (back_to);
+    }
+
+  return symaddr;
+}
+
+static CORE_ADDR
+bfd_lookup_symbol_from_dyn_symtab (bfd *abfd, const char *symname,
+				   int (*is_right_sym) (asymbol *,
+							const char *))
+{
+  long storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
+  CORE_ADDR symaddr = 0;
+
+  if (storage_needed > 0)
+    {
+      unsigned int i;
+      asymbol **symbol_table = (asymbol **) xmalloc (storage_needed);
+      struct cleanup *back_to = make_cleanup (xfree, symbol_table);
+      unsigned int number_of_symbols =
+	bfd_canonicalize_dynamic_symtab (abfd, symbol_table);
+
+      for (i = 0; i < number_of_symbols; i++)
+	{
+	  asymbol *sym = *symbol_table++;
+
+	  if (is_right_sym (sym, symname))
+	    {
+	      /* BFD symbols are section relative.  */
+	      symaddr = sym->value + sym->section->vma;
+	      break;
+	    }
+	}
+      do_cleanups (back_to);
+    }
+  return symaddr;
+}
+
+/* Lookup the value for a specific symbol.
+
+   An expensive way to lookup the value of a single symbol for
+   bfd's that are only temporary anyway.  This is used by the
+   shared library support to find the address of the debugger
+   notification routine in the shared library.
+
+   The returned symbol may be in a code or data section; functions
+   will normally be in a code section, but may be in a data section
+   if this architecture uses function descriptors.
+
+   Note that 0 is specifically allowed as an error return (no
+   such symbol).  */
+
+CORE_ADDR
+bfd_lookup_symbol (bfd *abfd, const char *symname,
+		   int (*is_right_sym) (asymbol *, const char *))
+{
+  CORE_ADDR symaddr = bfd_lookup_symbol_from_symtab (abfd, symname,
+						     is_right_sym);
+
+  /* On FreeBSD, the dynamic linker is stripped by default.  So we'll
+     have to check the dynamic string table too.  */
+  if (symaddr == 0)
+    symaddr = bfd_lookup_symbol_from_dyn_symtab (abfd, symname, is_right_sym);
+
+  return symaddr;
+}
 
 extern initialize_file_ftype _initialize_solib; /* -Wmissing-prototypes */
 
diff --git a/gdb/solib.h b/gdb/solib.h
index c473d85..4e788f8 100644
--- a/gdb/solib.h
+++ b/gdb/solib.h
@@ -78,4 +78,16 @@ extern void set_solib_ops (struct gdbarch *gdbarch,
 
 extern int libpthread_name_p (const char *name);
 
+/* Look up symbol from both symbol table and dynamic string table.  */
+
+extern CORE_ADDR bfd_lookup_symbol (bfd *abfd, const char *symname,
+				    int (*is_right_sym) (asymbol *,
+							 const char *));
+
+/* Look up symbol from symbol table.  */
+
+extern CORE_ADDR bfd_lookup_symbol_from_symtab (bfd *abfd, const char *symname,
+						int (*is_right_sym) (asymbol *,
+								     const char *));
+
 #endif /* SOLIB_H */
-- 
1.7.0.4