Update.

2000-05-05  Ulrich Drepper  <drepper@redhat.com>

	* elf/dl-load.c (_dl_map_object_from_fd): Little of computation of
	parameter to mprotect and for variable assignments.

2000-05-03  Jes Sorensen  <jes@linuxcare.com>

	* sysdeps/generic/ldsodefs.h (LOOKUP_VALUE_ADDRESS): Check the
	validity of map before dereferencing it.

	* elf/dl-reloc.c (RESOLVE_MAP): Define.

2000-05-02  Jes Sorensen  <jes@linuxcare.com>

	* elf/dl-runtime.c (fixup): Add the value returned in the symbol
	lookup to the arguments to elf_machine_fixup_plt().

	* sysdeps/ia64/dl-machine.h (elf_machine_fixup_plt): Add Link_map
	of the symbol being resolved to input argument list and make the
	function return the pointer to the reloc.

	* sysdeps/alpha/dl-machine.h (elf_machine_fixup_plt): Change
	return valuie to lookup_t and return the value.
	* sysdeps/arm/dl-machine.h (elf_machine_fixup_plt): Likewise.
	* sysdeps/generic/dl-machine.h (elf_machine_fixup_plt): Likewise.
	* sysdeps/i386/dl-machine.h (elf_machine_fixup_plt): Likewise.
	* sysdeps/m68k/dl-machine.h (elf_machine_fixup_plt): Likewise.
	* sysdeps/sparc/sparc32/dl-machine.h (elf_machine_fixup_plt): Likewise.
	* sysdeps/sparc/sparc64/dl-machine.h (elf_machine_fixup_plt): Likewise.

	* sysdeps/powerpc/dl-machine.h (elf_machine_fixup_plt): Likewise.
	Make it an inline function returning value after calling
	__elf_machine_fixup_plt().

	* elf/dl-sym.c (_dl_vsym): Use DL_SYMBOL_ADDRESS() to obtain the
	symbol address.

	* elf/dl-symbol.c (_dl_symbol_value): Use LOOKUP_VALUE_ADDRESS to
	obtain the symbol address.

	* sysdeps/generic/ldsodefs.h: Add generic DL_SYMBOL_ADDRESS() macro
	depending on the definition of ELF_FUNCTION_PTR_IS_SPECIAL.

	* sysdeps/ia64/dl-machine.h: Add DL_SYMBOL_ADDRESS() macro calling
	_dl_symbol_address() - this way DL_SYMBOL_ADDRESS() turns into an
	inline on non ia64.

2000-04-28  Jes Sorensen  <jes@linuxcare.com>

	* elf/dl-runtime.c (fixup): Use the portable macros to get the
	symbol address of an object.

	* elf/dl-runtime.c (fixup-profile): Use the portable macros to get
	the symbol address of an object.

	* elf/dl-libc.c (struct do_dlsym_args): Change loadbase to a lookup_t.
	* elf/dl-lookup.c (_dl_lookup_symbol): Likewise.
	(_dl_lookup_symbol_skip): Likewise.
	(_dl_lookup_versioned_symbol): Likewise.
	(_dl_lookup_versioned_symbol_skip): Likewise.

2000-04-27  Jes Sorensen  <jes@linuxcare.com>

	* elf/rtld.c (_dl_start): Get the function pointer return address
	via _dl_start_address for architectures that need a function
	pointer descriptor rather than just a pointer (ia64).

	* sysdeps/generic/dl-lookupcfg.h: New file.
	* sysdeps/ia64/dl-lookupcfg.h: New file.
	* sysdeps/ia64/dl-machine.h: New file.
	* sysdeps/ia64/dl-symaddr.c: New file.
	* sysdeps/ia64/dl-fptr.c: New file.

	* elf/elf.h: Add IA-64 specific definitions.

24 files changed, 1212 insertions, 125 deletions

diff --git a/ChangeLog b/ChangeLog
index ddf2240bf6..96ba5b89f2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,78 @@
+2000-05-05  Ulrich Drepper  <drepper@redhat.com>
+
+	* elf/dl-load.c (_dl_map_object_from_fd): Little of computation of
+	parameter to mprotect and for variable assignments.
+
+2000-05-03  Jes Sorensen  <jes@linuxcare.com>
+
+	* sysdeps/generic/ldsodefs.h (LOOKUP_VALUE_ADDRESS): Check the
+	validity of map before dereferencing it.
+
+	* elf/dl-reloc.c (RESOLVE_MAP): Define.
+
+2000-05-02  Jes Sorensen  <jes@linuxcare.com>
+
+	* elf/dl-runtime.c (fixup): Add the value returned in the symbol
+	lookup to the arguments to elf_machine_fixup_plt().
+
+	* sysdeps/ia64/dl-machine.h (elf_machine_fixup_plt): Add Link_map
+	of the symbol being resolved to input argument list and make the
+	function return the pointer to the reloc.
+
+	* sysdeps/alpha/dl-machine.h (elf_machine_fixup_plt): Change
+	return valuie to lookup_t and return the value.
+	* sysdeps/arm/dl-machine.h (elf_machine_fixup_plt): Likewise.
+	* sysdeps/generic/dl-machine.h (elf_machine_fixup_plt): Likewise.
+	* sysdeps/i386/dl-machine.h (elf_machine_fixup_plt): Likewise.
+	* sysdeps/m68k/dl-machine.h (elf_machine_fixup_plt): Likewise.
+	* sysdeps/sparc/sparc32/dl-machine.h (elf_machine_fixup_plt): Likewise.
+	* sysdeps/sparc/sparc64/dl-machine.h (elf_machine_fixup_plt): Likewise.
+
+	* sysdeps/powerpc/dl-machine.h (elf_machine_fixup_plt): Likewise.
+	Make it an inline function returning value after calling
+	__elf_machine_fixup_plt().
+
+	* elf/dl-sym.c (_dl_vsym): Use DL_SYMBOL_ADDRESS() to obtain the
+	symbol address.
+
+	* elf/dl-symbol.c (_dl_symbol_value): Use LOOKUP_VALUE_ADDRESS to
+	obtain the symbol address.
+
+	* sysdeps/generic/ldsodefs.h: Add generic DL_SYMBOL_ADDRESS() macro
+	depending on the definition of ELF_FUNCTION_PTR_IS_SPECIAL.
+
+	* sysdeps/ia64/dl-machine.h: Add DL_SYMBOL_ADDRESS() macro calling
+	_dl_symbol_address() - this way DL_SYMBOL_ADDRESS() turns into an
+	inline on non ia64.
+
+2000-04-28  Jes Sorensen  <jes@linuxcare.com>
+
+	* elf/dl-runtime.c (fixup): Use the portable macros to get the
+	symbol address of an object.
+
+	* elf/dl-runtime.c (fixup-profile): Use the portable macros to get
+	the symbol address of an object.
+
+	* elf/dl-libc.c (struct do_dlsym_args): Change loadbase to a lookup_t.
+	* elf/dl-lookup.c (_dl_lookup_symbol): Likewise.
+	(_dl_lookup_symbol_skip): Likewise.
+	(_dl_lookup_versioned_symbol): Likewise.
+	(_dl_lookup_versioned_symbol_skip): Likewise.
+
+2000-04-27  Jes Sorensen  <jes@linuxcare.com>
+
+	* elf/rtld.c (_dl_start): Get the function pointer return address
+	via _dl_start_address for architectures that need a function
+	pointer descriptor rather than just a pointer (ia64).
+
+	* sysdeps/generic/dl-lookupcfg.h: New file.
+	* sysdeps/ia64/dl-lookupcfg.h: New file.
+	* sysdeps/ia64/dl-machine.h: New file.
+	* sysdeps/ia64/dl-symaddr.c: New file.
+	* sysdeps/ia64/dl-fptr.c: New file.
+
+	* elf/elf.h: Add IA-64 specific definitions.
+
 2000-05-04  Jakub Jelinek  <jakub@redhat.com>
 
 	* sysdeps/generic/bits/confname.h (_SC* enum): Avoid comma at the
diff --git a/elf/dl-libc.c b/elf/dl-libc.c
index 39ccf82ed1..07aae9c8f9 100644
--- a/elf/dl-libc.c
+++ b/elf/dl-libc.c
@@ -65,7 +65,7 @@ struct do_dlsym_args
   const char *name;
 
   /* Return values of do_dlsym.  */
-  ElfW(Addr) loadbase;
+  lookup_t loadbase;
   const ElfW(Sym) *ref;
 };
 
diff --git a/elf/dl-load.c b/elf/dl-load.c
index 0291bf2a74..f5d91ba6c7 100644
--- a/elf/dl-load.c
+++ b/elf/dl-load.c
@@ -917,11 +917,14 @@ _dl_map_object_from_fd (const char *name, int fd, char *realname,
 	   As a refinement, sometimes we have an address that we would
 	   prefer to map such objects at; but this is only a preference,
 	   the OS can do whatever it likes. */
- 	caddr_t mapat;
 	ElfW(Addr) mappref;
 	mappref = (ELF_PREFERRED_ADDRESS (loader, maplength, c->mapstart)
 		   - MAP_BASE_ADDR (l));
-	mapat = map_segment (mappref, maplength, c->prot, 0, c->mapoff);
+
+	/* Remember which part of the address space this object uses.  */
+	l->l_map_start = map_segment (mappref, maplength, c->prot, 0,
+				      c->mapoff);
+	l->l_map_end = l->l_map_start + maplength;
 	l->l_addr = (ElfW(Addr)) mapat - c->mapstart;
 
 	/* Change protection on the excess portion to disallow all access;
@@ -929,14 +932,10 @@ _dl_map_object_from_fd (const char *name, int fd, char *realname,
 	   unallocated.  Then jump into the normal segment-mapping loop to
 	   handle the portion of the segment past the end of the file
 	   mapping.  */
-	__mprotect ((caddr_t) (l->l_addr + c->mapend),
+	__mprotect ((caddr_t) l->l_map_start,
 		    loadcmds[nloadcmds - 1].allocend - c->mapend,
 		    0);
 
-	/* Remember which part of the address space this object uses.  */
-	l->l_map_start = c->mapstart + l->l_addr;
-	l->l_map_end = l->l_map_start + maplength;
-
 	goto postmap;
       }
     else
diff --git a/elf/dl-lookup.c b/elf/dl-lookup.c
index dc4564f2c7..c38e2e81f7 100644
--- a/elf/dl-lookup.c
+++ b/elf/dl-lookup.c
@@ -86,7 +86,7 @@ static int
 add_dependency (struct link_map *undef_map, struct link_map *map)
 {
   struct link_map **list;
-  unsigned act;
+  unsigned int act;
   unsigned int i;
   int result = 0;
 
@@ -183,7 +183,7 @@ add_dependency (struct link_map *undef_map, struct link_map *map)
 /* Search loaded objects' symbol tables for a definition of the symbol
    UNDEF_NAME.  */
 
-ElfW(Addr)
+lookup_t
 internal_function
 _dl_lookup_symbol (const char *undef_name, struct link_map *undef_map,
 		   const ElfW(Sym) **ref, struct r_scope_elem *symbol_scope[],
@@ -241,7 +241,7 @@ _dl_lookup_symbol (const char *undef_name, struct link_map *undef_map,
 		       ": symbol `", undef_name, "'\n", NULL);
 
   *ref = current_value.s;
-  return current_value.m->l_addr;
+  return LOOKUP_VALUE (current_value.m);
 }
 
 
@@ -250,7 +250,7 @@ _dl_lookup_symbol (const char *undef_name, struct link_map *undef_map,
    it only considers objects which were loaded after the described
    object.  If there are more search lists the object described by
    SKIP_MAP is only skipped.  */
-ElfW(Addr)
+lookup_t
 internal_function
 _dl_lookup_symbol_skip (const char *undef_name,
 			struct link_map *undef_map, const ElfW(Sym) **ref,
@@ -328,7 +328,7 @@ _dl_lookup_symbol_skip (const char *undef_name,
 		       ": symbol `", undef_name, "' (skip)\n", NULL);
 
   *ref = current_value.s;
-  return current_value.m->l_addr;
+  return LOOKUP_VALUE (current_value.m);
 }
 
 
@@ -337,7 +337,7 @@ _dl_lookup_symbol_skip (const char *undef_name,
    symbol.
 
    XXX We'll see whether we need this separate function.  */
-ElfW(Addr)
+lookup_t
 internal_function
 _dl_lookup_versioned_symbol (const char *undef_name,
 			     struct link_map *undef_map, const ElfW(Sym) **ref,
@@ -422,13 +422,13 @@ _dl_lookup_versioned_symbol (const char *undef_name,
 		       "]\n", NULL);
 
   *ref = current_value.s;
-  return current_value.m->l_addr;
+  return LOOKUP_VALUE (current_value.m);
 }
 
 
 /* Similar to _dl_lookup_symbol_skip but takes an additional argument
    with the version we are looking for.  */
-ElfW(Addr)
+lookup_t
 internal_function
 _dl_lookup_versioned_symbol_skip (const char *undef_name,
 				  struct link_map *undef_map,
@@ -523,7 +523,7 @@ _dl_lookup_versioned_symbol_skip (const char *undef_name,
 		       "] (skip)\n", NULL);
 
   *ref = current_value.s;
-  return current_value.m->l_addr;
+  return LOOKUP_VALUE (current_value.m);
 }
 
 
diff --git a/elf/dl-reloc.c b/elf/dl-reloc.c
index 4c7aabea85..d1537ec3dc 100644
--- a/elf/dl-reloc.c
+++ b/elf/dl-reloc.c
@@ -70,6 +70,14 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[],
     const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
 
     /* This macro is used as a callback from the ELF_DYNAMIC_RELOCATE code.  */
+#define RESOLVE_MAP(ref, version, flags) \
+    (ELFW(ST_BIND) ((*ref)->st_info) != STB_LOCAL			      \
+     ? ((version) != NULL && (version)->hash != 0			      \
+	? _dl_lookup_versioned_symbol (strtab + (*ref)->st_name, l, (ref),    \
+				       scope, (version), (flags))	      \
+	: _dl_lookup_symbol (strtab + (*ref)->st_name, l, (ref), scope,	      \
+			     (flags)))					      \
+     : l)
 #define RESOLVE(ref, version, flags) \
     (__builtin_expect (ELFW(ST_VISIBILITY) ((*ref)->st_other), 0) == 0	      \
      ? ((version) != NULL && (version)->hash != 0			      \
diff --git a/elf/dl-runtime.c b/elf/dl-runtime.c
index d76b513a27..6237afce07 100644
--- a/elf/dl-runtime.c
+++ b/elf/dl-runtime.c
@@ -57,6 +57,7 @@ fixup (
     = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
   const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
   void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
+  lookup_t result;
   ElfW(Addr) value;
 
   /* The use of `alloca' here looks ridiculous but it helps.  The goal is
@@ -83,33 +84,38 @@ fixup (
 
 	    if (version->hash != 0)
 	      {
-		value = _dl_lookup_versioned_symbol(strtab + sym->st_name, l,
-						    &sym, l->l_scope, version,
-						    ELF_MACHINE_JMP_SLOT);
+		result = _dl_lookup_versioned_symbol (strtab + sym->st_name,
+						      l, &sym, l->l_scope,
+						      version,
+						      ELF_MACHINE_JMP_SLOT);
 		break;
 	      }
 	  }
 	case 0:
-	  value = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,
-				     l->l_scope, ELF_MACHINE_JMP_SLOT);
+	  result = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,
+				      l->l_scope, ELF_MACHINE_JMP_SLOT);
 	}
 
-      /* Currently value contains the base load address of the object
-	 that defines sym.  Now add in the symbol offset.  */
-      value = (sym ? value + sym->st_value : 0);
+      /* Currently result contains the base load address (or link map)
+	 of the object that defines sym.  Now add in the symbol
+	 offset.  */
+      value = (sym ? LOOKUP_VALUE_ADDRESS (result) + sym->st_value : 0);
     }
   else
+    {
     /* We already found the symbol.  The module (and therefore its load
        address) is also known.  */
-    value = l->l_addr + sym->st_value;
+      value = l->l_addr + sym->st_value;
+#ifdef DL_LOOKUP_RETURNS_MAP
+      result = l;
+#endif
+    }
 
   /* And now perhaps the relocation addend.  */
   value = elf_machine_plt_value (l, reloc, value);
 
   /* Finally, fix up the plt itself.  */
-  elf_machine_fixup_plt (l, reloc, rel_addr, value);
-
-  return value;
+  return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
 }
 #endif
 
@@ -124,6 +130,7 @@ profile_fixup (
 {
   void (*mcount_fct) (ElfW(Addr), ElfW(Addr)) = _dl_mcount;
   ElfW(Addr) *resultp;
+  lookup_t result;
   ElfW(Addr) value;
 
   /* The use of `alloca' here looks ridiculous but it helps.  The goal is
@@ -166,27 +173,32 @@ profile_fixup (
 
 		if (version->hash != 0)
 		  {
-		    value = _dl_lookup_versioned_symbol(strtab + sym->st_name,
-							l, &sym, l->l_scope,
-							version,
-							ELF_MACHINE_JMP_SLOT);
+		    result = _dl_lookup_versioned_symbol(strtab + sym->st_name,
+							 l, &sym, l->l_scope,
+							 version,
+							 ELF_MACHINE_JMP_SLOT);
 		    break;
 		  }
 	      }
 	    case 0:
-	      value = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,
-					 l->l_scope, ELF_MACHINE_JMP_SLOT);
+	      result = _dl_lookup_symbol (strtab + sym->st_name, l, &sym,
+					  l->l_scope, ELF_MACHINE_JMP_SLOT);
 	    }
 
-	  /* Currently value contains the base load address of the object
-	     that defines sym.  Now add in the symbol offset.  */
-	  value = (sym ? value + sym->st_value : 0);
+	  /* Currently result contains the base load address (or link map)
+	     of the object that defines sym.  Now add in the symbol
+	     offset.  */
+	  value = (sym ? LOOKUP_VALUE_ADDRESS (result) + sym->st_value : 0);
 	}
       else
+	{
 	/* We already found the symbol.  The module (and therefore its load
 	   address) is also known.  */
 	value = l->l_addr + sym->st_value;
-
+#ifdef DL_LOOKUP_RETURNS_MAP
+	result = l;
+#endif
+	}
       /* And now perhaps the relocation addend.  */
       value = elf_machine_plt_value (l, reloc, value);
 
diff --git a/elf/dl-sym.c b/elf/dl-sym.c
index 80be9544cb..84236ff993 100644
--- a/elf/dl-sym.c
+++ b/elf/dl-sym.c
@@ -1,5 +1,5 @@
 /* Look up a symbol in a shared object loaded by `dlopen'.
-   Copyright (C) 1999 Free Software Foundation, Inc.
+   Copyright (C) 1999, 2000 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -29,12 +29,12 @@ void *
 internal_function
 _dl_sym (void *handle, const char *name, void *who)
 {
-  ElfW(Addr) loadbase;
   const ElfW(Sym) *ref = NULL;
+  lookup_t result;
 
   if (handle == RTLD_DEFAULT)
     /* Search the global scope.  */
-    loadbase = _dl_lookup_symbol (name, NULL, &ref, _dl_global_scope, 0);
+    result = _dl_lookup_symbol (name, NULL, &ref, _dl_global_scope, 0);
   else
     {
       struct link_map *l, *match;
@@ -56,8 +56,8 @@ _dl_sym (void *handle, const char *name, void *who)
 	       main program (we hope).  */
 	    match = _dl_loaded;
 
-	  loadbase = _dl_lookup_symbol (name, match, &ref, map->l_local_scope,
-					0);
+	  result = _dl_lookup_symbol (name, match, &ref, map->l_local_scope,
+				      0);
 	}
       else
 	{
@@ -69,13 +69,13 @@ RTLD_NEXT used in code not dynamically loaded"));
 	  while (l->l_loader)
 	    l = l->l_loader;
 
-	  loadbase = _dl_lookup_symbol_skip (name, l, &ref, l->l_local_scope,
-					     match);
+	  result = _dl_lookup_symbol_skip (name, l, &ref, l->l_local_scope,
+					   match);
 	}
     }
 
-  if (loadbase)
-    return (void *) (loadbase + ref->st_value);
+  if (result)
+    return DL_SYMBOL_ADDRESS (result, ref);
 
   return NULL;
 }
@@ -84,9 +84,9 @@ void *
 internal_function
 _dl_vsym (void *handle, const char *name, const char *version, void *who)
 {
-  ElfW(Addr) loadbase;
   const ElfW(Sym) *ref = NULL;
   struct r_found_version vers;
+  lookup_t result;
 
   /* Compute hash value to the version string.  */
   vers.name = version;
@@ -97,8 +97,8 @@ _dl_vsym (void *handle, const char *name, const char *version, void *who)
 
   if (handle == RTLD_DEFAULT)
     /* Search the global scope.  */
-    loadbase = _dl_lookup_versioned_symbol (name, NULL, &ref, _dl_global_scope,
-					    &vers, 0);
+    result = _dl_lookup_versioned_symbol (name, NULL, &ref, _dl_global_scope,
+					  &vers, 0);
   else if (handle == RTLD_NEXT)
     {
       struct link_map *l, *match;
@@ -118,20 +118,19 @@ RTLD_NEXT used in code not dynamically loaded"));
       while (l->l_loader)
 	l = l->l_loader;
 
-      loadbase = _dl_lookup_versioned_symbol_skip (name, l, &ref,
-						   l->l_local_scope,
-						   &vers, match);
+      result = _dl_lookup_versioned_symbol_skip (name, l, &ref,
+						 l->l_local_scope,
+						 &vers, match);
     }
   else
     {
       /* Search the scope of the given object.  */
       struct link_map *map = handle;
-      loadbase = _dl_lookup_versioned_symbol (name, map, &ref,
-					      map->l_local_scope, &vers, 0);
+      result = _dl_lookup_versioned_symbol (name, map, &ref,
+					    map->l_local_scope, &vers, 0);
     }
 
-  if (loadbase)
-    return (void *) (loadbase + ref->st_value);
-
+  if (result)
+    return DL_SYMBOL_ADDRESS (result, ref);
   return NULL;
 }
diff --git a/elf/dl-symbol.c b/elf/dl-symbol.c
index 136b10a2b5..bdd7615e48 100644
--- a/elf/dl-symbol.c
+++ b/elf/dl-symbol.c
@@ -1,5 +1,5 @@
 /* Look up a symbol's run-time value in the scope of a loaded object.
-   Copyright (C) 1995,96,98,99,2000 Free Software Foundation, Inc.
+   Copyright (C) 1995, 96, 98, 99, 2000 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or