Re: RFA: don't use minsym name when searching block

[Jim Blandy <jimb@redhat.com>]

I've committed the following, which differs from my original patch:
1) it fixes the analogous uses in the HPPAHPUX block, and
2) it includes comments explaining why using the minsym name is
   inappropriate. 

2002-08-29  Jim Blandy  <jimb@redhat.com>

	* symtab.c (lookup_symbol_aux): In the cases where we find a
	minimal symbol of an appropriate name and use its address to
	select a symtab to read and search, use `name' (as passed to us)
	as the demangled name when searching the symtab's global and
	static blocks, not the minsym's name.

Index: gdb/symtab.c
===================================================================
RCS file: /cvs/src/src/gdb/symtab.c,v
retrieving revision 1.68
diff -c -r1.68 symtab.c
*** gdb/symtab.c	1 Aug 2002 17:18:33 -0000	1.68
--- gdb/symtab.c	30 Aug 2002 02:18:57 -0000
***************
*** 860,874 ****
  	      /* This is a function which has a symtab for its address.  */
  	      bv = BLOCKVECTOR (s);
  	      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
! 	      sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
! 					 mangled_name, namespace);
  	      /* We kept static functions in minimal symbol table as well as
  	         in static scope. We want to find them in the symbol table. */
  	      if (!sym)
  		{
  		  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
! 		  sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
! 					     mangled_name, namespace);
  		}
  
  	      /* sym == 0 if symbol was found in the minimal symbol table
--- 860,879 ----
  	      /* This is a function which has a symtab for its address.  */
  	      bv = BLOCKVECTOR (s);
  	      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
! 
!               /* This call used to pass `SYMBOL_NAME (msymbol)' as the
!                  `name' argument to lookup_block_symbol.  But the name
!                  of a minimal symbol is always mangled, so that seems
!                  to be clearly the wrong thing to pass as the
!                  unmangled name.  */
! 	      sym = lookup_block_symbol (block, name, mangled_name, namespace);
  	      /* We kept static functions in minimal symbol table as well as
  	         in static scope. We want to find them in the symbol table. */
  	      if (!sym)
  		{
  		  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
! 		  sym = lookup_block_symbol (block, name,
!                                              mangled_name, namespace);
  		}
  
  	      /* sym == 0 if symbol was found in the minimal symbol table
***************
*** 1027,1041 ****
  	    {
  	      bv = BLOCKVECTOR (s);
  	      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
! 	      sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
! 					 mangled_name, namespace);
  	      /* We kept static functions in minimal symbol table as well as
  	         in static scope. We want to find them in the symbol table. */
  	      if (!sym)
  		{
  		  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
! 		  sym = lookup_block_symbol (block, SYMBOL_NAME (msymbol),
! 					     mangled_name, namespace);
  		}
  	      /* If we found one, return it */
  	      if (sym)
--- 1032,1050 ----
  	    {
  	      bv = BLOCKVECTOR (s);
  	      block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
!               /* This call used to pass `SYMBOL_NAME (msymbol)' as the
!                  `name' argument to lookup_block_symbol.  But the name
!                  of a minimal symbol is always mangled, so that seems
!                  to be clearly the wrong thing to pass as the
!                  unmangled name.  */
! 	      sym = lookup_block_symbol (block, name, mangled_name, namespace);
  	      /* We kept static functions in minimal symbol table as well as
  	         in static scope. We want to find them in the symbol table. */
  	      if (!sym)
  		{
  		  block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
! 		  sym = lookup_block_symbol (block, name,
!                                              mangled_name, namespace);
  		}
  	      /* If we found one, return it */
  	      if (sym)