Move lookup_block_symbol to block.c, rename to block_lookup_symbol.

There is another function, lookup_symbol_aux_block, and
the names lookup_block_symbol and lookup_symbol_aux_block don't
convey any real difference between them.

The difference is that lookup_block_symbol lives in the lower level
block API, and lookup_symbol_aux_block lives in the higher level symtab API.
This patch makes this distinction clear.

gdb/ChangeLog:

	* symtab.c (lookup_block_symbol): Moved to ...
	* block.c (block_lookup_symbol):  ... here and renamed.
	All callers updated.
	* block.h (block_lookup_symbol): Declare.
	* symtab.h (lookup_block_symbol): Delete.

8 files changed, 85 insertions, 76 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 89937e2..dc78a6a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,13 @@
 2014-11-06  Doug Evans  <xdje42@gmail.com>
 
+	* symtab.c (lookup_block_symbol): Moved to ...
+	* block.c (block_lookup_symbol):  ... here and renamed.
+	All callers updated.
+	* block.h (block_lookup_symbol): Declare.
+	* symtab.h (lookup_block_symbol): Delete.
+
+2014-11-06  Doug Evans  <xdje42@gmail.com>
+
 	* ada-lang.c (ada_make_symbol_completion_list): Use
 	ALL_PRIMARY_SYMTABS instead of ALL_SYMTABS.
 	* symtab.c (lookup_objfile_from_block): Ditto.
diff --git a/gdb/block.c b/gdb/block.c
index 8d40c9d..3bb9de0 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -685,3 +685,61 @@ block_iter_match_next (const char *name,
 
   return block_iter_match_step (iterator, name, compare, 0);
 }
+
+/* See block.h.
+
+   Note that if NAME is the demangled form of a C++ symbol, we will fail
+   to find a match during the binary search of the non-encoded names, but
+   for now we don't worry about the slight inefficiency of looking for
+   a match we'll never find, since it will go pretty quick.  Once the
+   binary search terminates, we drop through and do a straight linear
+   search on the symbols.  Each symbol which is marked as being a ObjC/C++
+   symbol (language_cplus or language_objc set) has both the encoded and
+   non-encoded names tested for a match.  */
+
+struct symbol *
+block_lookup_symbol (const struct block *block, const char *name,
+		     const domain_enum domain)
+{
+  struct block_iterator iter;
+  struct symbol *sym;
+
+  if (!BLOCK_FUNCTION (block))
+    {
+      for (sym = block_iter_name_first (block, name, &iter);
+	   sym != NULL;
+	   sym = block_iter_name_next (name, &iter))
+	{
+	  if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+				     SYMBOL_DOMAIN (sym), domain))
+	    return sym;
+	}
+      return NULL;
+    }
+  else
+    {
+      /* Note that parameter symbols do not always show up last in the
+	 list; this loop makes sure to take anything else other than
+	 parameter symbols first; it only uses parameter symbols as a
+	 last resort.  Note that this only takes up extra computation
+	 time on a match.  */
+
+      struct symbol *sym_found = NULL;
+
+      for (sym = block_iter_name_first (block, name, &iter);
+	   sym != NULL;
+	   sym = block_iter_name_next (name, &iter))
+	{
+	  if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+				     SYMBOL_DOMAIN (sym), domain))
+	    {
+	      sym_found = sym;
+	      if (!SYMBOL_IS_ARGUMENT (sym))
+		{
+		  break;
+		}
+	    }
+	}
+      return (sym_found);	/* Will be NULL if not found.  */
+    }
+}
diff --git a/gdb/block.h b/gdb/block.h
index 30aaf98..e8d3452 100644
--- a/gdb/block.h
+++ b/gdb/block.h
@@ -271,6 +271,12 @@ extern struct symbol *block_iter_match_next (const char *name,
 					     symbol_compare_ftype *compare,
 					     struct block_iterator *iterator);
 
+/* Search BLOCK for symbol NAME in DOMAIN.  */
+
+extern struct symbol *block_lookup_symbol (const struct block *block,
+					   const char *name,
+					   const domain_enum domain);
+
 /* Macro to loop through all symbols in BLOCK, in no particular
    order.  ITER helps keep track of the iteration, and must be a
    struct block_iterator.  SYM points to the current symbol.  */
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 76f62b5..ce37adf 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -3616,7 +3616,7 @@ dw2_lookup_symbol (struct objfile *objfile, int block_index,
 	      const struct blockvector *bv = BLOCKVECTOR (stab);
 	      struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 
-	      sym = lookup_block_symbol (block, name, domain);
+	      sym = block_lookup_symbol (block, name, domain);
 	    }
 
 	  if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
diff --git a/gdb/psymtab.c b/gdb/psymtab.c
index 6c0c880..2514b55 100644
--- a/gdb/psymtab.c
+++ b/gdb/psymtab.c
@@ -519,7 +519,7 @@ lookup_symbol_aux_psymtabs (struct objfile *objfile,
 	    const struct blockvector *bv = BLOCKVECTOR (stab);
 	    struct block *block = BLOCKVECTOR_BLOCK (bv, block_index);
 
-	    sym = lookup_block_symbol (block, name, domain);
+	    sym = block_lookup_symbol (block, name, domain);
 	  }
 
 	if (sym && strcmp_iw (SYMBOL_SEARCH_NAME (sym), name) == 0)
@@ -2038,7 +2038,7 @@ maintenance_check_psymtabs (char *ignore, int from_tty)
     length = ps->n_static_syms;
     while (length--)
       {
-	sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
+	sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
 				   SYMBOL_DOMAIN (*psym));
 	if (!sym)
 	  {
@@ -2055,7 +2055,7 @@ maintenance_check_psymtabs (char *ignore, int from_tty)
     length = ps->n_global_syms;
     while (length--)
       {
-	sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
+	sym = block_lookup_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
 				   SYMBOL_DOMAIN (*psym));
 	if (!sym)
 	  {
diff --git a/gdb/spu-tdep.c b/gdb/spu-tdep.c
index 032f5de..30e569f 100644
--- a/gdb/spu-tdep.c
+++ b/gdb/spu-tdep.c
@@ -1987,7 +1987,7 @@ spu_catch_start (struct objfile *objfile)
       struct symbol *sym;
       struct symtab_and_line sal;
 
-      sym = lookup_block_symbol (block, "main", VAR_DOMAIN);
+      sym = block_lookup_symbol (block, "main", VAR_DOMAIN);
       if (sym)
 	{
 	  fixup_symbol_section (sym, objfile);
diff --git a/gdb/symtab.c b/gdb/symtab.c
index e9f37bc..482a23d 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -1344,7 +1344,7 @@ lookup_language_this (const struct language_defn *lang,
     {
       struct symbol *sym;
 
-      sym = lookup_block_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
+      sym = block_lookup_symbol (block, lang->la_name_of_this, VAR_DOMAIN);
       if (sym != NULL)
 	{
 	  block_found = block;
@@ -1572,7 +1572,7 @@ lookup_symbol_aux_block (const char *name, const struct block *block,
 {
   struct symbol *sym;
 
-  sym = lookup_block_symbol (block, name, domain);
+  sym = block_lookup_symbol (block, name, domain);
   if (sym)
     {
       block_found = block;
@@ -1604,7 +1604,7 @@ lookup_global_symbol_from_objfile (const struct objfile *main_objfile,
 	{
 	  bv = BLOCKVECTOR (s);
 	  block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-	  sym = lookup_block_symbol (block, name, domain);
+	  sym = block_lookup_symbol (block, name, domain);
 	  if (sym)
 	    {
 	      block_found = block;
@@ -1639,7 +1639,7 @@ lookup_symbol_aux_objfile (struct objfile *objfile, int block_index,
     {
       bv = BLOCKVECTOR (s);
       block = BLOCKVECTOR_BLOCK (bv, block_index);
-      sym = lookup_block_symbol (block, name, domain);
+      sym = block_lookup_symbol (block, name, domain);
       if (sym)
 	{
 	  block_found = block;
@@ -1747,7 +1747,7 @@ lookup_symbol_aux_quick (struct objfile *objfile, int block_index,
 
   bv = BLOCKVECTOR (symtab);
   block = BLOCKVECTOR_BLOCK (bv, block_index);
-  sym = lookup_block_symbol (block, name, domain);
+  sym = block_lookup_symbol (block, name, domain);
   if (!sym)
     error_in_psymtab_expansion (block_index, name, symtab);
   block_found = block;
@@ -1931,7 +1931,7 @@ basic_lookup_transparent_type_quick (struct objfile *objfile, int block_index,
 
   bv = BLOCKVECTOR (symtab);
   block = BLOCKVECTOR_BLOCK (bv, block_index);
-  sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+  sym = block_lookup_symbol (block, name, STRUCT_DOMAIN);
   if (!sym)
     error_in_psymtab_expansion (block_index, name, symtab);
 
@@ -1968,7 +1968,7 @@ basic_lookup_transparent_type (const char *name)
       {
 	bv = BLOCKVECTOR (s);
 	block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
-	sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+	sym = block_lookup_symbol (block, name, STRUCT_DOMAIN);
 	if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
 	  {
 	    return SYMBOL_TYPE (sym);
@@ -1996,7 +1996,7 @@ basic_lookup_transparent_type (const char *name)
       {
 	bv = BLOCKVECTOR (s);
 	block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
-	sym = lookup_block_symbol (block, name, STRUCT_DOMAIN);
+	sym = block_lookup_symbol (block, name, STRUCT_DOMAIN);
 	if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
 	  {
 	    return SYMBOL_TYPE (sym);
@@ -2014,64 +2014,6 @@ basic_lookup_transparent_type (const char *name)
   return (struct type *) 0;
 }
 
-/* See symtab.h.
-
-   Note that if NAME is the demangled form of a C++ symbol, we will fail
-   to find a match during the binary search of the non-encoded names, but
-   for now we don't worry about the slight inefficiency of looking for
-   a match we'll never find, since it will go pretty quick.  Once the
-   binary search terminates, we drop through and do a straight linear
-   search on the symbols.  Each symbol which is marked as being a ObjC/C++
-   symbol (language_cplus or language_objc set) has both the encoded and
-   non-encoded names tested for a match.  */
-
-struct symbol *
-lookup_block_symbol (const struct block *block, const char *name,
-		     const domain_enum domain)
-{
-  struct block_iterator iter;
-  struct symbol *sym;
-
-  if (!BLOCK_FUNCTION (block))
-    {
-      for (sym = block_iter_name_first (block, name, &iter);
-	   sym != NULL;
-	   sym = block_iter_name_next (name, &iter))
-	{
-	  if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-				     SYMBOL_DOMAIN (sym), domain))
-	    return sym;
-	}
-      return NULL;
-    }
-  else
-    {
-      /* Note that parameter symbols do not always show up last in the
-	 list; this loop makes sure to take anything else other than
-	 parameter symbols first; it only uses parameter symbols as a
-	 last resort.  Note that this only takes up extra computation
-	 time on a match.  */
-
-      struct symbol *sym_found = NULL;
-
-      for (sym = block_iter_name_first (block, name, &iter);
-	   sym != NULL;
-	   sym = block_iter_name_next (name, &iter))
-	{
-	  if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
-				     SYMBOL_DOMAIN (sym), domain))
-	    {
-	      sym_found = sym;
-	      if (!SYMBOL_IS_ARGUMENT (sym))
-		{
-		  break;
-		}
-	    }
-	}
-      return (sym_found);	/* Will be NULL if not found.  */
-    }
-}
-
 /* Iterate over the symbols named NAME, matching DOMAIN, in BLOCK.
    
    For each symbol that matches, CALLBACK is called.  The symbol and
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 73108f0..7fa42a6 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1125,11 +1125,6 @@ extern struct symbol *lookup_language_this (const struct language_defn *lang,
 extern struct symbol *lookup_static_symbol_aux (const char *name,
 						const domain_enum domain);
 
-/* Search BLOCK for symbol NAME in DOMAIN.  */
-
-extern struct symbol *lookup_block_symbol (const struct block *, const char *,
-					   const domain_enum);
-
 /* Lookup a [struct, union, enum] by name, within a specified block.  */
 
 extern struct type *lookup_struct (const char *, const struct block *);