[PATCH 7/9] Rewrite lookup_static_symbol to use gdbarch routine

[Doug Evans <xdje42 at gmail dot com>]

Hi.

This patch rewrites lookup_static_symbol to use
gdbarch_iterate_over_objfiles_in_search_order.

This function is currently implemented like this:
[This is before the function is renamed by this patch series.]

struct symbol *
lookup_static_symbol_aux (const char *name, const domain_enum domain)
{
  struct objfile *objfile;
  struct symbol *sym;

  sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
  if (sym != NULL)
    return sym;

  ALL_OBJFILES (objfile)
  {
    sym = lookup_symbol_aux_quick (objfile, STATIC_BLOCK, name, domain);
    if (sym != NULL)
      return sym;
  }

  return NULL;
}

Note what we're doing here.
First we're searching over all expanded symtabs in all objfiles,
and then we search partial/gdb_index tables in all objfiles.  Eh?

Normally when looking up a symbol in a particular objfile
we first list in expanded symtabs and then look in partial/gdb_index
tables.  And *then* we try the next objfile.

I can't think of any justification for the current behaviour.

This patch changes things to be consistent,
but it is a behavioural change.
The testsuite passes, and any noticeable difference
by this change would be dependent on the order in which
symtabs got expanded.  Thus I can't think of a reason to not
apply this change.

Contrary to lookup_global_symbol where at least for linux one might
not care what order objfiles are searched, for static symbols there
is more reason to care.  However, the current API doesn't provide
for this (we don't pass in BLOCK of OBJFILE as an argument) because
this routine is used as a last resort anyways.

2014-10-26  Doug Evans  <xdje42@gmail.com>

	* symtab.c (lookup_static_symbol): Rewrite to use
	gdbarch_iterate_over_objfiles_in_search_order.
	(iterated_sym_lookup_data): Renamed from global_sym_lookup_data.
	New member block_index.
	(lookup_symbol_iterator_cb): Renamed from
	lookup_symbol_global_iterator_cb.  Use block_index from
	iterated_sym_lookup_data.
	(lookup_symbol_global): Update.
	(lookup_symbol_aux_symtabs): Delete.

diff --git a/gdb/symtab.c b/gdb/symtab.c
index 07e9fce..54bbb67 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -80,11 +80,6 @@ struct symbol *lookup_local_symbol (const char *name,
 				    enum language language);
 
 static
-struct symbol *lookup_symbol_aux_symtabs (int block_index,
-					  const char *name,
-					  const domain_enum domain);
-
-static
 struct symbol *lookup_symbol_via_quick_fns (struct objfile *objfile,
 					    int block_index,
 					    const char *name,
@@ -1474,28 +1469,6 @@ lookup_symbol_aux (const char *name, const struct block *block,
   return lookup_static_symbol (name, domain);
 }
 
-/* See symtab.h.  */
-
-struct symbol *
-lookup_static_symbol (const char *name, const domain_enum domain)
-{
-  struct objfile *objfile;
-  struct symbol *sym;
-
-  sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, domain);
-  if (sym != NULL)
-    return sym;
-
-  ALL_OBJFILES (objfile)
-  {
-    sym = lookup_symbol_via_quick_fns (objfile, STATIC_BLOCK, name, domain);
-    if (sym != NULL)
-      return sym;
-  }
-
-  return NULL;
-}
-
 /* Check to see if the symbol is defined in BLOCK or its superiors.
    Don't search STATIC_BLOCK or GLOBAL_BLOCK.  */
 
@@ -1648,26 +1621,6 @@ lookup_symbol_in_symtabs (struct objfile *objfile, int block_index,
   return NULL;
 }
 
-/* Wrapper around lookup_symbol_in_symtabs to search all objfiles.
-   Returns the first match found.  */
-
-static struct symbol *
-lookup_symbol_aux_symtabs (int block_index, const char *name,
-			   const domain_enum domain)
-{
-  struct symbol *sym;
-  struct objfile *objfile;
-
-  ALL_OBJFILES (objfile)
-  {
-    sym = lookup_symbol_in_symtabs (objfile, block_index, name, domain);
-    if (sym)
-      return sym;
-  }
-
-  return NULL;
-}
-
 /* Wrapper around lookup_symbol_in_symtabs for search_symbols.
    Look up LINKAGE_NAME in DOMAIN in the global and static blocks of OBJFILE
    and all related objfiles.  */
@@ -1771,7 +1724,7 @@ basic_lookup_symbol_nonlocal (const char *name,
      not it would be appropriate to search the current global block
      here as well.  (That's what this code used to do before the
      is_a_field_of_this check was moved up.)  On the one hand, it's
-     redundant with the lookup_symbol_aux_symtabs search that happens
+     redundant with the lookup in all objfiles search that happens
      next.  On the other hand, if decode_line_1 is passed an argument
      like filename:var, then the user presumably wants 'var' to be
      searched for in filename.  On the third hand, there shouldn't be
@@ -1815,9 +1768,9 @@ lookup_symbol_in_static_block (const char *name,
     return NULL;
 }
 
-/* Private data to be used with lookup_symbol_global_iterator_cb.  */
+/* Private data to be used with lookup_symbol_iterator_cb.  */
 
-struct global_sym_lookup_data
+struct iterated_sym_lookup_data
 {
   /* The name of the symbol we are searching for.  */
   const char *name;
@@ -1825,29 +1778,31 @@ struct global_sym_lookup_data
   /* The domain to use for our search.  */
   domain_enum domain;
 
+  /* One of STATIC_BLOCK or GLOBAL_BLOCK.  */
+  int block_index;
+
   /* The field where the callback should store the symbol if found.
      It should be initialized to NULL before the search is started.  */
   struct symbol *result;
 };
 
 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
-   It searches by name for a symbol in the GLOBAL_BLOCK of the given
+   It searches by name for a symbol in the given block of the given
    OBJFILE.  The arguments for the search are passed via CB_DATA,
-   which in reality is a pointer to struct global_sym_lookup_data.  */
+   which in reality is a pointer to struct iterated_sym_lookup_data.  */
 
 static int
-lookup_symbol_global_iterator_cb (struct objfile *objfile,
-				  void *cb_data)
+lookup_symbol_iterator_cb (struct objfile *objfile, void *cb_data)
 {
-  struct global_sym_lookup_data *data =
-    (struct global_sym_lookup_data *) cb_data;
+  struct iterated_sym_lookup_data *data =
+    (struct iterated_sym_lookup_data *) cb_data;
 
   gdb_assert (data->result == NULL);
 
-  data->result = lookup_symbol_in_symtabs (objfile, GLOBAL_BLOCK,
+  data->result = lookup_symbol_in_symtabs (objfile, data->block_index,
 					   data->name, data->domain);
   if (data->result == NULL)
-    data->result = lookup_symbol_via_quick_fns (objfile, GLOBAL_BLOCK,
+    data->result = lookup_symbol_via_quick_fns (objfile, data->block_index,
 						data->name, data->domain);
 
   /* If we found a match, tell the iterator to stop.  Otherwise,
@@ -1858,13 +1813,30 @@ lookup_symbol_global_iterator_cb (struct objfile *objfile,
 /* See symtab.h.  */
 
 struct symbol *
+lookup_static_symbol (const char *name, const domain_enum domain)
+{
+  struct iterated_sym_lookup_data lookup_data;
+
+  memset (&lookup_data, 0, sizeof (lookup_data));
+  lookup_data.name = name;
+  lookup_data.domain = domain;
+  lookup_data.block_index = STATIC_BLOCK;
+  gdbarch_iterate_over_objfiles_in_search_order
+    (target_gdbarch (), lookup_symbol_iterator_cb, &lookup_data, NULL);
+
+  return lookup_data.result;
+}
+
+/* See symtab.h.  */
+
+struct symbol *
 lookup_symbol_global (const char *name,
 		      const struct block *block,
 		      const domain_enum domain)
 {
   struct symbol *sym = NULL;
   struct objfile *objfile = NULL;
-  struct global_sym_lookup_data lookup_data;
+  struct iterated_sym_lookup_data lookup_data;
 
   /* Call library-specific lookup procedure.  */
   objfile = lookup_objfile_from_block (block);
@@ -1876,9 +1848,10 @@ lookup_symbol_global (const char *name,
   memset (&lookup_data, 0, sizeof (lookup_data));
   lookup_data.name = name;
   lookup_data.domain = domain;
+  lookup_data.block_index = GLOBAL_BLOCK;
   gdbarch_iterate_over_objfiles_in_search_order
     (objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
-     lookup_symbol_global_iterator_cb, &lookup_data, objfile);
+     lookup_symbol_iterator_cb, &lookup_data, objfile);
 
   return lookup_data.result;
 }