Mon Jun 10 06:14:03 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>

	* sysdeps/mach/hurd/dl-sysdep.c (__open): Define this instead of open.
	(__close, __mmap): Likewise define with __ names now.

Mon Jun 10 05:13:18 1996  Roland McGrath  <roland@delasyd.gnu.ai.mit.edu>

	* elf/dl-support.c: New file.
	* elf/Makefile (CFLAGS-dl-support.c): New variable.
	(routines, elide-routines.so): Add dl-support.

	* elf/dl-minimal.c (_dl_pagesize): Remove common defn.
	* elf/dl-load.c (_dl_pagesize): Define it here.
	(_dl_map_object_from_fd): Initialize it if zero.
	* elf/link.h (_dl_pagesize): Remove const.

Sun Jun  9 04:04:26 1996  Roland McGrath  <roland@delasyd.gnu.ai.mit.edu>

	* elf/Makefile (routines): Add dl-symbol.
	* elf/dl-lookup.c (_dl_symbol_value): Moved to ...
	* elf/dl-symbol.c: New file.

	* elf/elf.h (Elf32_Xword, Elf32_Sxword): New types.
	(Elf32_Section, Elf64_Section): New types, 16 bits.
	(Elf32_Sym, Elf64_Sym): Use it.

	* elf/dl-deps.c (_dl_open): Moved to ...
	* elf/dl-open.c: New file.
	* Makefile (routines): Add dl-open.

	* elf/Makefile (dl-routines): New variable.
	(routines): Add $(dl-routines).
	(elide-routines.so): New variable, set to $(dl-routines).
	(libdl-inhibit-o): Variable removed; build all flavors of -ldl.
	(rtld-routines): All but rtld, dl-sysdep, and dl-minimal moved to
 	$(dl-routines).

	* elf/dl-lookup.c (_dl_lookup_symbol): Remove magic symbol grokage.

	* elf/dladdr.c: Use ELFW(ST_BIND) in place of ELF32_ST_BIND.

	* elf/dl-load.c (open_path): Use __ names for open and close.  Avoid
	using strdup.
	(_dl_map_object): Likewise.
	(_dl_map_object_from_fd): Use __ names for mmap, munmap, and mprotect.
	* elf/dl-minimal.c (malloc): Likewise.
	* elf/dl-reloc.c (_dl_relocate_object): Likewise.

	* elf/dl-minimal.c (_dl_pagesize): New variable.
	(malloc): Use that instead of a static variable.
	* elf/dl-reloc.c (_dl_relocate_object): Use _dl_pagesize instead of
	calling getpagesize.
	* elf/dl-load.c (_dl_map_object_from_fd): Likewise.
	* elf/link.h: Declare _dl_pagesize.

	* elf/rtld.c (dl_r_debug): Renamed to _dl_r_debug.

	* elf/link.h (struct link_map): Use Half for l_phnum instead of Word.
  	* elf/rtld.c (dl_main): Use Half for phdr count arg.
	(_dl_sysdep_start): Update prototype of DL_MAIN function ptr arg.

	* elf/dl-load.c (_dl_map_object_from_fd): Use explicit Elf32_Word to
 	extract 4-byte magic number, not ElfW(Word).  Match EI_CLASS against
 	native wordsize, either 32 or 64.

	* elf/elf.h (Elf64_Byte, Elf64_Section): Typedefs removed.  In C a
 	char is always a byte, no need for a typedef.  Section indices are
	16-bit quantities in elf64, which already have a typedef Elf64_Half.

	Remove partial -lelf implementation.  There is now a
	separately-distributed `libelf' package that implements it.
	* elf/dl-lookup.c: Don't #include <libelf.h> any more.
	(_dl_elf_hash): New function, moved from
	libelf.h:elf_hash.
	(_dl_lookup_symbol): Use it instead of elf_hash.
	* elf/libelf.h: File removed.
	* elf/elf_hash.c: File removed.
	* elf/Makefile (headers): Remove libelf.h.
	(extra-libs): Remove libelf.
	(libelf-routines): Variable removed.

	* elf/Makefile (libdl.so): Remove commands from this target.  The
 	implicit rule commands are correct, this explicit rule just serves to
 	add some dependencies.

	* elf/dl-lookup.c (_dl_lookup_symbol): Use ELFW(ST_TYPE) in place of
 	ELF32_ST_TYPE.  Likewise ST_BIND.
	* elf/do-rel.h (elf_dynamic_do_rel): Likewise R_SYM.

	* elf/link.h (ElfW): New macro for wordsize-independent ElfXX_* type
	naming.
	(ELFW): New macro, likewise for ELFXX_* macro naming.
	(_ElfW, _ElfW_1): New macros, subroutines of ElfW and ELF.

Sat Jun  8 20:52:38 1996  Roland McGrath  <roland@delasyd.gnu.ai.mit.edu>

	* elf/link.h, elf/do-rel.h, elf/dynamic-link.h, elf/dl-deps.c,
 	elf/dl-init.c, elf/dl-load.c, elf/dl-lookup.c, elf/dl-reloc.c,
 	elf/dl-runtime.c, elf/dladdr.c, elf/dlclose.c, elf/dlsym.c,
 	elf/linux-compat.c, elf/rtld.c: Change all uses of `Elf32_XXX' to
 	`ElfW(XXX)' for wordsize-independence.

Sat Jun  8 20:50:42 1996  Richard Henderson  <rth@tamu.edu>

	* elf/elf.h: Move Elf64_* types in parity with Elf32 counterparts.
	(Elf64_auxv_t): New type.
	(EM_ALPHA, R_ALPHA_*): New macros for elf64-alpha format.

1 files changed, 43 insertions, 60 deletions

diff --git a/elf/dl-lookup.c b/elf/dl-lookup.c
index 104963987b..0674253041 100644
--- a/elf/dl-lookup.c
+++ b/elf/dl-lookup.c
@@ -18,27 +18,48 @@ not, write to the Free Software Foundation, Inc., 675 Mass Ave,
 Cambridge, MA 02139, USA.  */
 
 #include <stddef.h>
-#include <libelf.h>
 #include <link.h>
 #include <assert.h>
 
+
+/* This is the hashing function specified by the ELF ABI.  */
+static inline unsigned
+_dl_elf_hash (const char *name)
+{
+  unsigned long int hash = 0;
+  while (*name != '\0')
+    {
+      unsigned long int hi;
+      hash = (hash << 4) + *name++;
+      hi = hash & 0xf0000000;
+      if (hi != 0)
+	{
+	  hash ^= hi >> 24;
+	  /* The ELF ABI says `hash &= ~hi', but this is equivalent
+	     in this case and on some machines one insn instead of two.  */
+	  hash ^= hi;
+	}
+    }
+  return hash;
+}
+
 /* Search loaded objects' symbol tables for a definition of the symbol
    UNDEF_NAME.  The chosen value can't be RELOC_ADDR.  If NOPLT is nonzero,
    then a PLT entry cannot satisfy the reference; some different binding
    must be found.  */
 
-Elf32_Addr
-_dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
+ElfW(Addr)
+_dl_lookup_symbol (const char *undef_name, const ElfW(Sym) **ref,
 		   struct link_map *symbol_scope[2],
 		   const char *reference_name,
-		   Elf32_Addr reloc_addr,
+		   ElfW(Addr) reloc_addr,
 		   int noplt)
 {
-  unsigned long int hash = elf_hash (undef_name);
+  const unsigned long int hash = _dl_elf_hash (undef_name);
   struct
     {
-      Elf32_Addr a;
-      const Elf32_Sym *s;
+      ElfW(Addr) a;
+      const ElfW(Sym) *s;
     } weak_value = { 0, NULL };
   size_t i;
   struct link_map **scope, *map;
@@ -48,9 +69,9 @@ _dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
     if (*scope)
       for (i = 0; i < (*scope)->l_nsearchlist; ++i)
 	{
-	  const Elf32_Sym *symtab;
+	  const ElfW(Sym) *symtab;
 	  const char *strtab;
-	  Elf32_Word symidx;
+	  ElfW(Word) symidx;
 
 	  map = (*scope)->l_searchlist[i];
 
@@ -63,7 +84,7 @@ _dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
 	       symidx != STN_UNDEF;
 	       symidx = map->l_chain[symidx])
 	    {
-	      const Elf32_Sym *sym = &symtab[symidx];
+	      const ElfW(Sym) *sym = &symtab[symidx];
 
 	      if (sym->st_value == 0 || /* No value.  */
 		  /* Cannot resolve to the location being filled in.  */
@@ -71,7 +92,7 @@ _dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
 		  (noplt && sym->st_shndx == SHN_UNDEF)) /* Reject PLT.  */
 		continue;
 
-	      switch (ELF32_ST_TYPE (sym->st_info))
+	      switch (ELFW(ST_TYPE) (sym->st_info))
 		{
 		case STT_NOTYPE:
 		case STT_FUNC:
@@ -86,7 +107,7 @@ _dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
 		/* Not the symbol we are looking for.  */
 		continue;
 
-	      switch (ELF32_ST_BIND (sym->st_info))
+	      switch (ELFW(ST_BIND) (sym->st_info))
 		{
 		case STB_GLOBAL:
 		  /* Global definition.  Just what we need.  */
@@ -108,41 +129,15 @@ _dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
 	    }
 	}
 
-  if (weak_value.s == NULL && ELF32_ST_BIND ((*ref)->st_info) != STB_WEAK)
+  if (weak_value.s == NULL && ELFW(ST_BIND) ((*ref)->st_info) != STB_WEAK)
     {
-      /* The symbol was not defined by any object in scope.  To allow
-	 access to dynamic linker functionality without using -ldl and
-	 thereby brining the dynamic linker's symbols into scope, we
-	 recognize a few magical symbol names and resolve them to the
-	 addresses of functions inside the dynamic linker.  */
-
-      struct magic
-	{
-	  unsigned long int hash;
-	  const char *name;
-	  Elf32_Addr value;
-	};
-      static struct magic magic[] =
-	{
-	  { 0xd6a2a5e, "_GNU_libc_dl_open", (Elf32_Addr) &_dl_open },
-/*	  { 0x69ef845, "_GNU_libc_dl_close", (Elf32_Addr) &_dl_close },*/
-	  { 0xae4d63c, "_GNU_libc_dl_symbol", (Elf32_Addr) &_dl_symbol_value },
-	  { 0, NULL, 0 }
-	};
-      struct magic *m;
-
-      for (m = magic; m->hash; ++m)
-	if (hash == m->hash && !strcmp (undef_name, m->name))
-	  return m->value;
-
-      {
-	const char msg[] = "undefined symbol: ";
-	char buf[sizeof msg + strlen (undef_name)];
-	memcpy (buf, msg, sizeof msg - 1);
-	memcpy (&buf[sizeof msg - 1], undef_name,
-		sizeof buf - sizeof msg + 1);
-	_dl_signal_error (0, reference_name, buf);
-      }
+      /* We could find no value for a strong reference.  */
+      const char msg[] = "undefined symbol: ";
+      char buf[sizeof msg + strlen (undef_name)];
+      memcpy (buf, msg, sizeof msg - 1);
+      memcpy (&buf[sizeof msg - 1], undef_name,
+	      sizeof buf - sizeof msg + 1);
+      _dl_signal_error (0, reference_name, buf);
     }
 
   *ref = weak_value.s;
@@ -155,23 +150,11 @@ _dl_lookup_symbol (const char *undef_name, const Elf32_Sym **ref,
 void
 _dl_setup_hash (struct link_map *map)
 {
-  Elf32_Word *hash = (void *) map->l_addr + map->l_info[DT_HASH]->d_un.d_ptr;
-  Elf32_Word nchain;
+  ElfW(Word) *hash = (void *) map->l_addr + map->l_info[DT_HASH]->d_un.d_ptr;
+  ElfW(Word) nchain;
   map->l_nbuckets = *hash++;
   nchain = *hash++;
   map->l_buckets = hash;
   hash += map->l_nbuckets;
   map->l_chain = hash;
 }
-
-/* Look up symbol NAME in MAP's scope and return its run-time address.  */
-
-Elf32_Addr
-_dl_symbol_value (struct link_map *map, const char *name)
-{
-  Elf32_Addr loadbase;
-  const Elf32_Sym *ref = NULL;
-  struct link_map *scope[2] = { map, NULL };
-  loadbase = _dl_lookup_symbol (name, &ref, scope, map->l_name, 0, 0);
-  return loadbase + ref->st_value;
-}