diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 5b352d1d77..14967ab975 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -149,7 +149,7 @@ cp_basic_lookup_symbol (const char *name, const struct block *block,
 	}
     }
   else
-    sym = lookup_global_symbol (name, block, domain);
+    sym = lookup_global_symbol (name, block, GLOBAL_BLOCK, domain);
 
   return sym;
 }
@@ -202,7 +202,7 @@ cp_lookup_bare_symbol (const struct language_defn *langdef,
 	return sym;
     }
 
-  sym = lookup_global_symbol (name, block, domain);
+  sym = lookup_global_symbol (name, block, GLOBAL_BLOCK, domain);
   if (sym.symbol != NULL)
     return sym;
 
@@ -270,7 +270,10 @@ cp_search_static_and_baseclasses (const char *name,
   block_symbol scope_sym = lookup_symbol_in_static_block (scope.c_str (),
 							  block, VAR_DOMAIN);
   if (scope_sym.symbol == NULL)
-    scope_sym = lookup_global_symbol (scope.c_str (), block, VAR_DOMAIN);
+    {
+      scope_sym = lookup_global_symbol (scope.c_str (), block, GLOBAL_BLOCK,
+					VAR_DOMAIN);
+    }
   if (scope_sym.symbol == NULL)
     return {};
 
@@ -881,7 +884,8 @@ cp_lookup_nested_symbol_1 (struct type *container_type,
      which we just searched.  */
   if (!is_in_anonymous)
     {
-      sym = lookup_static_symbol (concatenated_name, domain);
+      sym = lookup_global_symbol (concatenated_name, nullptr, STATIC_BLOCK,
+				  domain);
       if (sym.symbol != NULL)
 	return sym;
     }
diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index 768ba23f01..52c766d6d7 100644
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -102,7 +102,7 @@ d_lookup_symbol (const struct language_defn *langdef,
 	return sym;
     }
 
-  sym = lookup_global_symbol (name, block, domain);
+  sym = lookup_global_symbol (name, block, GLOBAL_BLOCK, domain);
 
   if (sym.symbol != NULL)
     return sym;
@@ -146,7 +146,8 @@ d_lookup_symbol (const struct language_defn *langdef,
 
       /* Lookup a class named CLASSNAME.  If none is found, there is nothing
 	 more that can be done.  */
-      class_sym = lookup_global_symbol (classname.c_str (), block, domain);
+      class_sym = lookup_global_symbol (classname.c_str (), block, GLOBAL_BLOCK,
+					domain);
       if (class_sym.symbol == NULL)
 	return {};
 
@@ -276,7 +277,8 @@ find_symbol_in_baseclass (struct type *parent_type, const char *name,
       /* Nope.  We now have to search all static blocks in all objfiles,
 	 even if block != NULL, because there's no guarantees as to which
 	 symtab the symbol we want is in.  */
-      sym = lookup_static_symbol (concatenated_name.c_str (), VAR_DOMAIN);
+      sym = lookup_global_symbol (concatenated_name.c_str (), nullptr,
+				  STATIC_BLOCK, VAR_DOMAIN);
       if (sym.symbol != NULL)
 	break;
 
@@ -336,7 +338,8 @@ d_lookup_nested_symbol (struct type *parent_type,
 	  xsnprintf (concatenated_name, size, "%s.%s",
 		     parent_name, nested_name);
 
-	  sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
+	  sym = lookup_global_symbol (concatenated_name, nullptr, STATIC_BLOCK,
+				      VAR_DOMAIN);
 	  if (sym.symbol != NULL)
 	    return sym;
 
diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index 7b44b56581..36f327e519 100644
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -660,7 +660,8 @@ gdbscm_lookup_global_symbol (SCM name_scm, SCM rest)
 
   try
     {
-      symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
+      symbol = lookup_global_symbol (name, NULL, GLOBAL_BLOCK,
+				     (domain_enum) domain).symbol;
     }
   catch (const gdb_exception &ex)
     {
diff --git a/gdb/python/py-symbol.c b/gdb/python/py-symbol.c
index 2b10e21d87..b16e66f557 100644
--- a/gdb/python/py-symbol.c
+++ b/gdb/python/py-symbol.c
@@ -449,7 +449,8 @@ gdbpy_lookup_global_symbol (PyObject *self, PyObject *args, PyObject *kw)
 
   try
     {
-      symbol = lookup_global_symbol (name, NULL, (domain_enum) domain).symbol;
+      symbol = lookup_global_symbol (name, NULL, GLOBAL_BLOCK,
+				     (domain_enum) domain).symbol;
     }
   catch (const gdb_exception &except)
     {
@@ -489,7 +490,8 @@ gdbpy_lookup_static_symbol (PyObject *self, PyObject *args, PyObject *kw)
 
   try
     {
-      symbol = lookup_static_symbol (name, (domain_enum) domain).symbol;
+      symbol = lookup_global_symbol (name, NULL, STATIC_BLOCK,
+				     (domain_enum) domain).symbol;
     }
   catch (const gdb_exception &except)
     {
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index 79f13311cd..a623d061e5 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -2077,7 +2077,7 @@ rust_lookup_symbol_nonlocal (const struct language_defn *langdef,
     {
       result = lookup_symbol_in_static_block (name, block, domain);
       if (result.symbol == NULL)
-	result = lookup_global_symbol (name, block, domain);
+	result = lookup_global_symbol (name, block, GLOBAL_BLOCK, domain);
     }
   return result;
 }
diff --git a/gdb/symtab.c b/gdb/symtab.c
index 87a0c8e4da..dbdf7dbfc6 100644
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -2102,7 +2102,7 @@ lookup_symbol_aux (const char *name, symbol_name_match_type match_type,
   /* Now search all static file-level symbols.  Not strictly correct,
      but more useful than an error.  */
 
-  result = lookup_static_symbol (name, domain);
+  result = lookup_global_symbol (name, nullptr, STATIC_BLOCK, domain);
   if (symbol_lookup_debug)
     {
       fprintf_unfiltered (gdb_stdlog, "lookup_symbol_aux (...) = %s\n",
@@ -2474,7 +2474,7 @@ basic_lookup_symbol_nonlocal (const struct language_defn *langdef,
 	return result;
     }
 
-  return lookup_global_symbol (name, block, domain);
+  return lookup_global_symbol (name, block, GLOBAL_BLOCK, domain);
 }
 
 /* See symtab.h.  */
@@ -2566,44 +2566,6 @@ lookup_symbol_in_objfile (struct objfile *objfile, enum block_enum block_index,
   return result;
 }
 
-/* See symtab.h.  */
-
-struct block_symbol
-lookup_static_symbol (const char *name, const domain_enum domain)
-{
-  struct symbol_cache *cache = get_symbol_cache (current_program_space);
-  struct block_symbol result;
-  struct block_symbol_cache *bsc;
-  struct symbol_cache_slot *slot;
-
-  /* Lookup in STATIC_BLOCK is not current-objfile-dependent, so just pass
-     NULL for OBJFILE_CONTEXT.  */
-  result = symbol_cache_lookup (cache, NULL, STATIC_BLOCK, name, domain,
-				&bsc, &slot);
-  if (result.symbol != NULL)
-    {
-      if (SYMBOL_LOOKUP_FAILED_P (result))
-	return {};
-      return result;
-    }
-
-  for (objfile *objfile : current_program_space->objfiles ())
-    {
-      result = lookup_symbol_in_objfile (objfile, STATIC_BLOCK, name, domain);
-      if (result.symbol != NULL)
-	{
-	  /* Still pass NULL for OBJFILE_CONTEXT here.  */
-	  symbol_cache_mark_found (bsc, slot, NULL, result.symbol,
-				   result.block);
-	  return result;
-	}
-    }
-
-  /* Still pass NULL for OBJFILE_CONTEXT here.  */
-  symbol_cache_mark_not_found (bsc, slot, NULL, name, domain);
-  return {};
-}
-
 /* Private data to be used with lookup_symbol_global_iterator_cb.  */
 
 struct global_sym_lookup_data
@@ -2614,6 +2576,9 @@ struct global_sym_lookup_data
   /* The domain to use for our search.  */
   domain_enum domain;
 
+  /* The block index in which to search */
+  enum block_enum block_index;
+
   /* The field where the callback should store the symbol if found.
      It should be initialized to {NULL, NULL} before the search is started.  */
   struct block_symbol result;
@@ -2634,7 +2599,7 @@ lookup_symbol_global_iterator_cb (struct objfile *objfile,
   gdb_assert (data->result.symbol == NULL
 	      && data->result.block == NULL);
 
-  data->result = lookup_symbol_in_objfile (objfile, GLOBAL_BLOCK,
+  data->result = lookup_symbol_in_objfile (objfile, data->block_index,
 					   data->name, data->domain);
 
   /* If we found a match, tell the iterator to stop.  Otherwise,
@@ -2647,6 +2612,7 @@ lookup_symbol_global_iterator_cb (struct objfile *objfile,
 struct block_symbol
 lookup_global_symbol (const char *name,
 		      const struct block *block,
+		      enum block_enum block_index,
 		      const domain_enum domain)
 {
   struct symbol_cache *cache = get_symbol_cache (current_program_space);
@@ -2656,11 +2622,19 @@ lookup_global_symbol (const char *name,
   struct block_symbol_cache *bsc;
   struct symbol_cache_slot *slot;
 
+  gdb_assert (block_index == GLOBAL_BLOCK || block_index == STATIC_BLOCK);
+
+  /* We only use the block when looking in the GLOBAL_BLOCK.
+     TODO: Wouldn't it be even more important to use the block for static
+     symbol lookups?  */
+  if (block_index != GLOBAL_BLOCK)
+    block = nullptr;
+
   objfile = lookup_objfile_from_block (block);
 
   /* First see if we can find the symbol in the cache.
      This works because we use the current objfile to qualify the lookup.  */
-  result = symbol_cache_lookup (cache, objfile, GLOBAL_BLOCK, name, domain,
+  result = symbol_cache_lookup (cache, objfile, block_index, name, domain,
 				&bsc, &slot);
   if (result.symbol != NULL)
     {
@@ -2679,6 +2653,7 @@ lookup_global_symbol (const char *name,
       memset (&lookup_data, 0, sizeof (lookup_data));
       lookup_data.name = name;
       lookup_data.domain = domain;
+      lookup_data.block_index = block_index;
       gdbarch_iterate_over_objfiles_in_search_order
 	(objfile != NULL ? get_objfile_arch (objfile) : target_gdbarch (),
 	 lookup_symbol_global_iterator_cb, &lookup_data, objfile);
diff --git a/gdb/symtab.h b/gdb/symtab.h
index 9880ecc4c5..5601a28350 100644
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -1617,15 +1617,10 @@ extern struct block_symbol
 				 const struct block *block,
 				 const domain_enum domain);
 
-/* Search all static file-level symbols for NAME from DOMAIN.
-   Upon success fixes up the symbol's section if necessary.  */
-
-extern struct block_symbol lookup_static_symbol (const char *name,
-						 const domain_enum domain);
-
-/* Lookup a symbol in all files' global blocks.
+/* Lookup a symbol in all files' global or static blocks.
 
-   If BLOCK is non-NULL then it is used for two things:
+   If BLOCK_INDEX is GLOBAL_BLOCK and BLOCK is non-NULL then it is used for
+   two things:
    1) If a target-specific lookup routine for libraries exists, then use the
       routine for the objfile of BLOCK, and
    2) The objfile of BLOCK is used to assist in determining the search order
@@ -1637,6 +1632,7 @@ extern struct block_symbol lookup_static_symbol (const char *name,
 extern struct block_symbol
   lookup_global_symbol (const char *name,
 			const struct block *block,
+			enum block_enum block_index,
 			const domain_enum domain);
 
 /* Lookup a symbol in block BLOCK.
